git.saurik.com Git - apple/ld64.git/blob

1 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-

2 *

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 */

26 #include <stdint.h>

27 #include <math.h>

28 #include <unistd.h>

29 #include <dlfcn.h>

31 #include <vector>

32 #include <map>

34 #include "MachOFileAbstraction.hpp"

35 #include "ld.hpp"

36 #include "got.h"

37 #include "configure.h"

39 namespace ld {

40 namespace passes {

41 namespace got {

43 class File; // forward reference

 class GOTEntryAtom : public ld::Atom {

46 public:

                                                                                         GOTEntryAtom(ld::Internal& internal, const ld::Atom* target, bool weakImport, bool weakDef, bool is64)

                                 : ld::Atom(weakDef ? _s_sectionWeak : _s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,

                                                         ld::Atom::scopeLinkageUnit, ld::Atom::typeNonLazyPointer, 

                                                         symbolTableNotIn, false, false, false, (is64 ? ld::Atom::Alignment(3) : ld::Atom::Alignment(2))),

                                 _fixup(0, ld::Fixup::k1of1, (is64 ? ld::Fixup::kindStoreTargetAddressLittleEndian64 : ld::Fixup::kindStoreTargetAddressLittleEndian32), target),

52 _target(target),

53 _is64(is64)

                                         { _fixup.weakImport = weakImport; internal.addAtom(*this); }

         virtual const ld::File*                                 file() const                                    { return NULL; }

         virtual const char*                                             name() const                                    { return _target->name(); }

         virtual uint64_t                                                size() const                                    { return (_is64 ? 8 : 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 &_fixup; }

         virtual ld::Fixup::iterator                             fixupsEnd()     const                           { return &((ld::Fixup*)&_fixup)[1]; }

65 private:

66 mutable ld::Fixup _fixup;

         const ld::Atom*                                                 _target;

68 bool _is64;

70 static ld::Section _s_section;

71 static ld::Section _s_sectionWeak;

72 };

 ld::Section GOTEntryAtom::_s_section("__DATA", "__got", ld::Section::typeNonLazyPointer);

 ld::Section GOTEntryAtom::_s_sectionWeak("__DATA", "__got_weak", ld::Section::typeNonLazyPointer);

77 #if SUPPORT_ARCH_arm64e

 class GOTAuthEntryAtom : public ld::Atom {

80 public:

                                                                                         GOTAuthEntryAtom(ld::Internal& internal, const ld::Atom* target, bool weakImport, bool weakDef)

                                 : ld::Atom(weakDef ? _s_sectionWeak : _s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,

                                                         ld::Atom::scopeLinkageUnit, ld::Atom::typeNonLazyPointer,

                                                         symbolTableNotIn, false, false, false, ld::Atom::Alignment(3)),

                                 _fixup1(0, ld::Fixup::k1of2, ld::Fixup::kindSetAuthData, (ld::Fixup::AuthData){ 0, true, ld::Fixup::AuthData::ptrauth_key_asia }),

                                 _fixup2(0, ld::Fixup::k2of2, ld::Fixup::kindStoreTargetAddressLittleEndianAuth64, target),

87 _target(target)

                                         { _fixup2.weakImport = weakImport; internal.addAtom(*this); }

         virtual const ld::File*                                 file() const                                    { return NULL; }

         virtual const char*                                             name() const                                    { return _target->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 (ld::Fixup*)&_fixup1; }

         virtual ld::Fixup::iterator                             fixupsEnd()     const                           { return &((ld::Fixup*)&_fixup2)[1]; }

99 private:

100 mutable ld::Fixup _fixup1;

101 mutable ld::Fixup _fixup2;

         const ld::Atom*                                                 _target;

103

104 static ld::Section _s_section;

105 static ld::Section _s_sectionWeak;

106 };

107

 ld::Section GOTAuthEntryAtom::_s_section("__DATA", "__got", ld::Section::typeNonLazyPointer);

 ld::Section GOTAuthEntryAtom::_s_sectionWeak("__DATA", "__got_weak", ld::Section::typeNonLazyPointer);

110

111 #endif

112

113

 static bool gotFixup(const Options& opts, ld::Internal& internal, const ld::Atom* targetOfGOT, const ld::Atom* fixupAtom,

                                          const ld::Fixup* fixup, bool* optimizable, bool* targetIsExternalWeakDef, bool* targetIsPersonalityFn)

116 {

117 *targetIsExternalWeakDef = false;

118 *targetIsPersonalityFn = false;

119 switch (fixup->kind) {

                 case ld::Fixup::kindStoreTargetAddressX86PCRel32GOTLoad:

121 #if SUPPORT_ARCH_arm64

                 case ld::Fixup::kindStoreTargetAddressARM64GOTLoadPage21:

                 case ld::Fixup::kindStoreTargetAddressARM64GOTLoadPageOff12:

124 #endif

125 // start by assuming this can be optimized

126 *optimizable = true;

127 // cannot do LEA optimization if target is in another dylib

                         if ( targetOfGOT->definition() == ld::Atom::definitionProxy ) 

129 *optimizable = false;

130 // cannot do LEA optimization if target in __huge section

                         if ( internal.usingHugeSections && (targetOfGOT->size() > 1024*1024)

                                                                                         && (   (targetOfGOT->section().type() == ld::Section::typeZeroFill)

                                                                                                 || (targetOfGOT->section().type() == ld::Section::typeTentativeDefs)) ) {

134 *optimizable = false;

135 }

                         if ( targetOfGOT->scope() == ld::Atom::scopeGlobal ) {

137 // cannot do LEA optimization if target is weak exported symbol

                                 if ( ((targetOfGOT->definition() == ld::Atom::definitionRegular) || (targetOfGOT->definition() == ld::Atom::definitionProxy)) && (targetOfGOT->combine() == ld::Atom::combineByName) ) {

                                         switch ( opts.outputKind() ) {

140 case Options::kDynamicExecutable:

141 case Options::kDynamicLibrary:

142 case Options::kDynamicBundle:

143 case Options::kKextBundle:

144 *targetIsExternalWeakDef = true;

145 *optimizable = false;

146 break;

147 case Options::kStaticExecutable:

148 case Options::kDyld:

149 case Options::kPreload:

150 case Options::kObjectFile:

151 break;

152 }

153 }

154 // cannot do LEA optimization if target is interposable

                                 if ( opts.interposable(targetOfGOT->name()) ) 

156 *optimizable = false;

157 // cannot do LEA optimization if target is resolver function

                                 if ( targetOfGOT->contentType() == ld::Atom::typeResolver ) 

159 *optimizable = false;

160 // cannot do LEA optimization for flat-namespace

                                 if ( opts.nameSpace() != Options::kTwoLevelNameSpace ) 

162 *optimizable = false;

163 }

                         else if ( targetOfGOT->scope() == ld::Atom::scopeLinkageUnit) {

165 // <rdar://problem/12379969> don't do optimization if target is in custom segment

                                 if ( opts.sharedRegionEligible() ) {

                                         const char* segName = targetOfGOT->section().segmentName();

                                         if ( (strcmp(segName, "__TEXT") != 0) && (strcmp(segName, "__DATA") != 0) ) {

169 *optimizable = false;

170 }

171 }

172 }

173 return true;

                 case ld::Fixup::kindStoreX86PCRel32GOT:

175 #if SUPPORT_ARCH_arm64

                 case ld::Fixup::kindStoreARM64PCRelToGOT:

177 #endif

178 #if SUPPORT_ARCH_arm64e

179 // Note, this handles identifying DWARF unwind info personality functions

                         if (opts.supportsAuthenticatedPointers()) {

                                 if (fixupAtom->section().type() == ld::Section::typeCFI)

182 *targetIsPersonalityFn = true;

183 }

184 #endif

185 *optimizable = false;

186 return true;

                 case ld::Fixup::kindNoneGroupSubordinatePersonality:

188 *optimizable = false;

189 #if SUPPORT_ARCH_arm64e

190 // Note, this is a compact unwind info personality function

                         if (opts.supportsAuthenticatedPointers())

192 *targetIsPersonalityFn = true;

193 #endif

194 return true;

195 default:

196 break;

197 }

198

199 return false;

200 }

201

202 struct AtomByNameSorter

203 {

          bool operator()(const ld::Atom* left, const ld::Atom* right)

205 {

                   return (strcmp(left->name(), right->name()) < 0);

207 }

208 };

209

210 struct GotMapEntry {

         const ld::Atom* atom;

212 bool isPersonalityFn;

213

         bool operator<(const GotMapEntry& other) const {

                 if (atom != other.atom)

216 return atom < other.atom;

                 return (int)isPersonalityFn < (int)other.isPersonalityFn;

218 }

219 };

220

 void doPass(const Options& opts, ld::Internal& internal)

222 {

223 const bool log = false;

224

225 // only make got section in final linked images

         if ( opts.outputKind() == Options::kObjectFile )

227 return;

228

229 // pre-fill gotMap with existing non-lazy pointers

         std::map<GotMapEntry, const ld::Atom*> gotMap;

         for (ld::Internal::FinalSection* sect : internal.sections) {

                 if ( sect->type() != ld::Section::typeNonLazyPointer )

233 continue;

                 for (const ld::Atom* atom : sect->atoms) {

                         const ld::Atom* target = NULL;

                         for (ld::Fixup::iterator fit = atom->fixupsBegin(), end=atom->fixupsEnd(); fit != end; ++fit) {

237 switch (fit->kind) {

                                 case ld::Fixup::kindStoreTargetAddressLittleEndian64:

                                 case ld::Fixup::kindStoreTargetAddressLittleEndian32:

240 switch ( fit->binding ) {

                                                 case ld::Fixup::bindingsIndirectlyBound:

                                                         target = internal.indirectBindingTable[fit->u.bindingIndex];

243 break;

                                                 case ld::Fixup::bindingDirectlyBound:

245 target = fit->u.target;

246 break;

247 default:

                                                         fprintf(stderr, "non-pointer is got entry\n");

249 break;

250 }

251 break;

252 default:

253 break;

254 }

255 }

256 if ( target != NULL ) {

                                 if (log) fprintf(stderr, "found existing got entry to %s\n", target->name());

                                 gotMap[{ target, false }] = atom;

259 }

260 }

261 }

262

263 // walk all atoms and fixups looking for GOT-able references

264 // don't create GOT atoms during this loop because that could invalidate the sections iterator

         std::vector<const ld::Atom*> atomsReferencingGOT;

         std::map<const ld::Atom*,bool>          weakImportMap;

         std::map<const ld::Atom*,bool>          weakDefMap;

         atomsReferencingGOT.reserve(128);

         for (std::vector<ld::Internal::FinalSection*>::iterator sit=internal.sections.begin(); sit != internal.sections.end(); ++sit) {

                 ld::Internal::FinalSection* sect = *sit;

                 for (std::vector<const ld::Atom*>::iterator ait=sect->atoms.begin();  ait != sect->atoms.end(); ++ait) {

                         const ld::Atom* atom = *ait;

273 bool atomUsesGOT = false;

                         const ld::Atom* targetOfGOT = NULL;

275 bool targetIsWeakImport = false;

                         for (ld::Fixup::iterator fit = atom->fixupsBegin(), end=atom->fixupsEnd(); fit != end; ++fit) {

                                 if ( fit->firstInCluster() ) 

278 targetOfGOT = NULL;

279 switch ( fit->binding ) {

                                         case ld::Fixup::bindingsIndirectlyBound:

                                                 targetOfGOT = internal.indirectBindingTable[fit->u.bindingIndex];

282 targetIsWeakImport = fit->weakImport;

283 break;

                                         case ld::Fixup::bindingDirectlyBound:

285 targetOfGOT = fit->u.target;

286 targetIsWeakImport = fit->weakImport;

287 break;

288 default:

289 break;

290 }

291 bool optimizable;

292 bool targetIsExternalWeakDef;

293 bool targetIsPersonalityFn;

                                 if ( !gotFixup(opts, internal, targetOfGOT, atom, fit, &optimizable, &targetIsExternalWeakDef, &targetIsPersonalityFn) )

295 continue;

296 if ( optimizable ) {

297 // change from load of GOT entry to lea of target

                                         if ( log ) fprintf(stderr, "optimized GOT usage in %s to %s\n", atom->name(), targetOfGOT->name());

299 switch ( fit->binding ) {

                                                 case ld::Fixup::bindingsIndirectlyBound:

                                                 case ld::Fixup::bindingDirectlyBound:

                                                         fit->binding = ld::Fixup::bindingDirectlyBound;

303 fit->u.target = targetOfGOT;

304 switch ( fit->kind ) {

                                                                 case ld::Fixup::kindStoreTargetAddressX86PCRel32GOTLoad:

                                                                         fit->kind = ld::Fixup::kindStoreTargetAddressX86PCRel32GOTLoadNowLEA;

307 break;

308 #if SUPPORT_ARCH_arm64

                                                                 case ld::Fixup::kindStoreTargetAddressARM64GOTLoadPage21:

                                                                         fit->kind = ld::Fixup::kindStoreTargetAddressARM64GOTLeaPage21;

311 break;

                                                                 case ld::Fixup::kindStoreTargetAddressARM64GOTLoadPageOff12:

                                                                         fit->kind = ld::Fixup::kindStoreTargetAddressARM64GOTLeaPageOff12;

314 break;

315 #endif

316 default:

                                                                         assert(0 && "unsupported GOT reference kind");

318 break;

319 }

320 break;

321 default:

                                                         assert(0 && "unsupported GOT reference");

323 break;

324 }

325 }

326 else {

327 // remember that we need to use GOT in this function

                                         if ( log ) fprintf(stderr, "found GOT use in %s\n", atom->name());

329 if ( !atomUsesGOT ) {

330 atomsReferencingGOT.push_back(atom);

331 atomUsesGOT = true;

332 }

                                         if ( gotMap.count({ targetOfGOT, targetIsPersonalityFn }) == 0 )

334 gotMap[{ targetOfGOT, targetIsPersonalityFn }] = NULL;

335 // record if target is weak def

336 weakDefMap[targetOfGOT] = targetIsExternalWeakDef;

337 // record weak_import attribute

                                         std::map<const ld::Atom*,bool>::iterator pos = weakImportMap.find(targetOfGOT);

                                         if ( pos == weakImportMap.end() ) {

340 // target not in weakImportMap, so add

                                                 if ( log ) fprintf(stderr, "weakImportMap[%s] = %d\n", targetOfGOT->name(), targetIsWeakImport);

342 weakImportMap[targetOfGOT] = targetIsWeakImport;

343 }

344 else {

345 // target in weakImportMap, check for weakness mismatch

                                                 if ( pos->second != targetIsWeakImport ) {

347 // found mismatch

                                                         switch ( opts.weakReferenceMismatchTreatment() ) {

349 case Options::kWeakReferenceMismatchError:

                                                                         throwf("mismatching weak references for symbol: %s", targetOfGOT->name());

351 case Options::kWeakReferenceMismatchWeak:

352 pos->second = true;

353 break;

354 case Options::kWeakReferenceMismatchNonWeak:

355 pos->second = false;

356 break;

357 }

358 }

359 }

360 }

361 }

362 }

363 }

364

365 bool is64 = false;

         switch ( opts.architecture() ) {

367 #if SUPPORT_ARCH_i386

368 case CPU_TYPE_I386:

369 is64 = false;

370 break;

371 #endif

372 #if SUPPORT_ARCH_x86_64

373 case CPU_TYPE_X86_64:

374 is64 = true;

375 break;

376 #endif

377 #if SUPPORT_ARCH_arm_any

378 case CPU_TYPE_ARM:

379 is64 = false;

380 break;

381 #endif

382 #if SUPPORT_ARCH_arm64

383 case CPU_TYPE_ARM64:

384 is64 = true;

385 break;

386 #endif

387 }

388

389 // make GOT entries

         for (auto& entry : gotMap) {

                 if ( entry.second == NULL ) {

392 #if SUPPORT_ARCH_arm64e

                         if ( entry.first.isPersonalityFn && (opts.supportsAuthenticatedPointers()) ) {

                                 entry.second = new GOTAuthEntryAtom(internal, entry.first.atom, weakImportMap[entry.first.atom], opts.useDataConstSegment() && weakDefMap[entry.first.atom]);

                                 if (log) fprintf(stderr, "making new GOT slot for %s, gotMap[%p] = %p\n", entry.first.atom->name(), entry.first.atom, entry.second);

396 continue;

397 }

398 #endif

                         entry.second = new GOTEntryAtom(internal, entry.first.atom, weakImportMap[entry.first.atom], opts.useDataConstSegment() && weakDefMap[entry.first.atom], is64);

                         if (log) fprintf(stderr, "making new GOT slot for %s, gotMap[%p] = %p\n", entry.first.atom->name(), entry.first.atom, entry.second);

401 }

402 }

403

404

405 // update atoms to use GOT entries

         for (std::vector<const ld::Atom*>::iterator it=atomsReferencingGOT.begin(); it != atomsReferencingGOT.end(); ++it) {

                 const ld::Atom* atom = *it;

                 const ld::Atom* targetOfGOT = NULL;

                 ld::Fixup::iterator fitThatSetTarget = NULL;

                 for (ld::Fixup::iterator fit = atom->fixupsBegin(), end=atom->fixupsEnd(); fit != end; ++fit) {

                         if ( fit->firstInCluster() ) {

412 targetOfGOT = NULL;

413 fitThatSetTarget = NULL;

414 }

415 switch ( fit->binding ) {

                                 case ld::Fixup::bindingsIndirectlyBound:

                                         targetOfGOT = internal.indirectBindingTable[fit->u.bindingIndex];

418 fitThatSetTarget = fit;

419 break;

                                 case ld::Fixup::bindingDirectlyBound:

421 targetOfGOT = fit->u.target;

422 fitThatSetTarget = fit;

423 break;

424 default:

425 break;

426 }

427 bool optimizable;

428 bool targetIsExternalWeakDef;

429 bool targetIsPersonalityFn;

                         if ( (targetOfGOT == NULL) || !gotFixup(opts, internal, targetOfGOT, atom, fit,

431 &optimizable, &targetIsExternalWeakDef, &targetIsPersonalityFn) )

432 continue;

433 if ( !optimizable ) {

434 // GOT use not optimized away, update to bind to GOT entry

435 assert(fitThatSetTarget != NULL);

436 switch ( fitThatSetTarget->binding ) {

                                         case ld::Fixup::bindingsIndirectlyBound:

                                         case ld::Fixup::bindingDirectlyBound:

                                                 if ( log ) fprintf(stderr, "updating GOT use in %s to %s\n", atom->name(), targetOfGOT->name());

                                                 fitThatSetTarget->binding = ld::Fixup::bindingDirectlyBound;

                                                 fitThatSetTarget->u.target = gotMap[{ targetOfGOT, targetIsPersonalityFn }];

442 break;

443 default:

                                                 assert(0 && "unsupported GOT reference");

445 break;

446 }

447 }

448 }

449 }

450

451 // sort new atoms so links are consistent

         for (std::vector<ld::Internal::FinalSection*>::iterator sit=internal.sections.begin(); sit != internal.sections.end(); ++sit) {

                 ld::Internal::FinalSection* sect = *sit;

                 if ( sect->type() == ld::Section::typeNonLazyPointer ) {

                         std::sort(sect->atoms.begin(), sect->atoms.end(), AtomByNameSorter());

456 }

457 }

458 }

459

460

461 } // namespace got

462 } // namespace passes

463 } // namespace ld