xref: /external/lldb/include/lldb/Target/Memory.h

//===-- Memory.h ------------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef liblldb_Memory_h_
#define liblldb_Memory_h_

// C Includes
// C++ Includes
#include <map>
#include <vector>

// Other libraries and framework includes

// Project includes
#include "lldb/lldb-private.h"
#include "lldb/Core/RangeMap.h"
#include "lldb/Host/Mutex.h"

namespace lldb_private {
    //----------------------------------------------------------------------
    // A class to track memory that was read from a live process between
    // runs.
    //----------------------------------------------------------------------
    class MemoryCache
    {
    public:
        //------------------------------------------------------------------
        // Constructors and Destructors
        //------------------------------------------------------------------
        MemoryCache (Process &process);

        ~MemoryCache ();

        void
        Clear(bool clear_invalid_ranges = false);

        void
        Flush (lldb::addr_t addr, size_t size);

        size_t
        Read (lldb::addr_t addr,
              void *dst,
              size_t dst_len,
              Error &error);

        uint32_t
        GetMemoryCacheLineSize() const
        {
            return m_cache_line_byte_size ;
        }

        void
        AddInvalidRange (lldb::addr_t base_addr, lldb::addr_t byte_size);

        bool
        RemoveInvalidRange (lldb::addr_t base_addr, lldb::addr_t byte_size);

    protected:
        typedef std::map<lldb::addr_t, lldb::DataBufferSP> BlockMap;
        typedef RangeArray<lldb::addr_t, lldb::addr_t, 4> InvalidRanges;
        //------------------------------------------------------------------
        // Classes that inherit from MemoryCache can see and modify these
        //------------------------------------------------------------------
        Process &m_process;
        uint32_t m_cache_line_byte_size;
        Mutex m_mutex;
        BlockMap m_cache;
        InvalidRanges m_invalid_ranges;
    private:
        DISALLOW_COPY_AND_ASSIGN (MemoryCache);
    };


    class AllocatedBlock
    {
    public:
        AllocatedBlock (lldb::addr_t addr,
                        uint32_t byte_size,
                        uint32_t permissions,
                        uint32_t chunk_size);

        ~AllocatedBlock ();

        lldb::addr_t
        ReserveBlock (uint32_t size);

        bool
        FreeBlock (lldb::addr_t addr);

        lldb::addr_t
        GetBaseAddress () const
        {
            return m_addr;
        }

        uint32_t
        GetByteSize () const
        {
            return m_byte_size;
        }

        uint32_t
        GetPermissions () const
        {
            return m_permissions;
        }

        uint32_t
        GetChunkSize () const
        {
            return m_chunk_size;
        }

        bool
        Contains (lldb::addr_t addr) const
        {
            return ((addr >= m_addr) && addr < (m_addr + m_byte_size));
        }
    protected:
        uint32_t
        TotalChunks () const
        {
            return m_byte_size / m_chunk_size;
        }

        uint32_t
        CalculateChunksNeededForSize (uint32_t size) const
        {
            return (size + m_chunk_size - 1) / m_chunk_size;
        }
        const lldb::addr_t m_addr;    // Base address of this block of memory
        const uint32_t m_byte_size;   // 4GB of chunk should be enough...
        const uint32_t m_permissions; // Permissions for this memory (logical OR of lldb::Permissions bits)
        const uint32_t m_chunk_size;  // The size of chunks that the memory at m_addr is divied up into
        typedef std::map<uint32_t, uint32_t> OffsetToChunkSize;
        OffsetToChunkSize m_offset_to_chunk_size;
    };


    //----------------------------------------------------------------------
    // A class that can track allocated memory and give out allocated memory
    // without us having to make an allocate/deallocate call every time we
    // need some memory in a process that is being debugged.
    //----------------------------------------------------------------------
    class AllocatedMemoryCache
    {
    public:
        //------------------------------------------------------------------
        // Constructors and Destructors
        //------------------------------------------------------------------
        AllocatedMemoryCache (Process &process);

        ~AllocatedMemoryCache ();

        void
        Clear();

        lldb::addr_t
        AllocateMemory (size_t byte_size,
                        uint32_t permissions,
                        Error &error);

        bool
        DeallocateMemory (lldb::addr_t ptr);

    protected:
        typedef std::shared_ptr<AllocatedBlock> AllocatedBlockSP;

        AllocatedBlockSP
        AllocatePage (uint32_t byte_size,
                      uint32_t permissions,
                      uint32_t chunk_size,
                      Error &error);


        //------------------------------------------------------------------
        // Classes that inherit from MemoryCache can see and modify these
        //------------------------------------------------------------------
        Process &m_process;
        Mutex m_mutex;
        typedef std::multimap<uint32_t, AllocatedBlockSP> PermissionsToBlockMap;
        PermissionsToBlockMap m_memory_map;

    private:
        DISALLOW_COPY_AND_ASSIGN (AllocatedMemoryCache);
    };

} // namespace lldb_private

#endif  // liblldb_Memory_h_