@@ -499,45 +499,78 @@ const Msf = struct {
499499
500500 const superblock = try in .readStruct (SuperBlock );
501501
502+ // Sanity checks
502503 if (! mem .eql (u8 , superblock .FileMagic , SuperBlock .file_magic ))
503504 return error .InvalidDebugInfo ;
504-
505+ if (superblock .FreeBlockMapBlock != 1 and superblock .FreeBlockMapBlock != 2 )
506+ return error .InvalidDebugInfo ;
507+ if (superblock .NumBlocks * superblock .BlockSize != try file .getEndPos ())
508+ return error .InvalidDebugInfo ;
505509 switch (superblock .BlockSize ) {
506510 // llvm only supports 4096 but we can handle any of these values
507511 512 , 1024 , 2048 , 4096 = > {},
508512 else = > return error .InvalidDebugInfo ,
509513 }
510514
511- if (superblock .NumBlocks * superblock .BlockSize != try file .getEndPos ())
512- return error .InvalidDebugInfo ;
515+ const dir_block_count = blockCountFromSize (superblock .NumDirectoryBytes , superblock .BlockSize );
516+ if (dir_block_count > superblock .BlockSize / @sizeOf (u32 ))
517+ return error .UnhandledBigDirectoryStream ; // cf. BlockMapAddr comment.
513518
514- self .directory = try MsfStream .init (
519+ try file .seekTo (superblock .BlockSize * superblock .BlockMapAddr );
520+ var dir_blocks = try allocator .alloc (u32 , dir_block_count );
521+ for (dir_blocks ) | * b | {
522+ b .* = try in .readIntLittle (u32 );
523+ }
524+ self .directory = MsfStream .init (
515525 superblock .BlockSize ,
516- blockCountFromSize (superblock .NumDirectoryBytes , superblock .BlockSize ),
517- superblock .BlockSize * superblock .BlockMapAddr ,
518526 file ,
519- allocator ,
527+ dir_blocks ,
520528 );
521529
530+ const begin = self .directory .pos ;
522531 const stream_count = try self .directory .stream .readIntLittle (u32 );
523-
524532 const stream_sizes = try allocator .alloc (u32 , stream_count );
525- for (stream_sizes ) | * s | {
533+ defer allocator .free (stream_sizes );
534+
535+ // Microsoft's implementation uses u32(-1) for inexistant streams.
536+ // These streams are not used, but still participate in the file
537+ // and must be taken into account when resolving stream indices.
538+ const Nil = 0xFFFFFFFF ;
539+ for (stream_sizes ) | * s , i | {
526540 const size = try self .directory .stream .readIntLittle (u32 );
527- s .* = blockCountFromSize (size , superblock .BlockSize );
541+ s .* = if ( size == Nil ) 0 else blockCountFromSize (size , superblock .BlockSize );
528542 }
529543
530544 self .streams = try allocator .alloc (MsfStream , stream_count );
531545 for (self .streams ) | * stream , i | {
532- stream .* = try MsfStream .init (
533- superblock .BlockSize ,
534- stream_sizes [i ],
535- // MsfStream.init expects the file to be at the part where it reads [N]u32
536- try file .getPos (),
537- file ,
538- allocator ,
539- );
546+ const size = stream_sizes [i ];
547+ if (size == 0 ) {
548+ stream .* = MsfStream {
549+ .blocks = [_ ]u32 {},
550+ };
551+ } else {
552+ var blocks = try allocator .alloc (u32 , size );
553+ var j : u32 = 0 ;
554+ while (j < size ) : (j += 1 ) {
555+ const block_id = try self .directory .stream .readIntLittle (u32 );
556+ const n = (block_id % superblock .BlockSize );
557+ // 0 is for SuperBlock, 1 and 2 for FPMs.
558+ if (block_id == 0 or n == 1 or n == 2 or block_id * superblock .BlockSize > try file .getEndPos ())
559+ return error .InvalidBlockIndex ;
560+ blocks [j ] = block_id ;
561+ }
562+
563+ stream .* = MsfStream .init (
564+ superblock .BlockSize ,
565+ file ,
566+ blocks ,
567+ );
568+ }
540569 }
570+
571+ const end = self .directory .pos ;
572+ if (end - begin != superblock .NumDirectoryBytes )
573+ return error .InvalidStreamDirectory ;
541574 }
542575};
543576
@@ -574,7 +607,6 @@ const SuperBlock = packed struct {
574607 NumDirectoryBytes : u32 ,
575608
576609 Unknown : u32 ,
577-
578610 /// The index of a block within the MSF file. At this block is an array of
579611 /// ulittle32_t’s listing the blocks that the stream directory resides on.
580612 /// For large MSF files, the stream directory (which describes the block
@@ -584,45 +616,41 @@ const SuperBlock = packed struct {
584616 /// and the stream directory itself can be stitched together accordingly.
585617 /// The number of ulittle32_t’s in this array is given by
586618 /// ceil(NumDirectoryBytes / BlockSize).
619+ // Note: microsoft-pdb code actually suggests this is a variable-length
620+ // array. If the indices of blocks occupied by the Stream Directory didn't
621+ // fit in one page, there would be other u32 following it.
622+ // This would mean the Stream Directory is bigger than BlockSize / sizeof(u32)
623+ // blocks. We're not even close to this with a 1GB pdb file, and LLVM didn't
624+ // implement it so we're kind of safe making this assumption for now.
587625 BlockMapAddr : u32 ,
588626};
589627
590628const MsfStream = struct {
591- in_file : File ,
592- pos : u64 ,
593- blocks : []u32 ,
594- block_size : u32 ,
629+ in_file : File = undefined ,
630+ pos : u64 = undefined ,
631+ blocks : []u32 = undefined ,
632+ block_size : u32 = undefined ,
595633
596634 /// Implementation of InStream trait for Pdb.MsfStream
597- stream : Stream ,
635+ stream : Stream = undefined ,
598636
599637 pub const Error = @typeOf (read ).ReturnType .ErrorSet ;
600638 pub const Stream = io .InStream (Error );
601639
602- fn init (block_size : u32 , block_count : u32 , pos : u64 , file : File , allocator : * mem.Allocator ) ! MsfStream {
603- var stream = MsfStream {
640+ fn init (block_size : u32 , file : File , blocks : [] u32 ) MsfStream {
641+ const stream = MsfStream {
604642 .in_file = file ,
605643 .pos = 0 ,
606- .blocks = try allocator . alloc ( u32 , block_count ) ,
644+ .blocks = blocks ,
607645 .block_size = block_size ,
608646 .stream = Stream { .readFn = readFn },
609647 };
610648
611- var file_stream = file .inStream ();
612- const in = & file_stream .stream ;
613- try file .seekTo (pos );
614-
615- var i : u32 = 0 ;
616- while (i < block_count ) : (i += 1 ) {
617- stream .blocks [i ] = try in .readIntLittle (u32 );
618- }
619-
620649 return stream ;
621650 }
622651
623652 fn readNullTermString (self : * MsfStream , allocator : * mem.Allocator ) ! []u8 {
624653 var list = ArrayList (u8 ).init (allocator );
625- defer list .deinit ();
626654 while (true ) {
627655 const byte = try self .stream .readByte ();
628656 if (byte == 0 ) {
@@ -642,11 +670,12 @@ const MsfStream = struct {
642670 const in = & file_stream .stream ;
643671
644672 var size : usize = 0 ;
645- for (buffer ) | * byte | {
646- byte .* = try in .readByte ();
647-
648- offset += 1 ;
649- size += 1 ;
673+ var rem_buffer = buffer ;
674+ while (size < buffer .len ) {
675+ const size_to_read = math .min (self .block_size - offset , rem_buffer .len );
676+ size += try in .read (rem_buffer [0.. size_to_read ]);
677+ rem_buffer = buffer [size .. ];
678+ offset += size_to_read ;
650679
651680 // If we're at the end of a block, go to the next one.
652681 if (offset == self .block_size ) {
@@ -657,8 +686,8 @@ const MsfStream = struct {
657686 }
658687 }
659688
660- self .pos += size ;
661- return size ;
689+ self .pos += buffer . len ;
690+ return buffer . len ;
662691 }
663692
664693 fn seekBy (self : * MsfStream , len : i64 ) ! void {
0 commit comments