Several performance-oriented changes to the introspecting data formatters:

 (a) the SystemParameters object is now passed around to the formatters; doing so enables the formatters to reuse computed values for things such as pointer-size and endianness
     instead of repeatedly computing these on their own
 (b) replacing the global ISA cache with a per-process one
 (c) providing a per-process types cache where each formatter can store the types it needs to operate, and be sure to find them the next time without recalculating them
     this also enables formatters to share types if they agree on a local naming convention
 (d) lazy fetching of data from Objective-C runtime data structures
     data is fetched as needed and we stop reading as soon as we determine that an ISA is actually garbage

llvm-svn: 152052

19 files changed, 594 insertions, 750 deletions

diff --git a/lldb/examples/summaries/cocoa/CFArray.py b/lldb/examples/summaries/cocoa/CFArray.py
index 4545a1b2370..0721e76b9f8 100644
--- a/lldb/examples/summaries/cocoa/CFArray.py
+++ b/lldb/examples/summaries/cocoa/CFArray.py
@@ -16,17 +16,14 @@ statistics.add_metric('code_notrun')
 class NSArrayKVC_SynthProvider:
 
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj, dict):
+	def __init__(self, valobj, dict, params):
 		self.valobj = valobj;
 		self.update()
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	def num_children(self):
 		stream = lldb.SBStream()
@@ -34,199 +31,78 @@ class NSArrayKVC_SynthProvider:
 		num_children_vo = self.valobj.CreateValueFromExpression("count","(int)[" + stream.GetData() + " count]");
 		return num_children_vo.GetValueAsUnsigned(0)
 
-	def get_child_index(self,name):
-		if name == "len":
-			return self.num_children();
-		else:
-			return None
-
-	def get_child_at_index(self, index):
-		return None
-
-
-
 # much less functional than the other two cases below
 # just runs code to get to the count and then returns
 # no children
 class NSArrayCF_SynthProvider:
 
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
-		self.cfruntime_size = self.size_of_cfruntime_base()
-
-	# CFRuntimeBase is defined as having an additional
-	# 4 bytes (padding?) on LP64 architectures
-	# to get its size we add up sizeof(pointer)+4
-	# and then add 4 more bytes if we are on a 64bit system
-	def size_of_cfruntime_base(self):
-		if self.is_64_bit == True:
-			return 8+4+4;
-		else:
-			return 4+4;
+		pass
 
-	def __init__(self, valobj, dict):
+	def __init__(self, valobj, dict, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not (self.sys_params.types_cache.ulong):
+			self.sys_params.types_cache.ulong = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
 		self.update()
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	def num_children(self):
 		num_children_vo = self.valobj.CreateChildAtOffset("count",
-							self.cfruntime_size,
-							self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong))
+							self.sys_params.cfruntime_size,
+							self.sys_params.types_cache.ulong)
 		return num_children_vo.GetValueAsUnsigned(0)
 
-	def get_child_index(self,name):
-		if name == "len":
-			return self.num_children();
-		else:
-			return None
-
-	def get_child_at_index(self, index):
-		return None
-
-
 class NSArrayI_SynthProvider:
-
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj, dict):
+	def __init__(self, valobj, dict, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not(self.sys_params.types_cache.long):
+			self.sys_params.types_cache.long = self.valobj.GetType().GetBasicType(lldb.eBasicTypeLong)
 		self.update()
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	# skip the isa pointer and get at the size
 	def num_children(self):
-		offset = self.pointer_size;
-		datatype = self.valobj.GetType().GetBasicType(lldb.eBasicTypeLong)
 		count = self.valobj.CreateChildAtOffset("count",
-				offset,
-				datatype);
-		return int(count.GetValue(), 0)
-
-	def get_child_index(self,name):
-		if name == "len":
-			return self.num_children();
-		else:
-			return int(name.lstrip('[').rstrip(']'), 0)
-
-	def get_child_at_index(self, index):
-		if index == self.num_children():
-			return self.valobj.CreateValueFromExpression("len",
-				str(index))
-		offset = 2 * self.pointer_size + self.id_type.GetByteSize()*index
-		return self.valobj.CreateChildAtOffset('[' + str(index) + ']',
-				offset,
-				self.id_type)
-
+				self.sys_params.pointer_size,
+				self.sys_params.types_cache.long);
+		return count.GetValueAsUnsigned(0)
 
 class NSArrayM_SynthProvider:
-
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj, dict):
+	def __init__(self, valobj, dict, params):
 		self.valobj = valobj;
-		self.update();
+		self.sys_params = params
+		if not(self.sys_params.types_cache.long):
+			self.sys_params.types_cache.long = self.valobj.GetType().GetBasicType(lldb.eBasicTypeLong)
+		self.update()
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	# skip the isa pointer and get at the size
 	def num_children(self):
-		offset = self.pointer_size;
-		datatype = self.valobj.GetType().GetBasicType(lldb.eBasicTypeLong)
 		count = self.valobj.CreateChildAtOffset("count",
-				offset,
-				datatype);
-		return int(count.GetValue(), 0)
-
-	def get_child_index(self,name):
-		if name == "len":
-			return self.num_children();
-		else:
-			return int(name.lstrip('[').rstrip(']'), 0)
-
-	def data_offset(self):
-		offset = self.pointer_size; # isa
-		offset += self.pointer_size; # _used
-		offset += self.pointer_size; # _doHardRetain, _doWeakAccess, _size
-		offset += self.pointer_size; # _hasObjects, _hasStrongReferences, _offset
-		offset += self.pointer_size; # _mutations
-		return offset;
-
-	# the _offset field is used to calculate the actual offset
-	# when reading a value out of the array. we need to read it
-	# to do so we read a whole pointer_size of data from the
-	# right spot, and then zero out the two LSB
-	def read_offset_field(self):
-		disp = self.pointer_size;  # isa
-		disp += self.pointer_size; # _used
-		disp += self.pointer_size; # _doHardRetain, _doWeakAccess, _size
-		offset = self.valobj.CreateChildAtOffset("offset",
-					disp,
-					self.valobj.GetType().GetBasicType(lldb.eBasicTypeLong))
-		offset_value = int(offset.GetValue(), 0)
-		offset_value = ctypes.c_uint32((offset_value & 0xFFFFFFFC) >> 2).value
-		return offset_value
-
-	# the _used field tells how many items are in the array
-	# but since this is a mutable array, it allocates more space
-	# for performance reasons. we need to get the real _size of
-	# the array to calculate the actual offset of each element
-	# in get_child_at_index() (see NSArray.m for details)
-	def read_size_field(self):
-		disp = self.pointer_size;  # isa
-		disp += self.pointer_size; # _used
-		size = self.valobj.CreateChildAtOffset("size",
-					disp,
-					self.valobj.GetType().GetBasicType(lldb.eBasicTypeLong))
-		size_value = int(size.GetValue(), 0)
-		size_value = ctypes.c_uint32((size_value & 0xFFFFFFFA) >> 2).value
-		return size_value
-
-	def get_child_at_index(self, index):
-		if index == self.num_children():
-			return self.valobj.CreateValueFromExpression("len",
-				str(index))
-		size = self.read_size_field()
-		offset = self.read_offset_field()
-		phys_idx = offset + index
-		if size <= phys_idx:
-			phys_idx -=size;
-		# we still need to multiply by element size to do a correct pointer read
-		phys_idx *= self.id_type.GetByteSize()
-		list_ptr = self.valobj.CreateChildAtOffset("_list",
-            self.data_offset(),
-            self.id_type.GetBasicType(lldb.eBasicTypeUnsignedLongLong))
-		list_addr = int(list_ptr.GetValue(), 0)
-		return self.valobj.CreateValueFromAddress('[' + str(index) + ']',
-				list_addr + phys_idx,
-				self.id_type)
+				self.sys_params.pointer_size,
+				self.sys_params.types_cache.long);
+		return count.GetValueAsUnsigned(0)
 
 # this is the actual synth provider, but is just a wrapper that checks
 # whether valobj is an instance of __NSArrayI or __NSArrayM and sets up an
 # appropriate backend layer to do the computations 
 class NSArray_SynthProvider:
-
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
+		pass
 
 	def __init__(self, valobj, dict):
 		self.valobj = valobj;
@@ -234,16 +110,6 @@ class NSArray_SynthProvider:
 		self.wrapper = self.make_wrapper(valobj,dict)
 		self.invalid = (self.wrapper == None)
 
-	def get_child_at_index(self, index):
-		if self.wrapper == None:
-			return None;
-		return self.wrapper.get_child_at_index(index)
-
-	def get_child_index(self,name):
-		if self.wrapper == None:
-			return None;
-		return self.wrapper.get_child_index(name)
-
 	def num_children(self):
 		if self.wrapper == None:
 			return 0;
@@ -251,23 +117,8 @@ class NSArray_SynthProvider:
 
 	def update(self):
 		if self.wrapper == None:
-			return None;
-		return self.wrapper.update()
-
-	def read_ascii(self, pointer):
-		process = self.valobj.GetTarget().GetProcess()
-		error = lldb.SBError()
-		pystr = ''
-		# cannot do the read at once because there is no length byte
-		while True:
-			content = process.ReadMemory(pointer, 1, error)
-			new_bytes = bytearray(content)
-			b0 = new_bytes[0]
-			pointer = pointer + 1
-			if b0 == 0:
-				break
-			pystr = pystr + chr(b0)
-		return pystr
+			return
+		self.wrapper.update()
 
 	# this code acts as our defense against NULL and unitialized
 	# NSArray pointers, which makes it much longer than it would be otherwise
@@ -292,16 +143,16 @@ class NSArray_SynthProvider:
 		
 		name_string = class_data.class_name()
 		if name_string == '__NSArrayI':
-			wrapper = NSArrayI_SynthProvider(valobj, dict)
+			wrapper = NSArrayI_SynthProvider(valobj, dict, class_data.sys_params)
 			statistics.metric_hit('code_notrun',valobj)
 		elif name_string == '__NSArrayM':
-			wrapper = NSArrayM_SynthProvider(valobj, dict)
+			wrapper = NSArrayM_SynthProvider(valobj, dict, class_data.sys_params)
 			statistics.metric_hit('code_notrun',valobj)
 		elif name_string == '__NSCFArray':
-			wrapper = NSArrayCF_SynthProvider(valobj, dict)
+			wrapper = NSArrayCF_SynthProvider(valobj, dict, class_data.sys_params)
 			statistics.metric_hit('code_notrun',valobj)
 		else:
-			wrapper = NSArrayKVC_SynthProvider(valobj, dict)
+			wrapper = NSArrayKVC_SynthProvider(valobj, dict, class_data.sys_params)
 			statistics.metric_hit('unknown_class',str(valobj) + " seen as " + name_string)
 		return wrapper;
 
diff --git a/lldb/examples/summaries/cocoa/CFBag.py b/lldb/examples/summaries/cocoa/CFBag.py
index 1403a122eb6..2db70ab603c 100644
--- a/lldb/examples/summaries/cocoa/CFBag.py
+++ b/lldb/examples/summaries/cocoa/CFBag.py
@@ -15,27 +15,26 @@ statistics.add_metric('code_notrun')
 # obey the interface specification for synthetic children providers
 class CFBagRef_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not(self.sys_params.types_cache.NSUInteger):
