diff --git a/AST/ASTContext.cpp b/AST/ASTContext.cpp
index 2487aba..b5b28bc 100644
--- a/AST/ASTContext.cpp
+++ b/AST/ASTContext.cpp
@@ -133,7 +133,7 @@
   // C99 6.2.5p2.
   InitBuiltinType(BoolTy,              BuiltinType::Bool);
   // C99 6.2.5p3.
-  if (Target.isCharSigned(FullSourceLoc()))
+  if (Target.isCharSigned())
     InitBuiltinType(CharTy,            BuiltinType::Char_S);
   else
     InitBuiltinType(CharTy,            BuiltinType::Char_U);
@@ -180,7 +180,7 @@
 /// getTypeSize - Return the size of the specified type, in bits.  This method
 /// does not work on incomplete types.
 std::pair<uint64_t, unsigned>
-ASTContext::getTypeInfo(QualType T, SourceLocation L) {
+ASTContext::getTypeInfo(QualType T) {
   T = T.getCanonicalType();
   uint64_t Size;
   unsigned Align;
@@ -195,8 +195,7 @@
   case Type::ConstantArray: {
     ConstantArrayType *CAT = cast<ConstantArrayType>(T);
     
-    std::pair<uint64_t, unsigned> EltInfo = 
-      getTypeInfo(CAT->getElementType(), L);
+    std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(CAT->getElementType());
     Size = EltInfo.first*CAT->getSize().getZExtValue();
     Align = EltInfo.second;
     break;
@@ -204,7 +203,7 @@
   case Type::OCUVector:
   case Type::Vector: {
     std::pair<uint64_t, unsigned> EltInfo = 
-      getTypeInfo(cast<VectorType>(T)->getElementType(), L);
+      getTypeInfo(cast<VectorType>(T)->getElementType());
     Size = EltInfo.first*cast<VectorType>(T)->getNumElements();
     // FIXME: Vector alignment is not the alignment of its elements.
     Align = EltInfo.second;
@@ -220,62 +219,62 @@
     case BuiltinType::Void:
       assert(0 && "Incomplete types have no size!");
     case BuiltinType::Bool:
-      Target.getBoolInfo(Size, Align, getFullLoc(L));
+      Target.getBoolInfo(Size, Align);
       break;
     case BuiltinType::Char_S:
     case BuiltinType::Char_U:
     case BuiltinType::UChar:
     case BuiltinType::SChar:
-      Target.getCharInfo(Size, Align, getFullLoc(L));
+      Target.getCharInfo(Size, Align);
       break;
     case BuiltinType::UShort:
     case BuiltinType::Short:
-      Target.getShortInfo(Size, Align, getFullLoc(L));
+      Target.getShortInfo(Size, Align);
       break;
     case BuiltinType::UInt:
     case BuiltinType::Int:
-      Target.getIntInfo(Size, Align, getFullLoc(L));
+      Target.getIntInfo(Size, Align);
       break;
     case BuiltinType::ULong:
     case BuiltinType::Long:
-      Target.getLongInfo(Size, Align, getFullLoc(L));
+      Target.getLongInfo(Size, Align);
       break;
     case BuiltinType::ULongLong:
     case BuiltinType::LongLong:
-      Target.getLongLongInfo(Size, Align, getFullLoc(L));
+      Target.getLongLongInfo(Size, Align);
       break;
     case BuiltinType::Float:
-      Target.getFloatInfo(Size, Align, F, getFullLoc(L));
+      Target.getFloatInfo(Size, Align, F);
       break;
     case BuiltinType::Double:
-      Target.getDoubleInfo(Size, Align, F, getFullLoc(L));
+      Target.getDoubleInfo(Size, Align, F);
       break;
     case BuiltinType::LongDouble:
-      Target.getLongDoubleInfo(Size, Align, F, getFullLoc(L));
+      Target.getLongDoubleInfo(Size, Align, F);
       break;
     }
     break;
   }
   case Type::ASQual:
-    return getTypeInfo(QualType(cast<ASQualType>(T)->getBaseType(), 0), L);
+    // FIXME: Pointers into different addr spaces could have different sizes and
+    // alignment requirements: getPointerInfo should take an AddrSpace.
+    return getTypeInfo(QualType(cast<ASQualType>(T)->getBaseType(), 0));
   case Type::ObjCQualifiedId:
-    Target.getPointerInfo(Size, Align, getFullLoc(L));
-    break;
   case Type::Pointer:
-    Target.getPointerInfo(Size, Align, getFullLoc(L));
+    Target.getPointerInfo(Size, Align);
     break;
   case Type::Reference:
     // "When applied to a reference or a reference type, the result is the size
     // of the referenced type." C++98 5.3.3p2: expr.sizeof.
     // FIXME: This is wrong for struct layout: a reference in a struct has
     // pointer size.
-    return getTypeInfo(cast<ReferenceType>(T)->getReferenceeType(), L);
+    return getTypeInfo(cast<ReferenceType>(T)->getReferenceeType());
     
   case Type::Complex: {
     // Complex types have the same alignment as their elements, but twice the
     // size.
     std::pair<uint64_t, unsigned> EltInfo = 
-      getTypeInfo(cast<ComplexType>(T)->getElementType(), L);
+      getTypeInfo(cast<ComplexType>(T)->getElementType());
     Size = EltInfo.first*2;
     Align = EltInfo.second;
     break;
@@ -283,11 +282,11 @@
   case Type::Tagged:
     TagType *TT = cast<TagType>(T);
     if (RecordType *RT = dyn_cast<RecordType>(TT)) {
-      const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl(), L);
+      const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl());
       Size = Layout.getSize();
       Align = Layout.getAlignment();
     } else if (EnumDecl *ED = dyn_cast<EnumDecl>(TT->getDecl())) {
-      return getTypeInfo(ED->getIntegerType(), L);
+      return getTypeInfo(ED->getIntegerType());
     } else {
       assert(0 && "Unimplemented type sizes!");
     }
@@ -301,8 +300,7 @@
 /// getASTRecordLayout - Get or compute information about the layout of the
 /// specified record (struct/union/class), which indicates its size and field
 /// position information.
-const ASTRecordLayout &ASTContext::getASTRecordLayout(const RecordDecl *D,
-                                                      SourceLocation L) {
+const ASTRecordLayout &ASTContext::getASTRecordLayout(const RecordDecl *D) {
   assert(D->isDefinition() && "Cannot get layout of forward declarations!");
   
   // Look up this layout, if already laid out, return what we have.
@@ -339,7 +337,7 @@
         assert (BitWidthIsICE  && "Invalid BitField size expression");
         FieldSize = I.getZExtValue();
 
-        std::pair<uint64_t, unsigned> TypeInfo = getTypeInfo(FD->getType(), L);
+        std::pair<uint64_t, unsigned> TypeInfo = getTypeInfo(FD->getType());
         uint64_t TypeSize = TypeInfo.first;
         
         if (const AlignedAttr *AA = FD->getAttr<AlignedAttr>())
@@ -372,11 +370,11 @@
             FieldAlign = 8;
           else {
             const ArrayType* ATy = FD->getType()->getAsArrayType();
-            FieldAlign = getTypeAlign(ATy->getElementType(), L);
+            FieldAlign = getTypeAlign(ATy->getElementType());
           }
           FieldSize = 0;
         } else {
-          std::pair<uint64_t, unsigned> FieldInfo = getTypeInfo(FD->getType(), L);
+          std::pair<uint64_t, unsigned> FieldInfo = getTypeInfo(FD->getType());
           FieldSize = FieldInfo.first;
         
           if (const AlignedAttr *AA = FD->getAttr<AlignedAttr>())
@@ -408,7 +406,7 @@
     // Union layout just puts each member at the start of the record.
     for (unsigned i = 0, e = D->getNumMembers(); i != e; ++i) {
       const FieldDecl *FD = D->getMember(i);
-      std::pair<uint64_t, unsigned> FieldInfo = getTypeInfo(FD->getType(), L);
+      std::pair<uint64_t, unsigned> FieldInfo = getTypeInfo(FD->getType());
       uint64_t FieldSize = FieldInfo.first;
       unsigned FieldAlign = FieldInfo.second;
       
@@ -1073,16 +1071,15 @@
 /// getObjCEncodingTypeSize returns size of type for objective-c encoding
 /// purpose.
 int ASTContext::getObjCEncodingTypeSize(QualType type) {
-  SourceLocation Loc;
-  uint64_t sz = getTypeSize(type, Loc);
+  uint64_t sz = getTypeSize(type);
   
   // Make all integer and enum types at least as large as an int
   if (sz > 0 && type->isIntegralType())
-    sz = std::max(sz, getTypeSize(IntTy, Loc));
+    sz = std::max(sz, getTypeSize(IntTy));
   // Treat arrays as pointers, since that's how they're passed in.
   else if (type->isArrayType())
-    sz = getTypeSize(VoidPtrTy, Loc);
-  return sz / getTypeSize(CharTy, Loc);
+    sz = getTypeSize(VoidPtrTy);
+  return sz / getTypeSize(CharTy);
 }
 
 /// getObjCEncodingForMethodDecl - Return the encoded type for this method
@@ -1098,7 +1095,7 @@
   // Start with computing size of a pointer in number of bytes.
   // FIXME: There might(should) be a better way of doing this computation!
   SourceLocation Loc;
-  int PtrSize = getTypeSize(VoidPtrTy, Loc) / getTypeSize(CharTy, Loc);
+  int PtrSize = getTypeSize(VoidPtrTy) / getTypeSize(CharTy);
   // The first two arguments (self and _cmd) are pointers; account for
   // their size.
   int ParmOffset = 2 * PtrSize;
diff --git a/AST/Expr.cpp b/AST/Expr.cpp
index 1c32d7c..11fcc41 100644
--- a/AST/Expr.cpp
+++ b/AST/Expr.cpp
@@ -510,8 +510,7 @@
   case CallExprClass: {
     const CallExpr *CE = cast<CallExpr>(this);
     llvm::APSInt Result(32);
-    Result.zextOrTrunc(
-      static_cast<uint32_t>(Ctx.getTypeSize(getType(), CE->getLocStart())));
+    Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
     if (CE->isBuiltinClassifyType(Result))
       return true;
     if (CE->isBuiltinConstantExpr())
@@ -673,23 +672,20 @@
     break;
   case CharacterLiteralClass: {
     const CharacterLiteral *CL = cast<CharacterLiteral>(this);
-    Result.zextOrTrunc(
-      static_cast<uint32_t>(Ctx.getTypeSize(getType(), CL->getLoc())));
+    Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
     Result = CL->getValue();
     Result.setIsUnsigned(!getType()->isSignedIntegerType());
     break;
   }
   case TypesCompatibleExprClass: {
     const TypesCompatibleExpr *TCE = cast<TypesCompatibleExpr>(this);
-    Result.zextOrTrunc(
-      static_cast<uint32_t>(Ctx.getTypeSize(getType(), TCE->getLocStart())));
+    Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
     Result = Ctx.typesAreCompatible(TCE->getArgType1(), TCE->getArgType2());
     break;
   }
   case CallExprClass: {
     const CallExpr *CE = cast<CallExpr>(this);
-    Result.zextOrTrunc(
-      static_cast<uint32_t>(Ctx.getTypeSize(getType(), CE->getLocStart())));
+    Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
     if (CE->isBuiltinClassifyType(Result))
       break;
     if (Loc) *Loc = getLocStart();
@@ -723,9 +719,7 @@
     case UnaryOperator::SizeOf:
     case UnaryOperator::AlignOf:
       // Return the result in the right width.
-      Result.zextOrTrunc(
-                         static_cast<uint32_t>(Ctx.getTypeSize(getType(),
-                                                       Exp->getOperatorLoc())));
+      Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
         
       // sizeof(void) and __alignof__(void) = 1 as a gcc extension.
       if (Exp->getSubExpr()->getType()->isVoidType()) {
@@ -744,22 +738,16 @@
         // GCC extension: sizeof(function) = 1.
         Result = Exp->getOpcode() == UnaryOperator::AlignOf ? 4 : 1;
       } else {
-        unsigned CharSize = 
-          Ctx.Target.getCharWidth(Ctx.getFullLoc(Exp->getOperatorLoc()));
-        
+        unsigned CharSize = Ctx.Target.getCharWidth();
         if (Exp->getOpcode() == UnaryOperator::AlignOf)
-          Result = Ctx.getTypeAlign(Exp->getSubExpr()->getType(),
-                                    Exp->getOperatorLoc()) / CharSize;
+          Result = Ctx.getTypeAlign(Exp->getSubExpr()->getType()) / CharSize;
         else
-          Result = Ctx.getTypeSize(Exp->getSubExpr()->getType(),
-                                   Exp->getOperatorLoc()) / CharSize;
+          Result = Ctx.getTypeSize(Exp->getSubExpr()->getType()) / CharSize;
       }
       break;
     case UnaryOperator::LNot: {
       bool Val = Result == 0;
-      Result.zextOrTrunc(
-        static_cast<uint32_t>(Ctx.getTypeSize(getType(),
-                                              Exp->getOperatorLoc())));
+      Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
       Result = Val;
       break;
     }
@@ -780,8 +768,7 @@
     const SizeOfAlignOfTypeExpr *Exp = cast<SizeOfAlignOfTypeExpr>(this);
     
     // Return the result in the right width.
-    Result.zextOrTrunc(
-      static_cast<uint32_t>(Ctx.getTypeSize(getType(), Exp->getOperatorLoc())));
+    Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
     
     // sizeof(void) and __alignof__(void) = 1 as a gcc extension.
     if (Exp->getArgumentType()->isVoidType()) {
@@ -800,17 +787,12 @@
       // GCC extension: sizeof(function) = 1.
       Result = Exp->isSizeOf() ? 1 : 4;
     } else { 
-      unsigned CharSize =
-        Ctx.Target.getCharWidth(Ctx.getFullLoc(Exp->getOperatorLoc()));
-      
+      unsigned CharSize = Ctx.Target.getCharWidth();
       if (Exp->isSizeOf())
-        Result = Ctx.getTypeSize(Exp->getArgumentType(),
-                                 Exp->getOperatorLoc()) / CharSize;
+        Result = Ctx.getTypeSize(Exp->getArgumentType()) / CharSize;
       else
-        Result = Ctx.getTypeAlign(Exp->getArgumentType(), 
-                                  Exp->getOperatorLoc()) / CharSize;
+        Result = Ctx.getTypeAlign(Exp->getArgumentType()) / CharSize;
     }
-
     break;
   }
   case BinaryOperatorClass: {
@@ -927,8 +909,7 @@
       return false;
     }
 
-    uint32_t DestWidth = 
-      static_cast<uint32_t>(Ctx.getTypeSize(getType(), CastLoc));
+    uint32_t DestWidth = static_cast<uint32_t>(Ctx.getTypeSize(getType()));
     
     // Handle simple integer->integer casts.
     if (SubExpr->getType()->isIntegerType()) {
@@ -1140,7 +1121,7 @@
     QualType Ty = ME->getBase()->getType();
     
     RecordDecl *RD = Ty->getAsRecordType()->getDecl();
-    const ASTRecordLayout &RL = C.getASTRecordLayout(RD, SourceLocation());
+    const ASTRecordLayout &RL = C.getASTRecordLayout(RD);
     FieldDecl *FD = ME->getMemberDecl();
     
     // FIXME: This is linear time.
@@ -1157,7 +1138,7 @@
     bool ICE = ASE->getIdx()->isIntegerConstantExpr(Idx, C);
     assert(ICE && "Array index is not a constant integer!");
     
-    int64_t size = C.getTypeSize(ASE->getType(), SourceLocation());
+    int64_t size = C.getTypeSize(ASE->getType());
     size *= Idx.getSExtValue();
     
     return size + evaluateOffsetOf(C, Base);
@@ -1172,9 +1153,7 @@
 {
   assert(Opc == OffsetOf && "Unary operator not offsetof!");
   
-  unsigned CharSize = 
-    C.Target.getCharWidth(C.getFullLoc(getOperatorLoc()));
-  
+  unsigned CharSize = C.Target.getCharWidth();
   return ::evaluateOffsetOf(C, Val) / CharSize;
 }
 
diff --git a/Analysis/GRExprEngine.cpp b/Analysis/GRExprEngine.cpp
index 2481f56..4cd942b 100644
--- a/Analysis/GRExprEngine.cpp
+++ b/Analysis/GRExprEngine.cpp
@@ -277,8 +277,7 @@
   // While most of this can be assumed (such as the signedness), having it
   // just computed makes sure everything makes the same assumptions end-to-end.
   
-  unsigned bits = getContext().getTypeSize(CondE->getType(),
-                                           CondE->getExprLoc());
+  unsigned bits = getContext().getTypeSize(CondE->getType());
 
   APSInt V1(bits, false);
   APSInt V2 = V1;
@@ -716,10 +715,8 @@
   
   uint64_t size = 1;  // Handle sizeof(void)
   
-  if (T != getContext().VoidTy) {
-    SourceLocation Loc = Ex->getExprLoc();
-    size = getContext().getTypeSize(T, Loc) / 8;
-  }
+  if (T != getContext().VoidTy)
+    size = getContext().getTypeSize(T) / 8;
   
   Nodify(Dst, Ex, Pred,
          SetRVal(Pred->getState(), Ex,
@@ -949,10 +946,9 @@
   if (!T.getTypePtr()->isConstantSizeType())
     return;
   
-  SourceLocation Loc = U->getExprLoc();
-  uint64_t size = getContext().getTypeSize(T, Loc) / 8;                
+  uint64_t size = getContext().getTypeSize(T) / 8;                
   ValueState* St = Pred->getState();
-  St = SetRVal(St, U, NonLVal::MakeVal(ValMgr, size, U->getType(), Loc));
+  St = SetRVal(St, U, NonLVal::MakeVal(ValMgr, size, U->getType()));
 
   Nodify(Dst, U, Pred, St);
 }
diff --git a/Analysis/GRSimpleVals.cpp b/Analysis/GRSimpleVals.cpp
index d8a3112..c00800c 100644
--- a/Analysis/GRSimpleVals.cpp
+++ b/Analysis/GRSimpleVals.cpp
@@ -160,7 +160,7 @@
   
   llvm::APSInt V = cast<nonlval::ConcreteInt>(X).getValue();
   V.setIsUnsigned(T->isUnsignedIntegerType() || T->isPointerType());
-  V.extOrTrunc(ValMgr.getContext().getTypeSize(T, SourceLocation()));
+  V.extOrTrunc(ValMgr.getContext().getTypeSize(T));
   
   if (T->isPointerType())
     return lval::ConcreteInt(ValMgr.getValue(V));
@@ -182,7 +182,7 @@
   
   llvm::APSInt V = cast<lval::ConcreteInt>(X).getValue();
   V.setIsUnsigned(T->isUnsignedIntegerType() || T->isPointerType());
-  V.extOrTrunc(ValMgr.getContext().getTypeSize(T, SourceLocation()));
+  V.extOrTrunc(ValMgr.getContext().getTypeSize(T));
 
   return nonlval::ConcreteInt(ValMgr.getValue(V));
 }
diff --git a/Analysis/RValues.cpp b/Analysis/RValues.cpp
index 6369da4..36ea2df 100644
--- a/Analysis/RValues.cpp
+++ b/Analysis/RValues.cpp
@@ -207,10 +207,8 @@
 // Utility methods for constructing Non-LVals.
 //===----------------------------------------------------------------------===//
 
-NonLVal NonLVal::MakeVal(ValueManager& ValMgr, uint64_t X, QualType T,
-                             SourceLocation Loc) {  
-
-  return nonlval::ConcreteInt(ValMgr.getValue(X, T, Loc));
+NonLVal NonLVal::MakeVal(ValueManager& ValMgr, uint64_t X, QualType T) {  
+  return nonlval::ConcreteInt(ValMgr.getValue(X, T));
 }
 
 NonLVal NonLVal::MakeVal(ValueManager& ValMgr, IntegerLiteral* I) {
@@ -220,7 +218,6 @@
 }
 
 NonLVal NonLVal::MakeIntTruthVal(ValueManager& ValMgr, bool b) {
-
   return nonlval::ConcreteInt(ValMgr.getTruthValue(b));
 }
 
diff --git a/Analysis/ValueManager.cpp b/Analysis/ValueManager.cpp
index 2a8d23d..a02f3e4 100644
--- a/Analysis/ValueManager.cpp
+++ b/Analysis/ValueManager.cpp
@@ -48,10 +48,9 @@
   return getValue(V);
 }
 
-const llvm::APSInt& ValueManager::getValue(uint64_t X, QualType T,
-                                           SourceLocation Loc) {
+const llvm::APSInt& ValueManager::getValue(uint64_t X, QualType T) {
   
-  unsigned bits = Ctx.getTypeSize(T, Loc);
+  unsigned bits = Ctx.getTypeSize(T);
   llvm::APSInt V(bits, T->isUnsignedIntegerType());
   V = X;
   return getValue(V);
diff --git a/Analysis/ValueState.cpp b/Analysis/ValueState.cpp
index 388dba6..f47e14b 100644
--- a/Analysis/ValueState.cpp
+++ b/Analysis/ValueState.cpp
@@ -258,8 +258,7 @@
         
       case Stmt::CharacterLiteralClass: {
         CharacterLiteral* C = cast<CharacterLiteral>(E);
-        return NonLVal::MakeVal(ValMgr, C->getValue(), C->getType(),
-                                C->getLoc());
+        return NonLVal::MakeVal(ValMgr, C->getValue(), C->getType());
       }
         
       case Stmt::IntegerLiteralClass: {
@@ -271,7 +270,6 @@
         // subexpression that has a value.
         
       case Stmt::ImplicitCastExprClass: {
-
         ImplicitCastExpr* C = cast<ImplicitCastExpr>(E);
         QualType CT = C->getType();
         
@@ -341,8 +339,7 @@
   switch (E->getStmtClass()) {
     case Stmt::CharacterLiteralClass: {
       CharacterLiteral* C = cast<CharacterLiteral>(E);
-      return NonLVal::MakeVal(ValMgr, C->getValue(), C->getType(),
-                              C->getLoc());
+      return NonLVal::MakeVal(ValMgr, C->getValue(), C->getType());
     }
       
     case Stmt::IntegerLiteralClass: {
diff --git a/Basic/TargetInfo.cpp b/Basic/TargetInfo.cpp
index 8701b38..1f0bece 100644
--- a/Basic/TargetInfo.cpp
+++ b/Basic/TargetInfo.cpp
@@ -28,22 +28,19 @@
 // TargetInfoImpl.
 
 void TargetInfo::getFloatInfo(uint64_t &Size, unsigned &Align,
-                              const llvm::fltSemantics *&Format,
-                              FullSourceLoc Loc) {
+                              const llvm::fltSemantics *&Format) {
   Align = 32;  // FIXME: implement correctly.
   Size = 32;
   Format = &llvm::APFloat::IEEEsingle;
 }
 void TargetInfo::getDoubleInfo(uint64_t &Size, unsigned &Align,
-                               const llvm::fltSemantics *&Format,
-                               FullSourceLoc Loc) {
+                               const llvm::fltSemantics *&Format) {
   Size = 64; // FIXME: implement correctly.
   Align = 32;
   Format = &llvm::APFloat::IEEEdouble;
 }
 void TargetInfo::getLongDoubleInfo(uint64_t &Size, unsigned &Align,
-                                   const llvm::fltSemantics *&Format,
-                                   FullSourceLoc Loc) {
+                                   const llvm::fltSemantics *&Format) {
   Size = Align = 64;  // FIXME: implement correctly.
   Format = &llvm::APFloat::IEEEdouble;
   //Size = 80; Align = 32;  // FIXME: implement correctly.
@@ -74,7 +71,7 @@
 /// ComputeWCharWidth - Determine the width of the wchar_t type for the primary
 /// target, diagnosing whether this is non-portable across the secondary
 /// targets.
-void TargetInfo::ComputeWCharInfo(FullSourceLoc Loc) {
+void TargetInfo::ComputeWCharInfo() {
   Target->getWCharInfo(WCharWidth, WCharAlign);
 }
 
diff --git a/Basic/Targets.cpp b/Basic/Targets.cpp
index d170fbe..89125b4 100644
--- a/Basic/Targets.cpp
+++ b/Basic/Targets.cpp
@@ -722,50 +722,6 @@
 
 } // end anonymous namespace.
 
-namespace {
-class LinuxTargetInfo : public DarwinTargetInfo {
-public:
-  LinuxTargetInfo(const std::string& triple) : DarwinTargetInfo(triple) {
-    // Note: I have no idea if this is right, just for testing.
-    WCharWidth = 16;
-    WCharAlign = 16;
-  }
-  
-  virtual void getTargetDefines(std::vector<char> &Defines) const {
-    // TODO: linux-specific stuff.
-    getX86Defines(Defines, false);
-  }
-  virtual void getTargetBuiltins(const Builtin::Info *&Records,
-                                 unsigned &NumRecords) const {
-    X86::getBuiltins(Records, NumRecords);
-  }
-  virtual const char *getVAListDeclaration() const {
-    return getI386VAListDeclaration();
-  }
-  virtual const char *getTargetPrefix() const {
-    return X86::getTargetPrefix();
-  }  
-  virtual void getGCCRegNames(const char * const *&Names, 
-                                   unsigned &NumNames) const {
-    X86::getGCCRegNames(Names, NumNames);
-  }  
-  virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 
-                                unsigned &NumAliases) const {
-    X86::getGCCRegAliases(Aliases, NumAliases);
-  }
-  virtual bool validateAsmConstraint(char c,
-                                     TargetInfo::ConstraintInfo &info) const {
-    return X86::validateAsmConstraint(c, info);
-  }
-  virtual std::string convertConstraint(const char Constraint) const {
-    return X86::convertConstraint(Constraint);
-  }
-  virtual const char *getClobbers() const {
-    return X86::getClobbers();
-  }  
-};
-} // end anonymous namespace.
-
 
 //===----------------------------------------------------------------------===//
 // Driver code
@@ -794,9 +750,6 @@
   if (IsX86(T))
     return new TargetInfo(new DarwinI386TargetInfo(T));
   
-  if (T.find("bogusW16W16-") == 0) // For testing portability.
-    return new TargetInfo(new LinuxTargetInfo(T));
-  
   return NULL;
 }
 
diff --git a/CodeGen/CGExprAgg.cpp b/CodeGen/CGExprAgg.cpp
index 493d279..325ac21 100644
--- a/CodeGen/CGExprAgg.cpp
+++ b/CodeGen/CGExprAgg.cpp
@@ -103,8 +103,7 @@
     DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp");
 
   // Get size and alignment info for this aggregate.
-  std::pair<uint64_t, unsigned> TypeInfo =
-    CGF.getContext().getTypeInfo(Ty, SourceLocation());
+  std::pair<uint64_t, unsigned> TypeInfo = CGF.getContext().getTypeInfo(Ty);
 
   // FIXME: Handle variable sized types.
   const llvm::Type *IntPtr = llvm::IntegerType::get(CGF.LLVMPointerWidth);
@@ -132,8 +131,7 @@
     SrcPtr = Builder.CreateBitCast(SrcPtr, BP, "tmp");
   
   // Get size and alignment info for this aggregate.
-  std::pair<uint64_t, unsigned> TypeInfo =
-    CGF.getContext().getTypeInfo(Ty, SourceLocation());
+  std::pair<uint64_t, unsigned> TypeInfo = CGF.getContext().getTypeInfo(Ty);
   
   // FIXME: Handle variable sized types.
   const llvm::Type *IntPtr = llvm::IntegerType::get(CGF.LLVMPointerWidth);
diff --git a/CodeGen/CGExprConstant.cpp b/CodeGen/CGExprConstant.cpp
index 30180c1..e2405b8 100644
--- a/CodeGen/CGExprConstant.cpp
+++ b/CodeGen/CGExprConstant.cpp
@@ -37,7 +37,8 @@
     
   llvm::Constant *VisitStmt(Stmt *S) {
     CGM.WarnUnsupported(S, "constant expression");
-    return llvm::UndefValue::get(CGM.getTypes().ConvertType(cast<Expr>(S)->getType()));
+    QualType T = cast<Expr>(S)->getType();
+    return llvm::UndefValue::get(CGM.getTypes().ConvertType(T));
   }
   
   llvm::Constant *VisitParenExpr(ParenExpr *PE) { 
@@ -314,8 +315,8 @@
     
     assert(E->getType()->isIntegerType() && "Result type must be an integer!");
     
-    uint32_t ResultWidth = static_cast<uint32_t>(
-      CGM.getContext().getTypeSize(E->getType(), SourceLocation()));
+    uint32_t ResultWidth =
+      static_cast<uint32_t>(CGM.getContext().getTypeSize(E->getType()));
     return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));    
   }
   
@@ -504,15 +505,15 @@
   llvm::Constant *EmitSizeAlignOf(QualType TypeToSize, 
                                   QualType RetType, bool isSizeOf) {
     std::pair<uint64_t, unsigned> Info =
-    CGM.getContext().getTypeInfo(TypeToSize, SourceLocation());
+      CGM.getContext().getTypeInfo(TypeToSize);
     
     uint64_t Val = isSizeOf ? Info.first : Info.second;
     Val /= 8;  // Return size in bytes, not bits.
     
     assert(RetType->isIntegerType() && "Result type must be an integer!");
     
-    uint32_t ResultWidth = static_cast<uint32_t>(
-      CGM.getContext().getTypeSize(RetType, SourceLocation()));
+    uint32_t ResultWidth = 
+      static_cast<uint32_t>(CGM.getContext().getTypeSize(RetType));
     return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
   }
 
@@ -616,8 +617,7 @@
   QualType type = E->getType().getCanonicalType();
   
   if (type->isIntegerType()) {
-    llvm::APSInt
-    Value(static_cast<uint32_t>(Context.getTypeSize(type, SourceLocation())));
+    llvm::APSInt Value(static_cast<uint32_t>(Context.getTypeSize(type)));
     if (E->isIntegerConstantExpr(Value, Context)) {
       return llvm::ConstantInt::get(Value);
     } 
diff --git a/CodeGen/CGExprScalar.cpp b/CodeGen/CGExprScalar.cpp
index 52b022b..892712a 100644
--- a/CodeGen/CGExprScalar.cpp
+++ b/CodeGen/CGExprScalar.cpp
@@ -656,16 +656,14 @@
                                           QualType RetType,bool isSizeOf){
   assert(RetType->isIntegerType() && "Result type must be an integer!");
   uint32_t ResultWidth = 
-    static_cast<uint32_t>(CGF.getContext().getTypeSize(RetType, 
-                                                       SourceLocation()));
+    static_cast<uint32_t>(CGF.getContext().getTypeSize(RetType));
 
   // sizeof(void) and __alignof__(void) = 1 as a gcc extension.
   if (TypeToSize->isVoidType())
     return llvm::ConstantInt::get(llvm::APInt(ResultWidth, 1));
   
   /// FIXME: This doesn't handle VLAs yet!
-  std::pair<uint64_t, unsigned> Info =
-    CGF.getContext().getTypeInfo(TypeToSize, SourceLocation());
+  std::pair<uint64_t, unsigned> Info = CGF.getContext().getTypeInfo(TypeToSize);
   
   uint64_t Val = isSizeOf ? Info.first : Info.second;
   Val /= 8;  // Return size in bytes, not bits.
@@ -696,8 +694,8 @@
   
   assert(E->getType()->isIntegerType() && "Result type must be an integer!");
   
-  uint32_t ResultWidth = static_cast<uint32_t>(
-    CGF.getContext().getTypeSize(E->getType(), SourceLocation()));
+  uint32_t ResultWidth =
+    static_cast<uint32_t>(CGF.getContext().getTypeSize(E->getType()));
   return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
 }
 
@@ -852,8 +850,7 @@
   
   const QualType LHSType = E->getLHS()->getType().getCanonicalType();
   const QualType LHSElementType = cast<PointerType>(LHSType)->getPointeeType();
-  uint64_t ElementSize = CGF.getContext().getTypeSize(LHSElementType,
-                                                      SourceLocation()) / 8;
+  uint64_t ElementSize = CGF.getContext().getTypeSize(LHSElementType) / 8;
   
   const llvm::Type *ResultType = ConvertType(E->getType());
   LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast");
diff --git a/CodeGen/CodeGenFunction.cpp b/CodeGen/CodeGenFunction.cpp
index adbb414..f48d093 100644
--- a/CodeGen/CodeGenFunction.cpp
+++ b/CodeGen/CodeGenFunction.cpp
@@ -59,8 +59,7 @@
 void CodeGenFunction::GenerateCode(const FunctionDecl *FD) {
   LLVMIntTy = ConvertType(getContext().IntTy);
   LLVMPointerWidth = static_cast<unsigned>(
-    getContext().getTypeSize(getContext().getPointerType(getContext().VoidTy),
-                             SourceLocation()));
+    getContext().getTypeSize(getContext().getPointerType(getContext().VoidTy)));
   
   CurFuncDecl = FD;
   CurFn = cast<llvm::Function>(CGM.GetAddrOfFunctionDecl(FD, true));
diff --git a/CodeGen/CodeGenModule.cpp b/CodeGen/CodeGenModule.cpp
index 1a69796..554fc3f 100644
--- a/CodeGen/CodeGenModule.cpp
+++ b/CodeGen/CodeGenModule.cpp
@@ -231,7 +231,7 @@
     Init = llvm::Constant::getNullValue(GV->getType()->getElementType());
   } else if (D->getType()->isIntegerType()) {
     llvm::APSInt Value(static_cast<uint32_t>(
-      getContext().getTypeSize(D->getInit()->getType(), SourceLocation())));
+      getContext().getTypeSize(D->getInit()->getType())));
     if (D->getInit()->isIntegerConstantExpr(Value, Context))
       Init = llvm::ConstantInt::get(Value);
   }
@@ -340,7 +340,7 @@
   if (MemCpyFn) return MemCpyFn;
   llvm::Intrinsic::ID IID;
   uint64_t Size; unsigned Align;
-  Context.Target.getPointerInfo(Size, Align, FullSourceLoc());
+  Context.Target.getPointerInfo(Size, Align);
   switch (Size) {
   default: assert(0 && "Unknown ptr width");
   case 32: IID = llvm::Intrinsic::memcpy_i32; break;
@@ -353,7 +353,7 @@
   if (MemSetFn) return MemSetFn;
   llvm::Intrinsic::ID IID;
   uint64_t Size; unsigned Align;
-  Context.Target.getPointerInfo(Size, Align, FullSourceLoc());
+  Context.Target.getPointerInfo(Size, Align);
   switch (Size) {
   default: assert(0 && "Unknown ptr width");
   case 32: IID = llvm::Intrinsic::memset_i32; break;
diff --git a/CodeGen/CodeGenTypes.cpp b/CodeGen/CodeGenTypes.cpp
index efdc0e8..9a669e8 100644
--- a/CodeGen/CodeGenTypes.cpp
+++ b/CodeGen/CodeGenTypes.cpp
@@ -118,8 +118,7 @@
     return R;
     
   // Otherwise, return an integer of the target-specified size.
-  unsigned BoolWidth = (unsigned)Context.getTypeSize(T, SourceLocation());
-  return llvm::IntegerType::get(BoolWidth);
+  return llvm::IntegerType::get((unsigned)Context.getTypeSize(T));
   
 }
 
@@ -179,7 +178,7 @@
     case BuiltinType::LongLong:
     case BuiltinType::ULongLong:
       return llvm::IntegerType::get(
-        static_cast<unsigned>(Context.getTypeSize(T, SourceLocation())));
+        static_cast<unsigned>(Context.getTypeSize(T)));
       
     case BuiltinType::Float:      return llvm::Type::FloatTy;
     case BuiltinType::Double:     return llvm::Type::DoubleTy;
@@ -356,7 +355,7 @@
     for (unsigned i = 0, e = RD->getNumMembers(); i != e; ++i)
       RO.addField(RD->getMember(i));
     
-    RO.layoutStructFields(Context.getASTRecordLayout(RD, SourceLocation()));
+    RO.layoutStructFields(Context.getASTRecordLayout(RD));
     
     // Get llvm::StructType.
     CGRecordLayouts[TD] = new CGRecordLayout(RO.getLLVMType(), 
@@ -514,7 +513,7 @@
  
   unsigned PrimaryEltNo = 0;
   std::pair<uint64_t, unsigned> PrimaryElt =
-    CGT.getContext().getTypeInfo(FieldDecls[0]->getType(), SourceLocation());
+    CGT.getContext().getTypeInfo(FieldDecls[0]->getType());
   CGT.addFieldInfo(FieldDecls[0], 0);
 
   unsigned Size = FieldDecls.size();
@@ -522,7 +521,7 @@
     const FieldDecl *FD = FieldDecls[i];
     assert (!FD->isBitField() && "Bit fields are not yet supported");
     std::pair<uint64_t, unsigned> EltInfo = 
-      CGT.getContext().getTypeInfo(FD->getType(), SourceLocation());
+      CGT.getContext().getTypeInfo(FD->getType());
 
     // Use largest element, breaking ties with the hightest aligned member.
     if (EltInfo.first > PrimaryElt.first ||
diff --git a/Driver/RewriteTest.cpp b/Driver/RewriteTest.cpp
index beabe92..097aa1b 100644
--- a/Driver/RewriteTest.cpp
+++ b/Driver/RewriteTest.cpp
@@ -2037,9 +2037,8 @@
     // FIXME: Value of 8 is base on ppc32/x86 ABI for the most common cases.
     // For X86 it is more complicated and some kind of target specific routine
     // is needed to decide what to do.
-    unsigned IntSize = static_cast<unsigned>(
-      Context->getTypeSize(Context->IntTy, SourceLocation()));
-
+    unsigned IntSize = 
+      static_cast<unsigned>(Context->getTypeSize(Context->IntTy));
     IntegerLiteral *limit = new IntegerLiteral(llvm::APInt(IntSize, 8), 
                                                Context->IntTy,
                                                SourceLocation());
diff --git a/Lex/LiteralSupport.cpp b/Lex/LiteralSupport.cpp
index 34ddfba..aa0b831 100644
--- a/Lex/LiteralSupport.cpp
+++ b/Lex/LiteralSupport.cpp
@@ -93,9 +93,7 @@
     }
 
     // See if any bits will be truncated when evaluated as a character.
-    unsigned CharWidth = IsWide 
-                       ? PP.getTargetInfo().getWCharWidth(PP.getFullLoc(Loc))
-                       : PP.getTargetInfo().getCharWidth(PP.getFullLoc(Loc));
+    unsigned CharWidth = PP.getTargetInfo().getCharWidth(IsWide);
                        
     if (CharWidth != 32 && (ResultChar >> CharWidth) != 0) {
       Overflow = true;
@@ -124,9 +122,7 @@
              ThisTokBuf[0] >= '0' && ThisTokBuf[0] <= '7');
     
     // Check for overflow.  Reject '\777', but not L'\777'.
-    unsigned CharWidth = IsWide
-                       ? PP.getTargetInfo().getWCharWidth(PP.getFullLoc(Loc))
-                       : PP.getTargetInfo().getCharWidth(PP.getFullLoc(Loc));
+    unsigned CharWidth = PP.getTargetInfo().getCharWidth(IsWide);
                        
     if (CharWidth != 32 && (ResultChar >> CharWidth) != 0) {
       PP.Diag(Loc, diag::warn_octal_escape_too_large);
@@ -457,13 +453,13 @@
 
   // FIXME: This assumes that 'int' is 32-bits in overflow calculation, and the
   // size of "value".
-  assert(PP.getTargetInfo().getIntWidth(PP.getFullLoc(Loc)) == 32 &&
+  assert(PP.getTargetInfo().getIntWidth() == 32 &&
          "Assumes sizeof(int) == 4 for now");
   // FIXME: This assumes that wchar_t is 32-bits for now.
-  assert(PP.getTargetInfo().getWCharWidth(PP.getFullLoc(Loc)) == 32 && 
+  assert(PP.getTargetInfo().getWCharWidth() == 32 && 
          "Assumes sizeof(wchar_t) == 4 for now");
   // FIXME: This extensively assumes that 'char' is 8-bits.
-  assert(PP.getTargetInfo().getCharWidth(PP.getFullLoc(Loc)) == 8 &&
+  assert(PP.getTargetInfo().getCharWidth() == 8 &&
          "Assumes char is 8 bits");
   
   bool isFirstChar = true;
@@ -509,7 +505,7 @@
   // character constants are not sign extended in the this implementation:
   // '\xFF\xFF' = 65536 and '\x0\xFF' = 255, which matches GCC.
   if (!IsWide && !isMultiChar && (Value & 128) &&
-      PP.getTargetInfo().isCharSigned(PP.getFullLoc(Loc)))
+      PP.getTargetInfo().isCharSigned())
     Value = (signed char)Value;
 }
 
@@ -587,9 +583,7 @@
   // query the target.  As such, wchar_tByteWidth is only valid if AnyWide=true.
   wchar_tByteWidth = ~0U;
   if (AnyWide) {
-    wchar_tByteWidth = 
-      Target.getWCharWidth(PP.getFullLoc(StringToks[0].getLocation()));
-      
+    wchar_tByteWidth = Target.getWCharWidth();
     assert((wchar_tByteWidth & 7) == 0 && "Assumes wchar_t is byte multiple!");
     wchar_tByteWidth /= 8;
   }
diff --git a/Lex/PPExpressions.cpp b/Lex/PPExpressions.cpp
index c56692e..cca7628 100644
--- a/Lex/PPExpressions.cpp
+++ b/Lex/PPExpressions.cpp
@@ -195,25 +195,17 @@
 
     // Character literals are always int or wchar_t, expand to intmax_t.
     TargetInfo &TI = PP.getTargetInfo();
-    unsigned NumBits;
-    if (Literal.isWide())
-      NumBits = TI.getWCharWidth(PP.getFullLoc(PeekTok.getLocation()));
-    else
-      NumBits = TI.getCharWidth(PP.getFullLoc(PeekTok.getLocation()));
+    unsigned NumBits = TI.getCharWidth(Literal.isWide());
     
     // Set the width.
     llvm::APSInt Val(NumBits);
     // Set the value.
     Val = Literal.getValue();
     // Set the signedness.
-    Val.setIsUnsigned(!TI.isCharSigned(PP.getFullLoc(PeekTok.getLocation())));
+    Val.setIsUnsigned(!TI.isCharSigned());
     
     if (Result.getBitWidth() > Val.getBitWidth()) {
-      if (Val.isSigned())
-        Result = Val.sext(Result.getBitWidth());
-      else
-        Result = Val.zext(Result.getBitWidth());
-      Result.setIsUnsigned(Val.isUnsigned());
+      Result = Val.extend(Result.getBitWidth());
     } else {
       assert(Result.getBitWidth() == Val.getBitWidth() &&
              "intmax_t smaller than char/wchar_t?");
@@ -603,8 +595,7 @@
   Lex(Tok);
   
   // C99 6.10.1p3 - All expressions are evaluated as intmax_t or uintmax_t.
-  unsigned BitWidth = 
-    getTargetInfo().getIntMaxTWidth(getFullLoc(Tok.getLocation()));
+  unsigned BitWidth = getTargetInfo().getIntMaxTWidth();
     
   llvm::APSInt ResVal(BitWidth);
   DefinedTracker DT;
diff --git a/Sema/SemaDecl.cpp b/Sema/SemaDecl.cpp
index b45317a..bb26ce7 100644
--- a/Sema/SemaDecl.cpp
+++ b/Sema/SemaDecl.cpp
@@ -1561,8 +1561,7 @@
     } else {
       // First value, set to zero.
       EltTy = Context.IntTy;
-      EnumVal.zextOrTrunc(
-        static_cast<uint32_t>(Context.getTypeSize(EltTy, IdLoc)));
+      EnumVal.zextOrTrunc(static_cast<uint32_t>(Context.getTypeSize(EltTy)));
     }
   }
   
@@ -1584,9 +1583,7 @@
   // TODO: If the result value doesn't fit in an int, it must be a long or long
   // long value.  ISO C does not support this, but GCC does as an extension,
   // emit a warning.
-  unsigned IntWidth =
-    Context.Target.getIntWidth(Context.getFullLoc(Enum->getLocation()));
-  
+  unsigned IntWidth = Context.Target.getIntWidth();
   
   // Verify that all the values are okay, compute the size of the values, and
   // reverse the list.
@@ -1643,14 +1640,12 @@
       BestType = Context.IntTy;
       BestWidth = IntWidth;
     } else {
-      BestWidth = 
-        Context.Target.getLongWidth(Context.getFullLoc(Enum->getLocation()));
+      BestWidth = Context.Target.getLongWidth();
       
       if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth)
         BestType = Context.LongTy;
       else {
-        BestWidth = Context.Target.getLongLongWidth(
-                       Context.getFullLoc(Enum->getLocation()));
+        BestWidth = Context.Target.getLongLongWidth();
         
         if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
           Diag(Enum->getLocation(), diag::warn_enum_too_large);
@@ -1664,14 +1659,10 @@
       BestType = Context.UnsignedIntTy;
       BestWidth = IntWidth;
     } else if (NumPositiveBits <=
-               (BestWidth = Context.Target.getLongWidth(
-                              Context.getFullLoc(Enum->getLocation()))))
-
+               (BestWidth = Context.Target.getLongWidth())) {
       BestType = Context.UnsignedLongTy;
-    else {
-      BestWidth =
-       Context.Target.getLongLongWidth(Context.getFullLoc(Enum->getLocation()));
-      
+    } else {
+      BestWidth = Context.Target.getLongLongWidth();
       assert(NumPositiveBits <= BestWidth &&
              "How could an initializer get larger than ULL?");
       BestType = Context.UnsignedLongLongTy;
@@ -1936,8 +1927,7 @@
          curType.getCanonicalType().getAsString());
     return QualType();
   }
-  unsigned typeSize = static_cast<unsigned>(
-    Context.getTypeSize(curType, rawAttr->getLoc()));
+  unsigned typeSize = static_cast<unsigned>(Context.getTypeSize(curType));
   // vecSize is specified in bytes - convert to bits.
   unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue() * 8); 
   
@@ -1970,7 +1960,7 @@
   else if (FieldDecl *FD = dyn_cast<FieldDecl>(d)) {
     // If the alignment is less than or equal to 8 bits, the packed attribute
     // has no effect.
-    if (Context.getTypeAlign(FD->getType(), SourceLocation()) <= 8)
+    if (Context.getTypeAlign(FD->getType()) <= 8)
       Diag(rawAttr->getLoc(), 
            diag::warn_attribute_ignored_for_field_of_type,
            rawAttr->getName()->getName(), FD->getType().getAsString());
diff --git a/Sema/SemaExpr.cpp b/Sema/SemaExpr.cpp
index 72bedab..f1b6ea2 100644
--- a/Sema/SemaExpr.cpp
+++ b/Sema/SemaExpr.cpp
@@ -169,8 +169,7 @@
   if (Tok.getLength() == 1) {
     const char *t = PP.getSourceManager().getCharacterData(Tok.getLocation());
     
-    unsigned IntSize = static_cast<unsigned>(
-      Context.getTypeSize(Context.IntTy, Tok.getLocation()));
+    unsigned IntSize =static_cast<unsigned>(Context.getTypeSize(Context.IntTy));
     return ExprResult(new IntegerLiteral(llvm::APInt(IntSize, *t-'0'),
                                          Context.IntTy, 
                                          Tok.getLocation()));
@@ -195,17 +194,13 @@
 
     if (Literal.isFloat) {
       Ty = Context.FloatTy;
-      Context.Target.getFloatInfo(Size, Align, Format,
-                                  Context.getFullLoc(Tok.getLocation()));
-      
+      Context.Target.getFloatInfo(Size, Align, Format);
     } else if (Literal.isLong) {
       Ty = Context.LongDoubleTy;
-      Context.Target.getLongDoubleInfo(Size, Align, Format,
-                                       Context.getFullLoc(Tok.getLocation()));
+      Context.Target.getLongDoubleInfo(Size, Align, Format);
     } else {
       Ty = Context.DoubleTy;
-      Context.Target.getDoubleInfo(Size, Align, Format,
-                                   Context.getFullLoc(Tok.getLocation()));
+      Context.Target.getDoubleInfo(Size, Align, Format);
     }
     
     // isExact will be set by GetFloatValue().
@@ -225,15 +220,14 @@
       Diag(Tok.getLocation(), diag::ext_longlong);
 
     // Get the value in the widest-possible width.
-    llvm::APInt ResultVal(Context.Target.getIntMaxTWidth(
-                            Context.getFullLoc(Tok.getLocation())), 0);
+    llvm::APInt ResultVal(Context.Target.getIntMaxTWidth(), 0);
    
     if (Literal.GetIntegerValue(ResultVal)) {
       // If this value didn't fit into uintmax_t, warn and force to ull.
       Diag(Tok.getLocation(), diag::warn_integer_too_large);
       t = Context.UnsignedLongLongTy;
-      assert(Context.getTypeSize(t, Tok.getLocation()) == 
-             ResultVal.getBitWidth() && "long long is not intmax_t?");
+      assert(Context.getTypeSize(t) == ResultVal.getBitWidth() &&
+             "long long is not intmax_t?");
     } else {
       // If this value fits into a ULL, try to figure out what else it fits into
       // according to the rules of C99 6.4.4.1p5.
@@ -245,8 +239,8 @@
       // Check from smallest to largest, picking the smallest type we can.
       if (!Literal.isLong && !Literal.isLongLong) {
         // Are int/unsigned possibilities?
-        unsigned IntSize = static_cast<unsigned>(
-          Context.getTypeSize(Context.IntTy,Tok.getLocation()));
+        unsigned IntSize = 
+          static_cast<unsigned>(Context.getTypeSize(Context.IntTy));
         // Does it fit in a unsigned int?
         if (ResultVal.isIntN(IntSize)) {
           // Does it fit in a signed int?
@@ -262,8 +256,8 @@
       
       // Are long/unsigned long possibilities?
       if (t.isNull() && !Literal.isLongLong) {
-        unsigned LongSize = static_cast<unsigned>(
-          Context.getTypeSize(Context.LongTy, Tok.getLocation()));
+        unsigned LongSize =
+          static_cast<unsigned>(Context.getTypeSize(Context.LongTy));
      
         // Does it fit in a unsigned long?
         if (ResultVal.isIntN(LongSize)) {
@@ -279,8 +273,8 @@
       
       // Finally, check long long if needed.
       if (t.isNull()) {
-        unsigned LongLongSize = static_cast<unsigned>(
-          Context.getTypeSize(Context.LongLongTy, Tok.getLocation()));
+        unsigned LongLongSize =
+          static_cast<unsigned>(Context.getTypeSize(Context.LongLongTy));
         
         // Does it fit in a unsigned long long?
         if (ResultVal.isIntN(LongLongSize)) {
@@ -718,8 +712,7 @@
   assert(VectorTy->isVectorType() && "Not a vector type!");
   
   if (Ty->isVectorType() || Ty->isIntegerType()) {
-    if (Context.getTypeSize(VectorTy, SourceLocation()) !=
-        Context.getTypeSize(Ty, SourceLocation()))
+    if (Context.getTypeSize(VectorTy) != Context.getTypeSize(Ty))
       return Diag(R.getBegin(),
                   Ty->isVectorType() ? 
                   diag::err_invalid_conversion_between_vectors :
@@ -1210,8 +1203,7 @@
         lhsType->isVectorType() && rhsType->isVectorType()) {
       if ((lhsType->isIntegerType() && rhsType->isIntegerType()) ||
           (lhsType->isRealFloatingType() && rhsType->isRealFloatingType())) {
-        if (Context.getTypeSize(lhsType, SourceLocation()) == 
-            Context.getTypeSize(rhsType, SourceLocation()))
+        if (Context.getTypeSize(lhsType) == Context.getTypeSize(rhsType))
           return Compatible;
       }
     }
diff --git a/Sema/SemaStmt.cpp b/Sema/SemaStmt.cpp
index 1c84771..fe62c8a 100644
--- a/Sema/SemaStmt.cpp
+++ b/Sema/SemaStmt.cpp
@@ -307,8 +307,7 @@
   
   // Get the bitwidth of the switched-on value before promotions.  We must
   // convert the integer case values to this width before comparison.
-  unsigned CondWidth = 
-    static_cast<unsigned>(Context.getTypeSize(CondType, SwitchLoc));
+  unsigned CondWidth = static_cast<unsigned>(Context.getTypeSize(CondType));
   bool CondIsSigned = CondType->isSignedIntegerType();
   
   // Accumulate all of the case values in a vector so that we can sort them
diff --git a/include/clang/AST/ASTContext.h b/include/clang/AST/ASTContext.h
index d986b7e..66ac9fd 100644
--- a/include/clang/AST/ASTContext.h
+++ b/include/clang/AST/ASTContext.h
@@ -261,24 +261,24 @@
   
   /// getTypeInfo - Get the size and alignment of the specified complete type in
   /// bits.
-  std::pair<uint64_t, unsigned> getTypeInfo(QualType T, SourceLocation L);
+  std::pair<uint64_t, unsigned> getTypeInfo(QualType T);
   
   /// getTypeSize - Return the size of the specified type, in bits.  This method
   /// does not work on incomplete types.
-  uint64_t getTypeSize(QualType T, SourceLocation L) {
-    return getTypeInfo(T, L).first;
+  uint64_t getTypeSize(QualType T) {
+    return getTypeInfo(T).first;
   }
   
   /// getTypeAlign - Return the alignment of the specified type, in bits.  This
   /// method does not work on incomplete types.
-  unsigned getTypeAlign(QualType T, SourceLocation L) {
-    return getTypeInfo(T, L).second;
+  unsigned getTypeAlign(QualType T) {
+    return getTypeInfo(T).second;
   }
   
   /// getASTRecordLayout - Get or compute information about the layout of the
   /// specified record (struct/union/class), which indicates its size and field
   /// position information.
-  const ASTRecordLayout &getASTRecordLayout(const RecordDecl *D, SourceLocation L);
+  const ASTRecordLayout &getASTRecordLayout(const RecordDecl *D);
   
   //===--------------------------------------------------------------------===//
   //                            Type Operators
diff --git a/include/clang/Analysis/PathSensitive/GRExprEngine.h b/include/clang/Analysis/PathSensitive/GRExprEngine.h
index c753249..6a7d243 100644
--- a/include/clang/Analysis/PathSensitive/GRExprEngine.h
+++ b/include/clang/Analysis/PathSensitive/GRExprEngine.h
@@ -286,7 +286,7 @@
   }
   
   inline NonLVal MakeConstantVal(uint64_t X, Expr* Ex) {
-    return NonLVal::MakeVal(ValMgr, X, Ex->getType(), Ex->getLocStart());
+    return NonLVal::MakeVal(ValMgr, X, Ex->getType());
   }
   
   /// Assume - Create new state by assuming that a given expression
diff --git a/include/clang/Analysis/PathSensitive/RValues.h b/include/clang/Analysis/PathSensitive/RValues.h
index e2d07c0..124d141 100644
--- a/include/clang/Analysis/PathSensitive/RValues.h
+++ b/include/clang/Analysis/PathSensitive/RValues.h
@@ -123,8 +123,7 @@
   void print(std::ostream& Out) const;
   
   // Utility methods to create NonLVals.
-  static NonLVal MakeVal(ValueManager& ValMgr, uint64_t X, QualType T,
-                         SourceLocation Loc = SourceLocation());
+  static NonLVal MakeVal(ValueManager& ValMgr, uint64_t X, QualType T);
   
   static NonLVal MakeVal(ValueManager& ValMgr, IntegerLiteral* I);
   
diff --git a/include/clang/Analysis/PathSensitive/ValueManager.h b/include/clang/Analysis/PathSensitive/ValueManager.h
index 0b463fb..fb5cd41 100644
--- a/include/clang/Analysis/PathSensitive/ValueManager.h
+++ b/include/clang/Analysis/PathSensitive/ValueManager.h
@@ -49,17 +49,14 @@
 
   const llvm::APSInt& getValue(const llvm::APSInt& X);
   const llvm::APSInt& getValue(uint64_t X, unsigned BitWidth, bool isUnsigned);
-  const llvm::APSInt& getValue(uint64_t X, QualType T,
-                               SourceLocation Loc = SourceLocation());
+  const llvm::APSInt& getValue(uint64_t X, QualType T);
 
   inline const llvm::APSInt& getZeroWithPtrWidth() {
-    return getValue(0, Ctx.getTypeSize(Ctx.VoidPtrTy, SourceLocation()), true);
+    return getValue(0, Ctx.getTypeSize(Ctx.VoidPtrTy), true);
   }
 
   inline const llvm::APSInt& getTruthValue(bool b) {
-    return getValue(b ? 1 : 0,
-                    Ctx.getTypeSize(Ctx.IntTy, SourceLocation()),
-                    false);
+    return getValue(b ? 1 : 0, Ctx.getTypeSize(Ctx.IntTy), false);
   }
 
   const SymIntConstraint& getConstraint(SymbolID sym, BinaryOperator::Opcode Op,
diff --git a/include/clang/Basic/TargetInfo.h b/include/clang/Basic/TargetInfo.h
index 16c959c..2febe6e 100644
--- a/include/clang/Basic/TargetInfo.h
+++ b/include/clang/Basic/TargetInfo.h
@@ -14,7 +14,6 @@
 #ifndef LLVM_CLANG_BASIC_TARGETINFO_H
 #define LLVM_CLANG_BASIC_TARGETINFO_H
 
-#include "clang/Basic/SourceLocation.h"
 #include "llvm/Support/DataTypes.h"
 #include <vector>
 #include <string>
@@ -66,79 +65,77 @@
   /// isCharSigned - Return true if 'char' is 'signed char' or false if it is
   /// treated as 'unsigned char'.  This is implementation defined according to
   /// C99 6.2.5p15.  In our implementation, this is target-specific.
-  bool isCharSigned(FullSourceLoc Loc) {
+  bool isCharSigned() {
     // FIXME: implement correctly.
     return true;
   }
   
   /// getPointerWidth - Return the width of pointers on this target, we
   /// currently assume one pointer type.
-  void getPointerInfo(uint64_t &Size, unsigned &Align, FullSourceLoc Loc) {
+  void getPointerInfo(uint64_t &Size, unsigned &Align) {
     Size = 32;  // FIXME: implement correctly.
     Align = 32;
   }
   
   /// getBoolInfo - Return the size of '_Bool' and C++ 'bool' for this target,
   /// in bits.  
-  void getBoolInfo(uint64_t &Size, unsigned &Align, FullSourceLoc Loc) {
+  void getBoolInfo(uint64_t &Size, unsigned &Align) {
     Size = Align = 8;    // FIXME: implement correctly: wrong for ppc32.
   }
   
   /// getCharInfo - Return the size of 'char', 'signed char' and
   /// 'unsigned char' for this target, in bits.  
-  void getCharInfo(uint64_t &Size, unsigned &Align, FullSourceLoc Loc) {
+  void getCharInfo(uint64_t &Size, unsigned &Align) {
     Size = Align = 8; // FIXME: implement correctly.
   }
   
   /// getShortInfo - Return the size of 'signed short' and 'unsigned short' for
   /// this target, in bits.  
-  void getShortInfo(uint64_t &Size, unsigned &Align, FullSourceLoc Loc) {
+  void getShortInfo(uint64_t &Size, unsigned &Align) {
     Size = Align = 16; // FIXME: implement correctly.
   }
   
   /// getIntInfo - Return the size of 'signed int' and 'unsigned int' for this
   /// target, in bits.  
-  void getIntInfo(uint64_t &Size, unsigned &Align, FullSourceLoc Loc) {
+  void getIntInfo(uint64_t &Size, unsigned &Align) {
     Size = Align = 32; // FIXME: implement correctly.
   }
   
   /// getLongInfo - Return the size of 'signed long' and 'unsigned long' for
   /// this target, in bits.  
-  void getLongInfo(uint64_t &Size, unsigned &Align, FullSourceLoc Loc) {
+  void getLongInfo(uint64_t &Size, unsigned &Align) {
     Size = Align = 32;  // FIXME: implement correctly: wrong for ppc64/x86-64
   }
 
   /// getLongLongInfo - Return the size of 'signed long long' and
   /// 'unsigned long long' for this target, in bits.  
-  void getLongLongInfo(uint64_t &Size, unsigned &Align, 
-                            FullSourceLoc Loc) {
+  void getLongLongInfo(uint64_t &Size, unsigned &Align) {
     Size = Align = 64; // FIXME: implement correctly.
   }
   
   /// getFloatInfo - Characterize 'float' for this target.  
   void getFloatInfo(uint64_t &Size, unsigned &Align,
-                    const llvm::fltSemantics *&Format, FullSourceLoc Loc);
+                    const llvm::fltSemantics *&Format);
 
   /// getDoubleInfo - Characterize 'double' for this target.
   void getDoubleInfo(uint64_t &Size, unsigned &Align,
-                     const llvm::fltSemantics *&Format,  FullSourceLoc Loc);
+                     const llvm::fltSemantics *&Format);
 
   /// getLongDoubleInfo - Characterize 'long double' for this target.
   void getLongDoubleInfo(uint64_t &Size, unsigned &Align,
-                         const llvm::fltSemantics *&Format, FullSourceLoc Loc);
+                         const llvm::fltSemantics *&Format);
   
   /// getWCharInfo - Return the size of wchar_t in bits.
   ///
-  void getWCharInfo(uint64_t &Size, unsigned &Align,
-                    FullSourceLoc Loc) {
-    if (!WCharWidth) ComputeWCharInfo(Loc);
+  void getWCharInfo(uint64_t &Size, unsigned &Align) {
+    if (!WCharWidth) ComputeWCharInfo();
     Size = WCharWidth;
     Align = WCharAlign;
   }
   
   /// getIntMaxTWidth - Return the size of intmax_t and uintmax_t for this
   /// target, in bits.  
-  unsigned getIntMaxTWidth(FullSourceLoc Loc) {
+  unsigned getIntMaxTWidth() {
     // FIXME: implement correctly.
     return 64;
   }
@@ -183,39 +180,42 @@
   
   ///===---- Some helper methods ------------------------------------------===//
 
-  unsigned getBoolWidth(FullSourceLoc Loc) {
+  unsigned getBoolWidth() {
     uint64_t Size; unsigned Align;
-    getBoolInfo(Size, Align, Loc);
+    getBoolInfo(Size, Align);
     return static_cast<unsigned>(Size);
   }
   
-  unsigned getCharWidth(FullSourceLoc Loc) {
+  unsigned getCharWidth(bool isWide = false) {
     uint64_t Size; unsigned Align;
-    getCharInfo(Size, Align, Loc);
+    if (isWide)
+      getWCharInfo(Size, Align);
+    else
+      getCharInfo(Size, Align);
     return static_cast<unsigned>(Size);
   }
   
-  unsigned getWCharWidth(FullSourceLoc Loc) {
+  unsigned getWCharWidth() {
     uint64_t Size; unsigned Align;
-    getWCharInfo(Size, Align, Loc);
+    getWCharInfo(Size, Align);
     return static_cast<unsigned>(Size);
   }
   
-  unsigned getIntWidth(FullSourceLoc Loc) {
+  unsigned getIntWidth() {
     uint64_t Size; unsigned Align;
-    getIntInfo(Size, Align, Loc);
+    getIntInfo(Size, Align);
     return static_cast<unsigned>(Size);
   }
   
-  unsigned getLongWidth(FullSourceLoc Loc) {
+  unsigned getLongWidth() {
     uint64_t Size; unsigned Align;
-    getLongInfo(Size, Align, Loc);
+    getLongInfo(Size, Align);
     return static_cast<unsigned>(Size);
   }
 
-  unsigned getLongLongWidth(FullSourceLoc Loc) {
+  unsigned getLongLongWidth() {
     uint64_t Size; unsigned Align;
-    getLongLongInfo(Size, Align, Loc);
+    getLongLongInfo(Size, Align);
     return static_cast<unsigned>(Size);
   }
 
@@ -233,7 +233,7 @@
 32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128";
   }
 private:
-  void ComputeWCharInfo(FullSourceLoc Loc);
+  void ComputeWCharInfo();
 };