This is an archive of the discontinued LLVM Phabricator instance.

Differential D5475

Adjust to LLVM JIT API change
ClosedPublic

Authored by endlessroad on Sep 23 2014, 5:06 PM.

Details

Reviewers
clayborg
tfiala
jasonmolenda

Diff Detail

Event Timeline

endlessroad updated this revision to Diff 14023.Sep 23 2014, 5:06 PM
endlessroad retitled this revision from to Adjust to LLVM JIT API change.
endlessroad updated this object.
endlessroad edited the test plan for this revision. (Show Details)
endlessroad added reviewers: tfiala, jasonmolenda, clayborg.
endlessroad added a subscriber: Unknown Object (MLST).
endlessroad added a comment.Sep 23 2014, 5:21 PM

Those wrapper functions seems not used by lldb... Removed

Reference for

  • replacing JITMemoryManager with SectionMemoryManager
  • replacing "llvm::JITMemoryManager::CreateDefaultMemManager()" with "new llvm::SectionMemoryManager()"

http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-jitlistener/llvm-jitlistener.cpp?r1=218316&r2=218315&pathrev=218316

tfiala edited edge metadata.Sep 24 2014, 8:44 AM

Having a look at this now.

tfiala accepted this revision.Sep 24 2014, 9:02 AM
tfiala edited edge metadata.

LGTM. Fix going in shortly.

This revision is now accepted and ready to land.Sep 24 2014, 9:02 AM
tfiala closed this revision.Sep 24 2014, 9:06 AM

svn commit
Sending include/lldb/Expression/ClangUserExpression.h
Sending include/lldb/Expression/IRExecutionUnit.h
Sending source/Expression/IRExecutionUnit.cpp
Transmitting file data ...
Committed revision 218383.

Revision Contents

PathSize
include/
lldb/
Expression/
2 lines
157 lines
source/
Expression/
113 lines

Diff 14023

include/lldb/Expression/ClangUserExpression.h

