lib/Bitcode/Reader/ValueList.h

   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