path: root/contrib/libs/llvm12/lib/DebugInfo/PDB/Native/DbiModuleList.cpp

//===- DbiModuleList.cpp - PDB module information list --------------------===// 
// 
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
// See https://llvm.org/LICENSE.txt for license information. 
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
// 
//===----------------------------------------------------------------------===// 
 
#include "llvm/DebugInfo/PDB/Native/DbiModuleList.h" 
#include "llvm/ADT/StringRef.h" 
#include "llvm/ADT/iterator_range.h" 
#include "llvm/DebugInfo/PDB/Native/RawError.h" 
#include "llvm/Support/BinaryStreamReader.h" 
#include "llvm/Support/Error.h" 
#include <algorithm> 
#include <cassert> 
#include <cstddef> 
#include <cstdint> 
 
using namespace llvm; 
using namespace llvm::pdb; 
 
DbiModuleSourceFilesIterator::DbiModuleSourceFilesIterator( 
    const DbiModuleList &Modules, uint32_t Modi, uint16_t Filei) 
    : Modules(&Modules), Modi(Modi), Filei(Filei) { 
  setValue(); 
} 
 
bool DbiModuleSourceFilesIterator:: 
operator==(const DbiModuleSourceFilesIterator &R) const { 
  // incompatible iterators are never equal 
  if (!isCompatible(R)) 
    return false; 
 
  // If they're compatible, and they're both ends, then they're equal. 
  if (isEnd() && R.isEnd()) 
    return true; 
 
  // If one is an end and the other is not, they're not equal. 
  if (isEnd() != R.isEnd()) 
    return false; 
 
  // Now we know: 
  // - They're compatible 
  // - They're not *both* end iterators 
  // - Their endness is the same. 
  // Thus, they're compatible iterators pointing to a valid file on the same 
  // module.  All we need to check are the file indices. 
  assert(Modules == R.Modules); 
  assert(Modi == R.Modi); 
  assert(!isEnd()); 
  assert(!R.isEnd()); 
 
  return (Filei == R.Filei); 
} 
 
bool DbiModuleSourceFilesIterator:: 
operator<(const DbiModuleSourceFilesIterator &R) const { 
  assert(isCompatible(R)); 
 
  // It's not sufficient to compare the file indices, because default 
  // constructed iterators could be equal to iterators with valid indices.  To 
  // account for this, early-out if they're equal. 
  if (*this == R) 
    return false; 
 
  return Filei < R.Filei; 
} 
 
std::ptrdiff_t DbiModuleSourceFilesIterator:: 
operator-(const DbiModuleSourceFilesIterator &R) const { 
  assert(isCompatible(R)); 
  assert(!(*this < R)); 
 
  // If they're both end iterators, the distance is 0. 
  if (isEnd() && R.isEnd()) 
    return 0; 
 
  assert(!R.isEnd()); 
 
  // At this point, R cannot be end, but *this can, which means that *this 
  // might be a universal end iterator with none of its fields set.  So in that 
  // case have to rely on R as the authority to figure out how many files there 
  // are to compute the distance. 
  uint32_t Thisi = Filei; 
  if (isEnd()) { 
    uint32_t RealModi = R.Modi; 
    Thisi = R.Modules->getSourceFileCount(RealModi); 
  } 
 
  assert(Thisi >= R.Filei); 
  return Thisi - R.Filei; 
} 
 
DbiModuleSourceFilesIterator &DbiModuleSourceFilesIterator:: 
operator+=(std::ptrdiff_t N) { 
  assert(!isEnd()); 
 
  Filei += N; 
  assert(Filei <= Modules->getSourceFileCount(Modi)); 
  setValue(); 
  return *this; 
} 
 
DbiModuleSourceFilesIterator &DbiModuleSourceFilesIterator:: 
operator-=(std::ptrdiff_t N) { 
  // Note that we can subtract from an end iterator, but not a universal end 
  // iterator. 
  assert(!isUniversalEnd()); 
 
  assert(N <= Filei); 
 
  Filei -= N; 
  return *this; 
} 
 
void DbiModuleSourceFilesIterator::setValue() { 
  if (isEnd()) { 
    ThisValue = ""; 
    return; 
  } 
 
  uint32_t Off = Modules->ModuleInitialFileIndex[Modi] + Filei; 
  auto ExpectedValue = Modules->getFileName(Off); 
  if (!ExpectedValue) { 
    consumeError(ExpectedValue.takeError()); 
    Filei = Modules->getSourceFileCount(Modi); 
  } else 
    ThisValue = *ExpectedValue; 
} 
 
bool DbiModuleSourceFilesIterator::isEnd() const { 
  if (isUniversalEnd()) 
    return true; 
 
  assert(Modules); 
  assert(Modi <= Modules->getModuleCount()); 
  assert(Filei <= Modules->getSourceFileCount(Modi)); 
 
  if (Modi == Modules->getModuleCount()) 
    return true; 
  if (Filei == Modules->getSourceFileCount(Modi)) 
    return true; 
  return false; 
} 
 
bool DbiModuleSourceFilesIterator::isUniversalEnd() const { return !Modules; } 
 
