LLVM  13.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/None.h"
20 #include "llvm/ADT/StringRef.h"
21 #include "llvm/ADT/ilist_node.h"
22 #include "llvm/IR/DebugLoc.h"
24 #include "llvm/IR/User.h"
25 #include "llvm/IR/Value.h"
27 #include "llvm/Support/Casting.h"
28 #include <algorithm>
29 #include <cassert>
30 #include <cstdint>
31 #include <utility>
32 
33 namespace llvm {
34 
35 class BasicBlock;
36 class FastMathFlags;
37 class MDNode;
38 class Module;
39 struct AAMDNodes;
40 
41 template <> struct ilist_alloc_traits<Instruction> {
42  static inline void deleteNode(Instruction *V);
43 };
44 
45 class Instruction : public User,
46  public ilist_node_with_parent<Instruction, BasicBlock> {
47  BasicBlock *Parent;
48  DebugLoc DbgLoc; // 'dbg' Metadata cache.
49 
50  /// Relative order of this instruction in its parent basic block. Used for
51  /// O(1) local dominance checks between instructions.
52  mutable unsigned Order = 0;
53 
54 protected:
55  // The 15 first bits of `Value::SubclassData` are available for subclasses of
56  // `Instruction` to use.
58 
59  // Template alias so that all Instruction storing alignment use the same
60  // definiton.
61  // Valid alignments are powers of two from 2^0 to 2^MaxAlignmentExponent =
62  // 2^29. We store them as Log2(Alignment), so we need 5 bits to encode the 30
63  // possible values.
64  template <unsigned Offset>
66  typename Bitfield::Element<unsigned, Offset, 5,
68 
69  template <unsigned Offset>
71 
72  template <unsigned Offset>
76 
77 private:
78  // The last bit is used to store whether the instruction has metadata attached
79  // or not.
81 
82 protected:
83  ~Instruction(); // Use deleteValue() to delete a generic Instruction.
84 
85 public:
86  Instruction(const Instruction &) = delete;
87  Instruction &operator=(const Instruction &) = delete;
88 
89  /// Specialize the methods defined in Value, as we know that an instruction
90  /// can only be used by other instructions.
91  Instruction *user_back() { return cast<Instruction>(*user_begin());}
92  const Instruction *user_back() const { return cast<Instruction>(*user_begin());}
93 
94  inline const BasicBlock *getParent() const { return Parent; }
95  inline BasicBlock *getParent() { return Parent; }
96 
97  /// Return the module owning the function this instruction belongs to
98  /// or nullptr it the function does not have a module.
99  ///
100  /// Note: this is undefined behavior if the instruction does not have a
101  /// parent, or the parent basic block does not have a parent function.
102  const Module *getModule() const;
104  return const_cast<Module *>(
105  static_cast<const Instruction *>(this)->getModule());
106  }
107 
108  /// Return the function this instruction belongs to.
109  ///
110  /// Note: it is undefined behavior to call this on an instruction not
111  /// currently inserted into a function.
112  const Function *getFunction() const;
114  return const_cast<Function *>(
115  static_cast<const Instruction *>(this)->getFunction());
116  }
117 
118  /// This method unlinks 'this' from the containing basic block, but does not
119  /// delete it.
120  void removeFromParent();
121 
122  /// This method unlinks 'this' from the containing basic block and deletes it.
123  ///
124  /// \returns an iterator pointing to the element after the erased one
126 
127  /// Insert an unlinked instruction into a basic block immediately before
128  /// the specified instruction.
129  void insertBefore(Instruction *InsertPos);
130 
131  /// Insert an unlinked instruction into a basic block immediately after the
132  /// specified instruction.
133  void insertAfter(Instruction *InsertPos);
134 
135  /// Unlink this instruction from its current basic block and insert it into
136  /// the basic block that MovePos lives in, right before MovePos.
137  void moveBefore(Instruction *MovePos);
138 
139  /// Unlink this instruction and insert into BB before I.
140  ///
141  /// \pre I is a valid iterator into BB.
143 
144  /// Unlink this instruction from its current basic block and insert it into
145  /// the basic block that MovePos lives in, right after MovePos.
146  void moveAfter(Instruction *MovePos);
147 
148  /// Given an instruction Other in the same basic block as this instruction,
149  /// return true if this instruction comes before Other. In this worst case,
150  /// this takes linear time in the number of instructions in the block. The
151  /// results are cached, so in common cases when the block remains unmodified,
152  /// it takes constant time.
153  bool comesBefore(const Instruction *Other) const;
154 
155  //===--------------------------------------------------------------------===//
156  // Subclass classification.
157  //===--------------------------------------------------------------------===//
158 
159  /// Returns a member of one of the enums like Instruction::Add.
160  unsigned getOpcode() const { return getValueID() - InstructionVal; }
161 
162  const char *getOpcodeName() const { return getOpcodeName(getOpcode()); }
163  bool isTerminator() const { return isTerminator(getOpcode()); }
164  bool isUnaryOp() const { return isUnaryOp(getOpcode()); }
165  bool isBinaryOp() const { return isBinaryOp(getOpcode()); }
166  bool isIntDivRem() const { return isIntDivRem(getOpcode()); }
167  bool isShift() const { return isShift(getOpcode()); }
168  bool isCast() const { return isCast(getOpcode()); }
169  bool isFuncletPad() const { return isFuncletPad(getOpcode()); }
170  bool isExceptionalTerminator() const {
172  }
173  bool isIndirectTerminator() const {
175  }
176 
177  static const char* getOpcodeName(unsigned OpCode);
178 
179  static inline bool isTerminator(unsigned OpCode) {
180  return OpCode >= TermOpsBegin && OpCode < TermOpsEnd;
181  }
182 
183  static inline bool isUnaryOp(unsigned Opcode) {
184  return Opcode >= UnaryOpsBegin && Opcode < UnaryOpsEnd;
185  }
186  static inline bool isBinaryOp(unsigned Opcode) {
187  return Opcode >= BinaryOpsBegin && Opcode < BinaryOpsEnd;
188  }
189 
190  static inline bool isIntDivRem(unsigned Opcode) {
191  return Opcode == UDiv || Opcode == SDiv || Opcode == URem || Opcode == SRem;
192  }
193 
194  /// Determine if the Opcode is one of the shift instructions.
195  static inline bool isShift(unsigned Opcode) {
196  return Opcode >= Shl && Opcode <= AShr;
197  }
198 
199  /// Return true if this is a logical shift left or a logical shift right.
200  inline bool isLogicalShift() const {
201  return getOpcode() == Shl || getOpcode() == LShr;
202  }
203 
204  /// Return true if this is an arithmetic shift right.
205  inline bool isArithmeticShift() const {
206  return getOpcode() == AShr;
207  }
208 
209  /// Determine if the Opcode is and/or/xor.
210  static inline bool isBitwiseLogicOp(unsigned Opcode) {
211  return Opcode == And || Opcode == Or || Opcode == Xor;
212  }
213 
214  /// Return true if this is and/or/xor.
215  inline bool isBitwiseLogicOp() const {
216  return isBitwiseLogicOp(getOpcode());
217  }
218 
219  /// Determine if the OpCode is one of the CastInst instructions.
220  static inline bool isCast(unsigned OpCode) {
221  return OpCode >= CastOpsBegin && OpCode < CastOpsEnd;
222  }
223 
224  /// Determine if the OpCode is one of the FuncletPadInst instructions.
225  static inline bool isFuncletPad(unsigned OpCode) {
226  return OpCode >= FuncletPadOpsBegin && OpCode < FuncletPadOpsEnd;
227  }
228 
229  /// Returns true if the OpCode is a terminator related to exception handling.
230  static inline bool isExceptionalTerminator(unsigned OpCode) {
231  switch (OpCode) {
232  case Instruction::CatchSwitch:
233  case Instruction::CatchRet:
234  case Instruction::CleanupRet:
235  case Instruction::Invoke:
236  case Instruction::Resume:
237  return true;
238  default:
239  return false;
240  }
241  }
242 
243  /// Returns true if the OpCode is a terminator with indirect targets.
244  static inline bool isIndirectTerminator(unsigned OpCode) {
245  switch (OpCode) {
246  case Instruction::IndirectBr:
247  case Instruction::CallBr:
248  return true;
249  default:
250  return false;
251  }
252  }
253 
254  //===--------------------------------------------------------------------===//
255  // Metadata manipulation.
256  //===--------------------------------------------------------------------===//
257 
258  /// Return true if this instruction has any metadata attached to it.
259  bool hasMetadata() const { return DbgLoc || Value::hasMetadata(); }
260 
261  /// Return true if this instruction has metadata attached to it other than a
262  /// debug location.
264 
265  /// Return true if this instruction has the given type of metadata attached.
266  bool hasMetadata(unsigned KindID) const {
267  return getMetadata(KindID) != nullptr;
268  }
269 
270  /// Return true if this instruction has the given type of metadata attached.
271  bool hasMetadata(StringRef Kind) const {
272  return getMetadata(Kind) != nullptr;
273  }
274 
275  /// Get the metadata of given kind attached to this Instruction.
276  /// If the metadata is not found then return null.
277  MDNode *getMetadata(unsigned KindID) const {
278  if (!hasMetadata()) return nullptr;
279  return getMetadataImpl(KindID);
280  }
281 
282  /// Get the metadata of given kind attached to this Instruction.
283  /// If the metadata is not found then return null.
285  if (!hasMetadata()) return nullptr;
286  return getMetadataImpl(Kind);
287  }
288 
289  /// Get all metadata attached to this Instruction. The first element of each
290  /// pair returned is the KindID, the second element is the metadata value.
291  /// This list is returned sorted by the KindID.
292  void
293  getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const {
294  if (hasMetadata())
295  getAllMetadataImpl(MDs);
296  }
297 
298  /// This does the same thing as getAllMetadata, except that it filters out the
299  /// debug location.
301  SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const {
303  }
304 
305  /// Fills the AAMDNodes structure with AA metadata from this instruction.
306  /// When Merge is true, the existing AA metadata is merged with that from this
307  /// instruction providing the most-general result.
308  void getAAMetadata(AAMDNodes &N, bool Merge = false) const;
309 
310  /// Set the metadata of the specified kind to the specified node. This updates
311  /// or replaces metadata if already present, or removes it if Node is null.
312  void setMetadata(unsigned KindID, MDNode *Node);
314 
315  /// Copy metadata from \p SrcInst to this instruction. \p WL, if not empty,
316  /// specifies the list of meta data that needs to be copied. If \p WL is
317  /// empty, all meta data will be copied.
318  void copyMetadata(const Instruction &SrcInst,
320 
321  /// If the instruction has "branch_weights" MD_prof metadata and the MDNode
322  /// has three operands (including name string), swap the order of the
323  /// metadata.
324  void swapProfMetadata();
325 
326  /// Drop all unknown metadata except for debug locations.
327  /// @{
328  /// Passes are required to drop metadata they don't understand. This is a
329  /// convenience method for passes to do so.
333  }
334  void dropUnknownNonDebugMetadata(unsigned ID1) {
336  }
337  void dropUnknownNonDebugMetadata(unsigned ID1, unsigned ID2) {
338  unsigned IDs[] = {ID1, ID2};
339  return dropUnknownNonDebugMetadata(IDs);
340  }
341  /// @}
342 
343  /// Adds an !annotation metadata node with \p Annotation to this instruction.
344  /// If this instruction already has !annotation metadata, append \p Annotation
345  /// to the existing node.
346  void addAnnotationMetadata(StringRef Annotation);
347 
348  /// Sets the metadata on this instruction from the AAMDNodes structure.
349  void setAAMetadata(const AAMDNodes &N);
350 
351  /// Retrieve the raw weight values of a conditional branch or select.
352  /// Returns true on success with profile weights filled in.
353  /// Returns false if no metadata or invalid metadata was found.
354  bool extractProfMetadata(uint64_t &TrueVal, uint64_t &FalseVal) const;
355 
356  /// Retrieve total raw weight values of a branch.
357  /// Returns true on success with profile total weights filled in.
358  /// Returns false if no metadata was found.
359  bool extractProfTotalWeight(uint64_t &TotalVal) const;
360 
361  /// Set the debug location information for this instruction.
362  void setDebugLoc(DebugLoc Loc) { DbgLoc = std::move(Loc); }
363 
364  /// Return the debug location for this node as a DebugLoc.
365  const DebugLoc &getDebugLoc() const { return DbgLoc; }
366 
367  /// Set or clear the nuw flag on this instruction, which must be an operator
368  /// which supports this flag. See LangRef.html for the meaning of this flag.
369  void setHasNoUnsignedWrap(bool b = true);
370 
371  /// Set or clear the nsw flag on this instruction, which must be an operator
372  /// which supports this flag. See LangRef.html for the meaning of this flag.
373  void setHasNoSignedWrap(bool b = true);
374 
375  /// Set or clear the exact flag on this instruction, which must be an operator
376  /// which supports this flag. See LangRef.html for the meaning of this flag.
377  void setIsExact(bool b = true);
378 
379  /// Determine whether the no unsigned wrap flag is set.
380  bool hasNoUnsignedWrap() const;
381 
382  /// Determine whether the no signed wrap flag is set.
383  bool hasNoSignedWrap() const;
384 
385  /// Drops flags that may cause this instruction to evaluate to poison despite
386  /// having non-poison inputs.
388 
389  /// Determine whether the exact flag is set.
390  bool isExact() const;
391 
392  /// Set or clear all fast-math-flags on this instruction, which must be an
393  /// operator which supports this flag. See LangRef.html for the meaning of
394  /// this flag.
395  void setFast(bool B);
396 
397  /// Set or clear the reassociation flag on this instruction, which must be
398  /// an operator which supports this flag. See LangRef.html for the meaning of
399  /// this flag.
400  void setHasAllowReassoc(bool B);
401 
402  /// Set or clear the no-nans flag on this instruction, which must be an
403  /// operator which supports this flag. See LangRef.html for the meaning of
404  /// this flag.
405  void setHasNoNaNs(bool B);
406 
407  /// Set or clear the no-infs flag on this instruction, which must be an
408  /// operator which supports this flag. See LangRef.html for the meaning of
409  /// this flag.
410  void setHasNoInfs(bool B);
411 
412  /// Set or clear the no-signed-zeros flag on this instruction, which must be
413  /// an operator which supports this flag. See LangRef.html for the meaning of
414  /// this flag.
415  void setHasNoSignedZeros(bool B);
416 
417  /// Set or clear the allow-reciprocal flag on this instruction, which must be
418  /// an operator which supports this flag. See LangRef.html for the meaning of
419  /// this flag.
420  void setHasAllowReciprocal(bool B);
421 
422  /// Set or clear the allow-contract flag on this instruction, which must be
423  /// an operator which supports this flag. See LangRef.html for the meaning of
424  /// this flag.
425  void setHasAllowContract(bool B);
426 
427  /// Set or clear the approximate-math-functions flag on this instruction,
428  /// which must be an operator which supports this flag. See LangRef.html for
429  /// the meaning of this flag.
430  void setHasApproxFunc(bool B);
431 
432  /// Convenience function for setting multiple fast-math flags on this
433  /// instruction, which must be an operator which supports these flags. See
434  /// LangRef.html for the meaning of these flags.
436 
437  /// Convenience function for transferring all fast-math flag values to this
438  /// instruction, which must be an operator which supports these flags. See
439  /// LangRef.html for the meaning of these flags.
441 
442  /// Determine whether all fast-math-flags are set.
443  bool isFast() const;
444 
445  /// Determine whether the allow-reassociation flag is set.
446  bool hasAllowReassoc() const;
447 
448  /// Determine whether the no-NaNs flag is set.
449  bool hasNoNaNs() const;
450 
451  /// Determine whether the no-infs flag is set.
452  bool hasNoInfs() const;
453 
454  /// Determine whether the no-signed-zeros flag is set.
455  bool hasNoSignedZeros() const;
456 
457  /// Determine whether the allow-reciprocal flag is set.
458  bool hasAllowReciprocal() const;
459 
460  /// Determine whether the allow-contract flag is set.
461  bool hasAllowContract() const;
462 
463  /// Determine whether the approximate-math-functions flag is set.
464  bool hasApproxFunc() const;
465 
466  /// Convenience function for getting all the fast-math flags, which must be an
467  /// operator which supports these flags. See LangRef.html for the meaning of
468  /// these flags.
470 
471  /// Copy I's fast-math flags
472  void copyFastMathFlags(const Instruction *I);
473 
474  /// Convenience method to copy supported exact, fast-math, and (optionally)
475  /// wrapping flags from V to this instruction.
476  void copyIRFlags(const Value *V, bool IncludeWrapFlags = true);
477 
478  /// Logical 'and' of any supported wrapping, exact, and fast-math flags of
479  /// V and this instruction.
480  void andIRFlags(const Value *V);
481 
482  /// Merge 2 debug locations and apply it to the Instruction. If the
483  /// instruction is a CallIns, we need to traverse the inline chain to find
484  /// the common scope. This is not efficient for N-way merging as each time
485  /// you merge 2 iterations, you need to rebuild the hashmap to find the
486  /// common scope. However, we still choose this API because:
487  /// 1) Simplicity: it takes 2 locations instead of a list of locations.
488  /// 2) In worst case, it increases the complexity from O(N*I) to
489  /// O(2*N*I), where N is # of Instructions to merge, and I is the
490  /// maximum level of inline stack. So it is still linear.
491  /// 3) Merging of call instructions should be extremely rare in real
492  /// applications, thus the N-way merging should be in code path.
493  /// The DebugLoc attached to this instruction will be overwritten by the
494  /// merged DebugLoc.
495  void applyMergedLocation(const DILocation *LocA, const DILocation *LocB);
496 
497  /// Updates the debug location given that the instruction has been hoisted
498  /// from a block to a predecessor of that block.
499  /// Note: it is undefined behavior to call this on an instruction not
500  /// currently inserted into a function.
502 
503  /// Drop the instruction's debug location. This does not guarantee removal
504  /// of the !dbg source location attachment, as it must set a line 0 location
505  /// with scope information attached on call instructions. To guarantee
506  /// removal of the !dbg attachment, use the \ref setDebugLoc() API.
507  /// Note: it is undefined behavior to call this on an instruction not
508  /// currently inserted into a function.
509  void dropLocation();
510 
511 private:
512  // These are all implemented in Metadata.cpp.
513  MDNode *getMetadataImpl(unsigned KindID) const;
514  MDNode *getMetadataImpl(StringRef Kind) const;
515  void
516  getAllMetadataImpl(SmallVectorImpl<std::pair<unsigned, MDNode *>> &) const;
517 
518 public:
519  //===--------------------------------------------------------------------===//
520  // Predicates and helper methods.
521  //===--------------------------------------------------------------------===//
522 
523  /// Return true if the instruction is associative:
524  ///
525  /// Associative operators satisfy: x op (y op z) === (x op y) op z
526  ///
527  /// In LLVM, the Add, Mul, And, Or, and Xor operators are associative.
528  ///
530  static bool isAssociative(unsigned Opcode) {
531  return Opcode == And || Opcode == Or || Opcode == Xor ||
532  Opcode == Add || Opcode == Mul;
533  }
534 
535  /// Return true if the instruction is commutative:
536  ///
537  /// Commutative operators satisfy: (x op y) === (y op x)
538  ///
539  /// In LLVM, these are the commutative operators, plus SetEQ and SetNE, when
540  /// applied to any type.
541  ///
543  static bool isCommutative(unsigned Opcode) {
544  switch (Opcode) {
545  case Add: case FAdd:
546  case Mul: case FMul:
547  case And: case Or: case Xor:
548  return true;
549  default:
550  return false;
551  }
552  }
553 
554  /// Return true if the instruction is idempotent:
555  ///
556  /// Idempotent operators satisfy: x op x === x
557  ///
558  /// In LLVM, the And and Or operators are idempotent.
559  ///
560  bool isIdempotent() const { return isIdempotent(getOpcode()); }
561  static bool isIdempotent(unsigned Opcode) {
562  return Opcode == And || Opcode == Or;
563  }
564 
565  /// Return true if the instruction is nilpotent:
566  ///
567  /// Nilpotent operators satisfy: x op x === Id,
568  ///
569  /// where Id is the identity for the operator, i.e. a constant such that
570  /// x op Id === x and Id op x === x for all x.
571  ///
572  /// In LLVM, the Xor operator is nilpotent.
573  ///
574  bool isNilpotent() const { return isNilpotent(getOpcode()); }
575  static bool isNilpotent(unsigned Opcode) {
576  return Opcode == Xor;
577  }
578 
579  /// Return true if this instruction may modify memory.
580  bool mayWriteToMemory() const;
581 
582  /// Return true if this instruction may read memory.
583  bool mayReadFromMemory() const;
584 
585  /// Return true if this instruction may read or write memory.
586  bool mayReadOrWriteMemory() const {
587  return mayReadFromMemory() || mayWriteToMemory();
588  }
589 
590  /// Return true if this instruction has an AtomicOrdering of unordered or
591  /// higher.
592  bool isAtomic() const;
593 
594  /// Return true if this atomic instruction loads from memory.
595  bool hasAtomicLoad() const;
596 
597  /// Return true if this atomic instruction stores to memory.
598  bool hasAtomicStore() const;
599 
600  /// Return true if this instruction may throw an exception.
601  bool mayThrow() const;
602 
603  /// Return true if this instruction behaves like a memory fence: it can load
604  /// or store to memory location without being given a memory location.
605  bool isFenceLike() const {
606  switch (getOpcode()) {
607  default:
608  return false;
609  // This list should be kept in sync with the list in mayWriteToMemory for
610  // all opcodes which don't have a memory location.
611  case Instruction::Fence:
612  case Instruction::CatchPad:
613  case Instruction::CatchRet:
614  case Instruction::Call:
615  case Instruction::Invoke:
616  return true;
617  }
618  }
619 
620  /// Return true if the instruction may have side effects.
621  ///
622  /// Note that this does not consider malloc and alloca to have side
623  /// effects because the newly allocated memory is completely invisible to
624  /// instructions which don't use the returned value. For cases where this
625  /// matters, isSafeToSpeculativelyExecute may be more appropriate.
626  bool mayHaveSideEffects() const { return mayWriteToMemory() || mayThrow(); }
627 
628  /// Return true if the instruction can be removed if the result is unused.
629  ///
630  /// When constant folding some instructions cannot be removed even if their
631  /// results are unused. Specifically terminator instructions and calls that
632  /// may have side effects cannot be removed without semantically changing the
633  /// generated program.
634  bool isSafeToRemove() const;
635 
636  /// Return true if the instruction will return (unwinding is considered as
637  /// a form of returning control flow here).
638  bool willReturn() const;
639 
640  /// Return true if the instruction is a variety of EH-block.
641  bool isEHPad() const {
642  switch (getOpcode()) {
643  case Instruction::CatchSwitch:
644  case Instruction::CatchPad:
645  case Instruction::CleanupPad:
646  case Instruction::LandingPad:
647  return true;
648  default:
649  return false;
650  }
651  }
652 
653  /// Return true if the instruction is a llvm.lifetime.start or
654  /// llvm.lifetime.end marker.
655  bool isLifetimeStartOrEnd() const;
656 
657  /// Return true if the instruction is a DbgInfoIntrinsic or PseudoProbeInst.
658  bool isDebugOrPseudoInst() const;
659 
660  /// Return a pointer to the next non-debug instruction in the same basic
661  /// block as 'this', or nullptr if no such instruction exists. Skip any pseudo
662  /// operations if \c SkipPseudoOp is true.
663  const Instruction *
664  getNextNonDebugInstruction(bool SkipPseudoOp = false) const;
665  Instruction *getNextNonDebugInstruction(bool SkipPseudoOp = false) {
666  return const_cast<Instruction *>(
667  static_cast<const Instruction *>(this)->getNextNonDebugInstruction(
668  SkipPseudoOp));
669  }
670 
671  /// Return a pointer to the previous non-debug instruction in the same basic
672  /// block as 'this', or nullptr if no such instruction exists. Skip any pseudo
673  /// operations if \c SkipPseudoOp is true.
674  const Instruction *
675  getPrevNonDebugInstruction(bool SkipPseudoOp = false) const;
676  Instruction *getPrevNonDebugInstruction(bool SkipPseudoOp = false) {
677  return const_cast<Instruction *>(
678  static_cast<const Instruction *>(this)->getPrevNonDebugInstruction(
679  SkipPseudoOp));
680  }
681 
682  /// Create a copy of 'this' instruction that is identical in all ways except
683  /// the following:
684  /// * The instruction has no parent
685  /// * The instruction has no name
686  ///
687  Instruction *clone() const;
688 
689  /// Return true if the specified instruction is exactly identical to the
690  /// current one. This means that all operands match and any extra information
691  /// (e.g. load is volatile) agree.
692  bool isIdenticalTo(const Instruction *I) const;
693 
694  /// This is like isIdenticalTo, except that it ignores the
695  /// SubclassOptionalData flags, which may specify conditions under which the
696  /// instruction's result is undefined.
697  bool isIdenticalToWhenDefined(const Instruction *I) const;
698 
699  /// When checking for operation equivalence (using isSameOperationAs) it is
700  /// sometimes useful to ignore certain attributes.
702  /// Check for equivalence ignoring load/store alignment.
704  /// Check for equivalence treating a type and a vector of that type
705  /// as equivalent.
707  };
708 
709  /// This function determines if the specified instruction executes the same
710  /// operation as the current one. This means that the opcodes, type, operand
711  /// types and any other factors affecting the operation must be the same. This
712  /// is similar to isIdenticalTo except the operands themselves don't have to
713  /// be identical.
714  /// @returns true if the specified instruction is the same operation as
715  /// the current one.
716  /// Determine if one instruction is the same operation as another.
717  bool isSameOperationAs(const Instruction *I, unsigned flags = 0) const;
718 
719  /// Return true if there are any uses of this instruction in blocks other than
720  /// the specified block. Note that PHI nodes are considered to evaluate their
721  /// operands in the corresponding predecessor block.
722  bool isUsedOutsideOfBlock(const BasicBlock *BB) const;
723 
724  /// Return the number of successors that this instruction has. The instruction
725  /// must be a terminator.
726  unsigned getNumSuccessors() const;
727 
728  /// Return the specified successor. This instruction must be a terminator.
729  BasicBlock *getSuccessor(unsigned Idx) const;
730 
731  /// Update the specified successor to point at the provided block. This
732  /// instruction must be a terminator.
733  void setSuccessor(unsigned Idx, BasicBlock *BB);
734 
735  /// Replace specified successor OldBB to point at the provided block.
736  /// This instruction must be a terminator.
737  void replaceSuccessorWith(BasicBlock *OldBB, BasicBlock *NewBB);
738 
739  /// Methods for support type inquiry through isa, cast, and dyn_cast:
740  static bool classof(const Value *V) {
741  return V->getValueID() >= Value::InstructionVal;
742  }
743 
744  //----------------------------------------------------------------------
745  // Exported enumerations.
746  //
747  enum TermOps { // These terminate basic blocks
748 #define FIRST_TERM_INST(N) TermOpsBegin = N,
749 #define HANDLE_TERM_INST(N, OPC, CLASS) OPC = N,
750 #define LAST_TERM_INST(N) TermOpsEnd = N+1
751 #include "llvm/IR/Instruction.def"
752  };
753 
754  enum UnaryOps {
755 #define FIRST_UNARY_INST(N) UnaryOpsBegin = N,
756 #define HANDLE_UNARY_INST(N, OPC, CLASS) OPC = N,
757 #define LAST_UNARY_INST(N) UnaryOpsEnd = N+1
758 #include "llvm/IR/Instruction.def"
759  };
760 
761  enum BinaryOps {
762 #define FIRST_BINARY_INST(N) BinaryOpsBegin = N,
763 #define HANDLE_BINARY_INST(N, OPC, CLASS) OPC = N,
764 #define LAST_BINARY_INST(N) BinaryOpsEnd = N+1
765 #include "llvm/IR/Instruction.def"
766  };
767 
768  enum MemoryOps {
769 #define FIRST_MEMORY_INST(N) MemoryOpsBegin = N,
770 #define HANDLE_MEMORY_INST(N, OPC, CLASS) OPC = N,
771 #define LAST_MEMORY_INST(N) MemoryOpsEnd = N+1
772 #include "llvm/IR/Instruction.def"
773  };
774 
775  enum CastOps {
776 #define FIRST_CAST_INST(N) CastOpsBegin = N,
777 #define HANDLE_CAST_INST(N, OPC, CLASS) OPC = N,
778 #define LAST_CAST_INST(N) CastOpsEnd = N+1
779 #include "llvm/IR/Instruction.def"
780  };
781 
783 #define FIRST_FUNCLETPAD_INST(N) FuncletPadOpsBegin = N,
784 #define HANDLE_FUNCLETPAD_INST(N, OPC, CLASS) OPC = N,
785 #define LAST_FUNCLETPAD_INST(N) FuncletPadOpsEnd = N+1
786 #include "llvm/IR/Instruction.def"
787  };
788 
789  enum OtherOps {
790 #define FIRST_OTHER_INST(N) OtherOpsBegin = N,
791 #define HANDLE_OTHER_INST(N, OPC, CLASS) OPC = N,
792 #define LAST_OTHER_INST(N) OtherOpsEnd = N+1
793 #include "llvm/IR/Instruction.def"
794  };
795 
796 private:
798  friend class BasicBlock; // For renumbering.
799 
800  // Shadow Value::setValueSubclassData with a private forwarding method so that
801  // subclasses cannot accidentally use it.
802  void setValueSubclassData(unsigned short D) {
804  }
805 
806  unsigned short getSubclassDataFromValue() const {
808  }
809 
810  void setParent(BasicBlock *P);
811 
812 protected:
813  // Instruction subclasses can stick up to 15 bits of stuff into the
814  // SubclassData field of instruction with these members.
815 
816  template <typename BitfieldElement>
818  static_assert(
819  std::is_same<BitfieldElement, HasMetadataField>::value ||
820  !Bitfield::isOverlapping<BitfieldElement, HasMetadataField>(),
821  "Must not overlap with the metadata bit");
822  return Bitfield::get<BitfieldElement>(getSubclassDataFromValue());
823  }
824 
825  template <typename BitfieldElement>
827  static_assert(
828  std::is_same<BitfieldElement, HasMetadataField>::value ||
829  !Bitfield::isOverlapping<BitfieldElement, HasMetadataField>(),
830  "Must not overlap with the metadata bit");
831  auto Storage = getSubclassDataFromValue();
832  Bitfield::set<BitfieldElement>(Storage, Value);
833  setValueSubclassData(Storage);
834  }
835 
836  Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
837  Instruction *InsertBefore = nullptr);
838  Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
839  BasicBlock *InsertAtEnd);
840 
841 private:
842  /// Create a copy of this instruction.
843  Instruction *cloneImpl() const;
844 };
845 
847  V->deleteValue();
848 }
849 
850 } // end namespace llvm
851 
852 #endif // LLVM_IR_INSTRUCTION_H
llvm::Instruction::getPrevNonDebugInstruction
const Instruction * getPrevNonDebugInstruction(bool SkipPseudoOp=false) const
Return a pointer to the previous non-debug instruction in the same basic block as 'this',...
Definition: Instruction.cpp:667
llvm::EngineKind::Kind
Kind
Definition: ExecutionEngine.h:524
llvm::Instruction::isTerminator
bool isTerminator() const
Definition: Instruction.h:163
llvm::Instruction::isAssociative
bool isAssociative() const LLVM_READONLY
Return true if the instruction is associative:
Definition: Instruction.cpp:674
llvm::Instruction::getNextNonDebugInstruction
Instruction * getNextNonDebugInstruction(bool SkipPseudoOp=false)
Definition: Instruction.h:665
LLVM_READONLY
#define LLVM_READONLY
Definition: Compiler.h:211
Merge
R600 Clause Merge
Definition: R600ClauseMergePass.cpp:69
llvm
This class represents lattice values for constants.
Definition: AllocatorList.h:23
llvm::Instruction::replaceSuccessorWith
void replaceSuccessorWith(BasicBlock *OldBB, BasicBlock *NewBB)
Replace specified successor OldBB to point at the provided block.
Definition: Instruction.cpp:732
llvm::Instruction::getModule
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:65
llvm::RecurKind::Or
@ Or
Bitwise or logical OR of integers.
llvm::Instruction::UnaryOps
UnaryOps
Definition: Instruction.h:754
llvm::Instruction::isBitwiseLogicOp
static bool isBitwiseLogicOp(unsigned Opcode)
Determine if the Opcode is and/or/xor.
Definition: Instruction.h:210
llvm::RecurKind::FMul
@ FMul
Product of floats.
llvm::Instruction::isExceptionalTerminator
static bool isExceptionalTerminator(unsigned OpCode)
Returns true if the OpCode is a terminator related to exception handling.
Definition: Instruction.h:230
AtomicOrdering.h
llvm::Instruction::getNextNonDebugInstruction
const Instruction * getNextNonDebugInstruction(bool SkipPseudoOp=false) const
Return a pointer to the next non-debug instruction in the same basic block as 'this',...
Definition: Instruction.cpp:659
llvm::Function
Definition: Function.h:61
llvm::Instruction::isCast
bool isCast() const
Definition: Instruction.h:168
StringRef.h
llvm::Value::getSubclassDataFromValue
unsigned short getSubclassDataFromValue() const
Definition: Value.h:832
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::Instruction::isNilpotent
static bool isNilpotent(unsigned Opcode)
Definition: Instruction.h:575
llvm::Instruction::getAllMetadataOtherThanDebugLoc
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:300
llvm::Instruction::getParent
BasicBlock * getParent()
Definition: Instruction.h:95
llvm::Instruction::setHasAllowContract
void setHasAllowContract(bool B)
Set or clear the allow-contract flag on this instruction, which must be an operator which supports th...
Definition: Instruction.cpp:198
llvm::ilist_node_with_parent
An ilist node that can access its parent list.
Definition: ilist_node.h:256
llvm::Instruction::getSubclassData
BitfieldElement::Type getSubclassData() const
Definition: Instruction.h:817
llvm::Instruction::hasNoUnsignedWrap
bool hasNoUnsignedWrap() const
Determine whether the no unsigned wrap flag is set.
Definition: Instruction.cpp:131
llvm::Instruction::insertBefore
void insertBefore(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately before the specified instruction.
Definition: Instruction.cpp:83
llvm::Instruction::hasAllowReciprocal
bool hasAllowReciprocal() const
Determine whether the allow-reciprocal flag is set.
Definition: Instruction.cpp:243
llvm::Instruction::isIndirectTerminator
static bool isIndirectTerminator(unsigned OpCode)
Returns true if the OpCode is a terminator with indirect targets.
Definition: Instruction.h:244
llvm::DILocation
Debug location.
Definition: DebugInfoMetadata.h:1554
llvm::AAMDNodes
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:640
llvm::Instruction::dropUnknownNonDebugMetadata
void dropUnknownNonDebugMetadata(unsigned ID1)
Definition: Instruction.h:334
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:46
llvm::Instruction::getPrevNonDebugInstruction
Instruction * getPrevNonDebugInstruction(bool SkipPseudoOp=false)
Definition: Instruction.h:676
llvm::Instruction::isShift
bool isShift() const
Definition: Instruction.h:167
llvm::Instruction::setSubclassData
void setSubclassData(typename BitfieldElement::Type Value)
Definition: Instruction.h:826
llvm::Instruction::hasApproxFunc
bool hasApproxFunc() const
Determine whether the approximate-math-functions flag is set.
Definition: Instruction.cpp:253
llvm::Instruction::comesBefore
bool comesBefore(const Instruction *Other) const
Given an instruction Other in the same basic block as this instruction, return true if this instructi...
Definition: Instruction.cpp:110
llvm::Instruction::AlignmentBitfieldElementT
typename Bitfield::Element< unsigned, Offset, 5, Value::MaxAlignmentExponent > AlignmentBitfieldElementT
Definition: Instruction.h:67
llvm::Instruction::setHasNoUnsignedWrap
void setHasNoUnsignedWrap(bool b=true)
Set or clear the nuw flag on this instruction, which must be an operator which supports this flag.
Definition: Instruction.cpp:119
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::tgtok::FalseVal
@ FalseVal
Definition: TGLexer.h:61
llvm::Instruction::mayThrow
bool mayThrow() const
Return true if this instruction may throw an exception.
Definition: Instruction.cpp:621
llvm::Value::user_begin
user_iterator user_begin()
Definition: Value.h:400
llvm::Instruction::copyMetadata
void copyMetadata(const Instruction &SrcInst, ArrayRef< unsigned > WL=ArrayRef< unsigned >())
Copy metadata from SrcInst to this instruction.
Definition: Instruction.cpp:760
llvm::Value::setValueSubclassData
void setValueSubclassData(unsigned short D)
Definition: Value.h:833
llvm::FastMathFlags
Convenience struct for specifying and reasoning about fast-math flags.
Definition: Operator.h:160
llvm::Instruction::~Instruction
~Instruction()
Definition: Instruction.cpp:44
llvm::Instruction::setIsExact
void setIsExact(bool b=true)
Set or clear the exact flag on this instruction, which must be an operator which supports this flag.
Definition: Instruction.cpp:127
llvm::Instruction::dropUnknownNonDebugMetadata
void dropUnknownNonDebugMetadata()
Definition: Instruction.h:331
llvm::Instruction::isExceptionalTerminator
bool isExceptionalTerminator() const
Definition: Instruction.h:170
llvm::Instruction::hasMetadata
bool hasMetadata(StringRef Kind) const
Return true if this instruction has the given type of metadata attached.
Definition: Instruction.h:271
llvm::Instruction::setMetadata
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1317
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::Instruction::getNumSuccessors
unsigned getNumSuccessors() const
Return the number of successors that this instruction has.
Definition: Instruction.cpp:696
llvm::Instruction::insertAfter
void insertAfter(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately after the specified instruction.
Definition: Instruction.cpp:89
llvm::Instruction::getOpcode
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:160
llvm::Instruction::willReturn
bool willReturn() const
Return true if the instruction will return (unwinding is considered as a form of returning control fl...
Definition: Instruction.cpp:636
llvm::Instruction::extractProfTotalWeight
bool extractProfTotalWeight(uint64_t &TotalVal) const
Retrieve total raw weight values of a branch.
Definition: Metadata.cpp:1402
llvm::Instruction::isArithmeticShift
bool isArithmeticShift() const
Return true if this is an arithmetic shift right.
Definition: Instruction.h:205
llvm::RecurKind::And
@ And
Bitwise or logical AND of integers.
llvm::Instruction::mayReadOrWriteMemory
bool mayReadOrWriteMemory() const
Return true if this instruction may read or write memory.
Definition: Instruction.h:586
llvm::Instruction::getAAMetadata
void getAAMetadata(AAMDNodes &N, bool Merge=false) const
Fills the AAMDNodes structure with AA metadata from this instruction.
Definition: TypeBasedAliasAnalysis.cpp:524
llvm::Instruction::setHasNoSignedWrap
void setHasNoSignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag.
Definition: Instruction.cpp:123
llvm::User
Definition: User.h:44
llvm::Instruction::BoolBitfieldElementT
typename Bitfield::Element< bool, Offset, 1 > BoolBitfieldElementT
Definition: Instruction.h:70
llvm::Instruction::isIdenticalToWhenDefined
bool isIdenticalToWhenDefined(const Instruction *I) const
This is like isIdenticalTo, except that it ignores the SubclassOptionalData flags,...
Definition: Instruction.cpp:473
b
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int b
Definition: README.txt:418
llvm::Instruction::applyMergedLocation
void applyMergedLocation(const DILocation *LocA, const DILocation *LocB)
Merge 2 debug locations and apply it to the Instruction.
Definition: DebugInfo.cpp:690
llvm::Instruction::OtherOps
OtherOps
Definition: Instruction.h:789
llvm::Instruction::isShift
static bool isShift(unsigned Opcode)
Determine if the Opcode is one of the shift instructions.
Definition: Instruction.h:195
llvm::Instruction::isNilpotent
bool isNilpotent() const
Return true if the instruction is nilpotent:
Definition: Instruction.h:574
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::Value::getValueID
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:531
llvm::Instruction::CastOps
CastOps
Definition: Instruction.h:775
llvm::Instruction::getOpcodeName
const char * getOpcodeName() const
Definition: Instruction.h:162
llvm::Instruction::classof
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Instruction.h:740
llvm::Instruction
Definition: Instruction.h:45
llvm::Instruction::getAllMetadata
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * >> &MDs) const
Get all metadata attached to this Instruction.
Definition: Instruction.h:293
llvm::Instruction::hasMetadata
bool hasMetadata(unsigned KindID) const
Return true if this instruction has the given type of metadata attached.
Definition: Instruction.h:266
DebugLoc.h
llvm::Instruction::getSuccessor
BasicBlock * getSuccessor(unsigned Idx) const
Return the specified successor. This instruction must be a terminator.
Definition: Instruction.cpp:708
llvm::Instruction::removeFromParent
void removeFromParent()
This method unlinks 'this' from the containing basic block, but does not delete it.
Definition: Instruction.cpp:73
llvm::Instruction::isSafeToRemove
bool isSafeToRemove() const
Return true if the instruction can be removed if the result is unused.
Definition: Instruction.cpp:631
llvm::MCID::Call
@ Call
Definition: MCInstrDesc.h:154
llvm::Instruction::mayWriteToMemory
bool mayWriteToMemory() const
Return true if this instruction may modify memory.
Definition: Instruction.cpp:562
llvm::Instruction::isLifetimeStartOrEnd
bool isLifetimeStartOrEnd() const
Return true if the instruction is a llvm.lifetime.start or llvm.lifetime.end marker.
Definition: Instruction.cpp:646
llvm::Instruction::isIntDivRem
bool isIntDivRem() const
Definition: Instruction.h:166
llvm::Instruction::extractProfMetadata
bool extractProfMetadata(uint64_t &TrueVal, uint64_t &FalseVal) const
Retrieve the raw weight values of a conditional branch or select.
Definition: Metadata.cpp:1377
llvm::None
const NoneType None
Definition: None.h:23
llvm::Instruction::OperationEquivalenceFlags
OperationEquivalenceFlags
When checking for operation equivalence (using isSameOperationAs) it is sometimes useful to ignore ce...
Definition: Instruction.h:701
llvm::Instruction::getMetadata
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:277
llvm::Instruction::isCommutative
bool isCommutative() const LLVM_READONLY
Return true if the instruction is commutative:
Definition: Instruction.cpp:689
llvm::Instruction::setHasNoNaNs
void setHasNoNaNs(bool B)
Set or clear the no-nans flag on this instruction, which must be an operator which supports this flag...
Definition: Instruction.cpp:178
llvm::Instruction::hasAtomicLoad
bool hasAtomicLoad() const
Return true if this atomic instruction loads from memory.
Definition: Instruction.cpp:597
llvm::Instruction::AtomicOrderingBitfieldElementT
typename Bitfield::Element< AtomicOrdering, Offset, 3, AtomicOrdering::LAST > AtomicOrderingBitfieldElementT
Definition: Instruction.h:75
llvm::Instruction::andIRFlags
void andIRFlags(const Value *V)
Logical 'and' of any supported wrapping, exact, and fast-math flags of V and this instruction.
Definition: Instruction.cpp:291
llvm::AtomicOrdering
AtomicOrdering
Atomic ordering for LLVM's memory model.
Definition: AtomicOrdering.h:56
llvm::Instruction::isTerminator
static bool isTerminator(unsigned OpCode)
Definition: Instruction.h:179
llvm::Instruction::addAnnotationMetadata
void addAnnotationMetadata(StringRef Annotation)
Adds an !annotation metadata node with Annotation to this instruction.
Definition: Metadata.cpp:1330
llvm::Instruction::eraseFromParent
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:77
llvm::Instruction::isLogicalShift
bool isLogicalShift() const
Return true if this is a logical shift left or a logical shift right.
Definition: Instruction.h:200
llvm::SymbolTableListTraits
Definition: GlobalAlias.h:25
llvm::Instruction::setFast
void setFast(bool B)
Set or clear all fast-math-flags on this instruction, which must be an operator which supports this f...
Definition: Instruction.cpp:168
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::AtomicOrdering::LAST
@ LAST
llvm::Instruction::hasAllowContract
bool hasAllowContract() const
Determine whether the allow-contract flag is set.
Definition: Instruction.cpp:248
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
llvm::Instruction::user_back
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:91
llvm::Instruction::MemoryOps
MemoryOps
Definition: Instruction.h:768
llvm::Instruction::isIdenticalTo
bool isIdenticalTo(const Instruction *I) const
Return true if the specified instruction is exactly identical to the current one.
Definition: Instruction.cpp:468
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::Instruction::moveAfter
void moveAfter(Instruction *MovePos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
Definition: Instruction.cpp:100
llvm::Instruction::isFenceLike
bool isFenceLike() const
Return true if this instruction behaves like a memory fence: it can load or store to memory location ...
Definition: Instruction.h:605
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::Instruction::hasAtomicStore
bool hasAtomicStore() const
Return true if this atomic instruction stores to memory.
Definition: Instruction.cpp:609
llvm::ilist_alloc_traits
Use delete by default for iplist and ilist.
Definition: ilist.h:40
ArrayRef.h
llvm::Instruction::updateLocationAfterHoist
void updateLocationAfterHoist()
Updates the debug location given that the instruction has been hoisted from a block to a predecessor ...
Definition: DebugInfo.cpp:695
llvm::Instruction::setDebugLoc
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:362
llvm::Instruction::isIdempotent
bool isIdempotent() const
Return true if the instruction is idempotent:
Definition: Instruction.h:560
llvm::Instruction::dropLocation
void dropLocation()
Drop the instruction's debug location.
Definition: DebugInfo.cpp:697
llvm::Instruction::mayHaveSideEffects
bool mayHaveSideEffects() const
Return true if the instruction may have side effects.
Definition: Instruction.h:626
llvm::Instruction::hasMetadata
bool hasMetadata() const
Return true if this instruction has any metadata attached to it.
Definition: Instruction.h:259
llvm::Instruction::isFast
bool isFast() const
Determine whether all fast-math-flags are set.
Definition: Instruction.cpp:218
llvm::ISD::BasicBlock
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:64
llvm::Instruction::isBinaryOp
bool isBinaryOp() const
Definition: Instruction.h:165
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::MDNode
Metadata node.
Definition: Metadata.h:886
llvm::Instruction::FuncletPadOps
FuncletPadOps
Definition: Instruction.h:782
llvm::Instruction::clone
Instruction * clone() const
Create a copy of 'this' instruction that is identical in all ways except the following:
Definition: Instruction.cpp:781
llvm::ArrayRef< unsigned >
llvm::Instruction::getFastMathFlags
FastMathFlags getFastMathFlags() const
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
Definition: Instruction.cpp:258
None.h
llvm::SymbolTableList
List that automatically updates parent links and symbol tables.
Definition: SymbolTableListTraits.h:60
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm::Instruction::setSuccessor
void setSuccessor(unsigned Idx, BasicBlock *BB)
Update the specified successor to point at the provided block.
Definition: Instruction.cpp:720
llvm::Instruction::getFunction
const Function * getFunction() const
Return the function this instruction belongs to.
Definition: Instruction.cpp:69
llvm::Instruction::isExact
bool isExact() const
Determine whether the exact flag is set.
Definition: Instruction.cpp:164
llvm::RecurKind::Mul
@ Mul
Product of integers.
Module
Machine Check Debug Module
Definition: MachineCheckDebugify.cpp:122
llvm::Instruction::copyFastMathFlags
void copyFastMathFlags(FastMathFlags FMF)
Convenience function for transferring all fast-math flag values to this instruction,...
Definition: Instruction.cpp:213
llvm::Instruction::TermOps
TermOps
Definition: Instruction.h:747
llvm::Instruction::user_back
const Instruction * user_back() const
Definition: Instruction.h:92
Node
Definition: ItaniumDemangle.h:114
llvm::Instruction::mayReadFromMemory
bool mayReadFromMemory() const
Return true if this instruction may read memory.
Definition: Instruction.cpp:542
llvm::Instruction::operator=
Instruction & operator=(const Instruction &)=delete
llvm::Instruction::isBinaryOp
static bool isBinaryOp(unsigned Opcode)
Definition: Instruction.h:186
llvm::Instruction::setFastMathFlags
void setFastMathFlags(FastMathFlags FMF)
Convenience function for setting multiple fast-math flags on this instruction, which must be an opera...
Definition: Instruction.cpp:208
llvm::Instruction::isAtomic
bool isAtomic() const
Return true if this instruction has an AtomicOrdering of unordered or higher.
Definition: Instruction.cpp:582
llvm::Instruction::isFuncletPad
static bool isFuncletPad(unsigned OpCode)
Determine if the OpCode is one of the FuncletPadInst instructions.
Definition: Instruction.h:225
llvm::Instruction::setHasApproxFunc
void setHasApproxFunc(bool B)
Set or clear the approximate-math-functions flag on this instruction, which must be an operator which...
Definition: Instruction.cpp:203
llvm::Instruction::CompareIgnoringAlignment
@ CompareIgnoringAlignment
Check for equivalence ignoring load/store alignment.
Definition: Instruction.h:703
llvm::Instruction::Instruction
Instruction(const Instruction &)=delete
llvm::Instruction::isUsedOutsideOfBlock
bool isUsedOutsideOfBlock(const BasicBlock *BB) const
Return true if there are any uses of this instruction in blocks other than the specified block.
Definition: Instruction.cpp:524
llvm::Instruction::isFuncletPad
bool isFuncletPad() const
Definition: Instruction.h:169
llvm::Instruction::dropUnknownNonDebugMetadata
void dropUnknownNonDebugMetadata(unsigned ID1, unsigned ID2)
Definition: Instruction.h:337
llvm::Value::MaxAlignmentExponent
static const unsigned MaxAlignmentExponent
The maximum alignment for instructions.
Definition: Value.h:772
llvm::Instruction::getModule
Module * getModule()
Definition: Instruction.h:103
Casting.h
llvm::Instruction::setAAMetadata
void setAAMetadata(const AAMDNodes &N)
Sets the metadata on this instruction from the AAMDNodes structure.
Definition: Metadata.cpp:1351
Bitfields.h
llvm::Instruction::isIntDivRem
static bool isIntDivRem(unsigned Opcode)
Definition: Instruction.h:190
llvm::Instruction::isEHPad
bool isEHPad() const
Return true if the instruction is a variety of EH-block.
Definition: Instruction.h:641
llvm::Bitfield::Element
Describes an element of a Bitfield.
Definition: Bitfields.h:223
llvm::Instruction::isUnaryOp
static bool isUnaryOp(unsigned Opcode)
Definition: Instruction.h:183
llvm::Instruction::isBitwiseLogicOp
bool isBitwiseLogicOp() const
Return true if this is and/or/xor.
Definition: Instruction.h:215
llvm::Instruction::hasAllowReassoc
bool hasAllowReassoc() const
Determine whether the allow-reassociation flag is set.
Definition: Instruction.cpp:223
llvm::Instruction::isDebugOrPseudoInst
bool isDebugOrPseudoInst() const
Return true if the instruction is a DbgInfoIntrinsic or PseudoProbeInst.
Definition: Instruction.cpp:654
llvm::Instruction::hasNoNaNs
bool hasNoNaNs() const
Determine whether the no-NaNs flag is set.
Definition: Instruction.cpp:228
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:474
llvm::Instruction::setHasAllowReciprocal
void setHasAllowReciprocal(bool B)
Set or clear the allow-reciprocal flag on this instruction, which must be an operator which supports ...
Definition: Instruction.cpp:193
llvm::Instruction::getMetadata
MDNode * getMetadata(StringRef Kind) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:284
llvm::Instruction::BinaryOps
BinaryOps
Definition: Instruction.h:761
llvm::RecurKind::FAdd
@ FAdd
Sum of floats.
llvm::Instruction::isIdempotent
static bool isIdempotent(unsigned Opcode)
Definition: Instruction.h:561
llvm::Instruction::setHasNoInfs
void setHasNoInfs(bool B)
Set or clear the no-infs flag on this instruction, which must be an operator which supports this flag...
Definition: Instruction.cpp:183
llvm::Instruction::getDebugLoc
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:365
User.h
llvm::ilist_alloc_traits::deleteNode
static void deleteNode(NodeTy *V)
Definition: ilist.h:41
llvm::Instruction::setHasNoSignedZeros
void setHasNoSignedZeros(bool B)
Set or clear the no-signed-zeros flag on this instruction, which must be an operator which supports t...
Definition: Instruction.cpp:188
llvm::Instruction::hasNoSignedWrap
bool hasNoSignedWrap() const
Determine whether the no signed wrap flag is set.
Definition: Instruction.cpp:135
N
#define N
llvm::Instruction::getParent
const BasicBlock * getParent() const
Definition: Instruction.h:94
llvm::Value::deleteValue
void deleteValue()
Delete a pointer to a generic Value.
Definition: Value.cpp:107
llvm::Instruction::CompareUsingScalarTypes
@ CompareUsingScalarTypes
Check for equivalence treating a type and a vector of that type as equivalent.
Definition: Instruction.h:706
llvm::Instruction::isUnaryOp
bool isUnaryOp() const
Definition: Instruction.h:164
llvm::Instruction::swapProfMetadata
void swapProfMetadata()
If the instruction has "branch_weights" MD_prof metadata and the MDNode has three operands (including...
Definition: Instruction.cpp:743
ilist_node.h
llvm::Instruction::copyIRFlags
void copyIRFlags(const Value *V, bool IncludeWrapFlags=true)
Convenience method to copy supported exact, fast-math, and (optionally) wrapping flags from V to this...
Definition: Instruction.cpp:267
llvm::Value::getAllMetadata
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * >> &MDs) const
Appends all metadata attached to this value to MDs, sorting by KindID.
Definition: Metadata.cpp:1204
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:43
llvm::msgpack::Type
Type
MessagePack types as defined in the standard, with the exception of Integer being divided into a sign...
Definition: MsgPackReader.h:49
llvm::Instruction::hasNoInfs
bool hasNoInfs() const
Determine whether the no-infs flag is set.
Definition: Instruction.cpp:233
llvm::Instruction::hasNoSignedZeros
bool hasNoSignedZeros() const
Determine whether the no-signed-zeros flag is set.
Definition: Instruction.cpp:238
llvm::Instruction::getFunction
Function * getFunction()
Definition: Instruction.h:113
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
llvm::Instruction::isSameOperationAs
bool isSameOperationAs(const Instruction *I, unsigned flags=0) const
This function determines if the specified instruction executes the same operation as the current one.
Definition: Instruction.cpp:500
SymbolTableListTraits.h
llvm::tgtok::TrueVal
@ TrueVal
Definition: TGLexer.h:61
Value.h
llvm::Value::hasMetadata
bool hasMetadata() const
Return true if this value has any metadata attached to it.
Definition: Value.h:584
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::Instruction::setHasAllowReassoc
void setHasAllowReassoc(bool B)
Set or clear the reassociation flag on this instruction, which must be an operator which supports thi...
Definition: Instruction.cpp:173
llvm::Instruction::dropPoisonGeneratingFlags
void dropPoisonGeneratingFlags()
Drops flags that may cause this instruction to evaluate to poison despite having non-poison inputs.
Definition: Instruction.cpp:139
llvm::Instruction::isIndirectTerminator
bool isIndirectTerminator() const
Definition: Instruction.h:173
llvm::Instruction::BasicBlock
friend class BasicBlock
Various leaf nodes.
Definition: Instruction.h:798
llvm::RecurKind::Xor
@ Xor
Bitwise or logical XOR of integers.
llvm::Instruction::moveBefore
void moveBefore(Instruction *MovePos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
Definition: Instruction.cpp:96
llvm::Use
A Use represents the edge between a Value definition and its users.
Definition: Use.h:44
llvm::Instruction::hasMetadataOtherThanDebugLoc
bool hasMetadataOtherThanDebugLoc() const
Return true if this instruction has metadata attached to it other than a debug location.
Definition: Instruction.h:263
llvm::Instruction::isCast
static bool isCast(unsigned OpCode)
Determine if the OpCode is one of the CastInst instructions.
Definition: Instruction.h:220