Class SharedCache

view/sharedcache/core/SharedCache.h:171–254

The C in DSC. This represents the entire cache, all regions and images are visible from here. This is the dump for all the information, and what the workflow activities and the UI want. Creating this is expensive, both in actual processing and just copying, so we only generate this once every time the database is open.

// Creating this is expensive, both in actual processing and just copying, so we only generate this
// once every time the database is open.
class SharedCache
{
	// Calculated within `AddEntry`, this indicates where the shared cache image is based at.
	uint64_t m_baseAddress = 0;
	// The shared cache can own the virtual memory, this is fine...
	std::shared_ptr<VirtualMemory> m_vm;
	std::vector<CacheEntry> m_entries {};
	// This information is used in tandem with the cache images to load memory regions into the binary view.
	AddressRangeMap<CacheRegion> m_regions {};
	// Describes the images of the cache.
	std::unordered_map<uint64_t, CacheImage> m_images {};
	// All the external symbols for this cache. Both mapped and unmapped (not in the view).
	std::unordered_map<uint64_t, CacheSymbol> m_symbols {};
	// Quickly lookup a symbol by name, populated by `FinalizeSymbols`.
	// `m_namedSymbols` is modified in a worker thread spawned by view init so we must not get a symbol until its populated.
	std::unordered_map<std::string, uint64_t> m_namedSymbols {};
	// Used to guard `m_namedSymbols` as it's accessed on multiple threads.
	// NOTE: Wrapped in unique_ptr to keep SharedCache movable.
	std::unique_ptr<std::shared_mutex> m_namedSymMutex;

	bool ProcessEntryImage(const std::string& path, const dyld_cache_image_info& info);

	// Add a region known not to overlap with another, otherwise use AddRegion.
	// returns whether the region was inserted.
	bool AddNonOverlappingRegion(CacheRegion region);

public:
	SharedCache() = default;
	explicit SharedCache(uint64_t addressSize);

	SharedCache(const SharedCache &) = delete;
	SharedCache &operator=(const SharedCache &) = delete;

	SharedCache(SharedCache &&) noexcept = default;
	SharedCache &operator=(SharedCache &&) noexcept = default;

	uint64_t GetBaseAddress() const { return m_baseAddress; }
	std::shared_ptr<VirtualMemory> GetVirtualMemory() const { return m_vm; }
	const std::vector<CacheEntry>& GetEntries() const { return m_entries; }
	const AddressRangeMap<CacheRegion>& GetRegions() const { return m_regions; }
	const std::unordered_map<uint64_t, CacheImage>& GetImages() const { return m_images; }
	const std::unordered_map<uint64_t, CacheSymbol>& GetSymbols() const { return m_symbols; }

	void AddImage(CacheImage&& image);

	// Add a region that may overlap with another.
	void AddRegion(CacheRegion&& region);

	void AddSymbol(CacheSymbol symbol);

	void AddSymbols(std::vector<CacheSymbol>&& symbols);

	// Adds the cache entry and populates the virtual memory using the mapping information.
	// After being added the entry is read only, there is nothing that can modify it.
	void AddEntry(CacheEntry entry);

	void ProcessEntryImages(const CacheEntry& entry);