Index: lib/Analysis/Lint.cpp
===================================================================
--- lib/Analysis/Lint.cpp	(revision 165940)
+++ lib/Analysis/Lint.cpp	(working copy)
@@ -607,6 +607,8 @@
   // TODO: Look through calls with unique return values.
   // TODO: Look through vector insert/extract/shuffle.
   V = OffsetOk ? GetUnderlyingObject(V, TD) : V->stripPointerCasts();
+  unsigned AS = V->getType()->isPointerTy() ?
+    cast<PointerType>(V->getType())->getAddressSpace() : 0;
   if (LoadInst *L = dyn_cast<LoadInst>(V)) {
     BasicBlock::iterator BBI = L;
     BasicBlock *BB = L->getParent();
@@ -626,7 +628,7 @@
       if (W != V)
         return findValueImpl(W, OffsetOk, Visited);
   } else if (CastInst *CI = dyn_cast<CastInst>(V)) {
-    if (CI->isNoopCast(TD ? TD->getIntPtrType(V->getContext()) :
+    if (CI->isNoopCast(TD ? TD->getIntPtrType(V->getContext(), AS) :
                             Type::getInt64Ty(V->getContext())))
       return findValueImpl(CI->getOperand(0), OffsetOk, Visited);
   } else if (ExtractValueInst *Ex = dyn_cast<ExtractValueInst>(V)) {
@@ -640,7 +642,7 @@
       if (CastInst::isNoopCast(Instruction::CastOps(CE->getOpcode()),
                                CE->getOperand(0)->getType(),
                                CE->getType(),
-                               TD ? TD->getIntPtrType(V->getContext()) :
+                               TD ? TD->getIntPtrType(V->getContext(), AS) :
                                     Type::getInt64Ty(V->getContext())))
         return findValueImpl(CE->getOperand(0), OffsetOk, Visited);
     } else if (CE->getOpcode() == Instruction::ExtractValue) {
Index: lib/Analysis/InlineCost.cpp
===================================================================
--- lib/Analysis/InlineCost.cpp	(revision 165941)
+++ lib/Analysis/InlineCost.cpp	(working copy)
@@ -788,7 +788,7 @@
     assert(V->getType()->isPointerTy() && "Unexpected operand type!");
   } while (Visited.insert(V));
 
-  Type *IntPtrTy = TD->getIntPtrType(V->getContext());
+  Type *IntPtrTy = TD->getIntPtrType(V->getContext(), AS);
   return cast<ConstantInt>(ConstantInt::get(IntPtrTy, Offset));
 }
 
Index: lib/Analysis/MemoryBuiltins.cpp
===================================================================
--- lib/Analysis/MemoryBuiltins.cpp	(revision 165940)
+++ lib/Analysis/MemoryBuiltins.cpp	(working copy)
@@ -376,9 +376,10 @@
 ObjectSizeOffsetVisitor::ObjectSizeOffsetVisitor(const DataLayout *TD,
                                                  const TargetLibraryInfo *TLI,
                                                  LLVMContext &Context,
-                                                 bool RoundToAlign)
+                                                 bool RoundToAlign,
+                                                 unsigned AS)
 : TD(TD), TLI(TLI), RoundToAlign(RoundToAlign) {
-  IntegerType *IntTy = TD->getIntPtrType(Context);
+  IntegerType *IntTy = TD->getIntPtrType(Context, AS);
   IntTyBits = IntTy->getBitWidth();
   Zero = APInt::getNullValue(IntTyBits);
 }
@@ -561,9 +562,10 @@
 
 ObjectSizeOffsetEvaluator::ObjectSizeOffsetEvaluator(const DataLayout *TD,
                                                    const TargetLibraryInfo *TLI,
-                                                     LLVMContext &Context)
+                                                     LLVMContext &Context,
+                                                     unsigned AS)
 : TD(TD), TLI(TLI), Context(Context), Builder(Context, TargetFolder(TD)) {
-  IntTy = TD->getIntPtrType(Context);
+  IntTy = TD->getIntPtrType(Context, AS);
   Zero = ConstantInt::get(IntTy, 0);
 }
 
Index: lib/Analysis/InstructionSimplify.cpp
===================================================================
--- lib/Analysis/InstructionSimplify.cpp	(revision 165941)
+++ lib/Analysis/InstructionSimplify.cpp	(working copy)
@@ -728,7 +728,7 @@
     assert(V->getType()->isPointerTy() && "Unexpected operand type!");
   } while (Visited.insert(V));
 
-  Type *IntPtrTy = TD.getIntPtrType(V->getContext());
+  Type *IntPtrTy = TD.getIntPtrType(V->getContext(), AS);
   return ConstantInt::get(IntPtrTy, Offset);
 }
 
Index: lib/Analysis/ConstantFolding.cpp
===================================================================
--- lib/Analysis/ConstantFolding.cpp	(revision 165941)
+++ lib/Analysis/ConstantFolding.cpp	(working copy)
@@ -377,10 +377,12 @@
   }
       
   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
-    if (CE->getOpcode() == Instruction::IntToPtr &&
-        CE->getOperand(0)->getType() == TD.getIntPtrType(CE->getContext())) 
+    if (CE->getOpcode() == Instruction::IntToPtr) {
+      unsigned AS = dyn_cast<PointerType>(CE->getType())->getAddressSpace();
+      if (CE->getOperand(0)->getType() == TD.getIntPtrType(CE->getContext(), AS)) 
       return ReadDataFromGlobal(CE->getOperand(0), ByteOffset, CurPtr, 
                                 BytesLeft, TD);
+    }
   }
 
   // Otherwise, unknown initializer type.
