[Refinery] Introduce TypePropagatorAnalyzer - pointer types.

syzygy/refinery/analyzers/stack_frame_analyzer.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,
 // 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 "syzygy/refinery/analyzers/stack_frame_analyzer.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/strings/stringprintf.h"
 #include "base/win/scoped_comptr.h"
 #include "syzygy/common/com_utils.h"
 #include "syzygy/pe/dia_util.h"
 #include "syzygy/refinery/analyzers/stack_frame_analyzer_impl.h"
+#include "syzygy/refinery/process_state/layer_data.h"
 #include "syzygy/refinery/types/type_repository.h"
 
 namespace refinery {
 
 namespace {
 
 bool GetInnerMostScopeForVA(IDiaSession* session,
                             Address va,
                             base::win::ScopedComPtr<IDiaSymbol>* scope) {
   DCHECK(session);
@@ skipping 59 matching lines @@
 
   const StackFrame& frame_proto = frame_record->data();
   Address instruction_pointer =
       static_cast<Address>(frame_proto.register_info().eip());
 
   // Retrieve symbol information.
   if (!SetSymbolInformation(instruction_pointer, process_state)) {
     LOG(INFO) << "Unable to get symbol information for frame. Skipping.";
     return true;  // Not an error.
   }
+  ModuleLayerAccessor accessor(process_state);
+  ModuleId module_id = accessor.GetModuleId(instruction_pointer);
+  if (module_id == kNoModuleId) {
+    LOG(INFO) << "No module corresponding to instruction pointer.";
+    return false;
+  }
 
   // Get the innermost scope, be it a block or the function itself.
   // TODO(manzagop): Identical code folding means there may be more than one
   // symbol for a given address. Look into this.
   base::win::ScopedComPtr<IDiaSymbol> scope;
   if (!GetInnerMostScopeForVA(dia_session_.get(), instruction_pointer, &scope))
     return false;
 
   // Walk up the scopes, processing scope's data.
-  StackFrameDataAnalyzer data_analyzer(frame_record, typename_index_,
+  StackFrameDataAnalyzer data_analyzer(frame_record, typename_index_, module_id,
                                        process_state);
   while (true) {
     // Process each SymTagData child in the block / function.
     // TODO(manzagop): the data visitor will stop visiting at the first error.
     // Figure out how to surface issues without preventing processing (eg
     // with a callback).
     pe::ChildVisitor data_visitor(scope.get(), SymTagData);
     if (!data_visitor.VisitChildren(
             base::Bind(&StackFrameDataAnalyzer::Analyze,
                        base::Unretained(&data_analyzer)))) {
@@ skipping 34 matching lines @@
   // Get dia session for the module.
   if (!dia_symbol_provider_->FindOrCreateDiaSession(
           instruction_pointer, process_state, &dia_session_)) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace refinery