LLVM  14.0.0git
MachineFunction.h
Go to the documentation of this file.
1 //===- llvm/CodeGen/MachineFunction.h ---------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Collect native machine code for a function. This class contains a list of
10 // MachineBasicBlock instances that make up the current compiled function.
11 //
12 // This class also contains pointers to various classes which hold
13 // target-specific information about the generated code.
14 //
15 //===----------------------------------------------------------------------===//
16 
17 #ifndef LLVM_CODEGEN_MACHINEFUNCTION_H
18 #define LLVM_CODEGEN_MACHINEFUNCTION_H
19 
20 #include "llvm/ADT/ArrayRef.h"
21 #include "llvm/ADT/BitVector.h"
22 #include "llvm/ADT/DenseMap.h"
23 #include "llvm/ADT/GraphTraits.h"
24 #include "llvm/ADT/SmallVector.h"
25 #include "llvm/ADT/ilist.h"
26 #include "llvm/ADT/iterator.h"
31 #include "llvm/Support/Allocator.h"
34 #include "llvm/Support/Compiler.h"
35 #include "llvm/Support/Recycler.h"
37 #include <cassert>
38 #include <cstdint>
39 #include <memory>
40 #include <utility>
41 #include <vector>
42 
43 namespace llvm {
44 
45 class BasicBlock;
46 class BlockAddress;
47 class DataLayout;
48 class DebugLoc;
49 struct DenormalMode;
50 class DIExpression;
51 class DILocalVariable;
52 class DILocation;
53 class Function;
54 class GISelChangeObserver;
55 class GlobalValue;
56 class LLVMTargetMachine;
57 class MachineConstantPool;
58 class MachineFrameInfo;
59 class MachineFunction;
60 class MachineJumpTableInfo;
61 class MachineModuleInfo;
62 class MachineRegisterInfo;
63 class MCContext;
64 class MCInstrDesc;
65 class MCSymbol;
66 class MCSection;
67 class Pass;
68 class PseudoSourceValueManager;
69 class raw_ostream;
70 class SlotIndexes;
71 class StringRef;
72 class TargetRegisterClass;
73 class TargetSubtargetInfo;
74 struct WasmEHFuncInfo;
75 struct WinEHFuncInfo;
76 
79 };
80 
84 
85  template <class Iterator>
86  void transferNodesFromList(ilist_callback_traits &OldList, Iterator, Iterator) {
87  assert(this == &OldList && "never transfer MBBs between functions");
88  }
89 };
90 
91 /// MachineFunctionInfo - This class can be derived from and used by targets to
92 /// hold private target-specific information for each MachineFunction. Objects
93 /// of type are accessed/created with MF::getInfo and destroyed when the
94 /// MachineFunction is destroyed.
96  virtual ~MachineFunctionInfo();
97 
98  /// Factory function: default behavior is to call new using the
99  /// supplied allocator.
100  ///
101  /// This function can be overridden in a derive class.
102  template<typename Ty>
104  return new (Allocator.Allocate<Ty>()) Ty(MF);
105  }
106 };
107 
108 /// Properties which a MachineFunction may have at a given point in time.
109 /// Each of these has checking code in the MachineVerifier, and passes can
110 /// require that a property be set.
112  // Possible TODO: Allow targets to extend this (perhaps by allowing the
113  // constructor to specify the size of the bit vector)
114  // Possible TODO: Allow requiring the negative (e.g. VRegsAllocated could be
115  // stated as the negative of "has vregs"
116 
117 public:
118  // The properties are stated in "positive" form; i.e. a pass could require
119  // that the property hold, but not that it does not hold.
120 
121  // Property descriptions:
122  // IsSSA: True when the machine function is in SSA form and virtual registers
123  // have a single def.
124  // NoPHIs: The machine function does not contain any PHI instruction.
125  // TracksLiveness: True when tracking register liveness accurately.
126  // While this property is set, register liveness information in basic block
127  // live-in lists and machine instruction operands (e.g. implicit defs) is
128  // accurate, kill flags are conservatively accurate (kill flag correctly
129  // indicates the last use of a register, an operand without kill flag may or
130  // may not be the last use of a register). This means it can be used to
131  // change the code in ways that affect the values in registers, for example
132  // by the register scavenger.
133  // When this property is cleared at a very late time, liveness is no longer
134  // reliable.
135  // NoVRegs: The machine function does not use any virtual registers.
136  // Legalized: In GlobalISel: the MachineLegalizer ran and all pre-isel generic
137  // instructions have been legalized; i.e., all instructions are now one of:
138  // - generic and always legal (e.g., COPY)
139  // - target-specific
140  // - legal pre-isel generic instructions.
141  // RegBankSelected: In GlobalISel: the RegBankSelect pass ran and all generic
142  // virtual registers have been assigned to a register bank.
143  // Selected: In GlobalISel: the InstructionSelect pass ran and all pre-isel
144  // generic instructions have been eliminated; i.e., all instructions are now
145  // target-specific or non-pre-isel generic instructions (e.g., COPY).
146  // Since only pre-isel generic instructions can have generic virtual register
147  // operands, this also means that all generic virtual registers have been
148  // constrained to virtual registers (assigned to register classes) and that
149  // all sizes attached to them have been eliminated.
150  // TiedOpsRewritten: The twoaddressinstruction pass will set this flag, it
151  // means that tied-def have been rewritten to meet the RegConstraint.
152  enum class Property : unsigned {
153  IsSSA,
154  NoPHIs,
156  NoVRegs,
157  FailedISel,
158  Legalized,
160  Selected,
163  };
164 
165  bool hasProperty(Property P) const {
166  return Properties[static_cast<unsigned>(P)];
167  }
168 
170  Properties.set(static_cast<unsigned>(P));
171  return *this;
172  }
173 
175  Properties.reset(static_cast<unsigned>(P));
176  return *this;
177  }
178 
179  /// Reset all the properties.
181  Properties.reset();
182  return *this;
183  }
184 
186  Properties |= MFP.Properties;
187  return *this;
188  }
189 
191  Properties.reset(MFP.Properties);
192  return *this;
193  }
194 
195  // Returns true if all properties set in V (i.e. required by a pass) are set
196  // in this.
198  return !V.Properties.test(Properties);
199  }
200 
201  /// Print the MachineFunctionProperties in human-readable form.
202  void print(raw_ostream &OS) const;
203 
204 private:
205  BitVector Properties =
206  BitVector(static_cast<unsigned>(Property::LastProperty)+1);
207 };
208 
209 struct SEHHandler {
210  /// Filter or finally function. Null indicates a catch-all.
212 
213  /// Address of block to recover at. Null for a finally handler.
215 };
216 
217 /// This structure is used to retain landing pad info for the current function.
219  MachineBasicBlock *LandingPadBlock; // Landing pad block.
220  SmallVector<MCSymbol *, 1> BeginLabels; // Labels prior to invoke.
221  SmallVector<MCSymbol *, 1> EndLabels; // Labels after invoke.
222  SmallVector<SEHHandler, 1> SEHHandlers; // SEH handlers active at this lpad.
223  MCSymbol *LandingPadLabel = nullptr; // Label at beginning of landing pad.
224  std::vector<int> TypeIds; // List of type ids (filters negative).
225 
227  : LandingPadBlock(MBB) {}
228 };
229 
231  Function &F;
232  const LLVMTargetMachine &Target;
233  const TargetSubtargetInfo *STI;
234  MCContext &Ctx;
235  MachineModuleInfo &MMI;
236 
237  // RegInfo - Information about each register in use in the function.
239 
240  // Used to keep track of target-specific per-machine function information for
241  // the target implementation.
242  MachineFunctionInfo *MFInfo;
243 
244  // Keep track of objects allocated on the stack.
245  MachineFrameInfo *FrameInfo;
246 
247  // Keep track of constants which are spilled to memory
249 
250  // Keep track of jump tables for switch instructions
251  MachineJumpTableInfo *JumpTableInfo;
252 
253  // Keep track of the function section.
254  MCSection *Section = nullptr;
255 
256  // Keeps track of Wasm exception handling related data. This will be null for
257  // functions that aren't using a wasm EH personality.
258  WasmEHFuncInfo *WasmEHInfo = nullptr;
259 
260  // Keeps track of Windows exception handling related data. This will be null
261  // for functions that aren't using a funclet-based EH personality.
262  WinEHFuncInfo *WinEHInfo = nullptr;
263 
264  // Function-level unique numbering for MachineBasicBlocks. When a
265  // MachineBasicBlock is inserted into a MachineFunction is it automatically
266  // numbered and this vector keeps track of the mapping from ID's to MBB's.
267  std::vector<MachineBasicBlock*> MBBNumbering;
268 
269  // Unary encoding of basic block symbols is used to reduce size of ".strtab".
270  // Basic block number 'i' gets a prefix of length 'i'. The ith character also
271  // denotes the type of basic block number 'i'. Return blocks are marked with
272  // 'r', landing pads with 'l' and regular blocks with 'a'.
273  std::vector<char> BBSectionsSymbolPrefix;
274 
275  // Pool-allocate MachineFunction-lifetime and IR objects.
276  BumpPtrAllocator Allocator;
277 
278  // Allocation management for instructions in function.
279  Recycler<MachineInstr> InstructionRecycler;
280 
281  // Allocation management for operand arrays on instructions.
282  ArrayRecycler<MachineOperand> OperandRecycler;
283 
284  // Allocation management for basic blocks in function.
285  Recycler<MachineBasicBlock> BasicBlockRecycler;
286 
287  // List of machine basic blocks in function
289  BasicBlockListType BasicBlocks;
290 
291  /// FunctionNumber - This provides a unique ID for each function emitted in
292  /// this translation unit.
293  ///
294  unsigned FunctionNumber;
295 
296  /// Alignment - The alignment of the function.
297  Align Alignment;
298 
299  /// ExposesReturnsTwice - True if the function calls setjmp or related
300  /// functions with attribute "returns twice", but doesn't have
301  /// the attribute itself.
302  /// This is used to limit optimizations which cannot reason
303  /// about the control flow of such functions.
304  bool ExposesReturnsTwice = false;
305 
306  /// True if the function includes any inline assembly.
307  bool HasInlineAsm = false;
308 
309  /// True if any WinCFI instruction have been emitted in this function.
310  bool HasWinCFI = false;
311 
312  /// Current high-level properties of the IR of the function (e.g. is in SSA
313  /// form or whether registers have been allocated)
314  MachineFunctionProperties Properties;
315 
316  // Allocation management for pseudo source values.
317  std::unique_ptr<PseudoSourceValueManager> PSVManager;
318 
319  /// List of moves done by a function's prolog. Used to construct frame maps
320  /// by debug and exception handling consumers.
321  std::vector<MCCFIInstruction> FrameInstructions;
322 
323  /// List of basic blocks immediately following calls to _setjmp. Used to
324  /// construct a table of valid longjmp targets for Windows Control Flow Guard.
325  std::vector<MCSymbol *> LongjmpTargets;
326 
327  /// List of basic blocks that are the target of catchrets. Used to construct
328  /// a table of valid targets for Windows EHCont Guard.
329  std::vector<MCSymbol *> CatchretTargets;
330 
331  /// \name Exception Handling
332  /// \{
333 
334  /// List of LandingPadInfo describing the landing pad information.
335  std::vector<LandingPadInfo> LandingPads;
336 
337  /// Map a landing pad's EH symbol to the call site indexes.
339 
340  /// Map a landing pad to its index.
342 
343  /// Map of invoke call site index values to associated begin EH_LABEL.
344  DenseMap<MCSymbol*, unsigned> CallSiteMap;
345 
346  /// CodeView label annotations.
347  std::vector<std::pair<MCSymbol *, MDNode *>> CodeViewAnnotations;
348 
349  bool CallsEHReturn = false;
350  bool CallsUnwindInit = false;
351  bool HasEHCatchret = false;
352  bool HasEHScopes = false;
353  bool HasEHFunclets = false;
354 
355  /// Section Type for basic blocks, only relevant with basic block sections.
357 
358  /// List of C++ TypeInfo used.
359  std::vector<const GlobalValue *> TypeInfos;
360 
361  /// List of typeids encoding filters used.
362  std::vector<unsigned> FilterIds;
363 
364  /// List of the indices in FilterIds corresponding to filter terminators.
365  std::vector<unsigned> FilterEnds;
366 
367  EHPersonality PersonalityTypeCache = EHPersonality::Unknown;
368 
369  /// \}
370 
371  /// Clear all the members of this MachineFunction, but the ones used
372  /// to initialize again the MachineFunction.
373  /// More specifically, this deallocates all the dynamically allocated
374  /// objects and get rid of all the XXXInfo data structure, but keep
375  /// unchanged the references to Fn, Target, MMI, and FunctionNumber.
376  void clear();
377  /// Allocate and initialize the different members.
378  /// In particular, the XXXInfo data structure.
379  /// \pre Fn, Target, MMI, and FunctionNumber are properly set.
380  void init();
381 
382 public:
386  // The Slot can be negative for fixed stack objects.
387  int Slot;
388  const DILocation *Loc;
389 
391  int Slot, const DILocation *Loc)
392  : Var(Var), Expr(Expr), Slot(Slot), Loc(Loc) {}
393  };
394 
395  class Delegate {
396  virtual void anchor();
397 
398  public:
399  virtual ~Delegate() = default;
400  /// Callback after an insertion. This should not modify the MI directly.
401  virtual void MF_HandleInsertion(MachineInstr &MI) = 0;
402  /// Callback before a removal. This should not modify the MI directly.
403  virtual void MF_HandleRemoval(MachineInstr &MI) = 0;
404  };
405 
406  /// Structure used to represent pair of argument number after call lowering
407  /// and register used to transfer that argument.
408  /// For now we support only cases when argument is transferred through one
409  /// register.
410  struct ArgRegPair {
413  ArgRegPair(Register R, unsigned Arg) : Reg(R), ArgNo(Arg) {
414  assert(Arg < (1 << 16) && "Arg out of range");
415  }
416  };
417  /// Vector of call argument and its forwarding register.
420 
421 private:
422  Delegate *TheDelegate = nullptr;
423  GISelChangeObserver *Observer = nullptr;
424 
426  /// Map a call instruction to call site arguments forwarding info.
427  CallSiteInfoMap CallSitesInfo;
428 
429  /// A helper function that returns call site info for a give call
430  /// instruction if debug entry value support is enabled.
431  CallSiteInfoMap::iterator getCallSiteInfo(const MachineInstr *MI);
432 
433  // Callbacks for insertion and removal.
434  void handleInsertion(MachineInstr &MI);
435  void handleRemoval(MachineInstr &MI);
436  friend struct ilist_traits<MachineInstr>;
437 
438 public:
441 
442  /// A count of how many instructions in the function have had numbers
443  /// assigned to them. Used for debug value tracking, to determine the
444  /// next instruction number.
446 
447  /// Set value of DebugInstrNumberingCount field. Avoid using this unless
448  /// you're deserializing this data.
449  void setDebugInstrNumberingCount(unsigned Num);
450 
451  /// Pair of instruction number and operand number.
452  using DebugInstrOperandPair = std::pair<unsigned, unsigned>;
453 
454  /// Replacement definition for a debug instruction reference. Made up of a
455  /// source instruction / operand pair, destination pair, and a qualifying
456  /// subregister indicating what bits in the operand make up the substitution.
457  // For example, a debug user
458  /// of %1:
459  /// %0:gr32 = someinst, debug-instr-number 1
460  /// %1:gr16 = %0.some_16_bit_subreg, debug-instr-number 2
461  /// Would receive the substitution {{2, 0}, {1, 0}, $subreg}, where $subreg is
462  /// the subregister number for some_16_bit_subreg.
464  public:
465  DebugInstrOperandPair Src; ///< Source instruction / operand pair.
466  DebugInstrOperandPair Dest; ///< Replacement instruction / operand pair.
467  unsigned Subreg; ///< Qualifier for which part of Dest is read.
468 
470  const DebugInstrOperandPair &Dest, unsigned Subreg)
471  : Src(Src), Dest(Dest), Subreg(Subreg) {}
472 
473  /// Order only by source instruction / operand pair: there should never
474  /// be duplicate entries for the same source in any collection.
475  bool operator<(const DebugSubstitution &Other) const {
476  return Src < Other.Src;
477  }
478  };
479 
480  /// Debug value substitutions: a collection of DebugSubstitution objects,
481  /// recording changes in where a value is defined. For example, when one
482  /// instruction is substituted for another. Keeping a record allows recovery
483  /// of variable locations after compilation finishes.
485 
486  /// Location of a PHI instruction that is also a debug-info variable value,
487  /// for the duration of register allocation. Loaded by the PHI-elimination
488  /// pass, and emitted as DBG_PHI instructions during VirtRegRewriter, with
489  /// maintenance applied by intermediate passes that edit registers (such as
490  /// coalescing and the allocator passes).
492  public:
493  MachineBasicBlock *MBB; ///< Block where this PHI was originally located.
494  Register Reg; ///< VReg where the control-flow-merge happens.
495  unsigned SubReg; ///< Optional subreg qualifier within Reg.
497  : MBB(MBB), Reg(Reg), SubReg(SubReg) {}
498  };
499 
500  /// Map of debug instruction numbers to the position of their PHI instructions
501  /// during register allocation. See DebugPHIRegallocPos.
503 
504  /// Create a substitution between one <instr,operand> value to a different,
505  /// new value.
507  unsigned SubReg = 0);
508 
509  /// Create substitutions for any tracked values in \p Old, to point at
510  /// \p New. Needed when we re-create an instruction during optimization,
511  /// which has the same signature (i.e., def operands in the same place) but
512  /// a modified instruction type, flags, or otherwise. An example: X86 moves
513  /// are sometimes transformed into equivalent LEAs.
514  /// If the two instructions are not the same opcode, limit which operands to
515  /// examine for substitutions to the first N operands by setting
516  /// \p MaxOperand.
518  unsigned MaxOperand = UINT_MAX);
519 
520  /// Find the underlying defining instruction / operand for a COPY instruction
521  /// while in SSA form. Copies do not actually define values -- they move them
522  /// between registers. Labelling a COPY-like instruction with an instruction
523  /// number is to be avoided as it makes value numbers non-unique later in
524  /// compilation. This method follows the definition chain for any sequence of
525  /// COPY-like instructions to find whatever non-COPY-like instruction defines
526  /// the copied value; or for parameters, creates a DBG_PHI on entry.
527  /// May insert instructions into the entry block!
528  /// \p MI The copy-like instruction to salvage.
529  /// \returns An instruction/operand pair identifying the defining value.
531 
532  /// Finalise any partially emitted debug instructions. These are DBG_INSTR_REF
533  /// instructions where we only knew the vreg of the value they use, not the
534  /// instruction that defines that vreg. Once isel finishes, we should have
535  /// enough information for every DBG_INSTR_REF to point at an instruction
536  /// (or DBG_PHI).
537  void finalizeDebugInstrRefs();
538 
540  const TargetSubtargetInfo &STI, unsigned FunctionNum,
541  MachineModuleInfo &MMI);
542  MachineFunction(const MachineFunction &) = delete;
543  MachineFunction &operator=(const MachineFunction &) = delete;
545 
546  /// Reset the instance as if it was just created.
547  void reset() {
548  clear();
549  init();
550  }
551 
552  /// Reset the currently registered delegate - otherwise assert.
553  void resetDelegate(Delegate *delegate) {
554  assert(TheDelegate == delegate &&
555  "Only the current delegate can perform reset!");
556  TheDelegate = nullptr;
557  }
558 
559  /// Set the delegate. resetDelegate must be called before attempting
560  /// to set.
561  void setDelegate(Delegate *delegate) {
562  assert(delegate && !TheDelegate &&
563  "Attempted to set delegate to null, or to change it without "
564  "first resetting it!");
565 
566  TheDelegate = delegate;
567  }
568 
569  void setObserver(GISelChangeObserver *O) { Observer = O; }
570 
571  GISelChangeObserver *getObserver() const { return Observer; }
572 
573  MachineModuleInfo &getMMI() const { return MMI; }
574  MCContext &getContext() const { return Ctx; }
575 
576  /// Returns the Section this function belongs to.
577  MCSection *getSection() const { return Section; }
578 
579  /// Indicates the Section this function belongs to.
580  void setSection(MCSection *S) { Section = S; }
581 
582  PseudoSourceValueManager &getPSVManager() const { return *PSVManager; }
583 
584  /// Return the DataLayout attached to the Module associated to this MF.
585  const DataLayout &getDataLayout() const;
586 
587  /// Return the LLVM function that this machine code represents
588  Function &getFunction() { return F; }
589 
590  /// Return the LLVM function that this machine code represents
591  const Function &getFunction() const { return F; }
592 
593  /// getName - Return the name of the corresponding LLVM function.
594  StringRef getName() const;
595 
596  /// getFunctionNumber - Return a unique ID for the current function.
597  unsigned getFunctionNumber() const { return FunctionNumber; }
598 
599  /// Returns true if this function has basic block sections enabled.
600  bool hasBBSections() const {
601  return (BBSectionsType == BasicBlockSection::All ||
602  BBSectionsType == BasicBlockSection::List ||
603  BBSectionsType == BasicBlockSection::Preset);
604  }
605 
606  /// Returns true if basic block labels are to be generated for this function.
607  bool hasBBLabels() const {
608  return BBSectionsType == BasicBlockSection::Labels;
609  }
610 
611  void setBBSectionsType(BasicBlockSection V) { BBSectionsType = V; }
612 
613  /// Assign IsBeginSection IsEndSection fields for basic blocks in this
614  /// function.
615  void assignBeginEndSections();
616 
617  /// getTarget - Return the target machine this machine code is compiled with
618  const LLVMTargetMachine &getTarget() const { return Target; }
619 
620  /// getSubtarget - Return the subtarget for which this machine code is being
621  /// compiled.
622  const TargetSubtargetInfo &getSubtarget() const { return *STI; }
623 
624  /// getSubtarget - This method returns a pointer to the specified type of
625  /// TargetSubtargetInfo. In debug builds, it verifies that the object being
626  /// returned is of the correct type.
627  template<typename STC> const STC &getSubtarget() const {
628  return *static_cast<const STC *>(STI);
629  }
630 
631  /// getRegInfo - Return information about the registers currently in use.
633  const MachineRegisterInfo &getRegInfo() const { return *RegInfo; }
634 
635  /// getFrameInfo - Return the frame info object for the current function.
636  /// This object contains information about objects allocated on the stack
637  /// frame of the current function in an abstract way.
638  MachineFrameInfo &getFrameInfo() { return *FrameInfo; }
639  const MachineFrameInfo &getFrameInfo() const { return *FrameInfo; }
640 
641  /// getJumpTableInfo - Return the jump table info object for the current
642  /// function. This object contains information about jump tables in the
643  /// current function. If the current function has no jump tables, this will
644  /// return null.
645  const MachineJumpTableInfo *getJumpTableInfo() const { return JumpTableInfo; }
646  MachineJumpTableInfo *getJumpTableInfo() { return JumpTableInfo; }
647 
648  /// getOrCreateJumpTableInfo - Get the JumpTableInfo for this function, if it
649  /// does already exist, allocate one.
650  MachineJumpTableInfo *getOrCreateJumpTableInfo(unsigned JTEntryKind);
651 
652  /// getConstantPool - Return the constant pool object for the current
653  /// function.
656 
657  /// getWasmEHFuncInfo - Return information about how the current function uses
658  /// Wasm exception handling. Returns null for functions that don't use wasm
659  /// exception handling.
660  const WasmEHFuncInfo *getWasmEHFuncInfo() const { return WasmEHInfo; }
661  WasmEHFuncInfo *getWasmEHFuncInfo() { return WasmEHInfo; }
662 
663  /// getWinEHFuncInfo - Return information about how the current function uses
664  /// Windows exception handling. Returns null for functions that don't use
665  /// funclets for exception handling.
666  const WinEHFuncInfo *getWinEHFuncInfo() const { return WinEHInfo; }
667  WinEHFuncInfo *getWinEHFuncInfo() { return WinEHInfo; }
668 
669  /// getAlignment - Return the alignment of the function.
670  Align getAlignment() const { return Alignment; }
671 
672  /// setAlignment - Set the alignment of the function.
673  void setAlignment(Align A) { Alignment = A; }
674 
675  /// ensureAlignment - Make sure the function is at least A bytes aligned.
677  if (Alignment < A)
678  Alignment = A;
679  }
680 
681  /// exposesReturnsTwice - Returns true if the function calls setjmp or
682  /// any other similar functions with attribute "returns twice" without
683  /// having the attribute itself.
684  bool exposesReturnsTwice() const {
685  return ExposesReturnsTwice;
686  }
687 
688  /// setCallsSetJmp - Set a flag that indicates if there's a call to
689  /// a "returns twice" function.
691  ExposesReturnsTwice = B;
692  }
693 
694  /// Returns true if the function contains any inline assembly.
695  bool hasInlineAsm() const {
696  return HasInlineAsm;
697  }
698 
699  /// Set a flag that indicates that the function contains inline assembly.
700  void setHasInlineAsm(bool B) {
701  HasInlineAsm = B;
702  }
703 
704  bool hasWinCFI() const {
705  return HasWinCFI;
706  }
707  void setHasWinCFI(bool v) { HasWinCFI = v; }
708 
709  /// True if this function needs frame moves for debug or exceptions.
710  bool needsFrameMoves() const;
711 
712  /// Get the function properties
713  const MachineFunctionProperties &getProperties() const { return Properties; }
714  MachineFunctionProperties &getProperties() { return Properties; }
715 
716  /// getInfo - Keep track of various per-function pieces of information for
717  /// backends that would like to do so.
718  ///
719  template<typename Ty>
720  Ty *getInfo() {
721  if (!MFInfo)
722  MFInfo = Ty::template create<Ty>(Allocator, *this);
723  return static_cast<Ty*>(MFInfo);
724  }
725 
726  template<typename Ty>
727  const Ty *getInfo() const {
728  return const_cast<MachineFunction*>(this)->getInfo<Ty>();
729  }
730 
731  /// Returns the denormal handling type for the default rounding mode of the
732  /// function.
733  DenormalMode getDenormalMode(const fltSemantics &FPType) const;
734 
735  /// getBlockNumbered - MachineBasicBlocks are automatically numbered when they
736  /// are inserted into the machine function. The block number for a machine
737  /// basic block can be found by using the MBB::getNumber method, this method
738  /// provides the inverse mapping.
740  assert(N < MBBNumbering.size() && "Illegal block number");
741  assert(MBBNumbering[N] && "Block was removed from the machine function!");
742  return MBBNumbering[N];
743  }
744 
745  /// Should we be emitting segmented stack stuff for the function
746  bool shouldSplitStack() const;
747 
748  /// getNumBlockIDs - Return the number of MBB ID's allocated.
749  unsigned getNumBlockIDs() const { return (unsigned)MBBNumbering.size(); }
750 
751  /// RenumberBlocks - This discards all of the MachineBasicBlock numbers and
752  /// recomputes them. This guarantees that the MBB numbers are sequential,
753  /// dense, and match the ordering of the blocks within the function. If a
754  /// specific MachineBasicBlock is specified, only that block and those after
755  /// it are renumbered.
756  void RenumberBlocks(MachineBasicBlock *MBBFrom = nullptr);
757 
758  /// print - Print out the MachineFunction in a format suitable for debugging
759  /// to the specified stream.
760  void print(raw_ostream &OS, const SlotIndexes* = nullptr) const;
761 
762  /// viewCFG - This function is meant for use from the debugger. You can just
763  /// say 'call F->viewCFG()' and a ghostview window should pop up from the
764  /// program, displaying the CFG of the current function with the code for each
765  /// basic block inside. This depends on there being a 'dot' and 'gv' program
766  /// in your path.
767  void viewCFG() const;
768 
769  /// viewCFGOnly - This function is meant for use from the debugger. It works
770  /// just like viewCFG, but it does not include the contents of basic blocks
771  /// into the nodes, just the label. If you are only interested in the CFG
772  /// this can make the graph smaller.
773  ///
774  void viewCFGOnly() const;
775 
776  /// dump - Print the current MachineFunction to cerr, useful for debugger use.
777  void dump() const;
778 
779  /// Run the current MachineFunction through the machine code verifier, useful
780  /// for debugger use.
781  /// \returns true if no problems were found.
782  bool verify(Pass *p = nullptr, const char *Banner = nullptr,
783  bool AbortOnError = true) const;
784 
785  // Provide accessors for the MachineBasicBlock list...
790 
791  /// Support for MachineBasicBlock::getNextNode().
794  return &MachineFunction::BasicBlocks;
795  }
796 
797  /// addLiveIn - Add the specified physical register as a live-in value and
798  /// create a corresponding virtual register for it.
800 
801  //===--------------------------------------------------------------------===//
802  // BasicBlock accessor functions.
803  //
804  iterator begin() { return BasicBlocks.begin(); }
805  const_iterator begin() const { return BasicBlocks.begin(); }
806  iterator end () { return BasicBlocks.end(); }
807  const_iterator end () const { return BasicBlocks.end(); }
808 
809  reverse_iterator rbegin() { return BasicBlocks.rbegin(); }
810  const_reverse_iterator rbegin() const { return BasicBlocks.rbegin(); }
811  reverse_iterator rend () { return BasicBlocks.rend(); }
812  const_reverse_iterator rend () const { return BasicBlocks.rend(); }
813 
814  unsigned size() const { return (unsigned)BasicBlocks.size();}
815  bool empty() const { return BasicBlocks.empty(); }
816  const MachineBasicBlock &front() const { return BasicBlocks.front(); }
817  MachineBasicBlock &front() { return BasicBlocks.front(); }
818  const MachineBasicBlock & back() const { return BasicBlocks.back(); }
819  MachineBasicBlock & back() { return BasicBlocks.back(); }
820 
821  void push_back (MachineBasicBlock *MBB) { BasicBlocks.push_back (MBB); }
822  void push_front(MachineBasicBlock *MBB) { BasicBlocks.push_front(MBB); }
824  BasicBlocks.insert(MBBI, MBB);
825  }
826  void splice(iterator InsertPt, iterator MBBI) {
827  BasicBlocks.splice(InsertPt, BasicBlocks, MBBI);
828  }
830  BasicBlocks.splice(InsertPt, BasicBlocks, MBB);
831  }
832  void splice(iterator InsertPt, iterator MBBI, iterator MBBE) {
833  BasicBlocks.splice(InsertPt, BasicBlocks, MBBI, MBBE);
834  }
835 
836  void remove(iterator MBBI) { BasicBlocks.remove(MBBI); }
837  void remove(MachineBasicBlock *MBBI) { BasicBlocks.remove(MBBI); }
838  void erase(iterator MBBI) { BasicBlocks.erase(MBBI); }
839  void erase(MachineBasicBlock *MBBI) { BasicBlocks.erase(MBBI); }
840 
841  template <typename Comp>
842  void sort(Comp comp) {
843  BasicBlocks.sort(comp);
844  }
845 
846  /// Return the number of \p MachineInstrs in this \p MachineFunction.
847  unsigned getInstructionCount() const {
848  unsigned InstrCount = 0;
849  for (const MachineBasicBlock &MBB : BasicBlocks)
850  InstrCount += MBB.size();
851  return InstrCount;
852  }
853 
854  //===--------------------------------------------------------------------===//
855  // Internal functions used to automatically number MachineBasicBlocks
856 
857  /// Adds the MBB to the internal numbering. Returns the unique number
858  /// assigned to the MBB.
860  MBBNumbering.push_back(MBB);
861  return (unsigned)MBBNumbering.size()-1;
862  }
863 
864  /// removeFromMBBNumbering - Remove the specific machine basic block from our
865  /// tracker, this is only really to be used by the MachineBasicBlock
866  /// implementation.
867  void removeFromMBBNumbering(unsigned N) {
868  assert(N < MBBNumbering.size() && "Illegal basic block #");
869  MBBNumbering[N] = nullptr;
870  }
871 
872  /// CreateMachineInstr - Allocate a new MachineInstr. Use this instead
873  /// of `new MachineInstr'.
875  bool NoImplicit = false);
876 
877  /// Create a new MachineInstr which is a copy of \p Orig, identical in all
878  /// ways except the instruction has no parent, prev, or next. Bundling flags
879  /// are reset.
880  ///
881  /// Note: Clones a single instruction, not whole instruction bundles.
882  /// Does not perform target specific adjustments; consider using
883  /// TargetInstrInfo::duplicate() instead.
885 
886  /// Clones instruction or the whole instruction bundle \p Orig and insert
887  /// into \p MBB before \p InsertBefore.
888  ///
889  /// Note: Does not perform target specific adjustments; consider using
890  /// TargetInstrInfo::duplicate() intead.
892  MachineBasicBlock::iterator InsertBefore, const MachineInstr &Orig);
893 
894  /// DeleteMachineInstr - Delete the given MachineInstr.
896 
897  /// CreateMachineBasicBlock - Allocate a new MachineBasicBlock. Use this
898  /// instead of `new MachineBasicBlock'.
900 
901  /// DeleteMachineBasicBlock - Delete the given MachineBasicBlock.
903 
904  /// getMachineMemOperand - Allocate a new MachineMemOperand.
905  /// MachineMemOperands are owned by the MachineFunction and need not be
906  /// explicitly deallocated.
908  MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s,
909  Align base_alignment, const AAMDNodes &AAInfo = AAMDNodes(),
910  const MDNode *Ranges = nullptr, SyncScope::ID SSID = SyncScope::System,
912  AtomicOrdering FailureOrdering = AtomicOrdering::NotAtomic);
913 
916  Align base_alignment, const AAMDNodes &AAInfo = AAMDNodes(),
917  const MDNode *Ranges = nullptr, SyncScope::ID SSID = SyncScope::System,
919  AtomicOrdering FailureOrdering = AtomicOrdering::NotAtomic);
920 
921  /// getMachineMemOperand - Allocate a new MachineMemOperand by copying
922  /// an existing one, adjusting by an offset and using the given size.
923  /// MachineMemOperands are owned by the MachineFunction and need not be
924  /// explicitly deallocated.
926  int64_t Offset, LLT Ty);
928  int64_t Offset, uint64_t Size) {
929  return getMachineMemOperand(MMO, Offset, LLT::scalar(8 * Size));
930  }
931 
932  /// getMachineMemOperand - Allocate a new MachineMemOperand by copying
933  /// an existing one, replacing only the MachinePointerInfo and size.
934  /// MachineMemOperands are owned by the MachineFunction and need not be
935  /// explicitly deallocated.
937  const MachinePointerInfo &PtrInfo,
938  uint64_t Size);
940  const MachinePointerInfo &PtrInfo,
941  LLT Ty);
942 
943  /// Allocate a new MachineMemOperand by copying an existing one,
944  /// replacing only AliasAnalysis information. MachineMemOperands are owned
945  /// by the MachineFunction and need not be explicitly deallocated.
947  const AAMDNodes &AAInfo);
948 
949  /// Allocate a new MachineMemOperand by copying an existing one,
950  /// replacing the flags. MachineMemOperands are owned
951  /// by the MachineFunction and need not be explicitly deallocated.
954 
956 
957  /// Allocate an array of MachineOperands. This is only intended for use by
958  /// internal MachineInstr functions.
960  return OperandRecycler.allocate(Cap, Allocator);
961  }
962 
963  /// Dellocate an array of MachineOperands and recycle the memory. This is
964  /// only intended for use by internal MachineInstr functions.
965  /// Cap must be the same capacity that was used to allocate the array.
967  OperandRecycler.deallocate(Cap, Array);
968  }
969 
970  /// Allocate and initialize a register mask with @p NumRegister bits.
972 
974 
975  /// Allocate and construct an extra info structure for a `MachineInstr`.
976  ///
977  /// This is allocated on the function's allocator and so lives the life of
978  /// the function.
979  MachineInstr::ExtraInfo *createMIExtraInfo(
980  ArrayRef<MachineMemOperand *> MMOs, MCSymbol *PreInstrSymbol = nullptr,
981  MCSymbol *PostInstrSymbol = nullptr, MDNode *HeapAllocMarker = nullptr);
982 
983  /// Allocate a string and populate it with the given external symbol name.
985 
986  //===--------------------------------------------------------------------===//
987  // Label Manipulation.
988 
989  /// getJTISymbol - Return the MCSymbol for the specified non-empty jump table.
990  /// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
991  /// normal 'L' label is returned.
992  MCSymbol *getJTISymbol(unsigned JTI, MCContext &Ctx,
993  bool isLinkerPrivate = false) const;
994 
995  /// getPICBaseSymbol - Return a function-local symbol to represent the PIC
996  /// base.
997  MCSymbol *getPICBaseSymbol() const;
998 
999  /// Returns a reference to a list of cfi instructions in the function's
1000  /// prologue. Used to construct frame maps for debug and exception handling
1001  /// comsumers.
1002  const std::vector<MCCFIInstruction> &getFrameInstructions() const {
1003  return FrameInstructions;
1004  }
1005 
1006  LLVM_NODISCARD unsigned addFrameInst(const MCCFIInstruction &Inst);
1007 
1008  /// Returns a reference to a list of symbols immediately following calls to
1009  /// _setjmp in the function. Used to construct the longjmp target table used
1010  /// by Windows Control Flow Guard.
1011  const std::vector<MCSymbol *> &getLongjmpTargets() const {
1012  return LongjmpTargets;
1013  }
1014 
1015  /// Add the specified symbol to the list of valid longjmp targets for Windows
1016  /// Control Flow Guard.
1017  void addLongjmpTarget(MCSymbol *Target) { LongjmpTargets.push_back(Target); }
1018 
1019  /// Returns a reference to a list of symbols that we have catchrets.
1020  /// Used to construct the catchret target table used by Windows EHCont Guard.
1021  const std::vector<MCSymbol *> &getCatchretTargets() const {
1022  return CatchretTargets;
1023  }
1024 
1025  /// Add the specified symbol to the list of valid catchret targets for Windows
1026  /// EHCont Guard.
1028  CatchretTargets.push_back(Target);
1029  }
1030 
1031  /// \name Exception Handling
1032  /// \{
1033 
1034  bool callsEHReturn() const { return CallsEHReturn; }
1035  void setCallsEHReturn(bool b) { CallsEHReturn = b; }
1036 
1037  bool callsUnwindInit() const { return CallsUnwindInit; }
1038  void setCallsUnwindInit(bool b) { CallsUnwindInit = b; }
1039 
1040  bool hasEHCatchret() const { return HasEHCatchret; }
1041  void setHasEHCatchret(bool V) { HasEHCatchret = V; }
1042 
1043  bool hasEHScopes() const { return HasEHScopes; }
1044  void setHasEHScopes(bool V) { HasEHScopes = V; }
1045 
1046  bool hasEHFunclets() const { return HasEHFunclets; }
1047  void setHasEHFunclets(bool V) { HasEHFunclets = V; }
1048 
1049  /// Find or create an LandingPadInfo for the specified MachineBasicBlock.
1051 
1052  /// Remap landing pad labels and remove any deleted landing pads.
1053  void tidyLandingPads(DenseMap<MCSymbol *, uintptr_t> *LPMap = nullptr,
1054  bool TidyIfNoBeginLabels = true);
1055 
1056  /// Return a reference to the landing pad info for the current function.
1057  const std::vector<LandingPadInfo> &getLandingPads() const {
1058  return LandingPads;
1059  }
1060 
1061  /// Provide the begin and end labels of an invoke style call and associate it
1062  /// with a try landing pad block.
1063  void addInvoke(MachineBasicBlock *LandingPad,
1064  MCSymbol *BeginLabel, MCSymbol *EndLabel);
1065 
1066  /// Add a new panding pad, and extract the exception handling information from
1067  /// the landingpad instruction. Returns the label ID for the landing pad
1068  /// entry.
1070 
1071  /// Provide the catch typeinfo for a landing pad.
1072  void addCatchTypeInfo(MachineBasicBlock *LandingPad,
1074 
1075  /// Provide the filter typeinfo for a landing pad.
1076  void addFilterTypeInfo(MachineBasicBlock *LandingPad,
1078 
1079  /// Add a cleanup action for a landing pad.
1080  void addCleanup(MachineBasicBlock *LandingPad);
1081 
1082  void addSEHCatchHandler(MachineBasicBlock *LandingPad, const Function *Filter,
1083  const BlockAddress *RecoverBA);
1084 
1085  void addSEHCleanupHandler(MachineBasicBlock *LandingPad,
1086  const Function *Cleanup);
1087 
1088  /// Return the type id for the specified typeinfo. This is function wide.
1089  unsigned getTypeIDFor(const GlobalValue *TI);
1090 
1091  /// Return the id of the filter encoded by TyIds. This is function wide.
1092  int getFilterIDFor(std::vector<unsigned> &TyIds);
1093 
1094  /// Map the landing pad's EH symbol to the call site indexes.
1096 
1097  /// Map the landing pad to its index. Used for Wasm exception handling.
1098  void setWasmLandingPadIndex(const MachineBasicBlock *LPad, unsigned Index) {
1099  WasmLPadToIndexMap[LPad] = Index;
1100  }
1101 
1102  /// Returns true if the landing pad has an associate index in wasm EH.
1103  bool hasWasmLandingPadIndex(const MachineBasicBlock *LPad) const {
1104  return WasmLPadToIndexMap.count(LPad);
1105  }
1106 
1107  /// Get the index in wasm EH for a given landing pad.
1108  unsigned getWasmLandingPadIndex(const MachineBasicBlock *LPad) const {
1110  return WasmLPadToIndexMap.lookup(LPad);
1111  }
1112 
1113  /// Get the call site indexes for a landing pad EH symbol.
1116  "missing call site number for landing pad!");
1117  return LPadToCallSiteMap[Sym];
1118  }
1119 
1120  /// Return true if the landing pad Eh symbol has an associated call site.
1122  return !LPadToCallSiteMap[Sym].empty();
1123  }
1124 
1125  /// Map the begin label for a call site.
1126  void setCallSiteBeginLabel(MCSymbol *BeginLabel, unsigned Site) {
1127  CallSiteMap[BeginLabel] = Site;
1128  }
1129 
1130  /// Get the call site number for a begin label.
1131  unsigned getCallSiteBeginLabel(MCSymbol *BeginLabel) const {
1132  assert(hasCallSiteBeginLabel(BeginLabel) &&
1133  "Missing call site number for EH_LABEL!");
1134  return CallSiteMap.lookup(BeginLabel);
1135  }
1136 
1137  /// Return true if the begin label has a call site number associated with it.
1138  bool hasCallSiteBeginLabel(MCSymbol *BeginLabel) const {
1139  return CallSiteMap.count(BeginLabel);
1140  }
1141 
1142  /// Record annotations associated with a particular label.
1144  CodeViewAnnotations.push_back({Label, MD});
1145  }
1146 
1148  return CodeViewAnnotations;
1149  }
1150 
1151  /// Return a reference to the C++ typeinfo for the current function.
1152  const std::vector<const GlobalValue *> &getTypeInfos() const {
1153  return TypeInfos;
1154  }
1155 
1156  /// Return a reference to the typeids encoding filters used in the current
1157  /// function.
1158  const std::vector<unsigned> &getFilterIds() const {
1159  return FilterIds;
1160  }
1161 
1162  /// \}
1163 
1164  /// Collect information used to emit debugging information of a variable.
1165  void setVariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr,
1166  int Slot, const DILocation *Loc) {
1167  VariableDbgInfos.emplace_back(Var, Expr, Slot, Loc);
1168  }
1169 
1172  return VariableDbgInfos;
1173  }
1174 
1175  /// Start tracking the arguments passed to the call \p CallI.
1179  bool Inserted =
1180  CallSitesInfo.try_emplace(CallI, std::move(CallInfo)).second;
1181  (void)Inserted;
1182  assert(Inserted && "Call site info not unique");
1183  }
1184 
1186  return CallSitesInfo;
1187  }
1188 
1189  /// Following functions update call site info. They should be called before
1190  /// removing, replacing or copying call instruction.
1191 
1192  /// Erase the call site info for \p MI. It is used to remove a call
1193  /// instruction from the instruction stream.
1194  void eraseCallSiteInfo(const MachineInstr *MI);
1195  /// Copy the call site info from \p Old to \ New. Its usage is when we are
1196  /// making a copy of the instruction that will be inserted at different point
1197  /// of the instruction stream.
1198  void copyCallSiteInfo(const MachineInstr *Old,
1199  const MachineInstr *New);
1200 
1201  const std::vector<char> &getBBSectionsSymbolPrefix() const {
1202  return BBSectionsSymbolPrefix;
1203  }
1204 
1205  /// Move the call site info from \p Old to \New call site info. This function
1206  /// is used when we are replacing one call instruction with another one to
1207  /// the same callee.
1208  void moveCallSiteInfo(const MachineInstr *Old,
1209  const MachineInstr *New);
1210 
1211  unsigned getNewDebugInstrNum() {
1212  return ++DebugInstrNumberingCount;
1213  }
1214 };
1215 
1216 //===--------------------------------------------------------------------===//
1217 // GraphTraits specializations for function basic block graphs (CFGs)
1218 //===--------------------------------------------------------------------===//
1219 
1220 // Provide specializations of GraphTraits to be able to treat a
1221 // machine function as a graph of machine basic blocks... these are
1222 // the same as the machine basic block iterators, except that the root
1223 // node is implicitly the first node of the function.
1224 //
1225 template <> struct GraphTraits<MachineFunction*> :
1227  static NodeRef getEntryNode(MachineFunction *F) { return &F->front(); }
1228 
1229  // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
1231 
1233  return nodes_iterator(F->begin());
1234  }
1235 
1237  return nodes_iterator(F->end());
1238  }
1239 
1240  static unsigned size (MachineFunction *F) { return F->size(); }
1241 };
1242 template <> struct GraphTraits<const MachineFunction*> :
1244  static NodeRef getEntryNode(const MachineFunction *F) { return &F->front(); }
1245 
1246  // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
1248 
1250  return nodes_iterator(F->begin());
1251  }
1252 
1254  return nodes_iterator(F->end());
1255  }
1256 
1257  static unsigned size (const MachineFunction *F) {
1258  return F->size();
1259  }
1260 };
1261 
1262 // Provide specializations of GraphTraits to be able to treat a function as a
1263 // graph of basic blocks... and to walk it in inverse order. Inverse order for
1264 // a function is considered to be when traversing the predecessor edges of a BB
1265 // instead of the successor edges.
1266 //
1267 template <> struct GraphTraits<Inverse<MachineFunction*>> :
1270  return &G.Graph->front();
1271  }
1272 };
1273 template <> struct GraphTraits<Inverse<const MachineFunction*>> :
1276  return &G.Graph->front();
1277  }
1278 };
1279 
1280 class MachineFunctionAnalysisManager;
1281 void verifyMachineFunction(MachineFunctionAnalysisManager *,
1282  const std::string &Banner,
1283  const MachineFunction &MF);
1284 
1285 } // end namespace llvm
1286 
1287 #endif // LLVM_CODEGEN_MACHINEFUNCTION_H
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::MachineFunction::hasWinCFI
bool hasWinCFI() const
Definition: MachineFunction.h:704
llvm::MachineFunction::DebugPHIRegallocPos::MBB
MachineBasicBlock * MBB
Block where this PHI was originally located.
Definition: MachineFunction.h:493
llvm::MachineFunction::remove
void remove(iterator MBBI)
Definition: MachineFunction.h:836
llvm::MachineFunction::hasInlineAsm
bool hasInlineAsm() const
Returns true if the function contains any inline assembly.
Definition: MachineFunction.h:695
llvm::WasmEHFuncInfo
Definition: WasmEHFuncInfo.h:32
llvm::MachineFunction::DebugPHIRegallocPos::SubReg
unsigned SubReg
Optional subreg qualifier within Reg.
Definition: MachineFunction.h:495
llvm::MachineFunctionProperties::hasProperty
bool hasProperty(Property P) const
Definition: MachineFunction.h:165
llvm::MachineFunction::resetDelegate
void resetDelegate(Delegate *delegate)
Reset the currently registered delegate - otherwise assert.
Definition: MachineFunction.h:553
llvm::MachineFunction::getInfo
const Ty * getInfo() const
Definition: MachineFunction.h:727
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:102
MachineInstr.h
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
llvm::MachineFunction::getProperties
MachineFunctionProperties & getProperties()
Definition: MachineFunction.h:714
Pass
print lazy value Lazy Value Info Printer Pass
Definition: LazyValueInfo.cpp:1966
llvm::ArrayRecycler::allocate
T * allocate(Capacity Cap, AllocatorType &Allocator)
Allocate an array of at least the requested capacity.
Definition: ArrayRecycler.h:125
llvm::GraphTraits< MachineBasicBlock * >
Definition: MachineBasicBlock.h:1129
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:112
llvm::MachineFunction::getVariableDbgInfo
VariableDbgInfoMapTy & getVariableDbgInfo()
Definition: MachineFunction.h:1170
llvm::MachineFunction::DebugInstrOperandPair
std::pair< unsigned, unsigned > DebugInstrOperandPair
Pair of instruction number and operand number.
Definition: MachineFunction.h:452
llvm::MachineFunction::getBBSectionsSymbolPrefix
const std::vector< char > & getBBSectionsSymbolPrefix() const
Definition: MachineFunction.h:1201
llvm::MachineFunction::allocateRegMask
uint32_t * allocateRegMask()
Allocate and initialize a register mask with NumRegister bits.
Definition: MachineFunction.cpp:521
llvm::MachineFunctionProperties::print
void print(raw_ostream &OS) const
Print the MachineFunctionProperties in human-readable form.
Definition: MachineFunction.cpp:109
AtomicOrdering.h
llvm::iplist_impl::push_back
void push_back(pointer val)
Definition: ilist.h:313
llvm::MachineRegisterInfo
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
Definition: MachineRegisterInfo.h:52
llvm::MCContext
Context object for machine code objects.
Definition: MCContext.h:72
llvm::Function
Definition: Function.h:61
llvm::MachineFunctionProperties::Property
Property
Definition: MachineFunction.h:152
llvm::MachineFunction::getContext
MCContext & getContext() const
Definition: MachineFunction.h:574
llvm::MachineFunction::VariableDbgInfo::VariableDbgInfo
VariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr, int Slot, const DILocation *Loc)
Definition: MachineFunction.h:390
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::lookup
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:197
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::BitVector::set
BitVector & set()
Definition: BitVector.h:343
llvm::MachineFunction::getSubtarget
const STC & getSubtarget() const
getSubtarget - This method returns a pointer to the specified type of TargetSubtargetInfo.
Definition: MachineFunction.h:627
llvm::MachineFunction::assignBeginEndSections
void assignBeginEndSections()
Assign IsBeginSection IsEndSection fields for basic blocks in this function.
Definition: MachineFunction.cpp:334
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:137
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
ilist.h
llvm::MachineFunction::end
iterator end()
Definition: MachineFunction.h:806
llvm::MachineFunction::getObserver
GISelChangeObserver * getObserver() const
Definition: MachineFunction.h:571
llvm::LandingPadInfo::LandingPadLabel
MCSymbol * LandingPadLabel
Definition: MachineFunction.h:223
llvm::MachineFunction::splice
void splice(iterator InsertPt, MachineBasicBlock *MBB)
Definition: MachineFunction.h:829
llvm::MachineFunction::getMachineMemOperand
MachineMemOperand * getMachineMemOperand(MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s, Align base_alignment, const AAMDNodes &AAInfo=AAMDNodes(), const MDNode *Ranges=nullptr, SyncScope::ID SSID=SyncScope::System, AtomicOrdering Ordering=AtomicOrdering::NotAtomic, AtomicOrdering FailureOrdering=AtomicOrdering::NotAtomic)
getMachineMemOperand - Allocate a new MachineMemOperand.
Definition: MachineFunction.cpp:430
llvm::MachineFunction::copyCallSiteInfo
void copyCallSiteInfo(const MachineInstr *Old, const MachineInstr *New)
Copy the call site info from Old to \ New.
Definition: MachineFunction.cpp:930
llvm::LandingPadInfo::SEHHandlers
SmallVector< SEHHandler, 1 > SEHHandlers
Definition: MachineFunction.h:222
llvm::MachineFunction::exposesReturnsTwice
bool exposesReturnsTwice() const
exposesReturnsTwice - Returns true if the function calls setjmp or any other similar functions with a...
Definition: MachineFunction.h:684
llvm::SyncScope::System
@ System
Synchronized with respect to all concurrently executing threads.
Definition: LLVMContext.h:58
Allocator.h
llvm::MachineFunction::getOrCreateJumpTableInfo
MachineJumpTableInfo * getOrCreateJumpTableInfo(unsigned JTEntryKind)
getOrCreateJumpTableInfo - Get the JumpTableInfo for this function, if it does already exist,...
Definition: MachineFunction.cpp:267
llvm::MachineFunction::getFunctionNumber
unsigned getFunctionNumber() const
getFunctionNumber - Return a unique ID for the current function.
Definition: MachineFunction.h:597
llvm::MachineFunction::setCallsUnwindInit
void setCallsUnwindInit(bool b)
Definition: MachineFunction.h:1038
llvm::MachineFunction::back
const MachineBasicBlock & back() const
Definition: MachineFunction.h:818
MachineBasicBlock.h
llvm::ConstantPool
Definition: ConstantPools.h:43
llvm::MachineFunction::DebugSubstitution::Dest
DebugInstrOperandPair Dest
Replacement instruction / operand pair.
Definition: MachineFunction.h:466
llvm::iplist_impl< simple_ilist< T, Options... >, ilist_traits< T > >::const_reverse_iterator
base_list_type::const_reverse_iterator const_reverse_iterator
Definition: ilist.h:181
llvm::ilist_callback_traits
Callbacks do nothing by default in iplist and ilist.
Definition: ilist.h:64
llvm::MachineFunction::getNumBlockIDs
unsigned getNumBlockIDs() const
getNumBlockIDs - Return the number of MBB ID's allocated.
Definition: MachineFunction.h:749
llvm::MachineFunction::ensureAlignment
void ensureAlignment(Align A)
ensureAlignment - Make sure the function is at least A bytes aligned.
Definition: MachineFunction.h:676
llvm::MachineFunction::moveCallSiteInfo
void moveCallSiteInfo(const MachineInstr *Old, const MachineInstr *New)
Move the call site info from Old to \New call site info.
Definition: MachineFunction.cpp:948
InstrCount
static unsigned InstrCount
Definition: DFAPacketizer.cpp:53
llvm::DILocation
Debug location.
Definition: DebugInfoMetadata.h:1562
llvm::AAMDNodes
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:651
llvm::MachineFunction::push_front
void push_front(MachineBasicBlock *MBB)
Definition: MachineFunction.h:822
llvm::DenseMapIterator
Definition: DenseMap.h:56
llvm::MachineFunction::DebugSubstitution::Subreg
unsigned Subreg
Qualifier for which part of Dest is read.
Definition: MachineFunction.h:467
llvm::MachineFunction::Delegate::MF_HandleRemoval
virtual void MF_HandleRemoval(MachineInstr &MI)=0
Callback before a removal. This should not modify the MI directly.
llvm::MachineFunction::getInstructionCount
unsigned getInstructionCount() const
Return the number of MachineInstrs in this MachineFunction.
Definition: MachineFunction.h:847
DenseMap.h
llvm::MachineFunction::getNewDebugInstrNum
unsigned getNewDebugInstrNum()
Definition: MachineFunction.h:1211
llvm::MachineMemOperand
A description of a memory reference used in the backend.
Definition: MachineMemOperand.h:128
EHPersonalities.h
llvm::MachineFunction::insert
void insert(iterator MBBI, MachineBasicBlock *MBB)
Definition: MachineFunction.h:823
llvm::MachineFunction::getPSVManager
PseudoSourceValueManager & getPSVManager() const
Definition: MachineFunction.h:582
llvm::MachineFunction::setCallSiteLandingPad
void setCallSiteLandingPad(MCSymbol *Sym, ArrayRef< unsigned > Sites)
Map the landing pad's EH symbol to the call site indexes.
Definition: MachineFunction.cpp:855
llvm::MachineFunctionProperties::Property::IsSSA
@ IsSSA
llvm::MachineFunctionProperties
Properties which a MachineFunction may have at a given point in time.
Definition: MachineFunction.h:111
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::count
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:145
llvm::MachineFunction::setDelegate
void setDelegate(Delegate *delegate)
Set the delegate.
Definition: MachineFunction.h:561
llvm::MachineFunction::callsUnwindInit
bool callsUnwindInit() const
Definition: MachineFunction.h:1037
llvm::MachineFunction::addCodeViewAnnotation
void addCodeViewAnnotation(MCSymbol *Label, MDNode *MD)
Record annotations associated with a particular label.
Definition: MachineFunction.h:1143
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::MachineFunction::addSEHCatchHandler
void addSEHCatchHandler(MachineBasicBlock *LandingPad, const Function *Filter, const BlockAddress *RecoverBA)
Definition: MachineFunction.cpp:836
llvm::iplist_impl::remove
pointer remove(iterator &IT)
Definition: ilist.h:251
llvm::MachineFunction::hasCallSiteLandingPad
bool hasCallSiteLandingPad(MCSymbol *Sym)
Return true if the landing pad Eh symbol has an associated call site.
Definition: MachineFunction.h:1121
llvm::MachineFunction::getFunction
const Function & getFunction() const
Return the LLVM function that this machine code represents.
Definition: MachineFunction.h:591
llvm::DIExpression
DWARF expression.
Definition: DebugInfoMetadata.h:2557
llvm::MachineFunction::getJTISymbol
MCSymbol * getJTISymbol(unsigned JTI, MCContext &Ctx, bool isLinkerPrivate=false) const
getJTISymbol - Return the MCSymbol for the specified non-empty jump table.
Definition: MachineFunction.cpp:678
llvm::MachineFunction::setHasEHFunclets
void setHasEHFunclets(bool V)
Definition: MachineFunction.h:1047
llvm::MachineFunctionInfo::create
static Ty * create(BumpPtrAllocator &Allocator, MachineFunction &MF)
Factory function: default behavior is to call new using the supplied allocator.
Definition: MachineFunction.h:103
llvm::BitmaskEnumDetail::Mask
std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:80
llvm::BasicBlockSection::List
@ List
llvm::BasicBlockSection::None
@ None
p
the resulting code requires compare and branches when and if * p
Definition: README.txt:396
llvm::iplist
An intrusive list with ownership and callbacks specified/controlled by ilist_traits,...
Definition: ilist.h:390
llvm::iplist_impl::splice
void splice(iterator where, iplist_impl &L2)
Definition: ilist.h:329
llvm::SEHHandler::FilterOrFinally
const Function * FilterOrFinally
Filter or finally function. Null indicates a catch-all.
Definition: MachineFunction.h:211
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::MachineFunction::iterator
BasicBlockListType::iterator iterator
Definition: MachineFunction.h:786
llvm::iplist_impl::erase
iterator erase(iterator where)
Definition: ilist.h:267
llvm::MachineFunction::DebugSubstitution::DebugSubstitution
DebugSubstitution(const DebugInstrOperandPair &Src, const DebugInstrOperandPair &Dest, unsigned Subreg)
Definition: MachineFunction.h:469
llvm::MachineFunction::getFrameInstructions
const std::vector< MCCFIInstruction > & getFrameInstructions() const
Returns a reference to a list of cfi instructions in the function's prologue.
Definition: MachineFunction.h:1002
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::GraphTraits< MachineFunction * >::nodes_end
static nodes_iterator nodes_end(MachineFunction *F)
Definition: MachineFunction.h:1236
llvm::MachineFunction::setExposesReturnsTwice
void setExposesReturnsTwice(bool B)
setCallsSetJmp - Set a flag that indicates if there's a call to a "returns twice" function.
Definition: MachineFunction.h:690
GraphTraits.h
llvm::MachineFunction::setWasmLandingPadIndex
void setWasmLandingPadIndex(const MachineBasicBlock *LPad, unsigned Index)
Map the landing pad to its index. Used for Wasm exception handling.
Definition: MachineFunction.h:1098
llvm::MachineFunction::rend
reverse_iterator rend()
Definition: MachineFunction.h:811
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:206
llvm::MachineFunction::ArgRegPair::ArgNo
uint16_t ArgNo
Definition: MachineFunction.h:412
llvm::verifyMachineFunction
void verifyMachineFunction(MachineFunctionAnalysisManager *, const std::string &Banner, const MachineFunction &MF)
Definition: MachineVerifier.cpp:308
llvm::CallInfo
Definition: GVNHoist.cpp:217
llvm::GraphTraits< MachineFunction * >::nodes_begin
static nodes_iterator nodes_begin(MachineFunction *F)
Definition: MachineFunction.h:1232
llvm::MachineFunction::ArgRegPair
Structure used to represent pair of argument number after call lowering and register used to transfer...
Definition: MachineFunction.h:410
llvm::MachineFunction::substituteDebugValuesForInst
void substituteDebugValuesForInst(const MachineInstr &Old, MachineInstr &New, unsigned MaxOperand=UINT_MAX)
Create substitutions for any tracked values in Old, to point at New.
Definition: MachineFunction.cpp:979
llvm::GraphTraits< const MachineFunction * >::nodes_end
static nodes_iterator nodes_end(const MachineFunction *F)
Definition: MachineFunction.h:1253
bb
< i1 > br i1 label label bb bb
Definition: README.txt:978
llvm::MachineFunction::front
const MachineBasicBlock & front() const
Definition: MachineFunction.h:816
llvm::MachineFunction::ArgRegPair::ArgRegPair
ArgRegPair(Register R, unsigned Arg)
Definition: MachineFunction.h:413
llvm::MachineFunction::getRegInfo
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Definition: MachineFunction.h:632
llvm::MachineFunction::setSection
void setSection(MCSection *S)
Indicates the Section this function belongs to.
Definition: MachineFunction.h:580
llvm::MachineFunctionProperties::Property::Selected
@ Selected
llvm::MachineFunction::VariableDbgInfo::Slot
int Slot
Definition: MachineFunction.h:387
llvm::LandingPadInfo::EndLabels
SmallVector< MCSymbol *, 1 > EndLabels
Definition: MachineFunction.h:221
llvm::iplist_impl::push_front
void push_front(pointer val)
Definition: ilist.h:312
llvm::DILocalVariable
Local variable.
Definition: DebugInfoMetadata.h:3053
f
Itanium Name Demangler i e convert the string _Z1fv into f()". You can also use the CRTP base ManglingParser to perform some simple analysis on the mangled name
llvm::MachineFunction::setAlignment
void setAlignment(Align A)
setAlignment - Set the alignment of the function.
Definition: MachineFunction.h:673
llvm::MachineFunction::getInfo
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
Definition: MachineFunction.h:720
llvm::MachineFunction::getFilterIds
const std::vector< unsigned > & getFilterIds() const
Return a reference to the typeids encoding filters used in the current function.
Definition: MachineFunction.h:1158
llvm::MachineFunction::getDenormalMode
DenormalMode getDenormalMode(const fltSemantics &FPType) const
Returns the denormal handling type for the default rounding mode of the function.
Definition: MachineFunction.cpp:275
llvm::MachineFunction::salvageCopySSA
DebugInstrOperandPair salvageCopySSA(MachineInstr &MI)
Find the underlying defining instruction / operand for a COPY instruction while in SSA form.
Definition: MachineFunction.cpp:1008
llvm::MachineFunction::addCatchTypeInfo
void addCatchTypeInfo(MachineBasicBlock *LandingPad, ArrayRef< const GlobalValue * > TyInfo)
Provide the catch typeinfo for a landing pad.
Definition: MachineFunction.cpp:769
llvm::MachineFunctionProperties::verifyRequiredProperties
bool verifyRequiredProperties(const MachineFunctionProperties &V) const
Definition: MachineFunction.h:197
llvm::GraphTraits< const MachineFunction * >::size
static unsigned size(const MachineFunction *F)
Definition: MachineFunction.h:1257
llvm::MachineFunction::setObserver
void setObserver(GISelChangeObserver *O)
Definition: MachineFunction.h:569
llvm::MachineFunction::DeleteMachineInstr
void DeleteMachineInstr(MachineInstr *MI)
DeleteMachineInstr - Delete the given MachineInstr.
Definition: MachineFunction.cpp:393
llvm::TargetRegisterClass
Definition: TargetRegisterInfo.h:46
llvm::MachineFunctionInfo::~MachineFunctionInfo
virtual ~MachineFunctionInfo()
llvm::MachineFunction::getCallSiteLandingPad
SmallVectorImpl< unsigned > & getCallSiteLandingPad(MCSymbol *Sym)
Get the call site indexes for a landing pad EH symbol.
Definition: MachineFunction.h:1114
b
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int b
Definition: README.txt:418
llvm::MachineFunction::hasBBLabels
bool hasBBLabels() const
Returns true if basic block labels are to be generated for this function.
Definition: MachineFunction.h:607
llvm::MachineFunction::getProperties
const MachineFunctionProperties & getProperties() const
Get the function properties.
Definition: MachineFunction.h:713
llvm::ArrayRecycler::deallocate
void deallocate(Capacity Cap, T *Ptr)
Deallocate an array with the specified Capacity.
Definition: ArrayRecycler.h:137
llvm::LandingPadInfo::TypeIds
std::vector< int > TypeIds
Definition: MachineFunction.h:224
llvm::MachineFunction::setDebugInstrNumberingCount
void setDebugInstrNumberingCount(unsigned Num)
Set value of DebugInstrNumberingCount field.
Definition: MachineFunction.cpp:967
llvm::MachineFunction::size
unsigned size() const
Definition: MachineFunction.h:814
llvm::MachineFunction::getTypeIDFor
unsigned getTypeIDFor(const GlobalValue *TI)
Return the type id for the specified typeinfo. This is function wide.
Definition: MachineFunction.cpp:860
llvm::MCInstrDesc
Describe properties that are true of each instruction in the target description file.
Definition: MCInstrDesc.h:195
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:49
llvm::MachineFunction::rbegin
reverse_iterator rbegin()
Definition: MachineFunction.h:809
llvm::MachineFunctionProperties::set
MachineFunctionProperties & set(Property P)
Definition: MachineFunction.h:169
llvm::MachineFunction::getVariableDbgInfo
const VariableDbgInfoMapTy & getVariableDbgInfo() const
Definition: MachineFunction.h:1171
llvm::MachineFunction::hasEHCatchret
bool hasEHCatchret() const
Definition: MachineFunction.h:1040
llvm::BasicBlockSection::Labels
@ Labels
llvm::MachineModuleInfo
This class contains meta information specific to a module.
Definition: MachineModuleInfo.h:78
llvm::ilist_callback_traits< MachineBasicBlock >::transferNodesFromList
void transferNodesFromList(ilist_callback_traits &OldList, Iterator, Iterator)
Definition: MachineFunction.h:86
llvm::GraphTraits< Inverse< const MachineFunction * > >::getEntryNode
static NodeRef getEntryNode(Inverse< const MachineFunction * > G)
Definition: MachineFunction.h:1275
llvm::MachineFunction::viewCFG
void viewCFG() const
viewCFG - This function is meant for use from the debugger.
Definition: MachineFunction.cpp:631
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::MachineFunction::shouldSplitStack
bool shouldSplitStack() const
Should we be emitting segmented stack stuff for the function.
Definition: MachineFunction.cpp:280
llvm::MachineFunction::addToMBBNumbering
unsigned addToMBBNumbering(MachineBasicBlock *MBB)
Adds the MBB to the internal numbering.
Definition: MachineFunction.h:859
llvm::MachineFunction::Delegate
Definition: MachineFunction.h:395
BitVector.h
llvm::MachineFunction::begin
iterator begin()
Definition: MachineFunction.h:804
llvm::SlotIndexes
SlotIndexes pass.
Definition: SlotIndexes.h:314
llvm::MachineFunction::setHasWinCFI
void setHasWinCFI(bool v)
Definition: MachineFunction.h:707
llvm::MachineFunction::addFilterTypeInfo
void addFilterTypeInfo(MachineBasicBlock *LandingPad, ArrayRef< const GlobalValue * > TyInfo)
Provide the filter typeinfo for a landing pad.
Definition: MachineFunction.cpp:776
llvm::BitVector
Definition: BitVector.h:74
llvm::BasicBlockSection::All
@ All
llvm::MachineFunction::verify
bool verify(Pass *p=nullptr, const char *Banner=nullptr, bool AbortOnError=true) const
Run the current MachineFunction through the machine code verifier, useful for debugger use.
Definition: MachineVerifier.cpp:321
llvm::MachineFunction::DebugPHIRegallocPos::DebugPHIRegallocPos
DebugPHIRegallocPos(MachineBasicBlock *MBB, Register Reg, unsigned SubReg)
Definition: MachineFunction.h:496
llvm::MachineFunction::getWasmEHFuncInfo
const WasmEHFuncInfo * getWasmEHFuncInfo() const
getWasmEHFuncInfo - Return information about how the current function uses Wasm exception handling.
Definition: MachineFunction.h:660
llvm::MachineFunction::sort
void sort(Comp comp)
Definition: MachineFunction.h:842
llvm::MachineFunction::removeFromMBBNumbering
void removeFromMBBNumbering(unsigned N)
removeFromMBBNumbering - Remove the specific machine basic block from our tracker,...
Definition: MachineFunction.h:867
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::MachineFunction::tidyLandingPads
void tidyLandingPads(DenseMap< MCSymbol *, uintptr_t > *LPMap=nullptr, bool TidyIfNoBeginLabels=true)
Remap landing pad labels and remove any deleted landing pads.
Definition: MachineFunction.cpp:785
llvm::MachineFunction::addInvoke
void addInvoke(MachineBasicBlock *LandingPad, MCSymbol *BeginLabel, MCSymbol *EndLabel)
Provide the begin and end labels of an invoke style call and associate it with a try landing pad bloc...
Definition: MachineFunction.cpp:715
llvm::iplist_impl< simple_ilist< T, Options... >, ilist_traits< T > >::reverse_iterator
base_list_type::reverse_iterator reverse_iterator
Definition: ilist.h:179
llvm::MCCFIInstruction
Definition: MCDwarf.h:434
llvm::MachineFunctionProperties::reset
MachineFunctionProperties & reset(const MachineFunctionProperties &MFP)
Definition: MachineFunction.h:190
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
llvm::GraphTraits< MachineFunction * >::getEntryNode
static NodeRef getEntryNode(MachineFunction *F)
Definition: MachineFunction.h:1227
llvm::MachineFunction::viewCFGOnly
void viewCFGOnly() const
viewCFGOnly - This function is meant for use from the debugger.
Definition: MachineFunction.cpp:641
llvm::MachineFunction::getConstantPool
const MachineConstantPool * getConstantPool() const
Definition: MachineFunction.h:655
llvm::MachineFunction::DebugSubstitution::Src
DebugInstrOperandPair Src
Source instruction / operand pair.
Definition: MachineFunction.h:465
llvm::MachineFunction::VariableDbgInfo::Expr
const DIExpression * Expr
Definition: MachineFunction.h:385
llvm::ilist_traits
Template traits for intrusive list.
Definition: ilist.h:89
llvm::MachineFunctionProperties::Property::NoVRegs
@ NoVRegs
llvm::MachineFunctionProperties::set
MachineFunctionProperties & set(const MachineFunctionProperties &MFP)
Definition: MachineFunction.h:185
llvm::ISD::BlockAddress
@ BlockAddress
Definition: ISDOpcodes.h:84
llvm::MachineFunction::getMMI
MachineModuleInfo & getMMI() const
Definition: MachineFunction.h:573
G
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
llvm::MachineFunction::deallocateOperandArray
void deallocateOperandArray(OperandCapacity Cap, MachineOperand *Array)
Dellocate an array of MachineOperands and recycle the memory.
Definition: MachineFunction.h:966
llvm::MachineFunction::getSubtarget
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Definition: MachineFunction.h:622
llvm::pointer_iterator
Definition: iterator.h:320
llvm::AtomicOrdering
AtomicOrdering
Atomic ordering for LLVM's memory model.
Definition: AtomicOrdering.h:56
llvm::MachineFunction::setHasInlineAsm
void setHasInlineAsm(bool B)
Set a flag that indicates that the function contains inline assembly.
Definition: MachineFunction.h:700
llvm::MachineFunction::rend
const_reverse_iterator rend() const
Definition: MachineFunction.h:812
llvm::MachineFunction::push_back
void push_back(MachineBasicBlock *MBB)
Definition: MachineFunction.h:821
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:179
llvm::MachineFunction::setCallSiteBeginLabel
void setCallSiteBeginLabel(MCSymbol *BeginLabel, unsigned Site)
Map the begin label for a call site.
Definition: MachineFunction.h:1126
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::WinEHFuncInfo
Definition: WinEHFuncInfo.h:90
llvm::MachineFunction::addCallArgsForwardingRegs
void addCallArgsForwardingRegs(const MachineInstr *CallI, CallSiteInfoImpl &&CallInfo)
Start tracking the arguments passed to the call CallI.
Definition: MachineFunction.h:1176
llvm::LandingPadInfo::BeginLabels
SmallVector< MCSymbol *, 1 > BeginLabels
Definition: MachineFunction.h:220
llvm::MachineFunctionProperties::Property::TracksLiveness
@ TracksLiveness
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
llvm::MachineFunctionProperties::reset
MachineFunctionProperties & reset()
Reset all the properties.
Definition: MachineFunction.h:180
llvm::MachineFunction::callsEHReturn
bool callsEHReturn() const
Definition: MachineFunction.h:1034
llvm::MachineFunction::createMIExtraInfo
MachineInstr::ExtraInfo * createMIExtraInfo(ArrayRef< MachineMemOperand * > MMOs, MCSymbol *PreInstrSymbol=nullptr, MCSymbol *PostInstrSymbol=nullptr, MDNode *HeapAllocMarker=nullptr)
Allocate and construct an extra info structure for a MachineInstr.
Definition: MachineFunction.cpp:507
llvm::MachineFunction::front
MachineBasicBlock & front()
Definition: MachineFunction.h:817
llvm::MachineFunction::setHasEHCatchret
void setHasEHCatchret(bool V)
Definition: MachineFunction.h:1041
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
llvm::MachineFunction::addSEHCleanupHandler
void addSEHCleanupHandler(MachineBasicBlock *LandingPad, const Function *Cleanup)
Definition: MachineFunction.cpp:846
llvm::MachineFunction::CloneMachineInstr
MachineInstr * CloneMachineInstr(const MachineInstr *Orig)
Create a new MachineInstr which is a copy of Orig, identical in all ways except the instruction has n...
Definition: MachineFunction.cpp:358
llvm::BasicBlockSection::Preset
@ Preset
llvm::iplist_impl< simple_ilist< T, Options... >, ilist_traits< T > >::iterator
base_list_type::iterator iterator
Definition: ilist.h:177
llvm::MachineFunction::back
MachineBasicBlock & back()
Definition: MachineFunction.h:819
s
multiplies can be turned into SHL s
Definition: README.txt:370
llvm::MachineFunction::splice
void splice(iterator InsertPt, iterator MBBI)
Definition: MachineFunction.h:826
llvm::BumpPtrAllocatorImpl
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:67
llvm::MachinePointerInfo
This class contains a discriminated union of information about pointers in memory operands,...
Definition: MachineMemOperand.h:38
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::DenseMap
Definition: DenseMap.h:714
llvm::SyncScope::ID
uint8_t ID
Definition: LLVMContext.h:47
llvm::MachineConstantPool
The MachineConstantPool class keeps track of constants referenced by a function which must be spilled...
Definition: MachineConstantPool.h:117
llvm::MachineFunction::dump
void dump() const
dump - Print the current MachineFunction to cerr, useful for debugger use.
Definition: MachineFunction.cpp:536
iterator.h
llvm::MachineFunction::getCallSitesInfo
const CallSiteInfoMap & getCallSitesInfo() const
Definition: MachineFunction.h:1185
llvm::GraphTraits< const MachineFunction * >::getEntryNode
static NodeRef getEntryNode(const MachineFunction *F)
Definition: MachineFunction.h:1244
llvm::DenormalMode
Represent subnormal handling kind for floating point instruction inputs and outputs.
Definition: FloatingPointMode.h:67
llvm::GraphTraits< const MachineBasicBlock * >
Definition: MachineBasicBlock.h:1138
llvm::ilist_alloc_traits
Use delete by default for iplist and ilist.
Definition: ilist.h:40
llvm::MachineFunction::CreateMachineBasicBlock
MachineBasicBlock * CreateMachineBasicBlock(const BasicBlock *bb=nullptr)
CreateMachineBasicBlock - Allocate a new MachineBasicBlock.
Definition: MachineFunction.cpp:414
llvm::MachineFunction::finalizeDebugInstrRefs
void finalizeDebugInstrRefs()
Finalise any partially emitted debug instructions.
Definition: MachineFunction.cpp:1167
ArrayRef.h
llvm::MachineFunctionProperties::Property::RegBankSelected
@ RegBankSelected
llvm::MachineMemOperand::Flags
Flags
Flags values. These may be or'd together.
Definition: MachineMemOperand.h:131
llvm::MachineFunction::getName
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
Definition: MachineFunction.cpp:541
llvm::MachineFunction::getConstantPool
MachineConstantPool * getConstantPool()
getConstantPool - Return the constant pool object for the current function.
Definition: MachineFunction.h:654
llvm::MachineFunction::~MachineFunction
~MachineFunction()
Definition: MachineFunction.cpp:210
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::LandingPadInfo::LandingPadBlock
MachineBasicBlock * LandingPadBlock
Definition: MachineFunction.h:219
llvm::MachineFunction::getCodeViewAnnotations
ArrayRef< std::pair< MCSymbol *, MDNode * > > getCodeViewAnnotations() const
Definition: MachineFunction.h:1147
llvm::MachineFunction::getFrameInfo
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
Definition: MachineFunction.h:638
llvm::MachineFunction::getLandingPads
const std::vector< LandingPadInfo > & getLandingPads() const
Return a reference to the landing pad info for the current function.
Definition: MachineFunction.h:1057
llvm::MachineFunction::erase
void erase(iterator MBBI)
Definition: MachineFunction.h:838
llvm::ISD::BasicBlock
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
llvm::MachineFunction::makeDebugValueSubstitution
void makeDebugValueSubstitution(DebugInstrOperandPair, DebugInstrOperandPair, unsigned SubReg=0)
Create a substitution between one <instr,operand> value to a different, new value.
Definition: MachineFunction.cpp:971
llvm::Recycler
Recycler - This class manages a linked-list of deallocated nodes and facilitates reusing deallocated ...
Definition: Recycler.h:34
llvm::MachineFunction::DebugSubstitution::operator<
bool operator<(const DebugSubstitution &Other) const
Order only by source instruction / operand pair: there should never be duplicate entries for the same...
Definition: MachineFunction.h:475
llvm::MDNode
Metadata node.
Definition: Metadata.h:897
llvm::MachineFunction::begin
const_iterator begin() const
Definition: MachineFunction.h:805
llvm::MachineFunction
Definition: MachineFunction.h:230
llvm::MachineFunction::addLiveIn
Register addLiveIn(MCRegister PReg, const TargetRegisterClass *RC)
addLiveIn - Add the specified physical register as a live-in value and create a corresponding virtual...
Definition: MachineFunction.cpp:653
llvm::MachineFunction::getWasmEHFuncInfo
WasmEHFuncInfo * getWasmEHFuncInfo()
Definition: MachineFunction.h:661
TargetOptions.h
llvm::BlockAddress
The address of a basic block.
Definition: Constants.h:848
llvm::MachineFunction::OperandCapacity
ArrayRecycler< MachineOperand >::Capacity OperandCapacity
Definition: MachineFunction.h:955
llvm::GraphTraits< const MachineFunction * >::nodes_begin
static nodes_iterator nodes_begin(const MachineFunction *F)
Definition: MachineFunction.h:1249
llvm::MachineFunction::rbegin
const_reverse_iterator rbegin() const
Definition: MachineFunction.h:810
llvm::ArrayRef< int >
RegInfo
Definition: AMDGPUAsmParser.cpp:2366
llvm::MachineFunction::splice
void splice(iterator InsertPt, iterator MBBI, iterator MBBE)
Definition: MachineFunction.h:832
llvm::MachineFunction::DeleteMachineBasicBlock
void DeleteMachineBasicBlock(MachineBasicBlock *MBB)
DeleteMachineBasicBlock - Delete the given MachineBasicBlock.
Definition: MachineFunction.cpp:421
llvm::MachineFunction::allocateShuffleMask
ArrayRef< int > allocateShuffleMask(ArrayRef< int > Mask)
Definition: MachineFunction.cpp:529
llvm::MachineFunction::setHasEHScopes
void setHasEHScopes(bool V)
Definition: MachineFunction.h:1044
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::MachineFunction::VariableDbgInfo::Loc
const DILocation * Loc
Definition: MachineFunction.h:388
MBBI
MachineBasicBlock MachineBasicBlock::iterator MBBI
Definition: AArch64SLSHardening.cpp:75
llvm::ilist_callback_traits::addNodeToList
void addNodeToList(NodeTy *)
When an MBB is added to an MF, we need to update the parent pointer of the MBB, the MBB numbering,...
Definition: ilist.h:65
uint32_t
Compiler.h
llvm::MachineFunction::DebugPHIRegallocPos
Location of a PHI instruction that is also a debug-info variable value, for the duration of register ...
Definition: MachineFunction.h:491
llvm::MachineFunction::DebugPHIRegallocPos::Reg
Register Reg
VReg where the control-flow-merge happens.
Definition: MachineFunction.h:494
llvm::GraphTraits< MachineFunction * >::size
static unsigned size(MachineFunction *F)
Definition: MachineFunction.h:1240
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::MCSection
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::MachineFunction::hasBBSections
bool hasBBSections() const
Returns true if this function has basic block sections enabled.
Definition: MachineFunction.h:600
llvm::MachineFunctionProperties::Property::TiedOpsRewritten
@ TiedOpsRewritten
llvm::MachineFunctionProperties::reset
MachineFunctionProperties & reset(Property P)
Definition: MachineFunction.h:174
llvm::GISelChangeObserver
Abstract class that contains various methods for clients to notify about changes.
Definition: GISelChangeObserver.h:29
llvm::EHPersonality
EHPersonality
Definition: EHPersonalities.h:22
llvm::TargetSubtargetInfo
TargetSubtargetInfo - Generic base class for all target subtargets.
Definition: TargetSubtargetInfo.h:59
llvm::MachineFunction::DebugInstrNumberingCount
unsigned DebugInstrNumberingCount
A count of how many instructions in the function have had numbers assigned to them.
Definition: MachineFunction.h:445
llvm::MachineFunction::CloneMachineInstrBundle
MachineInstr & CloneMachineInstrBundle(MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore, const MachineInstr &Orig)
Clones instruction or the whole instruction bundle Orig and insert into MBB before InsertBefore.
Definition: MachineFunction.cpp:363
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::GraphTraits< Inverse< MachineFunction * > >::getEntryNode
static NodeRef getEntryNode(Inverse< MachineFunction * > G)
Definition: MachineFunction.h:1269
llvm::ArrayRecycler< MachineOperand >
llvm::MachineFunction::DebugSubstitution
Replacement definition for a debug instruction reference.
Definition: MachineFunction.h:463
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::empty
LLVM_NODISCARD bool empty() const
Definition: DenseMap.h:97
llvm::MachineFunction::getSection
MCSection * getSection() const
Returns the Section this function belongs to.
Definition: MachineFunction.h:577
llvm::MachineFunction::getFilterIDFor
int getFilterIDFor(std::vector< unsigned > &TyIds)
Return the id of the filter encoded by TyIds. This is function wide.
Definition: MachineFunction.cpp:868
llvm::EHPersonality::Unknown
@ Unknown
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::MachineFunction::end
const_iterator end() const
Definition: MachineFunction.h:807
llvm::MachineFunction::getFrameInfo
const MachineFrameInfo & getFrameInfo() const
Definition: MachineFunction.h:639
llvm::MachineFunctionProperties::Property::FailedISel
@ FailedISel
llvm::MachineFunction::getBlockNumbered
MachineBasicBlock * getBlockNumbered(unsigned N) const
getBlockNumbered - MachineBasicBlocks are automatically numbered when they are inserted into the mach...
Definition: MachineFunction.h:739
llvm::BitVector::test
bool test(unsigned Idx) const
Definition: BitVector.h:447
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::MachineFunction::getFunction
Function & getFunction()
Return the LLVM function that this machine code represents.
Definition: MachineFunction.h:588
llvm::MachineFunctionProperties::Property::NoPHIs
@ NoPHIs
llvm::MachineFunction::needsFrameMoves
bool needsFrameMoves() const
True if this function needs frame moves for debug or exceptions.
Definition: MachineFunction.cpp:587
uint16_t
llvm::MachineFunction::getTarget
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
Definition: MachineFunction.h:618
llvm::ilist_iterator
Iterator for intrusive lists based on ilist_node.
Definition: ilist_iterator.h:57
llvm::MachineFunction::erase
void erase(MachineBasicBlock *MBBI)
Definition: MachineFunction.h:839
llvm::MachineFunction::getWinEHFuncInfo
const WinEHFuncInfo * getWinEHFuncInfo() const
getWinEHFuncInfo - Return information about how the current function uses Windows exception handling.
Definition: MachineFunction.h:666
llvm::MachineFunction::addCatchretTarget
void addCatchretTarget(MCSymbol *Target)
Add the specified symbol to the list of valid catchret targets for Windows EHCont Guard.
Definition: MachineFunction.h:1027
llvm::fltSemantics
Definition: APFloat.cpp:54
llvm::MachineFunction::allocateOperandArray
MachineOperand * allocateOperandArray(OperandCapacity Cap)
Allocate an array of MachineOperands.
Definition: MachineFunction.h:959
llvm::MachineFunction::print
void print(raw_ostream &OS, const SlotIndexes *=nullptr) const
print - Print out the MachineFunction in a format suitable for debugging to the specified stream.
Definition: MachineFunction.cpp:545
llvm::MachineFunction::hasCallSiteBeginLabel
bool hasCallSiteBeginLabel(MCSymbol *BeginLabel) const
Return true if the begin label has a call site number associated with it.
Definition: MachineFunction.h:1138
llvm::ilist_callback_traits::removeNodeFromList
void removeNodeFromList(NodeTy *)
Definition: ilist.h:66
LLVM_NODISCARD
#define LLVM_NODISCARD
LLVM_NODISCARD - Warn if a type or return value is discarded.
Definition: Compiler.h:161
llvm::MachineFunction::getWinEHFuncInfo
WinEHFuncInfo * getWinEHFuncInfo()
Definition: MachineFunction.h:667
llvm::LLVMTargetMachine
This class describes a target machine that is implemented with the LLVM target-independent code gener...
Definition: TargetMachine.h:385
llvm::MachineInstr::isCandidateForCallSiteEntry
bool isCandidateForCallSiteEntry(QueryType Type=IgnoreBundle) const
Return true if this is a call instruction that may have an associated call site entry in the debug in...
Definition: MachineInstr.cpp:707
llvm::MachineFunction::MachineFunction
MachineFunction(Function &F, const LLVMTargetMachine &Target, const TargetSubtargetInfo &STI, unsigned FunctionNum, MachineModuleInfo &MMI)
Definition: MachineFunction.cpp:137
llvm::Inverse
Definition: GraphTraits.h:95
llvm::MachineFunction::hasEHFunclets
bool hasEHFunclets() const
Definition: MachineFunction.h:1046
llvm::MachineFunction::addCleanup
void addCleanup(MachineBasicBlock *LandingPad)
Add a cleanup action for a landing pad.
Definition: MachineFunction.cpp:831
llvm::BitVector::reset
BitVector & reset()
Definition: BitVector.h:384
llvm::MachineFunction::addLongjmpTarget
void addLongjmpTarget(MCSymbol *Target)
Add the specified symbol to the list of valid longjmp targets for Windows Control Flow Guard.
Definition: MachineFunction.h:1017
llvm::iplist_impl::insert
iterator insert(iterator where, pointer New)
Definition: ilist.h:228
llvm::MachineFunction::ArgRegPair::Reg
Register Reg
Definition: MachineFunction.h:411
llvm::MachineFunction::getPICBaseSymbol
MCSymbol * getPICBaseSymbol() const
getPICBaseSymbol - Return a function-local symbol to represent the PIC base.
Definition: MachineFunction.cpp:693
llvm::MachineFunction::addFrameInst
LLVM_NODISCARD unsigned addFrameInst(const MCCFIInstruction &Inst)
Definition: MachineFunction.cpp:285
llvm::SEHHandler
Definition: MachineFunction.h:209
llvm::MachineFrameInfo
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
Definition: MachineFrameInfo.h:107
llvm::Pass
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:91
llvm::BasicBlockSection
BasicBlockSection
Definition: TargetOptions.h:61
SmallVector.h
llvm::MachineFunction::hasWasmLandingPadIndex
bool hasWasmLandingPadIndex(const MachineBasicBlock *LPad) const
Returns true if the landing pad has an associate index in wasm EH.
Definition: MachineFunction.h:1103
llvm::MachineFunction::reset
void reset()
Reset the instance as if it was just created.
Definition: MachineFunction.h:547
llvm::PseudoSourceValueManager
Manages creation of pseudo source values.
Definition: PseudoSourceValue.h:156
ArrayRecycler.h
llvm::ilist_alloc_traits::deleteNode
static void deleteNode(NodeTy *V)
Definition: ilist.h:41
Allocator
Basic Register Allocator
Definition: RegAllocBasic.cpp:146
llvm::MachineFunctionProperties::Property::LastProperty
@ LastProperty
N
#define N
llvm::iplist_impl< simple_ilist< T, Options... >, ilist_traits< T > >::const_iterator
base_list_type::const_iterator const_iterator
Definition: ilist.h:178
llvm::MachineFunction::DebugValueSubstitutions
SmallVector< DebugSubstitution, 8 > DebugValueSubstitutions
Debug value substitutions: a collection of DebugSubstitution objects, recording changes in where a va...
Definition: MachineFunction.h:484
llvm::DenseMapBase::try_emplace
std::pair< iterator, bool > try_emplace(KeyT &&Key, Ts &&... Args)
Definition: DenseMap.h:222
llvm::MachineFunction::getDataLayout
const DataLayout & getDataLayout() const
Return the DataLayout attached to the Module associated to this MF.
Definition: MachineFunction.cpp:260
MachineMemOperand.h
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:43
llvm::MachineFunction::getCallSiteBeginLabel
unsigned getCallSiteBeginLabel(MCSymbol *BeginLabel) const
Get the call site number for a begin label.
Definition: MachineFunction.h:1131
llvm::LandingPadInfo
This structure is used to retain landing pad info for the current function.
Definition: MachineFunction.h:218
llvm::MachineFunction::getSublistAccess
static BasicBlockListType MachineFunction::* getSublistAccess(MachineBasicBlock *)
Support for MachineBasicBlock::getNextNode().
Definition: MachineFunction.h:793
llvm::MachineFunction::remove
void remove(MachineBasicBlock *MBBI)
Definition: MachineFunction.h:837
llvm::MachineFunction::VariableDbgInfo::Var
const DILocalVariable * Var
Definition: MachineFunction.h:384
llvm::MachineFunction::DebugPHIPositions
DenseMap< unsigned, DebugPHIRegallocPos > DebugPHIPositions
Map of debug instruction numbers to the position of their PHI instructions during register allocation...
Definition: MachineFunction.h:502
llvm::MachineFunction::getTypeInfos
const std::vector< const GlobalValue * > & getTypeInfos() const
Return a reference to the C++ typeinfo for the current function.
Definition: MachineFunction.h:1152
llvm::MachineFunction::createExternalSymbolName
const char * createExternalSymbolName(StringRef Name)
Allocate a string and populate it with the given external symbol name.
Definition: MachineFunction.cpp:514
llvm::MachineFunction::getCatchretTargets
const std::vector< MCSymbol * > & getCatchretTargets() const
Returns a reference to a list of symbols that we have catchrets.
Definition: MachineFunction.h:1021
llvm::MachineFunction::getWasmLandingPadIndex
unsigned getWasmLandingPadIndex(const MachineBasicBlock *LPad) const
Get the index in wasm EH for a given landing pad.
Definition: MachineFunction.h:1108
llvm::MachineFunction::getJumpTableInfo
const MachineJumpTableInfo * getJumpTableInfo() const
getJumpTableInfo - Return the jump table info object for the current function.
Definition: MachineFunction.h:645
llvm::MachineFunction::CreateMachineInstr
MachineInstr * CreateMachineInstr(const MCInstrDesc &MCID, const DebugLoc &DL, bool NoImplicit=false)
CreateMachineInstr - Allocate a new MachineInstr.
Definition: MachineFunction.cpp:348
llvm::GraphTraits
Definition: GraphTraits.h:35
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
Recycler.h
llvm::MachineFunction::addLandingPad
MCSymbol * addLandingPad(MachineBasicBlock *LandingPad)
Add a new panding pad, and extract the exception handling information from the landingpad instruction...
Definition: MachineFunction.cpp:722
llvm::MachineFunction::hasEHScopes
bool hasEHScopes() const
Definition: MachineFunction.h:1043
llvm::MachineJumpTableInfo
Definition: MachineJumpTableInfo.h:42
llvm::MachineFunction::operator=
MachineFunction & operator=(const MachineFunction &)=delete
llvm::MachineFunction::VariableDbgInfo
Definition: MachineFunction.h:383
llvm::MachineFunction::empty
bool empty() const
Definition: MachineFunction.h:815
llvm::MachineFunction::eraseCallSiteInfo
void eraseCallSiteInfo(const MachineInstr *MI)
Following functions update call site info.
Definition: MachineFunction.cpp:918
llvm::MachineFunction::getJumpTableInfo
MachineJumpTableInfo * getJumpTableInfo()
Definition: MachineFunction.h:646
llvm::MachineFunction::VariableDbgInfos
VariableDbgInfoMapTy VariableDbgInfos
Definition: MachineFunction.h:440
llvm::MachineInstrBundleIterator< MachineInstr >
llvm::LLT::scalar
static LLT scalar(unsigned SizeInBits)
Get a low-level scalar or aggregate "bag of bits".
Definition: LowLevelTypeImpl.h:43
llvm::MachineFunction::getMachineMemOperand
MachineMemOperand * getMachineMemOperand(const MachineMemOperand *MMO, int64_t Offset, uint64_t Size)
Definition: MachineFunction.h:927
llvm::MachineFunction::getAlignment
Align getAlignment() const
getAlignment - Return the alignment of the function.
Definition: MachineFunction.h:670
llvm::MachineFunction::setBBSectionsType
void setBBSectionsType(BasicBlockSection V)
Definition: MachineFunction.h:611
llvm::MachineFunctionInfo
MachineFunctionInfo - This class can be derived from and used by targets to hold private target-speci...
Definition: MachineFunction.h:95
llvm::SEHHandler::RecoverBA
const BlockAddress * RecoverBA
Address of block to recover at. Null for a finally handler.
Definition: MachineFunction.h:214
llvm::MachineFunction::Delegate::~Delegate
virtual ~Delegate()=default
llvm::MachineFunction::setVariableDbgInfo
void setVariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr, int Slot, const DILocation *Loc)
Collect information used to emit debugging information of a variable.
Definition: MachineFunction.h:1165
llvm::LandingPadInfo::LandingPadInfo
LandingPadInfo(MachineBasicBlock *MBB)
Definition: MachineFunction.h:226
SubReg
unsigned SubReg
Definition: AArch64AdvSIMDScalarPass.cpp:104
llvm::MachineFunction::RenumberBlocks
void RenumberBlocks(MachineBasicBlock *MBBFrom=nullptr)
RenumberBlocks - This discards all of the MachineBasicBlock numbers and recomputes them.
Definition: MachineFunction.cpp:294
llvm::MachineFunction::setCallsEHReturn
void setCallsEHReturn(bool b)
Definition: MachineFunction.h:1035
llvm::MachineFunction::getOrCreateLandingPadInfo
LandingPadInfo & getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad)
Find or create an LandingPadInfo for the specified MachineBasicBlock.
Definition: MachineFunction.cpp:703
llvm::AtomicOrdering::NotAtomic
@ NotAtomic
llvm::codeview::PublicSymFlags::Function
@ Function
llvm::ISD::MCSymbol
@ MCSymbol
Definition: ISDOpcodes.h:172
llvm::MachineFunction::getRegInfo
const MachineRegisterInfo & getRegInfo() const
Definition: MachineFunction.h:633
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1172
llvm::MachineFunction::getLongjmpTargets
const std::vector< MCSymbol * > & getLongjmpTargets() const
Returns a reference to a list of symbols immediately following calls to _setjmp in the function.
Definition: MachineFunction.h:1011
llvm::SmallVectorImpl::emplace_back
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:908
llvm::MCRegister
Wrapper class representing physical registers. Should be passed by value.
Definition: MCRegister.h:23
llvm::MachineFunction::Delegate::MF_HandleInsertion
virtual void MF_HandleInsertion(MachineInstr &MI)=0
Callback after an insertion. This should not modify the MI directly.
llvm::MachineFunctionProperties::Property::Legalized
@ Legalized
llvm::LLT
Definition: LowLevelTypeImpl.h:40