[apple/ld64.git] / src / ld / passes / stubs / stub_x86_64_classic.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 {
namespace classic {


class StubHelperAtom : public ld::Atom {
public:
					StubHelperAtom(ld::passes::stubs::Pass& pass, const ld::Atom& stubTo, 
																const ld::Atom& lazyPointer, bool forLazyDylib)
				: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
							ld::Atom::scopeLinkageUnit, ld::Atom::typeStubHelper, 
							symbolTableNotIn, false, false, false, ld::Atom::Alignment(2)), 
				_stubTo(stubTo), 
				_fixup1(3, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86PCRel32, &lazyPointer),
				_fixup2(8, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86BranchPCRel32, 
						forLazyDylib ? pass.internal()->lazyBindingHelper : pass.internal()->classicBindingHelper) 
					{ 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 12; }
	virtual uint64_t						objectAddress() const			{ return 0; }
	virtual void							copyRawContent(uint8_t buffer[]) const {
			buffer[0]  = 0x4C;		// lea foo$lazy_ptr(%rip),%r11
			buffer[1]  = 0x8D;
			buffer[2]  = 0x1D;
			buffer[3]  = 0x00;
			buffer[4]  = 0x00;
			buffer[5]  = 0x00;
			buffer[6]  = 0x00;
			buffer[7]  = 0xE9;		// jmp dyld_stub_binding_helper
			buffer[8]  = 0x00;
			buffer[9]  = 0x00;
			buffer[10] = 0x00;
			buffer[11] = 0x00;
	}
	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;
	mutable ld::Fixup						_fixup1;
	mutable ld::Fixup						_fixup2;
	
	static ld::Section						_s_section;
};

ld::Section StubHelperAtom::_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 forLazyDylib, bool weakImport)
				: ld::Atom( forLazyDylib ? _s_sectionLazy : _s_section, 
							ld::Atom::definitionRegular, ld::Atom::combineNever, 
							ld::Atom::scopeTranslationUnit,
							forLazyDylib ? ld::Atom::typeLazyDylibPointer : ld::Atom::typeLazyPointer,
							symbolTableNotIn, false, false, false, ld::Atom::Alignment(3)), 
				_stubTo(stubTo),
				_helper(pass, stubTo, *this, forLazyDylib),
				_fixup1(0, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian64, &_helper),
				_fixup2(0, ld::Fixup::k1of1, ld::Fixup::kindLazyTarget, &stubTo)
					{ _fixup2.weakImport = weakImport; 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 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;
	mutable ld::Fixup						_fixup1;
	mutable ld::Fixup						_fixup2;
	
	static ld::Section						_s_section;
	static ld::Section						_s_sectionLazy;
};

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


