LLVM 20.0.0git
MachineFunction.cpp
Go to the documentation of this file.
1//===- MachineFunction.cpp ------------------------------------------------===//
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// Collect native machine code information for a function. This allows
10// target-specific information about the generated code to be stored with each
11// function.
12//
13//===----------------------------------------------------------------------===//
14
16#include "llvm/ADT/BitVector.h"
17#include "llvm/ADT/DenseMap.h"
18#include "llvm/ADT/DenseSet.h"
19#include "llvm/ADT/STLExtras.h"
22#include "llvm/ADT/StringRef.h"
23#include "llvm/ADT/Twine.h"
43#include "llvm/Config/llvm-config.h"
44#include "llvm/IR/Attributes.h"
45#include "llvm/IR/BasicBlock.h"
46#include "llvm/IR/Constant.h"
47#include "llvm/IR/DataLayout.h"
50#include "llvm/IR/Function.h"
51#include "llvm/IR/GlobalValue.h"
52#include "llvm/IR/Instruction.h"
54#include "llvm/IR/Metadata.h"
55#include "llvm/IR/Module.h"
57#include "llvm/IR/Value.h"
58#include "llvm/MC/MCContext.h"
59#include "llvm/MC/MCSymbol.h"
60#include "llvm/MC/SectionKind.h"
69#include <algorithm>
70#include <cassert>
71#include <cstddef>
72#include <cstdint>
73#include <iterator>
74#include <string>
75#include <type_traits>
76#include <utility>
77#include <vector>
78
80
81using namespace llvm;
82
83#define DEBUG_TYPE "codegen"
84
86 "align-all-functions",
87 cl::desc("Force the alignment of all functions in log2 format (e.g. 4 "
88 "means align on 16B boundaries)."),
90
93
94 // clang-format off
95 switch(Prop) {
96 case P::FailedISel: return "FailedISel";
97 case P::IsSSA: return "IsSSA";
98 case P::Legalized: return "Legalized";
99 case P::NoPHIs: return "NoPHIs";
100 case P::NoVRegs: return "NoVRegs";
101 case P::RegBankSelected: return "RegBankSelected";
102 case P::Selected: return "Selected";
103 case P::TracksLiveness: return "TracksLiveness";
104 case P::TiedOpsRewritten: return "TiedOpsRewritten";
105 case P::FailsVerification: return "FailsVerification";
106 case P::TracksDebugUserValues: return "TracksDebugUserValues";
107 }
108 // clang-format on
109 llvm_unreachable("Invalid machine function property");
110}
111
113 if (!F.hasFnAttribute(Attribute::SafeStack))
114 return;
115
116 auto *Existing =
117 dyn_cast_or_null<MDTuple>(F.getMetadata(LLVMContext::MD_annotation));
118
119 if (!Existing || Existing->getNumOperands() != 2)
120 return;
121
122 auto *MetadataName = "unsafe-stack-size";
123 if (auto &N = Existing->getOperand(0)) {
124 if (N.equalsStr(MetadataName)) {
125 if (auto &Op = Existing->getOperand(1)) {
126 auto Val = mdconst::extract<ConstantInt>(Op)->getZExtValue();
127 FrameInfo.setUnsafeStackSize(Val);
128 }
129 }
130 }
131}
132
133// Pin the vtable to this file.
134void MachineFunction::Delegate::anchor() {}
135
137 const char *Separator = "";
138 for (BitVector::size_type I = 0; I < Properties.size(); ++I) {
139 if (!Properties[I])
140 continue;
141 OS << Separator << getPropertyName(static_cast<Property>(I));
142 Separator = ", ";
143 }
144}
145
146//===----------------------------------------------------------------------===//
147// MachineFunction implementation
148//===----------------------------------------------------------------------===//
149
150// Out-of-line virtual method.
152
155}
156
158 const Function &F) {
159 if (auto MA = F.getFnStackAlign())
160 return *MA;
161 return STI->getFrameLowering()->getStackAlign();
162}
163
165 const TargetSubtargetInfo &STI, MCContext &Ctx,
166 unsigned FunctionNum)
167 : F(F), Target(Target), STI(&STI), Ctx(Ctx) {
168 FunctionNumber = FunctionNum;
169 init();
170}
171
172void MachineFunction::handleInsertion(MachineInstr &MI) {
173 if (TheDelegate)
174 TheDelegate->MF_HandleInsertion(MI);
175}
176
177void MachineFunction::handleRemoval(MachineInstr &MI) {
178 if (TheDelegate)
179 TheDelegate->MF_HandleRemoval(MI);
180}
181
183 const MCInstrDesc &TID) {
184 if (TheDelegate)
185 TheDelegate->MF_HandleChangeDesc(MI, TID);
186}
187
188void MachineFunction::init() {
189 // Assume the function starts in SSA form with correct liveness.
192 if (STI->getRegisterInfo())
193 RegInfo = new (Allocator) MachineRegisterInfo(this);
194 else
195 RegInfo = nullptr;
196
197 MFInfo = nullptr;
198
199 // We can realign the stack if the target supports it and the user hasn't
200 // explicitly asked us not to.
201 bool CanRealignSP = STI->getFrameLowering()->isStackRealignable() &&
202 !F.hasFnAttribute("no-realign-stack");
203 bool ForceRealignSP = F.hasFnAttribute(Attribute::StackAlignment) ||
204 F.hasFnAttribute("stackrealign");
205 FrameInfo = new (Allocator) MachineFrameInfo(
206 getFnStackAlignment(STI, F), /*StackRealignable=*/CanRealignSP,
207 /*ForcedRealign=*/ForceRealignSP && CanRealignSP);
208
209 setUnsafeStackSize(F, *FrameInfo);
210
211 if (F.hasFnAttribute(Attribute::StackAlignment))
212 FrameInfo->ensureMaxAlignment(*F.getFnStackAlign());
213
215 Alignment = STI->getTargetLowering()->getMinFunctionAlignment();
216
217 // FIXME: Shouldn't use pref alignment if explicit alignment is set on F.
218 // FIXME: Use Function::hasOptSize().
219 if (!F.hasFnAttribute(Attribute::OptimizeForSize))
220 Alignment = std::max(Alignment,
222
223 // -fsanitize=function and -fsanitize=kcfi instrument indirect function calls
224 // to load a type hash before the function label. Ensure functions are aligned
225 // by a least 4 to avoid unaligned access, which is especially important for
226 // -mno-unaligned-access.
227 if (F.hasMetadata(LLVMContext::MD_func_sanitize) ||
228 F.getMetadata(LLVMContext::MD_kcfi_type))
229 Alignment = std::max(Alignment, Align(4));
230
232 Alignment = Align(1ULL << AlignAllFunctions);
233
234 JumpTableInfo = nullptr;
235
237 F.hasPersonalityFn() ? F.getPersonalityFn() : nullptr))) {
238 WinEHInfo = new (Allocator) WinEHFuncInfo();
239 }
240
242 F.hasPersonalityFn() ? F.getPersonalityFn() : nullptr))) {
243 WasmEHInfo = new (Allocator) WasmEHFuncInfo();
244 }
245
246 assert(Target.isCompatibleDataLayout(getDataLayout()) &&
247 "Can't create a MachineFunction using a Module with a "
248 "Target-incompatible DataLayout attached\n");
249
250 PSVManager = std::make_unique<PseudoSourceValueManager>(getTarget());
251}
252
254 const TargetSubtargetInfo &STI) {
255 assert(!MFInfo && "MachineFunctionInfo already set");
256 MFInfo = Target.createMachineFunctionInfo(Allocator, F, &STI);
257}
258
260 clear();
261}
262
263void MachineFunction::clear() {
264 Properties.reset();
265 // Don't call destructors on MachineInstr and MachineOperand. All of their
266 // memory comes from the BumpPtrAllocator which is about to be purged.
267 //
268 // Do call MachineBasicBlock destructors, it contains std::vectors.
269 for (iterator I = begin(), E = end(); I != E; I = BasicBlocks.erase(I))
270 I->Insts.clearAndLeakNodesUnsafely();
271 MBBNumbering.clear();
272
273 InstructionRecycler.clear(Allocator);
274 OperandRecycler.clear(Allocator);
275 BasicBlockRecycler.clear(Allocator);
276 CodeViewAnnotations.clear();
278 if (RegInfo) {
279 RegInfo->~MachineRegisterInfo();
280 Allocator.Deallocate(RegInfo);
281 }
282 if (MFInfo) {
283 MFInfo->~MachineFunctionInfo();
284 Allocator.Deallocate(MFInfo);
285 }
286
287 FrameInfo->~MachineFrameInfo();
288 Allocator.Deallocate(FrameInfo);
289
290 ConstantPool->~MachineConstantPool();
291 Allocator.Deallocate(ConstantPool);
292
293 if (JumpTableInfo) {
294 JumpTableInfo->~MachineJumpTableInfo();
295 Allocator.Deallocate(JumpTableInfo);
296 }
297
298 if (WinEHInfo) {
299 WinEHInfo->~WinEHFuncInfo();
300 Allocator.Deallocate(WinEHInfo);
301 }
302
303 if (WasmEHInfo) {
304 WasmEHInfo->~WasmEHFuncInfo();
305 Allocator.Deallocate(WasmEHInfo);
306 }
307}
308
310 return F.getDataLayout();
311}
312
313/// Get the JumpTableInfo for this function.
314/// If it does not already exist, allocate one.
316getOrCreateJumpTableInfo(unsigned EntryKind) {
317 if (JumpTableInfo) return JumpTableInfo;
318
319 JumpTableInfo = new (Allocator)
321 return JumpTableInfo;
322}
323
325 return F.getDenormalMode(FPType);
326}
327
328/// Should we be emitting segmented stack stuff for the function
330 return getFunction().hasFnAttribute("split-stack");
331}
332
333[[nodiscard]] unsigned
335 FrameInstructions.push_back(Inst);
336 return FrameInstructions.size() - 1;
337}
338
339/// This discards all of the MachineBasicBlock numbers and recomputes them.
340/// This guarantees that the MBB numbers are sequential, dense, and match the
341/// ordering of the blocks within the function. If a specific MachineBasicBlock
342/// is specified, only that block and those after it are renumbered.
344 if (empty()) { MBBNumbering.clear(); return; }
346 if (MBB == nullptr)
347 MBBI = begin();
348 else
349 MBBI = MBB->getIterator();
350
351 // Figure out the block number this should have.
352 unsigned BlockNo = 0;
353 if (MBBI != begin())
354 BlockNo = std::prev(MBBI)->getNumber() + 1;
355
356 for (; MBBI != E; ++MBBI, ++BlockNo) {
357 if (MBBI->getNumber() != (int)BlockNo) {
358 // Remove use of the old number.
359 if (MBBI->getNumber() != -1) {
360 assert(MBBNumbering[MBBI->getNumber()] == &*MBBI &&
361 "MBB number mismatch!");
362 MBBNumbering[MBBI->getNumber()] = nullptr;
363 }
364
365 // If BlockNo is already taken, set that block's number to -1.
366 if (MBBNumbering[BlockNo])
367 MBBNumbering[BlockNo]->setNumber(-1);
368
369 MBBNumbering[BlockNo] = &*MBBI;
370 MBBI->setNumber(BlockNo);
371 }
372 }
373
374 // Okay, all the blocks are renumbered. If we have compactified the block
375 // numbering, shrink MBBNumbering now.
376 assert(BlockNo <= MBBNumbering.size() && "Mismatch!");
377 MBBNumbering.resize(BlockNo);
378 MBBNumberingEpoch++;
379}
380
381/// This method iterates over the basic blocks and assigns their IsBeginSection
382/// and IsEndSection fields. This must be called after MBB layout is finalized
383/// and the SectionID's are assigned to MBBs.
386 auto CurrentSectionID = front().getSectionID();
387 for (auto MBBI = std::next(begin()), E = end(); MBBI != E; ++MBBI) {
388 if (MBBI->getSectionID() == CurrentSectionID)
389 continue;
391 std::prev(MBBI)->setIsEndSection();
392 CurrentSectionID = MBBI->getSectionID();
393 }
395}
396
397/// Allocate a new MachineInstr. Use this instead of `new MachineInstr'.
399 DebugLoc DL,
400 bool NoImplicit) {
401 return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
402 MachineInstr(*this, MCID, std::move(DL), NoImplicit);
403}
404
405/// Create a new MachineInstr which is a copy of the 'Orig' instruction,
406/// identical in all ways except the instruction has no parent, prev, or next.
409 return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
410 MachineInstr(*this, *Orig);
411}
412
415 const MachineInstr &Orig) {
416 MachineInstr *FirstClone = nullptr;
418 while (true) {
419 MachineInstr *Cloned = CloneMachineInstr(&*I);
420 MBB.insert(InsertBefore, Cloned);
421 if (FirstClone == nullptr) {
422 FirstClone = Cloned;
423 } else {
424 Cloned->bundleWithPred();
425 }
426
427 if (!I->isBundledWithSucc())
428 break;
429 ++I;
430 }
431 // Copy over call site info to the cloned instruction if needed. If Orig is in
432 // a bundle, copyCallSiteInfo takes care of finding the call instruction in
433 // the bundle.
434 if (Orig.shouldUpdateCallSiteInfo())
435 copyCallSiteInfo(&Orig, FirstClone);
436 return *FirstClone;
437}
438
439/// Delete the given MachineInstr.
440///
441/// This function also serves as the MachineInstr destructor - the real
442/// ~MachineInstr() destructor must be empty.
444 // Verify that a call site info is at valid state. This assertion should
445 // be triggered during the implementation of support for the
446 // call site info of a new architecture. If the assertion is triggered,
447 // back trace will tell where to insert a call to updateCallSiteInfo().
448 assert((!MI->isCandidateForCallSiteEntry() || !CallSitesInfo.contains(MI)) &&
449 "Call site info was not updated!");
450 // Strip it for parts. The operand array and the MI object itself are
451 // independently recyclable.
452 if (MI->Operands)
453 deallocateOperandArray(MI->CapOperands, MI->Operands);
454 // Don't call ~MachineInstr() which must be trivial anyway because
455 // ~MachineFunction drops whole lists of MachineInstrs wihout calling their
456 // destructors.
457 InstructionRecycler.Deallocate(Allocator, MI);
458}
459
460/// Allocate a new MachineBasicBlock. Use this instead of
461/// `new MachineBasicBlock'.
464 std::optional<UniqueBBID> BBID) {
466 new (BasicBlockRecycler.Allocate<MachineBasicBlock>(Allocator))
467 MachineBasicBlock(*this, BB);
468 // Set BBID for `-basic-block=sections=labels` and
469 // `-basic-block-sections=list` to allow robust mapping of profiles to basic
470 // blocks.
471 if (Target.getBBSectionsType() == BasicBlockSection::Labels ||
472 Target.Options.BBAddrMap ||
473 Target.getBBSectionsType() == BasicBlockSection::List)
474 MBB->setBBID(BBID.has_value() ? *BBID : UniqueBBID{NextBBID++, 0});
475 return MBB;
476}
477
478/// Delete the given MachineBasicBlock.
480 assert(MBB->getParent() == this && "MBB parent mismatch!");
481 // Clean up any references to MBB in jump tables before deleting it.
482 if (JumpTableInfo)
483 JumpTableInfo->RemoveMBBFromJumpTables(MBB);
484 MBB->~MachineBasicBlock();
485 BasicBlockRecycler.Deallocate(Allocator, MBB);
486}
487
490 Align BaseAlignment, const AAMDNodes &AAInfo, const MDNode *Ranges,
491 SyncScope::ID SSID, AtomicOrdering Ordering,
492 AtomicOrdering FailureOrdering) {
493 assert((!Size.hasValue() ||
494 Size.getValue().getKnownMinValue() != ~UINT64_C(0)) &&
495 "Unexpected an unknown size to be represented using "
496 "LocationSize::beforeOrAfter()");
497 return new (Allocator)
498 MachineMemOperand(PtrInfo, F, Size, BaseAlignment, AAInfo, Ranges, SSID,
499 Ordering, FailureOrdering);
500}
501
504 Align base_alignment, const AAMDNodes &AAInfo, const MDNode *Ranges,
505 SyncScope::ID SSID, AtomicOrdering Ordering,
506 AtomicOrdering FailureOrdering) {
507 return new (Allocator)
508 MachineMemOperand(PtrInfo, f, MemTy, base_alignment, AAInfo, Ranges, SSID,
509 Ordering, FailureOrdering);
510}
511
514 const MachinePointerInfo &PtrInfo,
516 assert((!Size.hasValue() ||
517 Size.getValue().getKnownMinValue() != ~UINT64_C(0)) &&
518 "Unexpected an unknown size to be represented using "
519 "LocationSize::beforeOrAfter()");
520 return new (Allocator)
521 MachineMemOperand(PtrInfo, MMO->getFlags(), Size, MMO->getBaseAlign(),
522 AAMDNodes(), nullptr, MMO->getSyncScopeID(),
524}
525
527 const MachineMemOperand *MMO, const MachinePointerInfo &PtrInfo, LLT Ty) {
528 return new (Allocator)
529 MachineMemOperand(PtrInfo, MMO->getFlags(), Ty, MMO->getBaseAlign(),
530 AAMDNodes(), nullptr, MMO->getSyncScopeID(),
532}
533
536 int64_t Offset, LLT Ty) {
537 const MachinePointerInfo &PtrInfo = MMO->getPointerInfo();
538
539 // If there is no pointer value, the offset isn't tracked so we need to adjust
540 // the base alignment.
541 Align Alignment = PtrInfo.V.isNull()
543 : MMO->getBaseAlign();
544
545 // Do not preserve ranges, since we don't necessarily know what the high bits
546 // are anymore.
547 return new (Allocator) MachineMemOperand(
548 PtrInfo.getWithOffset(Offset), MMO->getFlags(), Ty, Alignment,
549 MMO->getAAInfo(), nullptr, MMO->getSyncScopeID(),
551}
552
555 const AAMDNodes &AAInfo) {
556 MachinePointerInfo MPI = MMO->getValue() ?
557 MachinePointerInfo(MMO->getValue(), MMO->getOffset()) :
559
560 return new (Allocator) MachineMemOperand(
561 MPI, MMO->getFlags(), MMO->getSize(), MMO->getBaseAlign(), AAInfo,
562 MMO->getRanges(), MMO->getSyncScopeID(), MMO->getSuccessOrdering(),
563 MMO->getFailureOrdering());
564}
565
569 return new (Allocator) MachineMemOperand(
570 MMO->getPointerInfo(), Flags, MMO->getSize(), MMO->getBaseAlign(),
571 MMO->getAAInfo(), MMO->getRanges(), MMO->getSyncScopeID(),
573}
574
575MachineInstr::ExtraInfo *MachineFunction::createMIExtraInfo(
576 ArrayRef<MachineMemOperand *> MMOs, MCSymbol *PreInstrSymbol,
577 MCSymbol *PostInstrSymbol, MDNode *HeapAllocMarker, MDNode *PCSections,
578 uint32_t CFIType, MDNode *MMRAs) {
579 return MachineInstr::ExtraInfo::create(Allocator, MMOs, PreInstrSymbol,
580 PostInstrSymbol, HeapAllocMarker,
581 PCSections, CFIType, MMRAs);
582}
583
585 char *Dest = Allocator.Allocate<char>(Name.size() + 1);
586 llvm::copy(Name, Dest);
587 Dest[Name.size()] = 0;
588 return Dest;
589}
590
592 unsigned NumRegs = getSubtarget().getRegisterInfo()->getNumRegs();
593 unsigned Size = MachineOperand::getRegMaskSize(NumRegs);
594 uint32_t *Mask = Allocator.Allocate<uint32_t>(Size);
595 memset(Mask, 0, Size * sizeof(Mask[0]));
596 return Mask;
597}
598
600 int* AllocMask = Allocator.Allocate<int>(Mask.size());
601 copy(Mask, AllocMask);
602 return {AllocMask, Mask.size()};
603}
604
605#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
607 print(dbgs());
608}
609#endif
610
612 return getFunction().getName();
613}
614
615void MachineFunction::print(raw_ostream &OS, const SlotIndexes *Indexes) const {
616 OS << "# Machine code for function " << getName() << ": ";
618 OS << '\n';
619
620 // Print Frame Information
621 FrameInfo->print(*this, OS);
622
623 // Print JumpTable Information
624 if (JumpTableInfo)
625 JumpTableInfo->print(OS);
626
627 // Print Constant Pool
628 ConstantPool->print(OS);
629
631
632 if (RegInfo && !RegInfo->livein_empty()) {
633 OS << "Function Live Ins: ";
635 I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) {
636 OS << printReg(I->first, TRI);
637 if (I->second)
638 OS << " in " << printReg(I->second, TRI);
639 if (std::next(I) != E)
640 OS << ", ";
641 }
642 OS << '\n';
643 }
644
647 for (const auto &BB : *this) {
648 OS << '\n';
649 // If we print the whole function, print it at its most verbose level.
650 BB.print(OS, MST, Indexes, /*IsStandalone=*/true);
651 }
652
653 OS << "\n# End machine code for function " << getName() << ".\n\n";
654}
655
656/// True if this function needs frame moves for debug or exceptions.
658 // TODO: Ideally, what we'd like is to have a switch that allows emitting
659 // synchronous (precise at call-sites only) CFA into .eh_frame. However, even
660 // under this switch, we'd like .debug_frame to be precise when using -g. At
661 // this moment, there's no way to specify that some CFI directives go into
662 // .eh_frame only, while others go into .debug_frame only.
665 !F.getParent()->debug_compile_units().empty();
666}
667
668namespace llvm {
669
670 template<>
673
674 static std::string getGraphName(const MachineFunction *F) {
675 return ("CFG for '" + F->getName() + "' function").str();
676 }
677
678 std::string getNodeLabel(const MachineBasicBlock *Node,
679 const MachineFunction *Graph) {
680 std::string OutStr;
681 {
682 raw_string_ostream OSS(OutStr);
683
684 if (isSimple()) {
685 OSS << printMBBReference(*Node);
686 if (const BasicBlock *BB = Node->getBasicBlock())
687 OSS << ": " << BB->getName();
688 } else
689 Node->print(OSS);
690 }
691
692 if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());
693
694 // Process string output to make it nicer...
695 for (unsigned i = 0; i != OutStr.length(); ++i)
696 if (OutStr[i] == '\n') { // Left justify
697 OutStr[i] = '\\';
698 OutStr.insert(OutStr.begin()+i+1, 'l');
699 }
700 return OutStr;
701 }
702 };
703
704} // end namespace llvm
705
707{
708#ifndef NDEBUG
709 ViewGraph(this, "mf" + getName());
710#else
711 errs() << "MachineFunction::viewCFG is only available in debug builds on "
712 << "systems with Graphviz or gv!\n";
713#endif // NDEBUG
714}
715
717{
718#ifndef NDEBUG
719 ViewGraph(this, "mf" + getName(), true);
720#else
721 errs() << "MachineFunction::viewCFGOnly is only available in debug builds on "
722 << "systems with Graphviz or gv!\n";
723#endif // NDEBUG
724}
725
726/// Add the specified physical register as a live-in value and
727/// create a corresponding virtual register for it.
729 const TargetRegisterClass *RC) {
731 Register VReg = MRI.getLiveInVirtReg(PReg);
732 if (VReg) {
733 const TargetRegisterClass *VRegRC = MRI.getRegClass(VReg);
734 (void)VRegRC;
735 // A physical register can be added several times.
736 // Between two calls, the register class of the related virtual register
737 // may have been constrained to match some operation constraints.
738 // In that case, check that the current register class includes the
739 // physical register and is a sub class of the specified RC.
740 assert((VRegRC == RC || (VRegRC->contains(PReg) &&
741 RC->hasSubClassEq(VRegRC))) &&
742 "Register class mismatch!");
743 return VReg;
744 }
745 VReg = MRI.createVirtualRegister(RC);
746 MRI.addLiveIn(PReg, VReg);
747 return VReg;
748}
749
750/// Return the MCSymbol for the specified non-empty jump table.
751/// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
752/// normal 'L' label is returned.
754 bool isLinkerPrivate) const {
755 const DataLayout &DL = getDataLayout();
756 assert(JumpTableInfo && "No jump tables");
757 assert(JTI < JumpTableInfo->getJumpTables().size() && "Invalid JTI!");
758
759 StringRef Prefix = isLinkerPrivate ? DL.getLinkerPrivateGlobalPrefix()
760 : DL.getPrivateGlobalPrefix();
763 << Prefix << "JTI" << getFunctionNumber() << '_' << JTI;
764 return Ctx.getOrCreateSymbol(Name);
765}
766
767/// Return a function-local symbol to represent the PIC base.
769 const DataLayout &DL = getDataLayout();
770 return Ctx.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) +
771 Twine(getFunctionNumber()) + "$pb");
772}
773
774/// \name Exception Handling
775/// \{
776
779 unsigned N = LandingPads.size();
780 for (unsigned i = 0; i < N; ++i) {
781 LandingPadInfo &LP = LandingPads[i];
782 if (LP.LandingPadBlock == LandingPad)
783 return LP;
784 }
785
786 LandingPads.push_back(LandingPadInfo(LandingPad));
787 return LandingPads[N];
788}
789
791 MCSymbol *BeginLabel, MCSymbol *EndLabel) {
793 LP.BeginLabels.push_back(BeginLabel);
794 LP.EndLabels.push_back(EndLabel);
795}
796
798 MCSymbol *LandingPadLabel = Ctx.createTempSymbol();
800 LP.LandingPadLabel = LandingPadLabel;
801
802 const Instruction *FirstI = LandingPad->getBasicBlock()->getFirstNonPHI();
803 if (const auto *LPI = dyn_cast<LandingPadInst>(FirstI)) {
804 // If there's no typeid list specified, then "cleanup" is implicit.
805 // Otherwise, id 0 is reserved for the cleanup action.
806 if (LPI->isCleanup() && LPI->getNumClauses() != 0)
807 LP.TypeIds.push_back(0);
808
809 // FIXME: New EH - Add the clauses in reverse order. This isn't 100%
810 // correct, but we need to do it this way because of how the DWARF EH
811 // emitter processes the clauses.
812 for (unsigned I = LPI->getNumClauses(); I != 0; --I) {
813 Value *Val = LPI->getClause(I - 1);
814 if (LPI->isCatch(I - 1)) {
815 LP.TypeIds.push_back(
816 getTypeIDFor(dyn_cast<GlobalValue>(Val->stripPointerCasts())));
817 } else {
818 // Add filters in a list.
819 auto *CVal = cast<Constant>(Val);
820 SmallVector<unsigned, 4> FilterList;
821 for (const Use &U : CVal->operands())
822 FilterList.push_back(
823 getTypeIDFor(cast<GlobalValue>(U->stripPointerCasts())));
824
825 LP.TypeIds.push_back(getFilterIDFor(FilterList));
826 }
827 }
828
829 } else if (const auto *CPI = dyn_cast<CatchPadInst>(FirstI)) {
830 for (unsigned I = CPI->arg_size(); I != 0; --I) {
831 auto *TypeInfo =
832 dyn_cast<GlobalValue>(CPI->getArgOperand(I - 1)->stripPointerCasts());
833 LP.TypeIds.push_back(getTypeIDFor(TypeInfo));
834 }
835
836 } else {
837 assert(isa<CleanupPadInst>(FirstI) && "Invalid landingpad!");
838 }
839
840 return LandingPadLabel;
841}
842
844 ArrayRef<unsigned> Sites) {
845 LPadToCallSiteMap[Sym].append(Sites.begin(), Sites.end());
846}
847
849 for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i)
850 if (TypeInfos[i] == TI) return i + 1;
851
852 TypeInfos.push_back(TI);
853 return TypeInfos.size();
854}
855
857 // If the new filter coincides with the tail of an existing filter, then
858 // re-use the existing filter. Folding filters more than this requires
859 // re-ordering filters and/or their elements - probably not worth it.
860 for (unsigned i : FilterEnds) {
861 unsigned j = TyIds.size();
862
863 while (i && j)
864 if (FilterIds[--i] != TyIds[--j])
865 goto try_next;
866
867 if (!j)
868 // The new filter coincides with range [i, end) of the existing filter.
869 return -(1 + i);
870
871try_next:;
872 }
873
874 // Add the new filter.
875 int FilterID = -(1 + FilterIds.size());
876 FilterIds.reserve(FilterIds.size() + TyIds.size() + 1);
877 llvm::append_range(FilterIds, TyIds);
878 FilterEnds.push_back(FilterIds.size());
879 FilterIds.push_back(0); // terminator
880 return FilterID;
881}
882
884MachineFunction::getCallSiteInfo(const MachineInstr *MI) {
885 assert(MI->isCandidateForCallSiteEntry() &&
886 "Call site info refers only to call (MI) candidates");
887
888 if (!Target.Options.EmitCallSiteInfo)
889 return CallSitesInfo.end();
890 return CallSitesInfo.find(MI);
891}
892
893/// Return the call machine instruction or find a call within bundle.
895 if (!MI->isBundle())
896 return MI;
897
898 for (const auto &BMI : make_range(getBundleStart(MI->getIterator()),
899 getBundleEnd(MI->getIterator())))
900 if (BMI.isCandidateForCallSiteEntry())
901 return &BMI;
902
903 llvm_unreachable("Unexpected bundle without a call site candidate");
904}
905
907 assert(MI->shouldUpdateCallSiteInfo() &&
908 "Call site info refers only to call (MI) candidates or "
909 "candidates inside bundles");
910
911 const MachineInstr *CallMI = getCallInstr(MI);
912 CallSiteInfoMap::iterator CSIt = getCallSiteInfo(CallMI);
913 if (CSIt == CallSitesInfo.end())
914 return;
915 CallSitesInfo.erase(CSIt);
916}
917
919 const MachineInstr *New) {
921 "Call site info refers only to call (MI) candidates or "
922 "candidates inside bundles");
923
924 if (!New->isCandidateForCallSiteEntry())
925 return eraseCallSiteInfo(Old);
926
927 const MachineInstr *OldCallMI = getCallInstr(Old);
928 CallSiteInfoMap::iterator CSIt = getCallSiteInfo(OldCallMI);
929 if (CSIt == CallSitesInfo.end())
930 return;
931
932 CallSiteInfo CSInfo = CSIt->second;
933 CallSitesInfo[New] = CSInfo;
934}
935
937 const MachineInstr *New) {
939 "Call site info refers only to call (MI) candidates or "
940 "candidates inside bundles");
941
942 if (!New->isCandidateForCallSiteEntry())
943 return eraseCallSiteInfo(Old);
944
945 const MachineInstr *OldCallMI = getCallInstr(Old);
946 CallSiteInfoMap::iterator CSIt = getCallSiteInfo(OldCallMI);
947 if (CSIt == CallSitesInfo.end())
948 return;
949
950 CallSiteInfo CSInfo = std::move(CSIt->second);
951 CallSitesInfo.erase(CSIt);
952 CallSitesInfo[New] = CSInfo;
953}
954
957}
958
961 unsigned Subreg) {
962 // Catch any accidental self-loops.
963 assert(A.first != B.first);
964 // Don't allow any substitutions _from_ the memory operand number.
965 assert(A.second != DebugOperandMemNumber);
966
967 DebugValueSubstitutions.push_back({A, B, Subreg});
968}
969
971 MachineInstr &New,
972 unsigned MaxOperand) {
973 // If the Old instruction wasn't tracked at all, there is no work to do.
974 unsigned OldInstrNum = Old.peekDebugInstrNum();
975 if (!OldInstrNum)
976 return;
977
978 // Iterate over all operands looking for defs to create substitutions for.
979 // Avoid creating new instr numbers unless we create a new substitution.
980 // While this has no functional effect, it risks confusing someone reading
981 // MIR output.
982 // Examine all the operands, or the first N specified by the caller.
983 MaxOperand = std::min(MaxOperand, Old.getNumOperands());
984 for (unsigned int I = 0; I < MaxOperand; ++I) {
985 const auto &OldMO = Old.getOperand(I);
986 auto &NewMO = New.getOperand(I);
987 (void)NewMO;
988
989 if (!OldMO.isReg() || !OldMO.isDef())
990 continue;
991 assert(NewMO.isDef());
992
993 unsigned NewInstrNum = New.getDebugInstrNum();
994 makeDebugValueSubstitution(std::make_pair(OldInstrNum, I),
995 std::make_pair(NewInstrNum, I));
996 }
997}
998
1002 const TargetInstrInfo &TII = *getSubtarget().getInstrInfo();
1003
1004 // Check whether this copy-like instruction has already been salvaged into
1005 // an operand pair.
1006 Register Dest;
1007 if (auto CopyDstSrc = TII.isCopyInstr(MI)) {
1008 Dest = CopyDstSrc->Destination->getReg();
1009 } else {
1010 assert(MI.isSubregToReg());
1011 Dest = MI.getOperand(0).getReg();
1012 }
1013
1014 auto CacheIt = DbgPHICache.find(Dest);
1015 if (CacheIt != DbgPHICache.end())
1016 return CacheIt->second;
1017
1018 // Calculate the instruction number to use, or install a DBG_PHI.
1019 auto OperandPair = salvageCopySSAImpl(MI);
1020 DbgPHICache.insert({Dest, OperandPair});
1021 return OperandPair;
1022}
1023
1026 MachineRegisterInfo &MRI = getRegInfo();
1027 const TargetRegisterInfo &TRI = *MRI.getTargetRegisterInfo();
1028 const TargetInstrInfo &TII = *getSubtarget().getInstrInfo();
1029
1030 // Chase the value read by a copy-like instruction back to the instruction
1031 // that ultimately _defines_ that value. This may pass:
1032 // * Through multiple intermediate copies, including subregister moves /
1033 // copies,
1034 // * Copies from physical registers that must then be traced back to the
1035 // defining instruction,
1036 // * Or, physical registers may be live-in to (only) the entry block, which
1037 // requires a DBG_PHI to be created.
1038 // We can pursue this problem in that order: trace back through copies,
1039 // optionally through a physical register, to a defining instruction. We
1040 // should never move from physreg to vreg. As we're still in SSA form, no need
1041 // to worry about partial definitions of registers.
1042
1043 // Helper lambda to interpret a copy-like instruction. Takes instruction,
1044 // returns the register read and any subregister identifying which part is
1045 // read.
1046 auto GetRegAndSubreg =
1047 [&](const MachineInstr &Cpy) -> std::pair<Register, unsigned> {
1048 Register NewReg, OldReg;
1049 unsigned SubReg;
1050 if (Cpy.isCopy()) {
1051 OldReg = Cpy.getOperand(0).getReg();
1052 NewReg = Cpy.getOperand(1).getReg();
1053 SubReg = Cpy.getOperand(1).getSubReg();
1054 } else if (Cpy.isSubregToReg()) {
1055 OldReg = Cpy.getOperand(0).getReg();
1056 NewReg = Cpy.getOperand(2).getReg();
1057 SubReg = Cpy.getOperand(3).getImm();
1058 } else {
1059 auto CopyDetails = *TII.isCopyInstr(Cpy);
1060 const MachineOperand &Src = *CopyDetails.Source;
1061 const MachineOperand &Dest = *CopyDetails.Destination;
1062 OldReg = Dest.getReg();
1063 NewReg = Src.getReg();
1064 SubReg = Src.getSubReg();
1065 }
1066
1067 return {NewReg, SubReg};
1068 };
1069
1070 // First seek either the defining instruction, or a copy from a physreg.
1071 // During search, the current state is the current copy instruction, and which
1072 // register we've read. Accumulate qualifying subregisters into SubregsSeen;
1073 // deal with those later.
1074 auto State = GetRegAndSubreg(MI);
1075 auto CurInst = MI.getIterator();
1076 SmallVector<unsigned, 4> SubregsSeen;
1077 while (true) {
1078 // If we've found a copy from a physreg, first portion of search is over.
1079 if (!State.first.isVirtual())
1080 break;
1081
1082 // Record any subregister qualifier.
1083 if (State.second)
1084 SubregsSeen.push_back(State.second);
1085
1086 assert(MRI.hasOneDef(State.first));
1087 MachineInstr &Inst = *MRI.def_begin(State.first)->getParent();
1088 CurInst = Inst.getIterator();
1089
1090 // Any non-copy instruction is the defining instruction we're seeking.
1091 if (!Inst.isCopyLike() && !TII.isCopyInstr(Inst))
1092 break;
1093 State = GetRegAndSubreg(Inst);
1094 };
1095
1096 // Helper lambda to apply additional subregister substitutions to a known
1097 // instruction/operand pair. Adds new (fake) substitutions so that we can
1098 // record the subregister. FIXME: this isn't very space efficient if multiple
1099 // values are tracked back through the same copies; cache something later.
1100 auto ApplySubregisters =
1102 for (unsigned Subreg : reverse(SubregsSeen)) {
1103 // Fetch a new instruction number, not attached to an actual instruction.
1104 unsigned NewInstrNumber = getNewDebugInstrNum();
1105 // Add a substitution from the "new" number to the known one, with a
1106 // qualifying subreg.
1107 makeDebugValueSubstitution({NewInstrNumber, 0}, P, Subreg);
1108 // Return the new number; to find the underlying value, consumers need to
1109 // deal with the qualifying subreg.
1110 P = {NewInstrNumber, 0};
1111 }
1112 return P;
1113 };
1114
1115 // If we managed to find the defining instruction after COPYs, return an
1116 // instruction / operand pair after adding subregister qualifiers.
1117 if (State.first.isVirtual()) {
1118 // Virtual register def -- we can just look up where this happens.
1119 MachineInstr *Inst = MRI.def_begin(State.first)->getParent();
1120 for (auto &MO : Inst->all_defs()) {
1121 if (MO.getReg() != State.first)
1122 continue;
1123 return ApplySubregisters({Inst->getDebugInstrNum(), MO.getOperandNo()});
1124 }
1125
1126 llvm_unreachable("Vreg def with no corresponding operand?");
1127 }
1128
1129 // Our search ended in a copy from a physreg: walk back up the function
1130 // looking for whatever defines the physreg.
1131 assert(CurInst->isCopyLike() || TII.isCopyInstr(*CurInst));
1132 State = GetRegAndSubreg(*CurInst);
1133 Register RegToSeek = State.first;
1134
1135 auto RMII = CurInst->getReverseIterator();
1136 auto PrevInstrs = make_range(RMII, CurInst->getParent()->instr_rend());
1137 for (auto &ToExamine : PrevInstrs) {
1138 for (auto &MO : ToExamine.all_defs()) {
1139 // Test for operand that defines something aliasing RegToSeek.
1140 if (!TRI.regsOverlap(RegToSeek, MO.getReg()))
1141 continue;
1142
1143 return ApplySubregisters(
1144 {ToExamine.getDebugInstrNum(), MO.getOperandNo()});
1145 }
1146 }
1147
1148 MachineBasicBlock &InsertBB = *CurInst->getParent();
1149
1150 // We reached the start of the block before finding a defining instruction.
1151 // There are numerous scenarios where this can happen:
1152 // * Constant physical registers,
1153 // * Several intrinsics that allow LLVM-IR to read arbitary registers,
1154 // * Arguments in the entry block,
1155 // * Exception handling landing pads.
1156 // Validating all of them is too difficult, so just insert a DBG_PHI reading
1157 // the variable value at this position, rather than checking it makes sense.
1158
1159 // Create DBG_PHI for specified physreg.
1160 auto Builder = BuildMI(InsertBB, InsertBB.getFirstNonPHI(), DebugLoc(),
1161 TII.get(TargetOpcode::DBG_PHI));
1162 Builder.addReg(State.first);
1163 unsigned NewNum = getNewDebugInstrNum();
1164 Builder.addImm(NewNum);
1165 return ApplySubregisters({NewNum, 0u});
1166}
1167
1169 auto *TII = getSubtarget().getInstrInfo();
1170
1171 auto MakeUndefDbgValue = [&](MachineInstr &MI) {
1172 const MCInstrDesc &RefII = TII->get(TargetOpcode::DBG_VALUE_LIST);
1173 MI.setDesc(RefII);
1174 MI.setDebugValueUndef();
1175 };
1176
1178 for (auto &MBB : *this) {
1179 for (auto &MI : MBB) {
1180 if (!MI.isDebugRef())
1181 continue;
1182
1183 bool IsValidRef = true;
1184
1185 for (MachineOperand &MO : MI.debug_operands()) {
1186 if (!MO.isReg())
1187 continue;
1188
1189 Register Reg = MO.getReg();
1190
1191 // Some vregs can be deleted as redundant in the meantime. Mark those
1192 // as DBG_VALUE $noreg. Additionally, some normal instructions are
1193 // quickly deleted, leaving dangling references to vregs with no def.
1194 if (Reg == 0 || !RegInfo->hasOneDef(Reg)) {
1195 IsValidRef = false;
1196 break;
1197 }
1198
1199 assert(Reg.isVirtual());
1200 MachineInstr &DefMI = *RegInfo->def_instr_begin(Reg);
1201
1202 // If we've found a copy-like instruction, follow it back to the
1203 // instruction that defines the source value, see salvageCopySSA docs
1204 // for why this is important.
1205 if (DefMI.isCopyLike() || TII->isCopyInstr(DefMI)) {
1206 auto Result = salvageCopySSA(DefMI, ArgDbgPHIs);
1207 MO.ChangeToDbgInstrRef(Result.first, Result.second);
1208 } else {
1209 // Otherwise, identify the operand number that the VReg refers to.
1210 unsigned OperandIdx = 0;
1211 for (const auto &DefMO : DefMI.operands()) {
1212 if (DefMO.isReg() && DefMO.isDef() && DefMO.getReg() == Reg)
1213 break;
1214 ++OperandIdx;
1215 }
1216 assert(OperandIdx < DefMI.getNumOperands());
1217
1218 // Morph this instr ref to point at the given instruction and operand.
1219 unsigned ID = DefMI.getDebugInstrNum();
1220 MO.ChangeToDbgInstrRef(ID, OperandIdx);
1221 }
1222 }
1223
1224 if (!IsValidRef)
1225 MakeUndefDbgValue(MI);
1226 }
1227 }
1228}
1229
1231 // Disable instr-ref at -O0: it's very slow (in compile time). We can still
1232 // have optimized code inlined into this unoptimized code, however with
1233 // fewer and less aggressive optimizations happening, coverage and accuracy
1234 // should not suffer.
1235 if (getTarget().getOptLevel() == CodeGenOptLevel::None)
1236 return false;
1237
1238 // Don't use instr-ref if this function is marked optnone.
1239 if (F.hasFnAttribute(Attribute::OptimizeNone))
1240 return false;
1241
1242 if (llvm::debuginfoShouldUseDebugInstrRef(getTarget().getTargetTriple()))
1243 return true;
1244
1245 return false;
1246}
1247
1249 return UseDebugInstrRef;
1250}
1251
1254}
1255
1256// Use one million as a high / reserved number.
1257const unsigned MachineFunction::DebugOperandMemNumber = 1000000;
1258
1259/// \}
1260
1261//===----------------------------------------------------------------------===//
1262// MachineJumpTableInfo implementation
1263//===----------------------------------------------------------------------===//
1264
1265/// Return the size of each entry in the jump table.
1267 // The size of a jump table entry is 4 bytes unless the entry is just the
1268 // address of a block, in which case it is the pointer size.
1269 switch (getEntryKind()) {
1271 return TD.getPointerSize();
1274 return 8;
1278 return 4;
1280 return 0;
1281 }
1282 llvm_unreachable("Unknown jump table encoding!");
1283}
1284
1285/// Return the alignment of each entry in the jump table.
1287 // The alignment of a jump table entry is the alignment of int32 unless the
1288 // entry is just the address of a block, in which case it is the pointer
1289 // alignment.
1290 switch (getEntryKind()) {
1292 return TD.getPointerABIAlignment(0).value();
1295 return TD.getABIIntegerTypeAlignment(64).value();
1299 return TD.getABIIntegerTypeAlignment(32).value();
1301 return 1;
1302 }
1303 llvm_unreachable("Unknown jump table encoding!");
1304}
1305
1306/// Create a new jump table entry in the jump table info.
1308 const std::vector<MachineBasicBlock*> &DestBBs) {
1309 assert(!DestBBs.empty() && "Cannot create an empty jump table!");
1310 JumpTables.push_back(MachineJumpTableEntry(DestBBs));
1311 return JumpTables.size()-1;
1312}
1313
1314/// If Old is the target of any jump tables, update the jump tables to branch
1315/// to New instead.
1317 MachineBasicBlock *New) {
1318 assert(Old != New && "Not making a change?");
1319 bool MadeChange = false;
1320 for (size_t i = 0, e = JumpTables.size(); i != e; ++i)
1321 ReplaceMBBInJumpTable(i, Old, New);
1322 return MadeChange;
1323}
1324
1325/// If MBB is present in any jump tables, remove it.
1327 bool MadeChange = false;
1328 for (MachineJumpTableEntry &JTE : JumpTables) {
1329 auto removeBeginItr = std::remove(JTE.MBBs.begin(), JTE.MBBs.end(), MBB);
1330 MadeChange |= (removeBeginItr != JTE.MBBs.end());
1331 JTE.MBBs.erase(removeBeginItr, JTE.MBBs.end());
1332 }
1333 return MadeChange;
1334}
1335
1336/// If Old is a target of the jump tables, update the jump table to branch to
1337/// New instead.
1339 MachineBasicBlock *Old,
1340 MachineBasicBlock *New) {
1341 assert(Old != New && "Not making a change?");
1342 bool MadeChange = false;
1343 MachineJumpTableEntry &JTE = JumpTables[Idx];
1344 for (MachineBasicBlock *&MBB : JTE.MBBs)
1345 if (MBB == Old) {
1346 MBB = New;
1347 MadeChange = true;
1348 }
1349 return MadeChange;
1350}
1351
1353 if (JumpTables.empty()) return;
1354
1355 OS << "Jump Tables:\n";
1356
1357 for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) {
1358 OS << printJumpTableEntryReference(i) << ':';
1359 for (const MachineBasicBlock *MBB : JumpTables[i].MBBs)
1360 OS << ' ' << printMBBReference(*MBB);
1361 if (i != e)
1362 OS << '\n';
1363 }
1364
1365 OS << '\n';
1366}
1367
1368#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1370#endif
1371
1373 return Printable([Idx](raw_ostream &OS) { OS << "%jump-table." << Idx; });
1374}
1375
1376//===----------------------------------------------------------------------===//
1377// MachineConstantPool implementation
1378//===----------------------------------------------------------------------===//
1379
1380void MachineConstantPoolValue::anchor() {}
1381
1383 return DL.getTypeAllocSize(Ty);
1384}
1385
1388 return Val.MachineCPVal->getSizeInBytes(DL);
1389 return DL.getTypeAllocSize(Val.ConstVal->getType());
1390}
1391
1394 return true;
1395 return Val.ConstVal->needsDynamicRelocation();
1396}
1397
1400 if (needsRelocation())
1402 switch (getSizeInBytes(*DL)) {
1403 case 4:
1405 case 8:
1407 case 16:
1409 case 32:
1411 default:
1412 return SectionKind::getReadOnly();
1413 }
1414}
1415
1417 // A constant may be a member of both Constants and MachineCPVsSharingEntries,
1418 // so keep track of which we've deleted to avoid double deletions.
1420 for (const MachineConstantPoolEntry &C : Constants)
1421 if (C.isMachineConstantPoolEntry()) {
1422 Deleted.insert(C.Val.MachineCPVal);
1423 delete C.Val.MachineCPVal;
1424 }
1425 for (MachineConstantPoolValue *CPV : MachineCPVsSharingEntries) {
1426 if (Deleted.count(CPV) == 0)
1427 delete CPV;
1428 }
1429}
1430
1431/// Test whether the given two constants can be allocated the same constant pool
1432/// entry referenced by \param A.
1433static bool CanShareConstantPoolEntry(const Constant *A, const Constant *B,
1434 const DataLayout &DL) {
1435 // Handle the trivial case quickly.
1436 if (A == B) return true;
1437
1438 // If they have the same type but weren't the same constant, quickly
1439 // reject them.
1440 if (A->getType() == B->getType()) return false;
1441
1442 // We can't handle structs or arrays.
1443 if (isa<StructType>(A->getType()) || isa<ArrayType>(A->getType()) ||
1444 isa<StructType>(B->getType()) || isa<ArrayType>(B->getType()))
1445 return false;
1446
1447 // For now, only support constants with the same size.
1448 uint64_t StoreSize = DL.getTypeStoreSize(A->getType());
1449 if (StoreSize != DL.getTypeStoreSize(B->getType()) || StoreSize > 128)
1450 return false;
1451
1452 bool ContainsUndefOrPoisonA = A->containsUndefOrPoisonElement();
1453
1454 Type *IntTy = IntegerType::get(A->getContext(), StoreSize*8);
1455
1456 // Try constant folding a bitcast of both instructions to an integer. If we
1457 // get two identical ConstantInt's, then we are good to share them. We use
1458 // the constant folding APIs to do this so that we get the benefit of
1459 // DataLayout.
1460 if (isa<PointerType>(A->getType()))
1461 A = ConstantFoldCastOperand(Instruction::PtrToInt,
1462 const_cast<Constant *>(A), IntTy, DL);
1463 else if (A->getType() != IntTy)
1464 A = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(A),
1465 IntTy, DL);
1466 if (isa<PointerType>(B->getType()))
1467 B = ConstantFoldCastOperand(Instruction::PtrToInt,
1468 const_cast<Constant *>(B), IntTy, DL);
1469 else if (B->getType() != IntTy)
1470 B = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(B),
1471 IntTy, DL);
1472
1473 if (A != B)
1474 return false;
1475
1476 // Constants only safely match if A doesn't contain undef/poison.
1477 // As we'll be reusing A, it doesn't matter if B contain undef/poison.
1478 // TODO: Handle cases where A and B have the same undef/poison elements.
1479 // TODO: Merge A and B with mismatching undef/poison elements.
1480 return !ContainsUndefOrPoisonA;
1481}
1482
1483/// Create a new entry in the constant pool or return an existing one.
1484/// User must specify the log2 of the minimum required alignment for the object.
1486 Align Alignment) {
1487 if (Alignment > PoolAlignment) PoolAlignment = Alignment;
1488
1489 // Check to see if we already have this constant.
1490 //
1491 // FIXME, this could be made much more efficient for large constant pools.
1492 for (unsigned i = 0, e = Constants.size(); i != e; ++i)
1493 if (!Constants[i].isMachineConstantPoolEntry() &&
1494 CanShareConstantPoolEntry(Constants[i].Val.ConstVal, C, DL)) {
1495 if (Constants[i].getAlign() < Alignment)
1496 Constants[i].Alignment = Alignment;
1497 return i;
1498 }
1499
1500 Constants.push_back(MachineConstantPoolEntry(C, Alignment));
1501 return Constants.size()-1;
1502}
1503
1505 Align Alignment) {
1506 if (Alignment > PoolAlignment) PoolAlignment = Alignment;
1507
1508 // Check to see if we already have this constant.
1509 //
1510 // FIXME, this could be made much more efficient for large constant pools.
1511 int Idx = V->getExistingMachineCPValue(this, Alignment);
1512 if (Idx != -1) {
1513 MachineCPVsSharingEntries.insert(V);
1514 return (unsigned)Idx;
1515 }
1516
1517 Constants.push_back(MachineConstantPoolEntry(V, Alignment));
1518 return Constants.size()-1;
1519}
1520
1522 if (Constants.empty()) return;
1523
1524 OS << "Constant Pool:\n";
1525 for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
1526 OS << " cp#" << i << ": ";
1527 if (Constants[i].isMachineConstantPoolEntry())
1528 Constants[i].Val.MachineCPVal->print(OS);
1529 else
1530 Constants[i].Val.ConstVal->printAsOperand(OS, /*PrintType=*/false);
1531 OS << ", align=" << Constants[i].getAlign().value();
1532 OS << "\n";
1533 }
1534}
1535
1536//===----------------------------------------------------------------------===//
1537// Template specialization for MachineFunction implementation of
1538// ProfileSummaryInfo::getEntryCount().
1539//===----------------------------------------------------------------------===//
1540template <>
1541std::optional<Function::ProfileCount>
1542ProfileSummaryInfo::getEntryCount<llvm::MachineFunction>(
1543 const llvm::MachineFunction *F) const {
1544 return F->getFunction().getEntryCount();
1545}
1546
1547#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1549#endif
unsigned SubReg
unsigned const MachineRegisterInfo * MRI
MachineInstrBuilder MachineInstrBuilder & DefMI
aarch64 promote const
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
MachineBasicBlock MachineBasicBlock::iterator MBBI
This file contains the simple types necessary to represent the attributes associated with functions a...
static const Function * getParent(const Value *V)
This file implements the BitVector class.
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Definition: Compiler.h:537
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
This file defines the DenseMap class.
This file defines the DenseSet and SmallDenseSet classes.
std::string Name
uint64_t Size
Symbol * Sym
Definition: ELF_riscv.cpp:479
const HexagonInstrInfo * TII
IRTranslator LLVM IR MI
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
This file declares the MachineConstantPool class which is an abstract constant pool to keep track of ...
static Align getFnStackAlignment(const TargetSubtargetInfo *STI, const Function &F)
static cl::opt< unsigned > AlignAllFunctions("align-all-functions", cl::desc("Force the alignment of all functions in log2 format (e.g. 4 " "means align on 16B boundaries)."), cl::init(0), cl::Hidden)
static const MachineInstr * getCallInstr(const MachineInstr *MI)
Return the call machine instruction or find a call within bundle.
static bool CanShareConstantPoolEntry(const Constant *A, const Constant *B, const DataLayout &DL)
Test whether the given two constants can be allocated the same constant pool entry referenced by.
void setUnsafeStackSize(const Function &F, MachineFrameInfo &FrameInfo)
static const char * getPropertyName(MachineFunctionProperties::Property Prop)
unsigned const TargetRegisterInfo * TRI
unsigned Reg
This file contains the declarations for metadata subclasses.
Module.h This file contains the declarations for the Module class.
#define P(N)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static bool isSimple(Instruction *I)
This file contains some templates that are useful if you are working with the STL at all.
raw_pwrite_stream & OS
This file defines the SmallString class.
This file defines the SmallVector class.
This file describes how to lower LLVM code to machine code.
void clear(AllocatorType &Allocator)
Release all the tracked allocations to the allocator.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
iterator end() const
Definition: ArrayRef.h:154
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
iterator begin() const
Definition: ArrayRef.h:153
LLVM Basic Block Representation.
Definition: BasicBlock.h:61
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:367
LLVM_ATTRIBUTE_RETURNS_NONNULL void * Allocate(size_t Size, Align Alignment)
Allocate space at the specified alignment.
Definition: Allocator.h:148
void Deallocate(const void *Ptr, size_t Size, size_t)
Definition: Allocator.h:225
This is an important base class in LLVM.
Definition: Constant.h:42
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:63
Align getABIIntegerTypeAlignment(unsigned BitWidth) const
Returns the minimum ABI-required alignment for an integer type of the specified bitwidth.
Definition: DataLayout.h:491
unsigned getPointerSize(unsigned AS=0) const
Layout pointer size in bytes, rounded up to a whole number of bytes.
Definition: DataLayout.cpp:728
Align getPointerABIAlignment(unsigned AS) const
Layout pointer alignment.
Definition: DataLayout.cpp:720
A debug info location.
Definition: DebugLoc.h:33
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:155
bool erase(const KeyT &Val)
Definition: DenseMap.h:336
iterator end()
Definition: DenseMap.h:84
bool contains(const_arg_type_t< KeyT > Val) const
Return true if the specified key is in the map, false otherwise.
Definition: DenseMap.h:146
Implements a dense probed hash-table based set.
Definition: DenseSet.h:271
const DataLayout & getDataLayout() const
Get the data layout of the module this function belongs to.
Definition: Function.cpp:384
MaybeAlign getFnStackAlign() const
Return the stack alignment for the function.
Definition: Function.h:468
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:903
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1993
DenormalMode getDenormalMode(const fltSemantics &FPType) const
Returns the denormal handling type for the default rounding mode of the function.
Definition: Function.cpp:810
bool needsUnwindTableEntry() const
True if this function needs an unwind table.
Definition: Function.h:680
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:743
bool hasMetadata() const
Return true if this value has any metadata attached to it.
Definition: Value.h:589
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
Definition: Value.h:565
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:656
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:266
This class describes a target machine that is implemented with the LLVM target-independent code gener...
Context object for machine code objects.
Definition: MCContext.h:83
MCSymbol * createTempSymbol()
Create a temporary symbol with a unique name.
Definition: MCContext.cpp:346
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:213
Describe properties that are true of each instruction in the target description file.
Definition: MCInstrDesc.h:198
unsigned getNumRegs() const
Return the number of registers this target has (useful for sizing arrays holding per register informa...
Wrapper class representing physical registers. Should be passed by value.
Definition: MCRegister.h:33
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
Metadata node.
Definition: Metadata.h:1069
void setBBID(const UniqueBBID &V)
Sets the fixed BBID of this basic block.
void setIsEndSection(bool V=true)
instr_iterator insert(instr_iterator I, MachineInstr *M)
Insert MI into the instruction list before I, possibly inside a bundle.
int getNumber() const
MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a MachineFuncti...
const BasicBlock * getBasicBlock() const
Return the LLVM basic block that this instance corresponded to originally.
MBBSectionID getSectionID() const
Returns the section ID of this basic block.
iterator getFirstNonPHI()
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Instructions::const_iterator const_instr_iterator
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
void setIsBeginSection(bool V=true)
This class is a data container for one entry in a MachineConstantPool.
bool needsRelocation() const
This method classifies the entry according to whether or not it may generate a relocation entry.
bool isMachineConstantPoolEntry() const
isMachineConstantPoolEntry - Return true if the MachineConstantPoolEntry is indeed a target specific ...
union llvm::MachineConstantPoolEntry::@204 Val
The constant itself.
unsigned getSizeInBytes(const DataLayout &DL) const
SectionKind getSectionKind(const DataLayout *DL) const
Abstract base class for all machine specific constantpool value subclasses.
virtual unsigned getSizeInBytes(const DataLayout &DL) const
The MachineConstantPool class keeps track of constants referenced by a function which must be spilled...
void dump() const
dump - Call print(cerr) to be called from the debugger.
void print(raw_ostream &OS) const
print - Used by the MachineFunction printer to print information about constant pool objects.
unsigned getConstantPoolIndex(const Constant *C, Align Alignment)
getConstantPoolIndex - Create a new entry in the constant pool or return an existing one.
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
void ensureMaxAlignment(Align Alignment)
Make sure the function is at least Align bytes aligned.
void print(const MachineFunction &MF, raw_ostream &OS) const
Used by the MachineFunction printer to print information about stack objects.
void setUnsafeStackSize(uint64_t Size)
void print(raw_ostream &OS) const
Print the MachineFunctionProperties in human-readable form.
MachineFunctionProperties & set(Property P)
MachineFunctionProperties & reset(Property P)
virtual void MF_HandleChangeDesc(MachineInstr &MI, const MCInstrDesc &TID)
Callback before changing MCInstrDesc.
virtual void MF_HandleRemoval(MachineInstr &MI)=0
Callback before a removal. This should not modify the MI directly.
virtual void MF_HandleInsertion(MachineInstr &MI)=0
Callback after an insertion. This should not modify the MI directly.
MachineInstr::ExtraInfo * createMIExtraInfo(ArrayRef< MachineMemOperand * > MMOs, MCSymbol *PreInstrSymbol=nullptr, MCSymbol *PostInstrSymbol=nullptr, MDNode *HeapAllocMarker=nullptr, MDNode *PCSections=nullptr, uint32_t CFIType=0, MDNode *MMRAs=nullptr)
Allocate and construct an extra info structure for a MachineInstr.
int getFilterIDFor(ArrayRef< unsigned > TyIds)
Return the id of the filter encoded by TyIds. This is function wide.
bool UseDebugInstrRef
Flag for whether this function contains DBG_VALUEs (false) or DBG_INSTR_REF (true).
std::pair< unsigned, unsigned > DebugInstrOperandPair
Pair of instruction number and operand number.
unsigned addFrameInst(const MCCFIInstruction &Inst)
bool useDebugInstrRef() const
Returns true if the function's variable locations are tracked with instruction referencing.
SmallVector< DebugSubstitution, 8 > DebugValueSubstitutions
Debug value substitutions: a collection of DebugSubstitution objects, recording changes in where a va...
unsigned getFunctionNumber() const
getFunctionNumber - Return a unique ID for the current function.
MCSymbol * getPICBaseSymbol() const
getPICBaseSymbol - Return a function-local symbol to represent the PIC base.
void viewCFGOnly() const
viewCFGOnly - This function is meant for use from the debugger.
ArrayRef< int > allocateShuffleMask(ArrayRef< int > Mask)
void substituteDebugValuesForInst(const MachineInstr &Old, MachineInstr &New, unsigned MaxOperand=UINT_MAX)
Create substitutions for any tracked values in Old, to point at New.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MachineInstr & cloneMachineInstrBundle(MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore, const MachineInstr &Orig)
Clones instruction or the whole instruction bundle Orig and insert into MBB before InsertBefore.
MachineJumpTableInfo * getOrCreateJumpTableInfo(unsigned JTEntryKind)
getOrCreateJumpTableInfo - Get the JumpTableInfo for this function, if it does already exist,...
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
void dump() const
dump - Print the current MachineFunction to cerr, useful for debugger use.
MachineInstr * CreateMachineInstr(const MCInstrDesc &MCID, DebugLoc DL, bool NoImplicit=false)
CreateMachineInstr - Allocate a new MachineInstr.
void makeDebugValueSubstitution(DebugInstrOperandPair, DebugInstrOperandPair, unsigned SubReg=0)
Create a substitution between one <instr,operand> value to a different, new value.
MachineMemOperand * getMachineMemOperand(MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, LLT MemTy, Align base_alignment, const AAMDNodes &AAInfo=AAMDNodes(), const MDNode *Ranges=nullptr, SyncScope::ID SSID=SyncScope::System, AtomicOrdering Ordering=AtomicOrdering::NotAtomic, AtomicOrdering FailureOrdering=AtomicOrdering::NotAtomic)
getMachineMemOperand - Allocate a new MachineMemOperand.
bool needsFrameMoves() const
True if this function needs frame moves for debug or exceptions.
unsigned getTypeIDFor(const GlobalValue *TI)
Return the type id for the specified typeinfo. This is function wide.
void finalizeDebugInstrRefs()
Finalise any partially emitted debug instructions.
void deallocateOperandArray(OperandCapacity Cap, MachineOperand *Array)
Dellocate an array of MachineOperands and recycle the memory.
DenormalMode getDenormalMode(const fltSemantics &FPType) const
Returns the denormal handling type for the default rounding mode of the function.
void copyCallSiteInfo(const MachineInstr *Old, const MachineInstr *New)
Copy the call site info from Old to \ New.
void deleteMachineInstr(MachineInstr *MI)
DeleteMachineInstr - Delete the given MachineInstr.
void initTargetMachineFunctionInfo(const TargetSubtargetInfo &STI)
Initialize the target specific MachineFunctionInfo.
const char * createExternalSymbolName(StringRef Name)
Allocate a string and populate it with the given external symbol name.
uint32_t * allocateRegMask()
Allocate and initialize a register mask with NumRegister bits.
MCSymbol * getJTISymbol(unsigned JTI, MCContext &Ctx, bool isLinkerPrivate=false) const
getJTISymbol - Return the MCSymbol for the specified non-empty jump table.
void setCallSiteLandingPad(MCSymbol *Sym, ArrayRef< unsigned > Sites)
Map the landing pad's EH symbol to the call site indexes.
void setUseDebugInstrRef(bool UseInstrRef)
Set whether this function will use instruction referencing or not.
LandingPadInfo & getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad)
Find or create an LandingPadInfo for the specified MachineBasicBlock.
unsigned size() const
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
const DataLayout & getDataLayout() const
Return the DataLayout attached to the Module associated to this MF.
MCSymbol * addLandingPad(MachineBasicBlock *LandingPad)
Add a new panding pad, and extract the exception handling information from the landingpad instruction...
unsigned DebugInstrNumberingCount
A count of how many instructions in the function have had numbers assigned to them.
void deleteMachineBasicBlock(MachineBasicBlock *MBB)
DeleteMachineBasicBlock - Delete the given MachineBasicBlock.
void handleChangeDesc(MachineInstr &MI, const MCInstrDesc &TID)
static const unsigned int DebugOperandMemNumber
A reserved operand number representing the instructions memory operand, for instructions that have a ...
Function & getFunction()
Return the LLVM function that this machine code represents.
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
DebugInstrOperandPair salvageCopySSAImpl(MachineInstr &MI)
const MachineBasicBlock & back() const
BasicBlockListType::iterator iterator
void setDebugInstrNumberingCount(unsigned Num)
Set value of DebugInstrNumberingCount field.
bool shouldSplitStack() const
Should we be emitting segmented stack stuff for the function.
void viewCFG() const
viewCFG - This function is meant for use from the debugger.
bool shouldUseDebugInstrRef() const
Determine whether, in the current machine configuration, we should use instruction referencing or not...
const MachineFunctionProperties & getProperties() const
Get the function properties.
MachineFunction(Function &F, const LLVMTargetMachine &Target, const TargetSubtargetInfo &STI, MCContext &Ctx, unsigned FunctionNum)
MachineInstr * CloneMachineInstr(const MachineInstr *Orig)
Create a new MachineInstr which is a copy of Orig, identical in all ways except the instruction has n...
void eraseCallSiteInfo(const MachineInstr *MI)
Following functions update call site info.
void RenumberBlocks(MachineBasicBlock *MBBFrom=nullptr)
RenumberBlocks - This discards all of the MachineBasicBlock numbers and recomputes them.
const MachineBasicBlock & front() const
Register addLiveIn(MCRegister PReg, const TargetRegisterClass *RC)
addLiveIn - Add the specified physical register as a live-in value and create a corresponding virtual...
void moveCallSiteInfo(const MachineInstr *Old, const MachineInstr *New)
Move the call site info from Old to \New call site info.
void print(raw_ostream &OS, const SlotIndexes *=nullptr) const
print - Print out the MachineFunction in a format suitable for debugging to the specified stream.
void addInvoke(MachineBasicBlock *LandingPad, MCSymbol *BeginLabel, MCSymbol *EndLabel)
Provide the begin and end labels of an invoke style call and associate it with a try landing pad bloc...
MachineBasicBlock * CreateMachineBasicBlock(const BasicBlock *BB=nullptr, std::optional< UniqueBBID > BBID=std::nullopt)
CreateMachineBasicBlock - Allocate a new MachineBasicBlock.
VariableDbgInfoMapTy VariableDbgInfos
void assignBeginEndSections()
Assign IsBeginSection IsEndSection fields for basic blocks in this function.
DebugInstrOperandPair salvageCopySSA(MachineInstr &MI, DenseMap< Register, DebugInstrOperandPair > &DbgPHICache)
Find the underlying defining instruction / operand for a COPY instruction while in SSA form.
Representation of each machine instruction.
Definition: MachineInstr.h:69
void bundleWithPred()
Bundle this instruction with its predecessor.
bool isCopyLike() const
Return true if the instruction behaves like a copy.
unsigned getNumOperands() const
Retuns the total number of operands.
Definition: MachineInstr.h:572
unsigned peekDebugInstrNum() const
Examine the instruction number of this MachineInstr.
Definition: MachineInstr.h:545
bool shouldUpdateCallSiteInfo() const
Return true if copying, moving, or erasing this instruction requires updating Call Site Info (see cop...
unsigned getDebugInstrNum()
Fetch the instruction number of this MachineInstr.
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:579
iterator_range< filtered_mop_iterator > all_defs()
Returns an iterator range over all operands that are (explicit or implicit) register defs.
Definition: MachineInstr.h:756
bool RemoveMBBFromJumpTables(MachineBasicBlock *MBB)
RemoveMBBFromJumpTables - If MBB is present in any jump tables, remove it.
bool ReplaceMBBInJumpTables(MachineBasicBlock *Old, MachineBasicBlock *New)
ReplaceMBBInJumpTables - If Old is the target of any jump tables, update the jump tables to branch to...
void print(raw_ostream &OS) const
print - Used by the MachineFunction printer to print information about jump tables.
unsigned getEntrySize(const DataLayout &TD) const
getEntrySize - Return the size of each entry in the jump table.
unsigned createJumpTableIndex(const std::vector< MachineBasicBlock * > &DestBBs)
createJumpTableIndex - Create a new jump table.
void dump() const
dump - Call to stderr.
bool ReplaceMBBInJumpTable(unsigned Idx, MachineBasicBlock *Old, MachineBasicBlock *New)
ReplaceMBBInJumpTable - If Old is a target of the jump tables, update the jump table to branch to New...
JTEntryKind
JTEntryKind - This enum indicates how each entry of the jump table is represented and emitted.
@ EK_GPRel32BlockAddress
EK_GPRel32BlockAddress - Each entry is an address of block, encoded with a relocation as gp-relative,...
@ EK_Inline
EK_Inline - Jump table entries are emitted inline at their point of use.
@ EK_LabelDifference32
EK_LabelDifference32 - Each entry is the address of the block minus the address of the jump table.
@ EK_Custom32
EK_Custom32 - Each entry is a 32-bit value that is custom lowered by the TargetLowering::LowerCustomJ...
@ EK_LabelDifference64
EK_LabelDifference64 - Each entry is the address of the block minus the address of the jump table.
@ EK_BlockAddress
EK_BlockAddress - Each entry is a plain address of block, e.g.: .word LBB123.
@ EK_GPRel64BlockAddress
EK_GPRel64BlockAddress - Each entry is an address of block, encoded with a relocation as gp-relative,...
unsigned getEntryAlignment(const DataLayout &TD) const
getEntryAlignment - Return the alignment of each entry in the jump table.
JTEntryKind getEntryKind() const
A description of a memory reference used in the backend.
LocationSize getSize() const
Return the size in bytes of the memory reference.
AtomicOrdering getFailureOrdering() const
For cmpxchg atomic operations, return the atomic ordering requirements when store does not occur.
const PseudoSourceValue * getPseudoValue() const
const MDNode * getRanges() const
Return the range tag for the memory reference.
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID for this memory operation.
Flags
Flags values. These may be or'd together.
AtomicOrdering getSuccessOrdering() const
Return the atomic ordering requirements for this memory operation.
const MachinePointerInfo & getPointerInfo() const
Flags getFlags() const
Return the raw flags of the source value,.
AAMDNodes getAAInfo() const
Return the AA tags for the memory reference.
const Value * getValue() const
Return the base address of the memory access.
Align getBaseAlign() const
Return the minimum known alignment in bytes of the base address, without the offset.
int64_t getOffset() const
For normal values, this is a byte offset added to the base address.
MachineOperand class - Representation of each machine instruction operand.
static unsigned getRegMaskSize(unsigned NumRegs)
Returns number of elements needed for a regmask array.
Register getReg() const
getReg - Returns the register number.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
def_instr_iterator def_instr_begin(Register RegNo) const
std::vector< std::pair< MCRegister, Register > >::const_iterator livein_iterator
bool hasOneDef(Register RegNo) const
Return true if there is exactly one operand defining the specified register.
livein_iterator livein_end() const
livein_iterator livein_begin() const
Manage lifetime of a slot tracker for printing IR.
void incorporateFunction(const Function &F)
Incorporate the given function.
Definition: AsmWriter.cpp:903
iterator_range< debug_compile_units_iterator > debug_compile_units() const
Return an iterator for all DICompileUnits listed in this Module's llvm.dbg.cu named metadata node and...
Definition: Module.h:867
bool isNull() const
Test if the pointer held in the union is null, regardless of which type it is.
Definition: PointerUnion.h:142
Simple wrapper around std::function<void(raw_ostream&)>.
Definition: Printable.h:38
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
SectionKind - This is a simple POD value that classifies the properties of a section.
Definition: SectionKind.h:22
static SectionKind getMergeableConst4()
Definition: SectionKind.h:202
static SectionKind getReadOnlyWithRel()
Definition: SectionKind.h:214
static SectionKind getMergeableConst8()
Definition: SectionKind.h:203
static SectionKind getMergeableConst16()
Definition: SectionKind.h:204
static SectionKind getReadOnly()
Definition: SectionKind.h:192
static SectionKind getMergeableConst32()
Definition: SectionKind.h:205
SlotIndexes pass.
Definition: SlotIndexes.h:297
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
void push_back(const T &Elt)
Definition: SmallVector.h:427
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1210
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
bool isStackRealignable() const
isStackRealignable - This method returns whether the stack can be realigned.
Align getStackAlign() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
TargetInstrInfo - Interface to description of machine instruction set.
Align getPrefFunctionAlignment() const
Return the preferred function alignment.
Align getMinFunctionAlignment() const
Return the minimum function alignment.
TargetOptions Options
unsigned ForceDwarfFrameSection
Emit DWARF debug frame section.
bool contains(Register Reg) const
Return true if the specified register is included in this register class.
bool hasSubClassEq(const TargetRegisterClass *RC) const
Returns true if RC is a sub-class of or equal to this class.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
TargetSubtargetInfo - Generic base class for all target subtargets.
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
virtual const TargetFrameLowering * getFrameLowering() const
virtual const TargetInstrInfo * getInstrInfo() const
virtual const TargetLowering * getTargetLowering() const
Target - Wrapper for Target specific information.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
LLVM Value Representation.
Definition: Value.h:74
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Definition: Value.cpp:694
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
self_iterator getIterator()
Definition: ilist_node.h:132
iterator erase(iterator where)
Definition: ilist.h:204
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:661
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:691
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:443
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:480
MachineBasicBlock::instr_iterator getBundleStart(MachineBasicBlock::instr_iterator I)
Returns an iterator to the first instruction in the bundle containing I.
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
Definition: STLExtras.h:2073
MaybeAlign getAlign(const Function &F, unsigned Index)
Printable printJumpTableEntryReference(unsigned Idx)
Prints a jump table entry reference.
bool isScopedEHPersonality(EHPersonality Pers)
Returns true if this personality uses scope-style EH IR instructions: catchswitch,...
auto reverse(ContainerTy &&C)
Definition: STLExtras.h:419
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
MachineBasicBlock::instr_iterator getBundleEnd(MachineBasicBlock::instr_iterator I)
Returns an iterator pointing beyond the bundle containing I.
Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
AtomicOrdering
Atomic ordering for LLVM's memory model.
bool isFuncletEHPersonality(EHPersonality Pers)
Returns true if this is a personality function that invokes handler funclets (which must return to it...
void ViewGraph(const GraphType &G, const Twine &Name, bool ShortNames=false, const Twine &Title="", GraphProgram::Name Program=GraphProgram::DOT)
ViewGraph - Emit a dot graph, run 'dot', run gv on the postscript file, then cleanup.
Definition: GraphWriter.h:427
OutputIt copy(R &&Range, OutputIt Out)
Definition: STLExtras.h:1824
Align commonAlignment(Align A, uint64_t Offset)
Returns the alignment that satisfies both alignments.
Definition: Alignment.h:212
Printable printReg(Register Reg, const TargetRegisterInfo *TRI=nullptr, unsigned SubIdx=0, const MachineRegisterInfo *MRI=nullptr)
Prints virtual and physical registers with or without a TRI instance.
Printable printMBBReference(const MachineBasicBlock &MBB)
Prints a machine basic block reference.
bool debuginfoShouldUseDebugInstrRef(const Triple &T)
#define N
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:760
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
uint64_t value() const
This is a hole in the type system and should not be abused.
Definition: Alignment.h:85
std::string getNodeLabel(const MachineBasicBlock *Node, const MachineFunction *Graph)
static std::string getGraphName(const MachineFunction *F)
DOTGraphTraits - Template class that can be specialized to customize how graphs are converted to 'dot...
DefaultDOTGraphTraits - This class provides the default implementations of all of the DOTGraphTraits ...
Represent subnormal handling kind for floating point instruction inputs and outputs.
This structure is used to retain landing pad info for the current function.
SmallVector< MCSymbol *, 1 > EndLabels
MachineBasicBlock * LandingPadBlock
SmallVector< MCSymbol *, 1 > BeginLabels
std::vector< int > TypeIds
MachineJumpTableEntry - One jump table in the jump table info.
std::vector< MachineBasicBlock * > MBBs
MBBs - The vector of basic blocks from which to create the jump table.
This class contains a discriminated union of information about pointers in memory operands,...
PointerUnion< const Value *, const PseudoSourceValue * > V
This is the IR pointer value for the access, or it is null if unknown.
MachinePointerInfo getWithOffset(int64_t O) const
static void deleteNode(NodeTy *V)
Definition: ilist.h:42