LLVM: lib/Target/RISCV/MCTargetDesc/RISCVMatInt.cpp Source File

LLVM 22.0.0git
RISCVMatInt.cpp
Go to the documentation of this file.
1//===- RISCVMatInt.cpp - Immediate materialisation -------------*- C++ -*--===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "RISCVMatInt.h"
10#include "MCTargetDesc/RISCVMCTargetDesc.h"
11#include "llvm/ADT/APInt.h"
12#include "llvm/MC/MCInstBuilder.h"
13#include "llvm/Support/MathExtras.h"
14using namespace llvm;
15
16 static int getInstSeqCost(RISCVMatInt::InstSeq &Res, bool HasRVC) {
17 if (!HasRVC)
18 return Res.size();
19
20 int Cost = 0;
21 for (auto Instr : Res) {
22 // Assume instructions that aren't listed aren't compressible.
23 bool Compressed = false;
24 switch (Instr.getOpcode()) {
25 case RISCV::QC_E_LI:
26 // One 48-bit instruction takes the space of 1.5 regular instructions.
27 Cost += 150;
28 continue;
29 case RISCV::SLLI:
30 case RISCV::SRLI:
31 Compressed = true;
32 break;
33 case RISCV::ADDI:
34 case RISCV::ADDIW:
35 case RISCV::LUI:
36 Compressed = isInt<6>(Instr.getImm());
37 break;
38 }
39 // Two RVC instructions take the same space as one RVI instruction, but
40 // can take longer to execute than the single RVI instruction. Thus, we
41 // consider that two RVC instruction are slightly more costly than one
42 // RVI instruction. For longer sequences of RVC instructions the space
43 // savings can be worth it, though. The costs below try to model that.
44 if (!Compressed)
45 Cost += 100; // Baseline cost of one RVI instruction: 100%.
46 else
47 Cost += 70; // 70% cost of baseline.
48 }
49 return Cost;
50}
51
52// Recursively generate a sequence for materializing an integer.
53 static void generateInstSeqImpl(int64_t Val, const MCSubtargetInfo &STI,
55 bool IsRV64 = STI.hasFeature(RISCV::Feature64Bit);
56
57 // Use BSETI for a single bit that can't be expressed by a single LUI or ADDI.
58 if (STI.hasFeature(RISCV::FeatureStdExtZbs) && isPowerOf2_64(Val) &&
59 (!isInt<32>(Val) || Val == 0x800)) {
60 Res.emplace_back(RISCV::BSETI, Log2_64(Val));
61 return;
62 }
63
64 if (!IsRV64 && STI.hasFeature(RISCV::FeatureVendorXqcili)) {
65 bool FitsOneStandardInst = ((Val & 0xFFF) == 0) || isInt<12>(Val);
66
67 // 20-bit signed immediates that don't fit into `ADDI` or `LUI` should use
68 // `QC.LI` (a single 32-bit instruction).
69 if (!FitsOneStandardInst && isInt<20>(Val)) {
70 Res.emplace_back(RISCV::QC_LI, Val);
71 return;
72 }
73
74 // 32-bit signed immediates that don't fit into `ADDI`, `LUI` or `QC.LI`
75 // should use `QC.E.LI` (a single 48-bit instruction).
76 if (!FitsOneStandardInst && isInt<32>(Val)) {
77 Res.emplace_back(RISCV::QC_E_LI, Val);
78 return;
79 }
80 }
81
82 if (isInt<32>(Val)) {
83 // Depending on the active bits in the immediate Value v, the following
84 // instruction sequences are emitted:
85 //
86 // v == 0 : ADDI
87 // v[0,12) != 0 && v[12,32) == 0 : ADDI
88 // v[0,12) == 0 && v[12,32) != 0 : LUI
89 // v[0,32) != 0 : LUI+ADDI(W)
90 int64_t Hi20 = ((Val + 0x800) >> 12) & 0xFFFFF;
91 int64_t Lo12 = SignExtend64<12>(Val);
92
93 if (Hi20)
94 Res.emplace_back(RISCV::LUI, Hi20);
95
96 if (Lo12 || Hi20 == 0) {
97 unsigned AddiOpc = RISCV::ADDI;
98 if (IsRV64 && Hi20) {
99 // Use ADDIW rather than ADDI only when necessary for correctness. As
100 // noted in RISCVOptWInstrs, this helps reduce test differences vs
101 // RV32 without being a pessimization.
102 int64_t LuiRes = SignExtend64<32>(Hi20 << 12);
103 if (!isInt<32>(LuiRes + Lo12))
104 AddiOpc = RISCV::ADDIW;
105 }
106 Res.emplace_back(AddiOpc, Lo12);
107 }
108 return;
109 }
110
111 assert(IsRV64 && "Can't emit >32-bit imm for non-RV64 target");
112
113 // In the worst case, for a full 64-bit constant, a sequence of 8 instructions
114 // (i.e., LUI+ADDI+SLLI+ADDI+SLLI+ADDI+SLLI+ADDI) has to be emitted. Note
115 // that the first two instructions (LUI+ADDI) can contribute up to 32 bits
116 // while the following ADDI instructions contribute up to 12 bits each.
117 //
118 // On the first glance, implementing this seems to be possible by simply
119 // emitting the most significant 32 bits (LUI+ADDI(W)) followed by as many
120 // left shift (SLLI) and immediate additions (ADDI) as needed. However, due to
121 // the fact that ADDI performs a sign extended addition, doing it like that
122 // would only be possible when at most 11 bits of the ADDI instructions are
123 // used. Using all 12 bits of the ADDI instructions, like done by GAS,
124 // actually requires that the constant is processed starting with the least
125 // significant bit.
126 //
127 // In the following, constants are processed from LSB to MSB but instruction
128 // emission is performed from MSB to LSB by recursively calling
129 // generateInstSeq. In each recursion, first the lowest 12 bits are removed
130 // from the constant and the optimal shift amount, which can be greater than
131 // 12 bits if the constant is sparse, is determined. Then, the shifted
132 // remaining constant is processed recursively and gets emitted as soon as it
133 // fits into 32 bits. The emission of the shifts and additions is subsequently
134 // performed when the recursion returns.
135
136 int64_t Lo12 = SignExtend64<12>(Val);
137 Val = (uint64_t)Val - (uint64_t)Lo12;
138
139 int ShiftAmount = 0;
140 bool Unsigned = false;
141
142 // Val might now be valid for LUI without needing a shift.
143 if (!isInt<32>(Val)) {
144 ShiftAmount = llvm::countr_zero((uint64_t)Val);
145 Val >>= ShiftAmount;
146
147 // If the remaining bits don't fit in 12 bits, we might be able to reduce
148 // the shift amount in order to use LUI which will zero the lower 12
149 // bits.
150 if (ShiftAmount > 12 && !isInt<12>(Val)) {
151 if (isInt<32>((uint64_t)Val << 12)) {
152 // Reduce the shift amount and add zeros to the LSBs so it will match
153 // LUI.
154 ShiftAmount -= 12;
155 Val = (uint64_t)Val << 12;
156 } else if (isUInt<32>((uint64_t)Val << 12) &&
157 STI.hasFeature(RISCV::FeatureStdExtZba)) {
158 // Reduce the shift amount and add zeros to the LSBs so it will match
159 // LUI, then shift left with SLLI.UW to clear the upper 32 set bits.
160 ShiftAmount -= 12;
161 Val = SignExtend64<32>((uint64_t)Val << 12);
162 Unsigned = true;
163 }
164 }
165
166 // Try to use SLLI_UW for Val when it is uint32 but not int32.
167 if (isUInt<32>(Val) && !isInt<32>(Val) &&
168 STI.hasFeature(RISCV::FeatureStdExtZba)) {
169 // Use LUI+ADDI or LUI to compose, then clear the upper 32 bits with
170 // SLLI_UW.
171 Val = SignExtend64<32>((uint64_t)Val);
172 Unsigned = true;
173 }
174 }
175
176 generateInstSeqImpl(Val, STI, Res);
177
178 // Skip shift if we were able to use LUI directly.
179 if (ShiftAmount) {
180 unsigned Opc = Unsigned ? RISCV::SLLI_UW : RISCV::SLLI;
181 Res.emplace_back(Opc, ShiftAmount);
182 }
183
184 if (Lo12)
185 Res.emplace_back(RISCV::ADDI, Lo12);
186}
187
188 static unsigned extractRotateInfo(int64_t Val) {
189 // for case: 0b111..1..xxxxxx1..1..
190 unsigned LeadingOnes = llvm::countl_one((uint64_t)Val);
191 unsigned TrailingOnes = llvm::countr_one((uint64_t)Val);
192 if (TrailingOnes > 0 && TrailingOnes < 64 &&
193 (LeadingOnes + TrailingOnes) > (64 - 12))
194 return 64 - TrailingOnes;
195
196 // for case: 0bxxx1..1..1...xxx
197 unsigned UpperTrailingOnes = llvm::countr_one(Hi_32(Val));
198 unsigned LowerLeadingOnes = llvm::countl_one(Lo_32(Val));
199 if (UpperTrailingOnes < 32 &&
200 (UpperTrailingOnes + LowerLeadingOnes) > (64 - 12))
201 return 32 - UpperTrailingOnes;
202
203 return 0;
204}
205
206 static void generateInstSeqLeadingZeros(int64_t Val, const MCSubtargetInfo &STI,
208 assert(Val > 0 && "Expected positive val");
209
210 unsigned LeadingZeros = llvm::countl_zero((uint64_t)Val);
211 uint64_t ShiftedVal = (uint64_t)Val << LeadingZeros;
212 // Fill in the bits that will be shifted out with 1s. An example where this
213 // helps is trailing one masks with 32 or more ones. This will generate
214 // ADDI -1 and an SRLI.
215 ShiftedVal |= maskTrailingOnes<uint64_t>(LeadingZeros);
216
218 generateInstSeqImpl(ShiftedVal, STI, TmpSeq);
219
220 // Keep the new sequence if it is an improvement or the original is empty.
221 if ((TmpSeq.size() + 1) < Res.size() ||
222 (Res.empty() && TmpSeq.size() < 8)) {
223 TmpSeq.emplace_back(RISCV::SRLI, LeadingZeros);
224 Res = TmpSeq;
225 }
226
227 // Some cases can benefit from filling the lower bits with zeros instead.
228 ShiftedVal &= maskTrailingZeros<uint64_t>(LeadingZeros);
229 TmpSeq.clear();
230 generateInstSeqImpl(ShiftedVal, STI, TmpSeq);
231
232 // Keep the new sequence if it is an improvement or the original is empty.
233 if ((TmpSeq.size() + 1) < Res.size() ||
234 (Res.empty() && TmpSeq.size() < 8)) {
235 TmpSeq.emplace_back(RISCV::SRLI, LeadingZeros);
236 Res = TmpSeq;
237 }
238
239 // If we have exactly 32 leading zeros and Zba, we can try using zext.w at
240 // the end of the sequence.
241 if (LeadingZeros == 32 && STI.hasFeature(RISCV::FeatureStdExtZba)) {
242 // Bit 31 is set, so sign extend to fill the upper bits with 1s.
243 uint64_t LeadingOnesVal = SignExtend64<32>(Val);
244 TmpSeq.clear();
245 generateInstSeqImpl(LeadingOnesVal, STI, TmpSeq);
246
247 // Keep the new sequence if it is an improvement.
248 if ((TmpSeq.size() + 1) < Res.size() ||
249 (Res.empty() && TmpSeq.size() < 8)) {
250 TmpSeq.emplace_back(RISCV::ADD_UW, 0);
251 Res = TmpSeq;
252 }
253 }
254}
255
257 InstSeq generateInstSeq(int64_t Val, const MCSubtargetInfo &STI) {
259 generateInstSeqImpl(Val, STI, Res);
260
261 // If the low 12 bits are non-zero, the first expansion may end with an ADDI
262 // or ADDIW. If there are trailing zeros, try generating a sign extended
263 // constant with no trailing zeros and use a final SLLI to restore them.
264 if ((Val & 0xfff) != 0 && (Val & 1) == 0 && Res.size() >= 2) {
265 unsigned TrailingZeros = llvm::countr_zero((uint64_t)Val);
266 int64_t ShiftedVal = Val >> TrailingZeros;
267 // If we can use C.LI+C.SLLI instead of LUI+ADDI(W) prefer that since
268 // its more compressible. But only if LUI+ADDI(W) isn't fusable.
269 // NOTE: We don't check for C extension to minimize differences in generated
270 // code.
271 bool IsShiftedCompressible =
272 isInt<6>(ShiftedVal) && !STI.hasFeature(RISCV::TuneLUIADDIFusion);
274 generateInstSeqImpl(ShiftedVal, STI, TmpSeq);
275
276 // Keep the new sequence if it is an improvement.
277 if ((TmpSeq.size() + 1) < Res.size() || IsShiftedCompressible) {
278 TmpSeq.emplace_back(RISCV::SLLI, TrailingZeros);
279 Res = TmpSeq;
280 }
281 }
282
283 // If we have a 1 or 2 instruction sequence this is the best we can do. This
284 // will always be true for RV32 and will often be true for RV64.
285 if (Res.size() <= 2)
286 return Res;
287
288 assert(STI.hasFeature(RISCV::Feature64Bit) &&
289 "Expected RV32 to only need 2 instructions");
290
291 // If the lower 13 bits are something like 0x17ff, try to add 1 to change the
292 // lower 13 bits to 0x1800. We can restore this with an ADDI of -1 at the end
293 // of the sequence. Call generateInstSeqImpl on the new constant which may
294 // subtract 0xfffffffffffff800 to create another ADDI. This will leave a
295 // constant with more than 12 trailing zeros for the next recursive step.
296 if ((Val & 0xfff) != 0 && (Val & 0x1800) == 0x1000) {
297 int64_t Imm12 = -(0x800 - (Val & 0xfff));
298 int64_t AdjustedVal = Val - Imm12;
300 generateInstSeqImpl(AdjustedVal, STI, TmpSeq);
301
302 // Keep the new sequence if it is an improvement.
303 if ((TmpSeq.size() + 1) < Res.size()) {
304 TmpSeq.emplace_back(RISCV::ADDI, Imm12);
305 Res = TmpSeq;
306 }
307 }
308
309 // If the constant is positive we might be able to generate a shifted constant
310 // with no leading zeros and use a final SRLI to restore them.
311 if (Val > 0 && Res.size() > 2) {
312 generateInstSeqLeadingZeros(Val, STI, Res);
313 }
314
315 // If the constant is negative, trying inverting and using our trailing zero
316 // optimizations. Use an xori to invert the final value.
317 if (Val < 0 && Res.size() > 3) {
318 uint64_t InvertedVal = ~(uint64_t)Val;
320 generateInstSeqLeadingZeros(InvertedVal, STI, TmpSeq);
321
322 // Keep it if we found a sequence that is smaller after inverting.
323 if (!TmpSeq.empty() && (TmpSeq.size() + 1) < Res.size()) {
324 TmpSeq.emplace_back(RISCV::XORI, -1);
325 Res = TmpSeq;
326 }
327 }
328
329 // If the Low and High halves are the same, use pack. The pack instruction
330 // packs the XLEN/2-bit lower halves of rs1 and rs2 into rd, with rs1 in the
331 // lower half and rs2 in the upper half.
332 if (Res.size() > 2 && STI.hasFeature(RISCV::FeatureStdExtZbkb)) {
333 int64_t LoVal = SignExtend64<32>(Val);
334 int64_t HiVal = SignExtend64<32>(Val >> 32);
335 if (LoVal == HiVal) {
337 generateInstSeqImpl(LoVal, STI, TmpSeq);
338 if ((TmpSeq.size() + 1) < Res.size()) {
339 TmpSeq.emplace_back(RISCV::PACK, 0);
340 Res = TmpSeq;
341 }
342 }
343 }
344
345 // Perform optimization with BSETI in the Zbs extension.
346 if (Res.size() > 2 && STI.hasFeature(RISCV::FeatureStdExtZbs)) {
347 // Create a simm32 value for LUI+ADDI(W) by forcing the upper 33 bits to
348 // zero. Xor that with original value to get which bits should be set by
349 // BSETI.
350 uint64_t Lo = Val & 0x7fffffff;
351 uint64_t Hi = Val ^ Lo;
352 assert(Hi != 0);
354
355 if (Lo != 0)
356 generateInstSeqImpl(Lo, STI, TmpSeq);
357
358 if (TmpSeq.size() + llvm::popcount(Hi) < Res.size()) {
359 do {
360 TmpSeq.emplace_back(RISCV::BSETI, llvm::countr_zero(Hi));
361 Hi &= (Hi - 1); // Clear lowest set bit.
362 } while (Hi != 0);
363 Res = TmpSeq;
364 }
365
366 // Fold LI 1 + SLLI into BSETI.
367 if (Res[0].getOpcode() == RISCV::ADDI && Res[0].getImm() == 1 &&
368 Res[1].getOpcode() == RISCV::SLLI) {
369 Res.erase(Res.begin()); // Remove ADDI.
370 Res.front() = Inst(RISCV::BSETI, Res.front().getImm()); // Patch SLLI.
371 }
372 }
373
374 // Perform optimization with BCLRI in the Zbs extension.
375 if (Res.size() > 2 && STI.hasFeature(RISCV::FeatureStdExtZbs)) {
376 // Create a simm32 value for LUI+ADDI(W) by forcing the upper 33 bits to
377 // one. Xor that with original value to get which bits should be cleared by
378 // BCLRI.
379 uint64_t Lo = Val | 0xffffffff80000000;
380 uint64_t Hi = Val ^ Lo;
381 assert(Hi != 0);
382
384 generateInstSeqImpl(Lo, STI, TmpSeq);
385
386 if (TmpSeq.size() + llvm::popcount(Hi) < Res.size()) {
387 do {
388 TmpSeq.emplace_back(RISCV::BCLRI, llvm::countr_zero(Hi));
389 Hi &= (Hi - 1); // Clear lowest set bit.
390 } while (Hi != 0);
391 Res = TmpSeq;
392 }
393 }
394
395 // Perform optimization with SH*ADD in the Zba extension.
396 if (Res.size() > 2 && STI.hasFeature(RISCV::FeatureStdExtZba)) {
397 int64_t Div = 0;
398 unsigned Opc = 0;
400 // Select the opcode and divisor.
401 if ((Val % 3) == 0 && isInt<32>(Val / 3)) {
402 Div = 3;
403 Opc = RISCV::SH1ADD;
404 } else if ((Val % 5) == 0 && isInt<32>(Val / 5)) {
405 Div = 5;
406 Opc = RISCV::SH2ADD;
407 } else if ((Val % 9) == 0 && isInt<32>(Val / 9)) {
408 Div = 9;
409 Opc = RISCV::SH3ADD;
410 }
411 // Build the new instruction sequence.
412 if (Div > 0) {
413 generateInstSeqImpl(Val / Div, STI, TmpSeq);
414 if ((TmpSeq.size() + 1) < Res.size()) {
415 TmpSeq.emplace_back(Opc, 0);
416 Res = TmpSeq;
417 }
418 } else {
419 // Try to use LUI+SH*ADD+ADDI.
420 int64_t Hi52 = ((uint64_t)Val + 0x800ull) & ~0xfffull;
421 int64_t Lo12 = SignExtend64<12>(Val);
422 Div = 0;
423 if (isInt<32>(Hi52 / 3) && (Hi52 % 3) == 0) {
424 Div = 3;
425 Opc = RISCV::SH1ADD;
426 } else if (isInt<32>(Hi52 / 5) && (Hi52 % 5) == 0) {
427 Div = 5;
428 Opc = RISCV::SH2ADD;
429 } else if (isInt<32>(Hi52 / 9) && (Hi52 % 9) == 0) {
430 Div = 9;
431 Opc = RISCV::SH3ADD;
432 }
433 // Build the new instruction sequence.
434 if (Div > 0) {
435 // For Val that has zero Lo12 (implies Val equals to Hi52) should has
436 // already been processed to LUI+SH*ADD by previous optimization.
437 assert(Lo12 != 0 &&
438 "unexpected instruction sequence for immediate materialisation");
439 assert(TmpSeq.empty() && "Expected empty TmpSeq");
440 generateInstSeqImpl(Hi52 / Div, STI, TmpSeq);
441 if ((TmpSeq.size() + 2) < Res.size()) {
442 TmpSeq.emplace_back(Opc, 0);
443 TmpSeq.emplace_back(RISCV::ADDI, Lo12);
444 Res = TmpSeq;
445 }
446 }
447 }
448 }
449
450 // Perform optimization with rori in the Zbb and th.srri in the XTheadBb
451 // extension.
452 if (Res.size() > 2 && (STI.hasFeature(RISCV::FeatureStdExtZbb) ||
453 STI.hasFeature(RISCV::FeatureVendorXTHeadBb))) {
454 if (unsigned Rotate = extractRotateInfo(Val)) {
456 uint64_t NegImm12 = llvm::rotl<uint64_t>(Val, Rotate);
457 assert(isInt<12>(NegImm12));
458 TmpSeq.emplace_back(RISCV::ADDI, NegImm12);
459 TmpSeq.emplace_back(STI.hasFeature(RISCV::FeatureStdExtZbb)
460 ? RISCV::RORI
461 : RISCV::TH_SRRI,
462 Rotate);
463 Res = TmpSeq;
464 }
465 }
466 return Res;
467}
468
469 void generateMCInstSeq(int64_t Val, const MCSubtargetInfo &STI,
470 MCRegister DestReg, SmallVectorImpl<MCInst> &Insts) {
472
473 MCRegister SrcReg = RISCV::X0;
474 for (RISCVMatInt::Inst &Inst : Seq) {
475 switch (Inst.getOpndKind()) {
476 case RISCVMatInt::Imm:
478 .addReg(DestReg)
479 .addImm(Inst.getImm()));
480 break;
483 .addReg(DestReg)
484 .addReg(SrcReg)
485 .addReg(RISCV::X0));
486 break;
489 .addReg(DestReg)
490 .addReg(SrcReg)
491 .addReg(SrcReg));
492 break;
495 .addReg(DestReg)
496 .addReg(SrcReg)
497 .addImm(Inst.getImm()));
498 break;
499 }
500
501 // Only the first instruction has X0 as its source.
502 SrcReg = DestReg;
503 }
504}
505
507 unsigned &ShiftAmt, unsigned &AddOpc) {
508 int64_t LoVal = SignExtend64<32>(Val);
509 if (LoVal == 0)
510 return RISCVMatInt::InstSeq();
511
512 // Subtract the LoVal to emulate the effect of the final ADD.
513 uint64_t Tmp = (uint64_t)Val - (uint64_t)LoVal;
514 assert(Tmp != 0);
515
516 // Use trailing zero counts to figure how far we need to shift LoVal to line
517 // up with the remaining constant.
518 // TODO: This algorithm assumes all non-zero bits in the low 32 bits of the
519 // final constant come from LoVal.
520 unsigned TzLo = llvm::countr_zero((uint64_t)LoVal);
521 unsigned TzHi = llvm::countr_zero(Tmp);
522 assert(TzLo < 32 && TzHi >= 32);
523 ShiftAmt = TzHi - TzLo;
524 AddOpc = RISCV::ADD;
525
526 if (Tmp == ((uint64_t)LoVal << ShiftAmt))
527 return RISCVMatInt::generateInstSeq(LoVal, STI);
528
529 // If we have Zba, we can use (ADD_UW X, (SLLI X, 32)).
530 if (STI.hasFeature(RISCV::FeatureStdExtZba) && Lo_32(Val) == Hi_32(Val)) {
531 ShiftAmt = 32;
532 AddOpc = RISCV::ADD_UW;
533 return RISCVMatInt::generateInstSeq(LoVal, STI);
534 }
535
536 return RISCVMatInt::InstSeq();
537}
538
539 int getIntMatCost(const APInt &Val, unsigned Size, const MCSubtargetInfo &STI,
540 bool CompressionCost, bool FreeZeroes) {
541 bool IsRV64 = STI.hasFeature(RISCV::Feature64Bit);
542 bool HasRVC = CompressionCost && STI.hasFeature(RISCV::FeatureStdExtZca);
543 int PlatRegSize = IsRV64 ? 64 : 32;
544
545 // Split the constant into platform register sized chunks, and calculate cost
546 // of each chunk.
547 int Cost = 0;
548 for (unsigned ShiftVal = 0; ShiftVal < Size; ShiftVal += PlatRegSize) {
549 APInt Chunk = Val.ashr(ShiftVal).sextOrTrunc(PlatRegSize);
550 if (FreeZeroes && Chunk.getSExtValue() == 0)
551 continue;
552 InstSeq MatSeq = generateInstSeq(Chunk.getSExtValue(), STI);
553 Cost += getInstSeqCost(MatSeq, HasRVC);
554 }
555 return std::max(FreeZeroes ? 0 : 1, Cost);
556}
557
559 switch (Opc) {
560 default:
561 llvm_unreachable("Unexpected opcode!");
562 case RISCV::LUI:
563 case RISCV::QC_LI:
564 case RISCV::QC_E_LI:
565 return RISCVMatInt::Imm;
566 case RISCV::ADD_UW:
567 return RISCVMatInt::RegX0;
568 case RISCV::SH1ADD:
569 case RISCV::SH2ADD:
570 case RISCV::SH3ADD:
571 case RISCV::PACK:
572 return RISCVMatInt::RegReg;
573 case RISCV::ADDI:
574 case RISCV::ADDIW:
575 case RISCV::XORI:
576 case RISCV::SLLI:
577 case RISCV::SRLI:
578 case RISCV::SLLI_UW:
579 case RISCV::RORI:
580 case RISCV::BSETI:
581 case RISCV::BCLRI:
582 case RISCV::TH_SRRI:
583 return RISCVMatInt::RegImm;
584 }
585}
586
587} // namespace llvm::RISCVMatInt
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file implements a class to represent arbitrary precision integral constant values and operations...
@ Unsigned
static void generateInstSeqLeadingZeros(int64_t Val, const MCSubtargetInfo &STI, RISCVMatInt::InstSeq &Res)
static void generateInstSeqImpl(int64_t Val, const MCSubtargetInfo &STI, RISCVMatInt::InstSeq &Res)
Definition RISCVMatInt.cpp:53
static unsigned extractRotateInfo(int64_t Val)
static int getInstSeqCost(RISCVMatInt::InstSeq &Res, bool HasRVC)
Definition RISCVMatInt.cpp:16
static std::optional< unsigned > getOpcode(ArrayRef< VPValue * > Values)
Returns the opcode of Values or ~0 if they do not all agree.
Definition VPlanSLP.cpp:247
Class for arbitrary precision integers.
Definition APInt.h:78
LLVM_ABI APInt sextOrTrunc(unsigned width) const
Sign extend or truncate to width.
Definition APInt.cpp:1041
APInt ashr(unsigned ShiftAmt) const
Arithmetic right-shift function.
Definition APInt.h:828
int64_t getSExtValue() const
Get sign extended value.
Definition APInt.h:1563
MCInstBuilder & addReg(MCRegister Reg)
Add a new register operand.
Definition MCInstBuilder.h:37
MCInstBuilder & addImm(int64_t Val)
Add a new integer immediate operand.
Definition MCInstBuilder.h:43
Wrapper class representing physical registers. Should be passed by value.
Definition MCRegister.h:33
Generic base class for all target subtargets.
bool hasFeature(unsigned Feature) const
int64_t getImm() const
Definition RISCVMatInt.h:39
unsigned getOpcode() const
Definition RISCVMatInt.h:38
OpndKind getOpndKind() const
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition SmallVector.h:574
reference emplace_back(ArgTypes &&... Args)
Definition SmallVector.h:944
iterator erase(const_iterator CI)
Definition SmallVector.h:744
void push_back(const T &Elt)
Definition SmallVector.h:417
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
InstSeq generateInstSeq(int64_t Val, const MCSubtargetInfo &STI)
int getIntMatCost(const APInt &Val, unsigned Size, const MCSubtargetInfo &STI, bool CompressionCost, bool FreeZeroes)
InstSeq generateTwoRegInstSeq(int64_t Val, const MCSubtargetInfo &STI, unsigned &ShiftAmt, unsigned &AddOpc)
SmallVector< Inst, 8 > InstSeq
Definition RISCVMatInt.h:43
void generateMCInstSeq(int64_t Val, const MCSubtargetInfo &STI, MCRegister DestReg, SmallVectorImpl< MCInst > &Insts)
This is an optimization pass for GlobalISel generic memory operations.
Definition AddressRanges.h:18
InstructionCost Cost
constexpr bool isInt(int64_t x)
Checks if an integer fits into the given bit width.
Definition MathExtras.h:165
int countr_one(T Value)
Count the number of ones from the least significant bit to the first zero bit.
Definition bit.h:293
constexpr bool isPowerOf2_64(uint64_t Value)
Return true if the argument is a power of two > 0 (64 bit edition.)
Definition MathExtras.h:284
constexpr int popcount(T Value) noexcept
Count the number of set bits in a value.
Definition bit.h:154
unsigned Log2_64(uint64_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
Definition MathExtras.h:337
int countr_zero(T Val)
Count number of 0's from the least significant bit to the most stopping at the first 1.
Definition bit.h:202
int countl_zero(T Val)
Count number of 0's from the most significant bit to the least stopping at the first 1.
Definition bit.h:236
MachineInstr * getImm(const MachineOperand &MO, const MachineRegisterInfo *MRI)
Definition SPIRVUtils.cpp:998
constexpr uint32_t Hi_32(uint64_t Value)
Return the high 32 bits of a 64 bit value.
Definition MathExtras.h:150
constexpr bool isUInt(uint64_t x)
Checks if an unsigned integer fits into the given bit width.
Definition MathExtras.h:189
int countl_one(T Value)
Count the number of ones from the most significant bit to the first zero bit.
Definition bit.h:280
constexpr uint32_t Lo_32(uint64_t Value)
Return the low 32 bits of a 64 bit value.
Definition MathExtras.h:155
constexpr T maskTrailingZeros(unsigned N)
Create a bitmask with the N right-most bits set to 0, and all other bits set to 1.
Definition MathExtras.h:94
constexpr int64_t SignExtend64(uint64_t x)
Sign-extend the number in the bottom B bits of X to a 64-bit integer.
Definition MathExtras.h:572
constexpr T maskTrailingOnes(unsigned N)
Create a bitmask with the N right-most bits set to 1, and all other bits set to 0.
Definition MathExtras.h:77
constexpr T rotl(T V, int R)
Definition bit.h:369
Generated on for LLVM by doxygen 1.14.0

AltStyle によって変換されたページ (->オリジナル) /