| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef SRC_DEVELOPER_DEBUG_ZXDB_SYMBOLS_TARGET_SYMBOLS_H_ |
| #define SRC_DEVELOPER_DEBUG_ZXDB_SYMBOLS_TARGET_SYMBOLS_H_ |
| |
| #include <set> |
| |
| #include "src/developer/debug/zxdb/symbols/system_symbols.h" |
| |
| namespace zxdb { |
| |
| struct InputLocation; |
| class Location; |
| struct ResolveOptions; |
| class SessionSymbolsImpl; |
| |
| // Symbol interface for a Target. A target may or may not have a process, so this interface does not |
| // deal with anything related to addresses. See ProcessSymbols for that (which is most of the |
| // stuff). |
| // |
| // We can know about symbols associated with a target even when the process isn't loaded. For |
| // example, when setting a breakpoint on a symbol we can validate that it's a real symbol. |
| // |
| // The current implementation is that all modifications to the list of symbol modules is done by the |
| // ProcessSymbols which knows the actual symbols of the running program. This provides the minor |
| // benefit of symbols being available between identical runs of the same binary (useful for setting |
| // breakpoints). |
| // |
| // More useful would be that the symbols could be automatically loaded when we know the binary we'll |
| // be running, regardless of whether it's been started yet. This requires some system integration |
| // (how do you find the local binary for something on the target?) and may also depend on how |
| // typical programs will be started in the debugger (which may evolve). |
| class TargetSymbols { |
| public: |
| // This class is copyable and assignable (to support cloning Targets). The SessionSymbolsImpl |
| // object must outlive this class. |
| explicit TargetSymbols(SystemSymbols* system_symbols); |
| TargetSymbols(const TargetSymbols& other); |
| ~TargetSymbols(); |
| |
| TargetSymbols& operator=(const TargetSymbols& other); |
| |
| SystemSymbols* system_symbols() { return system_symbols_; } |
| |
| // Notifications from ProcessSymbols to keep things in sync. Multiple add notifications are |
| // allowed for the same module (this happens when the symbols exist, then the process is started |
| // and the module is loaded for real). |
| void AddModule(fxl::RefPtr<ModuleSymbols> module); |
| |
| // Returns |modules_| to the caller and clears |module_|. |
| std::vector<fxl::RefPtr<ModuleSymbols>> TakeModules(); |
| |
| // Returns the symbol information for all the modules known for this target. |
| std::vector<const ModuleSymbols*> GetModuleSymbols() const; |
| |
| // Converts the given InputLocation into one or more locations. The input can match zero, one, or |
| // many locations. |
| // |
| // If symbolize is true, the results will be symbolized, otherwise the output locations will be |
| // regular addresses (this will be slightly faster). |
| // |
| // This function will assert if given a kAddress-based InputLocation since that requires a running |
| // process. If you need that, use the variant on ProcessSymbols. |
| // |
| // Since the modules aren't loaded, there are no load addresses. As a result, all output addresses |
| // will be 0. This function's purpose is to expand file/line information for symbols. |
| std::vector<Location> ResolveInputLocation(const InputLocation& input_location, |
| const ResolveOptions& options) const; |
| |
| // Gets file matches across all known modules. Unlike ModuleSymbols::FindFileMatches(), it returns |
| // a list of pairs of filenames and build directories associated with the filenames. |
| std::vector<std::pair<std::string, std::string>> FindFileMatches(std::string_view name) const; |
| |
| // Returns the shortest possible name that uniquely identifies the given file in the index. |
| // |
| // Multiple files with the same name can exist in the different directories. If a name is unique, |
| // returns only the name part, otherwise appends directories from the right until the input is |
| // disambiguated from all other files of the same name. |
| // |
| // If the name isn't in the index, returns just the file part. |
| std::string GetShortestUniqueFileName(std::string_view file_name) const; |
| |
| private: |
| // Comparison functor for modules. Does a pointer-identity comparison of the refptr. |
| struct ModuleRefComparePtr { |
| bool operator()(const fxl::RefPtr<ModuleSymbols>& a, const fxl::RefPtr<ModuleSymbols>& b) const; |
| }; |
| |
| SystemSymbols* const system_symbols_; // Non-owning. |
| |
| // Since there are no addresses, there is no real ordering of these modules. Track them by pointer |
| // identity to make keeping in sync with the ProcessSymbols more efficient. |
| std::set<fxl::RefPtr<ModuleSymbols>, ModuleRefComparePtr> modules_; |
| }; |
| |
| } // namespace zxdb |
| |
| #endif // SRC_DEVELOPER_DEBUG_ZXDB_SYMBOLS_TARGET_SYMBOLS_H_ |