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