Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/lib/Bitcode/Reader/ValueList.h
Line
Count
Source (jump to first uncovered line)
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
7.79k
                                RefsUpperBound)) {}
58
59
7.78k
  ~BitcodeReaderValueList() {
60
7.78k
    assert(ResolveConstants.empty() && "Constants not resolved?");
61
7.78k
  }
62
63
  // vector compatibility methods
64
41.9M
  unsigned size() const { return ValuePtrs.size(); }
65
188k
  void resize(unsigned N) {
66
188k
    ValuePtrs.resize(N);
67
188k
    FullTypes.resize(N);
68
188k
  }
69
6.72M
  void push_back(Value *V, Type *Ty) {
70
6.72M
    ValuePtrs.emplace_back(V);
71
6.72M
    FullTypes.emplace_back(Ty);
72
6.72M
  }
73
74
0
  void clear() {
75
0
    assert(ResolveConstants.empty() && "Constants not resolved?");
76
0
    ValuePtrs.clear();
77
0
    FullTypes.clear();
78
0
  }
79
80
15.1M
  Value *operator[](unsigned i) const {
81
15.1M
    assert(i < ValuePtrs.size());
82
15.1M
    return ValuePtrs[i];
83
15.1M
  }
84
85
337k
  Value *back() const { return ValuePtrs.back(); }
86
0
  void pop_back() {
87
0
    ValuePtrs.pop_back();
88
0
    FullTypes.pop_back();
89
0
  }
90
0
  bool empty() const { return ValuePtrs.empty(); }
91
92
337k
  void shrinkTo(unsigned N) {
93
337k
    assert(N <= size() && "Invalid shrinkTo request!");
94
337k
    ValuePtrs.resize(N);
95
337k
    FullTypes.resize(N);
96
337k
  }
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