LLVM  10.0.0svn
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"
41 #include "llvm/Config/llvm-config.h"
42 #include "llvm/IR/Attributes.h"
43 #include "llvm/IR/BasicBlock.h"
44 #include "llvm/IR/Constant.h"
45 #include "llvm/IR/DataLayout.h"
47 #include "llvm/IR/DerivedTypes.h"
48 #include "llvm/IR/Function.h"
49 #include "llvm/IR/GlobalValue.h"
50 #include "llvm/IR/Instruction.h"
51 #include "llvm/IR/Instructions.h"
52 #include "llvm/IR/Metadata.h"
53 #include "llvm/IR/Module.h"
55 #include "llvm/IR/Value.h"
56 #include "llvm/MC/MCContext.h"
57 #include "llvm/MC/MCSymbol.h"
58 #include "llvm/MC/SectionKind.h"
59 #include "llvm/Support/Casting.h"
61 #include "llvm/Support/Compiler.h"
63 #include "llvm/Support/Debug.h"
68 #include <algorithm>
69 #include <cassert>
70 #include <cstddef>
71 #include <cstdint>
72 #include <iterator>
73 #include <string>
74 #include <utility>
75 #include <vector>
76 
77 using namespace llvm;
78 
79 #define DEBUG_TYPE "codegen"
80 
82  "align-all-functions",
83  cl::desc("Force the alignment of all functions in log2 format (e.g. 4 "
84  "means align on 16B boundaries)."),
85  cl::init(0), cl::Hidden);
86 
89 
90  switch(Prop) {
91  case P::FailedISel: return "FailedISel";
92  case P::IsSSA: return "IsSSA";
93  case P::Legalized: return "Legalized";
94  case P::NoPHIs: return "NoPHIs";
95  case P::NoVRegs: return "NoVRegs";
96  case P::RegBankSelected: return "RegBankSelected";
97  case P::Selected: return "Selected";
98  case P::TracksLiveness: return "TracksLiveness";
99  }
100  llvm_unreachable("Invalid machine function property");
101 }
102 
103 // Pin the vtable to this file.
104 void MachineFunction::Delegate::anchor() {}
105 
107  const char *Separator = "";
108  for (BitVector::size_type I = 0; I < Properties.size(); ++I) {
109  if (!Properties[I])
110  continue;
111  OS << Separator << getPropertyName(static_cast<Property>(I));
112  Separator = ", ";
113  }
114 }
115 
116 //===----------------------------------------------------------------------===//
117 // MachineFunction implementation
118 //===----------------------------------------------------------------------===//
119 
120 // Out-of-line virtual method.
122 
124  MBB->getParent()->DeleteMachineBasicBlock(MBB);
125 }
126 
127 static inline unsigned getFnStackAlignment(const TargetSubtargetInfo *STI,
128  const Function &F) {
129  if (F.hasFnAttribute(Attribute::StackAlignment))
130  return F.getFnStackAlignment();
131  return STI->getFrameLowering()->getStackAlignment();
132 }
133 
135  const LLVMTargetMachine &Target,
136  const TargetSubtargetInfo &STI,
137  unsigned FunctionNum, MachineModuleInfo &mmi)
138  : F(F), Target(Target), STI(&STI), Ctx(mmi.getContext()), MMI(mmi) {
139  FunctionNumber = FunctionNum;
140  init();
141 }
142 
143 void MachineFunction::handleInsertion(MachineInstr &MI) {
144  if (TheDelegate)
145  TheDelegate->MF_HandleInsertion(MI);
146 }
147 
148 void MachineFunction::handleRemoval(MachineInstr &MI) {
149  if (TheDelegate)
150  TheDelegate->MF_HandleRemoval(MI);
151 }
152 
153 void MachineFunction::init() {
154  // Assume the function starts in SSA form with correct liveness.
157  if (STI->getRegisterInfo())
158  RegInfo = new (Allocator) MachineRegisterInfo(this);
159  else
160  RegInfo = nullptr;
161 
162  MFInfo = nullptr;
163  // We can realign the stack if the target supports it and the user hasn't
164  // explicitly asked us not to.
165  bool CanRealignSP = STI->getFrameLowering()->isStackRealignable() &&
166  !F.hasFnAttribute("no-realign-stack");
167  FrameInfo = new (Allocator) MachineFrameInfo(
168  getFnStackAlignment(STI, F), /*StackRealignable=*/CanRealignSP,
169  /*ForcedRealign=*/CanRealignSP &&
170  F.hasFnAttribute(Attribute::StackAlignment));
171 
172  if (F.hasFnAttribute(Attribute::StackAlignment))
173  FrameInfo->ensureMaxAlignment(F.getFnStackAlignment());
174 
175  ConstantPool = new (Allocator) MachineConstantPool(getDataLayout());
176  Alignment = STI->getTargetLowering()->getMinFunctionAlignment();
177 
178  // FIXME: Shouldn't use pref alignment if explicit alignment is set on F.
179  // FIXME: Use Function::hasOptSize().
180  if (!F.hasFnAttribute(Attribute::OptimizeForSize))
181  Alignment = std::max(Alignment,
183 
184  if (AlignAllFunctions)
185  Alignment = llvm::Align(1ULL << AlignAllFunctions);
186 
187  JumpTableInfo = nullptr;
188 
190  F.hasPersonalityFn() ? F.getPersonalityFn() : nullptr))) {
191  WinEHInfo = new (Allocator) WinEHFuncInfo();
192  }
193 
195  F.hasPersonalityFn() ? F.getPersonalityFn() : nullptr))) {
196  WasmEHInfo = new (Allocator) WasmEHFuncInfo();
197  }
198 
199  assert(Target.isCompatibleDataLayout(getDataLayout()) &&
200  "Can't create a MachineFunction using a Module with a "
201  "Target-incompatible DataLayout attached\n");
202 
203  PSVManager =
204  std::make_unique<PseudoSourceValueManager>(*(getSubtarget().
205  getInstrInfo()));
206 }
207 
209  clear();
210 }
211 
212 void MachineFunction::clear() {
213  Properties.reset();
214  // Don't call destructors on MachineInstr and MachineOperand. All of their
215  // memory comes from the BumpPtrAllocator which is about to be purged.
216  //
217  // Do call MachineBasicBlock destructors, it contains std::vectors.
218  for (iterator I = begin(), E = end(); I != E; I = BasicBlocks.erase(I))
219  I->Insts.clearAndLeakNodesUnsafely();
220  MBBNumbering.clear();
221 
222  InstructionRecycler.clear(Allocator);
223  OperandRecycler.clear(Allocator);
224  BasicBlockRecycler.clear(Allocator);
225  CodeViewAnnotations.clear();
227  if (RegInfo) {
228  RegInfo->~MachineRegisterInfo();
229  Allocator.Deallocate(RegInfo);
230  }
231  if (MFInfo) {
232  MFInfo->~MachineFunctionInfo();
233  Allocator.Deallocate(MFInfo);
234  }
235 
236  FrameInfo->~MachineFrameInfo();
237  Allocator.Deallocate(FrameInfo);
238 
239  ConstantPool->~MachineConstantPool();
240  Allocator.Deallocate(ConstantPool);
241 
242  if (JumpTableInfo) {
243  JumpTableInfo->~MachineJumpTableInfo();
244  Allocator.Deallocate(JumpTableInfo);
245  }
246 
247  if (WinEHInfo) {
248  WinEHInfo->~WinEHFuncInfo();
249  Allocator.Deallocate(WinEHInfo);
250  }
251 
252  if (WasmEHInfo) {
253  WasmEHInfo->~WasmEHFuncInfo();
254  Allocator.Deallocate(WasmEHInfo);
255  }
256 }
257 
259  return F.getParent()->getDataLayout();
260 }
261 
262 /// Get the JumpTableInfo for this function.
263 /// If it does not already exist, allocate one.
265 getOrCreateJumpTableInfo(unsigned EntryKind) {
266  if (JumpTableInfo) return JumpTableInfo;
267 
268  JumpTableInfo = new (Allocator)
270  return JumpTableInfo;
271 }
272 
273 /// Should we be emitting segmented stack stuff for the function
275  return getFunction().hasFnAttribute("split-stack");
276 }
277 
278 LLVM_NODISCARD unsigned
280  FrameInstructions.push_back(Inst);
281  return FrameInstructions.size() - 1;
282 }
283 
284 /// This discards all of the MachineBasicBlock numbers and recomputes them.
285 /// This guarantees that the MBB numbers are sequential, dense, and match the
286 /// ordering of the blocks within the function. If a specific MachineBasicBlock
287 /// is specified, only that block and those after it are renumbered.
289  if (empty()) { MBBNumbering.clear(); return; }
290  MachineFunction::iterator MBBI, E = end();
291  if (MBB == nullptr)
292  MBBI = begin();
293  else
294  MBBI = MBB->getIterator();
295 
296  // Figure out the block number this should have.
297  unsigned BlockNo = 0;
298  if (MBBI != begin())
299  BlockNo = std::prev(MBBI)->getNumber() + 1;
300 
301  for (; MBBI != E; ++MBBI, ++BlockNo) {
302  if (MBBI->getNumber() != (int)BlockNo) {
303  // Remove use of the old number.
304  if (MBBI->getNumber() != -1) {
305  assert(MBBNumbering[MBBI->getNumber()] == &*MBBI &&
306  "MBB number mismatch!");
307  MBBNumbering[MBBI->getNumber()] = nullptr;
308  }
309 
310  // If BlockNo is already taken, set that block's number to -1.
311  if (MBBNumbering[BlockNo])
312  MBBNumbering[BlockNo]->setNumber(-1);
313 
314  MBBNumbering[BlockNo] = &*MBBI;
315  MBBI->setNumber(BlockNo);
316  }
317  }
318 
319  // Okay, all the blocks are renumbered. If we have compactified the block
320  // numbering, shrink MBBNumbering now.
321  assert(BlockNo <= MBBNumbering.size() && "Mismatch!");
322  MBBNumbering.resize(BlockNo);
323 }
324 
325 /// Allocate a new MachineInstr. Use this instead of `new MachineInstr'.
327  const DebugLoc &DL,
328  bool NoImp) {
329  return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
330  MachineInstr(*this, MCID, DL, NoImp);
331 }
332 
333 /// Create a new MachineInstr which is a copy of the 'Orig' instruction,
334 /// identical in all ways except the instruction has no parent, prev, or next.
335 MachineInstr *
337  return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
338  MachineInstr(*this, *Orig);
339 }
340 
342  MachineBasicBlock::iterator InsertBefore, const MachineInstr &Orig) {
343  MachineInstr *FirstClone = nullptr;
345  while (true) {
346  MachineInstr *Cloned = CloneMachineInstr(&*I);
347  MBB.insert(InsertBefore, Cloned);
348  if (FirstClone == nullptr) {
349  FirstClone = Cloned;
350  } else {
351  Cloned->bundleWithPred();
352  }
353 
354  if (!I->isBundledWithSucc())
355  break;
356  ++I;
357  }
358  return *FirstClone;
359 }
360 
361 /// Delete the given MachineInstr.
362 ///
363 /// This function also serves as the MachineInstr destructor - the real
364 /// ~MachineInstr() destructor must be empty.
365 void
367  // Verify that a call site info is at valid state. This assertion should
368  // be triggered during the implementation of support for the
369  // call site info of a new architecture. If the assertion is triggered,
370  // back trace will tell where to insert a call to updateCallSiteInfo().
372  CallSitesInfo.find(MI) == CallSitesInfo.end()) &&
373  "Call site info was not updated!");
374  // Strip it for parts. The operand array and the MI object itself are
375  // independently recyclable.
376  if (MI->Operands)
377  deallocateOperandArray(MI->CapOperands, MI->Operands);
378  // Don't call ~MachineInstr() which must be trivial anyway because
379  // ~MachineFunction drops whole lists of MachineInstrs wihout calling their
380  // destructors.
381  InstructionRecycler.Deallocate(Allocator, MI);
382 }
383 
384 /// Allocate a new MachineBasicBlock. Use this instead of
385 /// `new MachineBasicBlock'.
388  return new (BasicBlockRecycler.Allocate<MachineBasicBlock>(Allocator))
389  MachineBasicBlock(*this, bb);
390 }
391 
392 /// Delete the given MachineBasicBlock.
393 void
395  assert(MBB->getParent() == this && "MBB parent mismatch!");
396  MBB->~MachineBasicBlock();
397  BasicBlockRecycler.Deallocate(Allocator, MBB);
398 }
399 
401  MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s,
402  unsigned base_alignment, const AAMDNodes &AAInfo, const MDNode *Ranges,
403  SyncScope::ID SSID, AtomicOrdering Ordering,
404  AtomicOrdering FailureOrdering) {
405  return new (Allocator)
406  MachineMemOperand(PtrInfo, f, s, base_alignment, AAInfo, Ranges,
407  SSID, Ordering, FailureOrdering);
408 }
409 
412  int64_t Offset, uint64_t Size) {
413  const MachinePointerInfo &PtrInfo = MMO->getPointerInfo();
414 
415  // If there is no pointer value, the offset isn't tracked so we need to adjust
416  // the base alignment.
417  unsigned Align = PtrInfo.V.isNull()
418  ? MinAlign(MMO->getBaseAlignment(), Offset)
419  : MMO->getBaseAlignment();
420 
421  return new (Allocator)
422  MachineMemOperand(PtrInfo.getWithOffset(Offset), MMO->getFlags(), Size,
423  Align, AAMDNodes(), nullptr, MMO->getSyncScopeID(),
424  MMO->getOrdering(), MMO->getFailureOrdering());
425 }
426 
429  const AAMDNodes &AAInfo) {
430  MachinePointerInfo MPI = MMO->getValue() ?
431  MachinePointerInfo(MMO->getValue(), MMO->getOffset()) :
433 
434  return new (Allocator)
435  MachineMemOperand(MPI, MMO->getFlags(), MMO->getSize(),
436  MMO->getBaseAlignment(), AAInfo,
437  MMO->getRanges(), MMO->getSyncScopeID(),
438  MMO->getOrdering(), MMO->getFailureOrdering());
439 }
440 
443  MachineMemOperand::Flags Flags) {
444  return new (Allocator) MachineMemOperand(
445  MMO->getPointerInfo(), Flags, MMO->getSize(), MMO->getBaseAlignment(),
446  MMO->getAAInfo(), MMO->getRanges(), MMO->getSyncScopeID(),
447  MMO->getOrdering(), MMO->getFailureOrdering());
448 }
449 
450 MachineInstr::ExtraInfo *
452  MCSymbol *PreInstrSymbol,
453  MCSymbol *PostInstrSymbol) {
454  return MachineInstr::ExtraInfo::create(Allocator, MMOs, PreInstrSymbol,
455  PostInstrSymbol);
456 }
457 
459  char *Dest = Allocator.Allocate<char>(Name.size() + 1);
460  llvm::copy(Name, Dest);
461  Dest[Name.size()] = 0;
462  return Dest;
463 }
464 
466  unsigned NumRegs = getSubtarget().getRegisterInfo()->getNumRegs();
467  unsigned Size = MachineOperand::getRegMaskSize(NumRegs);
468  uint32_t *Mask = Allocator.Allocate<uint32_t>(Size);
469  memset(Mask, 0, Size * sizeof(Mask[0]));
470  return Mask;
471 }
472 
473 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
475  print(dbgs());
476 }
477 #endif
478 
480  return getFunction().getName();
481 }
482 
483 void MachineFunction::print(raw_ostream &OS, const SlotIndexes *Indexes) const {
484  OS << "# Machine code for function " << getName() << ": ";
485  getProperties().print(OS);
486  OS << '\n';
487 
488  // Print Frame Information
489  FrameInfo->print(*this, OS);
490 
491  // Print JumpTable Information
492  if (JumpTableInfo)
493  JumpTableInfo->print(OS);
494 
495  // Print Constant Pool
496  ConstantPool->print(OS);
497 
499 
500  if (RegInfo && !RegInfo->livein_empty()) {
501  OS << "Function Live Ins: ";
503  I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) {
504  OS << printReg(I->first, TRI);
505  if (I->second)
506  OS << " in " << printReg(I->second, TRI);
507  if (std::next(I) != E)
508  OS << ", ";
509  }
510  OS << '\n';
511  }
512 
515  for (const auto &BB : *this) {
516  OS << '\n';
517  // If we print the whole function, print it at its most verbose level.
518  BB.print(OS, MST, Indexes, /*IsStandalone=*/true);
519  }
520 
521  OS << "\n# End machine code for function " << getName() << ".\n\n";
522 }
523 
524 namespace llvm {
525 
526  template<>
529 
530  static std::string getGraphName(const MachineFunction *F) {
531  return ("CFG for '" + F->getName() + "' function").str();
532  }
533 
534  std::string getNodeLabel(const MachineBasicBlock *Node,
535  const MachineFunction *Graph) {
536  std::string OutStr;
537  {
538  raw_string_ostream OSS(OutStr);
539 
540  if (isSimple()) {
541  OSS << printMBBReference(*Node);
542  if (const BasicBlock *BB = Node->getBasicBlock())
543  OSS << ": " << BB->getName();
544  } else
545  Node->print(OSS);
546  }
547 
548  if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());
549 
550  // Process string output to make it nicer...
551  for (unsigned i = 0; i != OutStr.length(); ++i)
552  if (OutStr[i] == '\n') { // Left justify
553  OutStr[i] = '\\';
554  OutStr.insert(OutStr.begin()+i+1, 'l');
555  }
556  return OutStr;
557  }
558  };
559 
560 } // end namespace llvm
561 
563 {
564 #ifndef NDEBUG
565  ViewGraph(this, "mf" + getName());
566 #else
567  errs() << "MachineFunction::viewCFG is only available in debug builds on "
568  << "systems with Graphviz or gv!\n";
569 #endif // NDEBUG
570 }
571 
573 {
574 #ifndef NDEBUG
575  ViewGraph(this, "mf" + getName(), true);
576 #else
577  errs() << "MachineFunction::viewCFGOnly is only available in debug builds on "
578  << "systems with Graphviz or gv!\n";
579 #endif // NDEBUG
580 }
581 
582 /// Add the specified physical register as a live-in value and
583 /// create a corresponding virtual register for it.
584 unsigned MachineFunction::addLiveIn(unsigned PReg,
585  const TargetRegisterClass *RC) {
587  unsigned VReg = MRI.getLiveInVirtReg(PReg);
588  if (VReg) {
589  const TargetRegisterClass *VRegRC = MRI.getRegClass(VReg);
590  (void)VRegRC;
591  // A physical register can be added several times.
592  // Between two calls, the register class of the related virtual register
593  // may have been constrained to match some operation constraints.
594  // In that case, check that the current register class includes the
595  // physical register and is a sub class of the specified RC.
596  assert((VRegRC == RC || (VRegRC->contains(PReg) &&
597  RC->hasSubClassEq(VRegRC))) &&
598  "Register class mismatch!");
599  return VReg;
600  }
601  VReg = MRI.createVirtualRegister(RC);
602  MRI.addLiveIn(PReg, VReg);
603  return VReg;
604 }
605 
606 /// Return the MCSymbol for the specified non-empty jump table.
607 /// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
608 /// normal 'L' label is returned.
610  bool isLinkerPrivate) const {
611  const DataLayout &DL = getDataLayout();
612  assert(JumpTableInfo && "No jump tables");
613  assert(JTI < JumpTableInfo->getJumpTables().size() && "Invalid JTI!");
614 
615  StringRef Prefix = isLinkerPrivate ? DL.getLinkerPrivateGlobalPrefix()
616  : DL.getPrivateGlobalPrefix();
618  raw_svector_ostream(Name)
619  << Prefix << "JTI" << getFunctionNumber() << '_' << JTI;
620  return Ctx.getOrCreateSymbol(Name);
621 }
622 
623 /// Return a function-local symbol to represent the PIC base.
625  const DataLayout &DL = getDataLayout();
626  return Ctx.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) +
627  Twine(getFunctionNumber()) + "$pb");
628 }
629 
630 /// \name Exception Handling
631 /// \{
632 
635  unsigned N = LandingPads.size();
636  for (unsigned i = 0; i < N; ++i) {
637  LandingPadInfo &LP = LandingPads[i];
638  if (LP.LandingPadBlock == LandingPad)
639  return LP;
640  }
641 
642  LandingPads.push_back(LandingPadInfo(LandingPad));
643  return LandingPads[N];
644 }
645 
647  MCSymbol *BeginLabel, MCSymbol *EndLabel) {
648  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
649  LP.BeginLabels.push_back(BeginLabel);
650  LP.EndLabels.push_back(EndLabel);
651 }
652 
654  MCSymbol *LandingPadLabel = Ctx.createTempSymbol();
655  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
656  LP.LandingPadLabel = LandingPadLabel;
657 
658  const Instruction *FirstI = LandingPad->getBasicBlock()->getFirstNonPHI();
659  if (const auto *LPI = dyn_cast<LandingPadInst>(FirstI)) {
660  if (const auto *PF =
661  dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts()))
662  getMMI().addPersonality(PF);
663 
664  if (LPI->isCleanup())
665  addCleanup(LandingPad);
666 
667  // FIXME: New EH - Add the clauses in reverse order. This isn't 100%
668  // correct, but we need to do it this way because of how the DWARF EH
669  // emitter processes the clauses.
670  for (unsigned I = LPI->getNumClauses(); I != 0; --I) {
671  Value *Val = LPI->getClause(I - 1);
672  if (LPI->isCatch(I - 1)) {
673  addCatchTypeInfo(LandingPad,
674  dyn_cast<GlobalValue>(Val->stripPointerCasts()));
675  } else {
676  // Add filters in a list.
677  auto *CVal = cast<Constant>(Val);
679  for (User::op_iterator II = CVal->op_begin(), IE = CVal->op_end();
680  II != IE; ++II)
681  FilterList.push_back(cast<GlobalValue>((*II)->stripPointerCasts()));
682 
683  addFilterTypeInfo(LandingPad, FilterList);
684  }
685  }
686 
687  } else if (const auto *CPI = dyn_cast<CatchPadInst>(FirstI)) {
688  for (unsigned I = CPI->getNumArgOperands(); I != 0; --I) {
689  Value *TypeInfo = CPI->getArgOperand(I - 1)->stripPointerCasts();
690  addCatchTypeInfo(LandingPad, dyn_cast<GlobalValue>(TypeInfo));
691  }
692 
693  } else {
694  assert(isa<CleanupPadInst>(FirstI) && "Invalid landingpad!");
695  }
696 
697  return LandingPadLabel;
698 }
699 
702  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
703  for (unsigned N = TyInfo.size(); N; --N)
704  LP.TypeIds.push_back(getTypeIDFor(TyInfo[N - 1]));
705 }
706 
709  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
710  std::vector<unsigned> IdsInFilter(TyInfo.size());
711  for (unsigned I = 0, E = TyInfo.size(); I != E; ++I)
712  IdsInFilter[I] = getTypeIDFor(TyInfo[I]);
713  LP.TypeIds.push_back(getFilterIDFor(IdsInFilter));
714 }
715 
717  bool TidyIfNoBeginLabels) {
718  for (unsigned i = 0; i != LandingPads.size(); ) {
719  LandingPadInfo &LandingPad = LandingPads[i];
720  if (LandingPad.LandingPadLabel &&
721  !LandingPad.LandingPadLabel->isDefined() &&
722  (!LPMap || (*LPMap)[LandingPad.LandingPadLabel] == 0))
723  LandingPad.LandingPadLabel = nullptr;
724 
725  // Special case: we *should* emit LPs with null LP MBB. This indicates
726  // "nounwind" case.
727  if (!LandingPad.LandingPadLabel && LandingPad.LandingPadBlock) {
728  LandingPads.erase(LandingPads.begin() + i);
729  continue;
730  }
731 
732  if (TidyIfNoBeginLabels) {
733  for (unsigned j = 0, e = LandingPads[i].BeginLabels.size(); j != e; ++j) {
734  MCSymbol *BeginLabel = LandingPad.BeginLabels[j];
735  MCSymbol *EndLabel = LandingPad.EndLabels[j];
736  if ((BeginLabel->isDefined() || (LPMap && (*LPMap)[BeginLabel] != 0)) &&
737  (EndLabel->isDefined() || (LPMap && (*LPMap)[EndLabel] != 0)))
738  continue;
739 
740  LandingPad.BeginLabels.erase(LandingPad.BeginLabels.begin() + j);
741  LandingPad.EndLabels.erase(LandingPad.EndLabels.begin() + j);
742  --j;
743  --e;
744  }
745 
746  // Remove landing pads with no try-ranges.
747  if (LandingPads[i].BeginLabels.empty()) {
748  LandingPads.erase(LandingPads.begin() + i);
749  continue;
750  }
751  }
752 
753  // If there is no landing pad, ensure that the list of typeids is empty.
754  // If the only typeid is a cleanup, this is the same as having no typeids.
755  if (!LandingPad.LandingPadBlock ||
756  (LandingPad.TypeIds.size() == 1 && !LandingPad.TypeIds[0]))
757  LandingPad.TypeIds.clear();
758  ++i;
759  }
760 }
761 
763  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
764  LP.TypeIds.push_back(0);
765 }
766 
768  const Function *Filter,
769  const BlockAddress *RecoverBA) {
770  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
771  SEHHandler Handler;
772  Handler.FilterOrFinally = Filter;
773  Handler.RecoverBA = RecoverBA;
774  LP.SEHHandlers.push_back(Handler);
775 }
776 
778  const Function *Cleanup) {
779  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
780  SEHHandler Handler;
781  Handler.FilterOrFinally = Cleanup;
782  Handler.RecoverBA = nullptr;
783  LP.SEHHandlers.push_back(Handler);
784 }
785 
787  ArrayRef<unsigned> Sites) {
788  LPadToCallSiteMap[Sym].append(Sites.begin(), Sites.end());
789 }
790 
792  for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i)
793  if (TypeInfos[i] == TI) return i + 1;
794 
795  TypeInfos.push_back(TI);
796  return TypeInfos.size();
797 }
798 
799 int MachineFunction::getFilterIDFor(std::vector<unsigned> &TyIds) {
800  // If the new filter coincides with the tail of an existing filter, then
801  // re-use the existing filter. Folding filters more than this requires
802  // re-ordering filters and/or their elements - probably not worth it.
803  for (std::vector<unsigned>::iterator I = FilterEnds.begin(),
804  E = FilterEnds.end(); I != E; ++I) {
805  unsigned i = *I, j = TyIds.size();
806 
807  while (i && j)
808  if (FilterIds[--i] != TyIds[--j])
809  goto try_next;
810 
811  if (!j)
812  // The new filter coincides with range [i, end) of the existing filter.
813  return -(1 + i);
814 
815 try_next:;
816  }
817 
818  // Add the new filter.
819  int FilterID = -(1 + FilterIds.size());
820  FilterIds.reserve(FilterIds.size() + TyIds.size() + 1);
821  FilterIds.insert(FilterIds.end(), TyIds.begin(), TyIds.end());
822  FilterEnds.push_back(FilterIds.size());
823  FilterIds.push_back(0); // terminator
824  return FilterID;
825 }
826 
828  const MDNode *MD) {
829  MCSymbol *BeginLabel = Ctx.createTempSymbol("heapallocsite", true);
830  MCSymbol *EndLabel = Ctx.createTempSymbol("heapallocsite", true);
831  I->setPreInstrSymbol(*this, BeginLabel);
832  I->setPostInstrSymbol(*this, EndLabel);
833 
834  const DIType *DI = dyn_cast<DIType>(MD);
835  CodeViewHeapAllocSites.push_back(std::make_tuple(BeginLabel, EndLabel, DI));
836 }
837 
839  const MachineInstr *New) {
840  if (!Target.Options.EnableDebugEntryValues || Old == New)
841  return;
842 
843  assert(Old->isCall() && (!New || New->isCall()) &&
844  "Call site info referes only to call instructions!");
845  CallSiteInfoMap::iterator CSIt = CallSitesInfo.find(Old);
846  if (CSIt == CallSitesInfo.end())
847  return;
848  CallSiteInfo CSInfo = std::move(CSIt->second);
849  CallSitesInfo.erase(CSIt);
850  if (New)
851  CallSitesInfo[New] = CSInfo;
852 }
853 
854 /// \}
855 
856 //===----------------------------------------------------------------------===//
857 // MachineJumpTableInfo implementation
858 //===----------------------------------------------------------------------===//
859 
860 /// Return the size of each entry in the jump table.
862  // The size of a jump table entry is 4 bytes unless the entry is just the
863  // address of a block, in which case it is the pointer size.
864  switch (getEntryKind()) {
866  return TD.getPointerSize();
868  return 8;
872  return 4;
874  return 0;
875  }
876  llvm_unreachable("Unknown jump table encoding!");
877 }
878 
879 /// Return the alignment of each entry in the jump table.
881  // The alignment of a jump table entry is the alignment of int32 unless the
882  // entry is just the address of a block, in which case it is the pointer
883  // alignment.
884  switch (getEntryKind()) {
886  return TD.getPointerABIAlignment(0);
888  return TD.getABIIntegerTypeAlignment(64);
892  return TD.getABIIntegerTypeAlignment(32);
894  return 1;
895  }
896  llvm_unreachable("Unknown jump table encoding!");
897 }
898 
899 /// Create a new jump table entry in the jump table info.
901  const std::vector<MachineBasicBlock*> &DestBBs) {
902  assert(!DestBBs.empty() && "Cannot create an empty jump table!");
903  JumpTables.push_back(MachineJumpTableEntry(DestBBs));
904  return JumpTables.size()-1;
905 }
906 
907 /// If Old is the target of any jump tables, update the jump tables to branch
908 /// to New instead.
910  MachineBasicBlock *New) {
911  assert(Old != New && "Not making a change?");
912  bool MadeChange = false;
913  for (size_t i = 0, e = JumpTables.size(); i != e; ++i)
914  ReplaceMBBInJumpTable(i, Old, New);
915  return MadeChange;
916 }
917 
918 /// If Old is a target of the jump tables, update the jump table to branch to
919 /// New instead.
921  MachineBasicBlock *Old,
922  MachineBasicBlock *New) {
923  assert(Old != New && "Not making a change?");
924  bool MadeChange = false;
925  MachineJumpTableEntry &JTE = JumpTables[Idx];
926  for (size_t j = 0, e = JTE.MBBs.size(); j != e; ++j)
927  if (JTE.MBBs[j] == Old) {
928  JTE.MBBs[j] = New;
929  MadeChange = true;
930  }
931  return MadeChange;
932 }
933 
935  if (JumpTables.empty()) return;
936 
937  OS << "Jump Tables:\n";
938 
939  for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) {
940  OS << printJumpTableEntryReference(i) << ':';
941  for (unsigned j = 0, f = JumpTables[i].MBBs.size(); j != f; ++j)
942  OS << ' ' << printMBBReference(*JumpTables[i].MBBs[j]);
943  if (i != e)
944  OS << '\n';
945  }
946 
947  OS << '\n';
948 }
949 
950 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
952 #endif
953 
955  return Printable([Idx](raw_ostream &OS) { OS << "%jump-table." << Idx; });
956 }
957 
958 //===----------------------------------------------------------------------===//
959 // MachineConstantPool implementation
960 //===----------------------------------------------------------------------===//
961 
962 void MachineConstantPoolValue::anchor() {}
963 
965  if (isMachineConstantPoolEntry())
966  return Val.MachineCPVal->getType();
967  return Val.ConstVal->getType();
968 }
969 
971  if (isMachineConstantPoolEntry())
972  return true;
973  return Val.ConstVal->needsRelocation();
974 }
975 
978  if (needsRelocation())
980  switch (DL->getTypeAllocSize(getType())) {
981  case 4:
983  case 8:
985  case 16:
987  case 32:
989  default:
990  return SectionKind::getReadOnly();
991  }
992 }
993 
995  // A constant may be a member of both Constants and MachineCPVsSharingEntries,
996  // so keep track of which we've deleted to avoid double deletions.
998  for (unsigned i = 0, e = Constants.size(); i != e; ++i)
999  if (Constants[i].isMachineConstantPoolEntry()) {
1000  Deleted.insert(Constants[i].Val.MachineCPVal);
1001  delete Constants[i].Val.MachineCPVal;
1002  }
1004  MachineCPVsSharingEntries.begin(), E = MachineCPVsSharingEntries.end();
1005  I != E; ++I) {
1006  if (Deleted.count(*I) == 0)
1007  delete *I;
1008  }
1009 }
1010 
1011 /// Test whether the given two constants can be allocated the same constant pool
1012 /// entry.
1013 static bool CanShareConstantPoolEntry(const Constant *A, const Constant *B,
1014  const DataLayout &DL) {
1015  // Handle the trivial case quickly.
1016  if (A == B) return true;
1017 
1018  // If they have the same type but weren't the same constant, quickly
1019  // reject them.
1020  if (A->getType() == B->getType()) return false;
1021 
1022  // We can't handle structs or arrays.
1023  if (isa<StructType>(A->getType()) || isa<ArrayType>(A->getType()) ||
1024  isa<StructType>(B->getType()) || isa<ArrayType>(B->getType()))
1025  return false;
1026 
1027  // For now, only support constants with the same size.
1028  uint64_t StoreSize = DL.getTypeStoreSize(A->getType());
1029  if (StoreSize != DL.getTypeStoreSize(B->getType()) || StoreSize > 128)
1030  return false;
1031 
1032  Type *IntTy = IntegerType::get(A->getContext(), StoreSize*8);
1033 
1034  // Try constant folding a bitcast of both instructions to an integer. If we
1035  // get two identical ConstantInt's, then we are good to share them. We use
1036  // the constant folding APIs to do this so that we get the benefit of
1037  // DataLayout.
1038  if (isa<PointerType>(A->getType()))
1039  A = ConstantFoldCastOperand(Instruction::PtrToInt,
1040  const_cast<Constant *>(A), IntTy, DL);
1041  else if (A->getType() != IntTy)
1042  A = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(A),
1043  IntTy, DL);
1044  if (isa<PointerType>(B->getType()))
1045  B = ConstantFoldCastOperand(Instruction::PtrToInt,
1046  const_cast<Constant *>(B), IntTy, DL);
1047  else if (B->getType() != IntTy)
1048  B = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(B),
1049  IntTy, DL);
1050 
1051  return A == B;
1052 }
1053 
1054 /// Create a new entry in the constant pool or return an existing one.
1055 /// User must specify the log2 of the minimum required alignment for the object.
1057  unsigned Alignment) {
1058  assert(Alignment && "Alignment must be specified!");
1059  if (Alignment > PoolAlignment) PoolAlignment = Alignment;
1060 
1061  // Check to see if we already have this constant.
1062  //
1063  // FIXME, this could be made much more efficient for large constant pools.
1064  for (unsigned i = 0, e = Constants.size(); i != e; ++i)
1065  if (!Constants[i].isMachineConstantPoolEntry() &&
1066  CanShareConstantPoolEntry(Constants[i].Val.ConstVal, C, DL)) {
1067  if ((unsigned)Constants[i].getAlignment() < Alignment)
1068  Constants[i].Alignment = Alignment;
1069  return i;
1070  }
1071 
1072  Constants.push_back(MachineConstantPoolEntry(C, Alignment));
1073  return Constants.size()-1;
1074 }
1075 
1077  unsigned Alignment) {
1078  assert(Alignment && "Alignment must be specified!");
1079  if (Alignment > PoolAlignment) PoolAlignment = Alignment;
1080 
1081  // Check to see if we already have this constant.
1082  //
1083  // FIXME, this could be made much more efficient for large constant pools.
1084  int Idx = V->getExistingMachineCPValue(this, Alignment);
1085  if (Idx != -1) {
1086  MachineCPVsSharingEntries.insert(V);
1087  return (unsigned)Idx;
1088  }
1089 
1090  Constants.push_back(MachineConstantPoolEntry(V, Alignment));
1091  return Constants.size()-1;
1092 }
1093 
1095  if (Constants.empty()) return;
1096 
1097  OS << "Constant Pool:\n";
1098  for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
1099  OS << " cp#" << i << ": ";
1100  if (Constants[i].isMachineConstantPoolEntry())
1101  Constants[i].Val.MachineCPVal->print(OS);
1102  else
1103  Constants[i].Val.ConstVal->printAsOperand(OS, /*PrintType=*/false);
1104  OS << ", align=" << Constants[i].getAlignment();
1105  OS << "\n";
1106  }
1107 }
1108 
1109 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1111 #endif
Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
void print(raw_ostream &OS, const SlotIndexes *=nullptr, bool IsStandalone=true) const
uint64_t CallInst * C
void bundleWithPred()
Bundle this instruction with its predecessor.
static unsigned getRegMaskSize(unsigned NumRegs)
Returns number of elements needed for a regmask array.
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
The MachineConstantPool class keeps track of constants referenced by a function which must be spilled...
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
unsigned getFnStackAlignment() const
Return the stack alignment for the function.
Definition: Function.h:343
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
bool contains(unsigned Reg) const
Return true if the specified register is included in this register class.
bool isCall(QueryType Type=AnyInBundle) const
Definition: MachineInstr.h:651
unsigned getFunctionNumber() const
getFunctionNumber - Return a unique ID for the current function.
livein_iterator livein_begin() const
static SectionKind getMergeableConst32()
Definition: SectionKind.h:194
iterator erase(iterator where)
Definition: ilist.h:265
This class represents lattice values for constants.
Definition: AllocatorList.h:23
MachineFunctionProperties & reset(Property P)
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds...
Definition: Compiler.h:476
void RenumberBlocks(MachineBasicBlock *MBBFrom=nullptr)
RenumberBlocks - This discards all of the MachineBasicBlock numbers and recomputes them...
MCSymbol * addLandingPad(MachineBasicBlock *LandingPad)
Add a new panding pad, and extract the exception handling information from the landingpad instruction...
StringRef getPrivateGlobalPrefix() const
Definition: DataLayout.h:317
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
iterator begin() const
Definition: ArrayRef.h:136
Register createVirtualRegister(const TargetRegisterClass *RegClass, StringRef Name="")
createVirtualRegister - Create and return a new virtual register in the function with the specified r...
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
void addLiveIn(unsigned Reg, unsigned vreg=0)
addLiveIn - Add the specified register as a live-in.
const Function * FilterOrFinally
Filter or finally function. Null indicates a catch-all.
const MachineFunctionProperties & getProperties() const
Get the function properties.
Implements a dense probed hash-table based set.
Definition: DenseSet.h:249
unsigned size() const
AtomicOrdering getFailureOrdering() const
For cmpxchg atomic operations, return the atomic ordering requirements when store does not occur...
void push_back(const T &Elt)
Definition: SmallVector.h:211
unsigned addLiveIn(unsigned PReg, const TargetRegisterClass *RC)
addLiveIn - Add the specified physical register as a live-in value and create a corresponding virtual...
LLVM_NODISCARD unsigned addFrameInst(const MCCFIInstruction &Inst)
Describe properties that are true of each instruction in the target description file.
Definition: MCInstrDesc.h:178
This file contains the declarations for metadata subclasses.
EK_Inline - Jump table entries are emitted inline at their point of use.
std::string getNodeLabel(const MachineBasicBlock *Node, const MachineFunction *Graph)
void viewCFG() const
viewCFG - This function is meant for use from the debugger.
virtual const TargetLowering * getTargetLowering() const
uint64_t getSize() const
Return the size in bytes of the memory reference.
static SectionKind getMergeableConst8()
Definition: SectionKind.h:192
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:733
static SectionKind getMergeableConst16()
Definition: SectionKind.h:193
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:323
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:530
unsigned const TargetRegisterInfo * TRI
A debug info location.
Definition: DebugLoc.h:33
Metadata node.
Definition: Metadata.h:863
F(f)
MachineModuleInfo & getMMI() const
Manage lifetime of a slot tracker for printing IR.
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.
unsigned getTypeIDFor(const GlobalValue *TI)
Return the type id for the specified typeinfo. This is function wide.
uint64_t getBaseAlignment() const
Return the minimum known alignment in bytes of the base address, without the offset.
void dump() const
dump - Print the current MachineFunction to cerr, useful for debugger use.
MachineInstr * CreateMachineInstr(const MCInstrDesc &MCID, const DebugLoc &DL, bool NoImp=false)
CreateMachineInstr - Allocate a new MachineInstr.
void DeleteMachineBasicBlock(MachineBasicBlock *MBB)
DeleteMachineBasicBlock - Delete the given MachineBasicBlock.
unsigned getPointerABIAlignment(unsigned AS) const
Layout pointer alignment.
Definition: DataLayout.cpp:633
StringRef getLinkerPrivateGlobalPrefix() const
Definition: DataLayout.h:297
static SectionKind getMergeableConst4()
Definition: SectionKind.h:191
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...
const TargetRegisterClass * getRegClass(Register Reg) const
Return the register class of the specified virtual register.
MachineJumpTableInfo * getOrCreateJumpTableInfo(unsigned JTEntryKind)
getOrCreateJumpTableInfo - Get the JumpTableInfo for this function, if it does already exist...
*ViewGraph Emit a dot run run gv on the postscript *then cleanup For use from the debugger *void ViewGraph(const GraphType &G, const Twine &Name, bool ShortNames=false, const Twine &Title="", GraphProgram::Name Program=GraphProgram::DOT)
Definition: GraphWriter.h:366
void print(raw_ostream &OS) const
print - Used by the MachineFunction printer to print information about jump tables.
void addSEHCatchHandler(MachineBasicBlock *LandingPad, const Function *Filter, const BlockAddress *RecoverBA)
JTEntryKind
JTEntryKind - This enum indicates how each entry of the jump table is represented and emitted...
The address of a basic block.
Definition: Constants.h:839
AAMDNodes getAAInfo() const
Return the AA tags for the memory reference.
void addSEHCleanupHandler(MachineBasicBlock *LandingPad, const Function *Cleanup)
void print(raw_ostream &OS) const
Print the MachineFunctionProperties in human-readable form.
A description of a memory reference used in the backend.
This file declares the MachineConstantPool class which is an abstract constant pool to keep track of ...
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:369
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
SmallVector< MCSymbol *, 1 > EndLabels
Printable printMBBReference(const MachineBasicBlock &MBB)
Prints a machine basic block reference.
const MDNode * getRanges() const
Return the range tag for the memory reference.
A Use represents the edge between a Value definition and its users.
Definition: Use.h:55
SmallVector< SEHHandler, 1 > SEHHandlers
MachineInstr & CloneMachineInstrBundle(MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore, const MachineInstr &Orig)
Clones instruction or the whole instruction bundle Orig and insert into MBB before InsertBefore...
This file contains the simple types necessary to represent the attributes associated with functions a...
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
int getFilterIDFor(std::vector< unsigned > &TyIds)
Return the id of the filter encoded by TyIds. This is function wide.
void Deallocate(const void *Ptr, size_t Size)
Definition: Allocator.h:277
MachineMemOperand * getMachineMemOperand(MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s, unsigned 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.
MachineInstr::ExtraInfo * createMIExtraInfo(ArrayRef< MachineMemOperand *> MMOs, MCSymbol *PreInstrSymbol=nullptr, MCSymbol *PostInstrSymbol=nullptr)
Allocate and construct an extra info structure for a MachineInstr.
AtomicOrdering
Atomic ordering for LLVM&#39;s memory model.
bool isScopedEHPersonality(EHPersonality Pers)
Returns true if this personality uses scope-style EH IR instructions: catchswitch, catchpad/ret, and cleanuppad/ret.
static bool isSimple(Instruction *I)
Context object for machine code objects.
Definition: MCContext.h:65
unsigned getEntryAlignment(const DataLayout &TD) const
getEntryAlignment - Return the alignment of each entry in the jump table.
This structure is used to retain landing pad info for the current function.
bool isNull() const
Test if the pointer held in the union is null, regardless of which type it is.
Definition: PointerUnion.h:179
AtomicOrdering getOrdering() const
Return the atomic ordering requirements for this memory operation.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
SlotIndexes pass.
Definition: SlotIndexes.h:314
void tidyLandingPads(DenseMap< MCSymbol *, uintptr_t > *LPMap=nullptr, bool TidyIfNoBeginLabels=true)
Remap landing pad labels and remove any deleted landing pads.
EK_LabelDifference32 - Each entry is the address of the block minus the address of the jump table...
livein_iterator livein_end() const
virtual int getExistingMachineCPValue(MachineConstantPool *CP, unsigned Alignment)=0
static std::string getGraphName(const MachineFunction *F)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
EK_BlockAddress - Each entry is a plain address of block, e.g.
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:144
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:25
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:732
This class is a data container for one entry in a MachineConstantPool.
void setPostInstrSymbol(MachineFunction &MF, MCSymbol *Symbol)
Set a symbol that will be emitted just after the instruction itself.
instr_iterator insert(instr_iterator I, MachineInstr *M)
Insert MI into the instruction list before I, possibly inside a bundle.
MachineBasicBlock * CreateMachineBasicBlock(const BasicBlock *bb=nullptr)
CreateMachineBasicBlock - Allocate a new MachineBasicBlock.
void ensureMaxAlignment(llvm::Align Align)
Make sure the function is at least Align bytes aligned.
const DataLayout & getDataLayout() const
Return the DataLayout attached to the Module associated to this MF.
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
void updateCallSiteInfo(const MachineInstr *Old, const MachineInstr *New=nullptr)
Update call sites info by deleting entry for Old call instruction.
const Value * getValue() const
Return the base address of the memory access.
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:150
MCContext & getContext() const
constexpr uint64_t MinAlign(uint64_t A, uint64_t B)
A and B are either alignments or offsets.
Definition: MathExtras.h:614
llvm::Align getMinFunctionAlignment() const
Return the minimum function alignment.
#define P(N)
unsigned getNumRegs() const
Return the number of registers this target has (useful for sizing arrays holding per register informa...
EK_GPRel64BlockAddress - Each entry is an address of block, encoded with a relocation as gp-relative...
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:432
void print(raw_ostream &OS) const
print - Used by the MachineFunction printer to print information about constant pool objects...
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:189
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
EK_Custom32 - Each entry is a 32-bit value that is custom lowered by the TargetLowering::LowerCustomJ...
unsigned const MachineRegisterInfo * MRI
void print(const MachineFunction &MF, raw_ostream &OS) const
Used by the MachineFunction printer to print information about stack objects.
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
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...
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
static unsigned getFnStackAlignment(const TargetSubtargetInfo *STI, const Function &F)
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:148
void addPersonality(const Function *Personality)
Provide the personality function for the exception information.
PointerUnion< const Value *, const PseudoSourceValue * > V
This is the IR pointer value for the access, or it is null if unknown.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:41
SmallVector< MCSymbol *, 1 > BeginLabels
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:651
LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void * Allocate(size_t Size, size_t Alignment)
Allocate space at the specified alignment.
Definition: Allocator.h:214
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.
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
std::vector< int > TypeIds
const PseudoSourceValue * getPseudoValue() const
This class describes a target machine that is implemented with the LLVM target-independent code gener...
MCSymbol * getJTISymbol(unsigned JTI, MCContext &Ctx, bool isLinkerPrivate=false) const
getJTISymbol - Return the MCSymbol for the specified non-empty jump table.
SectionKind - This is a simple POD value that classifies the properties of a section.
Definition: SectionKind.h:22
self_iterator getIterator()
Definition: ilist_node.h:81
Printable printJumpTableEntryReference(unsigned Idx)
Prints a jump table entry reference.
std::vector< MachineBasicBlock * > MBBs
MBBs - The vector of basic blocks from which to create the jump table.
void incorporateFunction(const Function &F)
Incorporate the given function.
Definition: AsmWriter.cpp:843
void DeleteMachineInstr(MachineInstr *MI)
DeleteMachineInstr - Delete the given MachineInstr.
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Definition: Value.cpp:525
virtual void MF_HandleInsertion(MachineInstr &MI)=0
Callback after an insertion. This should not modify the MI directly.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Abstract base class for all machine specific constantpool value subclasses.
static wasm::ValType getType(const TargetRegisterClass *RC)
This class contains a discriminated union of information about pointers in memory operands...
const char * createExternalSymbolName(StringRef Name)
Allocate a string and populate it with the given external symbol name.
void print(raw_ostream &OS, const SlotIndexes *=nullptr) const
print - Print out the MachineFunction in a format suitable for debugging to the specified stream...
unsigned getStackAlignment() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:40
bool hasSubClassEq(const TargetRegisterClass *RC) const
Returns true if RC is a sub-class of or equal to this class.
void addCleanup(MachineBasicBlock *LandingPad)
Add a cleanup action for a landing pad.
DOTGraphTraits - Template class that can be specialized to customize how graphs are converted to &#39;dot...
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:239
Iterator for intrusive lists based on ilist_node.
Base class for types.
bool isFuncletEHPersonality(EHPersonality Pers)
Returns true if this is a personality function that invokes handler funclets (which must return to it...
bool shouldSplitStack() const
Should we be emitting segmented stack stuff for the function.
MachineInstr * CloneMachineInstr(const MachineInstr *Orig)
Create a new MachineInstr which is a copy of Orig, identical in all ways except the instruction has n...
bool ReplaceMBBInJumpTables(MachineBasicBlock *Old, MachineBasicBlock *New)
ReplaceMBBInJumpTables - If Old is the target of any jump tables, update the jump tables to branch to...
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
Module.h This file contains the declarations for the Module class.
iterator end() const
Definition: ArrayRef.h:137
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:643
static SectionKind getReadOnlyWithRel()
Definition: SectionKind.h:202
unsigned getABIIntegerTypeAlignment(unsigned BitWidth) const
Returns the minimum ABI-required alignment for an integer type of the specified bitwidth.
Definition: DataLayout.cpp:758
void addCatchTypeInfo(MachineBasicBlock *LandingPad, ArrayRef< const GlobalValue *> TyInfo)
Provide the catch typeinfo for a landing pad.
uint32_t * allocateRegMask()
Allocate and initialize a register mask with NumRegister bits.
void clear(AllocatorType &Allocator)
Release all the tracked allocations to the allocator.
virtual void MF_HandleRemoval(MachineInstr &MI)=0
Callback before a removal. This should not modify the MI directly.
static void deleteNode(NodeTy *V)
Definition: ilist.h:41
const Function & getFunction() const
Return the LLVM function that this machine code represents.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
MachinePointerInfo getWithOffset(int64_t O) const
void setCallSiteLandingPad(MCSymbol *Sym, ArrayRef< unsigned > Sites)
Map the landing pad&#39;s EH symbol to the call site indexes.
bool isDefined() const
isDefined - Check if this symbol is defined (i.e., it has an address).
Definition: MCSymbol.h:249
Target - Wrapper for Target specific information.
llvm::Align getPrefFunctionAlignment() const
Return the preferred function alignment.
unsigned getEntrySize(const DataLayout &TD) const
getEntrySize - Return the size of each entry in the jump table.
MachineJumpTableEntry - One jump table in the jump table info.
void addCodeViewHeapAllocSite(MachineInstr *I, const MDNode *MD)
Record heapallocsites.
MachineBasicBlock * LandingPadBlock
Flags
Flags values. These may be or&#39;d together.
MachineRegisterInfo - Keep track of information for virtual and physical registers, including vreg register classes, use/def chains for registers, etc.
MachineFunctionProperties & set(Property P)
TargetSubtargetInfo - Generic base class for all target subtargets.
uint64_t getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:470
static const char * getPropertyName(MachineFunctionProperties::Property Prop)
Representation of each machine instruction.
Definition: MachineInstr.h:64
std::vector< std::pair< unsigned, unsigned > >::const_iterator livein_iterator
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
const MachinePointerInfo & getPointerInfo() const
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
void setPreInstrSymbol(MachineFunction &MF, MCSymbol *Symbol)
Set a symbol that will be emitted just prior to the instruction itself.
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:129
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:214
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
Flags getFlags() const
Return the raw flags of the source value,.
virtual const TargetFrameLowering * getFrameLowering() const
iterator end()
Definition: DenseMap.h:82
SectionKind getSectionKind(const DataLayout *DL) const
const BasicBlock * getBasicBlock() const
Return the LLVM basic block that this instance corresponded to originally.
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:332
uint32_t Size
Definition: Profile.cpp:46
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:91
void viewCFGOnly() const
viewCFGOnly - This function is meant for use from the debugger.
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)
void dump() const
dump - Call print(cerr) to be called from the debugger.
#define LLVM_NODISCARD
LLVM_NODISCARD - Warn if a type or return value is discarded.
Definition: Compiler.h:145
bool isStackRealignable() const
isStackRealignable - This method returns whether the stack can be realigned.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:503
aarch64 promote const
LandingPadInfo & getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad)
Find or create an LandingPadInfo for the specified MachineBasicBlock.
int64_t getOffset() const
For normal values, this is a byte offset added to the base address.
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:575
LLVM Value Representation.
Definition: Value.h:73
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1405
MachineFunction(const Function &F, const LLVMTargetMachine &Target, const TargetSubtargetInfo &STI, unsigned FunctionNum, MachineModuleInfo &MMI)
void deallocateOperandArray(OperandCapacity Cap, MachineOperand *Array)
Dellocate an array of MachineOperands and recycle the memory.
uint64_t getTypeStoreSize(Type *Ty) const
Returns the maximum number of bytes that may be overwritten by storing the specified type...
Definition: DataLayout.h:445
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID for this memory operation.
MCSymbol * getPICBaseSymbol() const
getPICBaseSymbol - Return a function-local symbol to represent the PIC base.
const BlockAddress * RecoverBA
Address of block to recover at. Null for a finally handler.
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E&#39;s largest value.
Definition: BitmaskEnum.h:80
static const Function * getParent(const Value *V)
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
DefaultDOTGraphTraits - This class provides the default implementations of all of the DOTGraphTraits ...
unsigned createJumpTableIndex(const std::vector< MachineBasicBlock *> &DestBBs)
createJumpTableIndex - Create a new jump table.
void dump() const
dump - Call to stderr.
IRTranslator LLVM IR MI
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
EK_GPRel32BlockAddress - Each entry is an address of block, encoded with a relocation as gp-relative...
Simple wrapper around std::function<void(raw_ostream&)>.
Definition: Printable.h:37
unsigned getLiveInVirtReg(unsigned PReg) const
getLiveInVirtReg - If PReg is a live-in physical register, return the corresponding live-in physical ...
OutputIt copy(R &&Range, OutputIt Out)
Definition: STLExtras.h:1217
VariableDbgInfoMapTy VariableDbgInfos
static SectionKind getReadOnly()
Definition: SectionKind.h:181
unsigned getConstantPoolIndex(const Constant *C, unsigned Alignment)
getConstantPoolIndex - Create a new entry in the constant pool or return an existing one...
bool needsRelocation() const
This method classifies the entry according to whether or not it may generate a relocation entry...
This class contains meta information specific to a module.
This file describes how to lower LLVM code to machine code.
void addFilterTypeInfo(MachineBasicBlock *LandingPad, ArrayRef< const GlobalValue *> TyInfo)
Provide the filter typeinfo for a landing pad.