+			if self.sys_params.is_64_bit:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
+			else:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		if self.is_64_bit:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-		else:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 
 	# 12 bytes on i386
 	# 20 bytes on x64
 	# most probably 2 pointers and 4 bytes of data
 	def offset(self):
-		if self.is_64_bit:
+		if self.sys_params.is_64_bit:
 			return 20
 		else:
 			return 12
@@ -43,23 +42,21 @@ class CFBagRef_SummaryProvider:
 	def length(self):
 		size = self.valobj.CreateChildAtOffset("count",
 							self.offset(),
-							self.NSUInteger)
+							self.sys_params.types_cache.NSUInteger)
 		return size.GetValueAsUnsigned(0)
 
 
 class CFBagUnknown_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
-		self.update()
+		self.sys_params = params
+		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	def length(self):
 		stream = lldb.SBStream()
@@ -98,10 +95,10 @@ def GetSummary_Impl(valobj):
 			actual_name = pointee_type.GetName()
 			if actual_name == '__CFBag' or \
 			   actual_name == 'const struct __CFBag':
-				wrapper = CFBagRef_SummaryProvider(valobj)
+				wrapper = CFBagRef_SummaryProvider(valobj, class_data.sys_params)
 				statistics.metric_hit('code_notrun',valobj)
 				return wrapper
-	wrapper = CFBagUnknown_SummaryProvider(valobj)
+	wrapper = CFBagUnknown_SummaryProvider(valobj, class_data.sys_params)
 	statistics.metric_hit('unknown_class',str(valobj) + " seen as " + actual_name)
 	return wrapper;
 
@@ -120,7 +117,7 @@ def CFBag_SummaryProvider (valobj,dict):
 		if summary == None:
 			summary = 'no valid set here'
 		else:
-			if provider.is_64_bit:
+			if provider.sys_params.is_64_bit:
 				summary = summary & ~0x1fff000000000000
 		if summary == 1:
 			return '1 item'
diff --git a/lldb/examples/summaries/cocoa/CFBinaryHeap.py b/lldb/examples/summaries/cocoa/CFBinaryHeap.py
index 0a120745c3c..160389eae4e 100644
--- a/lldb/examples/summaries/cocoa/CFBinaryHeap.py
+++ b/lldb/examples/summaries/cocoa/CFBinaryHeap.py
@@ -15,51 +15,45 @@ statistics.add_metric('code_notrun')
 # obey the interface specification for synthetic children providers
 class CFBinaryHeapRef_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not(self.sys_params.types_cache.NSUInteger):
+			if self.sys_params.is_64_bit:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
+			else:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		if self.is_64_bit:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-		else:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 
 	# 8 bytes on i386
 	# 16 bytes on x64
 	# most probably 2 pointers
 	def offset(self):
-		if self.is_64_bit:
-			return 16
-		else:
-			return 8
+		return 2 * self.sys_params.pointer_size
 
 	def length(self):
 		size = self.valobj.CreateChildAtOffset("count",
 							self.offset(),
-							self.NSUInteger)
+							self.sys_params.types_cache.NSUInteger)
 		return size.GetValueAsUnsigned(0)
 
 
 class CFBinaryHeapUnknown_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
-		self.update()
+		self.sys_params = params
+		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	def length(self):
 		stream = lldb.SBStream()
@@ -95,10 +89,10 @@ def GetSummary_Impl(valobj):
 		if valobj_type.IsValid() and valobj_type.IsPointerType():
 			pointee_type = valobj_type.GetPointeeType()
 			if pointee_type.GetName() == '__CFBinaryHeap':
-				wrapper = CFBinaryHeapRef_SummaryProvider(valobj)
+				wrapper = CFBinaryHeapRef_SummaryProvider(valobj, class_data.sys_params)
 				statistics.metric_hit('code_notrun',valobj)
 				return wrapper
-	wrapper = CFBinaryHeapUnknown_SummaryProvider(valobj)
+	wrapper = CFBinaryHeapUnknown_SummaryProvider(valobj, class_data.sys_params)
 	statistics.metric_hit('unknown_class',str(valobj) + " seen as " + name_string)
 	return wrapper;
 
@@ -117,7 +111,7 @@ def CFBinaryHeap_SummaryProvider (valobj,dict):
 		if summary == None:
 			summary = 'no valid set here'
 		else:
-			if provider.is_64_bit:
+			if provider.sys_params.is_64_bit:
 				summary = summary & ~0x1fff000000000000
 		if summary == 1:
 			return '1 item'
diff --git a/lldb/examples/summaries/cocoa/CFBitVector.py b/lldb/examples/summaries/cocoa/CFBitVector.py
index a469ed407f7..7cd83fe6cb4 100644
--- a/lldb/examples/summaries/cocoa/CFBitVector.py
+++ b/lldb/examples/summaries/cocoa/CFBitVector.py
@@ -30,25 +30,23 @@ statistics.add_metric('code_notrun')
 # obey the interface specification for synthetic children providers
 class CFBitVectorKnown_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = self.sys_params.is_64_bit
-		self.is_little = self.sys_params.is_little
-		self.pointer_size = self.sys_params.pointer_size
-		self.cfruntime_size = 16 if self.is_64_bit else 8
+		self.uiint_size = self.sys_params.types_cache.NSUInteger.GetByteSize()
+		pass
 
 	def __init__(self, valobj, params):
 		self.valobj = valobj;
 		self.sys_params = params
+		if not(self.sys_params.types_cache.NSUInteger):
+			if self.sys_params.is_64_bit:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
+			else:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
+		if not(self.sys_params.types_cache.charptr):
+			self.sys_params.types_cache.charptr = self.valobj.GetType().GetBasicType(lldb.eBasicTypeChar).GetPointerType()
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		if self.is_64_bit:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-		else:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
-		self.charptr_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeChar).GetPointerType()
-		self.uiint_size = self.NSUInteger.GetByteSize()
 
 	# we skip the CFRuntimeBase
 	# then the next CFIndex is the count
@@ -56,15 +54,15 @@ class CFBitVectorKnown_SummaryProvider:
 	# that wraps the individual bits
 
 	def contents(self):
-		count_vo = self.valobj.CreateChildAtOffset("count",self.cfruntime_size,
-													self.NSUInteger)
+		count_vo = self.valobj.CreateChildAtOffset("count",self.sys_params.cfruntime_size,
+													self.sys_params.types_cache.NSUInteger)
 		count = count_vo.GetValueAsUnsigned(0)
 		if count == 0:
 			return '(empty)'
 		
 		array_vo = self.valobj.CreateChildAtOffset("data",
-													self.cfruntime_size+2*self.uiint_size,
-													self.charptr_type)
+													self.sys_params.cfruntime_size+2*self.uiint_size,
+													self.sys_params.types_cache.charptr)
 		
 		data_list = []
 		cur_byte_pos = None
@@ -92,17 +90,15 @@ class CFBitVectorKnown_SummaryProvider:
 
 class CFBitVectorUnknown_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
-		self.update()
+		self.sys_params = params
+		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	def contents(self):
 		return '*** unknown class *** very bad thing *** find out my name ***'
@@ -141,7 +137,7 @@ def GetSummary_Impl(valobj):
 				wrapper = CFBitVectorUnknown_SummaryProvider(valobj)
 				print pointee_type.GetName()
 	else:
-		wrapper = CFBitVectorUnknown_SummaryProvider(valobj)
+		wrapper = CFBitVectorUnknown_SummaryProvider(valobj, class_data.sys_params)
 		print name_string
 		statistics.metric_hit('unknown_class',str(valobj) + " seen as " + name_string)
 	return wrapper;
diff --git a/lldb/examples/summaries/cocoa/CFDictionary.py b/lldb/examples/summaries/cocoa/CFDictionary.py
index 5bd9e690b36..e2f6bdd51e6 100644
--- a/lldb/examples/summaries/cocoa/CFDictionary.py
+++ b/lldb/examples/summaries/cocoa/CFDictionary.py
@@ -15,28 +15,27 @@ statistics.add_metric('code_notrun')
 # obey the interface specification for synthetic children providers
 class NSCFDictionary_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not(self.sys_params.types_cache.NSUInteger):
+			if self.sys_params.is_64_bit:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
+			else:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		if self.is_64_bit:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-		else:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 
 	# empirically determined on both 32 and 64bit desktop Mac OS X
 	# probably boils down to 2 pointers and 4 bytes of data, but
 	# the description of __CFDictionary is not readily available so most
 	# of this is guesswork, plain and simple
 	def offset(self):
-		if self.is_64_bit:
+		if self.sys_params.is_64_bit:
 			return 20
 		else:
 			return 12
@@ -44,45 +43,41 @@ class NSCFDictionary_SummaryProvider:
 	def num_children(self):
 		num_children_vo = self.valobj.CreateChildAtOffset("count",
 							self.offset(),
-							self.NSUInteger)
+							self.sys_params.types_cache.NSUInteger)
 		return num_children_vo.GetValueAsUnsigned(0)
 
 
 class NSDictionaryI_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not(self.sys_params.types_cache.NSUInteger):
+			if self.sys_params.is_64_bit:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
+			else:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		if self.is_64_bit:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-		else:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 
 	# we just need to skip the ISA and the count immediately follows
 	def offset(self):
-		if self.is_64_bit:
-			return 8
-		else:
-			return 4
+		return self.sys_params.pointer_size
 
 	def num_children(self):
 		num_children_vo = self.valobj.CreateChildAtOffset("count",
 							self.offset(),
-							self.NSUInteger)
+							self.sys_params.types_cache.NSUInteger)
 		value = num_children_vo.GetValueAsUnsigned(0)
 		if value != None:
 			# the MS6bits on immutable dictionaries seem to be taken by the LSB of capacity
 			# not sure if it is a bug or some weird sort of feature, but masking that out
 			# gets the count right
-			if self.is_64_bit:
+			if self.sys_params.is_64_bit:
 				value = value & ~0xFC00000000000000
 			else:
 				value = value & ~0xFC000000
@@ -90,58 +85,51 @@ class NSDictionaryI_SummaryProvider:
 
 class NSDictionaryM_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not(self.sys_params.types_cache.NSUInteger):
+			if self.sys_params.is_64_bit:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
+			else:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		if self.is_64_bit:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-		else:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 
 	# we just need to skip the ISA and the count immediately follows
 	def offset(self):
-		if self.is_64_bit:
-			return 8
-		else:
-			return 4
+		return self.sys_params.pointer_size
 
 	def num_children(self):
 		num_children_vo = self.valobj.CreateChildAtOffset("count",
 							self.offset(),
-							self.NSUInteger)
+							self.sys_params.types_cache.NSUInteger)
 		value = num_children_vo.GetValueAsUnsigned(0)
 		if value != None:
