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