[apple/ld64.git] / src / ld / passes / stubs / stub_x86.hpp

/* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
 *
 * Copyright (c) 2009-2010 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */


// already in ld::passes::stubs namespace
namespace x86 {


class FastBindingPointerAtom : public ld::Atom {
public:
											FastBindingPointerAtom(ld::passes::stubs::Pass& pass)
				: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
							ld::Atom::scopeLinkageUnit, ld::Atom::typeNonLazyPointer, 
							symbolTableNotIn, false, false, false, ld::Atom::Alignment(2)), 
				_fixup(0, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, 
								pass.internal()->compressedFastBinderProxy)
					{ pass.addAtom(*this); }

	virtual const ld::File*					file() const					{ return NULL; }
	virtual const char*						name() const					{ return "fast binder pointer"; }
	virtual uint64_t						size() const					{ return 4; }
	virtual uint64_t						objectAddress() const			{ return 0; }
	virtual void							copyRawContent(uint8_t buffer[]) const { }
	virtual void							setScope(Scope)					{ }
	virtual ld::Fixup::iterator				fixupsBegin() const				{ return &_fixup; }
	virtual ld::Fixup::iterator				fixupsEnd()	const 				{ return &((ld::Fixup*)&_fixup)[1]; }

private:
	mutable ld::Fixup						_fixup;
	
	static ld::Section						_s_section;
};

ld::Section FastBindingPointerAtom::_s_section("__DATA", "__nl_symbol_ptr", ld::Section::typeNonLazyPointer);


class ImageCachePointerAtom : public ld::Atom {
public:
											ImageCachePointerAtom(ld::passes::stubs::Pass& pass)
				: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
							ld::Atom::scopeLinkageUnit, ld::Atom::typeNonLazyPointer, 
							symbolTableNotIn, false, false, false, ld::Atom::Alignment(2)) { pass.addAtom(*this); }

	virtual const ld::File*					file() const					{ return NULL; }
	virtual const char*						name() const					{ return "image cache pointer"; }
	virtual uint64_t						size() const					{ return 4; }
	virtual uint64_t						objectAddress() const			{ return 0; }
	virtual void							copyRawContent(uint8_t buffer[]) const { }
	virtual void							setScope(Scope)					{ }

private:
	
	static ld::Section						_s_section;
};

ld::Section ImageCachePointerAtom::_s_section("__DATA", "__nl_symbol_ptr", ld::Section::typeNonLazyPointer);


//
//  The stub-helper-helper is the common code factored out of each helper function.
//  It is in the same section as the stub-helpers.  
//  Similar to the PLT0 entry in ELF. 
//
class StubHelperHelperAtom : public ld::Atom {
public:
											StubHelperHelperAtom(ld::passes::stubs::Pass& pass)
				: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
							ld::Atom::scopeLinkageUnit, ld::Atom::typeStubHelper, 
							symbolTableNotIn, false, false, false, ld::Atom::Alignment(2)), 
				_fixup1(1,  ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, compressedImageCache(pass)),
				_fixup2(7, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, compressedFastBinder(pass)) 
					{ pass.addAtom(*this); }

	virtual ld::File*						file() const					{ return NULL; }
	virtual const char*						name() const					{ return "helper helper"; }
	virtual uint64_t						size() const					{ return 12; }
	virtual uint64_t						objectAddress() const			{ return 0; }
	virtual void							copyRawContent(uint8_t buffer[]) const {
			buffer[0]  = 0x68;		// pushl $dyld_ImageLoaderCache
			buffer[1]  = 0x00;
			buffer[2]  = 0x00;
			buffer[3]  = 0x00;
			buffer[4]  = 0x00;
			buffer[5]  = 0xFF;		// jmp *_fast_lazy_bind
			buffer[6]  = 0x25;
			buffer[7]  = 0x00;
			buffer[8]  = 0x00;
			buffer[9]  = 0x00;
			buffer[10] = 0x00;
			buffer[11] = 0x90;		// nop
	}
	virtual void							setScope(Scope)					{ }
	virtual ld::Fixup::iterator				fixupsBegin() const				{ return &_fixup1; }
	virtual ld::Fixup::iterator				fixupsEnd()	const				{ return &((ld::Fixup*)&_fixup2)[1]; }

