win: support x64 reading x86 (wow64)

snapshot/win/exception_snapshot_win.cc

 // Copyright 2015 The Crashpad Authors. 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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "snapshot/win/exception_snapshot_win.h"
 
 #include "snapshot/win/cpu_context_win.h"
 #include "snapshot/win/process_reader_win.h"
 #include "util/win/nt_internals.h"
-#include "util/win/process_structs.h"
 
 namespace crashpad {
 namespace internal {
 
 ExceptionSnapshotWin::ExceptionSnapshotWin()
     : ExceptionSnapshot(),
       context_union_(),
       context_(),
       codes_(),
       thread_id_(0),
@@ skipping 13 matching lines @@
 
   bool found_thread = false;
   for (const auto& loop_thread : process_reader->Threads()) {
     if (thread_id == loop_thread.id) {
       found_thread = true;
       break;
     }
   }
 
   if (!found_thread) {
-    LOG(ERROR) << "thread ID " << thread_id << "not found in process";
+    LOG(ERROR) << "thread ID " << thread_id << " not found in process";
     return false;
   } else {
     thread_id_ = thread_id;
   }
 
-  EXCEPTION_POINTERS exception_pointers;
-  if (!process_reader->ReadMemory(exception_pointers_address,
-                                  sizeof(EXCEPTION_POINTERS),
-                                  &exception_pointers)) {
-    LOG(ERROR) << "EXCEPTION_POINTERS read failed";
-    return false;
-  }
-  if (!exception_pointers.ExceptionRecord) {
-    LOG(ERROR) << "null ExceptionRecord";
-    return false;
-  }
+  using ExceptionPointers32 =
+      process_types::EXCEPTION_POINTERS<process_types::internal::Traits32>;
+  using ExceptionPointers64 =

[Mark Mentovai, 2015/09/18 15:44:06]

Goes in ARCH_CPU_64_BITS?

[scottmg, 2015/09/18 19:45:26]

I moved them to process_structs because they're basically just "missing" as
compared with the availability of EXCEPTION_RECORD32/64, etc.

+      process_types::EXCEPTION_POINTERS<process_types::internal::Traits64>;
 
 #if defined(ARCH_CPU_64_BITS)
   if (process_reader->Is64Bit()) {
+    ExceptionPointers64 exception_pointers;
+    if (!ReadExceptionPointers(
+            *process_reader, exception_pointers_address, &exception_pointers)) {
+      return false;
+    }
     CONTEXT context_record;
     if (!InitializeFromExceptionPointers<EXCEPTION_RECORD64>(
             *process_reader, exception_pointers, &context_record)) {
       return false;
     }
     context_.architecture = kCPUArchitectureX86_64;
     context_.x86_64 = &context_union_.x86_64;
     InitializeX64Context(context_record, context_.x86_64);
   } else {
-    CHECK(false) << "TODO(scottmg) WOW64";
+    ExceptionPointers32 exception_pointers;
+    if (!ReadExceptionPointers(
+            *process_reader, exception_pointers_address, &exception_pointers)) {
+      return false;
+    }
+    if (!CommonX86Initialize<WOW64_CONTEXT>(*process_reader,
+                                            exception_pointers)) {
+      return false;
+    }
+  }
+#else
+  ExceptionPointers32 exception_pointers;

[Mark Mentovai, 2015/09/18 15:44:06]

It’s only a small amount of duplication, but it’d be nice to share a little
more.

#if defined(ARCH_CPU_32_BITS)
  const bool is_64_bit = false;
  using NativeContext32 = CONTEXT;
#elif defined(ARCH_CPU_64_BITS)
  const bool is_64_bit = process_reader->Is64Bit();
  using NativeContext32 = WOW64_CONTEXT;
  if (is_64_bit) {
    ExceptionPointers64 …
  }
#endif
  if (!is_64_bit) {
    ExceptionPointers32 …
    CommonX86Initialize<NativeContext32>(…)
  }

but maybe we can get away with using WOW64_CONTEXT even for the native 32-bit
case?

[scottmg, 2015/09/18 19:45:26]

Done, and that made it clearer how to collapse the two helper functions too.

I didn't use WOW64_CONTEXT on x86, they're the same of course, but it just feels
wrong and only saves a couple using lines.

+  if (!ReadExceptionPointers(
+          *process_reader, exception_pointers_address, &exception_pointers)) {
     return false;
   }
-#else
-  CONTEXT context_record;
-  if (!InitializeFromExceptionPointers<EXCEPTION_RECORD32>(
-          *process_reader, exception_pointers, &context_record)) {
+  if (!CommonX86Initialize<CONTEXT>(*process_reader, exception_pointers))
     return false;
-  }
-  context_.architecture = kCPUArchitectureX86;
-  context_.x86 = &context_union_.x86;
-  InitializeX86Context(context_record, context_.x86);
 #endif  // ARCH_CPU_64_BITS
 
   INITIALIZATION_STATE_SET_VALID(initialized_);
   return true;
 }
 
 const CPUContext* ExceptionSnapshotWin::Context() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return &context_;
 }