Context not available.
#include "lldb/Symbol/TaggedASTType.h" #include "lldb/Symbol/TaggedASTType.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "llvm/ExecutionEngine/JITMemoryManager.h"
namespace lldb_private namespace lldb_private
{ {
Context not available.

include/lldb/Expression/IRExecutionUnit.h

Context not available.
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "lldb/Core/ClangForward.h" #include "lldb/Core/ClangForward.h"
#include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferHeap.h"
#include "llvm/ExecutionEngine/JITMemoryManager.h" #include "llvm/ExecutionEngine/SectionMemoryManager.h"
#include "lldb/Expression/ClangExpression.h" #include "lldb/Expression/ClangExpression.h"
#include "lldb/Expression/ClangExpressionParser.h" #include "lldb/Expression/ClangExpressionParser.h"
#include "lldb/Expression/IRMemoryMap.h" #include "lldb/Expression/IRMemoryMap.h"
Context not available.
/// then be used as input to the IR interpreter, or the address of the /// then be used as input to the IR interpreter, or the address of the
/// executable code can be passed to a thread plan to run in the target. /// executable code can be passed to a thread plan to run in the target.
/// ///
/// This class creates a subclass of LLVM's JITMemoryManager, because that is /// This class creates a subclass of LLVM's SectionMemoryManager, because that is
/// how the JIT emits code. Because LLDB needs to move JIT-compiled code /// how the JIT emits code. Because LLDB needs to move JIT-compiled code
/// into the target process, the IRExecutionUnit knows how to copy the /// into the target process, the IRExecutionUnit knows how to copy the
/// emitted code into the target process. /// emitted code into the target process.
Context not available.
DisassembleFunction (Stream &stream, DisassembleFunction (Stream &stream,
lldb::ProcessSP &process_sp); lldb::ProcessSP &process_sp);
class MemoryManager : public llvm::JITMemoryManager class MemoryManager : public llvm::SectionMemoryManager
{ {
public: public:
MemoryManager (IRExecutionUnit &parent); MemoryManager (IRExecutionUnit &parent);
virtual ~MemoryManager(); virtual ~MemoryManager();
//------------------------------------------------------------------
/// Passthrough interface stub
//------------------------------------------------------------------
virtual void setMemoryWritable ();
//------------------------------------------------------------------
/// Passthrough interface stub
//------------------------------------------------------------------
virtual void setMemoryExecutable ();
//------------------------------------------------------------------
/// Passthrough interface stub
//------------------------------------------------------------------
virtual void setPoisonMemory (bool poison)
{
m_default_mm_ap->setPoisonMemory (poison);
}
//------------------------------------------------------------------
/// Passthrough interface stub
//------------------------------------------------------------------
virtual void AllocateGOT()
{
m_default_mm_ap->AllocateGOT();
}
//------------------------------------------------------------------
/// Passthrough interface stub
//------------------------------------------------------------------
virtual uint8_t *getGOTBase() const
{
return m_default_mm_ap->getGOTBase();
}
//------------------------------------------------------------------
/// Passthrough interface stub
//------------------------------------------------------------------
virtual uint8_t *startFunctionBody(const llvm::Function *F,
uintptr_t &ActualSize);
//------------------------------------------------------------------
/// Allocate room for a dyld stub for a lazy-referenced function,
/// and add it to the m_stubs map
///
/// @param[in] F
/// The function being referenced.
///
/// @param[in] StubSize
/// The size of the stub.
///
/// @param[in] Alignment
/// The required alignment of the stub.
///
/// @return
/// Allocated space for the stub.
//------------------------------------------------------------------
virtual uint8_t *allocateStub(const llvm::GlobalValue* F,
unsigned StubSize,
unsigned Alignment);
//------------------------------------------------------------------
/// Complete the body of a function, and add it to the m_functions map
///
/// @param[in] F
/// The function being completed.
///
/// @param[in] FunctionStart
/// The first instruction of the function.
///
/// @param[in] FunctionEnd
/// The last byte of the last instruction of the function.
//------------------------------------------------------------------
virtual void endFunctionBody(const llvm::Function *F,
uint8_t *FunctionStart,
uint8_t *FunctionEnd);
//------------------------------------------------------------------
/// Allocate space for an unspecified purpose, and add it to the
/// m_spaceBlocks map
///
/// @param[in] Size
/// The size of the area.
///
/// @param[in] Alignment
/// The required alignment of the area.
///
/// @return
/// Allocated space.
//------------------------------------------------------------------
virtual uint8_t *allocateSpace(intptr_t Size, unsigned Alignment);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Allocate space for executable code, and add it to the /// Allocate space for executable code, and add it to the
Context not available.
bool IsReadOnly); bool IsReadOnly);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Allocate space for a global variable, and add it to the
/// m_spaceBlocks map
///
/// @param[in] Size
/// The size of the variable.
///
/// @param[in] Alignment
/// The required alignment of the variable.
///
/// @return
/// Allocated space for the global.
//------------------------------------------------------------------
virtual uint8_t *allocateGlobal(uintptr_t Size,
unsigned Alignment);
//------------------------------------------------------------------
/// Called when object loading is complete and section page /// Called when object loading is complete and section page
/// permissions can be applied. Currently unimplemented for LLDB. /// permissions can be applied. Currently unimplemented for LLDB.
/// ///
Context not available.
return false; return false;
} }
//------------------------------------------------------------------
/// Passthrough interface stub
//------------------------------------------------------------------
virtual void deallocateFunctionBody(void *Body);
//------------------------------------------------------------------
/// Passthrough interface stub
//------------------------------------------------------------------
virtual size_t GetDefaultCodeSlabSize() {
return m_default_mm_ap->GetDefaultCodeSlabSize();
}
//------------------------------------------------------------------
/// Passthrough interface stub
//------------------------------------------------------------------
virtual size_t GetDefaultDataSlabSize() {
return m_default_mm_ap->GetDefaultDataSlabSize();
}
virtual size_t GetDefaultStubSlabSize() {
return m_default_mm_ap->GetDefaultStubSlabSize();
}
//------------------------------------------------------------------
/// Passthrough interface stub
//------------------------------------------------------------------
virtual unsigned GetNumCodeSlabs() {
return m_default_mm_ap->GetNumCodeSlabs();
}
//------------------------------------------------------------------
/// Passthrough interface stub
//------------------------------------------------------------------
virtual unsigned GetNumDataSlabs() {
return m_default_mm_ap->GetNumDataSlabs();
}
//------------------------------------------------------------------
/// Passthrough interface stub
//------------------------------------------------------------------
virtual unsigned GetNumStubSlabs() {
return m_default_mm_ap->GetNumStubSlabs();
}
virtual void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) { virtual void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) {
return m_default_mm_ap->registerEHFrames(Addr, LoadAddr, Size); return m_default_mm_ap->registerEHFrames(Addr, LoadAddr, Size);
} }
Context not available.
return m_default_mm_ap->getPointerToNamedFunction(Name, AbortOnFailure); return m_default_mm_ap->getPointerToNamedFunction(Name, AbortOnFailure);
} }
private: private:
std::unique_ptr<JITMemoryManager> m_default_mm_ap; ///< The memory allocator to use in actually creating space. All calls are passed through to it. std::unique_ptr<SectionMemoryManager> m_default_mm_ap; ///< The memory allocator to use in actually creating space. All calls are passed through to it.
IRExecutionUnit &m_parent; ///< The execution unit this is a proxy for. IRExecutionUnit &m_parent; ///< The execution unit this is a proxy for.
}; };
Context not available.

source/Expression/IRExecutionUnit.cpp

