LLVM  6.0.0svn
GVNExpression.h
Go to the documentation of this file.
1 //===- GVNExpression.h - GVN Expression classes -----------------*- 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 /// \file
11 ///
12 /// The header file for the GVN pass that contains expression handling
13 /// classes
14 //
15 //===----------------------------------------------------------------------===//
16 
17 #ifndef LLVM_TRANSFORMS_SCALAR_GVNEXPRESSION_H
18 #define LLVM_TRANSFORMS_SCALAR_GVNEXPRESSION_H
19 
20 #include "llvm/ADT/Hashing.h"
23 #include "llvm/IR/Constant.h"
24 #include "llvm/IR/Instructions.h"
25 #include "llvm/IR/Value.h"
26 #include "llvm/Support/Allocator.h"
28 #include "llvm/Support/Casting.h"
29 #include "llvm/Support/Compiler.h"
31 #include <algorithm>
32 #include <cassert>
33 #include <iterator>
34 #include <utility>
35 
36 namespace llvm {
37 
38 class BasicBlock;
39 class Type;
40 
41 namespace GVNExpression {
42 
59 };
60 
61 class Expression {
62 private:
63  ExpressionType EType;
64  unsigned Opcode;
65  mutable hash_code HashVal = 0;
66 
67 public:
68  Expression(ExpressionType ET = ET_Base, unsigned O = ~2U)
69  : EType(ET), Opcode(O) {}
70  Expression(const Expression &) = delete;
71  Expression &operator=(const Expression &) = delete;
72  virtual ~Expression();
73 
74  static unsigned getEmptyKey() { return ~0U; }
75  static unsigned getTombstoneKey() { return ~1U; }
76 
77  bool operator!=(const Expression &Other) const { return !(*this == Other); }
78  bool operator==(const Expression &Other) const {
79  if (getOpcode() != Other.getOpcode())
80  return false;
81  if (getOpcode() == getEmptyKey() || getOpcode() == getTombstoneKey())
82  return true;
83  // Compare the expression type for anything but load and store.
84  // For load and store we set the opcode to zero to make them equal.
87  return false;
88 
89  return equals(Other);
90  }
91 
93  // It's theoretically possible for a thing to hash to zero. In that case,
94  // we will just compute the hash a few extra times, which is no worse that
95  // we did before, which was to compute it always.
96  if (static_cast<unsigned>(HashVal) == 0)
97  HashVal = getHashValue();
98  return HashVal;
99  }
100 
101  virtual bool equals(const Expression &Other) const { return true; }
102 
103  // Return true if the two expressions are exactly the same, including the
104  // normally ignored fields.
105  virtual bool exactlyEquals(const Expression &Other) const {
106  return getExpressionType() == Other.getExpressionType() && equals(Other);
107  }
108 
109  unsigned getOpcode() const { return Opcode; }
110  void setOpcode(unsigned opcode) { Opcode = opcode; }
111  ExpressionType getExpressionType() const { return EType; }
112 
113  // We deliberately leave the expression type out of the hash value.
114  virtual hash_code getHashValue() const { return getOpcode(); }
115 
116  // Debugging support
117  virtual void printInternal(raw_ostream &OS, bool PrintEType) const {
118  if (PrintEType)
119  OS << "etype = " << getExpressionType() << ",";
120  OS << "opcode = " << getOpcode() << ", ";
121  }
122 
123  void print(raw_ostream &OS) const {
124  OS << "{ ";
125  printInternal(OS, true);
126  OS << "}";
127  }
128 
129  LLVM_DUMP_METHOD void dump() const;
130 };
131 
133  E.print(OS);
134  return OS;
135 }
136 
137 class BasicExpression : public Expression {
138 private:
141 
142  Value **Operands = nullptr;
143  unsigned MaxOperands;
144  unsigned NumOperands = 0;
145  Type *ValueType = nullptr;
146 
147 public:
148  BasicExpression(unsigned NumOperands)
149  : BasicExpression(NumOperands, ET_Basic) {}
150  BasicExpression(unsigned NumOperands, ExpressionType ET)
151  : Expression(ET), MaxOperands(NumOperands) {}
152  BasicExpression() = delete;
153  BasicExpression(const BasicExpression &) = delete;
154  BasicExpression &operator=(const BasicExpression &) = delete;
155  ~BasicExpression() override;
156 
157  static bool classof(const Expression *EB) {
159  return ET > ET_BasicStart && ET < ET_BasicEnd;
160  }
161 
162  /// \brief Swap two operands. Used during GVN to put commutative operands in
163  /// order.
164  void swapOperands(unsigned First, unsigned Second) {
165  std::swap(Operands[First], Operands[Second]);
166  }
167 
168  Value *getOperand(unsigned N) const {
169  assert(Operands && "Operands not allocated");
170  assert(N < NumOperands && "Operand out of range");
171  return Operands[N];
172  }
173 
174  void setOperand(unsigned N, Value *V) {
175  assert(Operands && "Operands not allocated before setting");
176  assert(N < NumOperands && "Operand out of range");
177  Operands[N] = V;
178  }
179 
180  unsigned getNumOperands() const { return NumOperands; }
181 
182  using op_iterator = Value **;
183  using const_op_iterator = Value *const *;
184 
185  op_iterator op_begin() { return Operands; }
186  op_iterator op_end() { return Operands + NumOperands; }
187  const_op_iterator op_begin() const { return Operands; }
188  const_op_iterator op_end() const { return Operands + NumOperands; }
190  return iterator_range<op_iterator>(op_begin(), op_end());
191  }
193  return iterator_range<const_op_iterator>(op_begin(), op_end());
194  }
195 
197  assert(NumOperands < MaxOperands && "Tried to add too many operands");
198  assert(Operands && "Operandss not allocated before pushing");
199  Operands[NumOperands++] = Arg;
200  }
201  bool op_empty() const { return getNumOperands() == 0; }
202 
204  assert(!Operands && "Operands already allocated");
205  Operands = Recycler.allocate(RecyclerCapacity::get(MaxOperands), Allocator);
206  }
208  Recycler.deallocate(RecyclerCapacity::get(MaxOperands), Operands);
209  }
210 
211  void setType(Type *T) { ValueType = T; }
212  Type *getType() const { return ValueType; }
213 
214  bool equals(const Expression &Other) const override {
215  if (getOpcode() != Other.getOpcode())
216  return false;
217 
218  const auto &OE = cast<BasicExpression>(Other);
219  return getType() == OE.getType() && NumOperands == OE.NumOperands &&
220  std::equal(op_begin(), op_end(), OE.op_begin());
221  }
222 
223  hash_code getHashValue() const override {
224  return hash_combine(this->Expression::getHashValue(), ValueType,
225  hash_combine_range(op_begin(), op_end()));
226  }
227 
228  // Debugging support
229  void printInternal(raw_ostream &OS, bool PrintEType) const override {
230  if (PrintEType)
231  OS << "ExpressionTypeBasic, ";
232 
233  this->Expression::printInternal(OS, false);
234  OS << "operands = {";
235  for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
236  OS << "[" << i << "] = ";
237  Operands[i]->printAsOperand(OS);
238  OS << " ";
239  }
240  OS << "} ";
241  }
242 };
243 
245  : public std::iterator<std::output_iterator_tag, void, void, void, void> {
246 private:
247  using Container = BasicExpression;
248 
249  Container *BE;
250 
251 public:
252  explicit op_inserter(BasicExpression &E) : BE(&E) {}
253  explicit op_inserter(BasicExpression *E) : BE(E) {}
254 
256  BE->op_push_back(val);
257  return *this;
258  }
259  op_inserter &operator*() { return *this; }
260  op_inserter &operator++() { return *this; }
261  op_inserter &operator++(int) { return *this; }
262 };
263 
265 private:
266  const MemoryAccess *MemoryLeader;
267 
268 public:
269  MemoryExpression(unsigned NumOperands, enum ExpressionType EType,
270  const MemoryAccess *MemoryLeader)
271  : BasicExpression(NumOperands, EType), MemoryLeader(MemoryLeader) {}
272  MemoryExpression() = delete;
273  MemoryExpression(const MemoryExpression &) = delete;
274  MemoryExpression &operator=(const MemoryExpression &) = delete;
275 
276  static bool classof(const Expression *EB) {
277  return EB->getExpressionType() > ET_MemoryStart &&
279  }
280 
281  hash_code getHashValue() const override {
282  return hash_combine(this->BasicExpression::getHashValue(), MemoryLeader);
283  }
284 
285  bool equals(const Expression &Other) const override {
286  if (!this->BasicExpression::equals(Other))
287  return false;
288  const MemoryExpression &OtherMCE = cast<MemoryExpression>(Other);
289 
290  return MemoryLeader == OtherMCE.MemoryLeader;
291  }
292 
293  const MemoryAccess *getMemoryLeader() const { return MemoryLeader; }
294  void setMemoryLeader(const MemoryAccess *ML) { MemoryLeader = ML; }
295 };
296 
297 class CallExpression final : public MemoryExpression {
298 private:
299  CallInst *Call;
300 
301 public:
302  CallExpression(unsigned NumOperands, CallInst *C,
303  const MemoryAccess *MemoryLeader)
304  : MemoryExpression(NumOperands, ET_Call, MemoryLeader), Call(C) {}
305  CallExpression() = delete;
306  CallExpression(const CallExpression &) = delete;
307  CallExpression &operator=(const CallExpression &) = delete;
308  ~CallExpression() override;
309 
310  static bool classof(const Expression *EB) {
311  return EB->getExpressionType() == ET_Call;
312  }
313 
314  // Debugging support
315  void printInternal(raw_ostream &OS, bool PrintEType) const override {
316  if (PrintEType)
317  OS << "ExpressionTypeCall, ";
318  this->BasicExpression::printInternal(OS, false);
319  OS << " represents call at ";
320  Call->printAsOperand(OS);
321  }
322 };
323 
324 class LoadExpression final : public MemoryExpression {
325 private:
326  LoadInst *Load;
327  unsigned Alignment;
328 
329 public:
330  LoadExpression(unsigned NumOperands, LoadInst *L,
331  const MemoryAccess *MemoryLeader)
332  : LoadExpression(ET_Load, NumOperands, L, MemoryLeader) {}
333 
334  LoadExpression(enum ExpressionType EType, unsigned NumOperands, LoadInst *L,
335  const MemoryAccess *MemoryLeader)
336  : MemoryExpression(NumOperands, EType, MemoryLeader), Load(L) {
337  Alignment = L ? L->getAlignment() : 0;
338  }
339 
340  LoadExpression() = delete;
341  LoadExpression(const LoadExpression &) = delete;
342  LoadExpression &operator=(const LoadExpression &) = delete;
343  ~LoadExpression() override;
344 
345  static bool classof(const Expression *EB) {
346  return EB->getExpressionType() == ET_Load;
347  }
348 
349  LoadInst *getLoadInst() const { return Load; }
350  void setLoadInst(LoadInst *L) { Load = L; }
351 
352  unsigned getAlignment() const { return Alignment; }
353  void setAlignment(unsigned Align) { Alignment = Align; }
354 
355  bool equals(const Expression &Other) const override;
356  bool exactlyEquals(const Expression &Other) const override {
357  return Expression::exactlyEquals(Other) &&
358  cast<LoadExpression>(Other).getLoadInst() == getLoadInst();
359  }
360 
361  // Debugging support
362  void printInternal(raw_ostream &OS, bool PrintEType) const override {
363  if (PrintEType)
364  OS << "ExpressionTypeLoad, ";
365  this->BasicExpression::printInternal(OS, false);
366  OS << " represents Load at ";
367  Load->printAsOperand(OS);
368  OS << " with MemoryLeader " << *getMemoryLeader();
369  }
370 };
371 
372 class StoreExpression final : public MemoryExpression {
373 private:
374  StoreInst *Store;
375  Value *StoredValue;
376 
377 public:
378  StoreExpression(unsigned NumOperands, StoreInst *S, Value *StoredValue,
379  const MemoryAccess *MemoryLeader)
380  : MemoryExpression(NumOperands, ET_Store, MemoryLeader), Store(S),
381  StoredValue(StoredValue) {}
382  StoreExpression() = delete;
383  StoreExpression(const StoreExpression &) = delete;
384  StoreExpression &operator=(const StoreExpression &) = delete;
385  ~StoreExpression() override;
386 
387  static bool classof(const Expression *EB) {
388  return EB->getExpressionType() == ET_Store;
389  }
390 
391  StoreInst *getStoreInst() const { return Store; }
392  Value *getStoredValue() const { return StoredValue; }
393 
394  bool equals(const Expression &Other) const override;
395 
396  bool exactlyEquals(const Expression &Other) const override {
397  return Expression::exactlyEquals(Other) &&
398  cast<StoreExpression>(Other).getStoreInst() == getStoreInst();
399  }
400 
401  // Debugging support
402  void printInternal(raw_ostream &OS, bool PrintEType) const override {
403  if (PrintEType)
404  OS << "ExpressionTypeStore, ";
405  this->BasicExpression::printInternal(OS, false);
406  OS << " represents Store " << *Store;
407  OS << " with StoredValue ";
408  StoredValue->printAsOperand(OS);
409  OS << " and MemoryLeader " << *getMemoryLeader();
410  }
411 };
412 
414 private:
415  unsigned MaxIntOperands;
416  unsigned NumIntOperands = 0;
417  unsigned *IntOperands = nullptr;
418 
419 public:
420  AggregateValueExpression(unsigned NumOperands, unsigned NumIntOperands)
421  : BasicExpression(NumOperands, ET_AggregateValue),
422  MaxIntOperands(NumIntOperands) {}
423  AggregateValueExpression() = delete;
426  operator=(const AggregateValueExpression &) = delete;
427  ~AggregateValueExpression() override;
428 
429  static bool classof(const Expression *EB) {
430  return EB->getExpressionType() == ET_AggregateValue;
431  }
432 
433  using int_arg_iterator = unsigned *;
434  using const_int_arg_iterator = const unsigned *;
435 
436  int_arg_iterator int_op_begin() { return IntOperands; }
437  int_arg_iterator int_op_end() { return IntOperands + NumIntOperands; }
438  const_int_arg_iterator int_op_begin() const { return IntOperands; }
440  return IntOperands + NumIntOperands;
441  }
442  unsigned int_op_size() const { return NumIntOperands; }
443  bool int_op_empty() const { return NumIntOperands == 0; }
444  void int_op_push_back(unsigned IntOperand) {
445  assert(NumIntOperands < MaxIntOperands &&
446  "Tried to add too many int operands");
447  assert(IntOperands && "Operands not allocated before pushing");
448  IntOperands[NumIntOperands++] = IntOperand;
449  }
450 
452  assert(!IntOperands && "Operands already allocated");
453  IntOperands = Allocator.Allocate<unsigned>(MaxIntOperands);
454  }
455 
456  bool equals(const Expression &Other) const override {
457  if (!this->BasicExpression::equals(Other))
458  return false;
459  const AggregateValueExpression &OE = cast<AggregateValueExpression>(Other);
460  return NumIntOperands == OE.NumIntOperands &&
461  std::equal(int_op_begin(), int_op_end(), OE.int_op_begin());
462  }
463 
464  hash_code getHashValue() const override {
466  hash_combine_range(int_op_begin(), int_op_end()));
467  }
468 
469  // Debugging support
470  void printInternal(raw_ostream &OS, bool PrintEType) const override {
471  if (PrintEType)
472  OS << "ExpressionTypeAggregateValue, ";
473  this->BasicExpression::printInternal(OS, false);
474  OS << ", intoperands = {";
475  for (unsigned i = 0, e = int_op_size(); i != e; ++i) {
476  OS << "[" << i << "] = " << IntOperands[i] << " ";
477  }
478  OS << "}";
479  }
480 };
481 
483  : public std::iterator<std::output_iterator_tag, void, void, void, void> {
484 private:
486 
487  Container *AVE;
488 
489 public:
492 
493  int_op_inserter &operator=(unsigned int val) {
494  AVE->int_op_push_back(val);
495  return *this;
496  }
497  int_op_inserter &operator*() { return *this; }
498  int_op_inserter &operator++() { return *this; }
499  int_op_inserter &operator++(int) { return *this; }
500 };
501 
502 class PHIExpression final : public BasicExpression {
503 private:
504  BasicBlock *BB;
505 
506 public:
507  PHIExpression(unsigned NumOperands, BasicBlock *B)
508  : BasicExpression(NumOperands, ET_Phi), BB(B) {}
509  PHIExpression() = delete;
510  PHIExpression(const PHIExpression &) = delete;
511  PHIExpression &operator=(const PHIExpression &) = delete;
512  ~PHIExpression() override;
513 
514  static bool classof(const Expression *EB) {
515  return EB->getExpressionType() == ET_Phi;
516  }
517 
518  bool equals(const Expression &Other) const override {
519  if (!this->BasicExpression::equals(Other))
520  return false;
521  const PHIExpression &OE = cast<PHIExpression>(Other);
522  return BB == OE.BB;
523  }
524 
525  hash_code getHashValue() const override {
526  return hash_combine(this->BasicExpression::getHashValue(), BB);
527  }
528 
529  // Debugging support
530  void printInternal(raw_ostream &OS, bool PrintEType) const override {
531  if (PrintEType)
532  OS << "ExpressionTypePhi, ";
533  this->BasicExpression::printInternal(OS, false);
534  OS << "bb = " << BB;
535  }
536 };
537 
538 class DeadExpression final : public Expression {
539 public:
541  DeadExpression(const DeadExpression &) = delete;
542  DeadExpression &operator=(const DeadExpression &) = delete;
543 
544  static bool classof(const Expression *E) {
545  return E->getExpressionType() == ET_Dead;
546  }
547 };
548 
549 class VariableExpression final : public Expression {
550 private:
551  Value *VariableValue;
552 
553 public:
554  VariableExpression(Value *V) : Expression(ET_Variable), VariableValue(V) {}
555  VariableExpression() = delete;
556  VariableExpression(const VariableExpression &) = delete;
558 
559  static bool classof(const Expression *EB) {
560  return EB->getExpressionType() == ET_Variable;
561  }
562 
563  Value *getVariableValue() const { return VariableValue; }
564  void setVariableValue(Value *V) { VariableValue = V; }
565 
566  bool equals(const Expression &Other) const override {
567  const VariableExpression &OC = cast<VariableExpression>(Other);
568  return VariableValue == OC.VariableValue;
569  }
570 
571  hash_code getHashValue() const override {
572  return hash_combine(this->Expression::getHashValue(),
573  VariableValue->getType(), VariableValue);
574  }
575 
576  // Debugging support
577  void printInternal(raw_ostream &OS, bool PrintEType) const override {
578  if (PrintEType)
579  OS << "ExpressionTypeVariable, ";
580  this->Expression::printInternal(OS, false);
581  OS << " variable = " << *VariableValue;
582  }
583 };
584 
585 class ConstantExpression final : public Expression {
586 private:
587  Constant *ConstantValue = nullptr;
588 
589 public:
591  ConstantExpression(Constant *constantValue)
592  : Expression(ET_Constant), ConstantValue(constantValue) {}
593  ConstantExpression(const ConstantExpression &) = delete;
595 
596  static bool classof(const Expression *EB) {
597  return EB->getExpressionType() == ET_Constant;
598  }
599 
600  Constant *getConstantValue() const { return ConstantValue; }
601  void setConstantValue(Constant *V) { ConstantValue = V; }
602 
603  bool equals(const Expression &Other) const override {
604  const ConstantExpression &OC = cast<ConstantExpression>(Other);
605  return ConstantValue == OC.ConstantValue;
606  }
607 
608  hash_code getHashValue() const override {
609  return hash_combine(this->Expression::getHashValue(),
610  ConstantValue->getType(), ConstantValue);
611  }
612 
613  // Debugging support
614  void printInternal(raw_ostream &OS, bool PrintEType) const override {
615  if (PrintEType)
616  OS << "ExpressionTypeConstant, ";
617  this->Expression::printInternal(OS, false);
618  OS << " constant = " << *ConstantValue;
619  }
620 };
621 
622 class UnknownExpression final : public Expression {
623 private:
624  Instruction *Inst;
625 
626 public:
628  UnknownExpression() = delete;
629  UnknownExpression(const UnknownExpression &) = delete;
630  UnknownExpression &operator=(const UnknownExpression &) = delete;
631 
632  static bool classof(const Expression *EB) {
633  return EB->getExpressionType() == ET_Unknown;
634  }
635 
636  Instruction *getInstruction() const { return Inst; }
637  void setInstruction(Instruction *I) { Inst = I; }
638 
639  bool equals(const Expression &Other) const override {
640  const auto &OU = cast<UnknownExpression>(Other);
641  return Inst == OU.Inst;
642  }
643 
644  hash_code getHashValue() const override {
645  return hash_combine(this->Expression::getHashValue(), Inst);
646  }
647 
648  // Debugging support
649  void printInternal(raw_ostream &OS, bool PrintEType) const override {
650  if (PrintEType)
651  OS << "ExpressionTypeUnknown, ";
652  this->Expression::printInternal(OS, false);
653  OS << " inst = " << *Inst;
654  }
655 };
656 
657 } // end namespace GVNExpression
658 
659 } // end namespace llvm
660 
661 #endif // LLVM_TRANSFORMS_SCALAR_GVNEXPRESSION_H
uint64_t CallInst * C
const_op_iterator op_end() const
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
const_op_iterator op_begin() const
bool equals(const Expression &Other) const override
void printInternal(raw_ostream &OS, bool PrintEType) const override
PointerUnion< const Value *, const PseudoSourceValue * > ValueType
hash_code getHashValue() const override
int_op_inserter & operator++(int)
op_inserter & operator=(Value *val)
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
PHIExpression(unsigned NumOperands, BasicBlock *B)
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds...
Definition: Compiler.h:449
Various leaf nodes.
Definition: ISDOpcodes.h:60
T * allocate(Capacity Cap, AllocatorType &Allocator)
Allocate an array of at least the requested capacity.
int_op_inserter & operator=(unsigned int val)
const MemoryAccess * getMemoryLeader() const
static bool classof(const Expression *E)
bool equals(const Expression &Other) const override
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
This class represents a function call, abstracting a target machine&#39;s calling convention.
BasicExpression(unsigned NumOperands, ExpressionType ET)
bool exactlyEquals(const Expression &Other) const override
Recycle small arrays allocated from a BumpPtrAllocator.
Definition: ArrayRecycler.h:29
bool equals(const Expression &Other) const override
An instruction for reading from memory.
Definition: Instructions.h:164
bool operator==(const Expression &Other) const
Definition: GVNExpression.h:78
ExpressionType getExpressionType() const
AggregateValueExpression(unsigned NumOperands, unsigned NumIntOperands)
This file defines the MallocAllocator and BumpPtrAllocator interfaces.
MemoryExpression(unsigned NumOperands, enum ExpressionType EType, const MemoryAccess *MemoryLeader)
bool equals(const Expression &Other) const override
hash_code getComputedHash() const
Definition: GVNExpression.h:92
The size of an allocated array is represented by a Capacity instance.
Definition: ArrayRecycler.h:72
bool equals(const Expression &Other) const override
void printInternal(raw_ostream &OS, bool PrintEType) const override
raw_ostream & operator<<(raw_ostream &OS, const Expression &E)
void printInternal(raw_ostream &OS, bool PrintEType) const override
Expression & operator=(const Expression &)=delete
int_op_inserter(AggregateValueExpression *E)
void swapOperands(unsigned First, unsigned Second)
Swap two operands.
ELFYAML::ELF_STO Other
Definition: ELFYAML.cpp:736
void printInternal(raw_ostream &OS, bool PrintEType) const override
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
const_int_arg_iterator int_op_begin() const
#define T
void setMemoryLeader(const MemoryAccess *ML)
LLVM_DUMP_METHOD void dump() const
Definition: GVNSink.cpp:91
An instruction for storing to memory.
Definition: Instructions.h:306
virtual hash_code getHashValue() const
StoreExpression(unsigned NumOperands, StoreInst *S, Value *StoredValue, const MemoryAccess *MemoryLeader)
void printInternal(raw_ostream &OS, bool PrintEType) const override
int_op_inserter(AggregateValueExpression &E)
const_int_arg_iterator int_op_end() const
void print(raw_ostream &OS) const
static bool classof(const Expression *EB)
LoadExpression(unsigned NumOperands, LoadInst *L, const MemoryAccess *MemoryLeader)
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
LLVM Basic Block Representation.
Definition: BasicBlock.h:59
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:138
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:42
bool operator!=(const Expression &Other) const
Definition: GVNExpression.h:77
LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void * Allocate(size_t Size, size_t Alignment)
Allocate space at the specified alignment.
Definition: Allocator.h:212
static unsigned getTombstoneKey()
Definition: GVNExpression.h:75
CallExpression(unsigned NumOperands, CallInst *C, const MemoryAccess *MemoryLeader)
static wasm::ValType getType(const TargetRegisterClass *RC)
void printAsOperand(raw_ostream &O, bool PrintType=true, const Module *M=nullptr) const
Print the name of this Value out to the specified raw_ostream.
Definition: AsmWriter.cpp:3573
hash_code getHashValue() const override
void printInternal(raw_ostream &OS, bool PrintEType) const override
op_inserter(BasicExpression *E)
static bool classof(const Expression *EB)
hash_code getHashValue() const override
Basic Register Allocator
void setOperand(unsigned N, Value *V)
void setOpcode(unsigned opcode)
static bool classof(const Expression *EB)
Recycler - This class manages a linked-list of deallocated nodes and facilitates reusing deallocated ...
Definition: Recycler.h:35
virtual void printInternal(raw_ostream &OS, bool PrintEType) const
Expression(ExpressionType ET=ET_Base, unsigned O=~2U)
Definition: GVNExpression.h:68
static bool classof(const Expression *EB)
bool exactlyEquals(const Expression &Other) const override
void printInternal(raw_ostream &OS, bool PrintEType) const override
iterator_range< const_op_iterator > operands() const
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:923
A range adaptor for a pair of iterators.
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
Definition: Hashing.h:602
static bool classof(const Expression *EB)
ConstantExpression(Constant *constantValue)
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
Definition: Hashing.h:480
An opaque object representing a hash code.
Definition: Hashing.h:72
amdgpu Simplify well known AMD library false Value Value * Arg
virtual bool equals(const Expression &Other) const
LoadExpression(enum ExpressionType EType, unsigned NumOperands, LoadInst *L, const MemoryAccess *MemoryLeader)
static bool classof(const Expression *EB)
hash_code getHashValue() const override
bool equals(const Expression &Other) const override
unsigned getAlignment() const
Return the alignment of the access that is being performed.
Definition: Instructions.h:226
op_inserter(BasicExpression &E)
static bool classof(const Expression *EB)
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
void printInternal(raw_ostream &OS, bool PrintEType) const override
static bool classof(const Expression *EB)
bool equals(const Expression &Other) const override
BasicExpression(unsigned NumOperands)
iterator_range< op_iterator > operands()
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static bool classof(const Expression *EB)
LLVM Value Representation.
Definition: Value.h:73
static bool classof(const Expression *EB)
Value * getOperand(unsigned N) const
void printInternal(raw_ostream &OS, bool PrintEType) const override
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
virtual void allocateIntOperands(BumpPtrAllocator &Allocator)
This file exposes an interface to building/using memory SSA to walk memory instructions using a use/d...
void deallocate(Capacity Cap, T *Ptr)
Deallocate an array with the specified Capacity.
hash_code getHashValue() const override
virtual bool exactlyEquals(const Expression &Other) const
hash_code getHashValue() const override
void deallocateOperands(RecyclerType &Recycler)
void allocateOperands(RecyclerType &Recycler, BumpPtrAllocator &Allocator)
A discriminated union of two pointer types, with the discriminator in the low bit of the pointer...
Definition: PointerUnion.h:87