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
21namespace llvm {
22
23class Constant;
24class LLVMContext;
25class Type;
26class Value;
27
28class 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
53public:
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