LLVM 19.0.0git
Instruction.h
Go to the documentation of this file.
1//===-- llvm/Instruction.h - Instruction class definition -------*- 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 contains the declaration of the Instruction class, which is the
10// base class for all of the LLVM instructions.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_IR_INSTRUCTION_H
15#define LLVM_IR_INSTRUCTION_H
16
17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/Bitfields.h"
19#include "llvm/ADT/StringRef.h"
20#include "llvm/ADT/ilist_node.h"
21#include "llvm/IR/DebugLoc.h"
23#include "llvm/IR/User.h"
24#include "llvm/IR/Value.h"
26#include <cstdint>
27#include <utility>
28
29namespace llvm {
30
31class BasicBlock;
32class DPMarker;
33class FastMathFlags;
34class MDNode;
35class Module;
36struct AAMDNodes;
37class DPMarker;
38class DbgRecord;
39
40template <> struct ilist_alloc_traits<Instruction> {
41 static inline void deleteNode(Instruction *V);
42};
43
45
46class Instruction : public User,
47 public ilist_node_with_parent<Instruction, BasicBlock,
48 ilist_iterator_bits<true>> {
49public:
51private:
52 BasicBlock *Parent;
53 DebugLoc DbgLoc; // 'dbg' Metadata cache.
54
55 /// Relative order of this instruction in its parent basic block. Used for
56 /// O(1) local dominance checks between instructions.
57 mutable unsigned Order = 0;
58
59public:
60 /// Optional marker recording the position for debugging information that
61 /// takes effect immediately before this instruction. Null unless there is
62 /// debugging information present.
63 DPMarker *DbgMarker = nullptr;
64
65 /// Clone any debug-info attached to \p From onto this instruction. Used to
66 /// copy debugging information from one block to another, when copying entire
67 /// blocks. \see DebugProgramInstruction.h , because the ordering of DPValues
68 /// is still important, fine grain control of which instructions are moved and
69 /// where they go is necessary.
70 /// \p From The instruction to clone debug-info from.
71 /// \p from_here Optional iterator to limit DPValues cloned to be a range from
72 /// from_here to end().
73 /// \p InsertAtHead Whether the cloned DPValues should be placed at the end
74 /// or the beginning of existing DPValues attached to this.
75 /// \returns A range over the newly cloned DPValues.
77 const Instruction *From,
78 std::optional<simple_ilist<DbgRecord>::iterator> FromHere = std::nullopt,
79 bool InsertAtHead = false);
80
81 /// Return a range over the DPValues attached to this instruction.
84 }
85
86 /// Return an iterator to the position of the "Next" DPValue after this
87 /// instruction, or std::nullopt. This is the position to pass to
88 /// BasicBlock::reinsertInstInDPValues when re-inserting an instruction.
89 std::optional<simple_ilist<DbgRecord>::iterator> getDbgReinsertionPosition();
90
91 /// Returns true if any DPValues are attached to this instruction.
92 bool hasDbgValues() const;
93
94 /// Transfer any DPValues on the position \p It onto this instruction,
95 /// by simply adopting the sequence of DPValues (which is efficient) if
96 /// possible, by merging two sequences otherwise.
98 bool InsertAtHead);
99
100 /// Erase any DPValues attached to this instruction.
101 void dropDbgValues();
102
103 /// Erase a single DPValue \p I that is attached to this instruction.
105
106 /// Handle the debug-info implications of this instruction being removed. Any
107 /// attached DPValues need to "fall" down onto the next instruction.
108 void handleMarkerRemoval();
109
110protected:
111 // The 15 first bits of `Value::SubclassData` are available for subclasses of
112 // `Instruction` to use.
114
115 // Template alias so that all Instruction storing alignment use the same
116 // definiton.
117 // Valid alignments are powers of two from 2^0 to 2^MaxAlignmentExponent =
118 // 2^32. We store them as Log2(Alignment), so we need 6 bits to encode the 33
119 // possible values.
120 template <unsigned Offset>
122 typename Bitfield::Element<unsigned, Offset, 6,
124
125 template <unsigned Offset>
127
128 template <unsigned Offset>
132
133private:
134 // The last bit is used to store whether the instruction has metadata attached
135 // or not.
137
138protected:
139 ~Instruction(); // Use deleteValue() to delete a generic Instruction.
140
141public:
142 Instruction(const Instruction &) = delete;
144
145 /// Specialize the methods defined in Value, as we know that an instruction
146 /// can only be used by other instructions.
147 Instruction *user_back() { return cast<Instruction>(*user_begin());}
148 const Instruction *user_back() const { return cast<Instruction>(*user_begin());}
149
150 inline const BasicBlock *getParent() const { return Parent; }
151 inline BasicBlock *getParent() { return Parent; }
152
153 /// Return the module owning the function this instruction belongs to
154 /// or nullptr it the function does not have a module.
155 ///
156 /// Note: this is undefined behavior if the instruction does not have a
157 /// parent, or the parent basic block does not have a parent function.
158 const Module *getModule() const;
160 return const_cast<Module *>(
161 static_cast<const Instruction *>(this)->getModule());
162 }
163
164 /// Return the function this instruction belongs to.
165 ///
166 /// Note: it is undefined behavior to call this on an instruction not
167 /// currently inserted into a function.
168 const Function *getFunction() const;
170 return const_cast<Function *>(
171 static_cast<const Instruction *>(this)->getFunction());
172 }
173
174 /// This method unlinks 'this' from the containing basic block, but does not
175 /// delete it.
176 void removeFromParent();
177
178 /// This method unlinks 'this' from the containing basic block and deletes it.
179 ///
180 /// \returns an iterator pointing to the element after the erased one
182
183 /// Insert an unlinked instruction into a basic block immediately before
184 /// the specified instruction.
185 void insertBefore(Instruction *InsertPos);
186 void insertBefore(InstListType::iterator InsertPos);
187
188 /// Insert an unlinked instruction into a basic block immediately after the
189 /// specified instruction.
190 void insertAfter(Instruction *InsertPos);
191
192 /// Inserts an unlinked instruction into \p ParentBB at position \p It and
193 /// returns the iterator of the inserted instruction.
196
198
199 /// Unlink this instruction from its current basic block and insert it into
200 /// the basic block that MovePos lives in, right before MovePos.
201 void moveBefore(Instruction *MovePos);
202
203 /// Perform a \ref moveBefore operation, while signalling that the caller
204 /// intends to preserve the original ordering of instructions. This implicitly
205 /// means that any adjacent debug-info should move with this instruction.
206 /// This method is currently a no-op placeholder, but it will become meaningful
207 /// when the "RemoveDIs" project is enabled.
208 void moveBeforePreserving(Instruction *MovePos);
209
210private:
211 /// RemoveDIs project: all other moves implemented with this method,
212 /// centralising debug-info updates into one place.
213 void moveBeforeImpl(BasicBlock &BB, InstListType::iterator I, bool Preserve);
214
215public:
216 /// Unlink this instruction and insert into BB before I.
217 ///
218 /// \pre I is a valid iterator into BB.
220
221 /// (See other overload for moveBeforePreserving).
223
224 /// Unlink this instruction from its current basic block and insert it into
225 /// the basic block that MovePos lives in, right after MovePos.
226 void moveAfter(Instruction *MovePos);
227
228 /// See \ref moveBeforePreserving .
229 void moveAfterPreserving(Instruction *MovePos);
230
231 /// Given an instruction Other in the same basic block as this instruction,
232 /// return true if this instruction comes before Other. In this worst case,
233 /// this takes linear time in the number of instructions in the block. The
234 /// results are cached, so in common cases when the block remains unmodified,
235 /// it takes constant time.
236 bool comesBefore(const Instruction *Other) const;
237
238 /// Get the first insertion point at which the result of this instruction
239 /// is defined. This is *not* the directly following instruction in a number
240 /// of cases, e.g. phi nodes or terminators that return values. This function
241 /// may return null if the insertion after the definition is not possible,
242 /// e.g. due to a catchswitch terminator.
243 std::optional<InstListType::iterator> getInsertionPointAfterDef();
244
245 //===--------------------------------------------------------------------===//
246 // Subclass classification.
247 //===--------------------------------------------------------------------===//
248
249 /// Returns a member of one of the enums like Instruction::Add.
250 unsigned getOpcode() const { return getValueID() - InstructionVal; }
251
252 const char *getOpcodeName() const { return getOpcodeName(getOpcode()); }
253 bool isTerminator() const { return isTerminator(getOpcode()); }
254 bool isUnaryOp() const { return isUnaryOp(getOpcode()); }
255 bool isBinaryOp() const { return isBinaryOp(getOpcode()); }
256 bool isIntDivRem() const { return isIntDivRem(getOpcode()); }
257 bool isShift() const { return isShift(getOpcode()); }
258 bool isCast() const { return isCast(getOpcode()); }
259 bool isFuncletPad() const { return isFuncletPad(getOpcode()); }
261
262 /// It checks if this instruction is the only user of at least one of
263 /// its operands.
265
266 static const char *getOpcodeName(unsigned Opcode);
267
268 static inline bool isTerminator(unsigned Opcode) {
269 return Opcode >= TermOpsBegin && Opcode < TermOpsEnd;
270 }
271
272 static inline bool isUnaryOp(unsigned Opcode) {
273 return Opcode >= UnaryOpsBegin && Opcode < UnaryOpsEnd;
274 }
275 static inline bool isBinaryOp(unsigned Opcode) {
276 return Opcode >= BinaryOpsBegin && Opcode < BinaryOpsEnd;
277 }
278
279 static inline bool isIntDivRem(unsigned Opcode) {
280 return Opcode == UDiv || Opcode == SDiv || Opcode == URem || Opcode == SRem;
281 }
282
283 /// Determine if the Opcode is one of the shift instructions.
284 static inline bool isShift(unsigned Opcode) {
285 return Opcode >= Shl && Opcode <= AShr;
286 }
287
288 /// Return true if this is a logical shift left or a logical shift right.
289 inline bool isLogicalShift() const {
290 return getOpcode() == Shl || getOpcode() == LShr;
291 }
292
293 /// Return true if this is an arithmetic shift right.
294 inline bool isArithmeticShift() const {
295 return getOpcode() == AShr;
296 }
297
298 /// Determine if the Opcode is and/or/xor.
299 static inline bool isBitwiseLogicOp(unsigned Opcode) {
300 return Opcode == And || Opcode == Or || Opcode == Xor;
301 }
302
303 /// Return true if this is and/or/xor.
304 inline bool isBitwiseLogicOp() const {
305 return isBitwiseLogicOp(getOpcode());
306 }
307
308 /// Determine if the Opcode is one of the CastInst instructions.
309 static inline bool isCast(unsigned Opcode) {
310 return Opcode >= CastOpsBegin && Opcode < CastOpsEnd;
311 }
312
313 /// Determine if the Opcode is one of the FuncletPadInst instructions.
314 static inline bool isFuncletPad(unsigned Opcode) {
315 return Opcode >= FuncletPadOpsBegin && Opcode < FuncletPadOpsEnd;
316 }
317
318 /// Returns true if the Opcode is a "special" terminator that does more than
319 /// branch to a successor (e.g. have a side effect or return a value).
320 static inline bool isSpecialTerminator(unsigned Opcode) {
321 switch (Opcode) {
322 case Instruction::CatchSwitch:
323 case Instruction::CatchRet:
324 case Instruction::CleanupRet:
325 case Instruction::Invoke:
326 case Instruction::Resume:
327 case Instruction::CallBr:
328 return true;
329 default:
330 return false;
331 }
332 }
333
334 //===--------------------------------------------------------------------===//
335 // Metadata manipulation.
336 //===--------------------------------------------------------------------===//
337
338 /// Return true if this instruction has any metadata attached to it.
339 bool hasMetadata() const { return DbgLoc || Value::hasMetadata(); }
340
341 /// Return true if this instruction has metadata attached to it other than a
342 /// debug location.
344
345 /// Return true if this instruction has the given type of metadata attached.
346 bool hasMetadata(unsigned KindID) const {
347 return getMetadata(KindID) != nullptr;
348 }
349
350 /// Return true if this instruction has the given type of metadata attached.
351 bool hasMetadata(StringRef Kind) const {
352 return getMetadata(Kind) != nullptr;
353 }
354
355 /// Get the metadata of given kind attached to this Instruction.
356 /// If the metadata is not found then return null.
357 MDNode *getMetadata(unsigned KindID) const {
358 // Handle 'dbg' as a special case since it is not stored in the hash table.
359 if (KindID == LLVMContext::MD_dbg)
360 return DbgLoc.getAsMDNode();
361 return Value::getMetadata(KindID);
362 }
363
364 /// Get the metadata of given kind attached to this Instruction.
365 /// If the metadata is not found then return null.
367 if (!hasMetadata()) return nullptr;
368 return getMetadataImpl(Kind);
369 }
370
371 /// Get all metadata attached to this Instruction. The first element of each
372 /// pair returned is the KindID, the second element is the metadata value.
373 /// This list is returned sorted by the KindID.
374 void
375 getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const {
376 if (hasMetadata())
377 getAllMetadataImpl(MDs);
378 }
379
380 /// This does the same thing as getAllMetadata, except that it filters out the
381 /// debug location.
383 SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const {
385 }
386
387 /// Set the metadata of the specified kind to the specified node. This updates
388 /// or replaces metadata if already present, or removes it if Node is null.
389 void setMetadata(unsigned KindID, MDNode *Node);
390 void setMetadata(StringRef Kind, MDNode *Node);
391
392 /// Copy metadata from \p SrcInst to this instruction. \p WL, if not empty,
393 /// specifies the list of meta data that needs to be copied. If \p WL is
394 /// empty, all meta data will be copied.
395 void copyMetadata(const Instruction &SrcInst,
397
398 /// Erase all metadata that matches the predicate.
399 void eraseMetadataIf(function_ref<bool(unsigned, MDNode *)> Pred);
400
401 /// If the instruction has "branch_weights" MD_prof metadata and the MDNode
402 /// has three operands (including name string), swap the order of the
403 /// metadata.
404 void swapProfMetadata();
405
406 /// Drop all unknown metadata except for debug locations.
407 /// @{
408 /// Passes are required to drop metadata they don't understand. This is a
409 /// convenience method for passes to do so.
410 /// dropUBImplyingAttrsAndUnknownMetadata should be used instead of
411 /// this API if the Instruction being modified is a call.
414 return dropUnknownNonDebugMetadata(std::nullopt);
415 }
416 void dropUnknownNonDebugMetadata(unsigned ID1) {
418 }
419 void dropUnknownNonDebugMetadata(unsigned ID1, unsigned ID2) {
420 unsigned IDs[] = {ID1, ID2};
421 return dropUnknownNonDebugMetadata(IDs);
422 }
423 /// @}
424
425 /// Adds an !annotation metadata node with \p Annotation to this instruction.
426 /// If this instruction already has !annotation metadata, append \p Annotation
427 /// to the existing node.
428 void addAnnotationMetadata(StringRef Annotation);
429 /// Adds an !annotation metadata node with an array of \p Annotations
430 /// as a tuple to this instruction. If this instruction already has
431 /// !annotation metadata, append the tuple to
432 /// the existing node.
434 /// Returns the AA metadata for this instruction.
435 AAMDNodes getAAMetadata() const;
436
437 /// Sets the AA metadata on this instruction from the AAMDNodes structure.
438 void setAAMetadata(const AAMDNodes &N);
439
440 /// Sets the nosanitize metadata on this instruction.
442
443 /// Retrieve total raw weight values of a branch.
444 /// Returns true on success with profile total weights filled in.
445 /// Returns false if no metadata was found.
446 bool extractProfTotalWeight(uint64_t &TotalVal) const;
447
448 /// Set the debug location information for this instruction.
449 void setDebugLoc(DebugLoc Loc) { DbgLoc = std::move(Loc); }
450
451 /// Return the debug location for this node as a DebugLoc.
452 const DebugLoc &getDebugLoc() const { return DbgLoc; }
453
454 /// Fetch the debug location for this node, unless this is a debug intrinsic,
455 /// in which case fetch the debug location of the next non-debug node.
456 const DebugLoc &getStableDebugLoc() const;
457
458 /// Set or clear the nuw flag on this instruction, which must be an operator
459 /// which supports this flag. See LangRef.html for the meaning of this flag.
460 void setHasNoUnsignedWrap(bool b = true);
461
462 /// Set or clear the nsw flag on this instruction, which must be an operator
463 /// which supports this flag. See LangRef.html for the meaning of this flag.
464 void setHasNoSignedWrap(bool b = true);
465
466 /// Set or clear the exact flag on this instruction, which must be an operator
467 /// which supports this flag. See LangRef.html for the meaning of this flag.
468 void setIsExact(bool b = true);
469
470 /// Set or clear the nneg flag on this instruction, which must be a zext
471 /// instruction.
472 void setNonNeg(bool b = true);
473
474 /// Determine whether the no unsigned wrap flag is set.
476
477 /// Determine whether the no signed wrap flag is set.
479
480 /// Determine whether the the nneg flag is set.
482
483 /// Return true if this operator has flags which may cause this instruction
484 /// to evaluate to poison despite having non-poison inputs.
486
487 /// Drops flags that may cause this instruction to evaluate to poison despite
488 /// having non-poison inputs.
490
491 /// Return true if this instruction has poison-generating metadata.
493
494 /// Drops metadata that may generate poison.
496
497 /// Return true if this instruction has poison-generating flags or metadata.
500 }
501
502 /// Drops flags and metadata that may generate poison.
506 }
507
508 /// This function drops non-debug unknown metadata (through
509 /// dropUnknownNonDebugMetadata). For calls, it also drops parameter and
510 /// return attributes that can cause undefined behaviour. Both of these should
511 /// be done by passes which move instructions in IR.
513
514 /// Drop any attributes or metadata that can cause immediate undefined
515 /// behavior. Retain other attributes/metadata on a best-effort basis.
516 /// This should be used when speculating instructions.
518
519 /// Determine whether the exact flag is set.
521
522 /// Set or clear all fast-math-flags on this instruction, which must be an
523 /// operator which supports this flag. See LangRef.html for the meaning of
524 /// this flag.
525 void setFast(bool B);
526
527 /// Set or clear the reassociation flag on this instruction, which must be
528 /// an operator which supports this flag. See LangRef.html for the meaning of
529 /// this flag.
530 void setHasAllowReassoc(bool B);
531
532 /// Set or clear the no-nans flag on this instruction, which must be an
533 /// operator which supports this flag. See LangRef.html for the meaning of
534 /// this flag.
535 void setHasNoNaNs(bool B);
536
537 /// Set or clear the no-infs flag on this instruction, which must be an
538 /// operator which supports this flag. See LangRef.html for the meaning of
539 /// this flag.
540 void setHasNoInfs(bool B);
541
542 /// Set or clear the no-signed-zeros flag on this instruction, which must be
543 /// an operator which supports this flag. See LangRef.html for the meaning of
544 /// this flag.
545 void setHasNoSignedZeros(bool B);
546
547 /// Set or clear the allow-reciprocal flag on this instruction, which must be
548 /// an operator which supports this flag. See LangRef.html for the meaning of
549 /// this flag.
550 void setHasAllowReciprocal(bool B);
551
552 /// Set or clear the allow-contract flag on this instruction, which must be
553 /// an operator which supports this flag. See LangRef.html for the meaning of
554 /// this flag.
555 void setHasAllowContract(bool B);
556
557 /// Set or clear the approximate-math-functions flag on this instruction,
558 /// which must be an operator which supports this flag. See LangRef.html for
559 /// the meaning of this flag.
560 void setHasApproxFunc(bool B);
561
562 /// Convenience function for setting multiple fast-math flags on this
563 /// instruction, which must be an operator which supports these flags. See
564 /// LangRef.html for the meaning of these flags.
565 void setFastMathFlags(FastMathFlags FMF);
566
567 /// Convenience function for transferring all fast-math flag values to this
568 /// instruction, which must be an operator which supports these flags. See
569 /// LangRef.html for the meaning of these flags.
570 void copyFastMathFlags(FastMathFlags FMF);
571
572 /// Determine whether all fast-math-flags are set.
574
575 /// Determine whether the allow-reassociation flag is set.
577
578 /// Determine whether the no-NaNs flag is set.
580
581 /// Determine whether the no-infs flag is set.
583
584 /// Determine whether the no-signed-zeros flag is set.
586
587 /// Determine whether the allow-reciprocal flag is set.
589
590 /// Determine whether the allow-contract flag is set.
592
593 /// Determine whether the approximate-math-functions flag is set.
595
596 /// Convenience function for getting all the fast-math flags, which must be an
597 /// operator which supports these flags. See LangRef.html for the meaning of
598 /// these flags.
599 FastMathFlags getFastMathFlags() const LLVM_READONLY;
600
601 /// Copy I's fast-math flags
602 void copyFastMathFlags(const Instruction *I);
603
604 /// Convenience method to copy supported exact, fast-math, and (optionally)
605 /// wrapping flags from V to this instruction.
606 void copyIRFlags(const Value *V, bool IncludeWrapFlags = true);
607
608 /// Logical 'and' of any supported wrapping, exact, and fast-math flags of
609 /// V and this instruction.
610 void andIRFlags(const Value *V);
611
612 /// Merge 2 debug locations and apply it to the Instruction. If the
613 /// instruction is a CallIns, we need to traverse the inline chain to find
614 /// the common scope. This is not efficient for N-way merging as each time
615 /// you merge 2 iterations, you need to rebuild the hashmap to find the
616 /// common scope. However, we still choose this API because:
617 /// 1) Simplicity: it takes 2 locations instead of a list of locations.
618 /// 2) In worst case, it increases the complexity from O(N*I) to
619 /// O(2*N*I), where N is # of Instructions to merge, and I is the
620 /// maximum level of inline stack. So it is still linear.
621 /// 3) Merging of call instructions should be extremely rare in real
622 /// applications, thus the N-way merging should be in code path.
623 /// The DebugLoc attached to this instruction will be overwritten by the
624 /// merged DebugLoc.
625 void applyMergedLocation(DILocation *LocA, DILocation *LocB);
626
627 /// Updates the debug location given that the instruction has been hoisted
628 /// from a block to a predecessor of that block.
629 /// Note: it is undefined behavior to call this on an instruction not
630 /// currently inserted into a function.
632
633 /// Drop the instruction's debug location. This does not guarantee removal
634 /// of the !dbg source location attachment, as it must set a line 0 location
635 /// with scope information attached on call instructions. To guarantee
636 /// removal of the !dbg attachment, use the \ref setDebugLoc() API.
637 /// Note: it is undefined behavior to call this on an instruction not
638 /// currently inserted into a function.
639 void dropLocation();
640
641 /// Merge the DIAssignID metadata from this instruction and those attached to
642 /// instructions in \p SourceInstructions. This process performs a RAUW on
643 /// the MetadataAsValue uses of the merged DIAssignID nodes. Not every
644 /// instruction in \p SourceInstructions needs to have DIAssignID
645 /// metadata. If none of them do then nothing happens. If this instruction
646 /// does not have a DIAssignID attachment but at least one in \p
647 /// SourceInstructions does then the merged one will be attached to
648 /// it. However, instructions without attachments in \p SourceInstructions
649 /// are not modified.
650 void mergeDIAssignID(ArrayRef<const Instruction *> SourceInstructions);
651
652private:
653 // These are all implemented in Metadata.cpp.
654 MDNode *getMetadataImpl(StringRef Kind) const;
655 void
656 getAllMetadataImpl(SmallVectorImpl<std::pair<unsigned, MDNode *>> &) const;
657
658 /// Update the LLVMContext ID-to-Instruction(s) mapping. If \p ID is nullptr
659 /// then clear the mapping for this instruction.
660 void updateDIAssignIDMapping(DIAssignID *ID);
661
662public:
663 //===--------------------------------------------------------------------===//
664 // Predicates and helper methods.
665 //===--------------------------------------------------------------------===//
666
667 /// Return true if the instruction is associative:
668 ///
669 /// Associative operators satisfy: x op (y op z) === (x op y) op z
670 ///
671 /// In LLVM, the Add, Mul, And, Or, and Xor operators are associative.
672 ///
674 static bool isAssociative(unsigned Opcode) {
675 return Opcode == And || Opcode == Or || Opcode == Xor ||
676 Opcode == Add || Opcode == Mul;
677 }
678
679 /// Return true if the instruction is commutative:
680 ///
681 /// Commutative operators satisfy: (x op y) === (y op x)
682 ///
683 /// In LLVM, these are the commutative operators, plus SetEQ and SetNE, when
684 /// applied to any type.
685 ///
687 static bool isCommutative(unsigned Opcode) {
688 switch (Opcode) {
689 case Add: case FAdd:
690 case Mul: case FMul:
691 case And: case Or: case Xor:
692 return true;
693 default:
694 return false;
695 }
696 }
697
698 /// Return true if the instruction is idempotent:
699 ///
700 /// Idempotent operators satisfy: x op x === x
701 ///
702 /// In LLVM, the And and Or operators are idempotent.
703 ///
704 bool isIdempotent() const { return isIdempotent(getOpcode()); }
705 static bool isIdempotent(unsigned Opcode) {
706 return Opcode == And || Opcode == Or;
707 }
708
709 /// Return true if the instruction is nilpotent:
710 ///
711 /// Nilpotent operators satisfy: x op x === Id,
712 ///
713 /// where Id is the identity for the operator, i.e. a constant such that
714 /// x op Id === x and Id op x === x for all x.
715 ///
716 /// In LLVM, the Xor operator is nilpotent.
717 ///
718 bool isNilpotent() const { return isNilpotent(getOpcode()); }
719 static bool isNilpotent(unsigned Opcode) {
720 return Opcode == Xor;
721 }
722
723 /// Return true if this instruction may modify memory.
725
726 /// Return true if this instruction may read memory.
728
729 /// Return true if this instruction may read or write memory.
730 bool mayReadOrWriteMemory() const {
732 }
733
734 /// Return true if this instruction has an AtomicOrdering of unordered or
735 /// higher.
737
738 /// Return true if this atomic instruction loads from memory.
740
741 /// Return true if this atomic instruction stores to memory.
743
744 /// Return true if this instruction has a volatile memory access.
746
747 /// Return the type this instruction accesses in memory, if any.
749
750 /// Return true if this instruction may throw an exception.
751 ///
752 /// If IncludePhaseOneUnwind is set, this will also include cases where
753 /// phase one unwinding may unwind past this frame due to skipping of
754 /// cleanup landingpads.
755 bool mayThrow(bool IncludePhaseOneUnwind = false) const LLVM_READONLY;
756
757 /// Return true if this instruction behaves like a memory fence: it can load
758 /// or store to memory location without being given a memory location.
759 bool isFenceLike() const {
760 switch (getOpcode()) {
761 default:
762 return false;
763 // This list should be kept in sync with the list in mayWriteToMemory for
764 // all opcodes which don't have a memory location.
765 case Instruction::Fence:
766 case Instruction::CatchPad:
767 case Instruction::CatchRet:
768 case Instruction::Call:
769 case Instruction::Invoke:
770 return true;
771 }
772 }
773
774 /// Return true if the instruction may have side effects.
775 ///
776 /// Side effects are:
777 /// * Writing to memory.
778 /// * Unwinding.
779 /// * Not returning (e.g. an infinite loop).
780 ///
781 /// Note that this does not consider malloc and alloca to have side
782 /// effects because the newly allocated memory is completely invisible to
783 /// instructions which don't use the returned value. For cases where this
784 /// matters, isSafeToSpeculativelyExecute may be more appropriate.
786
787 /// Return true if the instruction can be removed if the result is unused.
788 ///
789 /// When constant folding some instructions cannot be removed even if their
790 /// results are unused. Specifically terminator instructions and calls that
791 /// may have side effects cannot be removed without semantically changing the
792 /// generated program.
794
795 /// Return true if the instruction will return (unwinding is considered as
796 /// a form of returning control flow here).
798
799 /// Return true if the instruction is a variety of EH-block.
800 bool isEHPad() const {
801 switch (getOpcode()) {
802 case Instruction::CatchSwitch:
803 case Instruction::CatchPad:
804 case Instruction::CleanupPad:
805 case Instruction::LandingPad:
806 return true;
807 default:
808 return false;
809 }
810 }
811
812 /// Return true if the instruction is a llvm.lifetime.start or
813 /// llvm.lifetime.end marker.
815
816 /// Return true if the instruction is a llvm.launder.invariant.group or
817 /// llvm.strip.invariant.group.
819
820 /// Return true if the instruction is a DbgInfoIntrinsic or PseudoProbeInst.
822
823 /// Return a pointer to the next non-debug instruction in the same basic
824 /// block as 'this', or nullptr if no such instruction exists. Skip any pseudo
825 /// operations if \c SkipPseudoOp is true.
827 getNextNonDebugInstruction(bool SkipPseudoOp = false) const;
829 return const_cast<Instruction *>(
830 static_cast<const Instruction *>(this)->getNextNonDebugInstruction(
831 SkipPseudoOp));
832 }
833
834 /// Return a pointer to the previous non-debug instruction in the same basic
835 /// block as 'this', or nullptr if no such instruction exists. Skip any pseudo
836 /// operations if \c SkipPseudoOp is true.
837 const Instruction *
838 getPrevNonDebugInstruction(bool SkipPseudoOp = false) const;
839 Instruction *getPrevNonDebugInstruction(bool SkipPseudoOp = false) {
840 return const_cast<Instruction *>(
841 static_cast<const Instruction *>(this)->getPrevNonDebugInstruction(
842 SkipPseudoOp));
843 }
844
845 /// Create a copy of 'this' instruction that is identical in all ways except
846 /// the following:
847 /// * The instruction has no parent
848 /// * The instruction has no name
849 ///
850 Instruction *clone() const;
851
852 /// Return true if the specified instruction is exactly identical to the
853 /// current one. This means that all operands match and any extra information
854 /// (e.g. load is volatile) agree.
855 bool isIdenticalTo(const Instruction *I) const LLVM_READONLY;
856
857 /// This is like isIdenticalTo, except that it ignores the
858 /// SubclassOptionalData flags, which may specify conditions under which the
859 /// instruction's result is undefined.
861
862 /// When checking for operation equivalence (using isSameOperationAs) it is
863 /// sometimes useful to ignore certain attributes.
865 /// Check for equivalence ignoring load/store alignment.
867 /// Check for equivalence treating a type and a vector of that type
868 /// as equivalent.
870 };
871
872 /// This function determines if the specified instruction executes the same
873 /// operation as the current one. This means that the opcodes, type, operand
874 /// types and any other factors affecting the operation must be the same. This
875 /// is similar to isIdenticalTo except the operands themselves don't have to
876 /// be identical.
877 /// @returns true if the specified instruction is the same operation as
878 /// the current one.
879 /// Determine if one instruction is the same operation as another.
880 bool isSameOperationAs(const Instruction *I, unsigned flags = 0) const LLVM_READONLY;
881
882 /// This function determines if the speficied instruction has the same
883 /// "special" characteristics as the current one. This means that opcode
884 /// specific details are the same. As a common example, if we are comparing
885 /// loads, then hasSameSpecialState would compare the alignments (among
886 /// other things).
887 /// @returns true if the specific instruction has the same opcde specific
888 /// characteristics as the current one. Determine if one instruction has the
889 /// same state as another.
891 bool IgnoreAlignment = false) const LLVM_READONLY;
892
893 /// Return true if there are any uses of this instruction in blocks other than
894 /// the specified block. Note that PHI nodes are considered to evaluate their
895 /// operands in the corresponding predecessor block.
897
898 /// Return the number of successors that this instruction has. The instruction
899 /// must be a terminator.
901
902 /// Return the specified successor. This instruction must be a terminator.
904
905 /// Update the specified successor to point at the provided block. This
906 /// instruction must be a terminator.
907 void setSuccessor(unsigned Idx, BasicBlock *BB);
908
909 /// Replace specified successor OldBB to point at the provided block.
910 /// This instruction must be a terminator.
911 void replaceSuccessorWith(BasicBlock *OldBB, BasicBlock *NewBB);
912
913 /// Methods for support type inquiry through isa, cast, and dyn_cast:
914 static bool classof(const Value *V) {
915 return V->getValueID() >= Value::InstructionVal;
916 }
917
918 //----------------------------------------------------------------------
919 // Exported enumerations.
920 //
921 enum TermOps { // These terminate basic blocks
922#define FIRST_TERM_INST(N) TermOpsBegin = N,
923#define HANDLE_TERM_INST(N, OPC, CLASS) OPC = N,
924#define LAST_TERM_INST(N) TermOpsEnd = N+1
925#include "llvm/IR/Instruction.def"
926 };
927
928 enum UnaryOps {
929#define FIRST_UNARY_INST(N) UnaryOpsBegin = N,
930#define HANDLE_UNARY_INST(N, OPC, CLASS) OPC = N,
931#define LAST_UNARY_INST(N) UnaryOpsEnd = N+1
932#include "llvm/IR/Instruction.def"
933 };
934
936#define FIRST_BINARY_INST(N) BinaryOpsBegin = N,
937#define HANDLE_BINARY_INST(N, OPC, CLASS) OPC = N,
938#define LAST_BINARY_INST(N) BinaryOpsEnd = N+1
939#include "llvm/IR/Instruction.def"
940 };
941
943#define FIRST_MEMORY_INST(N) MemoryOpsBegin = N,
944#define HANDLE_MEMORY_INST(N, OPC, CLASS) OPC = N,
945#define LAST_MEMORY_INST(N) MemoryOpsEnd = N+1
946#include "llvm/IR/Instruction.def"
947 };
948
949 enum CastOps {
950#define FIRST_CAST_INST(N) CastOpsBegin = N,
951#define HANDLE_CAST_INST(N, OPC, CLASS) OPC = N,
952#define LAST_CAST_INST(N) CastOpsEnd = N+1
953#include "llvm/IR/Instruction.def"
954 };
955
957#define FIRST_FUNCLETPAD_INST(N) FuncletPadOpsBegin = N,
958#define HANDLE_FUNCLETPAD_INST(N, OPC, CLASS) OPC = N,
959#define LAST_FUNCLETPAD_INST(N) FuncletPadOpsEnd = N+1
960#include "llvm/IR/Instruction.def"
961 };
962
963 enum OtherOps {
964#define FIRST_OTHER_INST(N) OtherOpsBegin = N,
965#define HANDLE_OTHER_INST(N, OPC, CLASS) OPC = N,
966#define LAST_OTHER_INST(N) OtherOpsEnd = N+1
967#include "llvm/IR/Instruction.def"
968 };
969
970private:
971 friend class SymbolTableListTraits<Instruction, ilist_iterator_bits<true>>;
972 friend class BasicBlock; // For renumbering.
973
974 // Shadow Value::setValueSubclassData with a private forwarding method so that
975 // subclasses cannot accidentally use it.
976 void setValueSubclassData(unsigned short D) {
978 }
979
980 unsigned short getSubclassDataFromValue() const {
982 }
983
984 void setParent(BasicBlock *P);
985
986protected:
987 // Instruction subclasses can stick up to 15 bits of stuff into the
988 // SubclassData field of instruction with these members.
989
990 template <typename BitfieldElement>
991 typename BitfieldElement::Type getSubclassData() const {
992 static_assert(
993 std::is_same<BitfieldElement, HasMetadataField>::value ||
994 !Bitfield::isOverlapping<BitfieldElement, HasMetadataField>(),
995 "Must not overlap with the metadata bit");
996 return Bitfield::get<BitfieldElement>(getSubclassDataFromValue());
997 }
998
999 template <typename BitfieldElement>
1000 void setSubclassData(typename BitfieldElement::Type Value) {
1001 static_assert(
1002 std::is_same<BitfieldElement, HasMetadataField>::value ||
1003 !Bitfield::isOverlapping<BitfieldElement, HasMetadataField>(),
1004 "Must not overlap with the metadata bit");
1005 auto Storage = getSubclassDataFromValue();
1006 Bitfield::set<BitfieldElement>(Storage, Value);
1007 setValueSubclassData(Storage);
1008 }
1009
1010 Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
1011 InstListType::iterator InsertBefore);
1012 Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
1013 Instruction *InsertBefore = nullptr);
1014 Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
1015 BasicBlock *InsertAtEnd);
1016
1017private:
1018 /// Create a copy of this instruction.
1019 Instruction *cloneImpl() const;
1020};
1021
1023 V->deleteValue();
1024}
1025
1026} // end namespace llvm
1027
1028#endif // LLVM_IR_INSTRUCTION_H
aarch64 promote const
Atomic ordering constants.
basic Basic Alias true
This file implements methods to test, set and extract typed bits from packed unsigned integers.
BlockVerifier::State From
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
#define LLVM_READONLY
Definition: Compiler.h:227
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
#define I(x, y, z)
Definition: MD5.cpp:58
Machine Check Debug Module
#define P(N)
Annotations lets you mark points and ranges inside source code, for tests:
Definition: Annotations.h:53
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
LLVM Basic Block Representation.
Definition: BasicBlock.h:60
Per-instruction record of debug-info.
Base class for non-instruction debug metadata records that have positions within IR.
A debug info location.
Definition: DebugLoc.h:33
MDNode * getAsMDNode() const
Return this as a bar MDNode.
Definition: DebugLoc.h:106
const DebugLoc & getStableDebugLoc() const
Fetch the debug location for this node, unless this is a debug intrinsic, in which case fetch the deb...
BitfieldElement::Type getSubclassData() const
Definition: Instruction.h:991
bool mayThrow(bool IncludePhaseOneUnwind=false) const LLVM_READONLY
Return true if this instruction may throw an exception.
Instruction * clone() const
Create a copy of 'this' instruction that is identical in all ways except the following:
void setHasNoUnsignedWrap(bool b=true)
Set or clear the nuw flag on this instruction, which must be an operator which supports this flag.
bool hasNoNaNs() const LLVM_READONLY
Determine whether the no-NaNs flag is set.
void removeFromParent()
This method unlinks 'this' from the containing basic block, but does not delete it.
Definition: Instruction.cpp:89
bool hasNoUnsignedWrap() const LLVM_READONLY
Determine whether the no unsigned wrap flag is set.
bool hasDbgValues() const
Returns true if any DPValues are attached to this instruction.
bool hasNoInfs() const LLVM_READONLY
Determine whether the no-infs flag is set.
bool isLifetimeStartOrEnd() const LLVM_READONLY
Return true if the instruction is a llvm.lifetime.start or llvm.lifetime.end marker.
bool hasMetadata(unsigned KindID) const
Return true if this instruction has the given type of metadata attached.
Definition: Instruction.h:346
static bool isBinaryOp(unsigned Opcode)
Definition: Instruction.h:275
bool isArithmeticShift() const
Return true if this is an arithmetic shift right.
Definition: Instruction.h:294
bool hasMetadata(StringRef Kind) const
Return true if this instruction has the given type of metadata attached.
Definition: Instruction.h:351
void copyFastMathFlags(FastMathFlags FMF)
Convenience function for transferring all fast-math flag values to this instruction,...
bool isSameOperationAs(const Instruction *I, unsigned flags=0) const LLVM_READONLY
This function determines if the specified instruction executes the same operation as the current one.
void mergeDIAssignID(ArrayRef< const Instruction * > SourceInstructions)
Merge the DIAssignID metadata from this instruction and those attached to instructions in SourceInstr...
Definition: DebugInfo.cpp:932
bool isCast() const
Definition: Instruction.h:258
void setHasNoSignedZeros(bool B)
Set or clear the no-signed-zeros flag on this instruction, which must be an operator which supports t...
void moveBeforePreserving(Instruction *MovePos)
Perform a moveBefore operation, while signalling that the caller intends to preserve the original ord...
bool hasNoSignedZeros() const LLVM_READONLY
Determine whether the no-signed-zeros flag is set.
iterator_range< simple_ilist< DbgRecord >::iterator > cloneDebugInfoFrom(const Instruction *From, std::optional< simple_ilist< DbgRecord >::iterator > FromHere=std::nullopt, bool InsertAtHead=false)
Clone any debug-info attached to From onto this instruction.
static bool isBitwiseLogicOp(unsigned Opcode)
Determine if the Opcode is and/or/xor.
Definition: Instruction.h:299
bool mayReadOrWriteMemory() const
Return true if this instruction may read or write memory.
Definition: Instruction.h:730
DPMarker * DbgMarker
Optional marker recording the position for debugging information that takes effect immediately before...
Definition: Instruction.h:63
bool isDebugOrPseudoInst() const LLVM_READONLY
Return true if the instruction is a DbgInfoIntrinsic or PseudoProbeInst.
unsigned getNumSuccessors() const LLVM_READONLY
Return the number of successors that this instruction has.
static bool isShift(unsigned Opcode)
Determine if the Opcode is one of the shift instructions.
Definition: Instruction.h:284
bool hasNoSignedWrap() const LLVM_READONLY
Determine whether the no signed wrap flag is set.
Function * getFunction()
Definition: Instruction.h:169
bool mayWriteToMemory() const LLVM_READONLY
Return true if this instruction may modify memory.
static bool isSpecialTerminator(unsigned Opcode)
Returns true if the Opcode is a "special" terminator that does more than branch to a successor (e....
Definition: Instruction.h:320
void copyIRFlags(const Value *V, bool IncludeWrapFlags=true)
Convenience method to copy supported exact, fast-math, and (optionally) wrapping flags from V to this...
void setHasAllowContract(bool B)
Set or clear the allow-contract flag on this instruction, which must be an operator which supports th...
bool hasAtomicStore() const LLVM_READONLY
Return true if this atomic instruction stores to memory.
void setHasNoSignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag.
typename Bitfield::Element< AtomicOrdering, Offset, 3, AtomicOrdering::LAST > AtomicOrderingBitfieldElementT
Definition: Instruction.h:131
bool isOnlyUserOfAnyOperand()
It checks if this instruction is the only user of at least one of its operands.
void dropLocation()
Drop the instruction's debug location.
Definition: DebugInfo.cpp:963
static bool isCast(unsigned Opcode)
Determine if the Opcode is one of the CastInst instructions.
Definition: Instruction.h:309
void insertBefore(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately before the specified instruction.
iterator_range< simple_ilist< DbgRecord >::iterator > getDbgValueRange() const
Return a range over the DPValues attached to this instruction.
Definition: Instruction.h:82
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:452
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:81
void setAAMetadata(const AAMDNodes &N)
Sets the AA metadata on this instruction from the AAMDNodes structure.
Definition: Metadata.cpp:1718
void andIRFlags(const Value *V)
Logical 'and' of any supported wrapping, exact, and fast-math flags of V and this instruction.
void setHasNoNaNs(bool B)
Set or clear the no-nans flag on this instruction, which must be an operator which supports this flag...
bool isAssociative() const LLVM_READONLY
Return true if the instruction is associative:
const Instruction * getPrevNonDebugInstruction(bool SkipPseudoOp=false) const
Return a pointer to the previous non-debug instruction in the same basic block as 'this',...
bool extractProfTotalWeight(uint64_t &TotalVal) const
Retrieve total raw weight values of a branch.
Definition: Metadata.cpp:1742
Instruction & operator=(const Instruction &)=delete
void setHasApproxFunc(bool B)
Set or clear the approximate-math-functions flag on this instruction, which must be an operator which...
void moveAfter(Instruction *MovePos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
bool hasMetadataOtherThanDebugLoc() const
Return true if this instruction has metadata attached to it other than a debug location.
Definition: Instruction.h:343
bool isCommutative() const LLVM_READONLY
Return true if the instruction is commutative:
typename Bitfield::Element< bool, Offset, 1 > BoolBitfieldElementT
Definition: Instruction.h:126
bool hasMetadata() const
Return true if this instruction has any metadata attached to it.
Definition: Instruction.h:339
Module * getModule()
Definition: Instruction.h:159
bool isAtomic() const LLVM_READONLY
Return true if this instruction has an AtomicOrdering of unordered or higher.
void setHasAllowReassoc(bool B)
Set or clear the reassociation flag on this instruction, which must be an operator which supports thi...
bool isBinaryOp() const
Definition: Instruction.h:255
void setFastMathFlags(FastMathFlags FMF)
Convenience function for setting multiple fast-math flags on this instruction, which must be an opera...
bool isEHPad() const
Return true if the instruction is a variety of EH-block.
Definition: Instruction.h:800
const BasicBlock * getParent() const
Definition: Instruction.h:150
InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
bool isFast() const LLVM_READONLY
Determine whether all fast-math-flags are set.
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Instruction.h:914
void replaceSuccessorWith(BasicBlock *OldBB, BasicBlock *NewBB)
Replace specified successor OldBB to point at the provided block.
Instruction * user_back()
Specialize the methods defined in Value, as we know that an instruction can only be used by other ins...
Definition: Instruction.h:147
static bool isIdempotent(unsigned Opcode)
Definition: Instruction.h:705
void addAnnotationMetadata(StringRef Annotation)
Adds an !annotation metadata node with Annotation to this instruction.
Definition: Metadata.cpp:1686
bool isExact() const LLVM_READONLY
Determine whether the exact flag is set.
bool isIdenticalToWhenDefined(const Instruction *I) const LLVM_READONLY
This is like isIdenticalTo, except that it ignores the SubclassOptionalData flags,...
const Function * getFunction() const
Return the function this instruction belongs to.
Definition: Instruction.cpp:85
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:357
void swapProfMetadata()
If the instruction has "branch_weights" MD_prof metadata and the MDNode has three operands (including...
BasicBlock * getSuccessor(unsigned Idx) const LLVM_READONLY
Return the specified successor. This instruction must be a terminator.
bool mayHaveSideEffects() const LLVM_READONLY
Return true if the instruction may have side effects.
bool isFuncletPad() const
Definition: Instruction.h:259
void setNonNeg(bool b=true)
Set or clear the nneg flag on this instruction, which must be a zext instruction.
bool isTerminator() const
Definition: Instruction.h:253
Type * getAccessType() const LLVM_READONLY
Return the type this instruction accesses in memory, if any.
bool hasSameSpecialState(const Instruction *I2, bool IgnoreAlignment=false) const LLVM_READONLY
This function determines if the speficied instruction has the same "special" characteristics as the c...
bool hasAllowReciprocal() const LLVM_READONLY
Determine whether the allow-reciprocal flag is set.
bool comesBefore(const Instruction *Other) const
Given an instruction Other in the same basic block as this instruction, return true if this instructi...
void dropUBImplyingAttrsAndMetadata()
Drop any attributes or metadata that can cause immediate undefined behavior.
typename Bitfield::Element< unsigned, Offset, 6, Value::MaxAlignmentExponent > AlignmentBitfieldElementT
Definition: Instruction.h:123
bool hasNonNeg() const LLVM_READONLY
Determine whether the the nneg flag is set.
void dropUnknownNonDebugMetadata(unsigned ID1, unsigned ID2)
Definition: Instruction.h:419
Instruction * getPrevNonDebugInstruction(bool SkipPseudoOp=false)
Definition: Instruction.h:839
BasicBlock * getParent()
Definition: Instruction.h:151
bool hasPoisonGeneratingFlags() const LLVM_READONLY
Return true if this operator has flags which may cause this instruction to evaluate to poison despite...
bool isNilpotent() const
Return true if the instruction is nilpotent:
Definition: Instruction.h:718
bool mayReadFromMemory() const LLVM_READONLY
Return true if this instruction may read memory.
const Instruction * getNextNonDebugInstruction(bool SkipPseudoOp=false) const
Return a pointer to the next non-debug instruction in the same basic block as 'this',...
bool isUsedOutsideOfBlock(const BasicBlock *BB) const LLVM_READONLY
Return true if there are any uses of this instruction in blocks other than the specified block.
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1633
bool isVolatile() const LLVM_READONLY
Return true if this instruction has a volatile memory access.
void setHasNoInfs(bool B)
Set or clear the no-infs flag on this instruction, which must be an operator which supports this flag...
void setNoSanitizeMetadata()
Sets the nosanitize metadata on this instruction.
Definition: Metadata.cpp:1725
FastMathFlags getFastMathFlags() const LLVM_READONLY
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
const char * getOpcodeName() const
Definition: Instruction.h:252
const Instruction * user_back() const
Definition: Instruction.h:148
void dropPoisonGeneratingFlagsAndMetadata()
Drops flags and metadata that may generate poison.
Definition: Instruction.h:503
bool willReturn() const LLVM_READONLY
Return true if the instruction will return (unwinding is considered as a form of returning control fl...
bool hasApproxFunc() const LLVM_READONLY
Determine whether the approximate-math-functions flag is set.
OperationEquivalenceFlags
When checking for operation equivalence (using isSameOperationAs) it is sometimes useful to ignore ce...
Definition: Instruction.h:864
@ CompareIgnoringAlignment
Check for equivalence ignoring load/store alignment.
Definition: Instruction.h:866
@ CompareUsingScalarTypes
Check for equivalence treating a type and a vector of that type as equivalent.
Definition: Instruction.h:869
MDNode * getMetadata(StringRef Kind) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:366
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * > > &MDs) const
Get all metadata attached to this Instruction.
Definition: Instruction.h:375
bool isLogicalShift() const
Return true if this is a logical shift left or a logical shift right.
Definition: Instruction.h:289
AAMDNodes getAAMetadata() const
Returns the AA metadata for this instruction.
Definition: Metadata.cpp:1704
void getAllMetadataOtherThanDebugLoc(SmallVectorImpl< std::pair< unsigned, MDNode * > > &MDs) const
This does the same thing as getAllMetadata, except that it filters out the debug location.
Definition: Instruction.h:382
static bool isFuncletPad(unsigned Opcode)
Determine if the Opcode is one of the FuncletPadInst instructions.
Definition: Instruction.h:314
void moveAfterPreserving(Instruction *MovePos)
See moveBeforePreserving .
static bool isUnaryOp(unsigned Opcode)
Definition: Instruction.h:272
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:250
bool hasAtomicLoad() const LLVM_READONLY
Return true if this atomic instruction loads from memory.
static bool isNilpotent(unsigned Opcode)
Definition: Instruction.h:719
bool hasPoisonGeneratingFlagsOrMetadata() const
Return true if this instruction has poison-generating flags or metadata.
Definition: Instruction.h:498
void dropUnknownNonDebugMetadata()
Definition: Instruction.h:413
void setIsExact(bool b=true)
Set or clear the exact flag on this instruction, which must be an operator which supports this flag.
void dropOneDbgValue(DbgRecord *I)
Erase a single DPValue I that is attached to this instruction.
void dropPoisonGeneratingMetadata()
Drops metadata that may generate poison.
bool isBitwiseLogicOp() const
Return true if this is and/or/xor.
Definition: Instruction.h:304
bool isShift() const
Definition: Instruction.h:257
static bool isTerminator(unsigned Opcode)
Definition: Instruction.h:268
void setHasAllowReciprocal(bool B)
Set or clear the allow-reciprocal flag on this instruction, which must be an operator which supports ...
bool isFenceLike() const
Return true if this instruction behaves like a memory fence: it can load or store to memory location ...
Definition: Instruction.h:759
void handleMarkerRemoval()
Handle the debug-info implications of this instruction being removed.
Definition: Instruction.cpp:96
std::optional< InstListType::iterator > getInsertionPointAfterDef()
Get the first insertion point at which the result of this instruction is defined.
void dropPoisonGeneratingFlags()
Drops flags that may cause this instruction to evaluate to poison despite having non-poison inputs.
void dropUBImplyingAttrsAndUnknownMetadata(ArrayRef< unsigned > KnownIDs={})
This function drops non-debug unknown metadata (through dropUnknownNonDebugMetadata).
bool isIdenticalTo(const Instruction *I) const LLVM_READONLY
Return true if the specified instruction is exactly identical to the current one.
std::optional< simple_ilist< DbgRecord >::iterator > getDbgReinsertionPosition()
Return an iterator to the position of the "Next" DPValue after this instruction, or std::nullopt.
bool isLaunderOrStripInvariantGroup() const LLVM_READONLY
Return true if the instruction is a llvm.launder.invariant.group or llvm.strip.invariant....
bool hasAllowContract() const LLVM_READONLY
Determine whether the allow-contract flag is set.
void adoptDbgValues(BasicBlock *BB, InstListType::iterator It, bool InsertAtHead)
Transfer any DPValues on the position It onto this instruction, by simply adopting the sequence of DP...
void updateLocationAfterHoist()
Updates the debug location given that the instruction has been hoisted from a block to a predecessor ...
Definition: DebugInfo.cpp:961
bool hasPoisonGeneratingMetadata() const LLVM_READONLY
Return true if this instruction has poison-generating metadata.
bool isUnaryOp() const
Definition: Instruction.h:254
void dropUnknownNonDebugMetadata(unsigned ID1)
Definition: Instruction.h:416
Instruction(const Instruction &)=delete
void applyMergedLocation(DILocation *LocA, DILocation *LocB)
Merge 2 debug locations and apply it to the Instruction.
Definition: DebugInfo.cpp:928
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:449
void setSuccessor(unsigned Idx, BasicBlock *BB)
Update the specified successor to point at the provided block.
static bool isIntDivRem(unsigned Opcode)
Definition: Instruction.h:279
bool isIdempotent() const
Return true if the instruction is idempotent:
Definition: Instruction.h:704
void copyMetadata(const Instruction &SrcInst, ArrayRef< unsigned > WL=ArrayRef< unsigned >())
Copy metadata from SrcInst to this instruction.
void setFast(bool B)
Set or clear all fast-math-flags on this instruction, which must be an operator which supports this f...
bool hasAllowReassoc() const LLVM_READONLY
Determine whether the allow-reassociation flag is set.
void insertAfter(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately after the specified instruction.
friend class BasicBlock
Various leaf nodes.
Definition: Instruction.h:972
void eraseMetadataIf(function_ref< bool(unsigned, MDNode *)> Pred)
Erase all metadata that matches the predicate.
Definition: Metadata.cpp:1580
void dropDbgValues()
Erase any DPValues attached to this instruction.
void moveBefore(Instruction *MovePos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
bool isSafeToRemove() const LLVM_READONLY
Return true if the instruction can be removed if the result is unused.
bool isIntDivRem() const
Definition: Instruction.h:256
void setSubclassData(typename BitfieldElement::Type Value)
Definition: Instruction.h:1000
bool isSpecialTerminator() const
Definition: Instruction.h:260
InstListType::iterator insertInto(BasicBlock *ParentBB, InstListType::iterator It)
Inserts an unlinked instruction into ParentBB at position It and returns the iterator of the inserted...
Metadata node.
Definition: Metadata.h:1067
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
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
LLVM Value Representation.
Definition: Value.h:74
unsigned short getSubclassDataFromValue() const
Definition: Value.h:866
user_iterator user_begin()
Definition: Value.h:397
bool hasMetadata() const
Return true if this value has any metadata attached to it.
Definition: Value.h:589
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * > > &MDs) const
Appends all metadata attached to this value to MDs, sorting by KindID.
Definition: Metadata.cpp:1475
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:532
void setValueSubclassData(unsigned short D)
Definition: Value.h:867
static constexpr unsigned MaxAlignmentExponent
The maximum alignment for instructions.
Definition: Value.h:806
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
Definition: Value.h:565
An efficient, type-erasing, non-owning reference to a callable.
An ilist node that can access its parent list.
Definition: ilist_node.h:284
base_list_type::iterator iterator
Definition: ilist.h:121
A range adaptor for a pair of iterators.
typename ilist_select_iterator_type< OptionsT::has_iterator_bits, OptionsT, false, false >::type iterator
Definition: simple_ilist.h:97
This file defines the ilist_node class template, which is a convenient base class for creating classe...
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
iterator_range< simple_ilist< DbgRecord >::iterator > getDbgValueRange(DPMarker *DbgMarker)
Inline helper to return a range of DPValues attached to a marker.
AtomicOrdering
Atomic ordering for LLVM's memory model.
@ Other
Any other memory.
@ Or
Bitwise or logical OR of integers.
@ Mul
Product of integers.
@ Xor
Bitwise or logical XOR of integers.
@ FMul
Product of floats.
@ And
Bitwise or logical AND of integers.
@ Add
Sum of integers.
@ FAdd
Sum of floats.
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
#define N
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:760
Describes an element of a Bitfield.
Definition: Bitfields.h:223
Use delete by default for iplist and ilist.
Definition: ilist.h:41
static void deleteNode(NodeTy *V)
Definition: ilist.h:42