LLVM 18.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 Type *VTy;
76 Use *UseList;
77
78 friend class ValueAsMetadata; // Allow access to IsUsedByMD.
79 friend class ValueHandleBase;
80
81 const unsigned char SubclassID; // Subclass identifier (for isa/dyn_cast)
82 unsigned char HasValueHandle : 1; // Has a ValueHandle pointing to this?
83
84protected:
85 /// Hold subclass data that can be dropped.
86 ///
87 /// This member is similar to SubclassData, however it is for holding
88 /// information which may be used to aid optimization, but which may be
89 /// cleared to zero without affecting conservative interpretation.
90 unsigned char SubclassOptionalData : 7;
91
92private:
93 /// Hold arbitrary subclass data.
94 ///
95 /// This member is defined by this class, but is not used for anything.
96 /// Subclasses can use it to hold whatever state they find useful. This
97 /// field is initialized to zero by the ctor.
98 unsigned short SubclassData;
99
100protected:
101 /// The number of operands in the subclass.
102 ///
103 /// This member is defined by this class, but not used for anything.
104 /// Subclasses can use it to store their number of operands, if they have
105 /// any.
106 ///
107 /// This is stored here to save space in User on 64-bit hosts. Since most
108 /// instances of Value have operands, 32-bit hosts aren't significantly
109 /// affected.
110 ///
111 /// Note, this should *NOT* be used directly by any class other than User.
112 /// User uses this value to find the Use list.
113 enum : unsigned { NumUserOperandsBits = 27 };
115
116 // Use the same type as the bitfield above so that MSVC will pack them.
117 unsigned IsUsedByMD : 1;
118 unsigned HasName : 1;
119 unsigned HasMetadata : 1; // Has metadata attached to this?
120 unsigned HasHungOffUses : 1;
121 unsigned HasDescriptor : 1;
122
123private:
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 MDNode *getMetadata(StringRef Kind) const;
567 /// @}
568
569 /// Appends all attachments with the given ID to \c MDs in insertion order.
570 /// If the Value has no attachments with the given ID, or if ID is invalid,
571 /// leaves MDs unchanged.
572 /// @{
573 void getMetadata(unsigned KindID, SmallVectorImpl<MDNode *> &MDs) const;
574 void getMetadata(StringRef Kind, SmallVectorImpl<MDNode *> &MDs) const;
575 /// @}
576
577 /// Appends all metadata attached to this value to \c MDs, sorting by
578 /// KindID. The first element of each pair returned is the KindID, the second
579 /// element is the metadata value. Attachments with the same ID appear in
580 /// insertion order.
581 void
582 getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const;
583
584 /// Return true if this value has any metadata attached to it.
585 bool hasMetadata() const { return (bool)HasMetadata; }
586
587 /// Return true if this value has the given type of metadata attached.
588 /// @{
589 bool hasMetadata(unsigned KindID) const {
590 return getMetadata(KindID) != nullptr;
591 }
592 bool hasMetadata(StringRef Kind) const {
593 return getMetadata(Kind) != nullptr;
594 }
595 /// @}
596
597 /// Set a particular kind of metadata attachment.
598 ///
599 /// Sets the given attachment to \c MD, erasing it if \c MD is \c nullptr or
600 /// replacing it if it already exists.
601 /// @{
602 void setMetadata(unsigned KindID, MDNode *Node);
603 void setMetadata(StringRef Kind, MDNode *Node);
604 /// @}
605
606 /// Add a metadata attachment.
607 /// @{
608 void addMetadata(unsigned KindID, MDNode &MD);
609 void addMetadata(StringRef Kind, MDNode &MD);
610 /// @}
611
612 /// Erase all metadata attachments with the given kind.
613 ///
614 /// \returns true if any metadata was removed.
615 bool eraseMetadata(unsigned KindID);
616
617 /// Erase all metadata attached to this Value.
618 void clearMetadata();
619
620public:
621 /// Return true if this value is a swifterror value.
622 ///
623 /// swifterror values can be either a function argument or an alloca with a
624 /// swifterror attribute.
625 bool isSwiftError() const;
626
627 /// Strip off pointer casts, all-zero GEPs and address space casts.
628 ///
629 /// Returns the original uncasted value. If this is called on a non-pointer
630 /// value, it returns 'this'.
631 const Value *stripPointerCasts() const;
633 return const_cast<Value *>(
634 static_cast<const Value *>(this)->stripPointerCasts());
635 }
636
637 /// Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
638 ///
639 /// Returns the original uncasted value. If this is called on a non-pointer
640 /// value, it returns 'this'.
641 const Value *stripPointerCastsAndAliases() const;
643 return const_cast<Value *>(
644 static_cast<const Value *>(this)->stripPointerCastsAndAliases());
645 }
646
647 /// Strip off pointer casts, all-zero GEPs and address space casts
648 /// but ensures the representation of the result stays the same.
649 ///
650 /// Returns the original uncasted value with the same representation. If this
651 /// is called on a non-pointer value, it returns 'this'.
654 return const_cast<Value *>(static_cast<const Value *>(this)
656 }
657
658 /// Strip off pointer casts, all-zero GEPs, single-argument phi nodes and
659 /// invariant group info.
660 ///
661 /// Returns the original uncasted value. If this is called on a non-pointer
662 /// value, it returns 'this'. This function should be used only in
663 /// Alias analysis.
666 return const_cast<Value *>(static_cast<const Value *>(this)
668 }
669
670 /// Strip off pointer casts and all-constant inbounds GEPs.
671 ///
672 /// Returns the original pointer value. If this is called on a non-pointer
673 /// value, it returns 'this'.
674 const Value *stripInBoundsConstantOffsets() const;
676 return const_cast<Value *>(
677 static_cast<const Value *>(this)->stripInBoundsConstantOffsets());
678 }
679
680 /// Accumulate the constant offset this value has compared to a base pointer.
681 /// Only 'getelementptr' instructions (GEPs) are accumulated but other
682 /// instructions, e.g., casts, are stripped away as well.
683 /// The accumulated constant offset is added to \p Offset and the base
684 /// pointer is returned.
685 ///
686 /// The APInt \p Offset has to have a bit-width equal to the IntPtr type for
687 /// the address space of 'this' pointer value, e.g., use
688 /// DataLayout::getIndexTypeSizeInBits(Ty).
689 ///
690 /// If \p AllowNonInbounds is true, offsets in GEPs are stripped and
691 /// accumulated even if the GEP is not "inbounds".
692 ///
693 /// If \p AllowInvariantGroup is true then this method also looks through
694 /// strip.invariant.group and launder.invariant.group intrinsics.
695 ///
696 /// If \p ExternalAnalysis is provided it will be used to calculate a offset
697 /// when a operand of GEP is not constant.
698 /// For example, for a value \p ExternalAnalysis might try to calculate a
699 /// lower bound. If \p ExternalAnalysis is successful, it should return true.
700 ///
701 /// If this is called on a non-pointer value, it returns 'this' and the
702 /// \p Offset is not modified.
703 ///
704 /// Note that this function will never return a nullptr. It will also never
705 /// manipulate the \p Offset in a way that would not match the difference
706 /// between the underlying value and the returned one. Thus, if no constant
707 /// offset was found, the returned value is the underlying one and \p Offset
708 /// is unchanged.
710 const DataLayout &DL, APInt &Offset, bool AllowNonInbounds,
711 bool AllowInvariantGroup = false,
712 function_ref<bool(Value &Value, APInt &Offset)> ExternalAnalysis =
713 nullptr) const;
715 bool AllowNonInbounds,
716 bool AllowInvariantGroup = false) {
717 return const_cast<Value *>(
718 static_cast<const Value *>(this)->stripAndAccumulateConstantOffsets(
719 DL, Offset, AllowNonInbounds, AllowInvariantGroup));
720 }
721
722 /// This is a wrapper around stripAndAccumulateConstantOffsets with the
723 /// in-bounds requirement set to false.
725 APInt &Offset) const {
727 /* AllowNonInbounds */ false);
728 }
730 APInt &Offset) {
732 /* AllowNonInbounds */ false);
733 }
734
735 /// Strip off pointer casts and inbounds GEPs.
736 ///
737 /// Returns the original pointer value. If this is called on a non-pointer
738 /// value, it returns 'this'.
739 const Value *stripInBoundsOffsets(function_ref<void(const Value *)> Func =
740 [](const Value *) {}) const;
741 inline Value *stripInBoundsOffsets(function_ref<void(const Value *)> Func =
742 [](const Value *) {}) {
743 return const_cast<Value *>(
744 static_cast<const Value *>(this)->stripInBoundsOffsets(Func));
745 }
746
747 /// If this ptr is provably equal to \p Other plus a constant offset, return
748 /// that offset in bytes. Essentially `ptr this` subtract `ptr Other`.
749 std::optional<int64_t> getPointerOffsetFrom(const Value *Other,
750 const DataLayout &DL) const;
751
752 /// Return true if the memory object referred to by V can by freed in the
753 /// scope for which the SSA value defining the allocation is statically
754 /// defined. E.g. deallocation after the static scope of a value does not
755 /// count, but a deallocation before that does.
756 bool canBeFreed() const;
757
758 /// Returns the number of bytes known to be dereferenceable for the
759 /// pointer value.
760 ///
761 /// If CanBeNull is set by this function the pointer can either be null or be
762 /// dereferenceable up to the returned number of bytes.
763 ///
764 /// IF CanBeFreed is true, the pointer is known to be dereferenceable at
765 /// point of definition only. Caller must prove that allocation is not
766 /// deallocated between point of definition and use.
768 bool &CanBeNull,
769 bool &CanBeFreed) const;
770
771 /// Returns an alignment of the pointer value.
772 ///
773 /// Returns an alignment which is either specified explicitly, e.g. via
774 /// align attribute of a function argument, or guaranteed by DataLayout.
775 Align getPointerAlignment(const DataLayout &DL) const;
776
777 /// Translate PHI node to its predecessor from the given basic block.
778 ///
779 /// If this value is a PHI node with CurBB as its parent, return the value in
780 /// the PHI node corresponding to PredBB. If not, return ourself. This is
781 /// useful if you want to know the value something has in a predecessor
782 /// block.
783 const Value *DoPHITranslation(const BasicBlock *CurBB,
784 const BasicBlock *PredBB) const;
785 Value *DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB) {
786 return const_cast<Value *>(
787 static_cast<const Value *>(this)->DoPHITranslation(CurBB, PredBB));
788 }
789
790 /// The maximum alignment for instructions.
791 ///
792 /// This is the greatest alignment value supported by load, store, and alloca
793 /// instructions, and global values.
794 static constexpr unsigned MaxAlignmentExponent = 32;
796
797 /// Mutate the type of this Value to be of the specified type.
798 ///
799 /// Note that this is an extremely dangerous operation which can create
800 /// completely invalid IR very easily. It is strongly recommended that you
801 /// recreate IR objects with the right types instead of mutating them in
802 /// place.
803 void mutateType(Type *Ty) {
804 VTy = Ty;
805 }
806
807 /// Sort the use-list.
808 ///
809 /// Sorts the Value's use-list by Cmp using a stable mergesort. Cmp is
810 /// expected to compare two \a Use references.
811 template <class Compare> void sortUseList(Compare Cmp);
812
813 /// Reverse the use-list.
814 void reverseUseList();
815
816private:
817 /// Merge two lists together.
818 ///
819 /// Merges \c L and \c R using \c Cmp. To enable stable sorts, always pushes
820 /// "equal" items from L before items from R.
821 ///
822 /// \return the first element in the list.
823 ///
824 /// \note Completely ignores \a Use::Prev (doesn't read, doesn't update).
825 template <class Compare>
826 static Use *mergeUseLists(Use *L, Use *R, Compare Cmp) {
827 Use *Merged;
828 Use **Next = &Merged;
829
830 while (true) {
831 if (!L) {
832 *Next = R;
833 break;
834 }
835 if (!R) {
836 *Next = L;
837 break;
838 }
839 if (Cmp(*R, *L)) {
840 *Next = R;
841 Next = &R->Next;
842 R = R->Next;
843 } else {
844 *Next = L;
845 Next = &L->Next;
846 L = L->Next;
847 }
848 }
849
850 return Merged;
851 }
852
853protected:
854 unsigned short getSubclassDataFromValue() const { return SubclassData; }
855 void setValueSubclassData(unsigned short D) { SubclassData = D; }
856};
857
858struct ValueDeleter { void operator()(Value *V) { V->deleteValue(); } };
859
860/// Use this instead of std::unique_ptr<Value> or std::unique_ptr<Instruction>.
861/// Those don't work because Value and Instruction's destructors are protected,
862/// aren't virtual, and won't destroy the complete object.
863using unique_value = std::unique_ptr<Value, ValueDeleter>;
864
866 V.print(OS);
867 return OS;
868}
869
870void Use::set(Value *V) {
871 if (Val) removeFromList();
872 Val = V;
873 if (V) V->addUse(*this);
874}
875
877 set(RHS);
878 return RHS;
879}
880
881const Use &Use::operator=(const Use &RHS) {
882 set(RHS.Val);
883 return *this;
884}
885
886template <class Compare> void Value::sortUseList(Compare Cmp) {
887 if (!UseList || !UseList->Next)
888 // No need to sort 0 or 1 uses.
889 return;
890
891 // Note: this function completely ignores Prev pointers until the end when
892 // they're fixed en masse.
893
894 // Create a binomial vector of sorted lists, visiting uses one at a time and
895 // merging lists as necessary.
896 const unsigned MaxSlots = 32;
897 Use *Slots[MaxSlots];
898
899 // Collect the first use, turning it into a single-item list.
900 Use *Next = UseList->Next;
901 UseList->Next = nullptr;
902 unsigned NumSlots = 1;
903 Slots[0] = UseList;
904
905 // Collect all but the last use.
906 while (Next->Next) {
907 Use *Current = Next;
908 Next = Current->Next;
909
910 // Turn Current into a single-item list.
911 Current->Next = nullptr;
912
913 // Save Current in the first available slot, merging on collisions.
914 unsigned I;
915 for (I = 0; I < NumSlots; ++I) {
916 if (!Slots[I])
917 break;
918
919 // Merge two lists, doubling the size of Current and emptying slot I.
920 //
921 // Since the uses in Slots[I] originally preceded those in Current, send
922 // Slots[I] in as the left parameter to maintain a stable sort.
923 Current = mergeUseLists(Slots[I], Current, Cmp);
924 Slots[I] = nullptr;
925 }
926 // Check if this is a new slot.
927 if (I == NumSlots) {
928 ++NumSlots;
929 assert(NumSlots <= MaxSlots && "Use list bigger than 2^32");
930 }
931
932 // Found an open slot.
933 Slots[I] = Current;
934 }
935
936 // Merge all the lists together.
937 assert(Next && "Expected one more Use");
938 assert(!Next->Next && "Expected only one Use");
939 UseList = Next;
940 for (unsigned I = 0; I < NumSlots; ++I)
941 if (Slots[I])
942 // Since the uses in Slots[I] originally preceded those in UseList, send
943 // Slots[I] in as the left parameter to maintain a stable sort.
944 UseList = mergeUseLists(Slots[I], UseList, Cmp);
945
946 // Fix the Prev pointers.
947 for (Use *I = UseList, **Prev = &UseList; I; I = I->Next) {
948 I->Prev = Prev;
949 Prev = &I->Next;
950 }
951}
952
953// isa - Provide some specializations of isa so that we don't have to include
954// the subtype header files to test to see if the value is a subclass...
955//
956template <> struct isa_impl<Constant, Value> {
957 static inline bool doit(const Value &Val) {
958 static_assert(Value::ConstantFirstVal == 0, "Val.getValueID() >= Value::ConstantFirstVal");
959 return Val.getValueID() <= Value::ConstantLastVal;
960 }
961};
962
963template <> struct isa_impl<ConstantData, Value> {
964 static inline bool doit(const Value &Val) {
965 return Val.getValueID() >= Value::ConstantDataFirstVal &&
966 Val.getValueID() <= Value::ConstantDataLastVal;
967 }
968};
969
970template <> struct isa_impl<ConstantAggregate, Value> {
971 static inline bool doit(const Value &Val) {
972 return Val.getValueID() >= Value::ConstantAggregateFirstVal &&
973 Val.getValueID() <= Value::ConstantAggregateLastVal;
974 }
975};
976
977template <> struct isa_impl<Argument, Value> {
978 static inline bool doit (const Value &Val) {
979 return Val.getValueID() == Value::ArgumentVal;
980 }
981};
982
983template <> struct isa_impl<InlineAsm, Value> {
984 static inline bool doit(const Value &Val) {
985 return Val.getValueID() == Value::InlineAsmVal;
986 }
987};
988
989template <> struct isa_impl<Instruction, Value> {
990 static inline bool doit(const Value &Val) {
991 return Val.getValueID() >= Value::InstructionVal;
992 }
993};
994
995template <> struct isa_impl<BasicBlock, Value> {
996 static inline bool doit(const Value &Val) {
997 return Val.getValueID() == Value::BasicBlockVal;
998 }
999};
1000
1001template <> struct isa_impl<Function, Value> {
1002 static inline bool doit(const Value &Val) {
1003 return Val.getValueID() == Value::FunctionVal;
1004 }
1005};
1006
1007template <> struct isa_impl<GlobalVariable, Value> {
1008 static inline bool doit(const Value &Val) {
1009 return Val.getValueID() == Value::GlobalVariableVal;
1010 }
1011};
1012
1013template <> struct isa_impl<GlobalAlias, Value> {
1014 static inline bool doit(const Value &Val) {
1015 return Val.getValueID() == Value::GlobalAliasVal;
1016 }
1017};
1018
1019template <> struct isa_impl<GlobalIFunc, Value> {
1020 static inline bool doit(const Value &Val) {
1021 return Val.getValueID() == Value::GlobalIFuncVal;
1022 }
1023};
1024
1025template <> struct isa_impl<GlobalValue, Value> {
1026 static inline bool doit(const Value &Val) {
1027 return isa<GlobalObject>(Val) || isa<GlobalAlias>(Val);
1028 }
1029};
1030
1031template <> struct isa_impl<GlobalObject, Value> {
1032 static inline bool doit(const Value &Val) {
1033 return isa<GlobalVariable>(Val) || isa<Function>(Val) ||
1034 isa<GlobalIFunc>(Val);
1035 }
1036};
1037
1038// Create wrappers for C Binding types (see CBindingWrapping.h).
1040
1041// Specialized opaque value conversions.
1043 return reinterpret_cast<Value**>(Vals);
1044}
1045
1046template<typename T>
1047inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
1048#ifndef NDEBUG
1049 for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
1050 unwrap<T>(*I); // For side effect of calling assert on invalid usage.
1051#endif
1052 (void)Length;
1053 return reinterpret_cast<T**>(Vals);
1054}
1055
1056inline LLVMValueRef *wrap(const Value **Vals) {
1057 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
1058}
1059
1060} // end namespace llvm
1061
1062#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:56
Base class for aggregate constants (with operands).
Definition: Constants.h:384
Base class for constants with no operands.
Definition: Constants.h:50
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:950
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:577
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:870
Value * operator=(Value *RHS)
Definition: Value.h:876
Value wrapper in the Metadata hierarchy.
Definition: Metadata.h:344
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:741
unsigned short getSubclassDataFromValue() const
Definition: Value.h:854
const_use_iterator materialized_use_begin() const
Definition: Value.h:357
static constexpr uint64_t MaximumAlignment
Definition: Value.h:795
Value * stripPointerCasts()
Definition: Value.h:632
unsigned IsUsedByMD
Definition: Value.h:117
bool hasMetadata(StringRef Kind) const
Definition: Value.h:592
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:724
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:1061
unsigned HasName
Definition: Value.h:118
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:4694
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:585
unsigned char SubclassOptionalData
Hold subclass data that can be dropped.
Definition: Value.h:90
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:1071
const User * getUniqueUndroppableUser() const
Definition: Value.h:464
void assertModuleIsMaterializedImpl() const
Definition: Value.cpp:457
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:692
void assertModuleIsMaterialized() const
Definition: Value.h:338
void setMetadata(unsigned KindID, MDNode *Node)
Set a particular kind of metadata attachment.
Definition: Metadata.cpp:1391
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:378
const Value * stripInBoundsConstantOffsets() const
Strip off pointer casts and all-constant inbounds GEPs.
Definition: Value.cpp:700
std::string getNameOrAsOperand() const
Definition: Value.cpp:446
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:535
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * > > &MDs) const
Appends all metadata attached to this value to MDs, sorting by KindID.
Definition: Metadata.cpp:1380
const Value * stripInBoundsOffsets(function_ref< void(const Value *)> Func=[](const Value *) {}) const
Strip off pointer casts and inbounds GEPs.
Definition: Value.cpp:780
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:886
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:921
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:642
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:729
const User * user_back() const
Definition: Value.h:411
bool materialized_use_empty() const
Definition: Value.h:349
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
Definition: Metadata.cpp:1354
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:4777
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:784
bool hasNUses(unsigned N) const
Return true if this Value has exactly N uses.
Definition: Value.cpp:149
@ NumUserOperandsBits
Definition: Value.h:113
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:543
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:688
bool isSwiftError() const
Return true if this value is a swifterror value.
Definition: Value.cpp:1090
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:696
bool use_empty() const
Definition: Value.h:344
bool eraseMetadata(unsigned KindID)
Erase all metadata attachments with the given kind.
Definition: Metadata.cpp:1436
unsigned HasMetadata
Definition: Value.h:119
Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, bool AllowInvariantGroup=false)
Definition: Value.h:714
void addMetadata(unsigned KindID, MDNode &MD)
Add a metadata attachment.
Definition: Metadata.cpp:1425
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:587
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:855
Value * DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB)
Definition: Value.h:785
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:1069
static constexpr unsigned MaxAlignmentExponent
The maximum alignment for instructions.
Definition: Value.h:794
bool hasValueHandle() const
Return true if there is a value handle associated with this value.
Definition: Value.h:554
unsigned NumUserOperands
Definition: Value.h:114
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:120
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:803
const_use_iterator use_end() const
Definition: Value.h:369
Value * stripPointerCastsForAliasAnalysis()
Definition: Value.h:665
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:1022
bool hasMetadata(unsigned KindID) const
Return true if this value has the given type of metadata attached.
Definition: Value.h:589
Value * stripInBoundsConstantOffsets()
Definition: Value.h:675
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:846
void clearMetadata()
Erase all metadata attached to this Value.
Definition: Metadata.cpp:1448
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:539
Value * stripPointerCastsSameRepresentation()
Definition: Value.h:653
unsigned HasDescriptor
Definition: Value.h:121
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:384
const_user_iterator user_end() const
Definition: Value.h:406
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:704
void dump() const
Support for debugging, callable in GDB: V->dump()
Definition: AsmWriter.cpp:4937
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:440
@ Length
Definition: DWP.cpp:440
std::unique_ptr< Value, ValueDeleter > unique_value
Use this instead of std::unique_ptr<Value> or std::unique_ptr<Instruction>.
Definition: Value.h:863
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:323
@ Other
Any other memory.
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:287
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:292
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:282
#define N
void operator()(Value *V)
Definition: Value.h:858
static bool doit(const Value &Val)
Definition: Value.h:978
static bool doit(const Value &Val)
Definition: Value.h:996
static bool doit(const Value &Val)
Definition: Value.h:971
static bool doit(const Value &Val)
Definition: Value.h:964
static bool doit(const Value &Val)
Definition: Value.h:957
static bool doit(const Value &Val)
Definition: Value.h:1002
static bool doit(const Value &Val)
Definition: Value.h:1014
static bool doit(const Value &Val)
Definition: Value.h:1020
static bool doit(const Value &Val)
Definition: Value.h:1032
static bool doit(const Value &Val)
Definition: Value.h:1026
static bool doit(const Value &Val)
Definition: Value.h:1008
static bool doit(const Value &Val)
Definition: Value.h:984
static bool doit(const Value &Val)
Definition: Value.h:990