-			# the MS6bits on mutable dictionaries seem to be taken by flags for
-			# KVO and probably other features. however, masking it out does get
-			# the count right
-			if self.is_64_bit:
+			# the MS6bits on immutable dictionaries seem to be taken by the LSB of capacity
+			# not sure if it is a bug or some weird sort of feature, but masking that out
+			# gets the count right
+			if self.sys_params.is_64_bit:
 				value = value & ~0xFC00000000000000
 			else:
 				value = value & ~0xFC000000
 		return value
 
-
 class NSDictionaryUnknown_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
-		self.update()
+		self.sys_params = params
+		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	def num_children(self):
 		stream = lldb.SBStream()
@@ -171,16 +159,16 @@ def GetSummary_Impl(valobj):
 	
 	name_string = class_data.class_name()
 	if name_string == '__NSCFDictionary':
-		wrapper = NSCFDictionary_SummaryProvider(valobj)
+		wrapper = NSCFDictionary_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('code_notrun',valobj)
 	elif name_string == '__NSDictionaryI':
-		wrapper = NSDictionaryI_SummaryProvider(valobj)
+		wrapper = NSDictionaryI_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('code_notrun',valobj)
 	elif name_string == '__NSDictionaryM':
-		wrapper = NSDictionaryM_SummaryProvider(valobj)
+		wrapper = NSDictionaryM_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('code_notrun',valobj)
 	else:
-		wrapper = NSDictionaryUnknown_SummaryProvider(valobj)
+		wrapper = NSDictionaryUnknown_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('unknown_class',str(valobj) + " seen as " + name_string)
 	return wrapper;
 
@@ -200,14 +188,14 @@ def CFDictionary_SummaryProvider2 (valobj,dict):
 	provider = GetSummary_Impl(valobj);
 	if provider != None:
 		try:
-			summary = (provider.num_children());
+			summary = provider.num_children();
 		except:
 			summary = None
 		if summary == None:
 			summary = 'no valid dictionary here'
 		# needed on OSX Mountain Lion
-		elif provider.is_64_bit:
-			summary = int(summary) & ~0x0f1f000000000000
+		elif provider.sys_params.is_64_bit:
+			summary = summary & ~0x0f1f000000000000
 		return str(summary) + " key/value pairs"
 	return ''
 
diff --git a/lldb/examples/summaries/cocoa/CFString.py b/lldb/examples/summaries/cocoa/CFString.py
index c954ae4d0de..ad2a1e4d6ba 100644
--- a/lldb/examples/summaries/cocoa/CFString.py
+++ b/lldb/examples/summaries/cocoa/CFString.py
@@ -102,10 +102,7 @@ class CFStringSynthProvider:
 				return self.handle_unicode_string_safe();
 			else:
 				# a full pointer is skipped here before getting to the live data
-				if self.is_64_bit == False:
-					pointer = pointer + 4
-				else:
-					pointer = pointer + 8;
+				pointer = pointer + self.pointer_size
 		else:
 			pointer = self.valobj.GetValueAsUnsigned(0) + self.size_of_cfruntime_base();
 			# read 8 bytes here and make an address out of them
@@ -123,19 +120,13 @@ class CFStringSynthProvider:
 			"(char*)\"" + pystr.encode('utf-8') + "\"")
 
 	def handle_inline_explicit(self):
-		if self.is_64_bit:
-			offset = 24
-		else:
-			offset = 12
+		offset = 3*self.pointer_size
 		offset = offset + self.valobj.GetValueAsUnsigned(0)
 		return self.valobj.CreateValueFromExpression("content",
 				"(char*)(" + str(offset) + ")")
 
 	def handle_mutable_string(self):
-		if self.is_64_bit:
-			offset = 16
-		else:
-			offset = 8
+		offset = 2 * self.pointer_size
 		data = self.valobj.CreateChildAtOffset("content",
 			offset, self.valobj.GetType().GetBasicType(lldb.eBasicTypeChar).GetPointerType());
 		data_value = data.GetValueAsUnsigned(0)
@@ -208,21 +199,12 @@ class CFStringSynthProvider:
 		if name == "special":
 			return 4;
 
-	def is_64bit(self):
-		return self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8
-
-	def is_little_endian(self):
-		return self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle
-
 	# CFRuntimeBase is defined as having an additional
 	# 4 bytes (padding?) on LP64 architectures
 	# to get its size we add up sizeof(pointer)+4
 	# and then add 4 more bytes if we are on a 64bit system
 	def size_of_cfruntime_base(self):
-		if self.is_64_bit == True:
-			return 8+4+4;
-		else:
-			return 4+4;
+		return self.pointer_size+4+(4 if self.is_64_bit else 0)
 
 	# the info bits are part of the CFRuntimeBase structure
 	# to get at them we have to skip a uintptr_t and then get
@@ -230,10 +212,7 @@ class CFStringSynthProvider:
 	# on big-endian this means going to byte 3, if we are on
 	# little endian (OSX & iOS), this means reading byte 0
 	def offset_of_info_bits(self):
-		if self.is_64_bit == True:
-			offset = 8;
-		else:
-			offset = 4;
+		offset = self.pointer_size
 		if self.is_little == False:
 			offset = offset + 3;
 		return offset;
@@ -278,8 +257,9 @@ class CFStringSynthProvider:
 	# preparing ourselves to read into memory
 	# by adjusting architecture-specific info
 	def adjust_for_architecture(self):
-		self.is_64_bit = self.is_64bit();
-		self.is_little = self.is_little_endian();
+		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		self.is_64_bit = self.pointer_size == 8
+		self.is_little = self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle
 
 	# reading info bits out of the CFString and computing
 	# useful values to get at the real data
diff --git a/lldb/examples/summaries/cocoa/NSBundle.py b/lldb/examples/summaries/cocoa/NSBundle.py
index cb748f5217f..b38b027a35a 100644
--- a/lldb/examples/summaries/cocoa/NSBundle.py
+++ b/lldb/examples/summaries/cocoa/NSBundle.py
@@ -16,41 +16,33 @@ statistics.add_metric('code_notrun')
 # obey the interface specification for synthetic children providers
 class NSBundleKnown_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not(self.sys_params.types_cache.NSString):
+			self.sys_params.types_cache.NSString = self.valobj.GetTarget().FindFirstType('NSString').GetPointerType()
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		if self.is_64_bit:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-			self.pointer_size = 8
-		else:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
-			self.pointer_size = 4
-		self.NSString = self.valobj.GetTarget().FindFirstType('NSString')
-		self.NSURL = self.valobj.GetTarget().FindFirstType('NSURL')
 
 	# we need to skip the ISA, plus four other values
 	# that are luckily each a pointer in size
 	# which makes our computation trivial :-)
 	def offset(self):
-		return 5 * self.pointer_size
+		return 5 * self.sys_params.pointer_size
 
 	def url_text(self):
 		global statistics
 		text = self.valobj.CreateChildAtOffset("text",
 							self.offset(),
-							self.NSString.GetPointerType())
+							self.sys_params.types_cache.NSString)
 		my_string = text.GetSummary()
 		if (my_string == None) or (my_string == ''):
 			statistics.metric_hit('unknown_class',str(self.valobj) + " triggered unkown pointer location")
-			return NSBundleUnknown_SummaryProvider(self.valobj).url_text()
+			return NSBundleUnknown_SummaryProvider(self.valobj, self.sys_params).url_text()
 		else:
 			statistics.metric_hit('code_notrun',self.valobj)
 			return my_string
@@ -58,17 +50,15 @@ class NSBundleKnown_SummaryProvider:
 
 class NSBundleUnknown_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
 		self.update()
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	def url_text(self):
 		stream = lldb.SBStream()
@@ -99,13 +89,13 @@ def GetSummary_Impl(valobj):
 	
 	name_string = class_data.class_name()
 	if name_string == 'NSBundle':
-		wrapper = NSBundleKnown_SummaryProvider(valobj)
+		wrapper = NSBundleKnown_SummaryProvider(valobj, class_data.sys_params)
 		# [NSBundle mainBundle] does return an object that is
 		# not correctly filled out for our purposes, so we still
 		# end up having to run code in that case
 		#statistics.metric_hit('code_notrun',valobj)
 	else:
-		wrapper = NSBundleUnknown_SummaryProvider(valobj)
+		wrapper = NSBundleUnknown_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('unknown_class',str(valobj) + " seen as " + name_string)
 	return wrapper;
 
diff --git a/lldb/examples/summaries/cocoa/NSData.py b/lldb/examples/summaries/cocoa/NSData.py
index 9acb2fefb32..8407a33f59e 100644
--- a/lldb/examples/summaries/cocoa/NSData.py
+++ b/lldb/examples/summaries/cocoa/NSData.py
@@ -15,21 +15,20 @@ statistics.add_metric('code_notrun')
 # obey the interface specification for synthetic children providers
 class NSConcreteData_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not(self.sys_params.types_cache.NSUInteger):
+			if self.sys_params.is_64_bit:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
+			else:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		if self.is_64_bit:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-		else:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 
 	# one pointer is the ISA
 	# then there are 32 bit worth of flags and other data
@@ -37,31 +36,26 @@ class NSConcreteData_SummaryProvider:
 	# machine word long, which means we actually have two pointers
 	# worth of data to skip
 	def offset(self):
-		if self.is_64_bit:
-			return 16
-		else:
-			return 8
+		return 2 * self.sys_params.pointer_size
 
 	def length(self):
 		size = self.valobj.CreateChildAtOffset("count",
 							self.offset(),
-							self.NSUInteger)
+							self.sys_params.types_cache.NSUInteger)
 		return size.GetValueAsUnsigned(0)
 
 
 class NSDataUnknown_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
-		self.update()
+		self.sys_params = params
+		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	def length(self):
 		stream = lldb.SBStream()
@@ -93,10 +87,10 @@ def GetSummary_Impl(valobj):
 	if name_string == 'NSConcreteData' or \
 	   name_string == 'NSConcreteMutableData' or \
 	   name_string == '__NSCFData':
-		wrapper = NSConcreteData_SummaryProvider(valobj)
+		wrapper = NSConcreteData_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('code_notrun',valobj)
 	else:
-		wrapper = NSDataUnknown_SummaryProvider(valobj)
+		wrapper = NSDataUnknown_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('unknown_class',str(valobj) + " seen as " + name_string)
 	return wrapper;
 
diff --git a/lldb/examples/summaries/cocoa/NSDate.py b/lldb/examples/summaries/cocoa/NSDate.py
index 800cf3200e2..3f0273fe16e 100644
--- a/lldb/examples/summaries/cocoa/NSDate.py
+++ b/lldb/examples/summaries/cocoa/NSDate.py
@@ -37,12 +37,11 @@ def osx_to_python_time(osx):
 # obey the interface specification for synthetic children providers
 class NSTaggedDate_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj, info_bits, data):
+	def __init__(self, valobj, info_bits, data, params):
 		self.valobj = valobj;
+		self.sys_params = params
 		self.update();
 		# NSDate is not using its info_bits for info like NSNumber is
 		# so we need to regroup info_bits and data
