InstrTypes.h File Reference

#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Sequence.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/Twine.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/IR/Attributes.h"
#include "llvm/IR/CallingConv.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/FMF.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/OperandTraits.h"
#include "llvm/IR/User.h"
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <optional>
#include <string>
#include <vector>
#include "llvm/IR/Instruction.def"

Go to the source code of this file.

Classes
class	llvm::UnaryInstruction
struct	llvm::OperandTraits< UnaryInstruction >
class	llvm::UnaryOperator
class	llvm::BinaryOperator
struct	llvm::OperandTraits< BinaryOperator >
class	llvm::PossiblyDisjointInst
	An or instruction, which can be marked as "disjoint", indicating that the inputs don't have a 1 in the same bit position. More...
class	llvm::CastInst
	This is the base class for all instructions that perform data casts. More...
class	llvm::PossiblyNonNegInst
	Instruction that can have a nneg flag (zext/uitofp). More...
class	llvm::CmpInst
	This class is the base class for the comparison instructions. More...
struct	llvm::OperandTraits< CmpInst >
struct	llvm::OperandBundleUse
	A lightweight accessor for an operand bundle meant to be passed around by value. More...
class	llvm::OperandBundleDefT< InputTy >
	A container for an operand bundle being viewed as a set of values rather than a set of uses. More...
class	llvm::CallBase
	Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to calling a function. More...
struct	llvm::CallBase::BundleOpInfo
	Used to keep track of an operand bundle. More...
struct	llvm::OperandTraits< CallBase >
class	llvm::FuncletPadInst
struct	llvm::OperandTraits< FuncletPadInst >

Namespaces
namespace	llvm
	This is an optimization pass for GlobalISel generic memory operations.
namespace	llvm::Intrinsic
	This namespace contains an enum with a value for every intrinsic/builtin function known by LLVM.

Macros
#define	HANDLE_UNARY_INST(N, OPC, CLASS)
	These methods just forward to Create, and are useful when you statically know what type of instruction you're going to create.
#define	HANDLE_UNARY_INST(N, OPC, CLASS)
	These methods just forward to Create, and are useful when you statically know what type of instruction you're going to create.
#define	HANDLE_UNARY_INST(N, OPC, CLASS)
	These methods just forward to Create, and are useful when you statically know what type of instruction you're going to create.
#define	HANDLE_UNARY_INST(N, OPC, CLASS)
	These methods just forward to Create, and are useful when you statically know what type of instruction you're going to create.
#define	HANDLE_BINARY_INST(N, OPC, CLASS)
	These methods just forward to Create, and are useful when you statically know what type of instruction you're going to create.
#define	HANDLE_BINARY_INST(N, OPC, CLASS)
	These methods just forward to Create, and are useful when you statically know what type of instruction you're going to create.
#define	HANDLE_BINARY_INST(N, OPC, CLASS)
	These methods just forward to Create, and are useful when you statically know what type of instruction you're going to create.
#define	HANDLE_BINARY_INST(N, OPC, CLASS)
	These methods just forward to Create, and are useful when you statically know what type of instruction you're going to create.
#define	DEFINE_HELPERS(OPC, NUWNSWEXACT)

Typedefs
using	llvm::ConstOperandBundleDef = OperandBundleDefT< const Value * >

Functions
raw_ostream &	llvm::operator<< (raw_ostream &OS, CmpInst::Predicate Pred)

Macro Definition Documentation

DEFINE_HELPERS

#define DEFINE_HELPERS	(		OPC,
			NUWNSWEXACT
	)

Value:

  static BinaryOperator *Create##NUWNSWEXACT##OPC(Value *V1, Value *V2,        \
                                                  const Twine &Name = "") {    \
    return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name);                \
  }                                                                            \
  static BinaryOperator *Create##NUWNSWEXACT##OPC(                             \
      Value *V1, Value *V2, const Twine &Name, BasicBlock *BB) {               \
    return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, BB);            \
  }                                                                            \
  static BinaryOperator *Create##NUWNSWEXACT##OPC(                             \
      Value *V1, Value *V2, const Twine &Name, Instruction *I) {               \
    return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, I);             \
  }                                                                            \
  static BinaryOperator *Create##NUWNSWEXACT##OPC(                             \
      Value *V1, Value *V2, const Twine &Name, BasicBlock::iterator It) {      \
    return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, It);            \
  }