private:
	static ld::Atom* compressedImageCache(ld::passes::stubs::Pass& pass) {
		if ( pass.compressedImageCache == NULL ) 
			pass.compressedImageCache = new ImageCachePointerAtom(pass);
		return pass.compressedImageCache;		
	}
	static ld::Atom* compressedFastBinder(ld::passes::stubs::Pass& pass) {
		if ( pass.compressedFastBinderPointer == NULL ) 
			pass.compressedFastBinderPointer = new FastBindingPointerAtom(pass);
		return pass.compressedFastBinderPointer;		
	}
	
	mutable ld::Fixup						_fixup1;
	ld::Fixup								_fixup2;
	
	static ld::Section						_s_section;
};

ld::Section StubHelperHelperAtom::_s_section("__TEXT", "__stub_helper", ld::Section::typeStubHelper);


class StubHelperAtom : public ld::Atom {
public:
											StubHelperAtom(ld::passes::stubs::Pass& pass, const ld::Atom* lazyPointer,
																							const ld::Atom& stubTo)
				: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
							ld::Atom::scopeLinkageUnit, ld::Atom::typeStubHelper, 
							symbolTableNotIn, false, false, false, ld::Atom::Alignment(1)), 
				_stubTo(stubTo),
				_fixup1(1, ld::Fixup::k1of2, ld::Fixup::kindSetLazyOffset, lazyPointer),
				_fixup2(1, ld::Fixup::k2of2, ld::Fixup::kindStoreLittleEndian32),
				_fixup3(6, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86BranchPCRel32, helperHelper(pass)) { }
				
	virtual const ld::File*					file() const					{ return _stubTo.file(); }
	virtual const char*						name() const					{ return _stubTo.name(); }
	virtual uint64_t						size() const					{ return 10; }
	virtual uint64_t						objectAddress() const			{ return 0; }
	virtual void							copyRawContent(uint8_t buffer[]) const {
			buffer[0]  = 0x68;		// pushl $lazy-info-offset
			buffer[1]  = 0x00;
			buffer[2]  = 0x00;
			buffer[3]  = 0x00;
			buffer[4]  = 0x00;
			buffer[5]  = 0xE9;		// jmp helperhelper
			buffer[6]  = 0x00;
			buffer[7]  = 0x00;
			buffer[8]  = 0x00;
			buffer[9]  = 0x00;
	}
	virtual void							setScope(Scope)					{ }
	virtual ld::Fixup::iterator				fixupsBegin() const				{ return &_fixup1; }
	virtual ld::Fixup::iterator				fixupsEnd() const				{ return &((ld::Fixup*)&_fixup3)[1]; }

private:
	static ld::Atom* helperHelper(ld::passes::stubs::Pass& pass) {
		if ( pass.compressedHelperHelper == NULL ) 
			pass.compressedHelperHelper = new StubHelperHelperAtom(pass);
		return pass.compressedHelperHelper;
	}

	const ld::Atom&							_stubTo;
	mutable ld::Fixup						_fixup1;
			ld::Fixup						_fixup2;
			ld::Fixup						_fixup3;
	
	static ld::Section						_s_section;
};

ld::Section						StubHelperAtom::_s_section("__TEXT", "__stub_helper", ld::Section::typeStubHelper);


