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 /// Struct containing fully-specified copies of the type of each 32 /// value. When pointers are opaque, this will be contain non-opaque 33 /// variants so that restructuring instructions can determine their 34 /// type correctly even if being loaded from old bitcode where some 35 /// types are implicit. 36 std::vector<Type *> FullTypes; 37 38 /// As we resolve forward-referenced constants, we add information about them 39 /// to this vector. This allows us to resolve them in bulk instead of 40 /// resolving each reference at a time. See the code in 41 /// ResolveConstantForwardRefs for more information about this. 42 /// 43 /// The key of this vector is the placeholder constant, the value is the slot 44 /// number that holds the resolved value. 45 using ResolveConstantsTy = std::vector<std::pair<Constant *, unsigned>>; 46 ResolveConstantsTy ResolveConstants; 47 LLVMContext &Context; 48 49 /// Maximum number of valid references. Forward references exceeding the 50 /// maximum must be invalid. 51 unsigned RefsUpperBound; 52 53 public: 54 BitcodeReaderValueList(LLVMContext &C, size_t RefsUpperBound) 55 : Context(C), 56 RefsUpperBound(std::min((size_t)std::numeric_limits<unsigned>::max(), 57 RefsUpperBound)) {} 58 59 ~BitcodeReaderValueList() { 60 assert(ResolveConstants.empty() && "Constants not resolved?"); 61 } 62 63 // vector compatibility methods 64 unsigned size() const { return ValuePtrs.size(); } 65 void resize(unsigned N) { 66 ValuePtrs.resize(N); 67 FullTypes.resize(N); 68 } 69 void push_back(Value *V, Type *Ty) { 70 ValuePtrs.emplace_back(V); 71 FullTypes.emplace_back(Ty); 72 } 73 74 void clear() { 75 assert(ResolveConstants.empty() && "Constants not resolved?"); 76 ValuePtrs.clear(); 77 FullTypes.clear(); 78 } 79 80 Value *operator[](unsigned i) const { 81 assert(i < ValuePtrs.size()); 82 return ValuePtrs[i]; 83 } 84 85 Value *back() const { return ValuePtrs.back(); } 86 void pop_back() { 87 ValuePtrs.pop_back(); 88 FullTypes.pop_back(); 89 } 90 bool empty() const { return ValuePtrs.empty(); } 91 92 void shrinkTo(unsigned N) { 93 assert(N <= size() && "Invalid shrinkTo request!"); 94 ValuePtrs.resize(N); 95 FullTypes.resize(N); 96 } 97 98 Constant *getConstantFwdRef(unsigned Idx, Type *Ty); 99 Value *getValueFwdRef(unsigned Idx, Type *Ty, Type **FullTy = nullptr); 100 101 void assignValue(Value *V, unsigned Idx, Type *FullTy); 102 103 /// Once all constants are read, this method bulk resolves any forward 104 /// references. 105 void resolveConstantForwardRefs(); 106 }; 107 108 } // end namespace llvm 109 110 #endif // LLVM_LIB_BITCODE_READER_VALUELIST_H 111