Definition at line 394 of file InstrTypes.h.

HANDLE_BINARY_INST [1/4]

#define HANDLE_BINARY_INST	(		N,
			OPC,
			CLASS
	)

Value:

  static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
                                     const Twine &Name = "") {\
    return Create(Instruction::OPC, V1, V2, Name);\
  }

These methods just forward to Create, and are useful when you statically know what type of instruction you're going to create.

These helpers just save some typing.

Definition at line 238 of file InstrTypes.h.

HANDLE_BINARY_INST [2/4]

#define HANDLE_BINARY_INST	(		N,
			OPC,
			CLASS
	)

Value:

  static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
                                     const Twine &Name, BasicBlock *BB) {\
    return Create(Instruction::OPC, V1, V2, Name, BB);\
  }

These methods just forward to Create, and are useful when you statically know what type of instruction you're going to create.

These helpers just save some typing.

Definition at line 238 of file InstrTypes.h.

HANDLE_BINARY_INST [3/4]

#define HANDLE_BINARY_INST	(		N,
			OPC,
			CLASS
	)

Value:

  static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
                                     const Twine &Name, Instruction *I) {\
    return Create(Instruction::OPC, V1, V2, Name, I);\
  }

These methods just forward to Create, and are useful when you statically know what type of instruction you're going to create.

These helpers just save some typing.

Definition at line 238 of file InstrTypes.h.

HANDLE_BINARY_INST [4/4]

#define HANDLE_BINARY_INST	(		N,
			OPC,
			CLASS
	)

Value:

  static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
                                     const Twine &Name, BasicBlock::iterator It) {\
    return Create(Instruction::OPC, V1, V2, Name, It);\
  }

These methods just forward to Create, and are useful when you statically know what type of instruction you're going to create.

These helpers just save some typing.

Definition at line 238 of file InstrTypes.h.

HANDLE_UNARY_INST [1/4]

#define HANDLE_UNARY_INST	(		N,
			OPC,
			CLASS
	)

Value:

  static UnaryOperator *Create##OPC(Value *V, const Twine &Name = "") {\
    return Create(Instruction::OPC, V, Name);\
  }

These methods just forward to Create, and are useful when you statically know what type of instruction you're going to create.

These helpers just save some typing.

Definition at line 148 of file InstrTypes.h.

HANDLE_UNARY_INST [2/4]

#define HANDLE_UNARY_INST	(		N,
			OPC,
			CLASS
	)

Value:

  static UnaryOperator *Create##OPC(Value *V, const Twine &Name, \
                                    BasicBlock *BB) {\
    return Create(Instruction::OPC, V, Name, BB);\
  }

These methods just forward to Create, and are useful when you statically know what type of instruction you're going to create.

These helpers just save some typing.

Definition at line 148 of file InstrTypes.h.

HANDLE_UNARY_INST [3/4]

#define HANDLE_UNARY_INST	(		N,
			OPC,
			CLASS
	)

Value:

  static UnaryOperator *Create##OPC(Value *V, const Twine &Name, \
                                    Instruction *I) {\
    return Create(Instruction::OPC, V, Name, I);\
  }

These methods just forward to Create, and are useful when you statically know what type of instruction you're going to create.

These helpers just save some typing.

Definition at line 148 of file InstrTypes.h.

HANDLE_UNARY_INST [4/4]

#define HANDLE_UNARY_INST	(		N,
			OPC,
			CLASS
	)

Value:

  static UnaryOperator *Create##OPC(Value *V, const Twine &Name, \
                                    BasicBlock::iterator It) {\
    return Create(Instruction::OPC, V, Name, It);\
  }

These methods just forward to Create, and are useful when you statically know what type of instruction you're going to create.

These helpers just save some typing.

Definition at line 148 of file InstrTypes.h.