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 and address space casts.
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 and address space casts
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 and invariant group info.
538  ///
539  /// Returns the original uncasted value. If this is called on a non-pointer
540  /// value, it returns 'this'. This function should be used only in
541  /// Alias analysis.
544  return const_cast<Value *>(static_cast<const Value *>(this)
546  }
547 
548  /// Strip off pointer casts and all-constant inbounds GEPs.
549  ///
550  /// Returns the original pointer value. If this is called on a non-pointer
551  /// value, it returns 'this'.
552  const Value *stripInBoundsConstantOffsets() const;
554  return const_cast<Value *>(
555  static_cast<const Value *>(this)->stripInBoundsConstantOffsets());
556  }
557 
558  /// Accumulate the constant offset this value has compared to a base pointer.
559  /// Only 'getelementptr' instructions (GEPs) with constant indices are
560  /// accumulated but other instructions, e.g., casts, are stripped away as
561  /// well. The accumulated constant offset is added to \p Offset and the base
562  /// pointer is returned.
563  ///
564  /// The APInt \p Offset has to have a bit-width equal to the IntPtr type for
565  /// the address space of 'this' pointer value, e.g., use
566  /// DataLayout::getIndexTypeSizeInBits(Ty).
567  ///
568  /// If \p AllowNonInbounds is true, constant offsets in GEPs are stripped and
569  /// accumulated even if the GEP is not "inbounds".
570  ///
571  /// If this is called on a non-pointer value, it returns 'this' and the
572  /// \p Offset is not modified.
573  ///
574  /// Note that this function will never return a nullptr. It will also never
575  /// manipulate the \p Offset in a way that would not match the difference
576  /// between the underlying value and the returned one. Thus, if no constant
577  /// offset was found, the returned value is the underlying one and \p Offset
578  /// is unchanged.
580  APInt &Offset,
581  bool AllowNonInbounds) const;
583  bool AllowNonInbounds) {
584  return const_cast<Value *>(
585  static_cast<const Value *>(this)->stripAndAccumulateConstantOffsets(
586  DL, Offset, AllowNonInbounds));
587  }
588 
589  /// This is a wrapper around stripAndAccumulateConstantOffsets with the
590  /// in-bounds requirement set to false.
592  APInt &Offset) const {
593  return stripAndAccumulateConstantOffsets(DL, Offset,
594  /* AllowNonInbounds */ false);
595  }
597  APInt &Offset) {
598  return stripAndAccumulateConstantOffsets(DL, Offset,
599  /* AllowNonInbounds */ false);
600  }
601 
602  /// Strip off pointer casts and inbounds GEPs.
603  ///
604  /// Returns the original pointer value. If this is called on a non-pointer
605  /// value, it returns 'this'.
606  const Value *stripInBoundsOffsets() const;
608  return const_cast<Value *>(
609  static_cast<const Value *>(this)->stripInBoundsOffsets());
610  }
611 
612  /// Returns the number of bytes known to be dereferenceable for the
613  /// pointer value.
614  ///
615  /// If CanBeNull is set by this function the pointer can either be null or be
616  /// dereferenceable up to the returned number of bytes.
617  uint64_t getPointerDereferenceableBytes(const DataLayout &DL,
618  bool &CanBeNull) const;
619 
620  /// Returns an alignment of the pointer value.
621  ///
622  /// Returns an alignment which is either specified explicitly, e.g. via
623  /// align attribute of a function argument, or guaranteed by DataLayout.
624  unsigned getPointerAlignment(const DataLayout &DL) const;
625 
626  /// Translate PHI node to its predecessor from the given basic block.
627  ///
628  /// If this value is a PHI node with CurBB as its parent, return the value in
629  /// the PHI node corresponding to PredBB. If not, return ourself. This is
630  /// useful if you want to know the value something has in a predecessor
631  /// block.
632  const Value *DoPHITranslation(const BasicBlock *CurBB,
633  const BasicBlock *PredBB) const;
634  Value *DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB) {
635  return const_cast<Value *>(
636  static_cast<const Value *>(this)->DoPHITranslation(CurBB, PredBB));
637  }
638 
639  /// The maximum alignment for instructions.
640  ///
641  /// This is the greatest alignment value supported by load, store, and alloca
642  /// instructions, and global values.
643  static const unsigned MaxAlignmentExponent = 29;
644  static const unsigned MaximumAlignment = 1u << MaxAlignmentExponent;
645 
646  /// Mutate the type of this Value to be of the specified type.
647  ///
648  /// Note that this is an extremely dangerous operation which can create
649  /// completely invalid IR very easily. It is strongly recommended that you
650  /// recreate IR objects with the right types instead of mutating them in
651  /// place.
652  void mutateType(Type *Ty) {
653  VTy = Ty;
654  }
655 
656  /// Sort the use-list.
657  ///
658  /// Sorts the Value's use-list by Cmp using a stable mergesort. Cmp is
659  /// expected to compare two \a Use references.
660  template <class Compare> void sortUseList(Compare Cmp);
661 
662  /// Reverse the use-list.
663  void reverseUseList();
664 
665 private:
666  /// Merge two lists together.
667  ///
668  /// Merges \c L and \c R using \c Cmp. To enable stable sorts, always pushes
669  /// "equal" items from L before items from R.
670  ///
671  /// \return the first element in the list.
672  ///
673  /// \note Completely ignores \a Use::Prev (doesn't read, doesn't update).
674  template <class Compare>
675  static Use *mergeUseLists(Use *L, Use *R, Compare Cmp) {
676  Use *Merged;
677  Use **Next = &Merged;
678 
679  while (true) {
680  if (!L) {
681  *Next = R;
682  break;
683  }
684  if (!R) {
685  *Next = L;
686  break;
687  }
688  if (Cmp(*R, *L)) {
689  *Next = R;
690  Next = &R->Next;
691  R = R->Next;
692  } else {
693  *Next = L;
694  Next = &L->Next;
695  L = L->Next;
696  }
697  }
698 
699  return Merged;
700  }
701 
702 protected:
703  unsigned short getSubclassDataFromValue() const { return SubclassData; }
704  void setValueSubclassData(unsigned short D) { SubclassData = D; }
705 };
706 
707 struct ValueDeleter { void operator()(Value *V) { V->deleteValue(); } };
708 
709 /// Use this instead of std::unique_ptr<Value> or std::unique_ptr<Instruction>.
710 /// Those don't work because Value and Instruction's destructors are protected,
711 /// aren't virtual, and won't destroy the complete object.
712 using unique_value = std::unique_ptr<Value, ValueDeleter>;
713 
714 inline raw_ostream &operator<<(raw_ostream &OS, const Value &V) {
715  V.print(OS);
716  return OS;
717 }
718 
719 void Use::set(Value *V) {
720  if (Val) removeFromList();
721  Val = V;
722  if (V) V->addUse(*this);
723 }
724 
726  set(RHS);
727  return RHS;
728 }
729 
730 const Use &Use::operator=(const Use &RHS) {
731  set(RHS.Val);
732  return *this;
733 }
734 
735 template <class Compare> void Value::sortUseList(Compare Cmp) {
736  if (!UseList || !UseList->Next)
737  // No need to sort 0 or 1 uses.
738  return;
739 
740  // Note: this function completely ignores Prev pointers until the end when
741  // they're fixed en masse.
742 
743  // Create a binomial vector of sorted lists, visiting uses one at a time and
744  // merging lists as necessary.
745  const unsigned MaxSlots = 32;
746  Use *Slots[MaxSlots];
747 
748  // Collect the first use, turning it into a single-item list.
749  Use *Next = UseList->Next;
750  UseList->Next = nullptr;
751  unsigned NumSlots = 1;
752  Slots[0] = UseList;
753 
754  // Collect all but the last use.
755  while (Next->Next) {
756  Use *Current = Next;
757  Next = Current->Next;
758 
759  // Turn Current into a single-item list.
760  Current->Next = nullptr;
761 
762  // Save Current in the first available slot, merging on collisions.
763  unsigned I;
764  for (I = 0; I < NumSlots; ++I) {
765  if (!Slots[I])
766  break;
767 
768  // Merge two lists, doubling the size of Current and emptying slot I.
769  //
770  // Since the uses in Slots[I] originally preceded those in Current, send
771  // Slots[I] in as the left parameter to maintain a stable sort.
772  Current = mergeUseLists(Slots[I], Current, Cmp);
773  Slots[I] = nullptr;
774  }
775  // Check if this is a new slot.
776  if (I == NumSlots) {
777  ++NumSlots;
778  assert(NumSlots <= MaxSlots && "Use list bigger than 2^32");
779  }
780 
781  // Found an open slot.
782  Slots[I] = Current;
783  }
784 
785  // Merge all the lists together.
786  assert(Next && "Expected one more Use");
787  assert(!Next->Next && "Expected only one Use");
788  UseList = Next;
789  for (unsigned I = 0; I < NumSlots; ++I)
790  if (Slots[I])
791  // Since the uses in Slots[I] originally preceded those in UseList, send
792  // Slots[I] in as the left parameter to maintain a stable sort.
793  UseList = mergeUseLists(Slots[I], UseList, Cmp);
794 
795  // Fix the Prev pointers.
796  for (Use *I = UseList, **Prev = &UseList; I; I = I->Next) {
797  I->setPrev(Prev);
798  Prev = &I->Next;
799  }
800 }
801 
802 // isa - Provide some specializations of isa so that we don't have to include
803 // the subtype header files to test to see if the value is a subclass...
804 //
805 template <> struct isa_impl<Constant, Value> {
806  static inline bool doit(const Value &Val) {
807  static_assert(Value::ConstantFirstVal == 0, "Val.getValueID() >= Value::ConstantFirstVal");
808  return Val.getValueID() <= Value::ConstantLastVal;
809  }
810 };
811 
812 template <> struct isa_impl<ConstantData, Value> {
813  static inline bool doit(const Value &Val) {
814  return Val.getValueID() >= Value::ConstantDataFirstVal &&
815  Val.getValueID() <= Value::ConstantDataLastVal;
816  }
817 };
818 
819 template <> struct isa_impl<ConstantAggregate, Value> {
820  static inline bool doit(const Value &Val) {
821  return Val.getValueID() >= Value::ConstantAggregateFirstVal &&
822  Val.getValueID() <= Value::ConstantAggregateLastVal;
823  }
824 };
825 
826 template <> struct isa_impl<Argument, Value> {
827  static inline bool doit (const Value &Val) {
828  return Val.getValueID() == Value::ArgumentVal;
829  }
830 };
831 
832 template <> struct isa_impl<InlineAsm, Value> {
833  static inline bool doit(const Value &Val) {
834  return Val.getValueID() == Value::InlineAsmVal;
835  }
836 };
837 
838 template <> struct isa_impl<Instruction, Value> {
839  static inline bool doit(const Value &Val) {
840  return Val.getValueID() >= Value::InstructionVal;
841  }
842 };
843 
844 template <> struct isa_impl<BasicBlock, Value> {
845  static inline bool doit(const Value &Val) {
846  return Val.getValueID() == Value::BasicBlockVal;
847  }
848 };
849 
850 template <> struct isa_impl<Function, Value> {
851  static inline bool doit(const Value &Val) {
852  return Val.getValueID() == Value::FunctionVal;
853  }
854 };
855 
856 template <> struct isa_impl<GlobalVariable, Value> {
857  static inline bool doit(const Value &Val) {
858  return Val.getValueID() == Value::GlobalVariableVal;
859  }
860 };
861 
862 template <> struct isa_impl<GlobalAlias, Value> {
863  static inline bool doit(const Value &Val) {
864  return Val.getValueID() == Value::GlobalAliasVal;
865  }
866 };
867 
868 template <> struct isa_impl<GlobalIFunc, Value> {
869  static inline bool doit(const Value &Val) {
870  return Val.getValueID() == Value::GlobalIFuncVal;
871  }
872 };
873 
874 template <> struct isa_impl<GlobalIndirectSymbol, Value> {
875  static inline bool doit(const Value &Val) {
876  return isa<GlobalAlias>(Val) || isa<GlobalIFunc>(Val);
877  }
878 };
879 
880 template <> struct isa_impl<GlobalValue, Value> {
881  static inline bool doit(const Value &Val) {
882  return isa<GlobalObject>(Val) || isa<GlobalIndirectSymbol>(Val);
883  }
884 };
885 
886 template <> struct isa_impl<GlobalObject, Value> {
887  static inline bool doit(const Value &Val) {
888  return isa<GlobalVariable>(Val) || isa<Function>(Val);
889  }
890 };
891 
892 // Create wrappers for C Binding types (see CBindingWrapping.h).
894 
895 // Specialized opaque value conversions.
897  return reinterpret_cast<Value**>(Vals);
898 }
899 
900 template<typename T>
901 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
902 #ifndef NDEBUG
903  for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
904  unwrap<T>(*I); // For side effect of calling assert on invalid usage.
905 #endif
906  (void)Length;
907  return reinterpret_cast<T**>(Vals);
908 }
909 
910 inline LLVMValueRef *wrap(const Value **Vals) {
911  return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
912 }
913 
914 } // end namespace llvm
915 
916 #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:703
void sortUseList(Compare Cmp)
Sort the use-list.
Definition: Value.h:735
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
unsigned HasDescriptor
Definition: Value.h:121
iterator_range< use_iterator > uses()
Definition: Value.h:374
void operator()(Value *V)
Definition: Value.h:707
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:596
static bool doit(const Value &Val)
Definition: Value.h:820
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:104
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:733
static bool doit(const Value &Val)
Definition: Value.h:857
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:725
unsigned getPointerAlignment(const DataLayout &DL) const
Returns an alignment of the pointer value.
Definition: Value.cpp:666
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:845
static const unsigned MaximumAlignment
Definition: Value.h:644
#define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref)
APInt operator*(APInt a, uint64_t RHS)
Definition: APInt.h:2099
static bool doit(const Value &Val)
Definition: Value.h:833
Value * stripInBoundsOffsets()
Definition: Value.h:607
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:754
static bool doit(const Value &Val)
Definition: Value.h:875
const_use_iterator use_end() const
Definition: Value.h:367
const_use_iterator materialized_use_begin() const
Definition: Value.h:355
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:591
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:719
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:869
Value * stripPointerCastsAndInvariantGroups()
Definition: Value.h:543
void print(raw_ostream &O, bool IsForDebug=false) const
Implement operator<< on Value.
Definition: AsmWriter.cpp:4278
Value * stripInBoundsConstantOffsets()
Definition: Value.h:553
const Value * stripPointerCastsSameRepresentation() const
Strip off pointer casts, all-zero GEPs and address space casts but ensures the representation of the ...
Definition: Value.cpp:529
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Definition: Value.cpp:525
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:643
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:887
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:712
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:600
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 and invariant group info.
Definition: Value.cpp:537
ValueTy
Concrete subclass of this.
Definition: Value.h:464
void setValueSubclassData(unsigned short D)
Definition: Value.h:704
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:542
void reverseUseList()
Reverse the use-list.
Definition: Value.cpp:735
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:1977
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:839
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:634
static bool doit(const Value &Val)
Definition: Value.h:806
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:2047
void mutateType(Type *Ty)
Mutate the type of this Value to be of the specified type.
Definition: Value.h:652
~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:596
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:827
Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds)
Definition: Value.h:582
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:881
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:863
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:1975
const Value * stripInBoundsConstantOffsets() const
Strip off pointer casts and all-constant inbounds GEPs.
Definition: Value.cpp:533
Base class for constants with no operands.
Definition: Constants.h:57
Value * operator=(Value *RHS)
Definition: Value.h:725
bool use_empty() const
Definition: Value.h:342
static bool doit(const Value &Val)
Definition: Value.h:851
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:813
user_iterator user_end()
Definition: Value.h:403