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 MI.getOperand(i: 0).isReg() &&
4383 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4384 MI.getOperand(i: 0).isReg() &&
4385 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg())) {
4386 // zext.h $rd, $rs1
4387 OutInst.setOpcode(RISCV::ZEXT_H_RV32);
4388 // Operand: rd
4389 OutInst.addOperand(Op: MI.getOperand(i: 0));
4390 // Operand: rs1
4391 OutInst.addOperand(Op: MI.getOperand(i: 0));
4392 OutInst.setLoc(MI.getLoc());
4393 return true;
4394 } // if
4395 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
4396 STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
4397 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4398 MI.getOperand(i: 0).isReg() &&
4399 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4400 MI.getOperand(i: 0).isReg() &&
4401 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg())) {
4402 // zext.h $rd, $rs1
4403 OutInst.setOpcode(RISCV::ZEXT_H_RV64);
4404 // Operand: rd
4405 OutInst.addOperand(Op: MI.getOperand(i: 0));
4406 // Operand: rs1
4407 OutInst.addOperand(Op: MI.getOperand(i: 0));
4408 OutInst.setLoc(MI.getLoc());
4409 return true;
4410 } // if
4411 break;
4412 } // case C_ZEXT_H
4413 case RISCV::C_ZEXT_W: {
4414 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
4415 STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
4416 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4417 MI.getOperand(i: 0).isReg() &&
4418 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4419 MI.getOperand(i: 0).isReg() &&
4420 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg())) {
4421 // add.uw $rd, $rs1, $rs2
4422 OutInst.setOpcode(RISCV::ADD_UW);
4423 // Operand: rd
4424 OutInst.addOperand(Op: MI.getOperand(i: 0));
4425 // Operand: rs1
4426 OutInst.addOperand(Op: MI.getOperand(i: 0));
4427 // Operand: rs2
4428 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
4429 OutInst.setLoc(MI.getLoc());
4430 return true;
4431 } // if
4432 break;
4433 } // case C_ZEXT_W
4434 case RISCV::QC_C_BEXTI: {
4435 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
4436 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
4437 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4438 MI.getOperand(i: 0).isReg() &&
4439 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4440 MI.getOperand(i: 0).isReg() &&
4441 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4442 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 19 /* uimmlog2xlennonzero */) &&
4443 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 20 /* uimmlog2xlen */)) {
4444 // bexti $rd, $rs1, $shamt
4445 OutInst.setOpcode(RISCV::BEXTI);
4446 // Operand: rd
4447 OutInst.addOperand(Op: MI.getOperand(i: 0));
4448 // Operand: rs1
4449 OutInst.addOperand(Op: MI.getOperand(i: 0));
4450 // Operand: shamt
4451 OutInst.addOperand(Op: MI.getOperand(i: 2));
4452 OutInst.setLoc(MI.getLoc());
4453 return true;
4454 } // if
4455 break;
4456 } // case QC_C_BEXTI
4457 case RISCV::QC_C_BSETI: {
4458 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
4459 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
4460 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4461 MI.getOperand(i: 0).isReg() &&
4462 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4463 MI.getOperand(i: 0).isReg() &&
4464 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4465 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 19 /* uimmlog2xlennonzero */) &&
4466 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 20 /* uimmlog2xlen */)) {
4467 // bseti $rd, $rs1, $shamt
4468 OutInst.setOpcode(RISCV::BSETI);
4469 // Operand: rd
4470 OutInst.addOperand(Op: MI.getOperand(i: 0));
4471 // Operand: rs1
4472 OutInst.addOperand(Op: MI.getOperand(i: 0));
4473 // Operand: shamt
4474 OutInst.addOperand(Op: MI.getOperand(i: 2));
4475 OutInst.setLoc(MI.getLoc());
4476 return true;
4477 } // if
4478 break;
4479 } // case QC_C_BSETI
4480 case RISCV::QC_C_EXTU: {
4481 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
4482 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4483 MI.getOperand(i: 0).isReg() &&
4484 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4485 MI.getOperand(i: 0).isReg() &&
4486 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4487 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 21 /* uimm5ge6_plus1 */) &&
4488 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 22 /* uimm5_plus1 */) &&
4489 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: 0), STI, PredicateIndex: 23 /* uimm5 */)) {
4490 // qc.extu $rd, $rs1, $width, $shamt
4491 OutInst.setOpcode(RISCV::QC_EXTU);
4492 // Operand: rd
4493 OutInst.addOperand(Op: MI.getOperand(i: 0));
4494 // Operand: rs1
4495 OutInst.addOperand(Op: MI.getOperand(i: 0));
4496 // Operand: width
4497 OutInst.addOperand(Op: MI.getOperand(i: 2));
4498 // Operand: shamt
4499 OutInst.addOperand(Op: MCOperand::createImm(Val: 0));
4500 OutInst.setLoc(MI.getLoc());
4501 return true;
4502 } // if
4503 break;
4504 } // case QC_C_EXTU
4505 case RISCV::QC_C_MVEQZ: {
4506 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcicm] &&
4507 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4508 MI.getOperand(i: 0).isReg() &&
4509 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4510 MI.getOperand(i: 0).isReg() &&
4511 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4512 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: 0), STI, PredicateIndex: 24 /* simm5 */) &&
4513 MI.getOperand(i: 2).isReg() &&
4514 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg())) {
4515 // qc.mveqi $rd, $rs1, $imm, $rs3
4516 OutInst.setOpcode(RISCV::QC_MVEQI);
4517 // Operand: rd_wb
4518 OutInst.addOperand(Op: MI.getOperand(i: 0));
4519 // Operand: rd
4520 OutInst.addOperand(Op: MI.getOperand(i: 0));
4521 // Operand: rs1
4522 OutInst.addOperand(Op: MI.getOperand(i: 0));
4523 // Operand: imm
4524 OutInst.addOperand(Op: MCOperand::createImm(Val: 0));
4525 // Operand: rs3
4526 OutInst.addOperand(Op: MI.getOperand(i: 2));
4527 OutInst.setLoc(MI.getLoc());
4528 return true;
4529 } // if
4530 break;
4531 } // case QC_C_MVEQZ
4532 case RISCV::QC_C_SYNC: {
4533 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
4534 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4535 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 25 /* uimm5slist */) &&
4536 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 23 /* uimm5 */)) {
4537 // qc.sync $imm5
4538 OutInst.setOpcode(RISCV::QC_SYNC);
4539 // Operand: imm5
4540 OutInst.addOperand(Op: MI.getOperand(i: 0));
4541 OutInst.setLoc(MI.getLoc());
4542 return true;
4543 } // if
4544 break;
4545 } // case QC_C_SYNC
4546 case RISCV::QC_C_SYNCR: {
4547 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
4548 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4549 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 25 /* uimm5slist */) &&
4550 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 23 /* uimm5 */)) {
4551 // qc.syncr $imm5
4552 OutInst.setOpcode(RISCV::QC_SYNCR);
4553 // Operand: imm5
4554 OutInst.addOperand(Op: MI.getOperand(i: 0));
4555 OutInst.setLoc(MI.getLoc());
4556 return true;
4557 } // if
4558 break;
4559 } // case QC_C_SYNCR
4560 case RISCV::QC_C_SYNCWF: {
4561 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
4562 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4563 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 25 /* uimm5slist */) &&
4564 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 23 /* uimm5 */)) {
4565 // qc.syncwf $imm5
4566 OutInst.setOpcode(RISCV::QC_SYNCWF);
4567 // Operand: imm5
4568 OutInst.addOperand(Op: MI.getOperand(i: 0));
4569 OutInst.setLoc(MI.getLoc());
4570 return true;
4571 } // if
4572 break;
4573 } // case QC_C_SYNCWF
4574 case RISCV::QC_C_SYNCWL: {
4575 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
4576 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4577 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 25 /* uimm5slist */) &&
4578 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 23 /* uimm5 */)) {
4579 // qc.syncwl $imm5
4580 OutInst.setOpcode(RISCV::QC_SYNCWL);
4581 // Operand: imm5
4582 OutInst.addOperand(Op: MI.getOperand(i: 0));
4583 OutInst.setLoc(MI.getLoc());
4584 return true;
4585 } // if
4586 break;
4587 } // case QC_C_SYNCWL
4588 case RISCV::QK_C_LBU: {
4589 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4590 MI.getOperand(i: 0).isReg() &&
4591 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4592 MI.getOperand(i: 1).isReg() &&
4593 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4594 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 23 /* uimm5 */) &&
4595 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4596 // lbu $rd, ${imm12}(${rs1})
4597 OutInst.setOpcode(RISCV::LBU);
4598 // Operand: rd
4599 OutInst.addOperand(Op: MI.getOperand(i: 0));
4600 // Operand: rs1
4601 OutInst.addOperand(Op: MI.getOperand(i: 1));
4602 // Operand: imm12
4603 OutInst.addOperand(Op: MI.getOperand(i: 2));
4604 OutInst.setLoc(MI.getLoc());
4605 return true;
4606 } // if
4607 break;
4608 } // case QK_C_LBU
4609 case RISCV::QK_C_LBUSP: {
4610 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4611 MI.getOperand(i: 0).isReg() &&
4612 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4613 MI.getOperand(i: 1).isReg() &&
4614 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4615 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 26 /* uimm4 */) &&
4616 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4617 // lbu $rd, ${imm12}(${rs1})
4618 OutInst.setOpcode(RISCV::LBU);
4619 // Operand: rd
4620 OutInst.addOperand(Op: MI.getOperand(i: 0));
4621 // Operand: rs1
4622 OutInst.addOperand(Op: MI.getOperand(i: 1));
4623 // Operand: imm12
4624 OutInst.addOperand(Op: MI.getOperand(i: 2));
4625 OutInst.setLoc(MI.getLoc());
4626 return true;
4627 } // if
4628 break;
4629 } // case QK_C_LBUSP
4630 case RISCV::QK_C_LHU: {
4631 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4632 MI.getOperand(i: 0).isReg() &&
4633 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4634 MI.getOperand(i: 1).isReg() &&
4635 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4636 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 27 /* uimm6_lsb0 */) &&
4637 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4638 // lhu $rd, ${imm12}(${rs1})
4639 OutInst.setOpcode(RISCV::LHU);
4640 // Operand: rd
4641 OutInst.addOperand(Op: MI.getOperand(i: 0));
4642 // Operand: rs1
4643 OutInst.addOperand(Op: MI.getOperand(i: 1));
4644 // Operand: imm12
4645 OutInst.addOperand(Op: MI.getOperand(i: 2));
4646 OutInst.setLoc(MI.getLoc());
4647 return true;
4648 } // if
4649 break;
4650 } // case QK_C_LHU
4651 case RISCV::QK_C_LHUSP: {
4652 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4653 MI.getOperand(i: 0).isReg() &&
4654 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4655 MI.getOperand(i: 1).isReg() &&
4656 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4657 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 28 /* uimm5_lsb0 */) &&
4658 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4659 // lhu $rd, ${imm12}(${rs1})
4660 OutInst.setOpcode(RISCV::LHU);
4661 // Operand: rd
4662 OutInst.addOperand(Op: MI.getOperand(i: 0));
4663 // Operand: rs1
4664 OutInst.addOperand(Op: MI.getOperand(i: 1));
4665 // Operand: imm12
4666 OutInst.addOperand(Op: MI.getOperand(i: 2));
4667 OutInst.setLoc(MI.getLoc());
4668 return true;
4669 } // if
4670 break;
4671 } // case QK_C_LHUSP
4672 case RISCV::QK_C_SB: {
4673 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4674 MI.getOperand(i: 0).isReg() &&
4675 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4676 MI.getOperand(i: 1).isReg() &&
4677 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4678 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 23 /* uimm5 */) &&
4679 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4680 // sb $rs2, ${imm12}(${rs1})
4681 OutInst.setOpcode(RISCV::SB);
4682 // Operand: rs2
4683 OutInst.addOperand(Op: MI.getOperand(i: 0));
4684 // Operand: rs1
4685 OutInst.addOperand(Op: MI.getOperand(i: 1));
4686 // Operand: imm12
4687 OutInst.addOperand(Op: MI.getOperand(i: 2));
4688 OutInst.setLoc(MI.getLoc());
4689 return true;
4690 } // if
4691 break;
4692 } // case QK_C_SB
4693 case RISCV::QK_C_SBSP: {
4694 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4695 MI.getOperand(i: 0).isReg() &&
4696 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4697 MI.getOperand(i: 1).isReg() &&
4698 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4699 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 26 /* uimm4 */) &&
4700 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4701 // sb $rs2, ${imm12}(${rs1})
4702 OutInst.setOpcode(RISCV::SB);
4703 // Operand: rs2
4704 OutInst.addOperand(Op: MI.getOperand(i: 0));
4705 // Operand: rs1
4706 OutInst.addOperand(Op: MI.getOperand(i: 1));
4707 // Operand: imm12
4708 OutInst.addOperand(Op: MI.getOperand(i: 2));
4709 OutInst.setLoc(MI.getLoc());
4710 return true;
4711 } // if
4712 break;
4713 } // case QK_C_SBSP
4714 case RISCV::QK_C_SH: {
4715 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4716 MI.getOperand(i: 0).isReg() &&
4717 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4718 MI.getOperand(i: 1).isReg() &&
4719 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4720 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 27 /* uimm6_lsb0 */) &&
4721 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4722 // sh $rs2, ${imm12}(${rs1})
4723 OutInst.setOpcode(RISCV::SH);
4724 // Operand: rs2
4725 OutInst.addOperand(Op: MI.getOperand(i: 0));
4726 // Operand: rs1
4727 OutInst.addOperand(Op: MI.getOperand(i: 1));
4728 // Operand: imm12
4729 OutInst.addOperand(Op: MI.getOperand(i: 2));
4730 OutInst.setLoc(MI.getLoc());
4731 return true;
4732 } // if
4733 break;
4734 } // case QK_C_SH
4735 case RISCV::QK_C_SHSP: {
4736 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4737 MI.getOperand(i: 0).isReg() &&
4738 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4739 MI.getOperand(i: 1).isReg() &&
4740 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4741 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 28 /* uimm5_lsb0 */) &&
4742 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4743 // sh $rs2, ${imm12}(${rs1})
4744 OutInst.setOpcode(RISCV::SH);
4745 // Operand: rs2
4746 OutInst.addOperand(Op: MI.getOperand(i: 0));
4747 // Operand: rs1
4748 OutInst.addOperand(Op: MI.getOperand(i: 1));
4749 // Operand: imm12
4750 OutInst.addOperand(Op: MI.getOperand(i: 2));
4751 OutInst.setLoc(MI.getLoc());
4752 return true;
4753 } // if
4754 break;
4755 } // case QK_C_SHSP
4756 } // switch
4757 return false;
4758}
4759
4760#endif // GEN_UNCOMPRESS_INSTR
4761
4762#ifdef GEN_CHECK_COMPRESS_INSTR
4763#undef GEN_CHECK_COMPRESS_INSTR
4764
4765static bool RISCVValidateMachineOperand(const MachineOperand &MO,
4766 const RISCVSubtarget *Subtarget,
4767 unsigned PredicateIndex) {
4768 int64_t Imm = MO.getImm();
4769 switch (PredicateIndex) {
4770 default:
4771 llvm_unreachable("Unknown ImmLeaf Predicate kind");
4772 break;
4773 case 1: {
4774 // simm6nonzero
4775 return (Imm != 0) && isInt<6>(Imm);
4776 }
4777 case 2: {
4778 // simm6
4779 return isInt<6>(Imm);
4780 }
4781 case 3: {
4782 // simm10_lsb0000nonzero
4783 return (Imm != 0) && isShiftedInt<6, 4>(Imm);
4784 }
4785 case 4: {
4786 // uimm10_lsb00nonzero
4787 return isShiftedUInt<8, 2>(Imm) && (Imm != 0);
4788 }
4789 case 5: {
4790 // bare_simm9_lsb0
4791 return isShiftedInt<8, 1>(Imm);
4792 }
4793 case 6: {
4794 // uimmlog2xlennonzero
4795 if (Subtarget->is64Bit())
4796 return isUInt<6>(Imm) && (Imm != 0);
4797 return isUInt<5>(Imm) && (Imm != 0);
4798 }
4799 case 7: {
4800 // uimm8_lsb000
4801 return isShiftedUInt<5, 3>(Imm);
4802 }
4803 case 8: {
4804 // uimm9_lsb000
4805 return isShiftedUInt<6, 3>(Imm);
4806 }
4807 case 9: {
4808 // uimm7_lsb00
4809 return isShiftedUInt<5, 2>(Imm);
4810 }
4811 case 10: {
4812 // uimm8_lsb00
4813 return isShiftedUInt<6, 2>(Imm);
4814 }
4815 case 11: {
4816 // bare_simm12_lsb0
4817 return isShiftedInt<11, 1>(Imm);
4818 }
4819 case 12: {
4820 // uimm2
4821 return isUInt<2>(Imm);
4822 }
4823 case 13: {
4824 // uimm5
4825 return isUInt<5>(Imm);
4826 }
4827 case 14: {
4828 // uimm4
4829 return isUInt<4>(Imm);
4830 }
4831 case 15: {
4832 // uimm2_lsb0
4833 return isShiftedUInt<1, 1>(Imm);
4834 }
4835 case 16: {
4836 // uimm6_lsb0
4837 return isShiftedUInt<5, 1>(Imm);
4838 }
4839 case 17: {
4840 // uimm5_lsb0
4841 return isShiftedUInt<4, 1>(Imm);
4842 }
4843 case 18: {
4844 // c_lui_imm
4845 return (Imm != 0) &&
4846 (isUInt<5>(Imm) ||
4847 (Imm >= 0xfffe0 && Imm <= 0xfffff));
4848 }
4849 case 19: {
4850 // uimm5ge6_plus1
4851 return Imm >= 6 && Imm <= 32;
4852 }
4853 case 20: {
4854 // simm12_lo
4855 return isInt<12>(Imm);
4856 }
4857 case 21: {
4858 // simm5nonzero
4859 return (Imm != 0) && isInt<5>(Imm);
4860 }
4861 case 22: {
4862 // bare_simm13_lsb0
4863 return isShiftedInt<12, 1>(Imm);
4864 }
4865 case 23: {
4866 // uimm5nonzero
4867 return (Imm != 0) && isUInt<5>(Imm);
4868 }
4869 case 24: {
4870 // simm21_lsb0_jal
4871 return isShiftedInt<20, 1>(Imm);
4872 }
4873 case 25: {
4874 // simm20_li
4875 return isInt<20>(Imm);
4876 }
4877 case 26: {
4878 // uimm5slist
4879 return ((Imm == 0) ||
4880 (Imm == 1) ||
4881 (Imm == 2) ||
4882 (Imm == 4) ||
4883 (Imm == 8) ||
4884 (Imm == 16) ||
4885 (Imm == 15) ||
4886 (Imm == 31));
4887 }
4888 case 27: {
4889 // uimmlog2xlen
4890 if (Subtarget->is64Bit())
4891 return isUInt<6>(Imm);
4892 return isUInt<5>(Imm);
4893 }
4894 }
4895}
4896
4897static bool isCompressibleInst(const MachineInstr &MI,
4898 const RISCVSubtarget &STI) {
4899 switch (MI.getOpcode()) {
4900 default: return false;
4901 case RISCV::ADD: {
4902 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4903 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
4904 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
4905 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
4906 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
4907 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
4908 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(2).getReg())) {
4909 // c.add $rs1, $rs2
4910 // Operand: rd
4911 // Operand: rs1
4912 // Operand: rs2
4913 return true;
4914 } // if
4915 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4916 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
4917 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
4918 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
4919 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(2).getReg()) &&
4920 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
4921 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg())) {
4922 // c.add $rs1, $rs2
4923 // Operand: rd
4924 // Operand: rs1
4925 // Operand: rs2
4926 return true;
4927 } // if
4928 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4929 MI.getOperand(1).isReg() &&
4930 (MI.getOperand(1).getReg() == RISCV::X0) &&
4931 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
4932 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
4933 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
4934 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(2).getReg())) {
4935 // c.mv $rs1, $rs2
4936 // Operand: rs1
4937 // Operand: rs2
4938 return true;
4939 } // if
4940 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4941 MI.getOperand(2).isReg() &&
4942 (MI.getOperand(2).getReg() == RISCV::X0) &&
4943 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
4944 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
4945 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
4946 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg())) {
4947 // c.mv $rs1, $rs2
4948 // Operand: rs1
4949 // Operand: rs2
4950 return true;
4951 } // if
4952 break;
4953 } // case ADD
4954 case RISCV::ADDI: {
4955 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4956 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
4957 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
4958 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
4959 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
4960 MI.getOperand(2).isImm() &&
4961 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 1 /* simm6nonzero */) &&
4962 MI.getOperand(2).isImm() &&
4963 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
4964 // c.addi $rd, $imm
4965 // Operand: rd_wb
4966 // Operand: rd
4967 // Operand: imm
4968 return true;
4969 } // if
4970 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4971 MI.getOperand(0).isReg() &&
4972 (MI.getOperand(0).getReg() == RISCV::X2) &&
4973 MI.getOperand(1).isReg() &&
4974 (MI.getOperand(1).getReg() == RISCV::X2) &&
4975 MI.getOperand(2).isImm() &&
4976 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 3 /* simm10_lsb0000nonzero */)) {
4977 // c.addi16sp $rd, $imm
4978 // Operand: rd_wb
4979 // Operand: rd
4980 // Operand: imm
4981 return true;
4982 } // if
4983 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4984 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
4985 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
4986 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
4987 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
4988 MI.getOperand(2).isImm() &&
4989 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 4 /* uimm10_lsb00nonzero */)) {
4990 // c.addi4spn $rd, $rs1, $imm
4991 // Operand: rd
4992 // Operand: rs1
4993 // Operand: imm
4994 return true;
4995 } // if
4996 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4997 MI.getOperand(1).isReg() &&
4998 (MI.getOperand(1).getReg() == RISCV::X0) &&
4999 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5000 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5001 MI.getOperand(2).isImm() &&
5002 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5003 // c.li $rd, $imm
5004 // Operand: rd
5005 // Operand: imm
5006 return true;
5007 } // if
5008 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5009 MI.getOperand(2).isImm() &&
5010 (MI.getOperand(2).getImm() == 0) &&
5011 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5012 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5013 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5014 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg())) {
5015 // c.mv $rs1, $rs2
5016 // Operand: rs1
5017 // Operand: rs2
5018 return true;
5019 } // if
5020 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5021 MI.getOperand(0).isReg() &&
5022 (MI.getOperand(0).getReg() == RISCV::X0) &&
5023 MI.getOperand(1).isReg() &&
5024 (MI.getOperand(1).getReg() == RISCV::X0) &&
5025 MI.getOperand(2).isImm() &&
5026 (MI.getOperand(2).getImm() == 0)) {
5027 // c.nop
5028 return true;
5029 } // if
5030 break;
5031 } // case ADDI
5032 case RISCV::ADDIW: {
5033 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5034 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5035 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5036 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5037 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5038 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
5039 MI.getOperand(2).isImm() &&
5040 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5041 // c.addiw $rd, $imm
5042 // Operand: rd_wb
5043 // Operand: rd
5044 // Operand: imm
5045 return true;
5046 } // if
5047 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5048 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5049 MI.getOperand(1).isReg() &&
5050 (MI.getOperand(1).getReg() == RISCV::X0) &&
5051 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5052 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5053 MI.getOperand(2).isImm() &&
5054 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5055 // c.li $rd, $imm
5056 // Operand: rd
5057 // Operand: imm
5058 return true;
5059 } // if
5060 break;
5061 } // case ADDIW
5062 case RISCV::ADDW: {
5063 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5064 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5065 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5066 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5067 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5068 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5069 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5070 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg())) {
5071 // c.addw $rd, $rs2
5072 // Operand: rd_wb
5073 // Operand: rd
5074 // Operand: rs2
5075 return true;
5076 } // if
5077 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5078 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5079 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
5080 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
5081 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5082 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
5083 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5084 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
5085 // c.addw $rd, $rs2
5086 // Operand: rd_wb
5087 // Operand: rd
5088 // Operand: rs2
5089 return true;
5090 } // if
5091 break;
5092 } // case ADDW
5093 case RISCV::ADD_UW: {
5094 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5095 STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
5096 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5097 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5098 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5099 MI.getOperand(2).isReg() &&
5100 (MI.getOperand(2).getReg() == RISCV::X0) &&
5101 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5102 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
5103 // c.zext.w $rd
5104 // Operand: rd_wb
5105 // Operand: rd
5106 return true;
5107 } // if
5108 break;
5109 } // case ADD_UW
5110 case RISCV::AND: {
5111 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5112 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5113 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5114 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5115 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5116 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5117 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg())) {
5118 // c.and $rd, $rs2
5119 // Operand: rd_wb
5120 // Operand: rd
5121 // Operand: rs2
5122 return true;
5123 } // if
5124 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5125 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
5126 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
5127 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5128 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
5129 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5130 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
5131 // c.and $rd, $rs2
5132 // Operand: rd_wb
5133 // Operand: rd
5134 // Operand: rs2
5135 return true;
5136 } // if
5137 break;
5138 } // case AND
5139 case RISCV::ANDI: {
5140 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5141 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5142 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5143 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5144 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5145 MI.getOperand(2).isImm() &&
5146 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5147 // c.andi $rs1, $imm
5148 // Operand: rd
5149 // Operand: rs1
5150 // Operand: imm
5151 return true;
5152 } // if
5153 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5154 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5155 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5156 MI.getOperand(2).isImm() &&
5157 (MI.getOperand(2).getImm() == 255) &&
5158 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5159 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
5160 // c.zext.b $rd
5161 // Operand: rd_wb
5162 // Operand: rd
5163 return true;
5164 } // if
5165 break;
5166 } // case ANDI
5167 case RISCV::BEQ: {
5168 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5169 MI.getOperand(1).isReg() &&
5170 (MI.getOperand(1).getReg() == RISCV::X0) &&
5171 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5172 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5173 MI.getOperand(2).isImm() &&
5174 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 5 /* bare_simm9_lsb0 */)) {
5175 // c.beqz $rs1, $imm
5176 // Operand: rs1
5177 // Operand: imm
5178 return true;
5179 } // if
5180 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5181 MI.getOperand(0).isReg() &&
5182 (MI.getOperand(0).getReg() == RISCV::X0) &&
5183 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5184 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5185 MI.getOperand(2).isImm() &&
5186 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 5 /* bare_simm9_lsb0 */)) {
5187 // c.beqz $rs1, $imm
5188 // Operand: rs1
5189 // Operand: imm
5190 return true;
5191 } // if
5192 break;
5193 } // case BEQ
5194 case RISCV::BEXTI: {
5195 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
5196 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
5197 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5198 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5199 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5200 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5201 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5202 MI.getOperand(2).isImm() &&
5203 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 6 /* uimmlog2xlennonzero */)) {
5204 // qc.c.bexti $rs1, $shamt
5205 // Operand: rd
5206 // Operand: rs1
5207 // Operand: shamt
5208 return true;
5209 } // if
5210 break;
5211 } // case BEXTI
5212 case RISCV::BNE: {
5213 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5214 MI.getOperand(1).isReg() &&
5215 (MI.getOperand(1).getReg() == RISCV::X0) &&
5216 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5217 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5218 MI.getOperand(2).isImm() &&
5219 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 5 /* bare_simm9_lsb0 */)) {
5220 // c.bnez $rs1, $imm
5221 // Operand: rs1
5222 // Operand: imm
5223 return true;
5224 } // if
5225 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5226 MI.getOperand(0).isReg() &&
5227 (MI.getOperand(0).getReg() == RISCV::X0) &&
5228 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5229 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5230 MI.getOperand(2).isImm() &&
5231 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 5 /* bare_simm9_lsb0 */)) {
5232 // c.bnez $rs1, $imm
5233 // Operand: rs1
5234 // Operand: imm
5235 return true;
5236 } // if
5237 break;
5238 } // case BNE
5239 case RISCV::BSETI: {
5240 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
5241 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
5242 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5243 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5244 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5245 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5246 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5247 MI.getOperand(2).isImm() &&
5248 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 6 /* uimmlog2xlennonzero */)) {
5249 // qc.c.bseti $rs1, $shamt
5250 // Operand: rd
5251 // Operand: rs1
5252 // Operand: shamt
5253 return true;
5254 } // if
5255 break;
5256 } // case BSETI
5257 case RISCV::EBREAK: {
5258 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca]) {
5259 // c.ebreak
5260 return true;
5261 } // if
5262 break;
5263 } // case EBREAK
5264 case RISCV::FLD: {
5265 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
5266 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5267 RISCVMCRegisterClasses[RISCV::FPR64CRegClassID].contains(MI.getOperand(0).getReg()) &&
5268 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5269 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5270 MI.getOperand(2).isImm() &&
5271 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */)) {
5272 // c.fld $rd, ${imm}(${rs1})
5273 // Operand: rd
5274 // Operand: rs1
5275 // Operand: imm
5276 return true;
5277 } // if
5278 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
5279 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5280 RISCVMCRegisterClasses[RISCV::FPR64RegClassID].contains(MI.getOperand(0).getReg()) &&
5281 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5282 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5283 MI.getOperand(2).isImm() &&
5284 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm9_lsb000 */)) {
5285 // c.fldsp $rd, ${imm}(${rs1})
5286 // Operand: rd
5287 // Operand: rs1
5288 // Operand: imm
5289 return true;
5290 } // if
5291 break;
5292 } // case FLD
5293 case RISCV::FLW: {
5294 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
5295 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5296 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5297 RISCVMCRegisterClasses[RISCV::FPR32CRegClassID].contains(MI.getOperand(0).getReg()) &&
5298 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5299 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5300 MI.getOperand(2).isImm() &&
5301 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm7_lsb00 */)) {
5302 // c.flw $rd, ${imm}(${rs1})
5303 // Operand: rd
5304 // Operand: rs1
5305 // Operand: imm
5306 return true;
5307 } // if
5308 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
5309 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5310 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5311 RISCVMCRegisterClasses[RISCV::FPR32RegClassID].contains(MI.getOperand(0).getReg()) &&
5312 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5313 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5314 MI.getOperand(2).isImm() &&
5315 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm8_lsb00 */)) {
5316 // c.flwsp $rd, ${imm}(${rs1})
5317 // Operand: rd
5318 // Operand: rs1
5319 // Operand: imm
5320 return true;
5321 } // if
5322 break;
5323 } // case FLW
5324 case RISCV::FSD: {
5325 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
5326 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5327 RISCVMCRegisterClasses[RISCV::FPR64CRegClassID].contains(MI.getOperand(0).getReg()) &&
5328 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5329 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5330 MI.getOperand(2).isImm() &&
5331 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */)) {
5332 // c.fsd $rs2, ${imm}(${rs1})
5333 // Operand: rs2
5334 // Operand: rs1
5335 // Operand: imm
5336 return true;
5337 } // if
5338 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
5339 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5340 RISCVMCRegisterClasses[RISCV::FPR64RegClassID].contains(MI.getOperand(0).getReg()) &&
5341 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5342 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5343 MI.getOperand(2).isImm() &&
5344 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm9_lsb000 */)) {
5345 // c.fsdsp $rs2, ${imm}(${rs1})
5346 // Operand: rs2
5347 // Operand: rs1
5348 // Operand: imm
5349 return true;
5350 } // if
5351 break;
5352 } // case FSD
5353 case RISCV::FSW: {
5354 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
5355 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5356 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5357 RISCVMCRegisterClasses[RISCV::FPR32CRegClassID].contains(MI.getOperand(0).getReg()) &&
5358 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5359 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5360 MI.getOperand(2).isImm() &&
5361 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm7_lsb00 */)) {
5362 // c.fsw $rs2, ${imm}(${rs1})
5363 // Operand: rs2
5364 // Operand: rs1
5365 // Operand: imm
5366 return true;
5367 } // if
5368 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
5369 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5370 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5371 RISCVMCRegisterClasses[RISCV::FPR32RegClassID].contains(MI.getOperand(0).getReg()) &&
5372 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5373 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5374 MI.getOperand(2).isImm() &&
5375 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm8_lsb00 */)) {
5376 // c.fswsp $rs2, ${imm}(${rs1})
5377 // Operand: rs2
5378 // Operand: rs1
5379 // Operand: imm
5380 return true;
5381 } // if
5382 break;
5383 } // case FSW
5384 case RISCV::JAL: {
5385 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5386 MI.getOperand(0).isReg() &&
5387 (MI.getOperand(0).getReg() == RISCV::X0) &&
5388 MI.getOperand(1).isImm() &&
5389 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 11 /* bare_simm12_lsb0 */)) {
5390 // c.j $offset
5391 // Operand: offset
5392 return true;
5393 } // if
5394 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5395 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5396 MI.getOperand(0).isReg() &&
5397 (MI.getOperand(0).getReg() == RISCV::X1) &&
5398 MI.getOperand(1).isImm() &&
5399 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 11 /* bare_simm12_lsb0 */)) {
5400 // c.jal $offset
5401 // Operand: offset
5402 return true;
5403 } // if
5404 break;
5405 } // case JAL
5406 case RISCV::JALR: {
5407 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5408 MI.getOperand(0).isReg() &&
5409 (MI.getOperand(0).getReg() == RISCV::X1) &&
5410 MI.getOperand(2).isImm() &&
5411 (MI.getOperand(2).getImm() == 0) &&
5412 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5413 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg())) {
5414 // c.jalr $rs1
5415 // Operand: rs1
5416 return true;
5417 } // if
5418 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5419 MI.getOperand(0).isReg() &&
5420 (MI.getOperand(0).getReg() == RISCV::X0) &&
5421 MI.getOperand(2).isImm() &&
5422 (MI.getOperand(2).getImm() == 0) &&
5423 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5424 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg())) {
5425 // c.jr $rs1
5426 // Operand: rs1
5427 return true;
5428 } // if
5429 break;
5430 } // case JALR
5431 case RISCV::LBU: {
5432 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5433 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5434 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5435 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5436 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5437 MI.getOperand(2).isImm() &&
5438 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 12 /* uimm2 */)) {
5439 // c.lbu $rd, ${imm}(${rs1})
5440 // Operand: rd
5441 // Operand: rs1
5442 // Operand: imm
5443 return true;
5444 } // if
5445 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
5446 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5447 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5448 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5449 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5450 MI.getOperand(2).isImm() &&
5451 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 13 /* uimm5 */)) {
5452 // qk.c.lbu $rd, ${imm}(${rs1})
5453 // Operand: rd
5454 // Operand: rs1
5455 // Operand: imm
5456 return true;
5457 } // if
5458 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
5459 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5460 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5461 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5462 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5463 MI.getOperand(2).isImm() &&
5464 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 14 /* uimm4 */)) {
5465 // qk.c.lbusp $rd_rs2, ${imm}(${rs1})
5466 // Operand: rd_rs2
5467 // Operand: rs1
5468 // Operand: imm
5469 return true;
5470 } // if
5471 break;
5472 } // case LBU
5473 case RISCV::LD: {
5474 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5475 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5476 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5477 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5478 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5479 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5480 MI.getOperand(2).isImm() &&
5481 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */)) {
5482 // c.ld $rd, ${imm}(${rs1})
5483 // Operand: rd
5484 // Operand: rs1
5485 // Operand: imm
5486 return true;
5487 } // if
5488 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5489 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5490 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5491 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5492 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5493 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5494 MI.getOperand(2).isImm() &&
5495 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm9_lsb000 */)) {
5496 // c.ldsp $rd, ${imm}(${rs1})
5497 // Operand: rd
5498 // Operand: rs1
5499 // Operand: imm
5500 return true;
5501 } // if
5502 break;
5503 } // case LD
5504 case RISCV::LD_RV32: {
5505 if (STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
5506 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5507 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5508 RISCVMCRegisterClasses[RISCV::GPRPairNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5509 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5510 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5511 MI.getOperand(2).isImm() &&
5512 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm9_lsb000 */)) {
5513 // c.ldsp $rd, ${imm}(${rs1})
5514 // Operand: rd
5515 // Operand: rs1
5516 // Operand: imm
5517 return true;
5518 } // if
5519 if (STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
5520 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5521 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5522 RISCVMCRegisterClasses[RISCV::GPRPairCRegClassID].contains(MI.getOperand(0).getReg()) &&
5523 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5524 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5525 MI.getOperand(2).isImm() &&
5526 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */)) {
5527 // c.ld $rd, ${imm}(${rs1})
5528 // Operand: rd
5529 // Operand: rs1
5530 // Operand: imm
5531 return true;
5532 } // if
5533 break;
5534 } // case LD_RV32
5535 case RISCV::LH: {
5536 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5537 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5538 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5539 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5540 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5541 MI.getOperand(2).isImm() &&
5542 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 15 /* uimm2_lsb0 */)) {
5543 // c.lh $rd, ${imm}(${rs1})
5544 // Operand: rd
5545 // Operand: rs1
5546 // Operand: imm
5547 return true;
5548 } // if
5549 break;
5550 } // case LH
5551 case RISCV::LHU: {
5552 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5553 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5554 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5555 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5556 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5557 MI.getOperand(2).isImm() &&
5558 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 15 /* uimm2_lsb0 */)) {
5559 // c.lhu $rd, ${imm}(${rs1})
5560 // Operand: rd
5561 // Operand: rs1
5562 // Operand: imm
5563 return true;
5564 } // if
5565 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
5566 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5567 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5568 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5569 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5570 MI.getOperand(2).isImm() &&
5571 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 16 /* uimm6_lsb0 */)) {
5572 // qk.c.lhu $rd, ${imm}(${rs1})
5573 // Operand: rd
5574 // Operand: rs1
5575 // Operand: imm
5576 return true;
5577 } // if
5578 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
5579 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5580 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5581 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5582 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5583 MI.getOperand(2).isImm() &&
5584 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 17 /* uimm5_lsb0 */)) {
5585 // qk.c.lhusp $rd_rs2, ${imm}(${rs1})
5586 // Operand: rd_rs2
5587 // Operand: rs1
5588 // Operand: imm
5589 return true;
5590 } // if
5591 break;
5592 } // case LHU
5593 case RISCV::LH_INX: {
5594 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5595 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5596 RISCVMCRegisterClasses[RISCV::GPRF16CRegClassID].contains(MI.getOperand(0).getReg()) &&
5597 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5598 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5599 MI.getOperand(2).isImm() &&
5600 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 15 /* uimm2_lsb0 */)) {
5601 // c.lh $rd, ${imm}(${rs1})
5602 // Operand: rd
5603 // Operand: rs1
5604 // Operand: imm
5605 return true;
5606 } // if
5607 break;
5608 } // case LH_INX
5609 case RISCV::LUI: {
5610 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5611 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5612 RISCVMCRegisterClasses[RISCV::GPRNoX0X2RegClassID].contains(MI.getOperand(0).getReg()) &&
5613 MI.getOperand(1).isImm() &&
5614 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 18 /* c_lui_imm */)) {
5615 // c.lui $rd, $imm
5616 // Operand: rd
5617 // Operand: imm
5618 return true;
5619 } // if
5620 break;
5621 } // case LUI
5622 case RISCV::LW: {
5623 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5624 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5625 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5626 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5627 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5628 MI.getOperand(2).isImm() &&
5629 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm7_lsb00 */)) {
5630 // c.lw $rd, ${imm}(${rs1})
5631 // Operand: rd
5632 // Operand: rs1
5633 // Operand: imm
5634 return true;
5635 } // if
5636 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5637 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5638 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5639 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5640 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5641 MI.getOperand(2).isImm() &&
5642 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm8_lsb00 */)) {
5643 // c.lwsp $rd, ${imm}(${rs1})
5644 // Operand: rd
5645 // Operand: rs1
5646 // Operand: imm
5647 return true;
5648 } // if
5649 break;
5650 } // case LW
5651 case RISCV::LW_INX: {
5652 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5653 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5654 RISCVMCRegisterClasses[RISCV::GPRF32NoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5655 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5656 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5657 MI.getOperand(2).isImm() &&
5658 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm8_lsb00 */)) {
5659 // c.lwsp $rd, ${imm}(${rs1})
5660 // Operand: rd
5661 // Operand: rs1
5662 // Operand: imm
5663 return true;
5664 } // if
5665 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5666 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5667 RISCVMCRegisterClasses[RISCV::GPRF32CRegClassID].contains(MI.getOperand(0).getReg()) &&
5668 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5669 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5670 MI.getOperand(2).isImm() &&
5671 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm7_lsb00 */)) {
5672 // c.lw $rd, ${imm}(${rs1})
5673 // Operand: rd
5674 // Operand: rs1
5675 // Operand: imm
5676 return true;
5677 } // if
5678 break;
5679 } // case LW_INX
5680 case RISCV::MUL: {
5681 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5682 STI.getFeatureBits()[RISCV::FeatureStdExtZmmul] &&
5683 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5684 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5685 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5686 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5687 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5688 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg())) {
5689 // c.mul $rd, $rs2
5690 // Operand: rd_wb
5691 // Operand: rd
5692 // Operand: rs2
5693 return true;
5694 } // if
5695 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5696 STI.getFeatureBits()[RISCV::FeatureStdExtZmmul] &&
5697 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
5698 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
5699 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5700 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
5701 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5702 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
5703 // c.mul $rd, $rs2
5704 // Operand: rd_wb
5705 // Operand: rd
5706 // Operand: rs2
5707 return true;
5708 } // if
5709 break;
5710 } // case MUL
5711 case RISCV::OR: {
5712 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5713 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5714 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5715 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5716 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5717 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5718 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg())) {
5719 // c.or $rd, $rs2
5720 // Operand: rd_wb
5721 // Operand: rd
5722 // Operand: rs2
5723 return true;
5724 } // if
5725 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5726 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
5727 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
5728 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5729 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
5730 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5731 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
5732 // c.or $rd, $rs2
5733 // Operand: rd_wb
5734 // Operand: rd
5735 // Operand: rs2
5736 return true;
5737 } // if
5738 break;
5739 } // case OR
5740 case RISCV::QC_EXTU: {
5741 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
5742 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
5743 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5744 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5745 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5746 MI.getOperand(2).isImm() &&
5747 (MI.getOperand(2).getImm() == 1) &&
5748 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5749 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5750 MI.getOperand(3).isImm() &&
5751 RISCVValidateMachineOperand(MI.getOperand(3), &STI, 6 /* uimmlog2xlennonzero */)) {
5752 // qc.c.bexti $rs1, $shamt
5753 // Operand: rd
5754 // Operand: rs1
5755 // Operand: shamt
5756 return true;
5757 } // if
5758 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
5759 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5760 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5761 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5762 MI.getOperand(3).isImm() &&
5763 (MI.getOperand(3).getImm() == 0) &&
5764 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5765 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
5766 MI.getOperand(2).isImm() &&
5767 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 19 /* uimm5ge6_plus1 */)) {
5768 // qc.c.extu $rd, $width
5769 // Operand: rd_wb
5770 // Operand: rd
5771 // Operand: width
5772 return true;
5773 } // if
5774 break;
5775 } // case QC_EXTU
5776 case RISCV::QC_E_ADDAI: {
5777 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5778 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5779 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5780 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5781 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5782 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5783 MI.getOperand(2).isImm() &&
5784 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
5785 // addi $rd, $rs1, $imm12
5786 // Operand: rd
5787 // Operand: rs1
5788 // Operand: imm12
5789 return true;
5790 } // if
5791 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5792 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5793 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5794 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5795 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5796 MI.getOperand(2).isImm() &&
5797 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 1 /* simm6nonzero */) &&
5798 MI.getOperand(2).isImm() &&
5799 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5800 // c.addi $rd, $imm
5801 // Operand: rd_wb
5802 // Operand: rd
5803 // Operand: imm
5804 return true;
5805 } // if
5806 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5807 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5808 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5809 MI.getOperand(0).isReg() &&
5810 (MI.getOperand(0).getReg() == RISCV::X2) &&
5811 MI.getOperand(1).isReg() &&
5812 (MI.getOperand(1).getReg() == RISCV::X2) &&
5813 MI.getOperand(2).isImm() &&
5814 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 3 /* simm10_lsb0000nonzero */)) {
5815 // c.addi16sp $rd, $imm
5816 // Operand: rd_wb
5817 // Operand: rd
5818 // Operand: imm
5819 return true;
5820 } // if
5821 break;
5822 } // case QC_E_ADDAI
5823 case RISCV::QC_E_ADDI: {
5824 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5825 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5826 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5827 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5828 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5829 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
5830 MI.getOperand(2).isImm() &&
5831 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
5832 // addi $rd, $rs1, $imm12
5833 // Operand: rd
5834 // Operand: rs1
5835 // Operand: imm12
5836 return true;
5837 } // if
5838 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5839 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5840 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5841 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5842 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5843 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5844 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
5845 MI.getOperand(2).isImm() &&
5846 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 1 /* simm6nonzero */) &&
5847 MI.getOperand(2).isImm() &&
5848 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5849 // c.addi $rd, $imm
5850 // Operand: rd_wb
5851 // Operand: rd
5852 // Operand: imm
5853 return true;
5854 } // if
5855 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5856 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5857 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5858 MI.getOperand(0).isReg() &&
5859 (MI.getOperand(0).getReg() == RISCV::X2) &&
5860 MI.getOperand(1).isReg() &&
5861 (MI.getOperand(1).getReg() == RISCV::X2) &&
5862 MI.getOperand(2).isImm() &&
5863 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 3 /* simm10_lsb0000nonzero */)) {
5864 // c.addi16sp $rd, $imm
5865 // Operand: rd_wb
5866 // Operand: rd
5867 // Operand: imm
5868 return true;
5869 } // if
5870 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5871 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5872 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5873 MI.getOperand(2).isImm() &&
5874 (MI.getOperand(2).getImm() == 0) &&
5875 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5876 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5877 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5878 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg())) {
5879 // c.mv $rs1, $rs2
5880 // Operand: rs1
5881 // Operand: rs2
5882 return true;
5883 } // if
5884 break;
5885 } // case QC_E_ADDI
5886 case RISCV::QC_E_ANDAI: {
5887 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5888 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5889 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5890 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5891 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5892 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5893 MI.getOperand(2).isImm() &&
5894 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
5895 // andi $rd, $rs1, $imm12
5896 // Operand: rd
5897 // Operand: rs1
5898 // Operand: imm12
5899 return true;
5900 } // if
5901 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5902 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5903 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5904 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5905 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5906 MI.getOperand(2).isImm() &&
5907 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5908 // c.andi $rs1, $imm
5909 // Operand: rd
5910 // Operand: rs1
5911 // Operand: imm
5912 return true;
5913 } // if
5914 break;
5915 } // case QC_E_ANDAI
5916 case RISCV::QC_E_ANDI: {
5917 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5918 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5919 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5920 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5921 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5922 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
5923 MI.getOperand(2).isImm() &&
5924 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
5925 // andi $rd, $rs1, $imm12
5926 // Operand: rd
5927 // Operand: rs1
5928 // Operand: imm12
5929 return true;
5930 } // if
5931 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5932 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5933 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5934 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5935 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5936 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5937 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5938 MI.getOperand(2).isImm() &&
5939 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5940 // c.andi $rs1, $imm
5941 // Operand: rd
5942 // Operand: rs1
5943 // Operand: imm
5944 return true;
5945 } // if
5946 break;
5947 } // case QC_E_ANDI
5948 case RISCV::QC_E_BEQI: {
5949 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
5950 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5951 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5952 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5953 MI.getOperand(1).isImm() &&
5954 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 21 /* simm5nonzero */) &&
5955 MI.getOperand(2).isImm() &&
5956 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* bare_simm13_lsb0 */)) {
5957 // qc.beqi $rs1, $rs2, $imm12
5958 // Operand: rs1
5959 // Operand: rs2
5960 // Operand: imm12
5961 return true;
5962 } // if
5963 break;
5964 } // case QC_E_BEQI
5965 case RISCV::QC_E_BGEI: {
5966 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
5967 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5968 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5969 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5970 MI.getOperand(1).isImm() &&
5971 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 21 /* simm5nonzero */) &&
5972 MI.getOperand(2).isImm() &&
5973 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* bare_simm13_lsb0 */)) {
5974 // qc.bgei $rs1, $rs2, $imm12
5975 // Operand: rs1
5976 // Operand: rs2
5977 // Operand: imm12
5978 return true;
5979 } // if
5980 break;
5981 } // case QC_E_BGEI
5982 case RISCV::QC_E_BGEUI: {
5983 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
5984 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5985 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5986 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5987 MI.getOperand(1).isImm() &&
5988 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 23 /* uimm5nonzero */) &&
5989 MI.getOperand(2).isImm() &&
5990 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* bare_simm13_lsb0 */)) {
5991 // qc.bgeui $rs1, $rs2, $imm12
5992 // Operand: rs1
5993 // Operand: rs2
5994 // Operand: imm12
5995 return true;
5996 } // if
5997 break;
5998 } // case QC_E_BGEUI
5999 case RISCV::QC_E_BLTI: {
6000 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
6001 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6002 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6003 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6004 MI.getOperand(1).isImm() &&
6005 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 21 /* simm5nonzero */) &&
6006 MI.getOperand(2).isImm() &&
6007 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* bare_simm13_lsb0 */)) {
6008 // qc.blti $rs1, $rs2, $imm12
6009 // Operand: rs1
6010 // Operand: rs2
6011 // Operand: imm12
6012 return true;
6013 } // if
6014 break;
6015 } // case QC_E_BLTI
6016 case RISCV::QC_E_BLTUI: {
6017 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
6018 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6019 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6020 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6021 MI.getOperand(1).isImm() &&
6022 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 23 /* uimm5nonzero */) &&
6023 MI.getOperand(2).isImm() &&
6024 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* bare_simm13_lsb0 */)) {
6025 // qc.bltui $rs1, $rs2, $imm12
6026 // Operand: rs1
6027 // Operand: rs2
6028 // Operand: imm12
6029 return true;
6030 } // if
6031 break;
6032 } // case QC_E_BLTUI
6033 case RISCV::QC_E_BNEI: {
6034 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
6035 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6036 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6037 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6038 MI.getOperand(1).isImm() &&
6039 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 21 /* simm5nonzero */) &&
6040 MI.getOperand(2).isImm() &&
6041 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* bare_simm13_lsb0 */)) {
6042 // qc.bnei $rs1, $rs2, $imm12
6043 // Operand: rs1
6044 // Operand: rs2
6045 // Operand: imm12
6046 return true;
6047 } // if
6048 break;
6049 } // case QC_E_BNEI
6050 case RISCV::QC_E_J: {
6051 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6052 STI.getFeatureBits()[RISCV::FeatureVendorXqcilb] &&
6053 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6054 MI.getOperand(0).isImm() &&
6055 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 11 /* bare_simm12_lsb0 */)) {
6056 // c.j $offset
6057 // Operand: offset
6058 return true;
6059 } // if
6060 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilb] &&
6061 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6062 MI.getOperand(0).isImm() &&
6063 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 24 /* simm21_lsb0_jal */)) {
6064 // jal $rd, $imm20
6065 // Operand: rd
6066 // Operand: imm20
6067 return true;
6068 } // if
6069 break;
6070 } // case QC_E_J
6071 case RISCV::QC_E_JAL: {
6072 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6073 STI.getFeatureBits()[RISCV::FeatureVendorXqcilb] &&
6074 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6075 MI.getOperand(0).isImm() &&
6076 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 11 /* bare_simm12_lsb0 */)) {
6077 // c.jal $offset
6078 // Operand: offset
6079 return true;
6080 } // if
6081 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilb] &&
6082 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6083 MI.getOperand(0).isImm() &&
6084 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 24 /* simm21_lsb0_jal */)) {
6085 // jal $rd, $imm20
6086 // Operand: rd
6087 // Operand: imm20
6088 return true;
6089 } // if
6090 break;
6091 } // case QC_E_JAL
6092 case RISCV::QC_E_LB: {
6093 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6094 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6095 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6096 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6097 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6098 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(1).getReg()) &&
6099 MI.getOperand(2).isImm() &&
6100 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6101 // lb $rd, ${imm12}(${rs1})
6102 // Operand: rd
6103 // Operand: rs1
6104 // Operand: imm12
6105 return true;
6106 } // if
6107 break;
6108 } // case QC_E_LB
6109 case RISCV::QC_E_LBU: {
6110 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6111 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6112 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6113 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6114 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6115 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6116 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6117 MI.getOperand(2).isImm() &&
6118 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 12 /* uimm2 */)) {
6119 // c.lbu $rd, ${imm}(${rs1})
6120 // Operand: rd
6121 // Operand: rs1
6122 // Operand: imm
6123 return true;
6124 } // if
6125 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6126 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6127 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6128 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6129 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6130 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(1).getReg()) &&
6131 MI.getOperand(2).isImm() &&
6132 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6133 // lbu $rd, ${imm12}(${rs1})
6134 // Operand: rd
6135 // Operand: rs1
6136 // Operand: imm12
6137 return true;
6138 } // if
6139 break;
6140 } // case QC_E_LBU
6141 case RISCV::QC_E_LH: {
6142 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6143 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6144 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6145 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6146 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6147 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6148 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6149 MI.getOperand(2).isImm() &&
6150 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 15 /* uimm2_lsb0 */)) {
6151 // c.lh $rd, ${imm}(${rs1})
6152 // Operand: rd
6153 // Operand: rs1
6154 // Operand: imm
6155 return true;
6156 } // if
6157 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6158 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6159 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6160 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6161 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6162 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(1).getReg()) &&
6163 MI.getOperand(2).isImm() &&
6164 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6165 // lh $rd, ${imm12}(${rs1})
6166 // Operand: rd
6167 // Operand: rs1
6168 // Operand: imm12
6169 return true;
6170 } // if
6171 break;
6172 } // case QC_E_LH
6173 case RISCV::QC_E_LHU: {
6174 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6175 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6176 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6177 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6178 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6179 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6180 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6181 MI.getOperand(2).isImm() &&
6182 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 15 /* uimm2_lsb0 */)) {
6183 // c.lhu $rd, ${imm}(${rs1})
6184 // Operand: rd
6185 // Operand: rs1
6186 // Operand: imm
6187 return true;
6188 } // if
6189 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6190 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6191 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6192 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6193 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6194 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(1).getReg()) &&
6195 MI.getOperand(2).isImm() &&
6196 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6197 // lhu $rd, ${imm12}(${rs1})
6198 // Operand: rd
6199 // Operand: rs1
6200 // Operand: imm12
6201 return true;
6202 } // if
6203 break;
6204 } // case QC_E_LHU
6205 case RISCV::QC_E_LI: {
6206 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6207 STI.getFeatureBits()[RISCV::FeatureVendorXqcili] &&
6208 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6209 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6210 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6211 MI.getOperand(1).isImm() &&
6212 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 2 /* simm6 */)) {
6213 // c.li $rd, $imm
6214 // Operand: rd
6215 // Operand: imm
6216 return true;
6217 } // if
6218 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcili] &&
6219 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6220 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6221 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6222 MI.getOperand(1).isImm() &&
6223 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 25 /* simm20_li */)) {
6224 // qc.li $rd, $imm20
6225 // Operand: rd
6226 // Operand: imm20
6227 return true;
6228 } // if
6229 break;
6230 } // case QC_E_LI
6231 case RISCV::QC_E_LW: {
6232 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6233 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6234 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6235 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6236 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6237 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6238 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6239 MI.getOperand(2).isImm() &&
6240 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm7_lsb00 */)) {
6241 // c.lw $rd, ${imm}(${rs1})
6242 // Operand: rd
6243 // Operand: rs1
6244 // Operand: imm
6245 return true;
6246 } // if
6247 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6248 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6249 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6250 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6251 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6252 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6253 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
6254 MI.getOperand(2).isImm() &&
6255 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm8_lsb00 */)) {
6256 // c.lwsp $rd, ${imm}(${rs1})
6257 // Operand: rd
6258 // Operand: rs1
6259 // Operand: imm
6260 return true;
6261 } // if
6262 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6263 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6264 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6265 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6266 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6267 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(1).getReg()) &&
6268 MI.getOperand(2).isImm() &&
6269 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6270 // lw $rd, ${imm12}(${rs1})
6271 // Operand: rd
6272 // Operand: rs1
6273 // Operand: imm12
6274 return true;
6275 } // if
6276 break;
6277 } // case QC_E_LW
6278 case RISCV::QC_E_ORAI: {
6279 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6280 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6281 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6282 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6283 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6284 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6285 MI.getOperand(2).isImm() &&
6286 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6287 // ori $rd, $rs1, $imm12
6288 // Operand: rd
6289 // Operand: rs1
6290 // Operand: imm12
6291 return true;
6292 } // if
6293 break;
6294 } // case QC_E_ORAI
6295 case RISCV::QC_E_ORI: {
6296 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6297 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6298 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6299 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6300 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6301 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
6302 MI.getOperand(2).isImm() &&
6303 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6304 // ori $rd, $rs1, $imm12
6305 // Operand: rd
6306 // Operand: rs1
6307 // Operand: imm12
6308 return true;
6309 } // if
6310 break;
6311 } // case QC_E_ORI
6312 case RISCV::QC_E_SB: {
6313 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6314 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6315 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6316 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6317 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6318 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6319 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6320 MI.getOperand(2).isImm() &&
6321 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 12 /* uimm2 */)) {
6322 // c.sb $rs2, ${imm}(${rs1})
6323 // Operand: rs2
6324 // Operand: rs1
6325 // Operand: imm
6326 return true;
6327 } // if
6328 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6329 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6330 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6331 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6332 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6333 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(1).getReg()) &&
6334 MI.getOperand(2).isImm() &&
6335 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6336 // sb $rs2, ${imm12}(${rs1})
6337 // Operand: rs2
6338 // Operand: rs1
6339 // Operand: imm12
6340 return true;
6341 } // if
6342 break;
6343 } // case QC_E_SB
6344 case RISCV::QC_E_SH: {
6345 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6346 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6347 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6348 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6349 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6350 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6351 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6352 MI.getOperand(2).isImm() &&
6353 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 15 /* uimm2_lsb0 */)) {
6354 // c.sh $rs2, ${imm}(${rs1})
6355 // Operand: rs2
6356 // Operand: rs1
6357 // Operand: imm
6358 return true;
6359 } // if
6360 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6361 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6362 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6363 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6364 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6365 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(1).getReg()) &&
6366 MI.getOperand(2).isImm() &&
6367 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6368 // sh $rs2, ${imm12}(${rs1})
6369 // Operand: rs2
6370 // Operand: rs1
6371 // Operand: imm12
6372 return true;
6373 } // if
6374 break;
6375 } // case QC_E_SH
6376 case RISCV::QC_E_SW: {
6377 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6378 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6379 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6380 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6381 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6382 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6383 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6384 MI.getOperand(2).isImm() &&
6385 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm7_lsb00 */)) {
6386 // c.sw $rs2, ${imm}(${rs1})
6387 // Operand: rs2
6388 // Operand: rs1
6389 // Operand: imm
6390 return true;
6391 } // if
6392 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6393 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6394 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6395 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6396 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6397 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6398 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
6399 MI.getOperand(2).isImm() &&
6400 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm8_lsb00 */)) {
6401 // c.swsp $rs2, ${imm}(${rs1})
6402 // Operand: rs2
6403 // Operand: rs1
6404 // Operand: imm
6405 return true;
6406 } // if
6407 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6408 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6409 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6410 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6411 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6412 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(1).getReg()) &&
6413 MI.getOperand(2).isImm() &&
6414 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6415 // sw $rs2, ${imm12}(${rs1})
6416 // Operand: rs2
6417 // Operand: rs1
6418 // Operand: imm12
6419 return true;
6420 } // if
6421 break;
6422 } // case QC_E_SW
6423 case RISCV::QC_E_XORAI: {
6424 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6425 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6426 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6427 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6428 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6429 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6430 MI.getOperand(2).isImm() &&
6431 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6432 // xori $rd, $rs1, $imm12
6433 // Operand: rd
6434 // Operand: rs1
6435 // Operand: imm12
6436 return true;
6437 } // if
6438 break;
6439 } // case QC_E_XORAI
6440 case RISCV::QC_E_XORI: {
6441 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6442 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6443 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6444 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6445 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6446 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
6447 MI.getOperand(2).isImm() &&
6448 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6449 // xori $rd, $rs1, $imm12
6450 // Operand: rd
6451 // Operand: rs1
6452 // Operand: imm12
6453 return true;
6454 } // if
6455 break;
6456 } // case QC_E_XORI
6457 case RISCV::QC_LI: {
6458 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6459 STI.getFeatureBits()[RISCV::FeatureVendorXqcili] &&
6460 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6461 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6462 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6463 MI.getOperand(1).isImm() &&
6464 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 2 /* simm6 */)) {
6465 // c.li $rd, $imm
6466 // Operand: rd
6467 // Operand: imm
6468 return true;
6469 } // if
6470 break;
6471 } // case QC_LI
6472 case RISCV::QC_MULIADD: {
6473 if (STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
6474 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6475 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6476 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6477 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6478 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
6479 MI.getOperand(3).isImm() &&
6480 RISCVValidateMachineOperand(MI.getOperand(3), &STI, 13 /* uimm5 */)) {
6481 // qc.c.muliadd $rd, $rs1, $uimm
6482 // Operand: rd_wb
6483 // Operand: rd
6484 // Operand: rs1
6485 // Operand: uimm
6486 return true;
6487 } // if
6488 break;
6489 } // case QC_MULIADD
6490 case RISCV::QC_MVEQI: {
6491 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcicm] &&
6492 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6493 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
6494 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
6495 MI.getOperand(3).isImm() &&
6496 (MI.getOperand(3).getImm() == 0) &&
6497 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6498 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
6499 MI.getOperand(4).isReg() && MI.getOperand(4).getReg().isPhysical() &&
6500 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(4).getReg())) {
6501 // qc.c.mveqz $rd, $rs1
6502 // Operand: rd_wb
6503 // Operand: rd
6504 // Operand: rs1
6505 return true;
6506 } // if
6507 break;
6508 } // case QC_MVEQI
6509 case RISCV::QC_MVLTUI: {
6510 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcicm] &&
6511 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6512 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
6513 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
6514 MI.getOperand(3).isImm() &&
6515 (MI.getOperand(3).getImm() == 1) &&
6516 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6517 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
6518 MI.getOperand(4).isReg() && MI.getOperand(4).getReg().isPhysical() &&
6519 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(4).getReg())) {
6520 // qc.c.mveqz $rd, $rs1
6521 // Operand: rd_wb
6522 // Operand: rd
6523 // Operand: rs1
6524 return true;
6525 } // if
6526 break;
6527 } // case QC_MVLTUI
6528 case RISCV::QC_SYNC: {
6529 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
6530 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6531 MI.getOperand(0).isImm() &&
6532 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 26 /* uimm5slist */)) {
6533 // qc.c.sync $slist
6534 // Operand: slist
6535 return true;
6536 } // if
6537 break;
6538 } // case QC_SYNC
6539 case RISCV::QC_SYNCR: {
6540 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
6541 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6542 MI.getOperand(0).isImm() &&
6543 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 26 /* uimm5slist */)) {
6544 // qc.c.syncr $slist
6545 // Operand: slist
6546 return true;
6547 } // if
6548 break;
6549 } // case QC_SYNCR
6550 case RISCV::QC_SYNCWF: {
6551 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
6552 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6553 MI.getOperand(0).isImm() &&
6554 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 26 /* uimm5slist */)) {
6555 // qc.c.syncwf $slist
6556 // Operand: slist
6557 return true;
6558 } // if
6559 break;
6560 } // case QC_SYNCWF
6561 case RISCV::QC_SYNCWL: {
6562 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
6563 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6564 MI.getOperand(0).isImm() &&
6565 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 26 /* uimm5slist */)) {
6566 // qc.c.syncwl $slist
6567 // Operand: slist
6568 return true;
6569 } // if
6570 break;
6571 } // case QC_SYNCWL
6572 case RISCV::SB: {
6573 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6574 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6575 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6576 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6577 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6578 MI.getOperand(2).isImm() &&
6579 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 12 /* uimm2 */)) {
6580 // c.sb $rs2, ${imm}(${rs1})
6581 // Operand: rs2
6582 // Operand: rs1
6583 // Operand: imm
6584 return true;
6585 } // if
6586 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
6587 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6588 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6589 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6590 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6591 MI.getOperand(2).isImm() &&
6592 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 13 /* uimm5 */)) {
6593 // qk.c.sb $rs2, ${imm}(${rs1})
6594 // Operand: rs2
6595 // Operand: rs1
6596 // Operand: imm
6597 return true;
6598 } // if
6599 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
6600 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6601 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6602 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6603 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
6604 MI.getOperand(2).isImm() &&
6605 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 14 /* uimm4 */)) {
6606 // qk.c.sbsp $rd_rs2, ${imm}(${rs1})
6607 // Operand: rd_rs2
6608 // Operand: rs1
6609 // Operand: imm
6610 return true;
6611 } // if
6612 break;
6613 } // case SB
6614 case RISCV::SD: {
6615 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
6616 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6617 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6618 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6619 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6620 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6621 MI.getOperand(2).isImm() &&
6622 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */)) {
6623 // c.sd $rs2, ${imm}(${rs1})
6624 // Operand: rs2
6625 // Operand: rs1
6626 // Operand: imm
6627 return true;
6628 } // if
6629 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
6630 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6631 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6632 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6633 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6634 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
6635 MI.getOperand(2).isImm() &&
6636 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm9_lsb000 */)) {
6637 // c.sdsp $rs2, ${imm}(${rs1})
6638 // Operand: rs2
6639 // Operand: rs1
6640 // Operand: imm
6641 return true;
6642 } // if
6643 break;
6644 } // case SD
6645 case RISCV::SD_RV32: {
6646 if (STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
6647 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6648 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6649 RISCVMCRegisterClasses[RISCV::GPRPairRegClassID].contains(MI.getOperand(0).getReg()) &&
6650 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6651 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
6652 MI.getOperand(2).isImm() &&
6653 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm9_lsb000 */)) {
6654 // c.sdsp $rs2, ${imm}(${rs1})
6655 // Operand: rs2
6656 // Operand: rs1
6657 // Operand: imm
6658 return true;
6659 } // if
6660 if (STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
6661 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6662 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6663 RISCVMCRegisterClasses[RISCV::GPRPairCRegClassID].contains(MI.getOperand(0).getReg()) &&
6664 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6665 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6666 MI.getOperand(2).isImm() &&
6667 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */)) {
6668 // c.sd $rs2, ${imm}(${rs1})
6669 // Operand: rs2
6670 // Operand: rs1
6671 // Operand: imm
6672 return true;
6673 } // if
6674 break;
6675 } // case SD_RV32
6676 case RISCV::SEXT_B: {
6677 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
6678 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6679 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6680 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6681 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6682 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
6683 // c.sext.b $rd
6684 // Operand: rd_wb
6685 // Operand: rd
6686 return true;
6687 } // if
6688 break;
6689 } // case SEXT_B
6690 case RISCV::SEXT_H: {
6691 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
6692 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6693 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6694 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6695 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6696 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
6697 // c.sext.h $rd
6698 // Operand: rd_wb
6699 // Operand: rd
6700 return true;
6701 } // if
6702 break;
6703 } // case SEXT_H
6704 case RISCV::SH: {
6705 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6706 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6707 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6708 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6709 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6710 MI.getOperand(2).isImm() &&
6711 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 15 /* uimm2_lsb0 */)) {
6712 // c.sh $rs2, ${imm}(${rs1})
6713 // Operand: rs2
6714 // Operand: rs1
6715 // Operand: imm
6716 return true;
6717 } // if
6718 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
6719 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6720 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6721 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6722 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6723 MI.getOperand(2).isImm() &&
6724 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 16 /* uimm6_lsb0 */)) {
6725 // qk.c.sh $rs2, ${imm}(${rs1})
6726 // Operand: rs2
6727 // Operand: rs1
6728 // Operand: imm
6729 return true;
6730 } // if
6731 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
6732 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6733 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6734 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6735 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
6736 MI.getOperand(2).isImm() &&
6737 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 17 /* uimm5_lsb0 */)) {
6738 // qk.c.shsp $rd_rs2, ${imm}(${rs1})
6739 // Operand: rd_rs2
6740 // Operand: rs1
6741 // Operand: imm
6742 return true;
6743 } // if
6744 break;
6745 } // case SH
6746 case RISCV::SH1ADD: {
6747 if (STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
6748 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
6749 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6750 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
6751 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
6752 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6753 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
6754 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6755 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6756 RISCVValidateMachineOperand(MachineOperand::CreateImm(2), &STI, 13 /* uimm5 */)) {
6757 // qc.c.muliadd $rd, $rs1, $uimm
6758 // Operand: rd_wb
6759 // Operand: rd
6760 // Operand: rs1
6761 // Operand: uimm
6762 return true;
6763 } // if
6764 break;
6765 } // case SH1ADD
6766 case RISCV::SH2ADD: {
6767 if (STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
6768 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
6769 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6770 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
6771 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
6772 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6773 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
6774 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6775 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6776 RISCVValidateMachineOperand(MachineOperand::CreateImm(4), &STI, 13 /* uimm5 */)) {
6777 // qc.c.muliadd $rd, $rs1, $uimm
6778 // Operand: rd_wb
6779 // Operand: rd
6780 // Operand: rs1
6781 // Operand: uimm
6782 return true;
6783 } // if
6784 break;
6785 } // case SH2ADD
6786 case RISCV::SH3ADD: {
6787 if (STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
6788 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
6789 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6790 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
6791 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
6792 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6793 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
6794 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6795 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6796 RISCVValidateMachineOperand(MachineOperand::CreateImm(8), &STI, 13 /* uimm5 */)) {
6797 // qc.c.muliadd $rd, $rs1, $uimm
6798 // Operand: rd_wb
6799 // Operand: rd
6800 // Operand: rs1
6801 // Operand: uimm
6802 return true;
6803 } // if
6804 break;
6805 } // case SH3ADD
6806 case RISCV::SH_INX: {
6807 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6808 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6809 RISCVMCRegisterClasses[RISCV::GPRF16CRegClassID].contains(MI.getOperand(0).getReg()) &&
6810 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6811 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6812 MI.getOperand(2).isImm() &&
6813 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 15 /* uimm2_lsb0 */)) {
6814 // c.sh $rs2, ${imm}(${rs1})
6815 // Operand: rs2
6816 // Operand: rs1
6817 // Operand: imm
6818 return true;
6819 } // if
6820 break;
6821 } // case SH_INX
6822 case RISCV::SLLI: {
6823 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6824 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6825 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6826 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6827 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
6828 MI.getOperand(2).isImm() &&
6829 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 6 /* uimmlog2xlennonzero */) &&
6830 MI.getOperand(2).isImm() &&
6831 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 27 /* uimmlog2xlen */)) {
6832 // c.slli $rd, $imm
6833 // Operand: rd_wb
6834 // Operand: rd
6835 // Operand: imm
6836 return true;
6837 } // if
6838 break;
6839 } // case SLLI
6840 case RISCV::SRAI: {
6841 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6842 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6843 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6844 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6845 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6846 MI.getOperand(2).isImm() &&
6847 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 6 /* uimmlog2xlennonzero */) &&
6848 MI.getOperand(2).isImm() &&
6849 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 27 /* uimmlog2xlen */)) {
6850 // c.srai $rs1, $imm
6851 // Operand: rd
6852 // Operand: rs1
6853 // Operand: imm
6854 return true;
6855 } // if
6856 break;
6857 } // case SRAI
6858 case RISCV::SRLI: {
6859 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6860 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6861 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6862 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6863 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6864 MI.getOperand(2).isImm() &&
6865 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 6 /* uimmlog2xlennonzero */) &&
6866 MI.getOperand(2).isImm() &&
6867 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 27 /* uimmlog2xlen */)) {
6868 // c.srli $rs1, $imm
6869 // Operand: rd
6870 // Operand: rs1
6871 // Operand: imm
6872 return true;
6873 } // if
6874 break;
6875 } // case SRLI
6876 case RISCV::SSPOPCHK: {
6877 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcmop] &&
6878 MI.getOperand(0).isReg() &&
6879 (MI.getOperand(0).getReg() == RISCV::X5)) {
6880 // c.sspopchk $rs1
6881 // Operand: rs1
6882 return true;
6883 } // if
6884 break;
6885 } // case SSPOPCHK
6886 case RISCV::SSPUSH: {
6887 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcmop] &&
6888 MI.getOperand(0).isReg() &&
6889 (MI.getOperand(0).getReg() == RISCV::X1)) {
6890 // c.sspush $rs1
6891 // Operand: rs1
6892 return true;
6893 } // if
6894 break;
6895 } // case SSPUSH
6896 case RISCV::SUB: {
6897 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6898 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6899 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6900 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6901 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6902 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6903 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg())) {
6904 // c.sub $rd, $rs2
6905 // Operand: rd_wb
6906 // Operand: rd
6907 // Operand: rs2
6908 return true;
6909 } // if
6910 break;
6911 } // case SUB
6912 case RISCV::SUBW: {
6913 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
6914 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6915 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6916 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6917 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6918 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6919 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6920 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg())) {
6921 // c.subw $rd, $rs2
6922 // Operand: rd_wb
6923 // Operand: rd
6924 // Operand: rs2
6925 return true;
6926 } // if
6927 break;
6928 } // case SUBW
6929 case RISCV::SW: {
6930 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6931 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6932 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6933 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6934 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6935 MI.getOperand(2).isImm() &&
6936 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm7_lsb00 */)) {
6937 // c.sw $rs2, ${imm}(${rs1})
6938 // Operand: rs2
6939 // Operand: rs1
6940 // Operand: imm
6941 return true;
6942 } // if
6943 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6944 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6945 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6946 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6947 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
6948 MI.getOperand(2).isImm() &&
6949 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm8_lsb00 */)) {
6950 // c.swsp $rs2, ${imm}(${rs1})
6951 // Operand: rs2
6952 // Operand: rs1
6953 // Operand: imm
6954 return true;
6955 } // if
6956 break;
6957 } // case SW
6958 case RISCV::SW_INX: {
6959 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6960 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6961 RISCVMCRegisterClasses[RISCV::GPRF32RegClassID].contains(MI.getOperand(0).getReg()) &&
6962 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6963 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
6964 MI.getOperand(2).isImm() &&
6965 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm8_lsb00 */)) {
6966 // c.swsp $rs2, ${imm}(${rs1})
6967 // Operand: rs2
6968 // Operand: rs1
6969 // Operand: imm
6970 return true;
6971 } // if
6972 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6973 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6974 RISCVMCRegisterClasses[RISCV::GPRF32CRegClassID].contains(MI.getOperand(0).getReg()) &&
6975 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6976 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6977 MI.getOperand(2).isImm() &&
6978 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm7_lsb00 */)) {
6979 // c.sw $rs2, ${imm}(${rs1})
6980 // Operand: rs2
6981 // Operand: rs1
6982 // Operand: imm
6983 return true;
6984 } // if
6985 break;
6986 } // case SW_INX
6987 case RISCV::UNIMP: {
6988 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca]) {
6989 // c.unimp
6990 return true;
6991 } // if
6992 break;
6993 } // case UNIMP
6994 case RISCV::XOR: {
6995 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6996 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6997 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6998 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6999 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
7000 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
7001 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg())) {
7002 // c.xor $rd, $rs2
7003 // Operand: rd_wb
7004 // Operand: rd
7005 // Operand: rs2
7006 return true;
7007 } // if
7008 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
7009 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
7010 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
7011 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
7012 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
7013 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7014 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
7015 // c.xor $rd, $rs2
7016 // Operand: rd_wb
7017 // Operand: rd
7018 // Operand: rs2
7019 return true;
7020 } // if
7021 break;
7022 } // case XOR
7023 case RISCV::XORI: {
7024 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
7025 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7026 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7027 MI.getOperand(2).isImm() &&
7028 (MI.getOperand(2).getImm() == -1) &&
7029 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7030 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
7031 // c.not $rd
7032 // Operand: rd_wb
7033 // Operand: rd
7034 return true;
7035 } // if
7036 break;
7037 } // case XORI
7038 case RISCV::ZEXT_H_RV32: {
7039 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
7040 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
7041 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7042 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7043 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7044 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
7045 // c.zext.h $rd
7046 // Operand: rd_wb
7047 // Operand: rd
7048 return true;
7049 } // if
7050 break;
7051 } // case ZEXT_H_RV32
7052 case RISCV::ZEXT_H_RV64: {
7053 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
7054 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
7055 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7056 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7057 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7058 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
7059 // c.zext.h $rd
7060 // Operand: rd_wb
7061 // Operand: rd
7062 return true;
7063 } // if
7064 break;
7065 } // case ZEXT_H_RV64
7066 } // switch
7067 return false;
7068}
7069
7070#endif // GEN_CHECK_COMPRESS_INSTR
7071
7072