LLVM 17.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 constanst 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 {
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 /// Return true if the memory object referred to by V can by freed in the
748 /// scope for which the SSA value defining the allocation is statically
749 /// defined. E.g. deallocation after the static scope of a value does not
750 /// count, but a deallocation before that does.
751 bool canBeFreed() const;
752
753 /// Returns the number of bytes known to be dereferenceable for the
754 /// pointer value.
755 ///
756 /// If CanBeNull is set by this function the pointer can either be null or be
757 /// dereferenceable up to the returned number of bytes.
758 ///
759 /// IF CanBeFreed is true, the pointer is known to be dereferenceable at
760 /// point of definition only. Caller must prove that allocation is not
761 /// deallocated between point of definition and use.
763 bool &CanBeNull,
764 bool &CanBeFreed) const;
765
766 /// Returns an alignment of the pointer value.
767 ///
768 /// Returns an alignment which is either specified explicitly, e.g. via
769 /// align attribute of a function argument, or guaranteed by DataLayout.
770 Align getPointerAlignment(const DataLayout &DL) const;
771
772 /// Translate PHI node to its predecessor from the given basic block.
773 ///
774 /// If this value is a PHI node with CurBB as its parent, return the value in
775 /// the PHI node corresponding to PredBB. If not, return ourself. This is
776 /// useful if you want to know the value something has in a predecessor
777 /// block.
778 const Value *DoPHITranslation(const BasicBlock *CurBB,
779 const BasicBlock *PredBB) const;
780 Value *DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB) {
781 return const_cast<Value *>(
782 static_cast<const Value *>(this)->DoPHITranslation(CurBB, PredBB));
783 }
784
785 /// The maximum alignment for instructions.
786 ///
787 /// This is the greatest alignment value supported by load, store, and alloca
788 /// instructions, and global values.
789 static constexpr unsigned MaxAlignmentExponent = 32;
791
792 /// Mutate the type of this Value to be of the specified type.
793 ///
794 /// Note that this is an extremely dangerous operation which can create
795 /// completely invalid IR very easily. It is strongly recommended that you
796 /// recreate IR objects with the right types instead of mutating them in
797 /// place.
798 void mutateType(Type *Ty) {
799 VTy = Ty;
800 }
801
802 /// Sort the use-list.
803 ///
804 /// Sorts the Value's use-list by Cmp using a stable mergesort. Cmp is
805 /// expected to compare two \a Use references.
806 template <class Compare> void sortUseList(Compare Cmp);
807
808 /// Reverse the use-list.
809 void reverseUseList();
810
811private:
812 /// Merge two lists together.
813 ///
814 /// Merges \c L and \c R using \c Cmp. To enable stable sorts, always pushes
815 /// "equal" items from L before items from R.
816 ///
817 /// \return the first element in the list.
818 ///
819 /// \note Completely ignores \a Use::Prev (doesn't read, doesn't update).
820 template <class Compare>
821 static Use *mergeUseLists(Use *L, Use *R, Compare Cmp) {
822 Use *Merged;
823 Use **Next = &Merged;
824
825 while (true) {
826 if (!L) {
827 *Next = R;
828 break;
829 }
830 if (!R) {
831 *Next = L;
832 break;
833 }
834 if (Cmp(*R, *L)) {
835 *Next = R;
836 Next = &R->Next;
837 R = R->Next;
838 } else {
839 *Next = L;
840 Next = &L->Next;
841 L = L->Next;
842 }
843 }
844
845 return Merged;
846 }
847
848protected:
849 unsigned short getSubclassDataFromValue() const { return SubclassData; }
850 void setValueSubclassData(unsigned short D) { SubclassData = D; }
851};
852
853struct ValueDeleter { void operator()(Value *V) { V->deleteValue(); } };
854
855/// Use this instead of std::unique_ptr<Value> or std::unique_ptr<Instruction>.
856/// Those don't work because Value and Instruction's destructors are protected,
857/// aren't virtual, and won't destroy the complete object.
858using unique_value = std::unique_ptr<Value, ValueDeleter>;
859
860inline raw_ostream &operator<<(raw_ostream &OS, const Value &V) {
861 V.print(OS);
862 return OS;
863}
864
865void Use::set(Value *V) {
866 if (Val) removeFromList();
867 Val = V;
868 if (V) V->addUse(*this);
869}
870
872 set(RHS);
873 return RHS;
874}
875
876const Use &Use::operator=(const Use &RHS) {
877 set(RHS.Val);
878 return *this;
879}
880
881template <class Compare> void Value::sortUseList(Compare Cmp) {
882 if (!UseList || !UseList->Next)
883 // No need to sort 0 or 1 uses.
884 return;
885
886 // Note: this function completely ignores Prev pointers until the end when
887 // they're fixed en masse.
888
889 // Create a binomial vector of sorted lists, visiting uses one at a time and
890 // merging lists as necessary.
891 const unsigned MaxSlots = 32;
892 Use *Slots[MaxSlots];
893
894 // Collect the first use, turning it into a single-item list.
895 Use *Next = UseList->Next;
896 UseList->Next = nullptr;
897 unsigned NumSlots = 1;
898 Slots[0] = UseList;
899
900 // Collect all but the last use.
901 while (Next->Next) {
902 Use *Current = Next;
903 Next = Current->Next;
904
905 // Turn Current into a single-item list.
906 Current->Next = nullptr;
907
908 // Save Current in the first available slot, merging on collisions.
909 unsigned I;
910 for (I = 0; I < NumSlots; ++I) {
911 if (!Slots[I])
912 break;
913
914 // Merge two lists, doubling the size of Current and emptying slot I.
915 //
916 // Since the uses in Slots[I] originally preceded those in Current, send
917 // Slots[I] in as the left parameter to maintain a stable sort.
918 Current = mergeUseLists(Slots[I], Current, Cmp);
919 Slots[I] = nullptr;
920 }
921 // Check if this is a new slot.
922 if (I == NumSlots) {
923 ++NumSlots;
924 assert(NumSlots <= MaxSlots && "Use list bigger than 2^32");
925 }
926
927 // Found an open slot.
928 Slots[I] = Current;
929 }
930
931 // Merge all the lists together.
932 assert(Next && "Expected one more Use");
933 assert(!Next->Next && "Expected only one Use");
934 UseList = Next;
935 for (unsigned I = 0; I < NumSlots; ++I)
936 if (Slots[I])
937 // Since the uses in Slots[I] originally preceded those in UseList, send
938 // Slots[I] in as the left parameter to maintain a stable sort.
939 UseList = mergeUseLists(Slots[I], UseList, Cmp);
940
941 // Fix the Prev pointers.
942 for (Use *I = UseList, **Prev = &UseList; I; I = I->Next) {
943 I->Prev = Prev;
944 Prev = &I->Next;
945 }
946}
947
948// isa - Provide some specializations of isa so that we don't have to include
949// the subtype header files to test to see if the value is a subclass...
950//
951template <> struct isa_impl<Constant, Value> {
952 static inline bool doit(const Value &Val) {
953 static_assert(Value::ConstantFirstVal == 0, "Val.getValueID() >= Value::ConstantFirstVal");
954 return Val.getValueID() <= Value::ConstantLastVal;
955 }
956};
957
958template <> struct isa_impl<ConstantData, Value> {
959 static inline bool doit(const Value &Val) {
960 return Val.getValueID() >= Value::ConstantDataFirstVal &&
961 Val.getValueID() <= Value::ConstantDataLastVal;
962 }
963};
964
965template <> struct isa_impl<ConstantAggregate, Value> {
966 static inline bool doit(const Value &Val) {
967 return Val.getValueID() >= Value::ConstantAggregateFirstVal &&
968 Val.getValueID() <= Value::ConstantAggregateLastVal;
969 }
970};
971
972template <> struct isa_impl<Argument, Value> {
973 static inline bool doit (const Value &Val) {
974 return Val.getValueID() == Value::ArgumentVal;
975 }
976};
977
978template <> struct isa_impl<InlineAsm, Value> {
979 static inline bool doit(const Value &Val) {
980 return Val.getValueID() == Value::InlineAsmVal;
981 }
982};
983
984template <> struct isa_impl<Instruction, Value> {
985 static inline bool doit(const Value &Val) {
986 return Val.getValueID() >= Value::InstructionVal;
987 }
988};
989
990template <> struct isa_impl<BasicBlock, Value> {
991 static inline bool doit(const Value &Val) {
992 return Val.getValueID() == Value::BasicBlockVal;
993 }
994};
995
996template <> struct isa_impl<Function, Value> {
997 static inline bool doit(const Value &Val) {
998 return Val.getValueID() == Value::FunctionVal;
999 }
1000};
1001
1002template <> struct isa_impl<GlobalVariable, Value> {
1003 static inline bool doit(const Value &Val) {
1004 return Val.getValueID() == Value::GlobalVariableVal;
1005 }
1006};
1007
1008template <> struct isa_impl<GlobalAlias, Value> {
1009 static inline bool doit(const Value &Val) {
1010 return Val.getValueID() == Value::GlobalAliasVal;
1011 }
1012};
1013
1014template <> struct isa_impl<GlobalIFunc, Value> {
1015 static inline bool doit(const Value &Val) {
1016 return Val.getValueID() == Value::GlobalIFuncVal;
1017 }
1018};
1019
1020template <> struct isa_impl<GlobalValue, Value> {
1021 static inline bool doit(const Value &Val) {
1022 return isa<GlobalObject>(Val) || isa<GlobalAlias>(Val);
1023 }
1024};
1025
1026template <> struct isa_impl<GlobalObject, Value> {
1027 static inline bool doit(const Value &Val) {
1028 return isa<GlobalVariable>(Val) || isa<Function>(Val) ||
1029 isa<GlobalIFunc>(Val);
1030 }
1031};
1032
1033// Create wrappers for C Binding types (see CBindingWrapping.h).
1035
1036// Specialized opaque value conversions.
1038 return reinterpret_cast<Value**>(Vals);
1039}
1040
1041template<typename T>
1042inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
1043#ifndef NDEBUG
1044 for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
1045 unwrap<T>(*I); // For side effect of calling assert on invalid usage.
1046#endif
1047 (void)Length;
1048 return reinterpret_cast<T**>(Vals);
1049}
1050
1051inline LLVMValueRef *wrap(const Value **Vals) {
1052 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
1053}
1054
1055} // end namespace llvm
1056
1057#endif // LLVM_IR_VALUE_H
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Replace within non kernel function use of LDS with pointer
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:390
uint64_t Align
std::string Name
#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.
bool operator==(const StringView &LHS, const StringView &RHS)
Definition: StringView.h:115
This defines the Use class.
Value * RHS
Class for arbitrary precision integers.
Definition: APInt.h:75
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:385
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:114
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
Metadata node.
Definition: Metadata.h:943
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:865
Value * operator=(Value *RHS)
Definition: Value.h:871
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:849
const_use_iterator materialized_use_begin() const
Definition: Value.h:357
static constexpr uint64_t MaximumAlignment
Definition: Value.h:790
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:986
unsigned HasName
Definition: Value.h:118
Value(Type *Ty, unsigned scid)
Definition: Value.cpp:52
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:4695
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:996
const User * getUniqueUndroppableUser() const
Definition: Value.h:464
void assertModuleIsMaterializedImpl() const
Definition: Value.cpp:454
bool hasNUndroppableUsesOrMore(unsigned N) const
Return true if this value has N uses or more.
Definition: Value.cpp:194
bool hasOneUser() const
Return true if there is exactly one user of this value.
Definition: Value.cpp:156
const Value * stripPointerCastsAndAliases() const
Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
Definition: Value.cpp:689
void assertModuleIsMaterialized() const
Definition: Value.h:338
void setMetadata(unsigned KindID, MDNode *Node)
Set a particular kind of metadata attachment.
Definition: Metadata.cpp:1325
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:375
const Value * stripInBoundsConstantOffsets() const
Strip off pointer casts and all-constant inbounds GEPs.
Definition: Value.cpp:697
std::string getNameOrAsOperand() const
Definition: Value.cpp:443
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:75
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:532
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * > > &MDs) const
Appends all metadata attached to this value to MDs, sorting by KindID.
Definition: Metadata.cpp:1314
const Value * stripInBoundsOffsets(function_ref< void(const Value *)> Func=[](const Value *) {}) const
Strip off pointer casts and inbounds GEPs.
Definition: Value.cpp:777
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:216
void sortUseList(Compare Cmp)
Sort the use-list.
Definition: Value.h:881
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:918
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:233
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:1288
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:4778
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:152
void dropDroppableUsesIn(User &Usr)
Remove every use of this value in User that can safely be removed.
Definition: Value.cpp:208
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:166
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:781
bool hasNUses(unsigned N) const
Return true if this Value has exactly N uses.
Definition: Value.cpp:148
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:540
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:291
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:178
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Definition: Value.cpp:685
bool isSwiftError() const
Return true if this value is a swifterror value.
Definition: Value.cpp:1015
void deleteValue()
Delete a pointer to a generic Value.
Definition: Value.cpp:109
ValueName * getValueName() const
Definition: Value.cpp:280
const Value * stripPointerCastsSameRepresentation() const
Strip off pointer casts, all-zero GEPs and address space casts but ensures the representation of the ...
Definition: Value.cpp:693
bool use_empty() const
Definition: Value.h:344
bool eraseMetadata(unsigned KindID)
Erase all metadata attachments with the given kind.
Definition: Metadata.cpp:1370
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:1359
void dropDroppableUses(llvm::function_ref< bool(const Use *)> ShouldDrop=[](const Use *) { return true;})
Remove every uses that can safely be removed.
Definition: Value.cpp:198
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:584
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:850
Value * DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB)
Definition: Value.h:780
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:994
@ NumUserOperandsBits
Definition: Value.h:113
static constexpr unsigned MaxAlignmentExponent
The maximum alignment for instructions.
Definition: Value.h:789
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:254
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:798
const_use_iterator use_end() const
Definition: Value.h:369
Value * stripPointerCastsForAliasAnalysis()
Definition: Value.h:665
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:843
void clearMetadata()
Erase all metadata attached to this Value.
Definition: Metadata.cpp:1382
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:308
void replaceNonMetadataUsesWith(Value *V)
Change non-metadata uses of this to point to a new Value.
Definition: Value.cpp:536
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:381
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:190
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:701
void dump() const
Support for debugging, callable in GDB: V->dump()
Definition: AsmWriter.cpp:4938
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
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:406
@ Length
Definition: DWP.cpp:406
std::unique_ptr< Value, ValueDeleter > unique_value
Use this instead of std::unique_ptr<Value> or std::unique_ptr<Instruction>.
Definition: Value.h:858
APInt operator*(APInt a, uint64_t RHS)
Definition: APInt.h:2162
bool operator!=(uint64_t V1, const APInt &V2)
Definition: APInt.h:2040
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:379
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:285
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:292
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:280
#define N
void operator()(Value *V)
Definition: Value.h:853
static bool doit(const Value &Val)
Definition: Value.h:973
static bool doit(const Value &Val)
Definition: Value.h:991
static bool doit(const Value &Val)
Definition: Value.h:966
static bool doit(const Value &Val)
Definition: Value.h:959
static bool doit(const Value &Val)
Definition: Value.h:952
static bool doit(const Value &Val)
Definition: Value.h:997
static bool doit(const Value &Val)
Definition: Value.h:1009
static bool doit(const Value &Val)
Definition: Value.h:1015
static bool doit(const Value &Val)
Definition: Value.h:1027
static bool doit(const Value &Val)
Definition: Value.h:1021
static bool doit(const Value &Val)
Definition: Value.h:1003
static bool doit(const Value &Val)
Definition: Value.h:979
static bool doit(const Value &Val)
Definition: Value.h:985