From: Chris Lattner Date: Mon, 27 Aug 2001 05:16:50 +0000 (+0000) Subject: Lots of new functionality X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=86660981e1382f954152b0f029f874aa36de0308;p=oota-llvm.git Lots of new functionality git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@372 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/ExecutionEngine/Interpreter/Execution.cpp b/lib/ExecutionEngine/Interpreter/Execution.cpp index 92d8b663cc5..e9861581d5f 100644 --- a/lib/ExecutionEngine/Interpreter/Execution.cpp +++ b/lib/ExecutionEngine/Interpreter/Execution.cpp @@ -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"; diff --git a/lib/ExecutionEngine/Interpreter/ExecutionAnnotations.h b/lib/ExecutionEngine/Interpreter/ExecutionAnnotations.h index 931de6a4998..e03c24cc046 100644 --- a/lib/ExecutionEngine/Interpreter/ExecutionAnnotations.h +++ b/lib/ExecutionEngine/Interpreter/ExecutionAnnotations.h @@ -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 } diff --git a/lib/ExecutionEngine/Interpreter/Interpreter.h b/lib/ExecutionEngine/Interpreter/Interpreter.h index 9ff83365dbe..3b14954c999 100644 --- a/lib/ExecutionEngine/Interpreter/Interpreter.h +++ b/lib/ExecutionEngine/Interpreter/Interpreter.h @@ -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 { diff --git a/lib/ExecutionEngine/Interpreter/UserInput.cpp b/lib/ExecutionEngine/Interpreter/UserInput.cpp index cfa74f1ffa5..f0c7fe1b6b8 100644 --- a/lib/ExecutionEngine/Interpreter/UserInput.cpp +++ b/lib/ExecutionEngine/Interpreter/UserInput.cpp @@ -9,10 +9,10 @@ #include 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: diff --git a/lib/ExecutionEngine/Makefile b/lib/ExecutionEngine/Makefile index 522665f8bef..bf4483f5b4d 100644 --- a/lib/ExecutionEngine/Makefile +++ b/lib/ExecutionEngine/Makefile @@ -8,4 +8,4 @@ clean:: lli : $(ObjectsG) $(LinkG) -o $@ $(ObjectsG) \ -lopt -lbcreader -lbcwriter \ - -lvmcore -lasmwriter -lanalysis -lsupport + -lvmcore -lasmwriter -lanalysis -lsupport -ltarget diff --git a/tools/lli/Makefile b/tools/lli/Makefile index 522665f8bef..bf4483f5b4d 100644 --- a/tools/lli/Makefile +++ b/tools/lli/Makefile @@ -8,4 +8,4 @@ clean:: lli : $(ObjectsG) $(LinkG) -o $@ $(ObjectsG) \ -lopt -lbcreader -lbcwriter \ - -lvmcore -lasmwriter -lanalysis -lsupport + -lvmcore -lasmwriter -lanalysis -lsupport -ltarget