diff --git a/llvm/lib/ExecutionEngine/Interpreter/Execution.cpp b/llvm/lib/ExecutionEngine/Interpreter/Execution.cpp
index 92d8b66..e986158 100644
--- a/llvm/lib/ExecutionEngine/Interpreter/Execution.cpp
+++ b/llvm/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 @@
     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 @@
 
 #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 @@
     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 @@
     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 @@
 #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 @@
     IMPLEMENT_SETCC(==, Int);
     IMPLEMENT_SETCC(==, Float);
     IMPLEMENT_SETCC(==, Double);
+    IMPLEMENT_SETCC(==, Pointer);
   case Type::ULongTyID:
   case Type::LongTyID:
   default:
@@ -134,6 +157,7 @@
     IMPLEMENT_SETCC(!=, Int);
     IMPLEMENT_SETCC(!=, Float);
     IMPLEMENT_SETCC(!=, Double);
+    IMPLEMENT_SETCC(!=, Pointer);
   case Type::ULongTyID:
   case Type::LongTyID:
   default:
@@ -154,6 +178,7 @@
     IMPLEMENT_SETCC(<=, Int);
     IMPLEMENT_SETCC(<=, Float);
     IMPLEMENT_SETCC(<=, Double);
+    IMPLEMENT_SETCC(<=, Pointer);
   case Type::ULongTyID:
   case Type::LongTyID:
   default:
@@ -174,6 +199,7 @@
     IMPLEMENT_SETCC(>=, Int);
     IMPLEMENT_SETCC(>=, Float);
     IMPLEMENT_SETCC(>=, Double);
+    IMPLEMENT_SETCC(>=, Pointer);
   case Type::ULongTyID:
   case Type::LongTyID:
   default:
@@ -194,6 +220,7 @@
     IMPLEMENT_SETCC(<, Int);
     IMPLEMENT_SETCC(<, Float);
     IMPLEMENT_SETCC(<, Double);
+    IMPLEMENT_SETCC(<, Pointer);
   case Type::ULongTyID:
   case Type::LongTyID:
   default:
@@ -214,6 +241,7 @@
     IMPLEMENT_SETCC(>, Int);
     IMPLEMENT_SETCC(>, Float);
     IMPLEMENT_SETCC(>, Double);
+    IMPLEMENT_SETCC(>, Pointer);
   case Type::ULongTyID:
   case Type::LongTyID:
   default:
@@ -244,7 +272,6 @@
   SetValue(I, R, SF);
 }
 
-
 //===----------------------------------------------------------------------===//
 //                     Terminator Instruction Implementations
 //===----------------------------------------------------------------------===//
@@ -306,12 +333,102 @@
 }
 
 //===----------------------------------------------------------------------===//
+//                     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 @@
   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 @@
   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 @@
   // 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 @@
   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 @@
     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 @@
   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::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";