@@ -575,7 +577,9 @@
                                 Type *ResultTy, const DataLayout *TD,
                                 const TargetLibraryInfo *TLI) {
   if (!TD) return 0;
-  Type *IntPtrTy = TD->getIntPtrType(ResultTy->getContext());
+  unsigned AS = ResultTy->isPointerTy() ?
+    dyn_cast<PointerType>(ResultTy)->getAddressSpace() : 0;
+  Type *IntPtrTy = TD->getIntPtrType(ResultTy->getContext(), AS);
 
   bool Any = false;
   SmallVector<Constant*, 32> NewIdxs;
@@ -628,8 +632,9 @@
   if (!TD || !cast<PointerType>(Ptr->getType())->getElementType()->isSized() ||
       !Ptr->getType()->isPointerTy())
     return 0;
-  
-  Type *IntPtrTy = TD->getIntPtrType(Ptr->getContext());
+ 
+  unsigned AS = cast<PointerType>(Ptr->getType())->getAddressSpace();
+  Type *IntPtrTy = TD->getIntPtrType(Ptr->getContext(), AS);
 
   // If this is a constant expr gep that is effectively computing an
   // "offsetof", fold it into 'cast int Size to T*' instead of 'gep 0, 0, 12'
@@ -701,6 +706,7 @@
   // This makes it easy to determine if the getelementptr is "inbounds".
   // Also, this helps GlobalOpt do SROA on GlobalVariables.
   Type *Ty = Ptr->getType();
+  AS = cast<PointerType>(Ty)->getAddressSpace();
   assert(Ty->isPointerTy() && "Forming regular GEP of non-pointer type");
   SmallVector<Constant*, 32> NewIdxs;
   do {
@@ -717,7 +723,7 @@
         
       // Determine which element of the array the offset points into.
       APInt ElemSize(BitWidth, TD->getTypeAllocSize(ATy->getElementType()));
-      IntegerType *IntPtrTy = TD->getIntPtrType(Ty->getContext());
+      IntegerType *IntPtrTy = TD->getIntPtrType(Ty->getContext(), AS);
       if (ElemSize == 0)
         // The element size is 0. This may be [0 x Ty]*, so just use a zero
         // index for this level and proceed to the next level to see if it can
@@ -988,9 +994,12 @@
   // ConstantExpr::getCompare cannot do this, because it doesn't have TD
   // around to know if bit truncation is happening.
   if (ConstantExpr *CE0 = dyn_cast<ConstantExpr>(Ops0)) {
+    Type *IntPtrTy = NULL;
+    unsigned AS = 0;
     if (TD && Ops1->isNullValue()) {
-      Type *IntPtrTy = TD->getIntPtrType(CE0->getContext());
       if (CE0->getOpcode() == Instruction::IntToPtr) {
+        AS = dyn_cast<PointerType>(CE0->getType())->getAddressSpace();
+        IntPtrTy = TD->getIntPtrType(CE0->getContext(), AS);
         // Convert the integer value to the right size to ensure we get the
         // proper extension or truncation.
         Constant *C = ConstantExpr::getIntegerCast(CE0->getOperand(0),
@@ -1001,19 +1010,22 @@
       
       // Only do this transformation if the int is intptrty in size, otherwise
       // there is a truncation or extension that we aren't modeling.
-      if (CE0->getOpcode() == Instruction::PtrToInt && 
-          CE0->getType() == IntPtrTy) {
-        Constant *C = CE0->getOperand(0);
-        Constant *Null = Constant::getNullValue(C->getType());
-        return ConstantFoldCompareInstOperands(Predicate, C, Null, TD, TLI);
+      if (CE0->getOpcode() == Instruction::PtrToInt) {
+        AS = dyn_cast<PointerType>(CE0->getOperand(0)->getType())->getAddressSpace();
+        IntPtrTy = TD->getIntPtrType(CE0->getContext(), AS);
+        if (CE0->getType() == IntPtrTy) {
+          Constant *C = CE0->getOperand(0);
+          Constant *Null = Constant::getNullValue(C->getType());
+          return ConstantFoldCompareInstOperands(Predicate, C, Null, TD, TLI);
+        }
       }
     }
     
     if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(Ops1)) {
       if (TD && CE0->getOpcode() == CE1->getOpcode()) {
-        Type *IntPtrTy = TD->getIntPtrType(CE0->getContext());
-
         if (CE0->getOpcode() == Instruction::IntToPtr) {
+          AS = dyn_cast<PointerType>(CE0->getType())->getAddressSpace();
+          IntPtrTy = TD->getIntPtrType(CE0->getContext(), AS);
           // Convert the integer value to the right size to ensure we get the
           // proper extension or truncation.
           Constant *C0 = ConstantExpr::getIntegerCast(CE0->getOperand(0),
@@ -1022,14 +1034,17 @@
                                                       IntPtrTy, false);
           return ConstantFoldCompareInstOperands(Predicate, C0, C1, TD, TLI);
         }
+      }
 
-        // Only do this transformation if the int is intptrty in size, otherwise
-        // there is a truncation or extension that we aren't modeling.
-        if ((CE0->getOpcode() == Instruction::PtrToInt &&
-             CE0->getType() == IntPtrTy &&
-             CE0->getOperand(0)->getType() == CE1->getOperand(0)->getType()))
+      // Only do this transformation if the int is intptrty in size, otherwise
+      // there is a truncation or extension that we aren't modeling.
+      if (CE0->getOpcode() == Instruction::PtrToInt) {
+        AS = dyn_cast<PointerType>(CE0->getOperand(0)->getType())->getAddressSpace();
+        IntPtrTy = TD->getIntPtrType(CE0->getContext(), AS);
+        if (CE0->getType() == IntPtrTy &&
+            CE0->getOperand(0)->getType() == CE1->getOperand(0)->getType())
           return ConstantFoldCompareInstOperands(Predicate, CE0->getOperand(0),
-                                                 CE1->getOperand(0), TD, TLI);
+              CE1->getOperand(0), TD, TLI);
       }
     }
     
Index: lib/Analysis/ScalarEvolution.cpp
===================================================================
--- lib/Analysis/ScalarEvolution.cpp	(revision 165940)
+++ lib/Analysis/ScalarEvolution.cpp	(working copy)
@@ -2585,8 +2585,10 @@
   // If we have DataLayout, we can bypass creating a target-independent
   // constant expression and then folding it back into a ConstantInt.
   // This is just a compile-time optimization.
+  unsigned AS = AllocTy->isPointerTy() ?
+    cast<PointerType>(AllocTy)->getAddressSpace() : 0;
   if (TD)
-    return getConstant(TD->getIntPtrType(getContext()),
+    return getConstant(TD->getIntPtrType(getContext(), AS),
                        TD->getTypeAllocSize(AllocTy));
 
   Constant *C = ConstantExpr::getSizeOf(AllocTy);
@@ -2611,8 +2613,9 @@
   // If we have DataLayout, we can bypass creating a target-independent
   // constant expression and then folding it back into a ConstantInt.
   // This is just a compile-time optimization.
+  unsigned AS = 0;
   if (TD)
-    return getConstant(TD->getIntPtrType(getContext()),
+    return getConstant(TD->getIntPtrType(getContext(), AS),
                        TD->getStructLayout(STy)->getElementOffset(FieldNo));
 
   Constant *C = ConstantExpr::getOffsetOf(STy, FieldNo);
@@ -2699,7 +2702,8 @@
 
   // The only other support type is pointer.
   assert(Ty->isPointerTy() && "Unexpected non-pointer non-integer type!");
-  if (TD) return TD->getIntPtrType(getContext());
+  unsigned AS = cast<PointerType>(Ty)->getAddressSpace();
+  if (TD) return TD->getIntPtrType(getContext(), AS);
 
   // Without DataLayout, conservatively assume pointers are 64-bit.
   return Type::getInt64Ty(getContext());
Index: lib/Target/XCore/XCoreISelLowering.cpp
===================================================================
--- lib/Target/XCore/XCoreISelLowering.cpp	(revision 165940)
+++ lib/Target/XCore/XCoreISelLowering.cpp	(working copy)
@@ -477,7 +477,8 @@
   }
 
   // Lower to a call to __misaligned_load(BasePtr).
-  Type *IntPtrTy = getDataLayout()->getIntPtrType(*DAG.getContext());
+  unsigned AS = LD->getAddressSpace();
+  Type *IntPtrTy = getDataLayout()->getIntPtrType(*DAG.getContext(), AS);
   TargetLowering::ArgListTy Args;
   TargetLowering::ArgListEntry Entry;
 
@@ -536,7 +537,8 @@
   }
 
   // Lower to a call to __misaligned_store(BasePtr, Value).
-  Type *IntPtrTy = getDataLayout()->getIntPtrType(*DAG.getContext());
+  unsigned AS = ST->getAddressSpace();
+  Type *IntPtrTy = getDataLayout()->getIntPtrType(*DAG.getContext(), AS);
   TargetLowering::ArgListTy Args;
   TargetLowering::ArgListEntry Entry;
 
Index: lib/Target/X86/X86FastISel.cpp
===================================================================
--- lib/Target/X86/X86FastISel.cpp	(revision 165940)
+++ lib/Target/X86/X86FastISel.cpp	(working copy)
@@ -282,8 +282,11 @@
 bool X86FastISel::X86FastEmitStore(EVT VT, const Value *Val,
                                    const X86AddressMode &AM) {
   // Handle 'null' like i32/i64 0.
-  if (isa<ConstantPointerNull>(Val))
-    Val = Constant::getNullValue(TD.getIntPtrType(Val->getContext()));
+  if (isa<ConstantPointerNull>(Val)) {
+    unsigned AS = Val->getType()->isPointerTy() ?
+      Val->getType()->getPointerAddressSpace() : 0;
+    Val = Constant::getNullValue(TD.getIntPtrType(Val->getContext(), AS));
+  }
 
   // If this is a store of a simple constant, fold the constant into the store.
   if (const ConstantInt *CI = dyn_cast<ConstantInt>(Val)) {
@@ -894,8 +897,11 @@
   if (Op0Reg == 0) return false;
 
   // Handle 'null' like i32/i64 0.
-  if (isa<ConstantPointerNull>(Op1))
-    Op1 = Constant::getNullValue(TD.getIntPtrType(Op0->getContext()));
+  if (isa<ConstantPointerNull>(Op1)) {
+    unsigned AS = Op1->getType()->isPointerTy() ?
+      Op1->getType()->getPointerAddressSpace() : 0;
+    Op1 = Constant::getNullValue(TD.getIntPtrType(Op0->getContext(), AS));
+  }
 
   // We have two options: compare with register or immediate.  If the RHS of
   // the compare is an immediate that we can fold into this compare, use
Index: lib/Target/X86/X86SelectionDAGInfo.cpp
===================================================================
--- lib/Target/X86/X86SelectionDAGInfo.cpp	(revision 165940)
+++ lib/Target/X86/X86SelectionDAGInfo.cpp	(working copy)
@@ -54,7 +54,8 @@
     if (const char *bzeroEntry =  V &&
         V->isNullValue() ? Subtarget->getBZeroEntry() : 0) {
       EVT IntPtr = TLI.getPointerTy();
-      Type *IntPtrTy = getDataLayout()->getIntPtrType(*DAG.getContext());
+      unsigned AS = DstPtrInfo.getAddrSpace();
+      Type *IntPtrTy = getDataLayout()->getIntPtrType(*DAG.getContext(), AS);
       TargetLowering::ArgListTy Args;
       TargetLowering::ArgListEntry Entry;
       Entry.Node = Dst;
Index: lib/Target/NVPTX/NVPTXAsmPrinter.cpp
===================================================================
--- lib/Target/NVPTX/NVPTXAsmPrinter.cpp	(revision 165941)
+++ lib/Target/NVPTX/NVPTXAsmPrinter.cpp	(working copy)
@@ -151,7 +151,8 @@
     // Handle casts to pointers by changing them into casts to the appropriate
     // integer type.  This promotes constant folding and simplifies this code.
     Constant *Op = CE->getOperand(0);
-    Op = ConstantExpr::getIntegerCast(Op, TD.getIntPtrType(CV->getContext()),
+    unsigned AS = CE->getType()->getPointerAddressSpace();
+    Op = ConstantExpr::getIntegerCast(Op, TD.getIntPtrType(CV->getContext(), AS),
                                       false/*ZExt*/);
     return LowerConstant(Op, AP);
   }
Index: lib/Target/PowerPC/PPCISelLowering.cpp
===================================================================
--- lib/Target/PowerPC/PPCISelLowering.cpp	(revision 165940)
+++ lib/Target/PowerPC/PPCISelLowering.cpp	(working copy)
@@ -1498,9 +1498,10 @@
 
   EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
   bool isPPC64 = (PtrVT == MVT::i64);
+  unsigned AS = 0;
   Type *IntPtrTy =
     DAG.getTargetLoweringInfo().getDataLayout()->getIntPtrType(
-                                                             *DAG.getContext());
+                                                             *DAG.getContext(), AS);
 
   TargetLowering::ArgListTy Args;
   TargetLowering::ArgListEntry Entry;
Index: lib/Target/ARM/ARMSelectionDAGInfo.cpp
===================================================================
--- lib/Target/ARM/ARMSelectionDAGInfo.cpp	(revision 165940)
+++ lib/Target/ARM/ARMSelectionDAGInfo.cpp	(working copy)
@@ -155,7 +155,8 @@
   TargetLowering::ArgListEntry Entry;
 
   // First argument: data pointer
-  Type *IntPtrTy = TLI.getDataLayout()->getIntPtrType(*DAG.getContext());
+  unsigned AS = DstPtrInfo.getAddrSpace();
+  Type *IntPtrTy = TLI.getDataLayout()->getIntPtrType(*DAG.getContext(), AS);
   Entry.Node = Dst;
   Entry.Ty = IntPtrTy;
   Args.push_back(Entry);
Index: lib/Target/Target.cpp
===================================================================
--- lib/Target/Target.cpp	(revision 165941)
+++ lib/Target/Target.cpp	(working copy)
@@ -64,7 +64,7 @@
 }
 
 LLVMTypeRef LLVMIntPtrType(LLVMTargetDataRef TD) {
-  return wrap(unwrap(TD)->getIntPtrType(getGlobalContext()));
+  return wrap(unwrap(TD)->getIntPtrType(getGlobalContext(), 0));
 }
 
 LLVMTypeRef LLVMIntPtrTypeForAS(LLVMTargetDataRef TD, unsigned AS) {
Index: lib/VMCore/Type.cpp
===================================================================
--- lib/VMCore/Type.cpp	(revision 165940)
+++ lib/VMCore/Type.cpp	(working copy)
@@ -233,7 +233,12 @@
 }
 
 unsigned Type::getPointerAddressSpace() const {
+  if (isPointerTy())
   return cast<PointerType>(this)->getAddressSpace();
+  if (isVectorTy())
+    return getSequentialElementType()->getPointerAddressSpace();
+  llvm_unreachable("Should never reach here!");
+  return 0;
 }
 
 
Index: lib/CodeGen/IntrinsicLowering.cpp
===================================================================
--- lib/CodeGen/IntrinsicLowering.cpp	(revision 165940)
+++ lib/CodeGen/IntrinsicLowering.cpp	(working copy)
@@ -115,21 +115,21 @@
           Type::getInt8PtrTy(Context),
                               Type::getInt8PtrTy(Context), 
                               Type::getInt8PtrTy(Context), 
-                              TD.getIntPtrType(Context), (Type *)0);
+                              TD.getIntPtrType(Context, 0), (Type *)0);
         break;
       case Intrinsic::memmove:
         M.getOrInsertFunction("memmove",
           Type::getInt8PtrTy(Context),
                               Type::getInt8PtrTy(Context), 
                               Type::getInt8PtrTy(Context), 
-                              TD.getIntPtrType(Context), (Type *)0);
+                              TD.getIntPtrType(Context, 0), (Type *)0);
         break;
       case Intrinsic::memset:
         M.getOrInsertFunction("memset",
           Type::getInt8PtrTy(Context),
                               Type::getInt8PtrTy(Context), 
                               Type::getInt32Ty(M.getContext()), 
-                              TD.getIntPtrType(Context), (Type *)0);
+                              TD.getIntPtrType(Context, 0), (Type *)0);
         break;
       case Intrinsic::sqrt:
         EnsureFPIntrinsicsExist(M, I, "sqrtf", "sqrt", "sqrtl");
@@ -340,6 +340,7 @@
 void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) {
   IRBuilder<> Builder(CI->getParent(), CI);
   LLVMContext &Context = CI->getContext();
+  unsigned AS;
 
   const Function *Callee = CI->getCalledFunction();
   assert(Callee && "Cannot lower an indirect call!");
@@ -457,7 +458,8 @@
     break;   // Strip out annotate intrinsic
     
   case Intrinsic::memcpy: {
-    IntegerType *IntPtr = TD.getIntPtrType(Context);
+    AS = CI->getArgOperand(0)->getType()->getPointerAddressSpace();
+    IntegerType *IntPtr = TD.getIntPtrType(Context, AS);
     Value *Size = Builder.CreateIntCast(CI->getArgOperand(2), IntPtr,
                                         /* isSigned */ false);
     Value *Ops[3];
@@ -468,7 +470,8 @@
     break;
   }
   case Intrinsic::memmove: {
-    IntegerType *IntPtr = TD.getIntPtrType(Context);
+    AS = CI->getArgOperand(0)->getType()->getPointerAddressSpace();
+    IntegerType *IntPtr = TD.getIntPtrType(Context, AS);
     Value *Size = Builder.CreateIntCast(CI->getArgOperand(2), IntPtr,
                                         /* isSigned */ false);
     Value *Ops[3];
@@ -479,7 +482,8 @@
     break;
   }
   case Intrinsic::memset: {
-    IntegerType *IntPtr = TD.getIntPtrType(Context);
+    AS = CI->getArgOperand(0)->getType()->getPointerAddressSpace();
+    IntegerType *IntPtr = TD.getIntPtrType(Context, AS);
     Value *Size = Builder.CreateIntCast(CI->getArgOperand(2), IntPtr,
                                         /* isSigned */ false);
     Value *Ops[3];
Index: lib/CodeGen/AsmPrinter/AsmPrinter.cpp
===================================================================
--- lib/CodeGen/AsmPrinter/AsmPrinter.cpp	(revision 165941)
+++ lib/CodeGen/AsmPrinter/AsmPrinter.cpp	(working copy)
@@ -1505,7 +1505,8 @@
     // Handle casts to pointers by changing them into casts to the appropriate
     // integer type.  This promotes constant folding and simplifies this code.
     Constant *Op = CE->getOperand(0);
-    Op = ConstantExpr::getIntegerCast(Op, TD.getIntPtrType(CV->getContext()),
+    unsigned AS = CE->getType()->getPointerAddressSpace();
+    Op = ConstantExpr::getIntegerCast(Op, TD.getIntPtrType(CV->getContext(), AS),
                                       false/*ZExt*/);
     return lowerConstant(Op, AP);
   }
Index: lib/CodeGen/SelectionDAG/SelectionDAG.cpp
===================================================================
--- lib/CodeGen/SelectionDAG/SelectionDAG.cpp	(revision 165941)
+++ lib/CodeGen/SelectionDAG/SelectionDAG.cpp	(working copy)
@@ -3804,7 +3804,8 @@
   // Emit a library call.
   TargetLowering::ArgListTy Args;
   TargetLowering::ArgListEntry Entry;
-  Entry.Ty = TLI.getDataLayout()->getIntPtrType(*getContext());
+  unsigned AS = SrcPtrInfo.getAddrSpace();
+  Entry.Ty = TLI.getDataLayout()->getIntPtrType(*getContext(), AS);
   Entry.Node = Dst; Args.push_back(Entry);
   Entry.Node = Src; Args.push_back(Entry);
   Entry.Node = Size; Args.push_back(Entry);
@@ -3859,7 +3860,8 @@
   // Emit a library call.
   TargetLowering::ArgListTy Args;
   TargetLowering::ArgListEntry Entry;
-  Entry.Ty = TLI.getDataLayout()->getIntPtrType(*getContext());
+  unsigned AS = SrcPtrInfo.getAddrSpace();
+  Entry.Ty = TLI.getDataLayout()->getIntPtrType(*getContext(), AS);
   Entry.Node = Dst; Args.push_back(Entry);
   Entry.Node = Src; Args.push_back(Entry);
   Entry.Node = Size; Args.push_back(Entry);
@@ -3908,7 +3910,8 @@
     return Result;
 
   // Emit a library call.
-  Type *IntPtrTy = TLI.getDataLayout()->getIntPtrType(*getContext());
+  unsigned AS = DstPtrInfo.getAddrSpace();
+  Type *IntPtrTy = TLI.getDataLayout()->getIntPtrType(*getContext(), AS);
   TargetLowering::ArgListTy Args;
   TargetLowering::ArgListEntry Entry;
   Entry.Node = Dst; Entry.Ty = IntPtrTy;
Index: lib/CodeGen/SelectionDAG/FastISel.cpp
===================================================================
--- lib/CodeGen/SelectionDAG/FastISel.cpp	(revision 165940)
+++ lib/CodeGen/SelectionDAG/FastISel.cpp	(working copy)
@@ -100,10 +100,13 @@
     return false;
 
   // No-op casts are trivially coalesced by fast-isel.
-  if (const CastInst *Cast = dyn_cast<CastInst>(I))
-    if (Cast->isNoopCast(TD.getIntPtrType(Cast->getContext())) &&
+  if (const CastInst *Cast = dyn_cast<CastInst>(I)) {
+    unsigned AS = V->getType()->isPointerTy() ? 
+      V->getType()->getPointerAddressSpace() : 0;
+    if (Cast->isNoopCast(TD.getIntPtrType(Cast->getContext(), AS)) &&
         !hasTrivialKill(Cast->getOperand(0)))
       return false;
+    }
 
   // GEPs with all zero indices are trivially coalesced by fast-isel.
   if (const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I))
@@ -172,10 +175,13 @@
   } else if (isa<AllocaInst>(V)) {
     Reg = TargetMaterializeAlloca(cast<AllocaInst>(V));
   } else if (isa<ConstantPointerNull>(V)) {
+    unsigned AS = V->getType()->isPointerTy() ?V->getType()->getPointerAddressSpace()
+      : 0;
     // Translate this as an integer zero so that it can be
     // local-CSE'd with actual integer zeros.
     Reg =
-      getRegForValue(Constant::getNullValue(TD.getIntPtrType(V->getContext())));
+      getRegForValue(Constant::getNullValue(
+            TD.getIntPtrType(V->getContext(), AS)));
   } else if (const ConstantFP *CF = dyn_cast<ConstantFP>(V)) {
     if (CF->isNullValue()) {
       Reg = TargetMaterializeFloatZero(CF);
Index: lib/Transforms/Utils/SimplifyLibCalls.cpp
===================================================================
--- lib/Transforms/Utils/SimplifyLibCalls.cpp	(revision 165940)
+++ lib/Transforms/Utils/SimplifyLibCalls.cpp	(working copy)
@@ -103,13 +103,15 @@
     this->CI = CI;
     FunctionType *FT = Callee->getFunctionType();
     LLVMContext &Context = CI->getParent()->getContext();
+    unsigned AS0 = cast<PointerType>(FT->getParamType(0))->getAddressSpace();
+    unsigned AS1 = cast<PointerType>(FT->getParamType(1))->getAddressSpace();
 
     // Check if this has the right signature.
     if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
         !FT->getParamType(0)->isPointerTy() ||
         !FT->getParamType(1)->isPointerTy() ||
-        FT->getParamType(2) != TD->getIntPtrType(Context) ||
-        FT->getParamType(3) != TD->getIntPtrType(Context))
+        FT->getParamType(2) != TD->getIntPtrType(Context, AS0) ||
+        FT->getParamType(3) != TD->getIntPtrType(Context, AS1))
       return 0;
 
     if (isFoldable(3, 2, false)) {
@@ -126,13 +128,15 @@
     this->CI = CI;
     FunctionType *FT = Callee->getFunctionType();
     LLVMContext &Context = CI->getParent()->getContext();
+    unsigned AS0 = cast<PointerType>(FT->getParamType(0))->getAddressSpace();
+    unsigned AS1 = cast<PointerType>(FT->getParamType(1))->getAddressSpace();
 
     // Check if this has the right signature.
     if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
         !FT->getParamType(0)->isPointerTy() ||
         !FT->getParamType(1)->isPointerTy() ||
-        FT->getParamType(2) != TD->getIntPtrType(Context) ||
-        FT->getParamType(3) != TD->getIntPtrType(Context))
+        FT->getParamType(2) != TD->getIntPtrType(Context, AS0) ||
+        FT->getParamType(3) != TD->getIntPtrType(Context, AS1))
       return 0;
 
     if (isFoldable(3, 2, false)) {
@@ -149,13 +153,14 @@
     this->CI = CI;
     FunctionType *FT = Callee->getFunctionType();
     LLVMContext &Context = CI->getParent()->getContext();
+    unsigned AS = cast<PointerType>(FT->getParamType(0))->getAddressSpace();
 
     // Check if this has the right signature.
     if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
         !FT->getParamType(0)->isPointerTy() ||
         !FT->getParamType(1)->isIntegerTy() ||
-        FT->getParamType(2) != TD->getIntPtrType(Context) ||
-        FT->getParamType(3) != TD->getIntPtrType(Context))
+        FT->getParamType(2) != TD->getIntPtrType(Context, AS) ||
+        FT->getParamType(3) != TD->getIntPtrType(Context, AS))
       return 0;
 
     if (isFoldable(3, 2, false)) {
@@ -174,13 +179,14 @@
     StringRef Name = Callee->getName();
     FunctionType *FT = Callee->getFunctionType();
     LLVMContext &Context = CI->getParent()->getContext();
+    unsigned AS = cast<PointerType>(FT->getParamType(0))->getAddressSpace();
 
     // Check if this has the right signature.
     if (FT->getNumParams() != 3 ||
         FT->getReturnType() != FT->getParamType(0) ||
         FT->getParamType(0) != FT->getParamType(1) ||
         FT->getParamType(0) != Type::getInt8PtrTy(Context) ||
-        FT->getParamType(2) != TD->getIntPtrType(Context))
+        FT->getParamType(2) != TD->getIntPtrType(Context, AS))
       return 0;
 
     // If a) we don't have any length information, or b) we know this will
