2010-06-09 00:52:24 +08:00
|
|
|
//===-- RecordingMemoryManager.cpp ------------------------------*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
// C Includes
|
|
|
|
// C++ Includes
|
|
|
|
// Other libraries and framework includes
|
|
|
|
// Project includes
|
|
|
|
#include "lldb/Expression/RecordingMemoryManager.h"
|
|
|
|
|
|
|
|
using namespace lldb_private;
|
|
|
|
|
|
|
|
RecordingMemoryManager::RecordingMemoryManager () :
|
|
|
|
llvm::JITMemoryManager(),
|
|
|
|
m_default_mm_ap (llvm::JITMemoryManager::CreateDefaultMemManager())
|
|
|
|
{
|
2010-07-28 09:00:59 +08:00
|
|
|
m_log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
RecordingMemoryManager::~RecordingMemoryManager ()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RecordingMemoryManager::setMemoryWritable ()
|
|
|
|
{
|
|
|
|
m_default_mm_ap->setMemoryWritable();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RecordingMemoryManager::setMemoryExecutable ()
|
|
|
|
{
|
|
|
|
m_default_mm_ap->setMemoryExecutable();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
uint8_t *
|
|
|
|
RecordingMemoryManager::startFunctionBody(const llvm::Function *F,
|
|
|
|
uintptr_t &ActualSize)
|
|
|
|
{
|
|
|
|
uint8_t *return_value = m_default_mm_ap->startFunctionBody(F, ActualSize);
|
|
|
|
return return_value;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t *
|
|
|
|
RecordingMemoryManager::allocateStub(const llvm::GlobalValue* F, unsigned StubSize,
|
|
|
|
unsigned Alignment)
|
|
|
|
{
|
|
|
|
uint8_t *return_value = m_default_mm_ap->allocateStub(F, StubSize, Alignment);
|
|
|
|
m_stubs.insert (std::pair<uint8_t *,unsigned>(return_value, StubSize));
|
|
|
|
return return_value;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RecordingMemoryManager::endFunctionBody(const llvm::Function *F, uint8_t *FunctionStart,
|
|
|
|
uint8_t *FunctionEnd)
|
|
|
|
{
|
|
|
|
m_default_mm_ap->endFunctionBody(F, FunctionStart, FunctionEnd);
|
2010-07-28 09:00:59 +08:00
|
|
|
if (m_log)
|
|
|
|
m_log->Printf("Adding [%p-%p] to m_functions",
|
|
|
|
FunctionStart, FunctionEnd);
|
2010-06-09 00:52:24 +08:00
|
|
|
m_functions.insert(std::pair<uint8_t *, uint8_t *>(FunctionStart, FunctionEnd));
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t *
|
|
|
|
RecordingMemoryManager::allocateSpace(intptr_t Size, unsigned Alignment)
|
|
|
|
{
|
|
|
|
uint8_t *return_value = m_default_mm_ap->allocateSpace(Size, Alignment);
|
2010-07-28 09:00:59 +08:00
|
|
|
if (m_log)
|
|
|
|
m_log->Printf("RecordingMemoryManager::allocateSpace(Size=0x%llx, Alignment=%u) = %p",
|
|
|
|
(uint64_t)Size, Alignment, return_value);
|
2010-06-09 00:52:24 +08:00
|
|
|
m_spaceBlocks.insert (std::pair<uint8_t *, intptr_t>(return_value, Size));
|
|
|
|
return return_value;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t *
|
|
|
|
RecordingMemoryManager::allocateGlobal(uintptr_t Size, unsigned Alignment)
|
|
|
|
{
|
|
|
|
uint8_t *return_value = m_default_mm_ap->allocateGlobal(Size, Alignment);
|
2010-07-28 09:00:59 +08:00
|
|
|
if (m_log)
|
|
|
|
m_log->Printf("RecordingMemoryManager::allocateGlobal(Size=0x%llx, Alignment=%u) = %p",
|
|
|
|
(uint64_t)Size, Alignment, return_value);
|
2010-06-09 00:52:24 +08:00
|
|
|
m_globals.insert (std::pair<uint8_t *, uintptr_t>(return_value, Size));
|
|
|
|
return return_value;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RecordingMemoryManager::deallocateFunctionBody(void *Body)
|
|
|
|
{
|
|
|
|
m_default_mm_ap->deallocateFunctionBody(Body);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t*
|
|
|
|
RecordingMemoryManager::startExceptionTable(const llvm::Function* F,
|
|
|
|
uintptr_t &ActualSize)
|
|
|
|
{
|
|
|
|
uint8_t *return_value = m_default_mm_ap->startExceptionTable(F, ActualSize);
|
|
|
|
return return_value;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RecordingMemoryManager::endExceptionTable(const llvm::Function *F, uint8_t *TableStart,
|
|
|
|
uint8_t *TableEnd, uint8_t* FrameRegister)
|
|
|
|
{
|
|
|
|
m_default_mm_ap->endExceptionTable(F, TableStart, TableEnd, FrameRegister);
|
|
|
|
m_exception_tables.insert (std::pair<uint8_t *, uint8_t *>(TableStart, TableEnd));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RecordingMemoryManager::deallocateExceptionTable(void *ET)
|
|
|
|
{
|
|
|
|
m_default_mm_ap->deallocateExceptionTable (ET);
|
|
|
|
}
|
|
|
|
|
|
|
|
lldb::addr_t
|
|
|
|
RecordingMemoryManager::GetRemoteAddressForLocal (lldb::addr_t local_address)
|
|
|
|
{
|
|
|
|
std::vector<LocalToRemoteAddressRange>::iterator pos, end = m_address_map.end();
|
|
|
|
for (pos = m_address_map.begin(); pos < end; pos++)
|
|
|
|
{
|
|
|
|
lldb::addr_t lstart = (*pos).m_local_start;
|
|
|
|
if (local_address >= lstart && local_address < lstart + (*pos).m_size)
|
|
|
|
{
|
|
|
|
return (*pos).m_remote_start + (local_address - lstart);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return LLDB_INVALID_ADDRESS;
|
|
|
|
}
|
|
|
|
|
2010-07-23 10:19:15 +08:00
|
|
|
std::pair <lldb::addr_t, lldb::addr_t>
|
|
|
|
RecordingMemoryManager::GetRemoteRangeForLocal (lldb::addr_t local_address)
|
|
|
|
{
|
|
|
|
std::vector<LocalToRemoteAddressRange>::iterator pos, end = m_address_map.end();
|
|
|
|
|
|
|
|
for (pos = m_address_map.begin(); pos < end; ++pos)
|
|
|
|
{
|
|
|
|
lldb::addr_t lstart = pos->m_local_start;
|
|
|
|
lldb::addr_t lend = lstart + pos->m_size;
|
|
|
|
|
|
|
|
if (local_address >= lstart && local_address < lend)
|
|
|
|
{
|
|
|
|
return std::pair <lldb::addr_t, lldb::addr_t> (pos->m_remote_start, pos->m_remote_start + pos->m_size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return std::pair <lldb::addr_t, lldb::addr_t> (0, 0);
|
|
|
|
}
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
void
|
|
|
|
RecordingMemoryManager::AddToLocalToRemoteMap (lldb::addr_t lstart, size_t size, lldb::addr_t rstart)
|
|
|
|
{
|
2010-07-28 09:00:59 +08:00
|
|
|
if (m_log)
|
|
|
|
m_log->Printf("Adding local [0x%llx-0x%llx], remote [0x%llx-0x%llx] to local->remote map", lstart, lstart + size, rstart, rstart + size);
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
m_address_map.push_back (LocalToRemoteAddressRange(lstart, size, rstart));
|
|
|
|
}
|
|
|
|
|