14#ifndef LLVM_LIB_IR_CONSTANTSCONTEXT_H
15#define LLVM_LIB_IR_CONSTANTSCONTEXT_H
39#define DEBUG_TYPE "ir"
53 void *
operator new(
size_t S) {
return User::operator
new(S, 1); }
54 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
62 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
79 void *
operator new(
size_t S) {
return User::operator
new(S, 2); }
80 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
89 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
105 void *
operator new(
size_t S) {
return User::operator
new(S, 3); }
106 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
112 return CE->getOpcode() == Instruction::Select;
115 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
132 void *
operator new(
size_t S) {
return User::operator
new(S, 2); }
133 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
139 return CE->getOpcode() == Instruction::ExtractElement;
142 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
160 void *
operator new(
size_t S) {
return User::operator
new(S, 3); }
161 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
167 return CE->getOpcode() == Instruction::InsertElement;
170 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
185 "Invalid shuffle vector instruction operands!");
196 void *
operator new(
size_t S) {
return User::operator
new(S, 2); }
197 void operator delete(
void *
Ptr) {
return User::operator
delete(
Ptr); }
203 return CE->getOpcode() == Instruction::ShuffleVector;
206 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
222 Type *DestTy,
unsigned Flags) {
225 Result->SubclassOptionalData = Flags;
236 return CE->getOpcode() == Instruction::GetElementPtr;
239 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
257 void *
operator new(
size_t S) {
return User::operator
new(S, 2); }
258 void operator delete(
void *
Ptr) {
return User::operator
delete(
Ptr); }
264 return CE->getOpcode() == Instruction::ICmp ||
265 CE->getOpcode() == Instruction::FCmp;
268 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
349 assert(Storage.
empty() &&
"Expected empty storage");
350 for (
unsigned I = 0,
E =
C->getNumOperands();
I !=
E; ++
I)
360 if (
Operands.size() !=
C->getNumOperands())
414 FTy == Asm->getFunctionType() &&
CanThrow == Asm->canThrow();
434 uint8_t SubclassOptionalData;
441 if (CE->getOpcode() == Instruction::ShuffleVector)
442 return CE->getShuffleMask();
447 if (
auto *GEPCE = dyn_cast<GetElementPtrConstantExpr>(CE))
448 return GEPCE->getSourceElementType();
454 unsigned short SubclassData = 0,
455 unsigned short SubclassOptionalData = 0,
457 Type *ExplicitTy =
nullptr)
458 : Opcode(Opcode), SubclassOptionalData(SubclassOptionalData),
459 SubclassData(SubclassData), Ops(Ops), ShuffleMask(ShuffleMask),
460 ExplicitTy(ExplicitTy) {}
464 SubclassOptionalData(CE->getRawSubclassOptionalData()),
465 SubclassData(CE->isCompare() ? CE->getPredicate() : 0), Ops(
Operands),
466 ShuffleMask(getShuffleMaskIfValid(CE)),
467 ExplicitTy(getSourceElementTypeIfValid(CE)) {}
472 SubclassOptionalData(CE->getRawSubclassOptionalData()),
473 SubclassData(CE->isCompare() ? CE->getPredicate() : 0),
474 ShuffleMask(getShuffleMaskIfValid(CE)),
475 ExplicitTy(getSourceElementTypeIfValid(CE)) {
476 assert(Storage.
empty() &&
"Expected empty storage");
477 for (
unsigned I = 0,
E = CE->getNumOperands();
I !=
E; ++
I)
483 return Opcode ==
X.Opcode && SubclassData ==
X.SubclassData &&
484 SubclassOptionalData ==
X.SubclassOptionalData && Ops ==
X.Ops &&
485 ShuffleMask ==
X.ShuffleMask && ExplicitTy ==
X.ExplicitTy;
489 if (Opcode != CE->getOpcode())
491 if (SubclassOptionalData != CE->getRawSubclassOptionalData())
493 if (Ops.
size() != CE->getNumOperands())
495 if (SubclassData != (CE->isCompare() ? CE->getPredicate() : 0))
497 for (
unsigned I = 0,
E = Ops.
size();
I !=
E; ++
I)
498 if (Ops[
I] != CE->getOperand(
I))
500 if (ShuffleMask != getShuffleMaskIfValid(CE))
502 if (ExplicitTy != getSourceElementTypeIfValid(CE))
509 Opcode, SubclassOptionalData, SubclassData,
521 if ((Opcode >= Instruction::BinaryOpsBegin &&
522 Opcode < Instruction::BinaryOpsEnd))
524 SubclassOptionalData);
526 case Instruction::Select:
528 case Instruction::ExtractElement:
530 case Instruction::InsertElement:
532 case Instruction::ShuffleVector:
534 case Instruction::GetElementPtr:
536 Ty, SubclassOptionalData);
537 case Instruction::ICmp:
540 case Instruction::FCmp:
564 static inline ConstantClass *getEmptyKey() {
565 return ConstantClassInfo::getEmptyKey();
568 static inline ConstantClass *getTombstoneKey() {
569 return ConstantClassInfo::getTombstoneKey();
572 static unsigned getHashValue(
const ConstantClass *CP) {
577 static bool isEqual(
const ConstantClass *
LHS,
const ConstantClass *
RHS) {
581 static unsigned getHashValue(
const LookupKey &Val) {
590 if (
RHS == getEmptyKey() ||
RHS == getTombstoneKey())
592 if (
LHS.first !=
RHS->getType())
619 ConstantClass *Result = V.create(Ty);
621 assert(Result->getType() == Ty &&
"Type specified is not correct!");
622 Map.insert_as(Result, HashKey);
634 ConstantClass *Result =
nullptr;
638 Result = create(Ty, V,
Lookup);
641 assert(Result &&
"Unexpected nullptr");
649 assert(
I != Map.end() &&
"Constant not found in constant table!");
650 assert(*
I == CP &&
"Didn't find correct element?");
656 Constant *To,
unsigned NumUpdated = 0,
657 unsigned OperandNo = ~0u) {
662 auto ItMap = Map.find_as(
Lookup);
663 if (ItMap != Map.end())
669 if (NumUpdated == 1) {
670 assert(OperandNo < CP->getNumOperands() &&
"Invalid index");
671 assert(CP->getOperand(OperandNo) != To &&
"I didn't contain From!");
672 CP->setOperand(OperandNo, To);
674 for (
unsigned I = 0,
E = CP->getNumOperands();
I !=
E; ++
I)
675 if (CP->getOperand(
I) ==
From)
676 CP->setOperand(
I, To);
678 Map.insert_as(CP,
Lookup);
amdgpu AMDGPU Register Bank Select
BlockVerifier::State From
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file defines DenseMapInfo traits for DenseMap.
This file defines the DenseSet and SmallDenseSet classes.
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
mir Rename Register Operands
return ToRemove size() > 0
#define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS)
Macro for generating out-of-class operand accessor definitions.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
static std::optional< unsigned > getOpcode(ArrayRef< VPValue * > Values)
Returns the opcode of Values or ~0 if they do not all agree.
static bool canThrow(const Value *V)
static int Lookup(ArrayRef< TableEntry > Table, unsigned Opcode)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
size - Get the array size.
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.
Class to represent array types.
BinaryConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to impleme...
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
static bool classof(const ConstantExpr *CE)
static bool classof(const Value *V)
BinaryConstantExpr(unsigned Opcode, Constant *C1, Constant *C2, unsigned Flags)
CastConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement...
static bool classof(const Value *V)
static bool classof(const ConstantExpr *CE)
CastConstantExpr(unsigned Opcode, Constant *C, Type *Ty)
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
static bool classof(const Value *V)
CompareConstantExpr(Type *ty, Instruction::OtherOps opc, unsigned short pred, Constant *LHS, Constant *RHS)
static bool classof(const ConstantExpr *CE)
ConstantArray - Constant Array Declarations.
A constant value that is initialized with an expression using other constant values.
static Constant * get(unsigned Opcode, Constant *C1, Constant *C2, unsigned Flags=0, Type *OnlyIfReducedTy=nullptr)
get - Return a binary or shift operator constant expression, folding if possible.
typename ConstantInfo< ConstantClass >::ValType ValType
typename ConstantInfo< ConstantClass >::TypeClass TypeClass
ConstantClass * getOrCreate(TypeClass *Ty, ValType V)
Return the specified constant from the map, creating it if necessary.
std::pair< unsigned, LookupKey > LookupKeyHashed
Key and hash together, so that we compute the hash only once and reuse it.
void remove(ConstantClass *CP)
Remove this constant from the map.
ConstantClass * replaceOperandsInPlace(ArrayRef< Constant * > Operands, ConstantClass *CP, Value *From, Constant *To, unsigned NumUpdated=0, unsigned OperandNo=~0u)
std::pair< TypeClass *, ValType > LookupKey
Constant Vector Declarations.
This is an important base class in LLVM.
Class to represent function types.
GetElementPtrConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to ...
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
static bool classof(const ConstantExpr *CE)
Type * getResultElementType() const
Type * getSourceElementType() const
static bool classof(const Value *V)
static GetElementPtrConstantExpr * Create(Type *SrcElementTy, Constant *C, ArrayRef< Constant * > IdxList, Type *DestTy, unsigned Flags)
InsertElementConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to ...
static bool classof(const ConstantExpr *CE)
InsertElementConstantExpr(Constant *C1, Constant *C2, Constant *C3)
static bool classof(const Value *V)
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
Class to represent pointers.
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
Class to represent scalable SIMD vectors.
SelectConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to impleme...
SelectConstantExpr(Constant *C1, Constant *C2, Constant *C3)
static bool classof(const Value *V)
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
static bool classof(const ConstantExpr *CE)
ShuffleVectorConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to ...
Constant * ShuffleMaskForBitcode
SmallVector< int, 4 > ShuffleMask
static bool classof(const ConstantExpr *CE)
ShuffleVectorConstantExpr(Constant *C1, Constant *C2, ArrayRef< int > Mask)
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
static bool classof(const Value *V)
static bool isValidOperands(const Value *V1, const Value *V2, const Value *Mask)
Return true if a shufflevector instruction can be formed with the specified operands.
static Constant * convertShuffleMaskForBitcode(ArrayRef< int > Mask, Type *ResultTy)
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void assign(size_type NumElts, ValueParamT Elt)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
Class to represent struct types.
The instances of the Type class are immutable: once they are created, they are never changed.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
unsigned char SubclassOptionalData
Hold subclass data that can be dropped.
Base class of all SIMD vector types.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
This is an optimization pass for GlobalISel generic memory operations.
bool isEqual(const GCNRPTracker::LiveRegSet &S1, const GCNRPTracker::LiveRegSet &S2)
void deleteConstant(Constant *C)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
bool operator==(const ConstantClass *C) const
ArrayRef< Constant * > Operands
ConstantAggrKeyType(ArrayRef< Constant * > Operands)
ConstantAggrKeyType(ArrayRef< Constant * > Operands, const ConstantClass *)
typename ConstantInfo< ConstantClass >::TypeClass TypeClass
ConstantClass * create(TypeClass *Ty) const
ConstantAggrKeyType(const ConstantClass *C, SmallVectorImpl< Constant * > &Storage)
bool operator==(const ConstantAggrKeyType &X) const
ConstantExprKeyType(const ConstantExpr *CE, SmallVectorImpl< Constant * > &Storage)
ConstantExprKeyType(unsigned Opcode, ArrayRef< Constant * > Ops, unsigned short SubclassData=0, unsigned short SubclassOptionalData=0, ArrayRef< int > ShuffleMask=std::nullopt, Type *ExplicitTy=nullptr)
ConstantInfo< ConstantExpr >::TypeClass TypeClass
ConstantExpr * create(TypeClass *Ty) const
bool operator==(const ConstantExprKeyType &X) const
bool operator==(const ConstantExpr *CE) const
ConstantExprKeyType(ArrayRef< Constant * > Operands, const ConstantExpr *CE)
An information struct used to provide DenseMap with the various necessary components for a given valu...
FixedNumOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...
bool operator==(const InlineAsmKeyType &X) const
ConstantInfo< InlineAsm >::TypeClass TypeClass
InlineAsm * create(TypeClass *Ty) const
bool operator==(const InlineAsm *Asm) const
InlineAsmKeyType(const InlineAsm *Asm, SmallVectorImpl< Constant * > &)
InlineAsmKeyType(StringRef AsmString, StringRef Constraints, FunctionType *FTy, bool HasSideEffects, bool IsAlignStack, InlineAsm::AsmDialect AsmDialect, bool canThrow)
InlineAsm::AsmDialect AsmDialect
Compile-time customization of User operands.
VariadicOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...