LLVM  7.0.0svn
MachineFunction.h
Go to the documentation of this file.
1 //===- llvm/CodeGen/MachineFunction.h ---------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Collect native machine code for a function. This class contains a list of
11 // MachineBasicBlock instances that make up the current compiled function.
12 //
13 // This class also contains pointers to various classes which hold
14 // target-specific information about the generated code.
15 //
16 //===----------------------------------------------------------------------===//
17 
18 #ifndef LLVM_CODEGEN_MACHINEFUNCTION_H
19 #define LLVM_CODEGEN_MACHINEFUNCTION_H
20 
21 #include "llvm/ADT/ArrayRef.h"
22 #include "llvm/ADT/BitVector.h"
23 #include "llvm/ADT/DenseMap.h"
24 #include "llvm/ADT/GraphTraits.h"
25 #include "llvm/ADT/Optional.h"
26 #include "llvm/ADT/SmallVector.h"
27 #include "llvm/ADT/StringRef.h"
28 #include "llvm/ADT/ilist.h"
29 #include "llvm/ADT/iterator.h"
34 #include "llvm/IR/DebugLoc.h"
35 #include "llvm/IR/Instructions.h"
36 #include "llvm/IR/Metadata.h"
37 #include "llvm/MC/MCDwarf.h"
38 #include "llvm/MC/MCSymbol.h"
39 #include "llvm/Support/Allocator.h"
42 #include "llvm/Support/Compiler.h"
44 #include "llvm/Support/Recycler.h"
45 #include <cassert>
46 #include <cstdint>
47 #include <memory>
48 #include <utility>
49 #include <vector>
50 
51 namespace llvm {
52 
53 class BasicBlock;
54 class BlockAddress;
55 class DataLayout;
56 class DIExpression;
57 class DILocalVariable;
58 class DILocation;
59 class Function;
60 class GlobalValue;
61 class MachineConstantPool;
62 class MachineFrameInfo;
63 class MachineFunction;
64 class MachineJumpTableInfo;
65 class MachineModuleInfo;
66 class MachineRegisterInfo;
67 class MCContext;
68 class MCInstrDesc;
69 class Pass;
70 class PseudoSourceValueManager;
71 class raw_ostream;
72 class SlotIndexes;
73 class TargetMachine;
74 class TargetRegisterClass;
75 class TargetSubtargetInfo;
76 struct WasmEHFuncInfo;
77 struct WinEHFuncInfo;
78 
80  void deleteNode(MachineBasicBlock *MBB);
81 };
82 
84  void addNodeToList(MachineBasicBlock* MBB);
85  void removeNodeFromList(MachineBasicBlock* MBB);
86 
87  template <class Iterator>
88  void transferNodesFromList(ilist_callback_traits &OldList, Iterator, Iterator) {
89  llvm_unreachable("Never transfer between lists");
90  }
91 };
92 
93 /// MachineFunctionInfo - This class can be derived from and used by targets to
94 /// hold private target-specific information for each MachineFunction. Objects
95 /// of type are accessed/created with MF::getInfo and destroyed when the
96 /// MachineFunction is destroyed.
98  virtual ~MachineFunctionInfo();
99 
100  /// Factory function: default behavior is to call new using the
101  /// supplied allocator.
102  ///
103  /// This function can be overridden in a derive class.
104  template<typename Ty>
106  return new (Allocator.Allocate<Ty>()) Ty(MF);
107  }
108 };
109 
110 /// Properties which a MachineFunction may have at a given point in time.
111 /// Each of these has checking code in the MachineVerifier, and passes can
112 /// require that a property be set.
114  // Possible TODO: Allow targets to extend this (perhaps by allowing the
115  // constructor to specify the size of the bit vector)
116  // Possible TODO: Allow requiring the negative (e.g. VRegsAllocated could be
117  // stated as the negative of "has vregs"
118 
119 public:
120  // The properties are stated in "positive" form; i.e. a pass could require
121  // that the property hold, but not that it does not hold.
122 
123  // Property descriptions:
124  // IsSSA: True when the machine function is in SSA form and virtual registers
125  // have a single def.
126  // NoPHIs: The machine function does not contain any PHI instruction.
127  // TracksLiveness: True when tracking register liveness accurately.
128  // While this property is set, register liveness information in basic block
129  // live-in lists and machine instruction operands (e.g. kill flags, implicit
130  // defs) is accurate. This means it can be used to change the code in ways
131  // that affect the values in registers, for example by the register
132  // scavenger.
133  // When this property is clear, liveness is no longer reliable.
134  // NoVRegs: The machine function does not use any virtual registers.
135  // Legalized: In GlobalISel: the MachineLegalizer ran and all pre-isel generic
136  // instructions have been legalized; i.e., all instructions are now one of:
137  // - generic and always legal (e.g., COPY)
138  // - target-specific
139  // - legal pre-isel generic instructions.
140  // RegBankSelected: In GlobalISel: the RegBankSelect pass ran and all generic
141  // virtual registers have been assigned to a register bank.
142  // Selected: In GlobalISel: the InstructionSelect pass ran and all pre-isel
143  // generic instructions have been eliminated; i.e., all instructions are now
144  // target-specific or non-pre-isel generic instructions (e.g., COPY).
145  // Since only pre-isel generic instructions can have generic virtual register
146  // operands, this also means that all generic virtual registers have been
147  // constrained to virtual registers (assigned to register classes) and that
148  // all sizes attached to them have been eliminated.
149  enum class Property : unsigned {
150  IsSSA,
151  NoPHIs,
152  TracksLiveness,
153  NoVRegs,
154  FailedISel,
155  Legalized,
156  RegBankSelected,
157  Selected,
158  LastProperty = Selected,
159  };
160 
161  bool hasProperty(Property P) const {
162  return Properties[static_cast<unsigned>(P)];
163  }
164 
166  Properties.set(static_cast<unsigned>(P));
167  return *this;
168  }
169 
171  Properties.reset(static_cast<unsigned>(P));
172  return *this;
173  }
174 
175  /// Reset all the properties.
177  Properties.reset();
178  return *this;
179  }
180 
182  Properties |= MFP.Properties;
183  return *this;
184  }
185 
187  Properties.reset(MFP.Properties);
188  return *this;
189  }
190 
191  // Returns true if all properties set in V (i.e. required by a pass) are set
192  // in this.
194  return !V.Properties.test(Properties);
195  }
196 
197  /// Print the MachineFunctionProperties in human-readable form.
198  void print(raw_ostream &OS) const;
199 
200 private:
201  BitVector Properties =
202  BitVector(static_cast<unsigned>(Property::LastProperty)+1);
203 };
204 
205 struct SEHHandler {
206  /// Filter or finally function. Null indicates a catch-all.
208 
209  /// Address of block to recover at. Null for a finally handler.
211 };
212 
213 /// This structure is used to retain landing pad info for the current function.
215  MachineBasicBlock *LandingPadBlock; // Landing pad block.
216  SmallVector<MCSymbol *, 1> BeginLabels; // Labels prior to invoke.
217  SmallVector<MCSymbol *, 1> EndLabels; // Labels after invoke.
218  SmallVector<SEHHandler, 1> SEHHandlers; // SEH handlers active at this lpad.
219  MCSymbol *LandingPadLabel = nullptr; // Label at beginning of landing pad.
220  std::vector<int> TypeIds; // List of type ids (filters negative).
221 
223  : LandingPadBlock(MBB) {}
224 };
225 
227  const Function &F;
228  const TargetMachine &Target;
229  const TargetSubtargetInfo *STI;
230  MCContext &Ctx;
231  MachineModuleInfo &MMI;
232 
233  // RegInfo - Information about each register in use in the function.
234  MachineRegisterInfo *RegInfo;
235 
236  // Used to keep track of target-specific per-machine function information for
237  // the target implementation.
238  MachineFunctionInfo *MFInfo;
239 
240  // Keep track of objects allocated on the stack.
241  MachineFrameInfo *FrameInfo;
242 
243  // Keep track of constants which are spilled to memory
245 
246  // Keep track of jump tables for switch instructions
247  MachineJumpTableInfo *JumpTableInfo;
248 
249  // Keeps track of Wasm exception handling related data. This will be null for
250  // functions that aren't using a wasm EH personality.
251  WasmEHFuncInfo *WasmEHInfo = nullptr;
252 
253  // Keeps track of Windows exception handling related data. This will be null
254  // for functions that aren't using a funclet-based EH personality.
255  WinEHFuncInfo *WinEHInfo = nullptr;
256 
257  // Function-level unique numbering for MachineBasicBlocks. When a
258  // MachineBasicBlock is inserted into a MachineFunction is it automatically
259  // numbered and this vector keeps track of the mapping from ID's to MBB's.
260  std::vector<MachineBasicBlock*> MBBNumbering;
261 
262  // Pool-allocate MachineFunction-lifetime and IR objects.
264 
265  // Allocation management for instructions in function.
266  Recycler<MachineInstr> InstructionRecycler;
267 
268  // Allocation management for operand arrays on instructions.
269  ArrayRecycler<MachineOperand> OperandRecycler;
270 
271  // Allocation management for basic blocks in function.
272  Recycler<MachineBasicBlock> BasicBlockRecycler;
273 
274  // List of machine basic blocks in function
276  BasicBlockListType BasicBlocks;
277 
278  /// FunctionNumber - This provides a unique ID for each function emitted in
279  /// this translation unit.
280  ///
281  unsigned FunctionNumber;
282 
283  /// Alignment - The alignment of the function.
284  unsigned Alignment;
285 
286  /// ExposesReturnsTwice - True if the function calls setjmp or related
287  /// functions with attribute "returns twice", but doesn't have
288  /// the attribute itself.
289  /// This is used to limit optimizations which cannot reason
290  /// about the control flow of such functions.
291  bool ExposesReturnsTwice = false;
292 
293  /// True if the function includes any inline assembly.
294  bool HasInlineAsm = false;
295 
296  /// True if any WinCFI instruction have been emitted in this function.
297  Optional<bool> HasWinCFI;
298 
299  /// Current high-level properties of the IR of the function (e.g. is in SSA
300  /// form or whether registers have been allocated)
301  MachineFunctionProperties Properties;
302 
303  // Allocation management for pseudo source values.
304  std::unique_ptr<PseudoSourceValueManager> PSVManager;
305 
306  /// List of moves done by a function's prolog. Used to construct frame maps
307  /// by debug and exception handling consumers.
308  std::vector<MCCFIInstruction> FrameInstructions;
309 
310  /// \name Exception Handling
311  /// \{
312 
313  /// List of LandingPadInfo describing the landing pad information.
314  std::vector<LandingPadInfo> LandingPads;
315 
316  /// Map a landing pad's EH symbol to the call site indexes.
318 
319  /// Map of invoke call site index values to associated begin EH_LABEL.
320  DenseMap<MCSymbol*, unsigned> CallSiteMap;
321 
322  /// CodeView label annotations.
323  std::vector<std::pair<MCSymbol *, MDNode *>> CodeViewAnnotations;
324 
325  bool CallsEHReturn = false;
326  bool CallsUnwindInit = false;
327  bool HasEHScopes = false;
328  bool HasEHFunclets = false;
329 
330  /// List of C++ TypeInfo used.
331  std::vector<const GlobalValue *> TypeInfos;
332 
333  /// List of typeids encoding filters used.
334  std::vector<unsigned> FilterIds;
335 
336  /// List of the indices in FilterIds corresponding to filter terminators.
337  std::vector<unsigned> FilterEnds;
338 
339  EHPersonality PersonalityTypeCache = EHPersonality::Unknown;
340 
341  /// \}
342 
343  /// Clear all the members of this MachineFunction, but the ones used
344  /// to initialize again the MachineFunction.
345  /// More specifically, this deallocates all the dynamically allocated
346  /// objects and get rid of all the XXXInfo data structure, but keep
347  /// unchanged the references to Fn, Target, MMI, and FunctionNumber.
348  void clear();
349  /// Allocate and initialize the different members.
350  /// In particular, the XXXInfo data structure.
351  /// \pre Fn, Target, MMI, and FunctionNumber are properly set.
352  void init();
353 
354 public:
358  // The Slot can be negative for fixed stack objects.
359  int Slot;
360  const DILocation *Loc;
361 
363  int Slot, const DILocation *Loc)
364  : Var(Var), Expr(Expr), Slot(Slot), Loc(Loc) {}
365  };
368 
369  MachineFunction(const Function &F, const TargetMachine &TM,
370  const TargetSubtargetInfo &STI, unsigned FunctionNum,
371  MachineModuleInfo &MMI);
372  MachineFunction(const MachineFunction &) = delete;
373  MachineFunction &operator=(const MachineFunction &) = delete;
374  ~MachineFunction();
375 
376  /// Reset the instance as if it was just created.
377  void reset() {
378  clear();
379  init();
380  }
381 
382  MachineModuleInfo &getMMI() const { return MMI; }
383  MCContext &getContext() const { return Ctx; }
384 
385  PseudoSourceValueManager &getPSVManager() const { return *PSVManager; }
386 
387  /// Return the DataLayout attached to the Module associated to this MF.
388  const DataLayout &getDataLayout() const;
389 
390  /// Return the LLVM function that this machine code represents
391  const Function &getFunction() const { return F; }
392 
393  /// getName - Return the name of the corresponding LLVM function.
394  StringRef getName() const;
395 
396  /// getFunctionNumber - Return a unique ID for the current function.
397  unsigned getFunctionNumber() const { return FunctionNumber; }
398 
399  /// getTarget - Return the target machine this machine code is compiled with
400  const TargetMachine &getTarget() const { return Target; }
401 
402  /// getSubtarget - Return the subtarget for which this machine code is being
403  /// compiled.
404  const TargetSubtargetInfo &getSubtarget() const { return *STI; }
405  void setSubtarget(const TargetSubtargetInfo *ST) { STI = ST; }
406 
407  /// getSubtarget - This method returns a pointer to the specified type of
408  /// TargetSubtargetInfo. In debug builds, it verifies that the object being
409  /// returned is of the correct type.
410  template<typename STC> const STC &getSubtarget() const {
411  return *static_cast<const STC *>(STI);
412  }
413 
414  /// getRegInfo - Return information about the registers currently in use.
415  MachineRegisterInfo &getRegInfo() { return *RegInfo; }
416  const MachineRegisterInfo &getRegInfo() const { return *RegInfo; }
417 
418  /// getFrameInfo - Return the frame info object for the current function.
419  /// This object contains information about objects allocated on the stack
420  /// frame of the current function in an abstract way.
421  MachineFrameInfo &getFrameInfo() { return *FrameInfo; }
422  const MachineFrameInfo &getFrameInfo() const { return *FrameInfo; }
423 
424  /// getJumpTableInfo - Return the jump table info object for the current
425  /// function. This object contains information about jump tables in the
426  /// current function. If the current function has no jump tables, this will
427  /// return null.
428  const MachineJumpTableInfo *getJumpTableInfo() const { return JumpTableInfo; }
429  MachineJumpTableInfo *getJumpTableInfo() { return JumpTableInfo; }
430 
431  /// getOrCreateJumpTableInfo - Get the JumpTableInfo for this function, if it
432  /// does already exist, allocate one.
433  MachineJumpTableInfo *getOrCreateJumpTableInfo(unsigned JTEntryKind);
434 
435  /// getConstantPool - Return the constant pool object for the current
436  /// function.
439 
440  /// getWasmEHFuncInfo - Return information about how the current function uses
441  /// Wasm exception handling. Returns null for functions that don't use wasm
442  /// exception handling.
443  const WasmEHFuncInfo *getWasmEHFuncInfo() const { return WasmEHInfo; }
444  WasmEHFuncInfo *getWasmEHFuncInfo() { return WasmEHInfo; }
445 
446  /// getWinEHFuncInfo - Return information about how the current function uses
447  /// Windows exception handling. Returns null for functions that don't use
448  /// funclets for exception handling.
449  const WinEHFuncInfo *getWinEHFuncInfo() const { return WinEHInfo; }
450  WinEHFuncInfo *getWinEHFuncInfo() { return WinEHInfo; }
451 
452  /// getAlignment - Return the alignment (log2, not bytes) of the function.
453  unsigned getAlignment() const { return Alignment; }
454 
455  /// setAlignment - Set the alignment (log2, not bytes) of the function.
456  void setAlignment(unsigned A) { Alignment = A; }
457 
458  /// ensureAlignment - Make sure the function is at least 1 << A bytes aligned.
459  void ensureAlignment(unsigned A) {
460  if (Alignment < A) Alignment = A;
461  }
462 
463  /// exposesReturnsTwice - Returns true if the function calls setjmp or
464  /// any other similar functions with attribute "returns twice" without
465  /// having the attribute itself.
466  bool exposesReturnsTwice() const {
467  return ExposesReturnsTwice;
468  }
469 
470  /// setCallsSetJmp - Set a flag that indicates if there's a call to
471  /// a "returns twice" function.
473  ExposesReturnsTwice = B;
474  }
475 
476  /// Returns true if the function contains any inline assembly.
477  bool hasInlineAsm() const {
478  return HasInlineAsm;
479  }
480 
481  /// Set a flag that indicates that the function contains inline assembly.
482  void setHasInlineAsm(bool B) {
483  HasInlineAsm = B;
484  }
485 
486  bool hasWinCFI() const {
487  assert(HasWinCFI.hasValue() && "HasWinCFI not set yet!");
488  return *HasWinCFI;
489  }
490  void setHasWinCFI(bool v) { HasWinCFI = v; }
491 
492  /// Get the function properties
493  const MachineFunctionProperties &getProperties() const { return Properties; }
494  MachineFunctionProperties &getProperties() { return Properties; }
495 
496  /// getInfo - Keep track of various per-function pieces of information for
497  /// backends that would like to do so.
498  ///
499  template<typename Ty>
500  Ty *getInfo() {
501  if (!MFInfo)
502  MFInfo = Ty::template create<Ty>(Allocator, *this);
503  return static_cast<Ty*>(MFInfo);
504  }
505 
506  template<typename Ty>
507  const Ty *getInfo() const {
508  return const_cast<MachineFunction*>(this)->getInfo<Ty>();
509  }
510 
511  /// getBlockNumbered - MachineBasicBlocks are automatically numbered when they
512  /// are inserted into the machine function. The block number for a machine
513  /// basic block can be found by using the MBB::getNumber method, this method
514  /// provides the inverse mapping.
516  assert(N < MBBNumbering.size() && "Illegal block number");
517  assert(MBBNumbering[N] && "Block was removed from the machine function!");
518  return MBBNumbering[N];
519  }
520 
521  /// Should we be emitting segmented stack stuff for the function
522  bool shouldSplitStack() const;
523 
524  /// getNumBlockIDs - Return the number of MBB ID's allocated.
525  unsigned getNumBlockIDs() const { return (unsigned)MBBNumbering.size(); }
526 
527  /// RenumberBlocks - This discards all of the MachineBasicBlock numbers and
528  /// recomputes them. This guarantees that the MBB numbers are sequential,
529  /// dense, and match the ordering of the blocks within the function. If a
530  /// specific MachineBasicBlock is specified, only that block and those after
531  /// it are renumbered.
532  void RenumberBlocks(MachineBasicBlock *MBBFrom = nullptr);
533 
534  /// print - Print out the MachineFunction in a format suitable for debugging
535  /// to the specified stream.
536  void print(raw_ostream &OS, const SlotIndexes* = nullptr) const;
537 
538  /// viewCFG - This function is meant for use from the debugger. You can just
539  /// say 'call F->viewCFG()' and a ghostview window should pop up from the
540  /// program, displaying the CFG of the current function with the code for each
541  /// basic block inside. This depends on there being a 'dot' and 'gv' program
542  /// in your path.
543  void viewCFG() const;
544 
545  /// viewCFGOnly - This function is meant for use from the debugger. It works
546  /// just like viewCFG, but it does not include the contents of basic blocks
547  /// into the nodes, just the label. If you are only interested in the CFG
548  /// this can make the graph smaller.
549  ///
550  void viewCFGOnly() const;
551 
552  /// dump - Print the current MachineFunction to cerr, useful for debugger use.
553  void dump() const;
554 
555  /// Run the current MachineFunction through the machine code verifier, useful
556  /// for debugger use.
557  /// \returns true if no problems were found.
558  bool verify(Pass *p = nullptr, const char *Banner = nullptr,
559  bool AbortOnError = true) const;
560 
561  // Provide accessors for the MachineBasicBlock list...
562  using iterator = BasicBlockListType::iterator;
566 
567  /// Support for MachineBasicBlock::getNextNode().
570  return &MachineFunction::BasicBlocks;
571  }
572 
573  /// addLiveIn - Add the specified physical register as a live-in value and
574  /// create a corresponding virtual register for it.
575  unsigned addLiveIn(unsigned PReg, const TargetRegisterClass *RC);
576 
577  //===--------------------------------------------------------------------===//
578  // BasicBlock accessor functions.
579  //
580  iterator begin() { return BasicBlocks.begin(); }
581  const_iterator begin() const { return BasicBlocks.begin(); }
582  iterator end () { return BasicBlocks.end(); }
583  const_iterator end () const { return BasicBlocks.end(); }
584 
585  reverse_iterator rbegin() { return BasicBlocks.rbegin(); }
586  const_reverse_iterator rbegin() const { return BasicBlocks.rbegin(); }
587  reverse_iterator rend () { return BasicBlocks.rend(); }
588  const_reverse_iterator rend () const { return BasicBlocks.rend(); }
589 
590  unsigned size() const { return (unsigned)BasicBlocks.size();}
591  bool empty() const { return BasicBlocks.empty(); }
592  const MachineBasicBlock &front() const { return BasicBlocks.front(); }
593  MachineBasicBlock &front() { return BasicBlocks.front(); }
594  const MachineBasicBlock & back() const { return BasicBlocks.back(); }
595  MachineBasicBlock & back() { return BasicBlocks.back(); }
596 
597  void push_back (MachineBasicBlock *MBB) { BasicBlocks.push_back (MBB); }
598  void push_front(MachineBasicBlock *MBB) { BasicBlocks.push_front(MBB); }
599  void insert(iterator MBBI, MachineBasicBlock *MBB) {
600  BasicBlocks.insert(MBBI, MBB);
601  }
602  void splice(iterator InsertPt, iterator MBBI) {
603  BasicBlocks.splice(InsertPt, BasicBlocks, MBBI);
604  }
605  void splice(iterator InsertPt, MachineBasicBlock *MBB) {
606  BasicBlocks.splice(InsertPt, BasicBlocks, MBB);
607  }
608  void splice(iterator InsertPt, iterator MBBI, iterator MBBE) {
609  BasicBlocks.splice(InsertPt, BasicBlocks, MBBI, MBBE);
610  }
611 
612  void remove(iterator MBBI) { BasicBlocks.remove(MBBI); }
613  void remove(MachineBasicBlock *MBBI) { BasicBlocks.remove(MBBI); }
614  void erase(iterator MBBI) { BasicBlocks.erase(MBBI); }
615  void erase(MachineBasicBlock *MBBI) { BasicBlocks.erase(MBBI); }
616 
617  template <typename Comp>
618  void sort(Comp comp) {
619  BasicBlocks.sort(comp);
620  }
621 
622  //===--------------------------------------------------------------------===//
623  // Internal functions used to automatically number MachineBasicBlocks
624 
625  /// Adds the MBB to the internal numbering. Returns the unique number
626  /// assigned to the MBB.
628  MBBNumbering.push_back(MBB);
629  return (unsigned)MBBNumbering.size()-1;
630  }
631 
632  /// removeFromMBBNumbering - Remove the specific machine basic block from our
633  /// tracker, this is only really to be used by the MachineBasicBlock
634  /// implementation.
635  void removeFromMBBNumbering(unsigned N) {
636  assert(N < MBBNumbering.size() && "Illegal basic block #");
637  MBBNumbering[N] = nullptr;
638  }
639 
640  /// CreateMachineInstr - Allocate a new MachineInstr. Use this instead
641  /// of `new MachineInstr'.
642  MachineInstr *CreateMachineInstr(const MCInstrDesc &MCID, const DebugLoc &DL,
643  bool NoImp = false);
644 
645  /// Create a new MachineInstr which is a copy of \p Orig, identical in all
646  /// ways except the instruction has no parent, prev, or next. Bundling flags
647  /// are reset.
648  ///
649  /// Note: Clones a single instruction, not whole instruction bundles.
650  /// Does not perform target specific adjustments; consider using
651  /// TargetInstrInfo::duplicate() instead.
652  MachineInstr *CloneMachineInstr(const MachineInstr *Orig);
653 
654  /// Clones instruction or the whole instruction bundle \p Orig and insert
655  /// into \p MBB before \p InsertBefore.
656  ///
657  /// Note: Does not perform target specific adjustments; consider using
658  /// TargetInstrInfo::duplicate() intead.
659  MachineInstr &CloneMachineInstrBundle(MachineBasicBlock &MBB,
660  MachineBasicBlock::iterator InsertBefore, const MachineInstr &Orig);
661 
662  /// DeleteMachineInstr - Delete the given MachineInstr.
663  void DeleteMachineInstr(MachineInstr *MI);
664 
665  /// CreateMachineBasicBlock - Allocate a new MachineBasicBlock. Use this
666  /// instead of `new MachineBasicBlock'.
667  MachineBasicBlock *CreateMachineBasicBlock(const BasicBlock *bb = nullptr);
668 
669  /// DeleteMachineBasicBlock - Delete the given MachineBasicBlock.
670  void DeleteMachineBasicBlock(MachineBasicBlock *MBB);
671 
672  /// getMachineMemOperand - Allocate a new MachineMemOperand.
673  /// MachineMemOperands are owned by the MachineFunction and need not be
674  /// explicitly deallocated.
675  MachineMemOperand *getMachineMemOperand(
676  MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s,
677  unsigned base_alignment, const AAMDNodes &AAInfo = AAMDNodes(),
678  const MDNode *Ranges = nullptr,
681  AtomicOrdering FailureOrdering = AtomicOrdering::NotAtomic);
682 
683  /// getMachineMemOperand - Allocate a new MachineMemOperand by copying
684  /// an existing one, adjusting by an offset and using the given size.
685  /// MachineMemOperands are owned by the MachineFunction and need not be
686  /// explicitly deallocated.
687  MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
688  int64_t Offset, uint64_t Size);
689 
690  /// Allocate a new MachineMemOperand by copying an existing one,
691  /// replacing only AliasAnalysis information. MachineMemOperands are owned
692  /// by the MachineFunction and need not be explicitly deallocated.
693  MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
694  const AAMDNodes &AAInfo);
695 
697 
698  /// Allocate an array of MachineOperands. This is only intended for use by
699  /// internal MachineInstr functions.
701  return OperandRecycler.allocate(Cap, Allocator);
702  }
703 
704  /// Dellocate an array of MachineOperands and recycle the memory. This is
705  /// only intended for use by internal MachineInstr functions.
706  /// Cap must be the same capacity that was used to allocate the array.
708  OperandRecycler.deallocate(Cap, Array);
709  }
710 
711  /// Allocate and initialize a register mask with @p NumRegister bits.
712  uint32_t *allocateRegisterMask(unsigned NumRegister) {
713  unsigned Size = (NumRegister + 31) / 32;
714  uint32_t *Mask = Allocator.Allocate<uint32_t>(Size);
715  for (unsigned i = 0; i != Size; ++i)
716  Mask[i] = 0;
717  return Mask;
718  }
719 
720  /// allocateMemRefsArray - Allocate an array to hold MachineMemOperand
721  /// pointers. This array is owned by the MachineFunction.
722  MachineInstr::mmo_iterator allocateMemRefsArray(unsigned long Num);
723 
724  /// extractLoadMemRefs - Allocate an array and populate it with just the
725  /// load information from the given MachineMemOperand sequence.
726  std::pair<MachineInstr::mmo_iterator,
727  MachineInstr::mmo_iterator>
728  extractLoadMemRefs(MachineInstr::mmo_iterator Begin,
729  MachineInstr::mmo_iterator End);
730 
731  /// extractStoreMemRefs - Allocate an array and populate it with just the
732  /// store information from the given MachineMemOperand sequence.
733  std::pair<MachineInstr::mmo_iterator,
734  MachineInstr::mmo_iterator>
735  extractStoreMemRefs(MachineInstr::mmo_iterator Begin,
736  MachineInstr::mmo_iterator End);
737 
738  /// Allocate a string and populate it with the given external symbol name.
739  const char *createExternalSymbolName(StringRef Name);
740 
741  //===--------------------------------------------------------------------===//
742  // Label Manipulation.
743 
744  /// getJTISymbol - Return the MCSymbol for the specified non-empty jump table.
745  /// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
746  /// normal 'L' label is returned.
747  MCSymbol *getJTISymbol(unsigned JTI, MCContext &Ctx,
748  bool isLinkerPrivate = false) const;
749 
750  /// getPICBaseSymbol - Return a function-local symbol to represent the PIC
751  /// base.
752  MCSymbol *getPICBaseSymbol() const;
753 
754  /// Returns a reference to a list of cfi instructions in the function's
755  /// prologue. Used to construct frame maps for debug and exception handling
756  /// comsumers.
757  const std::vector<MCCFIInstruction> &getFrameInstructions() const {
758  return FrameInstructions;
759  }
760 
762  FrameInstructions.push_back(Inst);
763  return FrameInstructions.size() - 1;
764  }
765 
766  /// \name Exception Handling
767  /// \{
768 
769  bool callsEHReturn() const { return CallsEHReturn; }
770  void setCallsEHReturn(bool b) { CallsEHReturn = b; }
771 
772  bool callsUnwindInit() const { return CallsUnwindInit; }
773  void setCallsUnwindInit(bool b) { CallsUnwindInit = b; }
774 
775  bool hasEHScopes() const { return HasEHScopes; }
776  void setHasEHScopes(bool V) { HasEHScopes = V; }
777 
778  bool hasEHFunclets() const { return HasEHFunclets; }
779  void setHasEHFunclets(bool V) { HasEHFunclets = V; }
780 
781  /// Find or create an LandingPadInfo for the specified MachineBasicBlock.
782  LandingPadInfo &getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad);
783 
784  /// Remap landing pad labels and remove any deleted landing pads.
785  void tidyLandingPads(DenseMap<MCSymbol*, uintptr_t> *LPMap = nullptr);
786 
787  /// Return a reference to the landing pad info for the current function.
788  const std::vector<LandingPadInfo> &getLandingPads() const {
789  return LandingPads;
790  }
791 
792  /// Provide the begin and end labels of an invoke style call and associate it
793  /// with a try landing pad block.
794  void addInvoke(MachineBasicBlock *LandingPad,
795  MCSymbol *BeginLabel, MCSymbol *EndLabel);
796 
797  /// Add a new panding pad. Returns the label ID for the landing pad entry.
798  MCSymbol *addLandingPad(MachineBasicBlock *LandingPad);
799 
800  /// Provide the catch typeinfo for a landing pad.
801  void addCatchTypeInfo(MachineBasicBlock *LandingPad,
803 
804  /// Provide the filter typeinfo for a landing pad.
805  void addFilterTypeInfo(MachineBasicBlock *LandingPad,
807 
808  /// Add a cleanup action for a landing pad.
809  void addCleanup(MachineBasicBlock *LandingPad);
810 
811  void addSEHCatchHandler(MachineBasicBlock *LandingPad, const Function *Filter,
812  const BlockAddress *RecoverLabel);
813 
814  void addSEHCleanupHandler(MachineBasicBlock *LandingPad,
815  const Function *Cleanup);
816 
817  /// Return the type id for the specified typeinfo. This is function wide.
818  unsigned getTypeIDFor(const GlobalValue *TI);
819 
820  /// Return the id of the filter encoded by TyIds. This is function wide.
821  int getFilterIDFor(std::vector<unsigned> &TyIds);
822 
823  /// Map the landing pad's EH symbol to the call site indexes.
824  void setCallSiteLandingPad(MCSymbol *Sym, ArrayRef<unsigned> Sites);
825 
826  /// Get the call site indexes for a landing pad EH symbol.
828  assert(hasCallSiteLandingPad(Sym) &&
829  "missing call site number for landing pad!");
830  return LPadToCallSiteMap[Sym];
831  }
832 
833  /// Return true if the landing pad Eh symbol has an associated call site.
835  return !LPadToCallSiteMap[Sym].empty();
836  }
837 
838  /// Map the begin label for a call site.
839  void setCallSiteBeginLabel(MCSymbol *BeginLabel, unsigned Site) {
840  CallSiteMap[BeginLabel] = Site;
841  }
842 
843  /// Get the call site number for a begin label.
844  unsigned getCallSiteBeginLabel(MCSymbol *BeginLabel) const {
845  assert(hasCallSiteBeginLabel(BeginLabel) &&
846  "Missing call site number for EH_LABEL!");
847  return CallSiteMap.lookup(BeginLabel);
848  }
849 
850  /// Return true if the begin label has a call site number associated with it.
851  bool hasCallSiteBeginLabel(MCSymbol *BeginLabel) const {
852  return CallSiteMap.count(BeginLabel);
853  }
854 
855  /// Record annotations associated with a particular label.
857  CodeViewAnnotations.push_back({Label, MD});
858  }
859 
861  return CodeViewAnnotations;
862  }
863 
864  /// Return a reference to the C++ typeinfo for the current function.
865  const std::vector<const GlobalValue *> &getTypeInfos() const {
866  return TypeInfos;
867  }
868 
869  /// Return a reference to the typeids encoding filters used in the current
870  /// function.
871  const std::vector<unsigned> &getFilterIds() const {
872  return FilterIds;
873  }
874 
875  /// \}
876 
877  /// Collect information used to emit debugging information of a variable.
878  void setVariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr,
879  int Slot, const DILocation *Loc) {
880  VariableDbgInfos.emplace_back(Var, Expr, Slot, Loc);
881  }
882 
883  VariableDbgInfoMapTy &getVariableDbgInfo() { return VariableDbgInfos; }
885  return VariableDbgInfos;
886  }
887 };
888 
889 /// \name Exception Handling
890 /// \{
891 
892 /// Extract the exception handling information from the landingpad instruction
893 /// and add them to the specified machine module info.
895 
896 /// \}
897 
898 //===--------------------------------------------------------------------===//
899 // GraphTraits specializations for function basic block graphs (CFGs)
900 //===--------------------------------------------------------------------===//
901 
902 // Provide specializations of GraphTraits to be able to treat a
903 // machine function as a graph of machine basic blocks... these are
904 // the same as the machine basic block iterators, except that the root
905 // node is implicitly the first node of the function.
906 //
907 template <> struct GraphTraits<MachineFunction*> :
909  static NodeRef getEntryNode(MachineFunction *F) { return &F->front(); }
910 
911  // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
913 
915  return nodes_iterator(F->begin());
916  }
917 
919  return nodes_iterator(F->end());
920  }
921 
922  static unsigned size (MachineFunction *F) { return F->size(); }
923 };
924 template <> struct GraphTraits<const MachineFunction*> :
926  static NodeRef getEntryNode(const MachineFunction *F) { return &F->front(); }
927 
928  // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
930 
932  return nodes_iterator(F->begin());
933  }
934 
936  return nodes_iterator(F->end());
937  }
938 
939  static unsigned size (const MachineFunction *F) {
940  return F->size();
941  }
942 };
943 
944 // Provide specializations of GraphTraits to be able to treat a function as a
945 // graph of basic blocks... and to walk it in inverse order. Inverse order for
946 // a function is considered to be when traversing the predecessor edges of a BB
947 // instead of the successor edges.
948 //
949 template <> struct GraphTraits<Inverse<MachineFunction*>> :
952  return &G.Graph->front();
953  }
954 };
955 template <> struct GraphTraits<Inverse<const MachineFunction*>> :
958  return &G.Graph->front();
959  }
960 };
961 
962 } // end namespace llvm
963 
964 #endif // LLVM_CODEGEN_MACHINEFUNCTION_H
void push_front(MachineBasicBlock *MBB)
Pass interface - Implemented by all &#39;passes&#39;.
Definition: Pass.h:81
ArrayRef< std::pair< MCSymbol *, MDNode * > > getCodeViewAnnotations() const
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
The MachineConstantPool class keeps track of constants referenced by a function which must be spilled...
bool hasCallSiteLandingPad(MCSymbol *Sym)
Return true if the landing pad Eh symbol has an associated call site.
static BasicBlockListType MachineFunction::* getSublistAccess(MachineBasicBlock *)
Support for MachineBasicBlock::getNextNode().
unsigned getFunctionNumber() const
getFunctionNumber - Return a unique ID for the current function.
Atomic ordering constants.
iterator erase(iterator where)
Definition: ilist.h:267
const std::vector< MCCFIInstruction > & getFrameInstructions() const
Returns a reference to a list of cfi instructions in the function&#39;s prologue.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
MachineFunctionProperties & reset(Property P)
Various leaf nodes.
Definition: ISDOpcodes.h:60
void setCallsUnwindInit(bool b)
T * allocate(Capacity Cap, AllocatorType &Allocator)
Allocate an array of at least the requested capacity.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:42
void transferNodesFromList(ilist_callback_traits &OldList, Iterator, Iterator)
unsigned getNumBlockIDs() const
getNumBlockIDs - Return the number of MBB ID&#39;s allocated.
static nodes_iterator nodes_end(MachineFunction *F)
void setHasEHFunclets(bool V)
const Function * FilterOrFinally
Filter or finally function. Null indicates a catch-all.
const MachineFunctionProperties & getProperties() const
Get the function properties.
void addLandingPadInfo(const LandingPadInst &I, MachineBasicBlock &MBB)
Extract the exception handling information from the landingpad instruction and add them to the specif...
unsigned size() const
Describe properties that are true of each instruction in the target description file.
Definition: MCInstrDesc.h:161
This file contains the declarations for metadata subclasses.
unsigned getCallSiteBeginLabel(MCSymbol *BeginLabel) const
Get the call site number for a begin label.
bool test(unsigned Idx) const
Definition: BitVector.h:502
void sort(Comp comp)
A debug info location.
Definition: DebugLoc.h:34
Metadata node.
Definition: Metadata.h:862
F(f)
MachineModuleInfo & getMMI() const
static NodeRef getEntryNode(Inverse< MachineFunction *> G)
static nodes_iterator nodes_begin(const MachineFunction *F)
const MachineConstantPool * getConstantPool() const
VariableDbgInfoMapTy & getVariableDbgInfo()
This file defines the MallocAllocator and BumpPtrAllocator interfaces.
const std::vector< unsigned > & getFilterIds() const
Return a reference to the typeids encoding filters used in the current function.
static nodes_iterator nodes_begin(MachineFunction *F)
MachineFunctionInfo - This class can be derived from and used by targets to hold private target-speci...
The address of a basic block.
Definition: Constants.h:836
A description of a memory reference used in the backend.
MachineJumpTableInfo * getJumpTableInfo()
SmallVector< MCSymbol *, 1 > EndLabels
static unsigned addLiveIn(MachineFunction &MF, unsigned PReg, const TargetRegisterClass *RC)
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
SmallVector< SEHHandler, 1 > SEHHandlers
static StringRef getName(Value *V)
unsigned getAlignment() const
getAlignment - Return the alignment (log2, not bytes) of the function.
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
LLVM_NODISCARD unsigned addFrameInst(const MCCFIInstruction &Inst)
const_iterator end() const
SmallVectorImpl< unsigned > & getCallSiteLandingPad(MCSymbol *Sym)
Get the call site indexes for a landing pad EH symbol.
AtomicOrdering
Atomic ordering for LLVM&#39;s memory model.
Context object for machine code objects.
Definition: MCContext.h:63
This structure is used to retain landing pad info for the current function.
SlotIndexes pass.
Definition: SlotIndexes.h:331
void erase(MachineBasicBlock *MBBI)
PseudoSourceValueManager & getPSVManager() const
void setCallSiteBeginLabel(MCSymbol *BeginLabel, unsigned Site)
Map the begin label for a call site.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
const MachineFrameInfo & getFrameInfo() const
VariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr, int Slot, const DILocation *Loc)
Debug location.
const_iterator begin() const
bool hasCallSiteBeginLabel(MCSymbol *BeginLabel) const
Return true if the begin label has a call site number associated with it.
BasicBlockListType::iterator iterator
ArrayRecycler< MachineOperand >::Capacity OperandCapacity
Synchronized with respect to all concurrently executing threads.
Definition: LLVMContext.h:59
MCContext & getContext() const
Use delete by default for iplist and ilist.
Definition: ilist.h:41
void setHasEHScopes(bool V)
#define P(N)
MachineMemOperand ** mmo_iterator
Definition: MachineInstr.h:64
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:410
typename MachineBasicBlock *::UnknownGraphTypeError NodeRef
Definition: GraphTraits.h:72
MachineBasicBlock * getBlockNumbered(unsigned N) const
getBlockNumbered - MachineBasicBlocks are automatically numbered when they are inserted into the mach...
The landingpad instruction holds all of the information necessary to generate correct exception handl...
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
LLVM Basic Block Representation.
Definition: BasicBlock.h:59
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:140
void push_front(pointer val)
Definition: ilist.h:312
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
bool hasEHFunclets() const
SmallVector< MCSymbol *, 1 > BeginLabels
static NodeRef getEntryNode(MachineFunction *F)
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
const_reverse_iterator rend() const
const MachineRegisterInfo & getRegInfo() const
void ensureAlignment(unsigned A)
ensureAlignment - Make sure the function is at least 1 << A bytes aligned.
bool verifyRequiredProperties(const MachineFunctionProperties &V) const
void splice(iterator where, iplist_impl &L2)
Definition: ilist.h:329
std::vector< int > TypeIds
void setSubtarget(const TargetSubtargetInfo *ST)
static const unsigned End
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
void setHasInlineAsm(bool B)
Set a flag that indicates that the function contains inline assembly.
void splice(iterator InsertPt, iterator MBBI, iterator MBBE)
WinEHFuncInfo * getWinEHFuncInfo()
MachineConstantPool * getConstantPool()
getConstantPool - Return the constant pool object for the current function.
const Ty * getInfo() const
uint32_t * allocateRegisterMask(unsigned NumRegister)
Allocate and initialize a register mask with NumRegister bits.
const MachineBasicBlock & front() const
MachineBasicBlock & back()
An intrusive list with ownership and callbacks specified/controlled by ilist_traits, only with API safe for polymorphic types.
Definition: ilist.h:390
This class contains a discriminated union of information about pointers in memory operands...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool verify(const TargetRegisterInfo &TRI) const
Check that information hold by this instance make sense for the given TRI.
const STC & getSubtarget() const
getSubtarget - This method returns a pointer to the specified type of TargetSubtargetInfo.
const std::vector< LandingPadInfo > & getLandingPads() const
Return a reference to the landing pad info for the current function.
Basic Register Allocator
print lazy value Lazy Value Info Printer Pass
Iterator for intrusive lists based on ilist_node.
const GraphType & Graph
Definition: GraphTraits.h:90
Recycler - This class manages a linked-list of deallocated nodes and facilitates reusing deallocated ...
Definition: Recycler.h:35
void splice(iterator InsertPt, iterator MBBI)
WasmEHFuncInfo * getWasmEHFuncInfo()
MachineOperand class - Representation of each machine instruction operand.
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
const DataFlowGraph & G
Definition: RDFGraph.cpp:211
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:642
void setCallsEHReturn(bool b)
MachineFunctionProperties & getProperties()
const WinEHFuncInfo * getWinEHFuncInfo() const
getWinEHFuncInfo - Return information about how the current function uses Windows exception handling...
bool callsUnwindInit() const
static void deleteNode(NodeTy *V)
Definition: ilist.h:42
DWARF expression.
const Function & getFunction() const
Return the LLVM function that this machine code represents.
reverse_iterator rend()
bool callsEHReturn() const
void splice(iterator InsertPt, MachineBasicBlock *MBB)
MachineFunctionProperties & reset()
Reset all the properties.
Target - Wrapper for Target specific information.
void push_back(pointer val)
Definition: ilist.h:313
static void clear(coro::Shape &Shape)
Definition: Coroutines.cpp:211
static unsigned size(MachineFunction *F)
MachineBasicBlock * LandingPadBlock
FunctionNumber(functionNumber)
Definition: LLParser.cpp:2639
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.
const WasmEHFuncInfo * getWasmEHFuncInfo() const
getWasmEHFuncInfo - Return information about how the current function uses Wasm exception handling...
Representation of each machine instruction.
Definition: MachineInstr.h:60
pointer remove(iterator &IT)
Definition: ilist.h:251
bool hasValue() const
Definition: Optional.h:183
static Ty * create(BumpPtrAllocator &Allocator, MachineFunction &MF)
Factory function: default behavior is to call new using the supplied allocator.
void reset()
Reset the instance as if it was just created.
iterator insert(iterator where, pointer New)
Definition: ilist.h:228
static unsigned size(const MachineFunction *F)
void emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:653
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
bool exposesReturnsTwice() const
exposesReturnsTwice - Returns true if the function calls setjmp or any other similar functions with a...
LandingPadInfo(MachineBasicBlock *MBB)
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
bool hasInlineAsm() const
Returns true if the function contains any inline assembly.
const MachineBasicBlock & back() const
MachineBasicBlock & front()
void setExposesReturnsTwice(bool B)
setCallsSetJmp - Set a flag that indicates if there&#39;s a call to a "returns twice" function...
void removeFromMBBNumbering(unsigned N)
removeFromMBBNumbering - Remove the specific machine basic block from our tracker, this is only really to be used by the MachineBasicBlock implementation.
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:141
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:181
#define LLVM_NODISCARD
LLVM_NODISCARD - Warn if a type or return value is discarded.
Definition: Compiler.h:126
static NodeRef getEntryNode(const MachineFunction *F)
void erase(iterator MBBI)
const_reverse_iterator rbegin() const
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool hasProperty(Property P) const
void insert(iterator MBBI, MachineBasicBlock *MBB)
static nodes_iterator nodes_end(const MachineFunction *F)
MachineFunctionProperties & reset(const MachineFunctionProperties &MFP)
aarch64 promote const
unsigned addToMBBNumbering(MachineBasicBlock *MBB)
Adds the MBB to the internal numbering.
void deallocateOperandArray(OperandCapacity Cap, MachineOperand *Array)
Dellocate an array of MachineOperands and recycle the memory.
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
void push_back(MachineBasicBlock *MBB)
const BlockAddress * RecoverBA
Address of block to recover at. Null for a finally handler.
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E&#39;s largest value.
Definition: BitmaskEnum.h:81
void setAlignment(unsigned A)
setAlignment - Set the alignment (log2, not bytes) of the function.
static NodeRef getEntryNode(Inverse< const MachineFunction *> G)
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
Callbacks do nothing by default in iplist and ilist.
Definition: ilist.h:65
const VariableDbgInfoMapTy & getVariableDbgInfo() const
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:59
void deallocate(Capacity Cap, T *Ptr)
Deallocate an array with the specified Capacity.
IRTranslator LLVM IR MI
Manages creation of pseudo source values.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
void addCodeViewAnnotation(MCSymbol *Label, MDNode *MD)
Record annotations associated with a particular label.
const std::vector< const GlobalValue * > & getTypeInfos() const
Return a reference to the C++ typeinfo for the current function.
const MachineJumpTableInfo * getJumpTableInfo() const
getJumpTableInfo - Return the jump table info object for the current function.
void setVariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr, int Slot, const DILocation *Loc)
Collect information used to emit debugging information of a variable.
reverse_iterator rbegin()
VariableDbgInfoMapTy VariableDbgInfos
MachineOperand * allocateOperandArray(OperandCapacity Cap)
Allocate an array of MachineOperands.
Properties which a MachineFunction may have at a given point in time.
This class contains meta information specific to a module.