@@ -50,18 +49,6 @@ class NSTaggedDate_SummaryProvider:
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-
-		self.char = self.valobj.GetType().GetBasicType(lldb.eBasicTypeChar)
-		self.short = self.valobj.GetType().GetBasicType(lldb.eBasicTypeShort)
-		self.ushort = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedShort)
-		self.int = self.valobj.GetType().GetBasicType(lldb.eBasicTypeInt)
-		self.long = self.valobj.GetType().GetBasicType(lldb.eBasicTypeLong)
-		self.ulong = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-		self.longlong = self.valobj.GetType().GetBasicType(lldb.eBasicTypeLongLong)
-		self.ulonglong = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLongLong)
-		self.float = self.valobj.GetType().GetBasicType(lldb.eBasicTypeFloat)
-		self.double = self.valobj.GetType().GetBasicType(lldb.eBasicTypeDouble)
 
 	def value(self):
 		# the value of the date-time object is wrapped into the pointer value
@@ -74,96 +61,78 @@ class NSTaggedDate_SummaryProvider:
 
 class NSUntaggedDate_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not (self.sys_params.types_cache.double):
+			self.sys_params.types_cache.double = self.valobj.GetType().GetBasicType(lldb.eBasicTypeDouble)
 		self.update()
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-		self.double = self.valobj.GetType().GetBasicType(lldb.eBasicTypeDouble)
 
 	def offset(self):
-		if self.is_64_bit:
-			return 8
-		else:
-			return 4
-
+		return self.sys_params.pointer_size
 
 	def value(self):
 		value = self.valobj.CreateChildAtOffset("value",
 							self.offset(),
-							self.double)
+							self.sys_params.types_cache.double)
 		value_double = struct.unpack('d', struct.pack('Q', value.GetValueAsUnsigned(0)))[0]
 		return time.ctime(osx_to_python_time(value_double))
 
 class NSCalendarDate_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not (self.sys_params.types_cache.double):
+			self.sys_params.types_cache.double = self.valobj.GetType().GetBasicType(lldb.eBasicTypeDouble)
 		self.update()
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-		self.double = self.valobj.GetType().GetBasicType(lldb.eBasicTypeDouble)
 
 	def offset(self):
-		if self.is_64_bit:
-			return 16
-		else:
-			return 8
-
+		return 2*self.sys_params.pointer_size
 
 	def value(self):
 		value = self.valobj.CreateChildAtOffset("value",
 							self.offset(),
-							self.double)
+							self.sys_params.types_cache.double)
 		value_double = struct.unpack('d', struct.pack('Q', value.GetValueAsUnsigned(0)))[0]
 		return time.ctime(osx_to_python_time(value_double))
 
 class NSTimeZoneClass_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not (self.sys_params.types_cache.voidptr):
+			self.sys_params.types_cache.voidptr = self.valobj.GetType().GetBasicType(lldb.eBasicTypeVoid).GetPointerType()
 		self.update()
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		self.voidptr_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeVoid).GetPointerType()
 
 	def offset(self):
-		if self.is_64_bit:
-			return 8
-		else:
-			return 4
+		return self.sys_params.pointer_size
 
 	def timezone(self):
 		tz_string = self.valobj.CreateChildAtOffset("tz_name",
 							self.offset(),
-							self.voidptr_type)
+							self.sys_params.types_cache.voidptr)
 		return CFString.CFString_SummaryProvider(tz_string,None)
 
 class NSUnknownDate_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
 	def __init__(self, valobj):
 		self.valobj = valobj;
@@ -171,7 +140,6 @@ class NSUnknownDate_SummaryProvider:
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	def value(self):
 		stream = lldb.SBStream()
@@ -202,19 +170,19 @@ def GetSummary_Impl(valobj):
 	name_string = class_data.class_name()
 	if name_string == 'NSDate' or name_string == '__NSDate' or name_string == '__NSTaggedDate':
 		if class_data.is_tagged():
-			wrapper = NSTaggedDate_SummaryProvider(valobj,class_data.info_bits(),class_data.value())
+			wrapper = NSTaggedDate_SummaryProvider(valobj,class_data.info_bits(),class_data.value(), class_data.sys_params)
 			statistics.metric_hit('code_notrun',valobj)
 		else:
-			wrapper = NSUntaggedDate_SummaryProvider(valobj)
+			wrapper = NSUntaggedDate_SummaryProvider(valobj, class_data.sys_params)
 			statistics.metric_hit('code_notrun',valobj)
 	elif name_string == 'NSCalendarDate':
-		wrapper = NSCalendarDate_SummaryProvider(valobj)
+		wrapper = NSCalendarDate_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('code_notrun',valobj)
 	elif name_string == '__NSTimeZone':
-		wrapper = NSTimeZoneClass_SummaryProvider(valobj)
+		wrapper = NSTimeZoneClass_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('code_notrun',valobj)
 	else:
-		wrapper = NSUnknownDate_SummaryProvider(valobj)
+		wrapper = NSUnknownDate_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('unknown_class',str(valobj) + " seen as " + name_string)
 	return wrapper;
 
diff --git a/lldb/examples/summaries/cocoa/NSException.py b/lldb/examples/summaries/cocoa/NSException.py
index ac85fe8c143..3a09198f84c 100644
--- a/lldb/examples/summaries/cocoa/NSException.py
+++ b/lldb/examples/summaries/cocoa/NSException.py
@@ -12,49 +12,43 @@ statistics.add_metric('code_notrun')
 
 class NSKnownException_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not (self.sys_params.types_cache.id):
+			self.sys_params.types_cache.id = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
 
-	# skip the ISA and go to the name pointer
-	def offset(self):
-		if self.is_64_bit:
-			return 8
-		else:
-			return 4
+	def offset_name(self):
+		return self.sys_params.pointer_size
+	def offset_reason(self):
+		return 2*self.sys_params.pointer_size
 
 	def description(self):
 		name_ptr = self.valobj.CreateChildAtOffset("name",
-							self.offset(),
-							self.id_type)
+							self.offset_name(),
+							self.sys_params.types_cache.id)
 		reason_ptr = self.valobj.CreateChildAtOffset("reason",
-							2*self.offset(),
-							self.id_type)
+							self.offset_reason(),
+							self.sys_params.types_cache.id)
 		return CFString.CFString_SummaryProvider(name_ptr,None) + " " + CFString.CFString_SummaryProvider(reason_ptr,None)
 
-
 class NSUnknownException_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
-		self.update()
+		self.sys_params = params
+		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	def description(self):
 		stream = lldb.SBStream()
@@ -85,10 +79,10 @@ def GetSummary_Impl(valobj):
 	
 	name_string = class_data.class_name()
 	if name_string == 'NSException':
-		wrapper = NSKnownException_SummaryProvider(valobj)
+		wrapper = NSKnownException_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('code_notrun',valobj)
 	else:
-		wrapper = NSUnknownException_SummaryProvider(valobj)
+		wrapper = NSUnknownException_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('unknown_class',str(valobj) + " seen as " + name_string)
 	return wrapper;
 
diff --git a/lldb/examples/summaries/cocoa/NSIndexSet.py b/lldb/examples/summaries/cocoa/NSIndexSet.py
index c030e16d388..043f8889858 100644
--- a/lldb/examples/summaries/cocoa/NSIndexSet.py
+++ b/lldb/examples/summaries/cocoa/NSIndexSet.py
@@ -15,18 +15,20 @@ statistics.add_metric('code_notrun')
 # obey the interface specification for synthetic children providers
 class NSIndexSetClass_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not(self.sys_params.types_cache.NSUInteger):
+			if self.sys_params.is_64_bit:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
+			else:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
 
 	# NS(Mutable)IndexSet works in one of two modes: when having a compact block of data (e.g. a Range)
 	# the count is stored in the set itself, 3 pointers into it
@@ -37,10 +39,10 @@ class NSIndexSetClass_SummaryProvider:
 	# location to go look for count in mode 2
 	def count(self):
 		mode_chooser_vo = self.valobj.CreateChildAtOffset("mode_chooser",
-							2*self.pointer_size,
-							self.NSUInteger)
+							2*self.sys_params.pointer_size,
+							self.sys_params.types_cache.NSUInteger)
 		mode_chooser =  mode_chooser_vo.GetValueAsUnsigned(0)
-		if self.is_64_bit:
+		if self.sys_params.is_64_bit:
 			mode_chooser = mode_chooser & 0xFFFFFFFFFFFFFF00
 		else:
 			mode_chooser = mode_chooser & 0xFFFFFF00
@@ -50,29 +52,27 @@ class NSIndexSetClass_SummaryProvider:
 			mode = 2
 		if mode == 1:
 			count_vo = self.valobj.CreateChildAtOffset("count",
-								3*self.pointer_size,
-								self.NSUInteger)
+								3*self.sys_params.pointer_size,
+								self.sys_params.types_cache.NSUInteger)
 		else:
 			count_ptr = mode_chooser_vo.GetValueAsUnsigned(0)
 			count_vo = self.valobj.CreateValueFromAddress("count",
-								count_ptr+2*self.pointer_size,
-								self.NSUInteger)
+								count_ptr+2*self.sys_params.pointer_size,
+								self.sys_params.types_cache.NSUInteger)
 		return count_vo.GetValueAsUnsigned(0)
 
 
 class NSIndexSetUnknown_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
-		self.update()
+		self.sys_params = params
+		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	def count(self):
 		stream = lldb.SBStream()
@@ -103,10 +103,10 @@ def GetSummary_Impl(valobj):
 	
 	name_string = class_data.class_name()
 	if name_string == 'NSIndexSet' or name_string == 'NSMutableIndexSet':
-		wrapper = NSIndexSetClass_SummaryProvider(valobj)
+		wrapper = NSIndexSetClass_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('code_notrun',valobj)
 	else:
-		wrapper = NSIndexSetUnknown_SummaryProvider(valobj)
+		wrapper = NSIndexSetUnknown_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('unknown_class',str(valobj) + " seen as " + name_string)
 	return wrapper;
 
diff --git a/lldb/examples/summaries/cocoa/NSMachPort.py b/lldb/examples/summaries/cocoa/NSMachPort.py
index eceb2d9ccfe..c7ffcc0c59b 100644
--- a/lldb/examples/summaries/cocoa/NSMachPort.py
+++ b/lldb/examples/summaries/cocoa/NSMachPort.py
@@ -15,24 +15,26 @@ statistics.add_metric('code_notrun')
 # obey the interface specification for synthetic children providers
 class NSMachPortKnown_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not(self.sys_params.types_cache.NSUInteger):
+			if self.sys_params.is_64_bit:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
+			else:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
 
 	# one pointer is the ISA
 	# then we have one other internal pointer, plus
 	# 4 bytes worth of flags. hence, these values
 	def offset(self):
-		if self.is_64_bit:
+		if self.sys_params.is_64_bit:
 			return 20
 		else:
 			return 12
@@ -40,23 +42,21 @@ class NSMachPortKnown_SummaryProvider:
 	def port(self):
 		vport = self.valobj.CreateChildAtOffset("port",
 							self.offset(),
-							self.NSUInteger)
+							self.sys_params.types_cache.NSUInteger)
 		return vport.GetValueAsUnsigned(0)
 
 
 class NSMachPortUnknown_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
