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_SHLADD: {
2267 if (STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
2268 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
2269 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
2270 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
2271 MI.getOperand(i: 3).isImm() &&
2272 (MI.getOperand(i: 3).getImm() == 4) &&
2273 MI.getOperand(i: 2).isReg() &&
2274 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg()) &&
2275 MI.getOperand(i: 1).isReg() &&
2276 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2277 RISCVValidateMCOperandForCompress(MCOp: MCOperand::createImm(Val: 16), STI, PredicateIndex: 13 /* uimm5 */)) {
2278 // qc.c.muliadd $rd, $rs1, $uimm
2279 OutInst.setOpcode(RISCV::QC_C_MULIADD);
2280 // Operand: rd_wb
2281 OutInst.addOperand(Op: MI.getOperand(i: 2));
2282 // Operand: rd
2283 OutInst.addOperand(Op: MI.getOperand(i: 2));
2284 // Operand: rs1
2285 OutInst.addOperand(Op: MI.getOperand(i: 1));
2286 // Operand: uimm
2287 OutInst.addOperand(Op: MCOperand::createImm(Val: 16));
2288 OutInst.setLoc(MI.getLoc());
2289 return true;
2290 } // if
2291 break;
2292 } // case QC_SHLADD
2293 case RISCV::QC_SYNC: {
2294 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
2295 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
2296 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 26 /* uimm5slist */)) {
2297 // qc.c.sync $slist
2298 OutInst.setOpcode(RISCV::QC_C_SYNC);
2299 // Operand: slist
2300 OutInst.addOperand(Op: MI.getOperand(i: 0));
2301 OutInst.setLoc(MI.getLoc());
2302 return true;
2303 } // if
2304 break;
2305 } // case QC_SYNC
2306 case RISCV::QC_SYNCR: {
2307 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
2308 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
2309 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 26 /* uimm5slist */)) {
2310 // qc.c.syncr $slist
2311 OutInst.setOpcode(RISCV::QC_C_SYNCR);
2312 // Operand: slist
2313 OutInst.addOperand(Op: MI.getOperand(i: 0));
2314 OutInst.setLoc(MI.getLoc());
2315 return true;
2316 } // if
2317 break;
2318 } // case QC_SYNCR
2319 case RISCV::QC_SYNCWF: {
2320 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
2321 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
2322 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 26 /* uimm5slist */)) {
2323 // qc.c.syncwf $slist
2324 OutInst.setOpcode(RISCV::QC_C_SYNCWF);
2325 // Operand: slist
2326 OutInst.addOperand(Op: MI.getOperand(i: 0));
2327 OutInst.setLoc(MI.getLoc());
2328 return true;
2329 } // if
2330 break;
2331 } // case QC_SYNCWF
2332 case RISCV::QC_SYNCWL: {
2333 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
2334 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
2335 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 26 /* uimm5slist */)) {
2336 // qc.c.syncwl $slist
2337 OutInst.setOpcode(RISCV::QC_C_SYNCWL);
2338 // Operand: slist
2339 OutInst.addOperand(Op: MI.getOperand(i: 0));
2340 OutInst.setLoc(MI.getLoc());
2341 return true;
2342 } // if
2343 break;
2344 } // case QC_SYNCWL
2345 case RISCV::SB: {
2346 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
2347 MI.getOperand(i: 0).isReg() &&
2348 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
2349 MI.getOperand(i: 1).isReg() &&
2350 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2351 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 12 /* uimm2 */)) {
2352 // c.sb $rs2, ${imm}(${rs1})
2353 OutInst.setOpcode(RISCV::C_SB);
2354 // Operand: rs2
2355 OutInst.addOperand(Op: MI.getOperand(i: 0));
2356 // Operand: rs1
2357 OutInst.addOperand(Op: MI.getOperand(i: 1));
2358 // Operand: imm
2359 OutInst.addOperand(Op: MI.getOperand(i: 2));
2360 OutInst.setLoc(MI.getLoc());
2361 return true;
2362 } // if
2363 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
2364 MI.getOperand(i: 0).isReg() &&
2365 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
2366 MI.getOperand(i: 1).isReg() &&
2367 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2368 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 13 /* uimm5 */)) {
2369 // qk.c.sb $rs2, ${imm}(${rs1})
2370 OutInst.setOpcode(RISCV::QK_C_SB);
2371 // Operand: rs2
2372 OutInst.addOperand(Op: MI.getOperand(i: 0));
2373 // Operand: rs1
2374 OutInst.addOperand(Op: MI.getOperand(i: 1));
2375 // Operand: imm
2376 OutInst.addOperand(Op: MI.getOperand(i: 2));
2377 OutInst.setLoc(MI.getLoc());
2378 return true;
2379 } // if
2380 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
2381 MI.getOperand(i: 0).isReg() &&
2382 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
2383 MI.getOperand(i: 1).isReg() &&
2384 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2385 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 14 /* uimm4 */)) {
2386 // qk.c.sbsp $rd_rs2, ${imm}(${rs1})
2387 OutInst.setOpcode(RISCV::QK_C_SBSP);
2388 // Operand: rd_rs2
2389 OutInst.addOperand(Op: MI.getOperand(i: 0));
2390 // Operand: rs1
2391 OutInst.addOperand(Op: MI.getOperand(i: 1));
2392 // Operand: imm
2393 OutInst.addOperand(Op: MI.getOperand(i: 2));
2394 OutInst.setLoc(MI.getLoc());
2395 return true;
2396 } // if
2397 break;
2398 } // case SB
2399 case RISCV::SD: {
2400 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
2401 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2402 MI.getOperand(i: 0).isReg() &&
2403 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
2404 MI.getOperand(i: 1).isReg() &&
2405 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2406 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 7 /* uimm8_lsb000 */)) {
2407 // c.sd $rs2, ${imm}(${rs1})
2408 OutInst.setOpcode(RISCV::C_SD);
2409 // Operand: rs2
2410 OutInst.addOperand(Op: MI.getOperand(i: 0));
2411 // Operand: rs1
2412 OutInst.addOperand(Op: MI.getOperand(i: 1));
2413 // Operand: imm
2414 OutInst.addOperand(Op: MI.getOperand(i: 2));
2415 OutInst.setLoc(MI.getLoc());
2416 return true;
2417 } // if
2418 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
2419 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2420 MI.getOperand(i: 0).isReg() &&
2421 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
2422 MI.getOperand(i: 1).isReg() &&
2423 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2424 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm9_lsb000 */)) {
2425 // c.sdsp $rs2, ${imm}(${rs1})
2426 OutInst.setOpcode(RISCV::C_SDSP);
2427 // Operand: rs2
2428 OutInst.addOperand(Op: MI.getOperand(i: 0));
2429 // Operand: rs1
2430 OutInst.addOperand(Op: MI.getOperand(i: 1));
2431 // Operand: imm
2432 OutInst.addOperand(Op: MI.getOperand(i: 2));
2433 OutInst.setLoc(MI.getLoc());
2434 return true;
2435 } // if
2436 break;
2437 } // case SD
2438 case RISCV::SD_RV32: {
2439 if (STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
2440 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
2441 MI.getOperand(i: 0).isReg() &&
2442 RISCVMCRegisterClasses[RISCV::GPRPairRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
2443 MI.getOperand(i: 1).isReg() &&
2444 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2445 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm9_lsb000 */)) {
2446 // c.sdsp $rs2, ${imm}(${rs1})
2447 OutInst.setOpcode(RISCV::C_SDSP_RV32);
2448 // Operand: rs2
2449 OutInst.addOperand(Op: MI.getOperand(i: 0));
2450 // Operand: rs1
2451 OutInst.addOperand(Op: MI.getOperand(i: 1));
2452 // Operand: imm
2453 OutInst.addOperand(Op: MI.getOperand(i: 2));
2454 OutInst.setLoc(MI.getLoc());
2455 return true;
2456 } // if
2457 if (STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
2458 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
2459 MI.getOperand(i: 0).isReg() &&
2460 RISCVMCRegisterClasses[RISCV::GPRPairCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
2461 MI.getOperand(i: 1).isReg() &&
2462 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2463 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 7 /* uimm8_lsb000 */)) {
2464 // c.sd $rs2, ${imm}(${rs1})
2465 OutInst.setOpcode(RISCV::C_SD_RV32);
2466 // Operand: rs2
2467 OutInst.addOperand(Op: MI.getOperand(i: 0));
2468 // Operand: rs1
2469 OutInst.addOperand(Op: MI.getOperand(i: 1));
2470 // Operand: imm
2471 OutInst.addOperand(Op: MI.getOperand(i: 2));
2472 OutInst.setLoc(MI.getLoc());
2473 return true;
2474 } // if
2475 break;
2476 } // case SD_RV32
2477 case RISCV::SEXT_B: {
2478 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
2479 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
2480 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2481 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2482 MI.getOperand(i: 1).isReg() &&
2483 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg())) {
2484 // c.sext.b $rd
2485 OutInst.setOpcode(RISCV::C_SEXT_B);
2486 // Operand: rd_wb
2487 OutInst.addOperand(Op: MI.getOperand(i: 1));
2488 // Operand: rd
2489 OutInst.addOperand(Op: MI.getOperand(i: 1));
2490 OutInst.setLoc(MI.getLoc());
2491 return true;
2492 } // if
2493 break;
2494 } // case SEXT_B
2495 case RISCV::SEXT_H: {
2496 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
2497 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
2498 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2499 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2500 MI.getOperand(i: 1).isReg() &&
2501 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg())) {
2502 // c.sext.h $rd
2503 OutInst.setOpcode(RISCV::C_SEXT_H);
2504 // Operand: rd_wb
2505 OutInst.addOperand(Op: MI.getOperand(i: 1));
2506 // Operand: rd
2507 OutInst.addOperand(Op: MI.getOperand(i: 1));
2508 OutInst.setLoc(MI.getLoc());
2509 return true;
2510 } // if
2511 break;
2512 } // case SEXT_H
2513 case RISCV::SH: {
2514 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
2515 MI.getOperand(i: 0).isReg() &&
2516 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
2517 MI.getOperand(i: 1).isReg() &&
2518 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2519 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 15 /* uimm2_lsb0 */)) {
2520 // c.sh $rs2, ${imm}(${rs1})
2521 OutInst.setOpcode(RISCV::C_SH);
2522 // Operand: rs2
2523 OutInst.addOperand(Op: MI.getOperand(i: 0));
2524 // Operand: rs1
2525 OutInst.addOperand(Op: MI.getOperand(i: 1));
2526 // Operand: imm
2527 OutInst.addOperand(Op: MI.getOperand(i: 2));
2528 OutInst.setLoc(MI.getLoc());
2529 return true;
2530 } // if
2531 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
2532 MI.getOperand(i: 0).isReg() &&
2533 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
2534 MI.getOperand(i: 1).isReg() &&
2535 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2536 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 16 /* uimm6_lsb0 */)) {
2537 // qk.c.sh $rs2, ${imm}(${rs1})
2538 OutInst.setOpcode(RISCV::QK_C_SH);
2539 // Operand: rs2
2540 OutInst.addOperand(Op: MI.getOperand(i: 0));
2541 // Operand: rs1
2542 OutInst.addOperand(Op: MI.getOperand(i: 1));
2543 // Operand: imm
2544 OutInst.addOperand(Op: MI.getOperand(i: 2));
2545 OutInst.setLoc(MI.getLoc());
2546 return true;
2547 } // if
2548 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
2549 MI.getOperand(i: 0).isReg() &&
2550 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
2551 MI.getOperand(i: 1).isReg() &&
2552 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2553 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 17 /* uimm5_lsb0 */)) {
2554 // qk.c.shsp $rd_rs2, ${imm}(${rs1})
2555 OutInst.setOpcode(RISCV::QK_C_SHSP);
2556 // Operand: rd_rs2
2557 OutInst.addOperand(Op: MI.getOperand(i: 0));
2558 // Operand: rs1
2559 OutInst.addOperand(Op: MI.getOperand(i: 1));
2560 // Operand: imm
2561 OutInst.addOperand(Op: MI.getOperand(i: 2));
2562 OutInst.setLoc(MI.getLoc());
2563 return true;
2564 } // if
2565 break;
2566 } // case SH
2567 case RISCV::SH1ADD: {
2568 if (STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
2569 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
2570 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
2571 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
2572 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
2573 MI.getOperand(i: 2).isReg() &&
2574 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg()) &&
2575 MI.getOperand(i: 1).isReg() &&
2576 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2577 RISCVValidateMCOperandForCompress(MCOp: MCOperand::createImm(Val: 2), STI, PredicateIndex: 13 /* uimm5 */)) {
2578 // qc.c.muliadd $rd, $rs1, $uimm
2579 OutInst.setOpcode(RISCV::QC_C_MULIADD);
2580 // Operand: rd_wb
2581 OutInst.addOperand(Op: MI.getOperand(i: 2));
2582 // Operand: rd
2583 OutInst.addOperand(Op: MI.getOperand(i: 2));
2584 // Operand: rs1
2585 OutInst.addOperand(Op: MI.getOperand(i: 1));
2586 // Operand: uimm
2587 OutInst.addOperand(Op: MCOperand::createImm(Val: 2));
2588 OutInst.setLoc(MI.getLoc());
2589 return true;
2590 } // if
2591 break;
2592 } // case SH1ADD
2593 case RISCV::SH2ADD: {
2594 if (STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
2595 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
2596 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
2597 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
2598 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
2599 MI.getOperand(i: 2).isReg() &&
2600 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg()) &&
2601 MI.getOperand(i: 1).isReg() &&
2602 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2603 RISCVValidateMCOperandForCompress(MCOp: MCOperand::createImm(Val: 4), STI, PredicateIndex: 13 /* uimm5 */)) {
2604 // qc.c.muliadd $rd, $rs1, $uimm
2605 OutInst.setOpcode(RISCV::QC_C_MULIADD);
2606 // Operand: rd_wb
2607 OutInst.addOperand(Op: MI.getOperand(i: 2));
2608 // Operand: rd
2609 OutInst.addOperand(Op: MI.getOperand(i: 2));
2610 // Operand: rs1
2611 OutInst.addOperand(Op: MI.getOperand(i: 1));
2612 // Operand: uimm
2613 OutInst.addOperand(Op: MCOperand::createImm(Val: 4));
2614 OutInst.setLoc(MI.getLoc());
2615 return true;
2616 } // if
2617 break;
2618 } // case SH2ADD
2619 case RISCV::SH3ADD: {
2620 if (STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
2621 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
2622 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
2623 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
2624 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
2625 MI.getOperand(i: 2).isReg() &&
2626 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg()) &&
2627 MI.getOperand(i: 1).isReg() &&
2628 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2629 RISCVValidateMCOperandForCompress(MCOp: MCOperand::createImm(Val: 8), STI, PredicateIndex: 13 /* uimm5 */)) {
2630 // qc.c.muliadd $rd, $rs1, $uimm
2631 OutInst.setOpcode(RISCV::QC_C_MULIADD);
2632 // Operand: rd_wb
2633 OutInst.addOperand(Op: MI.getOperand(i: 2));
2634 // Operand: rd
2635 OutInst.addOperand(Op: MI.getOperand(i: 2));
2636 // Operand: rs1
2637 OutInst.addOperand(Op: MI.getOperand(i: 1));
2638 // Operand: uimm
2639 OutInst.addOperand(Op: MCOperand::createImm(Val: 8));
2640 OutInst.setLoc(MI.getLoc());
2641 return true;
2642 } // if
2643 break;
2644 } // case SH3ADD
2645 case RISCV::SH_INX: {
2646 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
2647 MI.getOperand(i: 0).isReg() &&
2648 RISCVMCRegisterClasses[RISCV::GPRF16CRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
2649 MI.getOperand(i: 1).isReg() &&
2650 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2651 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 15 /* uimm2_lsb0 */)) {
2652 // c.sh $rs2, ${imm}(${rs1})
2653 OutInst.setOpcode(RISCV::C_SH_INX);
2654 // Operand: rs2
2655 OutInst.addOperand(Op: MI.getOperand(i: 0));
2656 // Operand: rs1
2657 OutInst.addOperand(Op: MI.getOperand(i: 1));
2658 // Operand: imm
2659 OutInst.addOperand(Op: MI.getOperand(i: 2));
2660 OutInst.setLoc(MI.getLoc());
2661 return true;
2662 } // if
2663 break;
2664 } // case SH_INX
2665 case RISCV::SLLI: {
2666 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2667 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2668 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2669 MI.getOperand(i: 1).isReg() &&
2670 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2671 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 6 /* uimmlog2xlennonzero */) &&
2672 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 27 /* uimmlog2xlen */)) {
2673 // c.slli $rd, $imm
2674 OutInst.setOpcode(RISCV::C_SLLI);
2675 // Operand: rd_wb
2676 OutInst.addOperand(Op: MI.getOperand(i: 1));
2677 // Operand: rd
2678 OutInst.addOperand(Op: MI.getOperand(i: 1));
2679 // Operand: imm
2680 OutInst.addOperand(Op: MI.getOperand(i: 2));
2681 OutInst.setLoc(MI.getLoc());
2682 return true;
2683 } // if
2684 break;
2685 } // case SLLI
2686 case RISCV::SRAI: {
2687 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2688 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2689 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2690 MI.getOperand(i: 1).isReg() &&
2691 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2692 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 6 /* uimmlog2xlennonzero */) &&
2693 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 27 /* uimmlog2xlen */)) {
2694 // c.srai $rs1, $imm
2695 OutInst.setOpcode(RISCV::C_SRAI);
2696 // Operand: rd
2697 OutInst.addOperand(Op: MI.getOperand(i: 1));
2698 // Operand: rs1
2699 OutInst.addOperand(Op: MI.getOperand(i: 1));
2700 // Operand: imm
2701 OutInst.addOperand(Op: MI.getOperand(i: 2));
2702 OutInst.setLoc(MI.getLoc());
2703 return true;
2704 } // if
2705 break;
2706 } // case SRAI
2707 case RISCV::SRLI: {
2708 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2709 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2710 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2711 MI.getOperand(i: 1).isReg() &&
2712 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2713 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 6 /* uimmlog2xlennonzero */) &&
2714 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 27 /* uimmlog2xlen */)) {
2715 // c.srli $rs1, $imm
2716 OutInst.setOpcode(RISCV::C_SRLI);
2717 // Operand: rd
2718 OutInst.addOperand(Op: MI.getOperand(i: 1));
2719 // Operand: rs1
2720 OutInst.addOperand(Op: MI.getOperand(i: 1));
2721 // Operand: imm
2722 OutInst.addOperand(Op: MI.getOperand(i: 2));
2723 OutInst.setLoc(MI.getLoc());
2724 return true;
2725 } // if
2726 break;
2727 } // case SRLI
2728 case RISCV::SSPOPCHK: {
2729 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcmop] &&
2730 MI.getOperand(i: 0).isReg() &&
2731 (MI.getOperand(i: 0).getReg() == RISCV::X5)) {
2732 // c.sspopchk $rs1
2733 OutInst.setOpcode(RISCV::C_SSPOPCHK);
2734 // Operand: rs1
2735 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X5));
2736 OutInst.setLoc(MI.getLoc());
2737 return true;
2738 } // if
2739 break;
2740 } // case SSPOPCHK
2741 case RISCV::SSPUSH: {
2742 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcmop] &&
2743 MI.getOperand(i: 0).isReg() &&
2744 (MI.getOperand(i: 0).getReg() == RISCV::X1)) {
2745 // c.sspush $rs1
2746 OutInst.setOpcode(RISCV::C_SSPUSH);
2747 // Operand: rs1
2748 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X1));
2749 OutInst.setLoc(MI.getLoc());
2750 return true;
2751 } // if
2752 break;
2753 } // case SSPUSH
2754 case RISCV::SUB: {
2755 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2756 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2757 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2758 MI.getOperand(i: 1).isReg() &&
2759 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2760 MI.getOperand(i: 2).isReg() &&
2761 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg())) {
2762 // c.sub $rd, $rs2
2763 OutInst.setOpcode(RISCV::C_SUB);
2764 // Operand: rd_wb
2765 OutInst.addOperand(Op: MI.getOperand(i: 1));
2766 // Operand: rd
2767 OutInst.addOperand(Op: MI.getOperand(i: 1));
2768 // Operand: rs2
2769 OutInst.addOperand(Op: MI.getOperand(i: 2));
2770 OutInst.setLoc(MI.getLoc());
2771 return true;
2772 } // if
2773 break;
2774 } // case SUB
2775 case RISCV::SUBW: {
2776 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
2777 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2778 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2779 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2780 MI.getOperand(i: 1).isReg() &&
2781 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2782 MI.getOperand(i: 2).isReg() &&
2783 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg())) {
2784 // c.subw $rd, $rs2
2785 OutInst.setOpcode(RISCV::C_SUBW);
2786 // Operand: rd_wb
2787 OutInst.addOperand(Op: MI.getOperand(i: 1));
2788 // Operand: rd
2789 OutInst.addOperand(Op: MI.getOperand(i: 1));
2790 // Operand: rs2
2791 OutInst.addOperand(Op: MI.getOperand(i: 2));
2792 OutInst.setLoc(MI.getLoc());
2793 return true;
2794 } // if
2795 break;
2796 } // case SUBW
2797 case RISCV::SW: {
2798 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2799 MI.getOperand(i: 0).isReg() &&
2800 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
2801 MI.getOperand(i: 1).isReg() &&
2802 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2803 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* uimm7_lsb00 */)) {
2804 // c.sw $rs2, ${imm}(${rs1})
2805 OutInst.setOpcode(RISCV::C_SW);
2806 // Operand: rs2
2807 OutInst.addOperand(Op: MI.getOperand(i: 0));
2808 // Operand: rs1
2809 OutInst.addOperand(Op: MI.getOperand(i: 1));
2810 // Operand: imm
2811 OutInst.addOperand(Op: MI.getOperand(i: 2));
2812 OutInst.setLoc(MI.getLoc());
2813 return true;
2814 } // if
2815 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2816 MI.getOperand(i: 0).isReg() &&
2817 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
2818 MI.getOperand(i: 1).isReg() &&
2819 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2820 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm8_lsb00 */)) {
2821 // c.swsp $rs2, ${imm}(${rs1})
2822 OutInst.setOpcode(RISCV::C_SWSP);
2823 // Operand: rs2
2824 OutInst.addOperand(Op: MI.getOperand(i: 0));
2825 // Operand: rs1
2826 OutInst.addOperand(Op: MI.getOperand(i: 1));
2827 // Operand: imm
2828 OutInst.addOperand(Op: MI.getOperand(i: 2));
2829 OutInst.setLoc(MI.getLoc());
2830 return true;
2831 } // if
2832 break;
2833 } // case SW
2834 case RISCV::SW_INX: {
2835 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2836 MI.getOperand(i: 0).isReg() &&
2837 RISCVMCRegisterClasses[RISCV::GPRF32CRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
2838 MI.getOperand(i: 1).isReg() &&
2839 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2840 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* uimm7_lsb00 */)) {
2841 // c.sw $rs2, ${imm}(${rs1})
2842 OutInst.setOpcode(RISCV::C_SW_INX);
2843 // Operand: rs2
2844 OutInst.addOperand(Op: MI.getOperand(i: 0));
2845 // Operand: rs1
2846 OutInst.addOperand(Op: MI.getOperand(i: 1));
2847 // Operand: imm
2848 OutInst.addOperand(Op: MI.getOperand(i: 2));
2849 OutInst.setLoc(MI.getLoc());
2850 return true;
2851 } // if
2852 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2853 MI.getOperand(i: 0).isReg() &&
2854 RISCVMCRegisterClasses[RISCV::GPRF32RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
2855 MI.getOperand(i: 1).isReg() &&
2856 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2857 RISCVValidateMCOperandForCompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm8_lsb00 */)) {
2858 // c.swsp $rs2, ${imm}(${rs1})
2859 OutInst.setOpcode(RISCV::C_SWSP_INX);
2860 // Operand: rs2
2861 OutInst.addOperand(Op: MI.getOperand(i: 0));
2862 // Operand: rs1
2863 OutInst.addOperand(Op: MI.getOperand(i: 1));
2864 // Operand: imm
2865 OutInst.addOperand(Op: MI.getOperand(i: 2));
2866 OutInst.setLoc(MI.getLoc());
2867 return true;
2868 } // if
2869 break;
2870 } // case SW_INX
2871 case RISCV::UNIMP: {
2872 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca]) {
2873 // c.unimp
2874 OutInst.setOpcode(RISCV::C_UNIMP);
2875 OutInst.setLoc(MI.getLoc());
2876 return true;
2877 } // if
2878 break;
2879 } // case UNIMP
2880 case RISCV::XOR: {
2881 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2882 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2883 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2884 MI.getOperand(i: 1).isReg() &&
2885 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
2886 MI.getOperand(i: 2).isReg() &&
2887 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg())) {
2888 // c.xor $rd, $rs2
2889 OutInst.setOpcode(RISCV::C_XOR);
2890 // Operand: rd_wb
2891 OutInst.addOperand(Op: MI.getOperand(i: 1));
2892 // Operand: rd
2893 OutInst.addOperand(Op: MI.getOperand(i: 1));
2894 // Operand: rs2
2895 OutInst.addOperand(Op: MI.getOperand(i: 2));
2896 OutInst.setLoc(MI.getLoc());
2897 return true;
2898 } // if
2899 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
2900 MI.getOperand(i: 2).isReg() && MI.getOperand(i: 0).isReg() &&
2901 (MI.getOperand(i: 2).getReg() == MI.getOperand(i: 0).getReg()) &&
2902 MI.getOperand(i: 2).isReg() &&
2903 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg()) &&
2904 MI.getOperand(i: 1).isReg() &&
2905 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg())) {
2906 // c.xor $rd, $rs2
2907 OutInst.setOpcode(RISCV::C_XOR);
2908 // Operand: rd_wb
2909 OutInst.addOperand(Op: MI.getOperand(i: 2));
2910 // Operand: rd
2911 OutInst.addOperand(Op: MI.getOperand(i: 2));
2912 // Operand: rs2
2913 OutInst.addOperand(Op: MI.getOperand(i: 1));
2914 OutInst.setLoc(MI.getLoc());
2915 return true;
2916 } // if
2917 break;
2918 } // case XOR
2919 case RISCV::XORI: {
2920 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
2921 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2922 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2923 MI.getOperand(i: 2).isImm() &&
2924 (MI.getOperand(i: 2).getImm() == -1) &&
2925 MI.getOperand(i: 1).isReg() &&
2926 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg())) {
2927 // c.not $rd
2928 OutInst.setOpcode(RISCV::C_NOT);
2929 // Operand: rd_wb
2930 OutInst.addOperand(Op: MI.getOperand(i: 1));
2931 // Operand: rd
2932 OutInst.addOperand(Op: MI.getOperand(i: 1));
2933 OutInst.setLoc(MI.getLoc());
2934 return true;
2935 } // if
2936 break;
2937 } // case XORI
2938 case RISCV::ZEXT_H_RV32: {
2939 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
2940 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
2941 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2942 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2943 MI.getOperand(i: 1).isReg() &&
2944 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg())) {
2945 // c.zext.h $rd
2946 OutInst.setOpcode(RISCV::C_ZEXT_H);
2947 // Operand: rd_wb
2948 OutInst.addOperand(Op: MI.getOperand(i: 1));
2949 // Operand: rd
2950 OutInst.addOperand(Op: MI.getOperand(i: 1));
2951 OutInst.setLoc(MI.getLoc());
2952 return true;
2953 } // if
2954 break;
2955 } // case ZEXT_H_RV32
2956 case RISCV::ZEXT_H_RV64: {
2957 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
2958 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
2959 MI.getOperand(i: 1).isReg() && MI.getOperand(i: 0).isReg() &&
2960 (MI.getOperand(i: 1).getReg() == MI.getOperand(i: 0).getReg()) &&
2961 MI.getOperand(i: 1).isReg() &&
2962 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg())) {
2963 // c.zext.h $rd
2964 OutInst.setOpcode(RISCV::C_ZEXT_H);
2965 // Operand: rd_wb
2966 OutInst.addOperand(Op: MI.getOperand(i: 1));
2967 // Operand: rd
2968 OutInst.addOperand(Op: MI.getOperand(i: 1));
2969 OutInst.setLoc(MI.getLoc());
2970 return true;
2971 } // if
2972 break;
2973 } // case ZEXT_H_RV64
2974 } // switch
2975 return false;
2976}
2977
2978#endif // GEN_COMPRESS_INSTR
2979
2980#ifdef GEN_UNCOMPRESS_INSTR
2981#undef GEN_UNCOMPRESS_INSTR
2982
2983static bool RISCVValidateMCOperandForUncompress(const MCOperand &MCOp,
2984 const MCSubtargetInfo &STI,
2985 unsigned PredicateIndex) {
2986 switch (PredicateIndex) {
2987 default:
2988 llvm_unreachable("Unknown MCOperandPredicate kind");
2989 break;
2990 case 1: {
2991 // simm6nonzero
2992 int64_t Imm;
2993 if (MCOp.evaluateAsConstantImm(Imm))
2994 return (Imm != 0) && isInt<6>(x: Imm);
2995 return MCOp.isBareSymbolRef();
2996 }
2997 case 2: {
2998 // simm12_lo
2999 int64_t Imm;
3000 if (MCOp.evaluateAsConstantImm(Imm))
3001 return isInt<12>(x: Imm);
3002 return MCOp.isBareSymbolRef();
3003 }
3004 case 3: {
3005 // simm10_lsb0000nonzero
3006 int64_t Imm;
3007 if (!MCOp.evaluateAsConstantImm(Imm))
3008 return false;
3009 return isShiftedInt<6, 4>(x: Imm) && (Imm != 0);
3010 }
3011 case 4: {
3012 // uimm10_lsb00nonzero
3013 int64_t Imm;
3014 if (!MCOp.evaluateAsConstantImm(Imm))
3015 return false;
3016 return isShiftedUInt<8, 2>(x: Imm) && (Imm != 0);
3017 }
3018 case 5: {
3019 // simm6
3020 int64_t Imm;
3021 if (MCOp.evaluateAsConstantImm(Imm))
3022 return isInt<6>(x: Imm);
3023 return MCOp.isBareSymbolRef();
3024 }
3025 case 6: {
3026 // bare_simm9_lsb0
3027 int64_t Imm;
3028 if (MCOp.evaluateAsConstantImm(Imm))
3029 return isShiftedInt<8, 1>(x: Imm);
3030 return MCOp.isBareSymbolRef();
3031 }
3032 case 7: {
3033 // bare_simm13_lsb0
3034 int64_t Imm;
3035 if (MCOp.evaluateAsConstantImm(Imm))
3036 return isShiftedInt<12, 1>(x: Imm);
3037 return MCOp.isBareSymbolRef();
3038 }
3039 case 8: {
3040 // uimm8_lsb000
3041 int64_t Imm;
3042 if (!MCOp.evaluateAsConstantImm(Imm))
3043 return false;
3044 return isShiftedUInt<5, 3>(x: Imm);
3045 }
3046 case 9: {
3047 // uimm9_lsb000
3048 int64_t Imm;
3049 if (!MCOp.evaluateAsConstantImm(Imm))
3050 return false;
3051 return isShiftedUInt<6, 3>(x: Imm);
3052 }
3053 case 10: {
3054 // uimm7_lsb00
3055 int64_t Imm;
3056 if (!MCOp.evaluateAsConstantImm(Imm))
3057 return false;
3058 return isShiftedUInt<5, 2>(x: Imm);
3059 }
3060 case 11: {
3061 // uimm8_lsb00
3062 int64_t Imm;
3063 if (!MCOp.evaluateAsConstantImm(Imm))
3064 return false;
3065 return isShiftedUInt<6, 2>(x: Imm);
3066 }
3067 case 12: {
3068 // bare_simm12_lsb0
3069 int64_t Imm;
3070 if (MCOp.evaluateAsConstantImm(Imm))
3071 return isShiftedInt<11, 1>(x: Imm);
3072 return MCOp.isBareSymbolRef();
3073 }
3074 case 13: {
3075 // simm21_lsb0_jal
3076 int64_t Imm;
3077 if (MCOp.evaluateAsConstantImm(Imm))
3078 return isShiftedInt<20, 1>(x: Imm);
3079 return MCOp.isBareSymbolRef();
3080 }
3081 case 14: {
3082 // uimm2
3083 int64_t Imm;
3084 if (!MCOp.evaluateAsConstantImm(Imm))
3085 return false;
3086 return isUInt<2>(x: Imm);
3087 }
3088 case 15: {
3089 // uimm2_lsb0
3090 int64_t Imm;
3091 if (!MCOp.evaluateAsConstantImm(Imm))
3092 return false;
3093 return isShiftedUInt<1, 1>(x: Imm);
3094 }
3095 case 16: {
3096 // simm20_li
3097 int64_t Imm;
3098 if (MCOp.evaluateAsConstantImm(Imm))
3099 return isInt<20>(x: Imm);
3100 return MCOp.isBareSymbolRef();
3101 }
3102 case 17: {
3103 // c_lui_imm
3104 int64_t Imm;
3105 if (!MCOp.evaluateAsConstantImm(Imm))
3106 return false;
3107 return (Imm != 0) && (isUInt<5>(x: Imm) ||
3108 (Imm >= 0xfffe0 && Imm <= 0xfffff));
3109 }
3110 case 18: {
3111 // uimm20_lui
3112 int64_t Imm;
3113 if (MCOp.evaluateAsConstantImm(Imm))
3114 return isUInt<20>(x: Imm);
3115 return MCOp.isBareSymbolRef();
3116 }
3117 case 19: {
3118 // uimmlog2xlennonzero
3119 int64_t Imm;
3120 if (!MCOp.evaluateAsConstantImm(Imm))
3121 return false;
3122 if (STI.getTargetTriple().isArch64Bit())
3123 return isUInt<6>(x: Imm) && (Imm != 0);
3124 return isUInt<5>(x: Imm) && (Imm != 0);
3125 }
3126 case 20: {
3127 // uimmlog2xlen
3128 int64_t Imm;
3129 if (!MCOp.evaluateAsConstantImm(Imm))
3130 return false;
3131 if (STI.getTargetTriple().isArch64Bit())
3132 return isUInt<6>(x: Imm);
3133 return isUInt<5>(x: Imm);
3134 }
3135 case 21: {
3136 // uimm5ge6_plus1
3137 int64_t Imm;
3138 if (!MCOp.evaluateAsConstantImm(Imm))
3139 return false;
3140 return Imm >= 6 && Imm <= 32;
3141 }
3142 case 22: {
3143 // uimm5_plus1
3144 int64_t Imm;
3145 if (!MCOp.evaluateAsConstantImm(Imm))
3146 return false;
3147 return Imm > 0 && isUInt<5>(x: Imm - 1);
3148 }
3149 case 23: {
3150 // uimm5
3151 int64_t Imm;
3152 if (!MCOp.evaluateAsConstantImm(Imm))
3153 return false;
3154 return isUInt<5>(x: Imm);
3155 }
3156 case 24: {
3157 // simm5
3158 int64_t Imm;
3159 if (MCOp.evaluateAsConstantImm(Imm))
3160 return isInt<5>(x: Imm);
3161 return MCOp.isBareSymbolRef();
3162 }
3163 case 25: {
3164 // uimm5slist
3165 int64_t Imm;
3166 if (!MCOp.evaluateAsConstantImm(Imm))
3167 return false;
3168 return ((Imm == 0) || (Imm == 1) ||
3169 (Imm == 2) || (Imm == 4) ||
3170 (Imm == 8) || (Imm == 16) ||
3171 (Imm == 15) || (Imm == 31));
3172 }
3173 case 26: {
3174 // uimm4
3175 int64_t Imm;
3176 if (!MCOp.evaluateAsConstantImm(Imm))
3177 return false;
3178 return isUInt<4>(x: Imm);
3179 }
3180 case 27: {
3181 // uimm6_lsb0
3182 int64_t Imm;
3183 if (!MCOp.evaluateAsConstantImm(Imm))
3184 return false;
3185 return isShiftedUInt<5, 1>(x: Imm);
3186 }
3187 case 28: {
3188 // uimm5_lsb0
3189 int64_t Imm;
3190 if (!MCOp.evaluateAsConstantImm(Imm))
3191 return false;
3192 return isShiftedUInt<4, 1>(x: Imm);
3193 }
3194 }
3195}
3196
3197static bool uncompressInst(MCInst &OutInst,
3198 const MCInst &MI,
3199 const MCSubtargetInfo &STI) {
3200 switch (MI.getOpcode()) {
3201 default: return false;
3202 case RISCV::C_ADD: {
3203 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3204 MI.getOperand(i: 0).isReg() &&
3205 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3206 MI.getOperand(i: 0).isReg() &&
3207 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3208 MI.getOperand(i: 2).isReg() &&
3209 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 2).getReg())) {
3210 // add $rd, $rs1, $rs2
3211 OutInst.setOpcode(RISCV::ADD);
3212 // Operand: rd
3213 OutInst.addOperand(Op: MI.getOperand(i: 0));
3214 // Operand: rs1
3215 OutInst.addOperand(Op: MI.getOperand(i: 0));
3216 // Operand: rs2
3217 OutInst.addOperand(Op: MI.getOperand(i: 2));
3218 OutInst.setLoc(MI.getLoc());
3219 return true;
3220 } // if
3221 break;
3222 } // case C_ADD
3223 case RISCV::C_ADDI: {
3224 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3225 MI.getOperand(i: 0).isReg() &&
3226 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3227 MI.getOperand(i: 0).isReg() &&
3228 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3229 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 1 /* simm6nonzero */) &&
3230 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3231 // addi $rd, $rs1, $imm12
3232 OutInst.setOpcode(RISCV::ADDI);
3233 // Operand: rd
3234 OutInst.addOperand(Op: MI.getOperand(i: 0));
3235 // Operand: rs1
3236 OutInst.addOperand(Op: MI.getOperand(i: 0));
3237 // Operand: imm12
3238 OutInst.addOperand(Op: MI.getOperand(i: 2));
3239 OutInst.setLoc(MI.getLoc());
3240 return true;
3241 } // if
3242 break;
3243 } // case C_ADDI
3244 case RISCV::C_ADDI16SP: {
3245 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3246 MI.getOperand(i: 0).isReg() &&
3247 (MI.getOperand(i: 0).getReg() == RISCV::X2) &&
3248 MI.getOperand(i: 1).isReg() &&
3249 (MI.getOperand(i: 1).getReg() == RISCV::X2) &&
3250 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 3 /* simm10_lsb0000nonzero */) &&
3251 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3252 // addi $rd, $rs1, $imm12
3253 OutInst.setOpcode(RISCV::ADDI);
3254 // Operand: rd
3255 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X2));
3256 // Operand: rs1
3257 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X2));
3258 // Operand: imm12
3259 OutInst.addOperand(Op: MI.getOperand(i: 2));
3260 OutInst.setLoc(MI.getLoc());
3261 return true;
3262 } // if
3263 break;
3264 } // case C_ADDI16SP
3265 case RISCV::C_ADDI4SPN: {
3266 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3267 MI.getOperand(i: 0).isReg() &&
3268 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3269 MI.getOperand(i: 1).isReg() &&
3270 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3271 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 4 /* uimm10_lsb00nonzero */) &&
3272 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3273 // addi $rd, $rs1, $imm12
3274 OutInst.setOpcode(RISCV::ADDI);
3275 // Operand: rd
3276 OutInst.addOperand(Op: MI.getOperand(i: 0));
3277 // Operand: rs1
3278 OutInst.addOperand(Op: MI.getOperand(i: 1));
3279 // Operand: imm12
3280 OutInst.addOperand(Op: MI.getOperand(i: 2));
3281 OutInst.setLoc(MI.getLoc());
3282 return true;
3283 } // if
3284 break;
3285 } // case C_ADDI4SPN
3286 case RISCV::C_ADDIW: {
3287 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
3288 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3289 MI.getOperand(i: 0).isReg() &&
3290 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3291 MI.getOperand(i: 0).isReg() &&
3292 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3293 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 5 /* simm6 */) &&
3294 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3295 // addiw $rd, $rs1, $imm12
3296 OutInst.setOpcode(RISCV::ADDIW);
3297 // Operand: rd
3298 OutInst.addOperand(Op: MI.getOperand(i: 0));
3299 // Operand: rs1
3300 OutInst.addOperand(Op: MI.getOperand(i: 0));
3301 // Operand: imm12
3302 OutInst.addOperand(Op: MI.getOperand(i: 2));
3303 OutInst.setLoc(MI.getLoc());
3304 return true;
3305 } // if
3306 break;
3307 } // case C_ADDIW
3308 case RISCV::C_ADDW: {
3309 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
3310 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3311 MI.getOperand(i: 0).isReg() &&
3312 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3313 MI.getOperand(i: 0).isReg() &&
3314 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3315 MI.getOperand(i: 2).isReg() &&
3316 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg())) {
3317 // addw $rd, $rs1, $rs2
3318 OutInst.setOpcode(RISCV::ADDW);
3319 // Operand: rd
3320 OutInst.addOperand(Op: MI.getOperand(i: 0));
3321 // Operand: rs1
3322 OutInst.addOperand(Op: MI.getOperand(i: 0));
3323 // Operand: rs2
3324 OutInst.addOperand(Op: MI.getOperand(i: 2));
3325 OutInst.setLoc(MI.getLoc());
3326 return true;
3327 } // if
3328 break;
3329 } // case C_ADDW
3330 case RISCV::C_AND: {
3331 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3332 MI.getOperand(i: 0).isReg() &&
3333 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3334 MI.getOperand(i: 0).isReg() &&
3335 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3336 MI.getOperand(i: 2).isReg() &&
3337 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg())) {
3338 // and $rd, $rs1, $rs2
3339 OutInst.setOpcode(RISCV::AND);
3340 // Operand: rd
3341 OutInst.addOperand(Op: MI.getOperand(i: 0));
3342 // Operand: rs1
3343 OutInst.addOperand(Op: MI.getOperand(i: 0));
3344 // Operand: rs2
3345 OutInst.addOperand(Op: MI.getOperand(i: 2));
3346 OutInst.setLoc(MI.getLoc());
3347 return true;
3348 } // if
3349 break;
3350 } // case C_AND
3351 case RISCV::C_ANDI: {
3352 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3353 MI.getOperand(i: 0).isReg() &&
3354 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3355 MI.getOperand(i: 0).isReg() &&
3356 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3357 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 5 /* simm6 */) &&
3358 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3359 // andi $rd, $rs1, $imm12
3360 OutInst.setOpcode(RISCV::ANDI);
3361 // Operand: rd
3362 OutInst.addOperand(Op: MI.getOperand(i: 0));
3363 // Operand: rs1
3364 OutInst.addOperand(Op: MI.getOperand(i: 0));
3365 // Operand: imm12
3366 OutInst.addOperand(Op: MI.getOperand(i: 2));
3367 OutInst.setLoc(MI.getLoc());
3368 return true;
3369 } // if
3370 break;
3371 } // case C_ANDI
3372 case RISCV::C_BEQZ: {
3373 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3374 MI.getOperand(i: 0).isReg() &&
3375 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3376 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 6 /* bare_simm9_lsb0 */) &&
3377 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 7 /* bare_simm13_lsb0 */)) {
3378 // beq $rs1, $rs2, $imm12
3379 OutInst.setOpcode(RISCV::BEQ);
3380 // Operand: rs1
3381 OutInst.addOperand(Op: MI.getOperand(i: 0));
3382 // Operand: rs2
3383 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
3384 // Operand: imm12
3385 OutInst.addOperand(Op: MI.getOperand(i: 1));
3386 OutInst.setLoc(MI.getLoc());
3387 return true;
3388 } // if
3389 break;
3390 } // case C_BEQZ
3391 case RISCV::C_BNEZ: {
3392 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3393 MI.getOperand(i: 0).isReg() &&
3394 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3395 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 6 /* bare_simm9_lsb0 */) &&
3396 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 7 /* bare_simm13_lsb0 */)) {
3397 // bne $rs1, $rs2, $imm12
3398 OutInst.setOpcode(RISCV::BNE);
3399 // Operand: rs1
3400 OutInst.addOperand(Op: MI.getOperand(i: 0));
3401 // Operand: rs2
3402 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
3403 // Operand: imm12
3404 OutInst.addOperand(Op: MI.getOperand(i: 1));
3405 OutInst.setLoc(MI.getLoc());
3406 return true;
3407 } // if
3408 break;
3409 } // case C_BNEZ
3410 case RISCV::C_EBREAK: {
3411 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca]) {
3412 // ebreak
3413 OutInst.setOpcode(RISCV::EBREAK);
3414 OutInst.setLoc(MI.getLoc());
3415 return true;
3416 } // if
3417 break;
3418 } // case C_EBREAK
3419 case RISCV::C_FLD: {
3420 if (STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
3421 STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
3422 MI.getOperand(i: 0).isReg() &&
3423 RISCVMCRegisterClasses[RISCV::FPR64CRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3424 MI.getOperand(i: 1).isReg() &&
3425 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3426 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000 */) &&
3427 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3428 // fld $rd, ${imm12}(${rs1})
3429 OutInst.setOpcode(RISCV::FLD);
3430 // Operand: rd
3431 OutInst.addOperand(Op: MI.getOperand(i: 0));
3432 // Operand: rs1
3433 OutInst.addOperand(Op: MI.getOperand(i: 1));
3434 // Operand: imm12
3435 OutInst.addOperand(Op: MI.getOperand(i: 2));
3436 OutInst.setLoc(MI.getLoc());
3437 return true;
3438 } // if
3439 break;
3440 } // case C_FLD
3441 case RISCV::C_FLDSP: {
3442 if (STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
3443 STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
3444 MI.getOperand(i: 0).isReg() &&
3445 RISCVMCRegisterClasses[RISCV::FPR64RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3446 MI.getOperand(i: 1).isReg() &&
3447 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3448 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* uimm9_lsb000 */) &&
3449 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3450 // fld $rd, ${imm12}(${rs1})
3451 OutInst.setOpcode(RISCV::FLD);
3452 // Operand: rd
3453 OutInst.addOperand(Op: MI.getOperand(i: 0));
3454 // Operand: rs1
3455 OutInst.addOperand(Op: MI.getOperand(i: 1));
3456 // Operand: imm12
3457 OutInst.addOperand(Op: MI.getOperand(i: 2));
3458 OutInst.setLoc(MI.getLoc());
3459 return true;
3460 } // if
3461 break;
3462 } // case C_FLDSP
3463 case RISCV::C_FLW: {
3464 if (STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
3465 STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
3466 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
3467 MI.getOperand(i: 0).isReg() &&
3468 RISCVMCRegisterClasses[RISCV::FPR32CRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3469 MI.getOperand(i: 1).isReg() &&
3470 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3471 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm7_lsb00 */) &&
3472 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3473 // flw $rd, ${imm12}(${rs1})
3474 OutInst.setOpcode(RISCV::FLW);
3475 // Operand: rd
3476 OutInst.addOperand(Op: MI.getOperand(i: 0));
3477 // Operand: rs1
3478 OutInst.addOperand(Op: MI.getOperand(i: 1));
3479 // Operand: imm12
3480 OutInst.addOperand(Op: MI.getOperand(i: 2));
3481 OutInst.setLoc(MI.getLoc());
3482 return true;
3483 } // if
3484 break;
3485 } // case C_FLW
3486 case RISCV::C_FLWSP: {
3487 if (STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
3488 STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
3489 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
3490 MI.getOperand(i: 0).isReg() &&
3491 RISCVMCRegisterClasses[RISCV::FPR32RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3492 MI.getOperand(i: 1).isReg() &&
3493 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3494 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 11 /* uimm8_lsb00 */) &&
3495 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3496 // flw $rd, ${imm12}(${rs1})
3497 OutInst.setOpcode(RISCV::FLW);
3498 // Operand: rd
3499 OutInst.addOperand(Op: MI.getOperand(i: 0));
3500 // Operand: rs1
3501 OutInst.addOperand(Op: MI.getOperand(i: 1));
3502 // Operand: imm12
3503 OutInst.addOperand(Op: MI.getOperand(i: 2));
3504 OutInst.setLoc(MI.getLoc());
3505 return true;
3506 } // if
3507 break;
3508 } // case C_FLWSP
3509 case RISCV::C_FSD: {
3510 if (STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
3511 STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
3512 MI.getOperand(i: 0).isReg() &&
3513 RISCVMCRegisterClasses[RISCV::FPR64CRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3514 MI.getOperand(i: 1).isReg() &&
3515 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3516 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000 */) &&
3517 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3518 // fsd $rs2, ${imm12}(${rs1})
3519 OutInst.setOpcode(RISCV::FSD);
3520 // Operand: rs2
3521 OutInst.addOperand(Op: MI.getOperand(i: 0));
3522 // Operand: rs1
3523 OutInst.addOperand(Op: MI.getOperand(i: 1));
3524 // Operand: imm12
3525 OutInst.addOperand(Op: MI.getOperand(i: 2));
3526 OutInst.setLoc(MI.getLoc());
3527 return true;
3528 } // if
3529 break;
3530 } // case C_FSD
3531 case RISCV::C_FSDSP: {
3532 if (STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
3533 STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
3534 MI.getOperand(i: 0).isReg() &&
3535 RISCVMCRegisterClasses[RISCV::FPR64RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3536 MI.getOperand(i: 1).isReg() &&
3537 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3538 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* uimm9_lsb000 */) &&
3539 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3540 // fsd $rs2, ${imm12}(${rs1})
3541 OutInst.setOpcode(RISCV::FSD);
3542 // Operand: rs2
3543 OutInst.addOperand(Op: MI.getOperand(i: 0));
3544 // Operand: rs1
3545 OutInst.addOperand(Op: MI.getOperand(i: 1));
3546 // Operand: imm12
3547 OutInst.addOperand(Op: MI.getOperand(i: 2));
3548 OutInst.setLoc(MI.getLoc());
3549 return true;
3550 } // if
3551 break;
3552 } // case C_FSDSP
3553 case RISCV::C_FSW: {
3554 if (STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
3555 STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
3556 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
3557 MI.getOperand(i: 0).isReg() &&
3558 RISCVMCRegisterClasses[RISCV::FPR32CRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3559 MI.getOperand(i: 1).isReg() &&
3560 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3561 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm7_lsb00 */) &&
3562 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3563 // fsw $rs2, ${imm12}(${rs1})
3564 OutInst.setOpcode(RISCV::FSW);
3565 // Operand: rs2
3566 OutInst.addOperand(Op: MI.getOperand(i: 0));
3567 // Operand: rs1
3568 OutInst.addOperand(Op: MI.getOperand(i: 1));
3569 // Operand: imm12
3570 OutInst.addOperand(Op: MI.getOperand(i: 2));
3571 OutInst.setLoc(MI.getLoc());
3572 return true;
3573 } // if
3574 break;
3575 } // case C_FSW
3576 case RISCV::C_FSWSP: {
3577 if (STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
3578 STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
3579 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
3580 MI.getOperand(i: 0).isReg() &&
3581 RISCVMCRegisterClasses[RISCV::FPR32RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3582 MI.getOperand(i: 1).isReg() &&
3583 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3584 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 11 /* uimm8_lsb00 */) &&
3585 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3586 // fsw $rs2, ${imm12}(${rs1})
3587 OutInst.setOpcode(RISCV::FSW);
3588 // Operand: rs2
3589 OutInst.addOperand(Op: MI.getOperand(i: 0));
3590 // Operand: rs1
3591 OutInst.addOperand(Op: MI.getOperand(i: 1));
3592 // Operand: imm12
3593 OutInst.addOperand(Op: MI.getOperand(i: 2));
3594 OutInst.setLoc(MI.getLoc());
3595 return true;
3596 } // if
3597 break;
3598 } // case C_FSWSP
3599 case RISCV::C_J: {
3600 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3601 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 12 /* bare_simm12_lsb0 */) &&
3602 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 13 /* simm21_lsb0_jal */)) {
3603 // jal $rd, $imm20
3604 OutInst.setOpcode(RISCV::JAL);
3605 // Operand: rd
3606 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
3607 // Operand: imm20
3608 OutInst.addOperand(Op: MI.getOperand(i: 0));
3609 OutInst.setLoc(MI.getLoc());
3610 return true;
3611 } // if
3612 break;
3613 } // case C_J
3614 case RISCV::C_JAL: {
3615 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3616 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
3617 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 12 /* bare_simm12_lsb0 */) &&
3618 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 13 /* simm21_lsb0_jal */)) {
3619 // jal $rd, $imm20
3620 OutInst.setOpcode(RISCV::JAL);
3621 // Operand: rd
3622 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X1));
3623 // Operand: imm20
3624 OutInst.addOperand(Op: MI.getOperand(i: 0));
3625 OutInst.setLoc(MI.getLoc());
3626 return true;
3627 } // if
3628 break;
3629 } // case C_JAL
3630 case RISCV::C_JALR: {
3631 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3632 MI.getOperand(i: 0).isReg() &&
3633 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3634 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: 0), STI, PredicateIndex: 2 /* simm12_lo */)) {
3635 // jalr $rd, ${imm12}(${rs1})
3636 OutInst.setOpcode(RISCV::JALR);
3637 // Operand: rd
3638 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X1));
3639 // Operand: rs1
3640 OutInst.addOperand(Op: MI.getOperand(i: 0));
3641 // Operand: imm12
3642 OutInst.addOperand(Op: MCOperand::createImm(Val: 0));
3643 OutInst.setLoc(MI.getLoc());
3644 return true;
3645 } // if
3646 break;
3647 } // case C_JALR
3648 case RISCV::C_JR: {
3649 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3650 MI.getOperand(i: 0).isReg() &&
3651 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3652 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: 0), STI, PredicateIndex: 2 /* simm12_lo */)) {
3653 // jalr $rd, ${imm12}(${rs1})
3654 OutInst.setOpcode(RISCV::JALR);
3655 // Operand: rd
3656 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
3657 // Operand: rs1
3658 OutInst.addOperand(Op: MI.getOperand(i: 0));
3659 // Operand: imm12
3660 OutInst.addOperand(Op: MCOperand::createImm(Val: 0));
3661 OutInst.setLoc(MI.getLoc());
3662 return true;
3663 } // if
3664 break;
3665 } // case C_JR
3666 case RISCV::C_LBU: {
3667 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
3668 MI.getOperand(i: 0).isReg() &&
3669 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3670 MI.getOperand(i: 1).isReg() &&
3671 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3672 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 14 /* uimm2 */) &&
3673 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3674 // lbu $rd, ${imm12}(${rs1})
3675 OutInst.setOpcode(RISCV::LBU);
3676 // Operand: rd
3677 OutInst.addOperand(Op: MI.getOperand(i: 0));
3678 // Operand: rs1
3679 OutInst.addOperand(Op: MI.getOperand(i: 1));
3680 // Operand: imm12
3681 OutInst.addOperand(Op: MI.getOperand(i: 2));
3682 OutInst.setLoc(MI.getLoc());
3683 return true;
3684 } // if
3685 break;
3686 } // case C_LBU
3687 case RISCV::C_LD: {
3688 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
3689 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3690 MI.getOperand(i: 0).isReg() &&
3691 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3692 MI.getOperand(i: 1).isReg() &&
3693 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3694 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000 */) &&
3695 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3696 // ld $rd, ${imm12}(${rs1})
3697 OutInst.setOpcode(RISCV::LD);
3698 // Operand: rd
3699 OutInst.addOperand(Op: MI.getOperand(i: 0));
3700 // Operand: rs1
3701 OutInst.addOperand(Op: MI.getOperand(i: 1));
3702 // Operand: imm12
3703 OutInst.addOperand(Op: MI.getOperand(i: 2));
3704 OutInst.setLoc(MI.getLoc());
3705 return true;
3706 } // if
3707 break;
3708 } // case C_LD
3709 case RISCV::C_LDSP: {
3710 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
3711 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3712 MI.getOperand(i: 0).isReg() &&
3713 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3714 MI.getOperand(i: 1).isReg() &&
3715 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3716 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* uimm9_lsb000 */) &&
3717 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3718 // ld $rd, ${imm12}(${rs1})
3719 OutInst.setOpcode(RISCV::LD);
3720 // Operand: rd
3721 OutInst.addOperand(Op: MI.getOperand(i: 0));
3722 // Operand: rs1
3723 OutInst.addOperand(Op: MI.getOperand(i: 1));
3724 // Operand: imm12
3725 OutInst.addOperand(Op: MI.getOperand(i: 2));
3726 OutInst.setLoc(MI.getLoc());
3727 return true;
3728 } // if
3729 break;
3730 } // case C_LDSP
3731 case RISCV::C_LDSP_RV32: {
3732 if (STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
3733 STI.getFeatureBits()[RISCV::FeatureStdExtZilsd] &&
3734 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
3735 MI.getOperand(i: 0).isReg() &&
3736 RISCVMCRegisterClasses[RISCV::GPRPairNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3737 MI.getOperand(i: 1).isReg() &&
3738 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3739 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* uimm9_lsb000 */) &&
3740 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3741 // ld $rd, ${imm12}(${rs1})
3742 OutInst.setOpcode(RISCV::LD_RV32);
3743 // Operand: rd
3744 OutInst.addOperand(Op: MI.getOperand(i: 0));
3745 // Operand: rs1
3746 OutInst.addOperand(Op: MI.getOperand(i: 1));
3747 // Operand: imm12
3748 OutInst.addOperand(Op: MI.getOperand(i: 2));
3749 OutInst.setLoc(MI.getLoc());
3750 return true;
3751 } // if
3752 break;
3753 } // case C_LDSP_RV32
3754 case RISCV::C_LD_RV32: {
3755 if (STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
3756 STI.getFeatureBits()[RISCV::FeatureStdExtZilsd] &&
3757 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
3758 MI.getOperand(i: 0).isReg() &&
3759 RISCVMCRegisterClasses[RISCV::GPRPairCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3760 MI.getOperand(i: 1).isReg() &&
3761 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3762 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000 */) &&
3763 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3764 // ld $rd, ${imm12}(${rs1})
3765 OutInst.setOpcode(RISCV::LD_RV32);
3766 // Operand: rd
3767 OutInst.addOperand(Op: MI.getOperand(i: 0));
3768 // Operand: rs1
3769 OutInst.addOperand(Op: MI.getOperand(i: 1));
3770 // Operand: imm12
3771 OutInst.addOperand(Op: MI.getOperand(i: 2));
3772 OutInst.setLoc(MI.getLoc());
3773 return true;
3774 } // if
3775 break;
3776 } // case C_LD_RV32
3777 case RISCV::C_LH: {
3778 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
3779 MI.getOperand(i: 0).isReg() &&
3780 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3781 MI.getOperand(i: 1).isReg() &&
3782 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3783 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 15 /* uimm2_lsb0 */) &&
3784 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3785 // lh $rd, ${imm12}(${rs1})
3786 OutInst.setOpcode(RISCV::LH);
3787 // Operand: rd
3788 OutInst.addOperand(Op: MI.getOperand(i: 0));
3789 // Operand: rs1
3790 OutInst.addOperand(Op: MI.getOperand(i: 1));
3791 // Operand: imm12
3792 OutInst.addOperand(Op: MI.getOperand(i: 2));
3793 OutInst.setLoc(MI.getLoc());
3794 return true;
3795 } // if
3796 break;
3797 } // case C_LH
3798 case RISCV::C_LHU: {
3799 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
3800 MI.getOperand(i: 0).isReg() &&
3801 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3802 MI.getOperand(i: 1).isReg() &&
3803 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3804 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 15 /* uimm2_lsb0 */) &&
3805 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3806 // lhu $rd, ${imm12}(${rs1})
3807 OutInst.setOpcode(RISCV::LHU);
3808 // Operand: rd
3809 OutInst.addOperand(Op: MI.getOperand(i: 0));
3810 // Operand: rs1
3811 OutInst.addOperand(Op: MI.getOperand(i: 1));
3812 // Operand: imm12
3813 OutInst.addOperand(Op: MI.getOperand(i: 2));
3814 OutInst.setLoc(MI.getLoc());
3815 return true;
3816 } // if
3817 break;
3818 } // case C_LHU
3819 case RISCV::C_LI: {
3820 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3821 MI.getOperand(i: 0).isReg() &&
3822 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3823 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 5 /* simm6 */) &&
3824 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 2 /* simm12_lo */)) {
3825 // addi $rd, $rs1, $imm12
3826 OutInst.setOpcode(RISCV::ADDI);
3827 // Operand: rd
3828 OutInst.addOperand(Op: MI.getOperand(i: 0));
3829 // Operand: rs1
3830 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
3831 // Operand: imm12
3832 OutInst.addOperand(Op: MI.getOperand(i: 1));
3833 OutInst.setLoc(MI.getLoc());
3834 return true;
3835 } // if
3836 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcili] &&
3837 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
3838 MI.getOperand(i: 0).isReg() &&
3839 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3840 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 5 /* simm6 */) &&
3841 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 16 /* simm20_li */)) {
3842 // qc.li $rd, $imm20
3843 OutInst.setOpcode(RISCV::QC_LI);
3844 // Operand: rd
3845 OutInst.addOperand(Op: MI.getOperand(i: 0));
3846 // Operand: imm20
3847 OutInst.addOperand(Op: MI.getOperand(i: 1));
3848 OutInst.setLoc(MI.getLoc());
3849 return true;
3850 } // if
3851 break;
3852 } // case C_LI
3853 case RISCV::C_LUI: {
3854 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3855 MI.getOperand(i: 0).isReg() &&
3856 RISCVMCRegisterClasses[RISCV::GPRNoX0X2RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3857 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 17 /* c_lui_imm */) &&
3858 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 1), STI, PredicateIndex: 18 /* uimm20_lui */)) {
3859 // lui $rd, $imm20
3860 OutInst.setOpcode(RISCV::LUI);
3861 // Operand: rd
3862 OutInst.addOperand(Op: MI.getOperand(i: 0));
3863 // Operand: imm20
3864 OutInst.addOperand(Op: MI.getOperand(i: 1));
3865 OutInst.setLoc(MI.getLoc());
3866 return true;
3867 } // if
3868 break;
3869 } // case C_LUI
3870 case RISCV::C_LW: {
3871 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3872 MI.getOperand(i: 0).isReg() &&
3873 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3874 MI.getOperand(i: 1).isReg() &&
3875 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3876 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm7_lsb00 */) &&
3877 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3878 // lw $rd, ${imm12}(${rs1})
3879 OutInst.setOpcode(RISCV::LW);
3880 // Operand: rd
3881 OutInst.addOperand(Op: MI.getOperand(i: 0));
3882 // Operand: rs1
3883 OutInst.addOperand(Op: MI.getOperand(i: 1));
3884 // Operand: imm12
3885 OutInst.addOperand(Op: MI.getOperand(i: 2));
3886 OutInst.setLoc(MI.getLoc());
3887 return true;
3888 } // if
3889 break;
3890 } // case C_LW
3891 case RISCV::C_LWSP: {
3892 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3893 MI.getOperand(i: 0).isReg() &&
3894 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3895 MI.getOperand(i: 1).isReg() &&
3896 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3897 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 11 /* uimm8_lsb00 */) &&
3898 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
3899 // lw $rd, ${imm12}(${rs1})
3900 OutInst.setOpcode(RISCV::LW);
3901 // Operand: rd
3902 OutInst.addOperand(Op: MI.getOperand(i: 0));
3903 // Operand: rs1
3904 OutInst.addOperand(Op: MI.getOperand(i: 1));
3905 // Operand: imm12
3906 OutInst.addOperand(Op: MI.getOperand(i: 2));
3907 OutInst.setLoc(MI.getLoc());
3908 return true;
3909 } // if
3910 break;
3911 } // case C_LWSP
3912 case RISCV::C_MUL: {
3913 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
3914 STI.getFeatureBits()[RISCV::FeatureStdExtZmmul] &&
3915 MI.getOperand(i: 0).isReg() &&
3916 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3917 MI.getOperand(i: 0).isReg() &&
3918 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3919 MI.getOperand(i: 2).isReg() &&
3920 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg())) {
3921 // mul $rd, $rs1, $rs2
3922 OutInst.setOpcode(RISCV::MUL);
3923 // Operand: rd
3924 OutInst.addOperand(Op: MI.getOperand(i: 0));
3925 // Operand: rs1
3926 OutInst.addOperand(Op: MI.getOperand(i: 0));
3927 // Operand: rs2
3928 OutInst.addOperand(Op: MI.getOperand(i: 2));
3929 OutInst.setLoc(MI.getLoc());
3930 return true;
3931 } // if
3932 break;
3933 } // case C_MUL
3934 case RISCV::C_MV: {
3935 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3936 MI.getOperand(i: 0).isReg() &&
3937 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3938 MI.getOperand(i: 1).isReg() &&
3939 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
3940 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: 0), STI, PredicateIndex: 2 /* simm12_lo */)) {
3941 // addi $rd, $rs1, $imm12
3942 OutInst.setOpcode(RISCV::ADDI);
3943 // Operand: rd
3944 OutInst.addOperand(Op: MI.getOperand(i: 0));
3945 // Operand: rs1
3946 OutInst.addOperand(Op: MI.getOperand(i: 1));
3947 // Operand: imm12
3948 OutInst.addOperand(Op: MCOperand::createImm(Val: 0));
3949 OutInst.setLoc(MI.getLoc());
3950 return true;
3951 } // if
3952 break;
3953 } // case C_MV
3954 case RISCV::C_NOP: {
3955 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3956 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: 0), STI, PredicateIndex: 2 /* simm12_lo */)) {
3957 // addi $rd, $rs1, $imm12
3958 OutInst.setOpcode(RISCV::ADDI);
3959 // Operand: rd
3960 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
3961 // Operand: rs1
3962 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
3963 // Operand: imm12
3964 OutInst.addOperand(Op: MCOperand::createImm(Val: 0));
3965 OutInst.setLoc(MI.getLoc());
3966 return true;
3967 } // if
3968 break;
3969 } // case C_NOP
3970 case RISCV::C_NOT: {
3971 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
3972 MI.getOperand(i: 0).isReg() &&
3973 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3974 MI.getOperand(i: 0).isReg() &&
3975 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3976 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: -1), STI, PredicateIndex: 2 /* simm12_lo */)) {
3977 // xori $rd, $rs1, $imm12
3978 OutInst.setOpcode(RISCV::XORI);
3979 // Operand: rd
3980 OutInst.addOperand(Op: MI.getOperand(i: 0));
3981 // Operand: rs1
3982 OutInst.addOperand(Op: MI.getOperand(i: 0));
3983 // Operand: imm12
3984 OutInst.addOperand(Op: MCOperand::createImm(Val: -1));
3985 OutInst.setLoc(MI.getLoc());
3986 return true;
3987 } // if
3988 break;
3989 } // case C_NOT
3990 case RISCV::C_OR: {
3991 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
3992 MI.getOperand(i: 0).isReg() &&
3993 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3994 MI.getOperand(i: 0).isReg() &&
3995 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
3996 MI.getOperand(i: 2).isReg() &&
3997 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg())) {
3998 // or $rd, $rs1, $rs2
3999 OutInst.setOpcode(RISCV::OR);
4000 // Operand: rd
4001 OutInst.addOperand(Op: MI.getOperand(i: 0));
4002 // Operand: rs1
4003 OutInst.addOperand(Op: MI.getOperand(i: 0));
4004 // Operand: rs2
4005 OutInst.addOperand(Op: MI.getOperand(i: 2));
4006 OutInst.setLoc(MI.getLoc());
4007 return true;
4008 } // if
4009 break;
4010 } // case C_OR
4011 case RISCV::C_SB: {
4012 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4013 MI.getOperand(i: 0).isReg() &&
4014 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4015 MI.getOperand(i: 1).isReg() &&
4016 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4017 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 14 /* uimm2 */) &&
4018 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4019 // sb $rs2, ${imm12}(${rs1})
4020 OutInst.setOpcode(RISCV::SB);
4021 // Operand: rs2
4022 OutInst.addOperand(Op: MI.getOperand(i: 0));
4023 // Operand: rs1
4024 OutInst.addOperand(Op: MI.getOperand(i: 1));
4025 // Operand: imm12
4026 OutInst.addOperand(Op: MI.getOperand(i: 2));
4027 OutInst.setLoc(MI.getLoc());
4028 return true;
4029 } // if
4030 break;
4031 } // case C_SB
4032 case RISCV::C_SD: {
4033 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
4034 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4035 MI.getOperand(i: 0).isReg() &&
4036 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4037 MI.getOperand(i: 1).isReg() &&
4038 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4039 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000 */) &&
4040 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4041 // sd $rs2, ${imm12}(${rs1})
4042 OutInst.setOpcode(RISCV::SD);
4043 // Operand: rs2
4044 OutInst.addOperand(Op: MI.getOperand(i: 0));
4045 // Operand: rs1
4046 OutInst.addOperand(Op: MI.getOperand(i: 1));
4047 // Operand: imm12
4048 OutInst.addOperand(Op: MI.getOperand(i: 2));
4049 OutInst.setLoc(MI.getLoc());
4050 return true;
4051 } // if
4052 break;
4053 } // case C_SD
4054 case RISCV::C_SDSP: {
4055 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
4056 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4057 MI.getOperand(i: 0).isReg() &&
4058 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4059 MI.getOperand(i: 1).isReg() &&
4060 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4061 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* uimm9_lsb000 */) &&
4062 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4063 // sd $rs2, ${imm12}(${rs1})
4064 OutInst.setOpcode(RISCV::SD);
4065 // Operand: rs2
4066 OutInst.addOperand(Op: MI.getOperand(i: 0));
4067 // Operand: rs1
4068 OutInst.addOperand(Op: MI.getOperand(i: 1));
4069 // Operand: imm12
4070 OutInst.addOperand(Op: MI.getOperand(i: 2));
4071 OutInst.setLoc(MI.getLoc());
4072 return true;
4073 } // if
4074 break;
4075 } // case C_SDSP
4076 case RISCV::C_SDSP_RV32: {
4077 if (STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
4078 STI.getFeatureBits()[RISCV::FeatureStdExtZilsd] &&
4079 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4080 MI.getOperand(i: 0).isReg() &&
4081 RISCVMCRegisterClasses[RISCV::GPRPairRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4082 MI.getOperand(i: 1).isReg() &&
4083 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4084 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 9 /* uimm9_lsb000 */) &&
4085 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4086 // sd $rs2, ${imm12}(${rs1})
4087 OutInst.setOpcode(RISCV::SD_RV32);
4088 // Operand: rs2
4089 OutInst.addOperand(Op: MI.getOperand(i: 0));
4090 // Operand: rs1
4091 OutInst.addOperand(Op: MI.getOperand(i: 1));
4092 // Operand: imm12
4093 OutInst.addOperand(Op: MI.getOperand(i: 2));
4094 OutInst.setLoc(MI.getLoc());
4095 return true;
4096 } // if
4097 break;
4098 } // case C_SDSP_RV32
4099 case RISCV::C_SD_RV32: {
4100 if (STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
4101 STI.getFeatureBits()[RISCV::FeatureStdExtZilsd] &&
4102 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4103 MI.getOperand(i: 0).isReg() &&
4104 RISCVMCRegisterClasses[RISCV::GPRPairCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4105 MI.getOperand(i: 1).isReg() &&
4106 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4107 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 8 /* uimm8_lsb000 */) &&
4108 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4109 // sd $rs2, ${imm12}(${rs1})
4110 OutInst.setOpcode(RISCV::SD_RV32);
4111 // Operand: rs2
4112 OutInst.addOperand(Op: MI.getOperand(i: 0));
4113 // Operand: rs1
4114 OutInst.addOperand(Op: MI.getOperand(i: 1));
4115 // Operand: imm12
4116 OutInst.addOperand(Op: MI.getOperand(i: 2));
4117 OutInst.setLoc(MI.getLoc());
4118 return true;
4119 } // if
4120 break;
4121 } // case C_SD_RV32
4122 case RISCV::C_SEXT_B: {
4123 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
4124 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4125 MI.getOperand(i: 0).isReg() &&
4126 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4127 MI.getOperand(i: 0).isReg() &&
4128 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg())) {
4129 // sext.b $rd, $rs1
4130 OutInst.setOpcode(RISCV::SEXT_B);
4131 // Operand: rd
4132 OutInst.addOperand(Op: MI.getOperand(i: 0));
4133 // Operand: rs1
4134 OutInst.addOperand(Op: MI.getOperand(i: 0));
4135 OutInst.setLoc(MI.getLoc());
4136 return true;
4137 } // if
4138 break;
4139 } // case C_SEXT_B
4140 case RISCV::C_SEXT_H: {
4141 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
4142 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4143 MI.getOperand(i: 0).isReg() &&
4144 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4145 MI.getOperand(i: 0).isReg() &&
4146 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg())) {
4147 // sext.h $rd, $rs1
4148 OutInst.setOpcode(RISCV::SEXT_H);
4149 // Operand: rd
4150 OutInst.addOperand(Op: MI.getOperand(i: 0));
4151 // Operand: rs1
4152 OutInst.addOperand(Op: MI.getOperand(i: 0));
4153 OutInst.setLoc(MI.getLoc());
4154 return true;
4155 } // if
4156 break;
4157 } // case C_SEXT_H
4158 case RISCV::C_SH: {
4159 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4160 MI.getOperand(i: 0).isReg() &&
4161 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4162 MI.getOperand(i: 1).isReg() &&
4163 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4164 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 15 /* uimm2_lsb0 */) &&
4165 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4166 // sh $rs2, ${imm12}(${rs1})
4167 OutInst.setOpcode(RISCV::SH);
4168 // Operand: rs2
4169 OutInst.addOperand(Op: MI.getOperand(i: 0));
4170 // Operand: rs1
4171 OutInst.addOperand(Op: MI.getOperand(i: 1));
4172 // Operand: imm12
4173 OutInst.addOperand(Op: MI.getOperand(i: 2));
4174 OutInst.setLoc(MI.getLoc());
4175 return true;
4176 } // if
4177 break;
4178 } // case C_SH
4179 case RISCV::C_SLLI: {
4180 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4181 MI.getOperand(i: 0).isReg() &&
4182 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4183 MI.getOperand(i: 0).isReg() &&
4184 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4185 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 19 /* uimmlog2xlennonzero */) &&
4186 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 20 /* uimmlog2xlen */)) {
4187 // slli $rd, $rs1, $shamt
4188 OutInst.setOpcode(RISCV::SLLI);
4189 // Operand: rd
4190 OutInst.addOperand(Op: MI.getOperand(i: 0));
4191 // Operand: rs1
4192 OutInst.addOperand(Op: MI.getOperand(i: 0));
4193 // Operand: shamt
4194 OutInst.addOperand(Op: MI.getOperand(i: 2));
4195 OutInst.setLoc(MI.getLoc());
4196 return true;
4197 } // if
4198 break;
4199 } // case C_SLLI
4200 case RISCV::C_SRAI: {
4201 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4202 MI.getOperand(i: 0).isReg() &&
4203 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4204 MI.getOperand(i: 0).isReg() &&
4205 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4206 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 19 /* uimmlog2xlennonzero */) &&
4207 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 20 /* uimmlog2xlen */)) {
4208 // srai $rd, $rs1, $shamt
4209 OutInst.setOpcode(RISCV::SRAI);
4210 // Operand: rd
4211 OutInst.addOperand(Op: MI.getOperand(i: 0));
4212 // Operand: rs1
4213 OutInst.addOperand(Op: MI.getOperand(i: 0));
4214 // Operand: shamt
4215 OutInst.addOperand(Op: MI.getOperand(i: 2));
4216 OutInst.setLoc(MI.getLoc());
4217 return true;
4218 } // if
4219 break;
4220 } // case C_SRAI
4221 case RISCV::C_SRLI: {
4222 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4223 MI.getOperand(i: 0).isReg() &&
4224 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4225 MI.getOperand(i: 0).isReg() &&
4226 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4227 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 19 /* uimmlog2xlennonzero */) &&
4228 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 20 /* uimmlog2xlen */)) {
4229 // srli $rd, $rs1, $shamt
4230 OutInst.setOpcode(RISCV::SRLI);
4231 // Operand: rd
4232 OutInst.addOperand(Op: MI.getOperand(i: 0));
4233 // Operand: rs1
4234 OutInst.addOperand(Op: MI.getOperand(i: 0));
4235 // Operand: shamt
4236 OutInst.addOperand(Op: MI.getOperand(i: 2));
4237 OutInst.setLoc(MI.getLoc());
4238 return true;
4239 } // if
4240 break;
4241 } // case C_SRLI
4242 case RISCV::C_SSPOPCHK: {
4243 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcmop] &&
4244 STI.getFeatureBits()[RISCV::FeatureStdExtZimop] &&
4245 MI.getOperand(i: 0).isReg() &&
4246 (MI.getOperand(i: 0).getReg() == RISCV::X5)) {
4247 // sspopchk $rs1
4248 OutInst.setOpcode(RISCV::SSPOPCHK);
4249 // Operand: rs1
4250 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X5));
4251 OutInst.setLoc(MI.getLoc());
4252 return true;
4253 } // if
4254 break;
4255 } // case C_SSPOPCHK
4256 case RISCV::C_SSPUSH: {
4257 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcmop] &&
4258 STI.getFeatureBits()[RISCV::FeatureStdExtZimop] &&
4259 MI.getOperand(i: 0).isReg() &&
4260 (MI.getOperand(i: 0).getReg() == RISCV::X1)) {
4261 // sspush $rs2
4262 OutInst.setOpcode(RISCV::SSPUSH);
4263 // Operand: rs2
4264 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X1));
4265 OutInst.setLoc(MI.getLoc());
4266 return true;
4267 } // if
4268 break;
4269 } // case C_SSPUSH
4270 case RISCV::C_SUB: {
4271 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4272 MI.getOperand(i: 0).isReg() &&
4273 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4274 MI.getOperand(i: 0).isReg() &&
4275 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4276 MI.getOperand(i: 2).isReg() &&
4277 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg())) {
4278 // sub $rd, $rs1, $rs2
4279 OutInst.setOpcode(RISCV::SUB);
4280 // Operand: rd
4281 OutInst.addOperand(Op: MI.getOperand(i: 0));
4282 // Operand: rs1
4283 OutInst.addOperand(Op: MI.getOperand(i: 0));
4284 // Operand: rs2
4285 OutInst.addOperand(Op: MI.getOperand(i: 2));
4286 OutInst.setLoc(MI.getLoc());
4287 return true;
4288 } // if
4289 break;
4290 } // case C_SUB
4291 case RISCV::C_SUBW: {
4292 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
4293 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4294 MI.getOperand(i: 0).isReg() &&
4295 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4296 MI.getOperand(i: 0).isReg() &&
4297 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4298 MI.getOperand(i: 2).isReg() &&
4299 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg())) {
4300 // subw $rd, $rs1, $rs2
4301 OutInst.setOpcode(RISCV::SUBW);
4302 // Operand: rd
4303 OutInst.addOperand(Op: MI.getOperand(i: 0));
4304 // Operand: rs1
4305 OutInst.addOperand(Op: MI.getOperand(i: 0));
4306 // Operand: rs2
4307 OutInst.addOperand(Op: MI.getOperand(i: 2));
4308 OutInst.setLoc(MI.getLoc());
4309 return true;
4310 } // if
4311 break;
4312 } // case C_SUBW
4313 case RISCV::C_SW: {
4314 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4315 MI.getOperand(i: 0).isReg() &&
4316 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4317 MI.getOperand(i: 1).isReg() &&
4318 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4319 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 10 /* uimm7_lsb00 */) &&
4320 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4321 // sw $rs2, ${imm12}(${rs1})
4322 OutInst.setOpcode(RISCV::SW);
4323 // Operand: rs2
4324 OutInst.addOperand(Op: MI.getOperand(i: 0));
4325 // Operand: rs1
4326 OutInst.addOperand(Op: MI.getOperand(i: 1));
4327 // Operand: imm12
4328 OutInst.addOperand(Op: MI.getOperand(i: 2));
4329 OutInst.setLoc(MI.getLoc());
4330 return true;
4331 } // if
4332 break;
4333 } // case C_SW
4334 case RISCV::C_SWSP: {
4335 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4336 MI.getOperand(i: 0).isReg() &&
4337 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4338 MI.getOperand(i: 1).isReg() &&
4339 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4340 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 11 /* uimm8_lsb00 */) &&
4341 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4342 // sw $rs2, ${imm12}(${rs1})
4343 OutInst.setOpcode(RISCV::SW);
4344 // Operand: rs2
4345 OutInst.addOperand(Op: MI.getOperand(i: 0));
4346 // Operand: rs1
4347 OutInst.addOperand(Op: MI.getOperand(i: 1));
4348 // Operand: imm12
4349 OutInst.addOperand(Op: MI.getOperand(i: 2));
4350 OutInst.setLoc(MI.getLoc());
4351 return true;
4352 } // if
4353 break;
4354 } // case C_SWSP
4355 case RISCV::C_UNIMP: {
4356 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca]) {
4357 // unimp
4358 OutInst.setOpcode(RISCV::UNIMP);
4359 OutInst.setLoc(MI.getLoc());
4360 return true;
4361 } // if
4362 break;
4363 } // case C_UNIMP
4364 case RISCV::C_XOR: {
4365 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4366 MI.getOperand(i: 0).isReg() &&
4367 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4368 MI.getOperand(i: 0).isReg() &&
4369 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4370 MI.getOperand(i: 2).isReg() &&
4371 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg())) {
4372 // xor $rd, $rs1, $rs2
4373 OutInst.setOpcode(RISCV::XOR);
4374 // Operand: rd
4375 OutInst.addOperand(Op: MI.getOperand(i: 0));
4376 // Operand: rs1
4377 OutInst.addOperand(Op: MI.getOperand(i: 0));
4378 // Operand: rs2
4379 OutInst.addOperand(Op: MI.getOperand(i: 2));
4380 OutInst.setLoc(MI.getLoc());
4381 return true;
4382 } // if
4383 break;
4384 } // case C_XOR
4385 case RISCV::C_ZEXT_B: {
4386 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4387 MI.getOperand(i: 0).isReg() &&
4388 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4389 MI.getOperand(i: 0).isReg() &&
4390 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4391 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: 255), STI, PredicateIndex: 2 /* simm12_lo */)) {
4392 // andi $rd, $rs1, $imm12
4393 OutInst.setOpcode(RISCV::ANDI);
4394 // Operand: rd
4395 OutInst.addOperand(Op: MI.getOperand(i: 0));
4396 // Operand: rs1
4397 OutInst.addOperand(Op: MI.getOperand(i: 0));
4398 // Operand: imm12
4399 OutInst.addOperand(Op: MCOperand::createImm(Val: 255));
4400 OutInst.setLoc(MI.getLoc());
4401 return true;
4402 } // if
4403 break;
4404 } // case C_ZEXT_B
4405 case RISCV::C_ZEXT_H: {
4406 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
4407 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4408 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4409 (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] || STI.getFeatureBits()[RISCV::FeatureStdExtZbkb]) &&
4410 MI.getOperand(i: 0).isReg() &&
4411 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4412 MI.getOperand(i: 0).isReg() &&
4413 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg())) {
4414 // zext.h $rd, $rs1
4415 OutInst.setOpcode(RISCV::ZEXT_H_RV32);
4416 // Operand: rd
4417 OutInst.addOperand(Op: MI.getOperand(i: 0));
4418 // Operand: rs1
4419 OutInst.addOperand(Op: MI.getOperand(i: 0));
4420 OutInst.setLoc(MI.getLoc());
4421 return true;
4422 } // if
4423 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
4424 STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
4425 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4426 (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] || STI.getFeatureBits()[RISCV::FeatureStdExtZbkb]) &&
4427 MI.getOperand(i: 0).isReg() &&
4428 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4429 MI.getOperand(i: 0).isReg() &&
4430 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg())) {
4431 // zext.h $rd, $rs1
4432 OutInst.setOpcode(RISCV::ZEXT_H_RV64);
4433 // Operand: rd
4434 OutInst.addOperand(Op: MI.getOperand(i: 0));
4435 // Operand: rs1
4436 OutInst.addOperand(Op: MI.getOperand(i: 0));
4437 OutInst.setLoc(MI.getLoc());
4438 return true;
4439 } // if
4440 break;
4441 } // case C_ZEXT_H
4442 case RISCV::C_ZEXT_W: {
4443 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
4444 STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
4445 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
4446 MI.getOperand(i: 0).isReg() &&
4447 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4448 MI.getOperand(i: 0).isReg() &&
4449 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg())) {
4450 // add.uw $rd, $rs1, $rs2
4451 OutInst.setOpcode(RISCV::ADD_UW);
4452 // Operand: rd
4453 OutInst.addOperand(Op: MI.getOperand(i: 0));
4454 // Operand: rs1
4455 OutInst.addOperand(Op: MI.getOperand(i: 0));
4456 // Operand: rs2
4457 OutInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
4458 OutInst.setLoc(MI.getLoc());
4459 return true;
4460 } // if
4461 break;
4462 } // case C_ZEXT_W
4463 case RISCV::QC_C_BEXTI: {
4464 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
4465 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
4466 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4467 MI.getOperand(i: 0).isReg() &&
4468 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4469 MI.getOperand(i: 0).isReg() &&
4470 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4471 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 19 /* uimmlog2xlennonzero */) &&
4472 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 20 /* uimmlog2xlen */)) {
4473 // bexti $rd, $rs1, $shamt
4474 OutInst.setOpcode(RISCV::BEXTI);
4475 // Operand: rd
4476 OutInst.addOperand(Op: MI.getOperand(i: 0));
4477 // Operand: rs1
4478 OutInst.addOperand(Op: MI.getOperand(i: 0));
4479 // Operand: shamt
4480 OutInst.addOperand(Op: MI.getOperand(i: 2));
4481 OutInst.setLoc(MI.getLoc());
4482 return true;
4483 } // if
4484 break;
4485 } // case QC_C_BEXTI
4486 case RISCV::QC_C_BSETI: {
4487 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
4488 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
4489 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4490 MI.getOperand(i: 0).isReg() &&
4491 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4492 MI.getOperand(i: 0).isReg() &&
4493 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4494 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 19 /* uimmlog2xlennonzero */) &&
4495 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 20 /* uimmlog2xlen */)) {
4496 // bseti $rd, $rs1, $shamt
4497 OutInst.setOpcode(RISCV::BSETI);
4498 // Operand: rd
4499 OutInst.addOperand(Op: MI.getOperand(i: 0));
4500 // Operand: rs1
4501 OutInst.addOperand(Op: MI.getOperand(i: 0));
4502 // Operand: shamt
4503 OutInst.addOperand(Op: MI.getOperand(i: 2));
4504 OutInst.setLoc(MI.getLoc());
4505 return true;
4506 } // if
4507 break;
4508 } // case QC_C_BSETI
4509 case RISCV::QC_C_EXTU: {
4510 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
4511 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4512 MI.getOperand(i: 0).isReg() &&
4513 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4514 MI.getOperand(i: 0).isReg() &&
4515 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4516 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 21 /* uimm5ge6_plus1 */) &&
4517 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 22 /* uimm5_plus1 */) &&
4518 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: 0), STI, PredicateIndex: 23 /* uimm5 */)) {
4519 // qc.extu $rd, $rs1, $width, $shamt
4520 OutInst.setOpcode(RISCV::QC_EXTU);
4521 // Operand: rd
4522 OutInst.addOperand(Op: MI.getOperand(i: 0));
4523 // Operand: rs1
4524 OutInst.addOperand(Op: MI.getOperand(i: 0));
4525 // Operand: width
4526 OutInst.addOperand(Op: MI.getOperand(i: 2));
4527 // Operand: shamt
4528 OutInst.addOperand(Op: MCOperand::createImm(Val: 0));
4529 OutInst.setLoc(MI.getLoc());
4530 return true;
4531 } // if
4532 break;
4533 } // case QC_C_EXTU
4534 case RISCV::QC_C_MVEQZ: {
4535 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcicm] &&
4536 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4537 MI.getOperand(i: 0).isReg() &&
4538 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4539 MI.getOperand(i: 0).isReg() &&
4540 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4541 RISCVValidateMCOperandForUncompress(MCOp: MCOperand::createImm(Val: 0), STI, PredicateIndex: 24 /* simm5 */) &&
4542 MI.getOperand(i: 2).isReg() &&
4543 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 2).getReg())) {
4544 // qc.mveqi $rd, $rs1, $imm, $rs3
4545 OutInst.setOpcode(RISCV::QC_MVEQI);
4546 // Operand: rd_wb
4547 OutInst.addOperand(Op: MI.getOperand(i: 0));
4548 // Operand: rd
4549 OutInst.addOperand(Op: MI.getOperand(i: 0));
4550 // Operand: rs1
4551 OutInst.addOperand(Op: MI.getOperand(i: 0));
4552 // Operand: imm
4553 OutInst.addOperand(Op: MCOperand::createImm(Val: 0));
4554 // Operand: rs3
4555 OutInst.addOperand(Op: MI.getOperand(i: 2));
4556 OutInst.setLoc(MI.getLoc());
4557 return true;
4558 } // if
4559 break;
4560 } // case QC_C_MVEQZ
4561 case RISCV::QC_C_SYNC: {
4562 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
4563 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4564 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 25 /* uimm5slist */) &&
4565 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 23 /* uimm5 */)) {
4566 // qc.sync $imm5
4567 OutInst.setOpcode(RISCV::QC_SYNC);
4568 // Operand: imm5
4569 OutInst.addOperand(Op: MI.getOperand(i: 0));
4570 OutInst.setLoc(MI.getLoc());
4571 return true;
4572 } // if
4573 break;
4574 } // case QC_C_SYNC
4575 case RISCV::QC_C_SYNCR: {
4576 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
4577 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4578 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 25 /* uimm5slist */) &&
4579 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 23 /* uimm5 */)) {
4580 // qc.syncr $imm5
4581 OutInst.setOpcode(RISCV::QC_SYNCR);
4582 // Operand: imm5
4583 OutInst.addOperand(Op: MI.getOperand(i: 0));
4584 OutInst.setLoc(MI.getLoc());
4585 return true;
4586 } // if
4587 break;
4588 } // case QC_C_SYNCR
4589 case RISCV::QC_C_SYNCWF: {
4590 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
4591 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4592 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 25 /* uimm5slist */) &&
4593 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 23 /* uimm5 */)) {
4594 // qc.syncwf $imm5
4595 OutInst.setOpcode(RISCV::QC_SYNCWF);
4596 // Operand: imm5
4597 OutInst.addOperand(Op: MI.getOperand(i: 0));
4598 OutInst.setLoc(MI.getLoc());
4599 return true;
4600 } // if
4601 break;
4602 } // case QC_C_SYNCWF
4603 case RISCV::QC_C_SYNCWL: {
4604 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
4605 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
4606 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 25 /* uimm5slist */) &&
4607 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 0), STI, PredicateIndex: 23 /* uimm5 */)) {
4608 // qc.syncwl $imm5
4609 OutInst.setOpcode(RISCV::QC_SYNCWL);
4610 // Operand: imm5
4611 OutInst.addOperand(Op: MI.getOperand(i: 0));
4612 OutInst.setLoc(MI.getLoc());
4613 return true;
4614 } // if
4615 break;
4616 } // case QC_C_SYNCWL
4617 case RISCV::QK_C_LBU: {
4618 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4619 MI.getOperand(i: 0).isReg() &&
4620 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4621 MI.getOperand(i: 1).isReg() &&
4622 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4623 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 23 /* uimm5 */) &&
4624 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4625 // lbu $rd, ${imm12}(${rs1})
4626 OutInst.setOpcode(RISCV::LBU);
4627 // Operand: rd
4628 OutInst.addOperand(Op: MI.getOperand(i: 0));
4629 // Operand: rs1
4630 OutInst.addOperand(Op: MI.getOperand(i: 1));
4631 // Operand: imm12
4632 OutInst.addOperand(Op: MI.getOperand(i: 2));
4633 OutInst.setLoc(MI.getLoc());
4634 return true;
4635 } // if
4636 break;
4637 } // case QK_C_LBU
4638 case RISCV::QK_C_LBUSP: {
4639 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4640 MI.getOperand(i: 0).isReg() &&
4641 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4642 MI.getOperand(i: 1).isReg() &&
4643 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4644 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 26 /* uimm4 */) &&
4645 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4646 // lbu $rd, ${imm12}(${rs1})
4647 OutInst.setOpcode(RISCV::LBU);
4648 // Operand: rd
4649 OutInst.addOperand(Op: MI.getOperand(i: 0));
4650 // Operand: rs1
4651 OutInst.addOperand(Op: MI.getOperand(i: 1));
4652 // Operand: imm12
4653 OutInst.addOperand(Op: MI.getOperand(i: 2));
4654 OutInst.setLoc(MI.getLoc());
4655 return true;
4656 } // if
4657 break;
4658 } // case QK_C_LBUSP
4659 case RISCV::QK_C_LHU: {
4660 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4661 MI.getOperand(i: 0).isReg() &&
4662 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4663 MI.getOperand(i: 1).isReg() &&
4664 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4665 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 27 /* uimm6_lsb0 */) &&
4666 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4667 // lhu $rd, ${imm12}(${rs1})
4668 OutInst.setOpcode(RISCV::LHU);
4669 // Operand: rd
4670 OutInst.addOperand(Op: MI.getOperand(i: 0));
4671 // Operand: rs1
4672 OutInst.addOperand(Op: MI.getOperand(i: 1));
4673 // Operand: imm12
4674 OutInst.addOperand(Op: MI.getOperand(i: 2));
4675 OutInst.setLoc(MI.getLoc());
4676 return true;
4677 } // if
4678 break;
4679 } // case QK_C_LHU
4680 case RISCV::QK_C_LHUSP: {
4681 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4682 MI.getOperand(i: 0).isReg() &&
4683 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4684 MI.getOperand(i: 1).isReg() &&
4685 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4686 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 28 /* uimm5_lsb0 */) &&
4687 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4688 // lhu $rd, ${imm12}(${rs1})
4689 OutInst.setOpcode(RISCV::LHU);
4690 // Operand: rd
4691 OutInst.addOperand(Op: MI.getOperand(i: 0));
4692 // Operand: rs1
4693 OutInst.addOperand(Op: MI.getOperand(i: 1));
4694 // Operand: imm12
4695 OutInst.addOperand(Op: MI.getOperand(i: 2));
4696 OutInst.setLoc(MI.getLoc());
4697 return true;
4698 } // if
4699 break;
4700 } // case QK_C_LHUSP
4701 case RISCV::QK_C_SB: {
4702 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4703 MI.getOperand(i: 0).isReg() &&
4704 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4705 MI.getOperand(i: 1).isReg() &&
4706 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4707 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 23 /* uimm5 */) &&
4708 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4709 // sb $rs2, ${imm12}(${rs1})
4710 OutInst.setOpcode(RISCV::SB);
4711 // Operand: rs2
4712 OutInst.addOperand(Op: MI.getOperand(i: 0));
4713 // Operand: rs1
4714 OutInst.addOperand(Op: MI.getOperand(i: 1));
4715 // Operand: imm12
4716 OutInst.addOperand(Op: MI.getOperand(i: 2));
4717 OutInst.setLoc(MI.getLoc());
4718 return true;
4719 } // if
4720 break;
4721 } // case QK_C_SB
4722 case RISCV::QK_C_SBSP: {
4723 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4724 MI.getOperand(i: 0).isReg() &&
4725 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4726 MI.getOperand(i: 1).isReg() &&
4727 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4728 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 26 /* uimm4 */) &&
4729 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4730 // sb $rs2, ${imm12}(${rs1})
4731 OutInst.setOpcode(RISCV::SB);
4732 // Operand: rs2
4733 OutInst.addOperand(Op: MI.getOperand(i: 0));
4734 // Operand: rs1
4735 OutInst.addOperand(Op: MI.getOperand(i: 1));
4736 // Operand: imm12
4737 OutInst.addOperand(Op: MI.getOperand(i: 2));
4738 OutInst.setLoc(MI.getLoc());
4739 return true;
4740 } // if
4741 break;
4742 } // case QK_C_SBSP
4743 case RISCV::QK_C_SH: {
4744 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4745 MI.getOperand(i: 0).isReg() &&
4746 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4747 MI.getOperand(i: 1).isReg() &&
4748 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4749 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 27 /* uimm6_lsb0 */) &&
4750 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4751 // sh $rs2, ${imm12}(${rs1})
4752 OutInst.setOpcode(RISCV::SH);
4753 // Operand: rs2
4754 OutInst.addOperand(Op: MI.getOperand(i: 0));
4755 // Operand: rs1
4756 OutInst.addOperand(Op: MI.getOperand(i: 1));
4757 // Operand: imm12
4758 OutInst.addOperand(Op: MI.getOperand(i: 2));
4759 OutInst.setLoc(MI.getLoc());
4760 return true;
4761 } // if
4762 break;
4763 } // case QK_C_SH
4764 case RISCV::QK_C_SHSP: {
4765 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
4766 MI.getOperand(i: 0).isReg() &&
4767 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(Reg: MI.getOperand(i: 0).getReg()) &&
4768 MI.getOperand(i: 1).isReg() &&
4769 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(Reg: MI.getOperand(i: 1).getReg()) &&
4770 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 28 /* uimm5_lsb0 */) &&
4771 RISCVValidateMCOperandForUncompress(MCOp: MI.getOperand(i: 2), STI, PredicateIndex: 2 /* simm12_lo */)) {
4772 // sh $rs2, ${imm12}(${rs1})
4773 OutInst.setOpcode(RISCV::SH);
4774 // Operand: rs2
4775 OutInst.addOperand(Op: MI.getOperand(i: 0));
4776 // Operand: rs1
4777 OutInst.addOperand(Op: MI.getOperand(i: 1));
4778 // Operand: imm12
4779 OutInst.addOperand(Op: MI.getOperand(i: 2));
4780 OutInst.setLoc(MI.getLoc());
4781 return true;
4782 } // if
4783 break;
4784 } // case QK_C_SHSP
4785 } // switch
4786 return false;
4787}
4788
4789#endif // GEN_UNCOMPRESS_INSTR
4790
4791#ifdef GEN_CHECK_COMPRESS_INSTR
4792#undef GEN_CHECK_COMPRESS_INSTR
4793
4794static bool RISCVValidateMachineOperand(const MachineOperand &MO,
4795 const RISCVSubtarget *Subtarget,
4796 unsigned PredicateIndex) {
4797 int64_t Imm = MO.getImm();
4798 switch (PredicateIndex) {
4799 default:
4800 llvm_unreachable("Unknown ImmLeaf Predicate kind");
4801 break;
4802 case 1: {
4803 // simm6nonzero
4804 return (Imm != 0) && isInt<6>(Imm);
4805 }
4806 case 2: {
4807 // simm6
4808 return isInt<6>(Imm);
4809 }
4810 case 3: {
4811 // simm10_lsb0000nonzero
4812 return (Imm != 0) && isShiftedInt<6, 4>(Imm);
4813 }
4814 case 4: {
4815 // uimm10_lsb00nonzero
4816 return isShiftedUInt<8, 2>(Imm) && (Imm != 0);
4817 }
4818 case 5: {
4819 // bare_simm9_lsb0
4820 return isShiftedInt<8, 1>(Imm);
4821 }
4822 case 6: {
4823 // uimmlog2xlennonzero
4824 if (Subtarget->is64Bit())
4825 return isUInt<6>(Imm) && (Imm != 0);
4826 return isUInt<5>(Imm) && (Imm != 0);
4827 }
4828 case 7: {
4829 // uimm8_lsb000
4830 return isShiftedUInt<5, 3>(Imm);
4831 }
4832 case 8: {
4833 // uimm9_lsb000
4834 return isShiftedUInt<6, 3>(Imm);
4835 }
4836 case 9: {
4837 // uimm7_lsb00
4838 return isShiftedUInt<5, 2>(Imm);
4839 }
4840 case 10: {
4841 // uimm8_lsb00
4842 return isShiftedUInt<6, 2>(Imm);
4843 }
4844 case 11: {
4845 // bare_simm12_lsb0
4846 return isShiftedInt<11, 1>(Imm);
4847 }
4848 case 12: {
4849 // uimm2
4850 return isUInt<2>(Imm);
4851 }
4852 case 13: {
4853 // uimm5
4854 return isUInt<5>(Imm);
4855 }
4856 case 14: {
4857 // uimm4
4858 return isUInt<4>(Imm);
4859 }
4860 case 15: {
4861 // uimm2_lsb0
4862 return isShiftedUInt<1, 1>(Imm);
4863 }
4864 case 16: {
4865 // uimm6_lsb0
4866 return isShiftedUInt<5, 1>(Imm);
4867 }
4868 case 17: {
4869 // uimm5_lsb0
4870 return isShiftedUInt<4, 1>(Imm);
4871 }
4872 case 18: {
4873 // c_lui_imm
4874 return (Imm != 0) &&
4875 (isUInt<5>(Imm) ||
4876 (Imm >= 0xfffe0 && Imm <= 0xfffff));
4877 }
4878 case 19: {
4879 // uimm5ge6_plus1
4880 return Imm >= 6 && Imm <= 32;
4881 }
4882 case 20: {
4883 // simm12_lo
4884 return isInt<12>(Imm);
4885 }
4886 case 21: {
4887 // simm5nonzero
4888 return (Imm != 0) && isInt<5>(Imm);
4889 }
4890 case 22: {
4891 // bare_simm13_lsb0
4892 return isShiftedInt<12, 1>(Imm);
4893 }
4894 case 23: {
4895 // uimm5nonzero
4896 return (Imm != 0) && isUInt<5>(Imm);
4897 }
4898 case 24: {
4899 // simm21_lsb0_jal
4900 return isShiftedInt<20, 1>(Imm);
4901 }
4902 case 25: {
4903 // simm20_li
4904 return isInt<20>(Imm);
4905 }
4906 case 26: {
4907 // uimm5slist
4908 return ((Imm == 0) ||
4909 (Imm == 1) ||
4910 (Imm == 2) ||
4911 (Imm == 4) ||
4912 (Imm == 8) ||
4913 (Imm == 16) ||
4914 (Imm == 15) ||
4915 (Imm == 31));
4916 }
4917 case 27: {
4918 // uimmlog2xlen
4919 if (Subtarget->is64Bit())
4920 return isUInt<6>(Imm);
4921 return isUInt<5>(Imm);
4922 }
4923 }
4924}
4925
4926static bool isCompressibleInst(const MachineInstr &MI,
4927 const RISCVSubtarget &STI) {
4928 switch (MI.getOpcode()) {
4929 default: return false;
4930 case RISCV::ADD: {
4931 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4932 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
4933 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
4934 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
4935 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
4936 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
4937 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(2).getReg())) {
4938 // c.add $rs1, $rs2
4939 // Operand: rd
4940 // Operand: rs1
4941 // Operand: rs2
4942 return true;
4943 } // if
4944 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4945 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
4946 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
4947 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
4948 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(2).getReg()) &&
4949 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
4950 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg())) {
4951 // c.add $rs1, $rs2
4952 // Operand: rd
4953 // Operand: rs1
4954 // Operand: rs2
4955 return true;
4956 } // if
4957 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4958 MI.getOperand(1).isReg() &&
4959 (MI.getOperand(1).getReg() == RISCV::X0) &&
4960 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
4961 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
4962 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
4963 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(2).getReg())) {
4964 // c.mv $rs1, $rs2
4965 // Operand: rs1
4966 // Operand: rs2
4967 return true;
4968 } // if
4969 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4970 MI.getOperand(2).isReg() &&
4971 (MI.getOperand(2).getReg() == RISCV::X0) &&
4972 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
4973 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
4974 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
4975 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg())) {
4976 // c.mv $rs1, $rs2
4977 // Operand: rs1
4978 // Operand: rs2
4979 return true;
4980 } // if
4981 break;
4982 } // case ADD
4983 case RISCV::ADDI: {
4984 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
4985 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
4986 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
4987 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
4988 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
4989 MI.getOperand(2).isImm() &&
4990 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 1 /* simm6nonzero */) &&
4991 MI.getOperand(2).isImm() &&
4992 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
4993 // c.addi $rd, $imm
4994 // Operand: rd_wb
4995 // Operand: rd
4996 // Operand: imm
4997 return true;
4998 } // if
4999 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5000 MI.getOperand(0).isReg() &&
5001 (MI.getOperand(0).getReg() == RISCV::X2) &&
5002 MI.getOperand(1).isReg() &&
5003 (MI.getOperand(1).getReg() == RISCV::X2) &&
5004 MI.getOperand(2).isImm() &&
5005 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 3 /* simm10_lsb0000nonzero */)) {
5006 // c.addi16sp $rd, $imm
5007 // Operand: rd_wb
5008 // Operand: rd
5009 // Operand: imm
5010 return true;
5011 } // if
5012 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5013 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5014 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5015 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5016 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5017 MI.getOperand(2).isImm() &&
5018 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 4 /* uimm10_lsb00nonzero */)) {
5019 // c.addi4spn $rd, $rs1, $imm
5020 // Operand: rd
5021 // Operand: rs1
5022 // Operand: imm
5023 return true;
5024 } // if
5025 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5026 MI.getOperand(1).isReg() &&
5027 (MI.getOperand(1).getReg() == RISCV::X0) &&
5028 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5029 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5030 MI.getOperand(2).isImm() &&
5031 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5032 // c.li $rd, $imm
5033 // Operand: rd
5034 // Operand: imm
5035 return true;
5036 } // if
5037 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5038 MI.getOperand(2).isImm() &&
5039 (MI.getOperand(2).getImm() == 0) &&
5040 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5041 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5042 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5043 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg())) {
5044 // c.mv $rs1, $rs2
5045 // Operand: rs1
5046 // Operand: rs2
5047 return true;
5048 } // if
5049 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5050 MI.getOperand(0).isReg() &&
5051 (MI.getOperand(0).getReg() == RISCV::X0) &&
5052 MI.getOperand(1).isReg() &&
5053 (MI.getOperand(1).getReg() == RISCV::X0) &&
5054 MI.getOperand(2).isImm() &&
5055 (MI.getOperand(2).getImm() == 0)) {
5056 // c.nop
5057 return true;
5058 } // if
5059 break;
5060 } // case ADDI
5061 case RISCV::ADDIW: {
5062 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5063 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5064 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5065 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5066 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5067 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
5068 MI.getOperand(2).isImm() &&
5069 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5070 // c.addiw $rd, $imm
5071 // Operand: rd_wb
5072 // Operand: rd
5073 // Operand: imm
5074 return true;
5075 } // if
5076 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5077 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5078 MI.getOperand(1).isReg() &&
5079 (MI.getOperand(1).getReg() == RISCV::X0) &&
5080 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5081 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5082 MI.getOperand(2).isImm() &&
5083 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5084 // c.li $rd, $imm
5085 // Operand: rd
5086 // Operand: imm
5087 return true;
5088 } // if
5089 break;
5090 } // case ADDIW
5091 case RISCV::ADDW: {
5092 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5093 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5094 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5095 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5096 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5097 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5098 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5099 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg())) {
5100 // c.addw $rd, $rs2
5101 // Operand: rd_wb
5102 // Operand: rd
5103 // Operand: rs2
5104 return true;
5105 } // if
5106 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5107 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5108 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
5109 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
5110 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5111 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
5112 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5113 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
5114 // c.addw $rd, $rs2
5115 // Operand: rd_wb
5116 // Operand: rd
5117 // Operand: rs2
5118 return true;
5119 } // if
5120 break;
5121 } // case ADDW
5122 case RISCV::ADD_UW: {
5123 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5124 STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
5125 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5126 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5127 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5128 MI.getOperand(2).isReg() &&
5129 (MI.getOperand(2).getReg() == RISCV::X0) &&
5130 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5131 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
5132 // c.zext.w $rd
5133 // Operand: rd_wb
5134 // Operand: rd
5135 return true;
5136 } // if
5137 break;
5138 } // case ADD_UW
5139 case RISCV::AND: {
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).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5146 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg())) {
5147 // c.and $rd, $rs2
5148 // Operand: rd_wb
5149 // Operand: rd
5150 // Operand: rs2
5151 return true;
5152 } // if
5153 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5154 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
5155 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
5156 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5157 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
5158 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5159 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
5160 // c.and $rd, $rs2
5161 // Operand: rd_wb
5162 // Operand: rd
5163 // Operand: rs2
5164 return true;
5165 } // if
5166 break;
5167 } // case AND
5168 case RISCV::ANDI: {
5169 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5170 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5171 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5172 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5173 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5174 MI.getOperand(2).isImm() &&
5175 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5176 // c.andi $rs1, $imm
5177 // Operand: rd
5178 // Operand: rs1
5179 // Operand: imm
5180 return true;
5181 } // if
5182 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5183 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5184 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5185 MI.getOperand(2).isImm() &&
5186 (MI.getOperand(2).getImm() == 255) &&
5187 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5188 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
5189 // c.zext.b $rd
5190 // Operand: rd_wb
5191 // Operand: rd
5192 return true;
5193 } // if
5194 break;
5195 } // case ANDI
5196 case RISCV::BEQ: {
5197 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5198 MI.getOperand(1).isReg() &&
5199 (MI.getOperand(1).getReg() == RISCV::X0) &&
5200 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5201 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5202 MI.getOperand(2).isImm() &&
5203 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 5 /* bare_simm9_lsb0 */)) {
5204 // c.beqz $rs1, $imm
5205 // Operand: rs1
5206 // Operand: imm
5207 return true;
5208 } // if
5209 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5210 MI.getOperand(0).isReg() &&
5211 (MI.getOperand(0).getReg() == RISCV::X0) &&
5212 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5213 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5214 MI.getOperand(2).isImm() &&
5215 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 5 /* bare_simm9_lsb0 */)) {
5216 // c.beqz $rs1, $imm
5217 // Operand: rs1
5218 // Operand: imm
5219 return true;
5220 } // if
5221 break;
5222 } // case BEQ
5223 case RISCV::BEXTI: {
5224 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
5225 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
5226 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5227 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5228 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5229 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5230 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5231 MI.getOperand(2).isImm() &&
5232 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 6 /* uimmlog2xlennonzero */)) {
5233 // qc.c.bexti $rs1, $shamt
5234 // Operand: rd
5235 // Operand: rs1
5236 // Operand: shamt
5237 return true;
5238 } // if
5239 break;
5240 } // case BEXTI
5241 case RISCV::BNE: {
5242 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5243 MI.getOperand(1).isReg() &&
5244 (MI.getOperand(1).getReg() == RISCV::X0) &&
5245 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5246 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5247 MI.getOperand(2).isImm() &&
5248 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 5 /* bare_simm9_lsb0 */)) {
5249 // c.bnez $rs1, $imm
5250 // Operand: rs1
5251 // Operand: imm
5252 return true;
5253 } // if
5254 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5255 MI.getOperand(0).isReg() &&
5256 (MI.getOperand(0).getReg() == RISCV::X0) &&
5257 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5258 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5259 MI.getOperand(2).isImm() &&
5260 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 5 /* bare_simm9_lsb0 */)) {
5261 // c.bnez $rs1, $imm
5262 // Operand: rs1
5263 // Operand: imm
5264 return true;
5265 } // if
5266 break;
5267 } // case BNE
5268 case RISCV::BSETI: {
5269 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
5270 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
5271 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5272 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5273 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5274 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5275 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5276 MI.getOperand(2).isImm() &&
5277 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 6 /* uimmlog2xlennonzero */)) {
5278 // qc.c.bseti $rs1, $shamt
5279 // Operand: rd
5280 // Operand: rs1
5281 // Operand: shamt
5282 return true;
5283 } // if
5284 break;
5285 } // case BSETI
5286 case RISCV::EBREAK: {
5287 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca]) {
5288 // c.ebreak
5289 return true;
5290 } // if
5291 break;
5292 } // case EBREAK
5293 case RISCV::FLD: {
5294 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
5295 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5296 RISCVMCRegisterClasses[RISCV::FPR64CRegClassID].contains(MI.getOperand(0).getReg()) &&
5297 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5298 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5299 MI.getOperand(2).isImm() &&
5300 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */)) {
5301 // c.fld $rd, ${imm}(${rs1})
5302 // Operand: rd
5303 // Operand: rs1
5304 // Operand: imm
5305 return true;
5306 } // if
5307 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
5308 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5309 RISCVMCRegisterClasses[RISCV::FPR64RegClassID].contains(MI.getOperand(0).getReg()) &&
5310 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5311 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5312 MI.getOperand(2).isImm() &&
5313 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm9_lsb000 */)) {
5314 // c.fldsp $rd, ${imm}(${rs1})
5315 // Operand: rd
5316 // Operand: rs1
5317 // Operand: imm
5318 return true;
5319 } // if
5320 break;
5321 } // case FLD
5322 case RISCV::FLW: {
5323 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
5324 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5325 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5326 RISCVMCRegisterClasses[RISCV::FPR32CRegClassID].contains(MI.getOperand(0).getReg()) &&
5327 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5328 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5329 MI.getOperand(2).isImm() &&
5330 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm7_lsb00 */)) {
5331 // c.flw $rd, ${imm}(${rs1})
5332 // Operand: rd
5333 // Operand: rs1
5334 // Operand: imm
5335 return true;
5336 } // if
5337 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
5338 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5339 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5340 RISCVMCRegisterClasses[RISCV::FPR32RegClassID].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, 10 /* uimm8_lsb00 */)) {
5345 // c.flwsp $rd, ${imm}(${rs1})
5346 // Operand: rd
5347 // Operand: rs1
5348 // Operand: imm
5349 return true;
5350 } // if
5351 break;
5352 } // case FLW
5353 case RISCV::FSD: {
5354 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
5355 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5356 RISCVMCRegisterClasses[RISCV::FPR64CRegClassID].contains(MI.getOperand(0).getReg()) &&
5357 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5358 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5359 MI.getOperand(2).isImm() &&
5360 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */)) {
5361 // c.fsd $rs2, ${imm}(${rs1})
5362 // Operand: rs2
5363 // Operand: rs1
5364 // Operand: imm
5365 return true;
5366 } // if
5367 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcd] &&
5368 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5369 RISCVMCRegisterClasses[RISCV::FPR64RegClassID].contains(MI.getOperand(0).getReg()) &&
5370 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5371 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5372 MI.getOperand(2).isImm() &&
5373 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm9_lsb000 */)) {
5374 // c.fsdsp $rs2, ${imm}(${rs1})
5375 // Operand: rs2
5376 // Operand: rs1
5377 // Operand: imm
5378 return true;
5379 } // if
5380 break;
5381 } // case FSD
5382 case RISCV::FSW: {
5383 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
5384 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5385 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5386 RISCVMCRegisterClasses[RISCV::FPR32CRegClassID].contains(MI.getOperand(0).getReg()) &&
5387 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5388 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5389 MI.getOperand(2).isImm() &&
5390 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm7_lsb00 */)) {
5391 // c.fsw $rs2, ${imm}(${rs1})
5392 // Operand: rs2
5393 // Operand: rs1
5394 // Operand: imm
5395 return true;
5396 } // if
5397 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcf] &&
5398 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5399 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5400 RISCVMCRegisterClasses[RISCV::FPR32RegClassID].contains(MI.getOperand(0).getReg()) &&
5401 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5402 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5403 MI.getOperand(2).isImm() &&
5404 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm8_lsb00 */)) {
5405 // c.fswsp $rs2, ${imm}(${rs1})
5406 // Operand: rs2
5407 // Operand: rs1
5408 // Operand: imm
5409 return true;
5410 } // if
5411 break;
5412 } // case FSW
5413 case RISCV::JAL: {
5414 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5415 MI.getOperand(0).isReg() &&
5416 (MI.getOperand(0).getReg() == RISCV::X0) &&
5417 MI.getOperand(1).isImm() &&
5418 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 11 /* bare_simm12_lsb0 */)) {
5419 // c.j $offset
5420 // Operand: offset
5421 return true;
5422 } // if
5423 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5424 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5425 MI.getOperand(0).isReg() &&
5426 (MI.getOperand(0).getReg() == RISCV::X1) &&
5427 MI.getOperand(1).isImm() &&
5428 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 11 /* bare_simm12_lsb0 */)) {
5429 // c.jal $offset
5430 // Operand: offset
5431 return true;
5432 } // if
5433 break;
5434 } // case JAL
5435 case RISCV::JALR: {
5436 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5437 MI.getOperand(0).isReg() &&
5438 (MI.getOperand(0).getReg() == RISCV::X1) &&
5439 MI.getOperand(2).isImm() &&
5440 (MI.getOperand(2).getImm() == 0) &&
5441 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5442 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg())) {
5443 // c.jalr $rs1
5444 // Operand: rs1
5445 return true;
5446 } // if
5447 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5448 MI.getOperand(0).isReg() &&
5449 (MI.getOperand(0).getReg() == RISCV::X0) &&
5450 MI.getOperand(2).isImm() &&
5451 (MI.getOperand(2).getImm() == 0) &&
5452 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5453 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg())) {
5454 // c.jr $rs1
5455 // Operand: rs1
5456 return true;
5457 } // if
5458 break;
5459 } // case JALR
5460 case RISCV::LBU: {
5461 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5462 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5463 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5464 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5465 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5466 MI.getOperand(2).isImm() &&
5467 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 12 /* uimm2 */)) {
5468 // c.lbu $rd, ${imm}(${rs1})
5469 // Operand: rd
5470 // Operand: rs1
5471 // Operand: imm
5472 return true;
5473 } // if
5474 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
5475 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5476 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5477 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5478 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5479 MI.getOperand(2).isImm() &&
5480 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 13 /* uimm5 */)) {
5481 // qk.c.lbu $rd, ${imm}(${rs1})
5482 // Operand: rd
5483 // Operand: rs1
5484 // Operand: imm
5485 return true;
5486 } // if
5487 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
5488 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5489 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5490 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5491 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5492 MI.getOperand(2).isImm() &&
5493 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 14 /* uimm4 */)) {
5494 // qk.c.lbusp $rd_rs2, ${imm}(${rs1})
5495 // Operand: rd_rs2
5496 // Operand: rs1
5497 // Operand: imm
5498 return true;
5499 } // if
5500 break;
5501 } // case LBU
5502 case RISCV::LD: {
5503 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5504 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5505 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5506 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5507 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5508 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5509 MI.getOperand(2).isImm() &&
5510 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */)) {
5511 // c.ld $rd, ${imm}(${rs1})
5512 // Operand: rd
5513 // Operand: rs1
5514 // Operand: imm
5515 return true;
5516 } // if
5517 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
5518 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5519 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5520 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5521 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5522 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5523 MI.getOperand(2).isImm() &&
5524 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm9_lsb000 */)) {
5525 // c.ldsp $rd, ${imm}(${rs1})
5526 // Operand: rd
5527 // Operand: rs1
5528 // Operand: imm
5529 return true;
5530 } // if
5531 break;
5532 } // case LD
5533 case RISCV::LD_RV32: {
5534 if (STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
5535 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5536 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5537 RISCVMCRegisterClasses[RISCV::GPRPairNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5538 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5539 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5540 MI.getOperand(2).isImm() &&
5541 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm9_lsb000 */)) {
5542 // c.ldsp $rd, ${imm}(${rs1})
5543 // Operand: rd
5544 // Operand: rs1
5545 // Operand: imm
5546 return true;
5547 } // if
5548 if (STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
5549 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5550 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5551 RISCVMCRegisterClasses[RISCV::GPRPairCRegClassID].contains(MI.getOperand(0).getReg()) &&
5552 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5553 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5554 MI.getOperand(2).isImm() &&
5555 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */)) {
5556 // c.ld $rd, ${imm}(${rs1})
5557 // Operand: rd
5558 // Operand: rs1
5559 // Operand: imm
5560 return true;
5561 } // if
5562 break;
5563 } // case LD_RV32
5564 case RISCV::LH: {
5565 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
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, 15 /* uimm2_lsb0 */)) {
5572 // c.lh $rd, ${imm}(${rs1})
5573 // Operand: rd
5574 // Operand: rs1
5575 // Operand: imm
5576 return true;
5577 } // if
5578 break;
5579 } // case LH
5580 case RISCV::LHU: {
5581 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5582 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5583 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5584 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5585 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5586 MI.getOperand(2).isImm() &&
5587 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 15 /* uimm2_lsb0 */)) {
5588 // c.lhu $rd, ${imm}(${rs1})
5589 // Operand: rd
5590 // Operand: rs1
5591 // Operand: imm
5592 return true;
5593 } // if
5594 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
5595 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5596 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].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, 16 /* uimm6_lsb0 */)) {
5601 // qk.c.lhu $rd, ${imm}(${rs1})
5602 // Operand: rd
5603 // Operand: rs1
5604 // Operand: imm
5605 return true;
5606 } // if
5607 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
5608 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5609 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5610 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5611 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5612 MI.getOperand(2).isImm() &&
5613 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 17 /* uimm5_lsb0 */)) {
5614 // qk.c.lhusp $rd_rs2, ${imm}(${rs1})
5615 // Operand: rd_rs2
5616 // Operand: rs1
5617 // Operand: imm
5618 return true;
5619 } // if
5620 break;
5621 } // case LHU
5622 case RISCV::LH_INX: {
5623 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5624 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5625 RISCVMCRegisterClasses[RISCV::GPRF16CRegClassID].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, 15 /* uimm2_lsb0 */)) {
5630 // c.lh $rd, ${imm}(${rs1})
5631 // Operand: rd
5632 // Operand: rs1
5633 // Operand: imm
5634 return true;
5635 } // if
5636 break;
5637 } // case LH_INX
5638 case RISCV::LUI: {
5639 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5640 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5641 RISCVMCRegisterClasses[RISCV::GPRNoX0X2RegClassID].contains(MI.getOperand(0).getReg()) &&
5642 MI.getOperand(1).isImm() &&
5643 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 18 /* c_lui_imm */)) {
5644 // c.lui $rd, $imm
5645 // Operand: rd
5646 // Operand: imm
5647 return true;
5648 } // if
5649 break;
5650 } // case LUI
5651 case RISCV::LW: {
5652 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5653 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5654 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5655 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5656 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5657 MI.getOperand(2).isImm() &&
5658 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm7_lsb00 */)) {
5659 // c.lw $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::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5668 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5669 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5670 MI.getOperand(2).isImm() &&
5671 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm8_lsb00 */)) {
5672 // c.lwsp $rd, ${imm}(${rs1})
5673 // Operand: rd
5674 // Operand: rs1
5675 // Operand: imm
5676 return true;
5677 } // if
5678 break;
5679 } // case LW
5680 case RISCV::LW_INX: {
5681 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5682 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5683 RISCVMCRegisterClasses[RISCV::GPRF32NoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5684 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5685 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
5686 MI.getOperand(2).isImm() &&
5687 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm8_lsb00 */)) {
5688 // c.lwsp $rd, ${imm}(${rs1})
5689 // Operand: rd
5690 // Operand: rs1
5691 // Operand: imm
5692 return true;
5693 } // if
5694 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5695 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5696 RISCVMCRegisterClasses[RISCV::GPRF32CRegClassID].contains(MI.getOperand(0).getReg()) &&
5697 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5698 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5699 MI.getOperand(2).isImm() &&
5700 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm7_lsb00 */)) {
5701 // c.lw $rd, ${imm}(${rs1})
5702 // Operand: rd
5703 // Operand: rs1
5704 // Operand: imm
5705 return true;
5706 } // if
5707 break;
5708 } // case LW_INX
5709 case RISCV::MUL: {
5710 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5711 STI.getFeatureBits()[RISCV::FeatureStdExtZmmul] &&
5712 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5713 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5714 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5715 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5716 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5717 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg())) {
5718 // c.mul $rd, $rs2
5719 // Operand: rd_wb
5720 // Operand: rd
5721 // Operand: rs2
5722 return true;
5723 } // if
5724 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
5725 STI.getFeatureBits()[RISCV::FeatureStdExtZmmul] &&
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.mul $rd, $rs2
5733 // Operand: rd_wb
5734 // Operand: rd
5735 // Operand: rs2
5736 return true;
5737 } // if
5738 break;
5739 } // case MUL
5740 case RISCV::OR: {
5741 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5742 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5743 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5744 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5745 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5746 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5747 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg())) {
5748 // c.or $rd, $rs2
5749 // Operand: rd_wb
5750 // Operand: rd
5751 // Operand: rs2
5752 return true;
5753 } // if
5754 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5755 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
5756 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
5757 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
5758 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
5759 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5760 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
5761 // c.or $rd, $rs2
5762 // Operand: rd_wb
5763 // Operand: rd
5764 // Operand: rs2
5765 return true;
5766 } // if
5767 break;
5768 } // case OR
5769 case RISCV::QC_EXTU: {
5770 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbs] &&
5771 STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
5772 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5773 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5774 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5775 MI.getOperand(2).isImm() &&
5776 (MI.getOperand(2).getImm() == 1) &&
5777 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5778 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5779 MI.getOperand(3).isImm() &&
5780 RISCVValidateMachineOperand(MI.getOperand(3), &STI, 6 /* uimmlog2xlennonzero */)) {
5781 // qc.c.bexti $rs1, $shamt
5782 // Operand: rd
5783 // Operand: rs1
5784 // Operand: shamt
5785 return true;
5786 } // if
5787 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcibm] &&
5788 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5789 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5790 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5791 MI.getOperand(3).isImm() &&
5792 (MI.getOperand(3).getImm() == 0) &&
5793 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5794 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
5795 MI.getOperand(2).isImm() &&
5796 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 19 /* uimm5ge6_plus1 */)) {
5797 // qc.c.extu $rd, $width
5798 // Operand: rd_wb
5799 // Operand: rd
5800 // Operand: width
5801 return true;
5802 } // if
5803 break;
5804 } // case QC_EXTU
5805 case RISCV::QC_E_ADDAI: {
5806 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5807 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5808 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5809 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5810 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5811 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5812 MI.getOperand(2).isImm() &&
5813 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
5814 // addi $rd, $rs1, $imm12
5815 // Operand: rd
5816 // Operand: rs1
5817 // Operand: imm12
5818 return true;
5819 } // if
5820 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5821 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5822 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5823 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5824 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5825 MI.getOperand(2).isImm() &&
5826 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 1 /* simm6nonzero */) &&
5827 MI.getOperand(2).isImm() &&
5828 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5829 // c.addi $rd, $imm
5830 // Operand: rd_wb
5831 // Operand: rd
5832 // Operand: imm
5833 return true;
5834 } // if
5835 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5836 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5837 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5838 MI.getOperand(0).isReg() &&
5839 (MI.getOperand(0).getReg() == RISCV::X2) &&
5840 MI.getOperand(1).isReg() &&
5841 (MI.getOperand(1).getReg() == RISCV::X2) &&
5842 MI.getOperand(2).isImm() &&
5843 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 3 /* simm10_lsb0000nonzero */)) {
5844 // c.addi16sp $rd, $imm
5845 // Operand: rd_wb
5846 // Operand: rd
5847 // Operand: imm
5848 return true;
5849 } // if
5850 break;
5851 } // case QC_E_ADDAI
5852 case RISCV::QC_E_ADDI: {
5853 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5854 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5855 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5856 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5857 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5858 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
5859 MI.getOperand(2).isImm() &&
5860 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
5861 // addi $rd, $rs1, $imm12
5862 // Operand: rd
5863 // Operand: rs1
5864 // Operand: imm12
5865 return true;
5866 } // if
5867 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5868 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5869 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5870 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5871 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5872 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5873 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
5874 MI.getOperand(2).isImm() &&
5875 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 1 /* simm6nonzero */) &&
5876 MI.getOperand(2).isImm() &&
5877 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5878 // c.addi $rd, $imm
5879 // Operand: rd_wb
5880 // Operand: rd
5881 // Operand: imm
5882 return true;
5883 } // if
5884 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5885 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5886 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5887 MI.getOperand(0).isReg() &&
5888 (MI.getOperand(0).getReg() == RISCV::X2) &&
5889 MI.getOperand(1).isReg() &&
5890 (MI.getOperand(1).getReg() == RISCV::X2) &&
5891 MI.getOperand(2).isImm() &&
5892 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 3 /* simm10_lsb0000nonzero */)) {
5893 // c.addi16sp $rd, $imm
5894 // Operand: rd_wb
5895 // Operand: rd
5896 // Operand: imm
5897 return true;
5898 } // if
5899 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5900 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5901 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5902 MI.getOperand(2).isImm() &&
5903 (MI.getOperand(2).getImm() == 0) &&
5904 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5905 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5906 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5907 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg())) {
5908 // c.mv $rs1, $rs2
5909 // Operand: rs1
5910 // Operand: rs2
5911 return true;
5912 } // if
5913 break;
5914 } // case QC_E_ADDI
5915 case RISCV::QC_E_ANDAI: {
5916 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5917 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5918 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5919 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5920 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5921 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5922 MI.getOperand(2).isImm() &&
5923 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
5924 // andi $rd, $rs1, $imm12
5925 // Operand: rd
5926 // Operand: rs1
5927 // Operand: imm12
5928 return true;
5929 } // if
5930 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5931 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5932 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5933 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5934 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
5935 MI.getOperand(2).isImm() &&
5936 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5937 // c.andi $rs1, $imm
5938 // Operand: rd
5939 // Operand: rs1
5940 // Operand: imm
5941 return true;
5942 } // if
5943 break;
5944 } // case QC_E_ANDAI
5945 case RISCV::QC_E_ANDI: {
5946 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5947 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5948 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5949 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5950 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5951 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
5952 MI.getOperand(2).isImm() &&
5953 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
5954 // andi $rd, $rs1, $imm12
5955 // Operand: rd
5956 // Operand: rs1
5957 // Operand: imm12
5958 return true;
5959 } // if
5960 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
5961 STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
5962 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5963 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
5964 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
5965 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
5966 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
5967 MI.getOperand(2).isImm() &&
5968 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 2 /* simm6 */)) {
5969 // c.andi $rs1, $imm
5970 // Operand: rd
5971 // Operand: rs1
5972 // Operand: imm
5973 return true;
5974 } // if
5975 break;
5976 } // case QC_E_ANDI
5977 case RISCV::QC_E_BEQI: {
5978 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
5979 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5980 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5981 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5982 MI.getOperand(1).isImm() &&
5983 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 21 /* simm5nonzero */) &&
5984 MI.getOperand(2).isImm() &&
5985 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* bare_simm13_lsb0 */)) {
5986 // qc.beqi $rs1, $rs2, $imm12
5987 // Operand: rs1
5988 // Operand: rs2
5989 // Operand: imm12
5990 return true;
5991 } // if
5992 break;
5993 } // case QC_E_BEQI
5994 case RISCV::QC_E_BGEI: {
5995 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
5996 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
5997 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
5998 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
5999 MI.getOperand(1).isImm() &&
6000 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 21 /* simm5nonzero */) &&
6001 MI.getOperand(2).isImm() &&
6002 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* bare_simm13_lsb0 */)) {
6003 // qc.bgei $rs1, $rs2, $imm12
6004 // Operand: rs1
6005 // Operand: rs2
6006 // Operand: imm12
6007 return true;
6008 } // if
6009 break;
6010 } // case QC_E_BGEI
6011 case RISCV::QC_E_BGEUI: {
6012 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
6013 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6014 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6015 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6016 MI.getOperand(1).isImm() &&
6017 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 23 /* uimm5nonzero */) &&
6018 MI.getOperand(2).isImm() &&
6019 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* bare_simm13_lsb0 */)) {
6020 // qc.bgeui $rs1, $rs2, $imm12
6021 // Operand: rs1
6022 // Operand: rs2
6023 // Operand: imm12
6024 return true;
6025 } // if
6026 break;
6027 } // case QC_E_BGEUI
6028 case RISCV::QC_E_BLTI: {
6029 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
6030 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6031 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6032 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6033 MI.getOperand(1).isImm() &&
6034 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 21 /* simm5nonzero */) &&
6035 MI.getOperand(2).isImm() &&
6036 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* bare_simm13_lsb0 */)) {
6037 // qc.blti $rs1, $rs2, $imm12
6038 // Operand: rs1
6039 // Operand: rs2
6040 // Operand: imm12
6041 return true;
6042 } // if
6043 break;
6044 } // case QC_E_BLTI
6045 case RISCV::QC_E_BLTUI: {
6046 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
6047 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6048 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6049 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6050 MI.getOperand(1).isImm() &&
6051 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 23 /* uimm5nonzero */) &&
6052 MI.getOperand(2).isImm() &&
6053 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* bare_simm13_lsb0 */)) {
6054 // qc.bltui $rs1, $rs2, $imm12
6055 // Operand: rs1
6056 // Operand: rs2
6057 // Operand: imm12
6058 return true;
6059 } // if
6060 break;
6061 } // case QC_E_BLTUI
6062 case RISCV::QC_E_BNEI: {
6063 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcibi] &&
6064 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6065 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6066 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6067 MI.getOperand(1).isImm() &&
6068 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 21 /* simm5nonzero */) &&
6069 MI.getOperand(2).isImm() &&
6070 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 22 /* bare_simm13_lsb0 */)) {
6071 // qc.bnei $rs1, $rs2, $imm12
6072 // Operand: rs1
6073 // Operand: rs2
6074 // Operand: imm12
6075 return true;
6076 } // if
6077 break;
6078 } // case QC_E_BNEI
6079 case RISCV::QC_E_J: {
6080 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6081 STI.getFeatureBits()[RISCV::FeatureVendorXqcilb] &&
6082 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6083 MI.getOperand(0).isImm() &&
6084 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 11 /* bare_simm12_lsb0 */)) {
6085 // c.j $offset
6086 // Operand: offset
6087 return true;
6088 } // if
6089 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilb] &&
6090 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6091 MI.getOperand(0).isImm() &&
6092 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 24 /* simm21_lsb0_jal */)) {
6093 // jal $rd, $imm20
6094 // Operand: rd
6095 // Operand: imm20
6096 return true;
6097 } // if
6098 break;
6099 } // case QC_E_J
6100 case RISCV::QC_E_JAL: {
6101 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6102 STI.getFeatureBits()[RISCV::FeatureVendorXqcilb] &&
6103 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6104 MI.getOperand(0).isImm() &&
6105 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 11 /* bare_simm12_lsb0 */)) {
6106 // c.jal $offset
6107 // Operand: offset
6108 return true;
6109 } // if
6110 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilb] &&
6111 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6112 MI.getOperand(0).isImm() &&
6113 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 24 /* simm21_lsb0_jal */)) {
6114 // jal $rd, $imm20
6115 // Operand: rd
6116 // Operand: imm20
6117 return true;
6118 } // if
6119 break;
6120 } // case QC_E_JAL
6121 case RISCV::QC_E_LB: {
6122 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6123 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6124 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6125 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6126 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6127 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(1).getReg()) &&
6128 MI.getOperand(2).isImm() &&
6129 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6130 // lb $rd, ${imm12}(${rs1})
6131 // Operand: rd
6132 // Operand: rs1
6133 // Operand: imm12
6134 return true;
6135 } // if
6136 break;
6137 } // case QC_E_LB
6138 case RISCV::QC_E_LBU: {
6139 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6140 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6141 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6142 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6143 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6144 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6145 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6146 MI.getOperand(2).isImm() &&
6147 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 12 /* uimm2 */)) {
6148 // c.lbu $rd, ${imm}(${rs1})
6149 // Operand: rd
6150 // Operand: rs1
6151 // Operand: imm
6152 return true;
6153 } // if
6154 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6155 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6156 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6157 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6158 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6159 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(1).getReg()) &&
6160 MI.getOperand(2).isImm() &&
6161 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6162 // lbu $rd, ${imm12}(${rs1})
6163 // Operand: rd
6164 // Operand: rs1
6165 // Operand: imm12
6166 return true;
6167 } // if
6168 break;
6169 } // case QC_E_LBU
6170 case RISCV::QC_E_LH: {
6171 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6172 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6173 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6174 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6175 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6176 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6177 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6178 MI.getOperand(2).isImm() &&
6179 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 15 /* uimm2_lsb0 */)) {
6180 // c.lh $rd, ${imm}(${rs1})
6181 // Operand: rd
6182 // Operand: rs1
6183 // Operand: imm
6184 return true;
6185 } // if
6186 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6187 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6188 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6189 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6190 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6191 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(1).getReg()) &&
6192 MI.getOperand(2).isImm() &&
6193 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6194 // lh $rd, ${imm12}(${rs1})
6195 // Operand: rd
6196 // Operand: rs1
6197 // Operand: imm12
6198 return true;
6199 } // if
6200 break;
6201 } // case QC_E_LH
6202 case RISCV::QC_E_LHU: {
6203 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6204 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6205 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6206 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6207 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6208 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6209 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6210 MI.getOperand(2).isImm() &&
6211 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 15 /* uimm2_lsb0 */)) {
6212 // c.lhu $rd, ${imm}(${rs1})
6213 // Operand: rd
6214 // Operand: rs1
6215 // Operand: imm
6216 return true;
6217 } // if
6218 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6219 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6220 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6221 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6222 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6223 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(1).getReg()) &&
6224 MI.getOperand(2).isImm() &&
6225 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6226 // lhu $rd, ${imm12}(${rs1})
6227 // Operand: rd
6228 // Operand: rs1
6229 // Operand: imm12
6230 return true;
6231 } // if
6232 break;
6233 } // case QC_E_LHU
6234 case RISCV::QC_E_LI: {
6235 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6236 STI.getFeatureBits()[RISCV::FeatureVendorXqcili] &&
6237 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6238 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6239 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6240 MI.getOperand(1).isImm() &&
6241 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 2 /* simm6 */)) {
6242 // c.li $rd, $imm
6243 // Operand: rd
6244 // Operand: imm
6245 return true;
6246 } // if
6247 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcili] &&
6248 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6249 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6250 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6251 MI.getOperand(1).isImm() &&
6252 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 25 /* simm20_li */)) {
6253 // qc.li $rd, $imm20
6254 // Operand: rd
6255 // Operand: imm20
6256 return true;
6257 } // if
6258 break;
6259 } // case QC_E_LI
6260 case RISCV::QC_E_LW: {
6261 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6262 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6263 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6264 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6265 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6266 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6267 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6268 MI.getOperand(2).isImm() &&
6269 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm7_lsb00 */)) {
6270 // c.lw $rd, ${imm}(${rs1})
6271 // Operand: rd
6272 // Operand: rs1
6273 // Operand: imm
6274 return true;
6275 } // if
6276 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6277 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6278 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6279 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6280 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6281 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6282 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
6283 MI.getOperand(2).isImm() &&
6284 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm8_lsb00 */)) {
6285 // c.lwsp $rd, ${imm}(${rs1})
6286 // Operand: rd
6287 // Operand: rs1
6288 // Operand: imm
6289 return true;
6290 } // if
6291 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6292 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6293 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6294 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6295 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6296 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(1).getReg()) &&
6297 MI.getOperand(2).isImm() &&
6298 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6299 // lw $rd, ${imm12}(${rs1})
6300 // Operand: rd
6301 // Operand: rs1
6302 // Operand: imm12
6303 return true;
6304 } // if
6305 break;
6306 } // case QC_E_LW
6307 case RISCV::QC_E_ORAI: {
6308 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6309 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6310 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6311 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6312 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6313 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6314 MI.getOperand(2).isImm() &&
6315 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6316 // ori $rd, $rs1, $imm12
6317 // Operand: rd
6318 // Operand: rs1
6319 // Operand: imm12
6320 return true;
6321 } // if
6322 break;
6323 } // case QC_E_ORAI
6324 case RISCV::QC_E_ORI: {
6325 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6326 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6327 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6328 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6329 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6330 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
6331 MI.getOperand(2).isImm() &&
6332 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6333 // ori $rd, $rs1, $imm12
6334 // Operand: rd
6335 // Operand: rs1
6336 // Operand: imm12
6337 return true;
6338 } // if
6339 break;
6340 } // case QC_E_ORI
6341 case RISCV::QC_E_SB: {
6342 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6343 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6344 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6345 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6346 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6347 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6348 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6349 MI.getOperand(2).isImm() &&
6350 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 12 /* uimm2 */)) {
6351 // c.sb $rs2, ${imm}(${rs1})
6352 // Operand: rs2
6353 // Operand: rs1
6354 // Operand: imm
6355 return true;
6356 } // if
6357 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6358 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6359 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6360 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6361 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6362 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(1).getReg()) &&
6363 MI.getOperand(2).isImm() &&
6364 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6365 // sb $rs2, ${imm12}(${rs1})
6366 // Operand: rs2
6367 // Operand: rs1
6368 // Operand: imm12
6369 return true;
6370 } // if
6371 break;
6372 } // case QC_E_SB
6373 case RISCV::QC_E_SH: {
6374 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6375 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6376 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6377 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6378 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6379 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6380 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6381 MI.getOperand(2).isImm() &&
6382 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 15 /* uimm2_lsb0 */)) {
6383 // c.sh $rs2, ${imm}(${rs1})
6384 // Operand: rs2
6385 // Operand: rs1
6386 // Operand: imm
6387 return true;
6388 } // if
6389 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6390 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6391 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6392 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6393 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6394 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(1).getReg()) &&
6395 MI.getOperand(2).isImm() &&
6396 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6397 // sh $rs2, ${imm12}(${rs1})
6398 // Operand: rs2
6399 // Operand: rs1
6400 // Operand: imm12
6401 return true;
6402 } // if
6403 break;
6404 } // case QC_E_SH
6405 case RISCV::QC_E_SW: {
6406 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6407 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6408 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6409 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6410 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6411 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6412 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6413 MI.getOperand(2).isImm() &&
6414 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm7_lsb00 */)) {
6415 // c.sw $rs2, ${imm}(${rs1})
6416 // Operand: rs2
6417 // Operand: rs1
6418 // Operand: imm
6419 return true;
6420 } // if
6421 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6422 STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6423 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6424 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6425 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6426 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6427 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
6428 MI.getOperand(2).isImm() &&
6429 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm8_lsb00 */)) {
6430 // c.swsp $rs2, ${imm}(${rs1})
6431 // Operand: rs2
6432 // Operand: rs1
6433 // Operand: imm
6434 return true;
6435 } // if
6436 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilo] &&
6437 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6438 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6439 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6440 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6441 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(1).getReg()) &&
6442 MI.getOperand(2).isImm() &&
6443 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6444 // sw $rs2, ${imm12}(${rs1})
6445 // Operand: rs2
6446 // Operand: rs1
6447 // Operand: imm12
6448 return true;
6449 } // if
6450 break;
6451 } // case QC_E_SW
6452 case RISCV::QC_E_XORAI: {
6453 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6454 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6455 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6456 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6457 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6458 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6459 MI.getOperand(2).isImm() &&
6460 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6461 // xori $rd, $rs1, $imm12
6462 // Operand: rd
6463 // Operand: rs1
6464 // Operand: imm12
6465 return true;
6466 } // if
6467 break;
6468 } // case QC_E_XORAI
6469 case RISCV::QC_E_XORI: {
6470 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcilia] &&
6471 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6472 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6473 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6474 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6475 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
6476 MI.getOperand(2).isImm() &&
6477 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 20 /* simm12_lo */)) {
6478 // xori $rd, $rs1, $imm12
6479 // Operand: rd
6480 // Operand: rs1
6481 // Operand: imm12
6482 return true;
6483 } // if
6484 break;
6485 } // case QC_E_XORI
6486 case RISCV::QC_LI: {
6487 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6488 STI.getFeatureBits()[RISCV::FeatureVendorXqcili] &&
6489 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6490 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6491 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(0).getReg()) &&
6492 MI.getOperand(1).isImm() &&
6493 RISCVValidateMachineOperand(MI.getOperand(1), &STI, 2 /* simm6 */)) {
6494 // c.li $rd, $imm
6495 // Operand: rd
6496 // Operand: imm
6497 return true;
6498 } // if
6499 break;
6500 } // case QC_LI
6501 case RISCV::QC_MULIADD: {
6502 if (STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
6503 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6504 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6505 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6506 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6507 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
6508 MI.getOperand(3).isImm() &&
6509 RISCVValidateMachineOperand(MI.getOperand(3), &STI, 13 /* uimm5 */)) {
6510 // qc.c.muliadd $rd, $rs1, $uimm
6511 // Operand: rd_wb
6512 // Operand: rd
6513 // Operand: rs1
6514 // Operand: uimm
6515 return true;
6516 } // if
6517 break;
6518 } // case QC_MULIADD
6519 case RISCV::QC_MVEQI: {
6520 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcicm] &&
6521 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6522 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
6523 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
6524 MI.getOperand(3).isImm() &&
6525 (MI.getOperand(3).getImm() == 0) &&
6526 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6527 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
6528 MI.getOperand(4).isReg() && MI.getOperand(4).getReg().isPhysical() &&
6529 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(4).getReg())) {
6530 // qc.c.mveqz $rd, $rs1
6531 // Operand: rd_wb
6532 // Operand: rd
6533 // Operand: rs1
6534 return true;
6535 } // if
6536 break;
6537 } // case QC_MVEQI
6538 case RISCV::QC_MVLTUI: {
6539 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcicm] &&
6540 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6541 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
6542 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
6543 MI.getOperand(3).isImm() &&
6544 (MI.getOperand(3).getImm() == 1) &&
6545 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6546 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
6547 MI.getOperand(4).isReg() && MI.getOperand(4).getReg().isPhysical() &&
6548 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(4).getReg())) {
6549 // qc.c.mveqz $rd, $rs1
6550 // Operand: rd_wb
6551 // Operand: rd
6552 // Operand: rs1
6553 return true;
6554 } // if
6555 break;
6556 } // case QC_MVLTUI
6557 case RISCV::QC_SHLADD: {
6558 if (STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
6559 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6560 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
6561 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
6562 MI.getOperand(3).isImm() &&
6563 (MI.getOperand(3).getImm() == 4) &&
6564 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6565 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
6566 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6567 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6568 RISCVValidateMachineOperand(MachineOperand::CreateImm(16), &STI, 13 /* uimm5 */)) {
6569 // qc.c.muliadd $rd, $rs1, $uimm
6570 // Operand: rd_wb
6571 // Operand: rd
6572 // Operand: rs1
6573 // Operand: uimm
6574 return true;
6575 } // if
6576 break;
6577 } // case QC_SHLADD
6578 case RISCV::QC_SYNC: {
6579 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
6580 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6581 MI.getOperand(0).isImm() &&
6582 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 26 /* uimm5slist */)) {
6583 // qc.c.sync $slist
6584 // Operand: slist
6585 return true;
6586 } // if
6587 break;
6588 } // case QC_SYNC
6589 case RISCV::QC_SYNCR: {
6590 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
6591 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6592 MI.getOperand(0).isImm() &&
6593 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 26 /* uimm5slist */)) {
6594 // qc.c.syncr $slist
6595 // Operand: slist
6596 return true;
6597 } // if
6598 break;
6599 } // case QC_SYNCR
6600 case RISCV::QC_SYNCWF: {
6601 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
6602 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6603 MI.getOperand(0).isImm() &&
6604 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 26 /* uimm5slist */)) {
6605 // qc.c.syncwf $slist
6606 // Operand: slist
6607 return true;
6608 } // if
6609 break;
6610 } // case QC_SYNCWF
6611 case RISCV::QC_SYNCWL: {
6612 if (STI.getFeatureBits()[RISCV::FeatureVendorXqcisync] &&
6613 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6614 MI.getOperand(0).isImm() &&
6615 RISCVValidateMachineOperand(MI.getOperand(0), &STI, 26 /* uimm5slist */)) {
6616 // qc.c.syncwl $slist
6617 // Operand: slist
6618 return true;
6619 } // if
6620 break;
6621 } // case QC_SYNCWL
6622 case RISCV::SB: {
6623 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6624 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6625 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6626 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6627 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6628 MI.getOperand(2).isImm() &&
6629 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 12 /* uimm2 */)) {
6630 // c.sb $rs2, ${imm}(${rs1})
6631 // Operand: rs2
6632 // Operand: rs1
6633 // Operand: imm
6634 return true;
6635 } // if
6636 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
6637 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6638 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6639 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6640 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6641 MI.getOperand(2).isImm() &&
6642 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 13 /* uimm5 */)) {
6643 // qk.c.sb $rs2, ${imm}(${rs1})
6644 // Operand: rs2
6645 // Operand: rs1
6646 // Operand: imm
6647 return true;
6648 } // if
6649 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
6650 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6651 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6652 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6653 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
6654 MI.getOperand(2).isImm() &&
6655 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 14 /* uimm4 */)) {
6656 // qk.c.sbsp $rd_rs2, ${imm}(${rs1})
6657 // Operand: rd_rs2
6658 // Operand: rs1
6659 // Operand: imm
6660 return true;
6661 } // if
6662 break;
6663 } // case SB
6664 case RISCV::SD: {
6665 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
6666 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6667 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6668 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6669 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6670 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6671 MI.getOperand(2).isImm() &&
6672 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */)) {
6673 // c.sd $rs2, ${imm}(${rs1})
6674 // Operand: rs2
6675 // Operand: rs1
6676 // Operand: imm
6677 return true;
6678 } // if
6679 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
6680 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6681 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6682 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6683 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6684 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
6685 MI.getOperand(2).isImm() &&
6686 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm9_lsb000 */)) {
6687 // c.sdsp $rs2, ${imm}(${rs1})
6688 // Operand: rs2
6689 // Operand: rs1
6690 // Operand: imm
6691 return true;
6692 } // if
6693 break;
6694 } // case SD
6695 case RISCV::SD_RV32: {
6696 if (STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
6697 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6698 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6699 RISCVMCRegisterClasses[RISCV::GPRPairRegClassID].contains(MI.getOperand(0).getReg()) &&
6700 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6701 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
6702 MI.getOperand(2).isImm() &&
6703 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 8 /* uimm9_lsb000 */)) {
6704 // c.sdsp $rs2, ${imm}(${rs1})
6705 // Operand: rs2
6706 // Operand: rs1
6707 // Operand: imm
6708 return true;
6709 } // if
6710 if (STI.getFeatureBits()[RISCV::FeatureStdExtZclsd] &&
6711 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6712 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6713 RISCVMCRegisterClasses[RISCV::GPRPairCRegClassID].contains(MI.getOperand(0).getReg()) &&
6714 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6715 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6716 MI.getOperand(2).isImm() &&
6717 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 7 /* uimm8_lsb000 */)) {
6718 // c.sd $rs2, ${imm}(${rs1})
6719 // Operand: rs2
6720 // Operand: rs1
6721 // Operand: imm
6722 return true;
6723 } // if
6724 break;
6725 } // case SD_RV32
6726 case RISCV::SEXT_B: {
6727 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
6728 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6729 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6730 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6731 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6732 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
6733 // c.sext.b $rd
6734 // Operand: rd_wb
6735 // Operand: rd
6736 return true;
6737 } // if
6738 break;
6739 } // case SEXT_B
6740 case RISCV::SEXT_H: {
6741 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
6742 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6743 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6744 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6745 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6746 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
6747 // c.sext.h $rd
6748 // Operand: rd_wb
6749 // Operand: rd
6750 return true;
6751 } // if
6752 break;
6753 } // case SEXT_H
6754 case RISCV::SH: {
6755 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6756 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6757 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6758 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6759 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6760 MI.getOperand(2).isImm() &&
6761 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 15 /* uimm2_lsb0 */)) {
6762 // c.sh $rs2, ${imm}(${rs1})
6763 // Operand: rs2
6764 // Operand: rs1
6765 // Operand: imm
6766 return true;
6767 } // if
6768 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
6769 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6770 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6771 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6772 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6773 MI.getOperand(2).isImm() &&
6774 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 16 /* uimm6_lsb0 */)) {
6775 // qk.c.sh $rs2, ${imm}(${rs1})
6776 // Operand: rs2
6777 // Operand: rs1
6778 // Operand: imm
6779 return true;
6780 } // if
6781 if (STI.getFeatureBits()[RISCV::FeatureVendorXwchc] &&
6782 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6783 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6784 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6785 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
6786 MI.getOperand(2).isImm() &&
6787 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 17 /* uimm5_lsb0 */)) {
6788 // qk.c.shsp $rd_rs2, ${imm}(${rs1})
6789 // Operand: rd_rs2
6790 // Operand: rs1
6791 // Operand: imm
6792 return true;
6793 } // if
6794 break;
6795 } // case SH
6796 case RISCV::SH1ADD: {
6797 if (STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
6798 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
6799 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6800 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
6801 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
6802 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6803 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
6804 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6805 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6806 RISCVValidateMachineOperand(MachineOperand::CreateImm(2), &STI, 13 /* uimm5 */)) {
6807 // qc.c.muliadd $rd, $rs1, $uimm
6808 // Operand: rd_wb
6809 // Operand: rd
6810 // Operand: rs1
6811 // Operand: uimm
6812 return true;
6813 } // if
6814 break;
6815 } // case SH1ADD
6816 case RISCV::SH2ADD: {
6817 if (STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
6818 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
6819 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6820 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
6821 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
6822 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6823 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
6824 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6825 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6826 RISCVValidateMachineOperand(MachineOperand::CreateImm(4), &STI, 13 /* uimm5 */)) {
6827 // qc.c.muliadd $rd, $rs1, $uimm
6828 // Operand: rd_wb
6829 // Operand: rd
6830 // Operand: rs1
6831 // Operand: uimm
6832 return true;
6833 } // if
6834 break;
6835 } // case SH2ADD
6836 case RISCV::SH3ADD: {
6837 if (STI.getFeatureBits()[RISCV::FeatureStdExtZba] &&
6838 STI.getFeatureBits()[RISCV::FeatureVendorXqciac] &&
6839 !STI.getFeatureBits()[RISCV::Feature64Bit] &&
6840 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
6841 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
6842 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6843 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
6844 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6845 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6846 RISCVValidateMachineOperand(MachineOperand::CreateImm(8), &STI, 13 /* uimm5 */)) {
6847 // qc.c.muliadd $rd, $rs1, $uimm
6848 // Operand: rd_wb
6849 // Operand: rd
6850 // Operand: rs1
6851 // Operand: uimm
6852 return true;
6853 } // if
6854 break;
6855 } // case SH3ADD
6856 case RISCV::SH_INX: {
6857 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
6858 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6859 RISCVMCRegisterClasses[RISCV::GPRF16CRegClassID].contains(MI.getOperand(0).getReg()) &&
6860 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6861 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6862 MI.getOperand(2).isImm() &&
6863 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 15 /* uimm2_lsb0 */)) {
6864 // c.sh $rs2, ${imm}(${rs1})
6865 // Operand: rs2
6866 // Operand: rs1
6867 // Operand: imm
6868 return true;
6869 } // if
6870 break;
6871 } // case SH_INX
6872 case RISCV::SLLI: {
6873 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6874 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6875 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6876 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6877 RISCVMCRegisterClasses[RISCV::GPRNoX0RegClassID].contains(MI.getOperand(1).getReg()) &&
6878 MI.getOperand(2).isImm() &&
6879 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 6 /* uimmlog2xlennonzero */) &&
6880 MI.getOperand(2).isImm() &&
6881 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 27 /* uimmlog2xlen */)) {
6882 // c.slli $rd, $imm
6883 // Operand: rd_wb
6884 // Operand: rd
6885 // Operand: imm
6886 return true;
6887 } // if
6888 break;
6889 } // case SLLI
6890 case RISCV::SRAI: {
6891 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6892 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6893 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6894 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6895 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6896 MI.getOperand(2).isImm() &&
6897 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 6 /* uimmlog2xlennonzero */) &&
6898 MI.getOperand(2).isImm() &&
6899 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 27 /* uimmlog2xlen */)) {
6900 // c.srai $rs1, $imm
6901 // Operand: rd
6902 // Operand: rs1
6903 // Operand: imm
6904 return true;
6905 } // if
6906 break;
6907 } // case SRAI
6908 case RISCV::SRLI: {
6909 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6910 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6911 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6912 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6913 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6914 MI.getOperand(2).isImm() &&
6915 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 6 /* uimmlog2xlennonzero */) &&
6916 MI.getOperand(2).isImm() &&
6917 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 27 /* uimmlog2xlen */)) {
6918 // c.srli $rs1, $imm
6919 // Operand: rd
6920 // Operand: rs1
6921 // Operand: imm
6922 return true;
6923 } // if
6924 break;
6925 } // case SRLI
6926 case RISCV::SSPOPCHK: {
6927 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcmop] &&
6928 MI.getOperand(0).isReg() &&
6929 (MI.getOperand(0).getReg() == RISCV::X5)) {
6930 // c.sspopchk $rs1
6931 // Operand: rs1
6932 return true;
6933 } // if
6934 break;
6935 } // case SSPOPCHK
6936 case RISCV::SSPUSH: {
6937 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcmop] &&
6938 MI.getOperand(0).isReg() &&
6939 (MI.getOperand(0).getReg() == RISCV::X1)) {
6940 // c.sspush $rs1
6941 // Operand: rs1
6942 return true;
6943 } // if
6944 break;
6945 } // case SSPUSH
6946 case RISCV::SUB: {
6947 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6948 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6949 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6950 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6951 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6952 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6953 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg())) {
6954 // c.sub $rd, $rs2
6955 // Operand: rd_wb
6956 // Operand: rd
6957 // Operand: rs2
6958 return true;
6959 } // if
6960 break;
6961 } // case SUB
6962 case RISCV::SUBW: {
6963 if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
6964 STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6965 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
6966 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
6967 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6968 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6969 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
6970 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg())) {
6971 // c.subw $rd, $rs2
6972 // Operand: rd_wb
6973 // Operand: rd
6974 // Operand: rs2
6975 return true;
6976 } // if
6977 break;
6978 } // case SUBW
6979 case RISCV::SW: {
6980 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6981 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6982 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(0).getReg()) &&
6983 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6984 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
6985 MI.getOperand(2).isImm() &&
6986 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm7_lsb00 */)) {
6987 // c.sw $rs2, ${imm}(${rs1})
6988 // Operand: rs2
6989 // Operand: rs1
6990 // Operand: imm
6991 return true;
6992 } // if
6993 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
6994 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
6995 RISCVMCRegisterClasses[RISCV::GPRRegClassID].contains(MI.getOperand(0).getReg()) &&
6996 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
6997 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
6998 MI.getOperand(2).isImm() &&
6999 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm8_lsb00 */)) {
7000 // c.swsp $rs2, ${imm}(${rs1})
7001 // Operand: rs2
7002 // Operand: rs1
7003 // Operand: imm
7004 return true;
7005 } // if
7006 break;
7007 } // case SW
7008 case RISCV::SW_INX: {
7009 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
7010 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
7011 RISCVMCRegisterClasses[RISCV::GPRF32RegClassID].contains(MI.getOperand(0).getReg()) &&
7012 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7013 RISCVMCRegisterClasses[RISCV::SPRegClassID].contains(MI.getOperand(1).getReg()) &&
7014 MI.getOperand(2).isImm() &&
7015 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 10 /* uimm8_lsb00 */)) {
7016 // c.swsp $rs2, ${imm}(${rs1})
7017 // Operand: rs2
7018 // Operand: rs1
7019 // Operand: imm
7020 return true;
7021 } // if
7022 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
7023 MI.getOperand(0).isReg() && MI.getOperand(0).getReg().isPhysical() &&
7024 RISCVMCRegisterClasses[RISCV::GPRF32CRegClassID].contains(MI.getOperand(0).getReg()) &&
7025 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7026 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
7027 MI.getOperand(2).isImm() &&
7028 RISCVValidateMachineOperand(MI.getOperand(2), &STI, 9 /* uimm7_lsb00 */)) {
7029 // c.sw $rs2, ${imm}(${rs1})
7030 // Operand: rs2
7031 // Operand: rs1
7032 // Operand: imm
7033 return true;
7034 } // if
7035 break;
7036 } // case SW_INX
7037 case RISCV::UNIMP: {
7038 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca]) {
7039 // c.unimp
7040 return true;
7041 } // if
7042 break;
7043 } // case UNIMP
7044 case RISCV::XOR: {
7045 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
7046 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7047 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7048 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7049 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg()) &&
7050 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
7051 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg())) {
7052 // c.xor $rd, $rs2
7053 // Operand: rd_wb
7054 // Operand: rd
7055 // Operand: rs2
7056 return true;
7057 } // if
7058 if (STI.getFeatureBits()[RISCV::FeatureStdExtZca] &&
7059 MI.getOperand(2).isReg() && MI.getOperand(0).isReg() &&
7060 (MI.getOperand(2).getReg() == MI.getOperand(0).getReg()) &&
7061 MI.getOperand(2).isReg() && MI.getOperand(2).getReg().isPhysical() &&
7062 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(2).getReg()) &&
7063 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7064 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
7065 // c.xor $rd, $rs2
7066 // Operand: rd_wb
7067 // Operand: rd
7068 // Operand: rs2
7069 return true;
7070 } // if
7071 break;
7072 } // case XOR
7073 case RISCV::XORI: {
7074 if (STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
7075 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7076 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7077 MI.getOperand(2).isImm() &&
7078 (MI.getOperand(2).getImm() == -1) &&
7079 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7080 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
7081 // c.not $rd
7082 // Operand: rd_wb
7083 // Operand: rd
7084 return true;
7085 } // if
7086 break;
7087 } // case XORI
7088 case RISCV::ZEXT_H_RV32: {
7089 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
7090 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
7091 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7092 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7093 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7094 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
7095 // c.zext.h $rd
7096 // Operand: rd_wb
7097 // Operand: rd
7098 return true;
7099 } // if
7100 break;
7101 } // case ZEXT_H_RV32
7102 case RISCV::ZEXT_H_RV64: {
7103 if (STI.getFeatureBits()[RISCV::FeatureStdExtZbb] &&
7104 STI.getFeatureBits()[RISCV::FeatureStdExtZcb] &&
7105 MI.getOperand(1).isReg() && MI.getOperand(0).isReg() &&
7106 (MI.getOperand(1).getReg() == MI.getOperand(0).getReg()) &&
7107 MI.getOperand(1).isReg() && MI.getOperand(1).getReg().isPhysical() &&
7108 RISCVMCRegisterClasses[RISCV::GPRCRegClassID].contains(MI.getOperand(1).getReg())) {
7109 // c.zext.h $rd
7110 // Operand: rd_wb
7111 // Operand: rd
7112 return true;
7113 } // if
7114 break;
7115 } // case ZEXT_H_RV64
7116 } // switch
7117 return false;
7118}
7119
7120#endif // GEN_CHECK_COMPRESS_INSTR
7121
7122