class ResolverHelperAtom : public ld::Atom {
public:
											ResolverHelperAtom(ld::passes::stubs::Pass& pass, const ld::Atom* lazyPointer,
																							const ld::Atom& stubTo)
				: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
							ld::Atom::scopeLinkageUnit, ld::Atom::typeStubHelper, 
							symbolTableNotIn, false, false, false, ld::Atom::Alignment(1)), 
				_stubTo(stubTo),
				_fixup1(4,  ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86BranchPCRel32, &stubTo),
				_fixup2(9,  ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, lazyPointer),
				_fixup3(18, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, lazyPointer) { }
				
	virtual const ld::File*					file() const					{ return _stubTo.file(); }
	virtual const char*						name() const					{ return _stubTo.name(); }
	virtual uint64_t						size() const					{ return 22; }
	virtual uint64_t						objectAddress() const			{ return 0; }
	virtual void							copyRawContent(uint8_t buffer[]) const {
			buffer[ 0]  = 0x50;		// push %eax
			buffer[ 1]  = 0x51;		// push %ecx
			buffer[ 2]  = 0x52;		// push %edx
			buffer[ 3]  = 0xE8;		// call foo
			buffer[ 4]  = 0x00;
			buffer[ 5]  = 0x00;		
			buffer[ 6]  = 0x00;
			buffer[ 7]  = 0x00;
			buffer[ 8]  = 0xA3;		// movl	%eax,foo$lazy_ptr
			buffer[ 9]  = 0x00;
			buffer[10]  = 0x00;	
			buffer[11]  = 0x00;
			buffer[12]  = 0x00;
			buffer[13]  = 0x5A;		// pop %edx
			buffer[14]  = 0x59;		// pop %ecx
			buffer[15]  = 0x58;		// pop %eax
			buffer[16]  = 0xFF;		// jmp *foo$lazy_ptr
			buffer[17]  = 0x25;
			buffer[18]  = 0x00;
			buffer[19]  = 0x00;
			buffer[20]  = 0x00;
			buffer[21]  = 0x00;
	}
	virtual void							setScope(Scope)					{ }
	virtual ld::Fixup::iterator				fixupsBegin() const				{ return &_fixup1; }
	virtual ld::Fixup::iterator				fixupsEnd() const				{ return &((ld::Fixup*)&_fixup3)[1]; }

private:

	const ld::Atom&							_stubTo;
	mutable ld::Fixup						_fixup1;
			ld::Fixup						_fixup2;
			ld::Fixup						_fixup3;
	
	static ld::Section						_s_section;
};

ld::Section						ResolverHelperAtom::_s_section("__TEXT", "__stub_helper", ld::Section::typeStubHelper);


class LazyPointerAtom : public ld::Atom {
public:
											LazyPointerAtom(ld::passes::stubs::Pass& pass, const ld::Atom& stubTo,
														bool stubToGlobalWeakDef, bool stubToResolver, bool weakImport)
				: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
							ld::Atom::scopeTranslationUnit, ld::Atom::typeLazyPointer, 
							symbolTableNotIn, false, false, false, ld::Atom::Alignment(2)), 
				_stubTo(stubTo),
				_helper(pass, this, stubTo),
				_resolverHelper(pass, this, stubTo),
				_fixup1(0, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, 
									stubToResolver ? &_resolverHelper : (stubToGlobalWeakDef ?  &stubTo : &_helper)),
				_fixup2(0, ld::Fixup::k1of1, ld::Fixup::kindLazyTarget, &stubTo) { 
						_fixup2.weakImport = weakImport; pass.addAtom(*this); 
						if ( stubToResolver )
							pass.addAtom(_resolverHelper);
						else if ( !stubToGlobalWeakDef ) 
							pass.addAtom(_helper); 
				}

	virtual const ld::File*					file() const					{ return _stubTo.file(); }
	virtual const char*						name() const					{ return _stubTo.name(); }
	virtual uint64_t						size() const					{ return 4; }
	virtual uint64_t						objectAddress() const			{ return 0; }
	virtual void							copyRawContent(uint8_t buffer[]) const { }
	virtual void							setScope(Scope)					{ }
	virtual ld::Fixup::iterator				fixupsBegin() const				{ return &_fixup1; }
	virtual ld::Fixup::iterator				fixupsEnd()	const 				{ return &((ld::Fixup*)&_fixup2)[1]; }

private:
	const ld::Atom&							_stubTo;
	StubHelperAtom							_helper;
	ResolverHelperAtom						_resolverHelper;
	mutable ld::Fixup						_fixup1;
	ld::Fixup								_fixup2;
	
	static ld::Section						_s_section;
};

ld::Section LazyPointerAtom::_s_section("__DATA", "__la_symbol_ptr", ld::Section::typeLazyPointer);


