1//===- llvm/CodeGen/GlobalISel/Utils.cpp -------------------------*- 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/// \file This file implements the utility functions used by the GlobalISel
9/// pipeline.
10//===----------------------------------------------------------------------===//
11
12#include "llvm/CodeGen/GlobalISel/Utils.h"
13#include "llvm/ADT/APFloat.h"
14#include "llvm/ADT/APInt.h"
15#include "llvm/Analysis/ValueTracking.h"
16#include "llvm/CodeGen/CodeGenCommonISel.h"
17#include "llvm/CodeGen/GlobalISel/GISelChangeObserver.h"
18#include "llvm/CodeGen/GlobalISel/GISelValueTracking.h"
19#include "llvm/CodeGen/GlobalISel/GenericMachineInstrs.h"
20#include "llvm/CodeGen/GlobalISel/LostDebugLocObserver.h"
21#include "llvm/CodeGen/GlobalISel/MIPatternMatch.h"
22#include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
23#include "llvm/CodeGen/MachineInstr.h"
24#include "llvm/CodeGen/MachineInstrBuilder.h"
25#include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
26#include "llvm/CodeGen/MachineRegisterInfo.h"
27#include "llvm/CodeGen/MachineSizeOpts.h"
28#include "llvm/CodeGen/RegisterBankInfo.h"
29#include "llvm/CodeGen/StackProtector.h"
30#include "llvm/CodeGen/TargetInstrInfo.h"
31#include "llvm/CodeGen/TargetLowering.h"
32#include "llvm/CodeGen/TargetOpcodes.h"
33#include "llvm/CodeGen/TargetPassConfig.h"
34#include "llvm/CodeGen/TargetRegisterInfo.h"
35#include "llvm/IR/Constants.h"
36#include "llvm/Target/TargetMachine.h"
37#include "llvm/Transforms/Utils/SizeOpts.h"
38#include <numeric>
39#include <optional>
40
41#define DEBUG_TYPE "globalisel-utils"
42
43using namespace llvm;
44using namespace MIPatternMatch;
45
46Register llvm::constrainRegToClass(MachineRegisterInfo &MRI,
47 const TargetInstrInfo &TII,
48 const RegisterBankInfo &RBI, Register Reg,
49 const TargetRegisterClass &RegClass) {
50 if (!RBI.constrainGenericRegister(Reg, RC: RegClass, MRI))
51 return MRI.createVirtualRegister(RegClass: &RegClass);
52
53 return Reg;
54}
55
56Register llvm::constrainOperandRegClass(
57 const MachineFunction &MF, const TargetRegisterInfo &TRI,
58 MachineRegisterInfo &MRI, const TargetInstrInfo &TII,
59 const RegisterBankInfo &RBI, MachineInstr &InsertPt,
60 const TargetRegisterClass &RegClass, MachineOperand &RegMO) {
61 Register Reg = RegMO.getReg();
62 // Assume physical registers are properly constrained.
63 assert(Reg.isVirtual() && "PhysReg not implemented");
64
65 // Save the old register class to check whether
66 // the change notifications will be required.
67 // TODO: A better approach would be to pass
68 // the observers to constrainRegToClass().
69 auto *OldRegClass = MRI.getRegClassOrNull(Reg);
70 Register ConstrainedReg = constrainRegToClass(MRI, TII, RBI, Reg, RegClass);
71 // If we created a new virtual register because the class is not compatible
72 // then create a copy between the new and the old register.
73 if (ConstrainedReg != Reg) {
74 MachineBasicBlock::iterator InsertIt(&InsertPt);
75 MachineBasicBlock &MBB = *InsertPt.getParent();
76 // FIXME: The copy needs to have the classes constrained for its operands.
77 // Use operand's regbank to get the class for old register (Reg).
78 if (RegMO.isUse()) {
79 BuildMI(BB&: MBB, I: InsertIt, MIMD: InsertPt.getDebugLoc(),
80 MCID: TII.get(Opcode: TargetOpcode::COPY), DestReg: ConstrainedReg)
81 .addReg(RegNo: Reg);
82 } else {
83 assert(RegMO.isDef() && "Must be a definition");
84 BuildMI(BB&: MBB, I: std::next(x: InsertIt), MIMD: InsertPt.getDebugLoc(),
85 MCID: TII.get(Opcode: TargetOpcode::COPY), DestReg: Reg)
86 .addReg(RegNo: ConstrainedReg);
87 }
88 if (GISelChangeObserver *Observer = MF.getObserver()) {
89 Observer->changingInstr(MI&: *RegMO.getParent());
90 }
91 RegMO.setReg(ConstrainedReg);
92 if (GISelChangeObserver *Observer = MF.getObserver()) {
93 Observer->changedInstr(MI&: *RegMO.getParent());
94 }
95 } else if (OldRegClass != MRI.getRegClassOrNull(Reg)) {
96 if (GISelChangeObserver *Observer = MF.getObserver()) {
97 if (!RegMO.isDef()) {
98 MachineInstr *RegDef = MRI.getVRegDef(Reg);
99 Observer->changedInstr(MI&: *RegDef);
100 }
101 Observer->changingAllUsesOfReg(MRI, Reg);
102 Observer->finishedChangingAllUsesOfReg();
103 }
104 }
105 return ConstrainedReg;
106}
107
108Register llvm::constrainOperandRegClass(
109 const MachineFunction &MF, const TargetRegisterInfo &TRI,
110 MachineRegisterInfo &MRI, const TargetInstrInfo &TII,
111 const RegisterBankInfo &RBI, MachineInstr &InsertPt, const MCInstrDesc &II,
112 MachineOperand &RegMO, unsigned OpIdx) {
113 Register Reg = RegMO.getReg();
114 // Assume physical registers are properly constrained.
115 assert(Reg.isVirtual() && "PhysReg not implemented");
116
117 const TargetRegisterClass *OpRC = TII.getRegClass(MCID: II, OpNum: OpIdx);
118 // Some of the target independent instructions, like COPY, may not impose any
119 // register class constraints on some of their operands: If it's a use, we can
120 // skip constraining as the instruction defining the register would constrain
121 // it.
122
123 if (OpRC) {
124 // Obtain the RC from incoming regbank if it is a proper sub-class. Operands
125 // can have multiple regbanks for a superclass that combine different
126 // register types (E.g., AMDGPU's VGPR and AGPR). The regbank ambiguity
127 // resolved by targets during regbankselect should not be overridden.
128 if (const auto *SubRC = TRI.getCommonSubClass(
129 A: OpRC, B: TRI.getConstrainedRegClassForOperand(MO: RegMO, MRI)))
130 OpRC = SubRC;
131
132 OpRC = TRI.getAllocatableClass(RC: OpRC);
133 }
134
135 if (!OpRC) {
136 assert((!isTargetSpecificOpcode(II.getOpcode()) || RegMO.isUse()) &&
137 "Register class constraint is required unless either the "
138 "instruction is target independent or the operand is a use");
139 // FIXME: Just bailing out like this here could be not enough, unless we
140 // expect the users of this function to do the right thing for PHIs and
141 // COPY:
142 // v1 = COPY v0
143 // v2 = COPY v1
144 // v1 here may end up not being constrained at all. Please notice that to
145 // reproduce the issue we likely need a destination pattern of a selection
146 // rule producing such extra copies, not just an input GMIR with them as
147 // every existing target using selectImpl handles copies before calling it
148 // and they never reach this function.
149 return Reg;
150 }
151 return constrainOperandRegClass(MF, TRI, MRI, TII, RBI, InsertPt, RegClass: *OpRC,
152 RegMO);
153}
154
155void llvm::constrainSelectedInstRegOperands(MachineInstr &I,
156 const TargetInstrInfo &TII,
157 const TargetRegisterInfo &TRI,
158 const RegisterBankInfo &RBI) {
159 assert(!isPreISelGenericOpcode(I.getOpcode()) &&
160 "A selected instruction is expected");
161 MachineBasicBlock &MBB = *I.getParent();
162 MachineFunction &MF = *MBB.getParent();
163 MachineRegisterInfo &MRI = MF.getRegInfo();
164
165 for (unsigned OpI = 0, OpE = I.getNumExplicitOperands(); OpI != OpE; ++OpI) {
166 MachineOperand &MO = I.getOperand(i: OpI);
167
168 // There's nothing to be done on non-register operands.
169 if (!MO.isReg())
170 continue;
171
172 LLVM_DEBUG(dbgs() << "Converting operand: " << MO << '\n');
173 assert(MO.isReg() && "Unsupported non-reg operand");
174
175 Register Reg = MO.getReg();
176 // Physical registers don't need to be constrained.
177 if (Reg.isPhysical())
178 continue;
179
180 // Register operands with a value of 0 (e.g. predicate operands) don't need
181 // to be constrained.
182 if (Reg == 0)
183 continue;
184
185 // If the operand is a vreg, we should constrain its regclass, and only
186 // insert COPYs if that's impossible.
187 // constrainOperandRegClass does that for us.
188 constrainOperandRegClass(MF, TRI, MRI, TII, RBI, InsertPt&: I, II: I.getDesc(), RegMO&: MO, OpIdx: OpI);
189
190 // Tie uses to defs as indicated in MCInstrDesc if this hasn't already been
191 // done.
192 if (MO.isUse()) {
193 int DefIdx = I.getDesc().getOperandConstraint(OpNum: OpI, Constraint: MCOI::TIED_TO);
194 if (DefIdx != -1 && !I.isRegTiedToUseOperand(DefOpIdx: DefIdx))
195 I.tieOperands(DefIdx, UseIdx: OpI);
196 }
197 }
198}
199
200bool llvm::canReplaceReg(Register DstReg, Register SrcReg,
201 MachineRegisterInfo &MRI) {
202 // Give up if either DstReg or SrcReg is a physical register.
203 if (DstReg.isPhysical() || SrcReg.isPhysical())
204 return false;
205 // Give up if the types don't match.
206 if (MRI.getType(Reg: DstReg) != MRI.getType(Reg: SrcReg))
207 return false;
208 // Replace if either DstReg has no constraints or the register
209 // constraints match.
210 const auto &DstRBC = MRI.getRegClassOrRegBank(Reg: DstReg);
211 if (!DstRBC || DstRBC == MRI.getRegClassOrRegBank(Reg: SrcReg))
212 return true;
213
214 // Otherwise match if the Src is already a regclass that is covered by the Dst
215 // RegBank.
216 return isa<const RegisterBank *>(Val: DstRBC) && MRI.getRegClassOrNull(Reg: SrcReg) &&
217 cast<const RegisterBank *>(Val: DstRBC)->covers(
218 RC: *MRI.getRegClassOrNull(Reg: SrcReg));
219}
220
221bool llvm::isTriviallyDead(const MachineInstr &MI,
222 const MachineRegisterInfo &MRI) {
223 // Instructions without side-effects are dead iff they only define dead regs.
224 // This function is hot and this loop returns early in the common case,
225 // so only perform additional checks before this if absolutely necessary.
226 for (const auto &MO : MI.all_defs()) {
227 Register Reg = MO.getReg();
228 if (Reg.isPhysical() || !MRI.use_nodbg_empty(RegNo: Reg))
229 return false;
230 }
231 return MI.wouldBeTriviallyDead();
232}
233
234static void reportGISelDiagnostic(DiagnosticSeverity Severity,
235 MachineFunction &MF,
236 MachineOptimizationRemarkEmitter &MORE,
237 MachineOptimizationRemarkMissed &R) {
238 bool IsGlobalISelAbortEnabled =
239 MF.getTarget().Options.GlobalISelAbort == GlobalISelAbortMode::Enable;
240 bool IsFatal = Severity == DS_Error && IsGlobalISelAbortEnabled;
241 // Print the function name explicitly if we don't have a debug location (which
242 // makes the diagnostic less useful) or if we're going to emit a raw error.
243 if (!R.getLocation().isValid() || IsFatal)
244 R << (" (in function: " + MF.getName() + ")").str();
245
246 if (IsFatal)
247 reportFatalUsageError(reason: Twine(R.getMsg()));
248 else
249 MORE.emit(OptDiag&: R);
250}
251
252void llvm::reportGISelWarning(MachineFunction &MF,
253 MachineOptimizationRemarkEmitter &MORE,
254 MachineOptimizationRemarkMissed &R) {
255 reportGISelDiagnostic(Severity: DS_Warning, MF, MORE, R);
256}
257
258void llvm::reportGISelFailure(MachineFunction &MF,
259 MachineOptimizationRemarkEmitter &MORE,
260 MachineOptimizationRemarkMissed &R) {
261 MF.getProperties().setFailedISel();
262 reportGISelDiagnostic(Severity: DS_Error, MF, MORE, R);
263}
264
265void llvm::reportGISelFailure(MachineFunction &MF,
266 MachineOptimizationRemarkEmitter &MORE,
267 const char *PassName, StringRef Msg,
268 const MachineInstr &MI) {
269 MachineOptimizationRemarkMissed R(PassName, "GISelFailure: ",
270 MI.getDebugLoc(), MI.getParent());
271 R << Msg;
272 // Printing MI is expensive; only do it if expensive remarks are enabled.
273 if (MF.getTarget().Options.GlobalISelAbort == GlobalISelAbortMode::Enable ||
274 MORE.allowExtraAnalysis(PassName))
275 R << ": " << ore::MNV("Inst", MI);
276 reportGISelFailure(MF, MORE, R);
277}
278
279unsigned llvm::getInverseGMinMaxOpcode(unsigned MinMaxOpc) {
280 switch (MinMaxOpc) {
281 case TargetOpcode::G_SMIN:
282 return TargetOpcode::G_SMAX;
283 case TargetOpcode::G_SMAX:
284 return TargetOpcode::G_SMIN;
285 case TargetOpcode::G_UMIN:
286 return TargetOpcode::G_UMAX;
287 case TargetOpcode::G_UMAX:
288 return TargetOpcode::G_UMIN;
289 default:
290 llvm_unreachable("unrecognized opcode");
291 }
292}
293
294std::optional<APInt> llvm::getIConstantVRegVal(Register VReg,
295 const MachineRegisterInfo &MRI) {
296 std::optional<ValueAndVReg> ValAndVReg = getIConstantVRegValWithLookThrough(
297 VReg, MRI, /*LookThroughInstrs*/ false);
298 assert((!ValAndVReg || ValAndVReg->VReg == VReg) &&
299 "Value found while looking through instrs");
300 if (!ValAndVReg)
301 return std::nullopt;
302 return ValAndVReg->Value;
303}
304
305const APInt &llvm::getIConstantFromReg(Register Reg,
306 const MachineRegisterInfo &MRI) {
307 MachineInstr *Const = MRI.getVRegDef(Reg);
308 assert((Const && Const->getOpcode() == TargetOpcode::G_CONSTANT) &&
309 "expected a G_CONSTANT on Reg");
310 return Const->getOperand(i: 1).getCImm()->getValue();
311}
312
313std::optional<int64_t>
314llvm::getIConstantVRegSExtVal(Register VReg, const MachineRegisterInfo &MRI) {
315 std::optional<APInt> Val = getIConstantVRegVal(VReg, MRI);
316 if (Val && Val->getBitWidth() <= 64)
317 return Val->getSExtValue();
318 return std::nullopt;
319}
320
321namespace {
322
323// This function is used in many places, and as such, it has some
324// micro-optimizations to try and make it as fast as it can be.
325//
326// - We use template arguments to avoid an indirect call caused by passing a
327// function_ref/std::function
328// - GetAPCstValue does not return std::optional<APInt> as that's expensive.
329// Instead it returns true/false and places the result in a pre-constructed
330// APInt.
331//
332// Please change this function carefully and benchmark your changes.
333template <bool (*IsConstantOpcode)(const MachineInstr *),
334 bool (*GetAPCstValue)(const MachineInstr *MI, APInt &)>
335std::optional<ValueAndVReg>
336getConstantVRegValWithLookThrough(Register VReg, const MachineRegisterInfo &MRI,
337 bool LookThroughInstrs = true,
338 bool LookThroughAnyExt = false) {
339 SmallVector<std::pair<unsigned, unsigned>, 4> SeenOpcodes;
340 MachineInstr *MI;
341
342 while ((MI = MRI.getVRegDef(Reg: VReg)) && !IsConstantOpcode(MI) &&
343 LookThroughInstrs) {
344 switch (MI->getOpcode()) {
345 case TargetOpcode::G_ANYEXT:
346 if (!LookThroughAnyExt)
347 return std::nullopt;
348 [[fallthrough]];
349 case TargetOpcode::G_TRUNC:
350 case TargetOpcode::G_SEXT:
351 case TargetOpcode::G_ZEXT:
352 SeenOpcodes.push_back(Elt: std::make_pair(
353 x: MI->getOpcode(),
354 y: MRI.getType(Reg: MI->getOperand(i: 0).getReg()).getSizeInBits()));
355 VReg = MI->getOperand(i: 1).getReg();
356 break;
357 case TargetOpcode::COPY:
358 VReg = MI->getOperand(i: 1).getReg();
359 if (VReg.isPhysical())
360 return std::nullopt;
361 break;
362 case TargetOpcode::G_INTTOPTR:
363 VReg = MI->getOperand(i: 1).getReg();
364 break;
365 default:
366 return std::nullopt;
367 }
368 }
369 if (!MI || !IsConstantOpcode(MI))
370 return std::nullopt;
371
372 APInt Val;
373 if (!GetAPCstValue(MI, Val))
374 return std::nullopt;
375 for (auto &Pair : reverse(C&: SeenOpcodes)) {
376 switch (Pair.first) {
377 case TargetOpcode::G_TRUNC:
378 Val = Val.trunc(width: Pair.second);
379 break;
380 case TargetOpcode::G_ANYEXT:
381 case TargetOpcode::G_SEXT:
382 Val = Val.sext(width: Pair.second);
383 break;
384 case TargetOpcode::G_ZEXT:
385 Val = Val.zext(width: Pair.second);
386 break;
387 }
388 }
389
390 return ValueAndVReg{.Value: std::move(Val), .VReg: VReg};
391}
392
393bool isIConstant(const MachineInstr *MI) {
394 if (!MI)
395 return false;
396 return MI->getOpcode() == TargetOpcode::G_CONSTANT;
397}
398
399bool isFConstant(const MachineInstr *MI) {
400 if (!MI)
401 return false;
402 return MI->getOpcode() == TargetOpcode::G_FCONSTANT;
403}
404
405bool isAnyConstant(const MachineInstr *MI) {
406 if (!MI)
407 return false;
408 unsigned Opc = MI->getOpcode();
409 return Opc == TargetOpcode::G_CONSTANT || Opc == TargetOpcode::G_FCONSTANT;
410}
411
412bool getCImmAsAPInt(const MachineInstr *MI, APInt &Result) {
413 const MachineOperand &CstVal = MI->getOperand(i: 1);
414 if (!CstVal.isCImm())
415 return false;
416 Result = CstVal.getCImm()->getValue();
417 return true;
418}
419
420bool getCImmOrFPImmAsAPInt(const MachineInstr *MI, APInt &Result) {
421 const MachineOperand &CstVal = MI->getOperand(i: 1);
422 if (CstVal.isCImm())
423 Result = CstVal.getCImm()->getValue();
424 else if (CstVal.isFPImm())
425 Result = CstVal.getFPImm()->getValueAPF().bitcastToAPInt();
426 else
427 return false;
428 return true;
429}
430
431} // end anonymous namespace
432
433std::optional<ValueAndVReg> llvm::getIConstantVRegValWithLookThrough(
434 Register VReg, const MachineRegisterInfo &MRI, bool LookThroughInstrs) {
435 return getConstantVRegValWithLookThrough<isIConstant, getCImmAsAPInt>(
436 VReg, MRI, LookThroughInstrs);
437}
438
439std::optional<ValueAndVReg> llvm::getAnyConstantVRegValWithLookThrough(
440 Register VReg, const MachineRegisterInfo &MRI, bool LookThroughInstrs,
441 bool LookThroughAnyExt) {
442 return getConstantVRegValWithLookThrough<isAnyConstant,
443 getCImmOrFPImmAsAPInt>(
444 VReg, MRI, LookThroughInstrs, LookThroughAnyExt);
445}
446
447std::optional<FPValueAndVReg> llvm::getFConstantVRegValWithLookThrough(
448 Register VReg, const MachineRegisterInfo &MRI, bool LookThroughInstrs) {
449 auto Reg =
450 getConstantVRegValWithLookThrough<isFConstant, getCImmOrFPImmAsAPInt>(
451 VReg, MRI, LookThroughInstrs);
452 if (!Reg)
453 return std::nullopt;
454
455 APFloat FloatVal(getFltSemanticForLLT(Ty: LLT::scalar(SizeInBits: Reg->Value.getBitWidth())),
456 Reg->Value);
457 return FPValueAndVReg{.Value: FloatVal, .VReg: Reg->VReg};
458}
459
460const ConstantFP *
461llvm::getConstantFPVRegVal(Register VReg, const MachineRegisterInfo &MRI) {
462 MachineInstr *MI = MRI.getVRegDef(Reg: VReg);
463 if (TargetOpcode::G_FCONSTANT != MI->getOpcode())
464 return nullptr;
465 return MI->getOperand(i: 1).getFPImm();
466}
467
468std::optional<DefinitionAndSourceRegister>
469llvm::getDefSrcRegIgnoringCopies(Register Reg, const MachineRegisterInfo &MRI) {
470 Register DefSrcReg = Reg;
471 // This assumes that the code is in SSA form, so there should only be one
472 // definition.
473 auto DefIt = MRI.def_begin(RegNo: Reg);
474 if (DefIt == MRI.def_end())
475 return {};
476 MachineOperand &DefOpnd = *DefIt;
477 MachineInstr *DefMI = DefOpnd.getParent();
478 auto DstTy = MRI.getType(Reg: DefOpnd.getReg());
479 if (!DstTy.isValid())
480 return std::nullopt;
481 unsigned Opc = DefMI->getOpcode();
482 while (Opc == TargetOpcode::COPY || isPreISelGenericOptimizationHint(Opcode: Opc)) {
483 Register SrcReg = DefMI->getOperand(i: 1).getReg();
484 auto SrcTy = MRI.getType(Reg: SrcReg);
485 if (!SrcTy.isValid())
486 break;
487 DefMI = MRI.getVRegDef(Reg: SrcReg);
488 DefSrcReg = SrcReg;
489 Opc = DefMI->getOpcode();
490 }
491 return DefinitionAndSourceRegister{.MI: DefMI, .Reg: DefSrcReg};
492}
493
494MachineInstr *llvm::getDefIgnoringCopies(Register Reg,
495 const MachineRegisterInfo &MRI) {
496 std::optional<DefinitionAndSourceRegister> DefSrcReg =
497 getDefSrcRegIgnoringCopies(Reg, MRI);
498 return DefSrcReg ? DefSrcReg->MI : nullptr;
499}
500
501Register llvm::getSrcRegIgnoringCopies(Register Reg,
502 const MachineRegisterInfo &MRI) {
503 std::optional<DefinitionAndSourceRegister> DefSrcReg =
504 getDefSrcRegIgnoringCopies(Reg, MRI);
505 return DefSrcReg ? DefSrcReg->Reg : Register();
506}
507
508void llvm::extractParts(Register Reg, LLT Ty, int NumParts,
509 SmallVectorImpl<Register> &VRegs,
510 MachineIRBuilder &MIRBuilder,
511 MachineRegisterInfo &MRI) {
512 for (int i = 0; i < NumParts; ++i)
513 VRegs.push_back(Elt: MRI.createGenericVirtualRegister(Ty));
514 MIRBuilder.buildUnmerge(Res: VRegs, Op: Reg);
515}
516
517bool llvm::extractParts(Register Reg, LLT RegTy, LLT MainTy, LLT &LeftoverTy,
518 SmallVectorImpl<Register> &VRegs,
519 SmallVectorImpl<Register> &LeftoverRegs,
520 MachineIRBuilder &MIRBuilder,
521 MachineRegisterInfo &MRI) {
522 assert(!LeftoverTy.isValid() && "this is an out argument");
523
524 unsigned RegSize = RegTy.getSizeInBits();
525 unsigned MainSize = MainTy.getSizeInBits();
526 unsigned NumParts = RegSize / MainSize;
527 unsigned LeftoverSize = RegSize - NumParts * MainSize;
528
529 // Use an unmerge when possible.
530 if (LeftoverSize == 0) {
531 for (unsigned I = 0; I < NumParts; ++I)
532 VRegs.push_back(Elt: MRI.createGenericVirtualRegister(Ty: MainTy));
533 MIRBuilder.buildUnmerge(Res: VRegs, Op: Reg);
534 return true;
535 }
536
537 // Try to use unmerge for irregular vector split where possible
538 // For example when splitting a <6 x i32> into <4 x i32> with <2 x i32>
539 // leftover, it becomes:
540 // <2 x i32> %2, <2 x i32>%3, <2 x i32> %4 = G_UNMERGE_VALUE <6 x i32> %1
541 // <4 x i32> %5 = G_CONCAT_VECTOR <2 x i32> %2, <2 x i32> %3
542 if (RegTy.isVector() && MainTy.isVector()) {
543 unsigned RegNumElts = RegTy.getNumElements();
544 unsigned MainNumElts = MainTy.getNumElements();
545 unsigned LeftoverNumElts = RegNumElts % MainNumElts;
546 // If can unmerge to LeftoverTy, do it
547 if (MainNumElts % LeftoverNumElts == 0 &&
548 RegNumElts % LeftoverNumElts == 0 &&
549 RegTy.getScalarSizeInBits() == MainTy.getScalarSizeInBits() &&
550 LeftoverNumElts > 1) {
551 LeftoverTy = LLT::fixed_vector(NumElements: LeftoverNumElts, ScalarTy: RegTy.getElementType());
552
553 // Unmerge the SrcReg to LeftoverTy vectors
554 SmallVector<Register, 4> UnmergeValues;
555 extractParts(Reg, Ty: LeftoverTy, NumParts: RegNumElts / LeftoverNumElts, VRegs&: UnmergeValues,
556 MIRBuilder, MRI);
557
558 // Find how many LeftoverTy makes one MainTy
559 unsigned LeftoverPerMain = MainNumElts / LeftoverNumElts;
560 unsigned NumOfLeftoverVal =
561 ((RegNumElts % MainNumElts) / LeftoverNumElts);
562
563 // Create as many MainTy as possible using unmerged value
564 SmallVector<Register, 4> MergeValues;
565 for (unsigned I = 0; I < UnmergeValues.size() - NumOfLeftoverVal; I++) {
566 MergeValues.push_back(Elt: UnmergeValues[I]);
567 if (MergeValues.size() == LeftoverPerMain) {
568 VRegs.push_back(
569 Elt: MIRBuilder.buildMergeLikeInstr(Res: MainTy, Ops: MergeValues).getReg(Idx: 0));
570 MergeValues.clear();
571 }
572 }
573 // Populate LeftoverRegs with the leftovers
574 for (unsigned I = UnmergeValues.size() - NumOfLeftoverVal;
575 I < UnmergeValues.size(); I++) {
576 LeftoverRegs.push_back(Elt: UnmergeValues[I]);
577 }
578 return true;
579 }
580 }
581 // Perform irregular split. Leftover is last element of RegPieces.
582 if (MainTy.isVector()) {
583 SmallVector<Register, 8> RegPieces;
584 extractVectorParts(Reg, NumElts: MainTy.getNumElements(), VRegs&: RegPieces, MIRBuilder,
585 MRI);
586 for (unsigned i = 0; i < RegPieces.size() - 1; ++i)
587 VRegs.push_back(Elt: RegPieces[i]);
588 LeftoverRegs.push_back(Elt: RegPieces[RegPieces.size() - 1]);
589 LeftoverTy = MRI.getType(Reg: LeftoverRegs[0]);
590 return true;
591 }
592
593 LeftoverTy = LLT::scalar(SizeInBits: LeftoverSize);
594 // For irregular sizes, extract the individual parts.
595 for (unsigned I = 0; I != NumParts; ++I) {
596 Register NewReg = MRI.createGenericVirtualRegister(Ty: MainTy);
597 VRegs.push_back(Elt: NewReg);
598 MIRBuilder.buildExtract(Res: NewReg, Src: Reg, Index: MainSize * I);
599 }
600
601 for (unsigned Offset = MainSize * NumParts; Offset < RegSize;
602 Offset += LeftoverSize) {
603 Register NewReg = MRI.createGenericVirtualRegister(Ty: LeftoverTy);
604 LeftoverRegs.push_back(Elt: NewReg);
605 MIRBuilder.buildExtract(Res: NewReg, Src: Reg, Index: Offset);
606 }
607
608 return true;
609}
610
611void llvm::extractVectorParts(Register Reg, unsigned NumElts,
612 SmallVectorImpl<Register> &VRegs,
613 MachineIRBuilder &MIRBuilder,
614 MachineRegisterInfo &MRI) {
615 LLT RegTy = MRI.getType(Reg);
616 assert(RegTy.isVector() && "Expected a vector type");
617
618 LLT EltTy = RegTy.getElementType();
619 LLT NarrowTy = (NumElts == 1) ? EltTy : LLT::fixed_vector(NumElements: NumElts, ScalarTy: EltTy);
620 unsigned RegNumElts = RegTy.getNumElements();
621 unsigned LeftoverNumElts = RegNumElts % NumElts;
622 unsigned NumNarrowTyPieces = RegNumElts / NumElts;
623
624 // Perfect split without leftover
625 if (LeftoverNumElts == 0)
626 return extractParts(Reg, Ty: NarrowTy, NumParts: NumNarrowTyPieces, VRegs, MIRBuilder,
627 MRI);
628
629 // Irregular split. Provide direct access to all elements for artifact
630 // combiner using unmerge to elements. Then build vectors with NumElts
631 // elements. Remaining element(s) will be (used to build vector) Leftover.
632 SmallVector<Register, 8> Elts;
633 extractParts(Reg, Ty: EltTy, NumParts: RegNumElts, VRegs&: Elts, MIRBuilder, MRI);
634
635 unsigned Offset = 0;
636 // Requested sub-vectors of NarrowTy.
637 for (unsigned i = 0; i < NumNarrowTyPieces; ++i, Offset += NumElts) {
638 ArrayRef<Register> Pieces(&Elts[Offset], NumElts);
639 VRegs.push_back(Elt: MIRBuilder.buildMergeLikeInstr(Res: NarrowTy, Ops: Pieces).getReg(Idx: 0));
640 }
641
642 // Leftover element(s).
643 if (LeftoverNumElts == 1) {
644 VRegs.push_back(Elt: Elts[Offset]);
645 } else {
646 LLT LeftoverTy = LLT::fixed_vector(NumElements: LeftoverNumElts, ScalarTy: EltTy);
647 ArrayRef<Register> Pieces(&Elts[Offset], LeftoverNumElts);
648 VRegs.push_back(
649 Elt: MIRBuilder.buildMergeLikeInstr(Res: LeftoverTy, Ops: Pieces).getReg(Idx: 0));
650 }
651}
652
653MachineInstr *llvm::getOpcodeDef(unsigned Opcode, Register Reg,
654 const MachineRegisterInfo &MRI) {
655 MachineInstr *DefMI = getDefIgnoringCopies(Reg, MRI);
656 return DefMI && DefMI->getOpcode() == Opcode ? DefMI : nullptr;
657}
658
659APFloat llvm::getAPFloatFromSize(double Val, unsigned Size) {
660 if (Size == 32)
661 return APFloat(float(Val));
662 if (Size == 64)
663 return APFloat(Val);
664 if (Size != 16)
665 llvm_unreachable("Unsupported FPConstant size");
666 bool Ignored;
667 APFloat APF(Val);
668 APF.convert(ToSemantics: APFloat::IEEEhalf(), RM: APFloat::rmNearestTiesToEven, losesInfo: &Ignored);
669 return APF;
670}
671
672std::optional<APInt> llvm::ConstantFoldBinOp(unsigned Opcode,
673 const Register Op1,
674 const Register Op2,
675 const MachineRegisterInfo &MRI) {
676 auto MaybeOp2Cst = getAnyConstantVRegValWithLookThrough(VReg: Op2, MRI, LookThroughInstrs: false);
677 if (!MaybeOp2Cst)
678 return std::nullopt;
679
680 auto MaybeOp1Cst = getAnyConstantVRegValWithLookThrough(VReg: Op1, MRI, LookThroughInstrs: false);
681 if (!MaybeOp1Cst)
682 return std::nullopt;
683
684 const APInt &C1 = MaybeOp1Cst->Value;
685 const APInt &C2 = MaybeOp2Cst->Value;
686 switch (Opcode) {
687 default:
688 break;
689 case TargetOpcode::G_ADD:
690 return C1 + C2;
691 case TargetOpcode::G_PTR_ADD:
692 // Types can be of different width here.
693 // Result needs to be the same width as C1, so trunc or sext C2.
694 return C1 + C2.sextOrTrunc(width: C1.getBitWidth());
695 case TargetOpcode::G_AND:
696 return C1 & C2;
697 case TargetOpcode::G_ASHR:
698 return C1.ashr(ShiftAmt: C2);
699 case TargetOpcode::G_LSHR:
700 return C1.lshr(ShiftAmt: C2);
701 case TargetOpcode::G_MUL:
702 return C1 * C2;
703 case TargetOpcode::G_OR:
704 return C1 | C2;
705 case TargetOpcode::G_SHL:
706 return C1 << C2;
707 case TargetOpcode::G_SUB:
708 return C1 - C2;
709 case TargetOpcode::G_XOR:
710 return C1 ^ C2;
711 case TargetOpcode::G_UDIV:
712 if (!C2.getBoolValue())
713 break;
714 return C1.udiv(RHS: C2);
715 case TargetOpcode::G_SDIV:
716 if (!C2.getBoolValue())
717 break;
718 return C1.sdiv(RHS: C2);
719 case TargetOpcode::G_UREM:
720 if (!C2.getBoolValue())
721 break;
722 return C1.urem(RHS: C2);
723 case TargetOpcode::G_SREM:
724 if (!C2.getBoolValue())
725 break;
726 return C1.srem(RHS: C2);
727 case TargetOpcode::G_SMIN:
728 return APIntOps::smin(A: C1, B: C2);
729 case TargetOpcode::G_SMAX:
730 return APIntOps::smax(A: C1, B: C2);
731 case TargetOpcode::G_UMIN:
732 return APIntOps::umin(A: C1, B: C2);
733 case TargetOpcode::G_UMAX:
734 return APIntOps::umax(A: C1, B: C2);
735 }
736
737 return std::nullopt;
738}
739
740std::optional<APFloat>
741llvm::ConstantFoldFPBinOp(unsigned Opcode, const Register Op1,
742 const Register Op2, const MachineRegisterInfo &MRI) {
743 const ConstantFP *Op2Cst = getConstantFPVRegVal(VReg: Op2, MRI);
744 if (!Op2Cst)
745 return std::nullopt;
746
747 const ConstantFP *Op1Cst = getConstantFPVRegVal(VReg: Op1, MRI);
748 if (!Op1Cst)
749 return std::nullopt;
750
751 APFloat C1 = Op1Cst->getValueAPF();
752 const APFloat &C2 = Op2Cst->getValueAPF();
753 switch (Opcode) {
754 case TargetOpcode::G_FADD:
755 C1.add(RHS: C2, RM: APFloat::rmNearestTiesToEven);
756 return C1;
757 case TargetOpcode::G_FSUB:
758 C1.subtract(RHS: C2, RM: APFloat::rmNearestTiesToEven);
759 return C1;
760 case TargetOpcode::G_FMUL:
761 C1.multiply(RHS: C2, RM: APFloat::rmNearestTiesToEven);
762 return C1;
763 case TargetOpcode::G_FDIV:
764 C1.divide(RHS: C2, RM: APFloat::rmNearestTiesToEven);
765 return C1;
766 case TargetOpcode::G_FREM:
767 C1.mod(RHS: C2);
768 return C1;
769 case TargetOpcode::G_FCOPYSIGN:
770 C1.copySign(RHS: C2);
771 return C1;
772 case TargetOpcode::G_FMINNUM:
773 return minnum(A: C1, B: C2);
774 case TargetOpcode::G_FMAXNUM:
775 return maxnum(A: C1, B: C2);
776 case TargetOpcode::G_FMINIMUM:
777 return minimum(A: C1, B: C2);
778 case TargetOpcode::G_FMAXIMUM:
779 return maximum(A: C1, B: C2);
780 case TargetOpcode::G_FMINNUM_IEEE:
781 case TargetOpcode::G_FMAXNUM_IEEE:
782 // FIXME: These operations were unfortunately named. fminnum/fmaxnum do not
783 // follow the IEEE behavior for signaling nans and follow libm's fmin/fmax,
784 // and currently there isn't a nice wrapper in APFloat for the version with
785 // correct snan handling.
786 break;
787 default:
788 break;
789 }
790
791 return std::nullopt;
792}
793
794SmallVector<APInt>
795llvm::ConstantFoldVectorBinop(unsigned Opcode, const Register Op1,
796 const Register Op2,
797 const MachineRegisterInfo &MRI) {
798 auto *SrcVec2 = getOpcodeDef<GBuildVector>(Reg: Op2, MRI);
799 if (!SrcVec2)
800 return SmallVector<APInt>();
801
802 auto *SrcVec1 = getOpcodeDef<GBuildVector>(Reg: Op1, MRI);
803 if (!SrcVec1)
804 return SmallVector<APInt>();
805
806 SmallVector<APInt> FoldedElements;
807 for (unsigned Idx = 0, E = SrcVec1->getNumSources(); Idx < E; ++Idx) {
808 auto MaybeCst = ConstantFoldBinOp(Opcode, Op1: SrcVec1->getSourceReg(I: Idx),
809 Op2: SrcVec2->getSourceReg(I: Idx), MRI);
810 if (!MaybeCst)
811 return SmallVector<APInt>();
812 FoldedElements.push_back(Elt: *MaybeCst);
813 }
814 return FoldedElements;
815}
816
817bool llvm::isKnownNeverNaN(Register Val, const MachineRegisterInfo &MRI,
818 bool SNaN) {
819 const MachineInstr *DefMI = MRI.getVRegDef(Reg: Val);
820 if (!DefMI)
821 return false;
822
823 if (DefMI->getFlag(Flag: MachineInstr::FmNoNans))
824 return true;
825
826 // If the value is a constant, we can obviously see if it is a NaN or not.
827 if (const ConstantFP *FPVal = getConstantFPVRegVal(VReg: Val, MRI)) {
828 return !FPVal->getValueAPF().isNaN() ||
829 (SNaN && !FPVal->getValueAPF().isSignaling());
830 }
831
832 if (DefMI->getOpcode() == TargetOpcode::G_BUILD_VECTOR) {
833 for (const auto &Op : DefMI->uses())
834 if (!isKnownNeverNaN(Val: Op.getReg(), MRI, SNaN))
835 return false;
836 return true;
837 }
838
839 switch (DefMI->getOpcode()) {
840 default:
841 break;
842 case TargetOpcode::G_FADD:
843 case TargetOpcode::G_FSUB:
844 case TargetOpcode::G_FMUL:
845 case TargetOpcode::G_FDIV:
846 case TargetOpcode::G_FREM:
847 case TargetOpcode::G_FSIN:
848 case TargetOpcode::G_FCOS:
849 case TargetOpcode::G_FTAN:
850 case TargetOpcode::G_FACOS:
851 case TargetOpcode::G_FASIN:
852 case TargetOpcode::G_FATAN:
853 case TargetOpcode::G_FATAN2:
854 case TargetOpcode::G_FCOSH:
855 case TargetOpcode::G_FSINH:
856 case TargetOpcode::G_FTANH:
857 case TargetOpcode::G_FMA:
858 case TargetOpcode::G_FMAD:
859 if (SNaN)
860 return true;
861
862 // TODO: Need isKnownNeverInfinity
863 return false;
864 case TargetOpcode::G_FMINNUM_IEEE:
865 case TargetOpcode::G_FMAXNUM_IEEE: {
866 if (SNaN)
867 return true;
868 // This can return a NaN if either operand is an sNaN, or if both operands
869 // are NaN.
870 return (isKnownNeverNaN(Val: DefMI->getOperand(i: 1).getReg(), MRI) &&
871 isKnownNeverSNaN(Val: DefMI->getOperand(i: 2).getReg(), MRI)) ||
872 (isKnownNeverSNaN(Val: DefMI->getOperand(i: 1).getReg(), MRI) &&
873 isKnownNeverNaN(Val: DefMI->getOperand(i: 2).getReg(), MRI));
874 }
875 case TargetOpcode::G_FMINNUM:
876 case TargetOpcode::G_FMAXNUM: {
877 // Only one needs to be known not-nan, since it will be returned if the
878 // other ends up being one.
879 return isKnownNeverNaN(Val: DefMI->getOperand(i: 1).getReg(), MRI, SNaN) ||
880 isKnownNeverNaN(Val: DefMI->getOperand(i: 2).getReg(), MRI, SNaN);
881 }
882 }
883
884 if (SNaN) {
885 // FP operations quiet. For now, just handle the ones inserted during
886 // legalization.
887 switch (DefMI->getOpcode()) {
888 case TargetOpcode::G_FPEXT:
889 case TargetOpcode::G_FPTRUNC:
890 case TargetOpcode::G_FCANONICALIZE:
891 return true;
892 default:
893 return false;
894 }
895 }
896
897 return false;
898}
899
900Align llvm::inferAlignFromPtrInfo(MachineFunction &MF,
901 const MachinePointerInfo &MPO) {
902 auto PSV = dyn_cast_if_present<const PseudoSourceValue *>(Val: MPO.V);
903 if (auto FSPV = dyn_cast_or_null<FixedStackPseudoSourceValue>(Val: PSV)) {
904 MachineFrameInfo &MFI = MF.getFrameInfo();
905 return commonAlignment(A: MFI.getObjectAlign(ObjectIdx: FSPV->getFrameIndex()),
906 Offset: MPO.Offset);
907 }
908
909 if (const Value *V = dyn_cast_if_present<const Value *>(Val: MPO.V)) {
910 const Module *M = MF.getFunction().getParent();
911 return V->getPointerAlignment(DL: M->getDataLayout());
912 }
913
914 return Align(1);
915}
916
917Register llvm::getFunctionLiveInPhysReg(MachineFunction &MF,
918 const TargetInstrInfo &TII,
919 MCRegister PhysReg,
920 const TargetRegisterClass &RC,
921 const DebugLoc &DL, LLT RegTy) {
922 MachineBasicBlock &EntryMBB = MF.front();
923 MachineRegisterInfo &MRI = MF.getRegInfo();
924 Register LiveIn = MRI.getLiveInVirtReg(PReg: PhysReg);
925 if (LiveIn) {
926 MachineInstr *Def = MRI.getVRegDef(Reg: LiveIn);
927 if (Def) {
928 // FIXME: Should the verifier check this is in the entry block?
929 assert(Def->getParent() == &EntryMBB && "live-in copy not in entry block");
930 return LiveIn;
931 }
932
933 // It's possible the incoming argument register and copy was added during
934 // lowering, but later deleted due to being/becoming dead. If this happens,
935 // re-insert the copy.
936 } else {
937 // The live in register was not present, so add it.
938 LiveIn = MF.addLiveIn(PReg: PhysReg, RC: &RC);
939 if (RegTy.isValid())
940 MRI.setType(VReg: LiveIn, Ty: RegTy);
941 }
942
943 BuildMI(BB&: EntryMBB, I: EntryMBB.begin(), MIMD: DL, MCID: TII.get(Opcode: TargetOpcode::COPY), DestReg: LiveIn)
944 .addReg(RegNo: PhysReg);
945 if (!EntryMBB.isLiveIn(Reg: PhysReg))
946 EntryMBB.addLiveIn(PhysReg);
947 return LiveIn;
948}
949
950std::optional<APInt> llvm::ConstantFoldExtOp(unsigned Opcode,
951 const Register Op1, uint64_t Imm,
952 const MachineRegisterInfo &MRI) {
953 auto MaybeOp1Cst = getIConstantVRegVal(VReg: Op1, MRI);
954 if (MaybeOp1Cst) {
955 switch (Opcode) {
956 default:
957 break;
958 case TargetOpcode::G_SEXT_INREG: {
959 LLT Ty = MRI.getType(Reg: Op1);
960 return MaybeOp1Cst->trunc(width: Imm).sext(width: Ty.getScalarSizeInBits());
961 }
962 }
963 }
964 return std::nullopt;
965}
966
967std::optional<APInt> llvm::ConstantFoldCastOp(unsigned Opcode, LLT DstTy,
968 const Register Op0,
969 const MachineRegisterInfo &MRI) {
970 std::optional<APInt> Val = getIConstantVRegVal(VReg: Op0, MRI);
971 if (!Val)
972 return Val;
973
974 const unsigned DstSize = DstTy.getScalarSizeInBits();
975
976 switch (Opcode) {
977 case TargetOpcode::G_SEXT:
978 return Val->sext(width: DstSize);
979 case TargetOpcode::G_ZEXT:
980 case TargetOpcode::G_ANYEXT:
981 // TODO: DAG considers target preference when constant folding any_extend.
982 return Val->zext(width: DstSize);
983 default:
984 break;
985 }
986
987 llvm_unreachable("unexpected cast opcode to constant fold");
988}
989
990std::optional<APFloat>
991llvm::ConstantFoldIntToFloat(unsigned Opcode, LLT DstTy, Register Src,
992 const MachineRegisterInfo &MRI) {
993 assert(Opcode == TargetOpcode::G_SITOFP || Opcode == TargetOpcode::G_UITOFP);
994 if (auto MaybeSrcVal = getIConstantVRegVal(VReg: Src, MRI)) {
995 APFloat DstVal(getFltSemanticForLLT(Ty: DstTy));
996 DstVal.convertFromAPInt(Input: *MaybeSrcVal, IsSigned: Opcode == TargetOpcode::G_SITOFP,
997 RM: APFloat::rmNearestTiesToEven);
998 return DstVal;
999 }
1000 return std::nullopt;
1001}
1002
1003std::optional<SmallVector<unsigned>>
1004llvm::ConstantFoldCountZeros(Register Src, const MachineRegisterInfo &MRI,
1005 std::function<unsigned(APInt)> CB) {
1006 LLT Ty = MRI.getType(Reg: Src);
1007 SmallVector<unsigned> FoldedCTLZs;
1008 auto tryFoldScalar = [&](Register R) -> std::optional<unsigned> {
1009 auto MaybeCst = getIConstantVRegVal(VReg: R, MRI);
1010 if (!MaybeCst)
1011 return std::nullopt;
1012 return CB(*MaybeCst);
1013 };
1014 if (Ty.isVector()) {
1015 // Try to constant fold each element.
1016 auto *BV = getOpcodeDef<GBuildVector>(Reg: Src, MRI);
1017 if (!BV)
1018 return std::nullopt;
1019 for (unsigned SrcIdx = 0; SrcIdx < BV->getNumSources(); ++SrcIdx) {
1020 if (auto MaybeFold = tryFoldScalar(BV->getSourceReg(I: SrcIdx))) {
1021 FoldedCTLZs.emplace_back(Args&: *MaybeFold);
1022 continue;
1023 }
1024 return std::nullopt;
1025 }
1026 return FoldedCTLZs;
1027 }
1028 if (auto MaybeCst = tryFoldScalar(Src)) {
1029 FoldedCTLZs.emplace_back(Args&: *MaybeCst);
1030 return FoldedCTLZs;
1031 }
1032 return std::nullopt;
1033}
1034
1035std::optional<SmallVector<APInt>>
1036llvm::ConstantFoldICmp(unsigned Pred, const Register Op1, const Register Op2,
1037 unsigned DstScalarSizeInBits, unsigned ExtOp,
1038 const MachineRegisterInfo &MRI) {
1039 assert(ExtOp == TargetOpcode::G_SEXT || ExtOp == TargetOpcode::G_ZEXT ||
1040 ExtOp == TargetOpcode::G_ANYEXT);
1041
1042 const LLT Ty = MRI.getType(Reg: Op1);
1043
1044 auto GetICmpResultCst = [&](bool IsTrue) {
1045 if (IsTrue)
1046 return ExtOp == TargetOpcode::G_SEXT
1047 ? APInt::getAllOnes(numBits: DstScalarSizeInBits)
1048 : APInt::getOneBitSet(numBits: DstScalarSizeInBits, BitNo: 0);
1049 return APInt::getZero(numBits: DstScalarSizeInBits);
1050 };
1051
1052 auto TryFoldScalar = [&](Register LHS, Register RHS) -> std::optional<APInt> {
1053 auto RHSCst = getIConstantVRegVal(VReg: RHS, MRI);
1054 if (!RHSCst)
1055 return std::nullopt;
1056 auto LHSCst = getIConstantVRegVal(VReg: LHS, MRI);
1057 if (!LHSCst)
1058 return std::nullopt;
1059
1060 switch (Pred) {
1061 case CmpInst::Predicate::ICMP_EQ:
1062 return GetICmpResultCst(LHSCst->eq(RHS: *RHSCst));
1063 case CmpInst::Predicate::ICMP_NE:
1064 return GetICmpResultCst(LHSCst->ne(RHS: *RHSCst));
1065 case CmpInst::Predicate::ICMP_UGT:
1066 return GetICmpResultCst(LHSCst->ugt(RHS: *RHSCst));
1067 case CmpInst::Predicate::ICMP_UGE:
1068 return GetICmpResultCst(LHSCst->uge(RHS: *RHSCst));
1069 case CmpInst::Predicate::ICMP_ULT:
1070 return GetICmpResultCst(LHSCst->ult(RHS: *RHSCst));
1071 case CmpInst::Predicate::ICMP_ULE:
1072 return GetICmpResultCst(LHSCst->ule(RHS: *RHSCst));
1073 case CmpInst::Predicate::ICMP_SGT:
1074 return GetICmpResultCst(LHSCst->sgt(RHS: *RHSCst));
1075 case CmpInst::Predicate::ICMP_SGE:
1076 return GetICmpResultCst(LHSCst->sge(RHS: *RHSCst));
1077 case CmpInst::Predicate::ICMP_SLT:
1078 return GetICmpResultCst(LHSCst->slt(RHS: *RHSCst));
1079 case CmpInst::Predicate::ICMP_SLE:
1080 return GetICmpResultCst(LHSCst->sle(RHS: *RHSCst));
1081 default:
1082 return std::nullopt;
1083 }
1084 };
1085
1086 SmallVector<APInt> FoldedICmps;
1087
1088 if (Ty.isVector()) {
1089 // Try to constant fold each element.
1090 auto *BV1 = getOpcodeDef<GBuildVector>(Reg: Op1, MRI);
1091 auto *BV2 = getOpcodeDef<GBuildVector>(Reg: Op2, MRI);
1092 if (!BV1 || !BV2)
1093 return std::nullopt;
1094 assert(BV1->getNumSources() == BV2->getNumSources() && "Invalid vectors");
1095 for (unsigned I = 0; I < BV1->getNumSources(); ++I) {
1096 if (auto MaybeFold =
1097 TryFoldScalar(BV1->getSourceReg(I), BV2->getSourceReg(I))) {
1098 FoldedICmps.emplace_back(Args&: *MaybeFold);
1099 continue;
1100 }
1101 return std::nullopt;
1102 }
1103 return FoldedICmps;
1104 }
1105
1106 if (auto MaybeCst = TryFoldScalar(Op1, Op2)) {
1107 FoldedICmps.emplace_back(Args&: *MaybeCst);
1108 return FoldedICmps;
1109 }
1110
1111 return std::nullopt;
1112}
1113
1114bool llvm::isKnownToBeAPowerOfTwo(Register Reg, const MachineRegisterInfo &MRI,
1115 GISelValueTracking *VT) {
1116 std::optional<DefinitionAndSourceRegister> DefSrcReg =
1117 getDefSrcRegIgnoringCopies(Reg, MRI);
1118 if (!DefSrcReg)
1119 return false;
1120
1121 const MachineInstr &MI = *DefSrcReg->MI;
1122 const LLT Ty = MRI.getType(Reg);
1123
1124 switch (MI.getOpcode()) {
1125 case TargetOpcode::G_CONSTANT: {
1126 unsigned BitWidth = Ty.getScalarSizeInBits();
1127 const ConstantInt *CI = MI.getOperand(i: 1).getCImm();
1128 return CI->getValue().zextOrTrunc(width: BitWidth).isPowerOf2();
1129 }
1130 case TargetOpcode::G_SHL: {
1131 // A left-shift of a constant one will have exactly one bit set because
1132 // shifting the bit off the end is undefined.
1133
1134 // TODO: Constant splat
1135 if (auto ConstLHS = getIConstantVRegVal(VReg: MI.getOperand(i: 1).getReg(), MRI)) {
1136 if (*ConstLHS == 1)
1137 return true;
1138 }
1139
1140 break;
1141 }
1142 case TargetOpcode::G_LSHR: {
1143 if (auto ConstLHS = getIConstantVRegVal(VReg: MI.getOperand(i: 1).getReg(), MRI)) {
1144 if (ConstLHS->isSignMask())
1145 return true;
1146 }
1147
1148 break;
1149 }
1150 case TargetOpcode::G_BUILD_VECTOR: {
1151 // TODO: Probably should have a recursion depth guard since you could have
1152 // bitcasted vector elements.
1153 for (const MachineOperand &MO : llvm::drop_begin(RangeOrContainer: MI.operands()))
1154 if (!isKnownToBeAPowerOfTwo(Reg: MO.getReg(), MRI, VT))
1155 return false;
1156
1157 return true;
1158 }
1159 case TargetOpcode::G_BUILD_VECTOR_TRUNC: {
1160 // Only handle constants since we would need to know if number of leading
1161 // zeros is greater than the truncation amount.
1162 const unsigned BitWidth = Ty.getScalarSizeInBits();
1163 for (const MachineOperand &MO : llvm::drop_begin(RangeOrContainer: MI.operands())) {
1164 auto Const = getIConstantVRegVal(VReg: MO.getReg(), MRI);
1165 if (!Const || !Const->zextOrTrunc(width: BitWidth).isPowerOf2())
1166 return false;
1167 }
1168
1169 return true;
1170 }
1171 default:
1172 break;
1173 }
1174
1175 if (!VT)
1176 return false;
1177
1178 // More could be done here, though the above checks are enough
1179 // to handle some common cases.
1180
1181 // Fall back to computeKnownBits to catch other known cases.
1182 KnownBits Known = VT->getKnownBits(R: Reg);
1183 return (Known.countMaxPopulation() == 1) && (Known.countMinPopulation() == 1);
1184}
1185
1186void llvm::getSelectionDAGFallbackAnalysisUsage(AnalysisUsage &AU) {
1187 AU.addPreserved<StackProtector>();
1188}
1189
1190LLT llvm::getLCMType(LLT OrigTy, LLT TargetTy) {
1191 if (OrigTy.getSizeInBits() == TargetTy.getSizeInBits())
1192 return OrigTy;
1193
1194 if (OrigTy.isVector() && TargetTy.isVector()) {
1195 LLT OrigElt = OrigTy.getElementType();
1196 LLT TargetElt = TargetTy.getElementType();
1197
1198 // TODO: The docstring for this function says the intention is to use this
1199 // function to build MERGE/UNMERGE instructions. It won't be the case that
1200 // we generate a MERGE/UNMERGE between fixed and scalable vector types. We
1201 // could implement getLCMType between the two in the future if there was a
1202 // need, but it is not worth it now as this function should not be used in
1203 // that way.
1204 assert(((OrigTy.isScalableVector() && !TargetTy.isFixedVector()) ||
1205 (OrigTy.isFixedVector() && !TargetTy.isScalableVector())) &&
1206 "getLCMType not implemented between fixed and scalable vectors.");
1207
1208 if (OrigElt.getSizeInBits() == TargetElt.getSizeInBits()) {
1209 int GCDMinElts = std::gcd(m: OrigTy.getElementCount().getKnownMinValue(),
1210 n: TargetTy.getElementCount().getKnownMinValue());
1211 // Prefer the original element type.
1212 ElementCount Mul = OrigTy.getElementCount().multiplyCoefficientBy(
1213 RHS: TargetTy.getElementCount().getKnownMinValue());
1214 return LLT::vector(EC: Mul.divideCoefficientBy(RHS: GCDMinElts),
1215 ScalarTy: OrigTy.getElementType());
1216 }
1217 unsigned LCM = std::lcm(m: OrigTy.getSizeInBits().getKnownMinValue(),
1218 n: TargetTy.getSizeInBits().getKnownMinValue());
1219 return LLT::vector(
1220 EC: ElementCount::get(MinVal: LCM / OrigElt.getSizeInBits(), Scalable: OrigTy.isScalable()),
1221 ScalarTy: OrigElt);
1222 }
1223
1224 // One type is scalar, one type is vector
1225 if (OrigTy.isVector() || TargetTy.isVector()) {
1226 LLT VecTy = OrigTy.isVector() ? OrigTy : TargetTy;
1227 LLT ScalarTy = OrigTy.isVector() ? TargetTy : OrigTy;
1228 LLT EltTy = VecTy.getElementType();
1229 LLT OrigEltTy = OrigTy.isVector() ? OrigTy.getElementType() : OrigTy;
1230
1231 // Prefer scalar type from OrigTy.
1232 if (EltTy.getSizeInBits() == ScalarTy.getSizeInBits())
1233 return LLT::vector(EC: VecTy.getElementCount(), ScalarTy: OrigEltTy);
1234
1235 // Different size scalars. Create vector with the same total size.
1236 // LCM will take fixed/scalable from VecTy.
1237 unsigned LCM = std::lcm(m: EltTy.getSizeInBits().getFixedValue() *
1238 VecTy.getElementCount().getKnownMinValue(),
1239 n: ScalarTy.getSizeInBits().getFixedValue());
1240 // Prefer type from OrigTy
1241 return LLT::vector(EC: ElementCount::get(MinVal: LCM / OrigEltTy.getSizeInBits(),
1242 Scalable: VecTy.getElementCount().isScalable()),
1243 ScalarTy: OrigEltTy);
1244 }
1245
1246 // At this point, both types are scalars of different size
1247 unsigned LCM = std::lcm(m: OrigTy.getSizeInBits().getFixedValue(),
1248 n: TargetTy.getSizeInBits().getFixedValue());
1249 // Preserve pointer types.
1250 if (LCM == OrigTy.getSizeInBits())
1251 return OrigTy;
1252 if (LCM == TargetTy.getSizeInBits())
1253 return TargetTy;
1254 return LLT::scalar(SizeInBits: LCM);
1255}
1256
1257LLT llvm::getCoverTy(LLT OrigTy, LLT TargetTy) {
1258
1259 if ((OrigTy.isScalableVector() && TargetTy.isFixedVector()) ||
1260 (OrigTy.isFixedVector() && TargetTy.isScalableVector()))
1261 llvm_unreachable(
1262 "getCoverTy not implemented between fixed and scalable vectors.");
1263
1264 if (!OrigTy.isVector() || !TargetTy.isVector() || OrigTy == TargetTy ||
1265 (OrigTy.getScalarSizeInBits() != TargetTy.getScalarSizeInBits()))
1266 return getLCMType(OrigTy, TargetTy);
1267
1268 unsigned OrigTyNumElts = OrigTy.getElementCount().getKnownMinValue();
1269 unsigned TargetTyNumElts = TargetTy.getElementCount().getKnownMinValue();
1270 if (OrigTyNumElts % TargetTyNumElts == 0)
1271 return OrigTy;
1272
1273 unsigned NumElts = alignTo(Value: OrigTyNumElts, Align: TargetTyNumElts);
1274 return LLT::scalarOrVector(EC: ElementCount::getFixed(MinVal: NumElts),
1275 ScalarTy: OrigTy.getElementType());
1276}
1277
1278LLT llvm::getGCDType(LLT OrigTy, LLT TargetTy) {
1279 if (OrigTy.getSizeInBits() == TargetTy.getSizeInBits())
1280 return OrigTy;
1281
1282 if (OrigTy.isVector() && TargetTy.isVector()) {
1283 LLT OrigElt = OrigTy.getElementType();
1284
1285 // TODO: The docstring for this function says the intention is to use this
1286 // function to build MERGE/UNMERGE instructions. It won't be the case that
1287 // we generate a MERGE/UNMERGE between fixed and scalable vector types. We
1288 // could implement getGCDType between the two in the future if there was a
1289 // need, but it is not worth it now as this function should not be used in
1290 // that way.
1291 assert(((OrigTy.isScalableVector() && !TargetTy.isFixedVector()) ||
1292 (OrigTy.isFixedVector() && !TargetTy.isScalableVector())) &&
1293 "getGCDType not implemented between fixed and scalable vectors.");
1294
1295 unsigned GCD = std::gcd(m: OrigTy.getSizeInBits().getKnownMinValue(),
1296 n: TargetTy.getSizeInBits().getKnownMinValue());
1297 if (GCD == OrigElt.getSizeInBits())
1298 return LLT::scalarOrVector(EC: ElementCount::get(MinVal: 1, Scalable: OrigTy.isScalable()),
1299 ScalarTy: OrigElt);
1300
1301 // Cannot produce original element type, but both have vscale in common.
1302 if (GCD < OrigElt.getSizeInBits())
1303 return LLT::scalarOrVector(EC: ElementCount::get(MinVal: 1, Scalable: OrigTy.isScalable()),
1304 ScalarSize: GCD);
1305
1306 return LLT::vector(
1307 EC: ElementCount::get(MinVal: GCD / OrigElt.getSizeInBits().getFixedValue(),
1308 Scalable: OrigTy.isScalable()),
1309 ScalarTy: OrigElt);
1310 }
1311
1312 // If one type is vector and the element size matches the scalar size, then
1313 // the gcd is the scalar type.
1314 if (OrigTy.isVector() &&
1315 OrigTy.getElementType().getSizeInBits() == TargetTy.getSizeInBits())
1316 return OrigTy.getElementType();
1317 if (TargetTy.isVector() &&
1318 TargetTy.getElementType().getSizeInBits() == OrigTy.getSizeInBits())
1319 return OrigTy;
1320
1321 // At this point, both types are either scalars of different type or one is a
1322 // vector and one is a scalar. If both types are scalars, the GCD type is the
1323 // GCD between the two scalar sizes. If one is vector and one is scalar, then
1324 // the GCD type is the GCD between the scalar and the vector element size.
1325 LLT OrigScalar = OrigTy.getScalarType();
1326 LLT TargetScalar = TargetTy.getScalarType();
1327 unsigned GCD = std::gcd(m: OrigScalar.getSizeInBits().getFixedValue(),
1328 n: TargetScalar.getSizeInBits().getFixedValue());
1329 return LLT::scalar(SizeInBits: GCD);
1330}
1331
1332std::optional<int> llvm::getSplatIndex(MachineInstr &MI) {
1333 assert(MI.getOpcode() == TargetOpcode::G_SHUFFLE_VECTOR &&
1334 "Only G_SHUFFLE_VECTOR can have a splat index!");
1335 ArrayRef<int> Mask = MI.getOperand(i: 3).getShuffleMask();
1336 auto FirstDefinedIdx = find_if(Range&: Mask, P: [](int Elt) { return Elt >= 0; });
1337
1338 // If all elements are undefined, this shuffle can be considered a splat.
1339 // Return 0 for better potential for callers to simplify.
1340 if (FirstDefinedIdx == Mask.end())
1341 return 0;
1342
1343 // Make sure all remaining elements are either undef or the same
1344 // as the first non-undef value.
1345 int SplatValue = *FirstDefinedIdx;
1346 if (any_of(Range: make_range(x: std::next(x: FirstDefinedIdx), y: Mask.end()),
1347 P: [&SplatValue](int Elt) { return Elt >= 0 && Elt != SplatValue; }))
1348 return std::nullopt;
1349
1350 return SplatValue;
1351}
1352
1353static bool isBuildVectorOp(unsigned Opcode) {
1354 return Opcode == TargetOpcode::G_BUILD_VECTOR ||
1355 Opcode == TargetOpcode::G_BUILD_VECTOR_TRUNC;
1356}
1357
1358namespace {
1359
1360std::optional<ValueAndVReg> getAnyConstantSplat(Register VReg,
1361 const MachineRegisterInfo &MRI,
1362 bool AllowUndef) {
1363 MachineInstr *MI = getDefIgnoringCopies(Reg: VReg, MRI);
1364 if (!MI)
1365 return std::nullopt;
1366
1367 bool isConcatVectorsOp = MI->getOpcode() == TargetOpcode::G_CONCAT_VECTORS;
1368 if (!isBuildVectorOp(Opcode: MI->getOpcode()) && !isConcatVectorsOp)
1369 return std::nullopt;
1370
1371 std::optional<ValueAndVReg> SplatValAndReg;
1372 for (MachineOperand &Op : MI->uses()) {
1373 Register Element = Op.getReg();
1374 // If we have a G_CONCAT_VECTOR, we recursively look into the
1375 // vectors that we're concatenating to see if they're splats.
1376 auto ElementValAndReg =
1377 isConcatVectorsOp
1378 ? getAnyConstantSplat(VReg: Element, MRI, AllowUndef)
1379 : getAnyConstantVRegValWithLookThrough(VReg: Element, MRI, LookThroughInstrs: true, LookThroughAnyExt: true);
1380
1381 // If AllowUndef, treat undef as value that will result in a constant splat.
1382 if (!ElementValAndReg) {
1383 if (AllowUndef && isa<GImplicitDef>(Val: MRI.getVRegDef(Reg: Element)))
1384 continue;
1385 return std::nullopt;
1386 }
1387
1388 // Record splat value
1389 if (!SplatValAndReg)
1390 SplatValAndReg = ElementValAndReg;
1391
1392 // Different constant than the one already recorded, not a constant splat.
1393 if (SplatValAndReg->Value != ElementValAndReg->Value)
1394 return std::nullopt;
1395 }
1396
1397 return SplatValAndReg;
1398}
1399
1400} // end anonymous namespace
1401
1402bool llvm::isBuildVectorConstantSplat(const Register Reg,
1403 const MachineRegisterInfo &MRI,
1404 int64_t SplatValue, bool AllowUndef) {
1405 if (auto SplatValAndReg = getAnyConstantSplat(VReg: Reg, MRI, AllowUndef))
1406 return SplatValAndReg->Value.getSExtValue() == SplatValue;
1407
1408 return false;
1409}
1410
1411bool llvm::isBuildVectorConstantSplat(const Register Reg,
1412 const MachineRegisterInfo &MRI,
1413 const APInt &SplatValue,
1414 bool AllowUndef) {
1415 if (auto SplatValAndReg = getAnyConstantSplat(VReg: Reg, MRI, AllowUndef)) {
1416 if (SplatValAndReg->Value.getBitWidth() < SplatValue.getBitWidth())
1417 return APInt::isSameValue(
1418 I1: SplatValAndReg->Value.sext(width: SplatValue.getBitWidth()), I2: SplatValue);
1419 return APInt::isSameValue(
1420 I1: SplatValAndReg->Value,
1421 I2: SplatValue.sext(width: SplatValAndReg->Value.getBitWidth()));
1422 }
1423
1424 return false;
1425}
1426
1427bool llvm::isBuildVectorConstantSplat(const MachineInstr &MI,
1428 const MachineRegisterInfo &MRI,
1429 int64_t SplatValue, bool AllowUndef) {
1430 return isBuildVectorConstantSplat(Reg: MI.getOperand(i: 0).getReg(), MRI, SplatValue,
1431 AllowUndef);
1432}
1433
1434bool llvm::isBuildVectorConstantSplat(const MachineInstr &MI,
1435 const MachineRegisterInfo &MRI,
1436 const APInt &SplatValue,
1437 bool AllowUndef) {
1438 return isBuildVectorConstantSplat(Reg: MI.getOperand(i: 0).getReg(), MRI, SplatValue,
1439 AllowUndef);
1440}
1441
1442std::optional<APInt>
1443llvm::getIConstantSplatVal(const Register Reg, const MachineRegisterInfo &MRI) {
1444 if (auto SplatValAndReg =
1445 getAnyConstantSplat(VReg: Reg, MRI, /* AllowUndef */ false)) {
1446 if (std::optional<ValueAndVReg> ValAndVReg =
1447 getIConstantVRegValWithLookThrough(VReg: SplatValAndReg->VReg, MRI))
1448 return ValAndVReg->Value;
1449 }
1450
1451 return std::nullopt;
1452}
1453
1454std::optional<APInt>
1455llvm::getIConstantSplatVal(const MachineInstr &MI,
1456 const MachineRegisterInfo &MRI) {
1457 return getIConstantSplatVal(Reg: MI.getOperand(i: 0).getReg(), MRI);
1458}
1459
1460std::optional<int64_t>
1461llvm::getIConstantSplatSExtVal(const Register Reg,
1462 const MachineRegisterInfo &MRI) {
1463 if (auto SplatValAndReg =
1464 getAnyConstantSplat(VReg: Reg, MRI, /* AllowUndef */ false))
1465 return getIConstantVRegSExtVal(VReg: SplatValAndReg->VReg, MRI);
1466 return std::nullopt;
1467}
1468
1469std::optional<int64_t>
1470llvm::getIConstantSplatSExtVal(const MachineInstr &MI,
1471 const MachineRegisterInfo &MRI) {
1472 return getIConstantSplatSExtVal(Reg: MI.getOperand(i: 0).getReg(), MRI);
1473}
1474
1475std::optional<FPValueAndVReg>
1476llvm::getFConstantSplat(Register VReg, const MachineRegisterInfo &MRI,
1477 bool AllowUndef) {
1478 if (auto SplatValAndReg = getAnyConstantSplat(VReg, MRI, AllowUndef))
1479 return getFConstantVRegValWithLookThrough(VReg: SplatValAndReg->VReg, MRI);
1480 return std::nullopt;
1481}
1482
1483bool llvm::isBuildVectorAllZeros(const MachineInstr &MI,
1484 const MachineRegisterInfo &MRI,
1485 bool AllowUndef) {
1486 return isBuildVectorConstantSplat(MI, MRI, SplatValue: 0, AllowUndef);
1487}
1488
1489bool llvm::isBuildVectorAllOnes(const MachineInstr &MI,
1490 const MachineRegisterInfo &MRI,
1491 bool AllowUndef) {
1492 return isBuildVectorConstantSplat(MI, MRI, SplatValue: -1, AllowUndef);
1493}
1494
1495std::optional<RegOrConstant>
1496llvm::getVectorSplat(const MachineInstr &MI, const MachineRegisterInfo &MRI) {
1497 unsigned Opc = MI.getOpcode();
1498 if (!isBuildVectorOp(Opcode: Opc))
1499 return std::nullopt;
1500 if (auto Splat = getIConstantSplatSExtVal(MI, MRI))
1501 return RegOrConstant(*Splat);
1502 auto Reg = MI.getOperand(i: 1).getReg();
1503 if (any_of(Range: drop_begin(RangeOrContainer: MI.operands(), N: 2),
1504 P: [&Reg](const MachineOperand &Op) { return Op.getReg() != Reg; }))
1505 return std::nullopt;
1506 return RegOrConstant(Reg);
1507}
1508
1509static bool isConstantScalar(const MachineInstr &MI,
1510 const MachineRegisterInfo &MRI,
1511 bool AllowFP = true,
1512 bool AllowOpaqueConstants = true) {
1513 switch (MI.getOpcode()) {
1514 case TargetOpcode::G_CONSTANT:
1515 case TargetOpcode::G_IMPLICIT_DEF:
1516 return true;
1517 case TargetOpcode::G_FCONSTANT:
1518 return AllowFP;
1519 case TargetOpcode::G_GLOBAL_VALUE:
1520 case TargetOpcode::G_FRAME_INDEX:
1521 case TargetOpcode::G_BLOCK_ADDR:
1522 case TargetOpcode::G_JUMP_TABLE:
1523 return AllowOpaqueConstants;
1524 default:
1525 return false;
1526 }
1527}
1528
1529bool llvm::isConstantOrConstantVector(MachineInstr &MI,
1530 const MachineRegisterInfo &MRI) {
1531 Register Def = MI.getOperand(i: 0).getReg();
1532 if (auto C = getIConstantVRegValWithLookThrough(VReg: Def, MRI))
1533 return true;
1534 GBuildVector *BV = dyn_cast<GBuildVector>(Val: &MI);
1535 if (!BV)
1536 return false;
1537 for (unsigned SrcIdx = 0; SrcIdx < BV->getNumSources(); ++SrcIdx) {
1538 if (getIConstantVRegValWithLookThrough(VReg: BV->getSourceReg(I: SrcIdx), MRI) ||
1539 getOpcodeDef<GImplicitDef>(Reg: BV->getSourceReg(I: SrcIdx), MRI))
1540 continue;
1541 return false;
1542 }
1543 return true;
1544}
1545
1546bool llvm::isConstantOrConstantVector(const MachineInstr &MI,
1547 const MachineRegisterInfo &MRI,
1548 bool AllowFP, bool AllowOpaqueConstants) {
1549 if (isConstantScalar(MI, MRI, AllowFP, AllowOpaqueConstants))
1550 return true;
1551
1552 if (!isBuildVectorOp(Opcode: MI.getOpcode()))
1553 return false;
1554
1555 const unsigned NumOps = MI.getNumOperands();
1556 for (unsigned I = 1; I != NumOps; ++I) {
1557 const MachineInstr *ElementDef = MRI.getVRegDef(Reg: MI.getOperand(i: I).getReg());
1558 if (!isConstantScalar(MI: *ElementDef, MRI, AllowFP, AllowOpaqueConstants))
1559 return false;
1560 }
1561
1562 return true;
1563}
1564
1565std::optional<APInt>
1566llvm::isConstantOrConstantSplatVector(MachineInstr &MI,
1567 const MachineRegisterInfo &MRI) {
1568 Register Def = MI.getOperand(i: 0).getReg();
1569 if (auto C = getIConstantVRegValWithLookThrough(VReg: Def, MRI))
1570 return C->Value;
1571 auto MaybeCst = getIConstantSplatSExtVal(MI, MRI);
1572 if (!MaybeCst)
1573 return std::nullopt;
1574 const unsigned ScalarSize = MRI.getType(Reg: Def).getScalarSizeInBits();
1575 return APInt(ScalarSize, *MaybeCst, true);
1576}
1577
1578std::optional<APFloat>
1579llvm::isConstantOrConstantSplatVectorFP(MachineInstr &MI,
1580 const MachineRegisterInfo &MRI) {
1581 Register Def = MI.getOperand(i: 0).getReg();
1582 if (auto FpConst = getFConstantVRegValWithLookThrough(VReg: Def, MRI))
1583 return FpConst->Value;
1584 auto MaybeCstFP = getFConstantSplat(VReg: Def, MRI, /*allowUndef=*/AllowUndef: false);
1585 if (!MaybeCstFP)
1586 return std::nullopt;
1587 return MaybeCstFP->Value;
1588}
1589
1590bool llvm::isNullOrNullSplat(const MachineInstr &MI,
1591 const MachineRegisterInfo &MRI, bool AllowUndefs) {
1592 switch (MI.getOpcode()) {
1593 case TargetOpcode::G_IMPLICIT_DEF:
1594 return AllowUndefs;
1595 case TargetOpcode::G_CONSTANT:
1596 return MI.getOperand(i: 1).getCImm()->isNullValue();
1597 case TargetOpcode::G_FCONSTANT: {
1598 const ConstantFP *FPImm = MI.getOperand(i: 1).getFPImm();
1599 return FPImm->isZero() && !FPImm->isNegative();
1600 }
1601 default:
1602 if (!AllowUndefs) // TODO: isBuildVectorAllZeros assumes undef is OK already
1603 return false;
1604 return isBuildVectorAllZeros(MI, MRI);
1605 }
1606}
1607
1608bool llvm::isAllOnesOrAllOnesSplat(const MachineInstr &MI,
1609 const MachineRegisterInfo &MRI,
1610 bool AllowUndefs) {
1611 switch (MI.getOpcode()) {
1612 case TargetOpcode::G_IMPLICIT_DEF:
1613 return AllowUndefs;
1614 case TargetOpcode::G_CONSTANT:
1615 return MI.getOperand(i: 1).getCImm()->isAllOnesValue();
1616 default:
1617 if (!AllowUndefs) // TODO: isBuildVectorAllOnes assumes undef is OK already
1618 return false;
1619 return isBuildVectorAllOnes(MI, MRI);
1620 }
1621}
1622
1623bool llvm::matchUnaryPredicate(
1624 const MachineRegisterInfo &MRI, Register Reg,
1625 std::function<bool(const Constant *ConstVal)> Match, bool AllowUndefs) {
1626
1627 const MachineInstr *Def = getDefIgnoringCopies(Reg, MRI);
1628 if (AllowUndefs && Def->getOpcode() == TargetOpcode::G_IMPLICIT_DEF)
1629 return Match(nullptr);
1630
1631 // TODO: Also handle fconstant
1632 if (Def->getOpcode() == TargetOpcode::G_CONSTANT)
1633 return Match(Def->getOperand(i: 1).getCImm());
1634
1635 if (Def->getOpcode() != TargetOpcode::G_BUILD_VECTOR)
1636 return false;
1637
1638 for (unsigned I = 1, E = Def->getNumOperands(); I != E; ++I) {
1639 Register SrcElt = Def->getOperand(i: I).getReg();
1640 const MachineInstr *SrcDef = getDefIgnoringCopies(Reg: SrcElt, MRI);
1641 if (AllowUndefs && SrcDef->getOpcode() == TargetOpcode::G_IMPLICIT_DEF) {
1642 if (!Match(nullptr))
1643 return false;
1644 continue;
1645 }
1646
1647 if (SrcDef->getOpcode() != TargetOpcode::G_CONSTANT ||
1648 !Match(SrcDef->getOperand(i: 1).getCImm()))
1649 return false;
1650 }
1651
1652 return true;
1653}
1654
1655bool llvm::isConstTrueVal(const TargetLowering &TLI, int64_t Val, bool IsVector,
1656 bool IsFP) {
1657 switch (TLI.getBooleanContents(isVec: IsVector, isFloat: IsFP)) {
1658 case TargetLowering::UndefinedBooleanContent:
1659 return Val & 0x1;
1660 case TargetLowering::ZeroOrOneBooleanContent:
1661 return Val == 1;
1662 case TargetLowering::ZeroOrNegativeOneBooleanContent:
1663 return Val == -1;
1664 }
1665 llvm_unreachable("Invalid boolean contents");
1666}
1667
1668bool llvm::isConstFalseVal(const TargetLowering &TLI, int64_t Val,
1669 bool IsVector, bool IsFP) {
1670 switch (TLI.getBooleanContents(isVec: IsVector, isFloat: IsFP)) {
1671 case TargetLowering::UndefinedBooleanContent:
1672 return ~Val & 0x1;
1673 case TargetLowering::ZeroOrOneBooleanContent:
1674 case TargetLowering::ZeroOrNegativeOneBooleanContent:
1675 return Val == 0;
1676 }
1677 llvm_unreachable("Invalid boolean contents");
1678}
1679
1680int64_t llvm::getICmpTrueVal(const TargetLowering &TLI, bool IsVector,
1681 bool IsFP) {
1682 switch (TLI.getBooleanContents(isVec: IsVector, isFloat: IsFP)) {
1683 case TargetLowering::UndefinedBooleanContent:
1684 case TargetLowering::ZeroOrOneBooleanContent:
1685 return 1;
1686 case TargetLowering::ZeroOrNegativeOneBooleanContent:
1687 return -1;
1688 }
1689 llvm_unreachable("Invalid boolean contents");
1690}
1691
1692void llvm::saveUsesAndErase(MachineInstr &MI, MachineRegisterInfo &MRI,
1693 LostDebugLocObserver *LocObserver,
1694 SmallInstListTy &DeadInstChain) {
1695 for (MachineOperand &Op : MI.uses()) {
1696 if (Op.isReg() && Op.getReg().isVirtual())
1697 DeadInstChain.insert(I: MRI.getVRegDef(Reg: Op.getReg()));
1698 }
1699 LLVM_DEBUG(dbgs() << MI << "Is dead; erasing.\n");
1700 DeadInstChain.remove(I: &MI);
1701 MI.eraseFromParent();
1702 if (LocObserver)
1703 LocObserver->checkpoint(CheckDebugLocs: false);
1704}
1705
1706void llvm::eraseInstrs(ArrayRef<MachineInstr *> DeadInstrs,
1707 MachineRegisterInfo &MRI,
1708 LostDebugLocObserver *LocObserver) {
1709 SmallInstListTy DeadInstChain;
1710 for (MachineInstr *MI : DeadInstrs)
1711 saveUsesAndErase(MI&: *MI, MRI, LocObserver, DeadInstChain);
1712
1713 while (!DeadInstChain.empty()) {
1714 MachineInstr *Inst = DeadInstChain.pop_back_val();
1715 if (!isTriviallyDead(MI: *Inst, MRI))
1716 continue;
1717 saveUsesAndErase(MI&: *Inst, MRI, LocObserver, DeadInstChain);
1718 }
1719}
1720
1721void llvm::eraseInstr(MachineInstr &MI, MachineRegisterInfo &MRI,
1722 LostDebugLocObserver *LocObserver) {
1723 return eraseInstrs(DeadInstrs: {&MI}, MRI, LocObserver);
1724}
1725
1726void llvm::salvageDebugInfo(const MachineRegisterInfo &MRI, MachineInstr &MI) {
1727 for (auto &Def : MI.defs()) {
1728 assert(Def.isReg() && "Must be a reg");
1729
1730 SmallVector<MachineOperand *, 16> DbgUsers;
1731 for (auto &MOUse : MRI.use_operands(Reg: Def.getReg())) {
1732 MachineInstr *DbgValue = MOUse.getParent();
1733 // Ignore partially formed DBG_VALUEs.
1734 if (DbgValue->isNonListDebugValue() && DbgValue->getNumOperands() == 4) {
1735 DbgUsers.push_back(Elt: &MOUse);
1736 }
1737 }
1738
1739 if (!DbgUsers.empty()) {
1740 salvageDebugInfoForDbgValue(MRI, MI, DbgUsers);
1741 }
1742 }
1743}
1744
1745bool llvm::isPreISelGenericFloatingPointOpcode(unsigned Opc) {
1746 switch (Opc) {
1747 case TargetOpcode::G_FABS:
1748 case TargetOpcode::G_FADD:
1749 case TargetOpcode::G_FCANONICALIZE:
1750 case TargetOpcode::G_FCEIL:
1751 case TargetOpcode::G_FCONSTANT:
1752 case TargetOpcode::G_FCOPYSIGN:
1753 case TargetOpcode::G_FCOS:
1754 case TargetOpcode::G_FDIV:
1755 case TargetOpcode::G_FEXP2:
1756 case TargetOpcode::G_FEXP:
1757 case TargetOpcode::G_FFLOOR:
1758 case TargetOpcode::G_FLOG10:
1759 case TargetOpcode::G_FLOG2:
1760 case TargetOpcode::G_FLOG:
1761 case TargetOpcode::G_FMA:
1762 case TargetOpcode::G_FMAD:
1763 case TargetOpcode::G_FMAXIMUM:
1764 case TargetOpcode::G_FMAXIMUMNUM:
1765 case TargetOpcode::G_FMAXNUM:
1766 case TargetOpcode::G_FMAXNUM_IEEE:
1767 case TargetOpcode::G_FMINIMUM:
1768 case TargetOpcode::G_FMINIMUMNUM:
1769 case TargetOpcode::G_FMINNUM:
1770 case TargetOpcode::G_FMINNUM_IEEE:
1771 case TargetOpcode::G_FMUL:
1772 case TargetOpcode::G_FNEARBYINT:
1773 case TargetOpcode::G_FNEG:
1774 case TargetOpcode::G_FPEXT:
1775 case TargetOpcode::G_FPOW:
1776 case TargetOpcode::G_FPTRUNC:
1777 case TargetOpcode::G_FREM:
1778 case TargetOpcode::G_FRINT:
1779 case TargetOpcode::G_FSIN:
1780 case TargetOpcode::G_FTAN:
1781 case TargetOpcode::G_FACOS:
1782 case TargetOpcode::G_FASIN:
1783 case TargetOpcode::G_FATAN:
1784 case TargetOpcode::G_FATAN2:
1785 case TargetOpcode::G_FCOSH:
1786 case TargetOpcode::G_FSINH:
1787 case TargetOpcode::G_FTANH:
1788 case TargetOpcode::G_FSQRT:
1789 case TargetOpcode::G_FSUB:
1790 case TargetOpcode::G_INTRINSIC_ROUND:
1791 case TargetOpcode::G_INTRINSIC_ROUNDEVEN:
1792 case TargetOpcode::G_INTRINSIC_TRUNC:
1793 return true;
1794 default:
1795 return false;
1796 }
1797}
1798
1799/// Shifts return poison if shiftwidth is larger than the bitwidth.
1800static bool shiftAmountKnownInRange(Register ShiftAmount,
1801 const MachineRegisterInfo &MRI) {
1802 LLT Ty = MRI.getType(Reg: ShiftAmount);
1803
1804 if (Ty.isScalableVector())
1805 return false; // Can't tell, just return false to be safe
1806
1807 if (Ty.isScalar()) {
1808 std::optional<ValueAndVReg> Val =
1809 getIConstantVRegValWithLookThrough(VReg: ShiftAmount, MRI);
1810 if (!Val)
1811 return false;
1812 return Val->Value.ult(RHS: Ty.getScalarSizeInBits());
1813 }
1814
1815 GBuildVector *BV = getOpcodeDef<GBuildVector>(Reg: ShiftAmount, MRI);
1816 if (!BV)
1817 return false;
1818
1819 unsigned Sources = BV->getNumSources();
1820 for (unsigned I = 0; I < Sources; ++I) {
1821 std::optional<ValueAndVReg> Val =
1822 getIConstantVRegValWithLookThrough(VReg: BV->getSourceReg(I), MRI);
1823 if (!Val)
1824 return false;
1825 if (!Val->Value.ult(RHS: Ty.getScalarSizeInBits()))
1826 return false;
1827 }
1828
1829 return true;
1830}
1831
1832namespace {
1833enum class UndefPoisonKind {
1834 PoisonOnly = (1 << 0),
1835 UndefOnly = (1 << 1),
1836 UndefOrPoison = PoisonOnly | UndefOnly,
1837};
1838}
1839
1840static bool includesPoison(UndefPoisonKind Kind) {
1841 return (unsigned(Kind) & unsigned(UndefPoisonKind::PoisonOnly)) != 0;
1842}
1843
1844static bool includesUndef(UndefPoisonKind Kind) {
1845 return (unsigned(Kind) & unsigned(UndefPoisonKind::UndefOnly)) != 0;
1846}
1847
1848static bool canCreateUndefOrPoison(Register Reg, const MachineRegisterInfo &MRI,
1849 bool ConsiderFlagsAndMetadata,
1850 UndefPoisonKind Kind) {
1851 MachineInstr *RegDef = MRI.getVRegDef(Reg);
1852
1853 if (ConsiderFlagsAndMetadata && includesPoison(Kind))
1854 if (auto *GMI = dyn_cast<GenericMachineInstr>(Val: RegDef))
1855 if (GMI->hasPoisonGeneratingFlags())
1856 return true;
1857
1858 // Check whether opcode is a poison/undef-generating operation.
1859 switch (RegDef->getOpcode()) {
1860 case TargetOpcode::G_BUILD_VECTOR:
1861 case TargetOpcode::G_CONSTANT_FOLD_BARRIER:
1862 return false;
1863 case TargetOpcode::G_SHL:
1864 case TargetOpcode::G_ASHR:
1865 case TargetOpcode::G_LSHR:
1866 return includesPoison(Kind) &&
1867 !shiftAmountKnownInRange(ShiftAmount: RegDef->getOperand(i: 2).getReg(), MRI);
1868 case TargetOpcode::G_FPTOSI:
1869 case TargetOpcode::G_FPTOUI:
1870 // fptosi/ui yields poison if the resulting value does not fit in the
1871 // destination type.
1872 return true;
1873 case TargetOpcode::G_CTLZ:
1874 case TargetOpcode::G_CTTZ:
1875 case TargetOpcode::G_CTLS:
1876 case TargetOpcode::G_ABS:
1877 case TargetOpcode::G_CTPOP:
1878 case TargetOpcode::G_BSWAP:
1879 case TargetOpcode::G_BITREVERSE:
1880 case TargetOpcode::G_FSHL:
1881 case TargetOpcode::G_FSHR:
1882 case TargetOpcode::G_SMAX:
1883 case TargetOpcode::G_SMIN:
1884 case TargetOpcode::G_SCMP:
1885 case TargetOpcode::G_UMAX:
1886 case TargetOpcode::G_UMIN:
1887 case TargetOpcode::G_UCMP:
1888 case TargetOpcode::G_PTRMASK:
1889 case TargetOpcode::G_SADDO:
1890 case TargetOpcode::G_SSUBO:
1891 case TargetOpcode::G_UADDO:
1892 case TargetOpcode::G_USUBO:
1893 case TargetOpcode::G_SMULO:
1894 case TargetOpcode::G_UMULO:
1895 case TargetOpcode::G_SADDSAT:
1896 case TargetOpcode::G_UADDSAT:
1897 case TargetOpcode::G_SSUBSAT:
1898 case TargetOpcode::G_USUBSAT:
1899 case TargetOpcode::G_SBFX:
1900 case TargetOpcode::G_UBFX:
1901 return false;
1902 case TargetOpcode::G_SSHLSAT:
1903 case TargetOpcode::G_USHLSAT:
1904 return includesPoison(Kind) &&
1905 !shiftAmountKnownInRange(ShiftAmount: RegDef->getOperand(i: 2).getReg(), MRI);
1906 case TargetOpcode::G_INSERT_VECTOR_ELT: {
1907 GInsertVectorElement *Insert = cast<GInsertVectorElement>(Val: RegDef);
1908 if (includesPoison(Kind)) {
1909 std::optional<ValueAndVReg> Index =
1910 getIConstantVRegValWithLookThrough(VReg: Insert->getIndexReg(), MRI);
1911 if (!Index)
1912 return true;
1913 LLT VecTy = MRI.getType(Reg: Insert->getVectorReg());
1914 return Index->Value.uge(RHS: VecTy.getElementCount().getKnownMinValue());
1915 }
1916 return false;
1917 }
1918 case TargetOpcode::G_EXTRACT_VECTOR_ELT: {
1919 GExtractVectorElement *Extract = cast<GExtractVectorElement>(Val: RegDef);
1920 if (includesPoison(Kind)) {
1921 std::optional<ValueAndVReg> Index =
1922 getIConstantVRegValWithLookThrough(VReg: Extract->getIndexReg(), MRI);
1923 if (!Index)
1924 return true;
1925 LLT VecTy = MRI.getType(Reg: Extract->getVectorReg());
1926 return Index->Value.uge(RHS: VecTy.getElementCount().getKnownMinValue());
1927 }
1928 return false;
1929 }
1930 case TargetOpcode::G_SHUFFLE_VECTOR: {
1931 GShuffleVector *Shuffle = cast<GShuffleVector>(Val: RegDef);
1932 ArrayRef<int> Mask = Shuffle->getMask();
1933 return includesPoison(Kind) && is_contained(Range&: Mask, Element: -1);
1934 }
1935 case TargetOpcode::G_FNEG:
1936 case TargetOpcode::G_PHI:
1937 case TargetOpcode::G_SELECT:
1938 case TargetOpcode::G_UREM:
1939 case TargetOpcode::G_SREM:
1940 case TargetOpcode::G_FREEZE:
1941 case TargetOpcode::G_ICMP:
1942 case TargetOpcode::G_FCMP:
1943 case TargetOpcode::G_FADD:
1944 case TargetOpcode::G_FSUB:
1945 case TargetOpcode::G_FMUL:
1946 case TargetOpcode::G_FDIV:
1947 case TargetOpcode::G_FREM:
1948 case TargetOpcode::G_PTR_ADD:
1949 return false;
1950 default:
1951 return !isa<GCastOp>(Val: RegDef) && !isa<GBinOp>(Val: RegDef);
1952 }
1953}
1954
1955static bool isGuaranteedNotToBeUndefOrPoison(Register Reg,
1956 const MachineRegisterInfo &MRI,
1957 unsigned Depth,
1958 UndefPoisonKind Kind) {
1959 if (Depth >= MaxAnalysisRecursionDepth)
1960 return false;
1961
1962 MachineInstr *RegDef = MRI.getVRegDef(Reg);
1963
1964 switch (RegDef->getOpcode()) {
1965 case TargetOpcode::G_FREEZE:
1966 return true;
1967 case TargetOpcode::G_IMPLICIT_DEF:
1968 return !includesUndef(Kind);
1969 case TargetOpcode::G_CONSTANT:
1970 case TargetOpcode::G_FCONSTANT:
1971 return true;
1972 case TargetOpcode::G_BUILD_VECTOR: {
1973 GBuildVector *BV = cast<GBuildVector>(Val: RegDef);
1974 unsigned NumSources = BV->getNumSources();
1975 for (unsigned I = 0; I < NumSources; ++I)
1976 if (!::isGuaranteedNotToBeUndefOrPoison(Reg: BV->getSourceReg(I), MRI,
1977 Depth: Depth + 1, Kind))
1978 return false;
1979 return true;
1980 }
1981 case TargetOpcode::G_PHI: {
1982 GPhi *Phi = cast<GPhi>(Val: RegDef);
1983 unsigned NumIncoming = Phi->getNumIncomingValues();
1984 for (unsigned I = 0; I < NumIncoming; ++I)
1985 if (!::isGuaranteedNotToBeUndefOrPoison(Reg: Phi->getIncomingValue(I), MRI,
1986 Depth: Depth + 1, Kind))
1987 return false;
1988 return true;
1989 }
1990 default: {
1991 auto MOCheck = [&](const MachineOperand &MO) {
1992 if (!MO.isReg())
1993 return true;
1994 return ::isGuaranteedNotToBeUndefOrPoison(Reg: MO.getReg(), MRI, Depth: Depth + 1,
1995 Kind);
1996 };
1997 return !::canCreateUndefOrPoison(Reg, MRI,
1998 /*ConsiderFlagsAndMetadata=*/true, Kind) &&
1999 all_of(Range: RegDef->uses(), P: MOCheck);
2000 }
2001 }
2002}
2003
2004bool llvm::canCreateUndefOrPoison(Register Reg, const MachineRegisterInfo &MRI,
2005 bool ConsiderFlagsAndMetadata) {
2006 return ::canCreateUndefOrPoison(Reg, MRI, ConsiderFlagsAndMetadata,
2007 Kind: UndefPoisonKind::UndefOrPoison);
2008}
2009
2010bool canCreatePoison(Register Reg, const MachineRegisterInfo &MRI,
2011 bool ConsiderFlagsAndMetadata = true) {
2012 return ::canCreateUndefOrPoison(Reg, MRI, ConsiderFlagsAndMetadata,
2013 Kind: UndefPoisonKind::PoisonOnly);
2014}
2015
2016bool llvm::isGuaranteedNotToBeUndefOrPoison(Register Reg,
2017 const MachineRegisterInfo &MRI,
2018 unsigned Depth) {
2019 return ::isGuaranteedNotToBeUndefOrPoison(Reg, MRI, Depth,
2020 Kind: UndefPoisonKind::UndefOrPoison);
2021}
2022
2023bool llvm::isGuaranteedNotToBePoison(Register Reg,
2024 const MachineRegisterInfo &MRI,
2025 unsigned Depth) {
2026 return ::isGuaranteedNotToBeUndefOrPoison(Reg, MRI, Depth,
2027 Kind: UndefPoisonKind::PoisonOnly);
2028}
2029
2030bool llvm::isGuaranteedNotToBeUndef(Register Reg,
2031 const MachineRegisterInfo &MRI,
2032 unsigned Depth) {
2033 return ::isGuaranteedNotToBeUndefOrPoison(Reg, MRI, Depth,
2034 Kind: UndefPoisonKind::UndefOnly);
2035}
2036
2037Type *llvm::getTypeForLLT(LLT Ty, LLVMContext &C) {
2038 if (Ty.isVector())
2039 return VectorType::get(ElementType: IntegerType::get(C, NumBits: Ty.getScalarSizeInBits()),
2040 EC: Ty.getElementCount());
2041 return IntegerType::get(C, NumBits: Ty.getSizeInBits());
2042}
2043
2044bool llvm::isAssertMI(const MachineInstr &MI) {
2045 switch (MI.getOpcode()) {
2046 default:
2047 return false;
2048 case TargetOpcode::G_ASSERT_ALIGN:
2049 case TargetOpcode::G_ASSERT_SEXT:
2050 case TargetOpcode::G_ASSERT_ZEXT:
2051 return true;
2052 }
2053}
2054
2055APInt llvm::GIConstant::getScalarValue() const {
2056 assert(Kind == GIConstantKind::Scalar && "Expected scalar constant");
2057
2058 return Value;
2059}
2060
2061std::optional<GIConstant>
2062llvm::GIConstant::getConstant(Register Const, const MachineRegisterInfo &MRI) {
2063 MachineInstr *Constant = getDefIgnoringCopies(Reg: Const, MRI);
2064
2065 if (GSplatVector *Splat = dyn_cast<GSplatVector>(Val: Constant)) {
2066 std::optional<ValueAndVReg> MayBeConstant =
2067 getIConstantVRegValWithLookThrough(VReg: Splat->getScalarReg(), MRI);
2068 if (!MayBeConstant)
2069 return std::nullopt;
2070 return GIConstant(MayBeConstant->Value, GIConstantKind::ScalableVector);
2071 }
2072
2073 if (GBuildVector *Build = dyn_cast<GBuildVector>(Val: Constant)) {
2074 SmallVector<APInt> Values;
2075 unsigned NumSources = Build->getNumSources();
2076 for (unsigned I = 0; I < NumSources; ++I) {
2077 Register SrcReg = Build->getSourceReg(I);
2078 std::optional<ValueAndVReg> MayBeConstant =
2079 getIConstantVRegValWithLookThrough(VReg: SrcReg, MRI);
2080 if (!MayBeConstant)
2081 return std::nullopt;
2082 Values.push_back(Elt: MayBeConstant->Value);
2083 }
2084 return GIConstant(Values);
2085 }
2086
2087 std::optional<ValueAndVReg> MayBeConstant =
2088 getIConstantVRegValWithLookThrough(VReg: Const, MRI);
2089 if (!MayBeConstant)
2090 return std::nullopt;
2091
2092 return GIConstant(MayBeConstant->Value, GIConstantKind::Scalar);
2093}
2094
2095APFloat llvm::GFConstant::getScalarValue() const {
2096 assert(Kind == GFConstantKind::Scalar && "Expected scalar constant");
2097
2098 return Values[0];
2099}
2100
2101std::optional<GFConstant>
2102llvm::GFConstant::getConstant(Register Const, const MachineRegisterInfo &MRI) {
2103 MachineInstr *Constant = getDefIgnoringCopies(Reg: Const, MRI);
2104
2105 if (GSplatVector *Splat = dyn_cast<GSplatVector>(Val: Constant)) {
2106 std::optional<FPValueAndVReg> MayBeConstant =
2107 getFConstantVRegValWithLookThrough(VReg: Splat->getScalarReg(), MRI);
2108 if (!MayBeConstant)
2109 return std::nullopt;
2110 return GFConstant(MayBeConstant->Value, GFConstantKind::ScalableVector);
2111 }
2112
2113 if (GBuildVector *Build = dyn_cast<GBuildVector>(Val: Constant)) {
2114 SmallVector<APFloat> Values;
2115 unsigned NumSources = Build->getNumSources();
2116 for (unsigned I = 0; I < NumSources; ++I) {
2117 Register SrcReg = Build->getSourceReg(I);
2118 std::optional<FPValueAndVReg> MayBeConstant =
2119 getFConstantVRegValWithLookThrough(VReg: SrcReg, MRI);
2120 if (!MayBeConstant)
2121 return std::nullopt;
2122 Values.push_back(Elt: MayBeConstant->Value);
2123 }
2124 return GFConstant(Values);
2125 }
2126
2127 std::optional<FPValueAndVReg> MayBeConstant =
2128 getFConstantVRegValWithLookThrough(VReg: Const, MRI);
2129 if (!MayBeConstant)
2130 return std::nullopt;
2131
2132 return GFConstant(MayBeConstant->Value, GFConstantKind::Scalar);
2133}
2134