class StubAtom : public ld::Atom {
public:
											StubAtom(ld::passes::stubs::Pass& pass, const ld::Atom& stubTo, 
																					bool forLazyDylib, 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, forLazyDylib, weakImport),
				_fixup(2, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86PCRel32, &_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(%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 classic
} // 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	namespace classic {
	29
	30
	31
	32
	33	class StubHelperAtom : public ld::Atom {
	34	public:
	35	StubHelperAtom(ld::passes::stubs::Pass& pass, const ld::Atom& stubTo,
	36	const ld::Atom& lazyPointer, bool forLazyDylib)
	37	: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
	38	ld::Atom::scopeLinkageUnit, ld::Atom::typeStubHelper,
	39	symbolTableNotIn, false, false, false, ld::Atom::Alignment(2)),
	40	_stubTo(stubTo),
	41	_fixup1(3, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86PCRel32, &lazyPointer),
	42	_fixup2(8, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86BranchPCRel32,
	43	forLazyDylib ? pass.internal()->lazyBindingHelper : pass.internal()->classicBindingHelper)
	44	{ pass.addAtom(*this); }
	45
	46	virtual const ld::File* file() const { return _stubTo.file(); }
a645023d A	47	virtual const char* name() const { return _stubTo.name(); }
	48	virtual uint64_t size() const { return 12; }
	49	virtual uint64_t objectAddress() const { return 0; }
	50	virtual void copyRawContent(uint8_t buffer[]) const {
	51	buffer[0] = 0x4C; // lea foo$lazy_ptr(%rip),%r11
	52	buffer[1] = 0x8D;
	53	buffer[2] = 0x1D;
	54	buffer[3] = 0x00;
	55	buffer[4] = 0x00;
	56	buffer[5] = 0x00;
	57	buffer[6] = 0x00;
	58	buffer[7] = 0xE9; // jmp dyld_stub_binding_helper
	59	buffer[8] = 0x00;
	60	buffer[9] = 0x00;
	61	buffer[10] = 0x00;
	62	buffer[11] = 0x00;
	63	}
	64	virtual void setScope(Scope) { }
	65	virtual ld::Fixup::iterator fixupsBegin() const { return &_fixup1; }
	66	virtual ld::Fixup::iterator fixupsEnd() const { return &((ld::Fixup*)&_fixup2)[1]; }
	67
	68	private:
	69	const ld::Atom& _stubTo;
	70	mutable ld::Fixup _fixup1;
	71	mutable ld::Fixup _fixup2;
	72
	73	static ld::Section _s_section;
	74	};
	75
	76	ld::Section StubHelperAtom::_s_section("__TEXT", "__stub_helper", ld::Section::typeStubHelper);
	77
	78
	79
	80	class LazyPointerAtom : public ld::Atom {
	81	public:
	82	LazyPointerAtom(ld::passes::stubs::Pass& pass, const ld::Atom& stubTo,
	83	bool forLazyDylib, bool weakImport)
	84	: ld::Atom( forLazyDylib ? _s_sectionLazy : _s_section,
	85	ld::Atom::definitionRegular, ld::Atom::combineNever,
	86	ld::Atom::scopeTranslationUnit,
	87	forLazyDylib ? ld::Atom::typeLazyDylibPointer : ld::Atom::typeLazyPointer,
	88	symbolTableNotIn, false, false, false, ld::Atom::Alignment(3)),
	89	_stubTo(stubTo),
	90	_helper(pass, stubTo, *this, forLazyDylib),
	91	_fixup1(0, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian64, &_helper),
	92	_fixup2(0, ld::Fixup::k1of1, ld::Fixup::kindLazyTarget, &stubTo)
	93	{ _fixup2.weakImport = weakImport; pass.addAtom(*this); }
	94
	95	virtual const ld::File* file() const { return _stubTo.file(); }
a645023d A	96	virtual const char* name() const { return _stubTo.name(); }
	97	virtual uint64_t size() const { return 8; }
	98	virtual uint64_t objectAddress() const { return 0; }
	99	virtual void copyRawContent(uint8_t buffer[]) const { }
	100	virtual void setScope(Scope) { }
	101	virtual ld::Fixup::iterator fixupsBegin() const { return &_fixup1; }
	102	virtual ld::Fixup::iterator fixupsEnd() const { return &((ld::Fixup*)&_fixup2)[1]; }
	103
	104	private:
	105	const ld::Atom& _stubTo;
	106	StubHelperAtom _helper;
	107	mutable ld::Fixup _fixup1;
	108	mutable ld::Fixup _fixup2;
	109
	110	static ld::Section _s_section;
	111	static ld::Section _s_sectionLazy;
	112	};
	113
	114	ld::Section LazyPointerAtom::_s_section("__DATA", "__la_symbol_ptr", ld::Section::typeLazyPointer);
	115	ld::Section LazyPointerAtom::_s_sectionLazy("__DATA", "__ld_symbol_ptr", ld::Section::typeLazyDylibPointer);
	116
	117
	118
	119	class StubAtom : public ld::Atom {
	120	public:
	121	StubAtom(ld::passes::stubs::Pass& pass, const ld::Atom& stubTo,
	122	bool forLazyDylib, bool weakImport)
	123	: ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
	124	ld::Atom::scopeLinkageUnit, ld::Atom::typeStub,
	125	symbolTableNotIn, false, false, false, ld::Atom::Alignment(1)),
	126	_stubTo(stubTo),
	127	_lazyPointer(pass, stubTo, forLazyDylib, weakImport),
	128	_fixup(2, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressX86PCRel32, &_lazyPointer) { pass.addAtom(*this); }
	129
	130	virtual const ld::File* file() const { return _stubTo.file(); }
a645023d A	131	virtual const char* name() const { return _stubTo.name(); }
	132	virtual uint64_t size() const { return 6; }
	133	virtual uint64_t objectAddress() const { return 0; }
	134	virtual void copyRawContent(uint8_t buffer[]) const {
	135	buffer[0] = 0xFF; // jmp *foo$lazy_pointer(%rip)
	136	buffer[1] = 0x25;
	137	buffer[2] = 0x00;
	138	buffer[3] = 0x00;
	139	buffer[4] = 0x00;
	140	buffer[5] = 0x00;
	141	}
	142	virtual void setScope(Scope) { }
	143	virtual ld::Fixup::iterator fixupsBegin() const { return &_fixup; }
	144	virtual ld::Fixup::iterator fixupsEnd() const { return &((ld::Fixup*)&_fixup)[1]; }
	145
	146	private:
	147	const ld::Atom& _stubTo;
	148	LazyPointerAtom _lazyPointer;
	149	mutable ld::Fixup _fixup;
	150
	151	static ld::Section _s_section;
	152	};
	153
	154	ld::Section StubAtom::_s_section("__TEXT", "__stubs", ld::Section::typeStub);
	155
	156
	157	} // namespace classic
	158	} // namespace x86_64
	159