class StubAtom : public ld::Atom {
public:
											StubAtom(ld::passes::stubs::Pass& pass, const ld::Atom& stubTo,
													bool stubToGlobalWeakDef, bool stubToResolver, bool weakImport)
				: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
							ld::Atom::scopeLinkageUnit, ld::Atom::typeStub, 
							symbolTableNotIn, false, false, false, ld::Atom::Alignment(1)), 
				_stubTo(stubTo), 
				_lazyPointer(pass, stubTo, stubToGlobalWeakDef, stubToResolver, weakImport),
				_fixup(2, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, &_lazyPointer) { pass.addAtom(*this); }

	virtual const ld::File*					file() const					{ return _stubTo.file(); }
	virtual const char*						name() const					{ return _stubTo.name(); }
	virtual uint64_t						size() const					{ return 6; }
	virtual uint64_t						objectAddress() const			{ return 0; }
	virtual void							copyRawContent(uint8_t buffer[]) const {
			buffer[0] = 0xFF;		// jmp *foo$lazy_pointer
			buffer[1] = 0x25;
			buffer[2] = 0x00;
			buffer[3] = 0x00;
			buffer[4] = 0x00;
			buffer[5] = 0x00;
	}
	virtual void							setScope(Scope)					{ }
	virtual ld::Fixup::iterator				fixupsBegin() const				{ return &_fixup; }
	virtual ld::Fixup::iterator				fixupsEnd()	const 				{ return &((ld::Fixup*)&_fixup)[1]; }

private:
	const ld::Atom&							_stubTo;
	LazyPointerAtom							_lazyPointer;
	mutable ld::Fixup						_fixup;
	
	static ld::Section						_s_section;
};

