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