win: Make reading CrashpadInfo work across bitness

snapshot/win/pe_image_reader.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/pe_image_reader.h"
 
 #include <string.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "client/crashpad_info.h"
 #include "snapshot/win/process_reader_win.h"
 #include "util/misc/pdb_structures.h"
+#include "util/win/process_structs.h"
 
 namespace crashpad {
 
 namespace {
 
 std::string RangeToString(const CheckedWinAddressRange& range) {
   return base::StringPrintf("[0x%llx + 0x%llx (%s)]",
                             range.Base(),
                             range.Size(),
                             range.Is64Bit() ? "64" : "32");
 }
 
+// Map from Traits to an IMAGE_NT_HEADERSxx.
+template <class Traits>
+struct NtHeadersForTraits;
+
+template <>
+struct NtHeadersForTraits<process_types::internal::Traits32> {
+  using type = IMAGE_NT_HEADERS32;
+};
+
+template <>
+struct NtHeadersForTraits<process_types::internal::Traits64> {
+  using type = IMAGE_NT_HEADERS64;
+};
+
 }  // namespace
 
 PEImageReader::PEImageReader()
     : process_reader_(nullptr),
       module_range_(),
       module_name_(),
       initialized_() {
 }
 
 PEImageReader::~PEImageReader() {
@@ skipping 11 matching lines @@
     LOG(WARNING) << "invalid module range for " << module_name << ": "
                  << RangeToString(module_range_);
     return false;
   }
   module_name_ = module_name;
 
   INITIALIZATION_STATE_SET_VALID(initialized_);
   return true;
 }
 
+template <class Traits>
 bool PEImageReader::GetCrashpadInfo(
-    process_types::CrashpadInfo* crashpad_info) const {
+    process_types::CrashpadInfo<Traits>* crashpad_info) const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
 
   IMAGE_SECTION_HEADER section;
-  if (process_reader_->Is64Bit()) {
-    if (!GetSectionByName<IMAGE_NT_HEADERS64>("CPADinfo", &section))
-      return false;
-  } else {
-    if (!GetSectionByName<IMAGE_NT_HEADERS32>("CPADinfo", &section))
-      return false;
-  }
+  if (!GetSectionByName<NtHeadersForTraits<Traits>::type>("CPADinfo", &section))
+    return false;
 
-  if (section.Misc.VirtualSize < sizeof(process_types::CrashpadInfo)) {
+  if (section.Misc.VirtualSize < sizeof(process_types::CrashpadInfo<Traits>)) {
     LOG(WARNING) << "small crashpad info section size "
                  << section.Misc.VirtualSize << ", " << module_name_;
     return false;
   }
 
   WinVMAddress crashpad_info_address = Address() + section.VirtualAddress;
   CheckedWinAddressRange crashpad_info_range(process_reader_->Is64Bit(),
                                              crashpad_info_address,
                                              section.Misc.VirtualSize);
   if (!crashpad_info_range.IsValid()) {
     LOG(WARNING) << "invalid range for crashpad info: "
                  << RangeToString(crashpad_info_range);
     return false;
   }
 
   if (!module_range_.ContainsRange(crashpad_info_range)) {
     LOG(WARNING) << "crashpad info does not fall inside module "
                  << module_name_;
     return false;
   }
 
-  // TODO(scottmg): process_types for cross-bitness.
   if (!process_reader_->ReadMemory(crashpad_info_address,
-                                   sizeof(process_types::CrashpadInfo),
+                                   sizeof(process_types::CrashpadInfo<Traits>),
                                    crashpad_info)) {
     LOG(WARNING) << "could not read crashpad info " << module_name_;
     return false;
   }
 
   if (crashpad_info->signature != CrashpadInfo::kSignature ||
       crashpad_info->version < 1) {
     LOG(WARNING) << "unexpected crashpad info data " << module_name_;
     return false;
   }
@@ skipping 147 matching lines @@
     return false;
   }
   if (!module_range_.ContainsRange(read_range)) {
     LOG(WARNING) << "attempt to read outside of module " << module_name_
                  << " at range: " << RangeToString(read_range);
     return false;
   }
   return process_reader_->ReadMemory(address, size, into);
 }
 
+// Explicit instantiations with the only 2 valid template arguments to avoid
+// putting the body of the function in the header.
+template bool PEImageReader::GetCrashpadInfo<process_types::internal::Traits32>(
+    process_types::CrashpadInfo<process_types::internal::Traits32>*
+        crashpad_info) const;
+template bool PEImageReader::GetCrashpadInfo<process_types::internal::Traits64>(
+    process_types::CrashpadInfo<process_types::internal::Traits64>*
+        crashpad_info) const;
+
 }  // namespace crashpad