-		self.update()
+		self.sys_params = params
+		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	def port(self):
 		stream = lldb.SBStream()
@@ -86,10 +86,10 @@ def GetSummary_Impl(valobj):
 	
 	name_string = class_data.class_name()
 	if name_string == 'NSMachPort':
-		wrapper = NSMachPortKnown_SummaryProvider(valobj)
+		wrapper = NSMachPortKnown_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('code_notrun',valobj)
 	else:
-		wrapper = NSMachPortUnknown_SummaryProvider(valobj)
+		wrapper = NSMachPortUnknown_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('unknown_class',str(valobj) + " seen as " + name_string)
 	return wrapper;
 
diff --git a/lldb/examples/summaries/cocoa/NSNotification.py b/lldb/examples/summaries/cocoa/NSNotification.py
index 0f8cccd322c..48ad18a4331 100644
--- a/lldb/examples/summaries/cocoa/NSNotification.py
+++ b/lldb/examples/summaries/cocoa/NSNotification.py
@@ -12,46 +12,39 @@ statistics.add_metric('code_notrun')
 
 class NSConcreteNotification_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		if not (self.sys_params.types_cache.id):
+			self.sys_params.types_cache.id = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
 
 	# skip the ISA and go to the name pointer
 	def offset(self):
-		if self.is_64_bit:
-			return 8
-		else:
-			return 4
-
+		return self.sys_params.pointer_size
+\
 	def name(self):
 		string_ptr = self.valobj.CreateChildAtOffset("name",
 							self.offset(),
-							self.id_type)
+							self.sys_params.types_cache.id)
 		return CFString.CFString_SummaryProvider(string_ptr,None)
 
 
 class NSNotificationUnknown_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
 		self.update()
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	def name(self):
 		stream = lldb.SBStream()
diff --git a/lldb/examples/summaries/cocoa/NSNumber.py b/lldb/examples/summaries/cocoa/NSNumber.py
index 7726dedb179..7eddcb44d31 100644
--- a/lldb/examples/summaries/cocoa/NSNumber.py
+++ b/lldb/examples/summaries/cocoa/NSNumber.py
@@ -16,30 +16,17 @@ statistics.add_metric('code_notrun')
 # obey the interface specification for synthetic children providers
 class NSTaggedNumber_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj, info_bits, data):
+	def __init__(self, valobj, info_bits, data, params):
 		self.valobj = valobj;
-		self.update();
+		self.sys_params = params
 		self.info_bits = info_bits
 		self.data = data
+		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-
-		self.char = self.valobj.GetType().GetBasicType(lldb.eBasicTypeChar)
-		self.short = self.valobj.GetType().GetBasicType(lldb.eBasicTypeShort)
-		self.ushort = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedShort)
-		self.int = self.valobj.GetType().GetBasicType(lldb.eBasicTypeInt)
-		self.long = self.valobj.GetType().GetBasicType(lldb.eBasicTypeLong)
-		self.ulong = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-		self.longlong = self.valobj.GetType().GetBasicType(lldb.eBasicTypeLongLong)
-		self.ulonglong = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLongLong)
-		self.float = self.valobj.GetType().GetBasicType(lldb.eBasicTypeFloat)
-		self.double = self.valobj.GetType().GetBasicType(lldb.eBasicTypeDouble)
 
 	def value(self):
 		# in spite of the plenty of types made available by the public NSNumber API
@@ -60,28 +47,35 @@ class NSTaggedNumber_SummaryProvider:
 
 class NSUntaggedNumber_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
-		self.update()
+		self.sys_params = params
+		if not(self.sys_params.types_cache.char):
+			self.sys_params.types_cache.char = self.valobj.GetType().GetBasicType(lldb.eBasicTypeChar)
+		if not(self.sys_params.types_cache.short):
+			self.sys_params.types_cache.short = self.valobj.GetType().GetBasicType(lldb.eBasicTypeShort)
+		if not(self.sys_params.types_cache.ushort):
+			self.sys_params.types_cache.ushort = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedShort)
+		if not(self.sys_params.types_cache.int):
+			self.sys_params.types_cache.int = self.valobj.GetType().GetBasicType(lldb.eBasicTypeInt)
+		if not(self.sys_params.types_cache.long):
+			self.sys_params.types_cache.long = self.valobj.GetType().GetBasicType(lldb.eBasicTypeLong)
+		if not(self.sys_params.types_cache.ulong):
+			self.sys_params.types_cache.ulong = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
+		if not(self.sys_params.types_cache.longlong):
+			self.sys_params.types_cache.longlong = self.valobj.GetType().GetBasicType(lldb.eBasicTypeLongLong)
+		if not(self.sys_params.types_cache.ulonglong):
+			self.sys_params.types_cache.ulonglong = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLongLong)
+		if not(self.sys_params.types_cache.float):
+			self.sys_params.types_cache.float = self.valobj.GetType().GetBasicType(lldb.eBasicTypeFloat)
+		if not(self.sys_params.types_cache.double):
+			self.sys_params.types_cache.double = self.valobj.GetType().GetBasicType(lldb.eBasicTypeDouble)
+		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-
-		self.char = self.valobj.GetType().GetBasicType(lldb.eBasicTypeChar)
-		self.short = self.valobj.GetType().GetBasicType(lldb.eBasicTypeShort)
-		self.ushort = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedShort)
-		self.int = self.valobj.GetType().GetBasicType(lldb.eBasicTypeInt)
-		self.long = self.valobj.GetType().GetBasicType(lldb.eBasicTypeLong)
-		self.ulong = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-		self.longlong = self.valobj.GetType().GetBasicType(lldb.eBasicTypeLongLong)
-		self.ulonglong = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLongLong)
-		self.float = self.valobj.GetType().GetBasicType(lldb.eBasicTypeFloat)
-		self.double = self.valobj.GetType().GetBasicType(lldb.eBasicTypeDouble)
 
 	def value(self):
 		global statistics
@@ -89,20 +83,20 @@ class NSUntaggedNumber_SummaryProvider:
 		# we then skip one other full pointer worth of data and then fetch the contents
 		# if we are fetching an int64 value, one more pointer must be skipped to get at our data
 		data_type_vo = self.valobj.CreateChildAtOffset("dt",
-							self.pointer_size,
-							self.char)
+							self.sys_params.pointer_size,
+							self.sys_params.types_cache.char)
 		data_type = ((data_type_vo.GetValueAsUnsigned(0) % 256) & 0x1F)
-		data_offset = 2 * self.pointer_size
+		data_offset = 2 * self.sys_params.pointer_size
 		if data_type == 0B00001:
 			data_vo = self.valobj.CreateChildAtOffset("data",
 								data_offset,
-								self.char)
+								self.sys_params.types_cache.char)
 			statistics.metric_hit('code_notrun',self.valobj)
 			return '(char)' + str(data_vo.GetValueAsUnsigned(0))
 		elif data_type == 0B0010:
 			data_vo = self.valobj.CreateChildAtOffset("data",
 								data_offset,
-								self.short)
+								self.sys_params.types_cache.short)
 			statistics.metric_hit('code_notrun',self.valobj)
 			return '(short)' + str(data_vo.GetValueAsUnsigned(0) % (256*256))
 		# IF tagged pointers are possible on 32bit+v2 runtime
@@ -111,7 +105,7 @@ class NSUntaggedNumber_SummaryProvider:
 		elif data_type == 0B0011:
 			data_vo = self.valobj.CreateChildAtOffset("data",
 								data_offset,
-								self.int)
+								self.sys_params.types_cache.int)
 			statistics.metric_hit('code_notrun',self.valobj)
 			return '(int)' + str(data_vo.GetValueAsUnsigned(0) % (256*256*256*256))
 		# apparently, on is_64_bit architectures, these are the only values that will ever
@@ -120,21 +114,21 @@ class NSUntaggedNumber_SummaryProvider:
 			data_offset = data_offset + 8 # 8 is needed even if we are on 32bit
 			data_vo = self.valobj.CreateChildAtOffset("data",
 								data_offset,
-								self.longlong)
+								self.sys_params.types_cache.longlong)
 			statistics.metric_hit('code_notrun',self.valobj)
 			return '(long)' + str(data_vo.GetValueAsUnsigned(0))
 		elif data_type == 0B0100:
-			if self.is_64_bit:
-				data_offset = data_offset + self.pointer_size
+			if self.sys_params.is_64_bit:
+				data_offset = data_offset + self.sys_params.pointer_size
 			data_vo = self.valobj.CreateChildAtOffset("data",
 								data_offset,
-								self.longlong)
+								self.sys_params.types_cache.longlong)
 			statistics.metric_hit('code_notrun',self.valobj)
 			return '(long)' + str(data_vo.GetValueAsUnsigned(0))
 		elif data_type == 0B0101:
 			data_vo = self.valobj.CreateChildAtOffset("data",
 								data_offset,
-								self.longlong)
+								self.sys_params.types_cache.longlong)
 			data_plain = int(str(data_vo.GetValueAsUnsigned(0) & 0x00000000FFFFFFFF))
 			packed = struct.pack('I', data_plain)
 			data_float = struct.unpack('f', packed)[0]
@@ -143,7 +137,7 @@ class NSUntaggedNumber_SummaryProvider:
 		elif data_type == 0B0110:
 			data_vo = self.valobj.CreateChildAtOffset("data",
 								data_offset,
-								self.longlong)
+								self.sys_params.types_cache.longlong)
 			data_plain = data_vo.GetValueAsUnsigned(0)
 			data_double = struct.unpack('d', struct.pack('Q', data_plain))[0]
 			statistics.metric_hit('code_notrun',self.valobj)
@@ -154,17 +148,15 @@ class NSUntaggedNumber_SummaryProvider:
 
 class NSUnknownNumber_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
-		self.update()
+		self.sys_params = params
+		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	def value(self):
 		stream = lldb.SBStream()
@@ -195,14 +187,14 @@ def GetSummary_Impl(valobj):
 	name_string = class_data.class_name()
 	if name_string == 'NSNumber' or name_string == '__NSCFNumber':
 		if class_data.is_tagged():
-			wrapper = NSTaggedNumber_SummaryProvider(valobj,class_data.info_bits(),class_data.value())
+			wrapper = NSTaggedNumber_SummaryProvider(valobj,class_data.info_bits(),class_data.value(), class_data.sys_params)
 			statistics.metric_hit('code_notrun',valobj)
 		else:
 			# the wrapper might be unable to decipher what is into the NSNumber
 			# and then have to run code on it
-			wrapper = NSUntaggedNumber_SummaryProvider(valobj)
+			wrapper = NSUntaggedNumber_SummaryProvider(valobj, class_data.sys_params)
 	else:
-		wrapper = NSUnknownNumber_SummaryProvider(valobj)
+		wrapper = NSUnknownNumber_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('unknown_class',str(valobj) + " seen as " + name_string)
 	return wrapper;
 
diff --git a/lldb/examples/summaries/cocoa/NSSet.py b/lldb/examples/summaries/cocoa/NSSet.py
index 17ca6d39d7c..068949c2ee0 100644
--- a/lldb/examples/summaries/cocoa/NSSet.py
+++ b/lldb/examples/summaries/cocoa/NSSet.py
@@ -16,24 +16,26 @@ statistics.add_metric('code_notrun')
 # obey the interface specification for synthetic children providers
 class NSCFSet_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not(self.sys_params.types_cache.NSUInteger):