Context not available.
builder.setEngineKind(llvm::EngineKind::JIT) builder.setEngineKind(llvm::EngineKind::JIT)
.setErrorStr(&error_string) .setErrorStr(&error_string)
.setRelocationModel(relocModel) .setRelocationModel(relocModel)
.setJITMemoryManager(new MemoryManager(*this)) .setMCJITMemoryManager(new MemoryManager(*this))
.setCodeModel(codeModel) .setCodeModel(codeModel)
.setOptLevel(llvm::CodeGenOpt::Less); .setOptLevel(llvm::CodeGenOpt::Less);
Context not available.
} }
IRExecutionUnit::MemoryManager::MemoryManager (IRExecutionUnit &parent) : IRExecutionUnit::MemoryManager::MemoryManager (IRExecutionUnit &parent) :
m_default_mm_ap (llvm::JITMemoryManager::CreateDefaultMemManager()), m_default_mm_ap (new llvm::SectionMemoryManager()),
m_parent (parent) m_parent (parent)
{ {
} }
Context not available.
IRExecutionUnit::MemoryManager::~MemoryManager () IRExecutionUnit::MemoryManager::~MemoryManager ()
{ {
} }
void
IRExecutionUnit::MemoryManager::setMemoryWritable ()
{
m_default_mm_ap->setMemoryWritable();
}
void
IRExecutionUnit::MemoryManager::setMemoryExecutable ()
{
m_default_mm_ap->setMemoryExecutable();
}
uint8_t *
IRExecutionUnit::MemoryManager::startFunctionBody(const llvm::Function *F,
uintptr_t &ActualSize)
{
return m_default_mm_ap->startFunctionBody(F, ActualSize);
}
uint8_t *
IRExecutionUnit::MemoryManager::allocateStub(const llvm::GlobalValue* F,
unsigned StubSize,
unsigned Alignment)
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
uint8_t *return_value = m_default_mm_ap->allocateStub(F, StubSize, Alignment);
m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value,
lldb::ePermissionsReadable | lldb::ePermissionsWritable,
GetSectionTypeFromSectionName (llvm::StringRef(), AllocationKind::Stub),
StubSize,
Alignment,
eSectionIDInvalid,
NULL));
if (log)
{
log->Printf("IRExecutionUnit::allocateStub (F=%p, StubSize=%u, Alignment=%u) = %p",
static_cast<const void*>(F), StubSize, Alignment,
static_cast<void*>(return_value));
}
return return_value;
}
void
IRExecutionUnit::MemoryManager::endFunctionBody(const llvm::Function *F,
uint8_t *FunctionStart,
uint8_t *FunctionEnd)
{
m_default_mm_ap->endFunctionBody(F, FunctionStart, FunctionEnd);
}
lldb::SectionType lldb::SectionType
IRExecutionUnit::GetSectionTypeFromSectionName (const llvm::StringRef &name, IRExecutionUnit::AllocationKind alloc_kind) IRExecutionUnit::GetSectionTypeFromSectionName (const llvm::StringRef &name, IRExecutionUnit::AllocationKind alloc_kind)
Context not available.
} }
uint8_t * uint8_t *
IRExecutionUnit::MemoryManager::allocateSpace(intptr_t Size, unsigned Alignment)
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
uint8_t *return_value = m_default_mm_ap->allocateSpace(Size, Alignment);
m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value,
lldb::ePermissionsReadable | lldb::ePermissionsWritable,
GetSectionTypeFromSectionName (llvm::StringRef(), AllocationKind::Bytes),
Size,
Alignment,
eSectionIDInvalid,
NULL));
if (log)
{
log->Printf("IRExecutionUnit::allocateSpace(Size=%" PRIu64 ", Alignment=%u) = %p",
(uint64_t)Size, Alignment, return_value);
}
return return_value;
}
uint8_t *
IRExecutionUnit::MemoryManager::allocateCodeSection(uintptr_t Size, IRExecutionUnit::MemoryManager::allocateCodeSection(uintptr_t Size,
unsigned Alignment, unsigned Alignment,
unsigned SectionID, unsigned SectionID,
Context not available.
return return_value; return return_value;
} }
uint8_t *
IRExecutionUnit::MemoryManager::allocateGlobal(uintptr_t Size,
unsigned Alignment)
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
uint8_t *return_value = m_default_mm_ap->allocateGlobal(Size, Alignment);
m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value,
lldb::ePermissionsReadable | lldb::ePermissionsWritable,
GetSectionTypeFromSectionName (llvm::StringRef(), AllocationKind::Global),
Size,
Alignment,
eSectionIDInvalid,
NULL));
if (log)
{
log->Printf("IRExecutionUnit::allocateGlobal(Size=0x%" PRIx64 ", Alignment=%u) = %p",
(uint64_t)Size, Alignment, return_value);
}
return return_value;
}
void
IRExecutionUnit::MemoryManager::deallocateFunctionBody(void *Body)
{
m_default_mm_ap->deallocateFunctionBody(Body);
}
lldb::addr_t lldb::addr_t
IRExecutionUnit::GetRemoteAddressForLocal (lldb::addr_t local_address) IRExecutionUnit::GetRemoteAddressForLocal (lldb::addr_t local_address)
{ {
Context not available.