@@ -203,13 +209,14 @@
     StringRef Name = Callee->getName();
     FunctionType *FT = Callee->getFunctionType();
     LLVMContext &Context = CI->getParent()->getContext();
+    unsigned AS = cast<PointerType>(FT->getParamType(0))->getAddressSpace();
 
     // Check if this has the right signature.
     if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
         FT->getParamType(0) != FT->getParamType(1) ||
         FT->getParamType(0) != Type::getInt8PtrTy(Context) ||
         !FT->getParamType(2)->isIntegerTy() ||
-        FT->getParamType(3) != TD->getIntPtrType(Context))
+        FT->getParamType(3) != TD->getIntPtrType(Context, AS))
       return 0;
 
     if (isFoldable(3, 2, false)) {
@@ -268,10 +275,11 @@
     // the string .. we're concatenating).
     Value *CpyDst = B.CreateGEP(Dst, DstLen, "endptr");
 
+    unsigned AS = cast<PointerType>(CpyDst->getType())->getAddressSpace();
     // We have enough information to now generate the memcpy call to do the
     // concatenation for us.  Make a memcpy to copy the nul byte with align = 1.
     B.CreateMemCpy(CpyDst, Src,
-                   ConstantInt::get(TD->getIntPtrType(*Context), Len + 1), 1);
+                   ConstantInt::get(TD->getIntPtrType(*Context, AS), Len + 1), 1);
     return Dst;
   }
 };
@@ -343,8 +351,9 @@
       if (Len == 0 || !FT->getParamType(1)->isIntegerTy(32))// memchr needs i32.
         return 0;
 
+      unsigned AS = dyn_cast<PointerType>(FT->getParamType(0))->getAddressSpace();
       return EmitMemChr(SrcStr, CI->getArgOperand(1), // include nul.
-                        ConstantInt::get(TD->getIntPtrType(*Context), Len),
+                        ConstantInt::get(TD->getIntPtrType(*Context, AS), Len),
                         B, TD, TLI);
     }
 
@@ -438,8 +447,9 @@
       // These optimizations require DataLayout.
       if (!TD) return 0;
 
+      unsigned AS = dyn_cast<PointerType>(FT->getParamType(0))->getAddressSpace();
       return EmitMemCmp(Str1P, Str2P,
-                        ConstantInt::get(TD->getIntPtrType(*Context),
+                        ConstantInt::get(TD->getIntPtrType(*Context, AS),
                         std::min(Len1, Len2)), B, TD, TLI);
     }
 
Index: lib/Transforms/Utils/BuildLibCalls.cpp
===================================================================
--- lib/Transforms/Utils/BuildLibCalls.cpp	(revision 165940)
+++ lib/Transforms/Utils/BuildLibCalls.cpp	(working copy)
@@ -46,9 +46,11 @@
   AWI[1] = AttributeWithIndex::get(M->getContext(), AttrListPtr::FunctionIndex,
                                    ArrayRef<Attributes::AttrVal>(AVs, 2));
 
