1 //===-- Bitcode/Reader/ValueList.h - Number values --------------*- 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 class gives values and types Unique ID's. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_LIB_BITCODE_READER_VALUELIST_H 14 #define LLVM_LIB_BITCODE_READER_VALUELIST_H 15 16 #include "llvm/IR/ValueHandle.h" 17 #include <cassert> 18 #include <utility> 19 #include <vector> 20 21 namespace llvm { 22 23 class Constant; 24 class LLVMContext; 25 class Type; 26 class Value; 27 28 class BitcodeReaderValueList { 29 std::vector<WeakTrackingVH> ValuePtrs; 30 31 /// As we resolve forward-referenced constants, we add information about them 32 /// to this vector. This allows us to resolve them in bulk instead of 33 /// resolving each reference at a time. See the code in 34 /// ResolveConstantForwardRefs for more information about this. 35 /// 36 /// The key of this vector is the placeholder constant, the value is the slot 37 /// number that holds the resolved value. 38 using ResolveConstantsTy = std::vector<std::pair<Constant *, unsigned>>; 39 ResolveConstantsTy ResolveConstants; 40 LLVMContext &Context; 41 42 /// Maximum number of valid references. Forward references exceeding the 43 /// maximum must be invalid. 44 unsigned RefsUpperBound; 45 46 public: 47 BitcodeReaderValueList(LLVMContext &C, size_t RefsUpperBound) 48 : Context(C), 49 RefsUpperBound(std::min((size_t)std::numeric_limits<unsigned>::max(), 50 RefsUpperBound)) {} 51 52 ~BitcodeReaderValueList() { 53 assert(ResolveConstants.empty() && "Constants not resolved?"); 54 } 55 56 // vector compatibility methods 57 unsigned size() const { return ValuePtrs.size(); } 58 void resize(unsigned N) { 59 ValuePtrs.resize(N); 60 } 61 void push_back(Value *V) { ValuePtrs.emplace_back(V); } 62 63 void clear() { 64 assert(ResolveConstants.empty() && "Constants not resolved?"); 65 ValuePtrs.clear(); 66 } 67 68 Value *operator[](unsigned i) const { 69 assert(i < ValuePtrs.size()); 70 return ValuePtrs[i]; 71 } 72 73 Value *back() const { return ValuePtrs.back(); } 74 void pop_back() { 75 ValuePtrs.pop_back(); 76 } 77 bool empty() const { return ValuePtrs.empty(); } 78 79 void shrinkTo(unsigned N) { 80 assert(N <= size() && "Invalid shrinkTo request!"); 81 ValuePtrs.resize(N); 82 } 83 84 Constant *getConstantFwdRef(unsigned Idx, Type *Ty); 85 Value *getValueFwdRef(unsigned Idx, Type *Ty); 86 87 void assignValue(Value *V, unsigned Idx); 88 89 /// Once all constants are read, this method bulk resolves any forward 90 /// references. 91 void resolveConstantForwardRefs(); 92 }; 93 94 } // end namespace llvm 95 96 #endif // LLVM_LIB_BITCODE_READER_VALUELIST_H 97