6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-06-30 23:30:28 +00:00
Code Issues Projects Releases Wiki Activity

[ExecutionEngine] ArrayRefize argument passing.

Browse Source 
No functionality change intended.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@239687 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Benjamin Kramer 2015-06-13 19:50:29 +00:00
parent 09eacc1144
commit 4bb355e885
10 changed files with 34 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/llvm/ExecutionEngine/ExecutionEngine.h
View File

@ -205,7 +205,7 @@ public:
/// runFunction - Execute the specified function with the specified arguments,
/// and return the result.
virtual GenericValue runFunction(Function *F,
const std::vector<GenericValue> &ArgValues) = 0;
ArrayRef<GenericValue> ArgValues) = 0;
/// getPointerToNamedFunction - This method returns the address of the
/// specified function by using the dlsym function call. As such it is only

2
lib/ExecutionEngine/ExecutionEngine.cpp
View File

@ -376,7 +376,7 @@ void ExecutionEngine::runStaticConstructorsDestructors(Module &module,
// Execute the ctor/dtor function!
if (Function *F = dyn_cast<Function>(FP))
runFunction(F, std::vector<GenericValue>());
runFunction(F, None);
// FIXME: It is marginally lame that we just do nothing here if we see an
// entry we don't recognize. It might not be unreasonable for the verifier

3
lib/ExecutionEngine/Interpreter/Execution.cpp
View File

@ -2073,8 +2073,7 @@ GenericValue Interpreter::getOperandValue(Value *V, ExecutionContext &SF) {
//===----------------------------------------------------------------------===//
// callFunction - Execute the specified function...
//
void Interpreter::callFunction(Function *F,
const std::vector<GenericValue> &ArgVals) {
void Interpreter::callFunction(Function *F, ArrayRef<GenericValue> ArgVals) {
assert((ECStack.empty() || !ECStack.back().Caller.getInstruction() ||
ECStack.back().Caller.arg_size() == ArgVals.size()) &&
"Incorrect number of arguments passed into function call!");

49
lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp
View File

@ -49,8 +49,7 @@ using namespace llvm;
static ManagedStatic<sys::Mutex> FunctionsLock;
typedef GenericValue (*ExFunc)(FunctionType *,
const std::vector<GenericValue> &);
typedef GenericValue (*ExFunc)(FunctionType *, ArrayRef<GenericValue>);
static ManagedStatic<std::map<const Function *, ExFunc> > ExportedFunctions;
static ManagedStatic<std::map<std::string, ExFunc> > FuncNames;
@ -178,8 +177,7 @@ static void *ffiValueFor(Type *Ty, const GenericValue &AV,
return NULL;
}
static bool ffiInvoke(RawFunc Fn, Function *F,
const std::vector<GenericValue> &ArgVals,
static bool ffiInvoke(RawFunc Fn, Function *F, ArrayRef<GenericValue> ArgVals,
const DataLayout *TD, GenericValue &Result) {
ffi_cif cif;
FunctionType *FTy = F->getFunctionType();
@ -245,7 +243,7 @@ static bool ffiInvoke(RawFunc Fn, Function *F,
#endif // USE_LIBFFI
GenericValue Interpreter::callExternalFunction(Function *F,
const std::vector<GenericValue> &ArgVals) {
ArrayRef<GenericValue> ArgVals) {
TheInterpreter = this;
unique_lock<sys::Mutex> Guard(*FunctionsLock);
@ -298,9 +296,8 @@ GenericValue Interpreter::callExternalFunction(Function *F,
//
// void atexit(Function*)
static
GenericValue lle_X_atexit(FunctionType *FT,
const std::vector<GenericValue> &Args) {
static GenericValue lle_X_atexit(FunctionType *FT,
ArrayRef<GenericValue> Args) {
assert(Args.size() == 1);
TheInterpreter->addAtExitHandler((Function*)GVTOP(Args[0]));
GenericValue GV;
@ -309,17 +306,13 @@ GenericValue lle_X_atexit(FunctionType *FT,
}
// void exit(int)
static
GenericValue lle_X_exit(FunctionType *FT,
const std::vector<GenericValue> &Args) {
static GenericValue lle_X_exit(FunctionType *FT, ArrayRef<GenericValue> Args) {
TheInterpreter->exitCalled(Args[0]);
return GenericValue();
}
// void abort(void)
static
GenericValue lle_X_abort(FunctionType *FT,
const std::vector<GenericValue> &Args) {
static GenericValue lle_X_abort(FunctionType *FT, ArrayRef<GenericValue> Args) {
//FIXME: should we report or raise here?
//report_fatal_error("Interpreted program raised SIGABRT");
raise (SIGABRT);
@ -328,9 +321,8 @@ GenericValue lle_X_abort(FunctionType *FT,
// int sprintf(char *, const char *, ...) - a very rough implementation to make
// output useful.
static
GenericValue lle_X_sprintf(FunctionType *FT,
const std::vector<GenericValue> &Args) {
static GenericValue lle_X_sprintf(FunctionType *FT,
ArrayRef<GenericValue> Args) {
char *OutputBuffer = (char *)GVTOP(Args[0]);
const char *FmtStr = (const char *)GVTOP(Args[1]);
unsigned ArgNo = 2;
@ -411,9 +403,8 @@ GenericValue lle_X_sprintf(FunctionType *FT,
// int printf(const char *, ...) - a very rough implementation to make output
// useful.
static
GenericValue lle_X_printf(FunctionType *FT,
const std::vector<GenericValue> &Args) {
static GenericValue lle_X_printf(FunctionType *FT,
ArrayRef<GenericValue> Args) {
char Buffer[10000];
std::vector<GenericValue> NewArgs;
NewArgs.push_back(PTOGV((void*)&Buffer[0]));
@ -424,9 +415,8 @@ GenericValue lle_X_printf(FunctionType *FT,
}
// int sscanf(const char *format, ...);
static
GenericValue lle_X_sscanf(FunctionType *FT,
const std::vector<GenericValue> &args) {
static GenericValue lle_X_sscanf(FunctionType *FT,
ArrayRef<GenericValue> args) {
assert(args.size() < 10 && "Only handle up to 10 args to sscanf right now!");
char *Args[10];
@ -440,9 +430,7 @@ GenericValue lle_X_sscanf(FunctionType *FT,
}
// int scanf(const char *format, ...);
static
GenericValue lle_X_scanf(FunctionType *FT,
const std::vector<GenericValue> &args) {
static GenericValue lle_X_scanf(FunctionType *FT, ArrayRef<GenericValue> args) {
assert(args.size() < 10 && "Only handle up to 10 args to scanf right now!");
char *Args[10];
@ -457,9 +445,8 @@ GenericValue lle_X_scanf(FunctionType *FT,
// int fprintf(FILE *, const char *, ...) - a very rough implementation to make
// output useful.
static
GenericValue lle_X_fprintf(FunctionType *FT,
const std::vector<GenericValue> &Args) {
static GenericValue lle_X_fprintf(FunctionType *FT,
ArrayRef<GenericValue> Args) {
assert(Args.size() >= 2);
char Buffer[10000];
std::vector<GenericValue> NewArgs;
@ -472,7 +459,7 @@ GenericValue lle_X_fprintf(FunctionType *FT,
}
static GenericValue lle_X_memset(FunctionType *FT,
const std::vector<GenericValue> &Args) {
ArrayRef<GenericValue> Args) {
int val = (int)Args[1].IntVal.getSExtValue();
size_t len = (size_t)Args[2].IntVal.getZExtValue();
memset((void *)GVTOP(Args[0]), val, len);
@ -484,7 +471,7 @@ static GenericValue lle_X_memset(FunctionType *FT,
}
static GenericValue lle_X_memcpy(FunctionType *FT,
const std::vector<GenericValue> &Args) {
ArrayRef<GenericValue> Args) {
memcpy(GVTOP(Args[0]), GVTOP(Args[1]),
(size_t)(Args[2].IntVal.getLimitedValue()));

14
lib/ExecutionEngine/Interpreter/Interpreter.cpp
View File

@ -67,7 +67,7 @@ Interpreter::~Interpreter() {
void Interpreter::runAtExitHandlers () {
while (!AtExitHandlers.empty()) {
callFunction(AtExitHandlers.back(), std::vector<GenericValue>());
callFunction(AtExitHandlers.back(), None);
AtExitHandlers.pop_back();
run();
}
@ -75,9 +75,8 @@ void Interpreter::runAtExitHandlers () {
/// run - Start execution with the specified function and arguments.
///
GenericValue
Interpreter::runFunction(Function *F,
const std::vector<GenericValue> &ArgValues) {
GenericValue Interpreter::runFunction(Function *F,
ArrayRef<GenericValue> ArgValues) {
assert (F && "Function *F was null at entry to run()");
// Try extra hard not to pass extra args to a function that isn't
@ -87,10 +86,9 @@ Interpreter::runFunction(Function *F,
// parameters than it is declared to take. This does not attempt to
// take into account gratuitous differences in declared types,
// though.
std::vector<GenericValue> ActualArgs;
const unsigned ArgCount = F->getFunctionType()->getNumParams();
for (unsigned i = 0; i < ArgCount; ++i)
ActualArgs.push_back(ArgValues[i]);
const size_t ArgCount = F->getFunctionType()->getNumParams();
ArrayRef<GenericValue> ActualArgs =
ArgValues.slice(0, std::min(ArgValues.size(), ArgCount));
// Set up the function call.
callFunction(F, ActualArgs);

6
lib/ExecutionEngine/Interpreter/Interpreter.h
View File

@ -127,7 +127,7 @@ public:
/// run - Start execution with the specified function and arguments.
///
GenericValue runFunction(Function *F,
const std::vector<GenericValue> &ArgValues) override;
ArrayRef<GenericValue> ArgValues) override;
void *getPointerToNamedFunction(StringRef Name,
bool AbortOnFailure = true) override {
@ -137,7 +137,7 @@ public:
// Methods used to execute code:
// Place a call on the stack
void callFunction(Function *F, const std::vector<GenericValue> &ArgVals);
void callFunction(Function *F, ArrayRef<GenericValue> ArgVals);
void run(); // Execute instructions until nothing left to do
// Opcode Implementations
@ -194,7 +194,7 @@ public:
}
GenericValue callExternalFunction(Function *F,
const std::vector<GenericValue> &ArgVals);
ArrayRef<GenericValue> ArgVals);
void exitCalled(GenericValue GV);
void addAtExitHandler(Function *F) {

3
lib/ExecutionEngine/MCJIT/MCJIT.cpp
View File

@ -441,8 +441,7 @@ Function *MCJIT::FindFunctionNamed(const char *FnName) {
return F;
}
GenericValue MCJIT::runFunction(Function *F,
const std::vector<GenericValue> &ArgValues) {
GenericValue MCJIT::runFunction(Function *F, ArrayRef<GenericValue> ArgValues) {
assert(F && "Function *F was null at entry to run()");
void *FPtr = getPointerToFunction(F);

2
lib/ExecutionEngine/MCJIT/MCJIT.h
View File

@ -251,7 +251,7 @@ public:
void *getPointerToFunction(Function *F) override;
GenericValue runFunction(Function *F,
const std::vector<GenericValue> &ArgValues) override;
ArrayRef<GenericValue> ArgValues) override;
/// getPointerToNamedFunction - This method returns the address of the
/// specified function by using the dlsym function call. As such it is only

2
lib/ExecutionEngine/Orc/OrcMCJITReplacement.cpp
View File

@ -25,7 +25,7 @@ namespace orc {
GenericValue
OrcMCJITReplacement::runFunction(Function *F,
const std::vector<GenericValue> &ArgValues) {
ArrayRef<GenericValue> ArgValues) {
assert(F && "Function *F was null at entry to run()");
void *FPtr = getPointerToFunction(F);

2
lib/ExecutionEngine/Orc/OrcMCJITReplacement.h
View File

@ -229,7 +229,7 @@ public:
}
GenericValue runFunction(Function *F,
const std::vector<GenericValue> &ArgValues) override;
ArrayRef<GenericValue> ArgValues) override;
void setObjectCache(ObjectCache *NewCache) override {
CompileLayer.setObjectCache(NewCache);