[Refinery] Introduce TypePropagatorAnalyzer - pointer types.

syzygy/refinery/analyzers/stack_frame_analyzer_impl.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 87 matching lines @@
 
   *type = matching_types[0];
   return true;
 }
 
 }  // namespace
 
 StackFrameDataAnalyzer::StackFrameDataAnalyzer(
     StackFrameRecordPtr frame_record,
     scoped_refptr<TypeNameIndex> typename_index,
+    ModuleId module_id,
     ProcessState* process_state)
     : frame_record_(frame_record),
       typename_index_(typename_index),
+      module_id_(module_id),
       process_state_(process_state) {
   DCHECK(frame_record.get());
   DCHECK(typename_index.get());
   DCHECK(process_state);
 }
 
 bool StackFrameDataAnalyzer::Analyze(IDiaSymbol* data) {
   DCHECK(data);
   DCHECK(pe::IsSymTag(data, SymTagData));
 
@@ skipping 17 matching lines @@
     case DataIsConstant:
       // TODO(manzagop): look into these.
       return true;  // Ignore these for now.
   }
 
   // Get the data's information: name, type name and address range.
   base::string16 data_name;
   if (!pe::GetSymName(data, &data_name))
     return false;
 
-  base::string16 type_name;
-  if (!GetTypeName(data, &type_name))
+  // Get the data's type from the type_repository.
+  TypePtr type;
+  if (!GetDataType(typename_index_.get(), data, &type))
     return false;
+  if (type.get() == nullptr)
+    return true;  // The type was not found.
 
   AddressRange range;
-  if (!GetAddressRange(data, &range))
+  if (!GetAddressRange(data, type, &range))
     return false;
   // Note: successfully returning an invalid address range means the location
   // type is not yet supported.
   // TODO(manzagop): fully support location types and remove this.
   if (!range.IsValid())
     return true;
 
   // Add the typed block to the process state's typed block layer.
   // TODO(manzagop): handle CV qualifiers.
   // TODO(manzagop): avoid duplicating types we already know about.
-  return AddTypedBlockRecord(range, data_name, type_name, process_state_);
+  return AddTypedBlockRecord(range, data_name, module_id_, type->type_id(),
+                             process_state_);
 }
 
 bool StackFrameDataAnalyzer::GetAddressRange(IDiaSymbol* data,
+                                             TypePtr type,
                                              AddressRange* range) {
   DCHECK(data); DCHECK(range);
 
   LocationType location_type = LocIsNull;
   if (!pe::GetLocationType(data, &location_type))
     return false;
 
   switch (location_type) {
     case LocIsRegRel:
-      return GetAddressRangeRegRel(data, range);
+      return GetAddressRangeRegRel(data, type, range);
     case LocIsStatic:
     case LocIsTLS:
     case LocIsThisRel:
     case LocIsEnregistered:
     case LocIsBitField:
     case LocIsSlot:
     case LocIsIlRel:
     case LocInMetaData:
     case LocIsConstant:
       VLOG(1) << "Unhandled location type: " << location_type;
       // TODO(manzagop): implement.
       AddressRange address_range;
       *range = address_range;
       return true;
   }
 
   return false;
 }
 
 bool StackFrameDataAnalyzer::GetAddressRangeRegRel(IDiaSymbol* data,
+                                                   TypePtr type,
                                                    AddressRange* range) {
   DCHECK(data); DCHECK(range);
   DCHECK(IsLocType(data, LocIsRegRel));
 
   AddressRange address_range;
   *range = address_range;
 
   // Register-relative: determine location.
   uint32_t register_id = 0U;
   if (!pe::GetRegisterId(data, &register_id))
     return false;
   ptrdiff_t register_offset = 0;
   if (!pe::GetSymOffset(data, &register_offset))
     return false;
 
-  // Get the data's type from the type_repository.
-  TypePtr type;
-  if (!GetDataType(typename_index_.get(), data, &type))
-    return false;
-  if (type.get() == nullptr)
-    return true;  // The type was not found.
-
   // Figure out the data's range.
   uint32_t register_value = 0U;
   if (!GetRegRelLocationRegisterValue(frame_record_, register_id,
                                       &register_value)) {
     LOG(ERROR) << base::StringPrintf(
         "Failed to retrieve register value (%d). Skipping data.", register_id);
     return true;
   }
 
   // TODO(manzagop): check validity of operation.
   Address data_va = register_value + register_offset;
   address_range.set_start(data_va);
   address_range.set_size(type->size());
   if (!address_range.IsValid())
     return false;
 
   *range = address_range;
   return true;
 }
 
 }  // namespace refinery