diff options
Diffstat (limited to 'src/google_breakpad/processor')
5 files changed, 172 insertions, 36 deletions
diff --git a/src/google_breakpad/processor/basic_source_line_resolver.h b/src/google_breakpad/processor/basic_source_line_resolver.h index fe93f4d2..e6c13532 100644 --- a/src/google_breakpad/processor/basic_source_line_resolver.h +++ b/src/google_breakpad/processor/basic_source_line_resolver.h @@ -27,59 +27,56 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// BasicSourceLineResolver implements SourceLineResolverInterface, using -// address map files produced by a compatible writer, e.g. PDBSourceLineWriter. +// basic_source_line_resolver.h: BasicSourceLineResolver is derived from +// SourceLineResolverBase, and is a concrete implementation of +// SourceLineResolverInterface, using address map files produced by a +// compatible writer, e.g. PDBSourceLineWriter. +// +// see "processor/source_line_resolver_base.h" +// and "source_line_resolver_interface.h" for more documentation. #ifndef GOOGLE_BREAKPAD_PROCESSOR_BASIC_SOURCE_LINE_RESOLVER_H__ #define GOOGLE_BREAKPAD_PROCESSOR_BASIC_SOURCE_LINE_RESOLVER_H__ #include <map> -#include "google_breakpad/processor/source_line_resolver_interface.h" +#include "google_breakpad/processor/source_line_resolver_base.h" namespace google_breakpad { using std::string; using std::map; -class BasicSourceLineResolver : public SourceLineResolverInterface { +class BasicSourceLineResolver : public SourceLineResolverBase { public: BasicSourceLineResolver(); - virtual ~BasicSourceLineResolver(); - - // SourceLineResolverInterface methods, see source_line_resolver_interface.h - // for more details. - - // Adds a module to this resolver, returning true on success. - // The given map_file is read into memory, and its symbols will be - // retained until the BasicSourceLineResolver is destroyed. - virtual bool LoadModule(const CodeModule *module, const string &map_file); + virtual ~BasicSourceLineResolver() { } - // Exactly the same as above, except the given map_buffer is used - // for symbols. - virtual bool LoadModuleUsingMapBuffer(const CodeModule *module, - const string &map_buffer); - - void UnloadModule(const CodeModule *module); - virtual bool HasModule(const CodeModule *module); - virtual void FillSourceLineInfo(StackFrame *frame); - virtual WindowsFrameInfo *FindWindowsFrameInfo(const StackFrame *frame); - virtual CFIFrameInfo *FindCFIFrameInfo(const StackFrame *frame); + using SourceLineResolverBase::LoadModule; + using SourceLineResolverBase::LoadModuleUsingMapBuffer; + using SourceLineResolverBase::LoadModuleUsingMemoryBuffer; + using SourceLineResolverBase::UnloadModule; + using SourceLineResolverBase::HasModule; + using SourceLineResolverBase::FillSourceLineInfo; + using SourceLineResolverBase::FindWindowsFrameInfo; + using SourceLineResolverBase::FindCFIFrameInfo; private: - template<class T> class MemAddrMap; - struct Line; + // friend declarations: + friend class BasicModuleFactory; + + // Function derives from SourceLineResolverBase::Function. struct Function; - struct PublicSymbol; - struct File; - struct CompareString { - bool operator()(const string &s1, const string &s2) const; - }; + // Module implements SourceLineResolverBase::Module interface. class Module; - // All of the modules we've loaded - typedef map<string, Module*, CompareString> ModuleMap; - ModuleMap *modules_; + // Helper method. + virtual void DeleteDataAfterLoad(char *symbol_data); + // No-op helper methods. + virtual void DeleteDataUnload(const CodeModule *module) { } + virtual void ClearLocalMemory() { } + virtual void StoreDataBeforeLoad(const CodeModule *module, + char *symbol_data) { } // Disallow unwanted copy ctor and assignment operator BasicSourceLineResolver(const BasicSourceLineResolver&); diff --git a/src/google_breakpad/processor/network_source_line_resolver.h b/src/google_breakpad/processor/network_source_line_resolver.h index f2c7732d..f60ff701 100644 --- a/src/google_breakpad/processor/network_source_line_resolver.h +++ b/src/google_breakpad/processor/network_source_line_resolver.h @@ -37,8 +37,8 @@ // An implementation of the server side of the protocol is provided there // as NetworkSourceLineServer. -#ifndef GOOGLE_BREAKPAD_PROCESSOR_NETWORK_SOURCE_LINE_RESOLVER_H_ -#define GOOGLE_BREAKPAD_PROCESSOR_NETWORK_SOURCE_LINE_RESOLVER_H_ +#ifndef GOOGLE_BREAKPAD_PROCESSOR_NETWORK_SOURCE_LINE_RESOLVER_H__ +#define GOOGLE_BREAKPAD_PROCESSOR_NETWORK_SOURCE_LINE_RESOLVER_H__ #include <sys/socket.h> @@ -81,6 +81,8 @@ class NetworkSourceLineResolver : public SourceLineResolverInterface, virtual bool LoadModule(const CodeModule *module, const string &map_file); virtual bool LoadModuleUsingMapBuffer(const CodeModule *module, const string &map_buffer); + virtual bool LoadModuleUsingMemoryBuffer(const CodeModule *module, + char *memory_buffer); void UnloadModule(const CodeModule *module); @@ -104,6 +106,11 @@ class NetworkSourceLineResolver : public SourceLineResolverInterface, const SystemInfo *system_info, string *symbol_file, string *symbol_data); + // Similar as the above GetSymbolFile() method, see the comment above. + virtual SymbolResult GetCStringSymbolData(const CodeModule *module, + const SystemInfo *system_info, + string *symbol_file, + char **symbol_data); private: int wait_milliseconds_; @@ -165,4 +172,4 @@ class NetworkSourceLineResolver : public SourceLineResolverInterface, } // namespace google_breakpad -#endif // GOOGLE_BREAKPAD_PROCESSOR_NETWORK_SOURCE_LINE_RESOLVER_H_ +#endif // GOOGLE_BREAKPAD_PROCESSOR_NETWORK_SOURCE_LINE_RESOLVER_H__ diff --git a/src/google_breakpad/processor/source_line_resolver_base.h b/src/google_breakpad/processor/source_line_resolver_base.h new file mode 100644 index 00000000..3d978877 --- /dev/null +++ b/src/google_breakpad/processor/source_line_resolver_base.h @@ -0,0 +1,117 @@ +// Copyright (c) 2010 Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// source_line_resolver_base.h: SourceLineResolverBase, an (incomplete) +// implementation of SourceLineResolverInterface. It serves as a common base +// class for concrete implementations: FastSourceLineResolver and +// BasicSourceLineResolver. It is designed for refactoring that removes +// code redundancy in the two concrete source line resolver classes. +// +// See "google_breakpad/processor/source_line_resolver_interface.h" for more +// documentation. + +// Author: Siyang Xie (lambxsy@google.com) + +#ifndef GOOGLE_BREAKPAD_PROCESSOR_SOURCE_LINE_RESOLVER_BASE_H__ +#define GOOGLE_BREAKPAD_PROCESSOR_SOURCE_LINE_RESOLVER_BASE_H__ + +#include <map> +#include <string> + +#include "google_breakpad/processor/source_line_resolver_interface.h" + +namespace google_breakpad { + +using std::map; + +// Forward declaration. +// ModuleFactory is a simple factory interface for creating a Module instance +// at run-time. +class ModuleFactory; + +class SourceLineResolverBase : public SourceLineResolverInterface { + public: + // Read the symbol_data from a file with given file_name. + // The part of code was originally in BasicSourceLineResolver::Module's + // LoadMap() method. + static bool ReadSymbolFile(char **symbol_data, const string &file_name); + + protected: + // Users are not allowed create SourceLineResolverBase instance directly. + SourceLineResolverBase(ModuleFactory *module_factory); + virtual ~SourceLineResolverBase(); + + // Virtual methods inherited from SourceLineResolverInterface. + virtual bool LoadModule(const CodeModule *module, const string &map_file); + virtual bool LoadModuleUsingMapBuffer(const CodeModule *module, + const string &map_buffer); + virtual bool LoadModuleUsingMemoryBuffer(const CodeModule *module, + char *memory_buffer); + virtual void UnloadModule(const CodeModule *module); + virtual bool HasModule(const CodeModule *module); + virtual void FillSourceLineInfo(StackFrame *frame); + virtual WindowsFrameInfo *FindWindowsFrameInfo(const StackFrame *frame); + virtual CFIFrameInfo *FindCFIFrameInfo(const StackFrame *frame); + + // Helper methods to manage C-String format symbol data. + virtual void StoreDataBeforeLoad(const CodeModule *module, char *symbol_data); + virtual void DeleteDataAfterLoad(char *symbol_data); + virtual void DeleteDataUnload(const CodeModule *module); + virtual void ClearLocalMemory(); + + // Nested structs and classes. + struct Line; + struct Function; + struct PublicSymbol; + struct CompareString { + bool operator()(const string &s1, const string &s2) const; + }; + // Module is an interface for an in-memory symbol file. + class Module; + class AutoFileCloser; + + // All of the modules we've loaded + typedef map<string, Module*, CompareString> ModuleMap; + ModuleMap *modules_; + + // Creates a concrete module at run-time. + ModuleFactory *module_factory_; + + private: + // ModuleFactory needs to have access to protected type Module. + friend class ModuleFactory; + + // Disallow unwanted copy ctor and assignment operator + SourceLineResolverBase(const SourceLineResolverBase&); + void operator=(const SourceLineResolverBase&); +}; + +} // namespace google_breakpad + +#endif // GOOGLE_BREAKPAD_PROCESSOR_SOURCE_LINE_RESOLVER_BASE_H__ diff --git a/src/google_breakpad/processor/source_line_resolver_interface.h b/src/google_breakpad/processor/source_line_resolver_interface.h index fa45d75f..bd6a12d6 100644 --- a/src/google_breakpad/processor/source_line_resolver_interface.h +++ b/src/google_breakpad/processor/source_line_resolver_interface.h @@ -64,6 +64,12 @@ class SourceLineResolverInterface { virtual bool LoadModuleUsingMapBuffer(const CodeModule *module, const string &map_buffer) = 0; + // Add an interface to load symbol using C-String data insteading string. + // This is useful in the optimization design for avoiding unnecessary copying + // of symbol data, in order to improve memory efficiency. + virtual bool LoadModuleUsingMemoryBuffer(const CodeModule *module, + char *memory_buffer) = 0; + // Request that the specified module be unloaded from this resolver. // A resolver may choose to ignore such a request. virtual void UnloadModule(const CodeModule *module) = 0; diff --git a/src/google_breakpad/processor/symbol_supplier.h b/src/google_breakpad/processor/symbol_supplier.h index 7b9d00e4..4a41688e 100644 --- a/src/google_breakpad/processor/symbol_supplier.h +++ b/src/google_breakpad/processor/symbol_supplier.h @@ -75,6 +75,15 @@ class SymbolSupplier { const SystemInfo *system_info, string *symbol_file, string *symbol_data) = 0; + + // Same as above, except places symbol data into symbol_data as C-string in + // dynamically allocated memory. Using C-string as type of symbol data enables + // passing data by pointer, and thus avoids unncessary copying of data (to + // improve memory efficiency). + virtual SymbolResult GetCStringSymbolData(const CodeModule *module, + const SystemInfo *system_info, + string *symbol_file, + char **symbol_data) = 0; }; } // namespace google_breakpad |