src/ld/passes/stubs/stub_x86_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 {
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(1, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, &lazyPointer),
				_fixup2(6, 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 10; }
	virtual uint64_t						objectAddress() const			{ return 0; }
	virtual void							copyRawContent(uint8_t buffer[]) const {
			buffer[0]  = 0x68;		// pushl $foo$lazy_ptr
			buffer[1]  = 0x00;
			buffer[2]  = 0x00;
			buffer[3]  = 0x00;
			buffer[4]  = 0x00;
			buffer[5]  = 0xE9;		// jmp dyld_stub_binding_helper
			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*)&_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(2)),
				_stubTo(stubTo),
				_helper(pass, stubTo, *this, forLazyDylib),
				_fixup1(0, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, &_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 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;
	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::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(%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", "__symbol_stub", ld::Section::typeStub);


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