PdbDumper: Dump FPO records.

syzygy/experimental/pdb_dumper/pdb_dump.cc

 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 177 matching lines @@
 const char kUsage[] =
     "Usage: pdb_dump [options] <PDB file>...\n"
     "  Dumps information from streams in a supplied PDB files, and optionally\n"
     "  explodes the streams in the PDB files to individual files in an\n"
     "  output directory named '<PDB file>.streams'.\n"
     "\n"
     "  Optional Options:\n"
     "    --dump-symbol-records if provided the symbol record stream will be\n"
     "       dumped. This is a big stream so it could take a lot of time to\n"
     "       process.\n"
+    "    --dump-fpo if provided, the FPO stream will be dumped\n"
     "    --dump-type-info if provided the type info stream will be dumped.\n"
     "       This is a big stream so it could take a lot of time to process.\n"
     "    --dump-modules if provided the module streams will be dumped. Note\n"
     "       that this can take a long time as there may be many of these\n"
     "       streams.\n"
     "    --explode-streams if provided, each PDB file's streams will be\n"
     "       exploded into a directory named '<PDB file>.streams'\n";
 
 }  // namespace
 
 PdbDumpApp::PdbDumpApp()
     : application::AppImplBase("PDB Dumper"),
       explode_streams_(false),
       dump_symbol_record_(false),
+      dump_fpo_(false),
       dump_type_info_(false),
       dump_modules_(false) {
 }
 
 bool PdbDumpApp::ParseCommandLine(const base::CommandLine* command_line) {
   DCHECK(command_line != NULL);
 
   explode_streams_ = command_line->HasSwitch("explode-streams");
   dump_symbol_record_ = command_line->HasSwitch("dump-symbol-records");
+  dump_fpo_ = command_line->HasSwitch("dump-fpo");
   dump_type_info_ = command_line->HasSwitch("dump-type-info");
   dump_modules_ = command_line->HasSwitch("dump-modules");
 
   base::CommandLine::StringVector args = command_line->GetArgs();
   if (args.empty())
     return Usage("You must provide at least one input file.");
 
   for (size_t i = 0; i < args.size(); ++i) {
     pdb_files_.push_back(base::FilePath(args[i]));
   }
@@ skipping 41 matching lines @@
     // Read the dbi stream.
     DbiStream dbi_stream;
     stream = pdb_file.GetStream(pdb::kDbiStream).get();
     if (stream != NULL && dbi_stream.Read(stream)) {
       DumpDbiStream(dbi_stream);
     } else {
       LOG(ERROR) << "No Dbi stream.";
       return 1;
     }
 
+    if (dump_fpo_) {
+      scoped_refptr<pdb::PdbStream> fpo_stream =
+          pdb_file.GetStream(dbi_stream.dbg_header().fpo);
+
+      scoped_refptr<pdb::PdbStream> new_fpo_stream =
+          pdb_file.GetStream(dbi_stream.dbg_header().new_fpo);
+
+      DumpFpoStream(fpo_stream.get(), new_fpo_stream.get());
+    }
     // Read the type info stream.
     stream = pdb_file.GetStream(pdb::kTpiStream).get();
     TypeInfoEnumerator type_info_enum;
 
     if (type_info_enum.Init(stream)) {
       if (dump_type_info_)
         DumpTypeInfoStream(out(), type_info_enum);
     } else {
       LOG(ERROR) << "No type info stream.";
       return 1;
@@ skipping 134 matching lines @@
   ::fprintf(out(), "\tp_data: %d\n", dbi_stream.dbg_header().p_data);
   ::fprintf(out(), "\tnew_fpo: %d\n", dbi_stream.dbg_header().new_fpo);
   ::fprintf(out(), "\tsection_header_origin: %d\n",
             dbi_stream.dbg_header().section_header_origin);
 }
 
 void PdbDumpApp::DumpDbiStream(const DbiStream& dbi_stream) {
   DumpDbiHeaders(dbi_stream);
 }
 
+void PdbDumpApp::DumpFpoStream(PdbStream* fpo_stream,
+                               PdbStream* new_fpo_stream) {
+  if (!fpo_stream) {
+    ::fprintf(out(), "No FPO stream!\n");
+  } else {
+    ::fprintf(out(), "FPO Records:\n");
+    FPO_DATA fpo_data = {};
+    while (fpo_stream->Read(&fpo_data, 1)) {
+      // A bit of indentation makes it easier to separate the records visually.
+      ::fprintf(out(), "  ulOffStart: 0x%08X\n", fpo_data.ulOffStart);
+      ::fprintf(out(), "  cbProcSize: 0x%08X\n", fpo_data.cbProcSize);
+      ::fprintf(out(), "    cdwLocals: 0x%08X\n", fpo_data.cdwLocals);
+      ::fprintf(out(), "    cdwParams: 0x%04X\n", fpo_data.cdwParams);
+      ::fprintf(out(), "    cbProlog: %d\n", fpo_data.cbProlog);
+      ::fprintf(out(), "    cbRegs: %d\n", fpo_data.cbRegs);
+      ::fprintf(out(), "    fHasSEH: %d\n", fpo_data.fHasSEH);
+      ::fprintf(out(), "    fUseBP: %d\n", fpo_data.fUseBP);
+      ::fprintf(out(), "    reserved: %d\n", fpo_data.reserved);
+      ::fprintf(out(), "    cbFrame: %d\n", fpo_data.cbFrame);
+    }
+  }
+
+  if (!new_fpo_stream) {
+    ::fprintf(out(), "No new FPO stream!\n");
+  } else {
+    ::fprintf(out(), "Don't know how to dump new FPO stream yet.\n");
+  }
+}
+
 }  // namespace pdb