Windows dump_syms: Add dumping of x86_64 CFI from PDB files

src/common/windows/pdb_source_line_writer.cc

 // Copyright (c) 2006, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 19 matching lines @@
 #include "common/windows/pdb_source_line_writer.h"
 
 #include <windows.h>
 #include <winnt.h>
 #include <atlbase.h>
 #include <dia2.h>
 #include <diacreate.h>
 #include <ImageHlp.h>
 #include <stdio.h>
 
+#include <cassert>
 #include <limits>
 #include <set>
 
 #include "common/windows/dia_util.h"
 #include "common/windows/guid_string.h"
 #include "common/windows/string_utils-inl.h"
 
 // This constant may be missing from DbgHelp.h.  See the documentation for
 // IDiaSymbol::get_undecoratedNameEx.
 #ifndef UNDNAME_NO_ECSU
@@ skipping 629 matching lines @@
       last_code_size = code_size;
       last_prolog_size = prolog_size;
     }
 
     frame_data.Release();
   }
 
   return true;
 }
 
-bool PDBSourceLineWriter::PrintFrameDataUsingEXE() {
-  if (code_file_.empty() && !FindPEFile()) {
-    fprintf(stderr, "Couldn't locate EXE or DLL file.\n");
-    return false;
-  }
+// Prints CFI from xdata/pdata
+//
+// Performing the translation of RVA to a real pointer is very different for a
+// XDATA/PDATA streams read from a PDB, and XDATA/PDATA found in the loaded
+// image of an executable, so we specialize this function for each case with
+// RvaToVaTraits
+//
+template <typename RvaToVaTraits>
+static bool PrintCFIFromXData(FILE *output, PVOID pdata, size_t pdata_size,
+                              const typename RvaToVaTraits &t) {
+  PIMAGE_RUNTIME_FUNCTION_ENTRY funcs =
+    static_cast<PIMAGE_RUNTIME_FUNCTION_ENTRY>(pdata);
 
-  // Convert wchar to native charset because ImageLoad only takes
-  // a PSTR as input.
-  string code_file;
-  if (!WindowsStringUtils::safe_wcstombs(code_file_, &code_file)) {
-    return false;
-  }
-
-  AutoImage img(ImageLoad((PSTR)code_file.c_str(), NULL));
-  if (!img) {
-    fprintf(stderr, "Failed to load %s\n", code_file.c_str());
-    return false;
-  }
-  PIMAGE_OPTIONAL_HEADER64 optional_header =
-    &(reinterpret_cast<PIMAGE_NT_HEADERS64>(img->FileHeader))->OptionalHeader;
-  if (optional_header->Magic != IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
-    fprintf(stderr, "Not a PE32+ image\n");
-    return false;
-  }
-
-  // Read Exception Directory
-  DWORD exception_rva = optional_header->
-    DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress;
-  DWORD exception_size = optional_header->
-    DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size;
-  PIMAGE_RUNTIME_FUNCTION_ENTRY funcs =
-    static_cast<PIMAGE_RUNTIME_FUNCTION_ENTRY>(
-        ImageRvaToVa(img->FileHeader,
-                     img->MappedAddress,
-                     exception_rva,
-                     &img->LastRvaSection));
-  for (DWORD i = 0; i < exception_size / sizeof(*funcs); i++) {
+  for (size_t i = 0; i < pdata_size / sizeof(*funcs) ; i++) {
     DWORD unwind_rva = funcs[i].UnwindInfoAddress;
     // handle chaining
     while (unwind_rva & 0x1) {
       unwind_rva ^= 0x1;
       PIMAGE_RUNTIME_FUNCTION_ENTRY chained_func =
         static_cast<PIMAGE_RUNTIME_FUNCTION_ENTRY>(
-            ImageRvaToVa(img->FileHeader,
-                         img->MappedAddress,
-                         unwind_rva,
-                         &img->LastRvaSection));
+            t.PDataRvaToVa(unwind_rva));
       unwind_rva = chained_func->UnwindInfoAddress;
     }
 
     UnwindInfo *unwind_info = static_cast<UnwindInfo *>(
-        ImageRvaToVa(img->FileHeader,
-                     img->MappedAddress,
-                     unwind_rva,
-                     &img->LastRvaSection));
+        t.XDataRvaToVa(unwind_rva));
 
     DWORD stack_size = 8;  // minimal stack size is 8 for RIP
     DWORD rip_offset = 8;
     do {
       for (UBYTE c = 0; c < unwind_info->count_of_codes; c++) {
         UnwindCode *unwind_code = &unwind_info->unwind_code[c];
         switch (unwind_code->unwind_operation_code) {
           case UWOP_PUSH_NONVOL: {
             stack_size += 8;
             break;
@@ skipping 34 matching lines @@
               stack_size += 88;
             } else {
               stack_size += 80;
             }
             rip_offset += 80;
             break;
           }
         }
       }
       if (unwind_info->flags & UNW_FLAG_CHAININFO) {
+        // unwind_code[] is followed by an IMAGE_RUNTIME_FUNCTION_ENTRY
         PIMAGE_RUNTIME_FUNCTION_ENTRY chained_func =
           reinterpret_cast<PIMAGE_RUNTIME_FUNCTION_ENTRY>(
               (unwind_info->unwind_code +
               ((unwind_info->count_of_codes + 1) & ~1)));
 
         unwind_info = static_cast<UnwindInfo *>(
-            ImageRvaToVa(img->FileHeader,
-                         img->MappedAddress,
-                         chained_func->UnwindInfoAddress,
-                         &img->LastRvaSection));
+            t.XDataRvaToVa(chained_func->UnwindInfoAddress));
       } else {
         unwind_info = NULL;
       }
     } while (unwind_info);
