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