win: support x64 reading x86 (wow64)

snapshot/win/cpu_context_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/cpu_context_win.h"
 
 #include <string.h>
 
 #include "base/logging.h"
 #include "snapshot/cpu_context.h"
 
 namespace crashpad {
 
+namespace {
+
+template <int Control,

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

These flags have the same value regardless of whether you’re using the WOW64_*
names in 64-bit or the native names in 32-bit. Maybe we should dump the extra
parameters and have our own constants. Or if we can see the WOW64_* macros even
in 32-bit mode, maybe just use those.

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

Ah, I noticed they were identical, but not that the WOW64_* versions were
available when compiling as x86. Done.

+          int Integer,
+          int Segments,
+          int FloatingPoint,
+          int DebugRegisters,
+          int ExtendedRegisters,
+          class T>
+void CommonInitializeX86Context(const T& context, CPUContextX86* out) {
+  memset(out, 0, sizeof(*out));
+
+  if (context.ContextFlags & Control) {
+    out->ebp = context.Ebp;
+    out->eip = context.Eip;
+    out->cs = static_cast<uint16_t>(context.SegCs);
+    out->eflags = context.EFlags;
+    out->esp = context.Esp;
+    out->ss = static_cast<uint16_t>(context.SegSs);
+  }
+
+  if (context.ContextFlags & Integer) {
+    out->eax = context.Eax;
+    out->ebx = context.Ebx;
+    out->ecx = context.Ecx;
+    out->edx = context.Edx;
+    out->edi = context.Edi;
+    out->esi = context.Esi;
+  }
+
+  if (context.ContextFlags & Segments) {
+    out->ds = static_cast<uint16_t>(context.SegDs);
+    out->es = static_cast<uint16_t>(context.SegEs);
+    out->fs = static_cast<uint16_t>(context.SegFs);
+    out->gs = static_cast<uint16_t>(context.SegGs);
+  }
+
+  if (context.ContextFlags & DebugRegisters) {
+    out->dr0 = context.Dr0;
+    out->dr1 = context.Dr1;
+    out->dr2 = context.Dr2;
+    out->dr3 = context.Dr3;
+    // DR4 and DR5 are obsolete synonyms for DR6 and DR7, see
+    // https://en.wikipedia.org/wiki/X86_debug_register.
+    out->dr4 = context.Dr6;
+    out->dr5 = context.Dr7;
+    out->dr6 = context.Dr6;
+    out->dr7 = context.Dr7;
+  }
+
+  if (context.ContextFlags & ExtendedRegisters) {
+    static_assert(sizeof(out->fxsave) == sizeof(context.ExtendedRegisters),
+                  "types must be equivalent");
+    memcpy(&out->fxsave, &context.ExtendedRegisters, sizeof(out->fxsave));
+  } else if (context.ContextFlags & FloatingPoint) {
+    CHECK(false) << "TODO(scottmg): extract x87 data";
+  }
+}
+
+}  // namespace
+
 #if defined(ARCH_CPU_64_BITS)
 
 void InitializeX86Context(const WOW64_CONTEXT& context, CPUContextX86* out) {
-  CHECK(false) << "TODO(scottmg) InitializeX86Context()";
+  LOG_IF(ERROR, !(context.ContextFlags & WOW64_CONTEXT_i386))
+      << "non-wow64 context";
+  CommonInitializeX86Context<WOW64_CONTEXT_CONTROL,
+                             WOW64_CONTEXT_INTEGER,
+                             WOW64_CONTEXT_SEGMENTS,
+                             WOW64_CONTEXT_FLOATING_POINT,
+                             WOW64_CONTEXT_DEBUG_REGISTERS,
+                             WOW64_CONTEXT_EXTENDED_REGISTERS>(context, out);
 }
 
 void InitializeX64Context(const CONTEXT& context, CPUContextX86_64* out) {
   memset(out, 0, sizeof(*out));
 
   LOG_IF(ERROR, !(context.ContextFlags & CONTEXT_AMD64)) << "non-x64 context";
 
   if (context.ContextFlags & CONTEXT_CONTROL) {
     out->cs = context.SegCs;
     out->rflags = context.EFlags;
@@ skipping 43 matching lines @@
   if (context.ContextFlags & CONTEXT_FLOATING_POINT) {
     static_assert(sizeof(out->fxsave) == sizeof(context.FltSave),
                   "types must be equivalent");
     memcpy(&out->fxsave, &context.FltSave.ControlWord, sizeof(out->fxsave));
   }
 }
 
 #else  // ARCH_CPU_64_BITS
 
 void InitializeX86Context(const CONTEXT& context, CPUContextX86* out) {
-  memset(out, 0, sizeof(*out));
-
   LOG_IF(ERROR, !(context.ContextFlags & CONTEXT_i386)) << "non-x86 context";
-
-  if (context.ContextFlags & CONTEXT_CONTROL) {
-    out->ebp = context.Ebp;
-    out->eip = context.Eip;
-    out->cs = static_cast<uint16_t>(context.SegCs);
-    out->eflags = context.EFlags;
-    out->esp = context.Esp;
-    out->ss = static_cast<uint16_t>(context.SegSs);
-  }
-
-  if (context.ContextFlags & CONTEXT_INTEGER) {
-    out->eax = context.Eax;
-    out->ebx = context.Ebx;
-    out->ecx = context.Ecx;
-    out->edx = context.Edx;
-    out->edi = context.Edi;
-    out->esi = context.Esi;
-  }
-
-  if (context.ContextFlags & CONTEXT_SEGMENTS) {
-    out->ds = static_cast<uint16_t>(context.SegDs);
-    out->es = static_cast<uint16_t>(context.SegEs);
-    out->fs = static_cast<uint16_t>(context.SegFs);
-    out->gs = static_cast<uint16_t>(context.SegGs);
-  }
-
-  if (context.ContextFlags & CONTEXT_DEBUG_REGISTERS) {
-    out->dr0 = context.Dr0;
-    out->dr1 = context.Dr1;
-    out->dr2 = context.Dr2;
-    out->dr3 = context.Dr3;
-    // DR4 and DR5 are obsolete synonyms for DR6 and DR7, see
-    // https://en.wikipedia.org/wiki/X86_debug_register.
-    out->dr4 = context.Dr6;
-    out->dr5 = context.Dr7;
-    out->dr6 = context.Dr6;
-    out->dr7 = context.Dr7;
-  }
-
-  if (context.ContextFlags & CONTEXT_EXTENDED_REGISTERS) {
-    static_assert(sizeof(out->fxsave) == sizeof(context.ExtendedRegisters),
-                  "types must be equivalent");
-    memcpy(&out->fxsave, &context.ExtendedRegisters, sizeof(out->fxsave));
-  } else if (context.ContextFlags & CONTEXT_FLOATING_POINT) {
-    CHECK(false) << "TODO(scottmg): extract x87 data";
-  }
+  CommonInitializeX86Context<CONTEXT_CONTROL,
+                             CONTEXT_INTEGER,
+                             CONTEXT_SEGMENTS,
+                             CONTEXT_FLOATING_POINT,
+                             CONTEXT_DEBUG_REGISTERS,
+                             CONTEXT_EXTENDED_REGISTERS>(context, out);
 }
 
 #endif  // ARCH_CPU_64_BITS
 
 }  // namespace crashpad