+  unsigned AS = Ptr->getType()->isPointerTy() ?
+      cast<PointerType>(Ptr->getType())->getAddressSpace() : 0;
   LLVMContext &Context = B.GetInsertBlock()->getContext();
   Constant *StrLen = M->getOrInsertFunction("strlen", AttrListPtr::get(AWI),
-                                            TD->getIntPtrType(Context),
+                                            TD->getIntPtrType(Context, AS),
                                             B.getInt8PtrTy(),
                                             NULL);
   CallInst *CI = B.CreateCall(StrLen, CastToCStr(Ptr, B), "strlen");
@@ -73,11 +75,13 @@
   AWI[1] = AttributeWithIndex::get(M->getContext(), AttrListPtr::FunctionIndex,
                                    ArrayRef<Attributes::AttrVal>(AVs, 2));
 
+  unsigned AS = Ptr->getType()->isPointerTy() ?
+      cast<PointerType>(Ptr->getType())->getAddressSpace() : 0;
   LLVMContext &Context = B.GetInsertBlock()->getContext();
   Constant *StrNLen = M->getOrInsertFunction("strnlen", AttrListPtr::get(AWI),
-                                             TD->getIntPtrType(Context),
+                                             TD->getIntPtrType(Context, AS),
                                              B.getInt8PtrTy(),
-                                             TD->getIntPtrType(Context),
+                                             TD->getIntPtrType(Context, AS),
                                              NULL);
   CallInst *CI = B.CreateCall2(StrNLen, CastToCStr(Ptr, B), MaxLen, "strnlen");
   if (const Function *F = dyn_cast<Function>(StrNLen->stripPointerCasts()))
@@ -126,12 +130,14 @@
   AWI[2] = AttributeWithIndex::get(M->getContext(), AttrListPtr::FunctionIndex,
                                    ArrayRef<Attributes::AttrVal>(AVs, 2));
 
+  unsigned AS = Ptr1->getType()->isPointerTy() ?
+      cast<PointerType>(Ptr1->getType())->getAddressSpace() : 0;
   LLVMContext &Context = B.GetInsertBlock()->getContext();
   Value *StrNCmp = M->getOrInsertFunction("strncmp", AttrListPtr::get(AWI),
                                           B.getInt32Ty(),
                                           B.getInt8PtrTy(),
                                           B.getInt8PtrTy(),
-                                          TD->getIntPtrType(Context), NULL);
+                                          TD->getIntPtrType(Context, AS), NULL);
   CallInst *CI = B.CreateCall3(StrNCmp, CastToCStr(Ptr1, B),
                                CastToCStr(Ptr2, B), Len, "strncmp");
 
@@ -202,13 +208,18 @@
   AWI = AttributeWithIndex::get(M->getContext(), AttrListPtr::FunctionIndex,
                                 Attributes::NoUnwind);
   LLVMContext &Context = B.GetInsertBlock()->getContext();
+  unsigned DstAS = Dst->getType()->isPointerTy() ?
+      cast<PointerType>(Dst->getType())->getAddressSpace() : 0;
+  unsigned SrcAS = Src->getType()->isPointerTy() ?
+      cast<PointerType>(Src->getType())->getAddressSpace() : 0;
   Value *MemCpy = M->getOrInsertFunction("__memcpy_chk",
                                          AttrListPtr::get(AWI),
                                          B.getInt8PtrTy(),
                                          B.getInt8PtrTy(),
                                          B.getInt8PtrTy(),
-                                         TD->getIntPtrType(Context),
-                                         TD->getIntPtrType(Context), NULL);
+                                         TD->getIntPtrType(Context, DstAS),
+                                         TD->getIntPtrType(Context, SrcAS),
+                                         NULL);
   Dst = CastToCStr(Dst, B);
   Src = CastToCStr(Src, B);
   CallInst *CI = B.CreateCall4(MemCpy, Dst, Src, Len, ObjSize);
@@ -231,11 +242,13 @@
   AWI = AttributeWithIndex::get(M->getContext(), AttrListPtr::FunctionIndex,
                                 ArrayRef<Attributes::AttrVal>(AVs, 2));
   LLVMContext &Context = B.GetInsertBlock()->getContext();
+  unsigned AS = Ptr->getType()->isPointerTy() ?
+      cast<PointerType>(Ptr->getType())->getAddressSpace() : 0;
   Value *MemChr = M->getOrInsertFunction("memchr", AttrListPtr::get(AWI),
                                          B.getInt8PtrTy(),
                                          B.getInt8PtrTy(),
                                          B.getInt32Ty(),
-                                         TD->getIntPtrType(Context),
+                                         TD->getIntPtrType(Context, AS),
                                          NULL);
   CallInst *CI = B.CreateCall3(MemChr, CastToCStr(Ptr, B), Val, Len, "memchr");
 
@@ -261,11 +274,13 @@
                                    ArrayRef<Attributes::AttrVal>(AVs, 2));
 
   LLVMContext &Context = B.GetInsertBlock()->getContext();
+  unsigned AS = Ptr1->getType()->isPointerTy() ?
+      cast<PointerType>(Ptr1->getType())->getAddressSpace() : 0;
   Value *MemCmp = M->getOrInsertFunction("memcmp", AttrListPtr::get(AWI),
                                          B.getInt32Ty(),
                                          B.getInt8PtrTy(),
                                          B.getInt8PtrTy(),
-                                         TD->getIntPtrType(Context), NULL);
+                                         TD->getIntPtrType(Context, AS), NULL);
   CallInst *CI = B.CreateCall3(MemCmp, CastToCStr(Ptr1, B), CastToCStr(Ptr2, B),
                                Len, "memcmp");
 
@@ -428,21 +443,23 @@
   LLVMContext &Context = B.GetInsertBlock()->getContext();
   StringRef FWriteName = TLI->getName(LibFunc::fwrite);
   Constant *F;
+  unsigned AS = Ptr->getType()->isPointerTy() ?
+      cast<PointerType>(Ptr->getType())->getAddressSpace() : 0;
   if (File->getType()->isPointerTy())
     F = M->getOrInsertFunction(FWriteName, AttrListPtr::get(AWI),
-                               TD->getIntPtrType(Context),
+                               TD->getIntPtrType(Context, AS),
                                B.getInt8PtrTy(),
-                               TD->getIntPtrType(Context),
-                               TD->getIntPtrType(Context),
+                               TD->getIntPtrType(Context, AS),
+                               TD->getIntPtrType(Context, AS),
                                File->getType(), NULL);
   else
-    F = M->getOrInsertFunction(FWriteName, TD->getIntPtrType(Context),
+    F = M->getOrInsertFunction(FWriteName, TD->getIntPtrType(Context, AS),
                                B.getInt8PtrTy(),
-                               TD->getIntPtrType(Context),
-                               TD->getIntPtrType(Context),
+                               TD->getIntPtrType(Context, AS),
+                               TD->getIntPtrType(Context, AS),
                                File->getType(), NULL);
   CallInst *CI = B.CreateCall4(F, CastToCStr(Ptr, B), Size,
-                        ConstantInt::get(TD->getIntPtrType(Context), 1), File);
+                        ConstantInt::get(TD->getIntPtrType(Context, AS), 1), File);
 
   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
     CI->setCallingConv(Fn->getCallingConv());
@@ -464,12 +481,14 @@
   IRBuilder<> B(CI);
 
   if (Name == "__memcpy_chk") {
+    unsigned AS = FT->getParamType(0)->isPointerTy() ?
+      cast<PointerType>(FT->getParamType(0))->getAddressSpace() : 0;
     // Check if this has the right signature.
     if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
         !FT->getParamType(0)->isPointerTy() ||
         !FT->getParamType(1)->isPointerTy() ||
-        FT->getParamType(2) != TD->getIntPtrType(Context) ||
-        FT->getParamType(3) != TD->getIntPtrType(Context))
+        FT->getParamType(2) != TD->getIntPtrType(Context, AS) ||
+        FT->getParamType(3) != TD->getIntPtrType(Context, AS))
       return false;
 
     if (isFoldable(3, 2, false)) {
@@ -488,11 +507,13 @@
 
   if (Name == "__memmove_chk") {
     // Check if this has the right signature.
+    unsigned AS = FT->getParamType(0)->isPointerTy() ?
+      cast<PointerType>(FT->getParamType(0))->getAddressSpace() : 0;
     if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
         !FT->getParamType(0)->isPointerTy() ||
         !FT->getParamType(1)->isPointerTy() ||
-        FT->getParamType(2) != TD->getIntPtrType(Context) ||
-        FT->getParamType(3) != TD->getIntPtrType(Context))
+        FT->getParamType(2) != TD->getIntPtrType(Context, AS) ||
+        FT->getParamType(3) != TD->getIntPtrType(Context, AS))
       return false;
 
     if (isFoldable(3, 2, false)) {
@@ -506,11 +527,13 @@
 
   if (Name == "__memset_chk") {
     // Check if this has the right signature.
+    unsigned AS = FT->getParamType(0)->isPointerTy() ?
+      cast<PointerType>(FT->getParamType(0))->getAddressSpace() : 0;
     if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
         !FT->getParamType(0)->isPointerTy() ||
         !FT->getParamType(1)->isIntegerTy() ||
-        FT->getParamType(2) != TD->getIntPtrType(Context) ||
-        FT->getParamType(3) != TD->getIntPtrType(Context))
+        FT->getParamType(2) != TD->getIntPtrType(Context, AS) ||
+        FT->getParamType(3) != TD->getIntPtrType(Context, AS))
       return false;
 
     if (isFoldable(3, 2, false)) {
@@ -525,11 +548,13 @@
 
   if (Name == "__strcpy_chk" || Name == "__stpcpy_chk") {
     // Check if this has the right signature.
+    unsigned AS = FT->getParamType(0)->isPointerTy() ?
+      cast<PointerType>(FT->getParamType(0))->getAddressSpace() : 0;
     if (FT->getNumParams() != 3 ||
         FT->getReturnType() != FT->getParamType(0) ||
         FT->getParamType(0) != FT->getParamType(1) ||
         FT->getParamType(0) != Type::getInt8PtrTy(Context) ||
-        FT->getParamType(2) != TD->getIntPtrType(Context))
+        FT->getParamType(2) != TD->getIntPtrType(Context, AS))
       return 0;
     
     
@@ -551,11 +576,13 @@
 
   if (Name == "__strncpy_chk" || Name == "__stpncpy_chk") {
     // Check if this has the right signature.
+    unsigned AS = FT->getParamType(0)->isPointerTy() ?
+      cast<PointerType>(FT->getParamType(0))->getAddressSpace() : 0;
     if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
         FT->getParamType(0) != FT->getParamType(1) ||
         FT->getParamType(0) != Type::getInt8PtrTy(Context) ||
         !FT->getParamType(2)->isIntegerTy() ||
-        FT->getParamType(3) != TD->getIntPtrType(Context))
+        FT->getParamType(3) != TD->getIntPtrType(Context, AS))
       return false;
 
     if (isFoldable(3, 2, false)) {
Index: lib/Transforms/Utils/SimplifyCFG.cpp
===================================================================
--- lib/Transforms/Utils/SimplifyCFG.cpp	(revision 165940)
+++ lib/Transforms/Utils/SimplifyCFG.cpp	(working copy)
@@ -392,7 +392,8 @@
 
   // This is some kind of pointer constant. Turn it into a pointer-sized
   // ConstantInt if possible.
-  IntegerType *PtrTy = TD->getIntPtrType(V->getContext());
+  unsigned AS = cast<PointerType>(V->getType())->getAddressSpace();
+  IntegerType *PtrTy = TD->getIntPtrType(V->getContext(), AS);
 
   // Null pointer means 0, see SelectionDAGBuilder::getValue(const Value*).
   if (isa<ConstantPointerNull>(V))
@@ -532,9 +533,13 @@
           CV = ICI->getOperand(0);
 
   // Unwrap any lossless ptrtoint cast.
-  if (TD && CV && CV->getType() == TD->getIntPtrType(CV->getContext()))
-    if (PtrToIntInst *PTII = dyn_cast<PtrToIntInst>(CV))
+  if (TD && CV) {
+    PtrToIntInst *PTII = NULL;
+    if ((PTII = dyn_cast<PtrToIntInst>(CV)) &&
+        CV->getType() == TD->getIntPtrType(CV->getContext(),
+          PTII->getPointerAddressSpace()))
       CV = PTII->getOperand(0);
+  }
   return CV;
 }
 
