intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-01-18 07:57:36 +08:00
Code Issues Packages Projects Releases Wiki Activity

Replicated the materialization logic for persistent

Browse Source 
variables in the Materializer.  We don't use this
code yet, but will soon once the other materializers
are online.

llvm-svn: 179390
This commit is contained in:
Sean Callanan
2013-04-12 18:10:34 +00:00
parent e14b765a89
commit 35005f768e
5 changed files with 389 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
lldb/source/Expression/IRMemoryMap.cpp
View File

@@ -7,15 +7,26 @@
//
//===----------------------------------------------------------------------===//
#include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h"
#include "lldb/Core/Scalar.h"
#include "lldb/Expression/IRMemoryMap.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"
using namespace lldb_private;
IRMemoryMap::IRMemoryMap (lldb::ProcessSP process_sp) :
m_process_wp(process_sp)
m_process_wp(process_sp),
m_target_wp(process_sp->GetTarget().shared_from_this())
{
}
IRMemoryMap::IRMemoryMap (lldb::TargetSP target_sp) :
m_process_wp(),
m_target_wp(target_sp)
{
}
@@ -97,6 +108,54 @@ IRMemoryMap::FindAllocation (lldb::addr_t addr, size_t size)
return m_allocations.end();
}
lldb::ByteOrder
IRMemoryMap::GetByteOrder()
{
lldb::ProcessSP process_sp = m_process_wp.lock();
if (process_sp)
return process_sp->GetByteOrder();
lldb::TargetSP target_sp = m_target_wp.lock();
if (target_sp)
return target_sp->GetDefaultArchitecture().GetByteOrder();
return lldb::eByteOrderInvalid;
}
uint32_t
IRMemoryMap::GetAddressByteSize()
{
lldb::ProcessSP process_sp = m_process_wp.lock();
if (process_sp)
return process_sp->GetAddressByteSize();
lldb::TargetSP target_sp = m_target_wp.lock();
if (target_sp)
return target_sp->GetDefaultArchitecture().GetAddressByteSize();
return UINT32_MAX;
}
ExecutionContextScope *
IRMemoryMap::GetBestExecutionContextScope()
{
lldb::ProcessSP process_sp = m_process_wp.lock();
if (process_sp)
return process_sp.get();
lldb::TargetSP target_sp = m_target_wp.lock();
if (target_sp)
return target_sp.get();
return NULL;
}
lldb::addr_t
IRMemoryMap::Malloc (size_t size, uint8_t alignment, uint32_t permissions, AllocationPolicy policy, Error &error)
{
@@ -335,6 +394,34 @@ IRMemoryMap::WriteMemory (lldb::addr_t process_address, const uint8_t *bytes, si
}
}
void
IRMemoryMap::WriteScalarToMemory (lldb::addr_t process_address, Scalar &scalar, size_t size, Error &error)
{
if (size == UINT32_MAX)
size = scalar.GetByteSize();
if (size > 0)
{
uint8_t buf[32];
const size_t mem_size = scalar.GetAsMemoryData (buf, size, GetByteOrder(), error);
if (mem_size > 0)
{
return WriteMemory(process_address, buf, mem_size, error);
}
else
{
error.SetErrorToGenericError();
error.SetErrorString ("Couldn't write scalar: failed to get scalar as memory data");
}
}
else
{
error.SetErrorToGenericError();
error.SetErrorString ("Couldn't write scalar: its size was zero");
}
return;
}
void
IRMemoryMap::ReadMemory (uint8_t *bytes, lldb::addr_t process_address, size_t size, Error &error)
{
@@ -408,3 +495,39 @@ IRMemoryMap::ReadMemory (uint8_t *bytes, lldb::addr_t process_address, size_t si
(uint64_t)allocation.m_process_start + (uint64_t)allocation.m_size);
}
}
void
IRMemoryMap::ReadScalarFromMemory (Scalar &scalar, lldb::addr_t process_address, size_t size, Error &error)
{
if (size > 0)
{
DataBufferHeap buf(size, 0);
ReadMemory(buf.GetBytes(), process_address, size, error);
if (!error.Success())
return;
DataExtractor extractor(buf.GetBytes(), buf.GetByteSize(), GetByteOrder(), GetAddressByteSize());
lldb::offset_t offset = 0;
switch (size)
{
default:
error.SetErrorToGenericError();
error.SetErrorStringWithFormat("Couldn't read scalar: unsupported size %lld", (unsigned long long)size);
return;
case 1: scalar = extractor.GetU8(&offset); break;
case 2: scalar = extractor.GetU16(&offset); break;
case 4: scalar = extractor.GetU32(&offset); break;
case 8: scalar = extractor.GetU64(&offset); break;
}
}
else
{
error.SetErrorToGenericError();
error.SetErrorString ("Couldn't write scalar: its size was zero");
}
return;
}