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