LLVM  9.0.0svn
MachineFunction.cpp
Go to the documentation of this file.
1 //===- MachineFunction.cpp ------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Collect native machine code information for a function. This allows
10 // target-specific information about the generated code to be stored with each
11 // function.
12 //
13 //===----------------------------------------------------------------------===//
14 
16 #include "llvm/ADT/BitVector.h"
17 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/ADT/DenseSet.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/SmallString.h"
21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/ADT/StringRef.h"
23 #include "llvm/ADT/Twine.h"
41 #include "llvm/Config/llvm-config.h"
42 #include "llvm/IR/Attributes.h"
43 #include "llvm/IR/BasicBlock.h"
44 #include "llvm/IR/Constant.h"
45 #include "llvm/IR/DataLayout.h"
47 #include "llvm/IR/DerivedTypes.h"
48 #include "llvm/IR/Function.h"
49 #include "llvm/IR/GlobalValue.h"
50 #include "llvm/IR/Instruction.h"
51 #include "llvm/IR/Instructions.h"
52 #include "llvm/IR/Metadata.h"
53 #include "llvm/IR/Module.h"
55 #include "llvm/IR/Value.h"
56 #include "llvm/MC/MCContext.h"
57 #include "llvm/MC/MCSymbol.h"
58 #include "llvm/MC/SectionKind.h"
59 #include "llvm/Support/Casting.h"
61 #include "llvm/Support/Compiler.h"
63 #include "llvm/Support/Debug.h"
68 #include <algorithm>
69 #include <cassert>
70 #include <cstddef>
71 #include <cstdint>
72 #include <iterator>
73 #include <string>
74 #include <utility>
75 #include <vector>
76 
77 using namespace llvm;
78 
79 #define DEBUG_TYPE "codegen"
80 
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(MachineInstr &MI) {
143  if (TheDelegate)
144  TheDelegate->MF_HandleInsertion(MI);
145 }
146 
147 void MachineFunction::handleRemoval(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::hasOptSize().
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.
264 getOrCreateJumpTableInfo(unsigned EntryKind) {
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 LLVM_NODISCARD unsigned
279  FrameInstructions.push_back(Inst);
280  return FrameInstructions.size() - 1;
281 }
282 
283 /// This discards all of the MachineBasicBlock numbers and recomputes them.
284 /// This guarantees that the MBB numbers are sequential, dense, and match the
285 /// ordering of the blocks within the function. If a specific MachineBasicBlock
286 /// is specified, only that block and those after it are renumbered.
288  if (empty()) { MBBNumbering.clear(); return; }
289  MachineFunction::iterator MBBI, E = end();
290  if (MBB == nullptr)
291  MBBI = begin();
292  else
293  MBBI = MBB->getIterator();
294 
295  // Figure out the block number this should have.
296  unsigned BlockNo = 0;
297  if (MBBI != begin())
298  BlockNo = std::prev(MBBI)->getNumber() + 1;
299 
300  for (; MBBI != E; ++MBBI, ++BlockNo) {
301  if (MBBI->getNumber() != (int)BlockNo) {
302  // Remove use of the old number.
303  if (MBBI->getNumber() != -1) {
304  assert(MBBNumbering[MBBI->getNumber()] == &*MBBI &&
305  "MBB number mismatch!");
306  MBBNumbering[MBBI->getNumber()] = nullptr;
307  }
308 
309  // If BlockNo is already taken, set that block's number to -1.
310  if (MBBNumbering[BlockNo])
311  MBBNumbering[BlockNo]->setNumber(-1);
312 
313  MBBNumbering[BlockNo] = &*MBBI;
314  MBBI->setNumber(BlockNo);
315  }
316  }
317 
318  // Okay, all the blocks are renumbered. If we have compactified the block
319  // numbering, shrink MBBNumbering now.
320  assert(BlockNo <= MBBNumbering.size() && "Mismatch!");
321  MBBNumbering.resize(BlockNo);
322 }
323 
324 /// Allocate a new MachineInstr. Use this instead of `new MachineInstr'.
326  const DebugLoc &DL,
327  bool NoImp) {
328  return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
329  MachineInstr(*this, MCID, DL, NoImp);
330 }
331 
332 /// Create a new MachineInstr which is a copy of the 'Orig' instruction,
333 /// identical in all ways except the instruction has no parent, prev, or next.
334 MachineInstr *
336  return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
337  MachineInstr(*this, *Orig);
338 }
339 
341  MachineBasicBlock::iterator InsertBefore, const MachineInstr &Orig) {
342  MachineInstr *FirstClone = nullptr;
344  while (true) {
345  MachineInstr *Cloned = CloneMachineInstr(&*I);
346  MBB.insert(InsertBefore, Cloned);
347  if (FirstClone == nullptr) {
348  FirstClone = Cloned;
349  } else {
350  Cloned->bundleWithPred();
351  }
352 
353  if (!I->isBundledWithSucc())
354  break;
355  ++I;
356  }
357  return *FirstClone;
358 }
359 
360 /// Delete the given MachineInstr.
361 ///
362 /// This function also serves as the MachineInstr destructor - the real
363 /// ~MachineInstr() destructor must be empty.
364 void
366  // Strip it for parts. The operand array and the MI object itself are
367  // independently recyclable.
368  if (MI->Operands)
369  deallocateOperandArray(MI->CapOperands, MI->Operands);
370  // Don't call ~MachineInstr() which must be trivial anyway because
371  // ~MachineFunction drops whole lists of MachineInstrs wihout calling their
372  // destructors.
373  InstructionRecycler.Deallocate(Allocator, MI);
374 }
375 
376 /// Allocate a new MachineBasicBlock. Use this instead of
377 /// `new MachineBasicBlock'.
380  return new (BasicBlockRecycler.Allocate<MachineBasicBlock>(Allocator))
381  MachineBasicBlock(*this, bb);
382 }
383 
384 /// Delete the given MachineBasicBlock.
385 void
387  assert(MBB->getParent() == this && "MBB parent mismatch!");
388  MBB->~MachineBasicBlock();
389  BasicBlockRecycler.Deallocate(Allocator, MBB);
390 }
391 
393  MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s,
394  unsigned base_alignment, const AAMDNodes &AAInfo, const MDNode *Ranges,
395  SyncScope::ID SSID, AtomicOrdering Ordering,
396  AtomicOrdering FailureOrdering) {
397  return new (Allocator)
398  MachineMemOperand(PtrInfo, f, s, base_alignment, AAInfo, Ranges,
399  SSID, Ordering, FailureOrdering);
400 }
401 
404  int64_t Offset, uint64_t Size) {
405  const MachinePointerInfo &PtrInfo = MMO->getPointerInfo();
406 
407  // If there is no pointer value, the offset isn't tracked so we need to adjust
408  // the base alignment.
409  unsigned Align = PtrInfo.V.isNull()
410  ? MinAlign(MMO->getBaseAlignment(), Offset)
411  : MMO->getBaseAlignment();
412 
413  return new (Allocator)
414  MachineMemOperand(PtrInfo.getWithOffset(Offset), MMO->getFlags(), Size,
415  Align, AAMDNodes(), nullptr, MMO->getSyncScopeID(),
416  MMO->getOrdering(), MMO->getFailureOrdering());
417 }
418 
421  const AAMDNodes &AAInfo) {
422  MachinePointerInfo MPI = MMO->getValue() ?
423  MachinePointerInfo(MMO->getValue(), MMO->getOffset()) :
425 
426  return new (Allocator)
427  MachineMemOperand(MPI, MMO->getFlags(), MMO->getSize(),
428  MMO->getBaseAlignment(), AAInfo,
429  MMO->getRanges(), MMO->getSyncScopeID(),
430  MMO->getOrdering(), MMO->getFailureOrdering());
431 }
432 
433 MachineInstr::ExtraInfo *
435  MCSymbol *PreInstrSymbol,
436  MCSymbol *PostInstrSymbol) {
437  return MachineInstr::ExtraInfo::create(Allocator, MMOs, PreInstrSymbol,
438  PostInstrSymbol);
439 }
440 
442  char *Dest = Allocator.Allocate<char>(Name.size() + 1);
443  llvm::copy(Name, Dest);
444  Dest[Name.size()] = 0;
445  return Dest;
446 }
447 
449  unsigned NumRegs = getSubtarget().getRegisterInfo()->getNumRegs();
450  unsigned Size = MachineOperand::getRegMaskSize(NumRegs);
451  uint32_t *Mask = Allocator.Allocate<uint32_t>(Size);
452  memset(Mask, 0, Size * sizeof(Mask[0]));
453  return Mask;
454 }
455 
456 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
458  print(dbgs());
459 }
460 #endif
461 
463  return getFunction().getName();
464 }
465 
466 void MachineFunction::print(raw_ostream &OS, const SlotIndexes *Indexes) const {
467  OS << "# Machine code for function " << getName() << ": ";
468  getProperties().print(OS);
469  OS << '\n';
470 
471  // Print Frame Information
472  FrameInfo->print(*this, OS);
473 
474  // Print JumpTable Information
475  if (JumpTableInfo)
476  JumpTableInfo->print(OS);
477 
478  // Print Constant Pool
479  ConstantPool->print(OS);
480 
482 
483  if (RegInfo && !RegInfo->livein_empty()) {
484  OS << "Function Live Ins: ";
486  I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) {
487  OS << printReg(I->first, TRI);
488  if (I->second)
489  OS << " in " << printReg(I->second, TRI);
490  if (std::next(I) != E)
491  OS << ", ";
492  }
493  OS << '\n';
494  }
495 
498  for (const auto &BB : *this) {
499  OS << '\n';
500  // If we print the whole function, print it at its most verbose level.
501  BB.print(OS, MST, Indexes, /*IsStandalone=*/true);
502  }
503 
504  OS << "\n# End machine code for function " << getName() << ".\n\n";
505 }
506 
507 namespace llvm {
508 
509  template<>
512 
513  static std::string getGraphName(const MachineFunction *F) {
514  return ("CFG for '" + F->getName() + "' function").str();
515  }
516 
517  std::string getNodeLabel(const MachineBasicBlock *Node,
518  const MachineFunction *Graph) {
519  std::string OutStr;
520  {
521  raw_string_ostream OSS(OutStr);
522 
523  if (isSimple()) {
524  OSS << printMBBReference(*Node);
525  if (const BasicBlock *BB = Node->getBasicBlock())
526  OSS << ": " << BB->getName();
527  } else
528  Node->print(OSS);
529  }
530 
531  if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());
532 
533  // Process string output to make it nicer...
534  for (unsigned i = 0; i != OutStr.length(); ++i)
535  if (OutStr[i] == '\n') { // Left justify
536  OutStr[i] = '\\';
537  OutStr.insert(OutStr.begin()+i+1, 'l');
538  }
539  return OutStr;
540  }
541  };
542 
543 } // end namespace llvm
544 
546 {
547 #ifndef NDEBUG
548  ViewGraph(this, "mf" + getName());
549 #else
550  errs() << "MachineFunction::viewCFG is only available in debug builds on "
551  << "systems with Graphviz or gv!\n";
552 #endif // NDEBUG
553 }
554 
556 {
557 #ifndef NDEBUG
558  ViewGraph(this, "mf" + getName(), true);
559 #else
560  errs() << "MachineFunction::viewCFGOnly is only available in debug builds on "
561  << "systems with Graphviz or gv!\n";
562 #endif // NDEBUG
563 }
564 
565 /// Add the specified physical register as a live-in value and
566 /// create a corresponding virtual register for it.
567 unsigned MachineFunction::addLiveIn(unsigned PReg,
568  const TargetRegisterClass *RC) {
570  unsigned VReg = MRI.getLiveInVirtReg(PReg);
571  if (VReg) {
572  const TargetRegisterClass *VRegRC = MRI.getRegClass(VReg);
573  (void)VRegRC;
574  // A physical register can be added several times.
575  // Between two calls, the register class of the related virtual register
576  // may have been constrained to match some operation constraints.
577  // In that case, check that the current register class includes the
578  // physical register and is a sub class of the specified RC.
579  assert((VRegRC == RC || (VRegRC->contains(PReg) &&
580  RC->hasSubClassEq(VRegRC))) &&
581  "Register class mismatch!");
582  return VReg;
583  }
584  VReg = MRI.createVirtualRegister(RC);
585  MRI.addLiveIn(PReg, VReg);
586  return VReg;
587 }
588 
589 /// Return the MCSymbol for the specified non-empty jump table.
590 /// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
591 /// normal 'L' label is returned.
593  bool isLinkerPrivate) const {
594  const DataLayout &DL = getDataLayout();
595  assert(JumpTableInfo && "No jump tables");
596  assert(JTI < JumpTableInfo->getJumpTables().size() && "Invalid JTI!");
597 
598  StringRef Prefix = isLinkerPrivate ? DL.getLinkerPrivateGlobalPrefix()
599  : DL.getPrivateGlobalPrefix();
601  raw_svector_ostream(Name)
602  << Prefix << "JTI" << getFunctionNumber() << '_' << JTI;
603  return Ctx.getOrCreateSymbol(Name);
604 }
605 
606 /// Return a function-local symbol to represent the PIC base.
608  const DataLayout &DL = getDataLayout();
609  return Ctx.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) +
610  Twine(getFunctionNumber()) + "$pb");
611 }
612 
613 /// \name Exception Handling
614 /// \{
615 
618  unsigned N = LandingPads.size();
619  for (unsigned i = 0; i < N; ++i) {
620  LandingPadInfo &LP = LandingPads[i];
621  if (LP.LandingPadBlock == LandingPad)
622  return LP;
623  }
624 
625  LandingPads.push_back(LandingPadInfo(LandingPad));
626  return LandingPads[N];
627 }
628 
630  MCSymbol *BeginLabel, MCSymbol *EndLabel) {
631  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
632  LP.BeginLabels.push_back(BeginLabel);
633  LP.EndLabels.push_back(EndLabel);
634 }
635 
637  MCSymbol *LandingPadLabel = Ctx.createTempSymbol();
638  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
639  LP.LandingPadLabel = LandingPadLabel;
640 
641  const Instruction *FirstI = LandingPad->getBasicBlock()->getFirstNonPHI();
642  if (const auto *LPI = dyn_cast<LandingPadInst>(FirstI)) {
643  if (const auto *PF =
644  dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts()))
645  getMMI().addPersonality(PF);
646 
647  if (LPI->isCleanup())
648  addCleanup(LandingPad);
649 
650  // FIXME: New EH - Add the clauses in reverse order. This isn't 100%
651  // correct, but we need to do it this way because of how the DWARF EH
652  // emitter processes the clauses.
653  for (unsigned I = LPI->getNumClauses(); I != 0; --I) {
654  Value *Val = LPI->getClause(I - 1);
655  if (LPI->isCatch(I - 1)) {
656  addCatchTypeInfo(LandingPad,
657  dyn_cast<GlobalValue>(Val->stripPointerCasts()));
658  } else {
659  // Add filters in a list.
660  auto *CVal = cast<Constant>(Val);
662  for (User::op_iterator II = CVal->op_begin(), IE = CVal->op_end();
663  II != IE; ++II)
664  FilterList.push_back(cast<GlobalValue>((*II)->stripPointerCasts()));
665 
666  addFilterTypeInfo(LandingPad, FilterList);
667  }
668  }
669 
670  } else if (const auto *CPI = dyn_cast<CatchPadInst>(FirstI)) {
671  for (unsigned I = CPI->getNumArgOperands(); I != 0; --I) {
672  Value *TypeInfo = CPI->getArgOperand(I - 1)->stripPointerCasts();
673  addCatchTypeInfo(LandingPad, dyn_cast<GlobalValue>(TypeInfo));
674  }
675 
676  } else {
677  assert(isa<CleanupPadInst>(FirstI) && "Invalid landingpad!");
678  }
679 
680  return LandingPadLabel;
681 }
682 
685  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
686  for (unsigned N = TyInfo.size(); N; --N)
687  LP.TypeIds.push_back(getTypeIDFor(TyInfo[N - 1]));
688 }
689 
692  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
693  std::vector<unsigned> IdsInFilter(TyInfo.size());
694  for (unsigned I = 0, E = TyInfo.size(); I != E; ++I)
695  IdsInFilter[I] = getTypeIDFor(TyInfo[I]);
696  LP.TypeIds.push_back(getFilterIDFor(IdsInFilter));
697 }
698 
700  bool TidyIfNoBeginLabels) {
701  for (unsigned i = 0; i != LandingPads.size(); ) {
702  LandingPadInfo &LandingPad = LandingPads[i];
703  if (LandingPad.LandingPadLabel &&
704  !LandingPad.LandingPadLabel->isDefined() &&
705  (!LPMap || (*LPMap)[LandingPad.LandingPadLabel] == 0))
706  LandingPad.LandingPadLabel = nullptr;
707 
708  // Special case: we *should* emit LPs with null LP MBB. This indicates
709  // "nounwind" case.
710  if (!LandingPad.LandingPadLabel && LandingPad.LandingPadBlock) {
711  LandingPads.erase(LandingPads.begin() + i);
712  continue;
713  }
714 
715  if (TidyIfNoBeginLabels) {
716  for (unsigned j = 0, e = LandingPads[i].BeginLabels.size(); j != e; ++j) {
717  MCSymbol *BeginLabel = LandingPad.BeginLabels[j];
718  MCSymbol *EndLabel = LandingPad.EndLabels[j];
719  if ((BeginLabel->isDefined() || (LPMap && (*LPMap)[BeginLabel] != 0)) &&
720  (EndLabel->isDefined() || (LPMap && (*LPMap)[EndLabel] != 0)))
721  continue;
722 
723  LandingPad.BeginLabels.erase(LandingPad.BeginLabels.begin() + j);
724  LandingPad.EndLabels.erase(LandingPad.EndLabels.begin() + j);
725  --j;
726  --e;
727  }
728 
729  // Remove landing pads with no try-ranges.
730  if (LandingPads[i].BeginLabels.empty()) {
731  LandingPads.erase(LandingPads.begin() + i);
732  continue;
733  }
734  }
735 
736  // If there is no landing pad, ensure that the list of typeids is empty.
737  // If the only typeid is a cleanup, this is the same as having no typeids.
738  if (!LandingPad.LandingPadBlock ||
739  (LandingPad.TypeIds.size() == 1 && !LandingPad.TypeIds[0]))
740  LandingPad.TypeIds.clear();
741  ++i;
742  }
743 }
744 
746  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
747  LP.TypeIds.push_back(0);
748 }
749 
751  const Function *Filter,
752  const BlockAddress *RecoverBA) {
753  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
754  SEHHandler Handler;
755  Handler.FilterOrFinally = Filter;
756  Handler.RecoverBA = RecoverBA;
757  LP.SEHHandlers.push_back(Handler);
758 }
759 
761  const Function *Cleanup) {
762  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
763  SEHHandler Handler;
764  Handler.FilterOrFinally = Cleanup;
765  Handler.RecoverBA = nullptr;
766  LP.SEHHandlers.push_back(Handler);
767 }
768 
770  ArrayRef<unsigned> Sites) {
771  LPadToCallSiteMap[Sym].append(Sites.begin(), Sites.end());
772 }
773 
775  for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i)
776  if (TypeInfos[i] == TI) return i + 1;
777 
778  TypeInfos.push_back(TI);
779  return TypeInfos.size();
780 }
781 
782 int MachineFunction::getFilterIDFor(std::vector<unsigned> &TyIds) {
783  // If the new filter coincides with the tail of an existing filter, then
784  // re-use the existing filter. Folding filters more than this requires
785  // re-ordering filters and/or their elements - probably not worth it.
786  for (std::vector<unsigned>::iterator I = FilterEnds.begin(),
787  E = FilterEnds.end(); I != E; ++I) {
788  unsigned i = *I, j = TyIds.size();
789 
790  while (i && j)
791  if (FilterIds[--i] != TyIds[--j])
792  goto try_next;
793 
794  if (!j)
795  // The new filter coincides with range [i, end) of the existing filter.
796  return -(1 + i);
797 
798 try_next:;
799  }
800 
801  // Add the new filter.
802  int FilterID = -(1 + FilterIds.size());
803  FilterIds.reserve(FilterIds.size() + TyIds.size() + 1);
804  FilterIds.insert(FilterIds.end(), TyIds.begin(), TyIds.end());
805  FilterEnds.push_back(FilterIds.size());
806  FilterIds.push_back(0); // terminator
807  return FilterID;
808 }
809 
811  MCSymbol *BeginLabel = Ctx.createTempSymbol("heapallocsite", true);
812  MCSymbol *EndLabel = Ctx.createTempSymbol("heapallocsite", true);
813  I->setPreInstrSymbol(*this, BeginLabel);
814  I->setPostInstrSymbol(*this, EndLabel);
815 
816  DIType *DI = dyn_cast<DIType>(MD);
817  CodeViewHeapAllocSites.push_back(std::make_tuple(BeginLabel, EndLabel, DI));
818 }
819 
820 /// \}
821 
822 //===----------------------------------------------------------------------===//
823 // MachineJumpTableInfo implementation
824 //===----------------------------------------------------------------------===//
825 
826 /// Return the size of each entry in the jump table.
828  // The size of a jump table entry is 4 bytes unless the entry is just the
829  // address of a block, in which case it is the pointer size.
830  switch (getEntryKind()) {
832  return TD.getPointerSize();
834  return 8;
838  return 4;
840  return 0;
841  }
842  llvm_unreachable("Unknown jump table encoding!");
843 }
844 
845 /// Return the alignment of each entry in the jump table.
847  // The alignment of a jump table entry is the alignment of int32 unless the
848  // entry is just the address of a block, in which case it is the pointer
849  // alignment.
850  switch (getEntryKind()) {
852  return TD.getPointerABIAlignment(0);
854  return TD.getABIIntegerTypeAlignment(64);
858  return TD.getABIIntegerTypeAlignment(32);
860  return 1;
861  }
862  llvm_unreachable("Unknown jump table encoding!");
863 }
864 
865 /// Create a new jump table entry in the jump table info.
867  const std::vector<MachineBasicBlock*> &DestBBs) {
868  assert(!DestBBs.empty() && "Cannot create an empty jump table!");
869  JumpTables.push_back(MachineJumpTableEntry(DestBBs));
870  return JumpTables.size()-1;
871 }
872 
873 /// If Old is the target of any jump tables, update the jump tables to branch
874 /// to New instead.
876  MachineBasicBlock *New) {
877  assert(Old != New && "Not making a change?");
878  bool MadeChange = false;
879  for (size_t i = 0, e = JumpTables.size(); i != e; ++i)
880  ReplaceMBBInJumpTable(i, Old, New);
881  return MadeChange;
882 }
883 
884 /// If Old is a target of the jump tables, update the jump table to branch to
885 /// New instead.
887  MachineBasicBlock *Old,
888  MachineBasicBlock *New) {
889  assert(Old != New && "Not making a change?");
890  bool MadeChange = false;
891  MachineJumpTableEntry &JTE = JumpTables[Idx];
892  for (size_t j = 0, e = JTE.MBBs.size(); j != e; ++j)
893  if (JTE.MBBs[j] == Old) {
894  JTE.MBBs[j] = New;
895  MadeChange = true;
896  }
897  return MadeChange;
898 }
899 
901  if (JumpTables.empty()) return;
902 
903  OS << "Jump Tables:\n";
904 
905  for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) {
906  OS << printJumpTableEntryReference(i) << ": ";
907  for (unsigned j = 0, f = JumpTables[i].MBBs.size(); j != f; ++j)
908  OS << ' ' << printMBBReference(*JumpTables[i].MBBs[j]);
909  }
910 
911  OS << '\n';
912 }
913 
914 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
916 #endif
917 
919  return Printable([Idx](raw_ostream &OS) { OS << "%jump-table." << Idx; });
920 }
921 
922 //===----------------------------------------------------------------------===//
923 // MachineConstantPool implementation
924 //===----------------------------------------------------------------------===//
925 
926 void MachineConstantPoolValue::anchor() {}
927 
929  if (isMachineConstantPoolEntry())
930  return Val.MachineCPVal->getType();
931  return Val.ConstVal->getType();
932 }
933 
935  if (isMachineConstantPoolEntry())
936  return true;
937  return Val.ConstVal->needsRelocation();
938 }
939 
942  if (needsRelocation())
944  switch (DL->getTypeAllocSize(getType())) {
945  case 4:
947  case 8:
949  case 16:
951  case 32:
953  default:
954  return SectionKind::getReadOnly();
955  }
956 }
957 
959  // A constant may be a member of both Constants and MachineCPVsSharingEntries,
960  // so keep track of which we've deleted to avoid double deletions.
962  for (unsigned i = 0, e = Constants.size(); i != e; ++i)
963  if (Constants[i].isMachineConstantPoolEntry()) {
964  Deleted.insert(Constants[i].Val.MachineCPVal);
965  delete Constants[i].Val.MachineCPVal;
966  }
968  MachineCPVsSharingEntries.begin(), E = MachineCPVsSharingEntries.end();
969  I != E; ++I) {
970  if (Deleted.count(*I) == 0)
971  delete *I;
972  }
973 }
974 
975 /// Test whether the given two constants can be allocated the same constant pool
976 /// entry.
977 static bool CanShareConstantPoolEntry(const Constant *A, const Constant *B,
978  const DataLayout &DL) {
979  // Handle the trivial case quickly.
980  if (A == B) return true;
981 
982  // If they have the same type but weren't the same constant, quickly
983  // reject them.
984  if (A->getType() == B->getType()) return false;
985 
986  // We can't handle structs or arrays.
987  if (isa<StructType>(A->getType()) || isa<ArrayType>(A->getType()) ||
988  isa<StructType>(B->getType()) || isa<ArrayType>(B->getType()))
989  return false;
990 
991  // For now, only support constants with the same size.
992  uint64_t StoreSize = DL.getTypeStoreSize(A->getType());
993  if (StoreSize != DL.getTypeStoreSize(B->getType()) || StoreSize > 128)
994  return false;
995 
996  Type *IntTy = IntegerType::get(A->getContext(), StoreSize*8);
997 
998  // Try constant folding a bitcast of both instructions to an integer. If we
999  // get two identical ConstantInt's, then we are good to share them. We use
1000  // the constant folding APIs to do this so that we get the benefit of
1001  // DataLayout.
1002  if (isa<PointerType>(A->getType()))
1003  A = ConstantFoldCastOperand(Instruction::PtrToInt,
1004  const_cast<Constant *>(A), IntTy, DL);
1005  else if (A->getType() != IntTy)
1006  A = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(A),
1007  IntTy, DL);
1008  if (isa<PointerType>(B->getType()))
1009  B = ConstantFoldCastOperand(Instruction::PtrToInt,
1010  const_cast<Constant *>(B), IntTy, DL);
1011  else if (B->getType() != IntTy)
1012  B = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(B),
1013  IntTy, DL);
1014 
1015  return A == B;
1016 }
1017 
1018 /// Create a new entry in the constant pool or return an existing one.
1019 /// User must specify the log2 of the minimum required alignment for the object.
1021  unsigned Alignment) {
1022  assert(Alignment && "Alignment must be specified!");
1023  if (Alignment > PoolAlignment) PoolAlignment = Alignment;
1024 
1025  // Check to see if we already have this constant.
1026  //
1027  // FIXME, this could be made much more efficient for large constant pools.
1028  for (unsigned i = 0, e = Constants.size(); i != e; ++i)
1029  if (!Constants[i].isMachineConstantPoolEntry() &&
1030  CanShareConstantPoolEntry(Constants[i].Val.ConstVal, C, DL)) {
1031  if ((unsigned)Constants[i].getAlignment() < Alignment)
1032  Constants[i].Alignment = Alignment;
1033  return i;
1034  }
1035 
1036  Constants.push_back(MachineConstantPoolEntry(C, Alignment));
1037  return Constants.size()-1;
1038 }
1039 
1041  unsigned Alignment) {
1042  assert(Alignment && "Alignment must be specified!");
1043  if (Alignment > PoolAlignment) PoolAlignment = Alignment;
1044 
1045  // Check to see if we already have this constant.
1046  //
1047  // FIXME, this could be made much more efficient for large constant pools.
1048  int Idx = V->getExistingMachineCPValue(this, Alignment);
1049  if (Idx != -1) {
1050  MachineCPVsSharingEntries.insert(V);
1051  return (unsigned)Idx;
1052  }
1053 
1054  Constants.push_back(MachineConstantPoolEntry(V, Alignment));
1055  return Constants.size()-1;
1056 }
1057 
1059  if (Constants.empty()) return;
1060 
1061  OS << "Constant Pool:\n";
1062  for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
1063  OS << " cp#" << i << ": ";
1064  if (Constants[i].isMachineConstantPoolEntry())
1065  Constants[i].Val.MachineCPVal->print(OS);
1066  else
1067  Constants[i].Val.ConstVal->printAsOperand(OS, /*PrintType=*/false);
1068  OS << ", align=" << Constants[i].getAlignment();
1069  OS << "\n";
1070  }
1071 }
1072 
1073 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1075 #endif
Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
void print(raw_ostream &OS, const SlotIndexes *=nullptr, bool IsStandalone=true) const
uint64_t CallInst * C
void bundleWithPred()
Bundle this instruction with its predecessor.
static unsigned getRegMaskSize(unsigned NumRegs)
Returns number of elements needed for a regmask array.
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:110
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
The MachineConstantPool class keeps track of constants referenced by a function which must be spilled...
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
unsigned getFnStackAlignment() const
Return the stack alignment for the function.
Definition: Function.h:343
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
bool contains(unsigned Reg) const
Return true if the specified register is included in this register class.
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:194
iterator erase(iterator where)
Definition: ilist.h:265
This class represents lattice values for constants.
Definition: AllocatorList.h:23
MachineFunctionProperties & reset(Property P)
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds...
Definition: Compiler.h:473
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:316
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
iterator begin() const
Definition: ArrayRef.h:136
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
void addLiveIn(unsigned Reg, unsigned vreg=0)
addLiveIn - Add the specified register as a live-in.
const Function * FilterOrFinally
Filter or finally function. Null indicates a catch-all.
const MachineFunctionProperties & getProperties() const
Get the function properties.
Implements a dense probed hash-table based set.
Definition: DenseSet.h:249
unsigned size() const
AtomicOrdering getFailureOrdering() const
For cmpxchg atomic operations, return the atomic ordering requirements when store does not occur...
void push_back(const T &Elt)
Definition: SmallVector.h:211
unsigned addLiveIn(unsigned PReg, const TargetRegisterClass *RC)
addLiveIn - Add the specified physical register as a live-in value and create a corresponding virtual...
LLVM_NODISCARD unsigned addFrameInst(const MCCFIInstruction &Inst)
Describe properties that are true of each instruction in the target description file.
Definition: MCInstrDesc.h:163
This file contains the declarations for metadata subclasses.
EK_Inline - Jump table entries are emitted inline at their point of use.
std::string getNodeLabel(const MachineBasicBlock *Node, const MachineFunction *Graph)
void viewCFG() const
viewCFG - This function is meant for use from the debugger.
virtual const TargetLowering * getTargetLowering() const
uint64_t getSize() const
Return the size in bytes of the memory reference.
static SectionKind getMergeableConst8()
Definition: SectionKind.h:192
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:709
static SectionKind getMergeableConst16()
Definition: SectionKind.h:193
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:323
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:509
unsigned const TargetRegisterInfo * TRI
A debug info location.
Definition: DebugLoc.h:33
Metadata node.
Definition: Metadata.h:863
F(f)
MachineModuleInfo & getMMI() const
Manage lifetime of a slot tracker for printing IR.
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:630
StringRef getLinkerPrivateGlobalPrefix() const
Definition: DataLayout.h:296
static SectionKind getMergeableConst4()
Definition: SectionKind.h:191
bool ReplaceMBBInJumpTable(unsigned Idx, MachineBasicBlock *Old, MachineBasicBlock *New)
ReplaceMBBInJumpTable - If Old is a target of the jump tables, update the jump table to branch to New...
MachineJumpTableInfo * getOrCreateJumpTableInfo(unsigned JTEntryKind)
getOrCreateJumpTableInfo - Get the JumpTableInfo for this function, if it does already exist...
*ViewGraph Emit a dot run run gv on the postscript *then cleanup For use from the debugger *void ViewGraph(const GraphType &G, const Twine &Name, bool ShortNames=false, const Twine &Title="", GraphProgram::Name Program=GraphProgram::DOT)
Definition: GraphWriter.h:366
void print(raw_ostream &OS) const
print - Used by the MachineFunction printer to print information about jump tables.
void addSEHCatchHandler(MachineBasicBlock *LandingPad, const Function *Filter, const BlockAddress *RecoverBA)
JTEntryKind
JTEntryKind - This enum indicates how each entry of the jump table is represented and emitted...
The address of a basic block.
Definition: Constants.h:839
void addSEHCleanupHandler(MachineBasicBlock *LandingPad, const Function *Cleanup)
void print(raw_ostream &OS) const
Print the MachineFunctionProperties in human-readable form.
A description of a memory reference used in the backend.
This file declares the MachineConstantPool class which is an abstract constant pool to keep track of ...
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:369
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
SmallVector< MCSymbol *, 1 > EndLabels
Printable printMBBReference(const MachineBasicBlock &MBB)
Prints a machine basic block reference.
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:55
SmallVector< SEHHandler, 1 > SEHHandlers
MachineInstr & CloneMachineInstrBundle(MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore, const MachineInstr &Orig)
Clones instruction or the whole instruction bundle Orig and insert into MBB before InsertBefore...
This file contains the simple types necessary to represent the attributes associated with functions a...
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
int getFilterIDFor(std::vector< unsigned > &TyIds)
Return the id of the filter encoded by TyIds. This is function wide.
void Deallocate(const void *Ptr, size_t Size)
Definition: Allocator.h:277
MachineMemOperand * getMachineMemOperand(MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s, unsigned base_alignment, const AAMDNodes &AAInfo=AAMDNodes(), const MDNode *Ranges=nullptr, SyncScope::ID SSID=SyncScope::System, AtomicOrdering Ordering=AtomicOrdering::NotAtomic, AtomicOrdering FailureOrdering=AtomicOrdering::NotAtomic)
getMachineMemOperand - Allocate a new MachineMemOperand.
MachineInstr::ExtraInfo * createMIExtraInfo(ArrayRef< MachineMemOperand *> MMOs, MCSymbol *PreInstrSymbol=nullptr, MCSymbol *PostInstrSymbol=nullptr)
Allocate and construct an extra info structure for a MachineInstr.
AtomicOrdering
Atomic ordering for LLVM&#39;s memory model.
bool isScopedEHPersonality(EHPersonality Pers)
Returns true if this personality uses scope-style EH IR instructions: catchswitch, catchpad/ret, and cleanuppad/ret.
static bool isSimple(Instruction *I)
Context object for machine code objects.
Definition: MCContext.h:62
unsigned getEntryAlignment(const DataLayout &TD) const
getEntryAlignment - Return the alignment of each entry in the jump table.
This structure is used to retain landing pad info for the current function.
bool isNull() const
Test if the pointer held in the union is null, regardless of which type it is.
Definition: PointerUnion.h:185
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:244
SlotIndexes pass.
Definition: SlotIndexes.h:328
void tidyLandingPads(DenseMap< MCSymbol *, uintptr_t > *LPMap=nullptr, bool TidyIfNoBeginLabels=true)
Remap landing pad labels and remove any deleted landing pads.
EK_LabelDifference32 - Each entry is the address of the block minus the address of the jump table...
livein_iterator livein_end() const
virtual int getExistingMachineCPValue(MachineConstantPool *CP, unsigned Alignment)=0
static std::string getGraphName(const MachineFunction *F)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
EK_BlockAddress - Each entry is a plain address of block, e.g.
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:130
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:25
unsigned getPrefFunctionAlignment() const
Return the preferred function alignment.
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:707
This class is a data container for one entry in a MachineConstantPool.
void setPostInstrSymbol(MachineFunction &MF, MCSymbol *Symbol)
Set a symbol that will be emitted just after the instruction itself.
instr_iterator insert(instr_iterator I, MachineInstr *M)
Insert MI into the instruction list before I, possibly inside a bundle.
MachineBasicBlock * CreateMachineBasicBlock(const BasicBlock *bb=nullptr)
CreateMachineBasicBlock - Allocate a new MachineBasicBlock.
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
constexpr uint64_t MinAlign(uint64_t A, uint64_t B)
A and B are either alignments or offsets.
Definition: MathExtras.h:609
#define P(N)
unsigned getNumRegs() const
Return the number of registers this target has (useful for sizing arrays holding per register informa...
EK_GPRel64BlockAddress - Each entry is an address of block, encoded with a relocation as gp-relative...
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:432
void print(raw_ostream &OS) const
print - Used by the MachineFunction printer to print information about constant pool objects...
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:189
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
EK_Custom32 - Each entry is a 32-bit value that is custom lowered by the TargetLowering::LowerCustomJ...
unsigned const MachineRegisterInfo * MRI
void print(const MachineFunction &MF, raw_ostream &OS) const
Used by the MachineFunction printer to print information about stack objects.
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
void addInvoke(MachineBasicBlock *LandingPad, MCSymbol *BeginLabel, MCSymbol *EndLabel)
Provide the begin and end labels of an invoke style call and associate it with a try landing pad bloc...
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
static unsigned getFnStackAlignment(const TargetSubtargetInfo *STI, const Function &F)
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:148
void addPersonality(const Function *Personality)
Provide the personality function for the exception information.
PointerUnion< const Value *, const PseudoSourceValue * > V
This is the IR pointer value for the access, or it is null if unknown.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:41
SmallVector< MCSymbol *, 1 > BeginLabels
unsigned getPointerSize(unsigned AS=0) const
Layout pointer size FIXME: The defaults need to be removed once all of the backends/clients are updat...
Definition: DataLayout.cpp:648
LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void * Allocate(size_t Size, size_t Alignment)
Allocate space at the specified alignment.
Definition: Allocator.h:214
static bool CanShareConstantPoolEntry(const Constant *A, const Constant *B, const DataLayout &DL)
Test whether the given two constants can be allocated the same constant pool entry.
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
std::vector< int > TypeIds
const PseudoSourceValue * getPseudoValue() const
This class describes a target machine that is implemented with the LLVM target-independent code gener...
MCSymbol * getJTISymbol(unsigned JTI, MCContext &Ctx, bool isLinkerPrivate=false) const
getJTISymbol - Return the MCSymbol for the specified non-empty jump table.
SectionKind - This is a simple POD value that classifies the properties of a section.
Definition: SectionKind.h:22
void addCodeViewHeapAllocSite(MachineInstr *I, MDNode *MD)
Record heapallocsites.
self_iterator getIterator()
Definition: ilist_node.h:81
Printable printJumpTableEntryReference(unsigned Idx)
Prints a jump table entry reference.
std::vector< MachineBasicBlock * > MBBs
MBBs - The vector of basic blocks from which to create the jump table.
void incorporateFunction(const Function &F)
Incorporate the given function.
Definition: AsmWriter.cpp:840
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:529
virtual void MF_HandleInsertion(MachineInstr &MI)=0
Callback after an insertion. This should not modify the MI directly.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Abstract base class for all machine specific constantpool value subclasses.
static wasm::ValType getType(const TargetRegisterClass *RC)
This class contains a discriminated union of information about pointers in memory operands...
const char * createExternalSymbolName(StringRef Name)
Allocate a string and populate it with the given external symbol name.
void print(raw_ostream &OS, const SlotIndexes *=nullptr) const
print - Print out the MachineFunction in a format suitable for debugging to the specified stream...
unsigned getStackAlignment() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool hasSubClassEq(const TargetRegisterClass *RC) const
Returns true if RC is a sub-class of or equal to this class.
void addCleanup(MachineBasicBlock *LandingPad)
Add a cleanup action for a landing pad.
DOTGraphTraits - Template class that can be specialized to customize how graphs are converted to &#39;dot...
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:239
Iterator for intrusive lists based on ilist_node.
Base class for types.
bool isFuncletEHPersonality(EHPersonality Pers)
Returns true if this is a personality function that invokes handler funclets (which must return to it...
bool shouldSplitStack() const
Should we be emitting segmented stack stuff for the function.
MachineInstr * CloneMachineInstr(const MachineInstr *Orig)
Create a new MachineInstr which is a copy of Orig, identical in all ways except the instruction has n...
bool ReplaceMBBInJumpTables(MachineBasicBlock *Old, MachineBasicBlock *New)
ReplaceMBBInJumpTables - If Old is the target of any jump tables, update the jump tables to branch to...
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:841
Module.h This file contains the declarations for the Module class.
iterator end() const
Definition: ArrayRef.h:137
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:643
static SectionKind getReadOnlyWithRel()
Definition: SectionKind.h:202
unsigned getABIIntegerTypeAlignment(unsigned BitWidth) const
Returns the minimum ABI-required alignment for an integer type of the specified bitwidth.
Definition: DataLayout.cpp:755
void addCatchTypeInfo(MachineBasicBlock *LandingPad, ArrayRef< const GlobalValue *> TyInfo)
Provide the catch typeinfo for a landing pad.
uint32_t * allocateRegMask()
Allocate and initialize a register mask with NumRegister bits.
void clear(AllocatorType &Allocator)
Release all the tracked allocations to the allocator.
virtual void MF_HandleRemoval(MachineInstr &MI)=0
Callback before a removal. This should not modify the MI directly.
static void deleteNode(NodeTy *V)
Definition: ilist.h:41
const Function & getFunction() const
Return the LLVM function that this machine code represents.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
MachinePointerInfo getWithOffset(int64_t O) const
void setCallSiteLandingPad(MCSymbol *Sym, ArrayRef< unsigned > Sites)
Map the landing pad&#39;s EH symbol to the call site indexes.
bool isDefined() const
isDefined - Check if this symbol is defined (i.e., it has an address).
Definition: MCSymbol.h:247
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.
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:469
static const char * getPropertyName(MachineFunctionProperties::Property Prop)
Representation of each machine instruction.
Definition: MachineInstr.h:63
std::vector< std::pair< unsigned, unsigned > >::const_iterator livein_iterator
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
const MachinePointerInfo & getPointerInfo() const
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.
void setPreInstrSymbol(MachineFunction &MF, MCSymbol *Symbol)
Set a symbol that will be emitted just prior to the instruction itself.
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:123
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:214
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
Flags getFlags() const
Return the raw flags of the source value,.
virtual const TargetFrameLowering * getFrameLowering() const
SectionKind getSectionKind(const DataLayout *DL) const
const BasicBlock * getBasicBlock() const
Return the LLVM basic block that this instance corresponded to originally.
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:332
uint32_t Size
Definition: Profile.cpp:46
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:91
void viewCFGOnly() const
viewCFGOnly - This function is meant for use from the debugger.
void dump() const
dump - Call print(cerr) to be called from the debugger.
#define LLVM_NODISCARD
LLVM_NODISCARD - Warn if a type or return value is discarded.
Definition: Compiler.h:128
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:482
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:565
LLVM Value Representation.
Definition: Value.h:72
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1306
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:444
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID for this memory operation.
MCSymbol * getPICBaseSymbol() const
getPICBaseSymbol - Return a function-local symbol to represent the PIC base.
const BlockAddress * RecoverBA
Address of block to recover at. Null for a finally handler.
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E&#39;s largest value.
Definition: BitmaskEnum.h:80
static const Function * getParent(const Value *V)
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
DefaultDOTGraphTraits - This class provides the default implementations of all of the DOTGraphTraits ...
unsigned createJumpTableIndex(const std::vector< MachineBasicBlock *> &DestBBs)
createJumpTableIndex - Create a new jump table.
void dump() const
dump - Call to stderr.
IRTranslator LLVM IR MI
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
EK_GPRel32BlockAddress - Each entry is an address of block, encoded with a relocation as gp-relative...
Simple wrapper around std::function<void(raw_ostream&)>.
Definition: Printable.h:37
unsigned getLiveInVirtReg(unsigned PReg) const
getLiveInVirtReg - If PReg is a live-in physical register, return the corresponding live-in physical ...
OutputIt copy(R &&Range, OutputIt Out)
Definition: STLExtras.h:1237
VariableDbgInfoMapTy VariableDbgInfos
static SectionKind getReadOnly()
Definition: SectionKind.h:181
unsigned getConstantPoolIndex(const Constant *C, unsigned Alignment)
getConstantPoolIndex - Create a new entry in the constant pool or return an existing one...
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.