@@ skipping 16 matching lines @@
 uint64_t ExceptionSnapshotWin::ExceptionAddress() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return exception_address_;
 }
 
 const std::vector<uint64_t>& ExceptionSnapshotWin::Codes() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return codes_;
 }
 
-template <class ExceptionRecordType, class ContextType>
+template <class ExceptionRecordType,
+          class ExceptionPointersType,
+          class ContextType>
 bool ExceptionSnapshotWin::InitializeFromExceptionPointers(
     const ProcessReaderWin& process_reader,
-    const EXCEPTION_POINTERS& exception_pointers,
+    const ExceptionPointersType& exception_pointers,
     ContextType* context_record) {
   ExceptionRecordType first_record;
   if (!process_reader.ReadMemory(
-          reinterpret_cast<WinVMAddress>(exception_pointers.ExceptionRecord),
+          static_cast<WinVMAddress>(exception_pointers.ExceptionRecord),
           sizeof(first_record),
           &first_record)) {
     LOG(ERROR) << "ExceptionRecord";
     return false;
   }
   exception_code_ = first_record.ExceptionCode;
   exception_flags_ = first_record.ExceptionFlags;
   exception_address_ = first_record.ExceptionAddress;
   for (DWORD i = 0; i < first_record.NumberParameters; ++i)
     codes_.push_back(first_record.ExceptionInformation[i]);
   if (first_record.ExceptionRecord) {
     // https://code.google.com/p/crashpad/issues/detail?id=43
     LOG(WARNING) << "dropping chained ExceptionRecord";
   }
 
   if (!process_reader.ReadMemory(
-          reinterpret_cast<WinVMAddress>(exception_pointers.ContextRecord),
+          static_cast<WinVMAddress>(exception_pointers.ContextRecord),
           sizeof(*context_record),
           context_record)) {
     LOG(ERROR) << "ContextRecord";
     return false;
   }
 
   return true;
 }
 
+template <class ContextRecordType>
+bool ExceptionSnapshotWin::CommonX86Initialize(
+    const ProcessReaderWin& process_reader,
+    const process_types::EXCEPTION_POINTERS<process_types::internal::Traits32>&
+        exception_pointers) {
+  ContextRecordType context_record;
+  if (!InitializeFromExceptionPointers<EXCEPTION_RECORD32>(
+          process_reader, exception_pointers, &context_record)) {
+    return false;
+  }
+  context_.architecture = kCPUArchitectureX86;
+  context_.x86 = &context_union_.x86;
+  InitializeX86Context(context_record, context_.x86);
+  return true;
+}
+
+template <class ExceptionPointersType>
+bool ExceptionSnapshotWin::ReadExceptionPointers(
+    const ProcessReaderWin& process_reader,
+    WinVMAddress exception_pointers_address,
+    ExceptionPointersType* exception_pointers) {
+  if (!process_reader.ReadMemory(exception_pointers_address,
+                                 sizeof(EXCEPTION_POINTERS),
+                                 exception_pointers)) {
+    LOG(ERROR) << "EXCEPTION_POINTERS read failed";
+    return false;
+  }
+  if (!exception_pointers->ExceptionRecord) {
+    LOG(ERROR) << "null ExceptionRecord";
+    return false;
+  }
+  return true;
+}
+
 }  // namespace internal
 }  // namespace crashpad