LLVM  8.0.0svn
MachineFunction.cpp
Go to the documentation of this file.
1 //===- MachineFunction.cpp ------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Collect native machine code information for a function. This allows
11 // target-specific information about the generated code to be stored with each
12 // function.
13 //
14 //===----------------------------------------------------------------------===//
15 
17 #include "llvm/ADT/BitVector.h"
18 #include "llvm/ADT/DenseMap.h"
19 #include "llvm/ADT/DenseSet.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/SmallString.h"
22 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/ADT/StringRef.h"
24 #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"
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 
81 static cl::opt<unsigned>
82 AlignAllFunctions("align-all-functions",
83  cl::desc("Force the alignment of all functions."),
84  cl::init(0), cl::Hidden);
85 
88 
89  switch(Prop) {
90  case P::FailedISel: return "FailedISel";
91  case P::IsSSA: return "IsSSA";
92  case P::Legalized: return "Legalized";
93  case P::NoPHIs: return "NoPHIs";
94  case P::NoVRegs: return "NoVRegs";
95  case P::RegBankSelected: return "RegBankSelected";
96  case P::Selected: return "Selected";
97  case P::TracksLiveness: return "TracksLiveness";
98  }
99  llvm_unreachable("Invalid machine function property");
100 }
101 
102 // Pin the vtable to this file.
103 void MachineFunction::Delegate::anchor() {}
104 
106  const char *Separator = "";
107  for (BitVector::size_type I = 0; I < Properties.size(); ++I) {
108  if (!Properties[I])
109  continue;
110  OS << Separator << getPropertyName(static_cast<Property>(I));
111  Separator = ", ";
112  }
113 }
114 
115 //===----------------------------------------------------------------------===//
116 // MachineFunction implementation
117 //===----------------------------------------------------------------------===//
118 
119 // Out-of-line virtual method.
121 
123  MBB->getParent()->DeleteMachineBasicBlock(MBB);
124 }
125 
126 static inline unsigned getFnStackAlignment(const TargetSubtargetInfo *STI,
127  const Function &F) {
128  if (F.hasFnAttribute(Attribute::StackAlignment))
129  return F.getFnStackAlignment();
130  return STI->getFrameLowering()->getStackAlignment();
131 }
132 
134  const LLVMTargetMachine &Target,
135  const TargetSubtargetInfo &STI,
136  unsigned FunctionNum, MachineModuleInfo &mmi)
137  : F(F), Target(Target), STI(&STI), Ctx(mmi.getContext()), MMI(mmi) {
138  FunctionNumber = FunctionNum;
139  init();
140 }
141 
142 void MachineFunction::handleInsertion(const MachineInstr &MI) {
143  if (TheDelegate)
144  TheDelegate->MF_HandleInsertion(MI);
145 }
146 
147 void MachineFunction::handleRemoval(const MachineInstr &MI) {
148  if (TheDelegate)
149  TheDelegate->MF_HandleRemoval(MI);
150 }
151 
152 void MachineFunction::init() {
153  // Assume the function starts in SSA form with correct liveness.
156  if (STI->getRegisterInfo())
157  RegInfo = new (Allocator) MachineRegisterInfo(this);
158  else
159  RegInfo = nullptr;
160 
161  MFInfo = nullptr;
162  // We can realign the stack if the target supports it and the user hasn't
163  // explicitly asked us not to.
164  bool CanRealignSP = STI->getFrameLowering()->isStackRealignable() &&
165  !F.hasFnAttribute("no-realign-stack");
166  FrameInfo = new (Allocator) MachineFrameInfo(
167  getFnStackAlignment(STI, F), /*StackRealignable=*/CanRealignSP,
168  /*ForceRealign=*/CanRealignSP &&
169  F.hasFnAttribute(Attribute::StackAlignment));
170 
171  if (F.hasFnAttribute(Attribute::StackAlignment))
172  FrameInfo->ensureMaxAlignment(F.getFnStackAlignment());
173 
174  ConstantPool = new (Allocator) MachineConstantPool(getDataLayout());
175  Alignment = STI->getTargetLowering()->getMinFunctionAlignment();
176 
177  // FIXME: Shouldn't use pref alignment if explicit alignment is set on F.
178  // FIXME: Use Function::optForSize().
179  if (!F.hasFnAttribute(Attribute::OptimizeForSize))
180  Alignment = std::max(Alignment,
182 
183  if (AlignAllFunctions)
184  Alignment = AlignAllFunctions;
185 
186  JumpTableInfo = nullptr;
187 
189  F.hasPersonalityFn() ? F.getPersonalityFn() : nullptr))) {
190  WinEHInfo = new (Allocator) WinEHFuncInfo();
191  }
192 
194  F.hasPersonalityFn() ? F.getPersonalityFn() : nullptr))) {
195  WasmEHInfo = new (Allocator) WasmEHFuncInfo();
196  }
197 
198  assert(Target.isCompatibleDataLayout(getDataLayout()) &&
199  "Can't create a MachineFunction using a Module with a "
200  "Target-incompatible DataLayout attached\n");
201 
202  PSVManager =
203  llvm::make_unique<PseudoSourceValueManager>(*(getSubtarget().
204  getInstrInfo()));
205 }
206 
208  clear();
209 }
210 
211 void MachineFunction::clear() {
212  Properties.reset();
213  // Don't call destructors on MachineInstr and MachineOperand. All of their
214  // memory comes from the BumpPtrAllocator which is about to be purged.
215  //
216  // Do call MachineBasicBlock destructors, it contains std::vectors.
217  for (iterator I = begin(), E = end(); I != E; I = BasicBlocks.erase(I))
218  I->Insts.clearAndLeakNodesUnsafely();
219  MBBNumbering.clear();
220 
221  InstructionRecycler.clear(Allocator);
222  OperandRecycler.clear(Allocator);
223  BasicBlockRecycler.clear(Allocator);
224  CodeViewAnnotations.clear();
226  if (RegInfo) {
227  RegInfo->~MachineRegisterInfo();
228  Allocator.Deallocate(RegInfo);
229  }
230  if (MFInfo) {
231  MFInfo->~MachineFunctionInfo();
232  Allocator.Deallocate(MFInfo);
233  }
234 
235  FrameInfo->~MachineFrameInfo();
236  Allocator.Deallocate(FrameInfo);
237 
238  ConstantPool->~MachineConstantPool();
239  Allocator.Deallocate(ConstantPool);
240 
241  if (JumpTableInfo) {
242  JumpTableInfo->~MachineJumpTableInfo();
243  Allocator.Deallocate(JumpTableInfo);
244  }
245 
246  if (WinEHInfo) {
247  WinEHInfo->~WinEHFuncInfo();
248  Allocator.Deallocate(WinEHInfo);
249  }
250 
251  if (WasmEHInfo) {
252  WasmEHInfo->~WasmEHFuncInfo();
253  Allocator.Deallocate(WasmEHInfo);
254  }
255 }
256 
258  return F.getParent()->getDataLayout();
259 }
260 
261 /// Get the JumpTableInfo for this function.
262 /// If it does not already exist, allocate one.
265  if (JumpTableInfo) return JumpTableInfo;
266 
267  JumpTableInfo = new (Allocator)
269  return JumpTableInfo;
270 }
271 
272 /// Should we be emitting segmented stack stuff for the function
274  return getFunction().hasFnAttribute("split-stack");
275 }
276 
277 /// This discards all of the MachineBasicBlock numbers and recomputes them.
278 /// This guarantees that the MBB numbers are sequential, dense, and match the
279 /// ordering of the blocks within the function. If a specific MachineBasicBlock
280 /// is specified, only that block and those after it are renumbered.
282  if (empty()) { MBBNumbering.clear(); return; }
283  MachineFunction::iterator MBBI, E = end();
284  if (MBB == nullptr)
285  MBBI = begin();
286  else
287  MBBI = MBB->getIterator();
288 
289  // Figure out the block number this should have.
290  unsigned BlockNo = 0;
291  if (MBBI != begin())
292  BlockNo = std::prev(MBBI)->getNumber() + 1;
293 
294  for (; MBBI != E; ++MBBI, ++BlockNo) {
295  if (MBBI->getNumber() != (int)BlockNo) {
296  // Remove use of the old number.
297  if (MBBI->getNumber() != -1) {
298  assert(MBBNumbering[MBBI->getNumber()] == &*MBBI &&
299  "MBB number mismatch!");
300  MBBNumbering[MBBI->getNumber()] = nullptr;
301  }
302 
303  // If BlockNo is already taken, set that block's number to -1.
304  if (MBBNumbering[BlockNo])
305  MBBNumbering[BlockNo]->setNumber(-1);
306 
307  MBBNumbering[BlockNo] = &*MBBI;
308  MBBI->setNumber(BlockNo);
309  }
310  }
311 
312  // Okay, all the blocks are renumbered. If we have compactified the block
313  // numbering, shrink MBBNumbering now.
314  assert(BlockNo <= MBBNumbering.size() && "Mismatch!");
315  MBBNumbering.resize(BlockNo);
316 }
317 
318 /// Allocate a new MachineInstr. Use this instead of `new MachineInstr'.
320  const DebugLoc &DL,
321  bool NoImp) {
322  return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
323  MachineInstr(*this, MCID, DL, NoImp);
324 }
325 
326 /// Create a new MachineInstr which is a copy of the 'Orig' instruction,
327 /// identical in all ways except the instruction has no parent, prev, or next.
328 MachineInstr *
330  return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
331  MachineInstr(*this, *Orig);
332 }
333 
335  MachineBasicBlock::iterator InsertBefore, const MachineInstr &Orig) {
336  MachineInstr *FirstClone = nullptr;
338  while (true) {
339  MachineInstr *Cloned = CloneMachineInstr(&*I);
340  MBB.insert(InsertBefore, Cloned);
341  if (FirstClone == nullptr) {
342  FirstClone = Cloned;
343  } else {
344  Cloned->bundleWithPred();
345  }
346 
347  if (!I->isBundledWithSucc())
348  break;
349  ++I;
350  }
351  return *FirstClone;
352 }
353 
354 /// Delete the given MachineInstr.
355 ///
356 /// This function also serves as the MachineInstr destructor - the real
357 /// ~MachineInstr() destructor must be empty.
358 void
360  // Strip it for parts. The operand array and the MI object itself are
361  // independently recyclable.
362  if (MI->Operands)
363  deallocateOperandArray(MI->CapOperands, MI->Operands);
364  // Don't call ~MachineInstr() which must be trivial anyway because
365  // ~MachineFunction drops whole lists of MachineInstrs wihout calling their
366  // destructors.
367  InstructionRecycler.Deallocate(Allocator, MI);
368 }
369 
370 /// Allocate a new MachineBasicBlock. Use this instead of
371 /// `new MachineBasicBlock'.
374  return new (BasicBlockRecycler.Allocate<MachineBasicBlock>(Allocator))
375  MachineBasicBlock(*this, bb);
376 }
377 
378 /// Delete the given MachineBasicBlock.
379 void
381  assert(MBB->getParent() == this && "MBB parent mismatch!");
382  MBB->~MachineBasicBlock();
383  BasicBlockRecycler.Deallocate(Allocator, MBB);
384 }
385 
387  MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s,
388  unsigned base_alignment, const AAMDNodes &AAInfo, const MDNode *Ranges,
389  SyncScope::ID SSID, AtomicOrdering Ordering,
390  AtomicOrdering FailureOrdering) {
391  return new (Allocator)
392  MachineMemOperand(PtrInfo, f, s, base_alignment, AAInfo, Ranges,
393  SSID, Ordering, FailureOrdering);
394 }
395 
398  int64_t Offset, uint64_t Size) {
399  if (MMO->getValue())
400  return new (Allocator)
402  MMO->getOffset()+Offset),
403  MMO->getFlags(), Size, MMO->getBaseAlignment(),
404  AAMDNodes(), nullptr, MMO->getSyncScopeID(),
405  MMO->getOrdering(), MMO->getFailureOrdering());
406  return new (Allocator)
408  MMO->getOffset()+Offset),
409  MMO->getFlags(), Size, MMO->getBaseAlignment(),
410  AAMDNodes(), nullptr, MMO->getSyncScopeID(),
411  MMO->getOrdering(), MMO->getFailureOrdering());
412 }
413 
416  const AAMDNodes &AAInfo) {
417  MachinePointerInfo MPI = MMO->getValue() ?
418  MachinePointerInfo(MMO->getValue(), MMO->getOffset()) :
420 
421  return new (Allocator)
422  MachineMemOperand(MPI, MMO->getFlags(), MMO->getSize(),
423  MMO->getBaseAlignment(), AAInfo,
424  MMO->getRanges(), MMO->getSyncScopeID(),
425  MMO->getOrdering(), MMO->getFailureOrdering());
426 }
427 
428 MachineInstr::ExtraInfo *
430  MCSymbol *PreInstrSymbol,
431  MCSymbol *PostInstrSymbol) {
432  return MachineInstr::ExtraInfo::create(Allocator, MMOs, PreInstrSymbol,
433  PostInstrSymbol);
434 }
435 
437  char *Dest = Allocator.Allocate<char>(Name.size() + 1);
438  std::copy(Name.begin(), Name.end(), Dest);
439  Dest[Name.size()] = 0;
440  return Dest;
441 }
442 
444  unsigned NumRegs = getSubtarget().getRegisterInfo()->getNumRegs();
445  unsigned Size = MachineOperand::getRegMaskSize(NumRegs);
446  uint32_t *Mask = Allocator.Allocate<uint32_t>(Size);
447  memset(Mask, 0, Size * sizeof(Mask[0]));
448  return Mask;
449 }
450 
451 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
453  print(dbgs());
454 }
455 #endif
456 
458  return getFunction().getName();
459 }
460 
461 void MachineFunction::print(raw_ostream &OS, const SlotIndexes *Indexes) const {
462  OS << "# Machine code for function " << getName() << ": ";
463  getProperties().print(OS);
464  OS << '\n';
465 
466  // Print Frame Information
467  FrameInfo->print(*this, OS);
468 
469  // Print JumpTable Information
470  if (JumpTableInfo)
471  JumpTableInfo->print(OS);
472 
473  // Print Constant Pool
474  ConstantPool->print(OS);
475 
477 
478  if (RegInfo && !RegInfo->livein_empty()) {
479  OS << "Function Live Ins: ";
481  I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) {
482  OS << printReg(I->first, TRI);
483  if (I->second)
484  OS << " in " << printReg(I->second, TRI);
485  if (std::next(I) != E)
486  OS << ", ";
487  }
488  OS << '\n';
489  }
490 
493  for (const auto &BB : *this) {
494  OS << '\n';
495  // If we print the whole function, print it at its most verbose level.
496  BB.print(OS, MST, Indexes, /*IsStandalone=*/true);
497  }
498 
499  OS << "\n# End machine code for function " << getName() << ".\n\n";
500 }
501 
502 namespace llvm {
503 
504  template<>
507 
508  static std::string getGraphName(const MachineFunction *F) {
509  return ("CFG for '" + F->getName() + "' function").str();
510  }
511 
512  std::string getNodeLabel(const MachineBasicBlock *Node,
513  const MachineFunction *Graph) {
514  std::string OutStr;
515  {
516  raw_string_ostream OSS(OutStr);
517 
518  if (isSimple()) {
519  OSS << printMBBReference(*Node);
520  if (const BasicBlock *BB = Node->getBasicBlock())
521  OSS << ": " << BB->getName();
522  } else
523  Node->print(OSS);
524  }
525 
526  if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());
527 
528  // Process string output to make it nicer...
529  for (unsigned i = 0; i != OutStr.length(); ++i)
530  if (OutStr[i] == '\n') { // Left justify
531  OutStr[i] = '\\';
532  OutStr.insert(OutStr.begin()+i+1, 'l');
533  }
534  return OutStr;
535  }
536  };
537 
538 } // end namespace llvm
539 
541 {
542 #ifndef NDEBUG
543  ViewGraph(this, "mf" + getName());
544 #else
545  errs() << "MachineFunction::viewCFG is only available in debug builds on "
546  << "systems with Graphviz or gv!\n";
547 #endif // NDEBUG
548 }
549 
551 {
552 #ifndef NDEBUG
553  ViewGraph(this, "mf" + getName(), true);
554 #else
555  errs() << "MachineFunction::viewCFGOnly is only available in debug builds on "
556  << "systems with Graphviz or gv!\n";
557 #endif // NDEBUG
558 }
559 
560 /// Add the specified physical register as a live-in value and
561 /// create a corresponding virtual register for it.
562 unsigned MachineFunction::addLiveIn(unsigned PReg,
563  const TargetRegisterClass *RC) {
565  unsigned VReg = MRI.getLiveInVirtReg(PReg);
566  if (VReg) {
567  const TargetRegisterClass *VRegRC = MRI.getRegClass(VReg);
568  (void)VRegRC;
569  // A physical register can be added several times.
570  // Between two calls, the register class of the related virtual register
571  // may have been constrained to match some operation constraints.
572  // In that case, check that the current register class includes the
573  // physical register and is a sub class of the specified RC.
574  assert((VRegRC == RC || (VRegRC->contains(PReg) &&
575  RC->hasSubClassEq(VRegRC))) &&
576  "Register class mismatch!");
577  return VReg;
578  }
579  VReg = MRI.createVirtualRegister(RC);
580  MRI.addLiveIn(PReg, VReg);
581  return VReg;
582 }
583 
584 /// Return the MCSymbol for the specified non-empty jump table.
585 /// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
586 /// normal 'L' label is returned.
588  bool isLinkerPrivate) const {
589  const DataLayout &DL = getDataLayout();
590  assert(JumpTableInfo && "No jump tables");
591  assert(JTI < JumpTableInfo->getJumpTables().size() && "Invalid JTI!");
592 
593  StringRef Prefix = isLinkerPrivate ? DL.getLinkerPrivateGlobalPrefix()
594  : DL.getPrivateGlobalPrefix();
596  raw_svector_ostream(Name)
597  << Prefix << "JTI" << getFunctionNumber() << '_' << JTI;
598  return Ctx.getOrCreateSymbol(Name);
599 }
600 
601 /// Return a function-local symbol to represent the PIC base.
603  const DataLayout &DL = getDataLayout();
604  return Ctx.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) +
605  Twine(getFunctionNumber()) + "$pb");
606 }
607 
608 /// \name Exception Handling
609 /// \{
610 
613  unsigned N = LandingPads.size();
614  for (unsigned i = 0; i < N; ++i) {
615  LandingPadInfo &LP = LandingPads[i];
616  if (LP.LandingPadBlock == LandingPad)
617  return LP;
618  }
619 
620  LandingPads.push_back(LandingPadInfo(LandingPad));
621  return LandingPads[N];
622 }
623 
625  MCSymbol *BeginLabel, MCSymbol *EndLabel) {
626  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
627  LP.BeginLabels.push_back(BeginLabel);
628  LP.EndLabels.push_back(EndLabel);
629 }
630 
632  MCSymbol *LandingPadLabel = Ctx.createTempSymbol();
633  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
634  LP.LandingPadLabel = LandingPadLabel;
635 
636  const Instruction *FirstI = LandingPad->getBasicBlock()->getFirstNonPHI();
637  if (const auto *LPI = dyn_cast<LandingPadInst>(FirstI)) {
638  if (const auto *PF =
639  dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts()))
640  getMMI().addPersonality(PF);
641 
642  if (LPI->isCleanup())
643  addCleanup(LandingPad);
644 
645  // FIXME: New EH - Add the clauses in reverse order. This isn't 100%
646  // correct, but we need to do it this way because of how the DWARF EH
647  // emitter processes the clauses.
648  for (unsigned I = LPI->getNumClauses(); I != 0; --I) {
649  Value *Val = LPI->getClause(I - 1);
650  if (LPI->isCatch(I - 1)) {
651  addCatchTypeInfo(LandingPad,
652  dyn_cast<GlobalValue>(Val->stripPointerCasts()));
653  } else {
654  // Add filters in a list.
655  auto *CVal = cast<Constant>(Val);
657  for (User::op_iterator II = CVal->op_begin(), IE = CVal->op_end();
658  II != IE; ++II)
659  FilterList.push_back(cast<GlobalValue>((*II)->stripPointerCasts()));
660 
661  addFilterTypeInfo(LandingPad, FilterList);
662  }
663  }
664 
665  } else if (const auto *CPI = dyn_cast<CatchPadInst>(FirstI)) {
666  for (unsigned I = CPI->getNumArgOperands(); I != 0; --I) {
667  Value *TypeInfo = CPI->getArgOperand(I - 1)->stripPointerCasts();
668  addCatchTypeInfo(LandingPad, dyn_cast<GlobalValue>(TypeInfo));
669  }
670 
671  } else {
672  assert(isa<CleanupPadInst>(FirstI) && "Invalid landingpad!");
673  }
674 
675  return LandingPadLabel;
676 }
677 
680  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
681  for (unsigned N = TyInfo.size(); N; --N)
682  LP.TypeIds.push_back(getTypeIDFor(TyInfo[N - 1]));
683 }
684 
687  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
688  std::vector<unsigned> IdsInFilter(TyInfo.size());
689  for (unsigned I = 0, E = TyInfo.size(); I != E; ++I)
690  IdsInFilter[I] = getTypeIDFor(TyInfo[I]);
691  LP.TypeIds.push_back(getFilterIDFor(IdsInFilter));
692 }
693 
695  bool TidyIfNoBeginLabels) {
696  for (unsigned i = 0; i != LandingPads.size(); ) {
697  LandingPadInfo &LandingPad = LandingPads[i];
698  if (LandingPad.LandingPadLabel &&
699  !LandingPad.LandingPadLabel->isDefined() &&
700  (!LPMap || (*LPMap)[LandingPad.LandingPadLabel] == 0))
701  LandingPad.LandingPadLabel = nullptr;
702 
703  // Special case: we *should* emit LPs with null LP MBB. This indicates
704  // "nounwind" case.
705  if (!LandingPad.LandingPadLabel && LandingPad.LandingPadBlock) {
706  LandingPads.erase(LandingPads.begin() + i);
707  continue;
708  }
709 
710  if (TidyIfNoBeginLabels) {
711  for (unsigned j = 0, e = LandingPads[i].BeginLabels.size(); j != e; ++j) {
712  MCSymbol *BeginLabel = LandingPad.BeginLabels[j];
713  MCSymbol *EndLabel = LandingPad.EndLabels[j];
714  if ((BeginLabel->isDefined() || (LPMap && (*LPMap)[BeginLabel] != 0)) &&
715  (EndLabel->isDefined() || (LPMap && (*LPMap)[EndLabel] != 0)))
716  continue;
717 
718  LandingPad.BeginLabels.erase(LandingPad.BeginLabels.begin() + j);
719  LandingPad.EndLabels.erase(LandingPad.EndLabels.begin() + j);
720  --j;
721  --e;
722  }
723 
724  // Remove landing pads with no try-ranges.
725  if (LandingPads[i].BeginLabels.empty()) {
726  LandingPads.erase(LandingPads.begin() + i);
727  continue;
728  }
729  }
730 
731  // If there is no landing pad, ensure that the list of typeids is empty.
732  // If the only typeid is a cleanup, this is the same as having no typeids.
733  if (!LandingPad.LandingPadBlock ||
734  (LandingPad.TypeIds.size() == 1 && !LandingPad.TypeIds[0]))
735  LandingPad.TypeIds.clear();
736  ++i;
737  }
738 }
739 
741  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
742  LP.TypeIds.push_back(0);
743 }
744 
746  const Function *Filter,
747  const BlockAddress *RecoverBA) {
748  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
749  SEHHandler Handler;
750  Handler.FilterOrFinally = Filter;
751  Handler.RecoverBA = RecoverBA;
752  LP.SEHHandlers.push_back(Handler);
753 }
754 
756  const Function *Cleanup) {
757  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
758  SEHHandler Handler;
759  Handler.FilterOrFinally = Cleanup;
760  Handler.RecoverBA = nullptr;
761  LP.SEHHandlers.push_back(Handler);
762 }
763 
765  ArrayRef<unsigned> Sites) {
766  LPadToCallSiteMap[Sym].append(Sites.begin(), Sites.end());
767 }
768 
770  for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i)
771  if (TypeInfos[i] == TI) return i + 1;
772 
773  TypeInfos.push_back(TI);
774  return TypeInfos.size();
775 }
776 
777 int MachineFunction::getFilterIDFor(std::vector<unsigned> &TyIds) {
778  // If the new filter coincides with the tail of an existing filter, then
779  // re-use the existing filter. Folding filters more than this requires
780  // re-ordering filters and/or their elements - probably not worth it.
781  for (std::vector<unsigned>::iterator I = FilterEnds.begin(),
782  E = FilterEnds.end(); I != E; ++I) {
783  unsigned i = *I, j = TyIds.size();
784 
785  while (i && j)
786  if (FilterIds[--i] != TyIds[--j])
787  goto try_next;
788 
789  if (!j)
790  // The new filter coincides with range [i, end) of the existing filter.
791  return -(1 + i);
792 
793 try_next:;
794  }
795 
796  // Add the new filter.
797  int FilterID = -(1 + FilterIds.size());
798  FilterIds.reserve(FilterIds.size() + TyIds.size() + 1);
799  FilterIds.insert(FilterIds.end(), TyIds.begin(), TyIds.end());
800  FilterEnds.push_back(FilterIds.size());
801  FilterIds.push_back(0); // terminator
802  return FilterID;
803 }
804 
805 /// \}
806 
807 //===----------------------------------------------------------------------===//
808 // MachineJumpTableInfo implementation
809 //===----------------------------------------------------------------------===//
810 
811 /// Return the size of each entry in the jump table.
813  // The size of a jump table entry is 4 bytes unless the entry is just the
814  // address of a block, in which case it is the pointer size.
815  switch (getEntryKind()) {
817  return TD.getPointerSize();
819  return 8;
823  return 4;
825  return 0;
826  }
827  llvm_unreachable("Unknown jump table encoding!");
828 }
829 
830 /// Return the alignment of each entry in the jump table.
832  // The alignment of a jump table entry is the alignment of int32 unless the
833  // entry is just the address of a block, in which case it is the pointer
834  // alignment.
835  switch (getEntryKind()) {
837  return TD.getPointerABIAlignment(0);
839  return TD.getABIIntegerTypeAlignment(64);
843  return TD.getABIIntegerTypeAlignment(32);
845  return 1;
846  }
847  llvm_unreachable("Unknown jump table encoding!");
848 }
849 
850 /// Create a new jump table entry in the jump table info.
852  const std::vector<MachineBasicBlock*> &DestBBs) {
853  assert(!DestBBs.empty() && "Cannot create an empty jump table!");
854  JumpTables.push_back(MachineJumpTableEntry(DestBBs));
855  return JumpTables.size()-1;
856 }
857 
858 /// If Old is the target of any jump tables, update the jump tables to branch
859 /// to New instead.
861  MachineBasicBlock *New) {
862  assert(Old != New && "Not making a change?");
863  bool MadeChange = false;
864  for (size_t i = 0, e = JumpTables.size(); i != e; ++i)
865  ReplaceMBBInJumpTable(i, Old, New);
866  return MadeChange;
867 }
868 
869 /// If Old is a target of the jump tables, update the jump table to branch to
870 /// New instead.
872  MachineBasicBlock *Old,
873  MachineBasicBlock *New) {
874  assert(Old != New && "Not making a change?");
875  bool MadeChange = false;
876  MachineJumpTableEntry &JTE = JumpTables[Idx];
877  for (size_t j = 0, e = JTE.MBBs.size(); j != e; ++j)
878  if (JTE.MBBs[j] == Old) {
879  JTE.MBBs[j] = New;
880  MadeChange = true;
881  }
882  return MadeChange;
883 }
884 
886  if (JumpTables.empty()) return;
887 
888  OS << "Jump Tables:\n";
889 
890  for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) {
891  OS << printJumpTableEntryReference(i) << ": ";
892  for (unsigned j = 0, f = JumpTables[i].MBBs.size(); j != f; ++j)
893  OS << ' ' << printMBBReference(*JumpTables[i].MBBs[j]);
894  }
895 
896  OS << '\n';
897 }
898 
899 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
901 #endif
902 
904  return Printable([Idx](raw_ostream &OS) { OS << "%jump-table." << Idx; });
905 }
906 
907 //===----------------------------------------------------------------------===//
908 // MachineConstantPool implementation
909 //===----------------------------------------------------------------------===//
910 
911 void MachineConstantPoolValue::anchor() {}
912 
914  if (isMachineConstantPoolEntry())
915  return Val.MachineCPVal->getType();
916  return Val.ConstVal->getType();
917 }
918 
920  if (isMachineConstantPoolEntry())
921  return true;
922  return Val.ConstVal->needsRelocation();
923 }
924 
927  if (needsRelocation())
929  switch (DL->getTypeAllocSize(getType())) {
930  case 4:
932  case 8:
934  case 16:
936  case 32:
938  default:
939  return SectionKind::getReadOnly();
940  }
941 }
942 
944  // A constant may be a member of both Constants and MachineCPVsSharingEntries,
945  // so keep track of which we've deleted to avoid double deletions.
947  for (unsigned i = 0, e = Constants.size(); i != e; ++i)
948  if (Constants[i].isMachineConstantPoolEntry()) {
949  Deleted.insert(Constants[i].Val.MachineCPVal);
950  delete Constants[i].Val.MachineCPVal;
951  }
953  MachineCPVsSharingEntries.begin(), E = MachineCPVsSharingEntries.end();
954  I != E; ++I) {
955  if (Deleted.count(*I) == 0)
956  delete *I;
957  }
958 }
959 
960 /// Test whether the given two constants can be allocated the same constant pool
961 /// entry.
962 static bool CanShareConstantPoolEntry(const Constant *A, const Constant *B,
963  const DataLayout &DL) {
964  // Handle the trivial case quickly.
965  if (A == B) return true;
966 
967  // If they have the same type but weren't the same constant, quickly
968  // reject them.
969  if (A->getType() == B->getType()) return false;
970 
971  // We can't handle structs or arrays.
972  if (isa<StructType>(A->getType()) || isa<ArrayType>(A->getType()) ||
973  isa<StructType>(B->getType()) || isa<ArrayType>(B->getType()))
974  return false;
975 
976  // For now, only support constants with the same size.
977  uint64_t StoreSize = DL.getTypeStoreSize(A->getType());
978  if (StoreSize != DL.getTypeStoreSize(B->getType()) || StoreSize > 128)
979  return false;
980 
981  Type *IntTy = IntegerType::get(A->getContext(), StoreSize*8);
982 
983  // Try constant folding a bitcast of both instructions to an integer. If we
984  // get two identical ConstantInt's, then we are good to share them. We use
985  // the constant folding APIs to do this so that we get the benefit of
986  // DataLayout.
987  if (isa<PointerType>(A->getType()))
988  A = ConstantFoldCastOperand(Instruction::PtrToInt,
989  const_cast<Constant *>(A), IntTy, DL);
990  else if (A->getType() != IntTy)
991  A = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(A),
992  IntTy, DL);
993  if (isa<PointerType>(B->getType()))
994  B = ConstantFoldCastOperand(Instruction::PtrToInt,
995  const_cast<Constant *>(B), IntTy, DL);
996  else if (B->getType() != IntTy)
997  B = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(B),
998  IntTy, DL);
999 
1000  return A == B;
1001 }
1002 
1003 /// Create a new entry in the constant pool or return an existing one.
1004 /// User must specify the log2 of the minimum required alignment for the object.
1006  unsigned Alignment) {
1007  assert(Alignment && "Alignment must be specified!");
1008  if (Alignment > PoolAlignment) PoolAlignment = Alignment;
1009 
1010  // Check to see if we already have this constant.
1011  //
1012  // FIXME, this could be made much more efficient for large constant pools.
1013  for (unsigned i = 0, e = Constants.size(); i != e; ++i)
1014  if (!Constants[i].isMachineConstantPoolEntry() &&
1015  CanShareConstantPoolEntry(Constants[i].Val.ConstVal, C, DL)) {
1016  if ((unsigned)Constants[i].getAlignment() < Alignment)
1017  Constants[i].Alignment = Alignment;
1018  return i;
1019  }
1020 
1021  Constants.push_back(MachineConstantPoolEntry(C, Alignment));
1022  return Constants.size()-1;
1023 }
1024 
1026  unsigned Alignment) {
1027  assert(Alignment && "Alignment must be specified!");
1028  if (Alignment > PoolAlignment) PoolAlignment = Alignment;
1029 
1030  // Check to see if we already have this constant.
1031  //
1032  // FIXME, this could be made much more efficient for large constant pools.
1033  int Idx = V->getExistingMachineCPValue(this, Alignment);
1034  if (Idx != -1) {
1035  MachineCPVsSharingEntries.insert(V);
1036  return (unsigned)Idx;
1037  }
1038 
1039  Constants.push_back(MachineConstantPoolEntry(V, Alignment));
1040  return Constants.size()-1;
1041 }
1042 
1044  if (Constants.empty()) return;
1045 
1046  OS << "Constant Pool:\n";
1047  for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
1048  OS << " cp#" << i << ": ";
1049  if (Constants[i].isMachineConstantPoolEntry())
1050  Constants[i].Val.MachineCPVal->print(OS);
1051  else
1052  Constants[i].Val.ConstVal->printAsOperand(OS, /*PrintType=*/false);
1053  OS << ", align=" << Constants[i].getAlignment();
1054  OS << "\n";
1055  }
1056 }
1057 
1058 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1060 #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.
void push_back(const T &Elt)
Definition: SmallVector.h:218
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
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:341
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.
const TargetRegisterClass * getRegClass(unsigned Reg) const
Return the register class of the specified virtual register.
unsigned getFunctionNumber() const
getFunctionNumber - Return a unique ID for the current function.
livein_iterator livein_begin() const
static SectionKind getMergeableConst32()
Definition: SectionKind.h:195
iterator erase(iterator where)
Definition: ilist.h:267
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
MachineFunctionProperties & reset(Property P)
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:294
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:42
iterator begin() const
Definition: ArrayRef.h:137
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:250
unsigned size() const
AtomicOrdering getFailureOrdering() const
For cmpxchg atomic operations, return the atomic ordering requirements when store does not occur...
unsigned addLiveIn(unsigned PReg, const TargetRegisterClass *RC)
addLiveIn - Add the specified physical register as a live-in value and create a corresponding virtual...
Describe properties that are true of each instruction in the target description file.
Definition: MCInstrDesc.h:163
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
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:193
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:714
static SectionKind getMergeableConst16()
Definition: SectionKind.h:194
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:321
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:510
unsigned const TargetRegisterInfo * TRI
A debug info location.
Definition: DebugLoc.h:34
Metadata node.
Definition: Metadata.h:864
F(f)
MachineModuleInfo & getMMI() const
Manage lifetime of a slot tracker for printing IR.
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:611
StringRef getLinkerPrivateGlobalPrefix() const
Definition: DataLayout.h:274
static SectionKind getMergeableConst4()
Definition: SectionKind.h:192
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...
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:367
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:836
virtual void MF_HandleInsertion(const MachineInstr &MI)=0
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.
amdgpu Simplify well known AMD library false Value Value const Twine & Name
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:364
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
SmallVector< MCSymbol *, 1 > EndLabels
Printable printMBBReference(const MachineBasicBlock &MBB)
Prints a machine basic block reference.
Printable printReg(unsigned Reg, const TargetRegisterInfo *TRI=nullptr, unsigned SubIdx=0, const MachineRegisterInfo *MRI=nullptr)
Prints virtual and physical registers with or without a TRI instance.
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:56
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.
#define LLVM_DUMP_METHOD
Definition: Compiler.h:74
void Deallocate(const void *Ptr, size_t Size)
Definition: Allocator.h:278
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:63
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.
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:331
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:33
EK_BlockAddress - Each entry is a plain address of block, e.g.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
unsigned getPrefFunctionAlignment() const
Return the preferred function alignment.
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:702
This class is a data container for one entry in a MachineConstantPool.
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.
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.
const Value * getValue() const
Return the base address of the memory access.
MCContext & getContext() const
#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:419
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:190
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:58
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:46
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)
static cl::opt< unsigned > AlignAllFunctions("align-all-functions", cl::desc("Force the alignment of all functions."), cl::init(0), cl::Hidden)
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
void addPersonality(const Function *Personality)
Provide the personality function for the exception information.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:42
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:629
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:215
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:23
self_iterator getIterator()
Definition: ilist_node.h:82
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:842
void DeleteMachineInstr(MachineInstr *MI)
DeleteMachineInstr - Delete the given MachineInstr.
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:539
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.
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:240
Iterator for intrusive lists based on ilist_node.
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:847
Module.h This file contains the declarations for the Module class.
iterator end() const
Definition: ArrayRef.h:138
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:644
static SectionKind getReadOnlyWithRel()
Definition: SectionKind.h:203
unsigned getABIIntegerTypeAlignment(unsigned BitWidth) const
Returns the minimum ABI-required alignment for an integer type of the specified bitwidth.
Definition: DataLayout.cpp:728
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.
static void deleteNode(NodeTy *V)
Definition: ilist.h:42
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:133
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:248
Target - Wrapper for Target specific information.
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.
virtual void MF_HandleRemoval(const MachineInstr &MI)=0
iterator begin() const
Definition: StringRef.h:106
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:428
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.
void ensureMaxAlignment(unsigned Align)
Make sure the function is at least Align bytes aligned.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:123
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:224
#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
SectionKind getSectionKind(const DataLayout *DL) const
const BasicBlock * getBasicBlock() const
Return the LLVM basic block that this instance corresponded to originally.
uint32_t Size
Definition: Profile.cpp:47
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:92
void viewCFGOnly() const
viewCFGOnly - This function is meant for use from the debugger.
void dump() const
dump - Call print(cerr) to be called from the debugger.
bool isStackRealignable() const
isStackRealignable - This method returns whether the stack can be realigned.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
unsigned getMinFunctionAlignment() const
Return the minimum function alignment.
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:483
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:566
LLVM Value Representation.
Definition: Value.h:73
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1302
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:411
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:81
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:46
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:49
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:38
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:1100
iterator end() const
Definition: StringRef.h:108
VariableDbgInfoMapTy VariableDbgInfos
static SectionKind getReadOnly()
Definition: SectionKind.h:182
unsigned getConstantPoolIndex(const Constant *C, unsigned Alignment)
getConstantPoolIndex - Create a new entry in the constant pool or return an existing one...
unsigned createVirtualRegister(const TargetRegisterClass *RegClass, StringRef Name="")
createVirtualRegister - Create and return a new virtual register in the function with the specified r...
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.