-    fprintf(output_, "STACK CFI INIT %x %x .cfa: $rsp .ra: .cfa %d - ^\n",
+    fprintf(output, "STACK CFI INIT %x %x .cfa: $rsp .ra: .cfa %d - ^\n",
             funcs[i].BeginAddress,
             funcs[i].EndAddress - funcs[i].BeginAddress, rip_offset);
-    fprintf(output_, "STACK CFI %x .cfa: $rsp %d +\n",
+    fprintf(output, "STACK CFI %x .cfa: $rsp %d +\n",
             funcs[i].BeginAddress, stack_size);
   }
 
   return true;
 }
 
+// In a LOADED_IMAGE, we can simply use ImageRvaToVa() to translate RVAs
+class ImageRvaToVaTraits {
+ public:
+  ImageRvaToVaTraits(PLOADED_IMAGE img)
+      : img_(img)
+  {
+  };
+
+  PVOID XDataRvaToVa(DWORD rva) const {
+    return ImageRvaToVa(img_->FileHeader,
+                        img_->MappedAddress,
+                        rva,
+                        &img_->LastRvaSection);
+  };
+
+  PVOID PDataRvaToVa(DWORD rva) const {
+    return ImageRvaToVa(img_->FileHeader,
+                        img_->MappedAddress,
+                        rva,
+                        &img_->LastRvaSection);
+  };
+
+ private:
+  PLOADED_IMAGE img_;
+};
+
+bool PDBSourceLineWriter::PrintFrameDataUsingEXE() {
+  if (code_file_.empty() && !FindPEFile()) {
+    fprintf(stderr, "Couldn't locate EXE or DLL file.\n");
+    return false;
+  }
+
+  // Convert wchar to native charset because ImageLoad only takes
+  // a PSTR as input.
+  string code_file;
+  if (!WindowsStringUtils::safe_wcstombs(code_file_, &code_file)) {
+    return false;
+  }
+
+  AutoImage img(ImageLoad((PSTR)code_file.c_str(), NULL));
+  if (!img) {
+    fprintf(stderr, "Failed to load %s\n", code_file.c_str());
+    return false;
+  }
+  PIMAGE_OPTIONAL_HEADER64 optional_header =
+    &(reinterpret_cast<PIMAGE_NT_HEADERS64>(img->FileHeader))->OptionalHeader;
+  if (optional_header->Magic != IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
+    fprintf(stderr, "Not a PE32+ image\n");
+    return false;
+  }
+
+  // Read Exception Directory
+  DWORD exception_rva = optional_header->
+    DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress;
+  DWORD exception_size = optional_header->
+    DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size;
+
+  PVOID pdata = static_cast<PVOID>(
+        ImageRvaToVa(img->FileHeader,
+                     img->MappedAddress,
+                     exception_rva,
+                     &img->LastRvaSection));
+
+  ImageRvaToVaTraits t(img);
+
+  return PrintCFIFromXData(output_, pdata, exception_size, t);
+}
+
+// We have the XDATA/PDATA streams from the PDB, along with their base RVAs
+// provided by IDiaImageData.  It is assumed that all the RVAs we access lie
+// within the range of RVAs covered by the stream.
+class PdbRvaToVaTraits {
+ public:
+  PdbRvaToVaTraits(PVOID pdata, size_t pdata_size, DWORD pdata_base_rva,
+                   PVOID xdata, size_t xdata_size, DWORD xdata_base_rva)
+      : pdata_(pdata), pdata_size_(pdata_size), pdata_base_rva_(pdata_base_rva),
+        xdata_(xdata), xdata_size_(xdata_size), xdata_base_rva_(xdata_base_rva)
+  {
+  };
+
+  PVOID XDataRvaToVa(DWORD rva) const {
+    assert(rva >= xdata_base_rva_);
+    assert(rva < xdata_base_rva_ + xdata_size_);
+
+    return rva - xdata_base_rva_ + static_cast<PBYTE>(xdata_);
+  };
+
+  PVOID PDataRvaToVa(DWORD rva) const {
+    assert(rva >= pdata_base_rva_);
+    assert(rva < pdata_base_rva_ + pdata_size_);
+
+    return rva - pdata_base_rva_ + static_cast<PBYTE>(pdata_);
+  };
+
+ private:
+  PVOID pdata_;
+  size_t pdata_size_;
+  DWORD pdata_base_rva_;
+  PVOID xdata_;
+  size_t xdata_size_;
+  DWORD xdata_base_rva_;
+};
+
+bool PDBSourceLineWriter::PrintFrameDataUsingPDBXData() {
+  static const wchar_t kPdataStreamName[] = L"PDATA";
+  static const wchar_t kXdataStreamName[] = L"XDATA";
+
+  std::vector<BYTE> pdata;
+  std::vector<BYTE> xdata;
+  DWORD pdata_base_rva;
+  DWORD xdata_base_rva;
+
+  if (FindAndLoadDebugStream(kPdataStreamName, session_, &pdata,
+                             &pdata_base_rva) && pdata_base_rva &&
+      FindAndLoadDebugStream(kXdataStreamName, session_, &xdata,
+                             &xdata_base_rva) && xdata_base_rva) {
+
+    PdbRvaToVaTraits t(&pdata[0], pdata.size(), pdata_base_rva,
+                       &xdata[0], xdata.size(), xdata_base_rva);
+
+    return PrintCFIFromXData(output_, &pdata[0], pdata.size(), t);
+  }
+
+  return false;
+}
+
 bool PDBSourceLineWriter::PrintFrameData() {
   PDBModuleInfo info;
   if (GetModuleInfo(&info) && info.cpu == L"x86_64") {
+    // Print CFI using .pdata/.xdata streams in PDB
+    if (PrintFrameDataUsingPDBXData())
+      return true;
+    // If they are not present, fall-back to reading the .pdata/.xdata from the
+    // corresponding PE/COFF executable, if we can find it.
     return PrintFrameDataUsingEXE();
   } else {
     return PrintFrameDataUsingPDB();
   }
   return false;
 }
 
 bool PDBSourceLineWriter::PrintCodePublicSymbol(IDiaSymbol *symbol) {
   BOOL is_code;
   if (FAILED(symbol->get_code(&is_code))) {
@@ skipping 515 matching lines @@
   // an old-style CodeView record if a real 128-bit GUID has its first 32
   // bits set the same as the module's signature (timestamp) and the rest of
   // the GUID is set to 0.  This is highly unlikely.
 
   GUID signature_guid = {signature};  // 0-initializes other members
   *uses_guid = !IsEqualGUID(guid, signature_guid);
   return true;
 }
 
 }  // namespace google_breakpad