LLVM  14.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"
20 #include "llvm/ADT/SmallString.h"
21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/ADT/StringRef.h"
23 #include "llvm/ADT/Twine.h"
42 #include "llvm/Config/llvm-config.h"
43 #include "llvm/IR/Attributes.h"
44 #include "llvm/IR/BasicBlock.h"
45 #include "llvm/IR/Constant.h"
46 #include "llvm/IR/DataLayout.h"
48 #include "llvm/IR/DerivedTypes.h"
49 #include "llvm/IR/Function.h"
50 #include "llvm/IR/GlobalValue.h"
51 #include "llvm/IR/Instruction.h"
52 #include "llvm/IR/Instructions.h"
53 #include "llvm/IR/Metadata.h"
54 #include "llvm/IR/Module.h"
56 #include "llvm/IR/Value.h"
57 #include "llvm/MC/MCContext.h"
58 #include "llvm/MC/MCSymbol.h"
59 #include "llvm/MC/SectionKind.h"
60 #include "llvm/Support/Casting.h"
62 #include "llvm/Support/Compiler.h"
64 #include "llvm/Support/Debug.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 
79 using namespace llvm;
80 
81 #define DEBUG_TYPE "codegen"
82 
84  "align-all-functions",
85  cl::desc("Force the alignment of all functions in log2 format (e.g. 4 "
86  "means align on 16B boundaries)."),
87  cl::init(0), cl::Hidden);
88 
91 
92  switch(Prop) {
93  case P::FailedISel: return "FailedISel";
94  case P::IsSSA: return "IsSSA";
95  case P::Legalized: return "Legalized";
96  case P::NoPHIs: return "NoPHIs";
97  case P::NoVRegs: return "NoVRegs";
98  case P::RegBankSelected: return "RegBankSelected";
99  case P::Selected: return "Selected";
100  case P::TracksLiveness: return "TracksLiveness";
101  case P::TiedOpsRewritten: return "TiedOpsRewritten";
102  }
103  llvm_unreachable("Invalid machine function property");
104 }
105 
106 // Pin the vtable to this file.
107 void MachineFunction::Delegate::anchor() {}
108 
110  const char *Separator = "";
111  for (BitVector::size_type I = 0; I < Properties.size(); ++I) {
112  if (!Properties[I])
113  continue;
114  OS << Separator << getPropertyName(static_cast<Property>(I));
115  Separator = ", ";
116  }
117 }
118 
119 //===----------------------------------------------------------------------===//
120 // MachineFunction implementation
121 //===----------------------------------------------------------------------===//
122 
123 // Out-of-line virtual method.
125 
128 }
129 
130 static inline unsigned getFnStackAlignment(const TargetSubtargetInfo *STI,
131  const Function &F) {
132  if (auto MA = F.getFnStackAlign())
133  return MA->value();
134  return STI->getFrameLowering()->getStackAlign().value();
135 }
136 
138  const TargetSubtargetInfo &STI,
139  unsigned FunctionNum, MachineModuleInfo &mmi)
140  : F(F), Target(Target), STI(&STI), Ctx(mmi.getContext()), MMI(mmi) {
141  FunctionNumber = FunctionNum;
142  init();
143 }
144 
145 void MachineFunction::handleInsertion(MachineInstr &MI) {
146  if (TheDelegate)
147  TheDelegate->MF_HandleInsertion(MI);
148 }
149 
150 void MachineFunction::handleRemoval(MachineInstr &MI) {
151  if (TheDelegate)
152  TheDelegate->MF_HandleRemoval(MI);
153 }
154 
155 void MachineFunction::init() {
156  // Assume the function starts in SSA form with correct liveness.
159  if (STI->getRegisterInfo())
160  RegInfo = new (Allocator) MachineRegisterInfo(this);
161  else
162  RegInfo = nullptr;
163 
164  MFInfo = nullptr;
165  // We can realign the stack if the target supports it and the user hasn't
166  // explicitly asked us not to.
167  bool CanRealignSP = STI->getFrameLowering()->isStackRealignable() &&
168  !F.hasFnAttribute("no-realign-stack");
169  FrameInfo = new (Allocator) MachineFrameInfo(
170  getFnStackAlignment(STI, F), /*StackRealignable=*/CanRealignSP,
171  /*ForcedRealign=*/CanRealignSP &&
172  F.hasFnAttribute(Attribute::StackAlignment));
173 
174  if (F.hasFnAttribute(Attribute::StackAlignment))
175  FrameInfo->ensureMaxAlignment(*F.getFnStackAlign());
176 
177  ConstantPool = new (Allocator) MachineConstantPool(getDataLayout());
178  Alignment = STI->getTargetLowering()->getMinFunctionAlignment();
179 
180  // FIXME: Shouldn't use pref alignment if explicit alignment is set on F.
181  // FIXME: Use Function::hasOptSize().
182  if (!F.hasFnAttribute(Attribute::OptimizeForSize))
183  Alignment = std::max(Alignment,
185 
186  if (AlignAllFunctions)
187  Alignment = Align(1ULL << AlignAllFunctions);
188 
189  JumpTableInfo = nullptr;
190 
192  F.hasPersonalityFn() ? F.getPersonalityFn() : nullptr))) {
193  WinEHInfo = new (Allocator) WinEHFuncInfo();
194  }
195 
197  F.hasPersonalityFn() ? F.getPersonalityFn() : nullptr))) {
198  WasmEHInfo = new (Allocator) WasmEHFuncInfo();
199  }
200 
201  assert(Target.isCompatibleDataLayout(getDataLayout()) &&
202  "Can't create a MachineFunction using a Module with a "
203  "Target-incompatible DataLayout attached\n");
204 
205  PSVManager =
206  std::make_unique<PseudoSourceValueManager>(*(getSubtarget().
207  getInstrInfo()));
208 }
209 
211  clear();
212 }
213 
214 void MachineFunction::clear() {
215  Properties.reset();
216  // Don't call destructors on MachineInstr and MachineOperand. All of their
217  // memory comes from the BumpPtrAllocator which is about to be purged.
218  //
219  // Do call MachineBasicBlock destructors, it contains std::vectors.
220  for (iterator I = begin(), E = end(); I != E; I = BasicBlocks.erase(I))
221  I->Insts.clearAndLeakNodesUnsafely();
222  MBBNumbering.clear();
223 
224  InstructionRecycler.clear(Allocator);
225  OperandRecycler.clear(Allocator);
226  BasicBlockRecycler.clear(Allocator);
227  CodeViewAnnotations.clear();
229  if (RegInfo) {
230  RegInfo->~MachineRegisterInfo();
231  Allocator.Deallocate(RegInfo);
232  }
233  if (MFInfo) {
234  MFInfo->~MachineFunctionInfo();
235  Allocator.Deallocate(MFInfo);
236  }
237 
238  FrameInfo->~MachineFrameInfo();
239  Allocator.Deallocate(FrameInfo);
240 
241  ConstantPool->~MachineConstantPool();
242  Allocator.Deallocate(ConstantPool);
243 
244  if (JumpTableInfo) {
245  JumpTableInfo->~MachineJumpTableInfo();
246  Allocator.Deallocate(JumpTableInfo);
247  }
248 
249  if (WinEHInfo) {
250  WinEHInfo->~WinEHFuncInfo();
251  Allocator.Deallocate(WinEHInfo);
252  }
253 
254  if (WasmEHInfo) {
255  WasmEHInfo->~WasmEHFuncInfo();
256  Allocator.Deallocate(WasmEHInfo);
257  }
258 }
259 
261  return F.getParent()->getDataLayout();
262 }
263 
264 /// Get the JumpTableInfo for this function.
265 /// If it does not already exist, allocate one.
267 getOrCreateJumpTableInfo(unsigned EntryKind) {
268  if (JumpTableInfo) return JumpTableInfo;
269 
270  JumpTableInfo = new (Allocator)
272  return JumpTableInfo;
273 }
274 
276  return F.getDenormalMode(FPType);
277 }
278 
279 /// Should we be emitting segmented stack stuff for the function
281  return getFunction().hasFnAttribute("split-stack");
282 }
283 
284 LLVM_NODISCARD unsigned
286  FrameInstructions.push_back(Inst);
287  return FrameInstructions.size() - 1;
288 }
289 
290 /// This discards all of the MachineBasicBlock numbers and recomputes them.
291 /// This guarantees that the MBB numbers are sequential, dense, and match the
292 /// ordering of the blocks within the function. If a specific MachineBasicBlock
293 /// is specified, only that block and those after it are renumbered.
295  if (empty()) { MBBNumbering.clear(); return; }
297  if (MBB == nullptr)
298  MBBI = begin();
299  else
300  MBBI = MBB->getIterator();
301 
302  // Figure out the block number this should have.
303  unsigned BlockNo = 0;
304  if (MBBI != begin())
305  BlockNo = std::prev(MBBI)->getNumber() + 1;
306 
307  for (; MBBI != E; ++MBBI, ++BlockNo) {
308  if (MBBI->getNumber() != (int)BlockNo) {
309  // Remove use of the old number.
310  if (MBBI->getNumber() != -1) {
311  assert(MBBNumbering[MBBI->getNumber()] == &*MBBI &&
312  "MBB number mismatch!");
313  MBBNumbering[MBBI->getNumber()] = nullptr;
314  }
315 
316  // If BlockNo is already taken, set that block's number to -1.
317  if (MBBNumbering[BlockNo])
318  MBBNumbering[BlockNo]->setNumber(-1);
319 
320  MBBNumbering[BlockNo] = &*MBBI;
321  MBBI->setNumber(BlockNo);
322  }
323  }
324 
325  // Okay, all the blocks are renumbered. If we have compactified the block
326  // numbering, shrink MBBNumbering now.
327  assert(BlockNo <= MBBNumbering.size() && "Mismatch!");
328  MBBNumbering.resize(BlockNo);
329 }
330 
331 /// This method iterates over the basic blocks and assigns their IsBeginSection
332 /// and IsEndSection fields. This must be called after MBB layout is finalized
333 /// and the SectionID's are assigned to MBBs.
336  auto CurrentSectionID = front().getSectionID();
337  for (auto MBBI = std::next(begin()), E = end(); MBBI != E; ++MBBI) {
338  if (MBBI->getSectionID() == CurrentSectionID)
339  continue;
341  std::prev(MBBI)->setIsEndSection();
342  CurrentSectionID = MBBI->getSectionID();
343  }
344  back().setIsEndSection();
345 }
346 
347 /// Allocate a new MachineInstr. Use this instead of `new MachineInstr'.
349  const DebugLoc &DL,
350  bool NoImplicit) {
351  return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
352  MachineInstr(*this, MCID, DL, NoImplicit);
353 }
354 
355 /// Create a new MachineInstr which is a copy of the 'Orig' instruction,
356 /// identical in all ways except the instruction has no parent, prev, or next.
357 MachineInstr *
359  return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
360  MachineInstr(*this, *Orig);
361 }
362 
364  MachineBasicBlock::iterator InsertBefore, const MachineInstr &Orig) {
365  MachineInstr *FirstClone = nullptr;
367  while (true) {
368  MachineInstr *Cloned = CloneMachineInstr(&*I);
369  MBB.insert(InsertBefore, Cloned);
370  if (FirstClone == nullptr) {
371  FirstClone = Cloned;
372  } else {
373  Cloned->bundleWithPred();
374  }
375 
376  if (!I->isBundledWithSucc())
377  break;
378  ++I;
379  }
380  // Copy over call site info to the cloned instruction if needed. If Orig is in
381  // a bundle, copyCallSiteInfo takes care of finding the call instruction in
382  // the bundle.
383  if (Orig.shouldUpdateCallSiteInfo())
384  copyCallSiteInfo(&Orig, FirstClone);
385  return *FirstClone;
386 }
387 
388 /// Delete the given MachineInstr.
389 ///
390 /// This function also serves as the MachineInstr destructor - the real
391 /// ~MachineInstr() destructor must be empty.
392 void
394  // Verify that a call site info is at valid state. This assertion should
395  // be triggered during the implementation of support for the
396  // call site info of a new architecture. If the assertion is triggered,
397  // back trace will tell where to insert a call to updateCallSiteInfo().
398  assert((!MI->isCandidateForCallSiteEntry() ||
399  CallSitesInfo.find(MI) == CallSitesInfo.end()) &&
400  "Call site info was not updated!");
401  // Strip it for parts. The operand array and the MI object itself are
402  // independently recyclable.
403  if (MI->Operands)
404  deallocateOperandArray(MI->CapOperands, MI->Operands);
405  // Don't call ~MachineInstr() which must be trivial anyway because
406  // ~MachineFunction drops whole lists of MachineInstrs wihout calling their
407  // destructors.
408  InstructionRecycler.Deallocate(Allocator, MI);
409 }
410 
411 /// Allocate a new MachineBasicBlock. Use this instead of
412 /// `new MachineBasicBlock'.
415  return new (BasicBlockRecycler.Allocate<MachineBasicBlock>(Allocator))
416  MachineBasicBlock(*this, bb);
417 }
418 
419 /// Delete the given MachineBasicBlock.
420 void
422  assert(MBB->getParent() == this && "MBB parent mismatch!");
423  // Clean up any references to MBB in jump tables before deleting it.
424  if (JumpTableInfo)
425  JumpTableInfo->RemoveMBBFromJumpTables(MBB);
426  MBB->~MachineBasicBlock();
427  BasicBlockRecycler.Deallocate(Allocator, MBB);
428 }
429 
432  Align base_alignment, const AAMDNodes &AAInfo, const MDNode *Ranges,
433  SyncScope::ID SSID, AtomicOrdering Ordering,
434  AtomicOrdering FailureOrdering) {
435  return new (Allocator)
436  MachineMemOperand(PtrInfo, f, s, base_alignment, AAInfo, Ranges,
437  SSID, Ordering, FailureOrdering);
438 }
439 
442  Align base_alignment, const AAMDNodes &AAInfo, const MDNode *Ranges,
443  SyncScope::ID SSID, AtomicOrdering Ordering,
444  AtomicOrdering FailureOrdering) {
445  return new (Allocator)
446  MachineMemOperand(PtrInfo, f, MemTy, base_alignment, AAInfo, Ranges, SSID,
447  Ordering, FailureOrdering);
448 }
449 
451  const MachineMemOperand *MMO, const MachinePointerInfo &PtrInfo, uint64_t Size) {
452  return new (Allocator)
453  MachineMemOperand(PtrInfo, MMO->getFlags(), Size, MMO->getBaseAlign(),
454  AAMDNodes(), nullptr, MMO->getSyncScopeID(),
455  MMO->getSuccessOrdering(), MMO->getFailureOrdering());
456 }
457 
459  const MachineMemOperand *MMO, const MachinePointerInfo &PtrInfo, LLT Ty) {
460  return new (Allocator)
461  MachineMemOperand(PtrInfo, MMO->getFlags(), Ty, MMO->getBaseAlign(),
462  AAMDNodes(), nullptr, MMO->getSyncScopeID(),
463  MMO->getSuccessOrdering(), MMO->getFailureOrdering());
464 }
465 
468  int64_t Offset, LLT Ty) {
469  const MachinePointerInfo &PtrInfo = MMO->getPointerInfo();
470 
471  // If there is no pointer value, the offset isn't tracked so we need to adjust
472  // the base alignment.
473  Align Alignment = PtrInfo.V.isNull()
475  : MMO->getBaseAlign();
476 
477  // Do not preserve ranges, since we don't necessarily know what the high bits
478  // are anymore.
479  return new (Allocator) MachineMemOperand(
480  PtrInfo.getWithOffset(Offset), MMO->getFlags(), Ty, Alignment,
481  MMO->getAAInfo(), nullptr, MMO->getSyncScopeID(),
482  MMO->getSuccessOrdering(), MMO->getFailureOrdering());
483 }
484 
487  const AAMDNodes &AAInfo) {
488  MachinePointerInfo MPI = MMO->getValue() ?
489  MachinePointerInfo(MMO->getValue(), MMO->getOffset()) :
491 
492  return new (Allocator) MachineMemOperand(
493  MPI, MMO->getFlags(), MMO->getSize(), MMO->getBaseAlign(), AAInfo,
494  MMO->getRanges(), MMO->getSyncScopeID(), MMO->getSuccessOrdering(),
495  MMO->getFailureOrdering());
496 }
497 
500  MachineMemOperand::Flags Flags) {
501  return new (Allocator) MachineMemOperand(
502  MMO->getPointerInfo(), Flags, MMO->getSize(), MMO->getBaseAlign(),
503  MMO->getAAInfo(), MMO->getRanges(), MMO->getSyncScopeID(),
504  MMO->getSuccessOrdering(), MMO->getFailureOrdering());
505 }
506 
507 MachineInstr::ExtraInfo *MachineFunction::createMIExtraInfo(
508  ArrayRef<MachineMemOperand *> MMOs, MCSymbol *PreInstrSymbol,
509  MCSymbol *PostInstrSymbol, MDNode *HeapAllocMarker) {
510  return MachineInstr::ExtraInfo::create(Allocator, MMOs, PreInstrSymbol,
511  PostInstrSymbol, HeapAllocMarker);
512 }
513 
515  char *Dest = Allocator.Allocate<char>(Name.size() + 1);
516  llvm::copy(Name, Dest);
517  Dest[Name.size()] = 0;
518  return Dest;
519 }
520 
522  unsigned NumRegs = getSubtarget().getRegisterInfo()->getNumRegs();
523  unsigned Size = MachineOperand::getRegMaskSize(NumRegs);
524  uint32_t *Mask = Allocator.Allocate<uint32_t>(Size);
525  memset(Mask, 0, Size * sizeof(Mask[0]));
526  return Mask;
527 }
528 
530  int* AllocMask = Allocator.Allocate<int>(Mask.size());
531  copy(Mask, AllocMask);
532  return {AllocMask, Mask.size()};
533 }
534 
535 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
537  print(dbgs());
538 }
539 #endif
540 
542  return getFunction().getName();
543 }
544 
545 void MachineFunction::print(raw_ostream &OS, const SlotIndexes *Indexes) const {
546  OS << "# Machine code for function " << getName() << ": ";
547  getProperties().print(OS);
548  OS << '\n';
549 
550  // Print Frame Information
551  FrameInfo->print(*this, OS);
552 
553  // Print JumpTable Information
554  if (JumpTableInfo)
555  JumpTableInfo->print(OS);
556 
557  // Print Constant Pool
558  ConstantPool->print(OS);
559 
561 
562  if (RegInfo && !RegInfo->livein_empty()) {
563  OS << "Function Live Ins: ";
565  I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) {
566  OS << printReg(I->first, TRI);
567  if (I->second)
568  OS << " in " << printReg(I->second, TRI);
569  if (std::next(I) != E)
570  OS << ", ";
571  }
572  OS << '\n';
573  }
574 
577  for (const auto &BB : *this) {
578  OS << '\n';
579  // If we print the whole function, print it at its most verbose level.
580  BB.print(OS, MST, Indexes, /*IsStandalone=*/true);
581  }
582 
583  OS << "\n# End machine code for function " << getName() << ".\n\n";
584 }
585 
586 /// True if this function needs frame moves for debug or exceptions.
588  return getMMI().hasDebugInfo() ||
591 }
592 
593 namespace llvm {
594 
595  template<>
598 
599  static std::string getGraphName(const MachineFunction *F) {
600  return ("CFG for '" + F->getName() + "' function").str();
601  }
602 
603  std::string getNodeLabel(const MachineBasicBlock *Node,
604  const MachineFunction *Graph) {
605  std::string OutStr;
606  {
607  raw_string_ostream OSS(OutStr);
608 
609  if (isSimple()) {
610  OSS << printMBBReference(*Node);
611  if (const BasicBlock *BB = Node->getBasicBlock())
612  OSS << ": " << BB->getName();
613  } else
614  Node->print(OSS);
615  }
616 
617  if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());
618 
619  // Process string output to make it nicer...
620  for (unsigned i = 0; i != OutStr.length(); ++i)
621  if (OutStr[i] == '\n') { // Left justify
622  OutStr[i] = '\\';
623  OutStr.insert(OutStr.begin()+i+1, 'l');
624  }
625  return OutStr;
626  }
627  };
628 
629 } // end namespace llvm
630 
632 {
633 #ifndef NDEBUG
634  ViewGraph(this, "mf" + getName());
635 #else
636  errs() << "MachineFunction::viewCFG is only available in debug builds on "
637  << "systems with Graphviz or gv!\n";
638 #endif // NDEBUG
639 }
640 
642 {
643 #ifndef NDEBUG
644  ViewGraph(this, "mf" + getName(), true);
645 #else
646  errs() << "MachineFunction::viewCFGOnly is only available in debug builds on "
647  << "systems with Graphviz or gv!\n";
648 #endif // NDEBUG
649 }
650 
651 /// Add the specified physical register as a live-in value and
652 /// create a corresponding virtual register for it.
654  const TargetRegisterClass *RC) {
656  Register VReg = MRI.getLiveInVirtReg(PReg);
657  if (VReg) {
658  const TargetRegisterClass *VRegRC = MRI.getRegClass(VReg);
659  (void)VRegRC;
660  // A physical register can be added several times.
661  // Between two calls, the register class of the related virtual register
662  // may have been constrained to match some operation constraints.
663  // In that case, check that the current register class includes the
664  // physical register and is a sub class of the specified RC.
665  assert((VRegRC == RC || (VRegRC->contains(PReg) &&
666  RC->hasSubClassEq(VRegRC))) &&
667  "Register class mismatch!");
668  return VReg;
669  }
670  VReg = MRI.createVirtualRegister(RC);
671  MRI.addLiveIn(PReg, VReg);
672  return VReg;
673 }
674 
675 /// Return the MCSymbol for the specified non-empty jump table.
676 /// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
677 /// normal 'L' label is returned.
679  bool isLinkerPrivate) const {
680  const DataLayout &DL = getDataLayout();
681  assert(JumpTableInfo && "No jump tables");
682  assert(JTI < JumpTableInfo->getJumpTables().size() && "Invalid JTI!");
683 
684  StringRef Prefix = isLinkerPrivate ? DL.getLinkerPrivateGlobalPrefix()
685  : DL.getPrivateGlobalPrefix();
688  << Prefix << "JTI" << getFunctionNumber() << '_' << JTI;
689  return Ctx.getOrCreateSymbol(Name);
690 }
691 
692 /// Return a function-local symbol to represent the PIC base.
694  const DataLayout &DL = getDataLayout();
695  return Ctx.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) +
696  Twine(getFunctionNumber()) + "$pb");
697 }
698 
699 /// \name Exception Handling
700 /// \{
701 
704  unsigned N = LandingPads.size();
705  for (unsigned i = 0; i < N; ++i) {
706  LandingPadInfo &LP = LandingPads[i];
707  if (LP.LandingPadBlock == LandingPad)
708  return LP;
709  }
710 
711  LandingPads.push_back(LandingPadInfo(LandingPad));
712  return LandingPads[N];
713 }
714 
716  MCSymbol *BeginLabel, MCSymbol *EndLabel) {
717  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
718  LP.BeginLabels.push_back(BeginLabel);
719  LP.EndLabels.push_back(EndLabel);
720 }
721 
723  MCSymbol *LandingPadLabel = Ctx.createTempSymbol();
724  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
725  LP.LandingPadLabel = LandingPadLabel;
726 
727  const Instruction *FirstI = LandingPad->getBasicBlock()->getFirstNonPHI();
728  if (const auto *LPI = dyn_cast<LandingPadInst>(FirstI)) {
729  if (const auto *PF =
730  dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts()))
731  getMMI().addPersonality(PF);
732 
733  if (LPI->isCleanup())
734  addCleanup(LandingPad);
735 
736  // FIXME: New EH - Add the clauses in reverse order. This isn't 100%
737  // correct, but we need to do it this way because of how the DWARF EH
738  // emitter processes the clauses.
739  for (unsigned I = LPI->getNumClauses(); I != 0; --I) {
740  Value *Val = LPI->getClause(I - 1);
741  if (LPI->isCatch(I - 1)) {
742  addCatchTypeInfo(LandingPad,
743  dyn_cast<GlobalValue>(Val->stripPointerCasts()));
744  } else {
745  // Add filters in a list.
746  auto *CVal = cast<Constant>(Val);
748  for (User::op_iterator II = CVal->op_begin(), IE = CVal->op_end();
749  II != IE; ++II)
750  FilterList.push_back(cast<GlobalValue>((*II)->stripPointerCasts()));
751 
752  addFilterTypeInfo(LandingPad, FilterList);
753  }
754  }
755 
756  } else if (const auto *CPI = dyn_cast<CatchPadInst>(FirstI)) {
757  for (unsigned I = CPI->getNumArgOperands(); I != 0; --I) {
758  Value *TypeInfo = CPI->getArgOperand(I - 1)->stripPointerCasts();
759  addCatchTypeInfo(LandingPad, dyn_cast<GlobalValue>(TypeInfo));
760  }
761 
762  } else {
763  assert(isa<CleanupPadInst>(FirstI) && "Invalid landingpad!");
764  }
765 
766  return LandingPadLabel;
767 }
768 
771  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
772  for (unsigned N = TyInfo.size(); N; --N)
773  LP.TypeIds.push_back(getTypeIDFor(TyInfo[N - 1]));
774 }
775 
778  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
779  std::vector<unsigned> IdsInFilter(TyInfo.size());
780  for (unsigned I = 0, E = TyInfo.size(); I != E; ++I)
781  IdsInFilter[I] = getTypeIDFor(TyInfo[I]);
782  LP.TypeIds.push_back(getFilterIDFor(IdsInFilter));
783 }
784 
786  bool TidyIfNoBeginLabels) {
787  for (unsigned i = 0; i != LandingPads.size(); ) {
788  LandingPadInfo &LandingPad = LandingPads[i];
789  if (LandingPad.LandingPadLabel &&
790  !LandingPad.LandingPadLabel->isDefined() &&
791  (!LPMap || (*LPMap)[LandingPad.LandingPadLabel] == 0))
792  LandingPad.LandingPadLabel = nullptr;
793 
794  // Special case: we *should* emit LPs with null LP MBB. This indicates
795  // "nounwind" case.
796  if (!LandingPad.LandingPadLabel && LandingPad.LandingPadBlock) {
797  LandingPads.erase(LandingPads.begin() + i);
798  continue;
799  }
800 
801  if (TidyIfNoBeginLabels) {
802  for (unsigned j = 0, e = LandingPads[i].BeginLabels.size(); j != e; ++j) {
803  MCSymbol *BeginLabel = LandingPad.BeginLabels[j];
804  MCSymbol *EndLabel = LandingPad.EndLabels[j];
805  if ((BeginLabel->isDefined() || (LPMap && (*LPMap)[BeginLabel] != 0)) &&
806  (EndLabel->isDefined() || (LPMap && (*LPMap)[EndLabel] != 0)))
807  continue;
808 
809  LandingPad.BeginLabels.erase(LandingPad.BeginLabels.begin() + j);
810  LandingPad.EndLabels.erase(LandingPad.EndLabels.begin() + j);
811  --j;
812  --e;
813  }
814 
815  // Remove landing pads with no try-ranges.
816  if (LandingPads[i].BeginLabels.empty()) {
817  LandingPads.erase(LandingPads.begin() + i);
818  continue;
819  }
820  }
821 
822  // If there is no landing pad, ensure that the list of typeids is empty.
823  // If the only typeid is a cleanup, this is the same as having no typeids.
824  if (!LandingPad.LandingPadBlock ||
825  (LandingPad.TypeIds.size() == 1 && !LandingPad.TypeIds[0]))
826  LandingPad.TypeIds.clear();
827  ++i;
828  }
829 }
830 
832  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
833  LP.TypeIds.push_back(0);
834 }
835 
837  const Function *Filter,
838  const BlockAddress *RecoverBA) {
839  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
840  SEHHandler Handler;
841  Handler.FilterOrFinally = Filter;
842  Handler.RecoverBA = RecoverBA;
843  LP.SEHHandlers.push_back(Handler);
844 }
845 
847  const Function *Cleanup) {
848  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
849  SEHHandler Handler;
850  Handler.FilterOrFinally = Cleanup;
851  Handler.RecoverBA = nullptr;
852  LP.SEHHandlers.push_back(Handler);
853 }
854 
856  ArrayRef<unsigned> Sites) {
857  LPadToCallSiteMap[Sym].append(Sites.begin(), Sites.end());
858 }
859 
861  for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i)
862  if (TypeInfos[i] == TI) return i + 1;
863 
864  TypeInfos.push_back(TI);
865  return TypeInfos.size();
866 }
867 
868 int MachineFunction::getFilterIDFor(std::vector<unsigned> &TyIds) {
869  // If the new filter coincides with the tail of an existing filter, then
870  // re-use the existing filter. Folding filters more than this requires
871  // re-ordering filters and/or their elements - probably not worth it.
872  for (unsigned i : FilterEnds) {
873  unsigned j = TyIds.size();
874 
875  while (i && j)
876  if (FilterIds[--i] != TyIds[--j])
877  goto try_next;
878 
879  if (!j)
880  // The new filter coincides with range [i, end) of the existing filter.
881  return -(1 + i);
882 
883 try_next:;
884  }
885 
886  // Add the new filter.
887  int FilterID = -(1 + FilterIds.size());
888  FilterIds.reserve(FilterIds.size() + TyIds.size() + 1);
889  llvm::append_range(FilterIds, TyIds);
890  FilterEnds.push_back(FilterIds.size());
891  FilterIds.push_back(0); // terminator
892  return FilterID;
893 }
894 
896 MachineFunction::getCallSiteInfo(const MachineInstr *MI) {
897  assert(MI->isCandidateForCallSiteEntry() &&
898  "Call site info refers only to call (MI) candidates");
899 
900  if (!Target.Options.EmitCallSiteInfo)
901  return CallSitesInfo.end();
902  return CallSitesInfo.find(MI);
903 }
904 
905 /// Return the call machine instruction or find a call within bundle.
906 static const MachineInstr *getCallInstr(const MachineInstr *MI) {
907  if (!MI->isBundle())
908  return MI;
909 
910  for (auto &BMI : make_range(getBundleStart(MI->getIterator()),
911  getBundleEnd(MI->getIterator())))
912  if (BMI.isCandidateForCallSiteEntry())
913  return &BMI;
914 
915  llvm_unreachable("Unexpected bundle without a call site candidate");
916 }
917 
919  assert(MI->shouldUpdateCallSiteInfo() &&
920  "Call site info refers only to call (MI) candidates or "
921  "candidates inside bundles");
922 
923  const MachineInstr *CallMI = getCallInstr(MI);
924  CallSiteInfoMap::iterator CSIt = getCallSiteInfo(CallMI);
925  if (CSIt == CallSitesInfo.end())
926  return;
927  CallSitesInfo.erase(CSIt);
928 }
929 
931  const MachineInstr *New) {
933  "Call site info refers only to call (MI) candidates or "
934  "candidates inside bundles");
935 
936  if (!New->isCandidateForCallSiteEntry())
937  return eraseCallSiteInfo(Old);
938 
939  const MachineInstr *OldCallMI = getCallInstr(Old);
940  CallSiteInfoMap::iterator CSIt = getCallSiteInfo(OldCallMI);
941  if (CSIt == CallSitesInfo.end())
942  return;
943 
944  CallSiteInfo CSInfo = CSIt->second;
945  CallSitesInfo[New] = CSInfo;
946 }
947 
949  const MachineInstr *New) {
951  "Call site info refers only to call (MI) candidates or "
952  "candidates inside bundles");
953 
954  if (!New->isCandidateForCallSiteEntry())
955  return eraseCallSiteInfo(Old);
956 
957  const MachineInstr *OldCallMI = getCallInstr(Old);
958  CallSiteInfoMap::iterator CSIt = getCallSiteInfo(OldCallMI);
959  if (CSIt == CallSitesInfo.end())
960  return;
961 
962  CallSiteInfo CSInfo = std::move(CSIt->second);
963  CallSitesInfo.erase(CSIt);
964  CallSitesInfo[New] = CSInfo;
965 }
966 
969 }
970 
973  unsigned Subreg) {
974  // Catch any accidental self-loops.
975  assert(A.first != B.first);
976  DebugValueSubstitutions.push_back({A, B, Subreg});
977 }
978 
980  MachineInstr &New,
981  unsigned MaxOperand) {
982  // If the Old instruction wasn't tracked at all, there is no work to do.
983  unsigned OldInstrNum = Old.peekDebugInstrNum();
984  if (!OldInstrNum)
985  return;
986 
987  // Iterate over all operands looking for defs to create substitutions for.
988  // Avoid creating new instr numbers unless we create a new substitution.
989  // While this has no functional effect, it risks confusing someone reading
990  // MIR output.
991  // Examine all the operands, or the first N specified by the caller.
992  MaxOperand = std::min(MaxOperand, Old.getNumOperands());
993  for (unsigned int I = 0; I < MaxOperand; ++I) {
994  const auto &OldMO = Old.getOperand(I);
995  auto &NewMO = New.getOperand(I);
996  (void)NewMO;
997 
998  if (!OldMO.isReg() || !OldMO.isDef())
999  continue;
1000  assert(NewMO.isDef());
1001 
1002  unsigned NewInstrNum = New.getDebugInstrNum();
1003  makeDebugValueSubstitution(std::make_pair(OldInstrNum, I),
1004  std::make_pair(NewInstrNum, I));
1005  }
1006 }
1007 
1010  MachineRegisterInfo &MRI = getRegInfo();
1012  const TargetInstrInfo &TII = *getSubtarget().getInstrInfo();
1013 
1014  // Chase the value read by a copy-like instruction back to the instruction
1015  // that ultimately _defines_ that value. This may pass:
1016  // * Through multiple intermediate copies, including subregister moves /
1017  // copies,
1018  // * Copies from physical registers that must then be traced back to the
1019  // defining instruction,
1020  // * Or, physical registers may be live-in to (only) the entry block, which
1021  // requires a DBG_PHI to be created.
1022  // We can pursue this problem in that order: trace back through copies,
1023  // optionally through a physical register, to a defining instruction. We
1024  // should never move from physreg to vreg. As we're still in SSA form, no need
1025  // to worry about partial definitions of registers.
1026 
1027  // Helper lambda to interpret a copy-like instruction. Takes instruction,
1028  // returns the register read and any subregister identifying which part is
1029  // read.
1030  auto GetRegAndSubreg =
1031  [&](const MachineInstr &Cpy) -> std::pair<Register, unsigned> {
1032  Register NewReg, OldReg;
1033  unsigned SubReg;
1034  if (Cpy.isCopy()) {
1035  OldReg = Cpy.getOperand(0).getReg();
1036  NewReg = Cpy.getOperand(1).getReg();
1037  SubReg = Cpy.getOperand(1).getSubReg();
1038  } else if (Cpy.isSubregToReg()) {
1039  OldReg = Cpy.getOperand(0).getReg();
1040  NewReg = Cpy.getOperand(2).getReg();
1041  SubReg = Cpy.getOperand(3).getImm();
1042  } else {
1043  auto CopyDetails = *TII.isCopyInstr(Cpy);
1044  const MachineOperand &Src = *CopyDetails.Source;
1045  const MachineOperand &Dest = *CopyDetails.Destination;
1046  OldReg = Dest.getReg();
1047  NewReg = Src.getReg();
1048  SubReg = Src.getSubReg();
1049  }
1050 
1051  return {NewReg, SubReg};
1052  };
1053 
1054  // First seek either the defining instruction, or a copy from a physreg.
1055  // During search, the current state is the current copy instruction, and which
1056  // register we've read. Accumulate qualifying subregisters into SubregsSeen;
1057  // deal with those later.
1058  auto State = GetRegAndSubreg(MI);
1059  auto CurInst = MI.getIterator();
1060  SmallVector<unsigned, 4> SubregsSeen;
1061  while (true) {
1062  // If we've found a copy from a physreg, first portion of search is over.
1063  if (!State.first.isVirtual())
1064  break;
1065 
1066  // Record any subregister qualifier.
1067  if (State.second)
1068  SubregsSeen.push_back(State.second);
1069 
1070  assert(MRI.hasOneDef(State.first));
1071  MachineInstr &Inst = *MRI.def_begin(State.first)->getParent();
1072  CurInst = Inst.getIterator();
1073 
1074  // Any non-copy instruction is the defining instruction we're seeking.
1075  if (!Inst.isCopyLike() && !TII.isCopyInstr(Inst))
1076  break;
1077  State = GetRegAndSubreg(Inst);
1078  };
1079 
1080  // Helper lambda to apply additional subregister substitutions to a known
1081  // instruction/operand pair. Adds new (fake) substitutions so that we can
1082  // record the subregister. FIXME: this isn't very space efficient if multiple
1083  // values are tracked back through the same copies; cache something later.
1084  auto ApplySubregisters =
1086  for (unsigned Subreg : reverse(SubregsSeen)) {
1087  // Fetch a new instruction number, not attached to an actual instruction.
1088  unsigned NewInstrNumber = getNewDebugInstrNum();
1089  // Add a substitution from the "new" number to the known one, with a
1090  // qualifying subreg.
1091  makeDebugValueSubstitution({NewInstrNumber, 0}, P, Subreg);
1092  // Return the new number; to find the underlying value, consumers need to
1093  // deal with the qualifying subreg.
1094  P = {NewInstrNumber, 0};
1095  }
1096  return P;
1097  };
1098 
1099  // If we managed to find the defining instruction after COPYs, return an
1100  // instruction / operand pair after adding subregister qualifiers.
1101  if (State.first.isVirtual()) {
1102  // Virtual register def -- we can just look up where this happens.
1103  MachineInstr *Inst = MRI.def_begin(State.first)->getParent();
1104  for (auto &MO : Inst->operands()) {
1105  if (!MO.isReg() || !MO.isDef() || MO.getReg() != State.first)
1106  continue;
1107  return ApplySubregisters(
1108  {Inst->getDebugInstrNum(), Inst->getOperandNo(&MO)});
1109  }
1110 
1111  llvm_unreachable("Vreg def with no corresponding operand?");
1112  }
1113 
1114  // Our search ended in a copy from a physreg: walk back up the function
1115  // looking for whatever defines the physreg.
1116  assert(CurInst->isCopyLike() || TII.isCopyInstr(*CurInst));
1117  State = GetRegAndSubreg(*CurInst);
1118  Register RegToSeek = State.first;
1119 
1120  auto RMII = CurInst->getReverseIterator();
1121  auto PrevInstrs = make_range(RMII, CurInst->getParent()->instr_rend());
1122  for (auto &ToExamine : PrevInstrs) {
1123  for (auto &MO : ToExamine.operands()) {
1124  // Test for operand that defines something aliasing RegToSeek.
1125  if (!MO.isReg() || !MO.isDef() ||
1126  !TRI.regsOverlap(RegToSeek, MO.getReg()))
1127  continue;
1128 
1129  return ApplySubregisters(
1130  {ToExamine.getDebugInstrNum(), ToExamine.getOperandNo(&MO)});
1131  }
1132  }
1133 
1134  MachineBasicBlock &InsertBB = *CurInst->getParent();
1135 
1136  // We reached the start of the block before finding a defining instruction.
1137  // It could be from a constant register, otherwise it must be an argument.
1138  if (TRI.isConstantPhysReg(State.first)) {
1139  // We can produce a DBG_PHI that identifies the constant physreg. Doesn't
1140  // matter where we put it, as it's constant valued.
1141  assert(CurInst->isCopy());
1142  } else if (State.first == TRI.getFrameRegister(*this)) {
1143  // LLVM IR is allowed to read the framepointer by calling a
1144  // llvm.frameaddress.* intrinsic. We can support this by emitting a
1145  // DBG_PHI $fp. This isn't ideal, because it extends the behaviours /
1146  // position that DBG_PHIs appear at, limiting what can be done later.
1147  // TODO: see if there's a better way of expressing these variable
1148  // locations.
1149  ;
1150  } else {
1151  // Assert that this is the entry block. If it isn't, then there is some
1152  // code construct we don't recognise that deals with physregs across
1153  // blocks.
1154  assert(!State.first.isVirtual());
1155  assert(&*InsertBB.getParent()->begin() == &InsertBB);
1156  }
1157 
1158  // Create DBG_PHI for specified physreg.
1159  auto Builder = BuildMI(InsertBB, InsertBB.getFirstNonPHI(), DebugLoc(),
1160  TII.get(TargetOpcode::DBG_PHI));
1161  Builder.addReg(State.first, RegState::Debug);
1162  unsigned NewNum = getNewDebugInstrNum();
1163  Builder.addImm(NewNum);
1164  return ApplySubregisters({NewNum, 0u});
1165 }
1166 
1168  auto *TII = getSubtarget().getInstrInfo();
1169 
1170  auto MakeDbgValue = [&](MachineInstr &MI) {
1171  const MCInstrDesc &RefII = TII->get(TargetOpcode::DBG_VALUE);
1172  MI.setDesc(RefII);
1173  MI.getOperand(1).ChangeToRegister(0, false);
1174  MI.getOperand(0).setIsDebug();
1175  };
1176 
1177  if (!useDebugInstrRef())
1178  return;
1179 
1180  for (auto &MBB : *this) {
1181  for (auto &MI : MBB) {
1182  if (!MI.isDebugRef() || !MI.getOperand(0).isReg())
1183  continue;
1184 
1185  Register Reg = MI.getOperand(0).getReg();
1186 
1187  // Some vregs can be deleted as redundant in the meantime. Mark those
1188  // as DBG_VALUE $noreg.
1189  if (Reg == 0) {
1190  MakeDbgValue(MI);
1191  continue;
1192  }
1193 
1194  assert(Reg.isVirtual());
1195  MachineInstr &DefMI = *RegInfo->def_instr_begin(Reg);
1196  assert(RegInfo->hasOneDef(Reg));
1197 
1198  // If we've found a copy-like instruction, follow it back to the
1199  // instruction that defines the source value, see salvageCopySSA docs
1200  // for why this is important.
1201  if (DefMI.isCopyLike() || TII->isCopyInstr(DefMI)) {
1202  auto Result = salvageCopySSA(DefMI);
1203  MI.getOperand(0).ChangeToImmediate(Result.first);
1204  MI.getOperand(1).setImm(Result.second);
1205  } else {
1206  // Otherwise, identify the operand number that the VReg refers to.
1207  unsigned OperandIdx = 0;
1208  for (const auto &MO : DefMI.operands()) {
1209  if (MO.isReg() && MO.isDef() && MO.getReg() == Reg)
1210  break;
1211  ++OperandIdx;
1212  }
1213  assert(OperandIdx < DefMI.getNumOperands());
1214 
1215  // Morph this instr ref to point at the given instruction and operand.
1216  unsigned ID = DefMI.getDebugInstrNum();
1217  MI.getOperand(0).ChangeToImmediate(ID);
1218  MI.getOperand(1).setImm(OperandIdx);
1219  }
1220  }
1221  }
1222 }
1223 
1225  // Disable instr-ref at -O0: it's very slow (in compile time). We can still
1226  // have optimized code inlined into this unoptimized code, however with
1227  // fewer and less aggressive optimizations happening, coverage and accuracy
1228  // should not suffer.
1229  if (getTarget().getOptLevel() == CodeGenOpt::None)
1230  return false;
1231 
1232  // Don't use instr-ref if this function is marked optnone.
1233  if (F.hasFnAttribute(Attribute::OptimizeNone))
1234  return false;
1235 
1236  if (getTarget().Options.ValueTrackingVariableLocations)
1237  return true;
1238 
1239  return false;
1240 }
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();
1256  return 8;
1260  return 4;
1262  return 0;
1263  }
1264  llvm_unreachable("Unknown jump table encoding!");
1265 }
1266 
1267 /// Return the alignment of each entry in the jump table.
1269  // The alignment of a jump table entry is the alignment of int32 unless the
1270  // entry is just the address of a block, in which case it is the pointer
1271  // alignment.
1272  switch (getEntryKind()) {
1274  return TD.getPointerABIAlignment(0).value();
1276  return TD.getABIIntegerTypeAlignment(64).value();
1280  return TD.getABIIntegerTypeAlignment(32).value();
1282  return 1;
1283  }
1284  llvm_unreachable("Unknown jump table encoding!");
1285 }
1286 
1287 /// Create a new jump table entry in the jump table info.
1289  const std::vector<MachineBasicBlock*> &DestBBs) {
1290  assert(!DestBBs.empty() && "Cannot create an empty jump table!");
1291  JumpTables.push_back(MachineJumpTableEntry(DestBBs));
1292  return JumpTables.size()-1;
1293 }
1294 
1295 /// If Old is the target of any jump tables, update the jump tables to branch
1296 /// to New instead.
1298  MachineBasicBlock *New) {
1299  assert(Old != New && "Not making a change?");
1300  bool MadeChange = false;
1301  for (size_t i = 0, e = JumpTables.size(); i != e; ++i)
1302  ReplaceMBBInJumpTable(i, Old, New);
1303  return MadeChange;
1304 }
1305 
1306 /// If MBB is present in any jump tables, remove it.
1308  bool MadeChange = false;
1309  for (MachineJumpTableEntry &JTE : JumpTables) {
1310  auto removeBeginItr = std::remove(JTE.MBBs.begin(), JTE.MBBs.end(), MBB);
1311  MadeChange |= (removeBeginItr != JTE.MBBs.end());
1312  JTE.MBBs.erase(removeBeginItr, JTE.MBBs.end());
1313  }
1314  return MadeChange;
1315 }
1316 
1317 /// If Old is a target of the jump tables, update the jump table to branch to
1318 /// New instead.
1320  MachineBasicBlock *Old,
1321  MachineBasicBlock *New) {
1322  assert(Old != New && "Not making a change?");
1323  bool MadeChange = false;
1324  MachineJumpTableEntry &JTE = JumpTables[Idx];
1325  for (size_t j = 0, e = JTE.MBBs.size(); j != e; ++j)
1326  if (JTE.MBBs[j] == Old) {
1327  JTE.MBBs[j] = New;
1328  MadeChange = true;
1329  }
1330  return MadeChange;
1331 }
1332 
1334  if (JumpTables.empty()) return;
1335 
1336  OS << "Jump Tables:\n";
1337 
1338  for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) {
1339  OS << printJumpTableEntryReference(i) << ':';
1340  for (unsigned j = 0, f = JumpTables[i].MBBs.size(); j != f; ++j)
1341  OS << ' ' << printMBBReference(*JumpTables[i].MBBs[j]);
1342  if (i != e)
1343  OS << '\n';
1344  }
1345 
1346  OS << '\n';
1347 }
1348 
1349 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1351 #endif
1352 
1354  return Printable([Idx](raw_ostream &OS) { OS << "%jump-table." << Idx; });
1355 }
1356 
1357 //===----------------------------------------------------------------------===//
1358 // MachineConstantPool implementation
1359 //===----------------------------------------------------------------------===//
1360 
1361 void MachineConstantPoolValue::anchor() {}
1362 
1364  return DL.getTypeAllocSize(Ty);
1365 }
1366 
1369  return Val.MachineCPVal->getSizeInBytes(DL);
1370  return DL.getTypeAllocSize(Val.ConstVal->getType());
1371 }
1372 
1375  return true;
1376  return Val.ConstVal->needsDynamicRelocation();
1377 }
1378 
1381  if (needsRelocation())
1383  switch (getSizeInBytes(*DL)) {
1384  case 4:
1386  case 8:
1388  case 16:
1390  case 32:
1392  default:
1393  return SectionKind::getReadOnly();
1394  }
1395 }
1396 
1398  // A constant may be a member of both Constants and MachineCPVsSharingEntries,
1399  // so keep track of which we've deleted to avoid double deletions.
1401  for (unsigned i = 0, e = Constants.size(); i != e; ++i)
1402  if (Constants[i].isMachineConstantPoolEntry()) {
1403  Deleted.insert(Constants[i].Val.MachineCPVal);
1404  delete Constants[i].Val.MachineCPVal;
1405  }
1406  for (MachineConstantPoolValue *CPV : MachineCPVsSharingEntries) {
1407  if (Deleted.count(CPV) == 0)
1408  delete CPV;
1409  }
1410 }
1411 
1412 /// Test whether the given two constants can be allocated the same constant pool
1413 /// entry.
1414 static bool CanShareConstantPoolEntry(const Constant *A, const Constant *B,
1415  const DataLayout &DL) {
1416  // Handle the trivial case quickly.
1417  if (A == B) return true;
1418 
1419  // If they have the same type but weren't the same constant, quickly
1420  // reject them.
1421  if (A->getType() == B->getType()) return false;
1422 
1423  // We can't handle structs or arrays.
1424  if (isa<StructType>(A->getType()) || isa<ArrayType>(A->getType()) ||
1425  isa<StructType>(B->getType()) || isa<ArrayType>(B->getType()))
1426  return false;
1427 
1428  // For now, only support constants with the same size.
1429  uint64_t StoreSize = DL.getTypeStoreSize(A->getType());
1430  if (StoreSize != DL.getTypeStoreSize(B->getType()) || StoreSize > 128)
1431  return false;
1432 
1433  Type *IntTy = IntegerType::get(A->getContext(), StoreSize*8);
1434 
1435  // Try constant folding a bitcast of both instructions to an integer. If we
1436  // get two identical ConstantInt's, then we are good to share them. We use
1437  // the constant folding APIs to do this so that we get the benefit of
1438  // DataLayout.
1439  if (isa<PointerType>(A->getType()))
1440  A = ConstantFoldCastOperand(Instruction::PtrToInt,
1441  const_cast<Constant *>(A), IntTy, DL);
1442  else if (A->getType() != IntTy)
1443  A = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(A),
1444  IntTy, DL);
1445  if (isa<PointerType>(B->getType()))
1446  B = ConstantFoldCastOperand(Instruction::PtrToInt,
1447  const_cast<Constant *>(B), IntTy, DL);
1448  else if (B->getType() != IntTy)
1449  B = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(B),
1450  IntTy, DL);
1451 
1452  return A == B;
1453 }
1454 
1455 /// Create a new entry in the constant pool or return an existing one.
1456 /// User must specify the log2 of the minimum required alignment for the object.
1458  Align Alignment) {
1459  if (Alignment > PoolAlignment) PoolAlignment = Alignment;
1460 
1461  // Check to see if we already have this constant.
1462  //
1463  // FIXME, this could be made much more efficient for large constant pools.
1464  for (unsigned i = 0, e = Constants.size(); i != e; ++i)
1465  if (!Constants[i].isMachineConstantPoolEntry() &&
1466  CanShareConstantPoolEntry(Constants[i].Val.ConstVal, C, DL)) {
1467  if (Constants[i].getAlign() < Alignment)
1468  Constants[i].Alignment = Alignment;
1469  return i;
1470  }
1471 
1472  Constants.push_back(MachineConstantPoolEntry(C, Alignment));
1473  return Constants.size()-1;
1474 }
1475 
1477  Align Alignment) {
1478  if (Alignment > PoolAlignment) PoolAlignment = Alignment;
1479 
1480  // Check to see if we already have this constant.
1481  //
1482  // FIXME, this could be made much more efficient for large constant pools.
1483  int Idx = V->getExistingMachineCPValue(this, Alignment);
1484  if (Idx != -1) {
1485  MachineCPVsSharingEntries.insert(V);
1486  return (unsigned)Idx;
1487  }
1488 
1489  Constants.push_back(MachineConstantPoolEntry(V, Alignment));
1490  return Constants.size()-1;
1491 }
1492 
1494  if (Constants.empty()) return;
1495 
1496  OS << "Constant Pool:\n";
1497  for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
1498  OS << " cp#" << i << ": ";
1499  if (Constants[i].isMachineConstantPoolEntry())
1500  Constants[i].Val.MachineCPVal->print(OS);
1501  else
1502  Constants[i].Val.ConstVal->printAsOperand(OS, /*PrintType=*/false);
1503  OS << ", align=" << Constants[i].getAlign().value();
1504  OS << "\n";
1505  }
1506 }
1507 
1508 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1510 #endif
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::MachineRegisterInfo::addLiveIn
void addLiveIn(MCRegister Reg, Register vreg=Register())
addLiveIn - Add the specified register as a live-in.
Definition: MachineRegisterInfo.h:944
i
i
Definition: README.txt:29
llvm::WasmEHFuncInfo
Definition: WasmEHFuncInfo.h:32
llvm::DOTGraphTraits< const MachineFunction * >::getNodeLabel
std::string getNodeLabel(const MachineBasicBlock *Node, const MachineFunction *Graph)
Definition: MachineFunction.cpp:603
llvm::MachineInstr::getDebugInstrNum
unsigned getDebugInstrNum()
Fetch the instruction number of this MachineInstr.
Definition: MachineInstr.cpp:2372
llvm::SectionKind::getReadOnlyWithRel
static SectionKind getReadOnlyWithRel()
Definition: SectionKind.h:207
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:103
llvm::MachineInstr::getOperandNo
unsigned getOperandNo(const_mop_iterator I) const
Returns the number of the operand iterator I points to.
Definition: MachineInstr.h:683
MachineInstr.h
LLVM_DUMP_METHOD
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Definition: Compiler.h:491
llvm::PointerUnion::isNull
bool isNull() const
Test if the pointer held in the union is null, regardless of which type it is.
Definition: PointerUnion.h:142
llvm::MachineRegisterInfo::def_begin
def_iterator def_begin(Register RegNo) const
Definition: MachineRegisterInfo.h:384
llvm::MachineConstantPool::getConstantPoolIndex
unsigned getConstantPoolIndex(const Constant *C, Align Alignment)
getConstantPoolIndex - Create a new entry in the constant pool or return an existing one.
Definition: MachineFunction.cpp:1457
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::MachineJumpTableInfo::RemoveMBBFromJumpTables
bool RemoveMBBFromJumpTables(MachineBasicBlock *MBB)
RemoveMBBFromJumpTables - If MBB is present in any jump tables, remove it.
Definition: MachineFunction.cpp:1307
Reg
unsigned Reg
Definition: MachineSink.cpp:1566
llvm::dwarf::Constants
Constants
Definition: Dwarf.h:427
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
llvm::make_range
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Definition: iterator_range.h:53
TargetFrameLowering.h
llvm::MachineJumpTableInfo::createJumpTableIndex
unsigned createJumpTableIndex(const std::vector< MachineBasicBlock * > &DestBBs)
createJumpTableIndex - Create a new jump table.
Definition: MachineFunction.cpp:1288
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:112
llvm::MachineBasicBlock::getBasicBlock
const BasicBlock * getBasicBlock() const
Return the LLVM basic block that this instance corresponded to originally.
Definition: MachineBasicBlock.h:202
Metadata.h
llvm::MachineRegisterInfo::createVirtualRegister
Register createVirtualRegister(const TargetRegisterClass *RegClass, StringRef Name="")
createVirtualRegister - Create and return a new virtual register in the function with the specified r...
Definition: MachineRegisterInfo.cpp:158
llvm::MachineFunction::DebugInstrOperandPair
std::pair< unsigned, unsigned > DebugInstrOperandPair
Pair of instruction number and operand number.
Definition: MachineFunction.h:452
llvm::MachineFunction::allocateRegMask
uint32_t * allocateRegMask()
Allocate and initialize a register mask with NumRegister bits.
Definition: MachineFunction.cpp:521
llvm::MachineFunctionProperties::print
void print(raw_ostream &OS) const
Print the MachineFunctionProperties in human-readable form.
Definition: MachineFunction.cpp:109
DebugInfoMetadata.h
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:164
llvm::MachineRegisterInfo
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
Definition: MachineRegisterInfo.h:52
llvm::MCContext
Context object for machine code objects.
Definition: MCContext.h:72
llvm::Function
Definition: Function.h:61
llvm::MachineFunctionProperties::Property
Property
Definition: MachineFunction.h:152
llvm::MachineFunction::getContext
MCContext & getContext() const
Definition: MachineFunction.h:578
StringRef.h
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::TargetSubtargetInfo::getInstrInfo
virtual const TargetInstrInfo * getInstrInfo() const
Definition: TargetSubtargetInfo.h:92
llvm::MachineFunction::assignBeginEndSections
void assignBeginEndSections()
Assign IsBeginSection IsEndSection fields for basic blocks in this function.
Definition: MachineFunction.cpp:334
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:625
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:137
llvm::MachineRegisterInfo::def_instr_begin
def_instr_iterator def_instr_begin(Register RegNo) const
Definition: MachineRegisterInfo.h:397
llvm::Function::getFnStackAlign
MaybeAlign getFnStackAlign() const
Return the stack alignment for the function.
Definition: Function.h:429
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
llvm::MachineFunction::useDebugInstrRef
bool useDebugInstrRef() const
Returns true if the function's variable locations should be tracked with instruction referencing.
Definition: MachineFunction.cpp:1224
AlignAllFunctions
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)
llvm::TargetLoweringBase::getPrefFunctionAlignment
Align getPrefFunctionAlignment() const
Return the preferred function alignment.
Definition: TargetLowering.h:1769
llvm::MachineFunction::end
iterator end()
Definition: MachineFunction.h:810
llvm::LandingPadInfo::LandingPadLabel
MCSymbol * LandingPadLabel
Definition: MachineFunction.h:223
llvm::MachineFunction::getMachineMemOperand
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.
Definition: MachineFunction.cpp:430
llvm::MachineMemOperand::getOffset
int64_t getOffset() const
For normal values, this is a byte offset added to the base address.
Definition: MachineMemOperand.h:227
llvm::printMBBReference
Printable printMBBReference(const MachineBasicBlock &MBB)
Prints a machine basic block reference.
Definition: MachineBasicBlock.cpp:119
llvm::MachineRegisterInfo::livein_empty
bool livein_empty() const
Definition: MachineRegisterInfo.h:954
llvm::TargetRegisterInfo::isConstantPhysReg
virtual bool isConstantPhysReg(MCRegister PhysReg) const
Returns true if PhysReg is unallocatable and constant throughout the function.
Definition: TargetRegisterInfo.h:548
ErrorHandling.h
llvm::LandingPadInfo::SEHHandlers
SmallVector< SEHHandler, 1 > SEHHandlers
Definition: MachineFunction.h:222
llvm::MachineFunction::copyCallSiteInfo
void copyCallSiteInfo(const MachineInstr *Old, const MachineInstr *New)
Copy the call site info from Old to \ New.
Definition: MachineFunction.cpp:930
llvm::MCRegisterInfo::getNumRegs
unsigned getNumRegs() const
Return the number of registers this target has (useful for sizing arrays holding per register informa...
Definition: MCRegisterInfo.h:491
llvm::MachineRegisterInfo::getTargetRegisterInfo
const TargetRegisterInfo * getTargetRegisterInfo() const
Definition: MachineRegisterInfo.h:153
llvm::MachineFunction::getOrCreateJumpTableInfo
MachineJumpTableInfo * getOrCreateJumpTableInfo(unsigned JTEntryKind)
getOrCreateJumpTableInfo - Get the JumpTableInfo for this function, if it does already exist,...
Definition: MachineFunction.cpp:267
llvm::MachineFunction::getFunctionNumber
unsigned getFunctionNumber() const
getFunctionNumber - Return a unique ID for the current function.
Definition: MachineFunction.h:601
llvm::MachineInstr::bundleWithPred
void bundleWithPred()
Bundle this instruction with its predecessor.
Definition: MachineInstr.cpp:759
llvm::MachineFunction::back
const MachineBasicBlock & back() const
Definition: MachineFunction.h:822
MachineBasicBlock.h
llvm::ConstantPool
Definition: ConstantPools.h:43
llvm::TargetSubtargetInfo::getRegisterInfo
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
Definition: TargetSubtargetInfo.h:124
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:143
llvm::DenseMapBase::erase
bool erase(const KeyT &Val)
Definition: DenseMap.h:302
llvm::MachineModuleInfo::hasDebugInfo
bool hasDebugInfo() const
Returns true if valid debug info is present.
Definition: MachineModuleInfo.h:203
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:233
llvm::MachineFunction::moveCallSiteInfo
void moveCallSiteInfo(const MachineInstr *Old, const MachineInstr *New)
Move the call site info from Old to \New call site info.
Definition: MachineFunction.cpp:948
llvm::MachineConstantPoolValue
Abstract base class for all machine specific constantpool value subclasses.
Definition: MachineConstantPool.h:35
llvm::AAMDNodes
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:651
llvm::DenseMapIterator
Definition: DenseMap.h:56
llvm::MachineFunction::Delegate::MF_HandleRemoval
virtual void MF_HandleRemoval(MachineInstr &MI)=0
Callback before a removal. This should not modify the MI directly.
MachineJumpTableInfo.h
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
DenseMap.h
Module.h
llvm::reverse
auto reverse(ContainerTy &&C, std::enable_if_t< has_rbegin< ContainerTy >::value > *=nullptr)
Definition: STLExtras.h:329
llvm::MCSymbol::isDefined
bool isDefined() const
isDefined - Check if this symbol is defined (i.e., it has an address).
Definition: MCSymbol.h:243
TargetInstrInfo.h
llvm::SectionKind::getMergeableConst16
static SectionKind getMergeableConst16()
Definition: SectionKind.h:197
llvm::MachineMemOperand
A description of a memory reference used in the backend.
Definition: MachineMemOperand.h:128
EHPersonalities.h
llvm::MachineRegisterInfo::getLiveInVirtReg
Register getLiveInVirtReg(MCRegister PReg) const
getLiveInVirtReg - If PReg is a live-in physical register, return the corresponding live-in virtual r...
Definition: MachineRegisterInfo.cpp:454
llvm::copy
OutputIt copy(R &&Range, OutputIt Out)
Definition: STLExtras.h:1598
llvm::MachineFunction::setCallSiteLandingPad
void setCallSiteLandingPad(MCSymbol *Sym, ArrayRef< unsigned > Sites)
Map the landing pad's EH symbol to the call site indexes.
Definition: MachineFunction.cpp:855
llvm::MachineJumpTableInfo::EK_BlockAddress
@ EK_BlockAddress
EK_BlockAddress - Each entry is a plain address of block, e.g.
Definition: MachineJumpTableInfo.h:49
llvm::MachineFunctionProperties::Property::IsSSA
@ IsSSA
getFnStackAlignment
static unsigned getFnStackAlignment(const TargetSubtargetInfo *STI, const Function &F)
Definition: MachineFunction.cpp:130
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::MachineInstr::peekDebugInstrNum
unsigned peekDebugInstrNum() const
Examine the instruction number of this MachineInstr.
Definition: MachineInstr.h:465
llvm::MachineFunction::addSEHCatchHandler
void addSEHCatchHandler(MachineBasicBlock *LandingPad, const Function *Filter, const BlockAddress *RecoverBA)
Definition: MachineFunction.cpp:836
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:892
llvm::ViewGraph
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:375
llvm::ModuleSlotTracker::incorporateFunction
void incorporateFunction(const Function &F)
Incorporate the given function.
Definition: AsmWriter.cpp:855
STLExtras.h
llvm::MachineFunction::getJTISymbol
MCSymbol * getJTISymbol(unsigned JTI, MCContext &Ctx, bool isLinkerPrivate=false) const
getJTISymbol - Return the MCSymbol for the specified non-empty jump table.
Definition: MachineFunction.cpp:678
llvm::MachineMemOperand::getAAInfo
AAMDNodes getAAInfo() const
Return the AA tags for the memory reference.
Definition: MachineMemOperand.h:258
llvm::MachineJumpTableInfo::EK_Custom32
@ EK_Custom32
EK_Custom32 - Each entry is a 32-bit value that is custom lowered by the TargetLowering::LowerCustomJ...
Definition: MachineJumpTableInfo.h:76
llvm::BitmaskEnumDetail::Mask
std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:80
llvm::ModuleSlotTracker
Manage lifetime of a slot tracker for printing IR.
Definition: ModuleSlotTracker.h:44
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1567
ConstantFolding.h
llvm::SEHHandler::FilterOrFinally
const Function * FilterOrFinally
Filter or finally function. Null indicates a catch-all.
Definition: MachineFunction.h:211
F
#define F(x, y, z)
Definition: MD5.cpp:56
getPropertyName
static const char * getPropertyName(MachineFunctionProperties::Property Prop)
Definition: MachineFunction.cpp:89
llvm::MachineFunction::iterator
BasicBlockListType::iterator iterator
Definition: MachineFunction.h:790
MachineRegisterInfo.h
llvm::iplist_impl::erase
iterator erase(iterator where)
Definition: ilist.h:267
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::MachineJumpTableInfo::getEntrySize
unsigned getEntrySize(const DataLayout &TD) const
getEntrySize - Return the size of each entry in the jump table.
Definition: MachineFunction.cpp:1249
llvm::getBundleEnd
MachineBasicBlock::instr_iterator getBundleEnd(MachineBasicBlock::instr_iterator I)
Returns an iterator pointing beyond the bundle containing I.
Definition: MachineInstrBundle.h:60
llvm::MachineJumpTableInfo::ReplaceMBBInJumpTables
bool ReplaceMBBInJumpTables(MachineBasicBlock *Old, MachineBasicBlock *New)
ReplaceMBBInJumpTables - If Old is the target of any jump tables, update the jump tables to branch to...
Definition: MachineFunction.cpp:1297
llvm::MachineJumpTableInfo::getEntryKind
JTEntryKind getEntryKind() const
Definition: MachineJumpTableInfo.h:84
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::MachineJumpTableInfo::dump
void dump() const
dump - Call to stderr.
Definition: MachineFunction.cpp:1350
llvm::classifyEHPersonality
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
Definition: EHPersonalities.cpp:21
llvm::SectionKind::getReadOnly
static SectionKind getReadOnly()
Definition: SectionKind.h:185
llvm::MachineMemOperand::getPointerInfo
const MachinePointerInfo & getPointerInfo() const
Definition: MachineMemOperand.h:202
LoopDeletionResult::Deleted
@ Deleted
Instruction.h
CommandLine.h
TargetLowering.h
llvm::MachineFunction::substituteDebugValuesForInst
void substituteDebugValuesForInst(const MachineInstr &Old, MachineInstr &New, unsigned MaxOperand=UINT_MAX)
Create substitutions for any tracked values in Old, to point at New.
Definition: MachineFunction.cpp:979
llvm::TargetRegisterClass::contains
bool contains(Register Reg) const
Return true if the specified register is included in this register class.
Definition: TargetRegisterInfo.h:93
bb
< i1 > br i1 label label bb bb
Definition: README.txt:978
llvm::MachineFunction::front
const MachineBasicBlock & front() const
Definition: MachineFunction.h:820
llvm::MachineFunction::getRegInfo
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Definition: MachineFunction.h:636
llvm::MCContext::getOrCreateSymbol
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:191
llvm::TargetInstrInfo
TargetInstrInfo - Interface to description of machine instruction set.
Definition: TargetInstrInfo.h:97
GlobalValue.h
TargetMachine.h
llvm::BumpPtrAllocatorImpl::Allocate
LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void * Allocate(size_t Size, Align Alignment)
Allocate space at the specified alignment.
Definition: Allocator.h:145
llvm::MachineMemOperand::getBaseAlign
Align getBaseAlign() const
Return the minimum known alignment in bytes of the base address, without the offset.
Definition: MachineMemOperand.h:255
llvm::LandingPadInfo::EndLabels
SmallVector< MCSymbol *, 1 > EndLabels
Definition: MachineFunction.h:221
SmallString.h
f
Itanium Name Demangler i e convert the string _Z1fv into f()". You can also use the CRTP base ManglingParser to perform some simple analysis on the mangled name
llvm::MachineFrameInfo::ensureMaxAlignment
void ensureMaxAlignment(Align Alignment)
Make sure the function is at least Align bytes aligned.
Definition: MachineFrameInfo.cpp:31
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::MachineOperand::getRegMaskSize
static unsigned getRegMaskSize(unsigned NumRegs)
Returns number of elements needed for a regmask array.
Definition: MachineOperand.h:636
llvm::ConstantFoldCastOperand
Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
Definition: ConstantFolding.cpp:1379
llvm::MachineMemOperand::getValue
const Value * getValue() const
Return the base address of the memory access.
Definition: MachineMemOperand.h:211
llvm::TargetFrameLowering::getStackAlign
Align getStackAlign() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
Definition: TargetFrameLowering.h:100
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::MachineInstr::getOperand
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:499
llvm::MachineFunction::getDenormalMode
DenormalMode getDenormalMode(const fltSemantics &FPType) const
Returns the denormal handling type for the default rounding mode of the function.
Definition: MachineFunction.cpp:275
llvm::TargetOptions::ForceDwarfFrameSection
unsigned ForceDwarfFrameSection
Emit DWARF debug frame section.
Definition: TargetOptions.h:333
Twine.h
llvm::MachineFunction::salvageCopySSA
DebugInstrOperandPair salvageCopySSA(MachineInstr &MI)
Find the underlying defining instruction / operand for a COPY instruction while in SSA form.
Definition: MachineFunction.cpp:1008
llvm::MachineFunction::addCatchTypeInfo
void addCatchTypeInfo(MachineBasicBlock *LandingPad, ArrayRef< const GlobalValue * > TyInfo)
Provide the catch typeinfo for a landing pad.
Definition: MachineFunction.cpp:769
llvm::RegState::Debug
@ Debug
Register 'use' is for debugging purpose.
Definition: MachineInstrBuilder.h:56
MCContext.h
llvm::TargetLoweringBase::getMinFunctionAlignment
Align getMinFunctionAlignment() const
Return the minimum function alignment.
Definition: TargetLowering.h:1766
llvm::DataLayout::getABIIntegerTypeAlignment
Align getABIIntegerTypeAlignment(unsigned BitWidth) const
Returns the minimum ABI-required alignment for an integer type of the specified bitwidth.
Definition: DataLayout.h:531
llvm::MachineFunction::DeleteMachineInstr
void DeleteMachineInstr(MachineInstr *MI)
DeleteMachineInstr - Delete the given MachineInstr.
Definition: MachineFunction.cpp:393
llvm::MachineJumpTableEntry::MBBs
std::vector< MachineBasicBlock * > MBBs
MBBs - The vector of basic blocks from which to create the jump table.
Definition: MachineJumpTableInfo.h:36
llvm::MachineFrameInfo::print
void print(const MachineFunction &MF, raw_ostream &OS) const
Used by the MachineFunction printer to print information about stack objects.
Definition: MachineFrameInfo.cpp:212
llvm::TargetRegisterClass
Definition: TargetRegisterInfo.h:46
llvm::MachineFunctionInfo::~MachineFunctionInfo
virtual ~MachineFunctionInfo()
MCSymbol.h
llvm::MachineFunction::getProperties
const MachineFunctionProperties & getProperties() const
Get the function properties.
Definition: MachineFunction.h:717
DenseSet.h
llvm::LandingPadInfo::TypeIds
std::vector< int > TypeIds
Definition: MachineFunction.h:224
PseudoSourceValue.h
TII
const HexagonInstrInfo * TII
Definition: HexagonCopyToCombine.cpp:129
llvm::MachineFunction::setDebugInstrNumberingCount
void setDebugInstrNumberingCount(unsigned Num)
Set value of DebugInstrNumberingCount field.
Definition: MachineFunction.cpp:967
llvm::MachineFunction::size
unsigned size() const
Definition: MachineFunction.h:818
llvm::MachineConstantPoolEntry::getSectionKind
SectionKind getSectionKind(const DataLayout *DL) const
Definition: MachineFunction.cpp:1380
llvm::MachineFunction::getTypeIDFor
unsigned getTypeIDFor(const GlobalValue *TI)
Return the type id for the specified typeinfo. This is function wide.
Definition: MachineFunction.cpp:860
llvm::MCInstrDesc
Describe properties that are true of each instruction in the target description file.
Definition: MCInstrDesc.h:195
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:49
llvm::MachineFunctionProperties::set
MachineFunctionProperties & set(Property P)
Definition: MachineFunction.h:169
llvm::MachineConstantPoolEntry::Val
union llvm::MachineConstantPoolEntry::@180 Val
The constant itself.
llvm::Instruction
Definition: Instruction.h:45
llvm::MachineModuleInfo
This class contains meta information specific to a module.
Definition: MachineModuleInfo.h:78
llvm::MachineInstr::shouldUpdateCallSiteInfo
bool shouldUpdateCallSiteInfo() const
Return true if copying, moving, or erasing this instruction requires updating Call Site Info (see cop...
Definition: MachineInstr.cpp:720
llvm::TargetFrameLowering::isStackRealignable
bool isStackRealignable() const
isStackRealignable - This method returns whether the stack can be realigned.
Definition: TargetFrameLowering.h:122
llvm::MachineFunction::viewCFG
void viewCFG() const
viewCFG - This function is meant for use from the debugger.
Definition: MachineFunction.cpp:631
Options
const char LLVMTargetMachineRef LLVMPassBuilderOptionsRef Options
Definition: PassBuilderBindings.cpp:48
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::Function::hasPersonalityFn
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:785
llvm::MachineFunction::shouldSplitStack
bool shouldSplitStack() const
Should we be emitting segmented stack stuff for the function.
Definition: MachineFunction.cpp:280
llvm::TargetRegisterInfo::regsOverlap
bool regsOverlap(Register regA, Register regB) const
Returns true if the two registers are equal or alias each other.
Definition: TargetRegisterInfo.h:418
BitVector.h
llvm::MachineFunction::begin
iterator begin()
Definition: MachineFunction.h:808
llvm::SlotIndexes
SlotIndexes pass.
Definition: SlotIndexes.h:314
llvm::MachineConstantPool::~MachineConstantPool
~MachineConstantPool()
Definition: MachineFunction.cpp:1397
llvm::MachineFunction::addFilterTypeInfo
void addFilterTypeInfo(MachineBasicBlock *LandingPad, ArrayRef< const GlobalValue * > TyInfo)
Provide the filter typeinfo for a landing pad.
Definition: MachineFunction.cpp:776
llvm::printJumpTableEntryReference
Printable printJumpTableEntryReference(unsigned Idx)
Prints a jump table entry reference.
Definition: MachineFunction.cpp:1353
llvm::MachineRegisterInfo::livein_begin
livein_iterator livein_begin() const
Definition: MachineRegisterInfo.h:952
CanShareConstantPoolEntry
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.
Definition: MachineFunction.cpp:1414
Align
uint64_t Align
Definition: ELFObjHandler.cpp:83
llvm::BasicBlock::getFirstNonPHI
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:212
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::MachineOperand::getParent
MachineInstr * getParent()
getParent - Return the instruction that this operand belongs to.
Definition: MachineOperand.h:238
llvm::MachineMemOperand::getSyncScopeID
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID for this memory operation.
Definition: MachineMemOperand.h:264
llvm::MachineFunction::tidyLandingPads
void tidyLandingPads(DenseMap< MCSymbol *, uintptr_t > *LPMap=nullptr, bool TidyIfNoBeginLabels=true)
Remap landing pad labels and remove any deleted landing pads.
Definition: MachineFunction.cpp:785
llvm::MachineFunction::addInvoke
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...
Definition: MachineFunction.cpp:715
llvm::MCCFIInstruction
Definition: MCDwarf.h:434
getCallInstr
static const MachineInstr * getCallInstr(const MachineInstr *MI)
Return the call machine instruction or find a call within bundle.
Definition: MachineFunction.cpp:906
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
llvm::SmallString
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:25
llvm::MachineFunction::viewCFGOnly
void viewCFGOnly() const
viewCFGOnly - This function is meant for use from the debugger.
Definition: MachineFunction.cpp:641
llvm::MachineJumpTableInfo::EK_LabelDifference32
@ EK_LabelDifference32
EK_LabelDifference32 - Each entry is the address of the block minus the address of the jump table.
Definition: MachineJumpTableInfo.h:68
llvm::DOTGraphTraits
DOTGraphTraits - Template class that can be specialized to customize how graphs are converted to 'dot...
Definition: DOTGraphTraits.h:161
llvm::MachineRegisterInfo::getRegClass
const TargetRegisterClass * getRegClass(Register Reg) const
Return the register class of the specified virtual register.
Definition: MachineRegisterInfo.h:634
llvm::ARM_PROC::IE
@ IE
Definition: ARMBaseInfo.h:27
llvm::DOTGraphTraits< const MachineFunction * >::getGraphName
static std::string getGraphName(const MachineFunction *F)
Definition: MachineFunction.cpp:599
llvm::MachineFunction::getMMI
MachineModuleInfo & getMMI() const
Definition: MachineFunction.h:577
llvm::MachineFunction::deallocateOperandArray
void deallocateOperandArray(OperandCapacity Cap, MachineOperand *Array)
Dellocate an array of MachineOperands and recycle the memory.
Definition: MachineFunction.h:970
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
llvm::MachineFunction::getSubtarget
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Definition: MachineFunction.h:626
llvm::AtomicOrdering
AtomicOrdering
Atomic ordering for LLVM's memory model.
Definition: AtomicOrdering.h:56
llvm::Function::hasFnAttribute
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:626
BasicBlock.h
llvm::cl::opt
Definition: CommandLine.h:1434
llvm::ClrHandlerType::Filter
@ Filter
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::MachineJumpTableInfo::EK_GPRel64BlockAddress
@ EK_GPRel64BlockAddress
EK_GPRel64BlockAddress - Each entry is an address of block, encoded with a relocation as gp-relative,...
Definition: MachineJumpTableInfo.h:54
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::WinEHFuncInfo
Definition: WinEHFuncInfo.h:90
llvm::MachineConstantPoolValue::getSizeInBytes
virtual unsigned getSizeInBytes(const DataLayout &DL) const
Definition: MachineFunction.cpp:1363
llvm::LandingPadInfo::BeginLabels
SmallVector< MCSymbol *, 1 > BeginLabels
Definition: MachineFunction.h:220
llvm::MachineFunctionProperties::Property::TracksLiveness
@ TracksLiveness
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
uint64_t
llvm::MachineFunction::createMIExtraInfo
MachineInstr::ExtraInfo * createMIExtraInfo(ArrayRef< MachineMemOperand * > MMOs, MCSymbol *PreInstrSymbol=nullptr, MCSymbol *PostInstrSymbol=nullptr, MDNode *HeapAllocMarker=nullptr)
Allocate and construct an extra info structure for a MachineInstr.
Definition: MachineFunction.cpp:507
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:572
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
llvm::MachineFunction::addSEHCleanupHandler
void addSEHCleanupHandler(MachineBasicBlock *LandingPad, const Function *Cleanup)
Definition: MachineFunction.cpp:846
llvm::MachineFunction::CloneMachineInstr
MachineInstr * CloneMachineInstr(const MachineInstr *Orig)
Create a new MachineInstr which is a copy of Orig, identical in all ways except the instruction has n...
Definition: MachineFunction.cpp:358
s
multiplies can be turned into SHL s
Definition: README.txt:370
llvm::MachinePointerInfo
This class contains a discriminated union of information about pointers in memory operands,...
Definition: MachineMemOperand.h:38
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::TargetRegisterInfo::getFrameRegister
virtual Register getFrameRegister(const MachineFunction &MF) const =0
Debug information queries.
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::DenseMap
Definition: DenseMap.h:714
llvm::SyncScope::ID
uint8_t ID
Definition: LLVMContext.h:47
llvm::MachineConstantPool
The MachineConstantPool class keeps track of constants referenced by a function which must be spilled...
Definition: MachineConstantPool.h:117
llvm::MachineFunction::dump
void dump() const
dump - Print the current MachineFunction to cerr, useful for debugger use.
Definition: MachineFunction.cpp:536
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::isScopedEHPersonality
bool isScopedEHPersonality(EHPersonality Pers)
Returns true if this personality uses scope-style EH IR instructions: catchswitch,...
Definition: EHPersonalities.h:80
llvm::DenormalMode
Represent subnormal handling kind for floating point instruction inputs and outputs.
Definition: FloatingPointMode.h:67
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:443
llvm::MachineBasicBlock::getFirstNonPHI
iterator getFirstNonPHI()
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: MachineBasicBlock.cpp:200
MachineConstantPool.h
llvm::MachineJumpTableInfo::JTEntryKind
JTEntryKind
JTEntryKind - This enum indicates how each entry of the jump table is represented and emitted.
Definition: MachineJumpTableInfo.h:46
llvm::MachineFunction::CreateMachineBasicBlock
MachineBasicBlock * CreateMachineBasicBlock(const BasicBlock *bb=nullptr)
CreateMachineBasicBlock - Allocate a new MachineBasicBlock.
Definition: MachineFunction.cpp:414
llvm::MachineFunction::finalizeDebugInstrRefs
void finalizeDebugInstrRefs()
Finalise any partially emitted debug instructions.
Definition: MachineFunction.cpp:1167
llvm::MachineBasicBlock::setIsEndSection
void setIsEndSection(bool V=true)
Definition: MachineBasicBlock.h:571
llvm::DenseMapBase::find
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:150
llvm::MachineMemOperand::Flags
Flags
Flags values. These may be or'd together.
Definition: MachineMemOperand.h:131
llvm::MachineFunction::getName
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
Definition: MachineFunction.cpp:541
llvm::TargetMachine::Options
TargetOptions Options
Definition: TargetMachine.h:120
llvm::MachineFunction::~MachineFunction
~MachineFunction()
Definition: MachineFunction.cpp:210
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::MachineConstantPoolEntry::isMachineConstantPoolEntry
bool isMachineConstantPoolEntry() const
isMachineConstantPoolEntry - Return true if the MachineConstantPoolEntry is indeed a target specific ...
Definition: MachineConstantPool.h:93
llvm::LandingPadInfo::LandingPadBlock
MachineBasicBlock * LandingPadBlock
Definition: MachineFunction.h:219
llvm::DataLayout::getPointerABIAlignment
Align getPointerABIAlignment(unsigned AS) const
Layout pointer alignment.
Definition: DataLayout.cpp:693
llvm::MachineBasicBlock::getParent
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
Definition: MachineBasicBlock.h:225
llvm::BitVector::size_type
unsigned size_type
Definition: BitVector.h:88
llvm::MachineMemOperand::getSuccessOrdering
AtomicOrdering getSuccessOrdering() const
Return the atomic ordering requirements for this memory operation.
Definition: MachineMemOperand.h:271
llvm::MachineFunction::makeDebugValueSubstitution
void makeDebugValueSubstitution(DebugInstrOperandPair, DebugInstrOperandPair, unsigned SubReg=0)
Create a substitution between one <instr,operand> value to a different, new value.
Definition: MachineFunction.cpp:971
MachineModuleInfo.h
llvm::MachineOperand::getReg
Register getReg() const
getReg - Returns the register number.
Definition: MachineOperand.h:360
llvm::MachineRegisterInfo::hasOneDef
bool hasOneDef(Register RegNo) const
Return true if there is exactly one operand defining the specified register.
Definition: MachineRegisterInfo.h:444
llvm::MDNode
Metadata node.
Definition: Metadata.h:901
llvm::MachinePointerInfo::getWithOffset
MachinePointerInfo getWithOffset(int64_t O) const
Definition: MachineMemOperand.h:80
llvm::ArrayRecycler::clear
void clear(AllocatorType &Allocator)
Release all the tracked allocations to the allocator.
Definition: ArrayRecycler.h:104
Builder
assume Assume Builder
Definition: AssumeBundleBuilder.cpp:650
llvm::MachineFunction
Definition: MachineFunction.h:230
llvm::MachineConstantPoolEntry::needsRelocation
bool needsRelocation() const
This method classifies the entry according to whether or not it may generate a relocation entry.
Definition: MachineFunction.cpp:1373
llvm::MachineFunction::addLiveIn
Register addLiveIn(MCRegister PReg, const TargetRegisterClass *RC)
addLiveIn - Add the specified physical register as a live-in value and create a corresponding virtual...
Definition: MachineFunction.cpp:653
llvm::CodeGenOpt::None
@ None
Definition: CodeGen.h:53
llvm::sys::fs::remove
std::error_code remove(const Twine &path, bool IgnoreNonExisting=true)
Remove path.
llvm::BlockAddress
The address of a basic block.
Definition: Constants.h:848
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::MachineBasicBlock::getNumber
int getNumber() const
MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a MachineFuncti...
Definition: MachineBasicBlock.h:1056
llvm::MachinePointerInfo::V
PointerUnion< const Value *, const PseudoSourceValue * > V
This is the IR pointer value for the access, or it is null if unknown.
Definition: MachineMemOperand.h:42
llvm::min
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:357
DataLayout.h
llvm::MachineFunction::DeleteMachineBasicBlock
void DeleteMachineBasicBlock(MachineBasicBlock *MBB)
DeleteMachineBasicBlock - Delete the given MachineBasicBlock.
Definition: MachineFunction.cpp:421
llvm::MachineFunction::allocateShuffleMask
ArrayRef< int > allocateShuffleMask(ArrayRef< int > Mask)
Definition: MachineFunction.cpp:529
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
MBBI
MachineBasicBlock MachineBasicBlock::iterator MBBI
Definition: AArch64SLSHardening.cpp:75
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
A
* A
Definition: README_ALTIVEC.txt:89
getParent
static const Function * getParent(const Value *V)
Definition: BasicAliasAnalysis.cpp:776
uint32_t
Compiler.h
llvm::getBundleStart
MachineBasicBlock::instr_iterator getBundleStart(MachineBasicBlock::instr_iterator I)
Returns an iterator to the first instruction in the bundle containing I.
Definition: MachineInstrBundle.h:44
llvm::append_range
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:1744
llvm::ilist_node_impl::getIterator
self_iterator getIterator()
Definition: ilist_node.h:81
llvm::MachineJumpTableInfo::print
void print(raw_ostream &OS) const
print - Used by the MachineFunction printer to print information about jump tables.
Definition: MachineFunction.cpp:1333
TargetSubtargetInfo.h
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::MachineJumpTableInfo::ReplaceMBBInJumpTable
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...
Definition: MachineFunction.cpp:1319
llvm::MachineFunctionProperties::reset
MachineFunctionProperties & reset(Property P)
Definition: MachineFunction.h:174
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:297
llvm::MCContext::createTempSymbol
MCSymbol * createTempSymbol()
Create a temporary symbol with a unique name.
Definition: MCContext.cpp:303
llvm::TargetSubtargetInfo
TargetSubtargetInfo - Generic base class for all target subtargets.
Definition: TargetSubtargetInfo.h:59
llvm::MachineBasicBlock::getSectionID
MBBSectionID getSectionID() const
Returns the section ID of this basic block.
Definition: MachineBasicBlock.h:574
llvm::MachineFunction::DebugInstrNumberingCount
unsigned DebugInstrNumberingCount
A count of how many instructions in the function have had numbers assigned to them.
Definition: MachineFunction.h:445
llvm::Function::getDenormalMode
DenormalMode getDenormalMode(const fltSemantics &FPType) const
Returns the denormal handling type for the default rounding mode of the function.
Definition: Function.cpp:672
llvm::MachineFunction::CloneMachineInstrBundle
MachineInstr & CloneMachineInstrBundle(MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore, const MachineInstr &Orig)
Clones instruction or the whole instruction bundle Orig and insert into MBB before InsertBefore.
Definition: MachineFunction.cpp:363
MRI
unsigned const MachineRegisterInfo * MRI
Definition: AArch64AdvSIMDScalarPass.cpp:105
llvm::Value::stripPointerCasts
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Definition: Value.cpp:675
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::MachineFunction::getFilterIDFor
int getFilterIDFor(std::vector< unsigned > &TyIds)
Return the id of the filter encoded by TyIds. This is function wide.
Definition: MachineFunction.cpp:868
llvm::MachineBasicBlock::setNumber
void setNumber(int N)
Definition: MachineBasicBlock.h:1057
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
Attributes.h
j
return j(j<< 16)
llvm::SectionKind::getMergeableConst8
static SectionKind getMergeableConst8()
Definition: SectionKind.h:196
Constant.h
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::commonAlignment
Align commonAlignment(Align A, Align B)
Returns the alignment that satisfies both alignments.
Definition: Alignment.h:211
llvm::SectionKind
SectionKind - This is a simple POD value that classifies the properties of a section.
Definition: SectionKind.h:22
llvm::MachineConstantPoolEntry
This class is a data container for one entry in a MachineConstantPool.
Definition: MachineConstantPool.h:67
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
GraphWriter.h
llvm::MachineFunction::getFunction
Function & getFunction()
Return the LLVM function that this machine code represents.
Definition: MachineFunction.h:592
llvm::TargetSubtargetInfo::getFrameLowering
virtual const TargetFrameLowering * getFrameLowering() const
Definition: TargetSubtargetInfo.h:93
llvm::MachineFunction::needsFrameMoves
bool needsFrameMoves() const
True if this function needs frame moves for debug or exceptions.
Definition: MachineFunction.cpp:587
llvm::MachineInstr::isCopyLike
bool isCopyLike() const
Return true if the instruction behaves like a copy.
Definition: MachineInstr.h:1305
llvm::MachineFunction::getTarget
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
Definition: MachineFunction.h:622
llvm::DenseMapBase::end
iterator end()
Definition: DenseMap.h:83
llvm::ArrayRef::begin
iterator begin() const
Definition: ArrayRef.h:153
llvm::MachineBasicBlock::insert
instr_iterator insert(instr_iterator I, MachineInstr *M)
Insert MI into the instruction list before I, possibly inside a bundle.
Definition: MachineBasicBlock.cpp:1312
llvm::ilist_iterator
Iterator for intrusive lists based on ilist_node.
Definition: ilist_iterator.h:57
MachineFrameInfo.h
llvm::Align::value
uint64_t value() const
This is a hole in the type system and should not be abused.
Definition: Alignment.h:85
WasmEHFuncInfo.h
llvm::MachineMemOperand::getSize
uint64_t getSize() const
Return the size in bytes of the memory reference.
Definition: MachineMemOperand.h:236
llvm::MachineJumpTableInfo::EK_Inline
@ EK_Inline
EK_Inline - Jump table entries are emitted inline at their point of use.
Definition: MachineJumpTableInfo.h:72
llvm::MachineBasicBlock::setIsBeginSection
void setIsBeginSection(bool V=true)
Definition: MachineBasicBlock.h:569
Casting.h
llvm::fltSemantics
Definition: APFloat.cpp:54
llvm::MachineRegisterInfo::livein_iterator
std::vector< std::pair< MCRegister, Register > >::const_iterator livein_iterator
Definition: MachineRegisterInfo.h:951
Function.h
llvm::MachineFunction::print
void print(raw_ostream &OS, const SlotIndexes *=nullptr) const
print - Print out the MachineFunction in a format suitable for debugging to the specified stream.
Definition: MachineFunction.cpp:545
llvm::MachineJumpTableEntry
MachineJumpTableEntry - One jump table in the jump table info.
Definition: MachineJumpTableInfo.h:34
DOTGraphTraits.h
LLVM_NODISCARD
#define LLVM_NODISCARD
LLVM_NODISCARD - Warn if a type or return value is discarded.
Definition: Compiler.h:161
llvm::Function::needsUnwindTableEntry
bool needsUnwindTableEntry() const
True if this function needs an unwind table.
Definition: Function.h:646
llvm::LLVMTargetMachine
This class describes a target machine that is implemented with the LLVM target-independent code gener...
Definition: TargetMachine.h:393
llvm::SmallVectorImpl::clear
void clear()
Definition: SmallVector.h:585
llvm::MachineFunction::MachineFunction
MachineFunction(Function &F, const LLVMTargetMachine &Target, const TargetSubtargetInfo &STI, unsigned FunctionNum, MachineModuleInfo &MMI)
Definition: MachineFunction.cpp:137
isSimple
static bool isSimple(Instruction *I)
Definition: SLPVectorizer.cpp:528
llvm::Function::getPersonalityFn
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1823
SectionKind.h
llvm::MachineFunction::addCleanup
void addCleanup(MachineBasicBlock *LandingPad)
Add a cleanup action for a landing pad.
Definition: MachineFunction.cpp:831
llvm::MachineConstantPool::print
void print(raw_ostream &OS) const
print - Used by the MachineFunction printer to print information about constant pool objects.
Definition: MachineFunction.cpp:1493
llvm::getAlign
bool getAlign(const Function &F, unsigned index, unsigned &align)
Definition: NVPTXUtilities.cpp:284
WinEHFuncInfo.h
llvm::MachineFunction::getPICBaseSymbol
MCSymbol * getPICBaseSymbol() const
getPICBaseSymbol - Return a function-local symbol to represent the PIC base.
Definition: MachineFunction.cpp:693
llvm::SEHHandler
Definition: MachineFunction.h:209
llvm::MachineFunction::addFrameInst
LLVM_NODISCARD unsigned addFrameInst(const MCCFIInstruction &Inst)
Definition: MachineFunction.cpp:285
llvm::MachineFrameInfo
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
Definition: MachineFrameInfo.h:107
Instructions.h
llvm::TargetSubtargetInfo::getTargetLowering
virtual const TargetLowering * getTargetLowering() const
Definition: TargetSubtargetInfo.h:96
SmallVector.h
llvm::ilist_alloc_traits::deleteNode
static void deleteNode(NodeTy *V)
Definition: ilist.h:41
llvm::MachineConstantPoolValue::getExistingMachineCPValue
virtual int getExistingMachineCPValue(MachineConstantPool *CP, Align Alignment)=0
llvm::Printable
Simple wrapper around std::function<void(raw_ostream&)>.
Definition: Printable.h:38
llvm::MachineModuleInfo::addPersonality
void addPersonality(const Function *Personality)
Provide the personality function for the exception information.
Definition: MachineModuleInfo.cpp:278
llvm::BuildMI
MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
Definition: MachineInstrBuilder.h:328
llvm::SectionKind::getMergeableConst4
static SectionKind getMergeableConst4()
Definition: SectionKind.h:195
N
#define N
DefMI
MachineInstrBuilder MachineInstrBuilder & DefMI
Definition: AArch64ExpandPseudoInsts.cpp:103
llvm::MachineFunction::DebugValueSubstitutions
SmallVector< DebugSubstitution, 8 > DebugValueSubstitutions
Debug value substitutions: a collection of DebugSubstitution objects, recording changes in where a va...
Definition: MachineFunction.h:484
llvm::MachineInstr::getNumOperands
unsigned getNumOperands() const
Retuns the total number of operands.
Definition: MachineInstr.h:492
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
llvm::max
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:340
llvm::MachineFunction::getDataLayout
const DataLayout & getDataLayout() const
Return the DataLayout attached to the Module associated to this MF.
Definition: MachineFunction.cpp:260
llvm::raw_svector_ostream
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:658
llvm::MachineJumpTableInfo::EK_GPRel32BlockAddress
@ EK_GPRel32BlockAddress
EK_GPRel32BlockAddress - Each entry is an address of block, encoded with a relocation as gp-relative,...
Definition: MachineJumpTableInfo.h:59
ModuleSlotTracker.h
MachineMemOperand.h
llvm::DefaultDOTGraphTraits
DefaultDOTGraphTraits - This class provides the default implementations of all of the DOTGraphTraits ...
Definition: DOTGraphTraits.h:28
llvm::MachineMemOperand::getFailureOrdering
AtomicOrdering getFailureOrdering() const
For cmpxchg atomic operations, return the atomic ordering requirements when store does not occur.
Definition: MachineMemOperand.h:277
llvm::Module::getDataLayout
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:401
DerivedTypes.h
llvm::LandingPadInfo
This structure is used to retain landing pad info for the current function.
Definition: MachineFunction.h:218
llvm::IntegerType::get
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:275
llvm::TargetRegisterClass::hasSubClassEq
bool hasSubClassEq(const TargetRegisterClass *RC) const
Returns true if RC is a sub-class of or equal to this class.
Definition: TargetRegisterInfo.h:126
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::MachineFunction::createExternalSymbolName
const char * createExternalSymbolName(StringRef Name)
Allocate a string and populate it with the given external symbol name.
Definition: MachineFunction.cpp:514
llvm::MachineJumpTableInfo::getEntryAlignment
unsigned getEntryAlignment(const DataLayout &TD) const
getEntryAlignment - Return the alignment of each entry in the jump table.
Definition: MachineFunction.cpp:1268
llvm::MachineFunction::CreateMachineInstr
MachineInstr * CreateMachineInstr(const MCInstrDesc &MCID, const DebugLoc &DL, bool NoImplicit=false)
CreateMachineInstr - Allocate a new MachineInstr.
Definition: MachineFunction.cpp:348
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
llvm::MachineFunction::addLandingPad
MCSymbol * addLandingPad(MachineBasicBlock *LandingPad)
Add a new panding pad, and extract the exception handling information from the landingpad instruction...
Definition: MachineFunction.cpp:722
llvm::cl::desc
Definition: CommandLine.h:414
llvm::MachineJumpTableInfo
Definition: MachineJumpTableInfo.h:42
llvm::SectionKind::getMergeableConst32
static SectionKind getMergeableConst32()
Definition: SectionKind.h:198
raw_ostream.h
llvm::MachineMemOperand::getRanges
const MDNode * getRanges() const
Return the range tag for the memory reference.
Definition: MachineMemOperand.h:261
llvm::MachineConstantPool::dump
void dump() const
dump - Call print(cerr) to be called from the debugger.
Definition: MachineFunction.cpp:1509
llvm::MachineFunction::empty
bool empty() const
Definition: MachineFunction.h:819
MachineFunction.h
llvm::printReg
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.
Definition: TargetRegisterInfo.cpp:110
llvm::MachineFunction::eraseCallSiteInfo
void eraseCallSiteInfo(const MachineInstr *MI)
Following functions update call site info.
Definition: MachineFunction.cpp:918
llvm::MachineFunction::VariableDbgInfos
VariableDbgInfoMapTy VariableDbgInfos
Definition: MachineFunction.h:440
llvm::MachineInstrBundleIterator< MachineInstr >
Value.h
llvm::MachineRegisterInfo::livein_end
livein_iterator livein_end() const
Definition: MachineRegisterInfo.h:953
llvm::SEHHandler::RecoverBA
const BlockAddress * RecoverBA
Address of block to recover at. Null for a finally handler.
Definition: MachineFunction.h:214
llvm::DOTGraphTraits< const MachineFunction * >::DOTGraphTraits
DOTGraphTraits(bool isSimple=false)
Definition: MachineFunction.cpp:597
llvm::MachineInstr::operands
iterator_range< mop_iterator > operands()
Definition: MachineInstr.h:618
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::MachineMemOperand::getFlags
Flags getFlags() const
Return the raw flags of the source value,.
Definition: MachineMemOperand.h:220
TargetRegisterInfo.h
Debug.h
llvm::BumpPtrAllocatorImpl::Deallocate
void Deallocate(const void *Ptr, size_t Size, size_t)
Definition: Allocator.h:213
SubReg
unsigned SubReg
Definition: AArch64AdvSIMDScalarPass.cpp:104
llvm::MachineFunction::RenumberBlocks
void RenumberBlocks(MachineBasicBlock *MBBFrom=nullptr)
RenumberBlocks - This discards all of the MachineBasicBlock numbers and recomputes them.
Definition: MachineFunction.cpp:294
llvm::ArrayRef::end
iterator end() const
Definition: ArrayRef.h:154
llvm::MachineFunction::getOrCreateLandingPadInfo
LandingPadInfo & getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad)
Find or create an LandingPadInfo for the specified MachineBasicBlock.
Definition: MachineFunction.cpp:703
llvm::isFuncletEHPersonality
bool isFuncletEHPersonality(EHPersonality Pers)
Returns true if this is a personality function that invokes handler funclets (which must return to it...
Definition: EHPersonalities.h:65
llvm::DataLayout::getPointerSize
unsigned getPointerSize(unsigned AS=0) const
Layout pointer size FIXME: The defaults need to be removed once all of the backends/clients are updat...
Definition: DataLayout.cpp:701
llvm::MachineConstantPoolEntry::getSizeInBytes
unsigned getSizeInBytes(const DataLayout &DL) const
Definition: MachineFunction.cpp:1367
llvm::Use
A Use represents the edge between a Value definition and its users.
Definition: Use.h:44
llvm::MCRegister
Wrapper class representing physical registers. Should be passed by value.
Definition: MCRegister.h:23
llvm::MachineMemOperand::getPseudoValue
const PseudoSourceValue * getPseudoValue() const
Definition: MachineMemOperand.h:213
llvm::MachineFunction::Delegate::MF_HandleInsertion
virtual void MF_HandleInsertion(MachineInstr &MI)=0
Callback after an insertion. This should not modify the MI directly.
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37
llvm::LLT
Definition: LowLevelTypeImpl.h:40