LLVM  4.0.0
RDFGraph.h
Go to the documentation of this file.
1 //===--- RDFGraph.h ---------------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Target-independent, SSA-based data flow graph for register data flow (RDF)
11 // for a non-SSA program representation (e.g. post-RA machine code).
12 //
13 //
14 // *** Introduction
15 //
16 // The RDF graph is a collection of nodes, each of which denotes some element
17 // of the program. There are two main types of such elements: code and refe-
18 // rences. Conceptually, "code" is something that represents the structure
19 // of the program, e.g. basic block or a statement, while "reference" is an
20 // instance of accessing a register, e.g. a definition or a use. Nodes are
21 // connected with each other based on the structure of the program (such as
22 // blocks, instructions, etc.), and based on the data flow (e.g. reaching
23 // definitions, reached uses, etc.). The single-reaching-definition principle
24 // of SSA is generally observed, although, due to the non-SSA representation
25 // of the program, there are some differences between the graph and a "pure"
26 // SSA representation.
27 //
28 //
29 // *** Implementation remarks
30 //
31 // Since the graph can contain a large number of nodes, memory consumption
32 // was one of the major design considerations. As a result, there is a single
33 // base class NodeBase which defines all members used by all possible derived
34 // classes. The members are arranged in a union, and a derived class cannot
35 // add any data members of its own. Each derived class only defines the
36 // functional interface, i.e. member functions. NodeBase must be a POD,
37 // which implies that all of its members must also be PODs.
38 // Since nodes need to be connected with other nodes, pointers have been
39 // replaced with 32-bit identifiers: each node has an id of type NodeId.
40 // There are mapping functions in the graph that translate between actual
41 // memory addresses and the corresponding identifiers.
42 // A node id of 0 is equivalent to nullptr.
43 //
44 //
45 // *** Structure of the graph
46 //
47 // A code node is always a collection of other nodes. For example, a code
48 // node corresponding to a basic block will contain code nodes corresponding
49 // to instructions. In turn, a code node corresponding to an instruction will
50 // contain a list of reference nodes that correspond to the definitions and
51 // uses of registers in that instruction. The members are arranged into a
52 // circular list, which is yet another consequence of the effort to save
53 // memory: for each member node it should be possible to obtain its owner,
54 // and it should be possible to access all other members. There are other
55 // ways to accomplish that, but the circular list seemed the most natural.
56 //
57 // +- CodeNode -+
58 // | | <---------------------------------------------------+
59 // +-+--------+-+ |
60 // |FirstM |LastM |
61 // | +-------------------------------------+ |
62 // | | |
63 // V V |
64 // +----------+ Next +----------+ Next Next +----------+ Next |
65 // | |----->| |-----> ... ----->| |----->-+
66 // +- Member -+ +- Member -+ +- Member -+
67 //
68 // The order of members is such that related reference nodes (see below)
69 // should be contiguous on the member list.
70 //
71 // A reference node is a node that encapsulates an access to a register,
72 // in other words, data flowing into or out of a register. There are two
73 // major kinds of reference nodes: defs and uses. A def node will contain
74 // the id of the first reached use, and the id of the first reached def.
75 // Each def and use will contain the id of the reaching def, and also the
76 // id of the next reached def (for def nodes) or use (for use nodes).
77 // The "next node sharing the same reaching def" is denoted as "sibling".
78 // In summary:
79 // - Def node contains: reaching def, sibling, first reached def, and first
80 // reached use.
81 // - Use node contains: reaching def and sibling.
82 //
83 // +-- DefNode --+
84 // | R2 = ... | <---+--------------------+
85 // ++---------+--+ | |
86 // |Reached |Reached | |
87 // |Def |Use | |
88 // | | |Reaching |Reaching
89 // | V |Def |Def
90 // | +-- UseNode --+ Sib +-- UseNode --+ Sib Sib
91 // | | ... = R2 |----->| ... = R2 |----> ... ----> 0
92 // | +-------------+ +-------------+
93 // V
94 // +-- DefNode --+ Sib
95 // | R2 = ... |----> ...
96 // ++---------+--+
97 // | |
98 // | |
99 // ... ...
100 //
101 // To get a full picture, the circular lists connecting blocks within a
102 // function, instructions within a block, etc. should be superimposed with
103 // the def-def, def-use links shown above.
104 // To illustrate this, consider a small example in a pseudo-assembly:
105 // foo:
106 // add r2, r0, r1 ; r2 = r0+r1
107 // addi r0, r2, 1 ; r0 = r2+1
108 // ret r0 ; return value in r0
109 //
110 // The graph (in a format used by the debugging functions) would look like:
111 //
112 // DFG dump:[
113 // f1: Function foo
114 // b2: === BB#0 === preds(0), succs(0):
115 // p3: phi [d4<r0>(,d12,u9):]
116 // p5: phi [d6<r1>(,,u10):]
117 // s7: add [d8<r2>(,,u13):, u9<r0>(d4):, u10<r1>(d6):]
118 // s11: addi [d12<r0>(d4,,u15):, u13<r2>(d8):]
119 // s14: ret [u15<r0>(d12):]
120 // ]
121 //
122 // The f1, b2, p3, etc. are node ids. The letter is prepended to indicate the
123 // kind of the node (i.e. f - function, b - basic block, p - phi, s - state-
124 // ment, d - def, u - use).
125 // The format of a def node is:
126 // dN<R>(rd,d,u):sib,
127 // where
128 // N - numeric node id,
129 // R - register being defined
130 // rd - reaching def,
131 // d - reached def,
132 // u - reached use,
133 // sib - sibling.
134 // The format of a use node is:
135 // uN<R>[!](rd):sib,
136 // where
137 // N - numeric node id,
138 // R - register being used,
139 // rd - reaching def,
140 // sib - sibling.
141 // Possible annotations (usually preceding the node id):
142 // + - preserving def,
143 // ~ - clobbering def,
144 // " - shadow ref (follows the node id),
145 // ! - fixed register (appears after register name).
146 //
147 // The circular lists are not explicit in the dump.
148 //
149 //
150 // *** Node attributes
151 //
152 // NodeBase has a member "Attrs", which is the primary way of determining
153 // the node's characteristics. The fields in this member decide whether
154 // the node is a code node or a reference node (i.e. node's "type"), then
155 // within each type, the "kind" determines what specifically this node
156 // represents. The remaining bits, "flags", contain additional information
157 // that is even more detailed than the "kind".
158 // CodeNode's kinds are:
159 // - Phi: Phi node, members are reference nodes.
160 // - Stmt: Statement, members are reference nodes.
161 // - Block: Basic block, members are instruction nodes (i.e. Phi or Stmt).
162 // - Func: The whole function. The members are basic block nodes.
163 // RefNode's kinds are:
164 // - Use.
165 // - Def.
166 //
167 // Meaning of flags:
168 // - Preserving: applies only to defs. A preserving def is one that can
169 // preserve some of the original bits among those that are included in
170 // the register associated with that def. For example, if R0 is a 32-bit
171 // register, but a def can only change the lower 16 bits, then it will
172 // be marked as preserving.
173 // - Shadow: a reference that has duplicates holding additional reaching
174 // defs (see more below).
175 // - Clobbering: applied only to defs, indicates that the value generated
176 // by this def is unspecified. A typical example would be volatile registers
177 // after function calls.
178 // - Fixed: the register in this def/use cannot be replaced with any other
179 // register. A typical case would be a parameter register to a call, or
180 // the register with the return value from a function.
181 // - Undef: the register in this reference the register is assumed to have
182 // no pre-existing value, even if it appears to be reached by some def.
183 // This is typically used to prevent keeping registers artificially live
184 // in cases when they are defined via predicated instructions. For example:
185 // r0 = add-if-true cond, r10, r11 (1)
186 // r0 = add-if-false cond, r12, r13, r0<imp-use> (2)
187 // ... = r0 (3)
188 // Before (1), r0 is not intended to be live, and the use of r0 in (3) is
189 // not meant to be reached by any def preceding (1). However, since the
190 // defs in (1) and (2) are both preserving, these properties alone would
191 // imply that the use in (3) may indeed be reached by some prior def.
192 // Adding Undef flag to the def in (1) prevents that. The Undef flag
193 // may be applied to both defs and uses.
194 // - Dead: applies only to defs. The value coming out of a "dead" def is
195 // assumed to be unused, even if the def appears to be reaching other defs
196 // or uses. The motivation for this flag comes from dead defs on function
197 // calls: there is no way to determine if such a def is dead without
198 // analyzing the target's ABI. Hence the graph should contain this info,
199 // as it is unavailable otherwise. On the other hand, a def without any
200 // uses on a typical instruction is not the intended target for this flag.
201 //
202 // *** Shadow references
203 //
204 // It may happen that a super-register can have two (or more) non-overlapping
205 // sub-registers. When both of these sub-registers are defined and followed
206 // by a use of the super-register, the use of the super-register will not
207 // have a unique reaching def: both defs of the sub-registers need to be
208 // accounted for. In such cases, a duplicate use of the super-register is
209 // added and it points to the extra reaching def. Both uses are marked with
210 // a flag "shadow". Example:
211 // Assume t0 is a super-register of r0 and r1, r0 and r1 do not overlap:
212 // set r0, 1 ; r0 = 1
213 // set r1, 1 ; r1 = 1
214 // addi t1, t0, 1 ; t1 = t0+1
215 //
216 // The DFG:
217 // s1: set [d2<r0>(,,u9):]
218 // s3: set [d4<r1>(,,u10):]
219 // s5: addi [d6<t1>(,,):, u7"<t0>(d2):, u8"<t0>(d4):]
220 //
221 // The statement s5 has two use nodes for t0: u7" and u9". The quotation
222 // mark " indicates that the node is a shadow.
223 //
224 
225 #ifndef LLVM_LIB_TARGET_HEXAGON_RDFGRAPH_H
226 #define LLVM_LIB_TARGET_HEXAGON_RDFGRAPH_H
227 
228 #include "llvm/ADT/BitVector.h"
229 #include "llvm/ADT/STLExtras.h"
230 #include "llvm/MC/LaneBitmask.h"
231 #include "llvm/Support/Allocator.h"
232 #include "llvm/Support/MathExtras.h"
235 #include <cassert>
236 #include <cstdint>
237 #include <cstring>
238 #include <functional>
239 #include <map>
240 #include <set>
241 #include <unordered_map>
242 #include <utility>
243 #include <vector>
244 
245 // RDF uses uint32_t to refer to registers. This is to ensure that the type
246 // size remains specific. In other places, registers are often stored using
247 // unsigned.
248 static_assert(sizeof(uint32_t) == sizeof(unsigned), "Those should be equal");
249 
250 namespace llvm {
251 
252  class MachineBasicBlock;
253  class MachineFunction;
254  class MachineInstr;
255  class MachineOperand;
256  class MachineDominanceFrontier;
257  class MachineDominatorTree;
258  class TargetInstrInfo;
259 
260 namespace rdf {
261 
262  typedef uint32_t NodeId;
264 
265  struct DataFlowGraph;
266 
267  struct NodeAttrs {
268  enum : uint16_t {
269  None = 0x0000, // Nothing
270 
271  // Types: 2 bits
272  TypeMask = 0x0003,
273  Code = 0x0001, // 01, Container
274  Ref = 0x0002, // 10, Reference
275 
276  // Kind: 3 bits
277  KindMask = 0x0007 << 2,
278  Def = 0x0001 << 2, // 001
279  Use = 0x0002 << 2, // 010
280  Phi = 0x0003 << 2, // 011
281  Stmt = 0x0004 << 2, // 100
282  Block = 0x0005 << 2, // 101
283  Func = 0x0006 << 2, // 110
284 
285  // Flags: 7 bits for now
286  FlagMask = 0x007F << 5,
287  Shadow = 0x0001 << 5, // 0000001, Has extra reaching defs.
288  Clobbering = 0x0002 << 5, // 0000010, Produces unspecified values.
289  PhiRef = 0x0004 << 5, // 0000100, Member of PhiNode.
290  Preserving = 0x0008 << 5, // 0001000, Def can keep original bits.
291  Fixed = 0x0010 << 5, // 0010000, Fixed register.
292  Undef = 0x0020 << 5, // 0100000, Has no pre-existing value.
293  Dead = 0x0040 << 5, // 1000000, Does not define a value.
294  };
295 
296  static uint16_t type(uint16_t T) { return T & TypeMask; }
297  static uint16_t kind(uint16_t T) { return T & KindMask; }
298  static uint16_t flags(uint16_t T) { return T & FlagMask; }
299 
300  static uint16_t set_type(uint16_t A, uint16_t T) {
301  return (A & ~TypeMask) | T;
302  }
303 
304  static uint16_t set_kind(uint16_t A, uint16_t K) {
305  return (A & ~KindMask) | K;
306  }
307 
308  static uint16_t set_flags(uint16_t A, uint16_t F) {
309  return (A & ~FlagMask) | F;
310  }
311 
312  // Test if A contains B.
313  static bool contains(uint16_t A, uint16_t B) {
314  if (type(A) != Code)
315  return false;
316  uint16_t KB = kind(B);
317  switch (kind(A)) {
318  case Func:
319  return KB == Block;
320  case Block:
321  return KB == Phi || KB == Stmt;
322  case Phi:
323  case Stmt:
324  return type(B) == Ref;
325  }
326  return false;
327  }
328  };
329 
330  struct BuildOptions {
331  enum : unsigned {
332  None = 0x00,
333  KeepDeadPhis = 0x01, // Do not remove dead phis during build.
334  };
335  };
336 
337  template <typename T> struct NodeAddr {
338  NodeAddr() : Addr(nullptr) {}
339  NodeAddr(T A, NodeId I) : Addr(A), Id(I) {}
340 
341  // Type cast (casting constructor). The reason for having this class
342  // instead of std::pair.
343  template <typename S> NodeAddr(const NodeAddr<S> &NA)
344  : Addr(static_cast<T>(NA.Addr)), Id(NA.Id) {}
345 
346  bool operator== (const NodeAddr<T> &NA) const {
347  assert((Addr == NA.Addr) == (Id == NA.Id));
348  return Addr == NA.Addr;
349  }
350  bool operator!= (const NodeAddr<T> &NA) const {
351  return !operator==(NA);
352  }
353 
355  NodeId Id = 0;
356  };
357 
358  struct NodeBase;
359 
360  // Fast memory allocation and translation between node id and node address.
361  // This is really the same idea as the one underlying the "bump pointer
362  // allocator", the difference being in the translation. A node id is
363  // composed of two components: the index of the block in which it was
364  // allocated, and the index within the block. With the default settings,
365  // where the number of nodes per block is 4096, the node id (minus 1) is:
366  //
367  // bit position: 11 0
368  // +----------------------------+--------------+
369  // | Index of the block |Index in block|
370  // +----------------------------+--------------+
371  //
372  // The actual node id is the above plus 1, to avoid creating a node id of 0.
373  //
374  // This method significantly improved the build time, compared to using maps
375  // (std::unordered_map or DenseMap) to translate between pointers and ids.
376  struct NodeAllocator {
377  // Amount of storage for a single node.
378  enum { NodeMemSize = 32 };
379 
381  : NodesPerBlock(NPB), BitsPerIndex(Log2_32(NPB)),
382  IndexMask((1 << BitsPerIndex)-1) {
383  assert(isPowerOf2_32(NPB));
384  }
385 
386  NodeBase *ptr(NodeId N) const {
387  uint32_t N1 = N-1;
388  uint32_t BlockN = N1 >> BitsPerIndex;
389  uint32_t Offset = (N1 & IndexMask) * NodeMemSize;
390  return reinterpret_cast<NodeBase*>(Blocks[BlockN]+Offset);
391  }
392 
393  NodeId id(const NodeBase *P) const;
395  void clear();
396 
397  private:
398  void startNewBlock();
399  bool needNewBlock();
400 
401  uint32_t makeId(uint32_t Block, uint32_t Index) const {
402  // Add 1 to the id, to avoid the id of 0, which is treated as "null".
403  return ((Block << BitsPerIndex) | Index) + 1;
404  }
405 
406  const uint32_t NodesPerBlock;
407  const uint32_t BitsPerIndex;
408  const uint32_t IndexMask;
409  char *ActiveEnd = nullptr;
410  std::vector<char*> Blocks;
412  AllocatorTy MemPool;
413  };
414 
415  struct RegisterRef {
418 
421  : Reg(R), Mask(R != 0 ? M : LaneBitmask::getNone()) {}
422 
423  operator bool() const { return Reg != 0 && Mask.any(); }
424  bool operator== (const RegisterRef &RR) const {
425  return Reg == RR.Reg && Mask == RR.Mask;
426  }
427  bool operator!= (const RegisterRef &RR) const {
428  return !operator==(RR);
429  }
430  bool operator< (const RegisterRef &RR) const {
431  return Reg < RR.Reg || (Reg == RR.Reg && Mask < RR.Mask);
432  }
433  };
434  typedef std::set<RegisterRef> RegisterSet;
435 
437  TargetOperandInfo(const TargetInstrInfo &tii) : TII(tii) {}
438  virtual ~TargetOperandInfo() = default;
439 
440  virtual bool isPreserving(const MachineInstr &In, unsigned OpNum) const;
441  virtual bool isClobbering(const MachineInstr &In, unsigned OpNum) const;
442  virtual bool isFixedReg(const MachineInstr &In, unsigned OpNum) const;
443 
445  };
446 
447  // Packed register reference. Only used for storage.
451  };
452 
453  // Template class for a map translating uint32_t into arbitrary types.
454  // The map will act like an indexed set: upon insertion of a new object,
455  // it will automatically assign a new index to it. Index of 0 is treated
456  // as invalid and is never allocated.
457  template <typename T, unsigned N = 32>
458  struct IndexedSet {
459  IndexedSet() : Map() { Map.reserve(N); }
460 
461  T get(uint32_t Idx) const {
462  // Index Idx corresponds to Map[Idx-1].
463  assert(Idx != 0 && !Map.empty() && Idx-1 < Map.size());
464  return Map[Idx-1];
465  }
466 
468  // Linear search.
469  auto F = llvm::find(Map, Val);
470  if (F != Map.end())
471  return F - Map.begin() + 1;
472  Map.push_back(Val);
473  return Map.size(); // Return actual_index + 1.
474  }
475 
476  uint32_t find(T Val) const {
477  auto F = llvm::find(Map, Val);
478  assert(F != Map.end());
479  return F - Map.begin();
480  }
481 
482  private:
483  std::vector<T> Map;
484  };
485 
486  struct LaneMaskIndex : private IndexedSet<LaneBitmask> {
487  LaneMaskIndex() = default;
488 
490  return K == 0 ? LaneBitmask::getAll() : get(K);
491  }
493  assert(LM.any());
494  return LM.all() ? 0 : insert(LM);
495  }
497  assert(LM.any());
498  return LM.all() ? 0 : find(LM);
499  }
500 
502  return { RR.Reg, getIndexForLaneMask(RR.Mask) };
503  }
505  return { RR.Reg, getIndexForLaneMask(RR.Mask) };
506  }
507 
509  return RegisterRef(PR.Reg, getLaneMaskForIndex(PR.MaskId));
510  }
511  };
512 
513  struct RegisterAggr {
515  : ExpAliasUnits(tri.getNumRegUnits()), CheckUnits(false), TRI(tri) {}
516  RegisterAggr(const RegisterAggr &RG) = default;
517 
518  bool empty() const { return Masks.empty(); }
519  bool hasAliasOf(RegisterRef RR) const;
520  bool hasCoverOf(RegisterRef RR) const;
521  static bool isCoverOf(RegisterRef RA, RegisterRef RB,
522  const TargetRegisterInfo &TRI) {
523  return RegisterAggr(TRI).insert(RA).hasCoverOf(RB);
524  }
525 
527  RegisterAggr &insert(const RegisterAggr &RG);
529  RegisterAggr &clear(const RegisterAggr &RG);
530 
531  RegisterRef clearIn(RegisterRef RR) const;
532 
533  void print(raw_ostream &OS) const;
534 
535  private:
536  typedef std::unordered_map<RegisterId, LaneBitmask> MapType;
537 
538  public:
539  typedef MapType::const_iterator iterator;
540  iterator begin() const { return Masks.begin(); }
541  iterator end() const { return Masks.end(); }
543 
544  private:
545  MapType Masks;
546  BitVector ExpAliasUnits; // Register units for explicit aliases.
547  bool CheckUnits;
548  const TargetRegisterInfo &TRI;
549  };
550 
551  struct NodeBase {
552  public:
553  // Make sure this is a POD.
554  NodeBase() = default;
555 
556  uint16_t getType() const { return NodeAttrs::type(Attrs); }
557  uint16_t getKind() const { return NodeAttrs::kind(Attrs); }
558  uint16_t getFlags() const { return NodeAttrs::flags(Attrs); }
559  NodeId getNext() const { return Next; }
560 
561  uint16_t getAttrs() const { return Attrs; }
562  void setAttrs(uint16_t A) { Attrs = A; }
563  void setFlags(uint16_t F) { setAttrs(NodeAttrs::set_flags(getAttrs(), F)); }
564 
565  // Insert node NA after "this" in the circular chain.
566  void append(NodeAddr<NodeBase*> NA);
567  // Initialize all members to 0.
568  void init() { memset(this, 0, sizeof *this); }
569  void setNext(NodeId N) { Next = N; }
570 
571  protected:
572  uint16_t Attrs;
573  uint16_t Reserved;
574  NodeId Next; // Id of the next node in the circular chain.
575  // Definitions of nested types. Using anonymous nested structs would make
576  // this class definition clearer, but unnamed structs are not a part of
577  // the standard.
578  struct Def_struct {
579  NodeId DD, DU; // Ids of the first reached def and use.
580  };
581  struct PhiU_struct {
582  NodeId PredB; // Id of the predecessor block for a phi use.
583  };
584  struct Code_struct {
585  void *CP; // Pointer to the actual code.
586  NodeId FirstM, LastM; // Id of the first member and last.
587  };
588  struct Ref_struct {
589  NodeId RD, Sib; // Ids of the reaching def and the sibling.
590  union {
593  };
594  union {
595  MachineOperand *Op; // Non-phi refs point to a machine operand.
596  PackedRegisterRef PR; // Phi refs store register info directly.
597  };
598  };
599 
600  // The actual payload.
601  union {
604  };
605  };
606  // The allocator allocates chunks of 32 bytes for each node. The fact that
607  // each node takes 32 bytes in memory is used for fast translation between
608  // the node id and the node address.
609  static_assert(sizeof(NodeBase) <= NodeAllocator::NodeMemSize,
610  "NodeBase must be at most NodeAllocator::NodeMemSize bytes");
611 
612  typedef std::vector<NodeAddr<NodeBase*>> NodeList;
613  typedef std::set<NodeId> NodeSet;
614 
615  struct RefNode : public NodeBase {
616  RefNode() = default;
617 
618  RegisterRef getRegRef(const DataFlowGraph &G) const;
619 
622  return *Ref.Op;
623  }
624 
625  void setRegRef(RegisterRef RR, DataFlowGraph &G);
627 
629  return Ref.RD;
630  }
632  Ref.RD = RD;
633  }
634 
635  NodeId getSibling() const {
636  return Ref.Sib;
637  }
638  void setSibling(NodeId Sib) {
639  Ref.Sib = Sib;
640  }
641 
642  bool isUse() const {
644  return getKind() == NodeAttrs::Use;
645  }
646 
647  bool isDef() const {
649  return getKind() == NodeAttrs::Def;
650  }
651 
652  template <typename Predicate>
654  const DataFlowGraph &G);
656  };
657 
658  struct DefNode : public RefNode {
660  return Ref.Def.DD;
661  }
663  Ref.Def.DD = D;
664  }
666  return Ref.Def.DU;
667  }
669  Ref.Def.DU = U;
670  }
671 
672  void linkToDef(NodeId Self, NodeAddr<DefNode*> DA);
673  };
674 
675  struct UseNode : public RefNode {
676  void linkToDef(NodeId Self, NodeAddr<DefNode*> DA);
677  };
678 
679  struct PhiUseNode : public UseNode {
682  return Ref.PhiU.PredB;
683  }
686  Ref.PhiU.PredB = B;
687  }
688  };
689 
690  struct CodeNode : public NodeBase {
691  template <typename T> T getCode() const {
692  return static_cast<T>(Code.CP);
693  }
694  void setCode(void *C) {
695  Code.CP = C;
696  }
697 
700  void addMember(NodeAddr<NodeBase*> NA, const DataFlowGraph &G);
702  const DataFlowGraph &G);
704 
705  NodeList members(const DataFlowGraph &G) const;
706  template <typename Predicate>
707  NodeList members_if(Predicate P, const DataFlowGraph &G) const;
708  };
709 
710  struct InstrNode : public CodeNode {
712  };
713 
714  struct PhiNode : public InstrNode {
716  return nullptr;
717  }
718  };
719 
720  struct StmtNode : public InstrNode {
722  return CodeNode::getCode<MachineInstr*>();
723  }
724  };
725 
726  struct BlockNode : public CodeNode {
728  return CodeNode::getCode<MachineBasicBlock*>();
729  }
730 
731  void addPhi(NodeAddr<PhiNode*> PA, const DataFlowGraph &G);
732  };
733 
734  struct FuncNode : public CodeNode {
736  return CodeNode::getCode<MachineFunction*>();
737  }
738 
740  const DataFlowGraph &G) const;
742  };
743 
744  struct DataFlowGraph {
746  const TargetRegisterInfo &tri, const MachineDominatorTree &mdt,
747  const MachineDominanceFrontier &mdf, const TargetOperandInfo &toi);
748 
749  NodeBase *ptr(NodeId N) const;
750  template <typename T> T ptr(NodeId N) const {
751  return static_cast<T>(ptr(N));
752  }
753 
754  NodeId id(const NodeBase *P) const;
755 
756  template <typename T> NodeAddr<T> addr(NodeId N) const {
757  return { ptr<T>(N), N };
758  }
759 
760  NodeAddr<FuncNode*> getFunc() const { return Func; }
761  MachineFunction &getMF() const { return MF; }
762  const TargetInstrInfo &getTII() const { return TII; }
763  const TargetRegisterInfo &getTRI() const { return TRI; }
764  const MachineDominatorTree &getDT() const { return MDT; }
765  const MachineDominanceFrontier &getDF() const { return MDF; }
766 
767  struct DefStack {
768  DefStack() = default;
769 
770  bool empty() const { return Stack.empty() || top() == bottom(); }
771 
772  private:
773  typedef NodeAddr<DefNode*> value_type;
774  struct Iterator {
775  typedef DefStack::value_type value_type;
776 
777  Iterator &up() { Pos = DS.nextUp(Pos); return *this; }
778  Iterator &down() { Pos = DS.nextDown(Pos); return *this; }
779 
780  value_type operator*() const {
781  assert(Pos >= 1);
782  return DS.Stack[Pos-1];
783  }
784  const value_type *operator->() const {
785  assert(Pos >= 1);
786  return &DS.Stack[Pos-1];
787  }
788  bool operator==(const Iterator &It) const { return Pos == It.Pos; }
789  bool operator!=(const Iterator &It) const { return Pos != It.Pos; }
790 
791  private:
792  Iterator(const DefStack &S, bool Top);
793 
794  // Pos-1 is the index in the StorageType object that corresponds to
795  // the top of the DefStack.
796  const DefStack &DS;
797  unsigned Pos;
798  friend struct DefStack;
799  };
800 
801  public:
803  iterator top() const { return Iterator(*this, true); }
804  iterator bottom() const { return Iterator(*this, false); }
805  unsigned size() const;
806 
807  void push(NodeAddr<DefNode*> DA) { Stack.push_back(DA); }
808  void pop();
809  void start_block(NodeId N);
810  void clear_block(NodeId N);
811 
812  private:
813  friend struct Iterator;
814  typedef std::vector<value_type> StorageType;
815 
816  bool isDelimiter(const StorageType::value_type &P, NodeId N = 0) const {
817  return (P.Addr == nullptr) && (N == 0 || P.Id == N);
818  }
819 
820  unsigned nextUp(unsigned P) const;
821  unsigned nextDown(unsigned P) const;
822 
823  StorageType Stack;
824  };
825 
826  // Make this std::unordered_map for speed of accessing elements.
827  // Map: Register (physical or virtual) -> DefStack
828  typedef std::unordered_map<RegisterId,DefStack> DefStackMap;
829 
830  void build(unsigned Options = BuildOptions::None);
831  void pushDefs(NodeAddr<InstrNode*> IA, DefStackMap &DM);
832  void markBlock(NodeId B, DefStackMap &DefM);
833  void releaseBlock(NodeId B, DefStackMap &DefM);
834 
835  PackedRegisterRef pack(RegisterRef RR) { return LMI.pack(RR); }
836  PackedRegisterRef pack(RegisterRef RR) const { return LMI.pack(RR); }
837  RegisterRef unpack(PackedRegisterRef PR) const { return LMI.unpack(PR); }
838  RegisterRef makeRegRef(unsigned Reg, unsigned Sub) const;
841 
843  NodeAddr<RefNode*> RA) const;
845  NodeAddr<RefNode*> RA, bool Create);
847  NodeAddr<RefNode*> RA) const;
849  NodeAddr<RefNode*> RA, bool Create);
851  NodeAddr<RefNode*> RA) const;
852 
854  NodeAddr<RefNode*> RA) const;
855 
856  void unlinkUse(NodeAddr<UseNode*> UA, bool RemoveFromOwner) {
857  unlinkUseDF(UA);
858  if (RemoveFromOwner)
859  removeFromOwner(UA);
860  }
861 
862  void unlinkDef(NodeAddr<DefNode*> DA, bool RemoveFromOwner) {
863  unlinkDefDF(DA);
864  if (RemoveFromOwner)
865  removeFromOwner(DA);
866  }
867 
868  // Some useful filters.
869  template <uint16_t Kind>
870  static bool IsRef(const NodeAddr<NodeBase*> BA) {
871  return BA.Addr->getType() == NodeAttrs::Ref &&
872  BA.Addr->getKind() == Kind;
873  }
874 
875  template <uint16_t Kind>
876  static bool IsCode(const NodeAddr<NodeBase*> BA) {
877  return BA.Addr->getType() == NodeAttrs::Code &&
878  BA.Addr->getKind() == Kind;
879  }
880 
881  static bool IsDef(const NodeAddr<NodeBase*> BA) {
882  return BA.Addr->getType() == NodeAttrs::Ref &&
883  BA.Addr->getKind() == NodeAttrs::Def;
884  }
885 
886  static bool IsUse(const NodeAddr<NodeBase*> BA) {
887  return BA.Addr->getType() == NodeAttrs::Ref &&
888  BA.Addr->getKind() == NodeAttrs::Use;
889  }
890 
891  static bool IsPhi(const NodeAddr<NodeBase*> BA) {
892  return BA.Addr->getType() == NodeAttrs::Code &&
893  BA.Addr->getKind() == NodeAttrs::Phi;
894  }
895 
896  static bool IsPreservingDef(const NodeAddr<DefNode*> DA) {
897  uint16_t Flags = DA.Addr->getFlags();
898  return (Flags & NodeAttrs::Preserving) && !(Flags & NodeAttrs::Undef);
899  }
900 
901  // Register aliasing.
902  bool alias(RegisterRef RA, RegisterRef RB) const;
903 
904  private:
905  void reset();
906 
907  RegisterSet getAliasSet(RegisterId Reg) const;
908  RegisterSet getLandingPadLiveIns() const;
909 
910  NodeAddr<NodeBase*> newNode(uint16_t Attrs);
911  NodeAddr<NodeBase*> cloneNode(const NodeAddr<NodeBase*> B);
913  MachineOperand &Op, uint16_t Flags = NodeAttrs::None);
916  uint16_t Flags = NodeAttrs::PhiRef);
918  MachineOperand &Op, uint16_t Flags = NodeAttrs::None);
920  RegisterRef RR, uint16_t Flags = NodeAttrs::PhiRef);
923  MachineInstr *MI);
925  MachineBasicBlock *BB);
927 
928  template <typename Predicate>
929  std::pair<NodeAddr<RefNode*>,NodeAddr<RefNode*>>
930  locateNextRef(NodeAddr<InstrNode*> IA, NodeAddr<RefNode*> RA,
931  Predicate P) const;
932 
933  typedef std::map<NodeId,RegisterSet> BlockRefsMap;
934 
935  void buildStmt(NodeAddr<BlockNode*> BA, MachineInstr &In);
936  void buildBlockRefs(NodeAddr<BlockNode*> BA, BlockRefsMap &RefM);
937  void recordDefsForDF(BlockRefsMap &PhiM, BlockRefsMap &RefM,
939  void buildPhis(BlockRefsMap &PhiM, BlockRefsMap &RefM,
941  void removeUnusedPhis();
942 
943  template <typename T> void linkRefUp(NodeAddr<InstrNode*> IA,
944  NodeAddr<T> TA, DefStack &DS);
945  void linkStmtRefs(DefStackMap &DefM, NodeAddr<StmtNode*> SA);
946  void linkBlockRefs(DefStackMap &DefM, NodeAddr<BlockNode*> BA);
947 
948  void unlinkUseDF(NodeAddr<UseNode*> UA);
949  void unlinkDefDF(NodeAddr<DefNode*> DA);
950 
951  void removeFromOwner(NodeAddr<RefNode*> RA) {
952  NodeAddr<InstrNode*> IA = RA.Addr->getOwner(*this);
953  IA.Addr->removeMember(RA, *this);
954  }
955 
956  NodeAddr<BlockNode*> findBlock(MachineBasicBlock *BB) {
957  return BlockNodes[BB];
958  }
959 
960  NodeAddr<FuncNode*> Func;
961  NodeAllocator Memory;
962  // Local map: MachineBasicBlock -> NodeAddr<BlockNode*>
963  std::map<MachineBasicBlock*,NodeAddr<BlockNode*>> BlockNodes;
964  // Lane mask map.
965  LaneMaskIndex LMI;
966 
967  MachineFunction &MF;
968  const TargetInstrInfo &TII;
969  const TargetRegisterInfo &TRI;
970  const MachineDominatorTree &MDT;
971  const MachineDominanceFrontier &MDF;
972  const TargetOperandInfo &TOI;
973  }; // struct DataFlowGraph
974 
975  template <typename Predicate>
977  bool NextOnly, const DataFlowGraph &G) {
978  // Get the "Next" reference in the circular list that references RR and
979  // satisfies predicate "Pred".
980  auto NA = G.addr<NodeBase*>(getNext());
981 
982  while (NA.Addr != this) {
983  if (NA.Addr->getType() == NodeAttrs::Ref) {
984  NodeAddr<RefNode*> RA = NA;
985  if (RA.Addr->getRegRef(G) == RR && P(NA))
986  return NA;
987  if (NextOnly)
988  break;
989  NA = G.addr<NodeBase*>(NA.Addr->getNext());
990  } else {
991  // We've hit the beginning of the chain.
992  assert(NA.Addr->getType() == NodeAttrs::Code);
993  NodeAddr<CodeNode*> CA = NA;
994  NA = CA.Addr->getFirstMember(G);
995  }
996  }
997  // Return the equivalent of "nullptr" if such a node was not found.
998  return NodeAddr<RefNode*>();
999  }
1000 
1001  template <typename Predicate>
1003  NodeList MM;
1004  auto M = getFirstMember(G);
1005  if (M.Id == 0)
1006  return MM;
1007 
1008  while (M.Addr != this) {
1009  if (P(M))
1010  MM.push_back(M);
1011  M = G.addr<NodeBase*>(M.Addr->getNext());
1012  }
1013  return MM;
1014  }
1015 
1016  // Optionally print the lane mask, if it is not ~0.
1020  };
1022 
1023  template <typename T> struct Print;
1024  template <typename T>
1025  raw_ostream &operator<< (raw_ostream &OS, const Print<T> &P);
1026 
1027  template <typename T>
1028  struct Print {
1029  Print(const T &x, const DataFlowGraph &g) : Obj(x), G(g) {}
1030  const T &Obj;
1032  };
1033 
1034  template <typename T>
1035  struct PrintNode : Print<NodeAddr<T>> {
1037  : Print<NodeAddr<T>>(x, g) {}
1038  };
1039 
1040 } // end namespace rdf
1041 
1042 } // end namespace llvm
1043 
1044 #endif // LLVM_LIB_TARGET_HEXAGON_RDFGRAPH_H
NodeList members(const DataFlowGraph &G) const
Definition: RDFGraph.cpp:541
raw_ostream & operator<<(raw_ostream &OS, const PrintLaneMaskOpt &P)
Definition: RDFGraph.cpp:47
void pushDefs(NodeAddr< InstrNode * > IA, DefStackMap &DM)
Definition: RDFGraph.cpp:1140
void setReachingDef(NodeId RD)
Definition: RDFGraph.h:631
MachineFunction & getMF() const
Definition: RDFGraph.h:761
A common definition of LaneBitmask for use in TableGen and CodeGen.
PrintLaneMaskOpt(LaneBitmask M)
Definition: RDFGraph.h:1018
RegisterRef restrictRef(RegisterRef AR, RegisterRef BR) const
Definition: RDFGraph.cpp:1097
static uint16_t kind(uint16_t T)
Definition: RDFGraph.h:297
LaneBitmask getLaneMaskForIndex(uint32_t K) const
Definition: RDFGraph.h:489
bool alias(RegisterRef RA, RegisterRef RB) const
Definition: RDFGraph.cpp:1207
virtual ~TargetOperandInfo()=default
NodeAddr< RefNode * > getNextRelated(NodeAddr< InstrNode * > IA, NodeAddr< RefNode * > RA) const
Definition: RDFGraph.cpp:1272
void linkToDef(NodeId Self, NodeAddr< DefNode * > DA)
Definition: RDFGraph.cpp:467
void setCode(void *C)
Definition: RDFGraph.h:694
void setNext(NodeId N)
Definition: RDFGraph.h:569
NodeAddr< NodeBase * > New()
Definition: RDFGraph.cpp:379
NodeId getReachedDef() const
Definition: RDFGraph.h:659
uint16_t getFlags() const
Definition: RDFGraph.h:558
bool operator!=(const NodeAddr< T > &NA) const
Definition: RDFGraph.h:350
static uint16_t type(uint16_t T)
Definition: RDFGraph.h:296
NodeBase * ptr(NodeId N) const
Definition: RDFGraph.cpp:887
bool operator==(const RegisterRef &RR) const
Definition: RDFGraph.h:424
Code_struct Code
Definition: RDFGraph.h:603
static LaneBitmask getAll()
Definition: LaneBitmask.h:75
void push(NodeAddr< DefNode * > DA)
Definition: RDFGraph.h:807
static bool IsPreservingDef(const NodeAddr< DefNode * > DA)
Definition: RDFGraph.h:896
uint32_t RegisterId
Definition: RDFGraph.h:263
const TargetInstrInfo & getTII() const
Definition: RDFGraph.h:762
virtual bool isPreserving(const MachineInstr &In, unsigned OpNum) const
Definition: RDFGraph.cpp:612
DataFlowGraph(MachineFunction &mf, const TargetInstrInfo &tii, const TargetRegisterInfo &tri, const MachineDominatorTree &mdt, const MachineDominanceFrontier &mdf, const TargetOperandInfo &toi)
Definition: RDFGraph.cpp:764
uint16_t getAttrs() const
Definition: RDFGraph.h:561
bool operator==(const NodeAddr< T > &NA) const
Definition: RDFGraph.h:346
iterator begin() const
Definition: RDFGraph.h:540
RegisterRef(RegisterId R, LaneBitmask M=LaneBitmask::getAll())
Definition: RDFGraph.h:420
MachineOperand & getOp()
Definition: RDFGraph.h:620
MachineInstr * getCode() const
Definition: RDFGraph.h:715
static bool isCoverOf(RegisterRef RA, RegisterRef RB, const TargetRegisterInfo &TRI)
Definition: RDFGraph.h:521
const T & Obj
Definition: RDFGraph.h:1030
This file defines the MallocAllocator and BumpPtrAllocator interfaces.
void unlinkUse(NodeAddr< UseNode * > UA, bool RemoveFromOwner)
Definition: RDFGraph.h:856
void releaseBlock(NodeId B, DefStackMap &DefM)
Definition: RDFGraph.cpp:1122
const TargetInstrInfo & TII
Definition: RDFGraph.h:444
PackedRegisterRef pack(RegisterRef RR) const
Definition: RDFGraph.h:836
struct fuzzer::@269 Flags
const HexagonInstrInfo * TII
NodeList getRelatedRefs(NodeAddr< InstrNode * > IA, NodeAddr< RefNode * > RA) const
Definition: RDFGraph.cpp:1193
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
NodeId getReachedUse() const
Definition: RDFGraph.h:665
static GCRegistry::Add< StatepointGC > D("statepoint-example","an example strategy for statepoint")
Reg
All possible values of the reg field in the ModR/M byte.
NodeAddr< NodeBase * > getFirstMember(const DataFlowGraph &G) const
Definition: RDFGraph.cpp:474
std::vector< NodeAddr< NodeBase * > > NodeList
Definition: RDFGraph.h:610
constexpr bool any() const
Definition: LaneBitmask.h:51
void append(NodeAddr< NodeBase * > NA)
Definition: RDFGraph.cpp:410
bool isDef() const
Definition: RDFGraph.h:647
#define F(x, y, z)
Definition: MD5.cpp:51
iterator end() const
Definition: RDFGraph.h:541
RegisterRef unpack(PackedRegisterRef PR) const
Definition: RDFGraph.h:508
static bool IsDef(const NodeAddr< NodeBase * > BA)
Definition: RDFGraph.h:881
uint16_t getType() const
Definition: RDFGraph.h:556
#define T
MachineFunction * getCode() const
Definition: RDFGraph.h:735
Function Alias Analysis false
void print(raw_ostream &OS) const
Definition: RDFGraph.cpp:753
uint32_t find(T Val) const
Definition: RDFGraph.h:476
uint32_t insert(T Val)
Definition: RDFGraph.h:467
virtual bool isClobbering(const MachineInstr &In, unsigned OpNum) const
Definition: RDFGraph.cpp:618
static uint16_t set_flags(uint16_t A, uint16_t F)
Definition: RDFGraph.h:308
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
NodeAddr< BlockNode * > findBlock(const MachineBasicBlock *BB, const DataFlowGraph &G) const
Definition: RDFGraph.cpp:590
void addMember(NodeAddr< NodeBase * > NA, const DataFlowGraph &G)
Definition: RDFGraph.cpp:488
NodeAddr< NodeBase * > getOwner(const DataFlowGraph &G)
Definition: RDFGraph.cpp:547
NodeList members_if(Predicate P, const DataFlowGraph &G) const
Definition: RDFGraph.h:1002
Ref_struct Ref
Definition: RDFGraph.h:602
const TargetRegisterInfo & getTRI() const
Definition: RDFGraph.h:763
TargetInstrInfo - Interface to description of machine instruction set.
void linkToDef(NodeId Self, NodeAddr< DefNode * > DA)
Definition: RDFGraph.cpp:460
NodeAllocator(uint32_t NPB=4096)
Definition: RDFGraph.h:380
RegisterAggr & clear(RegisterRef RR)
Definition: RDFGraph.cpp:726
void setFlags(uint16_t F)
Definition: RDFGraph.h:563
void setReachedDef(NodeId D)
Definition: RDFGraph.h:662
#define P(N)
static bool IsRef(const NodeAddr< NodeBase * > BA)
Definition: RDFGraph.h:870
Control flow instructions. These all have token chains.
Definition: ISDOpcodes.h:551
bool hasCoverOf(RegisterRef RR) const
Definition: RDFGraph.cpp:688
PrintNode(const NodeAddr< T > &x, const DataFlowGraph &g)
Definition: RDFGraph.h:1036
constexpr bool isPowerOf2_32(uint32_t Value)
isPowerOf2_32 - This function returns true if the argument is a power of two > 0. ...
Definition: MathExtras.h:399
uint16_t getKind() const
Definition: RDFGraph.h:557
LaneBitmask Mask
Definition: RDFGraph.h:417
NodeAddr< BlockNode * > getEntryBlock(const DataFlowGraph &G)
Definition: RDFGraph.cpp:602
NodeId getNext() const
Definition: RDFGraph.h:559
uint32_t Offset
static uint16_t flags(uint16_t T)
Definition: RDFGraph.h:298
TargetOperandInfo(const TargetInstrInfo &tii)
Definition: RDFGraph.h:437
bool operator!=(const RegisterRef &RR) const
Definition: RDFGraph.h:427
static bool IsCode(const NodeAddr< NodeBase * > BA)
Definition: RDFGraph.h:876
MapType::const_iterator iterator
Definition: RDFGraph.h:539
NodeAddr< RefNode * > getNextImp(NodeAddr< InstrNode * > IA, NodeAddr< RefNode * > RA, bool Create)
static bool IsPhi(const NodeAddr< NodeBase * > BA)
Definition: RDFGraph.h:891
static bool contains(uint16_t A, uint16_t B)
Definition: RDFGraph.h:313
virtual bool isFixedReg(const MachineInstr &In, unsigned OpNum) const
Definition: RDFGraph.cpp:627
BlockMass operator*(BlockMass L, BranchProbability R)
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
PackedRegisterRef pack(RegisterRef RR) const
Definition: RDFGraph.h:504
uint32_t NodeId
Definition: RDFGraph.h:262
const DataFlowGraph & G
Definition: RDFGraph.h:1031
NodeId getPredecessor() const
Definition: RDFGraph.h:680
NodeAddr< NodeBase * > getLastMember(const DataFlowGraph &G) const
Definition: RDFGraph.cpp:481
void setPredecessor(NodeId B)
Definition: RDFGraph.h:684
RegisterAggr & insert(RegisterRef RR)
Definition: RDFGraph.cpp:699
void markBlock(NodeId B, DefStackMap &DefM)
Definition: RDFGraph.cpp:1115
auto find(R &&Range, const T &Val) -> decltype(std::begin(Range))
Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:757
const MachineDominanceFrontier & getDF() const
Definition: RDFGraph.h:765
MachineOperand class - Representation of each machine instruction operand.
NodeId getSibling() const
Definition: RDFGraph.h:635
NodeAddr(const NodeAddr< S > &NA)
Definition: RDFGraph.h:343
const DataFlowGraph & G
Definition: RDFGraph.cpp:206
NodeId id(const NodeBase *P) const
Definition: RDFGraph.cpp:894
T ptr(NodeId N) const
Definition: RDFGraph.h:750
void setAttrs(uint16_t A)
Definition: RDFGraph.h:562
static uint16_t set_type(uint16_t A, uint16_t T)
Definition: RDFGraph.h:300
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
PackedRegisterRef pack(RegisterRef RR)
Definition: RDFGraph.h:501
void addPhi(NodeAddr< PhiNode * > PA, const DataFlowGraph &G)
Definition: RDFGraph.cpp:560
unsigned Log2_32(uint32_t Value)
Log2_32 - This function returns the floor log base 2 of the specified value, -1 if the value is zero...
Definition: MathExtras.h:513
std::unordered_map< RegisterId, DefStack > DefStackMap
Definition: RDFGraph.h:828
const MachineDominatorTree & getDT() const
Definition: RDFGraph.h:764
std::set< NodeId > NodeSet
Definition: RDFGraph.h:613
NodeAddr< FuncNode * > getFunc() const
Definition: RDFGraph.h:760
RegisterRef getRegRef(const DataFlowGraph &G) const
Definition: RDFGraph.cpp:422
static bool IsUse(const NodeAddr< NodeBase * > BA)
Definition: RDFGraph.h:886
T getCode() const
Definition: RDFGraph.h:691
RegisterRef unpack(PackedRegisterRef PR) const
Definition: RDFGraph.h:837
bool operator!=(uint64_t V1, const APInt &V2)
Definition: APInt.h:1724
Representation of each machine instruction.
Definition: MachineInstr.h:52
NodeAddr< NodeBase * > getOwner(const DataFlowGraph &G)
Definition: RDFGraph.cpp:448
RegisterRef clearIn(RegisterRef RR) const
Definition: RDFGraph.cpp:745
static uint16_t set_kind(uint16_t A, uint16_t K)
Definition: RDFGraph.h:304
void setRegRef(RegisterRef RR, DataFlowGraph &G)
Definition: RDFGraph.cpp:432
bool empty() const
Definition: RDFGraph.h:518
PackedRegisterRef pack(RegisterRef RR)
Definition: RDFGraph.h:835
RegisterRef makeRegRef(unsigned Reg, unsigned Sub) const
Definition: RDFGraph.cpp:1073
void addMemberAfter(NodeAddr< NodeBase * > MA, NodeAddr< NodeBase * > NA, const DataFlowGraph &G)
Definition: RDFGraph.cpp:501
uint16_t Reserved
Definition: RDFGraph.h:573
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
void build(unsigned Options=BuildOptions::None)
Definition: RDFGraph.cpp:989
constexpr bool all() const
Definition: LaneBitmask.h:52
MachineBasicBlock * getCode() const
Definition: RDFGraph.h:727
RegisterRef normalizeRef(RegisterRef RR) const
Definition: RDFGraph.cpp:1080
Print(const T &x, const DataFlowGraph &g)
Definition: RDFGraph.h:1029
const unsigned Kind
bool operator<(const RegisterRef &RR) const
Definition: RDFGraph.h:430
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool isUse() const
Definition: RDFGraph.h:642
void removeMember(NodeAddr< NodeBase * > NA, const DataFlowGraph &G)
Definition: RDFGraph.cpp:509
NodeId id(const NodeBase *P) const
Definition: RDFGraph.cpp:391
void unlinkDef(NodeAddr< DefNode * > DA, bool RemoveFromOwner)
Definition: RDFGraph.h:862
MachineInstr * getCode() const
Definition: RDFGraph.h:721
NodeAddr< T > addr(NodeId N) const
Definition: RDFGraph.h:756
NodeId getReachingDef() const
Definition: RDFGraph.h:628
RegisterRef normalize(RegisterRef RR) const
Definition: RDFGraph.cpp:657
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:81
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
bool hasAliasOf(RegisterRef RR) const
Definition: RDFGraph.cpp:673
NodeBase * ptr(NodeId N) const
Definition: RDFGraph.h:386
IRTranslator LLVM IR MI
std::set< RegisterRef > RegisterSet
Definition: RDFGraph.h:434
RegisterAggr(const TargetRegisterInfo &tri)
Definition: RDFGraph.h:514
bool operator==(uint64_t V1, const APInt &V2)
Definition: APInt.h:1722
NodeAddr(T A, NodeId I)
Definition: RDFGraph.h:339
uint32_t getIndexForLaneMask(LaneBitmask LM) const
Definition: RDFGraph.h:496
NodeAddr< RefNode * > getNextRef(RegisterRef RR, Predicate P, bool NextOnly, const DataFlowGraph &G)
Definition: RDFGraph.h:976
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
NodeAddr< RefNode * > getNextShadow(NodeAddr< InstrNode * > IA, NodeAddr< RefNode * > RA, bool Create)
Definition: RDFGraph.cpp:1333
void setReachedUse(NodeId U)
Definition: RDFGraph.h:668
uint32_t getIndexForLaneMask(LaneBitmask LM)
Definition: RDFGraph.h:492
void setSibling(NodeId Sib)
Definition: RDFGraph.h:638