diff --git a/include/llvm/iMemory.h b/include/llvm/iMemory.h
index e2a1e1bd64e..c198aebd70c 100644
--- a/include/llvm/iMemory.h
+++ b/include/llvm/iMemory.h
@@ -63,13 +63,15 @@ public:
 //                                MallocInst Class
 //===----------------------------------------------------------------------===//
 
-struct MallocInst : public AllocationInst {
+class MallocInst : public AllocationInst {
+  MallocInst(const MallocInst &MI);
+public:
   MallocInst(const Type *Ty, Value *ArraySize = 0, const std::string &Name = "",
              Instruction *InsertBefore = 0)
     : AllocationInst(Ty, ArraySize, Malloc, Name, InsertBefore) {}
 
   virtual Instruction *clone() const { 
-    return new MallocInst((Type*)getType(), (Value*)Operands[0].get());
+    return new MallocInst(*this);
   }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -87,13 +89,15 @@ struct MallocInst : public AllocationInst {
 //                                AllocaInst Class
 //===----------------------------------------------------------------------===//
 
-struct AllocaInst : public AllocationInst {
+class AllocaInst : public AllocationInst {
+  AllocaInst(const AllocaInst &);
+public:
   AllocaInst(const Type *Ty, Value *ArraySize = 0, const std::string &Name = "",
              Instruction *InsertBefore = 0)
     : AllocationInst(Ty, ArraySize, Alloca, Name, InsertBefore) {}
 
   virtual Instruction *clone() const { 
-    return new AllocaInst((Type*)getType(), (Value*)Operands[0].get());
+    return new AllocaInst(*this);
   }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
diff --git a/lib/Bytecode/Reader/InstructionReader.cpp b/lib/Bytecode/Reader/InstructionReader.cpp
index 0b75c41b008..40360991f5c 100644
--- a/lib/Bytecode/Reader/InstructionReader.cpp
+++ b/lib/Bytecode/Reader/InstructionReader.cpp
@@ -329,13 +329,19 @@ bool BytecodeParser::ParseInstruction(const uchar *&Buf, const uchar *EndBuf,
   case Instruction::Malloc:
     if (Raw.NumOperands > 2) return true;
     V = Raw.NumOperands ? getValue(Type::UIntTy, Raw.Arg1) : 0;
-    Res = new MallocInst(Raw.Ty, V);
+    if (const PointerType *PTy = dyn_cast<PointerType>(Raw.Ty))
+      Res = new MallocInst(PTy->getElementType(), V);
+    else
+      return true;
     return false;
 
   case Instruction::Alloca:
     if (Raw.NumOperands > 2) return true;
     V = Raw.NumOperands ? getValue(Type::UIntTy, Raw.Arg1) : 0;
-    Res = new AllocaInst(Raw.Ty, V);
+    if (const PointerType *PTy = dyn_cast<PointerType>(Raw.Ty))
+      Res = new AllocaInst(PTy->getElementType(), V);
+    else
+      return true;
     return false;
 
   case Instruction::Free:
diff --git a/lib/Transforms/IPO/MutateStructTypes.cpp b/lib/Transforms/IPO/MutateStructTypes.cpp
index e5bad67f5ea..08ff6b8198d 100644
--- a/lib/Transforms/IPO/MutateStructTypes.cpp
+++ b/lib/Transforms/IPO/MutateStructTypes.cpp
@@ -399,12 +399,14 @@ void MutateStructTypes::transformFunction(Function *m) {
         // Memory Instructions
       case Instruction::Alloca:
         NewI = 
-          new AllocaInst(ConvertType(I.getType()),
+          new MallocInst(
+                  ConvertType(cast<PointerType>(I.getType())->getElementType()),
                          I.getNumOperands() ? ConvertValue(I.getOperand(0)) :0);
         break;
       case Instruction::Malloc:
         NewI = 
-          new MallocInst(ConvertType(I.getType()),
+          new MallocInst(
+                  ConvertType(cast<PointerType>(I.getType())->getElementType()),
                          I.getNumOperands() ? ConvertValue(I.getOperand(0)) :0);
         break;
 
diff --git a/lib/Transforms/IPO/OldPoolAllocate.cpp b/lib/Transforms/IPO/OldPoolAllocate.cpp
index 67ba0f12f1e..33110bd467f 100644
--- a/lib/Transforms/IPO/OldPoolAllocate.cpp
+++ b/lib/Transforms/IPO/OldPoolAllocate.cpp
@@ -1639,9 +1639,8 @@ void PoolAllocate::CreatePools(Function *F, const vector<AllocDSNode*> &Allocs,
            "Pool type should not be abstract anymore!");
 
     // Add an allocation and a free for each pool...
-    AllocaInst *PoolAlloc
-      = new AllocaInst(PointerType::get(PI.PoolType), 0,
-                       CurModule->getTypeName(PI.PoolType));
+    AllocaInst *PoolAlloc = new AllocaInst(PI.PoolType, 0,
+                                           CurModule->getTypeName(PI.PoolType));
     PI.Handle = PoolAlloc;
     EntryNodeInsts.push_back(PoolAlloc);
     AllocationInst *AI = Allocs[i]->getAllocation();
diff --git a/lib/VMCore/iMemory.cpp b/lib/VMCore/iMemory.cpp
index 1738d6e6a2f..dacb8fe2a23 100644
--- a/lib/VMCore/iMemory.cpp
+++ b/lib/VMCore/iMemory.cpp
@@ -10,8 +10,7 @@
 
 AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, 
                                const std::string &Name, Instruction *InsertBef)
-  : Instruction(Ty, iTy, Name, InsertBef) {
-  assert(isa<PointerType>(Ty) && "Can't allocate a non pointer type!");
+  : Instruction(PointerType::get(Ty), iTy, Name, InsertBef) {
 
   // ArraySize defaults to 1.
   if (!ArraySize) ArraySize = ConstantUInt::get(Type::UIntTy, 1);
@@ -31,6 +30,16 @@ const Type *AllocationInst::getAllocatedType() const {
   return getType()->getElementType();
 }
 
+AllocaInst::AllocaInst(const AllocaInst &AI)
+  : AllocationInst(AI.getType()->getElementType(), (Value*)AI.getOperand(0),
+                   Instruction::Alloca) {
+}
+
+MallocInst::MallocInst(const MallocInst &MI)
+  : AllocationInst(MI.getType()->getElementType(), (Value*)MI.getOperand(0),
+                   Instruction::Malloc) {
+}
+
 //===----------------------------------------------------------------------===//
 //                             FreeInst Implementation
 //===----------------------------------------------------------------------===//