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

/* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
 *
 * Copyright (c) 2009 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_64 {


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(3)), 
				_fixup(0, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian64, 
												pass.internal()->compressedFastBinderProxy)
					{ pass.addAtom(*this); }

	virtual const ld::File*					file() const					{ return NULL; }
	virtual bool							translationUnitSource(const char** dir, const char** nm) const 
																			{ return false; }
	virtual const char*						name() const					{ return "fast binder pointer"; }
	virtual uint64_t						size() const					{ return 8; }
	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(3)) { pass.addAtom(*this); }

	virtual const ld::File*					file() const					{ return NULL; }
	virtual bool							translationUnitSource(const char** dir, const char** nm) const 
																			{ return false; }
	virtual const char*						name() const					{ return "image cache pointer"; }
	virtual uint64_t						size() const					{ return 8; }
	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(3,  ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86PCRel32, compressedImageCache(pass)),
				_fixup2(11, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86PCRel32, compressedFastBinder(pass)) 
					{ pass.addAtom(*this); }

	virtual ld::File*						file() const					{ return NULL; }
	virtual bool							translationUnitSource(const char** dir, const char** nm) const 
																			{ return false; }
	virtual const char*						name() const					{ return "helper helper"; }
	virtual uint64_t						size() const					{ return 16; }
	virtual uint64_t						objectAddress() const			{ return 0; }
	virtual void							copyRawContent(uint8_t buffer[]) const {
		buffer[0]  = 0x4C;		// leaq dyld_mageLoaderCache(%rip),%r11
		buffer[1]  = 0x8D;
		buffer[2]  = 0x1D;
		buffer[3]  = 0x00;
		buffer[4]  = 0x00;
		buffer[5]  = 0x00;
		buffer[6]  = 0x00;
		buffer[7]  = 0x41;		// pushq %r11
		buffer[8]  = 0x53;
		buffer[9]  = 0xFF;		// jmp *_fast_lazy_bind(%rip)
		buffer[10] = 0x25;
		buffer[11] = 0x00;
		buffer[12] = 0x00;
		buffer[13] = 0x00;
		buffer[14] = 0x00;
		buffer[15] = 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** nm) 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;		// pushq $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(10, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86BranchPCRel32, &stubTo),
				_fixup2(17, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86PCRel32, lazyPointer),
				_fixup3(32, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86PCRel32, lazyPointer) { }
				
	virtual const ld::File*					file() const					{ return _stubTo.file(); }
	virtual bool							translationUnitSource(const char** dir, const char** nm) const 
																			{ return false; }
	virtual const char*						name() const					{ return _stubTo.name(); }
	virtual uint64_t						size() const					{ return 36; }
	virtual uint64_t						objectAddress() const			{ return 0; }
	virtual void							copyRawContent(uint8_t buffer[]) const {
			buffer[ 0]  = 0x50;		// push %rax
			buffer[ 1]  = 0x57;		// push %rdi
			buffer[ 2]  = 0x56;		// push %rsi
			buffer[ 3]  = 0x52;		// push %rdx
			buffer[ 4]  = 0x51;		// push %rcx
			buffer[ 5]  = 0x41;		// push %r8
			buffer[ 6]  = 0x50;
			buffer[ 7]  = 0x41;		// push %r9
			buffer[ 8]  = 0x51;
			buffer[ 9]  = 0xE8;		// call foo
			buffer[10]  = 0x00;
			buffer[11]  = 0x00;
			buffer[12]  = 0x00;		
			buffer[13]  = 0x00;
			buffer[14]  = 0x48;		// movq %rax,foo$lazy_pointer(%rip)
			buffer[15]  = 0x89;
			buffer[16]  = 0x05;
			buffer[17]  = 0x00;
			buffer[18]  = 0x00;
			buffer[19]  = 0x00;
			buffer[20]  = 0x00;
			buffer[21]  = 0x41;		// pop %r9
			buffer[22]  = 0x59;	
			buffer[23]  = 0x41;		// pop %r8
			buffer[24]  = 0x58;
			buffer[25]  = 0x59;		// pop %rcx
			buffer[26]  = 0x5A;		// pop %rdx
			buffer[27]  = 0x5E;		// pop %rsi
			buffer[28]  = 0x5F;		// pop %rdi
			buffer[29]  = 0x58;		// pop %rax
			buffer[30]  = 0xFF;		// jmp *foo$lazy_ptr(%rip)
			buffer[31]  = 0x25;
			buffer[32]  = 0x00;
			buffer[33]  = 0x00;
			buffer[34]  = 0x00;
			buffer[35]  = 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(3)), 
				_stubTo(stubTo),
				_helper(pass, this, stubTo),
				_resolverHelper(pass, this, stubTo),
				_fixup1(0, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian64, 
													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 8; }
	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::kindStoreTargetAddressX86PCRel32, &_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(%rip)
			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", "__stubs", ld::Section::typeStub);


} // namespace x86_64
Commit	Line	Data
a645023d A	1	/* -- mode: C++; c-basic-offset: 4; tab-width: 4 --
	2	*
	3	* Copyright (c) 2009 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_64 {
	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(3)),
	37	_fixup(0, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian64,
	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 nm) const
	43	{ return false; }
	44	virtual const char* name() const { return "fast binder pointer"; }
	45	virtual uint64_t size() const { return 8; }
	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(3)) { pass.addAtom(*this); }
67
68	virtual const ld::File* file() const { return NULL; }
69	virtual bool translationUnitSource(const char dir, const char nm) const
70	{ return false; }
71	virtual const char* name() const { return "image cache pointer"; }
72	virtual uint64_t size() const { return 8; }
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(3, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86PCRel32, compressedImageCache(pass)),
100	_fixup2(11, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86PCRel32, compressedFastBinder(pass))
101	{ pass.addAtom(*this); }
102
103	virtual ld::File* file() const { return NULL; }
104	virtual bool translationUnitSource(const char dir, const char nm) const
105	{ return false; }
106	virtual const char* name() const { return "helper helper"; }
107	virtual uint64_t size() const { return 16; }
108	virtual uint64_t objectAddress() const { return 0; }
109	virtual void copyRawContent(uint8_t buffer[]) const {
110	buffer[0] = 0x4C; // leaq dyld_mageLoaderCache(%rip),%r11
111	buffer[1] = 0x8D;
112	buffer[2] = 0x1D;
113	buffer[3] = 0x00;
114	buffer[4] = 0x00;
115	buffer[5] = 0x00;
116	buffer[6] = 0x00;
117	buffer[7] = 0x41; // pushq %r11
118	buffer[8] = 0x53;
119	buffer[9] = 0xFF; // jmp *_fast_lazy_bind(%rip)
120	buffer[10] = 0x25;
121	buffer[11] = 0x00;
122	buffer[12] = 0x00;
123	buffer[13] = 0x00;
124	buffer[14] = 0x00;
125	buffer[15] = 0x90; // nop
126	}
127	virtual void setScope(Scope) { }
128	virtual ld::Fixup::iterator fixupsBegin() const { return &_fixup1; }
129	virtual ld::Fixup::iterator fixupsEnd() const { return &((ld::Fixup*)&_fixup2)[1]; }
130
131	private:
132	static ld::Atom* compressedImageCache(ld::passes::stubs::Pass& pass) {
133	if ( pass.compressedImageCache == NULL )
134	pass.compressedImageCache = new ImageCachePointerAtom(pass);
135	return pass.compressedImageCache;
136	}
137	static ld::Atom* compressedFastBinder(ld::passes::stubs::Pass& pass) {
138	if ( pass.compressedFastBinderPointer == NULL )
139	pass.compressedFastBinderPointer = new FastBindingPointerAtom(pass);
140	return pass.compressedFastBinderPointer;
141	}
142
143	mutable ld::Fixup _fixup1;
144	ld::Fixup _fixup2;
145
146	static ld::Section _s_section;
147	};
148
149	ld::Section StubHelperHelperAtom::_s_section("__TEXT", "__stub_helper", ld::Section::typeStubHelper);
150
151
152
153	class StubHelperAtom : public ld::Atom {
154	public:
155	StubHelperAtom(ld::passes::stubs::Pass& pass, const ld::Atom* lazyPointer,
156	const ld::Atom& stubTo)
157	: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
158	ld::Atom::scopeLinkageUnit, ld::Atom::typeStubHelper,
159	symbolTableNotIn, false, false, false, ld::Atom::Alignment(1)),
160	_stubTo(stubTo),
161	_fixup1(1, ld::Fixup::k1of2, ld::Fixup::kindSetLazyOffset, lazyPointer),
162	_fixup2(1, ld::Fixup::k2of2, ld::Fixup::kindStoreLittleEndian32),
163	_fixup3(6, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86BranchPCRel32, helperHelper(pass)) { }
164
165	virtual const ld::File* file() const { return _stubTo.file(); }
166	virtual bool translationUnitSource(const char dir, const char nm) const
167	{ return false; }
168	virtual const char* name() const { return _stubTo.name(); }
169	virtual uint64_t size() const { return 10; }
170	virtual uint64_t objectAddress() const { return 0; }
171	virtual void copyRawContent(uint8_t buffer[]) const {
172	buffer[0] = 0x68; // pushq $lazy-info-offset
173	buffer[1] = 0x00;
174	buffer[2] = 0x00;
175	buffer[3] = 0x00;
176	buffer[4] = 0x00;
177	buffer[5] = 0xE9; // jmp helperhelper
178	buffer[6] = 0x00;
179	buffer[7] = 0x00;
180	buffer[8] = 0x00;
181	buffer[9] = 0x00;
182	}
183	virtual void setScope(Scope) { }
184	virtual ld::Fixup::iterator fixupsBegin() const { return &_fixup1; }
185	virtual ld::Fixup::iterator fixupsEnd() const { return &((ld::Fixup*)&_fixup3)[1]; }
186
187	private:
188	static ld::Atom* helperHelper(ld::passes::stubs::Pass& pass) {
189	if ( pass.compressedHelperHelper == NULL )
190	pass.compressedHelperHelper = new StubHelperHelperAtom(pass);
191	return pass.compressedHelperHelper;
192	}
193
194	const ld::Atom& _stubTo;
195	mutable ld::Fixup _fixup1;
196	ld::Fixup _fixup2;
197	ld::Fixup _fixup3;
198
199	static ld::Section _s_section;
200	};
201
202	ld::Section StubHelperAtom::_s_section("__TEXT", "__stub_helper", ld::Section::typeStubHelper);
203
204
205	class ResolverHelperAtom : public ld::Atom {
206	public:
207	ResolverHelperAtom(ld::passes::stubs::Pass& pass, const ld::Atom* lazyPointer,
208	const ld::Atom& stubTo)
209	: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
210	ld::Atom::scopeLinkageUnit, ld::Atom::typeStubHelper,
211	symbolTableNotIn, false, false, false, ld::Atom::Alignment(1)),
212	_stubTo(stubTo),
213	_fixup1(10, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86BranchPCRel32, &stubTo),
214	_fixup2(17, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86PCRel32, lazyPointer),
215	_fixup3(32, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86PCRel32, lazyPointer) { }
216
217	virtual const ld::File* file() const { return _stubTo.file(); }
218	virtual bool translationUnitSource(const char dir, const char nm) const
219	{ return false; }
220	virtual const char* name() const { return _stubTo.name(); }
221	virtual uint64_t size() const { return 36; }
222	virtual uint64_t objectAddress() const { return 0; }
223	virtual void copyRawContent(uint8_t buffer[]) const {
224	buffer[ 0] = 0x50; // push %rax
225	buffer[ 1] = 0x57; // push %rdi
226	buffer[ 2] = 0x56; // push %rsi
227	buffer[ 3] = 0x52; // push %rdx
228	buffer[ 4] = 0x51; // push %rcx
229	buffer[ 5] = 0x41; // push %r8
230	buffer[ 6] = 0x50;
231	buffer[ 7] = 0x41; // push %r9
232	buffer[ 8] = 0x51;
233	buffer[ 9] = 0xE8; // call foo
234	buffer[10] = 0x00;
235	buffer[11] = 0x00;
236	buffer[12] = 0x00;
237	buffer[13] = 0x00;
238	buffer[14] = 0x48; // movq %rax,foo$lazy_pointer(%rip)
239	buffer[15] = 0x89;
240	buffer[16] = 0x05;
241	buffer[17] = 0x00;
242	buffer[18] = 0x00;
243	buffer[19] = 0x00;
244	buffer[20] = 0x00;
245	buffer[21] = 0x41; // pop %r9
246	buffer[22] = 0x59;
247	buffer[23] = 0x41; // pop %r8
248	buffer[24] = 0x58;
249	buffer[25] = 0x59; // pop %rcx
250	buffer[26] = 0x5A; // pop %rdx
251	buffer[27] = 0x5E; // pop %rsi
252	buffer[28] = 0x5F; // pop %rdi
253	buffer[29] = 0x58; // pop %rax
254	buffer[30] = 0xFF; // jmp *foo$lazy_ptr(%rip)
255	buffer[31] = 0x25;
256	buffer[32] = 0x00;
257	buffer[33] = 0x00;
258	buffer[34] = 0x00;
259	buffer[35] = 0x00;
260	}
261	virtual void setScope(Scope) { }
262	virtual ld::Fixup::iterator fixupsBegin() const { return &_fixup1; }
263	virtual ld::Fixup::iterator fixupsEnd() const { return &((ld::Fixup*)&_fixup3)[1]; }
264
265	private:
266
267	const ld::Atom& _stubTo;
268	mutable ld::Fixup _fixup1;
269	ld::Fixup _fixup2;
270	ld::Fixup _fixup3;
271
272	static ld::Section _s_section;
273	};
274
275	ld::Section ResolverHelperAtom::_s_section("__TEXT", "__stub_helper", ld::Section::typeStubHelper);
276
277
278
279	class LazyPointerAtom : public ld::Atom {
280	public:
281	LazyPointerAtom(ld::passes::stubs::Pass& pass, const ld::Atom& stubTo,
282	bool stubToGlobalWeakDef, bool stubToResolver, bool weakImport)
283	: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
284	ld::Atom::scopeTranslationUnit, ld::Atom::typeLazyPointer,
285	symbolTableNotIn, false, false, false, ld::Atom::Alignment(3)),
286	_stubTo(stubTo),
287	_helper(pass, this, stubTo),
288	_resolverHelper(pass, this, stubTo),
289	_fixup1(0, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian64,
290	stubToResolver ? &_resolverHelper :
291	(stubToGlobalWeakDef ? &stubTo : &_helper)),
292	_fixup2(0, ld::Fixup::k1of1, ld::Fixup::kindLazyTarget, &stubTo) {
293	_fixup2.weakImport = weakImport; pass.addAtom(*this);
294	if ( stubToResolver )
295	pass.addAtom(_resolverHelper);
296	else if ( !stubToGlobalWeakDef )
297	pass.addAtom(_helper);
298	}
299
300	virtual const ld::File* file() const { return _stubTo.file(); }
301	virtual bool translationUnitSource(const char dir, const char ) const
302	{ return false; }
303	virtual const char* name() const { return _stubTo.name(); }
304	virtual uint64_t size() const { return 8; }
305	virtual uint64_t objectAddress() const { return 0; }
306	virtual void copyRawContent(uint8_t buffer[]) const { }
307	virtual void setScope(Scope) { }
308	virtual ld::Fixup::iterator fixupsBegin() const { return &_fixup1; }
309	virtual ld::Fixup::iterator fixupsEnd() const { return &((ld::Fixup*)&_fixup2)[1]; }
310
311	private:
312	const ld::Atom& _stubTo;
313	StubHelperAtom _helper;
314	ResolverHelperAtom _resolverHelper;
315	mutable ld::Fixup _fixup1;
316	ld::Fixup _fixup2;
317
318	static ld::Section _s_section;
319	};
320
321	ld::Section LazyPointerAtom::_s_section("__DATA", "__la_symbol_ptr", ld::Section::typeLazyPointer);
322
323
324	class StubAtom : public ld::Atom {
325	public:
326	StubAtom(ld::passes::stubs::Pass& pass, const ld::Atom& stubTo,
327	bool stubToGlobalWeakDef, bool stubToResolver, bool weakImport)
328	: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
329	ld::Atom::scopeLinkageUnit, ld::Atom::typeStub,
330	symbolTableNotIn, false, false, false, ld::Atom::Alignment(1)),
331	_stubTo(stubTo),
332	_lazyPointer(pass, stubTo, stubToGlobalWeakDef, stubToResolver, weakImport),
333	_fixup(2, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86PCRel32, &_lazyPointer) { pass.addAtom(*this); }
334
335	virtual const ld::File* file() const { return _stubTo.file(); }
336	virtual bool translationUnitSource(const char dir, const char ) const
337	{ return false; }
338	virtual const char* name() const { return _stubTo.name(); }
339	virtual uint64_t size() const { return 6; }
340	virtual uint64_t objectAddress() const { return 0; }
341	virtual void copyRawContent(uint8_t buffer[]) const {
342	buffer[0] = 0xFF; // jmp *foo$lazy_pointer(%rip)
343	buffer[1] = 0x25;
344	buffer[2] = 0x00;
345	buffer[3] = 0x00;
346	buffer[4] = 0x00;
347	buffer[5] = 0x00;
348	}
349	virtual void setScope(Scope) { }
350	virtual ld::Fixup::iterator fixupsBegin() const { return &_fixup; }
351	virtual ld::Fixup::iterator fixupsEnd() const { return &((ld::Fixup*)&_fixup)[1]; }
352
353	private:
354	const ld::Atom& _stubTo;
355	LazyPointerAtom _lazyPointer;
356	mutable ld::Fixup _fixup;
357
358	static ld::Section _s_section;
359	};
360
361	ld::Section StubAtom::_s_section("__TEXT", "__stubs", ld::Section::typeStub);
362
363
364
365	} // namespace x86_64
366