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 base_alignment, const AAMDNodes &AAInfo, const MDNode *Ranges,
489 SyncScope::ID SSID, AtomicOrdering Ordering,
490 AtomicOrdering FailureOrdering) {
491 return new (Allocator)
492 MachineMemOperand(PtrInfo, f, s, base_alignment, AAInfo, Ranges,
493 SSID, Ordering, FailureOrdering);
494}
495
498 Align base_alignment, const AAMDNodes &AAInfo, const MDNode *Ranges,
499 SyncScope::ID SSID, AtomicOrdering Ordering,
500 AtomicOrdering FailureOrdering) {
501 return new (Allocator)
502 MachineMemOperand(PtrInfo, f, MemTy, base_alignment, AAInfo, Ranges, SSID,
503 Ordering, FailureOrdering);
504}
505
507 const MachineMemOperand *MMO, const MachinePointerInfo &PtrInfo, uint64_t Size) {
508 return new (Allocator)
509 MachineMemOperand(PtrInfo, MMO->getFlags(), Size, MMO->getBaseAlign(),
510 AAMDNodes(), nullptr, MMO->getSyncScopeID(),
512}
513
515 const MachineMemOperand *MMO, const MachinePointerInfo &PtrInfo, LLT Ty) {
516 return new (Allocator)
517 MachineMemOperand(PtrInfo, MMO->getFlags(), Ty, MMO->getBaseAlign(),
518 AAMDNodes(), nullptr, MMO->getSyncScopeID(),
520}
521
524 int64_t Offset, LLT Ty) {
525 const MachinePointerInfo &PtrInfo = MMO->getPointerInfo();
526
527 // If there is no pointer value, the offset isn't tracked so we need to adjust
528 // the base alignment.
529 Align Alignment = PtrInfo.V.isNull()
531 : MMO->getBaseAlign();
532
533 // Do not preserve ranges, since we don't necessarily know what the high bits
534 // are anymore.
535 return new (Allocator) MachineMemOperand(
536 PtrInfo.getWithOffset(Offset), MMO->getFlags(), Ty, Alignment,
537 MMO->getAAInfo(), nullptr, MMO->getSyncScopeID(),
539}
540
543 const AAMDNodes &AAInfo) {
544 MachinePointerInfo MPI = MMO->getValue() ?
545 MachinePointerInfo(MMO->getValue(), MMO->getOffset()) :
547
548 return new (Allocator) MachineMemOperand(
549 MPI, MMO->getFlags(), MMO->getSize(), MMO->getBaseAlign(), AAInfo,
550 MMO->getRanges(), MMO->getSyncScopeID(), MMO->getSuccessOrdering(),
551 MMO->getFailureOrdering());
552}
553
557 return new (Allocator) MachineMemOperand(
558 MMO->getPointerInfo(), Flags, MMO->getSize(), MMO->getBaseAlign(),
559 MMO->getAAInfo(), MMO->getRanges(), MMO->getSyncScopeID(),
561}
562
563MachineInstr::ExtraInfo *MachineFunction::createMIExtraInfo(
564 ArrayRef<MachineMemOperand *> MMOs, MCSymbol *PreInstrSymbol,
565 MCSymbol *PostInstrSymbol, MDNode *HeapAllocMarker, MDNode *PCSections,
566 uint32_t CFIType) {
567 return MachineInstr::ExtraInfo::create(Allocator, MMOs, PreInstrSymbol,
568 PostInstrSymbol, HeapAllocMarker,
569 PCSections, CFIType);
570}
571
573 char *Dest = Allocator.Allocate<char>(Name.size() + 1);
574 llvm::copy(Name, Dest);
575 Dest[Name.size()] = 0;
576 return Dest;
577}
578
580 unsigned NumRegs = getSubtarget().getRegisterInfo()->getNumRegs();
581 unsigned Size = MachineOperand::getRegMaskSize(NumRegs);
582 uint32_t *Mask = Allocator.Allocate<uint32_t>(Size);
583 memset(Mask, 0, Size * sizeof(Mask[0]));
584 return Mask;
585}
586
588 int* AllocMask = Allocator.Allocate<int>(Mask.size());
589 copy(Mask, AllocMask);
590 return {AllocMask, Mask.size()};
591}
592
593#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
595 print(dbgs());
596}
597#endif
598
600 return getFunction().getName();
601}
602
603void MachineFunction::print(raw_ostream &OS, const SlotIndexes *Indexes) const {
604 OS << "# Machine code for function " << getName() << ": ";
606 OS << '\n';
607
608 // Print Frame Information
609 FrameInfo->print(*this, OS);
610
611 // Print JumpTable Information
612 if (JumpTableInfo)
613 JumpTableInfo->print(OS);
614
615 // Print Constant Pool
616 ConstantPool->print(OS);
617
619
620 if (RegInfo && !RegInfo->livein_empty()) {
621 OS << "Function Live Ins: ";
623 I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) {
624 OS << printReg(I->first, TRI);
625 if (I->second)
626 OS << " in " << printReg(I->second, TRI);
627 if (std::next(I) != E)
628 OS << ", ";
629 }
630 OS << '\n';
631 }
632
635 for (const auto &BB : *this) {
636 OS << '\n';
637 // If we print the whole function, print it at its most verbose level.
638 BB.print(OS, MST, Indexes, /*IsStandalone=*/true);
639 }
640
641 OS << "\n# End machine code for function " << getName() << ".\n\n";
642}
643
644/// True if this function needs frame moves for debug or exceptions.
646 return getMMI().hasDebugInfo() ||
649}
650
651namespace llvm {
652
653 template<>
656
657 static std::string getGraphName(const MachineFunction *F) {
658 return ("CFG for '" + F->getName() + "' function").str();
659 }
660
661 std::string getNodeLabel(const MachineBasicBlock *Node,
662 const MachineFunction *Graph) {
663 std::string OutStr;
664 {
665 raw_string_ostream OSS(OutStr);
666
667 if (isSimple()) {
668 OSS << printMBBReference(*Node);
669 if (const BasicBlock *BB = Node->getBasicBlock())
670 OSS << ": " << BB->getName();
671 } else
672 Node->print(OSS);
673 }
674
675 if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());
676
677 // Process string output to make it nicer...
678 for (unsigned i = 0; i != OutStr.length(); ++i)
679 if (OutStr[i] == '\n') { // Left justify
680 OutStr[i] = '\\';
681 OutStr.insert(OutStr.begin()+i+1, 'l');
682 }
683 return OutStr;
684 }
685 };
686
687} // end namespace llvm
688
690{
691#ifndef NDEBUG
692 ViewGraph(this, "mf" + getName());
693#else
694 errs() << "MachineFunction::viewCFG is only available in debug builds on "
695 << "systems with Graphviz or gv!\n";
696#endif // NDEBUG
697}
698
700{
701#ifndef NDEBUG
702 ViewGraph(this, "mf" + getName(), true);
703#else
704 errs() << "MachineFunction::viewCFGOnly is only available in debug builds on "
705 << "systems with Graphviz or gv!\n";
706#endif // NDEBUG
707}
708
709/// Add the specified physical register as a live-in value and
710/// create a corresponding virtual register for it.
712 const TargetRegisterClass *RC) {
714 Register VReg = MRI.getLiveInVirtReg(PReg);
715 if (VReg) {
716 const TargetRegisterClass *VRegRC = MRI.getRegClass(VReg);
717 (void)VRegRC;
718 // A physical register can be added several times.
719 // Between two calls, the register class of the related virtual register
720 // may have been constrained to match some operation constraints.
721 // In that case, check that the current register class includes the
722 // physical register and is a sub class of the specified RC.
723 assert((VRegRC == RC || (VRegRC->contains(PReg) &&
724 RC->hasSubClassEq(VRegRC))) &&
725 "Register class mismatch!");
726 return VReg;
727 }
728 VReg = MRI.createVirtualRegister(RC);
729 MRI.addLiveIn(PReg, VReg);
730 return VReg;
731}
732
733/// Return the MCSymbol for the specified non-empty jump table.
734/// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
735/// normal 'L' label is returned.
737 bool isLinkerPrivate) const {
738 const DataLayout &DL = getDataLayout();
739 assert(JumpTableInfo && "No jump tables");
740 assert(JTI < JumpTableInfo->getJumpTables().size() && "Invalid JTI!");
741
742 StringRef Prefix = isLinkerPrivate ? DL.getLinkerPrivateGlobalPrefix()
743 : DL.getPrivateGlobalPrefix();
746 << Prefix << "JTI" << getFunctionNumber() << '_' << JTI;
747 return Ctx.getOrCreateSymbol(Name);
748}
749
750/// Return a function-local symbol to represent the PIC base.
752 const DataLayout &DL = getDataLayout();
753 return Ctx.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) +
754 Twine(getFunctionNumber()) + "$pb");
755}
756
757/// \name Exception Handling
758/// \{
759
762 unsigned N = LandingPads.size();
763 for (unsigned i = 0; i < N; ++i) {
764 LandingPadInfo &LP = LandingPads[i];
765 if (LP.LandingPadBlock == LandingPad)
766 return LP;
767 }
768
769 LandingPads.push_back(LandingPadInfo(LandingPad));
770 return LandingPads[N];
771}
772
774 MCSymbol *BeginLabel, MCSymbol *EndLabel) {
776 LP.BeginLabels.push_back(BeginLabel);
777 LP.EndLabels.push_back(EndLabel);
778}
779
781 MCSymbol *LandingPadLabel = Ctx.createTempSymbol();
783 LP.LandingPadLabel = LandingPadLabel;
784
785 const Instruction *FirstI = LandingPad->getBasicBlock()->getFirstNonPHI();
786 if (const auto *LPI = dyn_cast<LandingPadInst>(FirstI)) {
787 // If there's no typeid list specified, then "cleanup" is implicit.
788 // Otherwise, id 0 is reserved for the cleanup action.
789 if (LPI->isCleanup() && LPI->getNumClauses() != 0)
790 LP.TypeIds.push_back(0);
791
792 // FIXME: New EH - Add the clauses in reverse order. This isn't 100%
793 // correct, but we need to do it this way because of how the DWARF EH
794 // emitter processes the clauses.
795 for (unsigned I = LPI->getNumClauses(); I != 0; --I) {
796 Value *Val = LPI->getClause(I - 1);
797 if (LPI->isCatch(I - 1)) {
798 LP.TypeIds.push_back(
799 getTypeIDFor(dyn_cast<GlobalValue>(Val->stripPointerCasts())));
800 } else {
801 // Add filters in a list.
802 auto *CVal = cast<Constant>(Val);
803 SmallVector<unsigned, 4> FilterList;
804 for (const Use &U : CVal->operands())
805 FilterList.push_back(
806 getTypeIDFor(cast<GlobalValue>(U->stripPointerCasts())));
807
808 LP.TypeIds.push_back(getFilterIDFor(FilterList));
809 }
810 }
811
812 } else if (const auto *CPI = dyn_cast<CatchPadInst>(FirstI)) {
813 for (unsigned I = CPI->arg_size(); I != 0; --I) {
814 auto *TypeInfo =
815 dyn_cast<GlobalValue>(CPI->getArgOperand(I - 1)->stripPointerCasts());
816 LP.TypeIds.push_back(getTypeIDFor(TypeInfo));
817 }
818
819 } else {
820 assert(isa<CleanupPadInst>(FirstI) && "Invalid landingpad!");
821 }
822
823 return LandingPadLabel;
824}
825
827 ArrayRef<unsigned> Sites) {
828 LPadToCallSiteMap[Sym].append(Sites.begin(), Sites.end());
829}
830
832 for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i)
833 if (TypeInfos[i] == TI) return i + 1;
834
835 TypeInfos.push_back(TI);
836 return TypeInfos.size();
837}
838
840 // If the new filter coincides with the tail of an existing filter, then
841 // re-use the existing filter. Folding filters more than this requires
842 // re-ordering filters and/or their elements - probably not worth it.
843 for (unsigned i : FilterEnds) {
844 unsigned j = TyIds.size();
845
846 while (i && j)
847 if (FilterIds[--i] != TyIds[--j])
848 goto try_next;
849
850 if (!j)
851 // The new filter coincides with range [i, end) of the existing filter.
852 return -(1 + i);
853
854try_next:;
855 }
856
857 // Add the new filter.
858 int FilterID = -(1 + FilterIds.size());
859 FilterIds.reserve(FilterIds.size() + TyIds.size() + 1);
860 llvm::append_range(FilterIds, TyIds);
861 FilterEnds.push_back(FilterIds.size());
862 FilterIds.push_back(0); // terminator
863 return FilterID;
864}
865
867MachineFunction::getCallSiteInfo(const MachineInstr *MI) {
868 assert(MI->isCandidateForCallSiteEntry() &&
869 "Call site info refers only to call (MI) candidates");
870
871 if (!Target.Options.EmitCallSiteInfo)
872 return CallSitesInfo.end();
873 return CallSitesInfo.find(MI);
874}
875
876/// Return the call machine instruction or find a call within bundle.
878 if (!MI->isBundle())
879 return MI;
880
881 for (const auto &BMI : make_range(getBundleStart(MI->getIterator()),
882 getBundleEnd(MI->getIterator())))
883 if (BMI.isCandidateForCallSiteEntry())
884 return &BMI;
885
886 llvm_unreachable("Unexpected bundle without a call site candidate");
887}
888
890 assert(MI->shouldUpdateCallSiteInfo() &&
891 "Call site info refers only to call (MI) candidates or "
892 "candidates inside bundles");
893
894 const MachineInstr *CallMI = getCallInstr(MI);
895 CallSiteInfoMap::iterator CSIt = getCallSiteInfo(CallMI);
896 if (CSIt == CallSitesInfo.end())
897 return;
898 CallSitesInfo.erase(CSIt);
899}
900
902 const MachineInstr *New) {
904 "Call site info refers only to call (MI) candidates or "
905 "candidates inside bundles");
906
907 if (!New->isCandidateForCallSiteEntry())
908 return eraseCallSiteInfo(Old);
909
910 const MachineInstr *OldCallMI = getCallInstr(Old);
911 CallSiteInfoMap::iterator CSIt = getCallSiteInfo(OldCallMI);
912 if (CSIt == CallSitesInfo.end())
913 return;
914
915 CallSiteInfo CSInfo = CSIt->second;
916 CallSitesInfo[New] = CSInfo;
917}
918
920 const MachineInstr *New) {
922 "Call site info refers only to call (MI) candidates or "
923 "candidates inside bundles");
924
925 if (!New->isCandidateForCallSiteEntry())
926 return eraseCallSiteInfo(Old);
927
928 const MachineInstr *OldCallMI = getCallInstr(Old);
929 CallSiteInfoMap::iterator CSIt = getCallSiteInfo(OldCallMI);
930 if (CSIt == CallSitesInfo.end())
931 return;
932
933 CallSiteInfo CSInfo = std::move(CSIt->second);
934 CallSitesInfo.erase(CSIt);
935 CallSitesInfo[New] = CSInfo;
936}
937
940}
941
944 unsigned Subreg) {
945 // Catch any accidental self-loops.
946 assert(A.first != B.first);
947 // Don't allow any substitutions _from_ the memory operand number.
948 assert(A.second != DebugOperandMemNumber);
949
950 DebugValueSubstitutions.push_back({A, B, Subreg});
951}
952
954 MachineInstr &New,
955 unsigned MaxOperand) {
956 // If the Old instruction wasn't tracked at all, there is no work to do.
957 unsigned OldInstrNum = Old.peekDebugInstrNum();
958 if (!OldInstrNum)
959 return;
960
961 // Iterate over all operands looking for defs to create substitutions for.
962 // Avoid creating new instr numbers unless we create a new substitution.
963 // While this has no functional effect, it risks confusing someone reading
964 // MIR output.
965 // Examine all the operands, or the first N specified by the caller.
966 MaxOperand = std::min(MaxOperand, Old.getNumOperands());
967 for (unsigned int I = 0; I < MaxOperand; ++I) {
968 const auto &OldMO = Old.getOperand(I);
969 auto &NewMO = New.getOperand(I);
970 (void)NewMO;
971
972 if (!OldMO.isReg() || !OldMO.isDef())
973 continue;
974 assert(NewMO.isDef());
975
976 unsigned NewInstrNum = New.getDebugInstrNum();
977 makeDebugValueSubstitution(std::make_pair(OldInstrNum, I),
978 std::make_pair(NewInstrNum, I));
979 }
980}
981
985 const TargetInstrInfo &TII = *getSubtarget().getInstrInfo();
986
987 // Check whether this copy-like instruction has already been salvaged into
988 // an operand pair.
989 Register Dest;
990 if (auto CopyDstSrc = TII.isCopyInstr(MI)) {
991 Dest = CopyDstSrc->Destination->getReg();
992 } else {
993 assert(MI.isSubregToReg());
994 Dest = MI.getOperand(0).getReg();
995 }
996
997 auto CacheIt = DbgPHICache.find(Dest);
998 if (CacheIt != DbgPHICache.end())
999 return CacheIt->second;
1000
1001 // Calculate the instruction number to use, or install a DBG_PHI.
1002 auto OperandPair = salvageCopySSAImpl(MI);
1003 DbgPHICache.insert({Dest, OperandPair});
1004 return OperandPair;
1005}
1006
1009 MachineRegisterInfo &MRI = getRegInfo();
1010 const TargetRegisterInfo &TRI = *MRI.getTargetRegisterInfo();
1011 const TargetInstrInfo &TII = *getSubtarget().getInstrInfo();
1012
1013 // Chase the value read by a copy-like instruction back to the instruction
1014 // that ultimately _defines_ that value. This may pass:
1015 // * Through multiple intermediate copies, including subregister moves /
1016 // copies,
1017 // * Copies from physical registers that must then be traced back to the
1018 // defining instruction,
1019 // * Or, physical registers may be live-in to (only) the entry block, which
1020 // requires a DBG_PHI to be created.
1021 // We can pursue this problem in that order: trace back through copies,
1022 // optionally through a physical register, to a defining instruction. We
1023 // should never move from physreg to vreg. As we're still in SSA form, no need
1024 // to worry about partial definitions of registers.
1025
1026 // Helper lambda to interpret a copy-like instruction. Takes instruction,
1027 // returns the register read and any subregister identifying which part is
1028 // read.
1029 auto GetRegAndSubreg =
1030 [&](const MachineInstr &Cpy) -> std::pair<Register, unsigned> {
1031 Register NewReg, OldReg;
1032 unsigned SubReg;
1033 if (Cpy.isCopy()) {
1034 OldReg = Cpy.getOperand(0).getReg();
1035 NewReg = Cpy.getOperand(1).getReg();
1036 SubReg = Cpy.getOperand(1).getSubReg();
1037 } else if (Cpy.isSubregToReg()) {
1038 OldReg = Cpy.getOperand(0).getReg();
1039 NewReg = Cpy.getOperand(2).getReg();
1040 SubReg = Cpy.getOperand(3).getImm();
1041 } else {
1042 auto CopyDetails = *TII.isCopyInstr(Cpy);
1043 const MachineOperand &Src = *CopyDetails.Source;
1044 const MachineOperand &Dest = *CopyDetails.Destination;
1045 OldReg = Dest.getReg();
1046 NewReg = Src.getReg();
1047 SubReg = Src.getSubReg();
1048 }
1049
1050 return {NewReg, SubReg};
1051 };
1052
1053 // First seek either the defining instruction, or a copy from a physreg.
1054 // During search, the current state is the current copy instruction, and which
1055 // register we've read. Accumulate qualifying subregisters into SubregsSeen;
1056 // deal with those later.
1057 auto State = GetRegAndSubreg(MI);
1058 auto CurInst = MI.getIterator();
1059 SmallVector<unsigned, 4> SubregsSeen;
1060 while (true) {
1061 // If we've found a copy from a physreg, first portion of search is over.
1062 if (!State.first.isVirtual())
1063 break;
1064
1065 // Record any subregister qualifier.
1066 if (State.second)
1067 SubregsSeen.push_back(State.second);
1068
1069 assert(MRI.hasOneDef(State.first));
1070 MachineInstr &Inst = *MRI.def_begin(State.first)->getParent();
1071 CurInst = Inst.getIterator();
1072
1073 // Any non-copy instruction is the defining instruction we're seeking.
1074 if (!Inst.isCopyLike() && !TII.isCopyInstr(Inst))
1075 break;
1076 State = GetRegAndSubreg(Inst);
1077 };
1078
1079 // Helper lambda to apply additional subregister substitutions to a known
1080 // instruction/operand pair. Adds new (fake) substitutions so that we can
1081 // record the subregister. FIXME: this isn't very space efficient if multiple
1082 // values are tracked back through the same copies; cache something later.
1083 auto ApplySubregisters =
1085 for (unsigned Subreg : reverse(SubregsSeen)) {
1086 // Fetch a new instruction number, not attached to an actual instruction.
1087 unsigned NewInstrNumber = getNewDebugInstrNum();
1088 // Add a substitution from the "new" number to the known one, with a
1089 // qualifying subreg.
1090 makeDebugValueSubstitution({NewInstrNumber, 0}, P, Subreg);
1091 // Return the new number; to find the underlying value, consumers need to
1092 // deal with the qualifying subreg.
1093 P = {NewInstrNumber, 0};
1094 }
1095 return P;
1096 };
1097
1098 // If we managed to find the defining instruction after COPYs, return an
1099 // instruction / operand pair after adding subregister qualifiers.
1100 if (State.first.isVirtual()) {
1101 // Virtual register def -- we can just look up where this happens.
1102 MachineInstr *Inst = MRI.def_begin(State.first)->getParent();
1103 for (auto &MO : Inst->all_defs()) {
1104 if (MO.getReg() != State.first)
1105 continue;
1106 return ApplySubregisters({Inst->getDebugInstrNum(), MO.getOperandNo()});
1107 }
1108
1109 llvm_unreachable("Vreg def with no corresponding operand?");
1110 }
1111
1112 // Our search ended in a copy from a physreg: walk back up the function
1113 // looking for whatever defines the physreg.
1114 assert(CurInst->isCopyLike() || TII.isCopyInstr(*CurInst));
1115 State = GetRegAndSubreg(*CurInst);
1116 Register RegToSeek = State.first;
1117
1118 auto RMII = CurInst->getReverseIterator();
1119 auto PrevInstrs = make_range(RMII, CurInst->getParent()->instr_rend());
1120 for (auto &ToExamine : PrevInstrs) {
1121 for (auto &MO : ToExamine.all_defs()) {
1122 // Test for operand that defines something aliasing RegToSeek.
1123 if (!TRI.regsOverlap(RegToSeek, MO.getReg()))
1124 continue;
1125
1126 return ApplySubregisters(
1127 {ToExamine.getDebugInstrNum(), MO.getOperandNo()});
1128 }
1129 }
1130
1131 MachineBasicBlock &InsertBB = *CurInst->getParent();
1132
1133 // We reached the start of the block before finding a defining instruction.
1134 // There are numerous scenarios where this can happen:
1135 // * Constant physical registers,
1136 // * Several intrinsics that allow LLVM-IR to read arbitary registers,
1137 // * Arguments in the entry block,
1138 // * Exception handling landing pads.
1139 // Validating all of them is too difficult, so just insert a DBG_PHI reading
1140 // the variable value at this position, rather than checking it makes sense.
1141
1142 // Create DBG_PHI for specified physreg.
1143 auto Builder = BuildMI(InsertBB, InsertBB.getFirstNonPHI(), DebugLoc(),
1144 TII.get(TargetOpcode::DBG_PHI));
1145 Builder.addReg(State.first);
1146 unsigned NewNum = getNewDebugInstrNum();
1147 Builder.addImm(NewNum);
1148 return ApplySubregisters({NewNum, 0u});
1149}
1150
1152 auto *TII = getSubtarget().getInstrInfo();
1153
1154 auto MakeUndefDbgValue = [&](MachineInstr &MI) {
1155 const MCInstrDesc &RefII = TII->get(TargetOpcode::DBG_VALUE_LIST);
1156 MI.setDesc(RefII);
1157 MI.setDebugValueUndef();
1158 };
1159
1161 for (auto &MBB : *this) {
1162 for (auto &MI : MBB) {
1163 if (!MI.isDebugRef())
1164 continue;
1165
1166 bool IsValidRef = true;
1167
1168 for (MachineOperand &MO : MI.debug_operands()) {
1169 if (!MO.isReg())
1170 continue;
1171
1172 Register Reg = MO.getReg();
1173
1174 // Some vregs can be deleted as redundant in the meantime. Mark those
1175 // as DBG_VALUE $noreg. Additionally, some normal instructions are
1176 // quickly deleted, leaving dangling references to vregs with no def.
1177 if (Reg == 0 || !RegInfo->hasOneDef(Reg)) {
1178 IsValidRef = false;
1179 break;
1180 }
1181
1182 assert(Reg.isVirtual());
1183 MachineInstr &DefMI = *RegInfo->def_instr_begin(Reg);
1184
1185 // If we've found a copy-like instruction, follow it back to the
1186 // instruction that defines the source value, see salvageCopySSA docs
1187 // for why this is important.
1188 if (DefMI.isCopyLike() || TII->isCopyInstr(DefMI)) {
1189 auto Result = salvageCopySSA(DefMI, ArgDbgPHIs);
1190 MO.ChangeToDbgInstrRef(Result.first, Result.second);
1191 } else {
1192 // Otherwise, identify the operand number that the VReg refers to.
1193 unsigned OperandIdx = 0;
1194 for (const auto &DefMO : DefMI.operands()) {
1195 if (DefMO.isReg() && DefMO.isDef() && DefMO.getReg() == Reg)
1196 break;
1197 ++OperandIdx;
1198 }
1199 assert(OperandIdx < DefMI.getNumOperands());
1200
1201 // Morph this instr ref to point at the given instruction and operand.
1202 unsigned ID = DefMI.getDebugInstrNum();
1203 MO.ChangeToDbgInstrRef(ID, OperandIdx);
1204 }
1205 }
1206
1207 if (!IsValidRef)
1208 MakeUndefDbgValue(MI);
1209 }
1210 }
1211}
1212
1214 // Disable instr-ref at -O0: it's very slow (in compile time). We can still
1215 // have optimized code inlined into this unoptimized code, however with
1216 // fewer and less aggressive optimizations happening, coverage and accuracy
1217 // should not suffer.
1218 if (getTarget().getOptLevel() == CodeGenOptLevel::None)
1219 return false;
1220
1221 // Don't use instr-ref if this function is marked optnone.
1222 if (F.hasFnAttribute(Attribute::OptimizeNone))
1223 return false;
1224
1225 if (llvm::debuginfoShouldUseDebugInstrRef(getTarget().getTargetTriple()))
1226 return true;
1227
1228 return false;
1229}
1230
1232 return UseDebugInstrRef;
1233}
1234
1237}
1238
1239// Use one million as a high / reserved number.
1240const unsigned MachineFunction::DebugOperandMemNumber = 1000000;
1241
1242/// \}
1243
1244//===----------------------------------------------------------------------===//
1245// MachineJumpTableInfo implementation
1246//===----------------------------------------------------------------------===//
1247
1248/// Return the size of each entry in the jump table.
1250 // The size of a jump table entry is 4 bytes unless the entry is just the
1251 // address of a block, in which case it is the pointer size.
1252 switch (getEntryKind()) {
1254 return TD.getPointerSize();
1257 return 8;
1261 return 4;
1263 return 0;
1264 }
1265 llvm_unreachable("Unknown jump table encoding!");
1266}
1267
1268/// Return the alignment of each entry in the jump table.
1270 // The alignment of a jump table entry is the alignment of int32 unless the
1271 // entry is just the address of a block, in which case it is the pointer
1272 // alignment.
1273 switch (getEntryKind()) {
1275 return TD.getPointerABIAlignment(0).value();
1278 return TD.getABIIntegerTypeAlignment(64).value();
1282 return TD.getABIIntegerTypeAlignment(32).value();
1284 return 1;
1285 }
1286 llvm_unreachable("Unknown jump table encoding!");
1287}
1288
1289/// Create a new jump table entry in the jump table info.
1291 const std::vector<MachineBasicBlock*> &DestBBs) {
1292 assert(!DestBBs.empty() && "Cannot create an empty jump table!");
1293 JumpTables.push_back(MachineJumpTableEntry(DestBBs));
1294 return JumpTables.size()-1;
1295}
1296
1297/// If Old is the target of any jump tables, update the jump tables to branch
1298/// to New instead.
1300 MachineBasicBlock *New) {
1301 assert(Old != New && "Not making a change?");
1302 bool MadeChange = false;
1303 for (size_t i = 0, e = JumpTables.size(); i != e; ++i)
1304 ReplaceMBBInJumpTable(i, Old, New);
1305 return MadeChange;
1306}
1307
1308/// If MBB is present in any jump tables, remove it.
1310 bool MadeChange = false;
1311 for (MachineJumpTableEntry &JTE : JumpTables) {
1312 auto removeBeginItr = std::remove(JTE.MBBs.begin(), JTE.MBBs.end(), MBB);
1313 MadeChange |= (removeBeginItr != JTE.MBBs.end());
1314 JTE.MBBs.erase(removeBeginItr, JTE.MBBs.end());
1315 }
1316 return MadeChange;
1317}
1318
1319/// If Old is a target of the jump tables, update the jump table to branch to
1320/// New instead.
1322 MachineBasicBlock *Old,
1323 MachineBasicBlock *New) {
1324 assert(Old != New && "Not making a change?");
1325 bool MadeChange = false;
1326 MachineJumpTableEntry &JTE = JumpTables[Idx];
1327 for (MachineBasicBlock *&MBB : JTE.MBBs)
1328 if (MBB == Old) {
1329 MBB = New;
1330 MadeChange = true;
1331 }
1332 return MadeChange;
1333}
1334
1336 if (JumpTables.empty()) return;
1337
1338 OS << "Jump Tables:\n";
1339
1340 for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) {
1341 OS << printJumpTableEntryReference(i) << ':';
1342 for (const MachineBasicBlock *MBB : JumpTables[i].MBBs)
1343 OS << ' ' << printMBBReference(*MBB);
1344 if (i != e)
1345 OS << '\n';
1346 }
1347
1348 OS << '\n';
1349}
1350
1351#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1353#endif
1354
1356 return Printable([Idx](raw_ostream &OS) { OS << "%jump-table." << Idx; });
1357}
1358
1359//===----------------------------------------------------------------------===//
1360// MachineConstantPool implementation
1361//===----------------------------------------------------------------------===//
1362
1363void MachineConstantPoolValue::anchor() {}
1364
1366 return DL.getTypeAllocSize(Ty);
1367}
1368
1371 return Val.MachineCPVal->getSizeInBytes(DL);
1372 return DL.getTypeAllocSize(Val.ConstVal->getType());
1373}
1374
1377 return true;
1378 return Val.ConstVal->needsDynamicRelocation();
1379}
1380
1383 if (needsRelocation())
1385 switch (getSizeInBytes(*DL)) {
1386 case 4:
1388 case 8:
1390 case 16:
1392 case 32:
1394 default:
1395 return SectionKind::getReadOnly();
1396 }
1397}
1398
1400 // A constant may be a member of both Constants and MachineCPVsSharingEntries,
1401 // so keep track of which we've deleted to avoid double deletions.
1403 for (const MachineConstantPoolEntry &C : Constants)
1404 if (C.isMachineConstantPoolEntry()) {
1405 Deleted.insert(C.Val.MachineCPVal);
1406 delete C.Val.MachineCPVal;
1407 }
1408 for (MachineConstantPoolValue *CPV : MachineCPVsSharingEntries) {
1409 if (Deleted.count(CPV) == 0)
1410 delete CPV;
1411 }
1412}
1413
1414/// Test whether the given two constants can be allocated the same constant pool
1415/// entry referenced by \param A.
1416static bool CanShareConstantPoolEntry(const Constant *A, const Constant *B,
1417 const DataLayout &DL) {
1418 // Handle the trivial case quickly.
1419 if (A == B) return true;
1420
1421 // If they have the same type but weren't the same constant, quickly
1422 // reject them.
1423 if (A->getType() == B->getType()) return false;
1424
1425 // We can't handle structs or arrays.
1426 if (isa<StructType>(A->getType()) || isa<ArrayType>(A->getType()) ||
1427 isa<StructType>(B->getType()) || isa<ArrayType>(B->getType()))
1428 return false;
1429
1430 // For now, only support constants with the same size.
1431 uint64_t StoreSize = DL.getTypeStoreSize(A->getType());
1432 if (StoreSize != DL.getTypeStoreSize(B->getType()) || StoreSize > 128)
1433 return false;
1434
1435 bool ContainsUndefOrPoisonA = A->containsUndefOrPoisonElement();
1436
1437 Type *IntTy = IntegerType::get(A->getContext(), StoreSize*8);
1438
1439 // Try constant folding a bitcast of both instructions to an integer. If we
1440 // get two identical ConstantInt's, then we are good to share them. We use
1441 // the constant folding APIs to do this so that we get the benefit of
1442 // DataLayout.
1443 if (isa<PointerType>(A->getType()))
1444 A = ConstantFoldCastOperand(Instruction::PtrToInt,
1445 const_cast<Constant *>(A), IntTy, DL);
1446 else if (A->getType() != IntTy)
1447 A = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(A),
1448 IntTy, DL);
1449 if (isa<PointerType>(B->getType()))
1450 B = ConstantFoldCastOperand(Instruction::PtrToInt,
1451 const_cast<Constant *>(B), IntTy, DL);
1452 else if (B->getType() != IntTy)
1453 B = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(B),
1454 IntTy, DL);
1455
1456 if (A != B)
1457 return false;
1458
1459 // Constants only safely match if A doesn't contain undef/poison.
1460 // As we'll be reusing A, it doesn't matter if B contain undef/poison.
1461 // TODO: Handle cases where A and B have the same undef/poison elements.
1462 // TODO: Merge A and B with mismatching undef/poison elements.
1463 return !ContainsUndefOrPoisonA;
1464}
1465
1466/// Create a new entry in the constant pool or return an existing one.
1467/// User must specify the log2 of the minimum required alignment for the object.
1469 Align Alignment) {
1470 if (Alignment > PoolAlignment) PoolAlignment = Alignment;
1471
1472 // Check to see if we already have this constant.
1473 //
1474 // FIXME, this could be made much more efficient for large constant pools.
1475 for (unsigned i = 0, e = Constants.size(); i != e; ++i)
1476 if (!Constants[i].isMachineConstantPoolEntry() &&
1477 CanShareConstantPoolEntry(Constants[i].Val.ConstVal, C, DL)) {
1478 if (Constants[i].getAlign() < Alignment)
1479 Constants[i].Alignment = Alignment;
1480 return i;
1481 }
1482
1483 Constants.push_back(MachineConstantPoolEntry(C, Alignment));
1484 return Constants.size()-1;
1485}
1486
1488 Align Alignment) {
1489 if (Alignment > PoolAlignment) PoolAlignment = Alignment;
1490
1491 // Check to see if we already have this constant.
1492 //
1493 // FIXME, this could be made much more efficient for large constant pools.
1494 int Idx = V->getExistingMachineCPValue(this, Alignment);
1495 if (Idx != -1) {
1496 MachineCPVsSharingEntries.insert(V);
1497 return (unsigned)Idx;
1498 }
1499
1500 Constants.push_back(MachineConstantPoolEntry(V, Alignment));
1501 return Constants.size()-1;
1502}
1503
1505 if (Constants.empty()) return;
1506
1507 OS << "Constant Pool:\n";
1508 for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
1509 OS << " cp#" << i << ": ";
1510 if (Constants[i].isMachineConstantPoolEntry())
1511 Constants[i].Val.MachineCPVal->print(OS);
1512 else
1513 Constants[i].Val.ConstVal->printAsOperand(OS, /*PrintType=*/false);
1514 OS << ", align=" << Constants[i].getAlign().value();
1515 OS << "\n";
1516 }
1517}
1518
1519//===----------------------------------------------------------------------===//
1520// Template specialization for MachineFunction implementation of
1521// ProfileSummaryInfo::getEntryCount().
1522//===----------------------------------------------------------------------===//
1523template <>
1524std::optional<Function::ProfileCount>
1525ProfileSummaryInfo::getEntryCount<llvm::MachineFunction>(
1526 const llvm::MachineFunction *F) const {
1527 return F->getFunction().getEntryCount();
1528}
1529
1530#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1532#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")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Definition: Compiler.h:529
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:407
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:218
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:446
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:847
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1870
DenormalMode getDenormalMode(const fltSemantics &FPType) const
Returns the denormal handling type for the default rounding mode of the function.
Definition: Function.cpp:728
bool needsUnwindTableEntry() const
True if this function needs an unwind table.
Definition: Function.h:652
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:669
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:76
MCSymbol * createTempSymbol()
Create a temporary symbol with a unique name.
Definition: MCContext.cpp:321
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:200
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 ...
unsigned getSizeInBytes(const DataLayout &DL) const
SectionKind getSectionKind(const DataLayout *DL) const
union llvm::MachineConstantPoolEntry::@195 Val
The constant itself.
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.
MachineMemOperand * getMachineMemOperand(MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s, 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.
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.
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...
MachineInstr::ExtraInfo * createMIExtraInfo(ArrayRef< MachineMemOperand * > MMOs, MCSymbol *PreInstrSymbol=nullptr, MCSymbol *PostInstrSymbol=nullptr, MDNode *HeapAllocMarker=nullptr, MDNode *PCSections=nullptr, uint32_t CFIType=0)
Allocate and construct an extra info structure for a MachineInstr.
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:547
unsigned peekDebugInstrNum() const
Examine the instruction number of this MachineInstr.
Definition: MachineInstr.h:520
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:554
iterator_range< filtered_mop_iterator > all_defs()
Returns an iterator range over all operands that are (explicit or implicit) register defs.
Definition: MachineInstr.h:731
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.
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.
uint64_t getSize() const
Return the size in bytes of 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:896
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.h:275
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.
bool getAlign(const Function &F, unsigned index, unsigned &align)
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:2053
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:428
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:1833
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