LLVM  10.0.0svn
ValueList.h
Go to the documentation of this file.
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 
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 
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.
106 };
107 
108 } // end namespace llvm
109 
110 #endif // LLVM_LIB_BITCODE_READER_VALUELIST_H
uint64_t CallInst * C
This class represents lattice values for constants.
Definition: AllocatorList.h:23
void shrinkTo(unsigned N)
Definition: ValueList.h:92
Value * operator[](unsigned i) const
Definition: ValueList.h:80
Definition: BitVector.h:937
Value * back() const
Definition: ValueList.h:85
unsigned size() const
Definition: ValueList.h:64
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:64
This is an important base class in LLVM.
Definition: Constant.h:41
void resolveConstantForwardRefs()
Once all constants are read, this method bulk resolves any forward references.
Definition: ValueList.cpp:153
Constant * getConstantFwdRef(unsigned Idx, Type *Ty)
Definition: ValueList.cpp:99
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:390
void assignValue(Value *V, unsigned Idx, Type *FullTy)
Definition: ValueList.cpp:68
Value * getValueFwdRef(unsigned Idx, Type *Ty, Type **FullTy=nullptr)
Definition: ValueList.cpp:119
void resize(unsigned N)
Definition: ValueList.h:65
#define N
BitcodeReaderValueList(LLVMContext &C, size_t RefsUpperBound)
Definition: ValueList.h:54
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:74
void push_back(Value *V, Type *Ty)
Definition: ValueList.h:69