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