mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-17 21:29:20 +00:00
* Remove trailing whitespace
* Convert tabs to spaces git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21421 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Misha Brukman
parent
edf128a7fa
commit
d1c881a8d4
@ -1,12 +1,12 @@
|
||||
//===-- Execution.cpp - Implement code to simulate the program ------------===//
|
||||
//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file was developed by the LLVM research group and is distributed under
|
||||
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
||||
//
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
//
|
||||
// This file contains the actual instruction interpreter.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
@ -34,39 +34,39 @@ namespace {
|
||||
// Value Manipulation code
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeDivInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeShrInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2,
|
||||
static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeDivInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeShrInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty);
|
||||
static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2,
|
||||
GenericValue Src3);
|
||||
|
||||
GenericValue Interpreter::getConstantExprValue (ConstantExpr *CE,
|
||||
@ -179,8 +179,8 @@ void Interpreter::initializeExecutionEngine() {
|
||||
#define IMPLEMENT_BINARY_OPERATOR(OP, TY) \
|
||||
case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; break
|
||||
|
||||
static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
GenericValue Dest;
|
||||
switch (Ty->getTypeID()) {
|
||||
IMPLEMENT_BINARY_OPERATOR(+, UByte);
|
||||
@ -200,8 +200,8 @@ static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
|
||||
return Dest;
|
||||
}
|
||||
|
||||
static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
GenericValue Dest;
|
||||
switch (Ty->getTypeID()) {
|
||||
IMPLEMENT_BINARY_OPERATOR(-, UByte);
|
||||
@ -221,8 +221,8 @@ static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
|
||||
return Dest;
|
||||
}
|
||||
|
||||
static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
GenericValue Dest;
|
||||
switch (Ty->getTypeID()) {
|
||||
IMPLEMENT_BINARY_OPERATOR(*, UByte);
|
||||
@ -242,8 +242,8 @@ static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2,
|
||||
return Dest;
|
||||
}
|
||||
|
||||
static GenericValue executeDivInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
static GenericValue executeDivInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
GenericValue Dest;
|
||||
switch (Ty->getTypeID()) {
|
||||
IMPLEMENT_BINARY_OPERATOR(/, UByte);
|
||||
@ -263,8 +263,8 @@ static GenericValue executeDivInst(GenericValue Src1, GenericValue Src2,
|
||||
return Dest;
|
||||
}
|
||||
|
||||
static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
GenericValue Dest;
|
||||
switch (Ty->getTypeID()) {
|
||||
IMPLEMENT_BINARY_OPERATOR(%, UByte);
|
||||
@ -288,8 +288,8 @@ static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2,
|
||||
return Dest;
|
||||
}
|
||||
|
||||
static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
GenericValue Dest;
|
||||
switch (Ty->getTypeID()) {
|
||||
IMPLEMENT_BINARY_OPERATOR(&, Bool);
|
||||
@ -308,7 +308,7 @@ static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
|
||||
return Dest;
|
||||
}
|
||||
|
||||
static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
|
||||
static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
GenericValue Dest;
|
||||
switch (Ty->getTypeID()) {
|
||||
@ -328,7 +328,7 @@ static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
|
||||
return Dest;
|
||||
}
|
||||
|
||||
static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
|
||||
static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
GenericValue Dest;
|
||||
switch (Ty->getTypeID()) {
|
||||
@ -360,8 +360,8 @@ static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
|
||||
Dest.BoolVal = (void*)(intptr_t)Src1.PointerVal OP \
|
||||
(void*)(intptr_t)Src2.PointerVal; break
|
||||
|
||||
static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
GenericValue Dest;
|
||||
switch (Ty->getTypeID()) {
|
||||
IMPLEMENT_SETCC(==, UByte);
|
||||
@ -382,8 +382,8 @@ static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
|
||||
return Dest;
|
||||
}
|
||||
|
||||
static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
GenericValue Dest;
|
||||
switch (Ty->getTypeID()) {
|
||||
IMPLEMENT_SETCC(!=, UByte);
|
||||
@ -405,8 +405,8 @@ static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
|
||||
return Dest;
|
||||
}
|
||||
|
||||
static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
GenericValue Dest;
|
||||
switch (Ty->getTypeID()) {
|
||||
IMPLEMENT_SETCC(<=, UByte);
|
||||
@ -427,8 +427,8 @@ static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
|
||||
return Dest;
|
||||
}
|
||||
|
||||
static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
GenericValue Dest;
|
||||
switch (Ty->getTypeID()) {
|
||||
IMPLEMENT_SETCC(>=, UByte);
|
||||
@ -449,8 +449,8 @@ static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
|
||||
return Dest;
|
||||
}
|
||||
|
||||
static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
GenericValue Dest;
|
||||
switch (Ty->getTypeID()) {
|
||||
IMPLEMENT_SETCC(<, UByte);
|
||||
@ -471,8 +471,8 @@ static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
|
||||
return Dest;
|
||||
}
|
||||
|
||||
static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
|
||||
const Type *Ty) {
|
||||
GenericValue Dest;
|
||||
switch (Ty->getTypeID()) {
|
||||
IMPLEMENT_SETCC(>, UByte);
|
||||
@ -523,7 +523,7 @@ void Interpreter::visitBinaryOperator(BinaryOperator &I) {
|
||||
SetValue(&I, R, SF);
|
||||
}
|
||||
|
||||
static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2,
|
||||
static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2,
|
||||
GenericValue Src3) {
|
||||
return Src1.BoolVal ? Src2 : Src3;
|
||||
}
|
||||
@ -564,15 +564,15 @@ void Interpreter::popStackAndReturnValueToCaller (const Type *RetTy,
|
||||
// Pop the current stack frame.
|
||||
ECStack.pop_back();
|
||||
|
||||
if (ECStack.empty()) { // Finished main. Put result into exit code...
|
||||
if (RetTy && RetTy->isIntegral()) { // Nonvoid return type?
|
||||
ExitCode = Result.IntVal; // Capture the exit code of the program
|
||||
} else {
|
||||
ExitCode = 0;
|
||||
}
|
||||
} else {
|
||||
// If we have a previous stack frame, and we have a previous call,
|
||||
// fill in the return value...
|
||||
if (ECStack.empty()) { // Finished main. Put result into exit code...
|
||||
if (RetTy && RetTy->isIntegral()) { // Nonvoid return type?
|
||||
ExitCode = Result.IntVal; // Capture the exit code of the program
|
||||
} else {
|
||||
ExitCode = 0;
|
||||
}
|
||||
} else {
|
||||
// If we have a previous stack frame, and we have a previous call,
|
||||
// fill in the return value...
|
||||
ExecutionContext &CallingSF = ECStack.back();
|
||||
if (Instruction *I = CallingSF.Caller.getInstruction()) {
|
||||
if (CallingSF.Caller.getType() != Type::VoidTy) // Save result...
|
||||
@ -629,7 +629,7 @@ void Interpreter::visitBranchInst(BranchInst &I) {
|
||||
if (!I.isUnconditional()) {
|
||||
Value *Cond = I.getCondition();
|
||||
if (getOperandValue(Cond, SF).BoolVal == 0) // If false cond...
|
||||
Dest = I.getSuccessor(1);
|
||||
Dest = I.getSuccessor(1);
|
||||
}
|
||||
SwitchToNewBasicBlock(Dest, SF);
|
||||
}
|
||||
@ -647,7 +647,7 @@ void Interpreter::visitSwitchInst(SwitchInst &I) {
|
||||
Dest = cast<BasicBlock>(I.getOperand(i+1));
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
if (!Dest) Dest = I.getDefaultDest(); // No cases matched: use default
|
||||
SwitchToNewBasicBlock(Dest, SF);
|
||||
}
|
||||
@ -677,7 +677,7 @@ void Interpreter::SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF){
|
||||
int i = PN->getBasicBlockIndex(PrevBB);
|
||||
assert(i != -1 && "PHINode doesn't contain entry for predecessor??");
|
||||
Value *IncomingValue = PN->getIncomingValue(i);
|
||||
|
||||
|
||||
// Save the incoming value for this PHI node...
|
||||
ResultValues.push_back(getOperandValue(IncomingValue, SF));
|
||||
}
|
||||
@ -724,8 +724,8 @@ void Interpreter::visitFreeInst(FreeInst &I) {
|
||||
// getElementOffset - The workhorse for getelementptr.
|
||||
//
|
||||
GenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I,
|
||||
gep_type_iterator E,
|
||||
ExecutionContext &SF) {
|
||||
gep_type_iterator E,
|
||||
ExecutionContext &SF) {
|
||||
assert(isa<PointerType>(Ptr->getType()) &&
|
||||
"Cannot getElementOffset of a nonpointer type!");
|
||||
|
||||
@ -734,10 +734,10 @@ GenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I,
|
||||
for (; I != E; ++I) {
|
||||
if (const StructType *STy = dyn_cast<StructType>(*I)) {
|
||||
const StructLayout *SLO = TD.getStructLayout(STy);
|
||||
|
||||
|
||||
const ConstantUInt *CPU = cast<ConstantUInt>(I.getOperand());
|
||||
unsigned Index = unsigned(CPU->getValue());
|
||||
|
||||
|
||||
Total += (PointerTy)SLO->MemberOffsets[Index];
|
||||
} else {
|
||||
const SequentialType *ST = cast<SequentialType>(*I);
|
||||
@ -845,23 +845,23 @@ void Interpreter::visitCallSite(CallSite CS) {
|
||||
const Type *Ty = V->getType();
|
||||
if (Ty->isIntegral() && Ty->getPrimitiveSize() < 4) {
|
||||
if (Ty == Type::ShortTy)
|
||||
ArgVals.back().IntVal = ArgVals.back().ShortVal;
|
||||
ArgVals.back().IntVal = ArgVals.back().ShortVal;
|
||||
else if (Ty == Type::UShortTy)
|
||||
ArgVals.back().UIntVal = ArgVals.back().UShortVal;
|
||||
ArgVals.back().UIntVal = ArgVals.back().UShortVal;
|
||||
else if (Ty == Type::SByteTy)
|
||||
ArgVals.back().IntVal = ArgVals.back().SByteVal;
|
||||
ArgVals.back().IntVal = ArgVals.back().SByteVal;
|
||||
else if (Ty == Type::UByteTy)
|
||||
ArgVals.back().UIntVal = ArgVals.back().UByteVal;
|
||||
ArgVals.back().UIntVal = ArgVals.back().UByteVal;
|
||||
else if (Ty == Type::BoolTy)
|
||||
ArgVals.back().UIntVal = ArgVals.back().BoolVal;
|
||||
ArgVals.back().UIntVal = ArgVals.back().BoolVal;
|
||||
else
|
||||
assert(0 && "Unknown type!");
|
||||
assert(0 && "Unknown type!");
|
||||
}
|
||||
}
|
||||
|
||||
// To handle indirect calls, we must get the pointer value from the argument
|
||||
// To handle indirect calls, we must get the pointer value from the argument
|
||||
// and treat it as a function pointer.
|
||||
GenericValue SRC = getOperandValue(SF.Caller.getCalledValue(), SF);
|
||||
GenericValue SRC = getOperandValue(SF.Caller.getCalledValue(), SF);
|
||||
callFunction((Function*)GVTOP(SRC), ArgVals);
|
||||
}
|
||||
|
||||
@ -958,7 +958,7 @@ void Interpreter::visitShr(ShiftInst &I) {
|
||||
IMPLEMENT_CAST_CASE_END()
|
||||
|
||||
GenericValue Interpreter::executeCastOperation(Value *SrcVal, const Type *Ty,
|
||||
ExecutionContext &SF) {
|
||||
ExecutionContext &SF) {
|
||||
const Type *SrcTy = SrcVal->getType();
|
||||
GenericValue Dest, Src = getOperandValue(SrcVal, SF);
|
||||
|
||||
@ -994,7 +994,7 @@ void Interpreter::visitVANextInst(VANextInst &I) {
|
||||
// Get the incoming valist parameter. LLI treats the valist as a
|
||||
// (ec-stack-depth var-arg-index) pair.
|
||||
GenericValue VAList = getOperandValue(I.getOperand(0), SF);
|
||||
|
||||
|
||||
// Move the pointer to the next vararg.
|
||||
++VAList.UIntPairVal.second;
|
||||
SetValue(&I, VAList, SF);
|
||||
@ -1011,7 +1011,7 @@ void Interpreter::visitVAArgInst(VAArgInst &I) {
|
||||
GenericValue VAList = getOperandValue(I.getOperand(0), SF);
|
||||
GenericValue Dest;
|
||||
GenericValue Src = ECStack[VAList.UIntPairVal.first]
|
||||
.VarArgs[VAList.UIntPairVal.second];
|
||||
.VarArgs[VAList.UIntPairVal.second];
|
||||
const Type *Ty = I.getType();
|
||||
switch (Ty->getTypeID()) {
|
||||
IMPLEMENT_VAARG(UByte);
|
||||
@ -1030,7 +1030,7 @@ void Interpreter::visitVAArgInst(VAArgInst &I) {
|
||||
std::cout << "Unhandled dest type for vaarg instruction: " << *Ty << "\n";
|
||||
abort();
|
||||
}
|
||||
|
||||
|
||||
// Set the Value of this Instruction.
|
||||
SetValue(&I, Dest, SF);
|
||||
}
|
||||
@ -1044,9 +1044,9 @@ void Interpreter::visitVAArgInst(VAArgInst &I) {
|
||||
//
|
||||
void Interpreter::callFunction(Function *F,
|
||||
const std::vector<GenericValue> &ArgVals) {
|
||||
assert((ECStack.empty() || ECStack.back().Caller.getInstruction() == 0 ||
|
||||
ECStack.back().Caller.arg_size() == ArgVals.size()) &&
|
||||
"Incorrect number of arguments passed into function call!");
|
||||
assert((ECStack.empty() || ECStack.back().Caller.getInstruction() == 0 ||
|
||||
ECStack.back().Caller.arg_size() == ArgVals.size()) &&
|
||||
"Incorrect number of arguments passed into function call!");
|
||||
// Make a new stack frame... and fill it in.
|
||||
ECStack.push_back(ExecutionContext());
|
||||
ExecutionContext &StackFrame = ECStack.back();
|
||||
@ -1066,7 +1066,7 @@ void Interpreter::callFunction(Function *F,
|
||||
|
||||
// Run through the function arguments and initialize their values...
|
||||
assert((ArgVals.size() == F->arg_size() ||
|
||||
(ArgVals.size() > F->arg_size() && F->getFunctionType()->isVarArg())) &&
|
||||
(ArgVals.size() > F->arg_size() && F->getFunctionType()->isVarArg()))&&
|
||||
"Invalid number of values passed to function invocation!");
|
||||
|
||||
// Handle non-varargs arguments...
|
||||
@ -1083,7 +1083,7 @@ void Interpreter::run() {
|
||||
// Interpret a single instruction & increment the "PC".
|
||||
ExecutionContext &SF = ECStack.back(); // Current stack frame
|
||||
Instruction &I = *SF.CurInst++; // Increment before execute
|
||||
|
||||
|
||||
// Track the number of dynamic instructions executed.
|
||||
++NumDynamicInsts;
|
||||
|
||||
|
||||
@ -1,16 +1,16 @@
|
||||
//===-- ExternalFunctions.cpp - Implement External Functions --------------===//
|
||||
//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file was developed by the LLVM research group and is distributed under
|
||||
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
||||
//
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
//
|
||||
// This file contains both code to deal with invoking "external" functions, but
|
||||
// also contains code that implements "exported" external functions.
|
||||
//
|
||||
// External functions in the interpreter are implemented by
|
||||
// External functions in the interpreter are implemented by
|
||||
// using the system's dynamic loader to look up the address of the function
|
||||
// we want to invoke. If a function is found, then one of the
|
||||
// many lle_* wrapper functions in this file will translate its arguments from
|
||||
@ -301,7 +301,7 @@ GenericValue lle_X_sprintf(FunctionType *M, const vector<GenericValue> &Args) {
|
||||
Last = *FB++ = *FmtStr++;
|
||||
}
|
||||
*FB = 0;
|
||||
|
||||
|
||||
switch (Last) {
|
||||
case '%':
|
||||
sprintf(Buffer, FmtBuf); break;
|
||||
@ -328,7 +328,7 @@ GenericValue lle_X_sprintf(FunctionType *M, const vector<GenericValue> &Args) {
|
||||
sprintf(Buffer, FmtBuf, Args[ArgNo++].DoubleVal); break;
|
||||
case 'p':
|
||||
sprintf(Buffer, FmtBuf, (void*)GVTOP(Args[ArgNo++])); break;
|
||||
case 's':
|
||||
case 's':
|
||||
sprintf(Buffer, FmtBuf, (char*)GVTOP(Args[ArgNo++])); break;
|
||||
default: std::cout << "<unknown printf code '" << *FmtStr << "'!>";
|
||||
ArgNo++; break;
|
||||
@ -504,7 +504,7 @@ static GenericValue size_t_to_GV (size_t n) {
|
||||
return Ret;
|
||||
}
|
||||
|
||||
static size_t GV_to_size_t (GenericValue GV) {
|
||||
static size_t GV_to_size_t (GenericValue GV) {
|
||||
size_t count;
|
||||
if (sizeof (size_t) == sizeof (uint64_t)) {
|
||||
count = (size_t)GV.ULongVal;
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
//===- Interpreter.cpp - Top-Level LLVM Interpreter Implementation --------===//
|
||||
//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file was developed by the LLVM research group and is distributed under
|
||||
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
||||
//
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This file implements the top-level functionality for the LLVM interpreter.
|
||||
@ -50,7 +50,7 @@ ExecutionEngine *Interpreter::create(Module *M, IntrinsicLowering *IL) {
|
||||
//
|
||||
Interpreter::Interpreter(Module *M, bool isLittleEndian, bool isLongPointer,
|
||||
IntrinsicLowering *il)
|
||||
: ExecutionEngine(M), ExitCode(0),
|
||||
: ExecutionEngine(M), ExitCode(0),
|
||||
TD("lli", isLittleEndian, isLongPointer ? 8 : 4, isLongPointer ? 8 : 4,
|
||||
isLongPointer ? 8 : 4), IL(il) {
|
||||
|
||||
@ -92,13 +92,13 @@ GenericValue Interpreter::runFunction(Function *F,
|
||||
const unsigned ArgCount = F->getFunctionType()->getNumParams();
|
||||
for (unsigned i = 0; i < ArgCount; ++i)
|
||||
ActualArgs.push_back(ArgValues[i]);
|
||||
|
||||
|
||||
// Set up the function call.
|
||||
callFunction(F, ActualArgs);
|
||||
|
||||
// Start executing the function.
|
||||
run();
|
||||
|
||||
|
||||
GenericValue rv;
|
||||
rv.IntVal = ExitCode;
|
||||
return rv;
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
//===-- Interpreter.h ------------------------------------------*- C++ -*--===//
|
||||
//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file was developed by the LLVM research group and is distributed under
|
||||
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
||||
//
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This header file defines the interpreter structure
|
||||
@ -123,7 +123,7 @@ public:
|
||||
/// freeMachineCodeForFunction - The interpreter does not generate any code.
|
||||
///
|
||||
void freeMachineCodeForFunction(Function *F) { }
|
||||
|
||||
|
||||
// Methods used to execute code:
|
||||
// Place a call on the stack
|
||||
void callFunction(Function *F, const std::vector<GenericValue> &ArgVals);
|
||||
@ -160,7 +160,7 @@ public:
|
||||
assert(0 && "Instruction not interpretable yet!");
|
||||
}
|
||||
|
||||
GenericValue callExternalFunction(Function *F,
|
||||
GenericValue callExternalFunction(Function *F,
|
||||
const std::vector<GenericValue> &ArgVals);
|
||||
void exitCalled(GenericValue GV);
|
||||
|
||||
@ -181,7 +181,7 @@ private: // Helper functions
|
||||
// SwitchToNewBasicBlock - Start execution in a new basic block and run any
|
||||
// PHI nodes in the top of the block. This is used for intraprocedural
|
||||
// control flow.
|
||||
//
|
||||
//
|
||||
void SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF);
|
||||
|
||||
void *getPointerToFunction(Function *F) { return (void*)F; }
|
||||
|
||||
Loading…
Reference in New Issue
Block a user