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