LLVM 20.0.0git
Classes | Namespaces | Macros | Typedefs | Functions
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_ostreamllvm::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); \
}
std::string Name
#define I(x, y, z)
Definition: MD5.cpp:58

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.