LLVM  10.0.0svn
Value.h
Go to the documentation of this file.
1 //===- llvm/Value.h - Definition of the Value class -------------*- 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 // This file declares the Value class.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_IR_VALUE_H
14 #define LLVM_IR_VALUE_H
15 
16 #include "llvm-c/Types.h"
17 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/IR/Use.h"
21 #include "llvm/Support/Casting.h"
22 #include <cassert>
23 #include <iterator>
24 #include <memory>
25 
26 namespace llvm {
27 
28 class APInt;
29 class Argument;
30 class BasicBlock;
31 class Constant;
32 class ConstantData;
33 class ConstantAggregate;
34 class DataLayout;
35 class Function;
36 class GlobalAlias;
37 class GlobalIFunc;
38 class GlobalIndirectSymbol;
39 class GlobalObject;
40 class GlobalValue;
41 class GlobalVariable;
42 class InlineAsm;
43 class Instruction;
44 class LLVMContext;
45 class Module;
46 class ModuleSlotTracker;
47 class raw_ostream;
48 template<typename ValueTy> class StringMapEntry;
49 class StringRef;
50 class Twine;
51 class Type;
52 class User;
53 
55 
56 //===----------------------------------------------------------------------===//
57 // Value Class
58 //===----------------------------------------------------------------------===//
59 
60 /// LLVM Value Representation
61 ///
62 /// This is a very important LLVM class. It is the base class of all values
63 /// computed by a program that may be used as operands to other values. Value is
64 /// the super class of other important classes such as Instruction and Function.
65 /// All Values have a Type. Type is not a subclass of Value. Some values can
66 /// have a name and they belong to some Module. Setting the name on the Value
67 /// automatically updates the module's symbol table.
68 ///
69 /// Every value has a "use list" that keeps track of which other Values are
70 /// using this Value. A Value can also have an arbitrary number of ValueHandle
71 /// objects that watch it and listen to RAUW and Destroy events. See
72 /// llvm/IR/ValueHandle.h for details.
73 class Value {
74  // The least-significant bit of the first word of Value *must* be zero:
75  // http://www.llvm.org/docs/ProgrammersManual.html#the-waymarking-algorithm
76  Type *VTy;
77  Use *UseList;
78 
79  friend class ValueAsMetadata; // Allow access to IsUsedByMD.
80  friend class ValueHandleBase;
81 
82  const unsigned char SubclassID; // Subclass identifier (for isa/dyn_cast)
83  unsigned char HasValueHandle : 1; // Has a ValueHandle pointing to this?
84 
85 protected:
86  /// Hold subclass data that can be dropped.
87  ///
88  /// This member is similar to SubclassData, however it is for holding
89  /// information which may be used to aid optimization, but which may be
90  /// cleared to zero without affecting conservative interpretation.
91  unsigned char SubclassOptionalData : 7;
92 
93 private:
94  /// Hold arbitrary subclass data.
95  ///
96  /// This member is defined by this class, but is not used for anything.
97  /// Subclasses can use it to hold whatever state they find useful. This
98  /// field is initialized to zero by the ctor.
99  unsigned short SubclassData;
100 
101 protected:
102  /// The number of operands in the subclass.
103  ///
104  /// This member is defined by this class, but not used for anything.
105  /// Subclasses can use it to store their number of operands, if they have
106  /// any.
107  ///
108  /// This is stored here to save space in User on 64-bit hosts. Since most
109  /// instances of Value have operands, 32-bit hosts aren't significantly
110  /// affected.
111  ///
112  /// Note, this should *NOT* be used directly by any class other than User.
113  /// User uses this value to find the Use list.
114  enum : unsigned { NumUserOperandsBits = 28 };
116 
117  // Use the same type as the bitfield above so that MSVC will pack them.
118  unsigned IsUsedByMD : 1;
119  unsigned HasName : 1;
120  unsigned HasHungOffUses : 1;
121  unsigned HasDescriptor : 1;
122 
123 private:
124  template <typename UseT> // UseT == 'Use' or 'const Use'
125  class use_iterator_impl
126  : public std::iterator<std::forward_iterator_tag, UseT *> {
127  friend class Value;
128 
129  UseT *U;
130 
131  explicit use_iterator_impl(UseT *u) : U(u) {}
132 
133  public:
134  use_iterator_impl() : U() {}
135 
136  bool operator==(const use_iterator_impl &x) const { return U == x.U; }
137  bool operator!=(const use_iterator_impl &x) const { return !operator==(x); }
138 
139  use_iterator_impl &operator++() { // Preincrement
140  assert(U && "Cannot increment end iterator!");
141  U = U->getNext();
142  return *this;
143  }
144 
145  use_iterator_impl operator++(int) { // Postincrement
146  auto tmp = *this;
147  ++*this;
148  return tmp;
149  }
150 
151  UseT &operator*() const {
152  assert(U && "Cannot dereference end iterator!");
153  return *U;
154  }
155 
156  UseT *operator->() const { return &operator*(); }
157 
158  operator use_iterator_impl<const UseT>() const {
159  return use_iterator_impl<const UseT>(U);
160  }
161  };
162 
163  template <typename UserTy> // UserTy == 'User' or 'const User'
164  class user_iterator_impl
165  : public std::iterator<std::forward_iterator_tag, UserTy *> {
166  use_iterator_impl<Use> UI;
167  explicit user_iterator_impl(Use *U) : UI(U) {}
168  friend class Value;
169 
170  public:
171  user_iterator_impl() = default;
172 
173  bool operator==(const user_iterator_impl &x) const { return UI == x.UI; }
174  bool operator!=(const user_iterator_impl &x) const { return !operator==(x); }
175 
176  /// Returns true if this iterator is equal to user_end() on the value.
177  bool atEnd() const { return *this == user_iterator_impl(); }
178 
179  user_iterator_impl &operator++() { // Preincrement
180  ++UI;
181  return *this;
182  }
183 
184  user_iterator_impl operator++(int) { // Postincrement
185  auto tmp = *this;
186  ++*this;
187  return tmp;
188  }
189 
190  // Retrieve a pointer to the current User.
191  UserTy *operator*() const {
192  return UI->getUser();
193  }
194 
195  UserTy *operator->() const { return operator*(); }
196 
197  operator user_iterator_impl<const UserTy>() const {
198  return user_iterator_impl<const UserTy>(*UI);
199  }
200 
201  Use &getUse() const { return *UI; }
202  };
203 
204 protected:
205  Value(Type *Ty, unsigned scid);
206 
207  /// Value's destructor should be virtual by design, but that would require
208  /// that Value and all of its subclasses have a vtable that effectively
209  /// duplicates the information in the value ID. As a size optimization, the
210  /// destructor has been protected, and the caller should manually call
211  /// deleteValue.
212  ~Value(); // Use deleteValue() to delete a generic Value.
213 
214 public:
215  Value(const Value &) = delete;
216  Value &operator=(const Value &) = delete;
217 
218  /// Delete a pointer to a generic Value.
219  void deleteValue();
220 
221  /// Support for debugging, callable in GDB: V->dump()
222  void dump() const;
223 
224  /// Implement operator<< on Value.
225  /// @{
226  void print(raw_ostream &O, bool IsForDebug = false) const;
227  void print(raw_ostream &O, ModuleSlotTracker &MST,
228  bool IsForDebug = false) const;
229  /// @}
230 
231  /// Print the name of this Value out to the specified raw_ostream.
232  ///
233  /// This is useful when you just want to print 'int %reg126', not the
234  /// instruction that generated it. If you specify a Module for context, then
235  /// even constanst get pretty-printed; for example, the type of a null
236  /// pointer is printed symbolically.
237  /// @{
238  void printAsOperand(raw_ostream &O, bool PrintType = true,
239  const Module *M = nullptr) const;
240  void printAsOperand(raw_ostream &O, bool PrintType,
241  ModuleSlotTracker &MST) const;
242  /// @}
243 
244  /// All values are typed, get the type of this value.
245  Type *getType() const { return VTy; }
246 
247  /// All values hold a context through their type.
248  LLVMContext &getContext() const;
249 
250  // All values can potentially be named.
251  bool hasName() const { return HasName; }
252  ValueName *getValueName() const;
253  void setValueName(ValueName *VN);
254 
255 private:
256  void destroyValueName();
257  enum class ReplaceMetadataUses { No, Yes };
258  void doRAUW(Value *New, ReplaceMetadataUses);
259  void setNameImpl(const Twine &Name);
260 
261 public:
262  /// Return a constant reference to the value's name.
263  ///
264  /// This guaranteed to return the same reference as long as the value is not
265  /// modified. If the value has a name, this does a hashtable lookup, so it's
266  /// not free.
267  StringRef getName() const;
268 
269  /// Change the name of the value.
270  ///
271  /// Choose a new unique name if the provided name is taken.
272  ///
273  /// \param Name The new name; or "" if the value's name should be removed.
274  void setName(const Twine &Name);
275 
276  /// Transfer the name from V to this value.
277  ///
278  /// After taking V's name, sets V's name to empty.
279  ///
280  /// \note It is an error to call V->takeName(V).
281  void takeName(Value *V);
282 
283  /// Change all uses of this to point to a new Value.
284  ///
285  /// Go through the uses list for this definition and make each use point to
286  /// "V" instead of "this". After this completes, 'this's use list is
287  /// guaranteed to be empty.
288  void replaceAllUsesWith(Value *V);
289 
290  /// Change non-metadata uses of this to point to a new Value.
291  ///
292  /// Go through the uses list for this definition and make each use point to
293  /// "V" instead of "this". This function skips metadata entries in the list.
295 
296  /// Go through the uses list for this definition and make each use point
297  /// to "V" if the callback ShouldReplace returns true for the given Use.
298  /// Unlike replaceAllUsesWith() this function does not support basic block
299  /// values or constant users.
301  llvm::function_ref<bool(Use &U)> ShouldReplace) {
302  assert(New && "Value::replaceUsesWithIf(<null>) is invalid!");
303  assert(New->getType() == getType() &&
304  "replaceUses of value with new value of different type!");
305 
306  for (use_iterator UI = use_begin(), E = use_end(); UI != E;) {
307  Use &U = *UI;
308  ++UI;
309  if (!ShouldReplace(U))
310  continue;
311  U.set(New);
312  }
313  }
314 
315  /// replaceUsesOutsideBlock - Go through the uses list for this definition and
316  /// make each use point to "V" instead of "this" when the use is outside the
317  /// block. 'This's use list is expected to have at least one element.
318  /// Unlike replaceAllUsesWith() this function does not support basic block
319  /// values or constant users.
321 
322  //----------------------------------------------------------------------
323  // Methods for handling the chain of uses of this Value.
324  //
325  // Materializing a function can introduce new uses, so these methods come in
326  // two variants:
327  // The methods that start with materialized_ check the uses that are
328  // currently known given which functions are materialized. Be very careful
329  // when using them since you might not get all uses.
330  // The methods that don't start with materialized_ assert that modules is
331  // fully materialized.
332  void assertModuleIsMaterializedImpl() const;
333  // This indirection exists so we can keep assertModuleIsMaterializedImpl()
334  // around in release builds of Value.cpp to be linked with other code built
335  // in debug mode. But this avoids calling it in any of the release built code.
337 #ifndef NDEBUG
339 #endif
340  }
341 
342  bool use_empty() const {
344  return UseList == nullptr;
345  }
346 
347  bool materialized_use_empty() const {
348  return UseList == nullptr;
349  }
350 
351  using use_iterator = use_iterator_impl<Use>;
352  using const_use_iterator = use_iterator_impl<const Use>;
353 
356  return const_use_iterator(UseList);
357  }
360  return materialized_use_begin();
361  }
364  return materialized_use_begin();
365  }
370  }
373  }
376  return materialized_uses();
377  }
380  return materialized_uses();
381  }
382 
383  bool user_empty() const {
385  return UseList == nullptr;
386  }
387 
388  using user_iterator = user_iterator_impl<User>;
389  using const_user_iterator = user_iterator_impl<const User>;
390 
393  return const_user_iterator(UseList);
394  }
397  return materialized_user_begin();
398  }
401  return materialized_user_begin();
402  }
407  return *materialized_user_begin();
408  }
409  const User *user_back() const {
411  return *materialized_user_begin();
412  }
415  }
418  }
421  return materialized_users();
422  }
425  return materialized_users();
426  }
427 
428  /// Return true if there is exactly one user of this value.
429  ///
430  /// This is specialized because it is a common request and does not require
431  /// traversing the whole use list.
432  bool hasOneUse() const {
434  if (I == E) return false;
435  return ++I == E;
436  }
437 
438  /// Return true if this Value has exactly N users.
439  bool hasNUses(unsigned N) const;
440 
441  /// Return true if this value has N users or more.
442  ///
443  /// This is logically equivalent to getNumUses() >= N.
444  bool hasNUsesOrMore(unsigned N) const;
445 
446  /// Check if this value is used in the specified basic block.
447  bool isUsedInBasicBlock(const BasicBlock *BB) const;
448 
449  /// This method computes the number of uses of this Value.
450  ///
451  /// This is a linear time operation. Use hasOneUse, hasNUses, or
452  /// hasNUsesOrMore to check for specific values.
453  unsigned getNumUses() const;
454 
455  /// This method should only be used by the Use class.
456  void addUse(Use &U) { U.addToList(&UseList); }
457 
458  /// Concrete subclass of this.
459  ///
460  /// An enumeration for keeping track of the concrete subclass of Value that
461  /// is actually instantiated. Values of this enumeration are kept in the
462  /// Value classes SubclassID field. They are used for concrete type
463  /// identification.
464  enum ValueTy {
465 #define HANDLE_VALUE(Name) Name##Val,
466 #include "llvm/IR/Value.def"
467 
468  // Markers:
469 #define HANDLE_CONSTANT_MARKER(Marker, Constant) Marker = Constant##Val,
470 #include "llvm/IR/Value.def"
471  };
472 
473  /// Return an ID for the concrete type of this object.
474  ///
475  /// This is used to implement the classof checks. This should not be used
476  /// for any other purpose, as the values may change as LLVM evolves. Also,
477  /// note that for instructions, the Instruction's opcode is added to
478  /// InstructionVal. So this means three things:
479  /// # there is no value with code InstructionVal (no opcode==0).
480  /// # there are more possible values for the value type than in ValueTy enum.
481  /// # the InstructionVal enumerator must be the highest valued enumerator in
482  /// the ValueTy enum.
483  unsigned getValueID() const {
484  return SubclassID;
485  }
486 
487  /// Return the raw optional flags value contained in this value.
488  ///
489  /// This should only be used when testing two Values for equivalence.
490  unsigned getRawSubclassOptionalData() const {
491  return SubclassOptionalData;
492  }
493 
494  /// Clear the optional flags contained in this value.
497  }
498 
499  /// Check the optional flags for equality.
500  bool hasSameSubclassOptionalData(const Value *V) const {
502  }
503 
504  /// Return true if there is a value handle associated with this value.
505  bool hasValueHandle() const { return HasValueHandle; }
506 
507  /// Return true if there is metadata referencing this value.
508  bool isUsedByMetadata() const { return IsUsedByMD; }
509 
510  /// Return true if this value is a swifterror value.
511  ///
512  /// swifterror values can be either a function argument or an alloca with a
513  /// swifterror attribute.
514  bool isSwiftError() const;
515 
516  /// Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
517  ///
518  /// Returns the original uncasted value. If this is called on a non-pointer
519  /// value, it returns 'this'.
520  const Value *stripPointerCasts() const;
522  return const_cast<Value *>(
523  static_cast<const Value *>(this)->stripPointerCasts());
524  }
525 
526  /// Strip off pointer casts, all-zero GEPs, address space casts, and aliases
527  /// but ensures the representation of the result stays the same.
528  ///
529  /// Returns the original uncasted value with the same representation. If this
530  /// is called on a non-pointer value, it returns 'this'.
533  return const_cast<Value *>(static_cast<const Value *>(this)
535  }
536 
537  /// Strip off pointer casts, all-zero GEPs, aliases and invariant group
538  /// info.
539  ///
540  /// Returns the original uncasted value. If this is called on a non-pointer
541  /// value, it returns 'this'. This function should be used only in
542  /// Alias analysis.
545  return const_cast<Value *>(
546  static_cast<const Value *>(this)->stripPointerCastsAndInvariantGroups());
547  }
548 
549  /// Strip off pointer casts and all-zero GEPs.
550  ///
551  /// Returns the original uncasted value. If this is called on a non-pointer
552  /// value, it returns 'this'.
555  return const_cast<Value *>(
556  static_cast<const Value *>(this)->stripPointerCastsNoFollowAliases());
557  }
558 
559  /// Strip off pointer casts and all-constant inbounds GEPs.
560  ///
561  /// Returns the original pointer value. If this is called on a non-pointer
562  /// value, it returns 'this'.
563  const Value *stripInBoundsConstantOffsets() const;
565  return const_cast<Value *>(
566  static_cast<const Value *>(this)->stripInBoundsConstantOffsets());
567  }
568 
569  /// Accumulate the constant offset this value has compared to a base pointer.
570  /// Only 'getelementptr' instructions (GEPs) with constant indices are
571  /// accumulated but other instructions, e.g., casts, are stripped away as
572  /// well. The accumulated constant offset is added to \p Offset and the base
573  /// pointer is returned.
574  ///
575  /// The APInt \p Offset has to have a bit-width equal to the IntPtr type for
576  /// the address space of 'this' pointer value, e.g., use
577  /// DataLayout::getIndexTypeSizeInBits(Ty).
578  ///
579  /// If \p AllowNonInbounds is true, constant offsets in GEPs are stripped and
580  /// accumulated even if the GEP is not "inbounds".
581  ///
582  /// If this is called on a non-pointer value, it returns 'this' and the
583  /// \p Offset is not modified.
584  ///
585  /// Note that this function will never return a nullptr. It will also never
586  /// manipulate the \p Offset in a way that would not match the difference
587  /// between the underlying value and the returned one. Thus, if no constant
588  /// offset was found, the returned value is the underlying one and \p Offset
589  /// is unchanged.
591  APInt &Offset,
592  bool AllowNonInbounds) const;
594  bool AllowNonInbounds) {
595  return const_cast<Value *>(
596  static_cast<const Value *>(this)->stripAndAccumulateConstantOffsets(
597  DL, Offset, AllowNonInbounds));
598  }
599 
600  /// This is a wrapper around stripAndAccumulateConstantOffsets with the
601  /// in-bounds requirement set to false.
603  APInt &Offset) const {
604  return stripAndAccumulateConstantOffsets(DL, Offset,
605  /* AllowNonInbounds */ false);
606  }
608  APInt &Offset) {
609  return stripAndAccumulateConstantOffsets(DL, Offset,
610  /* AllowNonInbounds */ false);
611  }
612 
613  /// Strip off pointer casts and inbounds GEPs.
614  ///
615  /// Returns the original pointer value. If this is called on a non-pointer
616  /// value, it returns 'this'.
617  const Value *stripInBoundsOffsets() const;
619  return const_cast<Value *>(
620  static_cast<const Value *>(this)->stripInBoundsOffsets());
621  }
622 
623  /// Returns the number of bytes known to be dereferenceable for the
624  /// pointer value.
625  ///
626  /// If CanBeNull is set by this function the pointer can either be null or be
627  /// dereferenceable up to the returned number of bytes.
628  uint64_t getPointerDereferenceableBytes(const DataLayout &DL,
629  bool &CanBeNull) const;
630 
631  /// Returns an alignment of the pointer value.
632  ///
633  /// Returns an alignment which is either specified explicitly, e.g. via
634  /// align attribute of a function argument, or guaranteed by DataLayout.
635  unsigned getPointerAlignment(const DataLayout &DL) const;
636 
637  /// Translate PHI node to its predecessor from the given basic block.
638  ///
639  /// If this value is a PHI node with CurBB as its parent, return the value in
640  /// the PHI node corresponding to PredBB. If not, return ourself. This is
641  /// useful if you want to know the value something has in a predecessor
642  /// block.
643  const Value *DoPHITranslation(const BasicBlock *CurBB,
644  const BasicBlock *PredBB) const;
645  Value *DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB) {
646  return const_cast<Value *>(
647  static_cast<const Value *>(this)->DoPHITranslation(CurBB, PredBB));
648  }
649 
650  /// The maximum alignment for instructions.
651  ///
652  /// This is the greatest alignment value supported by load, store, and alloca
653  /// instructions, and global values.
654  static const unsigned MaxAlignmentExponent = 29;
655  static const unsigned MaximumAlignment = 1u << MaxAlignmentExponent;
656 
657  /// Mutate the type of this Value to be of the specified type.
658  ///
659  /// Note that this is an extremely dangerous operation which can create
660  /// completely invalid IR very easily. It is strongly recommended that you
661  /// recreate IR objects with the right types instead of mutating them in
662  /// place.
663  void mutateType(Type *Ty) {
664  VTy = Ty;
665  }
666 
667  /// Sort the use-list.
668  ///
669  /// Sorts the Value's use-list by Cmp using a stable mergesort. Cmp is
670  /// expected to compare two \a Use references.
671  template <class Compare> void sortUseList(Compare Cmp);
672 
673  /// Reverse the use-list.
674  void reverseUseList();
675 
676 private:
677  /// Merge two lists together.
678  ///
679  /// Merges \c L and \c R using \c Cmp. To enable stable sorts, always pushes
680  /// "equal" items from L before items from R.
681  ///
682  /// \return the first element in the list.
683  ///
684  /// \note Completely ignores \a Use::Prev (doesn't read, doesn't update).
685  template <class Compare>
686  static Use *mergeUseLists(Use *L, Use *R, Compare Cmp) {
687  Use *Merged;
688  Use **Next = &Merged;
689 
690  while (true) {
691  if (!L) {
692  *Next = R;
693  break;
694  }
695  if (!R) {
696  *Next = L;
697  break;
698  }
699  if (Cmp(*R, *L)) {
700  *Next = R;
701  Next = &R->Next;
702  R = R->Next;
703  } else {
704  *Next = L;
705  Next = &L->Next;
706  L = L->Next;
707  }
708  }
709 
710  return Merged;
711  }
712 
713 protected:
714  unsigned short getSubclassDataFromValue() const { return SubclassData; }
715  void setValueSubclassData(unsigned short D) { SubclassData = D; }
716 };
717 
718 struct ValueDeleter { void operator()(Value *V) { V->deleteValue(); } };
719 
720 /// Use this instead of std::unique_ptr<Value> or std::unique_ptr<Instruction>.
721 /// Those don't work because Value and Instruction's destructors are protected,
722 /// aren't virtual, and won't destroy the complete object.
723 using unique_value = std::unique_ptr<Value, ValueDeleter>;
724 
725 inline raw_ostream &operator<<(raw_ostream &OS, const Value &V) {
726  V.print(OS);
727  return OS;
728 }
729 
730 void Use::set(Value *V) {
731  if (Val) removeFromList();
732  Val = V;
733  if (V) V->addUse(*this);
734 }
735 
737  set(RHS);
738  return RHS;
739 }
740 
741 const Use &Use::operator=(const Use &RHS) {
742  set(RHS.Val);
743  return *this;
744 }
745 
746 template <class Compare> void Value::sortUseList(Compare Cmp) {
747  if (!UseList || !UseList->Next)
748  // No need to sort 0 or 1 uses.
749  return;
750 
751  // Note: this function completely ignores Prev pointers until the end when
752  // they're fixed en masse.
753 
754  // Create a binomial vector of sorted lists, visiting uses one at a time and
755  // merging lists as necessary.
756  const unsigned MaxSlots = 32;
757  Use *Slots[MaxSlots];
758 
759  // Collect the first use, turning it into a single-item list.
760  Use *Next = UseList->Next;
761  UseList->Next = nullptr;
762  unsigned NumSlots = 1;
763  Slots[0] = UseList;
764 
765  // Collect all but the last use.
766  while (Next->Next) {
767  Use *Current = Next;
768  Next = Current->Next;
769 
770  // Turn Current into a single-item list.
771  Current->Next = nullptr;
772 
773  // Save Current in the first available slot, merging on collisions.
774  unsigned I;
775  for (I = 0; I < NumSlots; ++I) {
776  if (!Slots[I])
777  break;
778 
779  // Merge two lists, doubling the size of Current and emptying slot I.
780  //
781  // Since the uses in Slots[I] originally preceded those in Current, send
782  // Slots[I] in as the left parameter to maintain a stable sort.
783  Current = mergeUseLists(Slots[I], Current, Cmp);
784  Slots[I] = nullptr;
785  }
786  // Check if this is a new slot.
787  if (I == NumSlots) {
788  ++NumSlots;
789  assert(NumSlots <= MaxSlots && "Use list bigger than 2^32");
790  }
791 
792  // Found an open slot.
793  Slots[I] = Current;
794  }
795 
796  // Merge all the lists together.
797  assert(Next && "Expected one more Use");
798  assert(!Next->Next && "Expected only one Use");
799  UseList = Next;
800  for (unsigned I = 0; I < NumSlots; ++I)
801  if (Slots[I])
802  // Since the uses in Slots[I] originally preceded those in UseList, send
803  // Slots[I] in as the left parameter to maintain a stable sort.
804  UseList = mergeUseLists(Slots[I], UseList, Cmp);
805 
806  // Fix the Prev pointers.
807  for (Use *I = UseList, **Prev = &UseList; I; I = I->Next) {
808  I->setPrev(Prev);
809  Prev = &I->Next;
810  }
811 }
812 
813 // isa - Provide some specializations of isa so that we don't have to include
814 // the subtype header files to test to see if the value is a subclass...
815 //
816 template <> struct isa_impl<Constant, Value> {
817  static inline bool doit(const Value &Val) {
818  static_assert(Value::ConstantFirstVal == 0, "Val.getValueID() >= Value::ConstantFirstVal");
819  return Val.getValueID() <= Value::ConstantLastVal;
820  }
821 };
822 
823 template <> struct isa_impl<ConstantData, Value> {
824  static inline bool doit(const Value &Val) {
825  return Val.getValueID() >= Value::ConstantDataFirstVal &&
826  Val.getValueID() <= Value::ConstantDataLastVal;
827  }
828 };
829 
830 template <> struct isa_impl<ConstantAggregate, Value> {
831  static inline bool doit(const Value &Val) {
832  return Val.getValueID() >= Value::ConstantAggregateFirstVal &&
833  Val.getValueID() <= Value::ConstantAggregateLastVal;
834  }
835 };
836 
837 template <> struct isa_impl<Argument, Value> {
838  static inline bool doit (const Value &Val) {
839  return Val.getValueID() == Value::ArgumentVal;
840  }
841 };
842 
843 template <> struct isa_impl<InlineAsm, Value> {
844  static inline bool doit(const Value &Val) {
845  return Val.getValueID() == Value::InlineAsmVal;
846  }
847 };
848 
849 template <> struct isa_impl<Instruction, Value> {
850  static inline bool doit(const Value &Val) {
851  return Val.getValueID() >= Value::InstructionVal;
852  }
853 };
854 
855 template <> struct isa_impl<BasicBlock, Value> {
856  static inline bool doit(const Value &Val) {
857  return Val.getValueID() == Value::BasicBlockVal;
858  }
859 };
860 
861 template <> struct isa_impl<Function, Value> {
862  static inline bool doit(const Value &Val) {
863  return Val.getValueID() == Value::FunctionVal;
864  }
865 };
866 
867 template <> struct isa_impl<GlobalVariable, Value> {
868  static inline bool doit(const Value &Val) {
869  return Val.getValueID() == Value::GlobalVariableVal;
870  }
871 };
872 
873 template <> struct isa_impl<GlobalAlias, Value> {
874  static inline bool doit(const Value &Val) {
875  return Val.getValueID() == Value::GlobalAliasVal;
876  }
877 };
878 
879 template <> struct isa_impl<GlobalIFunc, Value> {
880  static inline bool doit(const Value &Val) {
881  return Val.getValueID() == Value::GlobalIFuncVal;
882  }
883 };
884 
885 template <> struct isa_impl<GlobalIndirectSymbol, Value> {
886  static inline bool doit(const Value &Val) {
887  return isa<GlobalAlias>(Val) || isa<GlobalIFunc>(Val);
888  }
889 };
890 
891 template <> struct isa_impl<GlobalValue, Value> {
892  static inline bool doit(const Value &Val) {
893  return isa<GlobalObject>(Val) || isa<GlobalIndirectSymbol>(Val);
894  }
895 };
896 
897 template <> struct isa_impl<GlobalObject, Value> {
898  static inline bool doit(const Value &Val) {
899  return isa<GlobalVariable>(Val) || isa<Function>(Val);
900  }
901 };
902 
903 // Create wrappers for C Binding types (see CBindingWrapping.h).
905 
906 // Specialized opaque value conversions.
908  return reinterpret_cast<Value**>(Vals);
909 }
910 
911 template<typename T>
912 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
913 #ifndef NDEBUG
914  for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
915  unwrap<T>(*I); // For side effect of calling assert on invalid usage.
916 #endif
917  (void)Length;
918  return reinterpret_cast<T**>(Vals);
919 }
920 
921 inline LLVMValueRef *wrap(const Value **Vals) {
922  return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
923 }
924 
925 } // end namespace llvm
926 
927 #endif // LLVM_IR_VALUE_H
This is the common base class of value handles.
Definition: ValueHandle.h:29
unsigned short getSubclassDataFromValue() const
Definition: Value.h:714
void sortUseList(Compare Cmp)
Sort the use-list.
Definition: Value.h:746
use_iterator use_end()
Definition: Value.h:366
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
Type
MessagePack types as defined in the standard, with the exception of Integer being divided into a sign...
Definition: MsgPackReader.h:48
unsigned HasDescriptor
Definition: Value.h:121
iterator_range< use_iterator > uses()
Definition: Value.h:374
void operator()(Value *V)
Definition: Value.h:718
This class represents an incoming formal argument to a Function.
Definition: Argument.h:29
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:483
const Value * stripInBoundsOffsets() const
Strip off pointer casts and inbounds GEPs.
Definition: Value.cpp:608
static bool doit(const Value &Val)
Definition: Value.h:831
This class represents lattice values for constants.
Definition: AllocatorList.h:23
void addUse(Use &U)
This method should only be used by the Use class.
Definition: Value.h:456
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
Definition: StringMap.h:125
Various leaf nodes.
Definition: ISDOpcodes.h:59
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
bool user_empty() const
Definition: Value.h:383
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
use_iterator materialized_use_begin()
Definition: Value.h:354
bool hasValueHandle() const
Return true if there is a value handle associated with this value.
Definition: Value.h:505
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:116
iterator_range< const_user_iterator > users() const
Definition: Value.h:423
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:745
static bool doit(const Value &Val)
Definition: Value.h:868
void deleteValue()
Delete a pointer to a generic Value.
Definition: Value.cpp:98
Manage lifetime of a slot tracker for printing IR.
This defines the Use class.
use_iterator_impl< const Use > const_use_iterator
Definition: Value.h:352
const Value * DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB) const
Translate PHI node to its predecessor from the given basic block.
Definition: Value.cpp:737
unsigned getPointerAlignment(const DataLayout &DL) const
Returns an alignment of the pointer value.
Definition: Value.cpp:678
iterator_range< user_iterator > materialized_users()
Definition: Value.h:413
void dump() const
Support for debugging, callable in GDB: V->dump()
Definition: AsmWriter.cpp:4428
const_user_iterator materialized_user_begin() const
Definition: Value.h:392
iterator_range< const_user_iterator > materialized_users() const
Definition: Value.h:416
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:204
A Use represents the edge between a Value definition and its users.
Definition: Use.h:55
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:285
void assertModuleIsMaterializedImpl() const
Definition: Value.cpp:351
static bool doit(const Value &Val)
Definition: Value.h:856
static const unsigned MaximumAlignment
Definition: Value.h:655
#define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref)
APInt operator*(APInt a, uint64_t RHS)
Definition: APInt.h:2097
static bool doit(const Value &Val)
Definition: Value.h:844
Value * stripInBoundsOffsets()
Definition: Value.h:618
unsigned HasHungOffUses
Definition: Value.h:120
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
iterator_range< const_use_iterator > materialized_uses() const
Definition: Value.h:371
bool isSwiftError() const
Return true if this value is a swifterror value.
Definition: Value.cpp:766
static bool doit(const Value &Val)
Definition: Value.h:886
const_use_iterator use_end() const
Definition: Value.h:367
const_use_iterator materialized_use_begin() const
Definition: Value.h:355
Value * stripPointerCastsNoFollowAliases()
Definition: Value.h:554
const Value * stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, APInt &Offset) const
This is a wrapper around stripAndAccumulateConstantOffsets with the in-bounds requirement set to fals...
Definition: Value.h:602
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:429
Value wrapper in the Metadata hierarchy.
Definition: Metadata.h:338
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:291
void replaceUsesWithIf(Value *New, llvm::function_ref< bool(Use &U)> ShouldReplace)
Go through the uses list for this definition and make each use point to "V" if the callback ShouldRep...
Definition: Value.h:300
use_iterator_impl< Use > use_iterator
Definition: Value.h:351
unsigned getRawSubclassOptionalData() const
Return the raw optional flags value contained in this value.
Definition: Value.h:490
const_use_iterator use_begin() const
Definition: Value.h:362
bool hasNUsesOrMore(unsigned N) const
Return true if this value has N users or more.
Definition: Value.cpp:135
bool hasNUses(unsigned N) const
Return true if this Value has exactly N users.
Definition: Value.cpp:131
void set(Value *Val)
Definition: Value.h:730
bool hasName() const
Definition: Value.h:251
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:64
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:41
void replaceNonMetadataUsesWith(Value *V)
Change non-metadata uses of this to point to a new Value.
Definition: Value.cpp:433
amdgpu inline
iterator_range< use_iterator > materialized_uses()
Definition: Value.h:368
bool isUsedInBasicBlock(const BasicBlock *BB) const
Check if this value is used in the specified basic block.
Definition: Value.cpp:139
bool hasSameSubclassOptionalData(const Value *V) const
Check the optional flags for equality.
Definition: Value.h:500
static bool doit(const Value &Val)
Definition: Value.h:880
Value * stripPointerCastsAndInvariantGroups()
Definition: Value.h:544
void print(raw_ostream &O, bool IsForDebug=false) const
Implement operator<< on Value.
Definition: AsmWriter.cpp:4278
Value * stripInBoundsConstantOffsets()
Definition: Value.h:564
const Value * stripPointerCastsSameRepresentation() const
Strip off pointer casts, all-zero GEPs, address space casts, and aliases but ensures the representati...
Definition: Value.cpp:535
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
Definition: Value.cpp:531
Value(Type *Ty, unsigned scid)
Definition: Value.cpp:52
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:4355
Value * stripPointerCasts()
Definition: Value.h:521
Value & operator=(const Value &)=delete
unsigned char SubclassOptionalData
Hold subclass data that can be dropped.
Definition: Value.h:91
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
static const unsigned MaxAlignmentExponent
The maximum alignment for instructions.
Definition: Value.h:654
bool materialized_use_empty() const
Definition: Value.h:347
unsigned IsUsedByMD
Definition: Value.h:118
void assertModuleIsMaterialized() const
Definition: Value.h:336
static bool doit(const Value &Val)
Definition: Value.h:898
ValueName * getValueName() const
Definition: Value.cpp:186
const User * user_back() const
Definition: Value.h:409
std::unique_ptr< Value, ValueDeleter > unique_value
Use this instead of std::unique_ptr<Value> or std::unique_ptr<Instruction>.
Definition: Value.h:723
uint64_t getPointerDereferenceableBytes(const DataLayout &DL, bool &CanBeNull) const
Returns the number of bytes known to be dereferenceable for the pointer value.
Definition: Value.cpp:612
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
unsigned NumUserOperands
Definition: Value.h:115
const Value * stripPointerCastsAndInvariantGroups() const
Strip off pointer casts, all-zero GEPs, aliases and invariant group info.
Definition: Value.cpp:548
ValueTy
Concrete subclass of this.
Definition: Value.h:464
void setValueSubclassData(unsigned short D)
Definition: Value.h:715
bool isUsedByMetadata() const
Return true if there is metadata referencing this value.
Definition: Value.h:508
A range adaptor for a pair of iterators.
Class for arbitrary precision integers.
Definition: APInt.h:69
const_user_iterator user_begin() const
Definition: Value.h:399
iterator_range< user_iterator > users()
Definition: Value.h:419
user_iterator_impl< const User > const_user_iterator
Definition: Value.h:389
could "use" a pointer
const Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds) const
Accumulate the constant offset this value has compared to a base pointer.
Definition: Value.cpp:554
void reverseUseList()
Reverse the use-list.
Definition: Value.cpp:747
iterator_range< const_use_iterator > uses() const
Definition: Value.h:378
use_iterator use_begin()
Definition: Value.h:358
bool operator!=(uint64_t V1, const APInt &V2)
Definition: APInt.h:1975
unsigned getNumUses() const
This method computes the number of uses of this Value.
Definition: Value.cpp:160
unsigned HasName
Definition: Value.h:119
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:199
static bool doit(const Value &Val)
Definition: Value.h:850
const Value * stripPointerCastsNoFollowAliases() const
Strip off pointer casts and all-zero GEPs.
Definition: Value.cpp:540
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:214
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
user_iterator_impl< User > user_iterator
Definition: Value.h:388
Value * DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB)
Definition: Value.h:645
static bool doit(const Value &Val)
Definition: Value.h:817
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:2045
void mutateType(Type *Ty)
Mutate the type of this Value to be of the specified type.
Definition: Value.h:663
~Value()
Value&#39;s destructor should be virtual by design, but that would require that Value and all of its subc...
Definition: Value.cpp:72
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Value * stripPointerCastsSameRepresentation()
Definition: Value.h:532
user_iterator user_begin()
Definition: Value.h:395
Value * stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, APInt &Offset)
Definition: Value.h:607
Base class for aggregate constants (with operands).
Definition: Constants.h:389
LLVM Value Representation.
Definition: Value.h:73
const_user_iterator user_end() const
Definition: Value.h:404
void clearSubclassOptionalData()
Clear the optional flags contained in this value.
Definition: Value.h:495
static bool doit(const Value &Val)
Definition: Value.h:838
Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds)
Definition: Value.h:593
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
user_iterator materialized_user_begin()
Definition: Value.h:391
void setValueName(ValueName *VN)
Definition: Value.cpp:197
static bool doit(const Value &Val)
Definition: Value.h:892
bool hasOneUse() const
Return true if there is exactly one user of this value.
Definition: Value.h:432
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
static bool doit(const Value &Val)
Definition: Value.h:874
void replaceUsesOutsideBlock(Value *V, BasicBlock *BB)
replaceUsesOutsideBlock - Go through the uses list for this definition and make each use point to "V"...
Definition: Value.cpp:439
bool operator==(uint64_t V1, const APInt &V2)
Definition: APInt.h:1973
const Value * stripInBoundsConstantOffsets() const
Strip off pointer casts and all-constant inbounds GEPs.
Definition: Value.cpp:544
Base class for constants with no operands.
Definition: Constants.h:57
Value * operator=(Value *RHS)
Definition: Value.h:736
bool use_empty() const
Definition: Value.h:342
static bool doit(const Value &Val)
Definition: Value.h:862
struct LLVMOpaqueValue * LLVMValueRef
Represents an individual value in LLVM IR.
Definition: Types.h:76
User * user_back()
Definition: Value.h:405
static bool doit(const Value &Val)
Definition: Value.h:824
user_iterator user_end()
Definition: Value.h:403