@@ -981,7 +986,8 @@
       // Convert pointer to int before we switch.
       if (CV->getType()->isPointerTy()) {
         assert(TD && "Cannot switch on pointer without DataLayout");
-        CV = Builder.CreatePtrToInt(CV, TD->getIntPtrType(CV->getContext()),
+        unsigned AS = cast<PointerType>(CV->getType())->getAddressSpace();
+        CV = Builder.CreatePtrToInt(CV, TD->getIntPtrType(CV->getContext(), AS),
                                     "magicptr");
       }
 
@@ -2708,8 +2714,9 @@
   // Convert pointer to int before we switch.
   if (CompVal->getType()->isPointerTy()) {
     assert(TD && "Cannot switch on pointer without DataLayout");
+    unsigned AS = cast<PointerType>(CompVal->getType())->getAddressSpace();
     CompVal = Builder.CreatePtrToInt(CompVal,
-                                     TD->getIntPtrType(CompVal->getContext()),
+                                     TD->getIntPtrType(CompVal->getContext(), AS),
                                      "magicptr");
   }
 
Index: lib/Transforms/Instrumentation/BoundsChecking.cpp
===================================================================
--- lib/Transforms/Instrumentation/BoundsChecking.cpp	(revision 165940)
+++ lib/Transforms/Instrumentation/BoundsChecking.cpp	(working copy)
@@ -143,7 +143,9 @@
   Value *Offset = SizeOffset.second;
   ConstantInt *SizeCI = dyn_cast<ConstantInt>(Size);
 
-  IntegerType *IntTy = TD->getIntPtrType(Inst->getContext());
+  unsigned AS = Ptr->getType()->isPointerTy() ?
+    cast<PointerType>(Ptr->getType())->getAddressSpace() : 0;
+  IntegerType *IntTy = TD->getIntPtrType(Inst->getContext(), AS);
   Value *NeededSizeVal = ConstantInt::get(IntTy, NeededSize);
 
   // three checks are required to ensure safety:
Index: lib/Transforms/Scalar/ScalarReplAggregates.cpp
===================================================================
--- lib/Transforms/Scalar/ScalarReplAggregates.cpp	(revision 165940)
+++ lib/Transforms/Scalar/ScalarReplAggregates.cpp	(working copy)
@@ -963,7 +963,8 @@
   if (SV->getType()->isFloatingPointTy() || SV->getType()->isVectorTy())
     SV = Builder.CreateBitCast(SV, IntegerType::get(SV->getContext(),SrcWidth));
   else if (SV->getType()->isPointerTy())
-    SV = Builder.CreatePtrToInt(SV, TD.getIntPtrType(SV->getContext()));
+    SV = Builder.CreatePtrToInt(SV, TD.getIntPtrType(SV->getContext(),
+          SV->getType()->getPointerAddressSpace()));
 
   // Zero extend or truncate the value if needed.
   if (SV->getType() != AllocaType) {
Index: lib/Transforms/Scalar/CodeGenPrepare.cpp
===================================================================
--- lib/Transforms/Scalar/CodeGenPrepare.cpp	(revision 165940)
+++ lib/Transforms/Scalar/CodeGenPrepare.cpp	(working copy)
@@ -933,8 +933,10 @@
   } else {
     DEBUG(dbgs() << "CGP: SINKING nonlocal addrmode: " << AddrMode << " for "
                  << *MemoryInst);
+    unsigned AS = Addr->getType()->isPointerTy() ?
+      Addr->getType()->getPointerAddressSpace() : 0;
     Type *IntPtrTy =
-          TLI->getDataLayout()->getIntPtrType(AccessTy->getContext());
+          TLI->getDataLayout()->getIntPtrType(AccessTy->getContext(), AS);
 
     Value *Result = 0;
 
Index: lib/Transforms/Scalar/LoopIdiomRecognize.cpp
===================================================================
--- lib/Transforms/Scalar/LoopIdiomRecognize.cpp	(revision 165940)
+++ lib/Transforms/Scalar/LoopIdiomRecognize.cpp	(working copy)
@@ -505,7 +505,7 @@
 
   // The # stored bytes is (BECount+1)*Size.  Expand the trip count out to
   // pointer size if it isn't already.
-  Type *IntPtr = TD->getIntPtrType(DestPtr->getContext());
+  Type *IntPtr = TD->getIntPtrType(DestPtr->getContext(), AddrSpace);
   BECount = SE->getTruncateOrZeroExtend(BECount, IntPtr);
 
   const SCEV *NumBytesS = SE->getAddExpr(BECount, SE->getConstant(IntPtr, 1),
@@ -611,7 +611,7 @@
 
   // The # stored bytes is (BECount+1)*Size.  Expand the trip count out to
   // pointer size if it isn't already.
-  Type *IntPtr = TD->getIntPtrType(SI->getContext());
+  Type *IntPtr = TD->getIntPtrType(SI->getContext(), SI->getPointerAddressSpace());
   BECount = SE->getTruncateOrZeroExtend(BECount, IntPtr);
 
   const SCEV *NumBytesS = SE->getAddExpr(BECount, SE->getConstant(IntPtr, 1),
Index: lib/Transforms/Scalar/SimplifyLibCalls.cpp
===================================================================
--- lib/Transforms/Scalar/SimplifyLibCalls.cpp	(revision 165940)
+++ lib/Transforms/Scalar/SimplifyLibCalls.cpp	(working copy)
@@ -165,12 +165,13 @@
 
     // We have enough information to now generate the memcpy call to do the
     // concatenation for us.  Make a memcpy to copy the nul byte with align = 1.
+    unsigned AS = FT->getParamType(0)->getPointerAddressSpace();
     if (!OptChkCall ||
         !EmitMemCpyChk(Dst, Src,
-                       ConstantInt::get(TD->getIntPtrType(*Context), Len),
+                       ConstantInt::get(TD->getIntPtrType(*Context, AS), Len),
                        CI->getArgOperand(2), B, TD, TLI))
       B.CreateMemCpy(Dst, Src,
-                     ConstantInt::get(TD->getIntPtrType(*Context), Len), 1);
+                     ConstantInt::get(TD->getIntPtrType(*Context, AS), Len), 1);
     return Dst;
   }
 };
@@ -206,9 +207,10 @@
     uint64_t Len = GetStringLength(Src);
     if (Len == 0) return 0;
 
-    Value *LenV = ConstantInt::get(TD->getIntPtrType(*Context), Len);
+    unsigned AS = FT->getParamType(0)->getPointerAddressSpace();
+    Value *LenV = ConstantInt::get(TD->getIntPtrType(*Context, AS), Len);
     Value *DstEnd = B.CreateGEP(Dst,
-                                ConstantInt::get(TD->getIntPtrType(*Context),
+                                ConstantInt::get(TD->getIntPtrType(*Context, AS),
                                                  Len - 1));
 
     // We have enough information to now generate the memcpy call to do the
@@ -261,9 +263,10 @@
     // Let strncpy handle the zero padding
     if (Len > SrcLen+1) return 0;
 
+    unsigned AS = FT->getParamType(0)->getPointerAddressSpace();
     // strncpy(x, s, c) -> memcpy(x, s, c, 1) [s and c are constant]
     B.CreateMemCpy(Dst, Src,
-                   ConstantInt::get(TD->getIntPtrType(*Context), Len), 1);
+                   ConstantInt::get(TD->getIntPtrType(*Context, AS), Len), 1);
 
     return Dst;
   }
@@ -550,10 +553,11 @@
     if (!TD) return 0;
 
     FunctionType *FT = Callee->getFunctionType();
+    unsigned AS = FT->getParamType(0)->getPointerAddressSpace();
     if (FT->getNumParams() != 3 || FT->getReturnType() != FT->getParamType(0) ||
         !FT->getParamType(0)->isPointerTy() ||
         !FT->getParamType(1)->isPointerTy() ||
-        FT->getParamType(2) != TD->getIntPtrType(*Context))
+        FT->getParamType(2) != TD->getIntPtrType(*Context, AS))
       return 0;
 
     // memcpy(x, y, n) -> llvm.memcpy(x, y, n, 1)
@@ -572,10 +576,11 @@
     if (!TD) return 0;
 
     FunctionType *FT = Callee->getFunctionType();
+    unsigned AS = FT->getParamType(0)->getPointerAddressSpace();
     if (FT->getNumParams() != 3 || FT->getReturnType() != FT->getParamType(0) ||
         !FT->getParamType(0)->isPointerTy() ||
         !FT->getParamType(1)->isPointerTy() ||
-        FT->getParamType(2) != TD->getIntPtrType(*Context))
+        FT->getParamType(2) != TD->getIntPtrType(*Context, AS))
       return 0;
 
     // memmove(x, y, n) -> llvm.memmove(x, y, n, 1)
@@ -594,10 +599,11 @@
     if (!TD) return 0;
 
     FunctionType *FT = Callee->getFunctionType();
+    unsigned AS = FT->getParamType(0)->getPointerAddressSpace();
     if (FT->getNumParams() != 3 || FT->getReturnType() != FT->getParamType(0) ||
         !FT->getParamType(0)->isPointerTy() ||
         !FT->getParamType(1)->isIntegerTy() ||
-        FT->getParamType(2) != TD->getIntPtrType(*Context))
+        FT->getParamType(2) != TD->getIntPtrType(*Context, AS))
       return 0;
 
     // memset(p, v, n) -> llvm.memset(p, v, n, 1)
@@ -1022,8 +1028,9 @@
       if (!TD) return 0;
 
       // sprintf(str, fmt) -> llvm.memcpy(str, fmt, strlen(fmt)+1, 1)
+      unsigned AS = CI->getArgOperand(0)->getType()->getPointerAddressSpace();
       B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(1),
-                     ConstantInt::get(TD->getIntPtrType(*Context), // Copy the
+                     ConstantInt::get(TD->getIntPtrType(*Context, AS), // Copy the
                                       FormatStr.size() + 1), 1);   // nul byte.
       return ConstantInt::get(CI->getType(), FormatStr.size());
     }
@@ -1150,8 +1157,9 @@
     uint64_t Len = GetStringLength(CI->getArgOperand(0));
     if (!Len) return 0;
     // Known to have no uses (see above).
+    unsigned AS = FT->getParamType(0)->getPointerAddressSpace();
     return EmitFWrite(CI->getArgOperand(0),
-                      ConstantInt::get(TD->getIntPtrType(*Context), Len-1),
+                      ConstantInt::get(TD->getIntPtrType(*Context, AS), Len-1),
                       CI->getArgOperand(1), B, TD, TLI);
   }
 };
@@ -1176,8 +1184,9 @@
       // These optimizations require DataLayout.
       if (!TD) return 0;
 
