LLVM  6.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/STLExtras.h"
18 #include "llvm/ADT/SmallString.h"
28 #include "llvm/CodeGen/Passes.h"
31 #include "llvm/IR/DataLayout.h"
32 #include "llvm/IR/DebugInfo.h"
33 #include "llvm/IR/Function.h"
34 #include "llvm/IR/Module.h"
36 #include "llvm/MC/MCAsmInfo.h"
37 #include "llvm/MC/MCContext.h"
38 #include "llvm/Support/Debug.h"
45 using namespace llvm;
46 
47 #define DEBUG_TYPE "codegen"
48 
49 static cl::opt<unsigned>
50  AlignAllFunctions("align-all-functions",
51  cl::desc("Force the alignment of all functions."),
52  cl::init(0), cl::Hidden);
53 
56  switch(Prop) {
57  case P::FailedISel: return "FailedISel";
58  case P::IsSSA: return "IsSSA";
59  case P::Legalized: return "Legalized";
60  case P::NoPHIs: return "NoPHIs";
61  case P::NoVRegs: return "NoVRegs";
62  case P::RegBankSelected: return "RegBankSelected";
63  case P::Selected: return "Selected";
64  case P::TracksLiveness: return "TracksLiveness";
65  }
66  llvm_unreachable("Invalid machine function property");
67 }
68 
70  const char *Separator = "";
71  for (BitVector::size_type I = 0; I < Properties.size(); ++I) {
72  if (!Properties[I])
73  continue;
74  OS << Separator << getPropertyName(static_cast<Property>(I));
75  Separator = ", ";
76  }
77 }
78 
79 //===----------------------------------------------------------------------===//
80 // MachineFunction implementation
81 //===----------------------------------------------------------------------===//
82 
83 // Out-of-line virtual method.
85 
88 }
89 
90 static inline unsigned getFnStackAlignment(const TargetSubtargetInfo *STI,
91  const Function *Fn) {
92  if (Fn->hasFnAttribute(Attribute::StackAlignment))
93  return Fn->getFnStackAlignment();
94  return STI->getFrameLowering()->getStackAlignment();
95 }
96 
98  unsigned FunctionNum, MachineModuleInfo &mmi)
99  : Fn(F), Target(TM), STI(TM.getSubtargetImpl(*F)), Ctx(mmi.getContext()),
100  MMI(mmi) {
101  FunctionNumber = FunctionNum;
102  init();
103 }
104 
105 void MachineFunction::init() {
106  // Assume the function starts in SSA form with correct liveness.
109  if (STI->getRegisterInfo())
110  RegInfo = new (Allocator) MachineRegisterInfo(this);
111  else
112  RegInfo = nullptr;
113 
114  MFInfo = nullptr;
115  // We can realign the stack if the target supports it and the user hasn't
116  // explicitly asked us not to.
117  bool CanRealignSP = STI->getFrameLowering()->isStackRealignable() &&
118  !Fn->hasFnAttribute("no-realign-stack");
119  FrameInfo = new (Allocator) MachineFrameInfo(
120  getFnStackAlignment(STI, Fn), /*StackRealignable=*/CanRealignSP,
121  /*ForceRealign=*/CanRealignSP &&
122  Fn->hasFnAttribute(Attribute::StackAlignment));
123 
124  if (Fn->hasFnAttribute(Attribute::StackAlignment))
125  FrameInfo->ensureMaxAlignment(Fn->getFnStackAlignment());
126 
127  ConstantPool = new (Allocator) MachineConstantPool(getDataLayout());
128  Alignment = STI->getTargetLowering()->getMinFunctionAlignment();
129 
130  // FIXME: Shouldn't use pref alignment if explicit alignment is set on Fn.
131  // FIXME: Use Function::optForSize().
132  if (!Fn->hasFnAttribute(Attribute::OptimizeForSize))
133  Alignment = std::max(Alignment,
135 
136  if (AlignAllFunctions)
137  Alignment = AlignAllFunctions;
138 
139  JumpTableInfo = nullptr;
140 
142  Fn->hasPersonalityFn() ? Fn->getPersonalityFn() : nullptr))) {
143  WinEHInfo = new (Allocator) WinEHFuncInfo();
144  }
145 
146  assert(Target.isCompatibleDataLayout(getDataLayout()) &&
147  "Can't create a MachineFunction using a Module with a "
148  "Target-incompatible DataLayout attached\n");
149 
150  PSVManager = llvm::make_unique<PseudoSourceValueManager>();
151 }
152 
154  clear();
155 }
156 
157 void MachineFunction::clear() {
158  Properties.reset();
159  // Don't call destructors on MachineInstr and MachineOperand. All of their
160  // memory comes from the BumpPtrAllocator which is about to be purged.
161  //
162  // Do call MachineBasicBlock destructors, it contains std::vectors.
163  for (iterator I = begin(), E = end(); I != E; I = BasicBlocks.erase(I))
164  I->Insts.clearAndLeakNodesUnsafely();
165 
166  InstructionRecycler.clear(Allocator);
167  OperandRecycler.clear(Allocator);
168  BasicBlockRecycler.clear(Allocator);
170  if (RegInfo) {
171  RegInfo->~MachineRegisterInfo();
172  Allocator.Deallocate(RegInfo);
173  }
174  if (MFInfo) {
175  MFInfo->~MachineFunctionInfo();
176  Allocator.Deallocate(MFInfo);
177  }
178 
179  FrameInfo->~MachineFrameInfo();
180  Allocator.Deallocate(FrameInfo);
181 
182  ConstantPool->~MachineConstantPool();
183  Allocator.Deallocate(ConstantPool);
184 
185  if (JumpTableInfo) {
186  JumpTableInfo->~MachineJumpTableInfo();
187  Allocator.Deallocate(JumpTableInfo);
188  }
189 
190  if (WinEHInfo) {
191  WinEHInfo->~WinEHFuncInfo();
192  Allocator.Deallocate(WinEHInfo);
193  }
194 }
195 
197  return Fn->getParent()->getDataLayout();
198 }
199 
200 /// Get the JumpTableInfo for this function.
201 /// If it does not already exist, allocate one.
203 getOrCreateJumpTableInfo(unsigned EntryKind) {
204  if (JumpTableInfo) return JumpTableInfo;
205 
206  JumpTableInfo = new (Allocator)
208  return JumpTableInfo;
209 }
210 
211 /// Should we be emitting segmented stack stuff for the function
213  return getFunction()->hasFnAttribute("split-stack");
214 }
215 
216 /// This discards all of the MachineBasicBlock numbers and recomputes them.
217 /// This guarantees that the MBB numbers are sequential, dense, and match the
218 /// ordering of the blocks within the function. If a specific MachineBasicBlock
219 /// is specified, only that block and those after it are renumbered.
221  if (empty()) { MBBNumbering.clear(); return; }
222  MachineFunction::iterator MBBI, E = end();
223  if (MBB == nullptr)
224  MBBI = begin();
225  else
226  MBBI = MBB->getIterator();
227 
228  // Figure out the block number this should have.
229  unsigned BlockNo = 0;
230  if (MBBI != begin())
231  BlockNo = std::prev(MBBI)->getNumber() + 1;
232 
233  for (; MBBI != E; ++MBBI, ++BlockNo) {
234  if (MBBI->getNumber() != (int)BlockNo) {
235  // Remove use of the old number.
236  if (MBBI->getNumber() != -1) {
237  assert(MBBNumbering[MBBI->getNumber()] == &*MBBI &&
238  "MBB number mismatch!");
239  MBBNumbering[MBBI->getNumber()] = nullptr;
240  }
241 
242  // If BlockNo is already taken, set that block's number to -1.
243  if (MBBNumbering[BlockNo])
244  MBBNumbering[BlockNo]->setNumber(-1);
245 
246  MBBNumbering[BlockNo] = &*MBBI;
247  MBBI->setNumber(BlockNo);
248  }
249  }
250 
251  // Okay, all the blocks are renumbered. If we have compactified the block
252  // numbering, shrink MBBNumbering now.
253  assert(BlockNo <= MBBNumbering.size() && "Mismatch!");
254  MBBNumbering.resize(BlockNo);
255 }
256 
257 /// Allocate a new MachineInstr. Use this instead of `new MachineInstr'.
259  const DebugLoc &DL,
260  bool NoImp) {
261  return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
262  MachineInstr(*this, MCID, DL, NoImp);
263 }
264 
265 /// Create a new MachineInstr which is a copy of the 'Orig' instruction,
266 /// identical in all ways except the instruction has no parent, prev, or next.
267 MachineInstr *
269  return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
270  MachineInstr(*this, *Orig);
271 }
272 
273 /// Delete the given MachineInstr.
274 ///
275 /// This function also serves as the MachineInstr destructor - the real
276 /// ~MachineInstr() destructor must be empty.
277 void
279  // Strip it for parts. The operand array and the MI object itself are
280  // independently recyclable.
281  if (MI->Operands)
282  deallocateOperandArray(MI->CapOperands, MI->Operands);
283  // Don't call ~MachineInstr() which must be trivial anyway because
284  // ~MachineFunction drops whole lists of MachineInstrs wihout calling their
285  // destructors.
286  InstructionRecycler.Deallocate(Allocator, MI);
287 }
288 
289 /// Allocate a new MachineBasicBlock. Use this instead of
290 /// `new MachineBasicBlock'.
293  return new (BasicBlockRecycler.Allocate<MachineBasicBlock>(Allocator))
294  MachineBasicBlock(*this, bb);
295 }
296 
297 /// Delete the given MachineBasicBlock.
298 void
300  assert(MBB->getParent() == this && "MBB parent mismatch!");
301  MBB->~MachineBasicBlock();
302  BasicBlockRecycler.Deallocate(Allocator, MBB);
303 }
304 
306  MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s,
307  unsigned base_alignment, const AAMDNodes &AAInfo, const MDNode *Ranges,
308  SyncScope::ID SSID, AtomicOrdering Ordering,
309  AtomicOrdering FailureOrdering) {
310  return new (Allocator)
311  MachineMemOperand(PtrInfo, f, s, base_alignment, AAInfo, Ranges,
312  SSID, Ordering, FailureOrdering);
313 }
314 
317  int64_t Offset, uint64_t Size) {
318  if (MMO->getValue())
319  return new (Allocator)
321  MMO->getOffset()+Offset),
322  MMO->getFlags(), Size, MMO->getBaseAlignment(),
323  AAMDNodes(), nullptr, MMO->getSyncScopeID(),
324  MMO->getOrdering(), MMO->getFailureOrdering());
325  return new (Allocator)
327  MMO->getOffset()+Offset),
328  MMO->getFlags(), Size, MMO->getBaseAlignment(),
329  AAMDNodes(), nullptr, MMO->getSyncScopeID(),
330  MMO->getOrdering(), MMO->getFailureOrdering());
331 }
332 
335  return Allocator.Allocate<MachineMemOperand *>(Num);
336 }
337 
338 std::pair<MachineInstr::mmo_iterator, MachineInstr::mmo_iterator>
341  // Count the number of load mem refs.
342  unsigned Num = 0;
343  for (MachineInstr::mmo_iterator I = Begin; I != End; ++I)
344  if ((*I)->isLoad())
345  ++Num;
346 
347  // Allocate a new array and populate it with the load information.
349  unsigned Index = 0;
350  for (MachineInstr::mmo_iterator I = Begin; I != End; ++I) {
351  if ((*I)->isLoad()) {
352  if (!(*I)->isStore())
353  // Reuse the MMO.
354  Result[Index] = *I;
355  else {
356  // Clone the MMO and unset the store flag.
357  MachineMemOperand *JustLoad =
358  getMachineMemOperand((*I)->getPointerInfo(),
359  (*I)->getFlags() & ~MachineMemOperand::MOStore,
360  (*I)->getSize(), (*I)->getBaseAlignment(),
361  (*I)->getAAInfo(), nullptr,
362  (*I)->getSyncScopeID(), (*I)->getOrdering(),
363  (*I)->getFailureOrdering());
364  Result[Index] = JustLoad;
365  }
366  ++Index;
367  }
368  }
369  return std::make_pair(Result, Result + Num);
370 }
371 
372 std::pair<MachineInstr::mmo_iterator, MachineInstr::mmo_iterator>
375  // Count the number of load mem refs.
376  unsigned Num = 0;
377  for (MachineInstr::mmo_iterator I = Begin; I != End; ++I)
378  if ((*I)->isStore())
379  ++Num;
380 
381  // Allocate a new array and populate it with the store information.
383  unsigned Index = 0;
384  for (MachineInstr::mmo_iterator I = Begin; I != End; ++I) {
385  if ((*I)->isStore()) {
386  if (!(*I)->isLoad())
387  // Reuse the MMO.
388  Result[Index] = *I;
389  else {
390  // Clone the MMO and unset the load flag.
391  MachineMemOperand *JustStore =
392  getMachineMemOperand((*I)->getPointerInfo(),
393  (*I)->getFlags() & ~MachineMemOperand::MOLoad,
394  (*I)->getSize(), (*I)->getBaseAlignment(),
395  (*I)->getAAInfo(), nullptr,
396  (*I)->getSyncScopeID(), (*I)->getOrdering(),
397  (*I)->getFailureOrdering());
398  Result[Index] = JustStore;
399  }
400  ++Index;
401  }
402  }
403  return std::make_pair(Result, Result + Num);
404 }
405 
407  char *Dest = Allocator.Allocate<char>(Name.size() + 1);
408  std::copy(Name.begin(), Name.end(), Dest);
409  Dest[Name.size()] = 0;
410  return Dest;
411 }
412 
413 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
415  print(dbgs());
416 }
417 #endif
418 
420  assert(getFunction() && "No function!");
421  return getFunction()->getName();
422 }
423 
424 void MachineFunction::print(raw_ostream &OS, const SlotIndexes *Indexes) const {
425  OS << "# Machine code for function " << getName() << ": ";
426  getProperties().print(OS);
427  OS << '\n';
428 
429  // Print Frame Information
430  FrameInfo->print(*this, OS);
431 
432  // Print JumpTable Information
433  if (JumpTableInfo)
434  JumpTableInfo->print(OS);
435 
436  // Print Constant Pool
437  ConstantPool->print(OS);
438 
440 
441  if (RegInfo && !RegInfo->livein_empty()) {
442  OS << "Function Live Ins: ";
444  I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) {
445  OS << PrintReg(I->first, TRI);
446  if (I->second)
447  OS << " in " << PrintReg(I->second, TRI);
448  if (std::next(I) != E)
449  OS << ", ";
450  }
451  OS << '\n';
452  }
453 
456  for (const auto &BB : *this) {
457  OS << '\n';
458  BB.print(OS, MST, Indexes);
459  }
460 
461  OS << "\n# End machine code for function " << getName() << ".\n\n";
462 }
463 
464 namespace llvm {
465  template<>
467 
469 
470  static std::string getGraphName(const MachineFunction *F) {
471  return ("CFG for '" + F->getName() + "' function").str();
472  }
473 
474  std::string getNodeLabel(const MachineBasicBlock *Node,
475  const MachineFunction *Graph) {
476  std::string OutStr;
477  {
478  raw_string_ostream OSS(OutStr);
479 
480  if (isSimple()) {
481  OSS << "BB#" << Node->getNumber();
482  if (const BasicBlock *BB = Node->getBasicBlock())
483  OSS << ": " << BB->getName();
484  } else
485  Node->print(OSS);
486  }
487 
488  if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());
489 
490  // Process string output to make it nicer...
491  for (unsigned i = 0; i != OutStr.length(); ++i)
492  if (OutStr[i] == '\n') { // Left justify
493  OutStr[i] = '\\';
494  OutStr.insert(OutStr.begin()+i+1, 'l');
495  }
496  return OutStr;
497  }
498  };
499 }
500 
502 {
503 #ifndef NDEBUG
504  ViewGraph(this, "mf" + getName());
505 #else
506  errs() << "MachineFunction::viewCFG is only available in debug builds on "
507  << "systems with Graphviz or gv!\n";
508 #endif // NDEBUG
509 }
510 
512 {
513 #ifndef NDEBUG
514  ViewGraph(this, "mf" + getName(), true);
515 #else
516  errs() << "MachineFunction::viewCFGOnly is only available in debug builds on "
517  << "systems with Graphviz or gv!\n";
518 #endif // NDEBUG
519 }
520 
521 /// Add the specified physical register as a live-in value and
522 /// create a corresponding virtual register for it.
523 unsigned MachineFunction::addLiveIn(unsigned PReg,
524  const TargetRegisterClass *RC) {
526  unsigned VReg = MRI.getLiveInVirtReg(PReg);
527  if (VReg) {
528  const TargetRegisterClass *VRegRC = MRI.getRegClass(VReg);
529  (void)VRegRC;
530  // A physical register can be added several times.
531  // Between two calls, the register class of the related virtual register
532  // may have been constrained to match some operation constraints.
533  // In that case, check that the current register class includes the
534  // physical register and is a sub class of the specified RC.
535  assert((VRegRC == RC || (VRegRC->contains(PReg) &&
536  RC->hasSubClassEq(VRegRC))) &&
537  "Register class mismatch!");
538  return VReg;
539  }
540  VReg = MRI.createVirtualRegister(RC);
541  MRI.addLiveIn(PReg, VReg);
542  return VReg;
543 }
544 
545 /// Return the MCSymbol for the specified non-empty jump table.
546 /// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
547 /// normal 'L' label is returned.
549  bool isLinkerPrivate) const {
550  const DataLayout &DL = getDataLayout();
551  assert(JumpTableInfo && "No jump tables");
552  assert(JTI < JumpTableInfo->getJumpTables().size() && "Invalid JTI!");
553 
554  StringRef Prefix = isLinkerPrivate ? DL.getLinkerPrivateGlobalPrefix()
555  : DL.getPrivateGlobalPrefix();
557  raw_svector_ostream(Name)
558  << Prefix << "JTI" << getFunctionNumber() << '_' << JTI;
559  return Ctx.getOrCreateSymbol(Name);
560 }
561 
562 /// Return a function-local symbol to represent the PIC base.
564  const DataLayout &DL = getDataLayout();
565  return Ctx.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) +
566  Twine(getFunctionNumber()) + "$pb");
567 }
568 
569 /// \name Exception Handling
570 /// \{
571 
574  unsigned N = LandingPads.size();
575  for (unsigned i = 0; i < N; ++i) {
576  LandingPadInfo &LP = LandingPads[i];
577  if (LP.LandingPadBlock == LandingPad)
578  return LP;
579  }
580 
581  LandingPads.push_back(LandingPadInfo(LandingPad));
582  return LandingPads[N];
583 }
584 
586  MCSymbol *BeginLabel, MCSymbol *EndLabel) {
587  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
588  LP.BeginLabels.push_back(BeginLabel);
589  LP.EndLabels.push_back(EndLabel);
590 }
591 
593  MCSymbol *LandingPadLabel = Ctx.createTempSymbol();
594  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
595  LP.LandingPadLabel = LandingPadLabel;
596  return LandingPadLabel;
597 }
598 
601  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
602  for (unsigned N = TyInfo.size(); N; --N)
603  LP.TypeIds.push_back(getTypeIDFor(TyInfo[N - 1]));
604 }
605 
608  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
609  std::vector<unsigned> IdsInFilter(TyInfo.size());
610  for (unsigned I = 0, E = TyInfo.size(); I != E; ++I)
611  IdsInFilter[I] = getTypeIDFor(TyInfo[I]);
612  LP.TypeIds.push_back(getFilterIDFor(IdsInFilter));
613 }
614 
616  for (unsigned i = 0; i != LandingPads.size(); ) {
617  LandingPadInfo &LandingPad = LandingPads[i];
618  if (LandingPad.LandingPadLabel &&
619  !LandingPad.LandingPadLabel->isDefined() &&
620  (!LPMap || (*LPMap)[LandingPad.LandingPadLabel] == 0))
621  LandingPad.LandingPadLabel = nullptr;
622 
623  // Special case: we *should* emit LPs with null LP MBB. This indicates
624  // "nounwind" case.
625  if (!LandingPad.LandingPadLabel && LandingPad.LandingPadBlock) {
626  LandingPads.erase(LandingPads.begin() + i);
627  continue;
628  }
629 
630  for (unsigned j = 0, e = LandingPads[i].BeginLabels.size(); j != e; ++j) {
631  MCSymbol *BeginLabel = LandingPad.BeginLabels[j];
632  MCSymbol *EndLabel = LandingPad.EndLabels[j];
633  if ((BeginLabel->isDefined() ||
634  (LPMap && (*LPMap)[BeginLabel] != 0)) &&
635  (EndLabel->isDefined() ||
636  (LPMap && (*LPMap)[EndLabel] != 0))) continue;
637 
638  LandingPad.BeginLabels.erase(LandingPad.BeginLabels.begin() + j);
639  LandingPad.EndLabels.erase(LandingPad.EndLabels.begin() + j);
640  --j;
641  --e;
642  }
643 
644  // Remove landing pads with no try-ranges.
645  if (LandingPads[i].BeginLabels.empty()) {
646  LandingPads.erase(LandingPads.begin() + i);
647  continue;
648  }
649 
650  // If there is no landing pad, ensure that the list of typeids is empty.
651  // If the only typeid is a cleanup, this is the same as having no typeids.
652  if (!LandingPad.LandingPadBlock ||
653  (LandingPad.TypeIds.size() == 1 && !LandingPad.TypeIds[0]))
654  LandingPad.TypeIds.clear();
655  ++i;
656  }
657 }
658 
660  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
661  LP.TypeIds.push_back(0);
662 }
663 
665  const Function *Filter,
666  const BlockAddress *RecoverBA) {
667  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
668  SEHHandler Handler;
669  Handler.FilterOrFinally = Filter;
670  Handler.RecoverBA = RecoverBA;
671  LP.SEHHandlers.push_back(Handler);
672 }
673 
675  const Function *Cleanup) {
676  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
677  SEHHandler Handler;
678  Handler.FilterOrFinally = Cleanup;
679  Handler.RecoverBA = nullptr;
680  LP.SEHHandlers.push_back(Handler);
681 }
682 
684  ArrayRef<unsigned> Sites) {
685  LPadToCallSiteMap[Sym].append(Sites.begin(), Sites.end());
686 }
687 
689  for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i)
690  if (TypeInfos[i] == TI) return i + 1;
691 
692  TypeInfos.push_back(TI);
693  return TypeInfos.size();
694 }
695 
696 int MachineFunction::getFilterIDFor(std::vector<unsigned> &TyIds) {
697  // If the new filter coincides with the tail of an existing filter, then
698  // re-use the existing filter. Folding filters more than this requires
699  // re-ordering filters and/or their elements - probably not worth it.
700  for (std::vector<unsigned>::iterator I = FilterEnds.begin(),
701  E = FilterEnds.end(); I != E; ++I) {
702  unsigned i = *I, j = TyIds.size();
703 
704  while (i && j)
705  if (FilterIds[--i] != TyIds[--j])
706  goto try_next;
707 
708  if (!j)
709  // The new filter coincides with range [i, end) of the existing filter.
710  return -(1 + i);
711 
712 try_next:;
713  }
714 
715  // Add the new filter.
716  int FilterID = -(1 + FilterIds.size());
717  FilterIds.reserve(FilterIds.size() + TyIds.size() + 1);
718  FilterIds.insert(FilterIds.end(), TyIds.begin(), TyIds.end());
719  FilterEnds.push_back(FilterIds.size());
720  FilterIds.push_back(0); // terminator
721  return FilterID;
722 }
723 
725  MachineFunction &MF = *MBB.getParent();
726  if (const auto *PF = dyn_cast<Function>(
728  MF.getMMI().addPersonality(PF);
729 
730  if (I.isCleanup())
731  MF.addCleanup(&MBB);
732 
733  // FIXME: New EH - Add the clauses in reverse order. This isn't 100% correct,
734  // but we need to do it this way because of how the DWARF EH emitter
735  // processes the clauses.
736  for (unsigned i = I.getNumClauses(); i != 0; --i) {
737  Value *Val = I.getClause(i - 1);
738  if (I.isCatch(i - 1)) {
739  MF.addCatchTypeInfo(&MBB,
740  dyn_cast<GlobalValue>(Val->stripPointerCasts()));
741  } else {
742  // Add filters in a list.
743  Constant *CVal = cast<Constant>(Val);
745  for (User::op_iterator II = CVal->op_begin(), IE = CVal->op_end();
746  II != IE; ++II)
747  FilterList.push_back(cast<GlobalValue>((*II)->stripPointerCasts()));
748 
749  MF.addFilterTypeInfo(&MBB, FilterList);
750  }
751  }
752 }
753 
754 /// \}
755 
756 //===----------------------------------------------------------------------===//
757 // MachineJumpTableInfo implementation
758 //===----------------------------------------------------------------------===//
759 
760 /// Return the size of each entry in the jump table.
762  // The size of a jump table entry is 4 bytes unless the entry is just the
763  // address of a block, in which case it is the pointer size.
764  switch (getEntryKind()) {
766  return TD.getPointerSize();
768  return 8;
772  return 4;
774  return 0;
775  }
776  llvm_unreachable("Unknown jump table encoding!");
777 }
778 
779 /// Return the alignment of each entry in the jump table.
781  // The alignment of a jump table entry is the alignment of int32 unless the
782  // entry is just the address of a block, in which case it is the pointer
783  // alignment.
784  switch (getEntryKind()) {
786  return TD.getPointerABIAlignment();
788  return TD.getABIIntegerTypeAlignment(64);
792  return TD.getABIIntegerTypeAlignment(32);
794  return 1;
795  }
796  llvm_unreachable("Unknown jump table encoding!");
797 }
798 
799 /// Create a new jump table entry in the jump table info.
801  const std::vector<MachineBasicBlock*> &DestBBs) {
802  assert(!DestBBs.empty() && "Cannot create an empty jump table!");
803  JumpTables.push_back(MachineJumpTableEntry(DestBBs));
804  return JumpTables.size()-1;
805 }
806 
807 /// If Old is the target of any jump tables, update the jump tables to branch
808 /// to New instead.
810  MachineBasicBlock *New) {
811  assert(Old != New && "Not making a change?");
812  bool MadeChange = false;
813  for (size_t i = 0, e = JumpTables.size(); i != e; ++i)
814  ReplaceMBBInJumpTable(i, Old, New);
815  return MadeChange;
816 }
817 
818 /// If Old is a target of the jump tables, update the jump table to branch to
819 /// New instead.
821  MachineBasicBlock *Old,
822  MachineBasicBlock *New) {
823  assert(Old != New && "Not making a change?");
824  bool MadeChange = false;
825  MachineJumpTableEntry &JTE = JumpTables[Idx];
826  for (size_t j = 0, e = JTE.MBBs.size(); j != e; ++j)
827  if (JTE.MBBs[j] == Old) {
828  JTE.MBBs[j] = New;
829  MadeChange = true;
830  }
831  return MadeChange;
832 }
833 
835  if (JumpTables.empty()) return;
836 
837  OS << "Jump Tables:\n";
838 
839  for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) {
840  OS << " jt#" << i << ": ";
841  for (unsigned j = 0, f = JumpTables[i].MBBs.size(); j != f; ++j)
842  OS << " BB#" << JumpTables[i].MBBs[j]->getNumber();
843  }
844 
845  OS << '\n';
846 }
847 
848 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
850 #endif
851 
852 
853 //===----------------------------------------------------------------------===//
854 // MachineConstantPool implementation
855 //===----------------------------------------------------------------------===//
856 
857 void MachineConstantPoolValue::anchor() { }
858 
860  if (isMachineConstantPoolEntry())
861  return Val.MachineCPVal->getType();
862  return Val.ConstVal->getType();
863 }
864 
866  if (isMachineConstantPoolEntry())
867  return true;
868  return Val.ConstVal->needsRelocation();
869 }
870 
873  if (needsRelocation())
875  switch (DL->getTypeAllocSize(getType())) {
876  case 4:
878  case 8:
880  case 16:
882  case 32:
884  default:
885  return SectionKind::getReadOnly();
886  }
887 }
888 
890  // A constant may be a member of both Constants and MachineCPVsSharingEntries,
891  // so keep track of which we've deleted to avoid double deletions.
893  for (unsigned i = 0, e = Constants.size(); i != e; ++i)
894  if (Constants[i].isMachineConstantPoolEntry()) {
895  Deleted.insert(Constants[i].Val.MachineCPVal);
896  delete Constants[i].Val.MachineCPVal;
897  }
899  MachineCPVsSharingEntries.begin(), E = MachineCPVsSharingEntries.end();
900  I != E; ++I) {
901  if (Deleted.count(*I) == 0)
902  delete *I;
903  }
904 }
905 
906 /// Test whether the given two constants can be allocated the same constant pool
907 /// entry.
908 static bool CanShareConstantPoolEntry(const Constant *A, const Constant *B,
909  const DataLayout &DL) {
910  // Handle the trivial case quickly.
911  if (A == B) return true;
912 
913  // If they have the same type but weren't the same constant, quickly
914  // reject them.
915  if (A->getType() == B->getType()) return false;
916 
917  // We can't handle structs or arrays.
918  if (isa<StructType>(A->getType()) || isa<ArrayType>(A->getType()) ||
919  isa<StructType>(B->getType()) || isa<ArrayType>(B->getType()))
920  return false;
921 
922  // For now, only support constants with the same size.
923  uint64_t StoreSize = DL.getTypeStoreSize(A->getType());
924  if (StoreSize != DL.getTypeStoreSize(B->getType()) || StoreSize > 128)
925  return false;
926 
927  Type *IntTy = IntegerType::get(A->getContext(), StoreSize*8);
928 
929  // Try constant folding a bitcast of both instructions to an integer. If we
930  // get two identical ConstantInt's, then we are good to share them. We use
931  // the constant folding APIs to do this so that we get the benefit of
932  // DataLayout.
933  if (isa<PointerType>(A->getType()))
934  A = ConstantFoldCastOperand(Instruction::PtrToInt,
935  const_cast<Constant *>(A), IntTy, DL);
936  else if (A->getType() != IntTy)
937  A = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(A),
938  IntTy, DL);
939  if (isa<PointerType>(B->getType()))
940  B = ConstantFoldCastOperand(Instruction::PtrToInt,
941  const_cast<Constant *>(B), IntTy, DL);
942  else if (B->getType() != IntTy)
943  B = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(B),
944  IntTy, DL);
945 
946  return A == B;
947 }
948 
949 /// Create a new entry in the constant pool or return an existing one.
950 /// User must specify the log2 of the minimum required alignment for the object.
952  unsigned Alignment) {
953  assert(Alignment && "Alignment must be specified!");
954  if (Alignment > PoolAlignment) PoolAlignment = Alignment;
955 
956  // Check to see if we already have this constant.
957  //
958  // FIXME, this could be made much more efficient for large constant pools.
959  for (unsigned i = 0, e = Constants.size(); i != e; ++i)
960  if (!Constants[i].isMachineConstantPoolEntry() &&
961  CanShareConstantPoolEntry(Constants[i].Val.ConstVal, C, DL)) {
962  if ((unsigned)Constants[i].getAlignment() < Alignment)
963  Constants[i].Alignment = Alignment;
964  return i;
965  }
966 
967  Constants.push_back(MachineConstantPoolEntry(C, Alignment));
968  return Constants.size()-1;
969 }
970 
972  unsigned Alignment) {
973  assert(Alignment && "Alignment must be specified!");
974  if (Alignment > PoolAlignment) PoolAlignment = Alignment;
975 
976  // Check to see if we already have this constant.
977  //
978  // FIXME, this could be made much more efficient for large constant pools.
979  int Idx = V->getExistingMachineCPValue(this, Alignment);
980  if (Idx != -1) {
981  MachineCPVsSharingEntries.insert(V);
982  return (unsigned)Idx;
983  }
984 
985  Constants.push_back(MachineConstantPoolEntry(V, Alignment));
986  return Constants.size()-1;
987 }
988 
990  if (Constants.empty()) return;
991 
992  OS << "Constant Pool:\n";
993  for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
994  OS << " cp#" << i << ": ";
995  if (Constants[i].isMachineConstantPoolEntry())
996  Constants[i].Val.MachineCPVal->print(OS);
997  else
998  Constants[i].Val.ConstVal->printAsOperand(OS, /*PrintType=*/false);
999  OS << ", align=" << Constants[i].getAlignment();
1000  OS << "\n";
1001  }
1002 }
1003 
1004 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1006 #endif
Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
uint64_t CallInst * C
void push_back(const T &Elt)
Definition: SmallVector.h:212
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:109
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:270
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:280
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
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:449
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. Returns the label ID for the landing pad entry.
StringRef getPrivateGlobalPrefix() const
Definition: DataLayout.h:281
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.
unsigned createVirtualRegister(const TargetRegisterClass *RegClass)
createVirtualRegister - Create and return a new virtual register in the function with the specified r...
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:221
void addLandingPadInfo(const LandingPadInst &I, MachineBasicBlock &MBB)
Extract the exception handling information from the landingpad instruction and add them to the specif...
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
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:697
static SectionKind getMergeableConst16()
Definition: SectionKind.h:194
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:254
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:490
A debug info location.
Definition: DebugLoc.h:34
Metadata node.
Definition: Metadata.h:862
MachineModuleInfo & getMMI() const
Manage lifetime of a slot tracker for printing IR.
Constant * getClause(unsigned Idx) const
Get the value of the clause at index Idx.
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.
StringRef getLinkerPrivateGlobalPrefix() const
Definition: DataLayout.h:261
static SectionKind getMergeableConst4()
Definition: SectionKind.h:192
op_iterator op_begin()
Definition: User.h:214
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...
void print(raw_ostream &OS) const
print - Used by the MachineFunction printer to print information about jump tables.
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:813
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:361
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
SmallVector< MCSymbol *, 1 > EndLabels
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
SmallVector< SEHHandler, 1 > SEHHandlers
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
std::pair< MachineInstr::mmo_iterator, MachineInstr::mmo_iterator > extractLoadMemRefs(MachineInstr::mmo_iterator Begin, MachineInstr::mmo_iterator End)
extractLoadMemRefs - Allocate an array and populate it with just the load information from the given ...
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:272
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.
unsigned getNumClauses() const
Get the number of clauses for this landing pad.
AtomicOrdering
Atomic ordering for LLVM&#39;s memory model.
static bool isSimple(Instruction *I)
Context object for machine code objects.
Definition: MCContext.h:59
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.
#define F(x, y, z)
Definition: MD5.cpp:55
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
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:626
This class is a data container for one entry in a MachineConstantPool.
int getNumber() const
MachineBasicBlocks are uniquely numbered at the function level, unless they&#39;re not in a MachineFuncti...
Printable PrintReg(unsigned Reg, const TargetRegisterInfo *TRI=nullptr, unsigned SubRegIdx=0)
Prints virtual and physical registers with or without a TRI instance.
MachineBasicBlock * CreateMachineBasicBlock(const BasicBlock *bb=nullptr)
CreateMachineBasicBlock - Allocate a new MachineBasicBlock.
const char * Name
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.
static unsigned getFnStackAlignment(const TargetSubtargetInfo *STI, const Function *Fn)
#define P(N)
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:404
void print(raw_ostream &OS) const
print - Used by the MachineFunction printer to print information about constant pool objects...
The landingpad instruction holds all of the information necessary to generate correct exception handl...
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:59
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.
void addSEHCatchHandler(MachineBasicBlock *LandingPad, const Function *Filter, const BlockAddress *RecoverLabel)
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.
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:605
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:212
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.
#define A
Definition: LargeTest.cpp:12
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
op_iterator op_end()
Definition: User.h:216
std::vector< int > TypeIds
const PseudoSourceValue * getPseudoValue() const
static const unsigned End
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
void ViewGraph(const GraphType &G, const Twine &Name, bool ShortNames=false, const Twine &Title="", GraphProgram::Name Program=GraphProgram::DOT)
ViewGraph - Emit a dot graph, run &#39;dot&#39;, run gv on the postscript file, then cleanup.
Definition: GraphWriter.h:348
void print(raw_ostream &OS, const SlotIndexes *=nullptr) const
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:769
void DeleteMachineInstr(MachineInstr *MI)
DeleteMachineInstr - Delete the given MachineInstr.
const Constant * stripPointerCasts() const
Definition: Constant.h:153
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:527
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.
#define E
Definition: LargeTest.cpp:27
#define B
Definition: LargeTest.cpp:24
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)
CloneMachineInstr - Create a new MachineInstr which is a copy of the &#39;Orig&#39; instruction, identical in all ways except the instruction has no parent, prev, or next.
static const char * Separator
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:864
MachineFunction(const Function *Fn, const TargetMachine &TM, unsigned FunctionNum, MachineModuleInfo &MMI)
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:642
static SectionKind getReadOnlyWithRel()
Definition: SectionKind.h:203
const size_t N
unsigned getABIIntegerTypeAlignment(unsigned BitWidth) const
Returns the minimum ABI-required alignment for an integer type of the specified bitwidth.
Definition: DataLayout.cpp:688
void addCatchTypeInfo(MachineBasicBlock *LandingPad, ArrayRef< const GlobalValue *> TyInfo)
Provide the catch typeinfo for a landing pad.
void clear(AllocatorType &Allocator)
Release all the tracked allocations to the allocator.
static void deleteNode(NodeTy *V)
Definition: ilist.h:42
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
void setCallSiteLandingPad(MCSymbol *Sym, ArrayRef< unsigned > Sites)
Map the landing pad&#39;s EH symbol to the call site indexes.
Target - Wrapper for Target specific information.
unsigned getEntrySize(const DataLayout &TD) const
getEntrySize - Return the size of each entry in the jump table.
bool isCleanup() const
Return &#39;true&#39; if this landingpad instruction is a cleanup.
MachineJumpTableEntry - One jump table in the jump table info.
iterator begin() const
Definition: StringRef.h:106
MachineBasicBlock * LandingPadBlock
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
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:405
static const char * getPropertyName(MachineFunctionProperties::Property Prop)
Representation of each machine instruction.
Definition: MachineInstr.h:59
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:121
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:218
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:108
#define I(x, y, z)
Definition: MD5.cpp:58
bool isDefined(bool SetUsed=true) const
isDefined - Check if this symbol is defined (i.e., it has an address).
Definition: MCSymbol.h:249
bool isCatch(unsigned Idx) const
Return &#39;true&#39; if the clause and index Idx is a catch clause.
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.
size_type size() const
size - Returns the number of bits in this bitvector.
Definition: BitVector.h:170
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.
void dump() const
dump - Call print(cerr) to be called from the debugger.
const Function * getFunction() const
getFunction - Return the LLVM function that this machine code represents
bool isStackRealignable() const
isStackRealignable - This method returns whether the stack can be realigned.
std::pair< MachineInstr::mmo_iterator, MachineInstr::mmo_iterator > extractStoreMemRefs(MachineInstr::mmo_iterator Begin, MachineInstr::mmo_iterator End)
extractStoreMemRefs - Allocate an array and populate it with just the store information from the give...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
unsigned getMinFunctionAlignment() const
Return the minimum function alignment.
unsigned getPointerABIAlignment(unsigned AS=0) const
Layout pointer alignment FIXME: The defaults need to be removed once all of the backends/clients are ...
Definition: DataLayout.cpp:587
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:463
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:545
LLVM Value Representation.
Definition: Value.h:73
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1255
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:388
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.
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:44
DefaultDOTGraphTraits - This class provides the default implementations of all of the DOTGraphTraits ...
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:56
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...
unsigned getLiveInVirtReg(unsigned PReg) const
getLiveInVirtReg - If PReg is a live-in physical register, return the corresponding live-in physical ...
iterator end() const
Definition: StringRef.h:108
VariableDbgInfoMapTy VariableDbgInfos
static SectionKind getReadOnly()
Definition: SectionKind.h:182
MachineInstr::mmo_iterator allocateMemRefsArray(unsigned long Num)
allocateMemRefsArray - Allocate an array to hold MachineMemOperand pointers.
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.
const BasicBlock * getParent() const
Definition: Instruction.h:66
void tidyLandingPads(DenseMap< MCSymbol *, uintptr_t > *LPMap=nullptr)
Remap landing pad labels and remove any deleted landing pads.