src/ld/passes/stubs/stub_x86_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 {
  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 bool                                                    translationUnitSource(const char** dir, const char** ) const
  48                                                                                                                                                         { return false; }
  49         virtual const char*                                             name() const                                    { return _stubTo.name(); }
  50         virtual uint64_t                                                size() const                                    { return 10; }
  51         virtual uint64_t                                                objectAddress() const                   { return 0; }
  52         virtual void                                                    copyRawContent(uint8_t buffer[]) const {
  53                         buffer[0]  = 0x68;              // pushl $foo$lazy_ptr
  54                         buffer[1]  = 0x00;
  55                         buffer[2]  = 0x00;
  56                         buffer[3]  = 0x00;
  57                         buffer[4]  = 0x00;
  58                         buffer[5]  = 0xE9;              // jmp dyld_stub_binding_helper
  59                         buffer[6]  = 0x00;
  60                         buffer[7]  = 0x00;
  61                         buffer[8]  = 0x00;
  62                         buffer[9]  = 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(2)),
  89                                 _stubTo(stubTo),
  90                                 _helper(pass, stubTo, *this, forLazyDylib),
  91                                 _fixup1(0, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, &_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 bool                                                    translationUnitSource(const char** dir, const char** ) const
  97                                                                                                                                                         { return false; }
  98         virtual const char*                                             name() const                                    { return _stubTo.name(); }
  99         virtual uint64_t                                                size() const                                    { return 4; }
 100         virtual uint64_t                                                objectAddress() const                   { return 0; }
 101         virtual void                                                    copyRawContent(uint8_t buffer[]) const { }
 102         virtual void                                                    setScope(Scope)                                 { }
 103         virtual ld::Fixup::iterator                             fixupsBegin() const                             { return &_fixup1; }
 104         virtual ld::Fixup::iterator                             fixupsEnd()     const                           { return &((ld::Fixup*)&_fixup2)[1]; }
 105
 106 private:
 107         const ld::Atom&                                                 _stubTo;
 108         StubHelperAtom                                                  _helper;
 109         mutable ld::Fixup                                               _fixup1;
 110         mutable ld::Fixup                                               _fixup2;
 111
 112         static ld::Section                                              _s_section;
 113         static ld::Section                                              _s_sectionLazy;
 114 };
 115
 116 ld::Section LazyPointerAtom::_s_section("__DATA", "__la_symbol_ptr", ld::Section::typeLazyPointer);
 117 ld::Section LazyPointerAtom::_s_sectionLazy("__DATA", "__ld_symbol_ptr", ld::Section::typeLazyDylibPointer);
 118
 119
 120
 121 class StubAtom : public ld::Atom {
 122 public:
 123                                                                                         StubAtom(ld::passes::stubs::Pass& pass, const ld::Atom& stubTo,
 124                                                                                                                                                                         bool forLazyDylib, bool weakImport)
 125                                 : ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
 126                                                         ld::Atom::scopeLinkageUnit, ld::Atom::typeStub,
 127                                                         symbolTableNotIn, false, false, false, ld::Atom::Alignment(1)),
 128                                 _stubTo(stubTo),
 129                                 _lazyPointer(pass, stubTo, forLazyDylib, weakImport),
 130                                 _fixup(2, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, &_lazyPointer) { pass.addAtom(*this); }
 131
 132         virtual const ld::File*                                 file() const                                    { return _stubTo.file(); }
 133         virtual bool                                                    translationUnitSource(const char** dir, const char** ) const
 134                                                                                                                                                         { return false; }
 135         virtual const char*                                             name() const                                    { return _stubTo.name(); }
 136         virtual uint64_t                                                size() const                                    { return 6; }
 137         virtual uint64_t                                                objectAddress() const                   { return 0; }
 138         virtual void                                                    copyRawContent(uint8_t buffer[]) const {
 139                         buffer[0] = 0xFF;               // jmp *foo$lazy_pointer(%rip)
 140                         buffer[1] = 0x25;
 141                         buffer[2] = 0x00;
 142                         buffer[3] = 0x00;
 143                         buffer[4] = 0x00;
 144                         buffer[5] = 0x00;
 145         }
 146         virtual void                                                    setScope(Scope)                                 { }
 147         virtual ld::Fixup::iterator                             fixupsBegin() const                             { return &_fixup; }
 148         virtual ld::Fixup::iterator                             fixupsEnd()     const                           { return &((ld::Fixup*)&_fixup)[1]; }
 149
 150 private:
 151         const ld::Atom&                                                 _stubTo;
 152         LazyPointerAtom                                                 _lazyPointer;
 153         mutable ld::Fixup                                               _fixup;
 154
 155         static ld::Section                                              _s_section;
 156 };
 157
 158 ld::Section StubAtom::_s_section("__TEXT", "__symbol_stub", ld::Section::typeStub);
 159
 160
 161 } // namespace classic
 162 } // namespace x86
 163