[Refinery] Introduce TypePropagatorAnalyzer - pointer types.

syzygy/refinery/process_state/process_state_util.cc

 // Copyright 2015 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 54 matching lines @@
 bool ModuleLayerAccessor::GetModuleSignature(const Address va,
                                              pe::PEFile::Signature* signature) {
   DCHECK(signature);
 
   // Find the module record corresponding to the virtual address.
   ModuleRecordPtr module_record;
   if (!process_state_->FindSingleRecord(va, &module_record))
     return false;
 
   // Retrieve the signature.
-  ModuleLayerPtr layer;
-  process_state_->FindOrCreateLayer(&layer);
   const Module& module = module_record->data();
-  if (!layer->mutable_data()->Find(module.module_id(), signature))
+  if (!GetModuleSignature(module.module_id(), signature))
     return false;
 
   // Set the signature's address.
   const AddressRange& module_range = module_record->range();
   if (!base::IsValueInRangeForNumericType<uint32>(module_range.start())) {
     LOG(ERROR) << "PE::Signature doesn't support 64bit addresses. Address: "
                << module_range.start();
     return false;
   }
   signature->base_address =
       core::AbsoluteAddress(base::checked_cast<uint32>(module_range.start()));
 
   return true;
 }
 
+bool ModuleLayerAccessor::GetModuleSignature(const ModuleId id,
+                                             pe::PEFile::Signature* signature) {
+  DCHECK_NE(kNoModuleId, id);
+  DCHECK(signature);
+
+  ModuleLayerPtr layer;
+  process_state_->FindOrCreateLayer(&layer);
+  return layer->data().Find(id, signature);
+}
+
+ModuleId ModuleLayerAccessor::GetModuleId(const Address va) {
+  ModuleRecordPtr module_record;
+  if (!process_state_->FindSingleRecord(va, &module_record))
+    return kNoModuleId;
+  return module_record->data().module_id();
+}
+
+ModuleId ModuleLayerAccessor::GetModuleId(
+    const pe::PEFile::Signature& signature) {
+  ModuleLayerPtr layer;
+  process_state_->FindOrCreateLayer(&layer);
+  return layer->data().Find(signature);
+}
+
 bool AddTypedBlockRecord(const AddressRange& range,
                          base::StringPiece16 data_name,
-                         base::StringPiece16 type_name,
+                         ModuleId module_id,
+                         TypeId type_id,
                          ProcessState* process_state) {
   DCHECK(range.IsValid());
   DCHECK(process_state);
 
   TypedBlock* typedblock_proto = CreateRecord<TypedBlock>(range, process_state);
 
   std::string data_name_narrow;
   if (!base::UTF16ToUTF8(data_name.data(), data_name.size(), &data_name_narrow))
     return false;
   typedblock_proto->set_data_name(data_name_narrow);
 
-  std::string type_name_narrow;
-  if (!base::UTF16ToUTF8(type_name.data(), type_name.size(), &type_name_narrow))
-    return false;
-  typedblock_proto->set_type_name(type_name_narrow);
+  typedblock_proto->set_module_id(module_id);
+  typedblock_proto->set_type_id(type_id);
 
   return true;
 }
 
 }  // namespace refinery