+      unsigned AS = CI->getArgOperand(1)->getType()->getPointerAddressSpace();
       Value *NewCI = EmitFWrite(CI->getArgOperand(1),
-                                ConstantInt::get(TD->getIntPtrType(*Context),
+                                ConstantInt::get(TD->getIntPtrType(*Context, AS),
                                                  FormatStr.size()),
                                 CI->getArgOperand(0), B, TD, TLI);
       return NewCI ? ConstantInt::get(CI->getType(), FormatStr.size()) : 0;
Index: lib/Transforms/Scalar/GVN.cpp
===================================================================
--- lib/Transforms/Scalar/GVN.cpp	(revision 165940)
+++ lib/Transforms/Scalar/GVN.cpp	(working copy)
@@ -774,13 +774,15 @@
 
     // Convert source pointers to integers, which can be bitcast.
     if (StoredValTy->isPointerTy()) {
-      StoredValTy = TD.getIntPtrType(StoredValTy->getContext());
+      StoredValTy = TD.getIntPtrType(StoredValTy->getContext(),
+          StoredValTy->getPointerAddressSpace());
       StoredVal = new PtrToIntInst(StoredVal, StoredValTy, "", InsertPt);
     }
 
     Type *TypeToCastTo = LoadedTy;
     if (TypeToCastTo->isPointerTy())
-      TypeToCastTo = TD.getIntPtrType(StoredValTy->getContext());
+      TypeToCastTo = TD.getIntPtrType(StoredValTy->getContext(),
+          TypeToCastTo->getPointerAddressSpace());
 
     if (StoredValTy != TypeToCastTo)
       StoredVal = new BitCastInst(StoredVal, TypeToCastTo, "", InsertPt);
@@ -799,7 +801,8 @@
 
   // Convert source pointers to integers, which can be manipulated.
   if (StoredValTy->isPointerTy()) {
-    StoredValTy = TD.getIntPtrType(StoredValTy->getContext());
+    StoredValTy = TD.getIntPtrType(StoredValTy->getContext(),
+        StoredValTy->getPointerAddressSpace());
     StoredVal = new PtrToIntInst(StoredVal, StoredValTy, "", InsertPt);
   }
 
@@ -1020,7 +1023,8 @@
   // Compute which bits of the stored value are being used by the load.  Convert
   // to an integer type to start with.
   if (SrcVal->getType()->isPointerTy())
-    SrcVal = Builder.CreatePtrToInt(SrcVal, TD.getIntPtrType(Ctx));
+    SrcVal = Builder.CreatePtrToInt(SrcVal, TD.getIntPtrType(Ctx,
+          SrcVal->getType()->getPointerAddressSpace()));
   if (!SrcVal->getType()->isIntegerTy())
     SrcVal = Builder.CreateBitCast(SrcVal, IntegerType::get(Ctx, StoreSize*8));
 
Index: lib/Transforms/InstCombine/InstCombineCasts.cpp
===================================================================
--- lib/Transforms/InstCombine/InstCombineCasts.cpp	(revision 165941)
+++ lib/Transforms/InstCombine/InstCombineCasts.cpp	(working copy)
@@ -239,16 +239,18 @@
   Instruction::CastOps firstOp = Instruction::CastOps(CI->getOpcode());
   Instruction::CastOps secondOp = Instruction::CastOps(opcode);
 
+  unsigned AS = SrcTy->isPointerTy() ? SrcTy->getPointerAddressSpace() : 
+    DstTy->isPointerTy() ? DstTy->getPointerAddressSpace() : 0;
   unsigned Res = CastInst::isEliminableCastPair(firstOp, secondOp, SrcTy, MidTy,
                                                 DstTy,
-                                  TD ? TD->getIntPtrType(CI->getContext()) : 0);
+                                  TD ? TD->getIntPtrType(CI->getContext(), AS) : 0);
   
   // We don't want to form an inttoptr or ptrtoint that converts to an integer
   // type that differs from the pointer size.
   if ((Res == Instruction::IntToPtr &&
-          (!TD || SrcTy != TD->getIntPtrType(CI->getContext()))) ||
+          (!TD || SrcTy != TD->getIntPtrType(CI->getContext(), AS))) ||
       (Res == Instruction::PtrToInt &&
-          (!TD || DstTy != TD->getIntPtrType(CI->getContext()))))
+          (!TD || DstTy != TD->getIntPtrType(CI->getContext(), AS))))
     Res = 0;
   
   return Instruction::CastOps(Res);
@@ -1298,13 +1300,13 @@
     if (CI.getOperand(0)->getType()->getScalarSizeInBits() >
         TD->getPointerSizeInBits(AS)) {
       Value *P = Builder->CreateTrunc(CI.getOperand(0),
-                                      TD->getIntPtrType(CI.getContext()));
+                                      TD->getIntPtrType(CI.getContext(), AS));
       return new IntToPtrInst(P, CI.getType());
     }
     if (CI.getOperand(0)->getType()->getScalarSizeInBits() <
         TD->getPointerSizeInBits(AS)) {
       Value *P = Builder->CreateZExt(CI.getOperand(0),
-                                     TD->getIntPtrType(CI.getContext()));
+                                     TD->getIntPtrType(CI.getContext(), AS));
       return new IntToPtrInst(P, CI.getType());
     }
   }
@@ -1373,12 +1375,12 @@
   if (TD) {
     if (CI.getType()->getScalarSizeInBits() < TD->getPointerSizeInBits(AS)) {
       Value *P = Builder->CreatePtrToInt(CI.getOperand(0),
-                                         TD->getIntPtrType(CI.getContext()));
+                                         TD->getIntPtrType(CI.getContext(), AS));
       return new TruncInst(P, CI.getType());
     }
     if (CI.getType()->getScalarSizeInBits() > TD->getPointerSizeInBits(AS)) {
       Value *P = Builder->CreatePtrToInt(CI.getOperand(0),
-                                         TD->getIntPtrType(CI.getContext()));
+                                         TD->getIntPtrType(CI.getContext(), AS));
       return new ZExtInst(P, CI.getType());
     }
   }
Index: lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
===================================================================
--- lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp	(revision 165940)
+++ lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp	(working copy)
@@ -173,7 +173,9 @@
   // Ensure that the alloca array size argument has type intptr_t, so that
   // any casting is exposed early.
   if (TD) {
-    Type *IntPtrTy = TD->getIntPtrType(AI.getContext());
+    unsigned AS = AI.getType()->isPointerTy() ?
+      AI.getType()->getPointerAddressSpace() : 0;
+    Type *IntPtrTy = TD->getIntPtrType(AI.getContext(), AS);
     if (AI.getArraySize()->getType() != IntPtrTy) {
       Value *V = Builder->CreateIntCast(AI.getArraySize(),
                                         IntPtrTy, false);
Index: lib/Transforms/InstCombine/InstCombineCompares.cpp
===================================================================
--- lib/Transforms/InstCombine/InstCombineCompares.cpp	(revision 165941)
+++ lib/Transforms/InstCombine/InstCombineCompares.cpp	(working copy)
@@ -371,7 +371,7 @@
   // an inbounds GEP because the index can't be out of range.
   if (!GEP->isInBounds() &&
       Idx->getType()->getPrimitiveSizeInBits() > TD->getPointerSizeInBits(AS))
-    Idx = Builder->CreateTrunc(Idx, TD->getIntPtrType(Idx->getContext()));
+    Idx = Builder->CreateTrunc(Idx, TD->getIntPtrType(Idx->getContext(), AS));
 
   // If the comparison is only true for one or two elements, emit direct
   // comparisons.
@@ -539,7 +539,7 @@
     // we don't need to bother extending: the extension won't affect where the
     // computation crosses zero.
     if (VariableIdx->getType()->getPrimitiveSizeInBits() > IntPtrWidth) {
-      Type *IntPtrTy = TD.getIntPtrType(VariableIdx->getContext());
+      Type *IntPtrTy = TD.getIntPtrType(VariableIdx->getContext(), AS);
       VariableIdx = IC.Builder->CreateTrunc(VariableIdx, IntPtrTy);
     }
     return VariableIdx;
@@ -561,7 +561,7 @@
     return 0;
 
   // Okay, we can do this evaluation.  Start by converting the index to intptr.
-  Type *IntPtrTy = TD.getIntPtrType(VariableIdx->getContext());
+  Type *IntPtrTy = TD.getIntPtrType(VariableIdx->getContext(), AS);
   if (VariableIdx->getType() != IntPtrTy)
     VariableIdx = IC.Builder->CreateIntCast(VariableIdx, IntPtrTy,
                                             true /*Signed*/);
@@ -2251,7 +2251,8 @@
       case Instruction::IntToPtr:
         // icmp pred inttoptr(X), null -> icmp pred X, 0
         if (RHSC->isNullValue() && TD &&
-            TD->getIntPtrType(RHSC->getContext()) ==
+            TD->getIntPtrType(RHSC->getContext(),
+              LHSI->getType()->getPointerAddressSpace()) ==
                LHSI->getOperand(0)->getType())
           return new ICmpInst(I.getPredicate(), LHSI->getOperand(0),
                         Constant::getNullValue(LHSI->getOperand(0)->getType()));
Index: lib/Transforms/InstCombine/InstructionCombining.cpp
===================================================================
--- lib/Transforms/InstCombine/InstructionCombining.cpp	(revision 165940)
+++ lib/Transforms/InstCombine/InstructionCombining.cpp	(working copy)
@@ -746,7 +746,8 @@
   // Start with the index over the outer type.  Note that the type size
   // might be zero (even if the offset isn't zero) if the indexed type
   // is something like [0 x {int, int}]
-  Type *IntPtrTy = TD->getIntPtrType(Ty->getContext());
+  unsigned AS = Ty->isPointerTy() ? Ty->getPointerAddressSpace() : 0;
+  Type *IntPtrTy = TD->getIntPtrType(Ty->getContext(), AS);
   int64_t FirstIdx = 0;
   if (int64_t TySize = TD->getTypeAllocSize(Ty)) {
     FirstIdx = Offset/TySize;
@@ -817,7 +818,8 @@
   // by multiples of a zero size type with zero.
   if (TD) {
     bool MadeChange = false;
-    Type *IntPtrTy = TD->getIntPtrType(GEP.getContext());
+    Type *IntPtrTy = TD->getIntPtrType(GEP.getContext(),
+        PtrOp->getType()->getPointerAddressSpace());
 
     gep_type_iterator GTI = gep_type_begin(GEP);
     for (User::op_iterator I = GEP.op_begin() + 1, E = GEP.op_end();
Index: lib/Transforms/InstCombine/InstCombineCalls.cpp
===================================================================
--- lib/Transforms/InstCombine/InstCombineCalls.cpp	(revision 165940)
+++ lib/Transforms/InstCombine/InstCombineCalls.cpp	(working copy)
@@ -992,13 +992,17 @@
 
   // Check to see if we are changing the return type...
   if (OldRetTy != NewRetTy) {
+    unsigned NewAS = NewRetTy->isPointerTy() ?
+      NewRetTy->getPointerAddressSpace() : 0;
+    unsigned OldAS = OldRetTy->isPointerTy() ?
+      OldRetTy->getPointerAddressSpace() : 0;
     if (Callee->isDeclaration() &&
         // Conversion is ok if changing from one pointer type to another or from
         // a pointer to an integer of the same size.
         !((OldRetTy->isPointerTy() || !TD ||
-           OldRetTy == TD->getIntPtrType(Caller->getContext())) &&
+           OldRetTy == TD->getIntPtrType(Caller->getContext(), OldAS)) &&
           (NewRetTy->isPointerTy() || !TD ||
-           NewRetTy == TD->getIntPtrType(Caller->getContext()))))
+           NewRetTy == TD->getIntPtrType(Caller->getContext(), NewAS))))
       return false;   // Cannot transform this return value.
 
     if (!Caller->use_empty() &&
@@ -1057,11 +1061,15 @@
 
     // Converting from one pointer type to another or between a pointer and an
     // integer of the same size is safe even if we do not have a body.
+    unsigned ParamAS = ParamTy->isPointerTy() ?
+      ParamTy->getPointerAddressSpace() : 0;
+    unsigned ActAS = ActTy->isPointerTy() ?
+      ActTy->getPointerAddressSpace() : 0;
     bool isConvertible = ActTy == ParamTy ||
       (TD && ((ParamTy->isPointerTy() ||
-      ParamTy == TD->getIntPtrType(Caller->getContext())) &&
+      ParamTy == TD->getIntPtrType(Caller->getContext(), ParamAS)) &&
               (ActTy->isPointerTy() ||
-              ActTy == TD->getIntPtrType(Caller->getContext()))));
+              ActTy == TD->getIntPtrType(Caller->getContext(), ActAS))));
     if (Callee->isDeclaration() && !isConvertible) return false;
   }
 
