src/ld/passes/stubs/stub_x86_64_classic.hpp

   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(); }
  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(); }
  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(); }
 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