[Refinery] Introduce TypePropagatorAnalyzer - pointer types.

syzygy/refinery/types/type_repository.h

 // 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.
 
 #ifndef SYZYGY_REFINERY_TYPES_TYPE_REPOSITORY_H_
 #define SYZYGY_REFINERY_TYPES_TYPE_REPOSITORY_H_
 
 #include <iterator>
 #include <map>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
+#include "syzygy/pe/pe_file.h"
 
 namespace refinery {
 
 typedef size_t TypeId;
 class Type;
 using TypePtr = scoped_refptr<Type>;
 
 // Keeps type instances, assigns them an ID and vends them out by ID on demand.
 // TODO(manzagop): cleave the interface so as to obtain something immutable.
 class TypeRepository : public base::RefCounted<TypeRepository> {
  public:
   class Iterator;
 
   TypeRepository();
+  explicit TypeRepository(const pe::PEFile::Signature& signature);

[Sigurður Ásgeirsson, 2015/11/26 21:45:12]

I think we want to abstract the module ID to something less Windowsy. Maybe we
can just use something like

using ModuleId = std::string;

and have a central service that casts from PE signature to string?

Also, I think it probably should be mandatory to provide the string. If it takes
a separate CL, then that's fine with a TODO here?

[manzagop (departed), 2015/11/27 15:20:28]

Yes, I was thinking we'd have a Signature interface that gets factory created
based on platform specific signatures, but thought it too heavy short term.
Added TODO.
I was hesitant with the notion of including a signature in a TypeRepo because
until now nothing about the class said there needs to be a 1:1 match between a
repo and a module. Agreed going halfway about it is actually worse. Will tackle
in a follow up cl, as this one is pretty large.

Added TODO.

 
   // Retrieve a type by @p id.
   TypePtr GetType(TypeId id) const;
 
   // Add @p type and get its assigned id.
   // @pre @p type must not be in any repository.
   TypeId AddType(TypePtr type);
 
   // Add @p type and with @p id if the give id is free.
   // @pre @p type must not be in any repository and @p id must be free.
   // @returns true on success, failure typically means id is already taken.
   bool AddTypeWithId(TypePtr type, TypeId id);
 
+
+  // Get the signature for the module this type represents.
+  bool GetModuleSignature(pe::PEFile::Signature* signature);
+
   // @name Accessors.
   // @{
   size_t size() const;
   Iterator begin() const;
   Iterator end() const;
   // @}
 
  private:
   friend class base::RefCounted<TypeRepository>;
   ~TypeRepository();
 
+  bool is_signature_set_;
+  pe::PEFile::Signature signature_;
   base::hash_map<TypeId, TypePtr> types_;
 
   DISALLOW_COPY_AND_ASSIGN(TypeRepository);
 };
 
 class TypeRepository::Iterator
     : public std::iterator<std::input_iterator_tag, TypePtr> {
  public:
   Iterator() {}
   const TypePtr& operator*() const { return it_->second; }
@@ skipping 34 matching lines @@
  private:
   friend class base::RefCounted<TypeNameIndex>;
   ~TypeNameIndex();
 
   std::multimap<base::string16, TypePtr> name_index_;
 };
 
 }  // namespace refinery
 
 #endif  // SYZYGY_REFINERY_TYPES_TYPE_REPOSITORY_H_