+			if self.sys_params.is_64_bit:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
+			else:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
 
 	# one pointer is the ISA
 	# then we have one other internal pointer, plus
 	# 4 bytes worth of flags. hence, these values
 	def offset(self):
-		if self.is_64_bit:
+		if self.sys_params.is_64_bit:
 			return 20
 		else:
 			return 12
@@ -41,23 +43,21 @@ class NSCFSet_SummaryProvider:
 	def count(self):
 		vcount = self.valobj.CreateChildAtOffset("count",
 							self.offset(),
-							self.NSUInteger)
+							self.sys_params.types_cache.NSUInteger)
 		return vcount.GetValueAsUnsigned(0)
 
 
 class NSSetUnknown_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
-		self.update()
+		self.sys_params = params
+		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	def count(self):
 		stream = lldb.SBStream()
@@ -68,40 +68,36 @@ class NSSetUnknown_SummaryProvider:
 
 class NSSetI_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not(self.sys_params.types_cache.NSUInteger):
+			if self.sys_params.is_64_bit:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
+			else:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		if self.is_64_bit:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-		else:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 
 	# we just need to skip the ISA and the count immediately follows
 	def offset(self):
-		if self.is_64_bit:
-			return 8
-		else:
-			return 4
+		return self.sys_params.pointer_size
 
 	def count(self):
 		num_children_vo = self.valobj.CreateChildAtOffset("count",
 							self.offset(),
-							self.NSUInteger)
+							self.sys_params.types_cache.NSUInteger)
 		value = num_children_vo.GetValueAsUnsigned(0)
 		if value != None:
 			# the MSB on immutable sets seems to be taken by some other data
 			# not sure if it is a bug or some weird sort of feature, but masking it out
 			# gets the count right (unless, of course, someone's dictionaries grow
 			#                       too large - but I have not tested this)
-			if self.is_64_bit:
+			if self.sys_params.is_64_bit:
 				value = value & ~0xFF00000000000000
 			else:
 				value = value & ~0xFF000000
@@ -109,63 +105,55 @@ class NSSetI_SummaryProvider:
 
 class NSSetM_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not(self.sys_params.types_cache.NSUInteger):
+			if self.sys_params.is_64_bit:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
+			else:
+				self.sys_params.types_cache.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		if self.is_64_bit:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-		else:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
 
 	# we just need to skip the ISA and the count immediately follows
 	def offset(self):
-		if self.is_64_bit:
-			return 8
-		else:
-			return 4
+		return self.sys_params.pointer_size
 
 	def count(self):
 		num_children_vo = self.valobj.CreateChildAtOffset("count",
 							self.offset(),
-							self.NSUInteger)
+							self.sys_params.types_cache.NSUInteger)
 		return num_children_vo.GetValueAsUnsigned(0)
 
 
 class NSCountedSet_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not (self.sys_params.types_cache.voidptr):
+			self.sys_params.types_cache.voidptr = self.valobj.GetType().GetBasicType(lldb.eBasicTypeVoid).GetPointerType()
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		self.voidptr_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeVoid).GetPointerType()
 
 	# an NSCountedSet is implemented using a CFBag whose pointer just follows the ISA
 	def offset(self):
-		if self.is_64_bit:
-			return 8
-		else:
-			return 4
+		return self.sys_params.pointer_size
 
 	def count(self):
 		cfbag_vo = self.valobj.CreateChildAtOffset("bag_impl",
 							self.offset(),
-							self.voidptr_type)
-		return CFBag.CFBagRef_SummaryProvider(cfbag_vo).length()
+							self.sys_params.types_cache.voidptr)
+		return CFBag.CFBagRef_SummaryProvider(cfbag_vo,self.sys_params).length()
 
 
 def GetSummary_Impl(valobj):
@@ -189,16 +177,16 @@ def GetSummary_Impl(valobj):
 	
 	name_string = class_data.class_name()
 	if name_string == '__NSCFSet':
-		wrapper = NSCFSet_SummaryProvider(valobj)
+		wrapper = NSCFSet_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('code_notrun',valobj)
 	elif name_string == '__NSSetI':
-		wrapper = NSSetI_SummaryProvider(valobj)
+		wrapper = NSSetI_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('code_notrun',valobj)
 	elif name_string == '__NSSetM':
-		wrapper = NSSetM_SummaryProvider(valobj)
+		wrapper = NSSetM_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('code_notrun',valobj)
 	elif name_string == 'NSCountedSet':
-		wrapper = NSCountedSet_SummaryProvider(valobj)
+		wrapper = NSCountedSet_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('code_notrun',valobj)
 	else:
 		wrapper = NSSetUnknown_SummaryProvider(valobj)
@@ -233,7 +221,7 @@ def NSSet_SummaryProvider2 (valobj,dict):
 		if summary == None:
 			summary = 'no valid set here'
 		else:
-			if provider.is_64_bit:
+			if provider.sys_params.is_64_bit:
 				summary = int(summary) & ~0x1fff000000000000
 		return str(summary) + ' objects'
 	return ''
diff --git a/lldb/examples/summaries/cocoa/NSURL.py b/lldb/examples/summaries/cocoa/NSURL.py
index b242323f4bf..4273b43abd1 100644
--- a/lldb/examples/summaries/cocoa/NSURL.py
+++ b/lldb/examples/summaries/cocoa/NSURL.py
@@ -16,43 +16,36 @@ statistics.add_metric('code_notrun')
 # obey the interface specification for synthetic children providers
 class NSURLKnown_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
+		if not(self.sys_params.types_cache.NSString):
+			self.sys_params.types_cache.NSString = self.valobj.GetTarget().FindFirstType('NSString').GetPointerType()
+		if not(self.sys_params.types_cache.NSURL):
+			self.sys_params.types_cache.NSURL = self.valobj.GetTarget().FindFirstType('NSURL').GetPointerType()
 		self.update();
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
-		if self.is_64_bit:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-			self.pointer_size = 8
-		else:
-			self.NSUInteger = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
-			self.pointer_size = 4
-		self.NSString = self.valobj.GetTarget().FindFirstType('NSString')
-		self.NSURL = self.valobj.GetTarget().FindFirstType('NSURL')
 
 	# one pointer is the ISA
 	# then there is one more pointer and 8 bytes of plain data
 	# (which are also present on a 32-bit system)
 	# plus another pointer, and then the real data
-	def offset(self):
-		if self.is_64_bit:
-			return 24
-		else:
-			return 16
+	def offset_text(self):
+		return 24 if self.sys_params.is_64_bit else 16
+	def offset_base(self):
+		return self.offset_text()+self.sys_params.pointer_size
 
 	def url_text(self):
 		text = self.valobj.CreateChildAtOffset("text",
-							self.offset(),
-							self.NSString.GetPointerType())
+							self.offset_text(),
+							self.sys_params.types_cache.NSString)
 		base = self.valobj.CreateChildAtOffset("base",
-							self.offset()+self.pointer_size,
-							self.NSURL.GetPointerType())
+							self.offset_base(),
+							self.sys_params.types_cache.NSURL)
 		my_string = CFString.CFString_SummaryProvider(text,None)
 		if base.GetValueAsUnsigned(0) != 0:
 			my_string = my_string + " (base path: " + NSURL_SummaryProvider(base,None) + ")"
@@ -61,17 +54,15 @@ class NSURLKnown_SummaryProvider:
 
 class NSURLUnknown_SummaryProvider:
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+		pass
 
-	def __init__(self, valobj):
+	def __init__(self, valobj, params):
 		self.valobj = valobj;
+		self.sys_params = params
 		self.update()
 
 	def update(self):
 		self.adjust_for_architecture();
-		self.id_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeObjCID)
 
 	def url_text(self):
 		stream = lldb.SBStream()
@@ -101,10 +92,10 @@ def GetSummary_Impl(valobj):
 	
 	name_string = class_data.class_name()
 	if name_string == 'NSURL':
-		wrapper = NSURLKnown_SummaryProvider(valobj)
+		wrapper = NSURLKnown_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('code_notrun',valobj)
 	else:
-		wrapper = NSURLUnknown_SummaryProvider(valobj)
+		wrapper = NSURLUnknown_SummaryProvider(valobj, class_data.sys_params)
 		statistics.metric_hit('unknown_class',str(valobj) + " seen as " + name_string)
 	return wrapper;
 
diff --git a/lldb/examples/summaries/cocoa/attrib_fromdict.py b/lldb/examples/summaries/cocoa/attrib_fromdict.py
new file mode 100644
index 00000000000..8ecd9ed27be
--- /dev/null
+++ b/lldb/examples/summaries/cocoa/attrib_fromdict.py
@@ -0,0 +1,31 @@
+class AttributesDictionary:
+	def __init__(self, allow_reset = True):
+		self.__dict__['_dictionary'] = {} # need to do it this way to prevent endless recursion
+		self.__dict__['_allow_reset'] = allow_reset
+
+	def __getattr__(self,name):
+		if not self._check_exists(name):
+			return None
+		value = self._dictionary[name]
+		return value
+
+	def _set_impl(self,name,value):
+		self._dictionary[name] = value
+
+	def _check_exists(self,name):
+		return name in self._dictionary
+
+	def __setattr__(self,name,value):
+		if self._allow_reset:
+			self._set_impl(name,value)
+		else:
+			self.set_if_necessary(name,value)
+
+	def set_if_necessary(self,name,value):
+		if not self._check_exists(name):
+			self._set_impl(name,value)
+			return True
+		return False
+
+	def __len__(self):
+		return len(self._dictionary)
\ No newline at end of file
diff --git a/lldb/examples/summaries/cocoa/objc_lldb.py b/lldb/examples/summaries/cocoa/objc_lldb.py
index 877674c24cd..a9f9322b9bb 100644
--- a/lldb/examples/summaries/cocoa/objc_lldb.py
+++ b/lldb/examples/summaries/cocoa/objc_lldb.py
@@ -1,6 +1,7 @@
 """
-Objective-C runtime wrapper - Replicates the behavior of AppleObjCRuntimeV2.cpp in Python code
-for the benefit of synthetic children providers and Python summaries
+Objective-C runtime wrapper for use by LLDB Python formatters
+This is an old and deprecated version of the wrapper
+The new code, to which everyone should convert, is in objc_runtime.py
 
 part of The LLVM Compiler Infrastructure
 This file is distributed under the University of Illinois Open Source
diff --git a/lldb/examples/summaries/cocoa/objc_runtime.py b/lldb/examples/summaries/cocoa/objc_runtime.py
index 0af07f0a3be..ddad00a2230 100644
--- a/lldb/examples/summaries/cocoa/objc_runtime.py
+++ b/lldb/examples/summaries/cocoa/objc_runtime.py
@@ -1,6 +1,14 @@
-# a wrapper for the Objective-C runtime for use by LLDB
+"""
+Objective-C runtime wrapper for use by LLDB Python formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
 import lldb
 import cache
