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