1// Copyright (c) 2010 Google Inc.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
8//     * Redistributions of source code must retain the above copyright
9// notice, this list of conditions and the following disclaimer.
10//     * Redistributions in binary form must reproduce the above
11// copyright notice, this list of conditions and the following disclaimer
12// in the documentation and/or other materials provided with the
13// distribution.
14//     * Neither the name of Google Inc. nor the names of its
15// contributors may be used to endorse or promote products derived from
16// this software without specific prior written permission.
17//
18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29//
30// source_line_resolver_base.h: SourceLineResolverBase, an (incomplete)
31// implementation of SourceLineResolverInterface.  It serves as a common base
32// class for concrete implementations: FastSourceLineResolver and
33// BasicSourceLineResolver.  It is designed for refactoring that removes
34// code redundancy in the two concrete source line resolver classes.
35//
36// See "google_breakpad/processor/source_line_resolver_interface.h" for more
37// documentation.
38
39// Author: Siyang Xie (lambxsy@google.com)
40
41#ifndef GOOGLE_BREAKPAD_PROCESSOR_SOURCE_LINE_RESOLVER_BASE_H__
42#define GOOGLE_BREAKPAD_PROCESSOR_SOURCE_LINE_RESOLVER_BASE_H__
43
44#include <map>
45#include <set>
46#include <string>
47
48#include "google_breakpad/processor/source_line_resolver_interface.h"
49
50namespace google_breakpad {
51
52using std::map;
53using std::set;
54
55// Forward declaration.
56// ModuleFactory is a simple factory interface for creating a Module instance
57// at run-time.
58class ModuleFactory;
59
60class SourceLineResolverBase : public SourceLineResolverInterface {
61 public:
62  // Read the symbol_data from a file with given file_name.
63  // The part of code was originally in BasicSourceLineResolver::Module's
64  // LoadMap() method.
65  // Place dynamically allocated heap buffer in symbol_data. Caller has the
66  // ownership of the buffer, and should call delete [] to free the buffer.
67  static bool ReadSymbolFile(const string &file_name,
68                             char **symbol_data,
69                             size_t *symbol_data_size);
70
71 protected:
72  // Users are not allowed create SourceLineResolverBase instance directly.
73  SourceLineResolverBase(ModuleFactory *module_factory);
74  virtual ~SourceLineResolverBase();
75
76  // Virtual methods inherited from SourceLineResolverInterface.
77  virtual bool LoadModule(const CodeModule *module, const string &map_file);
78  virtual bool LoadModuleUsingMapBuffer(const CodeModule *module,
79                                        const string &map_buffer);
80  virtual bool LoadModuleUsingMemoryBuffer(const CodeModule *module,
81                                           char *memory_buffer,
82                                           size_t memory_buffer_size);
83  virtual bool ShouldDeleteMemoryBufferAfterLoadModule();
84  virtual void UnloadModule(const CodeModule *module);
85  virtual bool HasModule(const CodeModule *module);
86  virtual bool IsModuleCorrupt(const CodeModule *module);
87  virtual void FillSourceLineInfo(StackFrame *frame);
88  virtual WindowsFrameInfo *FindWindowsFrameInfo(const StackFrame *frame);
89  virtual CFIFrameInfo *FindCFIFrameInfo(const StackFrame *frame);
90
91  // Nested structs and classes.
92  struct Line;
93  struct Function;
94  struct PublicSymbol;
95  struct CompareString {
96    bool operator()(const string &s1, const string &s2) const;
97  };
98  // Module is an interface for an in-memory symbol file.
99  class Module;
100  class AutoFileCloser;
101
102  // All of the modules that are loaded.
103  typedef map<string, Module*, CompareString> ModuleMap;
104  ModuleMap *modules_;
105
106  // The loaded modules that were detecting to be corrupt during load.
107  typedef set<string, CompareString> ModuleSet;
108  ModuleSet *corrupt_modules_;
109
110  // All of heap-allocated buffers that are owned locally by resolver.
111  typedef std::map<string, char*, CompareString> MemoryMap;
112  MemoryMap *memory_buffers_;
113
114  // Creates a concrete module at run-time.
115  ModuleFactory *module_factory_;
116
117 private:
118  // ModuleFactory needs to have access to protected type Module.
119  friend class ModuleFactory;
120
121  // Disallow unwanted copy ctor and assignment operator
122  SourceLineResolverBase(const SourceLineResolverBase&);
123  void operator=(const SourceLineResolverBase&);
124};
125
126}  // namespace google_breakpad
127
128#endif  // GOOGLE_BREAKPAD_PROCESSOR_SOURCE_LINE_RESOLVER_BASE_H__
129