1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Compress instruction Source Fragment *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* From: RISCV.td *|
7|* *|
8\*===----------------------------------------------------------------------===*/
9
10#ifdef GEN_COMPRESS_INSTR
11#undef GEN_COMPRESS_INSTR
12
13static bool RISCVValidateMCOperandForCompress(const MCOperand &MCOp,
14 const MCSubtargetInfo &STI,
15 unsigned PredicateIndex) {
16 switch (PredicateIndex) {
17 default:
18 llvm_unreachable("Unknown MCOperandPredicate kind");
19 break;
20 case 1: {
21 // uimm10_lsb00nonzero
22 int64_t Imm;
23 if (!MCOp.evaluateAsConstantImm(Imm))
24 return false;
25 return isShiftedUInt<8, 2>(x: Imm) && (Imm != 0);
26 }
27 case 2: {
28 // simm6nonzero
29 int64_t Imm;
30 if (MCOp.evaluateAsConstantImm(Imm))
31 return (Imm != 0) && isInt<6>(x: Imm);
32 return MCOp.isBareSymbolRef();
33 }
34 case 3: {
35 // simm6
36 int64_t Imm;
37 if (MCOp.evaluateAsConstantImm(Imm))
38 return isInt<6>(x: Imm);
39 return MCOp.isBareSymbolRef();
40 }
41 case 4: {
42 // simm10_lsb0000nonzero
43 int64_t Imm;
44 if (!MCOp.evaluateAsConstantImm(Imm))
45 return false;
46 return isShiftedInt<6, 4>(x: Imm) && (Imm != 0);
47 }
48 case 5: {
49 // bare_simm9_lsb0
50 int64_t Imm;
51 if (MCOp.evaluateAsConstantImm(Imm))
52 return isShiftedInt<8, 1>(x: Imm);
53 return MCOp.isBareSymbolRef();
54 }
55 case 6: {
56 // uimmlog2xlennonzero
57 int64_t Imm;
58 if (!MCOp.evaluateAsConstantImm(Imm))
59 return false;
60 if (STI.getTargetTriple().isArch64Bit())
61 return isUInt<6>(x: Imm) && (Imm != 0);
62 return isUInt<5>(x: Imm) && (Imm != 0);
63 }
64 case 7: {
65 // uimm8_lsb000
66 int64_t Imm;
67 if (!MCOp.evaluateAsConstantImm(Imm))
68 return false;
69 return isShiftedUInt<5, 3>(x: Imm);
70 }
71 case 8: {
72 // uimm8_lsb000_optional
73 int64_t Imm;
74 if (!MCOp.evaluateAsConstantImm(Imm))
75 return false;
76 return isShiftedUInt<5, 3>(x: Imm);
77 }
78 case 9: {
79 // uimm9_lsb000
80 int64_t Imm;
81 if (!MCOp.evaluateAsConstantImm(Imm))
82 return false;
83 return isShiftedUInt<6, 3>(x: Imm);
84 }
85 case 10: {
86 // uimm9_lsb000_optional
87 int64_t Imm;
88 if (!MCOp.evaluateAsConstantImm(Imm))
89 return false;
90 return isShiftedUInt<6, 3>(x: Imm);
91 }
92 case 11: {
93 // uimm7_lsb00
94 int64_t Imm;
95 if (!MCOp.evaluateAsConstantImm(Imm))
96 return false;
97 return isShiftedUInt<5, 2>(x: Imm);
98 }
99 case 12: {
100 // uimm7_lsb00_optional
101 int64_t Imm;
102 if (!MCOp.evaluateAsConstantImm(Imm))
103 return false;
104 return isShiftedUInt<5, 2>(x: Imm);
105 }
106 case 13: {
107 // uimm8_lsb00
108 int64_t Imm;
109 if (!MCOp.evaluateAsConstantImm(Imm))
110 return false;
111 return isShiftedUInt<6, 2>(x: Imm);
112 }
113 case 14: {
114 // uimm8_lsb00_optional
115 int64_t Imm;
116 if (!MCOp.evaluateAsConstantImm(Imm))
117 return false;
118 return isShiftedUInt<6, 2>(x: Imm);
119 }
120 case 15: {
121 // bare_simm12_lsb0
122 int64_t Imm;
123 if (MCOp.evaluateAsConstantImm(Imm))
124 return isShiftedInt<11, 1>(x: Imm);
125 return MCOp.isBareSymbolRef();
126 }
127 case 16: {
128 // uimm2
129 int64_t Imm;
130 if (!MCOp.evaluateAsConstantImm(Imm))
131 return false;
132 return isUInt<2>(x: Imm);
133 }
134 case 17: {
135 // uimm2_optional
136 int64_t Imm;
137 if (!MCOp.evaluateAsConstantImm(Imm))
138 return false;
139 return isUInt<2>(x: Imm);
140 }
141 case 18: {
142 // uimm5
143 int64_t Imm;
144 if (!MCOp.evaluateAsConstantImm(Imm))
145 return false;
146 return isUInt<5>(x: Imm);
147 }
148 case 19: {
149 // uimm5_optional
150 int64_t Imm;
151 if (!MCOp.evaluateAsConstantImm(Imm))
152 return false;
153 return isUInt<5>(x: Imm);
154 }
155 case 20: {
156 // uimm4
157 int64_t Imm;
158 if (!MCOp.evaluateAsConstantImm(Imm))
159 return false;
160 return isUInt<4>(x: Imm);
161 }
162 case 21: {
163 // uimm4_optional
164 int64_t Imm;
165 if (!MCOp.evaluateAsConstantImm(Imm))
166 return false;
167 return isUInt<4>(x: Imm);
168 }
169 case 22: {
170 // uimm2_lsb0
171 int64_t Imm;
172 if (!MCOp.evaluateAsConstantImm(Imm))
173 return false;
174 return isShiftedUInt<1, 1>(x: Imm);
175 }
176 case 23: {
177 // uimm2_lsb0_optional
178 int64_t Imm;
179 if (!MCOp.evaluateAsConstantImm(Imm))
180 return false;
181 return isShiftedUInt<1, 1>(x: Imm);
182 }
183 case 24: {
184 // uimm6_lsb0
185 int64_t Imm;
186 if (!MCOp.evaluateAsConstantImm(Imm))
187 return false;
188 return isShiftedUInt<5, 1>(x: Imm);
189 }
190 case 25: {
191 // uimm6_lsb0_optional
192 int64_t Imm;
193 if (!MCOp.evaluateAsConstantImm(Imm))
194 return false;
195 return isShiftedUInt<5, 1>(x: Imm);
196 }
197 case 26: {
198 // uimm5_lsb0
199 int64_t Imm;
200 if (!MCOp.evaluateAsConstantImm(Imm))
201 return false;
202 return isShiftedUInt<4, 1>(x: Imm);
203 }
204 case 27: {
205 // uimm5_lsb0_optional
206 int64_t Imm;
207 if (!MCOp.evaluateAsConstantImm(Imm))
208 return false;
209 return isShiftedUInt<4, 1>(x: Imm);
210 }
211 case 28: {
212 // c_lui_imm
213 int64_t Imm;
214 if (!MCOp.evaluateAsConstantImm(Imm))
215 return false;
216 return (Imm != 0) && (isUInt<5>(x: Imm) ||
217 (Imm >= 0xfffe0 && Imm <= 0xfffff));
218 }
219 case 29: {
220 // uimm5ge6_plus1
221 int64_t Imm;
222 if (!MCOp.evaluateAsConstantImm(Imm))
223 return false;
224 return Imm >= 6 && Imm <= 32;
225 }
226 case 30: {
227 // simm12_lo
228 int64_t Imm;
229 if (MCOp.evaluateAsConstantImm(Imm))
230 return isInt<12>(x: Imm);
231 return MCOp.isBareSymbolRef();
232 }
233 case 31: {
234 // simm5nonzero
235 int64_t Imm;
236 if (!MCOp.evaluateAsConstantImm(Imm))
237 return false;
238 return (Imm != 0) && isInt<5>(x: Imm);
239 }
240 case 32: {
241 // bare_simm13_lsb0
242 int64_t Imm;
243 if (MCOp.evaluateAsConstantImm(Imm))
244 return isShiftedInt<12, 1>(x: Imm);
245 return MCOp.isBareSymbolRef();
246 }
247 case 33: {
248 // uimm5nonzero
249 int64_t Imm;
250 if (!MCOp.evaluateAsConstantImm(Imm))
251 return false;
252 return (Imm != 0) && isUInt<5>(x: Imm);;
253 }
254 case 34: {
255 // simm21_lsb0_jal
256 int64_t Imm;
257 if (MCOp.evaluateAsConstantImm(Imm))
258 return isShiftedInt<20, 1>(x: Imm);
259 return MCOp.isBareSymbolRef();
260 }
261 case 35: {
262 // simm12_lo_optional
263 int64_t Imm;
264 if (MCOp.evaluateAsConstantImm(Imm))
265 return isInt<12>(x: Imm);
266 return MCOp.isBareSymbolRef();
267 }
268 case 36: {
269 // simm20_li
270 int64_t Imm;
271 if (MCOp.evaluateAsConstantImm(Imm))
272 return isInt<20>(x: Imm);
273 return MCOp.isBareSymbolRef();
274 }
275 case 37: {
276 // uimm5slist
277 int64_t Imm;
278 if (!MCOp.evaluateAsConstantImm(Imm))
279 return false;
280 return ((Imm == 0) || (Imm == 1) ||
281 (Imm == 2) || (Imm == 4) ||
282 (Imm == 8) || (Imm == 16) ||
283 (Imm == 15) || (Imm == 31));
284 }
285 case 38: {
286 // uimmlog2xlen
287 int64_t Imm;
288 if (!MCOp.evaluateAsConstantImm(Imm))
289 return false;
290 if (STI.getTargetTriple().isArch64Bit())
291 return isUInt<6>(x: Imm);
292 return isUInt<5>(x: Imm);
293 }
294 }
295}
296
297static bool compressInst(MCInst &OutInst,
298 const MCInst &MI,
299 const MCSubtargetInfo &STI) {
300 switch (MI.getOpcode()) {
301 default: return false;
302 case RISCV::ADD: {
303 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
304 MI.getOperand(i: 1).isReg() &&
305 (MI.getOperand(i: 1).getReg() == RISCV::X0) &&
306 MI.getOperand(i: 0).isReg() &&
307 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
308 MI.getOperand(i: 2).isReg() &&
309 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
310 // c.mv $rs1, $rs2
311 OutInst.setOpcode(RISCV::C_MV);
312 // Operand: rs1
313 OutInst.addOperand(Op: MI.getOperand(i: 0));
314 // Operand: rs2
315 OutInst.addOperand(Op: MI.getOperand(i: 2));
316 OutInst.setLoc(MI.getLoc());
317 return true;
318 } // if
319 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
320 MI.getOperand(i: 2).isReg() &&
321 (MI.getOperand(i: 2).getReg() == RISCV::X0) &&
322 MI.getOperand(i: 0).isReg() &&
323 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
324 MI.getOperand(i: 1).isReg() &&
325 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
326 // c.mv $rs1, $rs2
327 OutInst.setOpcode(RISCV::C_MV);
328 // Operand: rs1
329 OutInst.addOperand(Op: MI.getOperand(i: 0));
330 // Operand: rs2
331 OutInst.addOperand(Op: MI.getOperand(i: 1));
332 OutInst.setLoc(MI.getLoc());
333 return true;
334 } // if
335 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
336 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
337 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
338 MI.getOperand(i: 1).isReg() &&
339 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
340 MI.getOperand(i: 2).isReg() &&
341 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
342 // c.add $rs1, $rs2
343 OutInst.setOpcode(RISCV::C_ADD);
344 // Operand: rd
345 OutInst.addOperand(Op: MI.getOperand(i: 1));
346 // Operand: rs1
347 OutInst.addOperand(Op: MI.getOperand(i: 1));
348 // Operand: rs2
349 OutInst.addOperand(Op: MI.getOperand(i: 2));
350 OutInst.setLoc(MI.getLoc());
351 return true;
352 } // if
353 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
354 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
355 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
356 MI.getOperand(i: 2).isReg() &&
357 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 2).getReg()) &&
358 MI.getOperand(i: 1).isReg() &&
359 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
360 // c.add $rs1, $rs2
361 OutInst.setOpcode(RISCV::C_ADD);
362 // Operand: rd
363 OutInst.addOperand(Op: MI.getOperand(i: 2));
364 // Operand: rs1
365 OutInst.addOperand(Op: MI.getOperand(i: 2));
366 // Operand: rs2
367 OutInst.addOperand(Op: MI.getOperand(i: 1));
368 OutInst.setLoc(MI.getLoc());
369 return true;
370 } // if
371 break;
372 } // case ADD
373 case RISCV::ADDI: {
374 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
375 MI.getOperand(i: 0).isReg() &&
376 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
377 MI.getOperand(i: 1).isReg() &&
378 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
379 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 1 /* uimm10_lsb00nonzero */)) {
380 // c.addi4spn $rd, $rs1, $imm
381 OutInst.setOpcode(RISCV::C_ADDI4SPN);
382 // Operand: rd
383 OutInst.addOperand(Op: MI.getOperand(i: 0));
384 // Operand: rs1
385 OutInst.addOperand(Op: MI.getOperand(i: 1));
386 // Operand: imm
387 OutInst.addOperand(Op: MI.getOperand(i: 2));
388 OutInst.setLoc(MI.getLoc());
389 return true;
390 } // if
391 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
392 MI.getOperand(i: 0).isReg() &&
393 (MI.getOperand(i: 0).getReg() == RISCV::X0) &&
394 MI.getOperand(i: 1).isReg() &&
395 (MI.getOperand(i: 1).getReg() == RISCV::X0) &&
396 MI.getOperand(i: 2).isImm() &&
397 (MI.getOperand(i: 2).getImm() == 0)) {
398 // c.nop
399 OutInst.setOpcode(RISCV::C_NOP);
400 OutInst.setLoc(MI.getLoc());
401 return true;
402 } // if
403 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
404 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
405 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
406 MI.getOperand(i: 1).isReg() &&
407 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
408 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm6nonzero */) &&
409 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 3 /* simm6 */)) {
410 // c.addi $rd, $imm
411 OutInst.setOpcode(RISCV::C_ADDI);
412 // Operand: rd_wb
413 OutInst.addOperand(Op: MI.getOperand(i: 1));
414 // Operand: rd
415 OutInst.addOperand(Op: MI.getOperand(i: 1));
416 // Operand: imm
417 OutInst.addOperand(Op: MI.getOperand(i: 2));
418 OutInst.setLoc(MI.getLoc());
419 return true;
420 } // if
421 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
422 MI.getOperand(i: 1).isReg() &&
423 (MI.getOperand(i: 1).getReg() == RISCV::X0) &&
424 MI.getOperand(i: 0).isReg() &&
425 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
426 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 3 /* simm6 */)) {
427 // c.li $rd, $imm
428 OutInst.setOpcode(RISCV::C_LI);
429 // Operand: rd
430 OutInst.addOperand(Op: MI.getOperand(i: 0));
431 // Operand: imm
432 OutInst.addOperand(Op: MI.getOperand(i: 2));
433 OutInst.setLoc(MI.getLoc());
434 return true;
435 } // if
436 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
437 MI.getOperand(i: 0).isReg() &&
438 (MI.getOperand(i: 0).getReg() == RISCV::X2) &&
439 MI.getOperand(i: 1).isReg() &&
440 (MI.getOperand(i: 1).getReg() == RISCV::X2) &&
441 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 4 /* simm10_lsb0000nonzero */)) {
442 // c.addi16sp $rd, $imm
443 OutInst.setOpcode(RISCV::C_ADDI16SP);
444 // Operand: rd_wb
445 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X2));
446 // Operand: rd
447 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X2));
448 // Operand: imm
449 OutInst.addOperand(Op: MI.getOperand(i: 2));
450 OutInst.setLoc(MI.getLoc());
451 return true;
452 } // if
453 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
454 MI.getOperand(i: 2).isImm() &&
455 (MI.getOperand(i: 2).getImm() == 0) &&
456 MI.getOperand(i: 0).isReg() &&
457 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
458 MI.getOperand(i: 1).isReg() &&
459 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
460 // c.mv $rs1, $rs2
461 OutInst.setOpcode(RISCV::C_MV);
462 // Operand: rs1
463 OutInst.addOperand(Op: MI.getOperand(i: 0));
464 // Operand: rs2
465 OutInst.addOperand(Op: MI.getOperand(i: 1));
466 OutInst.setLoc(MI.getLoc());
467 return true;
468 } // if
469 break;
470 } // case ADDI
471 case RISCV::ADDIW: {
472 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
473 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
474 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
475 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
476 MI.getOperand(i: 1).isReg() &&
477 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
478 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 3 /* simm6 */)) {
479 // c.addiw $rd, $imm
480 OutInst.setOpcode(RISCV::C_ADDIW);
481 // Operand: rd_wb
482 OutInst.addOperand(Op: MI.getOperand(i: 1));
483 // Operand: rd
484 OutInst.addOperand(Op: MI.getOperand(i: 1));
485 // Operand: imm
486 OutInst.addOperand(Op: MI.getOperand(i: 2));
487 OutInst.setLoc(MI.getLoc());
488 return true;
489 } // if
490 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
491 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
492 MI.getOperand(i: 1).isReg() &&
493 (MI.getOperand(i: 1).getReg() == RISCV::X0) &&
494 MI.getOperand(i: 0).isReg() &&
495 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
496 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 3 /* simm6 */)) {
497 // c.li $rd, $imm
498 OutInst.setOpcode(RISCV::C_LI);
499 // Operand: rd
500 OutInst.addOperand(Op: MI.getOperand(i: 0));
501 // Operand: imm
502 OutInst.addOperand(Op: MI.getOperand(i: 2));
503 OutInst.setLoc(MI.getLoc());
504 return true;
505 } // if
506 break;
507 } // case ADDIW
508 case RISCV::ADDW: {
509 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
510 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
511 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
512 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
513 MI.getOperand(i: 1).isReg() &&
514 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
515 MI.getOperand(i: 2).isReg() &&
516 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
517 // c.addw $rd, $rs2
518 OutInst.setOpcode(RISCV::C_ADDW);
519 // Operand: rd_wb
520 OutInst.addOperand(Op: MI.getOperand(i: 1));
521 // Operand: rd
522 OutInst.addOperand(Op: MI.getOperand(i: 1));
523 // Operand: rs2
524 OutInst.addOperand(Op: MI.getOperand(i: 2));
525 OutInst.setLoc(MI.getLoc());
526 return true;
527 } // if
528 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
529 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
530 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
531 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
532 MI.getOperand(i: 2).isReg() &&
533 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg()) &&
534 MI.getOperand(i: 1).isReg() &&
535 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
536 // c.addw $rd, $rs2
537 OutInst.setOpcode(RISCV::C_ADDW);
538 // Operand: rd_wb
539 OutInst.addOperand(Op: MI.getOperand(i: 2));
540 // Operand: rd
541 OutInst.addOperand(Op: MI.getOperand(i: 2));
542 // Operand: rs2
543 OutInst.addOperand(Op: MI.getOperand(i: 1));
544 OutInst.setLoc(MI.getLoc());
545 return true;
546 } // if
547 break;
548 } // case ADDW
549 case RISCV::ADD_UW: {
550 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
551 STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
552 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
553 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
554 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
555 MI.getOperand(i: 2).isReg() &&
556 (MI.getOperand(i: 2).getReg() == RISCV::X0) &&
557 MI.getOperand(i: 1).isReg() &&
558 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
559 // c.zext.w $rd
560 OutInst.setOpcode(RISCV::C_ZEXT_W);
561 // Operand: rd_wb
562 OutInst.addOperand(Op: MI.getOperand(i: 1));
563 // Operand: rd
564 OutInst.addOperand(Op: MI.getOperand(i: 1));
565 OutInst.setLoc(MI.getLoc());
566 return true;
567 } // if
568 break;
569 } // case ADD_UW
570 case RISCV::AND: {
571 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
572 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
573 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
574 MI.getOperand(i: 1).isReg() &&
575 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
576 MI.getOperand(i: 2).isReg() &&
577 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
578 // c.and $rd, $rs2
579 OutInst.setOpcode(RISCV::C_AND);
580 // Operand: rd_wb
581 OutInst.addOperand(Op: MI.getOperand(i: 1));
582 // Operand: rd
583 OutInst.addOperand(Op: MI.getOperand(i: 1));
584 // Operand: rs2
585 OutInst.addOperand(Op: MI.getOperand(i: 2));
586 OutInst.setLoc(MI.getLoc());
587 return true;
588 } // if
589 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
590 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
591 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
592 MI.getOperand(i: 2).isReg() &&
593 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg()) &&
594 MI.getOperand(i: 1).isReg() &&
595 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
596 // c.and $rd, $rs2
597 OutInst.setOpcode(RISCV::C_AND);
598 // Operand: rd_wb
599 OutInst.addOperand(Op: MI.getOperand(i: 2));
600 // Operand: rd
601 OutInst.addOperand(Op: MI.getOperand(i: 2));
602 // Operand: rs2
603 OutInst.addOperand(Op: MI.getOperand(i: 1));
604 OutInst.setLoc(MI.getLoc());
605 return true;
606 } // if
607 break;
608 } // case AND
609 case RISCV::ANDI: {
610 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
611 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
612 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
613 MI.getOperand(i: 1).isReg() &&
614 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
615 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 3 /* simm6 */)) {
616 // c.andi $rs1, $imm
617 OutInst.setOpcode(RISCV::C_ANDI);
618 // Operand: rd
619 OutInst.addOperand(Op: MI.getOperand(i: 1));
620 // Operand: rs1
621 OutInst.addOperand(Op: MI.getOperand(i: 1));
622 // Operand: imm
623 OutInst.addOperand(Op: MI.getOperand(i: 2));
624 OutInst.setLoc(MI.getLoc());
625 return true;
626 } // if
627 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
628 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
629 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
630 MI.getOperand(i: 2).isImm() &&
631 (MI.getOperand(i: 2).getImm() == 255) &&
632 MI.getOperand(i: 1).isReg() &&
633 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
634 // c.zext.b $rd
635 OutInst.setOpcode(RISCV::C_ZEXT_B);
636 // Operand: rd_wb
637 OutInst.addOperand(Op: MI.getOperand(i: 1));
638 // Operand: rd
639 OutInst.addOperand(Op: MI.getOperand(i: 1));
640 OutInst.setLoc(MI.getLoc());
641 return true;
642 } // if
643 break;
644 } // case ANDI
645 case RISCV::BEQ: {
646 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
647 MI.getOperand(i: 1).isReg() &&
648 (MI.getOperand(i: 1).getReg() == RISCV::X0) &&
649 MI.getOperand(i: 0).isReg() &&
650 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
651 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 5 /* bare_simm9_lsb0 */)) {
652 // c.beqz $rs1, $imm
653 OutInst.setOpcode(RISCV::C_BEQZ);
654 // Operand: rs1
655 OutInst.addOperand(Op: MI.getOperand(i: 0));
656 // Operand: imm
657 OutInst.addOperand(Op: MI.getOperand(i: 2));
658 OutInst.setLoc(MI.getLoc());
659 return true;
660 } // if
661 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
662 MI.getOperand(i: 0).isReg() &&
663 (MI.getOperand(i: 0).getReg() == RISCV::X0) &&
664 MI.getOperand(i: 1).isReg() &&
665 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
666 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 5 /* bare_simm9_lsb0 */)) {
667 // c.beqz $rs1, $imm
668 OutInst.setOpcode(RISCV::C_BEQZ);
669 // Operand: rs1
670 OutInst.addOperand(Op: MI.getOperand(i: 1));
671 // Operand: imm
672 OutInst.addOperand(Op: MI.getOperand(i: 2));
673 OutInst.setLoc(MI.getLoc());
674 return true;
675 } // if
676 break;
677 } // case BEQ
678 case RISCV::BEXTI: {
679 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
680 STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
681 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
682 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
683 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
684 MI.getOperand(i: 1).isReg() &&
685 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
686 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 6 /* uimmlog2xlennonzero */)) {
687 // qc.c.bexti $rs1, $shamt
688 OutInst.setOpcode(RISCV::QC_C_BEXTI);
689 // Operand: rd
690 OutInst.addOperand(Op: MI.getOperand(i: 1));
691 // Operand: rs1
692 OutInst.addOperand(Op: MI.getOperand(i: 1));
693 // Operand: shamt
694 OutInst.addOperand(Op: MI.getOperand(i: 2));
695 OutInst.setLoc(MI.getLoc());
696 return true;
697 } // if
698 break;
699 } // case BEXTI
700 case RISCV::BNE: {
701 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
702 MI.getOperand(i: 1).isReg() &&
703 (MI.getOperand(i: 1).getReg() == RISCV::X0) &&
704 MI.getOperand(i: 0).isReg() &&
705 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
706 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 5 /* bare_simm9_lsb0 */)) {
707 // c.bnez $rs1, $imm
708 OutInst.setOpcode(RISCV::C_BNEZ);
709 // Operand: rs1
710 OutInst.addOperand(Op: MI.getOperand(i: 0));
711 // Operand: imm
712 OutInst.addOperand(Op: MI.getOperand(i: 2));
713 OutInst.setLoc(MI.getLoc());
714 return true;
715 } // if
716 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
717 MI.getOperand(i: 0).isReg() &&
718 (MI.getOperand(i: 0).getReg() == RISCV::X0) &&
719 MI.getOperand(i: 1).isReg() &&
720 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
721 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 5 /* bare_simm9_lsb0 */)) {
722 // c.bnez $rs1, $imm
723 OutInst.setOpcode(RISCV::C_BNEZ);
724 // Operand: rs1
725 OutInst.addOperand(Op: MI.getOperand(i: 1));
726 // Operand: imm
727 OutInst.addOperand(Op: MI.getOperand(i: 2));
728 OutInst.setLoc(MI.getLoc());
729 return true;
730 } // if
731 break;
732 } // case BNE
733 case RISCV::BSETI: {
734 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
735 STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
736 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
737 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
738 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
739 MI.getOperand(i: 1).isReg() &&
740 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
741 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 6 /* uimmlog2xlennonzero */)) {
742 // qc.c.bseti $rs1, $shamt
743 OutInst.setOpcode(RISCV::QC_C_BSETI);
744 // Operand: rd
745 OutInst.addOperand(Op: MI.getOperand(i: 1));
746 // Operand: rs1
747 OutInst.addOperand(Op: MI.getOperand(i: 1));
748 // Operand: shamt
749 OutInst.addOperand(Op: MI.getOperand(i: 2));
750 OutInst.setLoc(MI.getLoc());
751 return true;
752 } // if
753 break;
754 } // case BSETI
755 case RISCV::EBREAK: {
756 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca]) {
757 // c.ebreak
758 OutInst.setOpcode(RISCV::C_EBREAK);
759 OutInst.setLoc(MI.getLoc());
760 return true;
761 } // if
762 break;
763 } // case EBREAK
764 case RISCV::FLD: {
765 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
766 MI.getOperand(i: 0).isReg() &&
767 getRISCVMCRegisterClass(RC: RISCV::FPR64CRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
768 MI.getOperand(i: 1).isReg() &&
769 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
770 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 7 /* uimm8_lsb000 */) &&
771 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000_optional */)) {
772 // c.fld $rd, ${imm}(${rs1})
773 OutInst.setOpcode(RISCV::C_FLD);
774 // Operand: rd
775 OutInst.addOperand(Op: MI.getOperand(i: 0));
776 // Operand: rs1
777 OutInst.addOperand(Op: MI.getOperand(i: 1));
778 // Operand: imm
779 OutInst.addOperand(Op: MI.getOperand(i: 2));
780 OutInst.setLoc(MI.getLoc());
781 return true;
782 } // if
783 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
784 MI.getOperand(i: 0).isReg() &&
785 getRISCVMCRegisterClass(RC: RISCV::FPR64RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
786 MI.getOperand(i: 1).isReg() &&
787 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
788 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* uimm9_lsb000 */) &&
789 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm9_lsb000_optional */)) {
790 // c.fldsp $rd, ${imm}(${rs1})
791 OutInst.setOpcode(RISCV::C_FLDSP);
792 // Operand: rd
793 OutInst.addOperand(Op: MI.getOperand(i: 0));
794 // Operand: rs1
795 OutInst.addOperand(Op: MI.getOperand(i: 1));
796 // Operand: imm
797 OutInst.addOperand(Op: MI.getOperand(i: 2));
798 OutInst.setLoc(MI.getLoc());
799 return true;
800 } // if
801 break;
802 } // case FLD
803 case RISCV::FLW: {
804 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
805 STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
806 MI.getOperand(i: 0).isReg() &&
807 getRISCVMCRegisterClass(RC: RISCV::FPR32CRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
808 MI.getOperand(i: 1).isReg() &&
809 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
810 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 11 /* uimm7_lsb00 */) &&
811 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 12 /* uimm7_lsb00_optional */)) {
812 // c.flw $rd, ${imm}(${rs1})
813 OutInst.setOpcode(RISCV::C_FLW);
814 // Operand: rd
815 OutInst.addOperand(Op: MI.getOperand(i: 0));
816 // Operand: rs1
817 OutInst.addOperand(Op: MI.getOperand(i: 1));
818 // Operand: imm
819 OutInst.addOperand(Op: MI.getOperand(i: 2));
820 OutInst.setLoc(MI.getLoc());
821 return true;
822 } // if
823 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
824 STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
825 MI.getOperand(i: 0).isReg() &&
826 getRISCVMCRegisterClass(RC: RISCV::FPR32RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
827 MI.getOperand(i: 1).isReg() &&
828 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
829 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 13 /* uimm8_lsb00 */) &&
830 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 14 /* uimm8_lsb00_optional */)) {
831 // c.flwsp $rd, ${imm}(${rs1})
832 OutInst.setOpcode(RISCV::C_FLWSP);
833 // Operand: rd
834 OutInst.addOperand(Op: MI.getOperand(i: 0));
835 // Operand: rs1
836 OutInst.addOperand(Op: MI.getOperand(i: 1));
837 // Operand: imm
838 OutInst.addOperand(Op: MI.getOperand(i: 2));
839 OutInst.setLoc(MI.getLoc());
840 return true;
841 } // if
842 break;
843 } // case FLW
844 case RISCV::FSD: {
845 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
846 MI.getOperand(i: 0).isReg() &&
847 getRISCVMCRegisterClass(RC: RISCV::FPR64CRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
848 MI.getOperand(i: 1).isReg() &&
849 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
850 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 7 /* uimm8_lsb000 */) &&
851 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000_optional */)) {
852 // c.fsd $rs2, ${imm}(${rs1})
853 OutInst.setOpcode(RISCV::C_FSD);
854 // Operand: rs2
855 OutInst.addOperand(Op: MI.getOperand(i: 0));
856 // Operand: rs1
857 OutInst.addOperand(Op: MI.getOperand(i: 1));
858 // Operand: imm
859 OutInst.addOperand(Op: MI.getOperand(i: 2));
860 OutInst.setLoc(MI.getLoc());
861 return true;
862 } // if
863 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
864 MI.getOperand(i: 0).isReg() &&
865 getRISCVMCRegisterClass(RC: RISCV::FPR64RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
866 MI.getOperand(i: 1).isReg() &&
867 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
868 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* uimm9_lsb000 */) &&
869 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm9_lsb000_optional */)) {
870 // c.fsdsp $rs2, ${imm}(${rs1})
871 OutInst.setOpcode(RISCV::C_FSDSP);
872 // Operand: rs2
873 OutInst.addOperand(Op: MI.getOperand(i: 0));
874 // Operand: rs1
875 OutInst.addOperand(Op: MI.getOperand(i: 1));
876 // Operand: imm
877 OutInst.addOperand(Op: MI.getOperand(i: 2));
878 OutInst.setLoc(MI.getLoc());
879 return true;
880 } // if
881 break;
882 } // case FSD
883 case RISCV::FSW: {
884 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
885 STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
886 MI.getOperand(i: 0).isReg() &&
887 getRISCVMCRegisterClass(RC: RISCV::FPR32CRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
888 MI.getOperand(i: 1).isReg() &&
889 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
890 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 11 /* uimm7_lsb00 */) &&
891 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 12 /* uimm7_lsb00_optional */)) {
892 // c.fsw $rs2, ${imm}(${rs1})
893 OutInst.setOpcode(RISCV::C_FSW);
894 // Operand: rs2
895 OutInst.addOperand(Op: MI.getOperand(i: 0));
896 // Operand: rs1
897 OutInst.addOperand(Op: MI.getOperand(i: 1));
898 // Operand: imm
899 OutInst.addOperand(Op: MI.getOperand(i: 2));
900 OutInst.setLoc(MI.getLoc());
901 return true;
902 } // if
903 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
904 STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
905 MI.getOperand(i: 0).isReg() &&
906 getRISCVMCRegisterClass(RC: RISCV::FPR32RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
907 MI.getOperand(i: 1).isReg() &&
908 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
909 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 13 /* uimm8_lsb00 */) &&
910 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 14 /* uimm8_lsb00_optional */)) {
911 // c.fswsp $rs2, ${imm}(${rs1})
912 OutInst.setOpcode(RISCV::C_FSWSP);
913 // Operand: rs2
914 OutInst.addOperand(Op: MI.getOperand(i: 0));
915 // Operand: rs1
916 OutInst.addOperand(Op: MI.getOperand(i: 1));
917 // Operand: imm
918 OutInst.addOperand(Op: MI.getOperand(i: 2));
919 OutInst.setLoc(MI.getLoc());
920 return true;
921 } // if
922 break;
923 } // case FSW
924 case RISCV::JAL: {
925 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
926 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
927 MI.getOperand(i: 0).isReg() &&
928 (MI.getOperand(i: 0).getReg() == RISCV::X1) &&
929 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 15 /* bare_simm12_lsb0 */)) {
930 // c.jal $offset
931 OutInst.setOpcode(RISCV::C_JAL);
932 // Operand: offset
933 OutInst.addOperand(Op: MI.getOperand(i: 1));
934 OutInst.setLoc(MI.getLoc());
935 return true;
936 } // if
937 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
938 MI.getOperand(i: 0).isReg() &&
939 (MI.getOperand(i: 0).getReg() == RISCV::X0) &&
940 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 15 /* bare_simm12_lsb0 */)) {
941 // c.j $offset
942 OutInst.setOpcode(RISCV::C_J);
943 // Operand: offset
944 OutInst.addOperand(Op: MI.getOperand(i: 1));
945 OutInst.setLoc(MI.getLoc());
946 return true;
947 } // if
948 break;
949 } // case JAL
950 case RISCV::JALR: {
951 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
952 MI.getOperand(i: 0).isReg() &&
953 (MI.getOperand(i: 0).getReg() == RISCV::X0) &&
954 MI.getOperand(i: 2).isImm() &&
955 (MI.getOperand(i: 2).getImm() == 0) &&
956 MI.getOperand(i: 1).isReg() &&
957 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
958 // c.jr $rs1
959 OutInst.setOpcode(RISCV::C_JR);
960 // Operand: rs1
961 OutInst.addOperand(Op: MI.getOperand(i: 1));
962 OutInst.setLoc(MI.getLoc());
963 return true;
964 } // if
965 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
966 MI.getOperand(i: 0).isReg() &&
967 (MI.getOperand(i: 0).getReg() == RISCV::X1) &&
968 MI.getOperand(i: 2).isImm() &&
969 (MI.getOperand(i: 2).getImm() == 0) &&
970 MI.getOperand(i: 1).isReg() &&
971 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
972 // c.jalr $rs1
973 OutInst.setOpcode(RISCV::C_JALR);
974 // Operand: rs1
975 OutInst.addOperand(Op: MI.getOperand(i: 1));
976 OutInst.setLoc(MI.getLoc());
977 return true;
978 } // if
979 break;
980 } // case JALR
981 case RISCV::LBU: {
982 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
983 MI.getOperand(i: 0).isReg() &&
984 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
985 MI.getOperand(i: 1).isReg() &&
986 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
987 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 16 /* uimm2 */) &&
988 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 17 /* uimm2_optional */)) {
989 // c.lbu $rd, ${imm}(${rs1})
990 OutInst.setOpcode(RISCV::C_LBU);
991 // Operand: rd
992 OutInst.addOperand(Op: MI.getOperand(i: 0));
993 // Operand: rs1
994 OutInst.addOperand(Op: MI.getOperand(i: 1));
995 // Operand: imm
996 OutInst.addOperand(Op: MI.getOperand(i: 2));
997 OutInst.setLoc(MI.getLoc());
998 return true;
999 } // if
1000 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
1001 MI.getOperand(i: 0).isReg() &&
1002 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1003 MI.getOperand(i: 1).isReg() &&
1004 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1005 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 18 /* uimm5 */) &&
1006 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 19 /* uimm5_optional */)) {
1007 // qk.c.lbu $rd, ${imm}(${rs1})
1008 OutInst.setOpcode(RISCV::QK_C_LBU);
1009 // Operand: rd
1010 OutInst.addOperand(Op: MI.getOperand(i: 0));
1011 // Operand: rs1
1012 OutInst.addOperand(Op: MI.getOperand(i: 1));
1013 // Operand: imm
1014 OutInst.addOperand(Op: MI.getOperand(i: 2));
1015 OutInst.setLoc(MI.getLoc());
1016 return true;
1017 } // if
1018 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
1019 MI.getOperand(i: 0).isReg() &&
1020 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1021 MI.getOperand(i: 1).isReg() &&
1022 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1023 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 20 /* uimm4 */) &&
1024 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 21 /* uimm4_optional */)) {
1025 // qk.c.lbusp $rd_rs2, ${imm}(${rs1})
1026 OutInst.setOpcode(RISCV::QK_C_LBUSP);
1027 // Operand: rd_rs2
1028 OutInst.addOperand(Op: MI.getOperand(i: 0));
1029 // Operand: rs1
1030 OutInst.addOperand(Op: MI.getOperand(i: 1));
1031 // Operand: imm
1032 OutInst.addOperand(Op: MI.getOperand(i: 2));
1033 OutInst.setLoc(MI.getLoc());
1034 return true;
1035 } // if
1036 break;
1037 } // case LBU
1038 case RISCV::LD: {
1039 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
1040 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1041 MI.getOperand(i: 0).isReg() &&
1042 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1043 MI.getOperand(i: 1).isReg() &&
1044 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1045 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 7 /* uimm8_lsb000 */) &&
1046 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000_optional */)) {
1047 // c.ld $rd, ${imm}(${rs1})
1048 OutInst.setOpcode(RISCV::C_LD);
1049 // Operand: rd
1050 OutInst.addOperand(Op: MI.getOperand(i: 0));
1051 // Operand: rs1
1052 OutInst.addOperand(Op: MI.getOperand(i: 1));
1053 // Operand: imm
1054 OutInst.addOperand(Op: MI.getOperand(i: 2));
1055 OutInst.setLoc(MI.getLoc());
1056 return true;
1057 } // if
1058 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
1059 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1060 MI.getOperand(i: 0).isReg() &&
1061 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1062 MI.getOperand(i: 1).isReg() &&
1063 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1064 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* uimm9_lsb000 */) &&
1065 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm9_lsb000_optional */)) {
1066 // c.ldsp $rd, ${imm}(${rs1})
1067 OutInst.setOpcode(RISCV::C_LDSP);
1068 // Operand: rd
1069 OutInst.addOperand(Op: MI.getOperand(i: 0));
1070 // Operand: rs1
1071 OutInst.addOperand(Op: MI.getOperand(i: 1));
1072 // Operand: imm
1073 OutInst.addOperand(Op: MI.getOperand(i: 2));
1074 OutInst.setLoc(MI.getLoc());
1075 return true;
1076 } // if
1077 break;
1078 } // case LD
1079 case RISCV::LD_RV32: {
1080 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1081 STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
1082 MI.getOperand(i: 0).isReg() &&
1083 getRISCVMCRegisterClass(RC: RISCV::GPRPairNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1084 MI.getOperand(i: 1).isReg() &&
1085 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1086 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* uimm9_lsb000 */) &&
1087 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm9_lsb000_optional */)) {
1088 // c.ldsp $rd, ${imm}(${rs1})
1089 OutInst.setOpcode(RISCV::C_LDSP_RV32);
1090 // Operand: rd
1091 OutInst.addOperand(Op: MI.getOperand(i: 0));
1092 // Operand: rs1
1093 OutInst.addOperand(Op: MI.getOperand(i: 1));
1094 // Operand: imm
1095 OutInst.addOperand(Op: MI.getOperand(i: 2));
1096 OutInst.setLoc(MI.getLoc());
1097 return true;
1098 } // if
1099 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1100 STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
1101 MI.getOperand(i: 0).isReg() &&
1102 getRISCVMCRegisterClass(RC: RISCV::GPRPairCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1103 MI.getOperand(i: 1).isReg() &&
1104 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1105 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 7 /* uimm8_lsb000 */) &&
1106 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000_optional */)) {
1107 // c.ld $rd, ${imm}(${rs1})
1108 OutInst.setOpcode(RISCV::C_LD_RV32);
1109 // Operand: rd
1110 OutInst.addOperand(Op: MI.getOperand(i: 0));
1111 // Operand: rs1
1112 OutInst.addOperand(Op: MI.getOperand(i: 1));
1113 // Operand: imm
1114 OutInst.addOperand(Op: MI.getOperand(i: 2));
1115 OutInst.setLoc(MI.getLoc());
1116 return true;
1117 } // if
1118 break;
1119 } // case LD_RV32
1120 case RISCV::LH: {
1121 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
1122 MI.getOperand(i: 0).isReg() &&
1123 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1124 MI.getOperand(i: 1).isReg() &&
1125 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1126 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 22 /* uimm2_lsb0 */) &&
1127 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 23 /* uimm2_lsb0_optional */)) {
1128 // c.lh $rd, ${imm}(${rs1})
1129 OutInst.setOpcode(RISCV::C_LH);
1130 // Operand: rd
1131 OutInst.addOperand(Op: MI.getOperand(i: 0));
1132 // Operand: rs1
1133 OutInst.addOperand(Op: MI.getOperand(i: 1));
1134 // Operand: imm
1135 OutInst.addOperand(Op: MI.getOperand(i: 2));
1136 OutInst.setLoc(MI.getLoc());
1137 return true;
1138 } // if
1139 break;
1140 } // case LH
1141 case RISCV::LHU: {
1142 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
1143 MI.getOperand(i: 0).isReg() &&
1144 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1145 MI.getOperand(i: 1).isReg() &&
1146 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1147 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 22 /* uimm2_lsb0 */) &&
1148 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 23 /* uimm2_lsb0_optional */)) {
1149 // c.lhu $rd, ${imm}(${rs1})
1150 OutInst.setOpcode(RISCV::C_LHU);
1151 // Operand: rd
1152 OutInst.addOperand(Op: MI.getOperand(i: 0));
1153 // Operand: rs1
1154 OutInst.addOperand(Op: MI.getOperand(i: 1));
1155 // Operand: imm
1156 OutInst.addOperand(Op: MI.getOperand(i: 2));
1157 OutInst.setLoc(MI.getLoc());
1158 return true;
1159 } // if
1160 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
1161 MI.getOperand(i: 0).isReg() &&
1162 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1163 MI.getOperand(i: 1).isReg() &&
1164 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1165 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 24 /* uimm6_lsb0 */) &&
1166 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 25 /* uimm6_lsb0_optional */)) {
1167 // qk.c.lhu $rd, ${imm}(${rs1})
1168 OutInst.setOpcode(RISCV::QK_C_LHU);
1169 // Operand: rd
1170 OutInst.addOperand(Op: MI.getOperand(i: 0));
1171 // Operand: rs1
1172 OutInst.addOperand(Op: MI.getOperand(i: 1));
1173 // Operand: imm
1174 OutInst.addOperand(Op: MI.getOperand(i: 2));
1175 OutInst.setLoc(MI.getLoc());
1176 return true;
1177 } // if
1178 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
1179 MI.getOperand(i: 0).isReg() &&
1180 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1181 MI.getOperand(i: 1).isReg() &&
1182 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1183 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 26 /* uimm5_lsb0 */) &&
1184 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 27 /* uimm5_lsb0_optional */)) {
1185 // qk.c.lhusp $rd_rs2, ${imm}(${rs1})
1186 OutInst.setOpcode(RISCV::QK_C_LHUSP);
1187 // Operand: rd_rs2
1188 OutInst.addOperand(Op: MI.getOperand(i: 0));
1189 // Operand: rs1
1190 OutInst.addOperand(Op: MI.getOperand(i: 1));
1191 // Operand: imm
1192 OutInst.addOperand(Op: MI.getOperand(i: 2));
1193 OutInst.setLoc(MI.getLoc());
1194 return true;
1195 } // if
1196 break;
1197 } // case LHU
1198 case RISCV::LH_INX: {
1199 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
1200 MI.getOperand(i: 0).isReg() &&
1201 getRISCVMCRegisterClass(RC: RISCV::GPRF16CRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1202 MI.getOperand(i: 1).isReg() &&
1203 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1204 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 22 /* uimm2_lsb0 */) &&
1205 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 23 /* uimm2_lsb0_optional */)) {
1206 // c.lh $rd, ${imm}(${rs1})
1207 OutInst.setOpcode(RISCV::C_LH_INX);
1208 // Operand: rd
1209 OutInst.addOperand(Op: MI.getOperand(i: 0));
1210 // Operand: rs1
1211 OutInst.addOperand(Op: MI.getOperand(i: 1));
1212 // Operand: imm
1213 OutInst.addOperand(Op: MI.getOperand(i: 2));
1214 OutInst.setLoc(MI.getLoc());
1215 return true;
1216 } // if
1217 break;
1218 } // case LH_INX
1219 case RISCV::LUI: {
1220 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1221 MI.getOperand(i: 0).isReg() &&
1222 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0X2RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1223 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 28 /* c_lui_imm */)) {
1224 // c.lui $rd, $imm
1225 OutInst.setOpcode(RISCV::C_LUI);
1226 // Operand: rd
1227 OutInst.addOperand(Op: MI.getOperand(i: 0));
1228 // Operand: imm
1229 OutInst.addOperand(Op: MI.getOperand(i: 1));
1230 OutInst.setLoc(MI.getLoc());
1231 return true;
1232 } // if
1233 break;
1234 } // case LUI
1235 case RISCV::LW: {
1236 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1237 MI.getOperand(i: 0).isReg() &&
1238 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1239 MI.getOperand(i: 1).isReg() &&
1240 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1241 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 11 /* uimm7_lsb00 */) &&
1242 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 12 /* uimm7_lsb00_optional */)) {
1243 // c.lw $rd, ${imm}(${rs1})
1244 OutInst.setOpcode(RISCV::C_LW);
1245 // Operand: rd
1246 OutInst.addOperand(Op: MI.getOperand(i: 0));
1247 // Operand: rs1
1248 OutInst.addOperand(Op: MI.getOperand(i: 1));
1249 // Operand: imm
1250 OutInst.addOperand(Op: MI.getOperand(i: 2));
1251 OutInst.setLoc(MI.getLoc());
1252 return true;
1253 } // if
1254 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1255 MI.getOperand(i: 0).isReg() &&
1256 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1257 MI.getOperand(i: 1).isReg() &&
1258 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1259 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 13 /* uimm8_lsb00 */) &&
1260 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 14 /* uimm8_lsb00_optional */)) {
1261 // c.lwsp $rd, ${imm}(${rs1})
1262 OutInst.setOpcode(RISCV::C_LWSP);
1263 // Operand: rd
1264 OutInst.addOperand(Op: MI.getOperand(i: 0));
1265 // Operand: rs1
1266 OutInst.addOperand(Op: MI.getOperand(i: 1));
1267 // Operand: imm
1268 OutInst.addOperand(Op: MI.getOperand(i: 2));
1269 OutInst.setLoc(MI.getLoc());
1270 return true;
1271 } // if
1272 break;
1273 } // case LW
1274 case RISCV::LW_INX: {
1275 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1276 MI.getOperand(i: 0).isReg() &&
1277 getRISCVMCRegisterClass(RC: RISCV::GPRF32CRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1278 MI.getOperand(i: 1).isReg() &&
1279 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1280 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 11 /* uimm7_lsb00 */) &&
1281 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 12 /* uimm7_lsb00_optional */)) {
1282 // c.lw $rd, ${imm}(${rs1})
1283 OutInst.setOpcode(RISCV::C_LW_INX);
1284 // Operand: rd
1285 OutInst.addOperand(Op: MI.getOperand(i: 0));
1286 // Operand: rs1
1287 OutInst.addOperand(Op: MI.getOperand(i: 1));
1288 // Operand: imm
1289 OutInst.addOperand(Op: MI.getOperand(i: 2));
1290 OutInst.setLoc(MI.getLoc());
1291 return true;
1292 } // if
1293 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1294 MI.getOperand(i: 0).isReg() &&
1295 getRISCVMCRegisterClass(RC: RISCV::GPRF32NoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1296 MI.getOperand(i: 1).isReg() &&
1297 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1298 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 13 /* uimm8_lsb00 */) &&
1299 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 14 /* uimm8_lsb00_optional */)) {
1300 // c.lwsp $rd, ${imm}(${rs1})
1301 OutInst.setOpcode(RISCV::C_LWSP_INX);
1302 // Operand: rd
1303 OutInst.addOperand(Op: MI.getOperand(i: 0));
1304 // Operand: rs1
1305 OutInst.addOperand(Op: MI.getOperand(i: 1));
1306 // Operand: imm
1307 OutInst.addOperand(Op: MI.getOperand(i: 2));
1308 OutInst.setLoc(MI.getLoc());
1309 return true;
1310 } // if
1311 break;
1312 } // case LW_INX
1313 case RISCV::MUL: {
1314 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
1315 STI.getFeatureBits()[RISCV::FeatureStdExtZmmul] &&
1316 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
1317 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
1318 MI.getOperand(i: 1).isReg() &&
1319 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1320 MI.getOperand(i: 2).isReg() &&
1321 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
1322 // c.mul $rd, $rs2
1323 OutInst.setOpcode(RISCV::C_MUL);
1324 // Operand: rd_wb
1325 OutInst.addOperand(Op: MI.getOperand(i: 1));
1326 // Operand: rd
1327 OutInst.addOperand(Op: MI.getOperand(i: 1));
1328 // Operand: rs2
1329 OutInst.addOperand(Op: MI.getOperand(i: 2));
1330 OutInst.setLoc(MI.getLoc());
1331 return true;
1332 } // if
1333 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
1334 STI.getFeatureBits()[RISCV::FeatureStdExtZmmul] &&
1335 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
1336 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
1337 MI.getOperand(i: 2).isReg() &&
1338 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg()) &&
1339 MI.getOperand(i: 1).isReg() &&
1340 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
1341 // c.mul $rd, $rs2
1342 OutInst.setOpcode(RISCV::C_MUL);
1343 // Operand: rd_wb
1344 OutInst.addOperand(Op: MI.getOperand(i: 2));
1345 // Operand: rd
1346 OutInst.addOperand(Op: MI.getOperand(i: 2));
1347 // Operand: rs2
1348 OutInst.addOperand(Op: MI.getOperand(i: 1));
1349 OutInst.setLoc(MI.getLoc());
1350 return true;
1351 } // if
1352 break;
1353 } // case MUL
1354 case RISCV::OR: {
1355 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1356 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
1357 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
1358 MI.getOperand(i: 1).isReg() &&
1359 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1360 MI.getOperand(i: 2).isReg() &&
1361 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
1362 // c.or $rd, $rs2
1363 OutInst.setOpcode(RISCV::C_OR);
1364 // Operand: rd_wb
1365 OutInst.addOperand(Op: MI.getOperand(i: 1));
1366 // Operand: rd
1367 OutInst.addOperand(Op: MI.getOperand(i: 1));
1368 // Operand: rs2
1369 OutInst.addOperand(Op: MI.getOperand(i: 2));
1370 OutInst.setLoc(MI.getLoc());
1371 return true;
1372 } // if
1373 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1374 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
1375 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
1376 MI.getOperand(i: 2).isReg() &&
1377 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg()) &&
1378 MI.getOperand(i: 1).isReg() &&
1379 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
1380 // c.or $rd, $rs2
1381 OutInst.setOpcode(RISCV::C_OR);
1382 // Operand: rd_wb
1383 OutInst.addOperand(Op: MI.getOperand(i: 2));
1384 // Operand: rd
1385 OutInst.addOperand(Op: MI.getOperand(i: 2));
1386 // Operand: rs2
1387 OutInst.addOperand(Op: MI.getOperand(i: 1));
1388 OutInst.setLoc(MI.getLoc());
1389 return true;
1390 } // if
1391 break;
1392 } // case OR
1393 case RISCV::QC_EXTU: {
1394 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1395 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
1396 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
1397 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
1398 MI.getOperand(i: 3).isImm() &&
1399 (MI.getOperand(i: 3).getImm() == 0) &&
1400 MI.getOperand(i: 1).isReg() &&
1401 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1402 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 29 /* uimm5ge6_plus1 */)) {
1403 // qc.c.extu $rd, $width
1404 OutInst.setOpcode(RISCV::QC_C_EXTU);
1405 // Operand: rd_wb
1406 OutInst.addOperand(Op: MI.getOperand(i: 1));
1407 // Operand: rd
1408 OutInst.addOperand(Op: MI.getOperand(i: 1));
1409 // Operand: width
1410 OutInst.addOperand(Op: MI.getOperand(i: 2));
1411 OutInst.setLoc(MI.getLoc());
1412 return true;
1413 } // if
1414 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1415 STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
1416 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
1417 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
1418 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
1419 MI.getOperand(i: 2).isImm() &&
1420 (MI.getOperand(i: 2).getImm() == 1) &&
1421 MI.getOperand(i: 1).isReg() &&
1422 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1423 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 3), STI, PredicateIndex: 6 /* uimmlog2xlennonzero */)) {
1424 // qc.c.bexti $rs1, $shamt
1425 OutInst.setOpcode(RISCV::QC_C_BEXTI);
1426 // Operand: rd
1427 OutInst.addOperand(Op: MI.getOperand(i: 1));
1428 // Operand: rs1
1429 OutInst.addOperand(Op: MI.getOperand(i: 1));
1430 // Operand: shamt
1431 OutInst.addOperand(Op: MI.getOperand(i: 3));
1432 OutInst.setLoc(MI.getLoc());
1433 return true;
1434 } // if
1435 break;
1436 } // case QC_EXTU
1437 case RISCV::QC_E_ADDAI: {
1438 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1439 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1440 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
1441 MI.getOperand(i: 0).isReg() &&
1442 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1443 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm6nonzero */) &&
1444 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 3 /* simm6 */)) {
1445 // c.addi $rd, $imm
1446 OutInst.setOpcode(RISCV::C_ADDI);
1447 // Operand: rd_wb
1448 OutInst.addOperand(Op: MI.getOperand(i: 0));
1449 // Operand: rd
1450 OutInst.addOperand(Op: MI.getOperand(i: 0));
1451 // Operand: imm
1452 OutInst.addOperand(Op: MI.getOperand(i: 2));
1453 OutInst.setLoc(MI.getLoc());
1454 return true;
1455 } // if
1456 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1457 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1458 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
1459 MI.getOperand(i: 0).isReg() &&
1460 (MI.getOperand(i: 0).getReg() == RISCV::X2) &&
1461 MI.getOperand(i: 1).isReg() &&
1462 (MI.getOperand(i: 1).getReg() == RISCV::X2) &&
1463 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 4 /* simm10_lsb0000nonzero */)) {
1464 // c.addi16sp $rd, $imm
1465 OutInst.setOpcode(RISCV::C_ADDI16SP);
1466 // Operand: rd_wb
1467 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X2));
1468 // Operand: rd
1469 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X2));
1470 // Operand: imm
1471 OutInst.addOperand(Op: MI.getOperand(i: 2));
1472 OutInst.setLoc(MI.getLoc());
1473 return true;
1474 } // if
1475 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1476 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
1477 MI.getOperand(i: 0).isReg() &&
1478 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1479 MI.getOperand(i: 0).isReg() &&
1480 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1481 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 30 /* simm12_lo */)) {
1482 // addi $rd, $rs1, $imm12
1483 OutInst.setOpcode(RISCV::ADDI);
1484 // Operand: rd
1485 OutInst.addOperand(Op: MI.getOperand(i: 0));
1486 // Operand: rs1
1487 OutInst.addOperand(Op: MI.getOperand(i: 0));
1488 // Operand: imm12
1489 OutInst.addOperand(Op: MI.getOperand(i: 2));
1490 OutInst.setLoc(MI.getLoc());
1491 return true;
1492 } // if
1493 break;
1494 } // case QC_E_ADDAI
1495 case RISCV::QC_E_ADDI: {
1496 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1497 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1498 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
1499 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
1500 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
1501 MI.getOperand(i: 1).isReg() &&
1502 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1503 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm6nonzero */) &&
1504 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 3 /* simm6 */)) {
1505 // c.addi $rd, $imm
1506 OutInst.setOpcode(RISCV::C_ADDI);
1507 // Operand: rd_wb
1508 OutInst.addOperand(Op: MI.getOperand(i: 1));
1509 // Operand: rd
1510 OutInst.addOperand(Op: MI.getOperand(i: 1));
1511 // Operand: imm
1512 OutInst.addOperand(Op: MI.getOperand(i: 2));
1513 OutInst.setLoc(MI.getLoc());
1514 return true;
1515 } // if
1516 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1517 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1518 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
1519 MI.getOperand(i: 2).isImm() &&
1520 (MI.getOperand(i: 2).getImm() == 0) &&
1521 MI.getOperand(i: 0).isReg() &&
1522 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1523 MI.getOperand(i: 1).isReg() &&
1524 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
1525 // c.mv $rs1, $rs2
1526 OutInst.setOpcode(RISCV::C_MV);
1527 // Operand: rs1
1528 OutInst.addOperand(Op: MI.getOperand(i: 0));
1529 // Operand: rs2
1530 OutInst.addOperand(Op: MI.getOperand(i: 1));
1531 OutInst.setLoc(MI.getLoc());
1532 return true;
1533 } // if
1534 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1535 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1536 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
1537 MI.getOperand(i: 0).isReg() &&
1538 (MI.getOperand(i: 0).getReg() == RISCV::X2) &&
1539 MI.getOperand(i: 1).isReg() &&
1540 (MI.getOperand(i: 1).getReg() == RISCV::X2) &&
1541 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 4 /* simm10_lsb0000nonzero */)) {
1542 // c.addi16sp $rd, $imm
1543 OutInst.setOpcode(RISCV::C_ADDI16SP);
1544 // Operand: rd_wb
1545 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X2));
1546 // Operand: rd
1547 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X2));
1548 // Operand: imm
1549 OutInst.addOperand(Op: MI.getOperand(i: 2));
1550 OutInst.setLoc(MI.getLoc());
1551 return true;
1552 } // if
1553 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1554 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
1555 MI.getOperand(i: 0).isReg() &&
1556 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1557 MI.getOperand(i: 1).isReg() &&
1558 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1559 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 30 /* simm12_lo */)) {
1560 // addi $rd, $rs1, $imm12
1561 OutInst.setOpcode(RISCV::ADDI);
1562 // Operand: rd
1563 OutInst.addOperand(Op: MI.getOperand(i: 0));
1564 // Operand: rs1
1565 OutInst.addOperand(Op: MI.getOperand(i: 1));
1566 // Operand: imm12
1567 OutInst.addOperand(Op: MI.getOperand(i: 2));
1568 OutInst.setLoc(MI.getLoc());
1569 return true;
1570 } // if
1571 break;
1572 } // case QC_E_ADDI
1573 case RISCV::QC_E_ANDAI: {
1574 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1575 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1576 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
1577 MI.getOperand(i: 0).isReg() &&
1578 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1579 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 3 /* simm6 */)) {
1580 // c.andi $rs1, $imm
1581 OutInst.setOpcode(RISCV::C_ANDI);
1582 // Operand: rd
1583 OutInst.addOperand(Op: MI.getOperand(i: 0));
1584 // Operand: rs1
1585 OutInst.addOperand(Op: MI.getOperand(i: 0));
1586 // Operand: imm
1587 OutInst.addOperand(Op: MI.getOperand(i: 2));
1588 OutInst.setLoc(MI.getLoc());
1589 return true;
1590 } // if
1591 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1592 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
1593 MI.getOperand(i: 0).isReg() &&
1594 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1595 MI.getOperand(i: 0).isReg() &&
1596 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1597 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 30 /* simm12_lo */)) {
1598 // andi $rd, $rs1, $imm12
1599 OutInst.setOpcode(RISCV::ANDI);
1600 // Operand: rd
1601 OutInst.addOperand(Op: MI.getOperand(i: 0));
1602 // Operand: rs1
1603 OutInst.addOperand(Op: MI.getOperand(i: 0));
1604 // Operand: imm12
1605 OutInst.addOperand(Op: MI.getOperand(i: 2));
1606 OutInst.setLoc(MI.getLoc());
1607 return true;
1608 } // if
1609 break;
1610 } // case QC_E_ANDAI
1611 case RISCV::QC_E_ANDI: {
1612 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1613 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1614 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
1615 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
1616 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
1617 MI.getOperand(i: 1).isReg() &&
1618 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1619 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 3 /* simm6 */)) {
1620 // c.andi $rs1, $imm
1621 OutInst.setOpcode(RISCV::C_ANDI);
1622 // Operand: rd
1623 OutInst.addOperand(Op: MI.getOperand(i: 1));
1624 // Operand: rs1
1625 OutInst.addOperand(Op: MI.getOperand(i: 1));
1626 // Operand: imm
1627 OutInst.addOperand(Op: MI.getOperand(i: 2));
1628 OutInst.setLoc(MI.getLoc());
1629 return true;
1630 } // if
1631 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1632 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
1633 MI.getOperand(i: 0).isReg() &&
1634 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1635 MI.getOperand(i: 1).isReg() &&
1636 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1637 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 30 /* simm12_lo */)) {
1638 // andi $rd, $rs1, $imm12
1639 OutInst.setOpcode(RISCV::ANDI);
1640 // Operand: rd
1641 OutInst.addOperand(Op: MI.getOperand(i: 0));
1642 // Operand: rs1
1643 OutInst.addOperand(Op: MI.getOperand(i: 1));
1644 // Operand: imm12
1645 OutInst.addOperand(Op: MI.getOperand(i: 2));
1646 OutInst.setLoc(MI.getLoc());
1647 return true;
1648 } // if
1649 break;
1650 } // case QC_E_ANDI
1651 case RISCV::QC_E_BEQI: {
1652 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1653 STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
1654 MI.getOperand(i: 0).isReg() &&
1655 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1656 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 31 /* simm5nonzero */) &&
1657 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 32 /* bare_simm13_lsb0 */)) {
1658 // qc.beqi $rs1, $rs2, $imm12
1659 OutInst.setOpcode(RISCV::QC_BEQI);
1660 // Operand: rs1
1661 OutInst.addOperand(Op: MI.getOperand(i: 0));
1662 // Operand: rs2
1663 OutInst.addOperand(Op: MI.getOperand(i: 1));
1664 // Operand: imm12
1665 OutInst.addOperand(Op: MI.getOperand(i: 2));
1666 OutInst.setLoc(MI.getLoc());
1667 return true;
1668 } // if
1669 break;
1670 } // case QC_E_BEQI
1671 case RISCV::QC_E_BGEI: {
1672 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1673 STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
1674 MI.getOperand(i: 0).isReg() &&
1675 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1676 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 31 /* simm5nonzero */) &&
1677 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 32 /* bare_simm13_lsb0 */)) {
1678 // qc.bgei $rs1, $rs2, $imm12
1679 OutInst.setOpcode(RISCV::QC_BGEI);
1680 // Operand: rs1
1681 OutInst.addOperand(Op: MI.getOperand(i: 0));
1682 // Operand: rs2
1683 OutInst.addOperand(Op: MI.getOperand(i: 1));
1684 // Operand: imm12
1685 OutInst.addOperand(Op: MI.getOperand(i: 2));
1686 OutInst.setLoc(MI.getLoc());
1687 return true;
1688 } // if
1689 break;
1690 } // case QC_E_BGEI
1691 case RISCV::QC_E_BGEUI: {
1692 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1693 STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
1694 MI.getOperand(i: 0).isReg() &&
1695 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1696 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 33 /* uimm5nonzero */) &&
1697 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 32 /* bare_simm13_lsb0 */)) {
1698 // qc.bgeui $rs1, $rs2, $imm12
1699 OutInst.setOpcode(RISCV::QC_BGEUI);
1700 // Operand: rs1
1701 OutInst.addOperand(Op: MI.getOperand(i: 0));
1702 // Operand: rs2
1703 OutInst.addOperand(Op: MI.getOperand(i: 1));
1704 // Operand: imm12
1705 OutInst.addOperand(Op: MI.getOperand(i: 2));
1706 OutInst.setLoc(MI.getLoc());
1707 return true;
1708 } // if
1709 break;
1710 } // case QC_E_BGEUI
1711 case RISCV::QC_E_BLTI: {
1712 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1713 STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
1714 MI.getOperand(i: 0).isReg() &&
1715 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1716 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 31 /* simm5nonzero */) &&
1717 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 32 /* bare_simm13_lsb0 */)) {
1718 // qc.blti $rs1, $rs2, $imm12
1719 OutInst.setOpcode(RISCV::QC_BLTI);
1720 // Operand: rs1
1721 OutInst.addOperand(Op: MI.getOperand(i: 0));
1722 // Operand: rs2
1723 OutInst.addOperand(Op: MI.getOperand(i: 1));
1724 // Operand: imm12
1725 OutInst.addOperand(Op: MI.getOperand(i: 2));
1726 OutInst.setLoc(MI.getLoc());
1727 return true;
1728 } // if
1729 break;
1730 } // case QC_E_BLTI
1731 case RISCV::QC_E_BLTUI: {
1732 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1733 STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
1734 MI.getOperand(i: 0).isReg() &&
1735 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1736 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 33 /* uimm5nonzero */) &&
1737 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 32 /* bare_simm13_lsb0 */)) {
1738 // qc.bltui $rs1, $rs2, $imm12
1739 OutInst.setOpcode(RISCV::QC_BLTUI);
1740 // Operand: rs1
1741 OutInst.addOperand(Op: MI.getOperand(i: 0));
1742 // Operand: rs2
1743 OutInst.addOperand(Op: MI.getOperand(i: 1));
1744 // Operand: imm12
1745 OutInst.addOperand(Op: MI.getOperand(i: 2));
1746 OutInst.setLoc(MI.getLoc());
1747 return true;
1748 } // if
1749 break;
1750 } // case QC_E_BLTUI
1751 case RISCV::QC_E_BNEI: {
1752 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1753 STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
1754 MI.getOperand(i: 0).isReg() &&
1755 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1756 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 31 /* simm5nonzero */) &&
1757 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 32 /* bare_simm13_lsb0 */)) {
1758 // qc.bnei $rs1, $rs2, $imm12
1759 OutInst.setOpcode(RISCV::QC_BNEI);
1760 // Operand: rs1
1761 OutInst.addOperand(Op: MI.getOperand(i: 0));
1762 // Operand: rs2
1763 OutInst.addOperand(Op: MI.getOperand(i: 1));
1764 // Operand: imm12
1765 OutInst.addOperand(Op: MI.getOperand(i: 2));
1766 OutInst.setLoc(MI.getLoc());
1767 return true;
1768 } // if
1769 break;
1770 } // case QC_E_BNEI
1771 case RISCV::QC_E_J: {
1772 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1773 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1774 STI.getFeatureBits()[RISCV::FeatureVendorXqcilb] &&
1775 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 15 /* bare_simm12_lsb0 */)) {
1776 // c.j $offset
1777 OutInst.setOpcode(RISCV::C_J);
1778 // Operand: offset
1779 OutInst.addOperand(Op: MI.getOperand(i: 0));
1780 OutInst.setLoc(MI.getLoc());
1781 return true;
1782 } // if
1783 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1784 STI.getFeatureBits()[RISCV::FeatureVendorXqcilb] &&
1785 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 34 /* simm21_lsb0_jal */)) {
1786 // jal $rd, $imm20
1787 OutInst.setOpcode(RISCV::JAL);
1788 // Operand: rd
1789 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
1790 // Operand: imm20
1791 OutInst.addOperand(Op: MI.getOperand(i: 0));
1792 OutInst.setLoc(MI.getLoc());
1793 return true;
1794 } // if
1795 break;
1796 } // case QC_E_J
1797 case RISCV::QC_E_JAL: {
1798 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1799 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1800 STI.getFeatureBits()[RISCV::FeatureVendorXqcilb] &&
1801 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 15 /* bare_simm12_lsb0 */)) {
1802 // c.jal $offset
1803 OutInst.setOpcode(RISCV::C_JAL);
1804 // Operand: offset
1805 OutInst.addOperand(Op: MI.getOperand(i: 0));
1806 OutInst.setLoc(MI.getLoc());
1807 return true;
1808 } // if
1809 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1810 STI.getFeatureBits()[RISCV::FeatureVendorXqcilb] &&
1811 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 34 /* simm21_lsb0_jal */)) {
1812 // jal $rd, $imm20
1813 OutInst.setOpcode(RISCV::JAL);
1814 // Operand: rd
1815 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X1));
1816 // Operand: imm20
1817 OutInst.addOperand(Op: MI.getOperand(i: 0));
1818 OutInst.setLoc(MI.getLoc());
1819 return true;
1820 } // if
1821 break;
1822 } // case QC_E_JAL
1823 case RISCV::QC_E_LB: {
1824 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1825 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
1826 MI.getOperand(i: 0).isReg() &&
1827 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1828 MI.getOperand(i: 1).isReg() &&
1829 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1830 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 30 /* simm12_lo */) &&
1831 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 35 /* simm12_lo_optional */)) {
1832 // lb $rd, ${imm12}(${rs1})
1833 OutInst.setOpcode(RISCV::LB);
1834 // Operand: rd
1835 OutInst.addOperand(Op: MI.getOperand(i: 0));
1836 // Operand: rs1
1837 OutInst.addOperand(Op: MI.getOperand(i: 1));
1838 // Operand: imm12
1839 OutInst.addOperand(Op: MI.getOperand(i: 2));
1840 OutInst.setLoc(MI.getLoc());
1841 return true;
1842 } // if
1843 break;
1844 } // case QC_E_LB
1845 case RISCV::QC_E_LBU: {
1846 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1847 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
1848 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
1849 MI.getOperand(i: 0).isReg() &&
1850 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1851 MI.getOperand(i: 1).isReg() &&
1852 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1853 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 16 /* uimm2 */) &&
1854 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 17 /* uimm2_optional */)) {
1855 // c.lbu $rd, ${imm}(${rs1})
1856 OutInst.setOpcode(RISCV::C_LBU);
1857 // Operand: rd
1858 OutInst.addOperand(Op: MI.getOperand(i: 0));
1859 // Operand: rs1
1860 OutInst.addOperand(Op: MI.getOperand(i: 1));
1861 // Operand: imm
1862 OutInst.addOperand(Op: MI.getOperand(i: 2));
1863 OutInst.setLoc(MI.getLoc());
1864 return true;
1865 } // if
1866 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1867 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
1868 MI.getOperand(i: 0).isReg() &&
1869 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1870 MI.getOperand(i: 1).isReg() &&
1871 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1872 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 30 /* simm12_lo */) &&
1873 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 35 /* simm12_lo_optional */)) {
1874 // lbu $rd, ${imm12}(${rs1})
1875 OutInst.setOpcode(RISCV::LBU);
1876 // Operand: rd
1877 OutInst.addOperand(Op: MI.getOperand(i: 0));
1878 // Operand: rs1
1879 OutInst.addOperand(Op: MI.getOperand(i: 1));
1880 // Operand: imm12
1881 OutInst.addOperand(Op: MI.getOperand(i: 2));
1882 OutInst.setLoc(MI.getLoc());
1883 return true;
1884 } // if
1885 break;
1886 } // case QC_E_LBU
1887 case RISCV::QC_E_LH: {
1888 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1889 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
1890 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
1891 MI.getOperand(i: 0).isReg() &&
1892 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1893 MI.getOperand(i: 1).isReg() &&
1894 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1895 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 22 /* uimm2_lsb0 */) &&
1896 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 23 /* uimm2_lsb0_optional */)) {
1897 // c.lh $rd, ${imm}(${rs1})
1898 OutInst.setOpcode(RISCV::C_LH);
1899 // Operand: rd
1900 OutInst.addOperand(Op: MI.getOperand(i: 0));
1901 // Operand: rs1
1902 OutInst.addOperand(Op: MI.getOperand(i: 1));
1903 // Operand: imm
1904 OutInst.addOperand(Op: MI.getOperand(i: 2));
1905 OutInst.setLoc(MI.getLoc());
1906 return true;
1907 } // if
1908 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1909 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
1910 MI.getOperand(i: 0).isReg() &&
1911 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1912 MI.getOperand(i: 1).isReg() &&
1913 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1914 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 30 /* simm12_lo */) &&
1915 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 35 /* simm12_lo_optional */)) {
1916 // lh $rd, ${imm12}(${rs1})
1917 OutInst.setOpcode(RISCV::LH);
1918 // Operand: rd
1919 OutInst.addOperand(Op: MI.getOperand(i: 0));
1920 // Operand: rs1
1921 OutInst.addOperand(Op: MI.getOperand(i: 1));
1922 // Operand: imm12
1923 OutInst.addOperand(Op: MI.getOperand(i: 2));
1924 OutInst.setLoc(MI.getLoc());
1925 return true;
1926 } // if
1927 break;
1928 } // case QC_E_LH
1929 case RISCV::QC_E_LHU: {
1930 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1931 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
1932 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
1933 MI.getOperand(i: 0).isReg() &&
1934 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1935 MI.getOperand(i: 1).isReg() &&
1936 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1937 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 22 /* uimm2_lsb0 */) &&
1938 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 23 /* uimm2_lsb0_optional */)) {
1939 // c.lhu $rd, ${imm}(${rs1})
1940 OutInst.setOpcode(RISCV::C_LHU);
1941 // Operand: rd
1942 OutInst.addOperand(Op: MI.getOperand(i: 0));
1943 // Operand: rs1
1944 OutInst.addOperand(Op: MI.getOperand(i: 1));
1945 // Operand: imm
1946 OutInst.addOperand(Op: MI.getOperand(i: 2));
1947 OutInst.setLoc(MI.getLoc());
1948 return true;
1949 } // if
1950 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1951 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
1952 MI.getOperand(i: 0).isReg() &&
1953 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1954 MI.getOperand(i: 1).isReg() &&
1955 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
1956 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 30 /* simm12_lo */) &&
1957 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 35 /* simm12_lo_optional */)) {
1958 // lhu $rd, ${imm12}(${rs1})
1959 OutInst.setOpcode(RISCV::LHU);
1960 // Operand: rd
1961 OutInst.addOperand(Op: MI.getOperand(i: 0));
1962 // Operand: rs1
1963 OutInst.addOperand(Op: MI.getOperand(i: 1));
1964 // Operand: imm12
1965 OutInst.addOperand(Op: MI.getOperand(i: 2));
1966 OutInst.setLoc(MI.getLoc());
1967 return true;
1968 } // if
1969 break;
1970 } // case QC_E_LHU
1971 case RISCV::QC_E_LI: {
1972 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1973 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
1974 STI.getFeatureBits()[RISCV::FeatureVendorXqcili] &&
1975 MI.getOperand(i: 0).isReg() &&
1976 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1977 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 3 /* simm6 */)) {
1978 // c.li $rd, $imm
1979 OutInst.setOpcode(RISCV::C_LI);
1980 // Operand: rd
1981 OutInst.addOperand(Op: MI.getOperand(i: 0));
1982 // Operand: imm
1983 OutInst.addOperand(Op: MI.getOperand(i: 1));
1984 OutInst.setLoc(MI.getLoc());
1985 return true;
1986 } // if
1987 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
1988 STI.getFeatureBits()[RISCV::FeatureVendorXqcili] &&
1989 MI.getOperand(i: 0).isReg() &&
1990 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
1991 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 36 /* simm20_li */)) {
1992 // qc.li $rd, $imm20
1993 OutInst.setOpcode(RISCV::QC_LI);
1994 // Operand: rd
1995 OutInst.addOperand(Op: MI.getOperand(i: 0));
1996 // Operand: imm20
1997 OutInst.addOperand(Op: MI.getOperand(i: 1));
1998 OutInst.setLoc(MI.getLoc());
1999 return true;
2000 } // if
2001 break;
2002 } // case QC_E_LI
2003 case RISCV::QC_E_LW: {
2004 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2005 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2006 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
2007 MI.getOperand(i: 0).isReg() &&
2008 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2009 MI.getOperand(i: 1).isReg() &&
2010 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2011 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 11 /* uimm7_lsb00 */) &&
2012 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 12 /* uimm7_lsb00_optional */)) {
2013 // c.lw $rd, ${imm}(${rs1})
2014 OutInst.setOpcode(RISCV::C_LW);
2015 // Operand: rd
2016 OutInst.addOperand(Op: MI.getOperand(i: 0));
2017 // Operand: rs1
2018 OutInst.addOperand(Op: MI.getOperand(i: 1));
2019 // Operand: imm
2020 OutInst.addOperand(Op: MI.getOperand(i: 2));
2021 OutInst.setLoc(MI.getLoc());
2022 return true;
2023 } // if
2024 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2025 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2026 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
2027 MI.getOperand(i: 0).isReg() &&
2028 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2029 MI.getOperand(i: 1).isReg() &&
2030 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2031 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 13 /* uimm8_lsb00 */) &&
2032 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 14 /* uimm8_lsb00_optional */)) {
2033 // c.lwsp $rd, ${imm}(${rs1})
2034 OutInst.setOpcode(RISCV::C_LWSP);
2035 // Operand: rd
2036 OutInst.addOperand(Op: MI.getOperand(i: 0));
2037 // Operand: rs1
2038 OutInst.addOperand(Op: MI.getOperand(i: 1));
2039 // Operand: imm
2040 OutInst.addOperand(Op: MI.getOperand(i: 2));
2041 OutInst.setLoc(MI.getLoc());
2042 return true;
2043 } // if
2044 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2045 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
2046 MI.getOperand(i: 0).isReg() &&
2047 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2048 MI.getOperand(i: 1).isReg() &&
2049 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2050 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 30 /* simm12_lo */) &&
2051 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 35 /* simm12_lo_optional */)) {
2052 // lw $rd, ${imm12}(${rs1})
2053 OutInst.setOpcode(RISCV::LW);
2054 // Operand: rd
2055 OutInst.addOperand(Op: MI.getOperand(i: 0));
2056 // Operand: rs1
2057 OutInst.addOperand(Op: MI.getOperand(i: 1));
2058 // Operand: imm12
2059 OutInst.addOperand(Op: MI.getOperand(i: 2));
2060 OutInst.setLoc(MI.getLoc());
2061 return true;
2062 } // if
2063 break;
2064 } // case QC_E_LW
2065 case RISCV::QC_E_ORAI: {
2066 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2067 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
2068 MI.getOperand(i: 0).isReg() &&
2069 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2070 MI.getOperand(i: 0).isReg() &&
2071 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2072 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 30 /* simm12_lo */)) {
2073 // ori $rd, $rs1, $imm12
2074 OutInst.setOpcode(RISCV::ORI);
2075 // Operand: rd
2076 OutInst.addOperand(Op: MI.getOperand(i: 0));
2077 // Operand: rs1
2078 OutInst.addOperand(Op: MI.getOperand(i: 0));
2079 // Operand: imm12
2080 OutInst.addOperand(Op: MI.getOperand(i: 2));
2081 OutInst.setLoc(MI.getLoc());
2082 return true;
2083 } // if
2084 break;
2085 } // case QC_E_ORAI
2086 case RISCV::QC_E_ORI: {
2087 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2088 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
2089 MI.getOperand(i: 0).isReg() &&
2090 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2091 MI.getOperand(i: 1).isReg() &&
2092 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2093 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 30 /* simm12_lo */)) {
2094 // ori $rd, $rs1, $imm12
2095 OutInst.setOpcode(RISCV::ORI);
2096 // Operand: rd
2097 OutInst.addOperand(Op: MI.getOperand(i: 0));
2098 // Operand: rs1
2099 OutInst.addOperand(Op: MI.getOperand(i: 1));
2100 // Operand: imm12
2101 OutInst.addOperand(Op: MI.getOperand(i: 2));
2102 OutInst.setLoc(MI.getLoc());
2103 return true;
2104 } // if
2105 break;
2106 } // case QC_E_ORI
2107 case RISCV::QC_E_SB: {
2108 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2109 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
2110 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
2111 MI.getOperand(i: 0).isReg() &&
2112 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2113 MI.getOperand(i: 1).isReg() &&
2114 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2115 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 16 /* uimm2 */) &&
2116 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 17 /* uimm2_optional */)) {
2117 // c.sb $rs2, ${imm}(${rs1})
2118 OutInst.setOpcode(RISCV::C_SB);
2119 // Operand: rs2
2120 OutInst.addOperand(Op: MI.getOperand(i: 0));
2121 // Operand: rs1
2122 OutInst.addOperand(Op: MI.getOperand(i: 1));
2123 // Operand: imm
2124 OutInst.addOperand(Op: MI.getOperand(i: 2));
2125 OutInst.setLoc(MI.getLoc());
2126 return true;
2127 } // if
2128 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2129 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
2130 MI.getOperand(i: 0).isReg() &&
2131 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2132 MI.getOperand(i: 1).isReg() &&
2133 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2134 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 30 /* simm12_lo */) &&
2135 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 35 /* simm12_lo_optional */)) {
2136 // sb $rs2, ${imm12}(${rs1})
2137 OutInst.setOpcode(RISCV::SB);
2138 // Operand: rs2
2139 OutInst.addOperand(Op: MI.getOperand(i: 0));
2140 // Operand: rs1
2141 OutInst.addOperand(Op: MI.getOperand(i: 1));
2142 // Operand: imm12
2143 OutInst.addOperand(Op: MI.getOperand(i: 2));
2144 OutInst.setLoc(MI.getLoc());
2145 return true;
2146 } // if
2147 break;
2148 } // case QC_E_SB
2149 case RISCV::QC_E_SH: {
2150 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2151 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
2152 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
2153 MI.getOperand(i: 0).isReg() &&
2154 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2155 MI.getOperand(i: 1).isReg() &&
2156 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2157 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 22 /* uimm2_lsb0 */) &&
2158 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 23 /* uimm2_lsb0_optional */)) {
2159 // c.sh $rs2, ${imm}(${rs1})
2160 OutInst.setOpcode(RISCV::C_SH);
2161 // Operand: rs2
2162 OutInst.addOperand(Op: MI.getOperand(i: 0));
2163 // Operand: rs1
2164 OutInst.addOperand(Op: MI.getOperand(i: 1));
2165 // Operand: imm
2166 OutInst.addOperand(Op: MI.getOperand(i: 2));
2167 OutInst.setLoc(MI.getLoc());
2168 return true;
2169 } // if
2170 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2171 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
2172 MI.getOperand(i: 0).isReg() &&
2173 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2174 MI.getOperand(i: 1).isReg() &&
2175 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2176 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 30 /* simm12_lo */) &&
2177 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 35 /* simm12_lo_optional */)) {
2178 // sh $rs2, ${imm12}(${rs1})
2179 OutInst.setOpcode(RISCV::SH);
2180 // Operand: rs2
2181 OutInst.addOperand(Op: MI.getOperand(i: 0));
2182 // Operand: rs1
2183 OutInst.addOperand(Op: MI.getOperand(i: 1));
2184 // Operand: imm12
2185 OutInst.addOperand(Op: MI.getOperand(i: 2));
2186 OutInst.setLoc(MI.getLoc());
2187 return true;
2188 } // if
2189 break;
2190 } // case QC_E_SH
2191 case RISCV::QC_E_SW: {
2192 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2193 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2194 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
2195 MI.getOperand(i: 0).isReg() &&
2196 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2197 MI.getOperand(i: 1).isReg() &&
2198 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2199 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 11 /* uimm7_lsb00 */) &&
2200 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 12 /* uimm7_lsb00_optional */)) {
2201 // c.sw $rs2, ${imm}(${rs1})
2202 OutInst.setOpcode(RISCV::C_SW);
2203 // Operand: rs2
2204 OutInst.addOperand(Op: MI.getOperand(i: 0));
2205 // Operand: rs1
2206 OutInst.addOperand(Op: MI.getOperand(i: 1));
2207 // Operand: imm
2208 OutInst.addOperand(Op: MI.getOperand(i: 2));
2209 OutInst.setLoc(MI.getLoc());
2210 return true;
2211 } // if
2212 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2213 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2214 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
2215 MI.getOperand(i: 0).isReg() &&
2216 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2217 MI.getOperand(i: 1).isReg() &&
2218 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2219 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 13 /* uimm8_lsb00 */) &&
2220 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 14 /* uimm8_lsb00_optional */)) {
2221 // c.swsp $rs2, ${imm}(${rs1})
2222 OutInst.setOpcode(RISCV::C_SWSP);
2223 // Operand: rs2
2224 OutInst.addOperand(Op: MI.getOperand(i: 0));
2225 // Operand: rs1
2226 OutInst.addOperand(Op: MI.getOperand(i: 1));
2227 // Operand: imm
2228 OutInst.addOperand(Op: MI.getOperand(i: 2));
2229 OutInst.setLoc(MI.getLoc());
2230 return true;
2231 } // if
2232 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2233 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
2234 MI.getOperand(i: 0).isReg() &&
2235 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2236 MI.getOperand(i: 1).isReg() &&
2237 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2238 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 30 /* simm12_lo */) &&
2239 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 35 /* simm12_lo_optional */)) {
2240 // sw $rs2, ${imm12}(${rs1})
2241 OutInst.setOpcode(RISCV::SW);
2242 // Operand: rs2
2243 OutInst.addOperand(Op: MI.getOperand(i: 0));
2244 // Operand: rs1
2245 OutInst.addOperand(Op: MI.getOperand(i: 1));
2246 // Operand: imm12
2247 OutInst.addOperand(Op: MI.getOperand(i: 2));
2248 OutInst.setLoc(MI.getLoc());
2249 return true;
2250 } // if
2251 break;
2252 } // case QC_E_SW
2253 case RISCV::QC_E_XORAI: {
2254 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2255 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
2256 MI.getOperand(i: 0).isReg() &&
2257 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2258 MI.getOperand(i: 0).isReg() &&
2259 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2260 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 30 /* simm12_lo */)) {
2261 // xori $rd, $rs1, $imm12
2262 OutInst.setOpcode(RISCV::XORI);
2263 // Operand: rd
2264 OutInst.addOperand(Op: MI.getOperand(i: 0));
2265 // Operand: rs1
2266 OutInst.addOperand(Op: MI.getOperand(i: 0));
2267 // Operand: imm12
2268 OutInst.addOperand(Op: MI.getOperand(i: 2));
2269 OutInst.setLoc(MI.getLoc());
2270 return true;
2271 } // if
2272 break;
2273 } // case QC_E_XORAI
2274 case RISCV::QC_E_XORI: {
2275 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2276 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
2277 MI.getOperand(i: 0).isReg() &&
2278 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2279 MI.getOperand(i: 1).isReg() &&
2280 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2281 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 30 /* simm12_lo */)) {
2282 // xori $rd, $rs1, $imm12
2283 OutInst.setOpcode(RISCV::XORI);
2284 // Operand: rd
2285 OutInst.addOperand(Op: MI.getOperand(i: 0));
2286 // Operand: rs1
2287 OutInst.addOperand(Op: MI.getOperand(i: 1));
2288 // Operand: imm12
2289 OutInst.addOperand(Op: MI.getOperand(i: 2));
2290 OutInst.setLoc(MI.getLoc());
2291 return true;
2292 } // if
2293 break;
2294 } // case QC_E_XORI
2295 case RISCV::QC_LI: {
2296 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2297 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2298 STI.getFeatureBits()[RISCV::FeatureVendorXqcili] &&
2299 MI.getOperand(i: 0).isReg() &&
2300 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2301 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 3 /* simm6 */)) {
2302 // c.li $rd, $imm
2303 OutInst.setOpcode(RISCV::C_LI);
2304 // Operand: rd
2305 OutInst.addOperand(Op: MI.getOperand(i: 0));
2306 // Operand: imm
2307 OutInst.addOperand(Op: MI.getOperand(i: 1));
2308 OutInst.setLoc(MI.getLoc());
2309 return true;
2310 } // if
2311 break;
2312 } // case QC_LI
2313 case RISCV::QC_MULIADD: {
2314 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2315 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
2316 MI.getOperand(i: 0).isReg() &&
2317 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2318 MI.getOperand(i: 2).isReg() &&
2319 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg()) &&
2320 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 3), STI, PredicateIndex: 18 /* uimm5 */)) {
2321 // qc.c.muliadd $rd, $rs1, $uimm
2322 OutInst.setOpcode(RISCV::QC_C_MULIADD);
2323 // Operand: rd_wb
2324 OutInst.addOperand(Op: MI.getOperand(i: 0));
2325 // Operand: rd
2326 OutInst.addOperand(Op: MI.getOperand(i: 0));
2327 // Operand: rs1
2328 OutInst.addOperand(Op: MI.getOperand(i: 2));
2329 // Operand: uimm
2330 OutInst.addOperand(Op: MI.getOperand(i: 3));
2331 OutInst.setLoc(MI.getLoc());
2332 return true;
2333 } // if
2334 break;
2335 } // case QC_MULIADD
2336 case RISCV::QC_MVEQI: {
2337 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2338 STI.getFeatureBits()[RISCV::FeatureVendorXqcicm] &&
2339 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
2340 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
2341 MI.getOperand(i: 3).isImm() &&
2342 (MI.getOperand(i: 3).getImm() == 0) &&
2343 MI.getOperand(i: 2).isReg() &&
2344 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg()) &&
2345 MI.getOperand(i: 4).isReg() &&
2346 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 4).getReg())) {
2347 // qc.c.mveqz $rd, $rs1
2348 OutInst.setOpcode(RISCV::QC_C_MVEQZ);
2349 // Operand: rd_wb
2350 OutInst.addOperand(Op: MI.getOperand(i: 2));
2351 // Operand: rd
2352 OutInst.addOperand(Op: MI.getOperand(i: 2));
2353 // Operand: rs1
2354 OutInst.addOperand(Op: MI.getOperand(i: 4));
2355 OutInst.setLoc(MI.getLoc());
2356 return true;
2357 } // if
2358 break;
2359 } // case QC_MVEQI
2360 case RISCV::QC_MVLTUI: {
2361 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2362 STI.getFeatureBits()[RISCV::FeatureVendorXqcicm] &&
2363 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
2364 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
2365 MI.getOperand(i: 3).isImm() &&
2366 (MI.getOperand(i: 3).getImm() == 1) &&
2367 MI.getOperand(i: 2).isReg() &&
2368 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg()) &&
2369 MI.getOperand(i: 4).isReg() &&
2370 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 4).getReg())) {
2371 // qc.c.mveqz $rd, $rs1
2372 OutInst.setOpcode(RISCV::QC_C_MVEQZ);
2373 // Operand: rd_wb
2374 OutInst.addOperand(Op: MI.getOperand(i: 2));
2375 // Operand: rd
2376 OutInst.addOperand(Op: MI.getOperand(i: 2));
2377 // Operand: rs1
2378 OutInst.addOperand(Op: MI.getOperand(i: 4));
2379 OutInst.setLoc(MI.getLoc());
2380 return true;
2381 } // if
2382 break;
2383 } // case QC_MVLTUI
2384 case RISCV::QC_SHLADD: {
2385 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2386 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
2387 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
2388 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
2389 MI.getOperand(i: 3).isImm() &&
2390 (MI.getOperand(i: 3).getImm() == 4) &&
2391 MI.getOperand(i: 2).isReg() &&
2392 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg()) &&
2393 MI.getOperand(i: 1).isReg() &&
2394 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2395 RISCVValidateMCOperandForCompress(MCOp: MCOperand::createImm(Val: 16), STI, PredicateIndex: 18 /* uimm5 */)) {
2396 // qc.c.muliadd $rd, $rs1, $uimm
2397 OutInst.setOpcode(RISCV::QC_C_MULIADD);
2398 // Operand: rd_wb
2399 OutInst.addOperand(Op: MI.getOperand(i: 2));
2400 // Operand: rd
2401 OutInst.addOperand(Op: MI.getOperand(i: 2));
2402 // Operand: rs1
2403 OutInst.addOperand(Op: MI.getOperand(i: 1));
2404 // Operand: uimm
2405 OutInst.addOperand(Op: MCOperand::createImm(Val: 16));
2406 OutInst.setLoc(MI.getLoc());
2407 return true;
2408 } // if
2409 break;
2410 } // case QC_SHLADD
2411 case RISCV::QC_SYNC: {
2412 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2413 STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
2414 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 37 /* uimm5slist */)) {
2415 // qc.c.sync $slist
2416 OutInst.setOpcode(RISCV::QC_C_SYNC);
2417 // Operand: slist
2418 OutInst.addOperand(Op: MI.getOperand(i: 0));
2419 OutInst.setLoc(MI.getLoc());
2420 return true;
2421 } // if
2422 break;
2423 } // case QC_SYNC
2424 case RISCV::QC_SYNCR: {
2425 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2426 STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
2427 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 37 /* uimm5slist */)) {
2428 // qc.c.syncr $slist
2429 OutInst.setOpcode(RISCV::QC_C_SYNCR);
2430 // Operand: slist
2431 OutInst.addOperand(Op: MI.getOperand(i: 0));
2432 OutInst.setLoc(MI.getLoc());
2433 return true;
2434 } // if
2435 break;
2436 } // case QC_SYNCR
2437 case RISCV::QC_SYNCWF: {
2438 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2439 STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
2440 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 37 /* uimm5slist */)) {
2441 // qc.c.syncwf $slist
2442 OutInst.setOpcode(RISCV::QC_C_SYNCWF);
2443 // Operand: slist
2444 OutInst.addOperand(Op: MI.getOperand(i: 0));
2445 OutInst.setLoc(MI.getLoc());
2446 return true;
2447 } // if
2448 break;
2449 } // case QC_SYNCWF
2450 case RISCV::QC_SYNCWL: {
2451 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2452 STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
2453 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 37 /* uimm5slist */)) {
2454 // qc.c.syncwl $slist
2455 OutInst.setOpcode(RISCV::QC_C_SYNCWL);
2456 // Operand: slist
2457 OutInst.addOperand(Op: MI.getOperand(i: 0));
2458 OutInst.setLoc(MI.getLoc());
2459 return true;
2460 } // if
2461 break;
2462 } // case QC_SYNCWL
2463 case RISCV::SB: {
2464 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
2465 MI.getOperand(i: 0).isReg() &&
2466 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2467 MI.getOperand(i: 1).isReg() &&
2468 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2469 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 16 /* uimm2 */) &&
2470 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 17 /* uimm2_optional */)) {
2471 // c.sb $rs2, ${imm}(${rs1})
2472 OutInst.setOpcode(RISCV::C_SB);
2473 // Operand: rs2
2474 OutInst.addOperand(Op: MI.getOperand(i: 0));
2475 // Operand: rs1
2476 OutInst.addOperand(Op: MI.getOperand(i: 1));
2477 // Operand: imm
2478 OutInst.addOperand(Op: MI.getOperand(i: 2));
2479 OutInst.setLoc(MI.getLoc());
2480 return true;
2481 } // if
2482 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
2483 MI.getOperand(i: 0).isReg() &&
2484 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2485 MI.getOperand(i: 1).isReg() &&
2486 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2487 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 18 /* uimm5 */) &&
2488 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 19 /* uimm5_optional */)) {
2489 // qk.c.sb $rs2, ${imm}(${rs1})
2490 OutInst.setOpcode(RISCV::QK_C_SB);
2491 // Operand: rs2
2492 OutInst.addOperand(Op: MI.getOperand(i: 0));
2493 // Operand: rs1
2494 OutInst.addOperand(Op: MI.getOperand(i: 1));
2495 // Operand: imm
2496 OutInst.addOperand(Op: MI.getOperand(i: 2));
2497 OutInst.setLoc(MI.getLoc());
2498 return true;
2499 } // if
2500 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
2501 MI.getOperand(i: 0).isReg() &&
2502 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2503 MI.getOperand(i: 1).isReg() &&
2504 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2505 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 20 /* uimm4 */) &&
2506 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 21 /* uimm4_optional */)) {
2507 // qk.c.sbsp $rd_rs2, ${imm}(${rs1})
2508 OutInst.setOpcode(RISCV::QK_C_SBSP);
2509 // Operand: rd_rs2
2510 OutInst.addOperand(Op: MI.getOperand(i: 0));
2511 // Operand: rs1
2512 OutInst.addOperand(Op: MI.getOperand(i: 1));
2513 // Operand: imm
2514 OutInst.addOperand(Op: MI.getOperand(i: 2));
2515 OutInst.setLoc(MI.getLoc());
2516 return true;
2517 } // if
2518 break;
2519 } // case SB
2520 case RISCV::SD: {
2521 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
2522 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2523 MI.getOperand(i: 0).isReg() &&
2524 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2525 MI.getOperand(i: 1).isReg() &&
2526 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2527 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 7 /* uimm8_lsb000 */) &&
2528 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000_optional */)) {
2529 // c.sd $rs2, ${imm}(${rs1})
2530 OutInst.setOpcode(RISCV::C_SD);
2531 // Operand: rs2
2532 OutInst.addOperand(Op: MI.getOperand(i: 0));
2533 // Operand: rs1
2534 OutInst.addOperand(Op: MI.getOperand(i: 1));
2535 // Operand: imm
2536 OutInst.addOperand(Op: MI.getOperand(i: 2));
2537 OutInst.setLoc(MI.getLoc());
2538 return true;
2539 } // if
2540 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
2541 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2542 MI.getOperand(i: 0).isReg() &&
2543 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2544 MI.getOperand(i: 1).isReg() &&
2545 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2546 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* uimm9_lsb000 */) &&
2547 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm9_lsb000_optional */)) {
2548 // c.sdsp $rs2, ${imm}(${rs1})
2549 OutInst.setOpcode(RISCV::C_SDSP);
2550 // Operand: rs2
2551 OutInst.addOperand(Op: MI.getOperand(i: 0));
2552 // Operand: rs1
2553 OutInst.addOperand(Op: MI.getOperand(i: 1));
2554 // Operand: imm
2555 OutInst.addOperand(Op: MI.getOperand(i: 2));
2556 OutInst.setLoc(MI.getLoc());
2557 return true;
2558 } // if
2559 break;
2560 } // case SD
2561 case RISCV::SD_RV32: {
2562 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2563 STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
2564 MI.getOperand(i: 0).isReg() &&
2565 getRISCVMCRegisterClass(RC: RISCV::GPRPairRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2566 MI.getOperand(i: 1).isReg() &&
2567 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2568 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* uimm9_lsb000 */) &&
2569 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm9_lsb000_optional */)) {
2570 // c.sdsp $rs2, ${imm}(${rs1})
2571 OutInst.setOpcode(RISCV::C_SDSP_RV32);
2572 // Operand: rs2
2573 OutInst.addOperand(Op: MI.getOperand(i: 0));
2574 // Operand: rs1
2575 OutInst.addOperand(Op: MI.getOperand(i: 1));
2576 // Operand: imm
2577 OutInst.addOperand(Op: MI.getOperand(i: 2));
2578 OutInst.setLoc(MI.getLoc());
2579 return true;
2580 } // if
2581 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2582 STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
2583 MI.getOperand(i: 0).isReg() &&
2584 getRISCVMCRegisterClass(RC: RISCV::GPRPairCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2585 MI.getOperand(i: 1).isReg() &&
2586 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2587 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 7 /* uimm8_lsb000 */) &&
2588 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000_optional */)) {
2589 // c.sd $rs2, ${imm}(${rs1})
2590 OutInst.setOpcode(RISCV::C_SD_RV32);
2591 // Operand: rs2
2592 OutInst.addOperand(Op: MI.getOperand(i: 0));
2593 // Operand: rs1
2594 OutInst.addOperand(Op: MI.getOperand(i: 1));
2595 // Operand: imm
2596 OutInst.addOperand(Op: MI.getOperand(i: 2));
2597 OutInst.setLoc(MI.getLoc());
2598 return true;
2599 } // if
2600 break;
2601 } // case SD_RV32
2602 case RISCV::SEXT_B: {
2603 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
2604 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
2605 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2606 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2607 MI.getOperand(i: 1).isReg() &&
2608 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
2609 // c.sext.b $rd
2610 OutInst.setOpcode(RISCV::C_SEXT_B);
2611 // Operand: rd_wb
2612 OutInst.addOperand(Op: MI.getOperand(i: 1));
2613 // Operand: rd
2614 OutInst.addOperand(Op: MI.getOperand(i: 1));
2615 OutInst.setLoc(MI.getLoc());
2616 return true;
2617 } // if
2618 break;
2619 } // case SEXT_B
2620 case RISCV::SEXT_H: {
2621 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
2622 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
2623 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2624 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2625 MI.getOperand(i: 1).isReg() &&
2626 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
2627 // c.sext.h $rd
2628 OutInst.setOpcode(RISCV::C_SEXT_H);
2629 // Operand: rd_wb
2630 OutInst.addOperand(Op: MI.getOperand(i: 1));
2631 // Operand: rd
2632 OutInst.addOperand(Op: MI.getOperand(i: 1));
2633 OutInst.setLoc(MI.getLoc());
2634 return true;
2635 } // if
2636 break;
2637 } // case SEXT_H
2638 case RISCV::SH: {
2639 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
2640 MI.getOperand(i: 0).isReg() &&
2641 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2642 MI.getOperand(i: 1).isReg() &&
2643 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2644 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 22 /* uimm2_lsb0 */) &&
2645 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 23 /* uimm2_lsb0_optional */)) {
2646 // c.sh $rs2, ${imm}(${rs1})
2647 OutInst.setOpcode(RISCV::C_SH);
2648 // Operand: rs2
2649 OutInst.addOperand(Op: MI.getOperand(i: 0));
2650 // Operand: rs1
2651 OutInst.addOperand(Op: MI.getOperand(i: 1));
2652 // Operand: imm
2653 OutInst.addOperand(Op: MI.getOperand(i: 2));
2654 OutInst.setLoc(MI.getLoc());
2655 return true;
2656 } // if
2657 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
2658 MI.getOperand(i: 0).isReg() &&
2659 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2660 MI.getOperand(i: 1).isReg() &&
2661 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2662 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 24 /* uimm6_lsb0 */) &&
2663 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 25 /* uimm6_lsb0_optional */)) {
2664 // qk.c.sh $rs2, ${imm}(${rs1})
2665 OutInst.setOpcode(RISCV::QK_C_SH);
2666 // Operand: rs2
2667 OutInst.addOperand(Op: MI.getOperand(i: 0));
2668 // Operand: rs1
2669 OutInst.addOperand(Op: MI.getOperand(i: 1));
2670 // Operand: imm
2671 OutInst.addOperand(Op: MI.getOperand(i: 2));
2672 OutInst.setLoc(MI.getLoc());
2673 return true;
2674 } // if
2675 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
2676 MI.getOperand(i: 0).isReg() &&
2677 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2678 MI.getOperand(i: 1).isReg() &&
2679 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2680 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 26 /* uimm5_lsb0 */) &&
2681 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 27 /* uimm5_lsb0_optional */)) {
2682 // qk.c.shsp $rd_rs2, ${imm}(${rs1})
2683 OutInst.setOpcode(RISCV::QK_C_SHSP);
2684 // Operand: rd_rs2
2685 OutInst.addOperand(Op: MI.getOperand(i: 0));
2686 // Operand: rs1
2687 OutInst.addOperand(Op: MI.getOperand(i: 1));
2688 // Operand: imm
2689 OutInst.addOperand(Op: MI.getOperand(i: 2));
2690 OutInst.setLoc(MI.getLoc());
2691 return true;
2692 } // if
2693 break;
2694 } // case SH
2695 case RISCV::SH1ADD: {
2696 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2697 STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
2698 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
2699 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
2700 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
2701 MI.getOperand(i: 2).isReg() &&
2702 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg()) &&
2703 MI.getOperand(i: 1).isReg() &&
2704 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2705 RISCVValidateMCOperandForCompress(MCOp: MCOperand::createImm(Val: 2), STI, PredicateIndex: 18 /* uimm5 */)) {
2706 // qc.c.muliadd $rd, $rs1, $uimm
2707 OutInst.setOpcode(RISCV::QC_C_MULIADD);
2708 // Operand: rd_wb
2709 OutInst.addOperand(Op: MI.getOperand(i: 2));
2710 // Operand: rd
2711 OutInst.addOperand(Op: MI.getOperand(i: 2));
2712 // Operand: rs1
2713 OutInst.addOperand(Op: MI.getOperand(i: 1));
2714 // Operand: uimm
2715 OutInst.addOperand(Op: MCOperand::createImm(Val: 2));
2716 OutInst.setLoc(MI.getLoc());
2717 return true;
2718 } // if
2719 break;
2720 } // case SH1ADD
2721 case RISCV::SH2ADD: {
2722 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2723 STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
2724 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
2725 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
2726 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
2727 MI.getOperand(i: 2).isReg() &&
2728 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg()) &&
2729 MI.getOperand(i: 1).isReg() &&
2730 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2731 RISCVValidateMCOperandForCompress(MCOp: MCOperand::createImm(Val: 4), STI, PredicateIndex: 18 /* uimm5 */)) {
2732 // qc.c.muliadd $rd, $rs1, $uimm
2733 OutInst.setOpcode(RISCV::QC_C_MULIADD);
2734 // Operand: rd_wb
2735 OutInst.addOperand(Op: MI.getOperand(i: 2));
2736 // Operand: rd
2737 OutInst.addOperand(Op: MI.getOperand(i: 2));
2738 // Operand: rs1
2739 OutInst.addOperand(Op: MI.getOperand(i: 1));
2740 // Operand: uimm
2741 OutInst.addOperand(Op: MCOperand::createImm(Val: 4));
2742 OutInst.setLoc(MI.getLoc());
2743 return true;
2744 } // if
2745 break;
2746 } // case SH2ADD
2747 case RISCV::SH3ADD: {
2748 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
2749 STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
2750 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
2751 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
2752 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
2753 MI.getOperand(i: 2).isReg() &&
2754 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg()) &&
2755 MI.getOperand(i: 1).isReg() &&
2756 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2757 RISCVValidateMCOperandForCompress(MCOp: MCOperand::createImm(Val: 8), STI, PredicateIndex: 18 /* uimm5 */)) {
2758 // qc.c.muliadd $rd, $rs1, $uimm
2759 OutInst.setOpcode(RISCV::QC_C_MULIADD);
2760 // Operand: rd_wb
2761 OutInst.addOperand(Op: MI.getOperand(i: 2));
2762 // Operand: rd
2763 OutInst.addOperand(Op: MI.getOperand(i: 2));
2764 // Operand: rs1
2765 OutInst.addOperand(Op: MI.getOperand(i: 1));
2766 // Operand: uimm
2767 OutInst.addOperand(Op: MCOperand::createImm(Val: 8));
2768 OutInst.setLoc(MI.getLoc());
2769 return true;
2770 } // if
2771 break;
2772 } // case SH3ADD
2773 case RISCV::SH_INX: {
2774 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
2775 MI.getOperand(i: 0).isReg() &&
2776 getRISCVMCRegisterClass(RC: RISCV::GPRF16CRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2777 MI.getOperand(i: 1).isReg() &&
2778 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2779 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 22 /* uimm2_lsb0 */) &&
2780 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 23 /* uimm2_lsb0_optional */)) {
2781 // c.sh $rs2, ${imm}(${rs1})
2782 OutInst.setOpcode(RISCV::C_SH_INX);
2783 // Operand: rs2
2784 OutInst.addOperand(Op: MI.getOperand(i: 0));
2785 // Operand: rs1
2786 OutInst.addOperand(Op: MI.getOperand(i: 1));
2787 // Operand: imm
2788 OutInst.addOperand(Op: MI.getOperand(i: 2));
2789 OutInst.setLoc(MI.getLoc());
2790 return true;
2791 } // if
2792 break;
2793 } // case SH_INX
2794 case RISCV::SLLI: {
2795 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2796 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2797 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2798 MI.getOperand(i: 1).isReg() &&
2799 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2800 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 6 /* uimmlog2xlennonzero */) &&
2801 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 38 /* uimmlog2xlen */)) {
2802 // c.slli $rd, $imm
2803 OutInst.setOpcode(RISCV::C_SLLI);
2804 // Operand: rd_wb
2805 OutInst.addOperand(Op: MI.getOperand(i: 1));
2806 // Operand: rd
2807 OutInst.addOperand(Op: MI.getOperand(i: 1));
2808 // Operand: imm
2809 OutInst.addOperand(Op: MI.getOperand(i: 2));
2810 OutInst.setLoc(MI.getLoc());
2811 return true;
2812 } // if
2813 break;
2814 } // case SLLI
2815 case RISCV::SRAI: {
2816 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2817 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2818 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2819 MI.getOperand(i: 1).isReg() &&
2820 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2821 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 6 /* uimmlog2xlennonzero */) &&
2822 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 38 /* uimmlog2xlen */)) {
2823 // c.srai $rs1, $imm
2824 OutInst.setOpcode(RISCV::C_SRAI);
2825 // Operand: rd
2826 OutInst.addOperand(Op: MI.getOperand(i: 1));
2827 // Operand: rs1
2828 OutInst.addOperand(Op: MI.getOperand(i: 1));
2829 // Operand: imm
2830 OutInst.addOperand(Op: MI.getOperand(i: 2));
2831 OutInst.setLoc(MI.getLoc());
2832 return true;
2833 } // if
2834 break;
2835 } // case SRAI
2836 case RISCV::SRLI: {
2837 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2838 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2839 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2840 MI.getOperand(i: 1).isReg() &&
2841 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2842 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 6 /* uimmlog2xlennonzero */) &&
2843 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 38 /* uimmlog2xlen */)) {
2844 // c.srli $rs1, $imm
2845 OutInst.setOpcode(RISCV::C_SRLI);
2846 // Operand: rd
2847 OutInst.addOperand(Op: MI.getOperand(i: 1));
2848 // Operand: rs1
2849 OutInst.addOperand(Op: MI.getOperand(i: 1));
2850 // Operand: imm
2851 OutInst.addOperand(Op: MI.getOperand(i: 2));
2852 OutInst.setLoc(MI.getLoc());
2853 return true;
2854 } // if
2855 break;
2856 } // case SRLI
2857 case RISCV::SSPOPCHK: {
2858 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcmop] &&
2859 MI.getOperand(i: 0).isReg() &&
2860 (MI.getOperand(i: 0).getReg() == RISCV::X5)) {
2861 // c.sspopchk $rs1
2862 OutInst.setOpcode(RISCV::C_SSPOPCHK);
2863 // Operand: rs1
2864 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X5));
2865 OutInst.setLoc(MI.getLoc());
2866 return true;
2867 } // if
2868 break;
2869 } // case SSPOPCHK
2870 case RISCV::SSPUSH: {
2871 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcmop] &&
2872 MI.getOperand(i: 0).isReg() &&
2873 (MI.getOperand(i: 0).getReg() == RISCV::X1)) {
2874 // c.sspush $rs1
2875 OutInst.setOpcode(RISCV::C_SSPUSH);
2876 // Operand: rs1
2877 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X1));
2878 OutInst.setLoc(MI.getLoc());
2879 return true;
2880 } // if
2881 break;
2882 } // case SSPUSH
2883 case RISCV::SUB: {
2884 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2885 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2886 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2887 MI.getOperand(i: 1).isReg() &&
2888 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2889 MI.getOperand(i: 2).isReg() &&
2890 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
2891 // c.sub $rd, $rs2
2892 OutInst.setOpcode(RISCV::C_SUB);
2893 // Operand: rd_wb
2894 OutInst.addOperand(Op: MI.getOperand(i: 1));
2895 // Operand: rd
2896 OutInst.addOperand(Op: MI.getOperand(i: 1));
2897 // Operand: rs2
2898 OutInst.addOperand(Op: MI.getOperand(i: 2));
2899 OutInst.setLoc(MI.getLoc());
2900 return true;
2901 } // if
2902 break;
2903 } // case SUB
2904 case RISCV::SUBW: {
2905 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
2906 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2907 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2908 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2909 MI.getOperand(i: 1).isReg() &&
2910 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2911 MI.getOperand(i: 2).isReg() &&
2912 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
2913 // c.subw $rd, $rs2
2914 OutInst.setOpcode(RISCV::C_SUBW);
2915 // Operand: rd_wb
2916 OutInst.addOperand(Op: MI.getOperand(i: 1));
2917 // Operand: rd
2918 OutInst.addOperand(Op: MI.getOperand(i: 1));
2919 // Operand: rs2
2920 OutInst.addOperand(Op: MI.getOperand(i: 2));
2921 OutInst.setLoc(MI.getLoc());
2922 return true;
2923 } // if
2924 break;
2925 } // case SUBW
2926 case RISCV::SW: {
2927 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2928 MI.getOperand(i: 0).isReg() &&
2929 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2930 MI.getOperand(i: 1).isReg() &&
2931 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2932 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 11 /* uimm7_lsb00 */) &&
2933 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 12 /* uimm7_lsb00_optional */)) {
2934 // c.sw $rs2, ${imm}(${rs1})
2935 OutInst.setOpcode(RISCV::C_SW);
2936 // Operand: rs2
2937 OutInst.addOperand(Op: MI.getOperand(i: 0));
2938 // Operand: rs1
2939 OutInst.addOperand(Op: MI.getOperand(i: 1));
2940 // Operand: imm
2941 OutInst.addOperand(Op: MI.getOperand(i: 2));
2942 OutInst.setLoc(MI.getLoc());
2943 return true;
2944 } // if
2945 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2946 MI.getOperand(i: 0).isReg() &&
2947 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2948 MI.getOperand(i: 1).isReg() &&
2949 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2950 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 13 /* uimm8_lsb00 */) &&
2951 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 14 /* uimm8_lsb00_optional */)) {
2952 // c.swsp $rs2, ${imm}(${rs1})
2953 OutInst.setOpcode(RISCV::C_SWSP);
2954 // Operand: rs2
2955 OutInst.addOperand(Op: MI.getOperand(i: 0));
2956 // Operand: rs1
2957 OutInst.addOperand(Op: MI.getOperand(i: 1));
2958 // Operand: imm
2959 OutInst.addOperand(Op: MI.getOperand(i: 2));
2960 OutInst.setLoc(MI.getLoc());
2961 return true;
2962 } // if
2963 break;
2964 } // case SW
2965 case RISCV::SW_INX: {
2966 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2967 MI.getOperand(i: 0).isReg() &&
2968 getRISCVMCRegisterClass(RC: RISCV::GPRF32CRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2969 MI.getOperand(i: 1).isReg() &&
2970 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2971 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 11 /* uimm7_lsb00 */) &&
2972 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 12 /* uimm7_lsb00_optional */)) {
2973 // c.sw $rs2, ${imm}(${rs1})
2974 OutInst.setOpcode(RISCV::C_SW_INX);
2975 // Operand: rs2
2976 OutInst.addOperand(Op: MI.getOperand(i: 0));
2977 // Operand: rs1
2978 OutInst.addOperand(Op: MI.getOperand(i: 1));
2979 // Operand: imm
2980 OutInst.addOperand(Op: MI.getOperand(i: 2));
2981 OutInst.setLoc(MI.getLoc());
2982 return true;
2983 } // if
2984 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2985 MI.getOperand(i: 0).isReg() &&
2986 getRISCVMCRegisterClass(RC: RISCV::GPRF32RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
2987 MI.getOperand(i: 1).isReg() &&
2988 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
2989 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 13 /* uimm8_lsb00 */) &&
2990 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 14 /* uimm8_lsb00_optional */)) {
2991 // c.swsp $rs2, ${imm}(${rs1})
2992 OutInst.setOpcode(RISCV::C_SWSP_INX);
2993 // Operand: rs2
2994 OutInst.addOperand(Op: MI.getOperand(i: 0));
2995 // Operand: rs1
2996 OutInst.addOperand(Op: MI.getOperand(i: 1));
2997 // Operand: imm
2998 OutInst.addOperand(Op: MI.getOperand(i: 2));
2999 OutInst.setLoc(MI.getLoc());
3000 return true;
3001 } // if
3002 break;
3003 } // case SW_INX
3004 case RISCV::UNIMP: {
3005 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca]) {
3006 // c.unimp
3007 OutInst.setOpcode(RISCV::C_UNIMP);
3008 OutInst.setLoc(MI.getLoc());
3009 return true;
3010 } // if
3011 break;
3012 } // case UNIMP
3013 case RISCV::XOR: {
3014 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3015 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
3016 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
3017 MI.getOperand(i: 1).isReg() &&
3018 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3019 MI.getOperand(i: 2).isReg() &&
3020 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
3021 // c.xor $rd, $rs2
3022 OutInst.setOpcode(RISCV::C_XOR);
3023 // Operand: rd_wb
3024 OutInst.addOperand(Op: MI.getOperand(i: 1));
3025 // Operand: rd
3026 OutInst.addOperand(Op: MI.getOperand(i: 1));
3027 // Operand: rs2
3028 OutInst.addOperand(Op: MI.getOperand(i: 2));
3029 OutInst.setLoc(MI.getLoc());
3030 return true;
3031 } // if
3032 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3033 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
3034 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
3035 MI.getOperand(i: 2).isReg() &&
3036 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg()) &&
3037 MI.getOperand(i: 1).isReg() &&
3038 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
3039 // c.xor $rd, $rs2
3040 OutInst.setOpcode(RISCV::C_XOR);
3041 // Operand: rd_wb
3042 OutInst.addOperand(Op: MI.getOperand(i: 2));
3043 // Operand: rd
3044 OutInst.addOperand(Op: MI.getOperand(i: 2));
3045 // Operand: rs2
3046 OutInst.addOperand(Op: MI.getOperand(i: 1));
3047 OutInst.setLoc(MI.getLoc());
3048 return true;
3049 } // if
3050 break;
3051 } // case XOR
3052 case RISCV::XORI: {
3053 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
3054 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
3055 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
3056 MI.getOperand(i: 2).isImm() &&
3057 (MI.getOperand(i: 2).getImm() == -1) &&
3058 MI.getOperand(i: 1).isReg() &&
3059 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
3060 // c.not $rd
3061 OutInst.setOpcode(RISCV::C_NOT);
3062 // Operand: rd_wb
3063 OutInst.addOperand(Op: MI.getOperand(i: 1));
3064 // Operand: rd
3065 OutInst.addOperand(Op: MI.getOperand(i: 1));
3066 OutInst.setLoc(MI.getLoc());
3067 return true;
3068 } // if
3069 break;
3070 } // case XORI
3071 case RISCV::ZEXT_H_RV32: {
3072 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
3073 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
3074 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
3075 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
3076 MI.getOperand(i: 1).isReg() &&
3077 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
3078 // c.zext.h $rd
3079 OutInst.setOpcode(RISCV::C_ZEXT_H);
3080 // Operand: rd_wb
3081 OutInst.addOperand(Op: MI.getOperand(i: 1));
3082 // Operand: rd
3083 OutInst.addOperand(Op: MI.getOperand(i: 1));
3084 OutInst.setLoc(MI.getLoc());
3085 return true;
3086 } // if
3087 break;
3088 } // case ZEXT_H_RV32
3089 case RISCV::ZEXT_H_RV64: {
3090 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
3091 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
3092 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
3093 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
3094 MI.getOperand(i: 1).isReg() &&
3095 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg())) {
3096 // c.zext.h $rd
3097 OutInst.setOpcode(RISCV::C_ZEXT_H);
3098 // Operand: rd_wb
3099 OutInst.addOperand(Op: MI.getOperand(i: 1));
3100 // Operand: rd
3101 OutInst.addOperand(Op: MI.getOperand(i: 1));
3102 OutInst.setLoc(MI.getLoc());
3103 return true;
3104 } // if
3105 break;
3106 } // case ZEXT_H_RV64
3107 } // switch
3108 return false;
3109}
3110
3111#endif // GEN_COMPRESS_INSTR
3112
3113#ifdef GEN_UNCOMPRESS_INSTR
3114#undef GEN_UNCOMPRESS_INSTR
3115
3116static bool RISCVValidateMCOperandForUncompress(const MCOperand &MCOp,
3117 const MCSubtargetInfo &STI,
3118 unsigned PredicateIndex) {
3119 switch (PredicateIndex) {
3120 default:
3121 llvm_unreachable("Unknown MCOperandPredicate kind");
3122 break;
3123 case 1: {
3124 // simm6nonzero
3125 int64_t Imm;
3126 if (MCOp.evaluateAsConstantImm(Imm))
3127 return (Imm != 0) && isInt<6>(x: Imm);
3128 return MCOp.isBareSymbolRef();
3129 }
3130 case 2: {
3131 // simm12_lo
3132 int64_t Imm;
3133 if (MCOp.evaluateAsConstantImm(Imm))
3134 return isInt<12>(x: Imm);
3135 return MCOp.isBareSymbolRef();
3136 }
3137 case 3: {
3138 // simm10_lsb0000nonzero
3139 int64_t Imm;
3140 if (!MCOp.evaluateAsConstantImm(Imm))
3141 return false;
3142 return isShiftedInt<6, 4>(x: Imm) && (Imm != 0);
3143 }
3144 case 4: {
3145 // uimm10_lsb00nonzero
3146 int64_t Imm;
3147 if (!MCOp.evaluateAsConstantImm(Imm))
3148 return false;
3149 return isShiftedUInt<8, 2>(x: Imm) && (Imm != 0);
3150 }
3151 case 5: {
3152 // simm6
3153 int64_t Imm;
3154 if (MCOp.evaluateAsConstantImm(Imm))
3155 return isInt<6>(x: Imm);
3156 return MCOp.isBareSymbolRef();
3157 }
3158 case 6: {
3159 // bare_simm9_lsb0
3160 int64_t Imm;
3161 if (MCOp.evaluateAsConstantImm(Imm))
3162 return isShiftedInt<8, 1>(x: Imm);
3163 return MCOp.isBareSymbolRef();
3164 }
3165 case 7: {
3166 // bare_simm13_lsb0
3167 int64_t Imm;
3168 if (MCOp.evaluateAsConstantImm(Imm))
3169 return isShiftedInt<12, 1>(x: Imm);
3170 return MCOp.isBareSymbolRef();
3171 }
3172 case 8: {
3173 // uimm8_lsb000
3174 int64_t Imm;
3175 if (!MCOp.evaluateAsConstantImm(Imm))
3176 return false;
3177 return isShiftedUInt<5, 3>(x: Imm);
3178 }
3179 case 9: {
3180 // simm12_lo_optional
3181 int64_t Imm;
3182 if (MCOp.evaluateAsConstantImm(Imm))
3183 return isInt<12>(x: Imm);
3184 return MCOp.isBareSymbolRef();
3185 }
3186 case 10: {
3187 // uimm9_lsb000
3188 int64_t Imm;
3189 if (!MCOp.evaluateAsConstantImm(Imm))
3190 return false;
3191 return isShiftedUInt<6, 3>(x: Imm);
3192 }
3193 case 11: {
3194 // uimm7_lsb00
3195 int64_t Imm;
3196 if (!MCOp.evaluateAsConstantImm(Imm))
3197 return false;
3198 return isShiftedUInt<5, 2>(x: Imm);
3199 }
3200 case 12: {
3201 // uimm8_lsb00
3202 int64_t Imm;
3203 if (!MCOp.evaluateAsConstantImm(Imm))
3204 return false;
3205 return isShiftedUInt<6, 2>(x: Imm);
3206 }
3207 case 13: {
3208 // bare_simm12_lsb0
3209 int64_t Imm;
3210 if (MCOp.evaluateAsConstantImm(Imm))
3211 return isShiftedInt<11, 1>(x: Imm);
3212 return MCOp.isBareSymbolRef();
3213 }
3214 case 14: {
3215 // simm21_lsb0_jal
3216 int64_t Imm;
3217 if (MCOp.evaluateAsConstantImm(Imm))
3218 return isShiftedInt<20, 1>(x: Imm);
3219 return MCOp.isBareSymbolRef();
3220 }
3221 case 15: {
3222 // uimm2
3223 int64_t Imm;
3224 if (!MCOp.evaluateAsConstantImm(Imm))
3225 return false;
3226 return isUInt<2>(x: Imm);
3227 }
3228 case 16: {
3229 // uimm2_lsb0
3230 int64_t Imm;
3231 if (!MCOp.evaluateAsConstantImm(Imm))
3232 return false;
3233 return isShiftedUInt<1, 1>(x: Imm);
3234 }
3235 case 17: {
3236 // simm20_li
3237 int64_t Imm;
3238 if (MCOp.evaluateAsConstantImm(Imm))
3239 return isInt<20>(x: Imm);
3240 return MCOp.isBareSymbolRef();
3241 }
3242 case 18: {
3243 // c_lui_imm
3244 int64_t Imm;
3245 if (!MCOp.evaluateAsConstantImm(Imm))
3246 return false;
3247 return (Imm != 0) && (isUInt<5>(x: Imm) ||
3248 (Imm >= 0xfffe0 && Imm <= 0xfffff));
3249 }
3250 case 19: {
3251 // uimm20_lui
3252 int64_t Imm;
3253 if (MCOp.evaluateAsConstantImm(Imm))
3254 return isUInt<20>(x: Imm);
3255 return MCOp.isBareSymbolRef();
3256 }
3257 case 20: {
3258 // uimmlog2xlennonzero
3259 int64_t Imm;
3260 if (!MCOp.evaluateAsConstantImm(Imm))
3261 return false;
3262 if (STI.getTargetTriple().isArch64Bit())
3263 return isUInt<6>(x: Imm) && (Imm != 0);
3264 return isUInt<5>(x: Imm) && (Imm != 0);
3265 }
3266 case 21: {
3267 // uimmlog2xlen
3268 int64_t Imm;
3269 if (!MCOp.evaluateAsConstantImm(Imm))
3270 return false;
3271 if (STI.getTargetTriple().isArch64Bit())
3272 return isUInt<6>(x: Imm);
3273 return isUInt<5>(x: Imm);
3274 }
3275 case 22: {
3276 // uimm5ge6_plus1
3277 int64_t Imm;
3278 if (!MCOp.evaluateAsConstantImm(Imm))
3279 return false;
3280 return Imm >= 6 && Imm <= 32;
3281 }
3282 case 23: {
3283 // uimm5_plus1
3284 int64_t Imm;
3285 if (!MCOp.evaluateAsConstantImm(Imm))
3286 return false;
3287 return Imm > 0 && isUInt<5>(x: Imm - 1);
3288 }
3289 case 24: {
3290 // uimm5
3291 int64_t Imm;
3292 if (!MCOp.evaluateAsConstantImm(Imm))
3293 return false;
3294 return isUInt<5>(x: Imm);
3295 }
3296 case 25: {
3297 // simm5
3298 int64_t Imm;
3299 if (MCOp.evaluateAsConstantImm(Imm))
3300 return isInt<5>(x: Imm);
3301 return MCOp.isBareSymbolRef();
3302 }
3303 case 26: {
3304 // uimm5slist
3305 int64_t Imm;
3306 if (!MCOp.evaluateAsConstantImm(Imm))
3307 return false;
3308 return ((Imm == 0) || (Imm == 1) ||
3309 (Imm == 2) || (Imm == 4) ||
3310 (Imm == 8) || (Imm == 16) ||
3311 (Imm == 15) || (Imm == 31));
3312 }
3313 case 27: {
3314 // uimm4
3315 int64_t Imm;
3316 if (!MCOp.evaluateAsConstantImm(Imm))
3317 return false;
3318 return isUInt<4>(x: Imm);
3319 }
3320 case 28: {
3321 // uimm6_lsb0
3322 int64_t Imm;
3323 if (!MCOp.evaluateAsConstantImm(Imm))
3324 return false;
3325 return isShiftedUInt<5, 1>(x: Imm);
3326 }
3327 case 29: {
3328 // uimm5_lsb0
3329 int64_t Imm;
3330 if (!MCOp.evaluateAsConstantImm(Imm))
3331 return false;
3332 return isShiftedUInt<4, 1>(x: Imm);
3333 }
3334 }
3335}
3336
3337static bool uncompressInst(MCInst &OutInst,
3338 const MCInst &MI,
3339 const MCSubtargetInfo &STI) {
3340 switch (MI.getOpcode()) {
3341 default: return false;
3342 case RISCV::C_ADD: {
3343 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3344 MI.getOperand(i: 0).isReg() &&
3345 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3346 MI.getOperand(i: 0).isReg() &&
3347 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3348 MI.getOperand(i: 2).isReg() &&
3349 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
3350 // add $rd, $rs1, $rs2
3351 OutInst.setOpcode(RISCV::ADD);
3352 // Operand: rd
3353 OutInst.addOperand(Op: MI.getOperand(i: 0));
3354 // Operand: rs1
3355 OutInst.addOperand(Op: MI.getOperand(i: 0));
3356 // Operand: rs2
3357 OutInst.addOperand(Op: MI.getOperand(i: 2));
3358 OutInst.setLoc(MI.getLoc());
3359 return true;
3360 } // if
3361 break;
3362 } // case C_ADD
3363 case RISCV::C_ADDI: {
3364 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3365 MI.getOperand(i: 0).isReg() &&
3366 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3367 MI.getOperand(i: 0).isReg() &&
3368 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3369 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 1 /* simm6nonzero */) &&
3370 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3371 // addi $rd, $rs1, $imm12
3372 OutInst.setOpcode(RISCV::ADDI);
3373 // Operand: rd
3374 OutInst.addOperand(Op: MI.getOperand(i: 0));
3375 // Operand: rs1
3376 OutInst.addOperand(Op: MI.getOperand(i: 0));
3377 // Operand: imm12
3378 OutInst.addOperand(Op: MI.getOperand(i: 2));
3379 OutInst.setLoc(MI.getLoc());
3380 return true;
3381 } // if
3382 break;
3383 } // case C_ADDI
3384 case RISCV::C_ADDI16SP: {
3385 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3386 MI.getOperand(i: 0).isReg() &&
3387 (MI.getOperand(i: 0).getReg() == RISCV::X2) &&
3388 MI.getOperand(i: 1).isReg() &&
3389 (MI.getOperand(i: 1).getReg() == RISCV::X2) &&
3390 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 3 /* simm10_lsb0000nonzero */) &&
3391 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3392 // addi $rd, $rs1, $imm12
3393 OutInst.setOpcode(RISCV::ADDI);
3394 // Operand: rd
3395 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X2));
3396 // Operand: rs1
3397 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X2));
3398 // Operand: imm12
3399 OutInst.addOperand(Op: MI.getOperand(i: 2));
3400 OutInst.setLoc(MI.getLoc());
3401 return true;
3402 } // if
3403 break;
3404 } // case C_ADDI16SP
3405 case RISCV::C_ADDI4SPN: {
3406 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3407 MI.getOperand(i: 0).isReg() &&
3408 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3409 MI.getOperand(i: 1).isReg() &&
3410 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3411 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 4 /* uimm10_lsb00nonzero */) &&
3412 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3413 // addi $rd, $rs1, $imm12
3414 OutInst.setOpcode(RISCV::ADDI);
3415 // Operand: rd
3416 OutInst.addOperand(Op: MI.getOperand(i: 0));
3417 // Operand: rs1
3418 OutInst.addOperand(Op: MI.getOperand(i: 1));
3419 // Operand: imm12
3420 OutInst.addOperand(Op: MI.getOperand(i: 2));
3421 OutInst.setLoc(MI.getLoc());
3422 return true;
3423 } // if
3424 break;
3425 } // case C_ADDI4SPN
3426 case RISCV::C_ADDIW: {
3427 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
3428 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3429 MI.getOperand(i: 0).isReg() &&
3430 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3431 MI.getOperand(i: 0).isReg() &&
3432 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3433 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 5 /* simm6 */) &&
3434 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3435 // addiw $rd, $rs1, $imm12
3436 OutInst.setOpcode(RISCV::ADDIW);
3437 // Operand: rd
3438 OutInst.addOperand(Op: MI.getOperand(i: 0));
3439 // Operand: rs1
3440 OutInst.addOperand(Op: MI.getOperand(i: 0));
3441 // Operand: imm12
3442 OutInst.addOperand(Op: MI.getOperand(i: 2));
3443 OutInst.setLoc(MI.getLoc());
3444 return true;
3445 } // if
3446 break;
3447 } // case C_ADDIW
3448 case RISCV::C_ADDW: {
3449 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
3450 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3451 MI.getOperand(i: 0).isReg() &&
3452 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3453 MI.getOperand(i: 0).isReg() &&
3454 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3455 MI.getOperand(i: 2).isReg() &&
3456 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
3457 // addw $rd, $rs1, $rs2
3458 OutInst.setOpcode(RISCV::ADDW);
3459 // Operand: rd
3460 OutInst.addOperand(Op: MI.getOperand(i: 0));
3461 // Operand: rs1
3462 OutInst.addOperand(Op: MI.getOperand(i: 0));
3463 // Operand: rs2
3464 OutInst.addOperand(Op: MI.getOperand(i: 2));
3465 OutInst.setLoc(MI.getLoc());
3466 return true;
3467 } // if
3468 break;
3469 } // case C_ADDW
3470 case RISCV::C_AND: {
3471 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3472 MI.getOperand(i: 0).isReg() &&
3473 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3474 MI.getOperand(i: 0).isReg() &&
3475 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3476 MI.getOperand(i: 2).isReg() &&
3477 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
3478 // and $rd, $rs1, $rs2
3479 OutInst.setOpcode(RISCV::AND);
3480 // Operand: rd
3481 OutInst.addOperand(Op: MI.getOperand(i: 0));
3482 // Operand: rs1
3483 OutInst.addOperand(Op: MI.getOperand(i: 0));
3484 // Operand: rs2
3485 OutInst.addOperand(Op: MI.getOperand(i: 2));
3486 OutInst.setLoc(MI.getLoc());
3487 return true;
3488 } // if
3489 break;
3490 } // case C_AND
3491 case RISCV::C_ANDI: {
3492 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3493 MI.getOperand(i: 0).isReg() &&
3494 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3495 MI.getOperand(i: 0).isReg() &&
3496 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3497 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 5 /* simm6 */) &&
3498 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3499 // andi $rd, $rs1, $imm12
3500 OutInst.setOpcode(RISCV::ANDI);
3501 // Operand: rd
3502 OutInst.addOperand(Op: MI.getOperand(i: 0));
3503 // Operand: rs1
3504 OutInst.addOperand(Op: MI.getOperand(i: 0));
3505 // Operand: imm12
3506 OutInst.addOperand(Op: MI.getOperand(i: 2));
3507 OutInst.setLoc(MI.getLoc());
3508 return true;
3509 } // if
3510 break;
3511 } // case C_ANDI
3512 case RISCV::C_BEQZ: {
3513 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3514 MI.getOperand(i: 0).isReg() &&
3515 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3516 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 6 /* bare_simm9_lsb0 */) &&
3517 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 7 /* bare_simm13_lsb0 */)) {
3518 // beq $rs1, $rs2, $imm12
3519 OutInst.setOpcode(RISCV::BEQ);
3520 // Operand: rs1
3521 OutInst.addOperand(Op: MI.getOperand(i: 0));
3522 // Operand: rs2
3523 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
3524 // Operand: imm12
3525 OutInst.addOperand(Op: MI.getOperand(i: 1));
3526 OutInst.setLoc(MI.getLoc());
3527 return true;
3528 } // if
3529 break;
3530 } // case C_BEQZ
3531 case RISCV::C_BNEZ: {
3532 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3533 MI.getOperand(i: 0).isReg() &&
3534 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3535 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 6 /* bare_simm9_lsb0 */) &&
3536 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 7 /* bare_simm13_lsb0 */)) {
3537 // bne $rs1, $rs2, $imm12
3538 OutInst.setOpcode(RISCV::BNE);
3539 // Operand: rs1
3540 OutInst.addOperand(Op: MI.getOperand(i: 0));
3541 // Operand: rs2
3542 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
3543 // Operand: imm12
3544 OutInst.addOperand(Op: MI.getOperand(i: 1));
3545 OutInst.setLoc(MI.getLoc());
3546 return true;
3547 } // if
3548 break;
3549 } // case C_BNEZ
3550 case RISCV::C_EBREAK: {
3551 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca]) {
3552 // ebreak
3553 OutInst.setOpcode(RISCV::EBREAK);
3554 OutInst.setLoc(MI.getLoc());
3555 return true;
3556 } // if
3557 break;
3558 } // case C_EBREAK
3559 case RISCV::C_FLD: {
3560 if (STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
3561 STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
3562 MI.getOperand(i: 0).isReg() &&
3563 getRISCVMCRegisterClass(RC: RISCV::FPR64CRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3564 MI.getOperand(i: 1).isReg() &&
3565 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3566 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000 */) &&
3567 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3568 // fld $rd, ${imm12}(${rs1})
3569 OutInst.setOpcode(RISCV::FLD);
3570 // Operand: rd
3571 OutInst.addOperand(Op: MI.getOperand(i: 0));
3572 // Operand: rs1
3573 OutInst.addOperand(Op: MI.getOperand(i: 1));
3574 // Operand: imm12
3575 OutInst.addOperand(Op: MI.getOperand(i: 2));
3576 OutInst.setLoc(MI.getLoc());
3577 return true;
3578 } // if
3579 break;
3580 } // case C_FLD
3581 case RISCV::C_FLDSP: {
3582 if (STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
3583 STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
3584 MI.getOperand(i: 0).isReg() &&
3585 getRISCVMCRegisterClass(RC: RISCV::FPR64RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3586 MI.getOperand(i: 1).isReg() &&
3587 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3588 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm9_lsb000 */) &&
3589 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3590 // fld $rd, ${imm12}(${rs1})
3591 OutInst.setOpcode(RISCV::FLD);
3592 // Operand: rd
3593 OutInst.addOperand(Op: MI.getOperand(i: 0));
3594 // Operand: rs1
3595 OutInst.addOperand(Op: MI.getOperand(i: 1));
3596 // Operand: imm12
3597 OutInst.addOperand(Op: MI.getOperand(i: 2));
3598 OutInst.setLoc(MI.getLoc());
3599 return true;
3600 } // if
3601 break;
3602 } // case C_FLDSP
3603 case RISCV::C_FLW: {
3604 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
3605 STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
3606 STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
3607 MI.getOperand(i: 0).isReg() &&
3608 getRISCVMCRegisterClass(RC: RISCV::FPR32CRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3609 MI.getOperand(i: 1).isReg() &&
3610 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3611 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 11 /* uimm7_lsb00 */) &&
3612 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3613 // flw $rd, ${imm12}(${rs1})
3614 OutInst.setOpcode(RISCV::FLW);
3615 // Operand: rd
3616 OutInst.addOperand(Op: MI.getOperand(i: 0));
3617 // Operand: rs1
3618 OutInst.addOperand(Op: MI.getOperand(i: 1));
3619 // Operand: imm12
3620 OutInst.addOperand(Op: MI.getOperand(i: 2));
3621 OutInst.setLoc(MI.getLoc());
3622 return true;
3623 } // if
3624 break;
3625 } // case C_FLW
3626 case RISCV::C_FLWSP: {
3627 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
3628 STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
3629 STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
3630 MI.getOperand(i: 0).isReg() &&
3631 getRISCVMCRegisterClass(RC: RISCV::FPR32RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3632 MI.getOperand(i: 1).isReg() &&
3633 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3634 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 12 /* uimm8_lsb00 */) &&
3635 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3636 // flw $rd, ${imm12}(${rs1})
3637 OutInst.setOpcode(RISCV::FLW);
3638 // Operand: rd
3639 OutInst.addOperand(Op: MI.getOperand(i: 0));
3640 // Operand: rs1
3641 OutInst.addOperand(Op: MI.getOperand(i: 1));
3642 // Operand: imm12
3643 OutInst.addOperand(Op: MI.getOperand(i: 2));
3644 OutInst.setLoc(MI.getLoc());
3645 return true;
3646 } // if
3647 break;
3648 } // case C_FLWSP
3649 case RISCV::C_FSD: {
3650 if (STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
3651 STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
3652 MI.getOperand(i: 0).isReg() &&
3653 getRISCVMCRegisterClass(RC: RISCV::FPR64CRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3654 MI.getOperand(i: 1).isReg() &&
3655 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3656 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000 */) &&
3657 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3658 // fsd $rs2, ${imm12}(${rs1})
3659 OutInst.setOpcode(RISCV::FSD);
3660 // Operand: rs2
3661 OutInst.addOperand(Op: MI.getOperand(i: 0));
3662 // Operand: rs1
3663 OutInst.addOperand(Op: MI.getOperand(i: 1));
3664 // Operand: imm12
3665 OutInst.addOperand(Op: MI.getOperand(i: 2));
3666 OutInst.setLoc(MI.getLoc());
3667 return true;
3668 } // if
3669 break;
3670 } // case C_FSD
3671 case RISCV::C_FSDSP: {
3672 if (STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
3673 STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
3674 MI.getOperand(i: 0).isReg() &&
3675 getRISCVMCRegisterClass(RC: RISCV::FPR64RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3676 MI.getOperand(i: 1).isReg() &&
3677 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3678 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm9_lsb000 */) &&
3679 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3680 // fsd $rs2, ${imm12}(${rs1})
3681 OutInst.setOpcode(RISCV::FSD);
3682 // Operand: rs2
3683 OutInst.addOperand(Op: MI.getOperand(i: 0));
3684 // Operand: rs1
3685 OutInst.addOperand(Op: MI.getOperand(i: 1));
3686 // Operand: imm12
3687 OutInst.addOperand(Op: MI.getOperand(i: 2));
3688 OutInst.setLoc(MI.getLoc());
3689 return true;
3690 } // if
3691 break;
3692 } // case C_FSDSP
3693 case RISCV::C_FSW: {
3694 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
3695 STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
3696 STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
3697 MI.getOperand(i: 0).isReg() &&
3698 getRISCVMCRegisterClass(RC: RISCV::FPR32CRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3699 MI.getOperand(i: 1).isReg() &&
3700 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3701 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 11 /* uimm7_lsb00 */) &&
3702 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3703 // fsw $rs2, ${imm12}(${rs1})
3704 OutInst.setOpcode(RISCV::FSW);
3705 // Operand: rs2
3706 OutInst.addOperand(Op: MI.getOperand(i: 0));
3707 // Operand: rs1
3708 OutInst.addOperand(Op: MI.getOperand(i: 1));
3709 // Operand: imm12
3710 OutInst.addOperand(Op: MI.getOperand(i: 2));
3711 OutInst.setLoc(MI.getLoc());
3712 return true;
3713 } // if
3714 break;
3715 } // case C_FSW
3716 case RISCV::C_FSWSP: {
3717 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
3718 STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
3719 STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
3720 MI.getOperand(i: 0).isReg() &&
3721 getRISCVMCRegisterClass(RC: RISCV::FPR32RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3722 MI.getOperand(i: 1).isReg() &&
3723 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3724 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 12 /* uimm8_lsb00 */) &&
3725 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3726 // fsw $rs2, ${imm12}(${rs1})
3727 OutInst.setOpcode(RISCV::FSW);
3728 // Operand: rs2
3729 OutInst.addOperand(Op: MI.getOperand(i: 0));
3730 // Operand: rs1
3731 OutInst.addOperand(Op: MI.getOperand(i: 1));
3732 // Operand: imm12
3733 OutInst.addOperand(Op: MI.getOperand(i: 2));
3734 OutInst.setLoc(MI.getLoc());
3735 return true;
3736 } // if
3737 break;
3738 } // case C_FSWSP
3739 case RISCV::C_J: {
3740 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3741 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 13 /* bare_simm12_lsb0 */) &&
3742 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 14 /* simm21_lsb0_jal */)) {
3743 // jal $rd, $imm20
3744 OutInst.setOpcode(RISCV::JAL);
3745 // Operand: rd
3746 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
3747 // Operand: imm20
3748 OutInst.addOperand(Op: MI.getOperand(i: 0));
3749 OutInst.setLoc(MI.getLoc());
3750 return true;
3751 } // if
3752 break;
3753 } // case C_J
3754 case RISCV::C_JAL: {
3755 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
3756 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3757 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 13 /* bare_simm12_lsb0 */) &&
3758 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 14 /* simm21_lsb0_jal */)) {
3759 // jal $rd, $imm20
3760 OutInst.setOpcode(RISCV::JAL);
3761 // Operand: rd
3762 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X1));
3763 // Operand: imm20
3764 OutInst.addOperand(Op: MI.getOperand(i: 0));
3765 OutInst.setLoc(MI.getLoc());
3766 return true;
3767 } // if
3768 break;
3769 } // case C_JAL
3770 case RISCV::C_JALR: {
3771 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3772 MI.getOperand(i: 0).isReg() &&
3773 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3774 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: 0), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3775 // jalr $rd, ${imm12}(${rs1})
3776 OutInst.setOpcode(RISCV::JALR);
3777 // Operand: rd
3778 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X1));
3779 // Operand: rs1
3780 OutInst.addOperand(Op: MI.getOperand(i: 0));
3781 // Operand: imm12
3782 OutInst.addOperand(Op: MCOperand::createImm(Val: 0));
3783 OutInst.setLoc(MI.getLoc());
3784 return true;
3785 } // if
3786 break;
3787 } // case C_JALR
3788 case RISCV::C_JR: {
3789 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3790 MI.getOperand(i: 0).isReg() &&
3791 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3792 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: 0), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3793 // jalr $rd, ${imm12}(${rs1})
3794 OutInst.setOpcode(RISCV::JALR);
3795 // Operand: rd
3796 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
3797 // Operand: rs1
3798 OutInst.addOperand(Op: MI.getOperand(i: 0));
3799 // Operand: imm12
3800 OutInst.addOperand(Op: MCOperand::createImm(Val: 0));
3801 OutInst.setLoc(MI.getLoc());
3802 return true;
3803 } // if
3804 break;
3805 } // case C_JR
3806 case RISCV::C_LBU: {
3807 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
3808 MI.getOperand(i: 0).isReg() &&
3809 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3810 MI.getOperand(i: 1).isReg() &&
3811 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3812 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 15 /* uimm2 */) &&
3813 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3814 // lbu $rd, ${imm12}(${rs1})
3815 OutInst.setOpcode(RISCV::LBU);
3816 // Operand: rd
3817 OutInst.addOperand(Op: MI.getOperand(i: 0));
3818 // Operand: rs1
3819 OutInst.addOperand(Op: MI.getOperand(i: 1));
3820 // Operand: imm12
3821 OutInst.addOperand(Op: MI.getOperand(i: 2));
3822 OutInst.setLoc(MI.getLoc());
3823 return true;
3824 } // if
3825 break;
3826 } // case C_LBU
3827 case RISCV::C_LD: {
3828 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
3829 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3830 MI.getOperand(i: 0).isReg() &&
3831 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3832 MI.getOperand(i: 1).isReg() &&
3833 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3834 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000 */) &&
3835 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3836 // ld $rd, ${imm12}(${rs1})
3837 OutInst.setOpcode(RISCV::LD);
3838 // Operand: rd
3839 OutInst.addOperand(Op: MI.getOperand(i: 0));
3840 // Operand: rs1
3841 OutInst.addOperand(Op: MI.getOperand(i: 1));
3842 // Operand: imm12
3843 OutInst.addOperand(Op: MI.getOperand(i: 2));
3844 OutInst.setLoc(MI.getLoc());
3845 return true;
3846 } // if
3847 break;
3848 } // case C_LD
3849 case RISCV::C_LDSP: {
3850 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
3851 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3852 MI.getOperand(i: 0).isReg() &&
3853 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3854 MI.getOperand(i: 1).isReg() &&
3855 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3856 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm9_lsb000 */) &&
3857 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3858 // ld $rd, ${imm12}(${rs1})
3859 OutInst.setOpcode(RISCV::LD);
3860 // Operand: rd
3861 OutInst.addOperand(Op: MI.getOperand(i: 0));
3862 // Operand: rs1
3863 OutInst.addOperand(Op: MI.getOperand(i: 1));
3864 // Operand: imm12
3865 OutInst.addOperand(Op: MI.getOperand(i: 2));
3866 OutInst.setLoc(MI.getLoc());
3867 return true;
3868 } // if
3869 break;
3870 } // case C_LDSP
3871 case RISCV::C_LDSP_RV32: {
3872 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
3873 STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
3874 STI.getFeatureBits()[RISCV::FeatureStdExtZilsd] &&
3875 MI.getOperand(i: 0).isReg() &&
3876 getRISCVMCRegisterClass(RC: RISCV::GPRPairNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3877 MI.getOperand(i: 1).isReg() &&
3878 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3879 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm9_lsb000 */) &&
3880 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3881 // ld $rd, ${imm12}(${rs1})
3882 OutInst.setOpcode(RISCV::LD_RV32);
3883 // Operand: rd
3884 OutInst.addOperand(Op: MI.getOperand(i: 0));
3885 // Operand: rs1
3886 OutInst.addOperand(Op: MI.getOperand(i: 1));
3887 // Operand: imm12
3888 OutInst.addOperand(Op: MI.getOperand(i: 2));
3889 OutInst.setLoc(MI.getLoc());
3890 return true;
3891 } // if
3892 break;
3893 } // case C_LDSP_RV32
3894 case RISCV::C_LD_RV32: {
3895 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
3896 STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
3897 STI.getFeatureBits()[RISCV::FeatureStdExtZilsd] &&
3898 MI.getOperand(i: 0).isReg() &&
3899 getRISCVMCRegisterClass(RC: RISCV::GPRPairCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3900 MI.getOperand(i: 1).isReg() &&
3901 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3902 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000 */) &&
3903 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3904 // ld $rd, ${imm12}(${rs1})
3905 OutInst.setOpcode(RISCV::LD_RV32);
3906 // Operand: rd
3907 OutInst.addOperand(Op: MI.getOperand(i: 0));
3908 // Operand: rs1
3909 OutInst.addOperand(Op: MI.getOperand(i: 1));
3910 // Operand: imm12
3911 OutInst.addOperand(Op: MI.getOperand(i: 2));
3912 OutInst.setLoc(MI.getLoc());
3913 return true;
3914 } // if
3915 break;
3916 } // case C_LD_RV32
3917 case RISCV::C_LH: {
3918 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
3919 MI.getOperand(i: 0).isReg() &&
3920 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3921 MI.getOperand(i: 1).isReg() &&
3922 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3923 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 16 /* uimm2_lsb0 */) &&
3924 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3925 // lh $rd, ${imm12}(${rs1})
3926 OutInst.setOpcode(RISCV::LH);
3927 // Operand: rd
3928 OutInst.addOperand(Op: MI.getOperand(i: 0));
3929 // Operand: rs1
3930 OutInst.addOperand(Op: MI.getOperand(i: 1));
3931 // Operand: imm12
3932 OutInst.addOperand(Op: MI.getOperand(i: 2));
3933 OutInst.setLoc(MI.getLoc());
3934 return true;
3935 } // if
3936 break;
3937 } // case C_LH
3938 case RISCV::C_LHU: {
3939 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
3940 MI.getOperand(i: 0).isReg() &&
3941 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3942 MI.getOperand(i: 1).isReg() &&
3943 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
3944 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 16 /* uimm2_lsb0 */) &&
3945 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
3946 // lhu $rd, ${imm12}(${rs1})
3947 OutInst.setOpcode(RISCV::LHU);
3948 // Operand: rd
3949 OutInst.addOperand(Op: MI.getOperand(i: 0));
3950 // Operand: rs1
3951 OutInst.addOperand(Op: MI.getOperand(i: 1));
3952 // Operand: imm12
3953 OutInst.addOperand(Op: MI.getOperand(i: 2));
3954 OutInst.setLoc(MI.getLoc());
3955 return true;
3956 } // if
3957 break;
3958 } // case C_LHU
3959 case RISCV::C_LI: {
3960 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3961 MI.getOperand(i: 0).isReg() &&
3962 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3963 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 5 /* simm6 */) &&
3964 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 2 /* simm12_lo */)) {
3965 // addi $rd, $rs1, $imm12
3966 OutInst.setOpcode(RISCV::ADDI);
3967 // Operand: rd
3968 OutInst.addOperand(Op: MI.getOperand(i: 0));
3969 // Operand: rs1
3970 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
3971 // Operand: imm12
3972 OutInst.addOperand(Op: MI.getOperand(i: 1));
3973 OutInst.setLoc(MI.getLoc());
3974 return true;
3975 } // if
3976 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
3977 STI.getFeatureBits()[RISCV::FeatureVendorXqcili] &&
3978 MI.getOperand(i: 0).isReg() &&
3979 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3980 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 5 /* simm6 */) &&
3981 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 17 /* simm20_li */)) {
3982 // qc.li $rd, $imm20
3983 OutInst.setOpcode(RISCV::QC_LI);
3984 // Operand: rd
3985 OutInst.addOperand(Op: MI.getOperand(i: 0));
3986 // Operand: imm20
3987 OutInst.addOperand(Op: MI.getOperand(i: 1));
3988 OutInst.setLoc(MI.getLoc());
3989 return true;
3990 } // if
3991 break;
3992 } // case C_LI
3993 case RISCV::C_LUI: {
3994 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3995 MI.getOperand(i: 0).isReg() &&
3996 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0X2RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
3997 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 18 /* c_lui_imm */) &&
3998 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 19 /* uimm20_lui */)) {
3999 // lui $rd, $imm20
4000 OutInst.setOpcode(RISCV::LUI);
4001 // Operand: rd
4002 OutInst.addOperand(Op: MI.getOperand(i: 0));
4003 // Operand: imm20
4004 OutInst.addOperand(Op: MI.getOperand(i: 1));
4005 OutInst.setLoc(MI.getLoc());
4006 return true;
4007 } // if
4008 break;
4009 } // case C_LUI
4010 case RISCV::C_LW: {
4011 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4012 MI.getOperand(i: 0).isReg() &&
4013 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4014 MI.getOperand(i: 1).isReg() &&
4015 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4016 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 11 /* uimm7_lsb00 */) &&
4017 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4018 // lw $rd, ${imm12}(${rs1})
4019 OutInst.setOpcode(RISCV::LW);
4020 // Operand: rd
4021 OutInst.addOperand(Op: MI.getOperand(i: 0));
4022 // Operand: rs1
4023 OutInst.addOperand(Op: MI.getOperand(i: 1));
4024 // Operand: imm12
4025 OutInst.addOperand(Op: MI.getOperand(i: 2));
4026 OutInst.setLoc(MI.getLoc());
4027 return true;
4028 } // if
4029 break;
4030 } // case C_LW
4031 case RISCV::C_LWSP: {
4032 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4033 MI.getOperand(i: 0).isReg() &&
4034 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4035 MI.getOperand(i: 1).isReg() &&
4036 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4037 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 12 /* uimm8_lsb00 */) &&
4038 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4039 // lw $rd, ${imm12}(${rs1})
4040 OutInst.setOpcode(RISCV::LW);
4041 // Operand: rd
4042 OutInst.addOperand(Op: MI.getOperand(i: 0));
4043 // Operand: rs1
4044 OutInst.addOperand(Op: MI.getOperand(i: 1));
4045 // Operand: imm12
4046 OutInst.addOperand(Op: MI.getOperand(i: 2));
4047 OutInst.setLoc(MI.getLoc());
4048 return true;
4049 } // if
4050 break;
4051 } // case C_LWSP
4052 case RISCV::C_MUL: {
4053 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4054 STI.getFeatureBits()[RISCV::FeatureStdExtZmmul] &&
4055 MI.getOperand(i: 0).isReg() &&
4056 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4057 MI.getOperand(i: 0).isReg() &&
4058 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4059 MI.getOperand(i: 2).isReg() &&
4060 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
4061 // mul $rd, $rs1, $rs2
4062 OutInst.setOpcode(RISCV::MUL);
4063 // Operand: rd
4064 OutInst.addOperand(Op: MI.getOperand(i: 0));
4065 // Operand: rs1
4066 OutInst.addOperand(Op: MI.getOperand(i: 0));
4067 // Operand: rs2
4068 OutInst.addOperand(Op: MI.getOperand(i: 2));
4069 OutInst.setLoc(MI.getLoc());
4070 return true;
4071 } // if
4072 break;
4073 } // case C_MUL
4074 case RISCV::C_MV: {
4075 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4076 MI.getOperand(i: 0).isReg() &&
4077 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4078 MI.getOperand(i: 1).isReg() &&
4079 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4080 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: 0), STI, PredicateIndex: 2 /* simm12_lo */)) {
4081 // addi $rd, $rs1, $imm12
4082 OutInst.setOpcode(RISCV::ADDI);
4083 // Operand: rd
4084 OutInst.addOperand(Op: MI.getOperand(i: 0));
4085 // Operand: rs1
4086 OutInst.addOperand(Op: MI.getOperand(i: 1));
4087 // Operand: imm12
4088 OutInst.addOperand(Op: MCOperand::createImm(Val: 0));
4089 OutInst.setLoc(MI.getLoc());
4090 return true;
4091 } // if
4092 break;
4093 } // case C_MV
4094 case RISCV::C_NOP: {
4095 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4096 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: 0), STI, PredicateIndex: 2 /* simm12_lo */)) {
4097 // addi $rd, $rs1, $imm12
4098 OutInst.setOpcode(RISCV::ADDI);
4099 // Operand: rd
4100 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
4101 // Operand: rs1
4102 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
4103 // Operand: imm12
4104 OutInst.addOperand(Op: MCOperand::createImm(Val: 0));
4105 OutInst.setLoc(MI.getLoc());
4106 return true;
4107 } // if
4108 break;
4109 } // case C_NOP
4110 case RISCV::C_NOT: {
4111 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4112 MI.getOperand(i: 0).isReg() &&
4113 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4114 MI.getOperand(i: 0).isReg() &&
4115 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4116 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: -1), STI, PredicateIndex: 2 /* simm12_lo */)) {
4117 // xori $rd, $rs1, $imm12
4118 OutInst.setOpcode(RISCV::XORI);
4119 // Operand: rd
4120 OutInst.addOperand(Op: MI.getOperand(i: 0));
4121 // Operand: rs1
4122 OutInst.addOperand(Op: MI.getOperand(i: 0));
4123 // Operand: imm12
4124 OutInst.addOperand(Op: MCOperand::createImm(Val: -1));
4125 OutInst.setLoc(MI.getLoc());
4126 return true;
4127 } // if
4128 break;
4129 } // case C_NOT
4130 case RISCV::C_OR: {
4131 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4132 MI.getOperand(i: 0).isReg() &&
4133 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4134 MI.getOperand(i: 0).isReg() &&
4135 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4136 MI.getOperand(i: 2).isReg() &&
4137 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
4138 // or $rd, $rs1, $rs2
4139 OutInst.setOpcode(RISCV::OR);
4140 // Operand: rd
4141 OutInst.addOperand(Op: MI.getOperand(i: 0));
4142 // Operand: rs1
4143 OutInst.addOperand(Op: MI.getOperand(i: 0));
4144 // Operand: rs2
4145 OutInst.addOperand(Op: MI.getOperand(i: 2));
4146 OutInst.setLoc(MI.getLoc());
4147 return true;
4148 } // if
4149 break;
4150 } // case C_OR
4151 case RISCV::C_SB: {
4152 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4153 MI.getOperand(i: 0).isReg() &&
4154 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4155 MI.getOperand(i: 1).isReg() &&
4156 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4157 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 15 /* uimm2 */) &&
4158 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4159 // sb $rs2, ${imm12}(${rs1})
4160 OutInst.setOpcode(RISCV::SB);
4161 // Operand: rs2
4162 OutInst.addOperand(Op: MI.getOperand(i: 0));
4163 // Operand: rs1
4164 OutInst.addOperand(Op: MI.getOperand(i: 1));
4165 // Operand: imm12
4166 OutInst.addOperand(Op: MI.getOperand(i: 2));
4167 OutInst.setLoc(MI.getLoc());
4168 return true;
4169 } // if
4170 break;
4171 } // case C_SB
4172 case RISCV::C_SD: {
4173 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
4174 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4175 MI.getOperand(i: 0).isReg() &&
4176 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4177 MI.getOperand(i: 1).isReg() &&
4178 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4179 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000 */) &&
4180 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4181 // sd $rs2, ${imm12}(${rs1})
4182 OutInst.setOpcode(RISCV::SD);
4183 // Operand: rs2
4184 OutInst.addOperand(Op: MI.getOperand(i: 0));
4185 // Operand: rs1
4186 OutInst.addOperand(Op: MI.getOperand(i: 1));
4187 // Operand: imm12
4188 OutInst.addOperand(Op: MI.getOperand(i: 2));
4189 OutInst.setLoc(MI.getLoc());
4190 return true;
4191 } // if
4192 break;
4193 } // case C_SD
4194 case RISCV::C_SDSP: {
4195 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
4196 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4197 MI.getOperand(i: 0).isReg() &&
4198 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4199 MI.getOperand(i: 1).isReg() &&
4200 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4201 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm9_lsb000 */) &&
4202 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4203 // sd $rs2, ${imm12}(${rs1})
4204 OutInst.setOpcode(RISCV::SD);
4205 // Operand: rs2
4206 OutInst.addOperand(Op: MI.getOperand(i: 0));
4207 // Operand: rs1
4208 OutInst.addOperand(Op: MI.getOperand(i: 1));
4209 // Operand: imm12
4210 OutInst.addOperand(Op: MI.getOperand(i: 2));
4211 OutInst.setLoc(MI.getLoc());
4212 return true;
4213 } // if
4214 break;
4215 } // case C_SDSP
4216 case RISCV::C_SDSP_RV32: {
4217 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
4218 STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
4219 STI.getFeatureBits()[RISCV::FeatureStdExtZilsd] &&
4220 MI.getOperand(i: 0).isReg() &&
4221 getRISCVMCRegisterClass(RC: RISCV::GPRPairRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4222 MI.getOperand(i: 1).isReg() &&
4223 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4224 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm9_lsb000 */) &&
4225 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4226 // sd $rs2, ${imm12}(${rs1})
4227 OutInst.setOpcode(RISCV::SD_RV32);
4228 // Operand: rs2
4229 OutInst.addOperand(Op: MI.getOperand(i: 0));
4230 // Operand: rs1
4231 OutInst.addOperand(Op: MI.getOperand(i: 1));
4232 // Operand: imm12
4233 OutInst.addOperand(Op: MI.getOperand(i: 2));
4234 OutInst.setLoc(MI.getLoc());
4235 return true;
4236 } // if
4237 break;
4238 } // case C_SDSP_RV32
4239 case RISCV::C_SD_RV32: {
4240 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
4241 STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
4242 STI.getFeatureBits()[RISCV::FeatureStdExtZilsd] &&
4243 MI.getOperand(i: 0).isReg() &&
4244 getRISCVMCRegisterClass(RC: RISCV::GPRPairCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4245 MI.getOperand(i: 1).isReg() &&
4246 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4247 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000 */) &&
4248 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4249 // sd $rs2, ${imm12}(${rs1})
4250 OutInst.setOpcode(RISCV::SD_RV32);
4251 // Operand: rs2
4252 OutInst.addOperand(Op: MI.getOperand(i: 0));
4253 // Operand: rs1
4254 OutInst.addOperand(Op: MI.getOperand(i: 1));
4255 // Operand: imm12
4256 OutInst.addOperand(Op: MI.getOperand(i: 2));
4257 OutInst.setLoc(MI.getLoc());
4258 return true;
4259 } // if
4260 break;
4261 } // case C_SD_RV32
4262 case RISCV::C_SEXT_B: {
4263 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
4264 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4265 MI.getOperand(i: 0).isReg() &&
4266 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4267 MI.getOperand(i: 0).isReg() &&
4268 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg())) {
4269 // sext.b $rd, $rs1
4270 OutInst.setOpcode(RISCV::SEXT_B);
4271 // Operand: rd
4272 OutInst.addOperand(Op: MI.getOperand(i: 0));
4273 // Operand: rs1
4274 OutInst.addOperand(Op: MI.getOperand(i: 0));
4275 OutInst.setLoc(MI.getLoc());
4276 return true;
4277 } // if
4278 break;
4279 } // case C_SEXT_B
4280 case RISCV::C_SEXT_H: {
4281 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
4282 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4283 MI.getOperand(i: 0).isReg() &&
4284 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4285 MI.getOperand(i: 0).isReg() &&
4286 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg())) {
4287 // sext.h $rd, $rs1
4288 OutInst.setOpcode(RISCV::SEXT_H);
4289 // Operand: rd
4290 OutInst.addOperand(Op: MI.getOperand(i: 0));
4291 // Operand: rs1
4292 OutInst.addOperand(Op: MI.getOperand(i: 0));
4293 OutInst.setLoc(MI.getLoc());
4294 return true;
4295 } // if
4296 break;
4297 } // case C_SEXT_H
4298 case RISCV::C_SH: {
4299 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4300 MI.getOperand(i: 0).isReg() &&
4301 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4302 MI.getOperand(i: 1).isReg() &&
4303 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4304 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 16 /* uimm2_lsb0 */) &&
4305 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4306 // sh $rs2, ${imm12}(${rs1})
4307 OutInst.setOpcode(RISCV::SH);
4308 // Operand: rs2
4309 OutInst.addOperand(Op: MI.getOperand(i: 0));
4310 // Operand: rs1
4311 OutInst.addOperand(Op: MI.getOperand(i: 1));
4312 // Operand: imm12
4313 OutInst.addOperand(Op: MI.getOperand(i: 2));
4314 OutInst.setLoc(MI.getLoc());
4315 return true;
4316 } // if
4317 break;
4318 } // case C_SH
4319 case RISCV::C_SLLI: {
4320 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4321 MI.getOperand(i: 0).isReg() &&
4322 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4323 MI.getOperand(i: 0).isReg() &&
4324 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4325 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 20 /* uimmlog2xlennonzero */) &&
4326 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 21 /* uimmlog2xlen */)) {
4327 // slli $rd, $rs1, $shamt
4328 OutInst.setOpcode(RISCV::SLLI);
4329 // Operand: rd
4330 OutInst.addOperand(Op: MI.getOperand(i: 0));
4331 // Operand: rs1
4332 OutInst.addOperand(Op: MI.getOperand(i: 0));
4333 // Operand: shamt
4334 OutInst.addOperand(Op: MI.getOperand(i: 2));
4335 OutInst.setLoc(MI.getLoc());
4336 return true;
4337 } // if
4338 break;
4339 } // case C_SLLI
4340 case RISCV::C_SRAI: {
4341 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4342 MI.getOperand(i: 0).isReg() &&
4343 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4344 MI.getOperand(i: 0).isReg() &&
4345 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4346 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 20 /* uimmlog2xlennonzero */) &&
4347 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 21 /* uimmlog2xlen */)) {
4348 // srai $rd, $rs1, $shamt
4349 OutInst.setOpcode(RISCV::SRAI);
4350 // Operand: rd
4351 OutInst.addOperand(Op: MI.getOperand(i: 0));
4352 // Operand: rs1
4353 OutInst.addOperand(Op: MI.getOperand(i: 0));
4354 // Operand: shamt
4355 OutInst.addOperand(Op: MI.getOperand(i: 2));
4356 OutInst.setLoc(MI.getLoc());
4357 return true;
4358 } // if
4359 break;
4360 } // case C_SRAI
4361 case RISCV::C_SRLI: {
4362 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4363 MI.getOperand(i: 0).isReg() &&
4364 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4365 MI.getOperand(i: 0).isReg() &&
4366 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4367 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 20 /* uimmlog2xlennonzero */) &&
4368 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 21 /* uimmlog2xlen */)) {
4369 // srli $rd, $rs1, $shamt
4370 OutInst.setOpcode(RISCV::SRLI);
4371 // Operand: rd
4372 OutInst.addOperand(Op: MI.getOperand(i: 0));
4373 // Operand: rs1
4374 OutInst.addOperand(Op: MI.getOperand(i: 0));
4375 // Operand: shamt
4376 OutInst.addOperand(Op: MI.getOperand(i: 2));
4377 OutInst.setLoc(MI.getLoc());
4378 return true;
4379 } // if
4380 break;
4381 } // case C_SRLI
4382 case RISCV::C_SSPOPCHK: {
4383 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcmop] &&
4384 STI.getFeatureBits()[RISCV::FeatureStdExtZimop] &&
4385 MI.getOperand(i: 0).isReg() &&
4386 (MI.getOperand(i: 0).getReg() == RISCV::X5)) {
4387 // sspopchk $rs1
4388 OutInst.setOpcode(RISCV::SSPOPCHK);
4389 // Operand: rs1
4390 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X5));
4391 OutInst.setLoc(MI.getLoc());
4392 return true;
4393 } // if
4394 break;
4395 } // case C_SSPOPCHK
4396 case RISCV::C_SSPUSH: {
4397 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcmop] &&
4398 STI.getFeatureBits()[RISCV::FeatureStdExtZimop] &&
4399 MI.getOperand(i: 0).isReg() &&
4400 (MI.getOperand(i: 0).getReg() == RISCV::X1)) {
4401 // sspush $rs2
4402 OutInst.setOpcode(RISCV::SSPUSH);
4403 // Operand: rs2
4404 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X1));
4405 OutInst.setLoc(MI.getLoc());
4406 return true;
4407 } // if
4408 break;
4409 } // case C_SSPUSH
4410 case RISCV::C_SUB: {
4411 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4412 MI.getOperand(i: 0).isReg() &&
4413 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4414 MI.getOperand(i: 0).isReg() &&
4415 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4416 MI.getOperand(i: 2).isReg() &&
4417 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
4418 // sub $rd, $rs1, $rs2
4419 OutInst.setOpcode(RISCV::SUB);
4420 // Operand: rd
4421 OutInst.addOperand(Op: MI.getOperand(i: 0));
4422 // Operand: rs1
4423 OutInst.addOperand(Op: MI.getOperand(i: 0));
4424 // Operand: rs2
4425 OutInst.addOperand(Op: MI.getOperand(i: 2));
4426 OutInst.setLoc(MI.getLoc());
4427 return true;
4428 } // if
4429 break;
4430 } // case C_SUB
4431 case RISCV::C_SUBW: {
4432 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
4433 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4434 MI.getOperand(i: 0).isReg() &&
4435 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4436 MI.getOperand(i: 0).isReg() &&
4437 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4438 MI.getOperand(i: 2).isReg() &&
4439 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
4440 // subw $rd, $rs1, $rs2
4441 OutInst.setOpcode(RISCV::SUBW);
4442 // Operand: rd
4443 OutInst.addOperand(Op: MI.getOperand(i: 0));
4444 // Operand: rs1
4445 OutInst.addOperand(Op: MI.getOperand(i: 0));
4446 // Operand: rs2
4447 OutInst.addOperand(Op: MI.getOperand(i: 2));
4448 OutInst.setLoc(MI.getLoc());
4449 return true;
4450 } // if
4451 break;
4452 } // case C_SUBW
4453 case RISCV::C_SW: {
4454 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4455 MI.getOperand(i: 0).isReg() &&
4456 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4457 MI.getOperand(i: 1).isReg() &&
4458 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4459 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 11 /* uimm7_lsb00 */) &&
4460 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4461 // sw $rs2, ${imm12}(${rs1})
4462 OutInst.setOpcode(RISCV::SW);
4463 // Operand: rs2
4464 OutInst.addOperand(Op: MI.getOperand(i: 0));
4465 // Operand: rs1
4466 OutInst.addOperand(Op: MI.getOperand(i: 1));
4467 // Operand: imm12
4468 OutInst.addOperand(Op: MI.getOperand(i: 2));
4469 OutInst.setLoc(MI.getLoc());
4470 return true;
4471 } // if
4472 break;
4473 } // case C_SW
4474 case RISCV::C_SWSP: {
4475 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4476 MI.getOperand(i: 0).isReg() &&
4477 getRISCVMCRegisterClass(RC: RISCV::GPRRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4478 MI.getOperand(i: 1).isReg() &&
4479 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4480 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 12 /* uimm8_lsb00 */) &&
4481 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4482 // sw $rs2, ${imm12}(${rs1})
4483 OutInst.setOpcode(RISCV::SW);
4484 // Operand: rs2
4485 OutInst.addOperand(Op: MI.getOperand(i: 0));
4486 // Operand: rs1
4487 OutInst.addOperand(Op: MI.getOperand(i: 1));
4488 // Operand: imm12
4489 OutInst.addOperand(Op: MI.getOperand(i: 2));
4490 OutInst.setLoc(MI.getLoc());
4491 return true;
4492 } // if
4493 break;
4494 } // case C_SWSP
4495 case RISCV::C_UNIMP: {
4496 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca]) {
4497 // unimp
4498 OutInst.setOpcode(RISCV::UNIMP);
4499 OutInst.setLoc(MI.getLoc());
4500 return true;
4501 } // if
4502 break;
4503 } // case C_UNIMP
4504 case RISCV::C_XOR: {
4505 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4506 MI.getOperand(i: 0).isReg() &&
4507 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4508 MI.getOperand(i: 0).isReg() &&
4509 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4510 MI.getOperand(i: 2).isReg() &&
4511 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
4512 // xor $rd, $rs1, $rs2
4513 OutInst.setOpcode(RISCV::XOR);
4514 // Operand: rd
4515 OutInst.addOperand(Op: MI.getOperand(i: 0));
4516 // Operand: rs1
4517 OutInst.addOperand(Op: MI.getOperand(i: 0));
4518 // Operand: rs2
4519 OutInst.addOperand(Op: MI.getOperand(i: 2));
4520 OutInst.setLoc(MI.getLoc());
4521 return true;
4522 } // if
4523 break;
4524 } // case C_XOR
4525 case RISCV::C_ZEXT_B: {
4526 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4527 MI.getOperand(i: 0).isReg() &&
4528 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4529 MI.getOperand(i: 0).isReg() &&
4530 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4531 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: 255), STI, PredicateIndex: 2 /* simm12_lo */)) {
4532 // andi $rd, $rs1, $imm12
4533 OutInst.setOpcode(RISCV::ANDI);
4534 // Operand: rd
4535 OutInst.addOperand(Op: MI.getOperand(i: 0));
4536 // Operand: rs1
4537 OutInst.addOperand(Op: MI.getOperand(i: 0));
4538 // Operand: imm12
4539 OutInst.addOperand(Op: MCOperand::createImm(Val: 255));
4540 OutInst.setLoc(MI.getLoc());
4541 return true;
4542 } // if
4543 break;
4544 } // case C_ZEXT_B
4545 case RISCV::C_ZEXT_H: {
4546 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
4547 STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
4548 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4549 (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] || STI.getFeatureBits()[RISCV::FeatureStdExtZbkb]) &&
4550 MI.getOperand(i: 0).isReg() &&
4551 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4552 MI.getOperand(i: 0).isReg() &&
4553 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg())) {
4554 // zext.h $rd, $rs1
4555 OutInst.setOpcode(RISCV::ZEXT_H_RV32);
4556 // Operand: rd
4557 OutInst.addOperand(Op: MI.getOperand(i: 0));
4558 // Operand: rs1
4559 OutInst.addOperand(Op: MI.getOperand(i: 0));
4560 OutInst.setLoc(MI.getLoc());
4561 return true;
4562 } // if
4563 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
4564 STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
4565 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4566 (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] || STI.getFeatureBits()[RISCV::FeatureStdExtZbkb]) &&
4567 MI.getOperand(i: 0).isReg() &&
4568 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4569 MI.getOperand(i: 0).isReg() &&
4570 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg())) {
4571 // zext.h $rd, $rs1
4572 OutInst.setOpcode(RISCV::ZEXT_H_RV64);
4573 // Operand: rd
4574 OutInst.addOperand(Op: MI.getOperand(i: 0));
4575 // Operand: rs1
4576 OutInst.addOperand(Op: MI.getOperand(i: 0));
4577 OutInst.setLoc(MI.getLoc());
4578 return true;
4579 } // if
4580 break;
4581 } // case C_ZEXT_H
4582 case RISCV::C_ZEXT_W: {
4583 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
4584 STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
4585 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4586 MI.getOperand(i: 0).isReg() &&
4587 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4588 MI.getOperand(i: 0).isReg() &&
4589 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg())) {
4590 // add.uw $rd, $rs1, $rs2
4591 OutInst.setOpcode(RISCV::ADD_UW);
4592 // Operand: rd
4593 OutInst.addOperand(Op: MI.getOperand(i: 0));
4594 // Operand: rs1
4595 OutInst.addOperand(Op: MI.getOperand(i: 0));
4596 // Operand: rs2
4597 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
4598 OutInst.setLoc(MI.getLoc());
4599 return true;
4600 } // if
4601 break;
4602 } // case C_ZEXT_W
4603 case RISCV::QC_C_BEXTI: {
4604 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
4605 STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
4606 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
4607 MI.getOperand(i: 0).isReg() &&
4608 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4609 MI.getOperand(i: 0).isReg() &&
4610 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4611 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 20 /* uimmlog2xlennonzero */) &&
4612 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 21 /* uimmlog2xlen */)) {
4613 // bexti $rd, $rs1, $shamt
4614 OutInst.setOpcode(RISCV::BEXTI);
4615 // Operand: rd
4616 OutInst.addOperand(Op: MI.getOperand(i: 0));
4617 // Operand: rs1
4618 OutInst.addOperand(Op: MI.getOperand(i: 0));
4619 // Operand: shamt
4620 OutInst.addOperand(Op: MI.getOperand(i: 2));
4621 OutInst.setLoc(MI.getLoc());
4622 return true;
4623 } // if
4624 break;
4625 } // case QC_C_BEXTI
4626 case RISCV::QC_C_BSETI: {
4627 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
4628 STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
4629 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
4630 MI.getOperand(i: 0).isReg() &&
4631 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4632 MI.getOperand(i: 0).isReg() &&
4633 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4634 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 20 /* uimmlog2xlennonzero */) &&
4635 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 21 /* uimmlog2xlen */)) {
4636 // bseti $rd, $rs1, $shamt
4637 OutInst.setOpcode(RISCV::BSETI);
4638 // Operand: rd
4639 OutInst.addOperand(Op: MI.getOperand(i: 0));
4640 // Operand: rs1
4641 OutInst.addOperand(Op: MI.getOperand(i: 0));
4642 // Operand: shamt
4643 OutInst.addOperand(Op: MI.getOperand(i: 2));
4644 OutInst.setLoc(MI.getLoc());
4645 return true;
4646 } // if
4647 break;
4648 } // case QC_C_BSETI
4649 case RISCV::QC_C_EXTU: {
4650 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
4651 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
4652 MI.getOperand(i: 0).isReg() &&
4653 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4654 MI.getOperand(i: 0).isReg() &&
4655 getRISCVMCRegisterClass(RC: RISCV::GPRNoX0RegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4656 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 22 /* uimm5ge6_plus1 */) &&
4657 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 23 /* uimm5_plus1 */) &&
4658 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: 0), STI, PredicateIndex: 24 /* uimm5 */)) {
4659 // qc.extu $rd, $rs1, $width, $shamt
4660 OutInst.setOpcode(RISCV::QC_EXTU);
4661 // Operand: rd
4662 OutInst.addOperand(Op: MI.getOperand(i: 0));
4663 // Operand: rs1
4664 OutInst.addOperand(Op: MI.getOperand(i: 0));
4665 // Operand: width
4666 OutInst.addOperand(Op: MI.getOperand(i: 2));
4667 // Operand: shamt
4668 OutInst.addOperand(Op: MCOperand::createImm(Val: 0));
4669 OutInst.setLoc(MI.getLoc());
4670 return true;
4671 } // if
4672 break;
4673 } // case QC_C_EXTU
4674 case RISCV::QC_C_MVEQZ: {
4675 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
4676 STI.getFeatureBits()[RISCV::FeatureVendorXqcicm] &&
4677 MI.getOperand(i: 0).isReg() &&
4678 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4679 MI.getOperand(i: 0).isReg() &&
4680 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4681 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: 0), STI, PredicateIndex: 25 /* simm5 */) &&
4682 MI.getOperand(i: 2).isReg() &&
4683 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 2).getReg())) {
4684 // qc.mveqi $rd, $rs1, $imm, $rs3
4685 OutInst.setOpcode(RISCV::QC_MVEQI);
4686 // Operand: rd_wb
4687 OutInst.addOperand(Op: MI.getOperand(i: 0));
4688 // Operand: rd
4689 OutInst.addOperand(Op: MI.getOperand(i: 0));
4690 // Operand: rs1
4691 OutInst.addOperand(Op: MI.getOperand(i: 0));
4692 // Operand: imm
4693 OutInst.addOperand(Op: MCOperand::createImm(Val: 0));
4694 // Operand: rs3
4695 OutInst.addOperand(Op: MI.getOperand(i: 2));
4696 OutInst.setLoc(MI.getLoc());
4697 return true;
4698 } // if
4699 break;
4700 } // case QC_C_MVEQZ
4701 case RISCV::QC_C_SYNC: {
4702 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
4703 STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
4704 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 26 /* uimm5slist */) &&
4705 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 24 /* uimm5 */)) {
4706 // qc.sync $imm5
4707 OutInst.setOpcode(RISCV::QC_SYNC);
4708 // Operand: imm5
4709 OutInst.addOperand(Op: MI.getOperand(i: 0));
4710 OutInst.setLoc(MI.getLoc());
4711 return true;
4712 } // if
4713 break;
4714 } // case QC_C_SYNC
4715 case RISCV::QC_C_SYNCR: {
4716 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
4717 STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
4718 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 26 /* uimm5slist */) &&
4719 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 24 /* uimm5 */)) {
4720 // qc.syncr $imm5
4721 OutInst.setOpcode(RISCV::QC_SYNCR);
4722 // Operand: imm5
4723 OutInst.addOperand(Op: MI.getOperand(i: 0));
4724 OutInst.setLoc(MI.getLoc());
4725 return true;
4726 } // if
4727 break;
4728 } // case QC_C_SYNCR
4729 case RISCV::QC_C_SYNCWF: {
4730 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
4731 STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
4732 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 26 /* uimm5slist */) &&
4733 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 24 /* uimm5 */)) {
4734 // qc.syncwf $imm5
4735 OutInst.setOpcode(RISCV::QC_SYNCWF);
4736 // Operand: imm5
4737 OutInst.addOperand(Op: MI.getOperand(i: 0));
4738 OutInst.setLoc(MI.getLoc());
4739 return true;
4740 } // if
4741 break;
4742 } // case QC_C_SYNCWF
4743 case RISCV::QC_C_SYNCWL: {
4744 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
4745 STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
4746 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 26 /* uimm5slist */) &&
4747 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 24 /* uimm5 */)) {
4748 // qc.syncwl $imm5
4749 OutInst.setOpcode(RISCV::QC_SYNCWL);
4750 // Operand: imm5
4751 OutInst.addOperand(Op: MI.getOperand(i: 0));
4752 OutInst.setLoc(MI.getLoc());
4753 return true;
4754 } // if
4755 break;
4756 } // case QC_C_SYNCWL
4757 case RISCV::QK_C_LBU: {
4758 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4759 MI.getOperand(i: 0).isReg() &&
4760 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4761 MI.getOperand(i: 1).isReg() &&
4762 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4763 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 24 /* uimm5 */) &&
4764 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4765 // lbu $rd, ${imm12}(${rs1})
4766 OutInst.setOpcode(RISCV::LBU);
4767 // Operand: rd
4768 OutInst.addOperand(Op: MI.getOperand(i: 0));
4769 // Operand: rs1
4770 OutInst.addOperand(Op: MI.getOperand(i: 1));
4771 // Operand: imm12
4772 OutInst.addOperand(Op: MI.getOperand(i: 2));
4773 OutInst.setLoc(MI.getLoc());
4774 return true;
4775 } // if
4776 break;
4777 } // case QK_C_LBU
4778 case RISCV::QK_C_LBUSP: {
4779 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4780 MI.getOperand(i: 0).isReg() &&
4781 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4782 MI.getOperand(i: 1).isReg() &&
4783 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4784 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 27 /* uimm4 */) &&
4785 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4786 // lbu $rd, ${imm12}(${rs1})
4787 OutInst.setOpcode(RISCV::LBU);
4788 // Operand: rd
4789 OutInst.addOperand(Op: MI.getOperand(i: 0));
4790 // Operand: rs1
4791 OutInst.addOperand(Op: MI.getOperand(i: 1));
4792 // Operand: imm12
4793 OutInst.addOperand(Op: MI.getOperand(i: 2));
4794 OutInst.setLoc(MI.getLoc());
4795 return true;
4796 } // if
4797 break;
4798 } // case QK_C_LBUSP
4799 case RISCV::QK_C_LHU: {
4800 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4801 MI.getOperand(i: 0).isReg() &&
4802 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4803 MI.getOperand(i: 1).isReg() &&
4804 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4805 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 28 /* uimm6_lsb0 */) &&
4806 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4807 // lhu $rd, ${imm12}(${rs1})
4808 OutInst.setOpcode(RISCV::LHU);
4809 // Operand: rd
4810 OutInst.addOperand(Op: MI.getOperand(i: 0));
4811 // Operand: rs1
4812 OutInst.addOperand(Op: MI.getOperand(i: 1));
4813 // Operand: imm12
4814 OutInst.addOperand(Op: MI.getOperand(i: 2));
4815 OutInst.setLoc(MI.getLoc());
4816 return true;
4817 } // if
4818 break;
4819 } // case QK_C_LHU
4820 case RISCV::QK_C_LHUSP: {
4821 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4822 MI.getOperand(i: 0).isReg() &&
4823 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4824 MI.getOperand(i: 1).isReg() &&
4825 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4826 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 29 /* uimm5_lsb0 */) &&
4827 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4828 // lhu $rd, ${imm12}(${rs1})
4829 OutInst.setOpcode(RISCV::LHU);
4830 // Operand: rd
4831 OutInst.addOperand(Op: MI.getOperand(i: 0));
4832 // Operand: rs1
4833 OutInst.addOperand(Op: MI.getOperand(i: 1));
4834 // Operand: imm12
4835 OutInst.addOperand(Op: MI.getOperand(i: 2));
4836 OutInst.setLoc(MI.getLoc());
4837 return true;
4838 } // if
4839 break;
4840 } // case QK_C_LHUSP
4841 case RISCV::QK_C_SB: {
4842 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4843 MI.getOperand(i: 0).isReg() &&
4844 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4845 MI.getOperand(i: 1).isReg() &&
4846 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4847 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 24 /* uimm5 */) &&
4848 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4849 // sb $rs2, ${imm12}(${rs1})
4850 OutInst.setOpcode(RISCV::SB);
4851 // Operand: rs2
4852 OutInst.addOperand(Op: MI.getOperand(i: 0));
4853 // Operand: rs1
4854 OutInst.addOperand(Op: MI.getOperand(i: 1));
4855 // Operand: imm12
4856 OutInst.addOperand(Op: MI.getOperand(i: 2));
4857 OutInst.setLoc(MI.getLoc());
4858 return true;
4859 } // if
4860 break;
4861 } // case QK_C_SB
4862 case RISCV::QK_C_SBSP: {
4863 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4864 MI.getOperand(i: 0).isReg() &&
4865 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4866 MI.getOperand(i: 1).isReg() &&
4867 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4868 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 27 /* uimm4 */) &&
4869 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4870 // sb $rs2, ${imm12}(${rs1})
4871 OutInst.setOpcode(RISCV::SB);
4872 // Operand: rs2
4873 OutInst.addOperand(Op: MI.getOperand(i: 0));
4874 // Operand: rs1
4875 OutInst.addOperand(Op: MI.getOperand(i: 1));
4876 // Operand: imm12
4877 OutInst.addOperand(Op: MI.getOperand(i: 2));
4878 OutInst.setLoc(MI.getLoc());
4879 return true;
4880 } // if
4881 break;
4882 } // case QK_C_SBSP
4883 case RISCV::QK_C_SH: {
4884 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4885 MI.getOperand(i: 0).isReg() &&
4886 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4887 MI.getOperand(i: 1).isReg() &&
4888 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4889 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 28 /* uimm6_lsb0 */) &&
4890 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4891 // sh $rs2, ${imm12}(${rs1})
4892 OutInst.setOpcode(RISCV::SH);
4893 // Operand: rs2
4894 OutInst.addOperand(Op: MI.getOperand(i: 0));
4895 // Operand: rs1
4896 OutInst.addOperand(Op: MI.getOperand(i: 1));
4897 // Operand: imm12
4898 OutInst.addOperand(Op: MI.getOperand(i: 2));
4899 OutInst.setLoc(MI.getLoc());
4900 return true;
4901 } // if
4902 break;
4903 } // case QK_C_SH
4904 case RISCV::QK_C_SHSP: {
4905 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4906 MI.getOperand(i: 0).isReg() &&
4907 getRISCVMCRegisterClass(RC: RISCV::GPRCRegClassID).contains(Reg: MI.getOperand(i: 0).getReg()) &&
4908 MI.getOperand(i: 1).isReg() &&
4909 getRISCVMCRegisterClass(RC: RISCV::SPRegClassID).contains(Reg: MI.getOperand(i: 1).getReg()) &&
4910 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 29 /* uimm5_lsb0 */) &&
4911 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* simm12_lo_optional */)) {
4912 // sh $rs2, ${imm12}(${rs1})
4913 OutInst.setOpcode(RISCV::SH);
4914 // Operand: rs2
4915 OutInst.addOperand(Op: MI.getOperand(i: 0));
4916 // Operand: rs1
4917 OutInst.addOperand(Op: MI.getOperand(i: 1));
4918 // Operand: imm12
4919 OutInst.addOperand(Op: MI.getOperand(i: 2));
4920 OutInst.setLoc(MI.getLoc());
4921 return true;
4922 } // if
4923 break;
4924 } // case QK_C_SHSP
4925 } // switch
4926 return false;
4927}
4928
4929#endif // GEN_UNCOMPRESS_INSTR
4930
4931#ifdef GEN_CHECK_COMPRESS_INSTR
4932#undef GEN_CHECK_COMPRESS_INSTR
4933
4934static bool RISCVValidateMachineOperand(const MachineOperand &MO,
4935 const RISCVSubtarget *Subtarget,
4936 unsigned PredicateIndex) {
4937 int64_t Imm = MO.getImm();
4938 switch (PredicateIndex) {
4939 default:
4940 llvm_unreachable("Unknown ImmLeaf Predicate kind");
4941 break;
4942 case 1: {
4943 // simm6nonzero
4944 return (Imm != 0) && isInt<6>(Imm);
4945 }
4946 case 2: {
4947 // simm6
4948 return isInt<6>(Imm);
4949 }
4950 case 3: {
4951 // simm10_lsb0000nonzero
4952 return (Imm != 0) && isShiftedInt<6, 4>(Imm);
4953 }
4954 case 4: {
4955 // uimm10_lsb00nonzero
4956 return isShiftedUInt<8, 2>(Imm) && (Imm != 0);
4957 }
4958 case 5: {
4959 // bare_simm9_lsb0
4960 return isShiftedInt<8, 1>(Imm);
4961 }
4962 case 6: {
4963 // uimmlog2xlennonzero
4964 if (Subtarget->is64Bit())
4965 return isUInt<6>(Imm) && (Imm != 0);
4966 return isUInt<5>(Imm) && (Imm != 0);
4967 }
4968 case 7: {
4969 // uimm8_lsb000
4970 return isShiftedUInt<5, 3>(Imm);
4971 }
4972 case 8: {
4973 // uimm8_lsb000_optional
4974 return isShiftedUInt<5, 3>(Imm);
4975 }
4976 case 9: {
4977 // uimm9_lsb000
4978 return isShiftedUInt<6, 3>(Imm);
4979 }
4980 case 10: {
4981 // uimm9_lsb000_optional
4982 return isShiftedUInt<6, 3>(Imm);
4983 }
4984 case 11: {
4985 // uimm7_lsb00
4986 return isShiftedUInt<5, 2>(Imm);
4987 }
4988 case 12: {
4989 // uimm7_lsb00_optional
4990 return isShiftedUInt<5, 2>(Imm);
4991 }
4992 case 13: {
4993 // uimm8_lsb00
4994 return isShiftedUInt<6, 2>(Imm);
4995 }
4996 case 14: {
4997 // uimm8_lsb00_optional
4998 return isShiftedUInt<6, 2>(Imm);
4999 }
5000 case 15: {
5001 // bare_simm12_lsb0
5002 return isShiftedInt<11, 1>(Imm);
5003 }
5004 case 16: {
5005 // uimm2
5006 return isUInt<2>(Imm);
5007 }
5008 case 17: {
5009 // uimm2_optional
5010 return isUInt<2>(Imm);
5011 }
5012 case 18: {
5013 // uimm5
5014 return isUInt<5>(Imm);
5015 }
5016 case 19: {
5017 // uimm5_optional
5018 return isUInt<5>(Imm);
5019 }
5020 case 20: {
5021 // uimm4
5022 return isUInt<4>(Imm);
5023 }
5024 case 21: {
5025 // uimm4_optional
5026 return isUInt<4>(Imm);
5027 }
5028 case 22: {
5029 // uimm2_lsb0
5030 return isShiftedUInt<1, 1>(Imm);
5031 }
5032 case 23: {
5033 // uimm2_lsb0_optional
5034 return isShiftedUInt<1, 1>(Imm);
5035 }
5036 case 24: {
5037 // uimm6_lsb0
5038 return isShiftedUInt<5, 1>(Imm);
5039 }
5040 case 25: {
5041 // uimm6_lsb0_optional
5042 return isShiftedUInt<5, 1>(Imm);
5043 }
5044 case 26: {
5045 // uimm5_lsb0
5046 return isShiftedUInt<4, 1>(Imm);
5047 }
5048 case 27: {
5049 // uimm5_lsb0_optional
5050 return isShiftedUInt<4, 1>(Imm);
5051 }
5052 case 28: {
5053 // c_lui_imm
5054 return (Imm != 0) &&
5055 (isUInt<5>(Imm) ||
5056 (Imm >= 0xfffe0 && Imm <= 0xfffff));
5057 }
5058 case 29: {
5059 // uimm5ge6_plus1
5060 return Imm >= 6 && Imm <= 32;
5061 }
5062 case 30: {
5063 // simm12_lo
5064 return isInt<12>(Imm);
5065 }
5066 case 31: {
5067 // simm5nonzero
5068 return (Imm != 0) && isInt<5>(Imm);
5069 }
5070 case 32: {
5071 // bare_simm13_lsb0
5072 return isShiftedInt<12, 1>(Imm);
5073 }
5074 case 33: {
5075 // uimm5nonzero
5076 return (Imm != 0) && isUInt<5>(Imm);
5077 }
5078 case 34: {
5079 // simm21_lsb0_jal
5080 return isShiftedInt<20, 1>(Imm);
5081 }
5082 case 35: {
5083 // simm12_lo_optional
5084 return isInt<12>(Imm);
5085 }
5086 case 36: {
5087 // simm20_li
5088 return isInt<20>(Imm);
5089 }
5090 case 37: {
5091 // uimm5slist
5092 return ((Imm == 0) ||
5093 (Imm == 1) ||
5094 (Imm == 2) ||
5095 (Imm == 4) ||
5096 (Imm == 8) ||
5097 (Imm == 16) ||
5098 (Imm == 15) ||
5099 (Imm == 31));
5100 }
5101 case 38: {
5102 // uimmlog2xlen
5103 if (Subtarget->is64Bit())
5104 return isUInt<6>(Imm);
5105 return isUInt<5>(Imm);
5106 }
5107 }
5108}
5109
5110static unsigned getCompressedSize(const MachineInstr &MI,
5111 const RISCVSubtarget &STI) {
5112 // Returns the compressed size, or zero if not compressible.
5113 switch (MI.getOpcode()) {
5114 default: return 0;
5115 case RISCV::ADD: {
5116 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5117 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5118 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5119 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5120 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()) &&
5121 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5122 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(2).getReg())) {
5123 // c.add $rs1, $rs2
5124 // Operand: rd
5125 // Operand: rs1
5126 // Operand: rs2
5127 return 2;
5128 } // if
5129 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5130 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
5131 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
5132 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5133 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(2).getReg()) &&
5134 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5135 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg())) {
5136 // c.add $rs1, $rs2
5137 // Operand: rd
5138 // Operand: rs1
5139 // Operand: rs2
5140 return 2;
5141 } // if
5142 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5143 MI.getOperand(1).isReg() &&
5144 (MI.getOperand(1).getReg() == RISCV::X0) &&
5145 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5146 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
5147 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5148 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(2).getReg())) {
5149 // c.mv $rs1, $rs2
5150 // Operand: rs1
5151 // Operand: rs2
5152 return 2;
5153 } // if
5154 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5155 MI.getOperand(2).isReg() &&
5156 (MI.getOperand(2).getReg() == RISCV::X0) &&
5157 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5158 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
5159 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5160 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg())) {
5161 // c.mv $rs1, $rs2
5162 // Operand: rs1
5163 // Operand: rs2
5164 return 2;
5165 } // if
5166 break;
5167 } // case ADD
5168 case RISCV::ADDI: {
5169 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5170 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5171 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5172 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5173 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()) &&
5174 MI.getOperand(2).isImm() &&
5175 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 1 /* simm6nonzero */) &&
5176 MI.getOperand(2).isImm() &&
5177 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5178 // c.addi $rd, $imm
5179 // Operand: rd_wb
5180 // Operand: rd
5181 // Operand: imm
5182 return 2;
5183 } // if
5184 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5185 MI.getOperand(0).isReg() &&
5186 (MI.getOperand(0).getReg() == RISCV::X2) &&
5187 MI.getOperand(1).isReg() &&
5188 (MI.getOperand(1).getReg() == RISCV::X2) &&
5189 MI.getOperand(2).isImm() &&
5190 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 3 /* simm10_lsb0000nonzero */)) {
5191 // c.addi16sp $rd, $imm
5192 // Operand: rd_wb
5193 // Operand: rd
5194 // Operand: imm
5195 return 2;
5196 } // if
5197 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5198 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5199 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
5200 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5201 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
5202 MI.getOperand(2).isImm() &&
5203 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 4 /* uimm10_lsb00nonzero */)) {
5204 // c.addi4spn $rd, $rs1, $imm
5205 // Operand: rd
5206 // Operand: rs1
5207 // Operand: imm
5208 return 2;
5209 } // if
5210 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5211 MI.getOperand(1).isReg() &&
5212 (MI.getOperand(1).getReg() == RISCV::X0) &&
5213 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5214 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
5215 MI.getOperand(2).isImm() &&
5216 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5217 // c.li $rd, $imm
5218 // Operand: rd
5219 // Operand: imm
5220 return 2;
5221 } // if
5222 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5223 MI.getOperand(2).isImm() &&
5224 (MI.getOperand(2).getImm() == 0) &&
5225 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5226 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
5227 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5228 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg())) {
5229 // c.mv $rs1, $rs2
5230 // Operand: rs1
5231 // Operand: rs2
5232 return 2;
5233 } // if
5234 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5235 MI.getOperand(0).isReg() &&
5236 (MI.getOperand(0).getReg() == RISCV::X0) &&
5237 MI.getOperand(1).isReg() &&
5238 (MI.getOperand(1).getReg() == RISCV::X0) &&
5239 MI.getOperand(2).isImm() &&
5240 (MI.getOperand(2).getImm() == 0)) {
5241 // c.nop
5242 return 2;
5243 } // if
5244 break;
5245 } // case ADDI
5246 case RISCV::ADDIW: {
5247 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5248 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5249 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5250 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5251 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5252 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()) &&
5253 MI.getOperand(2).isImm() &&
5254 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5255 // c.addiw $rd, $imm
5256 // Operand: rd_wb
5257 // Operand: rd
5258 // Operand: imm
5259 return 2;
5260 } // if
5261 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5262 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5263 MI.getOperand(1).isReg() &&
5264 (MI.getOperand(1).getReg() == RISCV::X0) &&
5265 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5266 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
5267 MI.getOperand(2).isImm() &&
5268 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5269 // c.li $rd, $imm
5270 // Operand: rd
5271 // Operand: imm
5272 return 2;
5273 } // if
5274 break;
5275 } // case ADDIW
5276 case RISCV::ADDW: {
5277 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5278 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5279 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5280 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5281 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5282 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5283 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5284 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg())) {
5285 // c.addw $rd, $rs2
5286 // Operand: rd_wb
5287 // Operand: rd
5288 // Operand: rs2
5289 return 2;
5290 } // if
5291 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5292 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5293 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
5294 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
5295 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5296 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()) &&
5297 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5298 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) {
5299 // c.addw $rd, $rs2
5300 // Operand: rd_wb
5301 // Operand: rd
5302 // Operand: rs2
5303 return 2;
5304 } // if
5305 break;
5306 } // case ADDW
5307 case RISCV::ADD_UW: {
5308 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5309 STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
5310 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5311 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5312 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5313 MI.getOperand(2).isReg() &&
5314 (MI.getOperand(2).getReg() == RISCV::X0) &&
5315 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5316 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) {
5317 // c.zext.w $rd
5318 // Operand: rd_wb
5319 // Operand: rd
5320 return 2;
5321 } // if
5322 break;
5323 } // case ADD_UW
5324 case RISCV::AND: {
5325 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5326 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5327 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5328 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5329 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5330 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5331 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg())) {
5332 // c.and $rd, $rs2
5333 // Operand: rd_wb
5334 // Operand: rd
5335 // Operand: rs2
5336 return 2;
5337 } // if
5338 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5339 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
5340 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
5341 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5342 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()) &&
5343 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5344 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) {
5345 // c.and $rd, $rs2
5346 // Operand: rd_wb
5347 // Operand: rd
5348 // Operand: rs2
5349 return 2;
5350 } // if
5351 break;
5352 } // case AND
5353 case RISCV::ANDI: {
5354 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5355 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5356 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5357 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5358 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5359 MI.getOperand(2).isImm() &&
5360 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5361 // c.andi $rs1, $imm
5362 // Operand: rd
5363 // Operand: rs1
5364 // Operand: imm
5365 return 2;
5366 } // if
5367 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5368 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5369 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5370 MI.getOperand(2).isImm() &&
5371 (MI.getOperand(2).getImm() == 255) &&
5372 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5373 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) {
5374 // c.zext.b $rd
5375 // Operand: rd_wb
5376 // Operand: rd
5377 return 2;
5378 } // if
5379 break;
5380 } // case ANDI
5381 case RISCV::BEQ: {
5382 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5383 MI.getOperand(1).isReg() &&
5384 (MI.getOperand(1).getReg() == RISCV::X0) &&
5385 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5386 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
5387 MI.getOperand(2).isImm() &&
5388 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 5 /* bare_simm9_lsb0 */)) {
5389 // c.beqz $rs1, $imm
5390 // Operand: rs1
5391 // Operand: imm
5392 return 2;
5393 } // if
5394 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5395 MI.getOperand(0).isReg() &&
5396 (MI.getOperand(0).getReg() == RISCV::X0) &&
5397 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5398 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5399 MI.getOperand(2).isImm() &&
5400 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 5 /* bare_simm9_lsb0 */)) {
5401 // c.beqz $rs1, $imm
5402 // Operand: rs1
5403 // Operand: imm
5404 return 2;
5405 } // if
5406 break;
5407 } // case BEQ
5408 case RISCV::BEXTI: {
5409 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
5410 STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
5411 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
5412 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5413 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5414 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5415 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5416 MI.getOperand(2).isImm() &&
5417 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 6 /* uimmlog2xlennonzero */)) {
5418 // qc.c.bexti $rs1, $shamt
5419 // Operand: rd
5420 // Operand: rs1
5421 // Operand: shamt
5422 return 2;
5423 } // if
5424 break;
5425 } // case BEXTI
5426 case RISCV::BNE: {
5427 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5428 MI.getOperand(1).isReg() &&
5429 (MI.getOperand(1).getReg() == RISCV::X0) &&
5430 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5431 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
5432 MI.getOperand(2).isImm() &&
5433 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 5 /* bare_simm9_lsb0 */)) {
5434 // c.bnez $rs1, $imm
5435 // Operand: rs1
5436 // Operand: imm
5437 return 2;
5438 } // if
5439 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5440 MI.getOperand(0).isReg() &&
5441 (MI.getOperand(0).getReg() == RISCV::X0) &&
5442 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5443 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5444 MI.getOperand(2).isImm() &&
5445 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 5 /* bare_simm9_lsb0 */)) {
5446 // c.bnez $rs1, $imm
5447 // Operand: rs1
5448 // Operand: imm
5449 return 2;
5450 } // if
5451 break;
5452 } // case BNE
5453 case RISCV::BSETI: {
5454 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
5455 STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
5456 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
5457 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5458 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5459 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5460 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5461 MI.getOperand(2).isImm() &&
5462 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 6 /* uimmlog2xlennonzero */)) {
5463 // qc.c.bseti $rs1, $shamt
5464 // Operand: rd
5465 // Operand: rs1
5466 // Operand: shamt
5467 return 2;
5468 } // if
5469 break;
5470 } // case BSETI
5471 case RISCV::EBREAK: {
5472 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca]) {
5473 // c.ebreak
5474 return 2;
5475 } // if
5476 break;
5477 } // case EBREAK
5478 case RISCV::FLD: {
5479 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
5480 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5481 getRISCVMCRegisterClass(RISCV::FPR64CRegClassID).contains(MI.getOperand(0).getReg()) &&
5482 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5483 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5484 MI.getOperand(2).isImm() &&
5485 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */) &&
5486 MI.getOperand(2).isImm() &&
5487 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm8_lsb000_optional */)) {
5488 // c.fld $rd, ${imm}(${rs1})
5489 // Operand: rd
5490 // Operand: rs1
5491 // Operand: imm
5492 return 2;
5493 } // if
5494 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
5495 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5496 getRISCVMCRegisterClass(RISCV::FPR64RegClassID).contains(MI.getOperand(0).getReg()) &&
5497 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5498 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
5499 MI.getOperand(2).isImm() &&
5500 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm9_lsb000 */) &&
5501 MI.getOperand(2).isImm() &&
5502 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm9_lsb000_optional */)) {
5503 // c.fldsp $rd, ${imm}(${rs1})
5504 // Operand: rd
5505 // Operand: rs1
5506 // Operand: imm
5507 return 2;
5508 } // if
5509 break;
5510 } // case FLD
5511 case RISCV::FLW: {
5512 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
5513 STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
5514 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5515 getRISCVMCRegisterClass(RISCV::FPR32CRegClassID).contains(MI.getOperand(0).getReg()) &&
5516 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5517 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5518 MI.getOperand(2).isImm() &&
5519 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 11 /* uimm7_lsb00 */) &&
5520 MI.getOperand(2).isImm() &&
5521 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 12 /* uimm7_lsb00_optional */)) {
5522 // c.flw $rd, ${imm}(${rs1})
5523 // Operand: rd
5524 // Operand: rs1
5525 // Operand: imm
5526 return 2;
5527 } // if
5528 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
5529 STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
5530 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5531 getRISCVMCRegisterClass(RISCV::FPR32RegClassID).contains(MI.getOperand(0).getReg()) &&
5532 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5533 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
5534 MI.getOperand(2).isImm() &&
5535 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 13 /* uimm8_lsb00 */) &&
5536 MI.getOperand(2).isImm() &&
5537 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 14 /* uimm8_lsb00_optional */)) {
5538 // c.flwsp $rd, ${imm}(${rs1})
5539 // Operand: rd
5540 // Operand: rs1
5541 // Operand: imm
5542 return 2;
5543 } // if
5544 break;
5545 } // case FLW
5546 case RISCV::FSD: {
5547 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
5548 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5549 getRISCVMCRegisterClass(RISCV::FPR64CRegClassID).contains(MI.getOperand(0).getReg()) &&
5550 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5551 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5552 MI.getOperand(2).isImm() &&
5553 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */) &&
5554 MI.getOperand(2).isImm() &&
5555 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm8_lsb000_optional */)) {
5556 // c.fsd $rs2, ${imm}(${rs1})
5557 // Operand: rs2
5558 // Operand: rs1
5559 // Operand: imm
5560 return 2;
5561 } // if
5562 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
5563 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5564 getRISCVMCRegisterClass(RISCV::FPR64RegClassID).contains(MI.getOperand(0).getReg()) &&
5565 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5566 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
5567 MI.getOperand(2).isImm() &&
5568 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm9_lsb000 */) &&
5569 MI.getOperand(2).isImm() &&
5570 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm9_lsb000_optional */)) {
5571 // c.fsdsp $rs2, ${imm}(${rs1})
5572 // Operand: rs2
5573 // Operand: rs1
5574 // Operand: imm
5575 return 2;
5576 } // if
5577 break;
5578 } // case FSD
5579 case RISCV::FSW: {
5580 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
5581 STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
5582 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5583 getRISCVMCRegisterClass(RISCV::FPR32CRegClassID).contains(MI.getOperand(0).getReg()) &&
5584 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5585 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5586 MI.getOperand(2).isImm() &&
5587 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 11 /* uimm7_lsb00 */) &&
5588 MI.getOperand(2).isImm() &&
5589 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 12 /* uimm7_lsb00_optional */)) {
5590 // c.fsw $rs2, ${imm}(${rs1})
5591 // Operand: rs2
5592 // Operand: rs1
5593 // Operand: imm
5594 return 2;
5595 } // if
5596 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
5597 STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
5598 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5599 getRISCVMCRegisterClass(RISCV::FPR32RegClassID).contains(MI.getOperand(0).getReg()) &&
5600 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5601 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
5602 MI.getOperand(2).isImm() &&
5603 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 13 /* uimm8_lsb00 */) &&
5604 MI.getOperand(2).isImm() &&
5605 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 14 /* uimm8_lsb00_optional */)) {
5606 // c.fswsp $rs2, ${imm}(${rs1})
5607 // Operand: rs2
5608 // Operand: rs1
5609 // Operand: imm
5610 return 2;
5611 } // if
5612 break;
5613 } // case FSW
5614 case RISCV::JAL: {
5615 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5616 MI.getOperand(0).isReg() &&
5617 (MI.getOperand(0).getReg() == RISCV::X0) &&
5618 MI.getOperand(1).isImm() &&
5619 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 15 /* bare_simm12_lsb0 */)) {
5620 // c.j $offset
5621 // Operand: offset
5622 return 2;
5623 } // if
5624 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
5625 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5626 MI.getOperand(0).isReg() &&
5627 (MI.getOperand(0).getReg() == RISCV::X1) &&
5628 MI.getOperand(1).isImm() &&
5629 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 15 /* bare_simm12_lsb0 */)) {
5630 // c.jal $offset
5631 // Operand: offset
5632 return 2;
5633 } // if
5634 break;
5635 } // case JAL
5636 case RISCV::JALR: {
5637 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5638 MI.getOperand(0).isReg() &&
5639 (MI.getOperand(0).getReg() == RISCV::X1) &&
5640 MI.getOperand(2).isImm() &&
5641 (MI.getOperand(2).getImm() == 0) &&
5642 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5643 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg())) {
5644 // c.jalr $rs1
5645 // Operand: rs1
5646 return 2;
5647 } // if
5648 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5649 MI.getOperand(0).isReg() &&
5650 (MI.getOperand(0).getReg() == RISCV::X0) &&
5651 MI.getOperand(2).isImm() &&
5652 (MI.getOperand(2).getImm() == 0) &&
5653 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5654 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg())) {
5655 // c.jr $rs1
5656 // Operand: rs1
5657 return 2;
5658 } // if
5659 break;
5660 } // case JALR
5661 case RISCV::LBU: {
5662 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5663 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5664 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
5665 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5666 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5667 MI.getOperand(2).isImm() &&
5668 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 16 /* uimm2 */) &&
5669 MI.getOperand(2).isImm() &&
5670 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 17 /* uimm2_optional */)) {
5671 // c.lbu $rd, ${imm}(${rs1})
5672 // Operand: rd
5673 // Operand: rs1
5674 // Operand: imm
5675 return 2;
5676 } // if
5677 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
5678 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5679 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
5680 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5681 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5682 MI.getOperand(2).isImm() &&
5683 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 18 /* uimm5 */) &&
5684 MI.getOperand(2).isImm() &&
5685 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 19 /* uimm5_optional */)) {
5686 // qk.c.lbu $rd, ${imm}(${rs1})
5687 // Operand: rd
5688 // Operand: rs1
5689 // Operand: imm
5690 return 2;
5691 } // if
5692 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
5693 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5694 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
5695 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5696 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
5697 MI.getOperand(2).isImm() &&
5698 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* uimm4 */) &&
5699 MI.getOperand(2).isImm() &&
5700 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 21 /* uimm4_optional */)) {
5701 // qk.c.lbusp $rd_rs2, ${imm}(${rs1})
5702 // Operand: rd_rs2
5703 // Operand: rs1
5704 // Operand: imm
5705 return 2;
5706 } // if
5707 break;
5708 } // case LBU
5709 case RISCV::LD: {
5710 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5711 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5712 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5713 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
5714 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5715 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5716 MI.getOperand(2).isImm() &&
5717 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */) &&
5718 MI.getOperand(2).isImm() &&
5719 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm8_lsb000_optional */)) {
5720 // c.ld $rd, ${imm}(${rs1})
5721 // Operand: rd
5722 // Operand: rs1
5723 // Operand: imm
5724 return 2;
5725 } // if
5726 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5727 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5728 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5729 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
5730 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5731 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
5732 MI.getOperand(2).isImm() &&
5733 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm9_lsb000 */) &&
5734 MI.getOperand(2).isImm() &&
5735 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm9_lsb000_optional */)) {
5736 // c.ldsp $rd, ${imm}(${rs1})
5737 // Operand: rd
5738 // Operand: rs1
5739 // Operand: imm
5740 return 2;
5741 } // if
5742 break;
5743 } // case LD
5744 case RISCV::LD_RV32: {
5745 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
5746 STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
5747 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5748 getRISCVMCRegisterClass(RISCV::GPRPairNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
5749 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5750 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
5751 MI.getOperand(2).isImm() &&
5752 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm9_lsb000 */) &&
5753 MI.getOperand(2).isImm() &&
5754 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm9_lsb000_optional */)) {
5755 // c.ldsp $rd, ${imm}(${rs1})
5756 // Operand: rd
5757 // Operand: rs1
5758 // Operand: imm
5759 return 2;
5760 } // if
5761 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
5762 STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
5763 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5764 getRISCVMCRegisterClass(RISCV::GPRPairCRegClassID).contains(MI.getOperand(0).getReg()) &&
5765 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5766 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5767 MI.getOperand(2).isImm() &&
5768 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */) &&
5769 MI.getOperand(2).isImm() &&
5770 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm8_lsb000_optional */)) {
5771 // c.ld $rd, ${imm}(${rs1})
5772 // Operand: rd
5773 // Operand: rs1
5774 // Operand: imm
5775 return 2;
5776 } // if
5777 break;
5778 } // case LD_RV32
5779 case RISCV::LH: {
5780 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5781 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5782 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
5783 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5784 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5785 MI.getOperand(2).isImm() &&
5786 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* uimm2_lsb0 */) &&
5787 MI.getOperand(2).isImm() &&
5788 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 23 /* uimm2_lsb0_optional */)) {
5789 // c.lh $rd, ${imm}(${rs1})
5790 // Operand: rd
5791 // Operand: rs1
5792 // Operand: imm
5793 return 2;
5794 } // if
5795 break;
5796 } // case LH
5797 case RISCV::LHU: {
5798 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5799 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5800 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
5801 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5802 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5803 MI.getOperand(2).isImm() &&
5804 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* uimm2_lsb0 */) &&
5805 MI.getOperand(2).isImm() &&
5806 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 23 /* uimm2_lsb0_optional */)) {
5807 // c.lhu $rd, ${imm}(${rs1})
5808 // Operand: rd
5809 // Operand: rs1
5810 // Operand: imm
5811 return 2;
5812 } // if
5813 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
5814 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5815 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
5816 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5817 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5818 MI.getOperand(2).isImm() &&
5819 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 24 /* uimm6_lsb0 */) &&
5820 MI.getOperand(2).isImm() &&
5821 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 25 /* uimm6_lsb0_optional */)) {
5822 // qk.c.lhu $rd, ${imm}(${rs1})
5823 // Operand: rd
5824 // Operand: rs1
5825 // Operand: imm
5826 return 2;
5827 } // if
5828 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
5829 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5830 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
5831 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5832 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
5833 MI.getOperand(2).isImm() &&
5834 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 26 /* uimm5_lsb0 */) &&
5835 MI.getOperand(2).isImm() &&
5836 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 27 /* uimm5_lsb0_optional */)) {
5837 // qk.c.lhusp $rd_rs2, ${imm}(${rs1})
5838 // Operand: rd_rs2
5839 // Operand: rs1
5840 // Operand: imm
5841 return 2;
5842 } // if
5843 break;
5844 } // case LHU
5845 case RISCV::LH_INX: {
5846 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5847 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5848 getRISCVMCRegisterClass(RISCV::GPRF16CRegClassID).contains(MI.getOperand(0).getReg()) &&
5849 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5850 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5851 MI.getOperand(2).isImm() &&
5852 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* uimm2_lsb0 */) &&
5853 MI.getOperand(2).isImm() &&
5854 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 23 /* uimm2_lsb0_optional */)) {
5855 // c.lh $rd, ${imm}(${rs1})
5856 // Operand: rd
5857 // Operand: rs1
5858 // Operand: imm
5859 return 2;
5860 } // if
5861 break;
5862 } // case LH_INX
5863 case RISCV::LUI: {
5864 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5865 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5866 getRISCVMCRegisterClass(RISCV::GPRNoX0X2RegClassID).contains(MI.getOperand(0).getReg()) &&
5867 MI.getOperand(1).isImm() &&
5868 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 28 /* c_lui_imm */)) {
5869 // c.lui $rd, $imm
5870 // Operand: rd
5871 // Operand: imm
5872 return 2;
5873 } // if
5874 break;
5875 } // case LUI
5876 case RISCV::LW: {
5877 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5878 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5879 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
5880 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5881 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5882 MI.getOperand(2).isImm() &&
5883 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 11 /* uimm7_lsb00 */) &&
5884 MI.getOperand(2).isImm() &&
5885 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 12 /* uimm7_lsb00_optional */)) {
5886 // c.lw $rd, ${imm}(${rs1})
5887 // Operand: rd
5888 // Operand: rs1
5889 // Operand: imm
5890 return 2;
5891 } // if
5892 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5893 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5894 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
5895 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5896 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
5897 MI.getOperand(2).isImm() &&
5898 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 13 /* uimm8_lsb00 */) &&
5899 MI.getOperand(2).isImm() &&
5900 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 14 /* uimm8_lsb00_optional */)) {
5901 // c.lwsp $rd, ${imm}(${rs1})
5902 // Operand: rd
5903 // Operand: rs1
5904 // Operand: imm
5905 return 2;
5906 } // if
5907 break;
5908 } // case LW
5909 case RISCV::LW_INX: {
5910 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5911 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5912 getRISCVMCRegisterClass(RISCV::GPRF32NoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
5913 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5914 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
5915 MI.getOperand(2).isImm() &&
5916 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 13 /* uimm8_lsb00 */) &&
5917 MI.getOperand(2).isImm() &&
5918 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 14 /* uimm8_lsb00_optional */)) {
5919 // c.lwsp $rd, ${imm}(${rs1})
5920 // Operand: rd
5921 // Operand: rs1
5922 // Operand: imm
5923 return 2;
5924 } // if
5925 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5926 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5927 getRISCVMCRegisterClass(RISCV::GPRF32CRegClassID).contains(MI.getOperand(0).getReg()) &&
5928 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5929 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5930 MI.getOperand(2).isImm() &&
5931 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 11 /* uimm7_lsb00 */) &&
5932 MI.getOperand(2).isImm() &&
5933 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 12 /* uimm7_lsb00_optional */)) {
5934 // c.lw $rd, ${imm}(${rs1})
5935 // Operand: rd
5936 // Operand: rs1
5937 // Operand: imm
5938 return 2;
5939 } // if
5940 break;
5941 } // case LW_INX
5942 case RISCV::MUL: {
5943 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5944 STI.getFeatureBits()[RISCV::FeatureStdExtZmmul] &&
5945 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5946 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5947 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5948 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5949 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5950 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg())) {
5951 // c.mul $rd, $rs2
5952 // Operand: rd_wb
5953 // Operand: rd
5954 // Operand: rs2
5955 return 2;
5956 } // if
5957 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5958 STI.getFeatureBits()[RISCV::FeatureStdExtZmmul] &&
5959 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
5960 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
5961 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5962 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()) &&
5963 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5964 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) {
5965 // c.mul $rd, $rs2
5966 // Operand: rd_wb
5967 // Operand: rd
5968 // Operand: rs2
5969 return 2;
5970 } // if
5971 break;
5972 } // case MUL
5973 case RISCV::OR: {
5974 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5975 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5976 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5977 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5978 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
5979 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5980 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg())) {
5981 // c.or $rd, $rs2
5982 // Operand: rd_wb
5983 // Operand: rd
5984 // Operand: rs2
5985 return 2;
5986 } // if
5987 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5988 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
5989 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
5990 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5991 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()) &&
5992 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5993 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) {
5994 // c.or $rd, $rs2
5995 // Operand: rd_wb
5996 // Operand: rd
5997 // Operand: rs2
5998 return 2;
5999 } // if
6000 break;
6001 } // case OR
6002 case RISCV::QC_EXTU: {
6003 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6004 STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
6005 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
6006 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6007 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6008 MI.getOperand(2).isImm() &&
6009 (MI.getOperand(2).getImm() == 1) &&
6010 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6011 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
6012 MI.getOperand(3).isImm() &&
6013 RISCVValidateMachineOperand(MI.getOperand(3), &STI, 6 /* uimmlog2xlennonzero */)) {
6014 // qc.c.bexti $rs1, $shamt
6015 // Operand: rd
6016 // Operand: rs1
6017 // Operand: shamt
6018 return 2;
6019 } // if
6020 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6021 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
6022 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6023 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6024 MI.getOperand(3).isImm() &&
6025 (MI.getOperand(3).getImm() == 0) &&
6026 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6027 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()) &&
6028 MI.getOperand(2).isImm() &&
6029 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 29 /* uimm5ge6_plus1 */)) {
6030 // qc.c.extu $rd, $width
6031 // Operand: rd_wb
6032 // Operand: rd
6033 // Operand: width
6034 return 2;
6035 } // if
6036 break;
6037 } // case QC_EXTU
6038 case RISCV::QC_E_ADDAI: {
6039 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6040 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6041 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6042 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6043 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6044 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6045 MI.getOperand(2).isImm() &&
6046 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 30 /* simm12_lo */)) {
6047 // addi $rd, $rs1, $imm12
6048 // Operand: rd
6049 // Operand: rs1
6050 // Operand: imm12
6051 return 4;
6052 } // if
6053 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6054 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6055 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6056 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6057 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6058 MI.getOperand(2).isImm() &&
6059 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 1 /* simm6nonzero */) &&
6060 MI.getOperand(2).isImm() &&
6061 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
6062 // c.addi $rd, $imm
6063 // Operand: rd_wb
6064 // Operand: rd
6065 // Operand: imm
6066 return 2;
6067 } // if
6068 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6069 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6070 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6071 MI.getOperand(0).isReg() &&
6072 (MI.getOperand(0).getReg() == RISCV::X2) &&
6073 MI.getOperand(1).isReg() &&
6074 (MI.getOperand(1).getReg() == RISCV::X2) &&
6075 MI.getOperand(2).isImm() &&
6076 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 3 /* simm10_lsb0000nonzero */)) {
6077 // c.addi16sp $rd, $imm
6078 // Operand: rd_wb
6079 // Operand: rd
6080 // Operand: imm
6081 return 2;
6082 } // if
6083 break;
6084 } // case QC_E_ADDAI
6085 case RISCV::QC_E_ADDI: {
6086 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6087 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6088 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6089 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6090 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6091 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()) &&
6092 MI.getOperand(2).isImm() &&
6093 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 30 /* simm12_lo */)) {
6094 // addi $rd, $rs1, $imm12
6095 // Operand: rd
6096 // Operand: rs1
6097 // Operand: imm12
6098 return 4;
6099 } // if
6100 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6101 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6102 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6103 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6104 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6105 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6106 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()) &&
6107 MI.getOperand(2).isImm() &&
6108 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 1 /* simm6nonzero */) &&
6109 MI.getOperand(2).isImm() &&
6110 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
6111 // c.addi $rd, $imm
6112 // Operand: rd_wb
6113 // Operand: rd
6114 // Operand: imm
6115 return 2;
6116 } // if
6117 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6118 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6119 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6120 MI.getOperand(0).isReg() &&
6121 (MI.getOperand(0).getReg() == RISCV::X2) &&
6122 MI.getOperand(1).isReg() &&
6123 (MI.getOperand(1).getReg() == RISCV::X2) &&
6124 MI.getOperand(2).isImm() &&
6125 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 3 /* simm10_lsb0000nonzero */)) {
6126 // c.addi16sp $rd, $imm
6127 // Operand: rd_wb
6128 // Operand: rd
6129 // Operand: imm
6130 return 2;
6131 } // if
6132 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6133 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6134 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6135 MI.getOperand(2).isImm() &&
6136 (MI.getOperand(2).getImm() == 0) &&
6137 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6138 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6139 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6140 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg())) {
6141 // c.mv $rs1, $rs2
6142 // Operand: rs1
6143 // Operand: rs2
6144 return 2;
6145 } // if
6146 break;
6147 } // case QC_E_ADDI
6148 case RISCV::QC_E_ANDAI: {
6149 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6150 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6151 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6152 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6153 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6154 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6155 MI.getOperand(2).isImm() &&
6156 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 30 /* simm12_lo */)) {
6157 // andi $rd, $rs1, $imm12
6158 // Operand: rd
6159 // Operand: rs1
6160 // Operand: imm12
6161 return 4;
6162 } // if
6163 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6164 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6165 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6166 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6167 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
6168 MI.getOperand(2).isImm() &&
6169 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
6170 // c.andi $rs1, $imm
6171 // Operand: rd
6172 // Operand: rs1
6173 // Operand: imm
6174 return 2;
6175 } // if
6176 break;
6177 } // case QC_E_ANDAI
6178 case RISCV::QC_E_ANDI: {
6179 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6180 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6181 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6182 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6183 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6184 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()) &&
6185 MI.getOperand(2).isImm() &&
6186 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 30 /* simm12_lo */)) {
6187 // andi $rd, $rs1, $imm12
6188 // Operand: rd
6189 // Operand: rs1
6190 // Operand: imm12
6191 return 4;
6192 } // if
6193 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6194 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6195 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6196 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6197 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6198 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6199 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
6200 MI.getOperand(2).isImm() &&
6201 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
6202 // c.andi $rs1, $imm
6203 // Operand: rd
6204 // Operand: rs1
6205 // Operand: imm
6206 return 2;
6207 } // if
6208 break;
6209 } // case QC_E_ANDI
6210 case RISCV::QC_E_BEQI: {
6211 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6212 STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
6213 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6214 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6215 MI.getOperand(1).isImm() &&
6216 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 31 /* simm5nonzero */) &&
6217 MI.getOperand(2).isImm() &&
6218 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 32 /* bare_simm13_lsb0 */)) {
6219 // qc.beqi $rs1, $rs2, $imm12
6220 // Operand: rs1
6221 // Operand: rs2
6222 // Operand: imm12
6223 return 4;
6224 } // if
6225 break;
6226 } // case QC_E_BEQI
6227 case RISCV::QC_E_BGEI: {
6228 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6229 STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
6230 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6231 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6232 MI.getOperand(1).isImm() &&
6233 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 31 /* simm5nonzero */) &&
6234 MI.getOperand(2).isImm() &&
6235 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 32 /* bare_simm13_lsb0 */)) {
6236 // qc.bgei $rs1, $rs2, $imm12
6237 // Operand: rs1
6238 // Operand: rs2
6239 // Operand: imm12
6240 return 4;
6241 } // if
6242 break;
6243 } // case QC_E_BGEI
6244 case RISCV::QC_E_BGEUI: {
6245 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6246 STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
6247 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6248 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6249 MI.getOperand(1).isImm() &&
6250 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 33 /* uimm5nonzero */) &&
6251 MI.getOperand(2).isImm() &&
6252 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 32 /* bare_simm13_lsb0 */)) {
6253 // qc.bgeui $rs1, $rs2, $imm12
6254 // Operand: rs1
6255 // Operand: rs2
6256 // Operand: imm12
6257 return 4;
6258 } // if
6259 break;
6260 } // case QC_E_BGEUI
6261 case RISCV::QC_E_BLTI: {
6262 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6263 STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
6264 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6265 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6266 MI.getOperand(1).isImm() &&
6267 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 31 /* simm5nonzero */) &&
6268 MI.getOperand(2).isImm() &&
6269 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 32 /* bare_simm13_lsb0 */)) {
6270 // qc.blti $rs1, $rs2, $imm12
6271 // Operand: rs1
6272 // Operand: rs2
6273 // Operand: imm12
6274 return 4;
6275 } // if
6276 break;
6277 } // case QC_E_BLTI
6278 case RISCV::QC_E_BLTUI: {
6279 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6280 STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
6281 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6282 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6283 MI.getOperand(1).isImm() &&
6284 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 33 /* uimm5nonzero */) &&
6285 MI.getOperand(2).isImm() &&
6286 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 32 /* bare_simm13_lsb0 */)) {
6287 // qc.bltui $rs1, $rs2, $imm12
6288 // Operand: rs1
6289 // Operand: rs2
6290 // Operand: imm12
6291 return 4;
6292 } // if
6293 break;
6294 } // case QC_E_BLTUI
6295 case RISCV::QC_E_BNEI: {
6296 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6297 STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
6298 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6299 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6300 MI.getOperand(1).isImm() &&
6301 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 31 /* simm5nonzero */) &&
6302 MI.getOperand(2).isImm() &&
6303 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 32 /* bare_simm13_lsb0 */)) {
6304 // qc.bnei $rs1, $rs2, $imm12
6305 // Operand: rs1
6306 // Operand: rs2
6307 // Operand: imm12
6308 return 4;
6309 } // if
6310 break;
6311 } // case QC_E_BNEI
6312 case RISCV::QC_E_J: {
6313 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6314 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6315 STI.getFeatureBits()[RISCV::FeatureVendorXqcilb] &&
6316 MI.getOperand(0).isImm() &&
6317 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 15 /* bare_simm12_lsb0 */)) {
6318 // c.j $offset
6319 // Operand: offset
6320 return 2;
6321 } // if
6322 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6323 STI.getFeatureBits()[RISCV::FeatureVendorXqcilb] &&
6324 MI.getOperand(0).isImm() &&
6325 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 34 /* simm21_lsb0_jal */)) {
6326 // jal $rd, $imm20
6327 // Operand: rd
6328 // Operand: imm20
6329 return 4;
6330 } // if
6331 break;
6332 } // case QC_E_J
6333 case RISCV::QC_E_JAL: {
6334 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6335 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6336 STI.getFeatureBits()[RISCV::FeatureVendorXqcilb] &&
6337 MI.getOperand(0).isImm() &&
6338 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 15 /* bare_simm12_lsb0 */)) {
6339 // c.jal $offset
6340 // Operand: offset
6341 return 2;
6342 } // if
6343 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6344 STI.getFeatureBits()[RISCV::FeatureVendorXqcilb] &&
6345 MI.getOperand(0).isImm() &&
6346 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 34 /* simm21_lsb0_jal */)) {
6347 // jal $rd, $imm20
6348 // Operand: rd
6349 // Operand: imm20
6350 return 4;
6351 } // if
6352 break;
6353 } // case QC_E_JAL
6354 case RISCV::QC_E_LB: {
6355 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6356 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6357 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6358 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg()) &&
6359 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6360 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg()) &&
6361 MI.getOperand(2).isImm() &&
6362 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 30 /* simm12_lo */) &&
6363 MI.getOperand(2).isImm() &&
6364 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 35 /* simm12_lo_optional */)) {
6365 // lb $rd, ${imm12}(${rs1})
6366 // Operand: rd
6367 // Operand: rs1
6368 // Operand: imm12
6369 return 4;
6370 } // if
6371 break;
6372 } // case QC_E_LB
6373 case RISCV::QC_E_LBU: {
6374 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6375 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6376 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6377 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6378 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
6379 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6380 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
6381 MI.getOperand(2).isImm() &&
6382 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 16 /* uimm2 */) &&
6383 MI.getOperand(2).isImm() &&
6384 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 17 /* uimm2_optional */)) {
6385 // c.lbu $rd, ${imm}(${rs1})
6386 // Operand: rd
6387 // Operand: rs1
6388 // Operand: imm
6389 return 2;
6390 } // if
6391 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6392 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6393 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6394 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg()) &&
6395 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6396 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg()) &&
6397 MI.getOperand(2).isImm() &&
6398 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 30 /* simm12_lo */) &&
6399 MI.getOperand(2).isImm() &&
6400 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 35 /* simm12_lo_optional */)) {
6401 // lbu $rd, ${imm12}(${rs1})
6402 // Operand: rd
6403 // Operand: rs1
6404 // Operand: imm12
6405 return 4;
6406 } // if
6407 break;
6408 } // case QC_E_LBU
6409 case RISCV::QC_E_LH: {
6410 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6411 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6412 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6413 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6414 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
6415 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6416 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
6417 MI.getOperand(2).isImm() &&
6418 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* uimm2_lsb0 */) &&
6419 MI.getOperand(2).isImm() &&
6420 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 23 /* uimm2_lsb0_optional */)) {
6421 // c.lh $rd, ${imm}(${rs1})
6422 // Operand: rd
6423 // Operand: rs1
6424 // Operand: imm
6425 return 2;
6426 } // if
6427 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6428 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6429 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6430 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg()) &&
6431 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6432 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg()) &&
6433 MI.getOperand(2).isImm() &&
6434 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 30 /* simm12_lo */) &&
6435 MI.getOperand(2).isImm() &&
6436 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 35 /* simm12_lo_optional */)) {
6437 // lh $rd, ${imm12}(${rs1})
6438 // Operand: rd
6439 // Operand: rs1
6440 // Operand: imm12
6441 return 4;
6442 } // if
6443 break;
6444 } // case QC_E_LH
6445 case RISCV::QC_E_LHU: {
6446 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6447 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6448 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6449 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6450 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
6451 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6452 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
6453 MI.getOperand(2).isImm() &&
6454 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* uimm2_lsb0 */) &&
6455 MI.getOperand(2).isImm() &&
6456 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 23 /* uimm2_lsb0_optional */)) {
6457 // c.lhu $rd, ${imm}(${rs1})
6458 // Operand: rd
6459 // Operand: rs1
6460 // Operand: imm
6461 return 2;
6462 } // if
6463 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6464 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6465 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6466 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg()) &&
6467 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6468 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg()) &&
6469 MI.getOperand(2).isImm() &&
6470 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 30 /* simm12_lo */) &&
6471 MI.getOperand(2).isImm() &&
6472 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 35 /* simm12_lo_optional */)) {
6473 // lhu $rd, ${imm12}(${rs1})
6474 // Operand: rd
6475 // Operand: rs1
6476 // Operand: imm12
6477 return 4;
6478 } // if
6479 break;
6480 } // case QC_E_LHU
6481 case RISCV::QC_E_LI: {
6482 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6483 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6484 STI.getFeatureBits()[RISCV::FeatureVendorXqcili] &&
6485 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6486 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6487 MI.getOperand(1).isImm() &&
6488 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 2 /* simm6 */)) {
6489 // c.li $rd, $imm
6490 // Operand: rd
6491 // Operand: imm
6492 return 2;
6493 } // if
6494 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6495 STI.getFeatureBits()[RISCV::FeatureVendorXqcili] &&
6496 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6497 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6498 MI.getOperand(1).isImm() &&
6499 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 36 /* simm20_li */)) {
6500 // qc.li $rd, $imm20
6501 // Operand: rd
6502 // Operand: imm20
6503 return 4;
6504 } // if
6505 break;
6506 } // case QC_E_LI
6507 case RISCV::QC_E_LW: {
6508 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6509 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6510 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6511 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6512 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
6513 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6514 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
6515 MI.getOperand(2).isImm() &&
6516 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 11 /* uimm7_lsb00 */) &&
6517 MI.getOperand(2).isImm() &&
6518 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 12 /* uimm7_lsb00_optional */)) {
6519 // c.lw $rd, ${imm}(${rs1})
6520 // Operand: rd
6521 // Operand: rs1
6522 // Operand: imm
6523 return 2;
6524 } // if
6525 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6526 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6527 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6528 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6529 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6530 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6531 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
6532 MI.getOperand(2).isImm() &&
6533 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 13 /* uimm8_lsb00 */) &&
6534 MI.getOperand(2).isImm() &&
6535 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 14 /* uimm8_lsb00_optional */)) {
6536 // c.lwsp $rd, ${imm}(${rs1})
6537 // Operand: rd
6538 // Operand: rs1
6539 // Operand: imm
6540 return 2;
6541 } // if
6542 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6543 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6544 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6545 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg()) &&
6546 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6547 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg()) &&
6548 MI.getOperand(2).isImm() &&
6549 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 30 /* simm12_lo */) &&
6550 MI.getOperand(2).isImm() &&
6551 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 35 /* simm12_lo_optional */)) {
6552 // lw $rd, ${imm12}(${rs1})
6553 // Operand: rd
6554 // Operand: rs1
6555 // Operand: imm12
6556 return 4;
6557 } // if
6558 break;
6559 } // case QC_E_LW
6560 case RISCV::QC_E_ORAI: {
6561 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6562 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6563 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6564 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6565 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6566 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6567 MI.getOperand(2).isImm() &&
6568 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 30 /* simm12_lo */)) {
6569 // ori $rd, $rs1, $imm12
6570 // Operand: rd
6571 // Operand: rs1
6572 // Operand: imm12
6573 return 4;
6574 } // if
6575 break;
6576 } // case QC_E_ORAI
6577 case RISCV::QC_E_ORI: {
6578 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6579 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6580 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6581 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6582 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6583 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()) &&
6584 MI.getOperand(2).isImm() &&
6585 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 30 /* simm12_lo */)) {
6586 // ori $rd, $rs1, $imm12
6587 // Operand: rd
6588 // Operand: rs1
6589 // Operand: imm12
6590 return 4;
6591 } // if
6592 break;
6593 } // case QC_E_ORI
6594 case RISCV::QC_E_SB: {
6595 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6596 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6597 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6598 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6599 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
6600 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6601 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
6602 MI.getOperand(2).isImm() &&
6603 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 16 /* uimm2 */) &&
6604 MI.getOperand(2).isImm() &&
6605 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 17 /* uimm2_optional */)) {
6606 // c.sb $rs2, ${imm}(${rs1})
6607 // Operand: rs2
6608 // Operand: rs1
6609 // Operand: imm
6610 return 2;
6611 } // if
6612 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6613 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6614 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6615 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg()) &&
6616 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6617 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg()) &&
6618 MI.getOperand(2).isImm() &&
6619 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 30 /* simm12_lo */) &&
6620 MI.getOperand(2).isImm() &&
6621 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 35 /* simm12_lo_optional */)) {
6622 // sb $rs2, ${imm12}(${rs1})
6623 // Operand: rs2
6624 // Operand: rs1
6625 // Operand: imm12
6626 return 4;
6627 } // if
6628 break;
6629 } // case QC_E_SB
6630 case RISCV::QC_E_SH: {
6631 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6632 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6633 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6634 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6635 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
6636 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6637 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
6638 MI.getOperand(2).isImm() &&
6639 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* uimm2_lsb0 */) &&
6640 MI.getOperand(2).isImm() &&
6641 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 23 /* uimm2_lsb0_optional */)) {
6642 // c.sh $rs2, ${imm}(${rs1})
6643 // Operand: rs2
6644 // Operand: rs1
6645 // Operand: imm
6646 return 2;
6647 } // if
6648 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6649 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6650 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6651 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg()) &&
6652 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6653 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg()) &&
6654 MI.getOperand(2).isImm() &&
6655 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 30 /* simm12_lo */) &&
6656 MI.getOperand(2).isImm() &&
6657 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 35 /* simm12_lo_optional */)) {
6658 // sh $rs2, ${imm12}(${rs1})
6659 // Operand: rs2
6660 // Operand: rs1
6661 // Operand: imm12
6662 return 4;
6663 } // if
6664 break;
6665 } // case QC_E_SH
6666 case RISCV::QC_E_SW: {
6667 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6668 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6669 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6670 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6671 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
6672 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6673 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
6674 MI.getOperand(2).isImm() &&
6675 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 11 /* uimm7_lsb00 */) &&
6676 MI.getOperand(2).isImm() &&
6677 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 12 /* uimm7_lsb00_optional */)) {
6678 // c.sw $rs2, ${imm}(${rs1})
6679 // Operand: rs2
6680 // Operand: rs1
6681 // Operand: imm
6682 return 2;
6683 } // if
6684 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6685 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6686 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6687 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6688 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg()) &&
6689 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6690 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
6691 MI.getOperand(2).isImm() &&
6692 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 13 /* uimm8_lsb00 */) &&
6693 MI.getOperand(2).isImm() &&
6694 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 14 /* uimm8_lsb00_optional */)) {
6695 // c.swsp $rs2, ${imm}(${rs1})
6696 // Operand: rs2
6697 // Operand: rs1
6698 // Operand: imm
6699 return 2;
6700 } // if
6701 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6702 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6703 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6704 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg()) &&
6705 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6706 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg()) &&
6707 MI.getOperand(2).isImm() &&
6708 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 30 /* simm12_lo */) &&
6709 MI.getOperand(2).isImm() &&
6710 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 35 /* simm12_lo_optional */)) {
6711 // sw $rs2, ${imm12}(${rs1})
6712 // Operand: rs2
6713 // Operand: rs1
6714 // Operand: imm12
6715 return 4;
6716 } // if
6717 break;
6718 } // case QC_E_SW
6719 case RISCV::QC_E_XORAI: {
6720 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6721 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6722 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6723 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6724 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6725 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6726 MI.getOperand(2).isImm() &&
6727 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 30 /* simm12_lo */)) {
6728 // xori $rd, $rs1, $imm12
6729 // Operand: rd
6730 // Operand: rs1
6731 // Operand: imm12
6732 return 4;
6733 } // if
6734 break;
6735 } // case QC_E_XORAI
6736 case RISCV::QC_E_XORI: {
6737 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6738 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6739 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6740 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6741 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6742 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()) &&
6743 MI.getOperand(2).isImm() &&
6744 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 30 /* simm12_lo */)) {
6745 // xori $rd, $rs1, $imm12
6746 // Operand: rd
6747 // Operand: rs1
6748 // Operand: imm12
6749 return 4;
6750 } // if
6751 break;
6752 } // case QC_E_XORI
6753 case RISCV::QC_LI: {
6754 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6755 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6756 STI.getFeatureBits()[RISCV::FeatureVendorXqcili] &&
6757 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6758 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg()) &&
6759 MI.getOperand(1).isImm() &&
6760 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 2 /* simm6 */)) {
6761 // c.li $rd, $imm
6762 // Operand: rd
6763 // Operand: imm
6764 return 2;
6765 } // if
6766 break;
6767 } // case QC_LI
6768 case RISCV::QC_MULIADD: {
6769 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6770 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
6771 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6772 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
6773 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6774 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()) &&
6775 MI.getOperand(3).isImm() &&
6776 RISCVValidateMachineOperand(MI.getOperand(3), &STI, 18 /* uimm5 */)) {
6777 // qc.c.muliadd $rd, $rs1, $uimm
6778 // Operand: rd_wb
6779 // Operand: rd
6780 // Operand: rs1
6781 // Operand: uimm
6782 return 2;
6783 } // if
6784 break;
6785 } // case QC_MULIADD
6786 case RISCV::QC_MVEQI: {
6787 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6788 STI.getFeatureBits()[RISCV::FeatureVendorXqcicm] &&
6789 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
6790 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
6791 MI.getOperand(3).isImm() &&
6792 (MI.getOperand(3).getImm() == 0) &&
6793 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6794 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()) &&
6795 MI.getOperand(4).isReg() && MI.getOperand(4).getReg().isPhysical() &&
6796 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(4).getReg())) {
6797 // qc.c.mveqz $rd, $rs1
6798 // Operand: rd_wb
6799 // Operand: rd
6800 // Operand: rs1
6801 return 2;
6802 } // if
6803 break;
6804 } // case QC_MVEQI
6805 case RISCV::QC_MVLTUI: {
6806 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6807 STI.getFeatureBits()[RISCV::FeatureVendorXqcicm] &&
6808 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
6809 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
6810 MI.getOperand(3).isImm() &&
6811 (MI.getOperand(3).getImm() == 1) &&
6812 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6813 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()) &&
6814 MI.getOperand(4).isReg() && MI.getOperand(4).getReg().isPhysical() &&
6815 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(4).getReg())) {
6816 // qc.c.mveqz $rd, $rs1
6817 // Operand: rd_wb
6818 // Operand: rd
6819 // Operand: rs1
6820 return 2;
6821 } // if
6822 break;
6823 } // case QC_MVLTUI
6824 case RISCV::QC_SHLADD: {
6825 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6826 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
6827 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
6828 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
6829 MI.getOperand(3).isImm() &&
6830 (MI.getOperand(3).getImm() == 4) &&
6831 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6832 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()) &&
6833 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6834 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
6835 RISCVValidateMachineOperand(MachineOperand::CreateImm(16), &STI, 18 /* uimm5 */)) {
6836 // qc.c.muliadd $rd, $rs1, $uimm
6837 // Operand: rd_wb
6838 // Operand: rd
6839 // Operand: rs1
6840 // Operand: uimm
6841 return 2;
6842 } // if
6843 break;
6844 } // case QC_SHLADD
6845 case RISCV::QC_SYNC: {
6846 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6847 STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
6848 MI.getOperand(0).isImm() &&
6849 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 37 /* uimm5slist */)) {
6850 // qc.c.sync $slist
6851 // Operand: slist
6852 return 2;
6853 } // if
6854 break;
6855 } // case QC_SYNC
6856 case RISCV::QC_SYNCR: {
6857 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6858 STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
6859 MI.getOperand(0).isImm() &&
6860 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 37 /* uimm5slist */)) {
6861 // qc.c.syncr $slist
6862 // Operand: slist
6863 return 2;
6864 } // if
6865 break;
6866 } // case QC_SYNCR
6867 case RISCV::QC_SYNCWF: {
6868 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6869 STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
6870 MI.getOperand(0).isImm() &&
6871 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 37 /* uimm5slist */)) {
6872 // qc.c.syncwf $slist
6873 // Operand: slist
6874 return 2;
6875 } // if
6876 break;
6877 } // case QC_SYNCWF
6878 case RISCV::QC_SYNCWL: {
6879 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6880 STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
6881 MI.getOperand(0).isImm() &&
6882 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 37 /* uimm5slist */)) {
6883 // qc.c.syncwl $slist
6884 // Operand: slist
6885 return 2;
6886 } // if
6887 break;
6888 } // case QC_SYNCWL
6889 case RISCV::SB: {
6890 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6891 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6892 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
6893 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6894 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
6895 MI.getOperand(2).isImm() &&
6896 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 16 /* uimm2 */) &&
6897 MI.getOperand(2).isImm() &&
6898 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 17 /* uimm2_optional */)) {
6899 // c.sb $rs2, ${imm}(${rs1})
6900 // Operand: rs2
6901 // Operand: rs1
6902 // Operand: imm
6903 return 2;
6904 } // if
6905 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
6906 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6907 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
6908 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6909 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
6910 MI.getOperand(2).isImm() &&
6911 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 18 /* uimm5 */) &&
6912 MI.getOperand(2).isImm() &&
6913 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 19 /* uimm5_optional */)) {
6914 // qk.c.sb $rs2, ${imm}(${rs1})
6915 // Operand: rs2
6916 // Operand: rs1
6917 // Operand: imm
6918 return 2;
6919 } // if
6920 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
6921 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6922 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
6923 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6924 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
6925 MI.getOperand(2).isImm() &&
6926 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* uimm4 */) &&
6927 MI.getOperand(2).isImm() &&
6928 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 21 /* uimm4_optional */)) {
6929 // qk.c.sbsp $rd_rs2, ${imm}(${rs1})
6930 // Operand: rd_rs2
6931 // Operand: rs1
6932 // Operand: imm
6933 return 2;
6934 } // if
6935 break;
6936 } // case SB
6937 case RISCV::SD: {
6938 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
6939 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6940 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6941 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
6942 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6943 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
6944 MI.getOperand(2).isImm() &&
6945 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */) &&
6946 MI.getOperand(2).isImm() &&
6947 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm8_lsb000_optional */)) {
6948 // c.sd $rs2, ${imm}(${rs1})
6949 // Operand: rs2
6950 // Operand: rs1
6951 // Operand: imm
6952 return 2;
6953 } // if
6954 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
6955 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6956 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6957 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg()) &&
6958 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6959 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
6960 MI.getOperand(2).isImm() &&
6961 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm9_lsb000 */) &&
6962 MI.getOperand(2).isImm() &&
6963 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm9_lsb000_optional */)) {
6964 // c.sdsp $rs2, ${imm}(${rs1})
6965 // Operand: rs2
6966 // Operand: rs1
6967 // Operand: imm
6968 return 2;
6969 } // if
6970 break;
6971 } // case SD
6972 case RISCV::SD_RV32: {
6973 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6974 STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
6975 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6976 getRISCVMCRegisterClass(RISCV::GPRPairRegClassID).contains(MI.getOperand(0).getReg()) &&
6977 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6978 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
6979 MI.getOperand(2).isImm() &&
6980 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm9_lsb000 */) &&
6981 MI.getOperand(2).isImm() &&
6982 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm9_lsb000_optional */)) {
6983 // c.sdsp $rs2, ${imm}(${rs1})
6984 // Operand: rs2
6985 // Operand: rs1
6986 // Operand: imm
6987 return 2;
6988 } // if
6989 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
6990 STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
6991 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6992 getRISCVMCRegisterClass(RISCV::GPRPairCRegClassID).contains(MI.getOperand(0).getReg()) &&
6993 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6994 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
6995 MI.getOperand(2).isImm() &&
6996 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */) &&
6997 MI.getOperand(2).isImm() &&
6998 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm8_lsb000_optional */)) {
6999 // c.sd $rs2, ${imm}(${rs1})
7000 // Operand: rs2
7001 // Operand: rs1
7002 // Operand: imm
7003 return 2;
7004 } // if
7005 break;
7006 } // case SD_RV32
7007 case RISCV::SEXT_B: {
7008 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
7009 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
7010 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7011 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7012 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7013 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) {
7014 // c.sext.b $rd
7015 // Operand: rd_wb
7016 // Operand: rd
7017 return 2;
7018 } // if
7019 break;
7020 } // case SEXT_B
7021 case RISCV::SEXT_H: {
7022 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
7023 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
7024 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7025 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7026 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7027 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) {
7028 // c.sext.h $rd
7029 // Operand: rd_wb
7030 // Operand: rd
7031 return 2;
7032 } // if
7033 break;
7034 } // case SEXT_H
7035 case RISCV::SH: {
7036 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
7037 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
7038 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
7039 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7040 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
7041 MI.getOperand(2).isImm() &&
7042 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* uimm2_lsb0 */) &&
7043 MI.getOperand(2).isImm() &&
7044 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 23 /* uimm2_lsb0_optional */)) {
7045 // c.sh $rs2, ${imm}(${rs1})
7046 // Operand: rs2
7047 // Operand: rs1
7048 // Operand: imm
7049 return 2;
7050 } // if
7051 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
7052 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
7053 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
7054 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7055 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
7056 MI.getOperand(2).isImm() &&
7057 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 24 /* uimm6_lsb0 */) &&
7058 MI.getOperand(2).isImm() &&
7059 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 25 /* uimm6_lsb0_optional */)) {
7060 // qk.c.sh $rs2, ${imm}(${rs1})
7061 // Operand: rs2
7062 // Operand: rs1
7063 // Operand: imm
7064 return 2;
7065 } // if
7066 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
7067 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
7068 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
7069 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7070 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
7071 MI.getOperand(2).isImm() &&
7072 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 26 /* uimm5_lsb0 */) &&
7073 MI.getOperand(2).isImm() &&
7074 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 27 /* uimm5_lsb0_optional */)) {
7075 // qk.c.shsp $rd_rs2, ${imm}(${rs1})
7076 // Operand: rd_rs2
7077 // Operand: rs1
7078 // Operand: imm
7079 return 2;
7080 } // if
7081 break;
7082 } // case SH
7083 case RISCV::SH1ADD: {
7084 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
7085 STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
7086 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
7087 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
7088 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
7089 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
7090 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()) &&
7091 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7092 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
7093 RISCVValidateMachineOperand(MachineOperand::CreateImm(2), &STI, 18 /* uimm5 */)) {
7094 // qc.c.muliadd $rd, $rs1, $uimm
7095 // Operand: rd_wb
7096 // Operand: rd
7097 // Operand: rs1
7098 // Operand: uimm
7099 return 2;
7100 } // if
7101 break;
7102 } // case SH1ADD
7103 case RISCV::SH2ADD: {
7104 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
7105 STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
7106 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
7107 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
7108 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
7109 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
7110 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()) &&
7111 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7112 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
7113 RISCVValidateMachineOperand(MachineOperand::CreateImm(4), &STI, 18 /* uimm5 */)) {
7114 // qc.c.muliadd $rd, $rs1, $uimm
7115 // Operand: rd_wb
7116 // Operand: rd
7117 // Operand: rs1
7118 // Operand: uimm
7119 return 2;
7120 } // if
7121 break;
7122 } // case SH2ADD
7123 case RISCV::SH3ADD: {
7124 if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
7125 STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
7126 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
7127 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
7128 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
7129 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
7130 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()) &&
7131 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7132 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
7133 RISCVValidateMachineOperand(MachineOperand::CreateImm(8), &STI, 18 /* uimm5 */)) {
7134 // qc.c.muliadd $rd, $rs1, $uimm
7135 // Operand: rd_wb
7136 // Operand: rd
7137 // Operand: rs1
7138 // Operand: uimm
7139 return 2;
7140 } // if
7141 break;
7142 } // case SH3ADD
7143 case RISCV::SH_INX: {
7144 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
7145 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
7146 getRISCVMCRegisterClass(RISCV::GPRF16CRegClassID).contains(MI.getOperand(0).getReg()) &&
7147 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7148 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
7149 MI.getOperand(2).isImm() &&
7150 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* uimm2_lsb0 */) &&
7151 MI.getOperand(2).isImm() &&
7152 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 23 /* uimm2_lsb0_optional */)) {
7153 // c.sh $rs2, ${imm}(${rs1})
7154 // Operand: rs2
7155 // Operand: rs1
7156 // Operand: imm
7157 return 2;
7158 } // if
7159 break;
7160 } // case SH_INX
7161 case RISCV::SLLI: {
7162 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
7163 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7164 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7165 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7166 getRISCVMCRegisterClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()) &&
7167 MI.getOperand(2).isImm() &&
7168 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 6 /* uimmlog2xlennonzero */) &&
7169 MI.getOperand(2).isImm() &&
7170 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 38 /* uimmlog2xlen */)) {
7171 // c.slli $rd, $imm
7172 // Operand: rd_wb
7173 // Operand: rd
7174 // Operand: imm
7175 return 2;
7176 } // if
7177 break;
7178 } // case SLLI
7179 case RISCV::SRAI: {
7180 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
7181 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7182 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7183 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7184 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
7185 MI.getOperand(2).isImm() &&
7186 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 6 /* uimmlog2xlennonzero */) &&
7187 MI.getOperand(2).isImm() &&
7188 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 38 /* uimmlog2xlen */)) {
7189 // c.srai $rs1, $imm
7190 // Operand: rd
7191 // Operand: rs1
7192 // Operand: imm
7193 return 2;
7194 } // if
7195 break;
7196 } // case SRAI
7197 case RISCV::SRLI: {
7198 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
7199 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7200 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7201 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7202 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
7203 MI.getOperand(2).isImm() &&
7204 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 6 /* uimmlog2xlennonzero */) &&
7205 MI.getOperand(2).isImm() &&
7206 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 38 /* uimmlog2xlen */)) {
7207 // c.srli $rs1, $imm
7208 // Operand: rd
7209 // Operand: rs1
7210 // Operand: imm
7211 return 2;
7212 } // if
7213 break;
7214 } // case SRLI
7215 case RISCV::SSPOPCHK: {
7216 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcmop] &&
7217 MI.getOperand(0).isReg() &&
7218 (MI.getOperand(0).getReg() == RISCV::X5)) {
7219 // c.sspopchk $rs1
7220 // Operand: rs1
7221 return 2;
7222 } // if
7223 break;
7224 } // case SSPOPCHK
7225 case RISCV::SSPUSH: {
7226 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcmop] &&
7227 MI.getOperand(0).isReg() &&
7228 (MI.getOperand(0).getReg() == RISCV::X1)) {
7229 // c.sspush $rs1
7230 // Operand: rs1
7231 return 2;
7232 } // if
7233 break;
7234 } // case SSPUSH
7235 case RISCV::SUB: {
7236 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
7237 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7238 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7239 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7240 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
7241 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
7242 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg())) {
7243 // c.sub $rd, $rs2
7244 // Operand: rd_wb
7245 // Operand: rd
7246 // Operand: rs2
7247 return 2;
7248 } // if
7249 break;
7250 } // case SUB
7251 case RISCV::SUBW: {
7252 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
7253 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
7254 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7255 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7256 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7257 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
7258 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
7259 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg())) {
7260 // c.subw $rd, $rs2
7261 // Operand: rd_wb
7262 // Operand: rd
7263 // Operand: rs2
7264 return 2;
7265 } // if
7266 break;
7267 } // case SUBW
7268 case RISCV::SW: {
7269 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
7270 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
7271 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg()) &&
7272 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7273 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
7274 MI.getOperand(2).isImm() &&
7275 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 11 /* uimm7_lsb00 */) &&
7276 MI.getOperand(2).isImm() &&
7277 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 12 /* uimm7_lsb00_optional */)) {
7278 // c.sw $rs2, ${imm}(${rs1})
7279 // Operand: rs2
7280 // Operand: rs1
7281 // Operand: imm
7282 return 2;
7283 } // if
7284 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
7285 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
7286 getRISCVMCRegisterClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg()) &&
7287 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7288 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
7289 MI.getOperand(2).isImm() &&
7290 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 13 /* uimm8_lsb00 */) &&
7291 MI.getOperand(2).isImm() &&
7292 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 14 /* uimm8_lsb00_optional */)) {
7293 // c.swsp $rs2, ${imm}(${rs1})
7294 // Operand: rs2
7295 // Operand: rs1
7296 // Operand: imm
7297 return 2;
7298 } // if
7299 break;
7300 } // case SW
7301 case RISCV::SW_INX: {
7302 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
7303 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
7304 getRISCVMCRegisterClass(RISCV::GPRF32RegClassID).contains(MI.getOperand(0).getReg()) &&
7305 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7306 getRISCVMCRegisterClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg()) &&
7307 MI.getOperand(2).isImm() &&
7308 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 13 /* uimm8_lsb00 */) &&
7309 MI.getOperand(2).isImm() &&
7310 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 14 /* uimm8_lsb00_optional */)) {
7311 // c.swsp $rs2, ${imm}(${rs1})
7312 // Operand: rs2
7313 // Operand: rs1
7314 // Operand: imm
7315 return 2;
7316 } // if
7317 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
7318 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
7319 getRISCVMCRegisterClass(RISCV::GPRF32CRegClassID).contains(MI.getOperand(0).getReg()) &&
7320 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7321 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
7322 MI.getOperand(2).isImm() &&
7323 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 11 /* uimm7_lsb00 */) &&
7324 MI.getOperand(2).isImm() &&
7325 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 12 /* uimm7_lsb00_optional */)) {
7326 // c.sw $rs2, ${imm}(${rs1})
7327 // Operand: rs2
7328 // Operand: rs1
7329 // Operand: imm
7330 return 2;
7331 } // if
7332 break;
7333 } // case SW_INX
7334 case RISCV::UNIMP: {
7335 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca]) {
7336 // c.unimp
7337 return 2;
7338 } // if
7339 break;
7340 } // case UNIMP
7341 case RISCV::XOR: {
7342 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
7343 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7344 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7345 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7346 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()) &&
7347 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
7348 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg())) {
7349 // c.xor $rd, $rs2
7350 // Operand: rd_wb
7351 // Operand: rd
7352 // Operand: rs2
7353 return 2;
7354 } // if
7355 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
7356 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
7357 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
7358 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
7359 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()) &&
7360 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7361 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) {
7362 // c.xor $rd, $rs2
7363 // Operand: rd_wb
7364 // Operand: rd
7365 // Operand: rs2
7366 return 2;
7367 } // if
7368 break;
7369 } // case XOR
7370 case RISCV::XORI: {
7371 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
7372 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7373 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7374 MI.getOperand(2).isImm() &&
7375 (MI.getOperand(2).getImm() == -1) &&
7376 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7377 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) {
7378 // c.not $rd
7379 // Operand: rd_wb
7380 // Operand: rd
7381 return 2;
7382 } // if
7383 break;
7384 } // case XORI
7385 case RISCV::ZEXT_H_RV32: {
7386 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
7387 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
7388 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7389 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7390 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7391 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) {
7392 // c.zext.h $rd
7393 // Operand: rd_wb
7394 // Operand: rd
7395 return 2;
7396 } // if
7397 break;
7398 } // case ZEXT_H_RV32
7399 case RISCV::ZEXT_H_RV64: {
7400 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
7401 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
7402 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7403 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7404 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7405 getRISCVMCRegisterClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) {
7406 // c.zext.h $rd
7407 // Operand: rd_wb
7408 // Operand: rd
7409 return 2;
7410 } // if
7411 break;
7412 } // case ZEXT_H_RV64
7413 } // switch
7414 return 0;
7415}
7416
7417#endif // GEN_CHECK_COMPRESS_INSTR
7418
7419