LLVM  14.0.0git
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"
18 #include "llvm/ADT/StringRef.h"
20 #include "llvm/IR/Use.h"
21 #include "llvm/Support/Alignment.h"
23 #include "llvm/Support/Casting.h"
24 #include <cassert>
25 #include <iterator>
26 #include <memory>
27 
28 namespace llvm {
29 
30 class APInt;
31 class Argument;
32 class BasicBlock;
33 class Constant;
34 class ConstantData;
35 class ConstantAggregate;
36 class DataLayout;
37 class Function;
38 class GlobalAlias;
39 class GlobalIFunc;
40 class GlobalIndirectSymbol;
41 class GlobalObject;
42 class GlobalValue;
43 class GlobalVariable;
44 class InlineAsm;
45 class Instruction;
46 class LLVMContext;
47 class MDNode;
48 class Module;
49 class ModuleSlotTracker;
50 class raw_ostream;
51 template<typename ValueTy> class StringMapEntry;
52 class Twine;
53 class Type;
54 class User;
55 
57 
58 //===----------------------------------------------------------------------===//
59 // Value Class
60 //===----------------------------------------------------------------------===//
61 
62 /// LLVM Value Representation
63 ///
64 /// This is a very important LLVM class. It is the base class of all values
65 /// computed by a program that may be used as operands to other values. Value is
66 /// the super class of other important classes such as Instruction and Function.
67 /// All Values have a Type. Type is not a subclass of Value. Some values can
68 /// have a name and they belong to some Module. Setting the name on the Value
69 /// automatically updates the module's symbol table.
70 ///
71 /// Every value has a "use list" that keeps track of which other Values are
72 /// using this Value. A Value can also have an arbitrary number of ValueHandle
73 /// objects that watch it and listen to RAUW and Destroy events. See
74 /// llvm/IR/ValueHandle.h for details.
75 class Value {
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 = 27 };
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 HasMetadata : 1; // Has metadata attached to this?
121  unsigned HasHungOffUses : 1;
122  unsigned HasDescriptor : 1;
123 
124 private:
125  template <typename UseT> // UseT == 'Use' or 'const Use'
126  class use_iterator_impl {
127  friend class Value;
128 
129  UseT *U;
130 
131  explicit use_iterator_impl(UseT *u) : U(u) {}
132 
133  public:
134  using iterator_category = std::forward_iterator_tag;
135  using value_type = UseT *;
136  using difference_type = std::ptrdiff_t;
137  using pointer = value_type *;
138  using reference = value_type &;
139 
140  use_iterator_impl() : U() {}
141 
142  bool operator==(const use_iterator_impl &x) const { return U == x.U; }
143  bool operator!=(const use_iterator_impl &x) const { return !operator==(x); }
144 
145  use_iterator_impl &operator++() { // Preincrement
146  assert(U && "Cannot increment end iterator!");
147  U = U->getNext();
148  return *this;
149  }
150 
151  use_iterator_impl operator++(int) { // Postincrement
152  auto tmp = *this;
153  ++*this;
154  return tmp;
155  }
156 
157  UseT &operator*() const {
158  assert(U && "Cannot dereference end iterator!");
159  return *U;
160  }
161 
162  UseT *operator->() const { return &operator*(); }
163 
164  operator use_iterator_impl<const UseT>() const {
165  return use_iterator_impl<const UseT>(U);
166  }
167  };
168 
169  template <typename UserTy> // UserTy == 'User' or 'const User'
170  class user_iterator_impl {
171  use_iterator_impl<Use> UI;
172  explicit user_iterator_impl(Use *U) : UI(U) {}
173  friend class Value;
174 
175  public:
176  using iterator_category = std::forward_iterator_tag;
177  using value_type = UserTy *;
178  using difference_type = std::ptrdiff_t;
179  using pointer = value_type *;
180  using reference = value_type &;
181 
182  user_iterator_impl() = default;
183 
184  bool operator==(const user_iterator_impl &x) const { return UI == x.UI; }
185  bool operator!=(const user_iterator_impl &x) const { return !operator==(x); }
186 
187  /// Returns true if this iterator is equal to user_end() on the value.
188  bool atEnd() const { return *this == user_iterator_impl(); }
189 
190  user_iterator_impl &operator++() { // Preincrement
191  ++UI;
192  return *this;
193  }
194 
195  user_iterator_impl operator++(int) { // Postincrement
196  auto tmp = *this;
197  ++*this;
198  return tmp;
199  }
200 
201  // Retrieve a pointer to the current User.
202  UserTy *operator*() const {
203  return UI->getUser();
204  }
205 
206  UserTy *operator->() const { return operator*(); }
207 
208  operator user_iterator_impl<const UserTy>() const {
209  return user_iterator_impl<const UserTy>(*UI);
210  }
211 
212  Use &getUse() const { return *UI; }
213  };
214 
215 protected:
216  Value(Type *Ty, unsigned scid);
217 
218  /// Value's destructor should be virtual by design, but that would require
219  /// that Value and all of its subclasses have a vtable that effectively
220  /// duplicates the information in the value ID. As a size optimization, the
221  /// destructor has been protected, and the caller should manually call
222  /// deleteValue.
223  ~Value(); // Use deleteValue() to delete a generic Value.
224 
225 public:
226  Value(const Value &) = delete;
227  Value &operator=(const Value &) = delete;
228 
229  /// Delete a pointer to a generic Value.
230  void deleteValue();
231 
232  /// Support for debugging, callable in GDB: V->dump()
233  void dump() const;
234 
235  /// Implement operator<< on Value.
236  /// @{
237  void print(raw_ostream &O, bool IsForDebug = false) const;
238  void print(raw_ostream &O, ModuleSlotTracker &MST,
239  bool IsForDebug = false) const;
240  /// @}
241 
242  /// Print the name of this Value out to the specified raw_ostream.
243  ///
244  /// This is useful when you just want to print 'int %reg126', not the
245  /// instruction that generated it. If you specify a Module for context, then
246  /// even constanst get pretty-printed; for example, the type of a null
247  /// pointer is printed symbolically.
248  /// @{
249  void printAsOperand(raw_ostream &O, bool PrintType = true,
250  const Module *M = nullptr) const;
251  void printAsOperand(raw_ostream &O, bool PrintType,
252  ModuleSlotTracker &MST) const;
253  /// @}
254 
255  /// All values are typed, get the type of this value.
256  Type *getType() const { return VTy; }
257 
258  /// All values hold a context through their type.
259  LLVMContext &getContext() const;
260 
261  // All values can potentially be named.
262  bool hasName() const { return HasName; }
263  ValueName *getValueName() const;
264  void setValueName(ValueName *VN);
265 
266 private:
267  void destroyValueName();
268  enum class ReplaceMetadataUses { No, Yes };
269  void doRAUW(Value *New, ReplaceMetadataUses);
270  void setNameImpl(const Twine &Name);
271 
272 public:
273  /// Return a constant reference to the value's name.
274  ///
275  /// This guaranteed to return the same reference as long as the value is not
276  /// modified. If the value has a name, this does a hashtable lookup, so it's
277  /// not free.
278  StringRef getName() const;
279 
280  /// Change the name of the value.
281  ///
282  /// Choose a new unique name if the provided name is taken.
283  ///
284  /// \param Name The new name; or "" if the value's name should be removed.
285  void setName(const Twine &Name);
286 
287  /// Transfer the name from V to this value.
288  ///
289  /// After taking V's name, sets V's name to empty.
290  ///
291  /// \note It is an error to call V->takeName(V).
292  void takeName(Value *V);
293 
294 #ifndef NDEBUG
295  std::string getNameOrAsOperand() const;
296 #endif
297 
298  /// Change all uses of this to point to a new Value.
299  ///
300  /// Go through the uses list for this definition and make each use point to
301  /// "V" instead of "this". After this completes, 'this's use list is
302  /// guaranteed to be empty.
303  void replaceAllUsesWith(Value *V);
304 
305  /// Change non-metadata uses of this to point to a new Value.
306  ///
307  /// Go through the uses list for this definition and make each use point to
308  /// "V" instead of "this". This function skips metadata entries in the list.
310 
311  /// Go through the uses list for this definition and make each use point
312  /// to "V" if the callback ShouldReplace returns true for the given Use.
313  /// Unlike replaceAllUsesWith() this function does not support basic block
314  /// values.
315  void replaceUsesWithIf(Value *New,
316  llvm::function_ref<bool(Use &U)> ShouldReplace);
317 
318  /// replaceUsesOutsideBlock - Go through the uses list for this definition and
319  /// make each use point to "V" instead of "this" when the use is outside the
320  /// block. 'This's use list is expected to have at least one element.
321  /// Unlike replaceAllUsesWith() this function does not support basic block
322  /// values.
324 
325  //----------------------------------------------------------------------
326  // Methods for handling the chain of uses of this Value.
327  //
328  // Materializing a function can introduce new uses, so these methods come in
329  // two variants:
330  // The methods that start with materialized_ check the uses that are
331  // currently known given which functions are materialized. Be very careful
332  // when using them since you might not get all uses.
333  // The methods that don't start with materialized_ assert that modules is
334  // fully materialized.
335  void assertModuleIsMaterializedImpl() const;
336  // This indirection exists so we can keep assertModuleIsMaterializedImpl()
337  // around in release builds of Value.cpp to be linked with other code built
338  // in debug mode. But this avoids calling it in any of the release built code.
340 #ifndef NDEBUG
342 #endif
343  }
344 
345  bool use_empty() const {
347  return UseList == nullptr;
348  }
349 
350  bool materialized_use_empty() const {
351  return UseList == nullptr;
352  }
353 
354  using use_iterator = use_iterator_impl<Use>;
355  using const_use_iterator = use_iterator_impl<const Use>;
356 
359  return const_use_iterator(UseList);
360  }
363  return materialized_use_begin();
364  }
367  return materialized_use_begin();
368  }
373  }
376  }
379  return materialized_uses();
380  }
383  return materialized_uses();
384  }
385 
386  bool user_empty() const {
388  return UseList == nullptr;
389  }
390 
391  using user_iterator = user_iterator_impl<User>;
392  using const_user_iterator = user_iterator_impl<const User>;
393 
396  return const_user_iterator(UseList);
397  }
400  return materialized_user_begin();
401  }
404  return materialized_user_begin();
405  }
410  return *materialized_user_begin();
411  }
412  const User *user_back() const {
414  return *materialized_user_begin();
415  }
418  }
421  }
424  return materialized_users();
425  }
428  return materialized_users();
429  }
430 
431  /// Return true if there is exactly one use of this value.
432  ///
433  /// This is specialized because it is a common request and does not require
434  /// traversing the whole use list.
435  bool hasOneUse() const { return hasSingleElement(uses()); }
436 
437  /// Return true if this Value has exactly N uses.
438  bool hasNUses(unsigned N) const;
439 
440  /// Return true if this value has N uses or more.
441  ///
442  /// This is logically equivalent to getNumUses() >= N.
443  bool hasNUsesOrMore(unsigned N) const;
444 
445  /// Return true if there is exactly one user of this value.
446  ///
447  /// Note that this is not the same as "has one use". If a value has one use,
448  /// then there certainly is a single user. But if value has several uses,
449  /// it is possible that all uses are in a single user, or not.
450  ///
451  /// This check is potentially costly, since it requires traversing,
452  /// in the worst case, the whole use list of a value.
453  bool hasOneUser() const;
454 
455  /// Return true if there is exactly one use of this value that cannot be
456  /// dropped.
458  const Use *getSingleUndroppableUse() const {
459  return const_cast<Value *>(this)->getSingleUndroppableUse();
460  }
461 
462  /// Return true if there this value.
463  ///
464  /// This is specialized because it is a common request and does not require
465  /// traversing the whole use list.
466  bool hasNUndroppableUses(unsigned N) const;
467 
468  /// Return true if this value has N uses or more.
469  ///
470  /// This is logically equivalent to getNumUses() >= N.
471  bool hasNUndroppableUsesOrMore(unsigned N) const;
472 
473  /// Remove every uses that can safely be removed.
474  ///
475  /// This will remove for example uses in llvm.assume.
476  /// This should be used when performing want to perform a tranformation but
477  /// some Droppable uses pervent it.
478  /// This function optionally takes a filter to only remove some droppable
479  /// uses.
480  void dropDroppableUses(llvm::function_ref<bool(const Use *)> ShouldDrop =
481  [](const Use *) { return true; });
482 
483  /// Remove every use of this value in \p User that can safely be removed.
484  void dropDroppableUsesIn(User &Usr);
485 
486  /// Remove the droppable use \p U.
487  static void dropDroppableUse(Use &U);
488 
489  /// Check if this value is used in the specified basic block.
490  bool isUsedInBasicBlock(const BasicBlock *BB) const;
491 
492  /// This method computes the number of uses of this Value.
493  ///
494  /// This is a linear time operation. Use hasOneUse, hasNUses, or
495  /// hasNUsesOrMore to check for specific values.
496  unsigned getNumUses() const;
497 
498  /// This method should only be used by the Use class.
499  void addUse(Use &U) { U.addToList(&UseList); }
500 
501  /// Concrete subclass of this.
502  ///
503  /// An enumeration for keeping track of the concrete subclass of Value that
504  /// is actually instantiated. Values of this enumeration are kept in the
505  /// Value classes SubclassID field. They are used for concrete type
506  /// identification.
507  enum ValueTy {
508 #define HANDLE_VALUE(Name) Name##Val,
509 #include "llvm/IR/Value.def"
510 
511  // Markers:
512 #define HANDLE_CONSTANT_MARKER(Marker, Constant) Marker = Constant##Val,
513 #include "llvm/IR/Value.def"
514  };
515 
516  /// Return an ID for the concrete type of this object.
517  ///
518  /// This is used to implement the classof checks. This should not be used
519  /// for any other purpose, as the values may change as LLVM evolves. Also,
520  /// note that for instructions, the Instruction's opcode is added to
521  /// InstructionVal. So this means three things:
522  /// # there is no value with code InstructionVal (no opcode==0).
523  /// # there are more possible values for the value type than in ValueTy enum.
524  /// # the InstructionVal enumerator must be the highest valued enumerator in
525  /// the ValueTy enum.
526  unsigned getValueID() const {
527  return SubclassID;
528  }
529 
530  /// Return the raw optional flags value contained in this value.
531  ///
532  /// This should only be used when testing two Values for equivalence.
533  unsigned getRawSubclassOptionalData() const {
534  return SubclassOptionalData;
535  }
536 
537  /// Clear the optional flags contained in this value.
540  }
541 
542  /// Check the optional flags for equality.
543  bool hasSameSubclassOptionalData(const Value *V) const {
545  }
546 
547  /// Return true if there is a value handle associated with this value.
548  bool hasValueHandle() const { return HasValueHandle; }
549 
550  /// Return true if there is metadata referencing this value.
551  bool isUsedByMetadata() const { return IsUsedByMD; }
552 
553  // Return true if this value is only transitively referenced by metadata.
554  bool isTransitiveUsedByMetadataOnly() const;
555 
556 protected:
557  /// Get the current metadata attachments for the given kind, if any.
558  ///
559  /// These functions require that the value have at most a single attachment
560  /// of the given kind, and return \c nullptr if such an attachment is missing.
561  /// @{
562  MDNode *getMetadata(unsigned KindID) const;
564  /// @}
565 
566  /// Appends all attachments with the given ID to \c MDs in insertion order.
567  /// If the Value has no attachments with the given ID, or if ID is invalid,
568  /// leaves MDs unchanged.
569  /// @{
570  void getMetadata(unsigned KindID, SmallVectorImpl<MDNode *> &MDs) const;
572  /// @}
573 
574  /// Appends all metadata attached to this value to \c MDs, sorting by
575  /// KindID. The first element of each pair returned is the KindID, the second
576  /// element is the metadata value. Attachments with the same ID appear in
577  /// insertion order.
578  void
579  getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const;
580 
581  /// Return true if this value has any metadata attached to it.
582  bool hasMetadata() const { return (bool)HasMetadata; }
583 
584  /// Return true if this value has the given type of metadata attached.
585  /// @{
586  bool hasMetadata(unsigned KindID) const {
587  return getMetadata(KindID) != nullptr;
588  }
589  bool hasMetadata(StringRef Kind) const {
590  return getMetadata(Kind) != nullptr;
591  }
592  /// @}
593 
594  /// Set a particular kind of metadata attachment.
595  ///
596  /// Sets the given attachment to \c MD, erasing it if \c MD is \c nullptr or
597  /// replacing it if it already exists.
598  /// @{
599  void setMetadata(unsigned KindID, MDNode *Node);
601  /// @}
602 
603  /// Add a metadata attachment.
604  /// @{
605  void addMetadata(unsigned KindID, MDNode &MD);
606  void addMetadata(StringRef Kind, MDNode &MD);
607  /// @}
608 
609  /// Erase all metadata attachments with the given kind.
610  ///
611  /// \returns true if any metadata was removed.
612  bool eraseMetadata(unsigned KindID);
613 
614  /// Erase all metadata attached to this Value.
615  void clearMetadata();
616 
617 public:
618  /// Return true if this value is a swifterror value.
619  ///
620  /// swifterror values can be either a function argument or an alloca with a
621  /// swifterror attribute.
622  bool isSwiftError() const;
623 
624  /// Strip off pointer casts, all-zero GEPs and address space casts.
625  ///
626  /// Returns the original uncasted value. If this is called on a non-pointer
627  /// value, it returns 'this'.
628  const Value *stripPointerCasts() const;
630  return const_cast<Value *>(
631  static_cast<const Value *>(this)->stripPointerCasts());
632  }
633 
634  /// Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
635  ///
636  /// Returns the original uncasted value. If this is called on a non-pointer
637  /// value, it returns 'this'.
638  const Value *stripPointerCastsAndAliases() const;
640  return const_cast<Value *>(
641  static_cast<const Value *>(this)->stripPointerCastsAndAliases());
642  }
643 
644  /// Strip off pointer casts, all-zero GEPs and address space casts
645  /// but ensures the representation of the result stays the same.
646  ///
647  /// Returns the original uncasted value with the same representation. If this
648  /// is called on a non-pointer value, it returns 'this'.
651  return const_cast<Value *>(static_cast<const Value *>(this)
653  }
654 
655  /// Strip off pointer casts, all-zero GEPs, single-argument phi nodes and
656  /// invariant group info.
657  ///
658  /// Returns the original uncasted value. If this is called on a non-pointer
659  /// value, it returns 'this'. This function should be used only in
660  /// Alias analysis.
663  return const_cast<Value *>(static_cast<const Value *>(this)
665  }
666 
667  /// Strip off pointer casts and all-constant inbounds GEPs.
668  ///
669  /// Returns the original pointer value. If this is called on a non-pointer
670  /// value, it returns 'this'.
671  const Value *stripInBoundsConstantOffsets() const;
673  return const_cast<Value *>(
674  static_cast<const Value *>(this)->stripInBoundsConstantOffsets());
675  }
676 
677  /// Accumulate the constant offset this value has compared to a base pointer.
678  /// Only 'getelementptr' instructions (GEPs) are accumulated but other
679  /// instructions, e.g., casts, are stripped away as well.
680  /// The accumulated constant offset is added to \p Offset and the base
681  /// pointer is returned.
682  ///
683  /// The APInt \p Offset has to have a bit-width equal to the IntPtr type for
684  /// the address space of 'this' pointer value, e.g., use
685  /// DataLayout::getIndexTypeSizeInBits(Ty).
686  ///
687  /// If \p AllowNonInbounds is true, offsets in GEPs are stripped and
688  /// accumulated even if the GEP is not "inbounds".
689  ///
690  /// If \p ExternalAnalysis is provided it will be used to calculate a offset
691  /// when a operand of GEP is not constant.
692  /// For example, for a value \p ExternalAnalysis might try to calculate a
693  /// lower bound. If \p ExternalAnalysis is successful, it should return true.
694  ///
695  /// If this is called on a non-pointer value, it returns 'this' and the
696  /// \p Offset is not modified.
697  ///
698  /// Note that this function will never return a nullptr. It will also never
699  /// manipulate the \p Offset in a way that would not match the difference
700  /// between the underlying value and the returned one. Thus, if no constant
701  /// offset was found, the returned value is the underlying one and \p Offset
702  /// is unchanged.
704  const DataLayout &DL, APInt &Offset, bool AllowNonInbounds,
705  function_ref<bool(Value &Value, APInt &Offset)> ExternalAnalysis =
706  nullptr) const;
708  bool AllowNonInbounds) {
709  return const_cast<Value *>(
710  static_cast<const Value *>(this)->stripAndAccumulateConstantOffsets(
711  DL, Offset, AllowNonInbounds));
712  }
713 
714  /// This is a wrapper around stripAndAccumulateConstantOffsets with the
715  /// in-bounds requirement set to false.
717  APInt &Offset) const {
719  /* AllowNonInbounds */ false);
720  }
722  APInt &Offset) {
724  /* AllowNonInbounds */ false);
725  }
726 
727  /// Strip off pointer casts and inbounds GEPs.
728  ///
729  /// Returns the original pointer value. If this is called on a non-pointer
730  /// value, it returns 'this'.
731  const Value *stripInBoundsOffsets(function_ref<void(const Value *)> Func =
732  [](const Value *) {}) const;
733  inline Value *stripInBoundsOffsets(function_ref<void(const Value *)> Func =
734  [](const Value *) {}) {
735  return const_cast<Value *>(
736  static_cast<const Value *>(this)->stripInBoundsOffsets(Func));
737  }
738 
739  /// Return true if the memory object referred to by V can by freed in the
740  /// scope for which the SSA value defining the allocation is statically
741  /// defined. E.g. deallocation after the static scope of a value does not
742  /// count, but a deallocation before that does.
743  bool canBeFreed() const;
744 
745  /// Returns the number of bytes known to be dereferenceable for the
746  /// pointer value.
747  ///
748  /// If CanBeNull is set by this function the pointer can either be null or be
749  /// dereferenceable up to the returned number of bytes.
750  ///
751  /// IF CanBeFreed is true, the pointer is known to be dereferenceable at
752  /// point of definition only. Caller must prove that allocation is not
753  /// deallocated between point of definition and use.
754  uint64_t getPointerDereferenceableBytes(const DataLayout &DL,
755  bool &CanBeNull,
756  bool &CanBeFreed) const;
757 
758  /// Returns an alignment of the pointer value.
759  ///
760  /// Returns an alignment which is either specified explicitly, e.g. via
761  /// align attribute of a function argument, or guaranteed by DataLayout.
762  Align getPointerAlignment(const DataLayout &DL) const;
763 
764  /// Translate PHI node to its predecessor from the given basic block.
765  ///
766  /// If this value is a PHI node with CurBB as its parent, return the value in
767  /// the PHI node corresponding to PredBB. If not, return ourself. This is
768  /// useful if you want to know the value something has in a predecessor
769  /// block.
770  const Value *DoPHITranslation(const BasicBlock *CurBB,
771  const BasicBlock *PredBB) const;
772  Value *DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB) {
773  return const_cast<Value *>(
774  static_cast<const Value *>(this)->DoPHITranslation(CurBB, PredBB));
775  }
776 
777  /// The maximum alignment for instructions.
778  ///
779  /// This is the greatest alignment value supported by load, store, and alloca
780  /// instructions, and global values.
781  static constexpr unsigned MaxAlignmentExponent = 30;
782  static constexpr unsigned MaximumAlignment = 1u << MaxAlignmentExponent;
783 
784  /// Mutate the type of this Value to be of the specified type.
785  ///
786  /// Note that this is an extremely dangerous operation which can create
787  /// completely invalid IR very easily. It is strongly recommended that you
788  /// recreate IR objects with the right types instead of mutating them in
789  /// place.
790  void mutateType(Type *Ty) {
791  VTy = Ty;
792  }
793 
794  /// Sort the use-list.
795  ///
796  /// Sorts the Value's use-list by Cmp using a stable mergesort. Cmp is
797  /// expected to compare two \a Use references.
798  template <class Compare> void sortUseList(Compare Cmp);
799 
800  /// Reverse the use-list.
801  void reverseUseList();
802 
803 private:
804  /// Merge two lists together.
805  ///
806  /// Merges \c L and \c R using \c Cmp. To enable stable sorts, always pushes
807  /// "equal" items from L before items from R.
808  ///
809  /// \return the first element in the list.
810  ///
811  /// \note Completely ignores \a Use::Prev (doesn't read, doesn't update).
812  template <class Compare>
813  static Use *mergeUseLists(Use *L, Use *R, Compare Cmp) {
814  Use *Merged;
815  Use **Next = &Merged;
816 
817  while (true) {
818  if (!L) {
819  *Next = R;
820  break;
821  }
822  if (!R) {
823  *Next = L;
824  break;
825  }
826  if (Cmp(*R, *L)) {
827  *Next = R;
828  Next = &R->Next;
829  R = R->Next;
830  } else {
831  *Next = L;
832  Next = &L->Next;
833  L = L->Next;
834  }
835  }
836 
837  return Merged;
838  }
839 
840 protected:
841  unsigned short getSubclassDataFromValue() const { return SubclassData; }
842  void setValueSubclassData(unsigned short D) { SubclassData = D; }
843 };
844 
845 struct ValueDeleter { void operator()(Value *V) { V->deleteValue(); } };
846 
847 /// Use this instead of std::unique_ptr<Value> or std::unique_ptr<Instruction>.
848 /// Those don't work because Value and Instruction's destructors are protected,
849 /// aren't virtual, and won't destroy the complete object.
850 using unique_value = std::unique_ptr<Value, ValueDeleter>;
851 
852 inline raw_ostream &operator<<(raw_ostream &OS, const Value &V) {
853  V.print(OS);
854  return OS;
855 }
856 
857 void Use::set(Value *V) {
858  if (Val) removeFromList();
859  Val = V;
860  if (V) V->addUse(*this);
861 }
862 
864  set(RHS);
865  return RHS;
866 }
867 
868 const Use &Use::operator=(const Use &RHS) {
869  set(RHS.Val);
870  return *this;
871 }
872 
873 template <class Compare> void Value::sortUseList(Compare Cmp) {
874  if (!UseList || !UseList->Next)
875  // No need to sort 0 or 1 uses.
876  return;
877 
878  // Note: this function completely ignores Prev pointers until the end when
879  // they're fixed en masse.
880 
881  // Create a binomial vector of sorted lists, visiting uses one at a time and
882  // merging lists as necessary.
883  const unsigned MaxSlots = 32;
884  Use *Slots[MaxSlots];
885 
886  // Collect the first use, turning it into a single-item list.
887  Use *Next = UseList->Next;
888  UseList->Next = nullptr;
889  unsigned NumSlots = 1;
890  Slots[0] = UseList;
891 
892  // Collect all but the last use.
893  while (Next->Next) {
894  Use *Current = Next;
895  Next = Current->Next;
896 
897  // Turn Current into a single-item list.
898  Current->Next = nullptr;
899 
900  // Save Current in the first available slot, merging on collisions.
901  unsigned I;
902  for (I = 0; I < NumSlots; ++I) {
903  if (!Slots[I])
904  break;
905 
906  // Merge two lists, doubling the size of Current and emptying slot I.
907  //
908  // Since the uses in Slots[I] originally preceded those in Current, send
909  // Slots[I] in as the left parameter to maintain a stable sort.
910  Current = mergeUseLists(Slots[I], Current, Cmp);
911  Slots[I] = nullptr;
912  }
913  // Check if this is a new slot.
914  if (I == NumSlots) {
915  ++NumSlots;
916  assert(NumSlots <= MaxSlots && "Use list bigger than 2^32");
917  }
918 
919  // Found an open slot.
920  Slots[I] = Current;
921  }
922 
923  // Merge all the lists together.
924  assert(Next && "Expected one more Use");
925  assert(!Next->Next && "Expected only one Use");
926  UseList = Next;
927  for (unsigned I = 0; I < NumSlots; ++I)
928  if (Slots[I])
929  // Since the uses in Slots[I] originally preceded those in UseList, send
930  // Slots[I] in as the left parameter to maintain a stable sort.
931  UseList = mergeUseLists(Slots[I], UseList, Cmp);
932 
933  // Fix the Prev pointers.
934  for (Use *I = UseList, **Prev = &UseList; I; I = I->Next) {
935  I->Prev = Prev;
936  Prev = &I->Next;
937  }
938 }
939 
940 // isa - Provide some specializations of isa so that we don't have to include
941 // the subtype header files to test to see if the value is a subclass...
942 //
943 template <> struct isa_impl<Constant, Value> {
944  static inline bool doit(const Value &Val) {
945  static_assert(Value::ConstantFirstVal == 0, "Val.getValueID() >= Value::ConstantFirstVal");
946  return Val.getValueID() <= Value::ConstantLastVal;
947  }
948 };
949 
950 template <> struct isa_impl<ConstantData, Value> {
951  static inline bool doit(const Value &Val) {
952  return Val.getValueID() >= Value::ConstantDataFirstVal &&
953  Val.getValueID() <= Value::ConstantDataLastVal;
954  }
955 };
956 
957 template <> struct isa_impl<ConstantAggregate, Value> {
958  static inline bool doit(const Value &Val) {
959  return Val.getValueID() >= Value::ConstantAggregateFirstVal &&
960  Val.getValueID() <= Value::ConstantAggregateLastVal;
961  }
962 };
963 
964 template <> struct isa_impl<Argument, Value> {
965  static inline bool doit (const Value &Val) {
966  return Val.getValueID() == Value::ArgumentVal;
967  }
968 };
969 
970 template <> struct isa_impl<InlineAsm, Value> {
971  static inline bool doit(const Value &Val) {
972  return Val.getValueID() == Value::InlineAsmVal;
973  }
974 };
975 
976 template <> struct isa_impl<Instruction, Value> {
977  static inline bool doit(const Value &Val) {
978  return Val.getValueID() >= Value::InstructionVal;
979  }
980 };
981 
982 template <> struct isa_impl<BasicBlock, Value> {
983  static inline bool doit(const Value &Val) {
984  return Val.getValueID() == Value::BasicBlockVal;
985  }
986 };
987 
988 template <> struct isa_impl<Function, Value> {
989  static inline bool doit(const Value &Val) {
990  return Val.getValueID() == Value::FunctionVal;
991  }
992 };
993 
994 template <> struct isa_impl<GlobalVariable, Value> {
995  static inline bool doit(const Value &Val) {
996  return Val.getValueID() == Value::GlobalVariableVal;
997  }
998 };
999 
1000 template <> struct isa_impl<GlobalAlias, Value> {
1001  static inline bool doit(const Value &Val) {
1002  return Val.getValueID() == Value::GlobalAliasVal;
1003  }
1004 };
1005 
1006 template <> struct isa_impl<GlobalIFunc, Value> {
1007  static inline bool doit(const Value &Val) {
1008  return Val.getValueID() == Value::GlobalIFuncVal;
1009  }
1010 };
1011 
1012 template <> struct isa_impl<GlobalIndirectSymbol, Value> {
1013  static inline bool doit(const Value &Val) {
1014  return isa<GlobalAlias>(Val) || isa<GlobalIFunc>(Val);
1015  }
1016 };
1017 
1018 template <> struct isa_impl<GlobalValue, Value> {
1019  static inline bool doit(const Value &Val) {
1020  return isa<GlobalObject>(Val) || isa<GlobalIndirectSymbol>(Val);
1021  }
1022 };
1023 
1024 template <> struct isa_impl<GlobalObject, Value> {
1025  static inline bool doit(const Value &Val) {
1026  return isa<GlobalVariable>(Val) || isa<Function>(Val);
1027  }
1028 };
1029 
1030 // Create wrappers for C Binding types (see CBindingWrapping.h).
1032 
1033 // Specialized opaque value conversions.
1035  return reinterpret_cast<Value**>(Vals);
1036 }
1037 
1038 template<typename T>
1039 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
1040 #ifndef NDEBUG
1041  for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
1042  unwrap<T>(*I); // For side effect of calling assert on invalid usage.
1043 #endif
1044  (void)Length;
1045  return reinterpret_cast<T**>(Vals);
1046 }
1047 
1048 inline LLVMValueRef *wrap(const Value **Vals) {
1049  return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
1050 }
1051 
1052 } // end namespace llvm
1053 
1054 #endif // LLVM_IR_VALUE_H
llvm::objcarc::ARCInstKind::User
@ User
could "use" a pointer
llvm::Argument
This class represents an incoming formal argument to a Function.
Definition: Argument.h:29
llvm::Value::const_user_iterator
user_iterator_impl< const User > const_user_iterator
Definition: Value.h:392
llvm::Value::stripPointerCastsAndAliases
const Value * stripPointerCastsAndAliases() const
Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
Definition: Value.cpp:679
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::Value::isUsedInBasicBlock
bool isUsedInBasicBlock(const BasicBlock *BB) const
Check if this value is used in the specified basic block.
Definition: Value.cpp:222
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::Value::dropDroppableUse
static void dropDroppableUse(Use &U)
Remove the droppable use U.
Definition: Value.cpp:205
llvm::Value::getPointerAlignment
Align getPointerAlignment(const DataLayout &DL) const
Returns an alignment of the pointer value.
Definition: Value.cpp:905
llvm::make_range
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Definition: iterator_range.h:53
llvm::StringMapEntry
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
Definition: StringMapEntry.h:98
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:112
llvm::Value::hasOneUse
bool hasOneUse() const
Return true if there is exactly one use of this value.
Definition: Value.h:435
llvm::Value::stripInBoundsConstantOffsets
Value * stripInBoundsConstantOffsets()
Definition: Value.h:672
llvm::Value::SubclassOptionalData
unsigned char SubclassOptionalData
Hold subclass data that can be dropped.
Definition: Value.h:91
llvm::Value::hasMetadata
bool hasMetadata(unsigned KindID) const
Return true if this value has the given type of metadata attached.
Definition: Value.h:586
llvm::ValueHandleBase
This is the common base class of value handles.
Definition: ValueHandle.h:29
llvm::Function
Definition: Function.h:61
llvm::Value::stripPointerCastsAndAliases
Value * stripPointerCastsAndAliases()
Definition: Value.h:639
llvm::Value::dump
void dump() const
Support for debugging, callable in GDB: V->dump()
Definition: AsmWriter.cpp:4759
StringRef.h
llvm::Value::getSubclassDataFromValue
unsigned short getSubclassDataFromValue() const
Definition: Value.h:841
pointer
Replace within non kernel function use of LDS with pointer
Definition: AMDGPUReplaceLDSUseWithPointer.cpp:443
llvm::isa_impl< GlobalIFunc, Value >::doit
static bool doit(const Value &Val)
Definition: Value.h:1007
llvm::Value::uses
iterator_range< const_use_iterator > uses() const
Definition: Value.h:381
Types.h
llvm::Value::hasName
bool hasName() const
Definition: Value.h:262
llvm::GlobalIndirectSymbol
Definition: GlobalIndirectSymbol.h:28
llvm::GlobalVariable
Definition: GlobalVariable.h:40
llvm::ConstantAggregate
Base class for aggregate constants (with operands).
Definition: Constants.h:385
llvm::GlobalAlias
Definition: GlobalAlias.h:27
llvm::Value::materialized_users
iterator_range< const_user_iterator > materialized_users() const
Definition: Value.h:419
llvm::Value::materialized_user_begin
const_user_iterator materialized_user_begin() const
Definition: Value.h:395
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::Value::stripAndAccumulateConstantOffsets
const Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, function_ref< bool(Value &Value, APInt &Offset)> ExternalAnalysis=nullptr) const
Accumulate the constant offset this value has compared to a base pointer.
llvm::isa_impl< GlobalVariable, Value >::doit
static bool doit(const Value &Val)
Definition: Value.h:995
llvm::operator!=
bool operator!=(uint64_t V1, const APInt &V2)
Definition: APInt.h:1976
llvm::isa_impl< GlobalIndirectSymbol, Value >::doit
static bool doit(const Value &Val)
Definition: Value.h:1013
llvm::ValueDeleter
Definition: Value.h:845
llvm::Value::hasOneUser
bool hasOneUser() const
Return true if there is exactly one user of this value.
Definition: Value.cpp:157
llvm::Value::HasHungOffUses
unsigned HasHungOffUses
Definition: Value.h:121
T
#define T
Definition: Mips16ISelLowering.cpp:341
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
CBindingWrapping.h
llvm::Value::user_begin
user_iterator user_begin()
Definition: Value.h:398
llvm::Value::NumUserOperands
unsigned NumUserOperands
Definition: Value.h:115
STLExtras.h
tmp
alloca< 16 x float >, align 16 %tmp2=alloca< 16 x float >, align 16 store< 16 x float > %A,< 16 x float > *%tmp %s=bitcast< 16 x float > *%tmp to i8 *%s2=bitcast< 16 x float > *%tmp2 to i8 *call void @llvm.memcpy.i64(i8 *%s, i8 *%s2, i64 64, i32 16) %R=load< 16 x float > *%tmp2 ret< 16 x float > %R } declare void @llvm.memcpy.i64(i8 *nocapture, i8 *nocapture, i64, i32) nounwind which compiles to:_foo:subl $140, %esp movaps %xmm3, 112(%esp) movaps %xmm2, 96(%esp) movaps %xmm1, 80(%esp) movaps %xmm0, 64(%esp) movl 60(%esp), %eax movl %eax, 124(%esp) movl 56(%esp), %eax movl %eax, 120(%esp) movl 52(%esp), %eax< many many more 32-bit copies > movaps(%esp), %xmm0 movaps 16(%esp), %xmm1 movaps 32(%esp), %xmm2 movaps 48(%esp), %xmm3 addl $140, %esp ret On Nehalem, it may even be cheaper to just use movups when unaligned than to fall back to lower-granularity chunks. Implement processor-specific optimizations for parity with GCC on these processors. GCC does two optimizations:1. ix86_pad_returns inserts a noop before ret instructions if immediately preceded by a conditional branch or is the target of a jump. 2. ix86_avoid_jump_misspredicts inserts noops in cases where a 16-byte block of code contains more than 3 branches. The first one is done for all AMDs, Core2, and "Generic" The second one is done for:Atom, Pentium Pro, all AMDs, Pentium 4, Nocona, Core 2, and "Generic" Testcase:int x(int a) { return(a &0xf0)> >4 tmp
Definition: README.txt:1347
llvm::Value::setValueSubclassData
void setValueSubclassData(unsigned short D)
Definition: Value.h:842
llvm::Value::dropDroppableUses
void dropDroppableUses(llvm::function_ref< bool(const Use *)> ShouldDrop=[](const Use *) { return true;})
Remove every uses that can safely be removed.
Definition: Value.cpp:187
Use.h
llvm::Value::materialized_user_begin
user_iterator materialized_user_begin()
Definition: Value.h:394
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:193
llvm::isa_impl< BasicBlock, Value >::doit
static bool doit(const Value &Val)
Definition: Value.h:983
llvm::Use::operator=
Value * operator=(Value *RHS)
Definition: Value.h:863
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::Value::isSwiftError
bool isSwiftError() const
Return true if this value is a swifterror value.
Definition: Value.cpp:999
llvm::ConstantData
Base class for constants with no operands.
Definition: Constants.h:51
llvm::isa_impl< Instruction, Value >::doit
static bool doit(const Value &Val)
Definition: Value.h:977
llvm::Value::reverseUseList
void reverseUseList()
Reverse the use-list.
Definition: Value.cpp:980
DEFINE_ISA_CONVERSION_FUNCTIONS
#define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref)
Definition: CBindingWrapping.h:28
llvm::Value::HasName
unsigned HasName
Definition: Value.h:119
llvm::Value::operator=
Value & operator=(const Value &)=delete
llvm::InlinerFunctionImportStatsOpts::No
@ No
llvm::ISD::Constant
@ Constant
Definition: ISDOpcodes.h:76
llvm::Value::use_iterator
use_iterator_impl< Use > use_iterator
Definition: Value.h:354
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::isa_impl< Function, Value >::doit
static bool doit(const Value &Val)
Definition: Value.h:989
llvm::User
Definition: User.h:44
llvm::Value::DoPHITranslation
Value * DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB)
Definition: Value.h:772
llvm::Value::getSingleUndroppableUse
Use * getSingleUndroppableUse()
Return true if there is exactly one use of this value that cannot be dropped.
Definition: Value.cpp:167
llvm::GlobalObject
Definition: GlobalObject.h:28
llvm::unique_value
std::unique_ptr< Value, ValueDeleter > unique_value
Use this instead of std::unique_ptr<Value> or std::unique_ptr<Instruction>.
Definition: Value.h:850
llvm::Value::stripAndAccumulateInBoundsConstantOffsets
Value * stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, APInt &Offset)
Definition: Value.h:721
llvm::Value::assertModuleIsMaterializedImpl
void assertModuleIsMaterializedImpl() const
Definition: Value.cpp:442
llvm::isa_impl< GlobalAlias, Value >::doit
static bool doit(const Value &Val)
Definition: Value.h:1001
llvm::Value::user_end
const_user_iterator user_end() const
Definition: Value.h:407
llvm::Value::uses
iterator_range< use_iterator > uses()
Definition: Value.h:377
llvm::Value::getValueID
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:526
llvm::Instruction
Definition: Instruction.h:45
llvm::unwrap
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:256
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::Value::setName
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:364
llvm::operator<<
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:230
Align
uint64_t Align
Definition: ELFObjHandler.cpp:83
llvm::Value::MaxAlignmentExponent
static constexpr unsigned MaxAlignmentExponent
The maximum alignment for instructions.
Definition: Value.h:781
llvm::Value::isTransitiveUsedByMetadataOnly
bool isTransitiveUsedByMetadataOnly() const
Definition: Value.cpp:1009
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::Value::use_empty
bool use_empty() const
Definition: Value.h:345
llvm::Value::dropDroppableUsesIn
void dropDroppableUsesIn(User &Usr)
Remove every use of this value in User that can safely be removed.
Definition: Value.cpp:197
llvm::Value::hasValueHandle
bool hasValueHandle() const
Return true if there is a value handle associated with this value.
Definition: Value.h:548
llvm::Value::use_end
const_use_iterator use_end() const
Definition: Value.h:370
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:168
llvm::Value::user_end
user_iterator user_end()
Definition: Value.h:406
llvm::Value::user_back
User * user_back()
Definition: Value.h:408
llvm::Value::stripPointerCastsSameRepresentation
const Value * stripPointerCastsSameRepresentation() const
Strip off pointer casts, all-zero GEPs and address space casts but ensures the representation of the ...
Definition: Value.cpp:683
llvm::InlineAsm
Definition: InlineAsm.h:31
llvm::Value::Value
Value(Type *Ty, unsigned scid)
Definition: Value.cpp:53
llvm::Value::hasNUndroppableUsesOrMore
bool hasNUndroppableUsesOrMore(unsigned N) const
Return true if this value has N uses or more.
Definition: Value.cpp:183
llvm::Use::set
void set(Value *Val)
Definition: Value.h:857
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:192
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::isa_impl< InlineAsm, Value >::doit
static bool doit(const Value &Val)
Definition: Value.h:971
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::Value::getNameOrAsOperand
std::string getNameOrAsOperand() const
Definition: Value.cpp:431
llvm::Value::mutateType
void mutateType(Type *Ty)
Mutate the type of this Value to be of the specified type.
Definition: Value.h:790
llvm::Value::IsUsedByMD
unsigned IsUsedByMD
Definition: Value.h:118
llvm::Value::getPointerDereferenceableBytes
uint64_t getPointerDereferenceableBytes(const DataLayout &DL, bool &CanBeNull, bool &CanBeFreed) const
Returns the number of bytes known to be dereferenceable for the pointer value.
Definition: Value.cpp:830
llvm::Value::addMetadata
void addMetadata(unsigned KindID, MDNode &MD)
Add a metadata attachment.
Definition: Metadata.cpp:1268
uint64_t
llvm::isa_impl< ConstantData, Value >::doit
static bool doit(const Value &Val)
Definition: Value.h:951
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::Value::MaximumAlignment
static constexpr unsigned MaximumAlignment
Definition: Value.h:782
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::Value::hasNUsesOrMore
bool hasNUsesOrMore(unsigned N) const
Return true if this value has N uses or more.
Definition: Value.cpp:153
llvm::Value::materialized_use_empty
bool materialized_use_empty() const
Definition: Value.h:350
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::Value::clearSubclassOptionalData
void clearSubclassOptionalData()
Clear the optional flags contained in this value.
Definition: Value.h:538
llvm::Value::user_begin
const_user_iterator user_begin() const
Definition: Value.h:402
llvm::Value::getValueName
ValueName * getValueName() const
Definition: Value.cpp:269
llvm::Value::replaceNonMetadataUsesWith
void replaceNonMetadataUsesWith(Value *V)
Change non-metadata uses of this to point to a new Value.
Definition: Value.cpp:524
llvm::Value::print
void print(raw_ostream &O, bool IsForDebug=false) const
Implement operator<< on Value.
Definition: AsmWriter.cpp:4598
TemplateParamKind::Type
@ Type
inline
into xmm2 addss xmm2 xmm1 xmm3 addss xmm3 movaps xmm0 unpcklps xmm0 ret seems silly when it could just be one addps Expand libm rounding functions inline
Definition: README-SSE.txt:72
llvm::isa_impl< ConstantAggregate, Value >::doit
static bool doit(const Value &Val)
Definition: Value.h:958
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::Value::setValueName
void setValueName(ValueName *VN)
Definition: Value.cpp:280
llvm::Value::replaceUsesOutsideBlock
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:574
llvm::Value::stripPointerCastsForAliasAnalysis
const Value * stripPointerCastsForAliasAnalysis() const
Strip off pointer casts, all-zero GEPs, single-argument phi nodes and invariant group info.
Definition: Value.cpp:691
llvm::Value::materialized_uses
iterator_range< use_iterator > materialized_uses()
Definition: Value.h:371
llvm::operator==
bool operator==(uint64_t V1, const APInt &V2)
Definition: APInt.h:1974
iterator_range.h
llvm::Value::use_begin
use_iterator use_begin()
Definition: Value.h:361
llvm::ISD::BasicBlock
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
llvm::Value::user_empty
bool user_empty() const
Definition: Value.h:386
llvm::MDNode
Metadata node.
Definition: Metadata.h:901
llvm::Value::clearMetadata
void clearMetadata()
Erase all metadata attached to this Value.
Definition: Metadata.cpp:1291
llvm::Value::printAsOperand
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:4675
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
Compare
QP Compare Ordered outs ins xscmpudp No builtin are required Or llvm fcmp order unorder compare DP QP Compare builtin are required DP Compare
Definition: README_P9.txt:309
llvm::wrap
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:251
llvm::hasSingleElement
bool hasSingleElement(ContainerTy &&C)
Returns true if the given container only contains a single element.
Definition: STLExtras.h:259
llvm::Value::ValueTy
ValueTy
Concrete subclass of this.
Definition: Value.h:507
llvm::operator*
APInt operator*(APInt a, uint64_t RHS)
Definition: APInt.h:2098
llvm::Value::getSingleUndroppableUse
const Use * getSingleUndroppableUse() const
Definition: Value.h:458
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::Value::hasSameSubclassOptionalData
bool hasSameSubclassOptionalData(const Value *V) const
Check the optional flags for equality.
Definition: Value.h:543
llvm::Value::getNumUses
unsigned getNumUses() const
This method computes the number of uses of this Value.
Definition: Value.cpp:243
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:256
llvm::Value::stripPointerCasts
Value * stripPointerCasts()
Definition: Value.h:629
llvm::Value::replaceAllUsesWith
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:520
llvm::Value::getContext
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:978
llvm::Value::use_end
use_iterator use_end()
Definition: Value.h:369
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::Value::getMetadata
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
Definition: Metadata.cpp:1197
Module
Machine Check Debug Module
Definition: MachineCheckDebugify.cpp:122
Node
Definition: ItaniumDemangle.h:234
llvm::Value::setMetadata
void setMetadata(unsigned KindID, MDNode *Node)
Set a particular kind of metadata attachment.
Definition: Metadata.cpp:1234
llvm::Value::getRawSubclassOptionalData
unsigned getRawSubclassOptionalData() const
Return the raw optional flags value contained in this value.
Definition: Value.h:533
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:297
llvm::isa_impl< GlobalObject, Value >::doit
static bool doit(const Value &Val)
Definition: Value.h:1025
llvm::Value::stripPointerCasts
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Definition: Value.cpp:675
llvm::Value::stripAndAccumulateInBoundsConstantOffsets
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:716
llvm::Value::stripInBoundsOffsets
const Value * stripInBoundsOffsets(function_ref< void(const Value *)> Func=[](const Value *) {}) const
Strip off pointer casts and inbounds GEPs.
Definition: Value.cpp:764
llvm::Value::use_begin
const_use_iterator use_begin() const
Definition: Value.h:365
llvm::Value::stripPointerCastsSameRepresentation
Value * stripPointerCastsSameRepresentation()
Definition: Value.h:650
llvm::Value::sortUseList
void sortUseList(Compare Cmp)
Sort the use-list.
Definition: Value.h:873
llvm::Value::HasMetadata
unsigned HasMetadata
Definition: Value.h:120
llvm::Value::eraseMetadata
bool eraseMetadata(unsigned KindID)
Erase all metadata attachments with the given kind.
Definition: Metadata.cpp:1279
Alignment.h
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::Value::user_back
const User * user_back() const
Definition: Value.h:412
llvm::Value::user_iterator
user_iterator_impl< User > user_iterator
Definition: Value.h:391
llvm::Value::hasNUndroppableUses
bool hasNUndroppableUses(unsigned N) const
Return true if there this value.
Definition: Value.cpp:179
llvm::Value::~Value
~Value()
Value's destructor should be virtual by design, but that would require that Value and all of its subc...
Definition: Value.cpp:76
llvm::Value::hasMetadata
bool hasMetadata(StringRef Kind) const
Definition: Value.h:589
llvm::X86::FirstMacroFusionInstKind::Cmp
@ Cmp
llvm::Value::addUse
void addUse(Use &U)
This method should only be used by the Use class.
Definition: Value.h:499
Casting.h
llvm::Value::NumUserOperandsBits
@ NumUserOperandsBits
Definition: Value.h:114
llvm::Value::hasNUses
bool hasNUses(unsigned N) const
Return true if this Value has exactly N uses.
Definition: Value.cpp:149
llvm::Value::assertModuleIsMaterialized
void assertModuleIsMaterialized() const
Definition: Value.h:339
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
x
TODO unsigned x
Definition: README.txt:10
llvm::Value::users
iterator_range< const_user_iterator > users() const
Definition: Value.h:426
llvm::Value::HasDescriptor
unsigned HasDescriptor
Definition: Value.h:122
llvm::PrevailingType::Yes
@ Yes
llvm::Value::const_use_iterator
use_iterator_impl< const Use > const_use_iterator
Definition: Value.h:355
llvm::Value::materialized_uses
iterator_range< const_use_iterator > materialized_uses() const
Definition: Value.h:374
llvm::Value::canBeFreed
bool canBeFreed() const
Return true if the memory object referred to by V can by freed in the scope for which the SSA value d...
Definition: Value.cpp:768
llvm::isa_impl< GlobalValue, Value >::doit
static bool doit(const Value &Val)
Definition: Value.h:1019
llvm::Value::stripInBoundsOffsets
Value * stripInBoundsOffsets(function_ref< void(const Value *)> Func=[](const Value *) {})
Definition: Value.h:733
llvm::Value::isUsedByMetadata
bool isUsedByMetadata() const
Return true if there is metadata referencing this value.
Definition: Value.h:551
llvm::Value::stripInBoundsConstantOffsets
const Value * stripInBoundsConstantOffsets() const
Strip off pointer casts and all-constant inbounds GEPs.
Definition: Value.cpp:687
llvm::Value::DoPHITranslation
const Value * DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB) const
Translate PHI node to its predecessor from the given basic block.
Definition: Value.cpp:970
llvm::ValueDeleter::operator()
void operator()(Value *V)
Definition: Value.h:845
N
#define N
llvm::Value::stripAndAccumulateConstantOffsets
Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds)
Definition: Value.h:707
llvm::Value::deleteValue
void deleteValue()
Delete a pointer to a generic Value.
Definition: Value.cpp:110
llvm::iterator_range
A range adaptor for a pair of iterators.
Definition: iterator_range.h:30
llvm::Value::materialized_use_begin
use_iterator materialized_use_begin()
Definition: Value.h:357
llvm::isa_impl< Constant, Value >::doit
static bool doit(const Value &Val)
Definition: Value.h:944
llvm::Value::getAllMetadata
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * >> &MDs) const
Appends all metadata attached to this value to MDs, sorting by KindID.
Definition: Metadata.cpp:1223
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:43
llvm::ValueAsMetadata
Value wrapper in the Metadata hierarchy.
Definition: Metadata.h:344
LLVMValueRef
struct LLVMOpaqueValue * LLVMValueRef
Represents an individual value in LLVM IR.
Definition: Types.h:75
llvm::Value::materialized_use_begin
const_use_iterator materialized_use_begin() const
Definition: Value.h:358
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::Value::replaceUsesWithIf
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.cpp:528
llvm::Value::takeName
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:370
llvm::Value::stripPointerCastsForAliasAnalysis
Value * stripPointerCastsForAliasAnalysis()
Definition: Value.h:662
llvm::GlobalIFunc
Definition: GlobalIFunc.h:32
llvm::Value::hasMetadata
bool hasMetadata() const
Return true if this value has any metadata attached to it.
Definition: Value.h:582
llvm::isa_impl< Argument, Value >::doit
static bool doit(const Value &Val)
Definition: Value.h:965
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::Value::users
iterator_range< user_iterator > users()
Definition: Value.h:422
llvm::isa_impl
Definition: Casting.h:56
llvm::Value::materialized_users
iterator_range< user_iterator > materialized_users()
Definition: Value.h:416
llvm::codeview::PublicSymFlags::Function
@ Function
llvm::Use
A Use represents the edge between a Value definition and its users.
Definition: Use.h:44