ld::Section StubAtom::_s_section("__TEXT", "__symbol_stub", ld::Section::typeStub);


} // namespace x86
Commit	Line	Data
a645023d A	1	/* -- mode: C++; c-basic-offset: 4; tab-width: 4 --
	2	*
	3	* Copyright (c) 2009-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
	26	// already in ld::passes::stubs namespace
	27	namespace x86 {
	28
	29
	30
	31	class FastBindingPointerAtom : public ld::Atom {
	32	public:
	33	FastBindingPointerAtom(ld::passes::stubs::Pass& pass)
	34	: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
	35	ld::Atom::scopeLinkageUnit, ld::Atom::typeNonLazyPointer,
	36	symbolTableNotIn, false, false, false, ld::Atom::Alignment(2)),
	37	_fixup(0, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32,
	38	pass.internal()->compressedFastBinderProxy)
	39	{ pass.addAtom(*this); }
	40
	41	virtual const ld::File* file() const { return NULL; }
a645023d A	42	virtual const char* name() const { return "fast binder pointer"; }
	43	virtual uint64_t size() const { return 4; }
	44	virtual uint64_t objectAddress() const { return 0; }
	45	virtual void copyRawContent(uint8_t buffer[]) const { }
	46	virtual void setScope(Scope) { }
	47	virtual ld::Fixup::iterator fixupsBegin() const { return &_fixup; }
	48	virtual ld::Fixup::iterator fixupsEnd() const { return &((ld::Fixup*)&_fixup)[1]; }
	49
	50	private:
	51	mutable ld::Fixup _fixup;
	52
	53	static ld::Section _s_section;
	54	};
	55
	56	ld::Section FastBindingPointerAtom::_s_section("__DATA", "__nl_symbol_ptr", ld::Section::typeNonLazyPointer);
	57
	58
	59	class ImageCachePointerAtom : public ld::Atom {
	60	public:
	61	ImageCachePointerAtom(ld::passes::stubs::Pass& pass)
	62	: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
	63	ld::Atom::scopeLinkageUnit, ld::Atom::typeNonLazyPointer,
	64	symbolTableNotIn, false, false, false, ld::Atom::Alignment(2)) { pass.addAtom(*this); }
	65
	66	virtual const ld::File* file() const { return NULL; }
a645023d A	67	virtual const char* name() const { return "image cache pointer"; }
	68	virtual uint64_t size() const { return 4; }
	69	virtual uint64_t objectAddress() const { return 0; }
	70	virtual void copyRawContent(uint8_t buffer[]) const { }
	71	virtual void setScope(Scope) { }
	72
	73	private:
	74
	75	static ld::Section _s_section;
	76	};
	77
	78	ld::Section ImageCachePointerAtom::_s_section("__DATA", "__nl_symbol_ptr", ld::Section::typeNonLazyPointer);
	79
	80
	81
	82
	83
	84	//
	85	// The stub-helper-helper is the common code factored out of each helper function.
	86	// It is in the same section as the stub-helpers.
	87	// Similar to the PLT0 entry in ELF.
	88	//
	89	class StubHelperHelperAtom : public ld::Atom {
	90	public:
	91	StubHelperHelperAtom(ld::passes::stubs::Pass& pass)
	92	: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
	93	ld::Atom::scopeLinkageUnit, ld::Atom::typeStubHelper,
	94	symbolTableNotIn, false, false, false, ld::Atom::Alignment(2)),
	95	_fixup1(1, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, compressedImageCache(pass)),
	96	_fixup2(7, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, compressedFastBinder(pass))
	97	{ pass.addAtom(*this); }
	98
	99	virtual ld::File* file() const { return NULL; }
a645023d A	100	virtual const char* name() const { return "helper helper"; }
	101	virtual uint64_t size() const { return 12; }
	102	virtual uint64_t objectAddress() const { return 0; }
	103	virtual void copyRawContent(uint8_t buffer[]) const {
	104	buffer[0] = 0x68; // pushl $dyld_ImageLoaderCache
	105	buffer[1] = 0x00;
	106	buffer[2] = 0x00;
	107	buffer[3] = 0x00;
	108	buffer[4] = 0x00;
	109	buffer[5] = 0xFF; // jmp *_fast_lazy_bind
	110	buffer[6] = 0x25;
	111	buffer[7] = 0x00;
	112	buffer[8] = 0x00;
	113	buffer[9] = 0x00;
	114	buffer[10] = 0x00;
	115	buffer[11] = 0x90; // nop
	116	}
	117	virtual void setScope(Scope) { }
	118	virtual ld::Fixup::iterator fixupsBegin() const { return &_fixup1; }
	119	virtual ld::Fixup::iterator fixupsEnd() const { return &((ld::Fixup*)&_fixup2)[1]; }
	120
	121	private:
	122	static ld::Atom* compressedImageCache(ld::passes::stubs::Pass& pass) {
	123	if ( pass.compressedImageCache == NULL )
	124	pass.compressedImageCache = new ImageCachePointerAtom(pass);
	125	return pass.compressedImageCache;
	126	}
	127	static ld::Atom* compressedFastBinder(ld::passes::stubs::Pass& pass) {
	128	if ( pass.compressedFastBinderPointer == NULL )
	129	pass.compressedFastBinderPointer = new FastBindingPointerAtom(pass);
	130	return pass.compressedFastBinderPointer;
	131	}
	132
	133	mutable ld::Fixup _fixup1;
	134	ld::Fixup _fixup2;
	135
	136	static ld::Section _s_section;
	137	};
	138
	139	ld::Section StubHelperHelperAtom::_s_section("__TEXT", "__stub_helper", ld::Section::typeStubHelper);
	140
	141
	142
	143	class StubHelperAtom : public ld::Atom {
	144	public:
	145	StubHelperAtom(ld::passes::stubs::Pass& pass, const ld::Atom* lazyPointer,
	146	const ld::Atom& stubTo)
	147	: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
	148	ld::Atom::scopeLinkageUnit, ld::Atom::typeStubHelper,
	149	symbolTableNotIn, false, false, false, ld::Atom::Alignment(1)),
	150	_stubTo(stubTo),
	151	_fixup1(1, ld::Fixup::k1of2, ld::Fixup::kindSetLazyOffset, lazyPointer),
	152	_fixup2(1, ld::Fixup::k2of2, ld::Fixup::kindStoreLittleEndian32),
	153	_fixup3(6, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86BranchPCRel32, helperHelper(pass)) { }
	154
	155	virtual const ld::File* file() const { return _stubTo.file(); }
a645023d A	156	virtual const char* name() const { return _stubTo.name(); }
	157	virtual uint64_t size() const { return 10; }
	158	virtual uint64_t objectAddress() const { return 0; }
	159	virtual void copyRawContent(uint8_t buffer[]) const {
	160	buffer[0] = 0x68; // pushl $lazy-info-offset
	161	buffer[1] = 0x00;
	162	buffer[2] = 0x00;
	163	buffer[3] = 0x00;
	164	buffer[4] = 0x00;
	165	buffer[5] = 0xE9; // jmp helperhelper
	166	buffer[6] = 0x00;
	167	buffer[7] = 0x00;
	168	buffer[8] = 0x00;
	169	buffer[9] = 0x00;
	170	}
	171	virtual void setScope(Scope) { }
	172	virtual ld::Fixup::iterator fixupsBegin() const { return &_fixup1; }
	173	virtual ld::Fixup::iterator fixupsEnd() const { return &((ld::Fixup*)&_fixup3)[1]; }
	174
	175	private:
	176	static ld::Atom* helperHelper(ld::passes::stubs::Pass& pass) {
	177	if ( pass.compressedHelperHelper == NULL )
	178	pass.compressedHelperHelper = new StubHelperHelperAtom(pass);
	179	return pass.compressedHelperHelper;
	180	}
	181
	182	const ld::Atom& _stubTo;
	183	mutable ld::Fixup _fixup1;
	184	ld::Fixup _fixup2;
	185	ld::Fixup _fixup3;
	186
	187	static ld::Section _s_section;
	188	};
	189
	190	ld::Section StubHelperAtom::_s_section("__TEXT", "__stub_helper", ld::Section::typeStubHelper);
	191
	192
	193	class ResolverHelperAtom : public ld::Atom {
	194	public:
	195	ResolverHelperAtom(ld::passes::stubs::Pass& pass, const ld::Atom* lazyPointer,
	196	const ld::Atom& stubTo)
	197	: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
	198	ld::Atom::scopeLinkageUnit, ld::Atom::typeStubHelper,
	199	symbolTableNotIn, false, false, false, ld::Atom::Alignment(1)),
	200	_stubTo(stubTo),
	201	_fixup1(4, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86BranchPCRel32, &stubTo),
	202	_fixup2(9, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, lazyPointer),
	203	_fixup3(18, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, lazyPointer) { }
	204
	205	virtual const ld::File* file() const { return _stubTo.file(); }
a645023d A	206	virtual const char* name() const { return _stubTo.name(); }
	207	virtual uint64_t size() const { return 22; }
	208	virtual uint64_t objectAddress() const { return 0; }
	209	virtual void copyRawContent(uint8_t buffer[]) const {
	210	buffer[ 0] = 0x50; // push %eax
	211	buffer[ 1] = 0x51; // push %ecx
	212	buffer[ 2] = 0x52; // push %edx
	213	buffer[ 3] = 0xE8; // call foo
	214	buffer[ 4] = 0x00;
	215	buffer[ 5] = 0x00;
	216	buffer[ 6] = 0x00;
	217	buffer[ 7] = 0x00;
	218	buffer[ 8] = 0xA3; // movl %eax,foo$lazy_ptr
	219	buffer[ 9] = 0x00;
	220	buffer[10] = 0x00;
	221	buffer[11] = 0x00;
	222	buffer[12] = 0x00;
	223	buffer[13] = 0x5A; // pop %edx
	224	buffer[14] = 0x59; // pop %ecx
	225	buffer[15] = 0x58; // pop %eax
	226	buffer[16] = 0xFF; // jmp *foo$lazy_ptr
	227	buffer[17] = 0x25;
	228	buffer[18] = 0x00;
	229	buffer[19] = 0x00;
	230	buffer[20] = 0x00;
	231	buffer[21] = 0x00;
	232	}
	233	virtual void setScope(Scope) { }
	234	virtual ld::Fixup::iterator fixupsBegin() const { return &_fixup1; }
	235	virtual ld::Fixup::iterator fixupsEnd() const { return &((ld::Fixup*)&_fixup3)[1]; }
	236
	237	private:
	238
	239	const ld::Atom& _stubTo;
	240	mutable ld::Fixup _fixup1;
	241	ld::Fixup _fixup2;
	242	ld::Fixup _fixup3;
	243
	244	static ld::Section _s_section;
	245	};
	246
	247	ld::Section ResolverHelperAtom::_s_section("__TEXT", "__stub_helper", ld::Section::typeStubHelper);
	248
	249
	250
	251	class LazyPointerAtom : public ld::Atom {
	252	public:
	253	LazyPointerAtom(ld::passes::stubs::Pass& pass, const ld::Atom& stubTo,
	254	bool stubToGlobalWeakDef, bool stubToResolver, bool weakImport)
	255	: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
	256	ld::Atom::scopeTranslationUnit, ld::Atom::typeLazyPointer,
	257	symbolTableNotIn, false, false, false, ld::Atom::Alignment(2)),
	258	_stubTo(stubTo),
	259	_helper(pass, this, stubTo),
	260	_resolverHelper(pass, this, stubTo),
	261	_fixup1(0, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32,
	262	stubToResolver ? &_resolverHelper : (stubToGlobalWeakDef ? &stubTo : &_helper)),
	263	_fixup2(0, ld::Fixup::k1of1, ld::Fixup::kindLazyTarget, &stubTo) {
	264	_fixup2.weakImport = weakImport; pass.addAtom(*this);
	265	if ( stubToResolver )
	266	pass.addAtom(_resolverHelper);
	267	else if ( !stubToGlobalWeakDef )
	268	pass.addAtom(_helper);
	269	}
270
271	virtual const ld::File* file() const { return _stubTo.file(); }
a645023d A	272	virtual const char* name() const { return _stubTo.name(); }
	273	virtual uint64_t size() const { return 4; }
	274	virtual uint64_t objectAddress() const { return 0; }
	275	virtual void copyRawContent(uint8_t buffer[]) const { }
	276	virtual void setScope(Scope) { }
	277	virtual ld::Fixup::iterator fixupsBegin() const { return &_fixup1; }
	278	virtual ld::Fixup::iterator fixupsEnd() const { return &((ld::Fixup*)&_fixup2)[1]; }
	279
	280	private:
	281	const ld::Atom& _stubTo;
	282	StubHelperAtom _helper;
	283	ResolverHelperAtom _resolverHelper;
	284	mutable ld::Fixup _fixup1;
	285	ld::Fixup _fixup2;
	286
	287	static ld::Section _s_section;
	288	};
	289
	290	ld::Section LazyPointerAtom::_s_section("__DATA", "__la_symbol_ptr", ld::Section::typeLazyPointer);
	291
	292
	293	class StubAtom : public ld::Atom {
	294	public:
	295	StubAtom(ld::passes::stubs::Pass& pass, const ld::Atom& stubTo,
	296	bool stubToGlobalWeakDef, bool stubToResolver, bool weakImport)
	297	: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
	298	ld::Atom::scopeLinkageUnit, ld::Atom::typeStub,
	299	symbolTableNotIn, false, false, false, ld::Atom::Alignment(1)),
	300	_stubTo(stubTo),
	301	_lazyPointer(pass, stubTo, stubToGlobalWeakDef, stubToResolver, weakImport),
	302	_fixup(2, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, &_lazyPointer) { pass.addAtom(*this); }
	303
	304	virtual const ld::File* file() const { return _stubTo.file(); }
a645023d A	305	virtual const char* name() const { return _stubTo.name(); }
	306	virtual uint64_t size() const { return 6; }
	307	virtual uint64_t objectAddress() const { return 0; }
	308	virtual void copyRawContent(uint8_t buffer[]) const {
	309	buffer[0] = 0xFF; // jmp *foo$lazy_pointer
	310	buffer[1] = 0x25;
	311	buffer[2] = 0x00;
	312	buffer[3] = 0x00;
	313	buffer[4] = 0x00;
	314	buffer[5] = 0x00;
	315	}
	316	virtual void setScope(Scope) { }
	317	virtual ld::Fixup::iterator fixupsBegin() const { return &_fixup; }
	318	virtual ld::Fixup::iterator fixupsEnd() const { return &((ld::Fixup*)&_fixup)[1]; }
	319
	320	private:
	321	const ld::Atom& _stubTo;
	322	LazyPointerAtom _lazyPointer;
	323	mutable ld::Fixup _fixup;
	324
	325	static ld::Section _s_section;
	326	};
	327
	328	ld::Section StubAtom::_s_section("__TEXT", "__symbol_stub", ld::Section::typeStub);
	329
	330
	331
	332	} // namespace x86
	333