Line data    Source code

       1             : //===-- Bitcode/Reader/ValueList.h - Number values --------------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This class gives values and types Unique ID's.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #ifndef LLVM_LIB_BITCODE_READER_VALUELIST_H
      15             : #define LLVM_LIB_BITCODE_READER_VALUELIST_H
      16             : 
      17             : #include "llvm/IR/ValueHandle.h"
      18             : #include <cassert>
      19             : #include <utility>
      20             : #include <vector>
      21             : 
      22             : namespace llvm {
      23             : 
      24             : class Constant;
      25             : class LLVMContext;
      26             : class Type;
      27             : class Value;
      28             : 
      29             : class BitcodeReaderValueList {
      30             :   std::vector<WeakTrackingVH> ValuePtrs;
      31             : 
      32             :   /// As we resolve forward-referenced constants, we add information about them
      33             :   /// to this vector.  This allows us to resolve them in bulk instead of
      34             :   /// resolving each reference at a time.  See the code in
      35             :   /// ResolveConstantForwardRefs for more information about this.
      36             :   ///
      37             :   /// The key of this vector is the placeholder constant, the value is the slot
      38             :   /// number that holds the resolved value.
      39             :   using ResolveConstantsTy = std::vector<std::pair<Constant *, unsigned>>;
      40             :   ResolveConstantsTy ResolveConstants;
      41             :   LLVMContext &Context;
      42             : 
      43             : public:
      44        6958 :   BitcodeReaderValueList(LLVMContext &C) : Context(C) {}
      45             : 
      46        3551 :   ~BitcodeReaderValueList() {
      47             :     assert(ResolveConstants.empty() && "Constants not resolved?");
      48        3472 :   }
      49             : 
      50             :   // vector compatibility methods
      51     1552346 :   unsigned size() const { return ValuePtrs.size(); }
      52        1164 :   void resize(unsigned N) { ValuePtrs.resize(N); }
      53      225847 :   void push_back(Value *V) { ValuePtrs.emplace_back(V); }
      54             : 
      55             :   void clear() {
      56             :     assert(ResolveConstants.empty() && "Constants not resolved?");
      57             :     ValuePtrs.clear();
      58             :   }
      59             : 
      60             :   Value *operator[](unsigned i) const {
      61             :     assert(i < ValuePtrs.size());
      62       28921 :     return ValuePtrs[i];
      63             :   }
      64             : 
      65             :   Value *back() const { return ValuePtrs.back(); }
      66             :   void pop_back() { ValuePtrs.pop_back(); }
      67             :   bool empty() const { return ValuePtrs.empty(); }
      68             : 
      69             :   void shrinkTo(unsigned N) {
      70             :     assert(N <= size() && "Invalid shrinkTo request!");
      71       13164 :     ValuePtrs.resize(N);
      72             :   }
      73             : 
      74             :   Constant *getConstantFwdRef(unsigned Idx, Type *Ty);
      75             :   Value *getValueFwdRef(unsigned Idx, Type *Ty);
      76             : 
      77             :   void assignValue(Value *V, unsigned Idx);
      78             : 
      79             :   /// Once all constants are read, this method bulk resolves any forward
      80             :   /// references.
      81             :   void resolveConstantForwardRefs();
      82             : };
      83             : 
      84             : } // end namespace llvm
      85             : 
      86             : #endif // LLVM_LIB_BITCODE_READER_VALUELIST_H