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