1 //===- ExplainOutputStyle.cpp --------------------------------- *- 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 #include "ExplainOutputStyle.h" 11 12 #include "FormatUtil.h" 13 #include "InputFile.h" 14 #include "StreamUtil.h" 15 #include "llvm-pdbutil.h" 16 17 #include "llvm/DebugInfo/CodeView/Formatters.h" 18 #include "llvm/DebugInfo/MSF/MappedBlockStream.h" 19 #include "llvm/DebugInfo/PDB/Native/DbiStream.h" 20 #include "llvm/DebugInfo/PDB/Native/InfoStream.h" 21 #include "llvm/DebugInfo/PDB/Native/PDBFile.h" 22 #include "llvm/DebugInfo/PDB/Native/RawTypes.h" 23 #include "llvm/Support/BinaryByteStream.h" 24 #include "llvm/Support/BinaryStreamArray.h" 25 #include "llvm/Support/Error.h" 26 27 using namespace llvm; 28 using namespace llvm::codeview; 29 using namespace llvm::msf; 30 using namespace llvm::pdb; 31 32 ExplainOutputStyle::ExplainOutputStyle(InputFile &File, uint64_t FileOffset) 33 : File(File), FileOffset(FileOffset), P(2, false, outs()) {} 34 35 Error ExplainOutputStyle::dump() { 36 P.formatLine("Explaining file offset {0} of file '{1}'.", FileOffset, 37 File.getFilePath()); 38 39 if (File.isPdb()) 40 return explainPdbFile(); 41 42 return explainBinaryFile(); 43 } 44 45 Error ExplainOutputStyle::explainPdbFile() { 46 bool IsAllocated = explainPdbBlockStatus(); 47 if (!IsAllocated) 48 return Error::success(); 49 50 AutoIndent Indent(P); 51 if (isPdbSuperBlock()) 52 explainPdbSuperBlockOffset(); 53 else if (isPdbFpmBlock()) 54 explainPdbFpmBlockOffset(); 55 else if (isPdbBlockMapBlock()) 56 explainPdbBlockMapOffset(); 57 else if (isPdbStreamDirectoryBlock()) 58 explainPdbStreamDirectoryOffset(); 59 else if (auto Index = getPdbBlockStreamIndex()) 60 explainPdbStreamOffset(*Index); 61 else 62 explainPdbUnknownBlock(); 63 return Error::success(); 64 } 65 66 Error ExplainOutputStyle::explainBinaryFile() { 67 std::unique_ptr<BinaryByteStream> Stream = 68 llvm::make_unique<BinaryByteStream>(File.unknown().getBuffer(), 69 llvm::support::little); 70 switch (opts::explain::InputType) { 71 case opts::explain::InputFileType::DBIStream: { 72 DbiStream Dbi(std::move(Stream)); 73 if (auto EC = Dbi.reload(nullptr)) 74 return EC; 75 explainStreamOffset(Dbi, FileOffset); 76 break; 77 } 78 case opts::explain::InputFileType::PDBStream: { 79 InfoStream Info(std::move(Stream)); 80 if (auto EC = Info.reload()) 81 return EC; 82 explainStreamOffset(Info, FileOffset); 83 break; 84 } 85 default: 86 llvm_unreachable("Invalid input file type!"); 87 } 88 return Error::success(); 89 } 90 91 uint32_t ExplainOutputStyle::pdbBlockIndex() const { 92 return FileOffset / File.pdb().getBlockSize(); 93 } 94 95 uint32_t ExplainOutputStyle::pdbBlockOffset() const { 96 uint64_t BlockStart = pdbBlockIndex() * File.pdb().getBlockSize(); 97 assert(FileOffset >= BlockStart); 98 return FileOffset - BlockStart; 99 } 100 101 bool ExplainOutputStyle::isPdbSuperBlock() const { 102 return pdbBlockIndex() == 0; 103 } 104 105 bool ExplainOutputStyle::isPdbFpm1() const { 106 return ((pdbBlockIndex() - 1) % File.pdb().getBlockSize() == 0); 107 } 108 bool ExplainOutputStyle::isPdbFpm2() const { 109 return ((pdbBlockIndex() - 2) % File.pdb().getBlockSize() == 0); 110 } 111 112 bool ExplainOutputStyle::isPdbFpmBlock() const { 113 return isPdbFpm1() || isPdbFpm2(); 114 } 115 116 bool ExplainOutputStyle::isPdbBlockMapBlock() const { 117 return pdbBlockIndex() == File.pdb().getBlockMapIndex(); 118 } 119 120 bool ExplainOutputStyle::isPdbStreamDirectoryBlock() const { 121 const auto &Layout = File.pdb().getMsfLayout(); 122 return llvm::is_contained(Layout.DirectoryBlocks, pdbBlockIndex()); 123 } 124 125 Optional<uint32_t> ExplainOutputStyle::getPdbBlockStreamIndex() const { 126 const auto &Layout = File.pdb().getMsfLayout(); 127 for (const auto &Entry : enumerate(Layout.StreamMap)) { 128 if (!llvm::is_contained(Entry.value(), pdbBlockIndex())) 129 continue; 130 return Entry.index(); 131 } 132 return None; 133 } 134 135 bool ExplainOutputStyle::explainPdbBlockStatus() { 136 if (FileOffset >= File.pdb().getFileSize()) { 137 P.formatLine("Address {0} is not in the file (file size = {1}).", 138 FileOffset, File.pdb().getFileSize()); 139 return false; 140 } 141 P.formatLine("Block:Offset = {2:X-}:{1:X-4}.", FileOffset, pdbBlockOffset(), 142 pdbBlockIndex()); 143 144 bool IsFree = File.pdb().getMsfLayout().FreePageMap[pdbBlockIndex()]; 145 P.formatLine("Address is in block {0} ({1}allocated).", pdbBlockIndex(), 146 IsFree ? "un" : ""); 147 return !IsFree; 148 } 149 150 #define endof(Class, Field) (offsetof(Class, Field) + sizeof(Class::Field)) 151 152 void ExplainOutputStyle::explainPdbSuperBlockOffset() { 153 P.formatLine("This corresponds to offset {0} of the MSF super block, ", 154 pdbBlockOffset()); 155 if (pdbBlockOffset() < endof(SuperBlock, MagicBytes)) 156 P.printLine("which is part of the MSF file magic."); 157 else if (pdbBlockOffset() < endof(SuperBlock, BlockSize)) { 158 P.printLine("which contains the block size of the file."); 159 P.formatLine("The current value is {0}.", 160 uint32_t(File.pdb().getMsfLayout().SB->BlockSize)); 161 } else if (pdbBlockOffset() < endof(SuperBlock, FreeBlockMapBlock)) { 162 P.printLine("which contains the index of the FPM block (e.g. 1 or 2)."); 163 P.formatLine("The current value is {0}.", 164 uint32_t(File.pdb().getMsfLayout().SB->FreeBlockMapBlock)); 165 } else if (pdbBlockOffset() < endof(SuperBlock, NumBlocks)) { 166 P.printLine("which contains the number of blocks in the file."); 167 P.formatLine("The current value is {0}.", 168 uint32_t(File.pdb().getMsfLayout().SB->NumBlocks)); 169 } else if (pdbBlockOffset() < endof(SuperBlock, NumDirectoryBytes)) { 170 P.printLine("which contains the number of bytes in the stream directory."); 171 P.formatLine("The current value is {0}.", 172 uint32_t(File.pdb().getMsfLayout().SB->NumDirectoryBytes)); 173 } else if (pdbBlockOffset() < endof(SuperBlock, Unknown1)) { 174 P.printLine("whose purpose is unknown."); 175 P.formatLine("The current value is {0}.", 176 uint32_t(File.pdb().getMsfLayout().SB->Unknown1)); 177 } else if (pdbBlockOffset() < endof(SuperBlock, BlockMapAddr)) { 178 P.printLine("which contains the file offset of the block map."); 179 P.formatLine("The current value is {0}.", 180 uint32_t(File.pdb().getMsfLayout().SB->BlockMapAddr)); 181 } else { 182 assert(pdbBlockOffset() > sizeof(SuperBlock)); 183 P.printLine( 184 "which is outside the range of valid data for the super block."); 185 } 186 } 187 188 static std::string toBinaryString(uint8_t Byte) { 189 char Result[9] = {0}; 190 for (int I = 0; I < 8; ++I) { 191 char C = (Byte & 1) ? '1' : '0'; 192 Result[I] = C; 193 Byte >>= 1; 194 } 195 return std::string(Result); 196 } 197 198 void ExplainOutputStyle::explainPdbFpmBlockOffset() { 199 const MSFLayout &Layout = File.pdb().getMsfLayout(); 200 uint32_t MainFpm = Layout.mainFpmBlock(); 201 uint32_t AltFpm = Layout.alternateFpmBlock(); 202 203 assert(isPdbFpmBlock()); 204 uint32_t Fpm = isPdbFpm1() ? 1 : 2; 205 uint32_t FpmChunk = pdbBlockIndex() / File.pdb().getBlockSize(); 206 assert((Fpm == MainFpm) || (Fpm == AltFpm)); 207 (void)AltFpm; 208 bool IsMain = (Fpm == MainFpm); 209 P.formatLine("Address is in FPM{0} ({1} FPM)", Fpm, IsMain ? "Main" : "Alt"); 210 uint32_t DescribedBlockStart = 211 8 * (FpmChunk * File.pdb().getBlockSize() + pdbBlockOffset()); 212 if (DescribedBlockStart > File.pdb().getBlockCount()) { 213 P.printLine("Address is in extraneous FPM space."); 214 return; 215 } 216 217 P.formatLine("Address describes the allocation status of blocks [{0},{1})", 218 DescribedBlockStart, DescribedBlockStart + 8); 219 ArrayRef<uint8_t> Bytes; 220 cantFail(File.pdb().getMsfBuffer().readBytes(FileOffset, 1, Bytes)); 221 P.formatLine("Status = {0} (Note: 0 = allocated, 1 = free)", 222 toBinaryString(Bytes[0])); 223 } 224 225 void ExplainOutputStyle::explainPdbBlockMapOffset() { 226 uint64_t BlockMapOffset = File.pdb().getBlockMapOffset(); 227 uint32_t OffsetInBlock = FileOffset - BlockMapOffset; 228 P.formatLine("Address is at offset {0} of the directory block list", 229 OffsetInBlock); 230 } 231 232 static uint32_t getOffsetInStream(ArrayRef<support::ulittle32_t> StreamBlocks, 233 uint64_t FileOffset, uint32_t BlockSize) { 234 uint32_t BlockIndex = FileOffset / BlockSize; 235 uint32_t OffsetInBlock = FileOffset - BlockIndex * BlockSize; 236 237 auto Iter = llvm::find(StreamBlocks, BlockIndex); 238 assert(Iter != StreamBlocks.end()); 239 uint32_t StreamBlockIndex = std::distance(StreamBlocks.begin(), Iter); 240 return StreamBlockIndex * BlockSize + OffsetInBlock; 241 } 242 243 void ExplainOutputStyle::explainPdbStreamOffset(uint32_t Stream) { 244 SmallVector<StreamInfo, 12> Streams; 245 discoverStreamPurposes(File.pdb(), Streams); 246 247 assert(Stream <= Streams.size()); 248 const StreamInfo &S = Streams[Stream]; 249 const auto &Layout = File.pdb().getStreamLayout(Stream); 250 uint32_t StreamOff = 251 getOffsetInStream(Layout.Blocks, FileOffset, File.pdb().getBlockSize()); 252 P.formatLine("Address is at offset {0}/{1} of Stream {2} ({3}){4}.", 253 StreamOff, Layout.Length, Stream, S.getLongName(), 254 (StreamOff > Layout.Length) ? " in unused space" : ""); 255 switch (S.getPurpose()) { 256 case StreamPurpose::DBI: { 257 DbiStream &Dbi = cantFail(File.pdb().getPDBDbiStream()); 258 explainStreamOffset(Dbi, StreamOff); 259 break; 260 } 261 case StreamPurpose::PDB: { 262 InfoStream &Info = cantFail(File.pdb().getPDBInfoStream()); 263 explainStreamOffset(Info, StreamOff); 264 break; 265 } 266 case StreamPurpose::IPI: 267 case StreamPurpose::TPI: 268 case StreamPurpose::ModuleStream: 269 case StreamPurpose::NamedStream: 270 default: 271 break; 272 } 273 } 274 275 void ExplainOutputStyle::explainPdbStreamDirectoryOffset() { 276 auto DirectoryBlocks = File.pdb().getDirectoryBlockArray(); 277 const auto &Layout = File.pdb().getMsfLayout(); 278 uint32_t StreamOff = 279 getOffsetInStream(DirectoryBlocks, FileOffset, File.pdb().getBlockSize()); 280 P.formatLine("Address is at offset {0}/{1} of Stream Directory{2}.", 281 StreamOff, uint32_t(Layout.SB->NumDirectoryBytes), 282 uint32_t(StreamOff > Layout.SB->NumDirectoryBytes) 283 ? " in unused space" 284 : ""); 285 } 286 287 void ExplainOutputStyle::explainPdbUnknownBlock() { 288 P.formatLine("Address has unknown purpose."); 289 } 290 291 template <typename T> 292 static void printStructField(LinePrinter &P, StringRef Label, T Value) { 293 P.formatLine("which contains {0}.", Label); 294 P.formatLine("The current value is {0}.", Value); 295 } 296 297 static void explainDbiHeaderOffset(LinePrinter &P, DbiStream &Dbi, 298 uint32_t Offset) { 299 const DbiStreamHeader *Header = Dbi.getHeader(); 300 assert(Header != nullptr); 301 302 if (Offset < endof(DbiStreamHeader, VersionSignature)) 303 printStructField(P, "the DBI Stream Version Signature", 304 int32_t(Header->VersionSignature)); 305 else if (Offset < endof(DbiStreamHeader, VersionHeader)) 306 printStructField(P, "the DBI Stream Version Header", 307 uint32_t(Header->VersionHeader)); 308 else if (Offset < endof(DbiStreamHeader, Age)) 309 printStructField(P, "the age of the DBI Stream", uint32_t(Header->Age)); 310 else if (Offset < endof(DbiStreamHeader, GlobalSymbolStreamIndex)) 311 printStructField(P, "the index of the Global Symbol Stream", 312 uint16_t(Header->GlobalSymbolStreamIndex)); 313 else if (Offset < endof(DbiStreamHeader, BuildNumber)) 314 printStructField(P, "the build number", uint16_t(Header->BuildNumber)); 315 else if (Offset < endof(DbiStreamHeader, PublicSymbolStreamIndex)) 316 printStructField(P, "the index of the Public Symbol Stream", 317 uint16_t(Header->PublicSymbolStreamIndex)); 318 else if (Offset < endof(DbiStreamHeader, PdbDllVersion)) 319 printStructField(P, "the version of mspdb.dll", 320 uint16_t(Header->PdbDllVersion)); 321 else if (Offset < endof(DbiStreamHeader, SymRecordStreamIndex)) 322 printStructField(P, "the index of the Symbol Record Stream", 323 uint16_t(Header->SymRecordStreamIndex)); 324 else if (Offset < endof(DbiStreamHeader, PdbDllRbld)) 325 printStructField(P, "the rbld of mspdb.dll", uint16_t(Header->PdbDllRbld)); 326 else if (Offset < endof(DbiStreamHeader, ModiSubstreamSize)) 327 printStructField(P, "the size of the Module Info Substream", 328 int32_t(Header->ModiSubstreamSize)); 329 else if (Offset < endof(DbiStreamHeader, SecContrSubstreamSize)) 330 printStructField(P, "the size of the Section Contribution Substream", 331 int32_t(Header->SecContrSubstreamSize)); 332 else if (Offset < endof(DbiStreamHeader, SectionMapSize)) 333 printStructField(P, "the size of the Section Map Substream", 334 int32_t(Header->SectionMapSize)); 335 else if (Offset < endof(DbiStreamHeader, FileInfoSize)) 336 printStructField(P, "the size of the File Info Substream", 337 int32_t(Header->FileInfoSize)); 338 else if (Offset < endof(DbiStreamHeader, TypeServerSize)) 339 printStructField(P, "the size of the Type Server Map", 340 int32_t(Header->TypeServerSize)); 341 else if (Offset < endof(DbiStreamHeader, MFCTypeServerIndex)) 342 printStructField(P, "the index of the MFC Type Server stream", 343 uint32_t(Header->MFCTypeServerIndex)); 344 else if (Offset < endof(DbiStreamHeader, OptionalDbgHdrSize)) 345 printStructField(P, "the size of the Optional Debug Stream array", 346 int32_t(Header->OptionalDbgHdrSize)); 347 else if (Offset < endof(DbiStreamHeader, ECSubstreamSize)) 348 printStructField(P, "the size of the Edit & Continue Substream", 349 int32_t(Header->ECSubstreamSize)); 350 else if (Offset < endof(DbiStreamHeader, Flags)) 351 printStructField(P, "the DBI Stream flags", uint16_t(Header->Flags)); 352 else if (Offset < endof(DbiStreamHeader, MachineType)) 353 printStructField(P, "the machine type", uint16_t(Header->MachineType)); 354 else if (Offset < endof(DbiStreamHeader, Reserved)) 355 printStructField(P, "reserved data", uint32_t(Header->Reserved)); 356 } 357 358 static void explainDbiModiSubstreamOffset(LinePrinter &P, DbiStream &Dbi, 359 uint32_t Offset) { 360 VarStreamArray<DbiModuleDescriptor> ModuleDescriptors; 361 BinaryStreamRef ModiSubstreamData = Dbi.getModiSubstreamData().StreamData; 362 BinaryStreamReader Reader(ModiSubstreamData); 363 364 cantFail(Reader.readArray(ModuleDescriptors, ModiSubstreamData.getLength())); 365 auto Prev = ModuleDescriptors.begin(); 366 assert(Prev.offset() == 0); 367 auto Current = Prev; 368 uint32_t Index = 0; 369 while (true) { 370 Prev = Current; 371 ++Current; 372 if (Current == ModuleDescriptors.end() || Offset < Current.offset()) 373 break; 374 ++Index; 375 } 376 377 DbiModuleDescriptor &Descriptor = *Prev; 378 P.formatLine("which contains the descriptor for module {0} ({1}).", Index, 379 Descriptor.getModuleName()); 380 } 381 382 template <typename T> 383 static void dontExplain(LinePrinter &Printer, T &Stream, uint32_t Offset) {} 384 385 template <typename T, typename SubstreamRangeT> 386 static void explainSubstreamOffset(LinePrinter &P, uint32_t OffsetInStream, 387 T &Stream, 388 const SubstreamRangeT &Substreams) { 389 uint32_t SubOffset = OffsetInStream; 390 for (const auto &Entry : Substreams) { 391 if (Entry.Size <= 0) 392 continue; 393 uint32_t S = static_cast<uint32_t>(Entry.Size); 394 if (SubOffset < S) { 395 P.formatLine("address is at offset {0}/{1} of the {2}.", SubOffset, S, 396 Entry.Label); 397 Entry.Explain(P, Stream, SubOffset); 398 return; 399 } 400 SubOffset -= S; 401 } 402 } 403 404 void ExplainOutputStyle::explainStreamOffset(DbiStream &Dbi, 405 uint32_t OffsetInStream) { 406 P.printLine("Within the DBI stream:"); 407 AutoIndent Indent(P); 408 const DbiStreamHeader *Header = Dbi.getHeader(); 409 assert(Header != nullptr); 410 411 struct SubstreamInfo { 412 int32_t Size; 413 StringRef Label; 414 void (*Explain)(LinePrinter &, DbiStream &, uint32_t); 415 } Substreams[] = { 416 {sizeof(DbiStreamHeader), "DBI Stream Header", explainDbiHeaderOffset}, 417 {int32_t(Header->ModiSubstreamSize), "Module Info Substream", 418 explainDbiModiSubstreamOffset}, 419 {int32_t(Header->SecContrSubstreamSize), "Section Contribution Substream", 420 dontExplain<DbiStream>}, 421 {int32_t(Header->SectionMapSize), "Section Map", dontExplain<DbiStream>}, 422 {int32_t(Header->FileInfoSize), "File Info Substream", 423 dontExplain<DbiStream>}, 424 {int32_t(Header->TypeServerSize), "Type Server Map Substream", 425 dontExplain<DbiStream>}, 426 {int32_t(Header->ECSubstreamSize), "Edit & Continue Substream", 427 dontExplain<DbiStream>}, 428 {int32_t(Header->OptionalDbgHdrSize), "Optional Debug Stream Array", 429 dontExplain<DbiStream>}, 430 }; 431 432 explainSubstreamOffset(P, OffsetInStream, Dbi, Substreams); 433 } 434 435 static void explainPdbStreamHeaderOffset(LinePrinter &P, InfoStream &Info, 436 uint32_t Offset) { 437 const InfoStreamHeader *Header = Info.getHeader(); 438 assert(Header != nullptr); 439 440 if (Offset < endof(InfoStreamHeader, Version)) 441 printStructField(P, "the PDB Stream Version Signature", 442 uint32_t(Header->Version)); 443 else if (Offset < endof(InfoStreamHeader, Signature)) 444 printStructField(P, "the signature of the PDB Stream", 445 uint32_t(Header->Signature)); 446 else if (Offset < endof(InfoStreamHeader, Age)) 447 printStructField(P, "the age of the PDB", uint32_t(Header->Age)); 448 else if (Offset < endof(InfoStreamHeader, Guid)) 449 printStructField(P, "the guid of the PDB", fmt_guid(Header->Guid.Guid)); 450 } 451 452 void ExplainOutputStyle::explainStreamOffset(InfoStream &Info, 453 uint32_t OffsetInStream) { 454 P.printLine("Within the PDB stream:"); 455 AutoIndent Indent(P); 456 457 struct SubstreamInfo { 458 uint32_t Size; 459 StringRef Label; 460 void (*Explain)(LinePrinter &, InfoStream &, uint32_t); 461 } Substreams[] = {{sizeof(InfoStreamHeader), "PDB Stream Header", 462 explainPdbStreamHeaderOffset}, 463 {Info.getNamedStreamMapByteSize(), "Named Stream Map", 464 dontExplain<InfoStream>}, 465 {Info.getStreamSize(), "PDB Feature Signatures", 466 dontExplain<InfoStream>}}; 467 468 explainSubstreamOffset(P, OffsetInStream, Info, Substreams); 469 } 470
