SectionLoadHistory.h

Go to the documentation of this file.

//===-- SectionLoadHistory.h ------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#ifndef LLDB_TARGET_SECTIONLOADHISTORY_H
#define LLDB_TARGET_SECTIONLOADHISTORY_H
 
#include <map>
#include <mutex>
 
#include "lldb/lldb-public.h"
 
namespace lldb_private {
 
class SectionLoadHistory {
public:
  enum : unsigned {
    // Pass eStopIDNow to any function that takes a stop ID to get the current
    // value.
    eStopIDNow = UINT32_MAX
  };
  // Constructors and Destructors
  SectionLoadHistory() : m_stop_id_to_section_load_list(), m_mutex() {}
 
  ~SectionLoadHistory() {
    // Call clear since this takes a lock and clears the section load list in
    // case another thread is currently using this section load list
    Clear();
  }
 
  SectionLoadList &GetCurrentSectionLoadList();
 
  bool IsEmpty() const;
 
  void Clear();
 
  uint32_t GetLastStopID() const;
 
  // Get the section load address given a process stop ID
  lldb::addr_t GetSectionLoadAddress(uint32_t stop_id,
                                     const lldb::SectionSP &section_sp);
 
  bool ResolveLoadAddress(uint32_t stop_id, lldb::addr_t load_addr,
                          Address &so_addr);
 
  bool SetSectionLoadAddress(uint32_t stop_id,
                             const lldb::SectionSP &section_sp,
                             lldb::addr_t load_addr,
                             bool warn_multiple = false);
 
  // The old load address should be specified when unloading to ensure we get
  // the correct instance of the section as a shared library could be loaded at
  // more than one location.
  bool SetSectionUnloaded(uint32_t stop_id, const lldb::SectionSP &section_sp,
                          lldb::addr_t load_addr);
 
  // Unload all instances of a section. This function can be used on systems
  // that don't support multiple copies of the same shared library to be loaded
  // at the same time.
  size_t SetSectionUnloaded(uint32_t stop_id,
                            const lldb::SectionSP &section_sp);
 
  void Dump(Stream &s, Target *target);
 
protected:
  SectionLoadList *GetSectionLoadListForStopID(uint32_t stop_id,
                                               bool read_only);
 
  typedef std::map<uint32_t, lldb::SectionLoadListSP> StopIDToSectionLoadList;
  StopIDToSectionLoadList m_stop_id_to_section_load_list;
  mutable std::recursive_mutex m_mutex;
 
private:
  SectionLoadHistory(const SectionLoadHistory &) = delete;
  const SectionLoadHistory &operator=(const SectionLoadHistory &) = delete;
};
 
} // namespace lldb_private
 
#endif // LLDB_TARGET_SECTIONLOADHISTORY_H