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