bool DbiModuleSourceFilesIterator::isCompatible( 
    const DbiModuleSourceFilesIterator &R) const { 
  // Universal iterators are compatible with any other iterator. 
  if (isUniversalEnd() || R.isUniversalEnd()) 
    return true; 
 
  // At this point, neither iterator is a universal end iterator, although one 
  // or both might be non-universal end iterators.  Regardless, the module index 
  // is valid, so they are compatible if and only if they refer to the same 
  // module. 
  return Modi == R.Modi; 
} 
 
Error DbiModuleList::initialize(BinaryStreamRef ModInfo, 
                                BinaryStreamRef FileInfo) { 
  if (auto EC = initializeModInfo(ModInfo)) 
    return EC; 
  if (auto EC = initializeFileInfo(FileInfo)) 
    return EC; 
 
  return Error::success(); 
} 
 
Error DbiModuleList::initializeModInfo(BinaryStreamRef ModInfo) { 
  ModInfoSubstream = ModInfo; 
 
  if (ModInfo.getLength() == 0) 
    return Error::success(); 
 
  BinaryStreamReader Reader(ModInfo); 
 
  if (auto EC = Reader.readArray(Descriptors, ModInfo.getLength())) 
    return EC; 
 
  return Error::success(); 
} 
 
Error DbiModuleList::initializeFileInfo(BinaryStreamRef FileInfo) { 
  FileInfoSubstream = FileInfo; 
 
  if (FileInfo.getLength() == 0) 
    return Error::success(); 
 
  BinaryStreamReader FISR(FileInfo); 
  if (auto EC = FISR.readObject(FileInfoHeader)) 
    return EC; 
 
  // First is an array of `NumModules` module indices.  This does not seem to be 
  // used for anything meaningful, so we ignore it. 
  FixedStreamArray<support::ulittle16_t> ModuleIndices; 
  if (auto EC = FISR.readArray(ModuleIndices, FileInfoHeader->NumModules)) 
    return EC; 
  if (auto EC = FISR.readArray(ModFileCountArray, FileInfoHeader->NumModules)) 
    return EC; 
 
  // Compute the real number of source files.  We can't trust the value in 
  // `FileInfoHeader->NumSourceFiles` because it is a unit16, and the sum of all 
  // source file counts might be larger than a unit16.  So we compute the real 
  // count by summing up the individual counts. 
  uint32_t NumSourceFiles = 0; 
  for (auto Count : ModFileCountArray) 
    NumSourceFiles += Count; 
 
  // In the reference implementation, this array is where the pointer documented 
  // at the definition of ModuleInfoHeader::FileNameOffs points to.  Note that 
  // although the field in ModuleInfoHeader is ignored this array is not, as it 
  // is the authority on where each filename begins in the names buffer. 
  if (auto EC = FISR.readArray(FileNameOffsets, NumSourceFiles)) 
    return EC; 
 
  if (auto EC = FISR.readStreamRef(NamesBuffer)) 
    return EC; 
 
  auto DescriptorIter = Descriptors.begin(); 
  uint32_t NextFileIndex = 0; 
  ModuleInitialFileIndex.resize(FileInfoHeader->NumModules); 
  ModuleDescriptorOffsets.resize(FileInfoHeader->NumModules); 
  for (size_t I = 0; I < FileInfoHeader->NumModules; ++I) { 
    assert(DescriptorIter != Descriptors.end()); 
    ModuleInitialFileIndex[I] = NextFileIndex; 
    ModuleDescriptorOffsets[I] = DescriptorIter.offset(); 
 
    NextFileIndex += ModFileCountArray[I]; 
    ++DescriptorIter; 
  } 
 
  assert(DescriptorIter == Descriptors.end()); 
  assert(NextFileIndex == NumSourceFiles); 
 
  return Error::success(); 
} 
 
uint32_t DbiModuleList::getModuleCount() const { 
  return FileInfoHeader->NumModules; 
} 
 
uint32_t DbiModuleList::getSourceFileCount() const { 
  return FileNameOffsets.size(); 
} 
 
uint16_t DbiModuleList::getSourceFileCount(uint32_t Modi) const { 
  return ModFileCountArray[Modi]; 
} 
 
DbiModuleDescriptor DbiModuleList::getModuleDescriptor(uint32_t Modi) const { 
  assert(Modi < getModuleCount()); 
  uint32_t Offset = ModuleDescriptorOffsets[Modi]; 
  auto Iter = Descriptors.at(Offset); 
  assert(Iter != Descriptors.end()); 
  return *Iter; 
} 
 
iterator_range<DbiModuleSourceFilesIterator> 
DbiModuleList::source_files(uint32_t Modi) const { 
  return make_range<DbiModuleSourceFilesIterator>( 
      DbiModuleSourceFilesIterator(*this, Modi, 0), 
      DbiModuleSourceFilesIterator()); 
} 
 
Expected<StringRef> DbiModuleList::getFileName(uint32_t Index) const { 
  BinaryStreamReader Names(NamesBuffer); 
  if (Index >= getSourceFileCount()) 
    return make_error<RawError>(raw_error_code::index_out_of_bounds); 
 
  uint32_t FileOffset = FileNameOffsets[Index]; 
  Names.setOffset(FileOffset); 
  StringRef Name; 
  if (auto EC = Names.readCString(Name)) 
    return std::move(EC); 
  return Name; 
}