14#ifndef LLVM_LIB_IR_CONSTANTSCONTEXT_H
15#define LLVM_LIB_IR_CONSTANTSCONTEXT_H
40#define DEBUG_TYPE "ir"
54 void *
operator new(
size_t S) {
return User::operator
new(S, 1); }
55 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
63 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
80 void *
operator new(
size_t S) {
return User::operator
new(S, 2); }
81 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
90 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
107 void *
operator new(
size_t S) {
return User::operator
new(S, 2); }
108 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
114 return CE->getOpcode() == Instruction::ExtractElement;
117 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
135 void *
operator new(
size_t S) {
return User::operator
new(S, 3); }
136 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
142 return CE->getOpcode() == Instruction::InsertElement;
145 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
160 "Invalid shuffle vector instruction operands!");
171 void *
operator new(
size_t S) {
return User::operator
new(S, 2); }
172 void operator delete(
void *
Ptr) {
return User::operator
delete(
Ptr); }
178 return CE->getOpcode() == Instruction::ShuffleVector;
181 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
190 std::optional<ConstantRange> InRange;
194 std::optional<ConstantRange> InRange);
199 Type *DestTy,
unsigned Flags, std::optional<ConstantRange> InRange) {
203 Result->SubclassOptionalData = Flags;
209 std::optional<ConstantRange>
getInRange()
const;
215 return CE->getOpcode() == Instruction::GetElementPtr;
218 return isa<ConstantExpr>(V) &&
classof(cast<ConstantExpr>(V));
294 assert(Storage.
empty() &&
"Expected empty storage");
295 for (
unsigned I = 0,
E =
C->getNumOperands();
I !=
E; ++
I)
305 if (
Operands.size() !=
C->getNumOperands())
359 FTy == Asm->getFunctionType() &&
CanThrow == Asm->canThrow();
379 uint8_t SubclassOptionalData;
383 std::optional<ConstantRange> InRange;
386 if (CE->getOpcode() == Instruction::ShuffleVector)
387 return CE->getShuffleMask();
392 if (
auto *GEPCE = dyn_cast<GetElementPtrConstantExpr>(CE))
393 return GEPCE->getSourceElementType();
397 static std::optional<ConstantRange>
399 if (
auto *GEPCE = dyn_cast<GetElementPtrConstantExpr>(CE))
400 return GEPCE->getInRange();
406 unsigned short SubclassOptionalData = 0,
408 Type *ExplicitTy =
nullptr,
409 std::optional<ConstantRange> InRange = std::nullopt)
410 : Opcode(Opcode), SubclassOptionalData(SubclassOptionalData), Ops(Ops),
411 ShuffleMask(ShuffleMask), ExplicitTy(ExplicitTy),
416 SubclassOptionalData(CE->getRawSubclassOptionalData()), Ops(
Operands),
417 ShuffleMask(getShuffleMaskIfValid(CE)),
418 ExplicitTy(getSourceElementTypeIfValid(CE)),
419 InRange(getInRangeIfValid(CE)) {}
424 SubclassOptionalData(CE->getRawSubclassOptionalData()),
425 ShuffleMask(getShuffleMaskIfValid(CE)),
426 ExplicitTy(getSourceElementTypeIfValid(CE)),
427 InRange(getInRangeIfValid(CE)) {
428 assert(Storage.
empty() &&
"Expected empty storage");
429 for (
unsigned I = 0,
E = CE->getNumOperands();
I !=
E; ++
I)
435 const std::optional<ConstantRange> &
B) {
436 if (!
A.has_value() || !
B.has_value())
437 return A.has_value() ==
B.has_value();
438 return A->getBitWidth() ==
B->getBitWidth() &&
A ==
B;
442 return Opcode ==
X.Opcode &&
443 SubclassOptionalData ==
X.SubclassOptionalData && Ops ==
X.Ops &&
444 ShuffleMask ==
X.ShuffleMask && ExplicitTy ==
X.ExplicitTy &&
449 if (Opcode != CE->getOpcode())
451 if (SubclassOptionalData != CE->getRawSubclassOptionalData())
453 if (Ops.
size() != CE->getNumOperands())
455 for (
unsigned I = 0,
E = Ops.
size();
I !=
E; ++
I)
456 if (Ops[
I] != CE->getOperand(
I))
458 if (ShuffleMask != getShuffleMaskIfValid(CE))
460 if (ExplicitTy != getSourceElementTypeIfValid(CE))
469 Opcode, SubclassOptionalData,
481 if ((Opcode >= Instruction::BinaryOpsBegin &&
482 Opcode < Instruction::BinaryOpsEnd))
484 SubclassOptionalData);
486 case Instruction::ExtractElement:
488 case Instruction::InsertElement:
490 case Instruction::ShuffleVector:
492 case Instruction::GetElementPtr:
494 ExplicitTy, Ops[0], Ops.
slice(1), Ty, SubclassOptionalData, InRange);
509 assert(Storage.
empty() &&
"Expected empty storage");
510 for (
unsigned I = 0,
E =
C->getNumOperands();
I !=
E; ++
I)
511 Storage.
push_back(cast<Constant>(
C->getOperand(
I)));
520 if (
Operands.size() !=
C->getNumOperands())
557 static inline ConstantClass *getEmptyKey() {
558 return ConstantClassInfo::getEmptyKey();
561 static inline ConstantClass *getTombstoneKey() {
562 return ConstantClassInfo::getTombstoneKey();
565 static unsigned getHashValue(
const ConstantClass *CP) {
570 static bool isEqual(
const ConstantClass *
LHS,
const ConstantClass *
RHS) {
574 static unsigned getHashValue(
const LookupKey &Val) {
583 if (
RHS == getEmptyKey() ||
RHS == getTombstoneKey())
585 if (
LHS.first !=
RHS->getType())
612 ConstantClass *Result = V.create(Ty);
614 assert(Result->getType() == Ty &&
"Type specified is not correct!");
615 Map.insert_as(Result, HashKey);
627 ConstantClass *Result =
nullptr;
631 Result = create(Ty, V,
Lookup);
634 assert(Result &&
"Unexpected nullptr");
642 assert(
I != Map.end() &&
"Constant not found in constant table!");
643 assert(*
I == CP &&
"Didn't find correct element?");
649 Constant *To,
unsigned NumUpdated = 0,
650 unsigned OperandNo = ~0u) {
655 auto ItMap = Map.find_as(
Lookup);
656 if (ItMap != Map.end())
662 if (NumUpdated == 1) {
663 assert(OperandNo < CP->getNumOperands() &&
"Invalid index");
664 assert(CP->getOperand(OperandNo) != To &&
"I didn't contain From!");
665 CP->setOperand(OperandNo, To);
667 for (
unsigned I = 0,
E = CP->getNumOperands();
I !=
E; ++
I)
668 if (CP->getOperand(
I) ==
From)
669 CP->setOperand(
I, To);
671 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 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...
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
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.
Implement std::hash so that hash_code can be used in STL containers.
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)
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
ConstantExprKeyType(unsigned Opcode, ArrayRef< Constant * > Ops, unsigned short SubclassOptionalData=0, ArrayRef< int > ShuffleMask=std::nullopt, Type *ExplicitTy=nullptr, std::optional< ConstantRange > InRange=std::nullopt)
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.
VariadicOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...