mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-14 11:32:34 +00:00
14ef491582
use these to add support for C++ static ctors/dtors to the Orc-lazy JIT in LLI. Replace the trivial_retval_1 regression test - the new 'hello' test is covering strictly more code. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@233885 91177308-0d34-0410-b5e6-96231b3b80d8
103 lines
3.2 KiB
C++
103 lines
3.2 KiB
C++
//===---- ExecutionUtils.cpp - Utilities for executing functions in Orc ---===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
|
|
|
|
#include "llvm/IR/Constants.h"
|
|
#include "llvm/IR/Function.h"
|
|
#include "llvm/IR/GlobalVariable.h"
|
|
#include "llvm/IR/Module.h"
|
|
|
|
namespace llvm {
|
|
namespace orc {
|
|
|
|
CtorDtorIterator::CtorDtorIterator(const GlobalVariable *GV, bool End)
|
|
: InitList(
|
|
GV ? dyn_cast_or_null<ConstantArray>(GV->getInitializer()) : nullptr),
|
|
I((InitList && End) ? InitList->getNumOperands() : 0) {
|
|
}
|
|
|
|
bool CtorDtorIterator::operator==(const CtorDtorIterator &Other) const {
|
|
assert(InitList == Other.InitList && "Incomparable iterators.");
|
|
return I == Other.I;
|
|
}
|
|
|
|
bool CtorDtorIterator::operator!=(const CtorDtorIterator &Other) const {
|
|
return !(*this == Other);
|
|
}
|
|
|
|
CtorDtorIterator& CtorDtorIterator::operator++() {
|
|
++I;
|
|
return *this;
|
|
}
|
|
|
|
CtorDtorIterator CtorDtorIterator::operator++(int) {
|
|
CtorDtorIterator Temp = *this;
|
|
++I;
|
|
return Temp;
|
|
}
|
|
|
|
CtorDtorIterator::Element CtorDtorIterator::operator*() const {
|
|
ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(I));
|
|
assert(CS && "Unrecognized type in llvm.global_ctors/llvm.global_dtors");
|
|
|
|
Constant *FuncC = CS->getOperand(1);
|
|
Function *Func = nullptr;
|
|
|
|
// Extract function pointer, pulling off any casts.
|
|
while (FuncC) {
|
|
if (Function *F = dyn_cast_or_null<Function>(FuncC)) {
|
|
Func = F;
|
|
break;
|
|
} else if (ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(FuncC)) {
|
|
if (CE->isCast())
|
|
FuncC = dyn_cast_or_null<ConstantExpr>(CE->getOperand(0));
|
|
else
|
|
break;
|
|
} else {
|
|
// This isn't anything we recognize. Bail out with Func left set to null.
|
|
break;
|
|
}
|
|
}
|
|
|
|
ConstantInt *Priority = dyn_cast<ConstantInt>(CS->getOperand(0));
|
|
Value *Data = CS->getOperand(2);
|
|
return Element(Priority->getZExtValue(), Func, Data);
|
|
}
|
|
|
|
iterator_range<CtorDtorIterator> getConstructors(const Module &M) {
|
|
const GlobalVariable *CtorsList = M.getNamedGlobal("llvm.global_ctors");
|
|
return make_range(CtorDtorIterator(CtorsList, false),
|
|
CtorDtorIterator(CtorsList, true));
|
|
}
|
|
|
|
iterator_range<CtorDtorIterator> getDestructors(const Module &M) {
|
|
const GlobalVariable *DtorsList = M.getNamedGlobal("llvm.global_dtors");
|
|
return make_range(CtorDtorIterator(DtorsList, false),
|
|
CtorDtorIterator(DtorsList, true));
|
|
}
|
|
|
|
void LocalCXXRuntimeOverrides::runDestructors() {
|
|
auto& CXXDestructorDataPairs = DSOHandleOverride;
|
|
for (auto &P : CXXDestructorDataPairs)
|
|
P.first(P.second);
|
|
CXXDestructorDataPairs.clear();
|
|
}
|
|
|
|
int LocalCXXRuntimeOverrides::CXAAtExitOverride(DestructorPtr Destructor,
|
|
void *Arg, void *DSOHandle) {
|
|
auto& CXXDestructorDataPairs =
|
|
*reinterpret_cast<CXXDestructorDataPairList*>(DSOHandle);
|
|
CXXDestructorDataPairs.push_back(std::make_pair(Destructor, Arg));
|
|
return 0;
|
|
}
|
|
|
|
} // End namespace orc.
|
|
} // End namespace llvm.
|