git.saurik.com Git - apple/dyld.git/blame_incremental - launch-cache/ObjCModernAbstraction.hpp

... / ...

Commit	Line	Data
	1	/* -- mode: C++; c-basic-offset: 4; tab-width: 4 --
	2	*
	3	* Copyright (c) 2008-2010 Apple Inc. All rights reserved.
	4	*
	5	* @APPLE_LICENSE_HEADER_START@
	6	*
	7	* This file contains Original Code and/or Modifications of Original Code
	8	* as defined in and that are subject to the Apple Public Source License
	9	* Version 2.0 (the 'License'). You may not use this file except in
	10	* compliance with the License. Please obtain a copy of the License at
	11	* http://www.opensource.apple.com/apsl/ and read it before using this
	12	* file.
	13	*
	14	* The Original Code and all software distributed under the License are
	15	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	16	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	17	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	19	* Please see the License for the specific language governing rights and
	20	* limitations under the License.
	21	*
	22	* @APPLE_LICENSE_HEADER_END@
	23	*/
	24
	25	#include "MachOLayout.hpp"
	26	#include <iterator>
	27	#include <deque>
	28
	29	// iterate an entsize-based list
	30	// typedef entsize_iterator< A, type_t<A>, type_list_t<A> > type_iterator;
	31	template <typename A, typename T, typename Tlist>
	32	struct entsize_iterator {
	33	uint32_t entsize;
	34	uint32_t index; // keeping track of this saves a divide in operator-
	35	T* current;
	36
	37	typedef std::random_access_iterator_tag iterator_category;
	38	typedef T value_type;
	39	typedef ptrdiff_t difference_type;
	40	typedef T* pointer;
	41	typedef T& reference;
	42
	43	entsize_iterator() { }
	44
	45	entsize_iterator(const Tlist& list, uint32_t start = 0)
	46	: entsize(list.getEntsize()), index(start), current(&list.get(start))
	47	{ }
	48
	49	const entsize_iterator<A,T,Tlist>& operator += (ptrdiff_t count) {
	50	current = (T)((uint8_t )current + count*entsize);
	51	index += count;
	52	return *this;
	53	}
	54	const entsize_iterator<A,T,Tlist>& operator -= (ptrdiff_t count) {
	55	current = (T)((uint8_t )current - count*entsize);
	56	index -= count;
	57	return *this;
	58	}
	59	const entsize_iterator<A,T,Tlist> operator + (ptrdiff_t count) const {
	60	return entsize_iterator(*this) += count;
	61	}
	62	const entsize_iterator<A,T,Tlist> operator - (ptrdiff_t count) const {
	63	return entsize_iterator(*this) -= count;
	64	}
	65
	66	entsize_iterator<A,T,Tlist>& operator ++ () { this += 1; return this; }
	67	entsize_iterator<A,T,Tlist>& operator -- () { this -= 1; return this; }
	68	entsize_iterator<A,T,Tlist> operator ++ (int) {
	69	entsize_iterator<A,T,Tlist> result(this); this += 1; return result;
	70	}
	71	entsize_iterator<A,T,Tlist> operator -- (int) {
	72	entsize_iterator<A,T,Tlist> result(this); this -= 1; return result;
	73	}
	74
	75	ptrdiff_t operator - (const entsize_iterator<A,T,Tlist>& rhs) const {
	76	return (ptrdiff_t)this->index - (ptrdiff_t)rhs.index;
	77	}
	78
	79	T& operator * () { return *current; }
	80	T& operator * () const { return *current; }
	81	T& operator -> () { return *current; }
	82	const T& operator -> () const { return *current; }
	83
	84	operator T& () const { return *current; }
	85
	86	bool operator == (const entsize_iterator<A,T,Tlist>& rhs) {
	87	return this->current == rhs.current;
	88	}
	89	bool operator != (const entsize_iterator<A,T,Tlist>& rhs) {
	90	return this->current != rhs.current;
	91	}
	92
	93	bool operator < (const entsize_iterator<A,T,Tlist>& rhs) {
	94	return this->current < rhs.current;
	95	}
	96	bool operator > (const entsize_iterator<A,T,Tlist>& rhs) {
	97	return this->current > rhs.current;
	98	}
	99
	100
	101	static void overwrite(entsize_iterator<A,T,Tlist>& dst, const Tlist* srcList)
	102	{
	103	entsize_iterator<A,T,Tlist> src;
	104	uint32_t ee = srcList->getEntsize();
	105	for (src = srcList->begin(); src != srcList->end(); ++src) {
	106	memcpy(&dst, &src, ee);
	107	++dst;
	108	}
	109	}
	110	};
	111
	112	template <typename A>
	113	class objc_header_info_t {
	114
	115	typedef typename A::P P;
	116	typedef typename A::P::uint_t pint_t;
	117
	118	pint_t next; // objc_header_info *
	119	pint_t mhdr; // mach_header or mach_header_64
	120	pint_t info; // objc_image_info *
	121	pint_t fname; // const char *
	122	bool loaded;
	123	bool inSharedCache;
	124	bool allClassesRealized;
	125
	126	public:
	127	objc_header_info_t(SharedCache<A>* cache, const macho_header<P>* mh)
	128	: next(0),
	129	mhdr(0),
	130	info(0),
	131	fname(0),
	132	loaded(0),
	133	allClassesRealized(0)
	134	{
	135	A::P::setP(mhdr, cache->VMAddressForMappedAddress(mh));
	136	const macho_section<P>* sect = mh->getSection("__DATA", "__objc_imageinfo");
	137	if (sect) A::P::setP(info, sect->addr());
	138
	139	// can't set fname because dyld sometimes edits it
	140	}
	141
	142	void addPointers(std::vector<void*>& pointersToAdd) {
	143	pointersToAdd.push_back(&mhdr);
	144	if (info) pointersToAdd.push_back(&info);
	145	}
	146
	147	uint64_t header_vmaddr() const { return mhdr; }
	148	};
	149
	150	template <typename A> class objc_method_list_t; // forward reference
	151
	152	template <typename A>
	153	class objc_method_t {
	154	typename A::P::uint_t name; // SEL
	155	typename A::P::uint_t types; // const char *
	156	typename A::P::uint_t imp; // IMP
	157	friend class objc_method_list_t<A>;
	158	public:
	159	typename A::P::uint_t getName() const { return A::P::getP(name); }
	160	void setName(typename A::P::uint_t newName) { A::P::setP(name, newName); }
	161
	162	struct SortBySELAddress :
	163	public std::binary_function<const objc_method_t<A>&,
	164	const objc_method_t<A>&, bool>
	165	{
	166	bool operator() (const objc_method_t<A>& lhs,
	167	const objc_method_t<A>& rhs)
	168	{
	169	return lhs.getName() < rhs.getName();
	170	}
	171	};
	172	};
	173
	174	template <typename A>
	175	class objc_method_list_t {
	176	uint32_t entsize;
	177	uint32_t count;
	178	objc_method_t<A> first;
	179
	180	void* operator new (size_t, void* buf) { return buf; }
	181
	182	public:
	183
	184	typedef entsize_iterator< A, objc_method_t<A>, objc_method_list_t<A> > method_iterator;
	185
	186	uint32_t getCount() const { return A::P::E::get32(count); }
	187
	188	uint32_t getEntsize() const {return A::P::E::get32(entsize)&~(uint32_t)3;}
	189
	190	objc_method_t<A>& get(uint32_t i) const { return (objc_method_t<A> )((uint8_t )&first + i getEntsize()); }
	191
	192	uint32_t byteSize() const {
	193	return byteSizeForCount(getCount(), getEntsize());
	194	}
	195
	196	static uint32_t byteSizeForCount(uint32_t c, uint32_t e = sizeof(objc_method_t<A>)) {
	197	return sizeof(objc_method_list_t<A>) - sizeof(objc_method_t<A>) + c*e;
	198	}
	199
	200	method_iterator begin() { return method_iterator(*this, 0); }
	201	method_iterator end() { return method_iterator(*this, getCount()); }
	202	const method_iterator begin() const { return method_iterator(*this, 0); }
	203	const method_iterator end() const { return method_iterator(*this, getCount()); }
	204
	205	void setFixedUp() { A::P::E::set32(entsize, getEntsize() \| 3); }
	206
	207	void getPointers(std::set<void*>& pointersToRemove) {
	208	for(method_iterator it = begin(); it != end(); ++it) {
	209	objc_method_t<A>& entry = *it;
	210	pointersToRemove.insert(&(entry.name));
	211	pointersToRemove.insert(&(entry.types));
	212	pointersToRemove.insert(&(entry.imp));
	213	}
	214	}
	215
	216	static void addPointers(uint8_t* methodList, std::vector<void*>& pointersToAdd) {
	217	objc_method_list_t<A>* mlist = (objc_method_list_t<A>*)methodList;
	218	for(method_iterator it = mlist->begin(); it != mlist->end(); ++it) {
	219	objc_method_t<A>& entry = *it;
	220	pointersToAdd.push_back(&(entry.name));
	221	pointersToAdd.push_back(&(entry.types));
	222	pointersToAdd.push_back(&(entry.imp));
	223	}
	224	}
	225
	226	static objc_method_list_t<A>* newMethodList(size_t newCount, uint32_t newEntsize) {
	227	void *buf = ::calloc(byteSizeForCount(newCount, newEntsize), 1);
	228	return new (buf) objc_method_list_t<A>(newCount, newEntsize);
	229	}
	230
	231	void operator delete(void * p) {
	232	::free(p);
	233	}
	234
	235	objc_method_list_t(uint32_t newCount,
	236	uint32_t newEntsize = sizeof(objc_method_t<A>))
	237	: entsize(newEntsize), count(newCount)
	238	{ }
	239
	240	private:
	241	// use newMethodList instead
	242	void* operator new (size_t);
	243	};
	244
	245
	246	// Ivar offset variables are 64-bit on x86_64 and 32-bit everywhere else.
	247
	248	template <typename A>
	249	class objc_ivar_offset_t {
	250	typedef typename A::P::uint_t pint_t;
	251	typename A::P::uint_t ptr; // uint32_t *
	252
	253	uint32_t& offset(SharedCache<A> cache) const { return (uint32_t *)cache->mappedAddressForVMAddress(A::P::getP(ptr)); }
	254
	255	public:
	256	bool hasOffset() const { return A::P::getP(ptr) != 0; }
	257	pint_t getOffset(SharedCache<A> *cache) const { return A::P::E::get32(offset(cache)); }
	258	void setOffset(SharedCache<A> *cache, pint_t newOffset) { A::P::E::set32(offset(cache), newOffset); }
	259	};
	260
	261	template <>
	262	class objc_ivar_offset_t<x86_64> {
	263	typedef x86_64 A;
	264	typedef typename A::P::uint_t pint_t;
	265	typename A::P::uint_t ptr; // uint64_t *
	266
	267	uint64_t& offset(SharedCache<A> cache) const { return (uint64_t *)cache->mappedAddressForVMAddress(A::P::getP(ptr)); }
	268
	269	public:
	270	bool hasOffset() const { return A::P::getP(ptr) != 0; }
	271	pint_t getOffset(SharedCache<A> *cache) const { return A::P::E::get64(offset(cache)); }
	272	void setOffset(SharedCache<A> *cache, pint_t newOffset) { A::P::E::set64(offset(cache), newOffset); }
	273	};
	274
	275	template <typename A>
	276	class objc_ivar_t {
	277	typedef typename A::P::uint_t pint_t;
	278	objc_ivar_offset_t<A> offset; // uint32_t * (uint64_t * on x86_64)
	279	typename A::P::uint_t name; // const char *
	280	typename A::P::uint_t type; // const char *
	281	uint32_t alignment;
	282	uint32_t size;
	283
	284	public:
	285	const char * getName(SharedCache<A> cache) const { return (const char )cache->mappedAddressForVMAddress(A::P::getP(name)); }
	286
	287	bool hasOffset() const { return offset.hasOffset(); }
	288	pint_t getOffset(SharedCache<A> *cache) const { return offset.getOffset(cache); }
	289	void setOffset(SharedCache<A> *cache, pint_t newOffset) { offset.setOffset(cache, newOffset); }
	290
	291	uint32_t getAlignment()
	292	{
	293	uint32_t a = A::P::E::get32(alignment);
	294	return a == (uint32_t)-1 ? sizeof(typename A::P::uint_t) : 1<<a;
	295	}
	296	};
	297
	298	template <typename A>
	299	class objc_ivar_list_t {
	300	typedef typename A::P::uint_t pint_t;
	301	uint32_t entsize;
	302	uint32_t count;
	303	objc_ivar_t<A> first;
	304
	305	void* operator new (size_t, void* buf) { return buf; }
	306
	307	public:
	308
	309	typedef entsize_iterator< A, objc_ivar_t<A>, objc_ivar_list_t<A> > ivar_iterator;
	310
	311	uint32_t getCount() const { return A::P::E::get32(count); }
	312
	313	uint32_t getEntsize() const { return A::P::E::get32(entsize); }
	314
	315	objc_ivar_t<A>& get(pint_t i) const { return (objc_ivar_t<A> )((uint8_t )&first + i A::P::E::get32(entsize)); }
	316
	317	uint32_t byteSize() const {
	318	return byteSizeForCount(getCount(), getEntsize());
	319	}
	320
	321	static uint32_t byteSizeForCount(uint32_t c, uint32_t e = sizeof(objc_ivar_t<A>)) {
	322	return sizeof(objc_ivar_list_t<A>) - sizeof(objc_ivar_t<A>) + c*e;
	323	}
	324
	325	ivar_iterator begin() { return ivar_iterator(*this, 0); }
	326	ivar_iterator end() { return ivar_iterator(*this, getCount()); }
	327	const ivar_iterator begin() const { return ivar_iterator(*this, 0); }
	328	const ivar_iterator end() const { return ivar_iterator(*this, getCount()); }
	329
	330	static objc_ivar_list_t<A>* newIvarList(size_t newCount, uint32_t newEntsize) {
	331	void *buf = ::calloc(byteSizeForCount(newCount, newEntsize), 1);
	332	return new (buf) objc_ivar_list_t<A>(newCount, newEntsize);
	333	}
	334
	335	void operator delete(void * p) {
	336	::free(p);
	337	}
	338
	339	objc_ivar_list_t(uint32_t newCount,
	340	uint32_t newEntsize = sizeof(objc_ivar_t<A>))
	341	: entsize(newEntsize), count(newCount)
	342	{ }
	343	private:
	344	// use newIvarList instead
	345	void* operator new (size_t);
	346	};
	347
	348
	349	template <typename A> class objc_property_list_t; // forward
	350
	351	template <typename A>
	352	class objc_property_t {
	353	typename A::P::uint_t name;
	354	typename A::P::uint_t attributes;
	355	friend class objc_property_list_t<A>;
	356	public:
	357
	358	const char * getName(SharedCache<A>* cache) const { return (const char *)cache->mappedAddressForVMAddress(A::P::getP(name)); }
	359
	360	const char * getAttributes(SharedCache<A>* cache) const { return (const char *)cache->mappedAddressForVMAddress(A::P::getP(attributes)); }
	361	};
	362
	363	template <typename A>
	364	class objc_property_list_t {
	365	uint32_t entsize;
	366	uint32_t count;
	367	objc_property_t<A> first;
	368
	369	void* operator new (size_t, void* buf) { return buf; }
	370
	371	public:
	372
	373	typedef entsize_iterator< A, objc_property_t<A>, objc_property_list_t<A> > property_iterator;
	374
	375	uint32_t getCount() const { return A::P::E::get32(count); }
	376
	377	uint32_t getEntsize() const { return A::P::E::get32(entsize); }
	378
	379	objc_property_t<A>& get(uint32_t i) const { return (objc_property_t<A> )((uint8_t )&first + i getEntsize()); }
	380
	381	uint32_t byteSize() const {
	382	return byteSizeForCount(getCount(), getEntsize());
	383	}
	384
	385	static uint32_t byteSizeForCount(uint32_t c, uint32_t e = sizeof(objc_property_t<A>)) {
	386	return sizeof(objc_property_list_t<A>) - sizeof(objc_property_t<A>) + c*e;
	387	}
	388
	389	property_iterator begin() { return property_iterator(*this, 0); }
	390	property_iterator end() { return property_iterator(*this, getCount()); }
	391	const property_iterator begin() const { return property_iterator(*this, 0); }
	392	const property_iterator end() const { return property_iterator(*this, getCount()); }
	393
	394	void getPointers(std::set<void*>& pointersToRemove) {
	395	for(property_iterator it = begin(); it != end(); ++it) {
	396	objc_property_t<A>& entry = *it;
	397	pointersToRemove.insert(&(entry.name));
	398	pointersToRemove.insert(&(entry.attributes));
	399	}
	400	}
	401
	402	static void addPointers(uint8_t* propertyList, std::vector<void*>& pointersToAdd) {
	403	objc_property_list_t<A>* plist = (objc_property_list_t<A>*)propertyList;
	404	for(property_iterator it = plist->begin(); it != plist->end(); ++it) {
	405	objc_property_t<A>& entry = *it;
	406	pointersToAdd.push_back(&(entry.name));
	407	pointersToAdd.push_back(&(entry.attributes));
	408	}
	409	}
	410
	411	static objc_property_list_t<A>* newPropertyList(size_t newCount, uint32_t newEntsize) {
	412	void *buf = ::calloc(byteSizeForCount(newCount, newEntsize), 1);
	413	return new (buf) objc_property_list_t<A>(newCount, newEntsize);
	414	}
	415
	416	void operator delete(void * p) {
	417	::free(p);
	418	}
	419
	420	objc_property_list_t(uint32_t newCount,
	421	uint32_t newEntsize = sizeof(objc_property_t<A>))
	422	: entsize(newEntsize), count(newCount)
	423	{ }
	424	private:
	425	// use newPropertyList instead
	426	void* operator new (size_t);
	427	};
	428
	429	template <typename A>
	430	class objc_protocol_t {
	431	typename A::P::uint_t isa;
	432	typename A::P::uint_t name;
	433	typename A::P::uint_t protocols;
	434	typename A::P::uint_t instanceMethods;
	435	typename A::P::uint_t classMethods;
	436	typename A::P::uint_t optionalInstanceMethods;
	437	typename A::P::uint_t optionalClassMethods;
	438	typename A::P::uint_t instanceProperties;
	439
	440	public:
	441	objc_method_list_t<A> getInstanceMethods(SharedCache<A> cache) const { return (objc_method_list_t<A> *)cache->mappedAddressForVMAddress(A::P::getP(instanceMethods)); }
	442
	443	objc_method_list_t<A> getClassMethods(SharedCache<A> cache) const { return (objc_method_list_t<A> *)cache->mappedAddressForVMAddress(A::P::getP(classMethods)); }
	444
	445	objc_method_list_t<A> getOptionalInstanceMethods(SharedCache<A> cache) const { return (objc_method_list_t<A> *)cache->mappedAddressForVMAddress(A::P::getP(optionalInstanceMethods)); }
	446
	447	objc_method_list_t<A> getOptionalClassMethods(SharedCache<A> cache) const { return (objc_method_list_t<A> *)cache->mappedAddressForVMAddress(A::P::getP(optionalClassMethods)); }
	448
	449	};
	450
	451	template <typename A>
	452	class objc_protocol_list_t {
	453	typedef typename A::P::uint_t pint_t;
	454	pint_t count;
	455	pint_t list[0];
	456
	457	void* operator new (size_t, void* buf) { return buf; }
	458
	459	public:
	460
	461	pint_t getCount() const { return A::P::getP(count); }
	462
	463	objc_protocol_t<A>* get(SharedCache<A>* cache, pint_t i) {
	464	return (objc_protocol_t<A>*)cache->mappedAddressForVMAddress(A::P::getP(list[i]));
	465	}
	466
	467	void overwrite(pint_t& index, const objc_protocol_list_t<A>* src) {
	468	pint_t srcCount = src->getCount();
	469	memcpy(list+index, src->list, srcCount * sizeof(pint_t));
	470	index += srcCount;
	471	}
	472
	473	uint32_t byteSize() const {
	474	return byteSizeForCount(getCount());
	475	}
	476	static uint32_t byteSizeForCount(pint_t c) {
	477	return sizeof(objc_protocol_list_t<A>) + c*sizeof(pint_t);
	478	}
	479
	480	void getPointers(std::set<void*>& pointersToRemove) {
	481	for(int i=0 ; i < count; ++i) {
	482	pointersToRemove.insert(&list[i]);
	483	}
	484	}
	485
	486	static void addPointers(uint8_t* protocolList, std::vector<void*>& pointersToAdd) {
	487	objc_protocol_list_t<A>* plist = (objc_protocol_list_t<A>*)protocolList;
	488	for(int i=0 ; i < plist->count; ++i) {
	489	pointersToAdd.push_back(&plist->list[i]);
	490	}
	491	}
	492
	493	static objc_protocol_list_t<A>* newProtocolList(pint_t newCount) {
	494	void *buf = ::calloc(byteSizeForCount(newCount), 1);
	495	return new (buf) objc_protocol_list_t<A>(newCount);
	496	}
	497
	498	void operator delete(void * p) {
	499	::free(p);
	500	}
	501
	502	objc_protocol_list_t(uint32_t newCount) : count(newCount) { }
	503	private:
	504	// use newProtocolList instead
	505	void* operator new (size_t);
	506	};
	507
	508
	509	template <typename A>
	510	class objc_class_data_t {
	511	uint32_t flags;
	512	uint32_t instanceStart;
	513	// Note there is 4-bytes of alignment padding between instanceSize and ivarLayout
	514	// on 64-bit archs, but no padding on 32-bit archs.
	515	// This union is a way to model that.
	516	union {
	517	uint32_t instanceSize;
	518	typename A::P::uint_t pad;
	519	} instanceSize;
	520	typename A::P::uint_t ivarLayout;
	521	typename A::P::uint_t name;
	522	typename A::P::uint_t baseMethods;
	523	typename A::P::uint_t baseProtocols;
	524	typename A::P::uint_t ivars;
	525	typename A::P::uint_t weakIvarLayout;
	526	typename A::P::uint_t baseProperties;
	527
	528	public:
	529	bool isMetaClass() { return A::P::E::get32(flags) & 1; }
	530
	531	uint32_t getInstanceStart() { return A::P::E::get32(instanceStart); }
	532	void setInstanceStart(uint32_t newStart) { A::P::E::set32(instanceStart, newStart); }
	533
	534	uint32_t getInstanceSize() { return A::P::E::get32(instanceSize.instanceSize); }
	535	void setInstanceSize(uint32_t newSiz) { A::P::E::set32(instanceSize.instanceSize, newSiz); }
	536
	537	objc_method_list_t<A> getMethodList(SharedCache<A> cache) const { return (objc_method_list_t<A> *)cache->mappedAddressForVMAddress(A::P::getP(baseMethods)); }
	538
	539	objc_protocol_list_t<A> getProtocolList(SharedCache<A> cache) const { return (objc_protocol_list_t<A> *)cache->mappedAddressForVMAddress(A::P::getP(baseProtocols)); }
	540
	541	objc_ivar_list_t<A> getIvarList(SharedCache<A> cache) const { return (objc_ivar_list_t<A> *)cache->mappedAddressForVMAddress(A::P::getP(ivars)); }
	542
	543	objc_property_list_t<A> getPropertyList(SharedCache<A> cache) const { return (objc_property_list_t<A> *)cache->mappedAddressForVMAddress(A::P::getP(baseProperties)); }
	544
	545	const char * getName(SharedCache<A>* cache) const { return (const char *)cache->mappedAddressForVMAddress(A::P::getP(name)); }
	546
	547	void setMethodList(SharedCache<A>* cache, objc_method_list_t<A>* mlist) {
	548	A::P::setP(baseMethods, cache->VMAddressForMappedAddress(mlist));
	549	}
	550
	551	void setProtocolList(SharedCache<A>* cache, objc_protocol_list_t<A>* protolist) {
	552	A::P::setP(baseProtocols, cache->VMAddressForMappedAddress(protolist));
	553	}
	554
	555	void setPropertyList(SharedCache<A>* cache, objc_property_list_t<A>* proplist) {
	556	A::P::setP(baseProperties, cache->VMAddressForMappedAddress(proplist));
	557	}
	558
	559	void addMethodListPointer(std::vector<void*>& pointersToAdd) {
	560	pointersToAdd.push_back(&this->baseMethods);
	561	}
	562
	563	void addPropertyListPointer(std::vector<void*>& pointersToAdd) {
	564	pointersToAdd.push_back(&this->baseProperties);
	565	}
	566
	567	void addProtocolListPointer(std::vector<void*>& pointersToAdd) {
	568	pointersToAdd.push_back(&this->baseProtocols);
	569	}
	570	};
	571
	572	template <typename A>
	573	class objc_class_t {
	574	typename A::P::uint_t isa;
	575	typename A::P::uint_t superclass;
	576	typename A::P::uint_t method_cache;
	577	typename A::P::uint_t vtable;
	578	typename A::P::uint_t data;
	579
	580	public:
	581	bool isMetaClass(SharedCache<A>* cache) const { return getData(cache)->isMetaClass(); }
	582
	583	objc_class_t<A> getIsa(SharedCache<A> cache) const { return (objc_class_t<A> *)cache->mappedAddressForVMAddress(A::P::getP(isa)); }
	584
	585	objc_class_t<A> getSuperclass(SharedCache<A> cache) const { return (objc_class_t<A> *)cache->mappedAddressForVMAddress(A::P::getP(superclass)); }
	586
	587	objc_class_data_t<A> getData(SharedCache<A> cache) const { return (objc_class_data_t<A> *)cache->mappedAddressForVMAddress(A::P::getP(data)); }
	588
	589	objc_method_list_t<A> getMethodList(SharedCache<A> cache) const { return getData(cache)->getMethodList(cache); }
	590
	591	objc_protocol_list_t<A> getProtocolList(SharedCache<A> cache) const { return getData(cache)->getProtocolList(cache); }
	592
	593	objc_property_list_t<A> getPropertyList(SharedCache<A> cache) const { return getData(cache)->getPropertyList(cache); }
	594
	595	const char * getName(SharedCache<A>* cache) const {
	596	return getData(cache)->getName(cache);
	597	}
	598
	599	void setMethodList(SharedCache<A>* cache, objc_method_list_t<A>* mlist) {
	600	getData(cache)->setMethodList(cache, mlist);
	601	}
	602
	603	void setProtocolList(SharedCache<A>* cache, objc_protocol_list_t<A>* protolist) {
	604	getData(cache)->setProtocolList(cache, protolist);
	605	}
	606
	607	void setPropertyList(SharedCache<A>* cache, objc_property_list_t<A>* proplist) {
	608	getData(cache)->setPropertyList(cache, proplist);
	609	}
	610
	611	void addMethodListPointer(SharedCache<A>* cache, std::vector<void*>& pointersToAdd) {
	612	getData(cache)->addMethodListPointer(pointersToAdd);
	613	}
	614
	615	void addPropertyListPointer(SharedCache<A>* cache, std::vector<void*>& pointersToAdd) {
	616	getData(cache)->addPropertyListPointer(pointersToAdd);
	617	}
	618
	619	void addProtocolListPointer(SharedCache<A>* cache, std::vector<void*>& pointersToAdd) {
	620	getData(cache)->addProtocolListPointer(pointersToAdd);
	621	}
	622
	623	};
	624
	625
	626
	627	template <typename A>
	628	class objc_category_t {
	629	typename A::P::uint_t name;
	630	typename A::P::uint_t cls;
	631	typename A::P::uint_t instanceMethods;
	632	typename A::P::uint_t classMethods;
	633	typename A::P::uint_t protocols;
	634	typename A::P::uint_t instanceProperties;
	635
	636	public:
	637
	638	const char * getName(SharedCache<A> cache) const { return (const char )cache->mappedAddressForVMAddress(A::P::getP(name)); }
	639
	640	objc_class_t<A> getClass(SharedCache<A> cache) const { return (objc_class_t<A> *)cache->mappedAddressForVMAddress(A::P::getP(cls)); }
	641
	642	objc_method_list_t<A> getInstanceMethods(SharedCache<A> cache) const { return (objc_method_list_t<A> *)cache->mappedAddressForVMAddress(A::P::getP(instanceMethods)); }
	643
	644	objc_method_list_t<A> getClassMethods(SharedCache<A> cache) const { return (objc_method_list_t<A> *)cache->mappedAddressForVMAddress(A::P::getP(classMethods)); }
	645
	646	objc_protocol_list_t<A> getProtocols(SharedCache<A> cache) const { return (objc_protocol_list_t<A> *)cache->mappedAddressForVMAddress(A::P::getP(protocols)); }
	647
	648	objc_property_list_t<A> getInstanceProperties(SharedCache<A> cache) const { return (objc_property_list_t<A> *)cache->mappedAddressForVMAddress(A::P::getP(instanceProperties)); }
	649
	650	void getPointers(std::set<void*>& pointersToRemove) {
	651	pointersToRemove.insert(&name);
	652	pointersToRemove.insert(&cls);
	653	pointersToRemove.insert(&instanceMethods);
	654	pointersToRemove.insert(&classMethods);
	655	pointersToRemove.insert(&protocols);
	656	pointersToRemove.insert(&instanceProperties);
	657	}
	658
	659
	660	};
	661
	662	template <typename A>
	663	class objc_message_ref_t {
	664	typename A::P::uint_t imp;
	665	typename A::P::uint_t sel;
	666
	667	public:
	668	typename A::P::uint_t getName() const { return A::P::getP(sel); }
	669
	670	void setName(typename A::P::uint_t newName) { A::P::setP(sel, newName); }
	671	};
	672
	673	// Call visitor.visitIvar() on every ivar in a given class.
	674	template <typename A, typename V>
	675	class IvarWalker {
	676	typedef typename A::P P;
	677	typedef typename A::P::uint_t pint_t;
	678	V& ivarVisitor;
	679	public:
	680
	681	IvarWalker(V& visitor) : ivarVisitor(visitor) { }
	682
	683	void walk(SharedCache<A>* cache, const macho_header<P>* header, objc_class_t<A> *cls)
	684	{
	685	objc_class_data_t<A> *data = cls->getData(cache);
	686	objc_ivar_list_t<A> *ivars = data->getIvarList(cache);
	687	if (ivars) {
	688	for (pint_t i = 0; i < ivars->getCount(); i++) {
	689	objc_ivar_t<A>& ivar = ivars->get(i);
	690	//fprintf(stderr, "visiting ivar: %s\n", ivar.getName(cache));
	691	ivarVisitor.visitIvar(cache, header, cls, &ivar);
	692	}
	693	} else {
	694	//fprintf(stderr, "no ivars\n");
	695	}
	696	}
	697
	698	void visitClass(SharedCache<A>* cache, const macho_header<P>* header, objc_class_t<A> *cls)
	699	{
	700	walk(cache, header, cls);
	701	}
	702	};
	703
	704	// Call visitor.visitClass() on every class.
	705	template <typename A, typename V>
	706	class ClassWalker {
	707	typedef typename A::P P;
	708	typedef typename A::P::uint_t pint_t;
	709	V& classVisitor;
	710	public:
	711
	712	ClassWalker(V& visitor) : classVisitor(visitor) { }
	713
	714	void walk(SharedCache<A>* cache, const macho_header<P>* header)
	715	{
	716	PointerSection<A, objc_class_t<A> *>
	717	classes(cache, header, "__DATA", "__objc_classlist");
	718
	719	for (pint_t i = 0; i < classes.count(); i++) {
	720	objc_class_t<A> *cls = classes.get(i);
	721	//fprintf(stderr, "visiting class: %s\n", cls->getName(cache));
	722	classVisitor.visitClass(cache, header, cls);
	723	}
	724	}
	725	};
	726
	727
	728	// Call visitor.visitMethodList(mlist) on every method list in a header.
	729	template <typename A, typename V>
	730	class MethodListWalker {
	731
	732	typedef typename A::P P;
	733	typedef typename A::P::uint_t pint_t;
	734
	735	V& mVisitor;
	736
	737	public:
	738
	739	MethodListWalker(V& visitor) : mVisitor(visitor) { }
	740
	741	void walk(SharedCache<A>* cache, const macho_header<P>* header, bool walkProtocols)
	742	{
	743	// Method lists in classes
	744	PointerSection<A, objc_class_t<A> *>
	745	classes(cache, header, "__DATA", "__objc_classlist");
	746
	747	for (pint_t i = 0; i < classes.count(); i++) {
	748	objc_class_t<A> *cls = classes.get(i);
	749	objc_method_list_t<A> *mlist;
	750	if ((mlist = cls->getMethodList(cache))) {
	751	mVisitor.visitMethodList(mlist);
	752	}
	753	if ((mlist = cls->getIsa(cache)->getMethodList(cache))) {
	754	mVisitor.visitMethodList(mlist);
	755	}
	756	}
	757
	758	// Method lists from categories
	759	PointerSection<A, objc_category_t<A> *>
	760	cats(cache, header, "__DATA", "__objc_catlist");
	761	for (pint_t i = 0; i < cats.count(); i++) {
	762	objc_category_t<A> *cat = cats.get(i);
	763	objc_method_list_t<A> *mlist;
	764	if ((mlist = cat->getInstanceMethods(cache))) {
	765	mVisitor.visitMethodList(mlist);
	766	}
	767	if ((mlist = cat->getClassMethods(cache))) {
	768	mVisitor.visitMethodList(mlist);
	769	}
	770	}
	771
	772	// Method description lists from protocols
	773	if ( walkProtocols ) {
	774	PointerSection<A, objc_protocol_t<A> *>
	775	protocols(cache, header, "__DATA", "__objc_protolist");
	776	for (pint_t i = 0; i < protocols.count(); i++) {
	777	objc_protocol_t<A> *proto = protocols.get(i);
	778	objc_method_list_t<A> *mlist;
	779	if ((mlist = proto->getInstanceMethods(cache))) {
	780	mVisitor.visitMethodList(mlist);
	781	}
	782	if ((mlist = proto->getClassMethods(cache))) {
	783	mVisitor.visitMethodList(mlist);
	784	}
	785	if ((mlist = proto->getOptionalInstanceMethods(cache))) {
	786	mVisitor.visitMethodList(mlist);
	787	}
	788	if ((mlist = proto->getOptionalClassMethods(cache))) {
	789	mVisitor.visitMethodList(mlist);
	790	}
	791	}
	792	}
	793	}
	794	};
	795
	796
	797	// Update selector references. The visitor performs recording and uniquing.
	798	template <typename A, typename V>
	799	class SelectorOptimizer {
	800
	801	typedef typename A::P P;
	802	typedef typename A::P::uint_t pint_t;
	803
	804	V& mVisitor;
	805
	806	friend class MethodListWalker< A, SelectorOptimizer<A,V> >;
	807	void visitMethodList(objc_method_list_t<A> *mlist)
	808	{
	809	// Gather selectors. Update method names.
	810	for (pint_t m = 0; m < mlist->getCount(); m++) {
	811	pint_t oldValue = mlist->get(m).getName();
	812	pint_t newValue = mVisitor.visit(oldValue);
	813	mlist->get(m).setName(newValue);
	814	}
	815	// Do not setFixedUp: the methods are not yet sorted.
	816	}
	817
	818	public:
	819
	820	SelectorOptimizer(V& visitor) : mVisitor(visitor) { }
	821
	822	void optimize(SharedCache<A>* cache, const macho_header<P>* header)
	823	{
	824	// method lists of all kinds
	825	MethodListWalker< A, SelectorOptimizer<A,V> > mw(*this);
	826	mw.walk(cache, header, true);
	827
	828	// @selector references
	829	PointerSection<A, const char *>
	830	selrefs(cache, header, "__DATA", "__objc_selrefs");
	831	for (pint_t i = 0; i < selrefs.count(); i++) {
	832	pint_t oldValue = selrefs.getUnmapped(i);
	833	pint_t newValue = mVisitor.visit(oldValue);
	834	selrefs.set(i, newValue);
	835	}
	836
	837	// message references
	838	ArraySection<A, objc_message_ref_t<A> >
	839	msgrefs(cache, header, "__DATA", "__objc_msgrefs");
	840	for (pint_t i = 0; i < msgrefs.count(); i++) {
	841	objc_message_ref_t<A>& msg = msgrefs.get(i);
	842	pint_t oldValue = msg.getName();
	843	pint_t newValue = mVisitor.visit(oldValue);
	844	msg.setName(newValue);
	845	}
	846	}
	847	};
	848
	849
	850	// Update selector references. The visitor performs recording and uniquing.
	851	template <typename A>
	852	class IvarOffsetOptimizer {
	853	typedef typename A::P P;
	854
	855	uint32_t slide;
	856	uint32_t maxAlignment;
	857
	858	uint32_t fOptimized;
	859
	860	public:
	861
	862	IvarOffsetOptimizer() : fOptimized(0) { }
	863
	864	size_t optimized() const { return fOptimized; }
	865
	866	// dual purpose ivar visitor function
	867	// if slide!=0 then slides the ivar by that amount, otherwise computes maxAlignment
	868	void visitIvar(SharedCache<A>* cache, const macho_header<P>* /unused, may be NULL/, objc_class_t<A> cls, objc_ivar_t<A> ivar)
	869	{
	870	if (slide == 0) {
	871	uint32_t alignment = ivar->getAlignment();
	872	if (alignment > maxAlignment) maxAlignment = alignment;
	873	} else {
	874	// skip anonymous bitfields
	875	if (ivar->hasOffset()) {
	876	uint32_t oldOffset = (uint32_t)ivar->getOffset(cache);
	877	ivar->setOffset(cache, oldOffset + slide);
	878	fOptimized++;
	879	//fprintf(stderr, "%d -> %d for %s.%s\n", oldOffset, oldOffset + slide, cls->getName(cache), ivar->getName(cache));
	880	} else {
	881	//fprintf(stderr, "NULL offset\n");
	882	}
	883	}
	884	}
	885
	886	// Class visitor function. Evaluates whether to slide ivars and performs slide if needed.
	887	// The slide algorithm is also implemented in objc. Any changes here should be reflected there also.
	888	void visitClass(SharedCache<A>* cache, const macho_header<P>* /unused, may be NULL/, objc_class_t<A> *cls)
	889	{
	890	objc_class_t<A> *super = cls->getSuperclass(cache);
	891	if (super) {
	892	// Recursively visit superclasses to ensure we have the correct superclass start
	893	// Note that we don't need the macho_header, so just pass NULL.
	894	visitClass(cache, NULL, super);
	895
	896	objc_class_data_t<A> *data = cls->getData(cache);
	897	objc_class_data_t<A> *super_data = super->getData(cache);
	898	int32_t diff = super_data->getInstanceSize() - data->getInstanceStart();
	899	if (diff > 0) {
	900	IvarWalker<A, IvarOffsetOptimizer<A> > ivarVisitor(*this);
	901	maxAlignment = 0;
	902	slide = 0;
	903
	904	// This walk computes maxAlignment
	905	ivarVisitor.walk(cache, NULL, cls);
	906
	907	// Compute a slide value that preserves that alignment
	908	uint32_t alignMask = maxAlignment - 1;
	909	if (diff & alignMask) diff = (diff + alignMask) & ~alignMask;
	910
	911	// Slide all of this class's ivars en masse
	912	slide = diff;
	913	if (slide != 0) {
	914	//fprintf(stderr, "Sliding ivars in %s by %u (superclass was %d, now %d)\n", cls->getName(cache), slide, data->getInstanceStart(), super_data->getInstanceSize());
	915	ivarVisitor.walk(cache, NULL, cls);
	916	data->setInstanceStart(data->getInstanceStart() + slide);
	917	data->setInstanceSize(data->getInstanceSize() + slide);
	918	}
	919	}
	920	}
	921	}
	922
	923	// Enumerates objc classes in the module and performs any ivar slides
	924	void optimize(SharedCache<A>* cache, const macho_header<P>* header)
	925	{
	926	// The slide code cannot fix up GC layout strings so skip modules that support ore require GC
	927	const macho_section<P> *imageInfoSection = header->getSection("__DATA", "__objc_imageinfo");
	928	if (imageInfoSection) {
	929	objc_image_info<A> info = (objc_image_info<A> )cache->mappedAddressForVMAddress(imageInfoSection->addr());
	930	if (!info->supportsGCFlagSet() && !info->requiresGCFlagSet()) {
	931	ClassWalker<A, IvarOffsetOptimizer<A> > classVisitor(*this);
	932	classVisitor.walk(cache, header);
	933	} else {
	934	//fprintf(stderr, "GC support present - skipped module\n");
	935	}
	936	}
	937	}
	938	};
	939
	940
	941	// Sort methods in place by selector.
	942	template <typename A>
	943	class MethodListSorter {
	944
	945	typedef typename A::P P;
	946	typedef typename A::P::uint_t pint_t;
	947
	948	uint32_t fOptimized;
	949
	950	friend class MethodListWalker<A, MethodListSorter<A> >;
	951	void visitMethodList(objc_method_list_t<A> *mlist)
	952	{
	953	typename objc_method_t<A>::SortBySELAddress sorter;
	954	std::stable_sort(mlist->begin(), mlist->end(), sorter);
	955	mlist->setFixedUp();
	956	fOptimized++;
	957	}
	958
	959	public:
	960	MethodListSorter() : fOptimized(0) { }
	961
	962	size_t optimized() const { return fOptimized; }
	963
	964	void optimize(SharedCache<A>* cache, macho_header<P>* header)
	965	{
	966	MethodListWalker<A, MethodListSorter<A> > mw(*this);
	967	mw.walk(cache, header, false /* don't sort protocol method lists*/);
	968	}
	969	};
	970
	971
	972	template <typename A>
	973	class HeaderInfoOptimizer {
	974
	975	typedef typename A::P P;
	976	typedef typename A::P::uint_t pint_t;
	977
	978	objc_header_info_t<A>* fHinfos;
	979	size_t fCount;
	980
	981	public:
	982	HeaderInfoOptimizer() : fHinfos(0), fCount(0) { }
	983
	984	const char init(size_t count, uint8_t& buf, size_t& bufSize)
	985	{
	986	if (count == 0) return NULL;
	987
	988	if (bufSize < 2sizeof(uint32_t) + countsizeof(objc_header_info_t<A>)) {
	989	return "libobjc's read/write section is too small (metadata not optimized)";
	990	}
	991
	992	uint32_t buf32 = (uint32_t )buf;
	993	A::P::E::set32(buf32[0], count);
	994	A::P::E::set32(buf32[1], sizeof(objc_header_info_t<A>));
	995	fHinfos = (objc_header_info_t<A>*)(buf32+2);
	996
	997	size_t total = sizeof(uint32_t) + count*sizeof(objc_header_info_t<A>);
	998	buf += total;
	999	bufSize -= total;
	1000
	1001	return NULL;
	1002	}
	1003
	1004	void update(SharedCache<A>* cache, const macho_header<P>* mh, std::vector<void*>& pointersInData)
	1005	{
	1006	objc_header_info_t<A>* hi = new(&fHinfos[fCount++]) objc_header_info_t<A>(cache, mh);
	1007	hi->addPointers(pointersInData);
	1008	}
	1009
	1010	objc_header_info_t<A>* hinfoForHeader(SharedCache<A>* cache, const macho_header<P>* mh)
	1011	{
	1012	// fixme could be binary search
	1013	pint_t mh_vmaddr = cache->VMAddressForMappedAddress(mh);
	1014	for (size_t i = 0; i < fCount; i++) {
	1015	objc_header_info_t<A>* hi = &fHinfos[i];
	1016	if (hi->header_vmaddr() == mh_vmaddr) return hi;
	1017	}
	1018	return NULL;
	1019	}
	1020	};