Index: lib/Transforms/IPO/GlobalOpt.cpp
===================================================================
--- lib/Transforms/IPO/GlobalOpt.cpp	(revision 165940)
+++ lib/Transforms/IPO/GlobalOpt.cpp	(working copy)
@@ -1500,7 +1500,8 @@
     unsigned TypeSize = TD->getTypeAllocSize(FieldTy);
     if (StructType *ST = dyn_cast<StructType>(FieldTy))
       TypeSize = TD->getStructLayout(ST)->getSizeInBytes();
-    Type *IntPtrTy = TD->getIntPtrType(CI->getContext());
+    Type *IntPtrTy = TD->getIntPtrType(CI->getContext(),
+        GV->getType()->getAddressSpace());
     Value *NMI = CallInst::CreateMalloc(CI, IntPtrTy, FieldTy,
                                         ConstantInt::get(IntPtrTy, TypeSize),
                                         NElems, 0,
@@ -1730,7 +1731,8 @@
     // If this is a fixed size array, transform the Malloc to be an alloc of
     // structs.  malloc [100 x struct],1 -> malloc struct, 100
     if (ArrayType *AT = dyn_cast<ArrayType>(getMallocAllocatedType(CI, TLI))) {
-      Type *IntPtrTy = TD->getIntPtrType(CI->getContext());
+      Type *IntPtrTy = TD->getIntPtrType(CI->getContext(),
+          GV->getType()->getAddressSpace());
       unsigned TypeSize = TD->getStructLayout(AllocSTy)->getSizeInBytes();
       Value *AllocSize = ConstantInt::get(IntPtrTy, TypeSize);
       Value *NumElements = ConstantInt::get(IntPtrTy, AT->getNumElements());
Index: lib/Transforms/IPO/MergeFunctions.cpp
===================================================================
--- lib/Transforms/IPO/MergeFunctions.cpp	(revision 165940)
+++ lib/Transforms/IPO/MergeFunctions.cpp	(working copy)
@@ -207,8 +207,10 @@
   if (Ty1->getTypeID() != Ty2->getTypeID()) {
     if (TD) {
       LLVMContext &Ctx = Ty1->getContext();
-      if (isa<PointerType>(Ty1) && Ty2 == TD->getIntPtrType(Ctx)) return true;
-      if (isa<PointerType>(Ty2) && Ty1 == TD->getIntPtrType(Ctx)) return true;
+      unsigned AS1 = Ty1->isPointerTy() ? Ty1->getPointerAddressSpace() : 0;
+      unsigned AS2 = Ty1->isPointerTy() ? Ty1->getPointerAddressSpace() : 0;
+      if (isa<PointerType>(Ty1) && Ty2 == TD->getIntPtrType(Ctx, AS1)) return true;
+      if (isa<PointerType>(Ty2) && Ty1 == TD->getIntPtrType(Ctx, AS2)) return true;
     }
     return false;
   }
Index: include/llvm/DataLayout.h
===================================================================
--- include/llvm/DataLayout.h	(revision 165941)
+++ include/llvm/DataLayout.h	(working copy)
@@ -339,9 +339,7 @@
 
   /// getIntPtrType - Return an unsigned integer type that is the same size or
   /// greater to the host pointer size.
-  /// FIXME: Need to remove the default argument when the rest of the LLVM code
-  /// base has been updated.
-  IntegerType *getIntPtrType(LLVMContext &C, unsigned AddressSpace = 0) const;
+  IntegerType *getIntPtrType(LLVMContext &C, unsigned AddressSpace) const;
 
   /// getIndexedOffset - return the offset from the beginning of the type for
   /// the specified indices.  This is used to implement getelementptr.
Index: include/llvm/Transforms/Utils/Local.h
===================================================================
--- include/llvm/Transforms/Utils/Local.h	(revision 165941)
+++ include/llvm/Transforms/Utils/Local.h	(working copy)
@@ -177,16 +177,16 @@
 template<typename IRBuilderTy>
 Value *EmitGEPOffset(IRBuilderTy *Builder, const DataLayout &TD, User *GEP,
                      bool NoAssumptions = false) {
+  // Build a mask for high order bits.
+  unsigned AS = cast<GEPOperator>(GEP)->getPointerAddressSpace();
   gep_type_iterator GTI = gep_type_begin(GEP);
-  Type *IntPtrTy = TD.getIntPtrType(GEP->getContext());
+  Type *IntPtrTy = TD.getIntPtrType(GEP->getContext(), AS);
   Value *Result = Constant::getNullValue(IntPtrTy);
 
   // If the GEP is inbounds, we know that none of the addressing operations will
   // overflow in an unsigned sense.
   bool isInBounds = cast<GEPOperator>(GEP)->isInBounds() && !NoAssumptions;
 
-  // Build a mask for high order bits.
-  unsigned AS = cast<GEPOperator>(GEP)->getPointerAddressSpace();
   unsigned IntPtrWidth = TD.getPointerSizeInBits(AS);
   uint64_t PtrSizeMask = ~0ULL >> (64-IntPtrWidth);
 
Index: include/llvm/Analysis/MemoryBuiltins.h
===================================================================
--- include/llvm/Analysis/MemoryBuiltins.h	(revision 165940)
+++ include/llvm/Analysis/MemoryBuiltins.h	(working copy)
@@ -168,7 +168,8 @@
 
 public:
   ObjectSizeOffsetVisitor(const DataLayout *TD, const TargetLibraryInfo *TLI,
-                          LLVMContext &Context, bool RoundToAlign = false);
+                          LLVMContext &Context, bool RoundToAlign = false,
+                          unsigned AS = 0);
 
   SizeOffsetType compute(Value *V);
 
@@ -229,7 +230,7 @@
 
 public:
   ObjectSizeOffsetEvaluator(const DataLayout *TD, const TargetLibraryInfo *TLI,
-                            LLVMContext &Context);
+                            LLVMContext &Context, unsigned AS = 0);
   SizeOffsetEvalType compute(Value *V);
 
   bool knownSize(SizeOffsetEvalType SizeOffset) {
Index: tools/polly/lib/CodeGen/LoopGenerators.cpp
===================================================================
--- tools/polly/lib/CodeGen/LoopGenerators.cpp	(revision 165940)
+++ tools/polly/lib/CodeGen/LoopGenerators.cpp	(working copy)
@@ -178,8 +178,8 @@
   Builder.CreateCall(F);
 }
 
-IntegerType *OMPGenerator::getIntPtrTy() {
-  return P->getAnalysis<DataLayout>().getIntPtrType(Builder.getContext());
+IntegerType *OMPGenerator::getIntPtrTy(unsigned AS) {
+  return P->getAnalysis<DataLayout>().getIntPtrType(Builder.getContext(), AS);
 }
 
 Module *OMPGenerator::getModule() {
Index: tools/polly/lib/CodeGen/CodeGeneration.cpp
===================================================================
--- tools/polly/lib/CodeGen/CodeGeneration.cpp	(revision 165940)
+++ tools/polly/lib/CodeGen/CodeGeneration.cpp	(working copy)
@@ -348,7 +348,7 @@
 
   void addParameters(const CloogNames *names);
 
-  IntegerType *getIntPtrTy();
+  IntegerType *getIntPtrTy(unsigned AS = 0);
 
   public:
   void codegen(const clast_root *r);
@@ -357,8 +357,8 @@
 };
 }
 
-IntegerType *ClastStmtCodeGen::getIntPtrTy() {
-  return P->getAnalysis<DataLayout>().getIntPtrType(Builder.getContext());
+IntegerType *ClastStmtCodeGen::getIntPtrTy(unsigned AS) {
+  return P->getAnalysis<DataLayout>().getIntPtrType(Builder.getContext(), AS);
 }
 
 const std::vector<std::string> &ClastStmtCodeGen::getParallelLoops() {
Index: tools/polly/include/polly/CodeGen/LoopGenerators.h
===================================================================
--- tools/polly/include/polly/CodeGen/LoopGenerators.h	(revision 165940)
+++ tools/polly/include/polly/CodeGen/LoopGenerators.h	(working copy)
@@ -74,7 +74,7 @@
   IRBuilder<> &Builder;
   Pass *P;
 
-  IntegerType *getIntPtrTy();
+  IntegerType *getIntPtrTy(unsigned AS = 0);
   Module *getModule();
 
   void createCallParallelLoopStart(Value *SubFunction, Value *SubfunctionParam,
Index: tools/dragonegg/src/TypeConversion.cpp
===================================================================
--- tools/dragonegg/src/TypeConversion.cpp	(revision 165940)
+++ tools/dragonegg/src/TypeConversion.cpp	(working copy)
@@ -457,7 +457,9 @@
   }
 
   case OFFSET_TYPE:
-    return getDataLayout().getIntPtrType(Context);
+    // FIXME: Need to get the Address space here.
+    unsigned AS = 0;
+    return getDataLayout().getIntPtrType(Context, AS);
 
   case POINTER_TYPE:
   case REFERENCE_TYPE:
@@ -484,9 +486,11 @@
 
   case VECTOR_TYPE: {
     // LLVM does not support vectors of pointers, so turn any pointers into
-    // integers.
+    // integers. <-- This isn't true since at least 3.1 as far as I know - MicahV
+    // FIXME: Need to get the Address space here.
+    unsigned AS = 0;
     Type *EltTy = isa<ACCESS_TYPE>(TREE_TYPE(type)) ?
-      getDataLayout().getIntPtrType(Context) : getRegType(TREE_TYPE(type));
+      getDataLayout().getIntPtrType(Context, AS) : getRegType(TREE_TYPE(type));
     return VectorType::get(EltTy, TYPE_VECTOR_SUBPARTS(type));
   }
 
@@ -1422,7 +1426,9 @@
     // which are really just integer offsets.  Return the appropriate integer
     // type directly.
     // Caching the type conversion is not worth it.
-    return CheckTypeConversion(type, getDataLayout().getIntPtrType(Context));
+    // FIXME: Need to get the Address space here.
+    unsigned AS = 0;
+    return CheckTypeConversion(type, getDataLayout().getIntPtrType(Context, AS));
 
   case REAL_TYPE:
     // Caching the type conversion is not worth it.
@@ -1461,7 +1467,9 @@
     // LLVM does not support vectors of pointers, so turn any pointers into
     // integers.
     if (isa<ACCESS_TYPE>(TREE_TYPE(type)))
-      Ty = getDataLayout().getIntPtrType(Context);
+      // FIXME: Need to get the Address space here.
+      unsigned AS = 0;
+      Ty = getDataLayout().getIntPtrType(Context, AS);
     else
       Ty = ConvertTypeNonRecursive(main_type(type));
     Ty = VectorType::get(Ty, TYPE_VECTOR_SUBPARTS(type));
Index: tools/dragonegg/src/ConstantConversion.cpp
===================================================================
--- tools/dragonegg/src/ConstantConversion.cpp	(revision 165940)
+++ tools/dragonegg/src/ConstantConversion.cpp	(working copy)
@@ -294,8 +294,9 @@
   default:
     llvm_unreachable("Unsupported type!");
   case Type::PointerTyID: {
+    unsigned AS = Ty->getPointerAddressSpace();
     // Cast to an integer with the same number of bits and return that.
-    IntegerType *IntTy = getDataLayout().getIntPtrType(Context);
+    IntegerType *IntTy = getDataLayout().getIntPtrType(Context, AS);
     return BitSlice(0, StoreSize, Folder.CreatePtrToInt(C, IntTy));
   }
   case Type::DoubleTyID:
@@ -443,9 +444,10 @@
   }
 
   case Type::PointerTyID: {
+    unsigned AS = Ty->getPointerAddressSpace();
     // Interpret as an integer with the same number of bits then cast back to
     // the original type.
-    IntegerType *IntTy = getDataLayout().getIntPtrType(Context);
+    IntegerType *IntTy = getDataLayout().getIntPtrType(Context, AS);
     C = InterpretAsType(C, IntTy, StartingBit, Folder);
     return Folder.CreateIntToPtr(C, Ty);
   }
@@ -559,7 +561,9 @@
     unsigned NumElts = TYPE_VECTOR_SUBPARTS(type);
     unsigned Stride = GET_MODE_BITSIZE(TYPE_MODE(elt_type));
     SmallVector<Constant*, 16> Vals(NumElts);
-    IntegerType *IntPtrTy = getDataLayout().getIntPtrType(Context);
+    // FIXME: what is the address space here?
+    unsigned AS = 0;
+    IntegerType *IntPtrTy = getDataLayout().getIntPtrType(Context, AS);
     for (unsigned i = 0; i != NumElts; ++i) {
       Vals[i] = ExtractRegisterFromConstantImpl(C, elt_type,
                                                 StartingBit+i*Stride, Folder);
@@ -983,7 +987,8 @@
   if (isa<VECTOR_TYPE>(init_type) && ActualEltTy == EltTy) {
     // If this is a vector of pointers, convert it to a vector of integers.
     if (isa<PointerType>(EltTy)) {
-      IntegerType *IntPtrTy = getDataLayout().getIntPtrType(Context);
+    unsigned AS = EltTy->getPointerAddressSpace();
+      IntegerType *IntPtrTy = getDataLayout().getIntPtrType(Context, AS);
       for (unsigned i = 0, e = Elts.size(); i != e; ++i)
         Elts[i] = Folder.CreatePtrToInt(Elts[i], IntPtrTy);
     }
@@ -1351,7 +1356,8 @@
   Constant *LHS = getAsRegister(TREE_OPERAND(exp, 0), Folder);
   Constant *RHS = getAsRegister(TREE_OPERAND(exp, 1), Folder);
   if (LHS->getType()->getScalarType()->isPointerTy()) {
-    Type *PtrIntTy = getDataLayout().getIntPtrType(Context);
+    unsigned AS = LHS->getType()->getScalarType()->getPointerAddressSpace();
+    Type *PtrIntTy = getDataLayout().getIntPtrType(Context, AS);
     LHS = Folder.CreatePtrToInt(LHS, PtrIntTy);
     RHS = Folder.CreatePtrToInt(RHS, PtrIntTy);
   }
Index: tools/dragonegg/src/Convert.cpp
===================================================================
--- tools/dragonegg/src/Convert.cpp	(revision 165940)
+++ tools/dragonegg/src/Convert.cpp	(working copy)
@@ -461,7 +461,9 @@
     Value *Res = UndefValue::get(RegTy);
     bool isVectorOfPointers = isa<PointerType>(EltRegTy);
     unsigned Stride = GET_MODE_SIZE(TYPE_MODE(elt_type));
-    IntegerType *IntPtrTy = getDataLayout().getIntPtrType(Context);
+    unsigned AS = EltRegTy->isPointerTy() ?
+      EltRegTy->getPointerAddressSpace() : 0;
+    IntegerType *IntPtrTy = getDataLayout().getIntPtrType(Context, AS);
     for (unsigned i = 0; i != NumElts; ++i) {
       Value *Idx = Builder.getInt32(i);
       Value *Elt = LoadRegisterFromMemory(Loc, elt_type, AliasTag, Builder);
@@ -840,8 +842,10 @@
         // bytes, but only 10 are copied.  If the object is really a union
         // we might need the other bytes.  We must also be careful to use
         // the smaller alignment.
+        // FIXME: Where do we get the address space?
+        unsigned AS = 0;
         Type *SBP = Type::getInt8PtrTy(Context);
-        Type *IntPtr = getDataLayout().getIntPtrType(Context);
+        Type *IntPtr = getDataLayout().getIntPtrType(Context, AS);
         Value *Ops[5] = {
           Builder.CreateCast(Instruction::BitCast, Loc, SBP),
           Builder.CreateCast(Instruction::BitCast, AI, SBP),
@@ -1351,11 +1355,12 @@
         } else {
           // Advance to the point we want to load from.
           if (ReturnOffset) {
+            unsigned AS = ResultLV.Ptr->getType()->getPointerAddressSpace();
             ResultLV.Ptr =
               Builder.CreateBitCast(ResultLV.Ptr, Type::getInt8PtrTy(Context));
             ResultLV.Ptr =
               Builder.CreateGEP(ResultLV.Ptr,
-                                ConstantInt::get(TD.getIntPtrType(Context),
+                                ConstantInt::get(TD.getIntPtrType(Context, AS),
                                                  ReturnOffset),
                                 flag_verbose_asm ? "rtvl" : "");
             ResultLV.setAlignment(MinAlign(ResultLV.getAlignment(), ReturnOffset));
@@ -1860,8 +1865,9 @@
   unsigned VecElts = isa<VectorType>(OrigTy) ?
     cast<VectorType>(OrigTy)->getNumElements() : 0;
   if (OrigEltTy->isPointerTy()) {
+    unsigned AS = OrigEltTy->getPointerAddressSpace();
     // A pointer/vector of pointer - form a (vector of) pointer sized integers.
-    Type *NewEltTy = TD.getIntPtrType(Context);
+    Type *NewEltTy = TD.getIntPtrType(Context, AS);
     Type *NewTy = VecElts ? VectorType::get(NewEltTy, VecElts) : NewEltTy;
     return Builder.CreatePtrToInt(V, NewTy);
   }
@@ -2219,8 +2225,10 @@
 
 Value *TreeToLLVM::EmitMemCpy(Value *DestPtr, Value *SrcPtr, Value *Size,
                               unsigned Align) {
+
   Type *SBP = Type::getInt8PtrTy(Context);
-  Type *IntPtr = TD.getIntPtrType(Context);
+  unsigned AS = DestPtr->getType()->getPointerAddressSpace();
+  Type *IntPtr = TD.getIntPtrType(Context, AS);
   Value *Ops[5] = {
     Builder.CreateBitCast(DestPtr, SBP),
     Builder.CreateBitCast(SrcPtr, SBP),
@@ -2238,7 +2246,8 @@
 Value *TreeToLLVM::EmitMemMove(Value *DestPtr, Value *SrcPtr, Value *Size,
                                unsigned Align) {
   Type *SBP = Type::getInt8PtrTy(Context);
-  Type *IntPtr = TD.getIntPtrType(Context);
+  unsigned AS = DestPtr->getType()->getPointerAddressSpace();
+  Type *IntPtr = TD.getIntPtrType(Context, AS);
   Value *Ops[5] = {
     Builder.CreateBitCast(DestPtr, SBP),
     Builder.CreateBitCast(SrcPtr, SBP),
@@ -2256,7 +2265,8 @@
 Value *TreeToLLVM::EmitMemSet(Value *DestPtr, Value *SrcVal, Value *Size,
                               unsigned Align) {
   Type *SBP = Type::getInt8PtrTy(Context);
-  Type *IntPtr = TD.getIntPtrType(Context);
+  unsigned AS = DestPtr->getType()->getPointerAddressSpace();
+  Type *IntPtr = TD.getIntPtrType(Context, AS);
   Value *Ops[5] = {
     Builder.CreateBitCast(DestPtr, SBP),
     Builder.CreateIntCast(SrcVal, Type::getInt8Ty(Context), /*isSigned*/true),
@@ -2904,8 +2914,10 @@
       } else {
         // LLVM does not support vectors of pointers, so turn any pointers into
         // integers.
-        if (isa<PointerType>(Elt->getType()))
+        if (isa<PointerType>(Elt->getType())) {
+          unsigned AS = Elt->getType()->getPointerAddressSpace();
           Elt = Builder.CreatePtrToInt(Elt, TD.getIntPtrType(Context));
+        }
         assert(Elt->getType() == VTy->getElementType() &&
                "Unexpected type for vector constructor!");
         BuildVecOps.push_back(Elt);
@@ -3473,13 +3485,14 @@
   unsigned Align = DestLoc->getAlignment();
   // AggTy - The type of the aggregate being stored to.
   Type *AggTy = cast<PointerType>(Ptr->getType())->getElementType();
+  unsigned AS = Ptr->getType()->getPointerAddressSpace();
   // MaxStoreSize - The maximum number of bytes we can store without overflowing
   // the aggregate.
   int64_t MaxStoreSize = TD.getTypeAllocSize(AggTy);
   if (Client.Offset) {
     Ptr = Builder.CreateBitCast(Ptr, Type::getInt8PtrTy(Context));
     Ptr = Builder.CreateGEP(Ptr,
-                    ConstantInt::get(TD.getIntPtrType(Context), Client.Offset),
+                    ConstantInt::get(TD.getIntPtrType(Context, AS), Client.Offset),
                     flag_verbose_asm ? "ro" : "");
     Align = MinAlign(Align, Client.Offset);
     MaxStoreSize -= Client.Offset;
@@ -5676,7 +5689,9 @@
   if (!validate_gimple_arglist(stmt, INTEGER_TYPE, POINTER_TYPE, VOID_TYPE))
     return false;
 
-  Type *IntPtr = TD.getIntPtrType(Context);
+  // FIXME: Where do I get the address space from here?
+  unsigned AS = 0;
+  Type *IntPtr = TD.getIntPtrType(Context, AS);
   Value *Offset = EmitMemory(gimple_call_arg(stmt, 0));
   Value *Handler = EmitMemory(gimple_call_arg(stmt, 1));
 
@@ -6025,7 +6040,8 @@
   ArrayAddr = ArrayAddrLV.Ptr;
   ArrayAlign = ArrayAddrLV.getAlignment();
 
-  Type *IntPtrTy = getDataLayout().getIntPtrType(Context);
+  unsigned AS = ArrayAddr->getType()->getPointerAddressSpace();
+  Type *IntPtrTy = getDataLayout().getIntPtrType(Context, AS);
   IndexVal = Builder.CreateIntCast(IndexVal, IntPtrTy,
                                    /*isSigned*/!TYPE_UNSIGNED(IndexType));
 
@@ -6601,7 +6617,9 @@
 
   // Convert the elements.
   SmallVector<Constant*, 16> Elts;
-  IntegerType *IntTy = getDataLayout().getIntPtrType(Context);
+  // FIXME: Where do I get the address space from?
+  unsigned AS = 0;
+  IntegerType *IntTy = getDataLayout().getIntPtrType(Context, AS);
   for (tree elt = TREE_VECTOR_CST_ELTS(reg); elt; elt = TREE_CHAIN(elt)) {
     Constant *Elt = EmitRegisterConstant(TREE_VALUE(elt));
     // LLVM does not support vectors of pointers, so turn any pointers into