projects / apple / ld64.git / blame
| 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 |