maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Lots of new functionality 

llvm-svn: 372
This commit is contained in:
Chris Lattner 2001-08-27 05:16:50 +00:00
parent f04f646c1b
commit 2c1a98ef08
6 changed files with 279 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

273
llvm/lib/ExecutionEngine/Interpreter/Execution.cpp
View File

@ -8,9 +8,12 @@
#include "ExecutionAnnotations.h"
#include "llvm/iOther.h"
#include "llvm/iTerminators.h"
#include "llvm/iMemory.h"
#include "llvm/Type.h"
#include "llvm/ConstPoolVals.h"
#include "llvm/Assembly/Writer.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/CodeGen/TargetData.h"
static unsigned getOperandSlot(Value *V) {
SlotNumber *SN = (SlotNumber*)V->getAnnotation(SlotNumberAID);
@ -40,12 +43,27 @@ static GenericValue getOperandValue(Value *V, ExecutionContext &SF) {
return Result;
} else {
unsigned TyP = V->getType()->getUniqueID(); // TypePlane for value
unsigned Slot = getOperandSlot(V);
void *ElementPtr = &SF.Values[TyP][getOperandSlot(V)];
return SF.Values[TyP][getOperandSlot(V)];
}
}
static void printOperandInfo(Value *V, ExecutionContext &SF) {
if (!V->isConstant()) {
unsigned TyP = V->getType()->getUniqueID(); // TypePlane for value
unsigned Slot = getOperandSlot(V);
cout << "Value=" << (void*)V << " TypeID=" << TyP << " Slot=" << Slot
<< " Addr=" << &SF.Values[TyP][Slot] << " SF=" << &SF << endl;
}
}
static void SetValue(Value *V, GenericValue Val, ExecutionContext &SF) {
unsigned TyP = V->getType()->getUniqueID(); // TypePlane for value
//cout << "Setting value: " << &SF.Values[TyP][getOperandSlot(V)] << endl;
SF.Values[TyP][getOperandSlot(V)] = Val;
}
@ -57,6 +75,9 @@ static void SetValue(Value *V, GenericValue Val, ExecutionContext &SF) {
#define IMPLEMENT_BINARY_OPERATOR(OP, TY) \
case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; break
#define IMPLEMENT_BINARY_PTR_OPERATOR(OP) \
case Type::PointerTyID: Dest.PointerVal = \
(GenericValue*)((unsigned long)Src1.PointerVal OP (unsigned long)Src2.PointerVal); break
static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
const Type *Ty, ExecutionContext &SF) {
@ -70,6 +91,7 @@ static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
IMPLEMENT_BINARY_OPERATOR(+, Int);
IMPLEMENT_BINARY_OPERATOR(+, Float);
IMPLEMENT_BINARY_OPERATOR(+, Double);
IMPLEMENT_BINARY_PTR_OPERATOR(+);
case Type::ULongTyID:
case Type::LongTyID:
default:
@ -90,6 +112,7 @@ static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
IMPLEMENT_BINARY_OPERATOR(-, Int);
IMPLEMENT_BINARY_OPERATOR(-, Float);
IMPLEMENT_BINARY_OPERATOR(-, Double);
IMPLEMENT_BINARY_PTR_OPERATOR(-);
case Type::ULongTyID:
case Type::LongTyID:
default:
@ -101,7 +124,6 @@ static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
#define IMPLEMENT_SETCC(OP, TY) \
case Type::TY##TyID: Dest.BoolVal = Src1.TY##Val OP Src2.TY##Val; break
static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
const Type *Ty, ExecutionContext &SF) {
GenericValue Dest;
@ -114,6 +136,7 @@ static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
IMPLEMENT_SETCC(==, Int);
IMPLEMENT_SETCC(==, Float);
IMPLEMENT_SETCC(==, Double);
IMPLEMENT_SETCC(==, Pointer);
case Type::ULongTyID:
case Type::LongTyID:
default:
@ -134,6 +157,7 @@ static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
IMPLEMENT_SETCC(!=, Int);
IMPLEMENT_SETCC(!=, Float);
IMPLEMENT_SETCC(!=, Double);
IMPLEMENT_SETCC(!=, Pointer);
case Type::ULongTyID:
case Type::LongTyID:
default:
@ -154,6 +178,7 @@ static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
IMPLEMENT_SETCC(<=, Int);
IMPLEMENT_SETCC(<=, Float);
IMPLEMENT_SETCC(<=, Double);
IMPLEMENT_SETCC(<=, Pointer);
case Type::ULongTyID:
case Type::LongTyID:
default:
@ -174,6 +199,7 @@ static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
IMPLEMENT_SETCC(>=, Int);
IMPLEMENT_SETCC(>=, Float);
IMPLEMENT_SETCC(>=, Double);
IMPLEMENT_SETCC(>=, Pointer);
case Type::ULongTyID:
case Type::LongTyID:
default:
@ -194,6 +220,7 @@ static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
IMPLEMENT_SETCC(<, Int);
IMPLEMENT_SETCC(<, Float);
IMPLEMENT_SETCC(<, Double);
IMPLEMENT_SETCC(<, Pointer);
case Type::ULongTyID:
case Type::LongTyID:
default:
@ -214,6 +241,7 @@ static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
IMPLEMENT_SETCC(>, Int);
IMPLEMENT_SETCC(>, Float);
IMPLEMENT_SETCC(>, Double);
IMPLEMENT_SETCC(>, Pointer);
case Type::ULongTyID:
case Type::LongTyID:
default:
@ -244,7 +272,6 @@ static void executeBinaryInst(BinaryOperator *I, ExecutionContext &SF) {
SetValue(I, R, SF);
}
//===----------------------------------------------------------------------===//
// Terminator Instruction Implementations
//===----------------------------------------------------------------------===//
@ -305,13 +332,103 @@ void Interpreter::executeBrInst(BranchInst *I, ExecutionContext &SF) {
SF.CurInst = SF.CurBB->begin(); // Update new instruction ptr...
}
//===----------------------------------------------------------------------===//
// Memory Instruction Implementations
//===----------------------------------------------------------------------===//
// Create a TargetData structure to handle memory addressing and size/alignment
// computations
//
static TargetData TD("lli Interpreter");
void Interpreter::executeAllocInst(AllocationInst *I, ExecutionContext &SF) {
const Type *Ty = I->getType()->getValueType(); // Type to be allocated
unsigned NumElements = 1;
if (I->getNumOperands()) { // Allocating a unsized array type?
assert(Ty->isArrayType() && Ty->isArrayType()->isUnsized() &&
"Allocation inst with size operand for !unsized array type???");
Ty = ((const ArrayType*)Ty)->getElementType(); // Get the actual type...
// Get the number of elements being allocated by the array...
GenericValue NumEl = getOperandValue(I->getOperand(0), SF);
NumElements = NumEl.UIntVal;
}
// Allocate enough memory to hold the type...
GenericValue Result;
Result.PointerVal = (GenericValue*)malloc(NumElements * TD.getTypeSize(Ty));
assert(Result.PointerVal != 0 && "Null pointer returned by malloc!");
SetValue(I, Result, SF);
if (I->getOpcode() == Instruction::Alloca) {
// Keep track to free it later...
}
}
static void executeFreeInst(FreeInst *I, ExecutionContext &SF) {
assert(I->getOperand(0)->getType()->isPointerType() && "Freeing nonptr?");
GenericValue Value = getOperandValue(I->getOperand(0), SF);
// TODO: Check to make sure memory is allocated
free(Value.PointerVal); // Free memory
}
static void executeLoadInst(LoadInst *I, ExecutionContext &SF) {
assert(I->getNumOperands() == 1 && "NI!");
GenericValue *Ptr = getOperandValue(I->getPtrOperand(), SF).PointerVal;
GenericValue Result;
switch (I->getType()->getPrimitiveID()) {
case Type::BoolTyID:
case Type::UByteTyID:
case Type::SByteTyID: Result.SByteVal = Ptr->SByteVal; break;
case Type::UShortTyID:
case Type::ShortTyID: Result.ShortVal = Ptr->ShortVal; break;
case Type::UIntTyID:
case Type::IntTyID: Result.IntVal = Ptr->IntVal; break;
//case Type::ULongTyID:
//case Type::LongTyID: Result.LongVal = Ptr->LongVal; break;
case Type::FloatTyID: Result.FloatVal = Ptr->FloatVal; break;
case Type::DoubleTyID: Result.DoubleVal = Ptr->DoubleVal; break;
case Type::PointerTyID: Result.PointerVal = Ptr->PointerVal; break;
default:
cout << "Cannot load value of type " << I->getType() << "!\n";
}
SetValue(I, Result, SF);
}
static void executeStoreInst(StoreInst *I, ExecutionContext &SF) {
GenericValue *Ptr = getOperandValue(I->getPtrOperand(), SF).PointerVal;
GenericValue Val = getOperandValue(I->getOperand(0), SF);
assert(I->getNumOperands() == 2 && "NI!");
switch (I->getOperand(0)->getType()->getPrimitiveID()) {
case Type::BoolTyID:
case Type::UByteTyID:
case Type::SByteTyID: Ptr->SByteVal = Val.SByteVal; break;
case Type::UShortTyID:
case Type::ShortTyID: Ptr->ShortVal = Val.ShortVal; break;
case Type::UIntTyID:
case Type::IntTyID: Ptr->IntVal = Val.IntVal; break;
//case Type::ULongTyID:
//case Type::LongTyID: Ptr->LongVal = Val.LongVal; break;
case Type::FloatTyID: Ptr->FloatVal = Val.FloatVal; break;
case Type::DoubleTyID: Ptr->DoubleVal = Val.DoubleVal; break;
case Type::PointerTyID: Ptr->PointerVal = Val.PointerVal; break;
default:
cout << "Cannot store value of type " << I->getType() << "!\n";
}
}
//===----------------------------------------------------------------------===//
// Miscellaneous Instruction Implementations
//===----------------------------------------------------------------------===//
void Interpreter::executeCallInst(CallInst *I, ExecutionContext &SF) {
ECStack.back().Caller = I;
callMethod(I->getCalledMethod(), &ECStack.back());
callMethod(I->getCalledMethod(), ECStack.size()-1);
}
static void executePHINode(PHINode *I, ExecutionContext &SF) {
@ -331,6 +448,116 @@ static void executePHINode(PHINode *I, ExecutionContext &SF) {
SetValue(I, getOperandValue(IncomingValue, SF), SF);
}
#define IMPLEMENT_SHIFT(OP, TY) \
case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.UByteVal; break
static void executeShlInst(ShiftInst *I, ExecutionContext &SF) {
const Type *Ty = I->getOperand(0)->getType();
GenericValue Src1 = getOperandValue(I->getOperand(0), SF);
GenericValue Src2 = getOperandValue(I->getOperand(1), SF);
GenericValue Dest;
switch (Ty->getPrimitiveID()) {
IMPLEMENT_SHIFT(<<, UByte);
IMPLEMENT_SHIFT(<<, SByte);
IMPLEMENT_SHIFT(<<, UShort);
IMPLEMENT_SHIFT(<<, Short);
IMPLEMENT_SHIFT(<<, UInt);
IMPLEMENT_SHIFT(<<, Int);
case Type::ULongTyID:
case Type::LongTyID:
default:
cout << "Unhandled type for Shl instruction: " << Ty << endl;
}
SetValue(I, Dest, SF);
}
static void executeShrInst(ShiftInst *I, ExecutionContext &SF) {
const Type *Ty = I->getOperand(0)->getType();
GenericValue Src1 = getOperandValue(I->getOperand(0), SF);
GenericValue Src2 = getOperandValue(I->getOperand(1), SF);
GenericValue Dest;
switch (Ty->getPrimitiveID()) {
IMPLEMENT_SHIFT(>>, UByte);
IMPLEMENT_SHIFT(>>, SByte);
IMPLEMENT_SHIFT(>>, UShort);
IMPLEMENT_SHIFT(>>, Short);
IMPLEMENT_SHIFT(>>, UInt);
IMPLEMENT_SHIFT(>>, Int);
case Type::ULongTyID:
case Type::LongTyID:
default:
cout << "Unhandled type for Shr instruction: " << Ty << endl;
}
SetValue(I, Dest, SF);
}
#define IMPLEMENT_CAST(DTY, DCTY, STY) \
case Type::STY##TyID: Dest.DTY##Val = (DCTY)Src.STY##Val; break;
#define IMPLEMENT_CAST_CASE_START(DESTTY, DESTCTY) \
case Type::DESTTY##TyID: \
switch (SrcTy->getPrimitiveID()) { \
IMPLEMENT_CAST(DESTTY, DESTCTY, UByte); \
IMPLEMENT_CAST(DESTTY, DESTCTY, SByte); \
IMPLEMENT_CAST(DESTTY, DESTCTY, UShort); \
IMPLEMENT_CAST(DESTTY, DESTCTY, Short); \
IMPLEMENT_CAST(DESTTY, DESTCTY, UInt); \
IMPLEMENT_CAST(DESTTY, DESTCTY, Int);
#define IMPLEMENT_CAST_CASE_PTR_IMP(DESTTY, DESTCTY) \
IMPLEMENT_CAST(DESTTY, DESTCTY, Pointer)
#define IMPLEMENT_CAST_CASE_FP_IMP(DESTTY, DESTCTY) \
IMPLEMENT_CAST(DESTTY, DESTCTY, Float); \
IMPLEMENT_CAST(DESTTY, DESTCTY, Double)
#define IMPLEMENT_CAST_CASE_END() \
default: cout << "Unhandled cast: " << SrcTy << " to " << Ty << endl; \
break; \
} \
break
#define IMPLEMENT_CAST_CASE(DESTTY, DESTCTY) \
IMPLEMENT_CAST_CASE_START(DESTTY, DESTCTY); \
IMPLEMENT_CAST_CASE_FP_IMP(DESTTY, DESTCTY); \
IMPLEMENT_CAST_CASE_PTR_IMP(DESTTY, DESTCTY); \
IMPLEMENT_CAST_CASE_END()
#define IMPLEMENT_CAST_CASE_FP(DESTTY, DESTCTY) \
IMPLEMENT_CAST_CASE_START(DESTTY, DESTCTY); \
IMPLEMENT_CAST_CASE_FP_IMP(DESTTY, DESTCTY); \
IMPLEMENT_CAST_CASE_END()
#define IMPLEMENT_CAST_CASE_PTR(DESTTY, DESTCTY) \
IMPLEMENT_CAST_CASE_START(DESTTY, DESTCTY); \
IMPLEMENT_CAST_CASE_PTR_IMP(DESTTY, DESTCTY); \
IMPLEMENT_CAST_CASE_END()
static void executeCastInst(CastInst *I, ExecutionContext &SF) {
const Type *Ty = I->getType();
const Type *SrcTy = I->getOperand(0)->getType();
GenericValue Src = getOperandValue(I->getOperand(0), SF);
GenericValue Dest;
switch (Ty->getPrimitiveID()) {
IMPLEMENT_CAST_CASE(UByte , unsigned char);
IMPLEMENT_CAST_CASE(SByte , signed char);
IMPLEMENT_CAST_CASE(UShort, unsigned short);
IMPLEMENT_CAST_CASE(Short , signed char);
IMPLEMENT_CAST_CASE(UInt , unsigned int );
IMPLEMENT_CAST_CASE(Int , signed int );
IMPLEMENT_CAST_CASE_FP(Float , float);
IMPLEMENT_CAST_CASE_FP(Double, double);
IMPLEMENT_CAST_CASE_PTR(Pointer, GenericValue *);
case Type::ULongTyID:
case Type::LongTyID:
default:
cout << "Unhandled dest type for cast instruction: " << Ty << endl;
}
SetValue(I, Dest, SF);
}
@ -369,12 +596,10 @@ void Interpreter::initializeExecutionEngine() {
AnnotationManager::registerAnnotationFactory(MethodInfoAID, CreateMethodInfo);
}
//===----------------------------------------------------------------------===//
// callMethod - Execute the specified method...
//
void Interpreter::callMethod(Method *M, ExecutionContext *CallingSF = 0) {
void Interpreter::callMethod(Method *M, int CallingSF = -1) {
if (M->isExternal()) {
// Handle builtin methods
cout << "Error: Method '" << M->getName() << "' is external!\n";
@ -385,8 +610,8 @@ void Interpreter::callMethod(Method *M, ExecutionContext *CallingSF = 0) {
// the method. Also calculate the number of values for each type slot active.
//
MethodInfo *MethInfo = (MethodInfo*)M->getOrCreateAnnotation(MethodInfoAID);
ECStack.push_back(ExecutionContext()); // Make a new stack frame...
ExecutionContext &StackFrame = ECStack.back(); // Fill it in...
StackFrame.CurMethod = M;
StackFrame.CurBB = M->front();
@ -401,17 +626,17 @@ void Interpreter::callMethod(Method *M, ExecutionContext *CallingSF = 0) {
StackFrame.PrevBB = 0; // No previous BB for PHI nodes...
// Run through the method arguments and initialize their values...
if (CallingSF) {
CallInst *Call = CallingSF->Caller;
if (CallingSF != -1) {
CallInst *Call = ECStack[CallingSF].Caller;
assert(Call && "Caller improperly initialized!");
unsigned i = 0;
unsigned i = 1;
for (Method::ArgumentListType::iterator MI = M->getArgumentList().begin(),
ME = M->getArgumentList().end(); MI != ME; ++MI, ++i) {
Value *V = Call->getOperand(i+1);
Value *V = Call->getOperand(i);
MethodArgument *MA = *MI;
SetValue(MA, getOperandValue(V, *CallingSF), StackFrame);
SetValue(MA, getOperandValue(V, ECStack[CallingSF]), StackFrame);
}
}
}
@ -429,10 +654,22 @@ bool Interpreter::executeInstruction() {
executeBinaryInst((BinaryOperator*)I, SF);
} else {
switch (I->getOpcode()) {
// Terminators
case Instruction::Ret: executeRetInst ((ReturnInst*)I, SF); break;
case Instruction::Br: executeBrInst ((BranchInst*)I, SF); break;
// Memory Instructions
case Instruction::Alloca:
case Instruction::Malloc: executeAllocInst ((AllocationInst*)I, SF); break;
case Instruction::Free: executeFreeInst ((FreeInst*) I, SF); break;
case Instruction::Load: executeLoadInst ((LoadInst*) I, SF); break;
case Instruction::Store: executeStoreInst ((StoreInst*) I, SF); break;
// Miscellaneous Instructions
case Instruction::Call: executeCallInst ((CallInst*) I, SF); break;
case Instruction::PHINode: executePHINode ((PHINode*) I, SF); break;
case Instruction::Shl: executeShlInst ((ShiftInst*) I, SF); break;
case Instruction::Shr: executeShrInst ((ShiftInst*) I, SF); break;
case Instruction::Cast: executeCastInst ((CastInst*) I, SF); break;
default:
cout << "Don't know how to execute this instruction!\n-->" << I;
}
@ -557,6 +794,7 @@ void Interpreter::printValue(const Type *Ty, GenericValue V) {
case Type::UIntTyID: cout << V.UIntVal; break;
case Type::FloatTyID: cout << V.FloatVal; break;
case Type::DoubleTyID: cout << V.DoubleVal; break;
case Type::PointerTyID:cout << V.PointerVal; break;
default:
cout << "- Don't know how to print value of this type!";
break;
@ -577,6 +815,17 @@ void Interpreter::printValue(const string &Name) {
}
void Interpreter::infoValue(const string &Name) {
Value *PickedVal = ChooseOneOption(Name, LookupMatchingNames(Name));
if (!PickedVal) return;
cout << "Value: ";
printValue(PickedVal->getType(),
getOperandValue(PickedVal, ECStack[CurFrame]));
cout << endl;
printOperandInfo(PickedVal, ECStack[CurFrame]);
}
void Interpreter::list() {
if (ECStack.empty())
cout << "Error: No program executing!\n";

3
llvm/lib/ExecutionEngine/Interpreter/ExecutionAnnotations.h
View File

@ -32,7 +32,8 @@ private:
// CreateMethodInfo - Factory function to allow MethodInfo annotations to be
// created on demand.
//
inline static Annotation *CreateMethodInfo(AnnotationID AID, Annotable *O) {
inline static Annotation *CreateMethodInfo(AnnotationID AID, Annotable *O,
void *) {
assert(AID == MethodInfoAID);
return new MethodInfo((Method*)O); // Simply invoke the ctor
}

5
llvm/lib/ExecutionEngine/Interpreter/Interpreter.h
View File

@ -14,6 +14,7 @@ struct MethodInfo; // Defined in ExecutionAnnotations.h
class CallInst;
class ReturnInst;
class BranchInst;
class AllocationInst;
union GenericValue {
bool BoolVal;
@ -75,6 +76,7 @@ public:
// User Interation Methods...
bool callMethod(const string &Name); // return true on failure
void setBreakpoint(const string &Name);
void infoValue(const string &Name);
void printValue(const string &Name);
void printValue(const Type *Ty, GenericValue V);
@ -83,7 +85,7 @@ public:
void printStackTrace(); // Do the 'backtrace' command
// Code execution methods...
void callMethod(Method *Meth, ExecutionContext *SF = 0);
void callMethod(Method *Meth, int SF = -1);
bool executeInstruction(); // Execute one instruction...
void stepInstruction(); // Do the 'step' command
@ -95,6 +97,7 @@ public:
void executeCallInst(CallInst *I, ExecutionContext &SF);
void executeRetInst(ReturnInst *I, ExecutionContext &SF);
void executeBrInst(BranchInst *I, ExecutionContext &SF);
void executeAllocInst(AllocationInst *I, ExecutionContext &SF);
// getCurrentMethod - Return the currently executing method
inline Method *getCurrentMethod() const {

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

@ -9,10 +9,10 @@
#include <algorithm>
enum CommandID {
Quit, Help, // Basics
Print, List, StackTrace, Up, Down, // Inspection
Next, Step, Run, Finish, Call, // Control flow changes
Break, Watch, // Debugging
Quit, Help, // Basics
Print, Info, List, StackTrace, Up, Down, // Inspection
Next, Step, Run, Finish, Call, // Control flow changes
Break, Watch, // Debugging
Load, Flush
};
@ -33,6 +33,7 @@ static struct CommandTableElement {
{ "print" , Print }, { "p", Print },
{ "list" , List },
{ "info" , Info },
{ "backtrace", StackTrace }, { "bt", StackTrace }, { "where", StackTrace },
{ "up" , Up },
{ "down" , Down },
@ -84,6 +85,11 @@ void Interpreter::handleUserInput() {
cin >> Command;
printValue(Command);
break;
case Info:
cin >> Command;
infoValue(Command);
break;
case List: list(); break;
case StackTrace: printStackTrace(); break;
case Up:

2
llvm/lib/ExecutionEngine/Makefile
View File

@ -8,4 +8,4 @@ clean::
lli : $(ObjectsG)
$(LinkG) -o $@ $(ObjectsG) \
-lopt -lbcreader -lbcwriter \
-lvmcore -lasmwriter -lanalysis -lsupport
-lvmcore -lasmwriter -lanalysis -lsupport -ltarget

2
llvm/tools/lli/Makefile
View File

@ -8,4 +8,4 @@ clean::
lli : $(ObjectsG)
$(LinkG) -o $@ $(ObjectsG) \
-lopt -lbcreader -lbcwriter \
-lvmcore -lasmwriter -lanalysis -lsupport
-lvmcore -lasmwriter -lanalysis -lsupport -ltarget