LLVM 20.0.0git
ConstantsContext.h
Go to the documentation of this file.
1//===-- ConstantsContext.h - Constants-related Context Interals -*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines various helper methods and classes used by
10// LLVMContextImpl for creating and managing constants.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIB_IR_CONSTANTSCONTEXT_H
15#define LLVM_LIB_IR_CONSTANTSCONTEXT_H
16
17#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/DenseSet.h"
20#include "llvm/ADT/Hashing.h"
22#include "llvm/ADT/StringRef.h"
23#include "llvm/IR/Constant.h"
24#include "llvm/IR/Constants.h"
27#include "llvm/IR/InlineAsm.h"
28#include "llvm/IR/Instruction.h"
32#include "llvm/Support/Debug.h"
35#include <cassert>
36#include <cstddef>
37#include <cstdint>
38#include <utility>
39
40#define DEBUG_TYPE "ir"
41
42namespace llvm {
43
44/// CastConstantExpr - This class is private to Constants.cpp, and is used
45/// behind the scenes to implement cast constant exprs.
46class CastConstantExpr final : public ConstantExpr {
47 constexpr static IntrusiveOperandsAllocMarker AllocMarker{1};
48
49public:
50 CastConstantExpr(unsigned Opcode, Constant *C, Type *Ty)
51 : ConstantExpr(Ty, Opcode, AllocMarker) {
52 Op<0>() = C;
53 }
54
55 // allocate space for exactly one operand
56 void *operator new(size_t S) { return User::operator new(S, AllocMarker); }
57 void operator delete(void *Ptr) { User::operator delete(Ptr); }
58
60
61 static bool classof(const ConstantExpr *CE) {
62 return Instruction::isCast(CE->getOpcode());
63 }
64 static bool classof(const Value *V) {
65 return isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V));
66 }
67};
68
69/// BinaryConstantExpr - This class is private to Constants.cpp, and is used
70/// behind the scenes to implement binary constant exprs.
71class BinaryConstantExpr final : public ConstantExpr {
72 constexpr static IntrusiveOperandsAllocMarker AllocMarker{2};
73
74public:
75 BinaryConstantExpr(unsigned Opcode, Constant *C1, Constant *C2,
76 unsigned Flags)
77 : ConstantExpr(C1->getType(), Opcode, AllocMarker) {
78 Op<0>() = C1;
79 Op<1>() = C2;
81 }
82
83 // allocate space for exactly two operands
84 void *operator new(size_t S) { return User::operator new(S, AllocMarker); }
85 void operator delete(void *Ptr) { User::operator delete(Ptr); }
86
87 /// Transparently provide more efficient getOperand methods.
89
90 static bool classof(const ConstantExpr *CE) {
91 return Instruction::isBinaryOp(CE->getOpcode());
92 }
93 static bool classof(const Value *V) {
94 return isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V));
95 }
96};
97
98/// ExtractElementConstantExpr - This class is private to
99/// Constants.cpp, and is used behind the scenes to implement
100/// extractelement constant exprs.
102 constexpr static IntrusiveOperandsAllocMarker AllocMarker{2};
103
104public:
106 : ConstantExpr(cast<VectorType>(C1->getType())->getElementType(),
107 Instruction::ExtractElement, AllocMarker) {
108 Op<0>() = C1;
109 Op<1>() = C2;
110 }
111
112 // allocate space for exactly two operands
113 void *operator new(size_t S) { return User::operator new(S, AllocMarker); }
114 void operator delete(void *Ptr) { User::operator delete(Ptr); }
115
116 /// Transparently provide more efficient getOperand methods.
118
119 static bool classof(const ConstantExpr *CE) {
120 return CE->getOpcode() == Instruction::ExtractElement;
121 }
122 static bool classof(const Value *V) {
123 return isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V));
124 }
125};
126
127/// InsertElementConstantExpr - This class is private to
128/// Constants.cpp, and is used behind the scenes to implement
129/// insertelement constant exprs.
131 constexpr static IntrusiveOperandsAllocMarker AllocMarker{3};
132
133public:
135 : ConstantExpr(C1->getType(), Instruction::InsertElement, AllocMarker) {
136 Op<0>() = C1;
137 Op<1>() = C2;
138 Op<2>() = C3;
139 }
140
141 // allocate space for exactly three operands
142 void *operator new(size_t S) { return User::operator new(S, AllocMarker); }
143 void operator delete(void *Ptr) { User::operator delete(Ptr); }
144
145 /// Transparently provide more efficient getOperand methods.
147
148 static bool classof(const ConstantExpr *CE) {
149 return CE->getOpcode() == Instruction::InsertElement;
150 }
151 static bool classof(const Value *V) {
152 return isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V));
153 }
154};
155
156/// ShuffleVectorConstantExpr - This class is private to
157/// Constants.cpp, and is used behind the scenes to implement
158/// shufflevector constant exprs.
160 constexpr static IntrusiveOperandsAllocMarker AllocMarker{2};
161
162public:
165 cast<VectorType>(C1->getType())->getElementType(),
166 Mask.size(), isa<ScalableVectorType>(C1->getType())),
167 Instruction::ShuffleVector, AllocMarker) {
169 "Invalid shuffle vector instruction operands!");
170 Op<0>() = C1;
171 Op<1>() = C2;
172 ShuffleMask.assign(Mask.begin(), Mask.end());
175 }
176
179
180 void *operator new(size_t S) { return User::operator new(S, AllocMarker); }
181 void operator delete(void *Ptr) { return User::operator delete(Ptr); }
182
183 /// Transparently provide more efficient getOperand methods.
185
186 static bool classof(const ConstantExpr *CE) {
187 return CE->getOpcode() == Instruction::ShuffleVector;
188 }
189 static bool classof(const Value *V) {
190 return isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V));
191 }
192};
193
194/// GetElementPtrConstantExpr - This class is private to Constants.cpp, and is
195/// used behind the scenes to implement getelementptr constant exprs.
197 Type *SrcElementTy;
198 Type *ResElementTy;
199 std::optional<ConstantRange> InRange;
200
202 ArrayRef<Constant *> IdxList, Type *DestTy,
203 std::optional<ConstantRange> InRange,
205
206public:
208 Create(Type *SrcElementTy, Constant *C, ArrayRef<Constant *> IdxList,
209 Type *DestTy, unsigned Flags, std::optional<ConstantRange> InRange) {
210 IntrusiveOperandsAllocMarker AllocMarker{unsigned(IdxList.size() + 1)};
211 GetElementPtrConstantExpr *Result = new (AllocMarker)
212 GetElementPtrConstantExpr(SrcElementTy, C, IdxList, DestTy,
213 std::move(InRange), AllocMarker);
214 Result->SubclassOptionalData = Flags;
215 return Result;
216 }
217
218 Type *getSourceElementType() const;
219 Type *getResultElementType() const;
220 std::optional<ConstantRange> getInRange() const;
221
222 /// Transparently provide more efficient getOperand methods.
224
225 static bool classof(const ConstantExpr *CE) {
226 return CE->getOpcode() == Instruction::GetElementPtr;
227 }
228 static bool classof(const Value *V) {
229 return isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V));
230 }
231};
232
233template <>
235 : public FixedNumOperandTraits<CastConstantExpr, 1> {};
237
238template <>
240 : public FixedNumOperandTraits<BinaryConstantExpr, 2> {};
242
243template <>
245 : public FixedNumOperandTraits<ExtractElementConstantExpr, 2> {};
247
248template <>
250 : public FixedNumOperandTraits<InsertElementConstantExpr, 3> {};
252
253template <>
255 : public FixedNumOperandTraits<ShuffleVectorConstantExpr, 2> {};
257
258template <>
260 : public VariadicOperandTraits<GetElementPtrConstantExpr> {};
261
263
264template <class ConstantClass> struct ConstantAggrKeyType;
265struct InlineAsmKeyType;
268
269template <class ConstantClass> struct ConstantInfo;
270template <> struct ConstantInfo<ConstantExpr> {
273};
274template <> struct ConstantInfo<InlineAsm> {
277};
278template <> struct ConstantInfo<ConstantArray> {
281};
282template <> struct ConstantInfo<ConstantStruct> {
285};
286template <> struct ConstantInfo<ConstantVector> {
289};
290template <> struct ConstantInfo<ConstantPtrAuth> {
293};
294
295template <class ConstantClass> struct ConstantAggrKeyType {
297
299
301 : Operands(Operands) {}
302
303 ConstantAggrKeyType(const ConstantClass *C,
305 assert(Storage.empty() && "Expected empty storage");
306 Storage.reserve(C->getNumOperands());
307 for (unsigned I = 0, E = C->getNumOperands(); I != E; ++I)
308 Storage.push_back(C->getOperand(I));
309 Operands = Storage;
310 }
311
312 bool operator==(const ConstantAggrKeyType &X) const {
313 return Operands == X.Operands;
314 }
315
316 bool operator==(const ConstantClass *C) const {
317 if (Operands.size() != C->getNumOperands())
318 return false;
319 for (unsigned I = 0, E = Operands.size(); I != E; ++I)
320 if (Operands[I] != C->getOperand(I))
321 return false;
322 return true;
323 }
324
325 unsigned getHash() const {
326 return hash_combine_range(Operands.begin(), Operands.end());
327 }
328
330
331 ConstantClass *create(TypeClass *Ty) const {
333 return new (AllocMarker) ConstantClass(Ty, Operands, AllocMarker);
334 }
335};
336
345
352
354 : AsmString(Asm->getAsmString()), Constraints(Asm->getConstraintString()),
355 FTy(Asm->getFunctionType()), HasSideEffects(Asm->hasSideEffects()),
356 IsAlignStack(Asm->isAlignStack()), AsmDialect(Asm->getDialect()),
357 CanThrow(Asm->canThrow()) {}
358
359 bool operator==(const InlineAsmKeyType &X) const {
360 return HasSideEffects == X.HasSideEffects &&
361 IsAlignStack == X.IsAlignStack && AsmDialect == X.AsmDialect &&
362 AsmString == X.AsmString && Constraints == X.Constraints &&
363 FTy == X.FTy && CanThrow == X.CanThrow;
364 }
365
366 bool operator==(const InlineAsm *Asm) const {
367 return HasSideEffects == Asm->hasSideEffects() &&
368 IsAlignStack == Asm->isAlignStack() &&
369 AsmDialect == Asm->getDialect() &&
370 AsmString == Asm->getAsmString() &&
371 Constraints == Asm->getConstraintString() &&
372 FTy == Asm->getFunctionType() && CanThrow == Asm->canThrow();
373 }
374
375 unsigned getHash() const {
378 }
379
381
384 return new InlineAsm(FTy, std::string(AsmString), std::string(Constraints),
386 }
387};
388
390private:
391 uint8_t Opcode;
392 uint8_t SubclassOptionalData;
394 ArrayRef<int> ShuffleMask;
395 Type *ExplicitTy;
396 std::optional<ConstantRange> InRange;
397
398 static ArrayRef<int> getShuffleMaskIfValid(const ConstantExpr *CE) {
399 if (CE->getOpcode() == Instruction::ShuffleVector)
400 return CE->getShuffleMask();
401 return {};
402 }
403
404 static Type *getSourceElementTypeIfValid(const ConstantExpr *CE) {
405 if (auto *GEPCE = dyn_cast<GetElementPtrConstantExpr>(CE))
406 return GEPCE->getSourceElementType();
407 return nullptr;
408 }
409
410 static std::optional<ConstantRange>
411 getInRangeIfValid(const ConstantExpr *CE) {
412 if (auto *GEPCE = dyn_cast<GetElementPtrConstantExpr>(CE))
413 return GEPCE->getInRange();
414 return std::nullopt;
415 }
416
417public:
419 unsigned short SubclassOptionalData = 0,
420 ArrayRef<int> ShuffleMask = {},
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)) {}
426
428 : Opcode(CE->getOpcode()),
429 SubclassOptionalData(CE->getRawSubclassOptionalData()), Ops(Operands),
430 ShuffleMask(getShuffleMaskIfValid(CE)),
431 ExplicitTy(getSourceElementTypeIfValid(CE)),
432 InRange(getInRangeIfValid(CE)) {}
433
436 : Opcode(CE->getOpcode()),
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)
443 Storage.push_back(CE->getOperand(I));
444 Ops = Storage;
445 }
446
447 static bool rangesEqual(const std::optional<ConstantRange> &A,
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;
452 }
453
454 bool operator==(const ConstantExprKeyType &X) const {
455 return Opcode == X.Opcode &&
456 SubclassOptionalData == X.SubclassOptionalData && Ops == X.Ops &&
457 ShuffleMask == X.ShuffleMask && ExplicitTy == X.ExplicitTy &&
458 rangesEqual(InRange, X.InRange);
459 }
460
461 bool operator==(const ConstantExpr *CE) const {
462 if (Opcode != CE->getOpcode())
463 return false;
464 if (SubclassOptionalData != CE->getRawSubclassOptionalData())
465 return false;
466 if (Ops.size() != CE->getNumOperands())
467 return false;
468 for (unsigned I = 0, E = Ops.size(); I != E; ++I)
469 if (Ops[I] != CE->getOperand(I))
470 return false;
471 if (ShuffleMask != getShuffleMaskIfValid(CE))
472 return false;
473 if (ExplicitTy != getSourceElementTypeIfValid(CE))
474 return false;
475 if (!rangesEqual(InRange, getInRangeIfValid(CE)))
476 return false;
477 return true;
478 }
479
480 unsigned getHash() const {
481 return hash_combine(
482 Opcode, SubclassOptionalData,
483 hash_combine_range(Ops.begin(), Ops.end()),
484 hash_combine_range(ShuffleMask.begin(), ShuffleMask.end()), ExplicitTy);
485 }
486
488
490 switch (Opcode) {
491 default:
492 if (Instruction::isCast(Opcode))
493 return new CastConstantExpr(Opcode, Ops[0], Ty);
494 if (Instruction::isBinaryOp(Opcode))
495 return new BinaryConstantExpr(Opcode, Ops[0], Ops[1],
496 SubclassOptionalData);
497 llvm_unreachable("Invalid ConstantExpr!");
498 case Instruction::ExtractElement:
499 return new ExtractElementConstantExpr(Ops[0], Ops[1]);
500 case Instruction::InsertElement:
501 return new InsertElementConstantExpr(Ops[0], Ops[1], Ops[2]);
502 case Instruction::ShuffleVector:
503 return new ShuffleVectorConstantExpr(Ops[0], Ops[1], ShuffleMask);
504 case Instruction::GetElementPtr:
506 ExplicitTy, Ops[0], Ops.slice(1), Ty, SubclassOptionalData, InRange);
507 }
508 }
509};
510
513
515
517 : Operands(Operands) {}
518
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)));
524 Operands = Storage;
525 }
526
528 return Operands == X.Operands;
529 }
530
531 bool operator==(const ConstantPtrAuth *C) const {
532 if (Operands.size() != C->getNumOperands())
533 return false;
534 for (unsigned I = 0, E = Operands.size(); I != E; ++I)
535 if (Operands[I] != C->getOperand(I))
536 return false;
537 return true;
538 }
539
540 unsigned getHash() const {
541 return hash_combine_range(Operands.begin(), Operands.end());
542 }
543
545
547 return new ConstantPtrAuth(Operands[0], cast<ConstantInt>(Operands[1]),
548 cast<ConstantInt>(Operands[2]), Operands[3]);
549 }
550};
551
552// Free memory for a given constant. Assumes the constant has already been
553// removed from all relevant maps.
554void deleteConstant(Constant *C);
555
556template <class ConstantClass> class ConstantUniqueMap {
557public:
560 using LookupKey = std::pair<TypeClass *, ValType>;
561
562 /// Key and hash together, so that we compute the hash only once and reuse it.
563 using LookupKeyHashed = std::pair<unsigned, LookupKey>;
564
565private:
566 struct MapInfo {
567 using ConstantClassInfo = DenseMapInfo<ConstantClass *>;
568
569 static inline ConstantClass *getEmptyKey() {
570 return ConstantClassInfo::getEmptyKey();
571 }
572
573 static inline ConstantClass *getTombstoneKey() {
574 return ConstantClassInfo::getTombstoneKey();
575 }
576
577 static unsigned getHashValue(const ConstantClass *CP) {
579 return getHashValue(LookupKey(CP->getType(), ValType(CP, Storage)));
580 }
581
582 static bool isEqual(const ConstantClass *LHS, const ConstantClass *RHS) {
583 return LHS == RHS;
584 }
585
586 static unsigned getHashValue(const LookupKey &Val) {
587 return hash_combine(Val.first, Val.second.getHash());
588 }
589
590 static unsigned getHashValue(const LookupKeyHashed &Val) {
591 return Val.first;
592 }
593
594 static bool isEqual(const LookupKey &LHS, const ConstantClass *RHS) {
595 if (RHS == getEmptyKey() || RHS == getTombstoneKey())
596 return false;
597 if (LHS.first != RHS->getType())
598 return false;
599 return LHS.second == RHS;
600 }
601
602 static bool isEqual(const LookupKeyHashed &LHS, const ConstantClass *RHS) {
603 return isEqual(LHS.second, RHS);
604 }
605 };
606
607public:
609
610private:
611 MapTy Map;
612
613public:
614 typename MapTy::iterator begin() { return Map.begin(); }
615 typename MapTy::iterator end() { return Map.end(); }
616
618 for (auto &I : Map)
620 }
621
622private:
623 ConstantClass *create(TypeClass *Ty, ValType V, LookupKeyHashed &HashKey) {
624 ConstantClass *Result = V.create(Ty);
625
626 assert(Result->getType() == Ty && "Type specified is not correct!");
627 Map.insert_as(Result, HashKey);
628
629 return Result;
630 }
631
632public:
633 /// Return the specified constant from the map, creating it if necessary.
634 ConstantClass *getOrCreate(TypeClass *Ty, ValType V) {
635 LookupKey Key(Ty, V);
636 /// Hash once, and reuse it for the lookup and the insertion if needed.
637 LookupKeyHashed Lookup(MapInfo::getHashValue(Key), Key);
638
639 ConstantClass *Result = nullptr;
640
641 auto I = Map.find_as(Lookup);
642 if (I == Map.end())
643 Result = create(Ty, V, Lookup);
644 else
645 Result = *I;
646 assert(Result && "Unexpected nullptr");
647
648 return Result;
649 }
650
651 /// Remove this constant from the map
652 void remove(ConstantClass *CP) {
653 typename MapTy::iterator I = Map.find(CP);
654 assert(I != Map.end() && "Constant not found in constant table!");
655 assert(*I == CP && "Didn't find correct element?");
656 Map.erase(I);
657 }
658
660 ConstantClass *CP, Value *From,
661 Constant *To, unsigned NumUpdated = 0,
662 unsigned OperandNo = ~0u) {
663 LookupKey Key(CP->getType(), ValType(Operands, CP));
664 /// Hash once, and reuse it for the lookup and the insertion if needed.
665 LookupKeyHashed Lookup(MapInfo::getHashValue(Key), Key);
666
667 auto ItMap = Map.find_as(Lookup);
668 if (ItMap != Map.end())
669 return *ItMap;
670
671 // Update to the new value. Optimize for the case when we have a single
672 // operand that we're changing, but handle bulk updates efficiently.
673 remove(CP);
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);
678 } else {
679 for (unsigned I = 0, E = CP->getNumOperands(); I != E; ++I)
680 if (CP->getOperand(I) == From)
681 CP->setOperand(I, To);
682 }
683 Map.insert_as(CP, Lookup);
684 return nullptr;
685 }
686
687 void dump() const {
688 LLVM_DEBUG(dbgs() << "Constant.cpp: ConstantUniqueMap\n");
689 }
690};
691
693 for (auto &I : Map)
694 delete I;
695}
696
697} // end namespace llvm
698
699#endif // LLVM_LIB_IR_CONSTANTSCONTEXT_H
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...
#define LLVM_DEBUG(...)
Definition: Debug.h:106
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")
#define I(x, y, z)
Definition: MD5.cpp:58
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.
Definition: VPlanSLP.cpp:191
static bool canThrow(const Value *V)
static int Lookup(ArrayRef< TableEntry > Table, unsigned Opcode)
Value * RHS
Value * LHS
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
iterator end() const
Definition: ArrayRef.h:157
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:168
iterator begin() const
Definition: ArrayRef.h:156
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.
Definition: ArrayRef.h:198
Class to represent array types.
Definition: DerivedTypes.h:395
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.
Definition: Constants.h:427
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:1108
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.
Definition: Constants.cpp:2340
A signed pointer, in the ptrauth sense.
Definition: Constants.h:1021
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.
MapTy::iterator begin()
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.
Definition: Constants.h:511
This is an important base class in LLVM.
Definition: Constant.h:42
This class represents an Operation in the Expression.
ExtractElementConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to...
ExtractElementConstantExpr(Constant *C1, Constant *C2)
static bool classof(const ConstantExpr *CE)
static bool classof(const Value *V)
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
Class to represent function types.
Definition: DerivedTypes.h:105
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
Definition: Constants.cpp:2824
static bool classof(const ConstantExpr *CE)
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.
bool isCast() const
Definition: Instruction.h:283
bool isBinaryOp() const
Definition: Instruction.h:279
Class to represent pointers.
Definition: DerivedTypes.h:670
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
Definition: DerivedTypes.h:686
Class to represent scalable SIMD vectors.
Definition: DerivedTypes.h:610
ShuffleVectorConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to ...
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)
bool empty() const
Definition: SmallVector.h:81
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:573
void assign(size_type NumElts, ValueParamT Elt)
Definition: SmallVector.h:704
void reserve(size_type N)
Definition: SmallVector.h:663
void push_back(const T &Elt)
Definition: SmallVector.h:413
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1196
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:51
Class to represent struct types.
Definition: DerivedTypes.h:218
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
LLVM Value Representation.
Definition: Value.h:74
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
unsigned char SubclassOptionalData
Hold subclass data that can be dropped.
Definition: Value.h:84
Base class of all SIMD vector types.
Definition: DerivedTypes.h:427
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
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.
Definition: STLExtras.h:1697
void deleteConstant(Constant *C)
Definition: Constants.cpp:529
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
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...
Definition: Casting.h:548
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
Definition: Casting.h:565
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
Definition: Hashing.h:590
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
Definition: Hashing.h:468
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...
Definition: DenseMapInfo.h:52
FixedNumOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...
Definition: OperandTraits.h:30
unsigned getHash() const
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.
Definition: User.h:42
Information about how a User object was allocated, to be passed into the User constructor.
Definition: User.h:79
Indicates this User has operands co-allocated.
Definition: User.h:60
VariadicOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...
Definition: OperandTraits.h:67