+import attrib_fromdict
+import functools
 
 class Utilities:
 	@staticmethod
@@ -72,11 +80,11 @@ class RoT_Data:
 			self.sys_params = params
 			self.valobj = rot_pointer
 			#self.flags = Utilities.read_child_of(self.valobj,0,self.sys_params.uint32_t)
-			self.instanceStart = Utilities.read_child_of(self.valobj,4,self.sys_params.uint32_t)
-			self.instanceSize = Utilities.read_child_of(self.valobj,8,self.sys_params.uint32_t)
+			#self.instanceStart = Utilities.read_child_of(self.valobj,4,self.sys_params.uint32_t)
+			self.instanceSize = None # lazy fetching
 			offset = 24 if self.sys_params.is_64_bit else 16
 			#self.ivarLayoutPtr = Utilities.read_child_of(self.valobj,offset,self.sys_params.addr_ptr_type)
-			self.namePointer = Utilities.read_child_of(self.valobj,offset,self.sys_params.addr_ptr_type)
+			self.namePointer = Utilities.read_child_of(self.valobj,offset,self.sys_params.types_cache.addr_ptr_type)
 			self.check_valid()
 		else:
 			self.valid = False
@@ -85,7 +93,7 @@ class RoT_Data:
 			if not(Utilities.is_valid_identifier(self.name)):
 				self.valid = False
 
-	# perform sanity checks on the contents of this class_rw_t
+	# perform sanity checks on the contents of this class_ro_t
 	def check_valid(self):
 		self.valid = True
 		# misaligned pointers seem to be possible for this field
@@ -95,13 +103,25 @@ class RoT_Data:
 
 	def __str__(self):
 		return \
-		 "instanceStart = " + hex(self.instanceStart) + "\n" + \
-		 "instanceSize = " + hex(self.instanceSize) + "\n" + \
+		 "instanceSize = " + hex(self.instance_size()) + "\n" + \
 		 "namePointer = " + hex(self.namePointer) + " --> " + self.name
 
 	def is_valid(self):
 		return self.valid
 
+	def instance_size(self,align=False):
+		if self.is_valid() == False:
+			return None
+		if self.instanceSize == None:
+			self.instanceSize = Utilities.read_child_of(self.valobj,8,self.sys_params.types_cache.uint32_t)
+		if align:
+			unalign = self.instance_size(False)
+			if self.sys_params.is_64_bit:
+				return ((unalign + 7) & ~7) % 0x100000000
+			else:
+				return ((unalign + 3) & ~3) % 0x100000000
+		else:
+			return self.instanceSize
 
 class RwT_Data:
 	def __init__(self,rwt_pointer,params):
@@ -110,12 +130,12 @@ class RwT_Data:
 			self.valobj = rwt_pointer
 			#self.flags = Utilities.read_child_of(self.valobj,0,self.sys_params.uint32_t)
 			#self.version = Utilities.read_child_of(self.valobj,4,self.sys_params.uint32_t)
-			self.roPointer = Utilities.read_child_of(self.valobj,8,self.sys_params.addr_ptr_type)
+			self.roPointer = Utilities.read_child_of(self.valobj,8,self.sys_params.types_cache.addr_ptr_type)
 			self.check_valid()
 		else:
 			self.valid = False
 		if self.valid:
-			self.rot = self.valobj.CreateValueFromAddress("rot",self.roPointer,self.sys_params.addr_ptr_type).AddressOf()
+			self.rot = self.valobj.CreateValueFromAddress("rot",self.roPointer,self.sys_params.types_cache.addr_ptr_type).AddressOf()
 			self.data = RoT_Data(self.rot,self.sys_params)
 
 	# perform sanity checks on the contents of this class_rw_t
@@ -138,53 +158,56 @@ class Class_Data_V2:
 		if (isa_pointer != None) and (Utilities.is_valid_pointer(isa_pointer.GetValueAsUnsigned(),params.pointer_size, allow_tagged=False)):
 			self.sys_params = params
 			self.valobj = isa_pointer
-			self.isaPointer = Utilities.read_child_of(self.valobj,0,self.sys_params.addr_ptr_type)
-			self.superclassIsaPointer = Utilities.read_child_of(self.valobj,1*self.sys_params.pointer_size,self.sys_params.addr_ptr_type)
-			self.cachePointer = Utilities.read_child_of(self.valobj,2*self.sys_params.pointer_size,self.sys_params.addr_ptr_type)
-			self.vtablePointer = Utilities.read_child_of(self.valobj,3*self.sys_params.pointer_size,self.sys_params.addr_ptr_type)
-			self.dataPointer = Utilities.read_child_of(self.valobj,4*self.sys_params.pointer_size,self.sys_params.addr_ptr_type)
 			self.check_valid()
 		else:
 			self.valid = False
 		if self.valid:
-			self.rwt = self.valobj.CreateValueFromAddress("rwt",self.dataPointer,self.sys_params.addr_ptr_type).AddressOf()
+			self.rwt = self.valobj.CreateValueFromAddress("rwt",self.dataPointer,self.sys_params.types_cache.addr_ptr_type).AddressOf()
 			self.data = RwT_Data(self.rwt,self.sys_params)
 
 	# perform sanity checks on the contents of this class_t
+	# this call tries to minimize the amount of data fetched- as soon as we have "proven"
+	# that we have an invalid object, we stop reading
 	def check_valid(self):
 		self.valid = True
+		
+		self.isaPointer = Utilities.read_child_of(self.valobj,0,self.sys_params.types_cache.addr_ptr_type)
 		if not(Utilities.is_valid_pointer(self.isaPointer,self.sys_params.pointer_size,allow_tagged=False)):
 			self.valid = False
 			return
-		if not(Utilities.is_valid_pointer(self.superclassIsaPointer,self.sys_params.pointer_size,allow_tagged=False)):
-			# NULL is a valid value for superclass (it means we have reached NSObject)
-			if self.superclassIsaPointer != 0:
-				self.valid = False
-				return
+		if not(Utilities.is_allowed_pointer(self.isaPointer)):
+			self.valid = False
+			return
+
+		self.cachePointer = Utilities.read_child_of(self.valobj,2*self.sys_params.pointer_size,self.sys_params.types_cache.addr_ptr_type)
 		if not(Utilities.is_valid_pointer(self.cachePointer,self.sys_params.pointer_size,allow_tagged=False)):
 			self.valid = False
 			return
+		if not(Utilities.is_allowed_pointer(self.cachePointer)):
+			self.valid = False
+			return
+
+		self.vtablePointer = Utilities.read_child_of(self.valobj,3*self.sys_params.pointer_size,self.sys_params.types_cache.addr_ptr_type)
 		if not(Utilities.is_valid_pointer(self.vtablePointer,self.sys_params.pointer_size,allow_tagged=False)):
 			self.valid = False
 			return
-		if not(Utilities.is_valid_pointer(self.dataPointer,self.sys_params.pointer_size,allow_tagged=False)):
+		if not(Utilities.is_allowed_pointer(self.vtablePointer)):
 			self.valid = False
 			return
-		if not(Utilities.is_allowed_pointer(self.isaPointer)):
+
+		self.dataPointer = Utilities.read_child_of(self.valobj,4*self.sys_params.pointer_size,self.sys_params.types_cache.addr_ptr_type)
+		if not(Utilities.is_valid_pointer(self.dataPointer,self.sys_params.pointer_size,allow_tagged=False)):
 			self.valid = False
 			return
-		if not(Utilities.is_allowed_pointer(self.superclassIsaPointer)):
-			# NULL is a valid value for superclass (it means we have reached NSObject)
-			if self.superclassIsaPointer != 0:
-				self.valid = False
-				return
-		if not(Utilities.is_allowed_pointer(self.cachePointer)):
+		if not(Utilities.is_allowed_pointer(self.dataPointer)):
 			self.valid = False
 			return
-		if not(Utilities.is_allowed_pointer(self.vtablePointer)):
+
+		self.superclassIsaPointer = Utilities.read_child_of(self.valobj,1*self.sys_params.pointer_size,self.sys_params.types_cache.addr_ptr_type)
+		if not(Utilities.is_valid_pointer(self.superclassIsaPointer,self.sys_params.pointer_size,allow_tagged=False, allow_NULL=True)):
 			self.valid = False
 			return
-		if not(Utilities.is_allowed_pointer(self.dataPointer)):
+		if not(Utilities.is_allowed_pointer(self.superclassIsaPointer)):
 			self.valid = False
 			return
 
@@ -198,6 +221,14 @@ class Class_Data_V2:
 				return True
 		return False
 
