LLVM 19.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,
166 unsigned FunctionNum, MachineModuleInfo &mmi)
167 : F(F), Target(Target), STI(&STI), Ctx(mmi.getContext()), MMI(mmi) {
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 FrameInfo = new (Allocator) MachineFrameInfo(
204 getFnStackAlignment(STI, F), /*StackRealignable=*/CanRealignSP,
205 /*ForcedRealign=*/CanRealignSP &&
206 F.hasFnAttribute(Attribute::StackAlignment));
207
208 setUnsafeStackSize(F, *FrameInfo);
209
210 if (F.hasFnAttribute(Attribute::StackAlignment))
211 FrameInfo->ensureMaxAlignment(*F.getFnStackAlign());
212
214 Alignment = STI->getTargetLowering()->getMinFunctionAlignment();
215
216 // FIXME: Shouldn't use pref alignment if explicit alignment is set on F.
217 // FIXME: Use Function::hasOptSize().
218 if (!F.hasFnAttribute(Attribute::OptimizeForSize))
219 Alignment = std::max(Alignment,
221
222 // -fsanitize=function and -fsanitize=kcfi instrument indirect function calls
223 // to load a type hash before the function label. Ensure functions are aligned
224 // by a least 4 to avoid unaligned access, which is especially important for
225 // -mno-unaligned-access.
226 if (F.hasMetadata(LLVMContext::MD_func_sanitize) ||
227 F.getMetadata(LLVMContext::MD_kcfi_type))
228 Alignment = std::max(Alignment, Align(4));
229
231 Alignment = Align(1ULL << AlignAllFunctions);
232
233 JumpTableInfo = nullptr;
234
236 F.hasPersonalityFn() ? F.getPersonalityFn() : nullptr))) {
237 WinEHInfo = new (Allocator) WinEHFuncInfo();
238 }
239
241 F.hasPersonalityFn() ? F.getPersonalityFn() : nullptr))) {
242 WasmEHInfo = new (Allocator) WasmEHFuncInfo();
243 }
244
245 assert(Target.isCompatibleDataLayout(getDataLayout()) &&
246 "Can't create a MachineFunction using a Module with a "
247 "Target-incompatible DataLayout attached\n");
248
249 PSVManager = std::make_unique<PseudoSourceValueManager>(getTarget());
250}
251
253 const TargetSubtargetInfo &STI) {
254 assert(!MFInfo && "MachineFunctionInfo already set");
255 MFInfo = Target.createMachineFunctionInfo(Allocator, F, &STI);
256}
257
259 clear();
260}
261
262void MachineFunction::clear() {
263 Properties.reset();
264 // Don't call destructors on MachineInstr and MachineOperand. All of their
265 // memory comes from the BumpPtrAllocator which is about to be purged.
266 //
267 // Do call MachineBasicBlock destructors, it contains std::vectors.
268 for (iterator I = begin(), E = end(); I != E; I = BasicBlocks.erase(I))
269 I->Insts.clearAndLeakNodesUnsafely();
270 MBBNumbering.clear();
271
272 InstructionRecycler.clear(Allocator);
273 OperandRecycler.clear(Allocator);
274 BasicBlockRecycler.clear(Allocator);
275 CodeViewAnnotations.clear();
277 if (RegInfo) {
278 RegInfo->~MachineRegisterInfo();
279 Allocator.Deallocate(RegInfo);
280 }
281 if (MFInfo) {
282 MFInfo->~MachineFunctionInfo();
283 Allocator.Deallocate(MFInfo);
284 }
285
286 FrameInfo->~MachineFrameInfo();
287 Allocator.Deallocate(FrameInfo);
288
289 ConstantPool->~MachineConstantPool();
290 Allocator.Deallocate(ConstantPool);
291
292 if (JumpTableInfo) {
293 JumpTableInfo->~MachineJumpTableInfo();
294 Allocator.Deallocate(JumpTableInfo);
295 }
296
297 if (WinEHInfo) {
298 WinEHInfo->~WinEHFuncInfo();
299 Allocator.Deallocate(WinEHInfo);
300 }
301
302 if (WasmEHInfo) {
303 WasmEHInfo->~WasmEHFuncInfo();
304 Allocator.Deallocate(WasmEHInfo);
305 }
306}
307
309 return F.getParent()->getDataLayout();
310}
311
312/// Get the JumpTableInfo for this function.
313/// If it does not already exist, allocate one.
315getOrCreateJumpTableInfo(unsigned EntryKind) {
316 if (JumpTableInfo) return JumpTableInfo;
317
318 JumpTableInfo = new (Allocator)
320 return JumpTableInfo;
321}
322
324 return F.getDenormalMode(FPType);
325}
326
327/// Should we be emitting segmented stack stuff for the function
329 return getFunction().hasFnAttribute("split-stack");
330}
331
332[[nodiscard]] unsigned
334 FrameInstructions.push_back(Inst);
335 return FrameInstructions.size() - 1;
336}
337
338/// This discards all of the MachineBasicBlock numbers and recomputes them.
339/// This guarantees that the MBB numbers are sequential, dense, and match the
340/// ordering of the blocks within the function. If a specific MachineBasicBlock
341/// is specified, only that block and those after it are renumbered.
343 if (empty()) { MBBNumbering.clear(); return; }
345 if (MBB == nullptr)
346 MBBI = begin();
347 else
348 MBBI = MBB->getIterator();
349
350 // Figure out the block number this should have.
351 unsigned BlockNo = 0;
352 if (MBBI != begin())
353 BlockNo = std::prev(MBBI)->getNumber() + 1;
354
355 for (; MBBI != E; ++MBBI, ++BlockNo) {
356 if (MBBI->getNumber() != (int)BlockNo) {
357 // Remove use of the old number.
358 if (MBBI->getNumber() != -1) {
359 assert(MBBNumbering[MBBI->getNumber()] == &*MBBI &&
360 "MBB number mismatch!");
361 MBBNumbering[MBBI->getNumber()] = nullptr;
362 }
363
364 // If BlockNo is already taken, set that block's number to -1.
365 if (MBBNumbering[BlockNo])
366 MBBNumbering[BlockNo]->setNumber(-1);
367
368 MBBNumbering[BlockNo] = &*MBBI;
369 MBBI->setNumber(BlockNo);
370 }
371 }
372
373 // Okay, all the blocks are renumbered. If we have compactified the block
374 // numbering, shrink MBBNumbering now.
375 assert(BlockNo <= MBBNumbering.size() && "Mismatch!");
376 MBBNumbering.resize(BlockNo);
377}
378
379/// This method iterates over the basic blocks and assigns their IsBeginSection
380/// and IsEndSection fields. This must be called after MBB layout is finalized
381/// and the SectionID's are assigned to MBBs.
384 auto CurrentSectionID = front().getSectionID();
385 for (auto MBBI = std::next(begin()), E = end(); MBBI != E; ++MBBI) {
386 if (MBBI->getSectionID() == CurrentSectionID)
387 continue;
389 std::prev(MBBI)->setIsEndSection();
390 CurrentSectionID = MBBI->getSectionID();
391 }
393}
394
395/// Allocate a new MachineInstr. Use this instead of `new MachineInstr'.
397 DebugLoc DL,
398 bool NoImplicit) {
399 return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
400 MachineInstr(*this, MCID, std::move(DL), NoImplicit);
401}
402
403/// Create a new MachineInstr which is a copy of the 'Orig' instruction,
404/// identical in all ways except the instruction has no parent, prev, or next.
407 return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
408 MachineInstr(*this, *Orig);
409}
410
413 const MachineInstr &Orig) {
414 MachineInstr *FirstClone = nullptr;
416 while (true) {
417 MachineInstr *Cloned = CloneMachineInstr(&*I);
418 MBB.insert(InsertBefore, Cloned);
419 if (FirstClone == nullptr) {
420 FirstClone = Cloned;
421 } else {
422 Cloned->bundleWithPred();
423 }
424
425 if (!I->isBundledWithSucc())
426 break;
427 ++I;
428 }
429 // Copy over call site info to the cloned instruction if needed. If Orig is in
430 // a bundle, copyCallSiteInfo takes care of finding the call instruction in
431 // the bundle.
432 if (Orig.shouldUpdateCallSiteInfo())
433 copyCallSiteInfo(&Orig, FirstClone);
434 return *FirstClone;
435}
436
437/// Delete the given MachineInstr.
438///
439/// This function also serves as the MachineInstr destructor - the real
440/// ~MachineInstr() destructor must be empty.
442 // Verify that a call site info is at valid state. This assertion should
443 // be triggered during the implementation of support for the
444 // call site info of a new architecture. If the assertion is triggered,
445 // back trace will tell where to insert a call to updateCallSiteInfo().
446 assert((!MI->isCandidateForCallSiteEntry() || !CallSitesInfo.contains(MI)) &&
447 "Call site info was not updated!");
448 // Strip it for parts. The operand array and the MI object itself are
449 // independently recyclable.
450 if (MI->Operands)
451 deallocateOperandArray(MI->CapOperands, MI->Operands);
452 // Don't call ~MachineInstr() which must be trivial anyway because
453 // ~MachineFunction drops whole lists of MachineInstrs wihout calling their
454 // destructors.
455 InstructionRecycler.Deallocate(Allocator, MI);
456}
457
458/// Allocate a new MachineBasicBlock. Use this instead of
459/// `new MachineBasicBlock'.
462 std::optional<UniqueBBID> BBID) {
464 new (BasicBlockRecycler.Allocate<MachineBasicBlock>(Allocator))
465 MachineBasicBlock(*this, BB);
466 // Set BBID for `-basic-block=sections=labels` and
467 // `-basic-block-sections=list` to allow robust mapping of profiles to basic
468 // blocks.
469 if (Target.getBBSectionsType() == BasicBlockSection::Labels ||
470 Target.Options.BBAddrMap ||
471 Target.getBBSectionsType() == BasicBlockSection::List)
472 MBB->setBBID(BBID.has_value() ? *BBID : UniqueBBID{NextBBID++, 0});
473 return MBB;
474}
475
476/// Delete the given MachineBasicBlock.
478 assert(MBB->getParent() == this && "MBB parent mismatch!");
479 // Clean up any references to MBB in jump tables before deleting it.
480 if (JumpTableInfo)
481 JumpTableInfo->RemoveMBBFromJumpTables(MBB);
482 MBB->~MachineBasicBlock();
483 BasicBlockRecycler.Deallocate(Allocator, MBB);
484}
485
488 Align BaseAlignment, const AAMDNodes &AAInfo, const MDNode *Ranges,
489 SyncScope::ID SSID, AtomicOrdering Ordering,
490 AtomicOrdering FailureOrdering) {
491 assert((!Size.hasValue() ||
492 Size.getValue().getKnownMinValue() != ~UINT64_C(0)) &&
493 "Unexpected an unknown size to be represented using "
494 "LocationSize::beforeOrAfter()");
495 return new (Allocator)
496 MachineMemOperand(PtrInfo, F, Size, BaseAlignment, AAInfo, Ranges, SSID,
497 Ordering, FailureOrdering);
498}
499
502 Align base_alignment, const AAMDNodes &AAInfo, const MDNode *Ranges,
503 SyncScope::ID SSID, AtomicOrdering Ordering,
504 AtomicOrdering FailureOrdering) {
505 return new (Allocator)
506 MachineMemOperand(PtrInfo, f, MemTy, base_alignment, AAInfo, Ranges, SSID,
507 Ordering, FailureOrdering);
508}
509
512 const MachinePointerInfo &PtrInfo,
514 assert((!Size.hasValue() ||
515 Size.getValue().getKnownMinValue() != ~UINT64_C(0)) &&
516 "Unexpected an unknown size to be represented using "
517 "LocationSize::beforeOrAfter()");
518 return new (Allocator)
519 MachineMemOperand(PtrInfo, MMO->getFlags(), Size, MMO->getBaseAlign(),
520 AAMDNodes(), nullptr, MMO->getSyncScopeID(),
522}
523
525 const MachineMemOperand *MMO, const MachinePointerInfo &PtrInfo, LLT Ty) {
526 return new (Allocator)
527 MachineMemOperand(PtrInfo, MMO->getFlags(), Ty, MMO->getBaseAlign(),
528 AAMDNodes(), nullptr, MMO->getSyncScopeID(),
530}
531
534 int64_t Offset, LLT Ty) {
535 const MachinePointerInfo &PtrInfo = MMO->getPointerInfo();
536
537 // If there is no pointer value, the offset isn't tracked so we need to adjust
538 // the base alignment.
539 Align Alignment = PtrInfo.V.isNull()
541 : MMO->getBaseAlign();
542
543 // Do not preserve ranges, since we don't necessarily know what the high bits
544 // are anymore.
545 return new (Allocator) MachineMemOperand(
546 PtrInfo.getWithOffset(Offset), MMO->getFlags(), Ty, Alignment,
547 MMO->getAAInfo(), nullptr, MMO->getSyncScopeID(),
549}
550
553 const AAMDNodes &AAInfo) {
554 MachinePointerInfo MPI = MMO->getValue() ?
555 MachinePointerInfo(MMO->getValue(), MMO->getOffset()) :
557
558 return new (Allocator) MachineMemOperand(
559 MPI, MMO->getFlags(), MMO->getSize(), MMO->getBaseAlign(), AAInfo,
560 MMO->getRanges(), MMO->getSyncScopeID(), MMO->getSuccessOrdering(),
561 MMO->getFailureOrdering());
562}
563
567 return new (Allocator) MachineMemOperand(
568 MMO->getPointerInfo(), Flags, MMO->getSize(), MMO->getBaseAlign(),
569 MMO->getAAInfo(), MMO->getRanges(), MMO->getSyncScopeID(),
571}
572
573MachineInstr::ExtraInfo *MachineFunction::createMIExtraInfo(
574 ArrayRef<MachineMemOperand *> MMOs, MCSymbol *PreInstrSymbol,
575 MCSymbol *PostInstrSymbol, MDNode *HeapAllocMarker, MDNode *PCSections,
576 uint32_t CFIType, MDNode *MMRAs) {
577 return MachineInstr::ExtraInfo::create(Allocator, MMOs, PreInstrSymbol,
578 PostInstrSymbol, HeapAllocMarker,
579 PCSections, CFIType, MMRAs);
580}
581
583 char *Dest = Allocator.Allocate<char>(Name.size() + 1);
584 llvm::copy(Name, Dest);
585 Dest[Name.size()] = 0;
586 return Dest;
587}
588
590 unsigned NumRegs = getSubtarget().getRegisterInfo()->getNumRegs();
591 unsigned Size = MachineOperand::getRegMaskSize(NumRegs);
592 uint32_t *Mask = Allocator.Allocate<uint32_t>(Size);
593 memset(Mask, 0, Size * sizeof(Mask[0]));
594 return Mask;
595}
596
598 int* AllocMask = Allocator.Allocate<int>(Mask.size());
599 copy(Mask, AllocMask);
600 return {AllocMask, Mask.size()};
601}
602
603#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
605 print(dbgs());
606}
607#endif
608
610 return getFunction().getName();
611}
612
613void MachineFunction::print(raw_ostream &OS, const SlotIndexes *Indexes) const {
614 OS << "# Machine code for function " << getName() << ": ";
616 OS << '\n';
617
618 // Print Frame Information
619 FrameInfo->print(*this, OS);
620
621 // Print JumpTable Information
622 if (JumpTableInfo)
623 JumpTableInfo->print(OS);
624
625 // Print Constant Pool
626 ConstantPool->print(OS);
627
629
630 if (RegInfo && !RegInfo->livein_empty()) {
631 OS << "Function Live Ins: ";
633 I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) {
634 OS << printReg(I->first, TRI);
635 if (I->second)
636 OS << " in " << printReg(I->second, TRI);
637 if (std::next(I) != E)
638 OS << ", ";
639 }
640 OS << '\n';
641 }
642
645 for (const auto &BB : *this) {
646 OS << '\n';
647 // If we print the whole function, print it at its most verbose level.
648 BB.print(OS, MST, Indexes, /*IsStandalone=*/true);
649 }
650
651 OS << "\n# End machine code for function " << getName() << ".\n\n";
652}
653
654/// True if this function needs frame moves for debug or exceptions.
656 return getMMI().hasDebugInfo() ||
659}
660
661namespace llvm {
662
663 template<>
666
667 static std::string getGraphName(const MachineFunction *F) {
668 return ("CFG for '" + F->getName() + "' function").str();
669 }
670
671 std::string getNodeLabel(const MachineBasicBlock *Node,
672 const MachineFunction *Graph) {
673 std::string OutStr;
674 {
675 raw_string_ostream OSS(OutStr);
676
677 if (isSimple()) {
678 OSS << printMBBReference(*Node);
679 if (const BasicBlock *BB = Node->getBasicBlock())
680 OSS << ": " << BB->getName();
681 } else
682 Node->print(OSS);
683 }
684
685 if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());
686
687 // Process string output to make it nicer...
688 for (unsigned i = 0; i != OutStr.length(); ++i)
689 if (OutStr[i] == '\n') { // Left justify
690 OutStr[i] = '\\';
691 OutStr.insert(OutStr.begin()+i+1, 'l');
692 }
693 return OutStr;
694 }
695 };
696
697} // end namespace llvm
698
700{
701#ifndef NDEBUG
702 ViewGraph(this, "mf" + getName());
703#else
704 errs() << "MachineFunction::viewCFG is only available in debug builds on "
705 << "systems with Graphviz or gv!\n";
706#endif // NDEBUG
707}
708
710{
711#ifndef NDEBUG
712 ViewGraph(this, "mf" + getName(), true);
713#else
714 errs() << "MachineFunction::viewCFGOnly is only available in debug builds on "
715 << "systems with Graphviz or gv!\n";
716#endif // NDEBUG
717}
718
719/// Add the specified physical register as a live-in value and
720/// create a corresponding virtual register for it.
722 const TargetRegisterClass *RC) {
724 Register VReg = MRI.getLiveInVirtReg(PReg);
725 if (VReg) {
726 const TargetRegisterClass *VRegRC = MRI.getRegClass(VReg);
727 (void)VRegRC;
728 // A physical register can be added several times.
729 // Between two calls, the register class of the related virtual register
730 // may have been constrained to match some operation constraints.
731 // In that case, check that the current register class includes the
732 // physical register and is a sub class of the specified RC.
733 assert((VRegRC == RC || (VRegRC->contains(PReg) &&
734 RC->hasSubClassEq(VRegRC))) &&
735 "Register class mismatch!");
736 return VReg;
737 }
738 VReg = MRI.createVirtualRegister(RC);
739 MRI.addLiveIn(PReg, VReg);
740 return VReg;
741}
742
743/// Return the MCSymbol for the specified non-empty jump table.
744/// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
745/// normal 'L' label is returned.
747 bool isLinkerPrivate) const {
748 const DataLayout &DL = getDataLayout();
749 assert(JumpTableInfo && "No jump tables");
750 assert(JTI < JumpTableInfo->getJumpTables().size() && "Invalid JTI!");
751
752 StringRef Prefix = isLinkerPrivate ? DL.getLinkerPrivateGlobalPrefix()
753 : DL.getPrivateGlobalPrefix();
756 << Prefix << "JTI" << getFunctionNumber() << '_' << JTI;
757 return Ctx.getOrCreateSymbol(Name);
758}
759
760/// Return a function-local symbol to represent the PIC base.
762 const DataLayout &DL = getDataLayout();
763 return Ctx.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) +
764 Twine(getFunctionNumber()) + "$pb");
765}
766
767/// \name Exception Handling
768/// \{
769
772 unsigned N = LandingPads.size();
773 for (unsigned i = 0; i < N; ++i) {
774 LandingPadInfo &LP = LandingPads[i];
775 if (LP.LandingPadBlock == LandingPad)
776 return LP;
777 }
778
779 LandingPads.push_back(LandingPadInfo(LandingPad));
780 return LandingPads[N];
781}
782
784 MCSymbol *BeginLabel, MCSymbol *EndLabel) {
786 LP.BeginLabels.push_back(BeginLabel);
787 LP.EndLabels.push_back(EndLabel);
788}
789
791 MCSymbol *LandingPadLabel = Ctx.createTempSymbol();
793 LP.LandingPadLabel = LandingPadLabel;
794
795 const Instruction *FirstI = LandingPad->getBasicBlock()->getFirstNonPHI();
796 if (const auto *LPI = dyn_cast<LandingPadInst>(FirstI)) {
797 // If there's no typeid list specified, then "cleanup" is implicit.
798 // Otherwise, id 0 is reserved for the cleanup action.
799 if (LPI->isCleanup() && LPI->getNumClauses() != 0)
800 LP.TypeIds.push_back(0);
801
802 // FIXME: New EH - Add the clauses in reverse order. This isn't 100%
803 // correct, but we need to do it this way because of how the DWARF EH
804 // emitter processes the clauses.
805 for (unsigned I = LPI->getNumClauses(); I != 0; --I) {
806 Value *Val = LPI->getClause(I - 1);
807 if (LPI->isCatch(I - 1)) {
808 LP.TypeIds.push_back(
809 getTypeIDFor(dyn_cast<GlobalValue>(Val->stripPointerCasts())));
810 } else {
811 // Add filters in a list.
812 auto *CVal = cast<Constant>(Val);
813 SmallVector<unsigned, 4> FilterList;
814 for (const Use &U : CVal->operands())
815 FilterList.push_back(
816 getTypeIDFor(cast<GlobalValue>(U->stripPointerCasts())));
817
818 LP.TypeIds.push_back(getFilterIDFor(FilterList));
819 }
820 }
821
822 } else if (const auto *CPI = dyn_cast<CatchPadInst>(FirstI)) {
823 for (unsigned I = CPI->arg_size(); I != 0; --I) {
824 auto *TypeInfo =
825 dyn_cast<GlobalValue>(CPI->getArgOperand(I - 1)->stripPointerCasts());
826 LP.TypeIds.push_back(getTypeIDFor(TypeInfo));
827 }
828
829 } else {
830 assert(isa<CleanupPadInst>(FirstI) && "Invalid landingpad!");
831 }
832
833 return LandingPadLabel;
834}
835
837 ArrayRef<unsigned> Sites) {
838 LPadToCallSiteMap[Sym].append(Sites.begin(), Sites.end());
839}
840
842 for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i)
843 if (TypeInfos[i] == TI) return i + 1;
844
845 TypeInfos.push_back(TI);
846 return TypeInfos.size();
847}
848
850 // If the new filter coincides with the tail of an existing filter, then
851 // re-use the existing filter. Folding filters more than this requires
852 // re-ordering filters and/or their elements - probably not worth it.
853 for (unsigned i : FilterEnds) {
854 unsigned j = TyIds.size();
855
856 while (i && j)
857 if (FilterIds[--i] != TyIds[--j])
858 goto try_next;
859
860 if (!j)
861 // The new filter coincides with range [i, end) of the existing filter.
862 return -(1 + i);
863
864try_next:;
865 }
866
867 // Add the new filter.
868 int FilterID = -(1 + FilterIds.size());
869 FilterIds.reserve(FilterIds.size() + TyIds.size() + 1);
870 llvm::append_range(FilterIds, TyIds);
871 FilterEnds.push_back(FilterIds.size());
872 FilterIds.push_back(0); // terminator
873 return FilterID;
874}
875
877MachineFunction::getCallSiteInfo(const MachineInstr *MI) {
878 assert(MI->isCandidateForCallSiteEntry() &&
879 "Call site info refers only to call (MI) candidates");
880
881 if (!Target.Options.EmitCallSiteInfo)
882 return CallSitesInfo.end();
883 return CallSitesInfo.find(MI);
884}
885
886/// Return the call machine instruction or find a call within bundle.
888 if (!MI->isBundle())
889 return MI;
890
891 for (const auto &BMI : make_range(getBundleStart(MI->getIterator()),
892 getBundleEnd(MI->getIterator())))
893 if (BMI.isCandidateForCallSiteEntry())
894 return &BMI;
895
896 llvm_unreachable("Unexpected bundle without a call site candidate");
897}
898
900 assert(MI->shouldUpdateCallSiteInfo() &&
901 "Call site info refers only to call (MI) candidates or "
902 "candidates inside bundles");
903
904 const MachineInstr *CallMI = getCallInstr(MI);
905 CallSiteInfoMap::iterator CSIt = getCallSiteInfo(CallMI);
906 if (CSIt == CallSitesInfo.end())
907 return;
908 CallSitesInfo.erase(CSIt);
909}
910
912 const MachineInstr *New) {
914 "Call site info refers only to call (MI) candidates or "
915 "candidates inside bundles");
916
917 if (!New->isCandidateForCallSiteEntry())
918 return eraseCallSiteInfo(Old);
919
920 const MachineInstr *OldCallMI = getCallInstr(Old);
921 CallSiteInfoMap::iterator CSIt = getCallSiteInfo(OldCallMI);
922 if (CSIt == CallSitesInfo.end())
923 return;
924
925 CallSiteInfo CSInfo = CSIt->second;
926 CallSitesInfo[New] = CSInfo;
927}
928
930 const MachineInstr *New) {
932 "Call site info refers only to call (MI) candidates or "
933 "candidates inside bundles");
934
935 if (!New->isCandidateForCallSiteEntry())
936 return eraseCallSiteInfo(Old);
937
938 const MachineInstr *OldCallMI = getCallInstr(Old);
939 CallSiteInfoMap::iterator CSIt = getCallSiteInfo(OldCallMI);
940 if (CSIt == CallSitesInfo.end())
941 return;
942
943 CallSiteInfo CSInfo = std::move(CSIt->second);
944 CallSitesInfo.erase(CSIt);
945 CallSitesInfo[New] = CSInfo;
946}
947
950}
951
954 unsigned Subreg) {
955 // Catch any accidental self-loops.
956 assert(A.first != B.first);
957 // Don't allow any substitutions _from_ the memory operand number.
958 assert(A.second != DebugOperandMemNumber);
959
960 DebugValueSubstitutions.push_back({A, B, Subreg});
961}
962
964 MachineInstr &New,
965 unsigned MaxOperand) {
966 // If the Old instruction wasn't tracked at all, there is no work to do.
967 unsigned OldInstrNum = Old.peekDebugInstrNum();
968 if (!OldInstrNum)
969 return;
970
971 // Iterate over all operands looking for defs to create substitutions for.
972 // Avoid creating new instr numbers unless we create a new substitution.
973 // While this has no functional effect, it risks confusing someone reading
974 // MIR output.
975 // Examine all the operands, or the first N specified by the caller.
976 MaxOperand = std::min(MaxOperand, Old.getNumOperands());
977 for (unsigned int I = 0; I < MaxOperand; ++I) {
978 const auto &OldMO = Old.getOperand(I);
979 auto &NewMO = New.getOperand(I);
980 (void)NewMO;
981
982 if (!OldMO.isReg() || !OldMO.isDef())
983 continue;
984 assert(NewMO.isDef());
985
986 unsigned NewInstrNum = New.getDebugInstrNum();
987 makeDebugValueSubstitution(std::make_pair(OldInstrNum, I),
988 std::make_pair(NewInstrNum, I));
989 }
990}
991
995 const TargetInstrInfo &TII = *getSubtarget().getInstrInfo();
996
997 // Check whether this copy-like instruction has already been salvaged into
998 // an operand pair.
999 Register Dest;
1000 if (auto CopyDstSrc = TII.isCopyInstr(MI)) {
1001 Dest = CopyDstSrc->Destination->getReg();
1002 } else {
1003 assert(MI.isSubregToReg());
1004 Dest = MI.getOperand(0).getReg();
1005 }
1006
1007 auto CacheIt = DbgPHICache.find(Dest);
1008 if (CacheIt != DbgPHICache.end())
1009 return CacheIt->second;
1010
1011 // Calculate the instruction number to use, or install a DBG_PHI.
1012 auto OperandPair = salvageCopySSAImpl(MI);
1013 DbgPHICache.insert({Dest, OperandPair});
1014 return OperandPair;
1015}
1016
1019 MachineRegisterInfo &MRI = getRegInfo();
1020 const TargetRegisterInfo &TRI = *MRI.getTargetRegisterInfo();
1021 const TargetInstrInfo &TII = *getSubtarget().getInstrInfo();
1022
1023 // Chase the value read by a copy-like instruction back to the instruction
1024 // that ultimately _defines_ that value. This may pass:
1025 // * Through multiple intermediate copies, including subregister moves /
1026 // copies,
1027 // * Copies from physical registers that must then be traced back to the
1028 // defining instruction,
1029 // * Or, physical registers may be live-in to (only) the entry block, which
1030 // requires a DBG_PHI to be created.
1031 // We can pursue this problem in that order: trace back through copies,
1032 // optionally through a physical register, to a defining instruction. We
1033 // should never move from physreg to vreg. As we're still in SSA form, no need
1034 // to worry about partial definitions of registers.
1035
1036 // Helper lambda to interpret a copy-like instruction. Takes instruction,
1037 // returns the register read and any subregister identifying which part is
1038 // read.
1039 auto GetRegAndSubreg =
1040 [&](const MachineInstr &Cpy) -> std::pair<Register, unsigned> {
1041 Register NewReg, OldReg;
1042 unsigned SubReg;
1043 if (Cpy.isCopy()) {
1044 OldReg = Cpy.getOperand(0).getReg();
1045 NewReg = Cpy.getOperand(1).getReg();
1046 SubReg = Cpy.getOperand(1).getSubReg();
1047 } else if (Cpy.isSubregToReg()) {
1048 OldReg = Cpy.getOperand(0).getReg();
1049 NewReg = Cpy.getOperand(2).getReg();
1050 SubReg = Cpy.getOperand(3).getImm();
1051 } else {
1052 auto CopyDetails = *TII.isCopyInstr(Cpy);
1053 const MachineOperand &Src = *CopyDetails.Source;
1054 const MachineOperand &Dest = *CopyDetails.Destination;
1055 OldReg = Dest.getReg();
1056 NewReg = Src.getReg();
1057 SubReg = Src.getSubReg();
1058 }
1059
1060 return {NewReg, SubReg};
1061 };
1062
1063 // First seek either the defining instruction, or a copy from a physreg.
1064 // During search, the current state is the current copy instruction, and which
1065 // register we've read. Accumulate qualifying subregisters into SubregsSeen;
1066 // deal with those later.
1067 auto State = GetRegAndSubreg(MI);
1068 auto CurInst = MI.getIterator();
1069 SmallVector<unsigned, 4> SubregsSeen;
1070 while (true) {
1071 // If we've found a copy from a physreg, first portion of search is over.
1072 if (!State.first.isVirtual())
1073 break;
1074
1075 // Record any subregister qualifier.
1076 if (State.second)
1077 SubregsSeen.push_back(State.second);
1078
1079 assert(MRI.hasOneDef(State.first));
1080 MachineInstr &Inst = *MRI.def_begin(State.first)->getParent();
1081 CurInst = Inst.getIterator();
1082
1083 // Any non-copy instruction is the defining instruction we're seeking.
1084 if (!Inst.isCopyLike() && !TII.isCopyInstr(Inst))
1085 break;
1086 State = GetRegAndSubreg(Inst);
1087 };
1088
1089 // Helper lambda to apply additional subregister substitutions to a known
1090 // instruction/operand pair. Adds new (fake) substitutions so that we can
1091 // record the subregister. FIXME: this isn't very space efficient if multiple
1092 // values are tracked back through the same copies; cache something later.
1093 auto ApplySubregisters =
1095 for (unsigned Subreg : reverse(SubregsSeen)) {
1096 // Fetch a new instruction number, not attached to an actual instruction.
1097 unsigned NewInstrNumber = getNewDebugInstrNum();
1098 // Add a substitution from the "new" number to the known one, with a
1099 // qualifying subreg.
1100 makeDebugValueSubstitution({NewInstrNumber, 0}, P, Subreg);
1101 // Return the new number; to find the underlying value, consumers need to
1102 // deal with the qualifying subreg.
1103 P = {NewInstrNumber, 0};
1104 }
1105 return P;
1106 };
1107
1108 // If we managed to find the defining instruction after COPYs, return an
1109 // instruction / operand pair after adding subregister qualifiers.
1110 if (State.first.isVirtual()) {
1111 // Virtual register def -- we can just look up where this happens.
1112 MachineInstr *Inst = MRI.def_begin(State.first)->getParent();
1113 for (auto &MO : Inst->all_defs()) {
1114 if (MO.getReg() != State.first)
1115 continue;
1116 return ApplySubregisters({Inst->getDebugInstrNum(), MO.getOperandNo()});
1117 }
1118
1119 llvm_unreachable("Vreg def with no corresponding operand?");
1120 }
1121
1122 // Our search ended in a copy from a physreg: walk back up the function
1123 // looking for whatever defines the physreg.
1124 assert(CurInst->isCopyLike() || TII.isCopyInstr(*CurInst));
1125 State = GetRegAndSubreg(*CurInst);
1126 Register RegToSeek = State.first;
1127
1128 auto RMII = CurInst->getReverseIterator();
1129 auto PrevInstrs = make_range(RMII, CurInst->getParent()->instr_rend());
1130 for (auto &ToExamine : PrevInstrs) {
1131 for (auto &MO : ToExamine.all_defs()) {
1132 // Test for operand that defines something aliasing RegToSeek.
1133 if (!TRI.regsOverlap(RegToSeek, MO.getReg()))
1134 continue;
1135
1136 return ApplySubregisters(
1137 {ToExamine.getDebugInstrNum(), MO.getOperandNo()});
1138 }
1139 }
1140
1141 MachineBasicBlock &InsertBB = *CurInst->getParent();
1142
1143 // We reached the start of the block before finding a defining instruction.
1144 // There are numerous scenarios where this can happen:
1145 // * Constant physical registers,
1146 // * Several intrinsics that allow LLVM-IR to read arbitary registers,
1147 // * Arguments in the entry block,
1148 // * Exception handling landing pads.
1149 // Validating all of them is too difficult, so just insert a DBG_PHI reading
1150 // the variable value at this position, rather than checking it makes sense.
1151
1152 // Create DBG_PHI for specified physreg.
1153 auto Builder = BuildMI(InsertBB, InsertBB.getFirstNonPHI(), DebugLoc(),
1154 TII.get(TargetOpcode::DBG_PHI));
1155 Builder.addReg(State.first);
1156 unsigned NewNum = getNewDebugInstrNum();
1157 Builder.addImm(NewNum);
1158 return ApplySubregisters({NewNum, 0u});
1159}
1160
1162 auto *TII = getSubtarget().getInstrInfo();
1163
1164 auto MakeUndefDbgValue = [&](MachineInstr &MI) {
1165 const MCInstrDesc &RefII = TII->get(TargetOpcode::DBG_VALUE_LIST);
1166 MI.setDesc(RefII);
1167 MI.setDebugValueUndef();
1168 };
1169
1171 for (auto &MBB : *this) {
1172 for (auto &MI : MBB) {
1173 if (!MI.isDebugRef())
1174 continue;
1175
1176 bool IsValidRef = true;
1177
1178 for (MachineOperand &MO : MI.debug_operands()) {
1179 if (!MO.isReg())
1180 continue;
1181
1182 Register Reg = MO.getReg();
1183
1184 // Some vregs can be deleted as redundant in the meantime. Mark those
1185 // as DBG_VALUE $noreg. Additionally, some normal instructions are
1186 // quickly deleted, leaving dangling references to vregs with no def.
1187 if (Reg == 0 || !RegInfo->hasOneDef(Reg)) {
1188 IsValidRef = false;
1189 break;
1190 }
1191
1192 assert(Reg.isVirtual());
1193 MachineInstr &DefMI = *RegInfo->def_instr_begin(Reg);
1194
1195 // If we've found a copy-like instruction, follow it back to the
1196 // instruction that defines the source value, see salvageCopySSA docs
1197 // for why this is important.
1198 if (DefMI.isCopyLike() || TII->isCopyInstr(DefMI)) {
1199 auto Result = salvageCopySSA(DefMI, ArgDbgPHIs);
1200 MO.ChangeToDbgInstrRef(Result.first, Result.second);
1201 } else {
1202 // Otherwise, identify the operand number that the VReg refers to.
1203 unsigned OperandIdx = 0;
1204 for (const auto &DefMO : DefMI.operands()) {
1205 if (DefMO.isReg() && DefMO.isDef() && DefMO.getReg() == Reg)
1206 break;
1207 ++OperandIdx;
1208 }
1209 assert(OperandIdx < DefMI.getNumOperands());
1210
1211 // Morph this instr ref to point at the given instruction and operand.
1212 unsigned ID = DefMI.getDebugInstrNum();
1213 MO.ChangeToDbgInstrRef(ID, OperandIdx);
1214 }
1215 }
1216
1217 if (!IsValidRef)
1218 MakeUndefDbgValue(MI);
1219 }
1220 }
1221}
1222
1224 // Disable instr-ref at -O0: it's very slow (in compile time). We can still
1225 // have optimized code inlined into this unoptimized code, however with
1226 // fewer and less aggressive optimizations happening, coverage and accuracy
1227 // should not suffer.
1228 if (getTarget().getOptLevel() == CodeGenOptLevel::None)
1229 return false;
1230
1231 // Don't use instr-ref if this function is marked optnone.
1232 if (F.hasFnAttribute(Attribute::OptimizeNone))
1233 return false;
1234
1235 if (llvm::debuginfoShouldUseDebugInstrRef(getTarget().getTargetTriple()))
1236 return true;
1237
1238 return false;
1239}
1240
1242 return UseDebugInstrRef;
1243}
1244
1247}
1248
1249// Use one million as a high / reserved number.
1250const unsigned MachineFunction::DebugOperandMemNumber = 1000000;
1251
1252/// \}
1253
1254//===----------------------------------------------------------------------===//
1255// MachineJumpTableInfo implementation
1256//===----------------------------------------------------------------------===//
1257
1258/// Return the size of each entry in the jump table.
1260 // The size of a jump table entry is 4 bytes unless the entry is just the
1261 // address of a block, in which case it is the pointer size.
1262 switch (getEntryKind()) {
1264 return TD.getPointerSize();
1267 return 8;
1271 return 4;
1273 return 0;
1274 }
1275 llvm_unreachable("Unknown jump table encoding!");
1276}
1277
1278/// Return the alignment of each entry in the jump table.
1280 // The alignment of a jump table entry is the alignment of int32 unless the
1281 // entry is just the address of a block, in which case it is the pointer
1282 // alignment.
1283 switch (getEntryKind()) {
1285 return TD.getPointerABIAlignment(0).value();
1288 return TD.getABIIntegerTypeAlignment(64).value();
1292 return TD.getABIIntegerTypeAlignment(32).value();
1294 return 1;
1295 }
1296 llvm_unreachable("Unknown jump table encoding!");
1297}
1298
1299/// Create a new jump table entry in the jump table info.
1301 const std::vector<MachineBasicBlock*> &DestBBs) {
1302 assert(!DestBBs.empty() && "Cannot create an empty jump table!");
1303 JumpTables.push_back(MachineJumpTableEntry(DestBBs));
1304 return JumpTables.size()-1;
1305}
1306
1307/// If Old is the target of any jump tables, update the jump tables to branch
1308/// to New instead.
1310 MachineBasicBlock *New) {
1311 assert(Old != New && "Not making a change?");
1312 bool MadeChange = false;
1313 for (size_t i = 0, e = JumpTables.size(); i != e; ++i)
1314 ReplaceMBBInJumpTable(i, Old, New);
1315 return MadeChange;
1316}
1317
1318/// If MBB is present in any jump tables, remove it.
1320 bool MadeChange = false;
1321 for (MachineJumpTableEntry &JTE : JumpTables) {
1322 auto removeBeginItr = std::remove(JTE.MBBs.begin(), JTE.MBBs.end(), MBB);
1323 MadeChange |= (removeBeginItr != JTE.MBBs.end());
1324 JTE.MBBs.erase(removeBeginItr, JTE.MBBs.end());
1325 }
1326 return MadeChange;
1327}
1328
1329/// If Old is a target of the jump tables, update the jump table to branch to
1330/// New instead.
1332 MachineBasicBlock *Old,
1333 MachineBasicBlock *New) {
1334 assert(Old != New && "Not making a change?");
1335 bool MadeChange = false;
1336 MachineJumpTableEntry &JTE = JumpTables[Idx];
1337 for (MachineBasicBlock *&MBB : JTE.MBBs)
1338 if (MBB == Old) {
1339 MBB = New;
1340 MadeChange = true;
1341 }
1342 return MadeChange;
1343}
1344
1346 if (JumpTables.empty()) return;
1347
1348 OS << "Jump Tables:\n";
1349
1350 for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) {
1351 OS << printJumpTableEntryReference(i) << ':';
1352 for (const MachineBasicBlock *MBB : JumpTables[i].MBBs)
1353 OS << ' ' << printMBBReference(*MBB);
1354 if (i != e)
1355 OS << '\n';
1356 }
1357
1358 OS << '\n';
1359}
1360
1361#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1363#endif
1364
1366 return Printable([Idx](raw_ostream &OS) { OS << "%jump-table." << Idx; });
1367}
1368
1369//===----------------------------------------------------------------------===//
1370// MachineConstantPool implementation
1371//===----------------------------------------------------------------------===//
1372
1373void MachineConstantPoolValue::anchor() {}
1374
1376 return DL.getTypeAllocSize(Ty);
1377}
1378
1381 return Val.MachineCPVal->getSizeInBytes(DL);
1382 return DL.getTypeAllocSize(Val.ConstVal->getType());
1383}
1384
1387 return true;
1388 return Val.ConstVal->needsDynamicRelocation();
1389}
1390
1393 if (needsRelocation())
1395 switch (getSizeInBytes(*DL)) {
1396 case 4:
1398 case 8:
1400 case 16:
1402 case 32:
1404 default:
1405 return SectionKind::getReadOnly();
1406 }
1407}
1408
1410 // A constant may be a member of both Constants and MachineCPVsSharingEntries,
1411 // so keep track of which we've deleted to avoid double deletions.
1413 for (const MachineConstantPoolEntry &C : Constants)
1414 if (C.isMachineConstantPoolEntry()) {
1415 Deleted.insert(C.Val.MachineCPVal);
1416 delete C.Val.MachineCPVal;
1417 }
1418 for (MachineConstantPoolValue *CPV : MachineCPVsSharingEntries) {
1419 if (Deleted.count(CPV) == 0)
1420 delete CPV;
1421 }
1422}
1423
1424/// Test whether the given two constants can be allocated the same constant pool
1425/// entry referenced by \param A.
1426static bool CanShareConstantPoolEntry(const Constant *A, const Constant *B,
1427 const DataLayout &DL) {
1428 // Handle the trivial case quickly.
1429 if (A == B) return true;
1430
1431 // If they have the same type but weren't the same constant, quickly
1432 // reject them.
1433 if (A->getType() == B->getType()) return false;
1434
1435 // We can't handle structs or arrays.
1436 if (isa<StructType>(A->getType()) || isa<ArrayType>(A->getType()) ||
1437 isa<StructType>(B->getType()) || isa<ArrayType>(B->getType()))
1438 return false;
1439
1440 // For now, only support constants with the same size.
1441 uint64_t StoreSize = DL.getTypeStoreSize(A->getType());
1442 if (StoreSize != DL.getTypeStoreSize(B->getType()) || StoreSize > 128)
1443 return false;
1444
1445 bool ContainsUndefOrPoisonA = A->containsUndefOrPoisonElement();
1446
1447 Type *IntTy = IntegerType::get(A->getContext(), StoreSize*8);
1448
1449 // Try constant folding a bitcast of both instructions to an integer. If we
1450 // get two identical ConstantInt's, then we are good to share them. We use
1451 // the constant folding APIs to do this so that we get the benefit of
1452 // DataLayout.
1453 if (isa<PointerType>(A->getType()))
1454 A = ConstantFoldCastOperand(Instruction::PtrToInt,
1455 const_cast<Constant *>(A), IntTy, DL);
1456 else if (A->getType() != IntTy)
1457 A = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(A),
1458 IntTy, DL);
1459 if (isa<PointerType>(B->getType()))
1460 B = ConstantFoldCastOperand(Instruction::PtrToInt,
1461 const_cast<Constant *>(B), IntTy, DL);
1462 else if (B->getType() != IntTy)
1463 B = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(B),
1464 IntTy, DL);
1465
1466 if (A != B)
1467 return false;
1468
1469 // Constants only safely match if A doesn't contain undef/poison.
1470 // As we'll be reusing A, it doesn't matter if B contain undef/poison.
1471 // TODO: Handle cases where A and B have the same undef/poison elements.
1472 // TODO: Merge A and B with mismatching undef/poison elements.
1473 return !ContainsUndefOrPoisonA;
1474}
1475
1476/// Create a new entry in the constant pool or return an existing one.
1477/// User must specify the log2 of the minimum required alignment for the object.
1479 Align Alignment) {
1480 if (Alignment > PoolAlignment) PoolAlignment = Alignment;
1481
1482 // Check to see if we already have this constant.
1483 //
1484 // FIXME, this could be made much more efficient for large constant pools.
1485 for (unsigned i = 0, e = Constants.size(); i != e; ++i)
1486 if (!Constants[i].isMachineConstantPoolEntry() &&
1487 CanShareConstantPoolEntry(Constants[i].Val.ConstVal, C, DL)) {
1488 if (Constants[i].getAlign() < Alignment)
1489 Constants[i].Alignment = Alignment;
1490 return i;
1491 }
1492
1493 Constants.push_back(MachineConstantPoolEntry(C, Alignment));
1494 return Constants.size()-1;
1495}
1496
1498 Align Alignment) {
1499 if (Alignment > PoolAlignment) PoolAlignment = Alignment;
1500
1501 // Check to see if we already have this constant.
1502 //
1503 // FIXME, this could be made much more efficient for large constant pools.
1504 int Idx = V->getExistingMachineCPValue(this, Alignment);
1505 if (Idx != -1) {
1506 MachineCPVsSharingEntries.insert(V);
1507 return (unsigned)Idx;
1508 }
1509
1510 Constants.push_back(MachineConstantPoolEntry(V, Alignment));
1511 return Constants.size()-1;
1512}
1513
1515 if (Constants.empty()) return;
1516
1517 OS << "Constant Pool:\n";
1518 for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
1519 OS << " cp#" << i << ": ";
1520 if (Constants[i].isMachineConstantPoolEntry())
1521 Constants[i].Val.MachineCPVal->print(OS);
1522 else
1523 Constants[i].Val.ConstVal->printAsOperand(OS, /*PrintType=*/false);
1524 OS << ", align=" << Constants[i].getAlign().value();
1525 OS << "\n";
1526 }
1527}
1528
1529//===----------------------------------------------------------------------===//
1530// Template specialization for MachineFunction implementation of
1531// ProfileSummaryInfo::getEntryCount().
1532//===----------------------------------------------------------------------===//
1533template <>
1534std::optional<Function::ProfileCount>
1535ProfileSummaryInfo::getEntryCount<llvm::MachineFunction>(
1536 const llvm::MachineFunction *F) const {
1537 return F->getFunction().getEntryCount();
1538}
1539
1540#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1542#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:60
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:360
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:223
This is an important base class in LLVM.
Definition: Constant.h:41
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:110
Align getABIIntegerTypeAlignment(unsigned BitWidth) const
Returns the minimum ABI-required alignment for an integer type of the specified bitwidth.
Definition: DataLayout.h:533
unsigned getPointerSize(unsigned AS=0) const
Layout pointer size in bytes, rounded up to a whole number of bytes.
Definition: DataLayout.cpp:750
Align getPointerABIAlignment(unsigned AS) const
Layout pointer alignment.
Definition: DataLayout.cpp:742
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:329
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:145
Implements a dense probed hash-table based set.
Definition: DenseSet.h:271
MaybeAlign getFnStackAlign() const
Return the stack alignment for the function.
Definition: Function.h:451
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:855
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1919
DenormalMode getDenormalMode(const fltSemantics &FPType) const
Returns the denormal handling type for the default rounding mode of the function.
Definition: Function.cpp:742
bool needsUnwindTableEntry() const
True if this function needs an unwind table.
Definition: Function.h:660
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:675
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:655
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:278
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:81
MCSymbol * createTempSymbol()
Create a temporary symbol with a unique name.
Definition: MCContext.cpp:322
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:201
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:40
Metadata node.
Definition: Metadata.h:1067
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::@196 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.
MCContext & getContext() const
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
MachineModuleInfo & getMMI() 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.
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.
MachineFunction(Function &F, const LLVMTargetMachine &Target, const TargetSubtargetInfo &STI, unsigned FunctionNum, MachineModuleInfo &MMI)
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:567
unsigned peekDebugInstrNum() const
Examine the instruction number of this MachineInstr.
Definition: MachineInstr.h:540
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:574
iterator_range< filtered_mop_iterator > all_defs()
Returns an iterator range over all operands that are (explicit or implicit) register defs.
Definition: MachineInstr.h:751
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.
This class contains meta information specific to a module.
bool hasDebugInfo() const
Returns true if valid debug info is present.
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:899
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.h:293
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:300
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:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
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:693
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
self_iterator getIterator()
Definition: ilist_node.h:109
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:660
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:690
#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:450
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
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