14#ifndef LLVM_LIB_IR_CONSTANTSCONTEXT_H
15#define LLVM_LIB_IR_CONSTANTSCONTEXT_H
40#define DEBUG_TYPE "ir"
56 void *
operator new(
size_t S) {
return User::operator
new(S, AllocMarker); }
57 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
65 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
84 void *
operator new(
size_t S) {
return User::operator
new(S, AllocMarker); }
85 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
94 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
113 void *
operator new(
size_t S) {
return User::operator
new(S, AllocMarker); }
114 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
120 return CE->getOpcode() == Instruction::ExtractElement;
123 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
142 void *
operator new(
size_t S) {
return User::operator
new(S, AllocMarker); }
143 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
149 return CE->getOpcode() == Instruction::InsertElement;
152 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
169 "Invalid shuffle vector instruction operands!");
180 void *
operator new(
size_t S) {
return User::operator
new(S, AllocMarker); }
181 void operator delete(
void *
Ptr) {
return User::operator
delete(
Ptr); }
187 return CE->getOpcode() == Instruction::ShuffleVector;
190 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
199 std::optional<ConstantRange> InRange;
203 std::optional<ConstantRange> InRange,
209 Type *DestTy,
unsigned Flags, std::optional<ConstantRange> InRange) {
213 std::move(InRange), AllocMarker);
214 Result->SubclassOptionalData = Flags;
220 std::optional<ConstantRange>
getInRange()
const;
226 return CE->getOpcode() == Instruction::GetElementPtr;
229 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
305 assert(Storage.
empty() &&
"Expected empty storage");
306 Storage.
reserve(
C->getNumOperands());
307 for (
unsigned I = 0,
E =
C->getNumOperands();
I !=
E; ++
I)
317 if (
Operands.size() !=
C->getNumOperands())
333 return new (AllocMarker) ConstantClass(Ty,
Operands, AllocMarker);
372 FTy == Asm->getFunctionType() &&
CanThrow == Asm->canThrow();
396 std::optional<ConstantRange> InRange;
399 if (CE->getOpcode() == Instruction::ShuffleVector)
400 return CE->getShuffleMask();
405 if (
auto *GEPCE = dyn_cast<GetElementPtrConstantExpr>(CE))
406 return GEPCE->getSourceElementType();
410 static std::optional<ConstantRange>
412 if (
auto *GEPCE = dyn_cast<GetElementPtrConstantExpr>(CE))
413 return GEPCE->getInRange();
419 unsigned short SubclassOptionalData = 0,
421 Type *ExplicitTy =
nullptr,
422 std::optional<ConstantRange> InRange = std::nullopt)
423 : Opcode(Opcode), SubclassOptionalData(SubclassOptionalData), Ops(Ops),
424 ShuffleMask(ShuffleMask), ExplicitTy(ExplicitTy),
425 InRange(std::move(InRange)) {}
429 SubclassOptionalData(CE->getRawSubclassOptionalData()), Ops(
Operands),
430 ShuffleMask(getShuffleMaskIfValid(CE)),
431 ExplicitTy(getSourceElementTypeIfValid(CE)),
432 InRange(getInRangeIfValid(CE)) {}
437 SubclassOptionalData(CE->getRawSubclassOptionalData()),
438 ShuffleMask(getShuffleMaskIfValid(CE)),
439 ExplicitTy(getSourceElementTypeIfValid(CE)),
440 InRange(getInRangeIfValid(CE)) {
441 assert(Storage.
empty() &&
"Expected empty storage");
442 for (
unsigned I = 0,
E = CE->getNumOperands();
I !=
E; ++
I)
448 const std::optional<ConstantRange> &
B) {
449 if (!
A.has_value() || !
B.has_value())
450 return A.has_value() ==
B.has_value();
451 return A->getBitWidth() ==
B->getBitWidth() &&
A ==
B;
455 return Opcode ==
X.Opcode &&
456 SubclassOptionalData ==
X.SubclassOptionalData && Ops ==
X.Ops &&
457 ShuffleMask ==
X.ShuffleMask && ExplicitTy ==
X.ExplicitTy &&
462 if (Opcode != CE->getOpcode())
464 if (SubclassOptionalData != CE->getRawSubclassOptionalData())
466 if (Ops.
size() != CE->getNumOperands())
468 for (
unsigned I = 0,
E = Ops.
size();
I !=
E; ++
I)
469 if (Ops[
I] != CE->getOperand(
I))
471 if (ShuffleMask != getShuffleMaskIfValid(CE))
473 if (ExplicitTy != getSourceElementTypeIfValid(CE))
482 Opcode, SubclassOptionalData,
496 SubclassOptionalData);
498 case Instruction::ExtractElement:
500 case Instruction::InsertElement:
502 case Instruction::ShuffleVector:
504 case Instruction::GetElementPtr:
506 ExplicitTy, Ops[0], Ops.
slice(1), Ty, SubclassOptionalData, InRange);
521 assert(Storage.
empty() &&
"Expected empty storage");
522 for (
unsigned I = 0,
E =
C->getNumOperands();
I !=
E; ++
I)
523 Storage.
push_back(cast<Constant>(
C->getOperand(
I)));
532 if (
Operands.size() !=
C->getNumOperands())
569 static inline ConstantClass *getEmptyKey() {
570 return ConstantClassInfo::getEmptyKey();
573 static inline ConstantClass *getTombstoneKey() {
574 return ConstantClassInfo::getTombstoneKey();
577 static unsigned getHashValue(
const ConstantClass *CP) {
582 static bool isEqual(
const ConstantClass *
LHS,
const ConstantClass *
RHS) {
586 static unsigned getHashValue(
const LookupKey &Val) {
595 if (
RHS == getEmptyKey() ||
RHS == getTombstoneKey())
597 if (
LHS.first !=
RHS->getType())
624 ConstantClass *Result = V.create(Ty);
626 assert(Result->getType() == Ty &&
"Type specified is not correct!");
627 Map.insert_as(Result, HashKey);
639 ConstantClass *Result =
nullptr;
643 Result = create(Ty, V,
Lookup);
646 assert(Result &&
"Unexpected nullptr");
654 assert(
I != Map.end() &&
"Constant not found in constant table!");
655 assert(*
I == CP &&
"Didn't find correct element?");
661 Constant *To,
unsigned NumUpdated = 0,
662 unsigned OperandNo = ~0u) {
667 auto ItMap = Map.find_as(
Lookup);
668 if (ItMap != Map.end())
674 if (NumUpdated == 1) {
675 assert(OperandNo < CP->getNumOperands() &&
"Invalid index");
676 assert(CP->getOperand(OperandNo) != To &&
"I didn't contain From!");
677 CP->setOperand(OperandNo, To);
679 for (
unsigned I = 0,
E = CP->getNumOperands();
I !=
E; ++
I)
680 if (CP->getOperand(
I) ==
From)
681 CP->setOperand(
I, To);
683 Map.insert_as(CP,
Lookup);
BlockVerifier::State From
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
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
#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)
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.
A signed pointer, in the ptrauth sense.
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.
This class represents an Operation in the Expression.
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.
std::optional< ConstantRange > getInRange() const
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, std::optional< ConstantRange > InRange)
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.
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 reserve(size_type N)
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)
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
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(unsigned Opcode, ArrayRef< Constant * > Ops, unsigned short SubclassOptionalData=0, ArrayRef< int > ShuffleMask={}, Type *ExplicitTy=nullptr, std::optional< ConstantRange > InRange=std::nullopt)
ConstantExprKeyType(const ConstantExpr *CE, SmallVectorImpl< Constant * > &Storage)
ConstantInfo< ConstantExpr >::TypeClass TypeClass
static bool rangesEqual(const std::optional< ConstantRange > &A, const std::optional< ConstantRange > &B)
ConstantExpr * create(TypeClass *Ty) const
bool operator==(const ConstantExprKeyType &X) const
bool operator==(const ConstantExpr *CE) const
ConstantExprKeyType(ArrayRef< Constant * > Operands, const ConstantExpr *CE)
bool operator==(const ConstantPtrAuthKeyType &X) const
ArrayRef< Constant * > Operands
ConstantPtrAuthKeyType(ArrayRef< Constant * > Operands, const ConstantPtrAuth *)
ConstantPtrAuthKeyType(const ConstantPtrAuth *C, SmallVectorImpl< Constant * > &Storage)
ConstantPtrAuthKeyType(ArrayRef< Constant * > Operands)
bool operator==(const ConstantPtrAuth *C) const
ConstantPtrAuth * create(TypeClass *Ty) const
typename ConstantInfo< ConstantPtrAuth >::TypeClass TypeClass
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.
Information about how a User object was allocated, to be passed into the User constructor.
Indicates this User has operands co-allocated.
VariadicOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...