+	# some CF classes have a valid ObjC isa in their CFRuntimeBase
+	# but instead of being class-specific this isa points to a match-'em-all class
+	# which is __NSCFType (the versions without __ also exists and we are matching to it
+	#                      just to be on the safe side)
+	def is_cftype(self):
+		if self.is_valid():
+			return self.name == '__NSCFType' or self.name == 'NSCFType'
+
 	def get_superclass(self):
 		if self.is_valid():
 			parent_isa_pointer = self.valobj.CreateChildAtOffset("parent_isa",
@@ -231,14 +262,7 @@ class Class_Data_V2:
 	def instance_size(self,align=False):
 		if self.is_valid() == False:
 			return None
-		if align:
-			unalign = self.instance_size(False)
-			if self.sys_params.is_64_bit:
-				return ((unalign + 7) & ~7) % 0x100000000
-			else:
-				return ((unalign + 3) & ~3) % 0x100000000
-		else:
-			return self.rwt.rot.instanceSize
+		return self.rwt.rot.instance_size(align)
 
 # runtime v1 is much less intricate than v2 and stores relevant information directly in the class_t object
 class Class_Data_V1:
@@ -247,12 +271,7 @@ class Class_Data_V1:
 			self.valid = True
 			self.sys_params = params
 			self.valobj = isa_pointer
-			self.isaPointer = Utilities.read_child_of(self.valobj,0,self.sys_params.addr_ptr_type)
-			self.superclassIsaPointer = Utilities.read_child_of(self.valobj,1*self.sys_params.pointer_size,self.sys_params.addr_ptr_type)
-			self.namePointer = Utilities.read_child_of(self.valobj,2*self.sys_params.pointer_size,self.sys_params.addr_ptr_type)
-			self.version = Utilities.read_child_of(self.valobj,3*self.sys_params.pointer_size,self.sys_params.addr_ptr_type)
-			self.info = Utilities.read_child_of(self.valobj,4*self.sys_params.pointer_size,self.sys_params.addr_ptr_type)
-			self.instanceSize = Utilities.read_child_of(self.valobj,5*self.sys_params.pointer_size,self.sys_params.addr_ptr_type)
+			self.check_valid()
 		else:
 			self.valid = False
 		if self.valid:
@@ -263,18 +282,22 @@ class Class_Data_V1:
 	# perform sanity checks on the contents of this class_t
 	def check_valid(self):
 		self.valid = True
+
+		self.isaPointer = Utilities.read_child_of(self.valobj,0,self.sys_params.types_cache.addr_ptr_type)
 		if not(Utilities.is_valid_pointer(self.isaPointer,self.sys_params.pointer_size,allow_tagged=False)):
 			self.valid = False
 			return
-		if not(Utilities.is_valid_pointer(self.superclassIsaPointer,self.sys_params.pointer_size,allow_tagged=False)):
-			# NULL is a valid value for superclass (it means we have reached NSObject)
-			if self.superclassIsaPointer != 0:
-				self.valid = False
-				return
-		if not(Utilities.is_valid_pointer(self.namePointer,self.sys_params.pointer_size,allow_tagged=False,allow_NULL=True)):
+
+		self.superclassIsaPointer = Utilities.read_child_of(self.valobj,1*self.sys_params.pointer_size,self.sys_params.types_cache.addr_ptr_type)
+		if not(Utilities.is_valid_pointer(self.superclassIsaPointer,self.sys_params.pointer_size,allow_tagged=False,allow_NULL=True)):
 			self.valid = False
 			return
 
+		self.namePointer = Utilities.read_child_of(self.valobj,2*self.sys_params.pointer_size,self.sys_params.types_cache.addr_ptr_type)
+		#if not(Utilities.is_valid_pointer(self.namePointer,self.sys_params.pointer_size,allow_tagged=False,allow_NULL=False)):
+		#	self.valid = False
+		#	return
+
 	# in general, KVO is implemented by transparently subclassing
 	# however, there could be exceptions where a class does something else
 	# internally to implement the feature - this method will have no clue that a class
@@ -285,6 +308,14 @@ class Class_Data_V1:
 				return True
 		return False
 
+	# some CF classes have a valid ObjC isa in their CFRuntimeBase
+	# but instead of being class-specific this isa points to a match-'em-all class
+	# which is __NSCFType (the versions without __ also exists and we are matching to it
+	#                      just to be on the safe side)
+	def is_cftype(self):
+		if self.is_valid():
+			return self.name == '__NSCFType' or self.name == 'NSCFType'
+
 	def get_superclass(self):
 		if self.is_valid():
 			parent_isa_pointer = self.valobj.CreateChildAtOffset("parent_isa",
@@ -307,9 +338,7 @@ class Class_Data_V1:
 		return 'isaPointer = ' + hex(self.isaPointer) + "\n" + \
 		 "superclassIsaPointer = " + hex(self.superclassIsaPointer) + "\n" + \
 		 "namePointer = " + hex(self.namePointer) + " --> " + self.name + \
-		 "version = " + hex(self.version) + "\n" + \
-		 "info = " + hex(self.info) + "\n" + \
-		 "instanceSize = " + hex(self.instanceSize) + "\n"
+		 "instanceSize = " + hex(self.instanceSize()) + "\n"
 
 	def is_tagged(self):
 		return False
@@ -317,6 +346,8 @@ class Class_Data_V1:
 	def instance_size(self,align=False):
 		if self.is_valid() == False:
 			return None
+		if self.instanceSize == None:
+			self.instanceSize = Utilities.read_child_of(self.valobj,5*self.sys_params.pointer_size,self.sys_params.types_cache.addr_ptr_type)
 		if align:
 			unalign = self.instance_size(False)
 			if self.sys_params.is_64_bit:
@@ -381,6 +412,9 @@ class TaggedClass_Data:
 	def is_kvo(self):
 		return False
 
+	def is_cftype(self):
+		return False
+
 	# we would need to go around looking for the superclass or ask the runtime
 	# for now, we seem not to require support for this operation so we will merrily
 	# pretend to be at a root point in the hierarchy
@@ -395,7 +429,7 @@ class TaggedClass_Data:
 	def instance_size(self,align=False):
 		if self.is_valid() == False:
 			return None
-		return 8 if self.sys_params.is_64_bit else 4
+		return self.sys_params.pointer_size
 
 
 class InvalidClass_Data:
@@ -404,40 +438,106 @@ class InvalidClass_Data:
 	def is_valid(self):
 		return False
 
+@functools.total_ordering
+class Version:
+	def __init__(self, major, minor, release, build_string):
+		self._major = major
+		self._minor = minor
+		self._release = release
+		self._build_string = build_string
+
+	def get_major(self):
+		return self._major
+	def get_minor(self):
+		return self._minor
+	def get_release(self):
+		return self._release
+	def get_build_string(self):
+		return self._build_string
+
+	major = property(get_major,None)
+	minor = property(get_minor,None)
+	release = property(get_release,None)
+	build_string = property(get_build_string,None)
+
+	def __lt__(self,other):
+		if (self.major < other.major):
+			return True
+		if (self.minor < other.minor):
+			return True
+		if (self.release < other.release):
+			return True
+		# build strings are not compared since they are heavily platform-dependent and might not always
+		# be available
+		return False
+
+	def __eq__(self,other):
+		return (self.major == other.major) and \
+		       (self.minor == other.minor) and \
+		       (self.release == other.release) and \
+		       (self.build_string == other.build_string)
+
 runtime_version = cache.Cache()
 os_version = cache.Cache()
+types_caches = cache.Cache()
+isa_caches = cache.Cache()
 
-# TODO: make more extensive use of this class in the individual formatters
-# instead of recalculating the same information - since we are building this object
-# it makes sense to pass it around to the formatters
 class SystemParameters:
 	def __init__(self,valobj):
 		self.adjust_for_architecture(valobj)
+		self.adjust_for_process(valobj)
 
-	def adjust_for_architecture(self,valobj):
-		self.process = valobj.GetTarget().GetProcess()
-		self.is_64_bit = (self.process.GetAddressByteSize() == 8)
-		self.is_little = (self.process.GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.process.GetAddressByteSize()
-		self.addr_type = valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-		self.addr_ptr_type = self.addr_type.GetPointerType()
-		self.uint32_t = valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
+	def adjust_for_process(self, valobj):
 		global runtime_version
 		global os_version
-		pid = self.process.GetProcessID()
-		if runtime_version.look_for_key(pid):
-			self.runtime_version = runtime_version.get_value(pid)
+		global types_caches
+		global isa_caches
+		
+		process = valobj.GetTarget().GetProcess()
+		self.pid = process.GetProcessID()
+		
+		if runtime_version.look_for_key(self.pid):
+			self.runtime_version = runtime_version.get_value(self.pid)
 		else:
-			self.runtime_version = ObjCRuntime.runtime_version(self.process)
-			runtime_version.add_item(pid,self.runtime_version)
-		if os_version.look_for_key(pid):
-			self.is_lion = os_version.get_value(pid)
+			self.runtime_version = ObjCRuntime.runtime_version(process)
+			runtime_version.add_item(self.pid,self.runtime_version)
+		
+		if os_version.look_for_key(self.pid):
+			self.is_lion = os_version.get_value(self.pid)
 		else:
 			self.is_lion = Utilities.check_is_osx_lion(valobj.GetTarget())
-			os_version.add_item(pid,self.is_lion)
+			os_version.add_item(self.pid,self.is_lion)
+		
+		if types_caches.look_for_key(self.pid):
+			self.types_cache = types_caches.get_value(self.pid)
+		else:
+			self.types_cache = attrib_fromdict.AttributesDictionary(allow_reset=False)
+			self.types_cache.addr_type = valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
+			self.types_cache.addr_ptr_type = self.types_cache.addr_type.GetPointerType()
+			self.types_cache.uint32_t = valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedInt)
+			types_caches.add_item(self.pid,self.types_cache)
+		
+		if isa_caches.look_for_key(self.pid):
+			self.isa_cache = isa_caches.get_value(self.pid)
+		else:
+			self.isa_cache = cache.Cache()
+			isa_caches.add_item(self.pid,self.isa_cache)
+
+	def adjust_for_architecture(self,valobj):
+		process = valobj.GetTarget().GetProcess()
+		self.pointer_size = process.GetAddressByteSize()
+		self.is_64_bit = (self.pointer_size == 8)
+		self.is_little = (process.GetByteOrder() == lldb.eByteOrderLittle)
 		self.cfruntime_size = 16 if self.is_64_bit else 8
 
-isa_cache = cache.Cache()
+	# a simple helper function that makes it more explicit that one is calculating
+	# an offset that is made up of X pointers and Y bytes of additional data
+	# taking into account pointer size - if you know there is going to be some padding
+	# you can pass that in and it will be taken into account (since padding may be different between
+	# 32 and 64 bit versions, you can pass padding value for both, the right one will be used)
+	def calculate_offset(self, num_pointers = 0, bytes_count = 0, padding32 = 0, padding64 = 0):
+		value = bytes_count + num_pointers*self.pointer_size
+		return value + padding64 if self.is_64_bit else value + padding32
 
 class ObjCRuntime:
 
@@ -477,32 +577,28 @@ class ObjCRuntime:
 		self.isa_value = None
 
 	def adjust_for_architecture(self):
-		self.is_64_bit = (self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
-		self.is_little = (self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle)
-		self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
-		self.addr_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeUnsignedLong)
-		self.addr_ptr_type = self.addr_type.GetPointerType()
+		pass
 
 # an ObjC pointer can either be tagged or must be aligned
 	def is_tagged(self):
 		if self.valobj is None:
 			return False
-		return (Utilities.is_valid_pointer(self.unsigned_value,self.pointer_size, allow_tagged=True) and \
-		not(Utilities.is_valid_pointer(self.unsigned_value,self.pointer_size, allow_tagged=False)))
+		return (Utilities.is_valid_pointer(self.unsigned_value,self.sys_params.pointer_size, allow_tagged=True) and \
+		not(Utilities.is_valid_pointer(self.unsigned_value,self.sys_params.pointer_size, allow_tagged=False)))
 
 	def is_valid(self):
 		if self.valobj is None:
 			return False
 		if self.valobj.IsInScope() == False:
 			return False
-		return Utilities.is_valid_pointer(self.unsigned_value,self.pointer_size, allow_tagged=True)
+		return Utilities.is_valid_pointer(self.unsigned_value,self.sys_params.pointer_size, allow_tagged=True)
 
 	def read_isa(self):
 		if self.isa_value != None:
 			return self.isa_value
 		isa_pointer = self.valobj.CreateChildAtOffset("cfisa",
 			0,
-			self.addr_ptr_type)
+			self.sys_params.types_cache.addr_ptr_type)
 		if isa_pointer == None or isa_pointer.IsValid() == False:
 			return None;
 		if isa_pointer.GetValueAsUnsigned(1) == 1:
@@ -530,7 +626,7 @@ class ObjCRuntime:
 		isa_value = isa.GetValueAsUnsigned(1)
 		if isa_value == 1:
 			return InvalidClass_Data()
-		data = isa_cache.get_value(isa_value,default=None)
+		data = self.sys_params.isa_cache.get_value(isa_value,default=None)
 		if data != None:
 			return data
 		if self.sys_params.runtime_version == 2:
@@ -540,6 +636,6 @@ class ObjCRuntime:
 		if data == None:
 			return InvalidClass_Data()
 		if data.is_valid():
-			isa_cache.add_item(isa_value,data,ok_to_replace=True)
+			self.sys_params.isa_cache.add_item(isa_value,data,ok_to_replace=True)
 		return data