]> git.saurik.com Git - apple/ld64.git/blob - src/ld/passes/objc.cpp
projects / apple / ld64.git / blob
? search:


b209b1dd61217066c1c92958fce8991a97cb866b
[apple/ld64.git] / src / ld / passes / objc.cpp
1 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
2 *
3 * Copyright (c) 2010-2011 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 #include <stdint.h>
27 #include <math.h>
28 #include <unistd.h>
29 #include <dlfcn.h>
30 #include <mach/machine.h>
31
32 #include <vector>
33 #include <map>
34 #include <set>
35
36 #include "Architectures.hpp"
37 #include "MachOFileAbstraction.hpp"
38
39 #include "ld.hpp"
40 #include "objc.h"
41
42 namespace ld {
43 namespace passes {
44 namespace objc {
45
46
47
48 struct objc_image_info {
49 uint32_t version; // initially 0
50 uint32_t flags;
51 };
52
53 #define OBJC_IMAGE_IS_REPLACEMENT (1<<0)
54 #define OBJC_IMAGE_SUPPORTS_GC (1<<1)
55 #define OBJC_IMAGE_REQUIRES_GC (1<<2)
56 #define OBJC_IMAGE_OPTIMIZED_BY_DYLD (1<<3)
57 #define OBJC_IMAGE_SUPPORTS_COMPACTION (1<<4)
58
59
60
61 //
62 // This class is the 8 byte section containing ObjC flags
63 //
64 template <typename A>
65 class ObjCImageInfoAtom : public ld::Atom {
66 public:
67 ObjCImageInfoAtom(ld::File::ObjcConstraint objcConstraint,
68 bool compaction, bool objcReplacementClasses, bool abi2);
69
70 virtual const ld::File* file() const { return NULL; }
71 virtual bool translationUnitSource(const char** dir, const char**) const
72 { return false; }
73 virtual const char* name() const { return "objc image info"; }
74 virtual uint64_t size() const { return sizeof(objc_image_info); }
75 virtual uint64_t objectAddress() const { return 0; }
76 virtual void setScope(Scope) { }
77 virtual void copyRawContent(uint8_t buffer[]) const {
78 memcpy(buffer, &_content, sizeof(objc_image_info));
79 }
80
81 private:
82 objc_image_info _content;
83
84 static ld::Section _s_sectionABI1;
85 static ld::Section _s_sectionABI2;
86 };
87
88 template <typename A> ld::Section ObjCImageInfoAtom<A>::_s_sectionABI1("__OBJC", "__image_info", ld::Section::typeUnclassified);
89 template <typename A> ld::Section ObjCImageInfoAtom<A>::_s_sectionABI2("__DATA", "__objc_imageinfo", ld::Section::typeUnclassified);
90
91
92 template <typename A>
93 ObjCImageInfoAtom<A>::ObjCImageInfoAtom(ld::File::ObjcConstraint objcConstraint, bool compaction,
94 bool objcReplacementClasses, bool abi2)
95 : ld::Atom(abi2 ? _s_sectionABI2 : _s_sectionABI1, ld::Atom::definitionRegular, ld::Atom::combineNever,
96 ld::Atom::scopeLinkageUnit, ld::Atom::typeUnclassified,
97 symbolTableNotIn, false, false, false, ld::Atom::Alignment(2))
98 {
99
100 uint32_t value = 0;
101 if ( objcReplacementClasses )
102 value = OBJC_IMAGE_IS_REPLACEMENT;
103 switch ( objcConstraint ) {
104 case ld::File::objcConstraintNone:
105 case ld::File::objcConstraintRetainRelease:
106 if ( compaction )
107 warning("ignoring -objc_gc_compaction because code not compiled for ObjC garbage collection");
108 break;
109 case ld::File::objcConstraintRetainReleaseOrGC:
110 value |= OBJC_IMAGE_SUPPORTS_GC;
111 if ( compaction )
112 value |= OBJC_IMAGE_SUPPORTS_COMPACTION;
113 break;
114 case ld::File::objcConstraintGC:
115 value |= OBJC_IMAGE_SUPPORTS_GC | OBJC_IMAGE_REQUIRES_GC;
116 if ( compaction )
117 value |= OBJC_IMAGE_SUPPORTS_COMPACTION;
118 break;
119 }
120
121 _content.version = 0;
122 A::P::E::set32(_content.flags, value);
123 }
124
125
126
127 //
128 // This class is for a new Atom which is an ObjC method list created by merging method lists from categories
129 //
130 template <typename A>
131 class MethodListAtom : public ld::Atom {
132 public:
133 MethodListAtom(ld::Internal& state, const ld::Atom* baseMethodList, bool meta,
134 const std::vector<const ld::Atom*>* categories,
135 std::set<const ld::Atom*>& deadAtoms);
136
137 virtual const ld::File* file() const { return _file; }
138 virtual bool translationUnitSource(const char** dir, const char**) const
139 { return false; }
140 virtual const char* name() const { return "objc merged method list"; }
141 virtual uint64_t size() const { return _methodCount*3*sizeof(pint_t) + 8; }
142 virtual uint64_t objectAddress() const { return 0; }
143 virtual void setScope(Scope) { }
144 virtual void copyRawContent(uint8_t buffer[]) const {
145 bzero(buffer, size());
146 A::P::E::set32(*((uint32_t*)(&buffer[0])), 24);
147 A::P::E::set32(*((uint32_t*)(&buffer[4])), _methodCount);
148 }
149 virtual ld::Fixup::iterator fixupsBegin() const { return (ld::Fixup*)&_fixups[0]; }
150 virtual ld::Fixup::iterator fixupsEnd() const { return (ld::Fixup*)&_fixups[_fixups.size()]; }
151
152 private:
153 typedef typename A::P::uint_t pint_t;
154
155 const ld::File* _file;
156 unsigned int _methodCount;
157 std::vector<ld::Fixup> _fixups;
158
159 static ld::Section _s_section;
160 };
161
162 template <typename A>
163 ld::Section MethodListAtom<A>::_s_section("__DATA", "__objc_const", ld::Section::typeUnclassified);
164
165
166 //
167 // This class is for a new Atom which is an ObjC protocol list created by merging protocol lists from categories
168 //
169 template <typename A>
170 class ProtocolListAtom : public ld::Atom {
171 public:
172 ProtocolListAtom(ld::Internal& state, const ld::Atom* baseProtocolList,
173 const std::vector<const ld::Atom*>* categories,
174 std::set<const ld::Atom*>& deadAtoms);
175
176 virtual const ld::File* file() const { return _file; }
177 virtual bool translationUnitSource(const char** dir, const char**) const
178 { return false; }
179 virtual const char* name() const { return "objc merged protocol list"; }
180 virtual uint64_t size() const { return (_protocolCount+1)*sizeof(pint_t); }
181 virtual uint64_t objectAddress() const { return 0; }
182 virtual void setScope(Scope) { }
183 virtual void copyRawContent(uint8_t buffer[]) const {
184 bzero(buffer, size());
185 A::P::setP(*((pint_t*)(buffer)), _protocolCount);
186 }
187 virtual ld::Fixup::iterator fixupsBegin() const { return (ld::Fixup*)&_fixups[0]; }
188 virtual ld::Fixup::iterator fixupsEnd() const { return (ld::Fixup*)&_fixups[_fixups.size()]; }
189
190 private:
191 typedef typename A::P::uint_t pint_t;
192
193 const ld::File* _file;
194 unsigned int _protocolCount;
195 std::vector<ld::Fixup> _fixups;
196
197 static ld::Section _s_section;
198 };
199
200 template <typename A>
201 ld::Section ProtocolListAtom<A>::_s_section("__DATA", "__objc_const", ld::Section::typeUnclassified);
202
203
204
205 //
206 // This class is for a new Atom which is an ObjC property list created by merging property lists from categories
207 //
208 template <typename A>
209 class PropertyListAtom : public ld::Atom {
210 public:
211 PropertyListAtom(ld::Internal& state, const ld::Atom* baseProtocolList,
212 const std::vector<const ld::Atom*>* categories,
213 std::set<const ld::Atom*>& deadAtoms);
214
215 virtual const ld::File* file() const { return _file; }
216 virtual bool translationUnitSource(const char** dir, const char**) const
217 { return false; }
218 virtual const char* name() const { return "objc merged property list"; }
219 virtual uint64_t size() const { return _propertyCount*2*sizeof(pint_t) + 8; }
220 virtual uint64_t objectAddress() const { return 0; }
221 virtual void setScope(Scope) { }
222 virtual void copyRawContent(uint8_t buffer[]) const {
223 bzero(buffer, size());
224 A::P::E::set32(((uint32_t*)(buffer))[0], 2*sizeof(pint_t)); // sizeof(objc_property)
225 A::P::E::set32(((uint32_t*)(buffer))[1], _propertyCount);
226 }
227 virtual ld::Fixup::iterator fixupsBegin() const { return (ld::Fixup*)&_fixups[0]; }
228 virtual ld::Fixup::iterator fixupsEnd() const { return (ld::Fixup*)&_fixups[_fixups.size()]; }
229
230 private:
231 typedef typename A::P::uint_t pint_t;
232
233 const ld::File* _file;
234 unsigned int _propertyCount;
235 std::vector<ld::Fixup> _fixups;
236
237 static ld::Section _s_section;
238 };
239
240 template <typename A>
241 ld::Section PropertyListAtom<A>::_s_section("__DATA", "__objc_const", ld::Section::typeUnclassified);
242
243
244
245
246
247 //
248 // This class is used to create an Atom that replaces an atom from a .o file that holds a class_ro_t.
249 // It is needed because there is no way to add Fixups to an existing atom.
250 //
251 template <typename A>
252 class ClassROOverlayAtom : public ld::Atom {
253 public:
254 ClassROOverlayAtom(const ld::Atom* classROAtom);
255
256 // overrides of ld::Atom
257 virtual const ld::File* file() const { return _atom->file(); }
258 virtual bool translationUnitSource(const char** dir, const char** nm) const
259 { return _atom->translationUnitSource(dir, nm); }
260 virtual const char* name() const { return _atom->name(); }
261 virtual uint64_t size() const { return _atom->size(); }
262 virtual uint64_t objectAddress() const { return _atom->objectAddress(); }
263 virtual void copyRawContent(uint8_t buffer[]) const
264 { _atom->copyRawContent(buffer); }
265 virtual const uint8_t* rawContentPointer() const
266 { return _atom->rawContentPointer(); }
267 virtual unsigned long contentHash(const class ld::IndirectBindingTable& ibt) const
268 { return _atom->contentHash(ibt); }
269 virtual bool canCoalesceWith(const ld::Atom& rhs, const class ld::IndirectBindingTable& ibt) const
270 { return _atom->canCoalesceWith(rhs,ibt); }
271
272 virtual ld::Fixup::iterator fixupsBegin() const { return (ld::Fixup*)&_fixups[0]; }
273 virtual ld::Fixup::iterator fixupsEnd() const { return (ld::Fixup*)&_fixups[_fixups.size()]; }
274
275 void addProtocolListFixup();
276 void addPropertyListFixup();
277 void addMethodListFixup();
278
279 private:
280 typedef typename A::P::uint_t pint_t;
281
282 const ld::Atom* _atom;
283 std::vector<ld::Fixup> _fixups;
284 };
285
286 template <typename A>
287 ClassROOverlayAtom<A>::ClassROOverlayAtom(const ld::Atom* classROAtom)
288 : ld::Atom(classROAtom->section(), ld::Atom::definitionRegular, ld::Atom::combineNever,
289 ld::Atom::scopeLinkageUnit, ld::Atom::typeUnclassified,
290 classROAtom->symbolTableInclusion(), false, false, false, classROAtom->alignment()),
291 _atom(classROAtom)
292 {
293 // ensure all attributes are same as original
294 this->setAttributesFromAtom(*classROAtom);
295
296 // copy fixups from orginal atom
297 for (ld::Fixup::iterator fit=classROAtom->fixupsBegin(); fit != classROAtom->fixupsEnd(); ++fit) {
298 ld::Fixup fixup = *fit;
299 _fixups.push_back(fixup);
300 }
301 }
302
303
304 //
305 // Base class for reading and updating existing ObjC atoms from .o files
306 //
307 template <typename A>
308 class ObjCData {
309 public:
310 static const ld::Atom* getPointerInContent(ld::Internal& state, const ld::Atom* contentAtom, unsigned int offset, bool* hasAddend=NULL);
311 static void setPointerInContent(ld::Internal& state, const ld::Atom* contentAtom,
312 unsigned int offset, const ld::Atom* newAtom);
313 typedef typename A::P::uint_t pint_t;
314 };
315
316 template <typename A>
317 const ld::Atom* ObjCData<A>::getPointerInContent(ld::Internal& state, const ld::Atom* contentAtom, unsigned int offset, bool* hasAddend)
318 {
319 const ld::Atom* target = NULL;
320 if ( hasAddend != NULL )
321 *hasAddend = false;
322 for (ld::Fixup::iterator fit=contentAtom->fixupsBegin(); fit != contentAtom->fixupsEnd(); ++fit) {
323 if ( fit->offsetInAtom == offset ) {
324 switch ( fit->binding ) {
325 case ld::Fixup::bindingsIndirectlyBound:
326 target = state.indirectBindingTable[fit->u.bindingIndex];
327 break;
328 case ld::Fixup::bindingDirectlyBound:
329 target = fit->u.target;
330 break;
331 case ld::Fixup::bindingNone:
332 if ( fit->kind == ld::Fixup::kindAddAddend ) {
333 if ( hasAddend != NULL )
334 *hasAddend = true;
335 }
336 break;
337 default:
338 break;
339 }
340 }
341 }
342 return target;
343 }
344
345 template <typename A>
346 void ObjCData<A>::setPointerInContent(ld::Internal& state, const ld::Atom* contentAtom,
347 unsigned int offset, const ld::Atom* newAtom)
348 {
349 for (ld::Fixup::iterator fit=contentAtom->fixupsBegin(); fit != contentAtom->fixupsEnd(); ++fit) {
350 if ( fit->offsetInAtom == offset ) {
351 switch ( fit->binding ) {
352 case ld::Fixup::bindingsIndirectlyBound:
353 state.indirectBindingTable[fit->u.bindingIndex] = newAtom;
354 return;
355 case ld::Fixup::bindingDirectlyBound:
356 fit->u.target = newAtom;
357 return;
358 default:
359 break;
360 }
361 }
362 }
363 assert(0 && "could not update method list");
364 }
365
366
367
368 //
369 // Helper class for reading and updating existing ObjC category atoms from .o files
370 //
371 template <typename A>
372 class Category : public ObjCData<A> {
373 public:
374 static const ld::Atom* getClass(ld::Internal& state, const ld::Atom* contentAtom);
375 static const ld::Atom* getInstanceMethods(ld::Internal& state, const ld::Atom* contentAtom);
376 static const ld::Atom* getClassMethods(ld::Internal& state, const ld::Atom* contentAtom);
377 static const ld::Atom* getProtocols(ld::Internal& state, const ld::Atom* contentAtom);
378 static const ld::Atom* getProperties(ld::Internal& state, const ld::Atom* contentAtom);
379 static uint32_t size() { return 6*sizeof(pint_t); }
380 private:
381 typedef typename A::P::uint_t pint_t;
382 };
383
384
385 template <typename A>
386 const ld::Atom* Category<A>::getClass(ld::Internal& state, const ld::Atom* contentAtom)
387 {
388 return ObjCData<A>::getPointerInContent(state, contentAtom, sizeof(pint_t)); // category_t.cls
389 }
390
391 template <typename A>
392 const ld::Atom* Category<A>::getInstanceMethods(ld::Internal& state, const ld::Atom* contentAtom)
393 {
394 return ObjCData<A>::getPointerInContent(state, contentAtom, 2*sizeof(pint_t)); // category_t.instanceMethods
395 }
396
397 template <typename A>
398 const ld::Atom* Category<A>::getClassMethods(ld::Internal& state, const ld::Atom* contentAtom)
399 {
400 return ObjCData<A>::getPointerInContent(state, contentAtom, 3*sizeof(pint_t)); // category_t.classMethods
401 }
402
403 template <typename A>
404 const ld::Atom* Category<A>::getProtocols(ld::Internal& state, const ld::Atom* contentAtom)
405 {
406 return ObjCData<A>::getPointerInContent(state, contentAtom, 4*sizeof(pint_t)); // category_t.protocols
407 }
408
409 template <typename A>
410 const ld::Atom* Category<A>::getProperties(ld::Internal& state, const ld::Atom* contentAtom)
411 {
412 return ObjCData<A>::getPointerInContent(state, contentAtom, 5*sizeof(pint_t)); // category_t.instanceProperties
413 }
414
415
416 template <typename A>
417 class MethodList : public ObjCData<A> {
418 public:
419 static uint32_t count(ld::Internal& state, const ld::Atom* methodListAtom) {
420 const uint32_t* methodListData = (uint32_t*)(methodListAtom->rawContentPointer());
421 return A::P::E::get32(methodListData[1]); // method_list_t.count
422 }
423 };
424
425 template <typename A>
426 class ProtocolList : public ObjCData<A> {
427 public:
428 static uint32_t count(ld::Internal& state, const ld::Atom* protocolListAtom) {
429 pint_t* protocolListData = (pint_t*)(protocolListAtom->rawContentPointer());
430 return A::P::getP(*protocolListData); // protocol_list_t.count
431 }
432 private:
433 typedef typename A::P::uint_t pint_t;
434 };
435
436 template <typename A>
437 class PropertyList : public ObjCData<A> {
438 public:
439 static uint32_t count(ld::Internal& state, const ld::Atom* protocolListAtom) {
440 uint32_t* protocolListData = (uint32_t*)(protocolListAtom->rawContentPointer());
441 return A::P::E::get32(protocolListData[1]); // property_list_t.count
442 }
443 private:
444 typedef typename A::P::uint_t pint_t;
445 };
446
447
448
449 //
450 // Helper class for reading and updating existing ObjC class atoms from .o files
451 //
452 template <typename A>
453 class Class : public ObjCData<A> {
454 public:
455 static const ld::Atom* getInstanceMethodList(ld::Internal& state, const ld::Atom* classAtom);
456 static const ld::Atom* getInstanceProtocolList(ld::Internal& state, const ld::Atom* classAtom);
457 static const ld::Atom* getInstancePropertyList(ld::Internal& state, const ld::Atom* classAtom);
458 static const ld::Atom* getClassMethodList(ld::Internal& state, const ld::Atom* classAtom);
459 static const ld::Atom* setInstanceMethodList(ld::Internal& state, const ld::Atom* classAtom,
460 const ld::Atom* methodListAtom, std::set<const ld::Atom*>& deadAtoms);
461 static const ld::Atom* setInstanceProtocolList(ld::Internal& state, const ld::Atom* classAtom,
462 const ld::Atom* protocolListAtom, std::set<const ld::Atom*>& deadAtoms);
463 static const ld::Atom* setInstancePropertyList(ld::Internal& state, const ld::Atom* classAtom,
464 const ld::Atom* propertyListAtom, std::set<const ld::Atom*>& deadAtoms);
465 static const ld::Atom* setClassMethodList(ld::Internal& state, const ld::Atom* classAtom,
466 const ld::Atom* methodListAtom, std::set<const ld::Atom*>& deadAtoms);
467 static const ld::Atom* setClassProtocolList(ld::Internal& state, const ld::Atom* classAtom,
468 const ld::Atom* protocolListAtom, std::set<const ld::Atom*>& deadAtoms);
469 static uint32_t size() { return 5*sizeof(pint_t); }
470 static unsigned int class_ro_header_size();
471 private:
472 typedef typename A::P::uint_t pint_t;
473 static const ld::Atom* getROData(ld::Internal& state, const ld::Atom* classAtom);
474 };
475
476 template <> unsigned int Class<x86_64>::class_ro_header_size() { return 16; }
477 template <> unsigned int Class<arm>::class_ro_header_size() { return 12;}
478 template <> unsigned int Class<x86>::class_ro_header_size() { return 12; }
479
480
481 template <typename A>
482 const ld::Atom* Class<A>::getROData(ld::Internal& state, const ld::Atom* classAtom)
483 {
484 return ObjCData<A>::getPointerInContent(state, classAtom, 4*sizeof(pint_t)); // class_t.data
485
486 }
487
488 template <typename A>
489 const ld::Atom* Class<A>::getInstanceMethodList(ld::Internal& state, const ld::Atom* classAtom)
490 {
491 const ld::Atom* classROAtom = getROData(state, classAtom); // class_t.data
492 assert(classROAtom != NULL);
493 return ObjCData<A>::getPointerInContent(state, classROAtom, class_ro_header_size() + 2*sizeof(pint_t)); // class_ro_t.baseMethods
494 }
495
496 template <typename A>
497 const ld::Atom* Class<A>::getInstanceProtocolList(ld::Internal& state, const ld::Atom* classAtom)
498 {
499 const ld::Atom* classROAtom = getROData(state, classAtom); // class_t.data
500 assert(classROAtom != NULL);
501 return ObjCData<A>::getPointerInContent(state, classROAtom, class_ro_header_size() + 3*sizeof(pint_t)); // class_ro_t.baseProtocols
502 }
503
504 template <typename A>
505 const ld::Atom* Class<A>::getInstancePropertyList(ld::Internal& state, const ld::Atom* classAtom)
506 {
507 const ld::Atom* classROAtom = getROData(state, classAtom); // class_t.data
508 assert(classROAtom != NULL);
509 return ObjCData<A>::getPointerInContent(state, classROAtom, class_ro_header_size() + 6*sizeof(pint_t)); // class_ro_t.baseProperties
510 }
511
512 template <typename A>
513 const ld::Atom* Class<A>::getClassMethodList(ld::Internal& state, const ld::Atom* classAtom)
514 {
515 const ld::Atom* metaClassAtom = ObjCData<A>::getPointerInContent(state, classAtom, 0); // class_t.isa
516 assert(metaClassAtom != NULL);
517 return Class<A>::getInstanceMethodList(state, metaClassAtom);
518 }
519
520 template <typename A>
521 const ld::Atom* Class<A>::setInstanceMethodList(ld::Internal& state, const ld::Atom* classAtom,
522 const ld::Atom* methodListAtom, std::set<const ld::Atom*>& deadAtoms)
523 {
524 const ld::Atom* classROAtom = getROData(state, classAtom); // class_t.data
525 assert(classROAtom != NULL);
526 // if the base class does not already have a method list, we need to create an overlay
527 if ( getInstanceMethodList(state, classAtom) == NULL ) {
528 ClassROOverlayAtom<A>* overlay = new ClassROOverlayAtom<A>(classROAtom);
529 //fprintf(stderr, "replace class RO atom %p with %p for method list in class atom %s\n", classROAtom, overlay, classAtom->name());
530 overlay->addMethodListFixup();
531 ObjCData<A>::setPointerInContent(state, classAtom, 4*sizeof(pint_t), overlay); // class_t.data
532 deadAtoms.insert(classROAtom);
533 ObjCData<A>::setPointerInContent(state, overlay, class_ro_header_size() + 2*sizeof(pint_t), methodListAtom); // class_ro_t.baseMethods
534 return overlay;
535 }
536 ObjCData<A>::setPointerInContent(state, classROAtom, class_ro_header_size() + 2*sizeof(pint_t), methodListAtom); // class_ro_t.baseMethods
537 return NULL; // means classRO atom was not replaced
538 }
539
540 template <typename A>
541 const ld::Atom* Class<A>::setInstanceProtocolList(ld::Internal& state, const ld::Atom* classAtom,
542 const ld::Atom* protocolListAtom, std::set<const ld::Atom*>& deadAtoms)
543 {
544 const ld::Atom* classROAtom = getROData(state, classAtom); // class_t.data
545 assert(classROAtom != NULL);
546 // if the base class does not already have a protocol list, we need to create an overlay
547 if ( getInstanceProtocolList(state, classAtom) == NULL ) {
548 ClassROOverlayAtom<A>* overlay = new ClassROOverlayAtom<A>(classROAtom);
549 //fprintf(stderr, "replace class RO atom %p with %p for protocol list in class atom %s\n", classROAtom, overlay, classAtom->name());
550 overlay->addProtocolListFixup();
551 ObjCData<A>::setPointerInContent(state, classAtom, 4*sizeof(pint_t), overlay); // class_t.data
552 deadAtoms.insert(classROAtom);
553 ObjCData<A>::setPointerInContent(state, overlay, class_ro_header_size() + 3*sizeof(pint_t), protocolListAtom); // class_ro_t.baseProtocols
554 return overlay;
555 }
556 //fprintf(stderr, "set class RO atom %p protocol list in class atom %s\n", classROAtom, classAtom->name());
557 ObjCData<A>::setPointerInContent(state, classROAtom, class_ro_header_size() + 3*sizeof(pint_t), protocolListAtom); // class_ro_t.baseProtocols
558 return NULL; // means classRO atom was not replaced
559 }
560
561 template <typename A>
562 const ld::Atom* Class<A>::setClassProtocolList(ld::Internal& state, const ld::Atom* classAtom,
563 const ld::Atom* protocolListAtom, std::set<const ld::Atom*>& deadAtoms)
564 {
565 // meta class also points to same protocol list as class
566 const ld::Atom* metaClassAtom = ObjCData<A>::getPointerInContent(state, classAtom, 0); // class_t.isa
567 //fprintf(stderr, "setClassProtocolList(), classAtom=%p %s, metaClass=%p %s\n", classAtom, classAtom->name(), metaClassAtom, metaClassAtom->name());
568 assert(metaClassAtom != NULL);
569 return setInstanceProtocolList(state, metaClassAtom, protocolListAtom, deadAtoms);
570 }
571
572
573
574 template <typename A>
575 const ld::Atom* Class<A>::setInstancePropertyList(ld::Internal& state, const ld::Atom* classAtom,
576 const ld::Atom* propertyListAtom, std::set<const ld::Atom*>& deadAtoms)
577 {
578 const ld::Atom* classROAtom = getROData(state, classAtom); // class_t.data
579 assert(classROAtom != NULL);
580 // if the base class does not already have a property list, we need to create an overlay
581 if ( getInstancePropertyList(state, classAtom) == NULL ) {
582 ClassROOverlayAtom<A>* overlay = new ClassROOverlayAtom<A>(classROAtom);
583 //fprintf(stderr, "replace class RO atom %p with %p for property list in class atom %s\n", classROAtom, overlay, classAtom->name());
584 overlay->addPropertyListFixup();
585 ObjCData<A>::setPointerInContent(state, classAtom, 4*sizeof(pint_t), overlay); // class_t.data
586 deadAtoms.insert(classROAtom);
587 ObjCData<A>::setPointerInContent(state, overlay, class_ro_header_size() + 6*sizeof(pint_t), propertyListAtom); // class_ro_t.baseProperties
588 return overlay;
589 }
590 ObjCData<A>::setPointerInContent(state, classROAtom, class_ro_header_size() + 6*sizeof(pint_t), propertyListAtom); // class_ro_t.baseProperties
591 return NULL; // means classRO atom was not replaced
592 }
593
594 template <typename A>
595 const ld::Atom* Class<A>::setClassMethodList(ld::Internal& state, const ld::Atom* classAtom,
596 const ld::Atom* methodListAtom, std::set<const ld::Atom*>& deadAtoms)
597 {
598 // class methods is just instance methods of metaClass
599 const ld::Atom* metaClassAtom = ObjCData<A>::getPointerInContent(state, classAtom, 0); // class_t.isa
600 assert(metaClassAtom != NULL);
601 return setInstanceMethodList(state, metaClassAtom, methodListAtom, deadAtoms);
602 }
603
604
605
606 template <>
607 void ClassROOverlayAtom<x86_64>::addMethodListFixup()
608 {
609 const ld::Atom* targetAtom = this; // temporary
610 uint32_t offset = Class<x86_64>::class_ro_header_size() + 2*8; // class_ro_t.baseMethods
611 _fixups.push_back(ld::Fixup(offset, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian64, targetAtom));
612 }
613
614 template <>
615 void ClassROOverlayAtom<arm>::addMethodListFixup()
616 {
617 const ld::Atom* targetAtom = this; // temporary
618 uint32_t offset = Class<arm>::class_ro_header_size() + 2*4; // class_ro_t.baseMethods
619 _fixups.push_back(ld::Fixup(offset, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, targetAtom));
620 }
621
622 template <>
623 void ClassROOverlayAtom<x86>::addMethodListFixup()
624 {
625 const ld::Atom* targetAtom = this; // temporary
626 uint32_t offset = Class<x86>::class_ro_header_size() + 2*4; // class_ro_t.baseMethods
627 _fixups.push_back(ld::Fixup(offset, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, targetAtom));
628 }
629
630
631
632 template <>
633 void ClassROOverlayAtom<x86_64>::addProtocolListFixup()
634 {
635 const ld::Atom* targetAtom = this; // temporary
636 uint32_t offset = Class<x86_64>::class_ro_header_size() + 3*8; // class_ro_t.baseProtocols
637 _fixups.push_back(ld::Fixup(offset, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian64, targetAtom));
638 }
639
640 template <>
641 void ClassROOverlayAtom<arm>::addProtocolListFixup()
642 {
643 const ld::Atom* targetAtom = this; // temporary
644 uint32_t offset = Class<arm>::class_ro_header_size() + 3*4; // class_ro_t.baseProtocols
645 _fixups.push_back(ld::Fixup(offset, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, targetAtom));
646 }
647
648 template <>
649 void ClassROOverlayAtom<x86>::addProtocolListFixup()
650 {
651 const ld::Atom* targetAtom = this; // temporary
652 uint32_t offset = Class<x86>::class_ro_header_size() + 3*4; // class_ro_t.baseProtocols
653 _fixups.push_back(ld::Fixup(offset, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, targetAtom));
654 }
655
656
657 template <>
658 void ClassROOverlayAtom<x86_64>::addPropertyListFixup()
659 {
660 const ld::Atom* targetAtom = this; // temporary
661 uint32_t offset = Class<x86_64>::class_ro_header_size() + 6*8; // class_ro_t.baseProperties
662 _fixups.push_back(ld::Fixup(offset, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian64, targetAtom));
663 }
664
665 template <>
666 void ClassROOverlayAtom<arm>::addPropertyListFixup()
667 {
668 const ld::Atom* targetAtom = this; // temporary
669 uint32_t offset = Class<arm>::class_ro_header_size() + 6*4; // class_ro_t.baseProperties
670 _fixups.push_back(ld::Fixup(offset, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, targetAtom));
671 }
672
673 template <>
674 void ClassROOverlayAtom<x86>::addPropertyListFixup()
675 {
676 const ld::Atom* targetAtom = this; // temporary
677 uint32_t offset = Class<x86>::class_ro_header_size() + 6*4; // class_ro_t.baseProperties
678 _fixups.push_back(ld::Fixup(offset, ld::Fixup::k1of1, ld::Fixup::kindStoreTargetAddressLittleEndian32, targetAtom));
679 }
680
681
682
683
684 //
685 // Encapsulates merging of ObjC categories
686 //
687 template <typename A>
688 class OptimizeCategories {
689 public:
690 static void doit(const Options& opts, ld::Internal& state);
691 static bool hasInstanceMethods(ld::Internal& state, const std::vector<const ld::Atom*>* categories);
692 static bool hasClassMethods(ld::Internal& state, const std::vector<const ld::Atom*>* categories);
693 static bool hasProtocols(ld::Internal& state, const std::vector<const ld::Atom*>* categories);
694 static bool hasProperties(ld::Internal& state, const std::vector<const ld::Atom*>* categories);
695
696
697 static unsigned int class_ro_baseMethods_offset();
698 private:
699 typedef typename A::P::uint_t pint_t;
700
701 };
702
703
704 template <typename A>
705 bool OptimizeCategories<A>::hasInstanceMethods(ld::Internal& state, const std::vector<const ld::Atom*>* categories)
706 {
707 for (std::vector<const ld::Atom*>::const_iterator it=categories->begin(); it != categories->end(); ++it) {
708 const ld::Atom* categoryAtom = *it;
709 const ld::Atom* methodList = Category<A>::getInstanceMethods(state, categoryAtom);
710 if ( methodList != NULL ) {
711 if ( MethodList<A>::count(state, methodList) > 0 )
712 return true;
713 }
714 }
715 return false;
716 }
717
718
719 template <typename A>
720 bool OptimizeCategories<A>::hasClassMethods(ld::Internal& state, const std::vector<const ld::Atom*>* categories)
721 {
722 for (std::vector<const ld::Atom*>::const_iterator it=categories->begin(); it != categories->end(); ++it) {
723 const ld::Atom* categoryAtom = *it;
724 const ld::Atom* methodList = Category<A>::getClassMethods(state, categoryAtom);
725 if ( methodList != NULL ) {
726 if ( MethodList<A>::count(state, methodList) > 0 )
727 return true;
728 }
729 }
730 return false;
731 }
732
733 template <typename A>
734 bool OptimizeCategories<A>::hasProtocols(ld::Internal& state, const std::vector<const ld::Atom*>* categories)
735 {
736 for (std::vector<const ld::Atom*>::const_iterator it=categories->begin(); it != categories->end(); ++it) {
737 const ld::Atom* categoryAtom = *it;
738 const ld::Atom* protocolListAtom = Category<A>::getProtocols(state, categoryAtom);
739 if ( protocolListAtom != NULL ) {
740 if ( ProtocolList<A>::count(state, protocolListAtom) > 0 ) {
741 return true;
742 }
743 }
744 }
745 return false;
746 }
747
748
749 template <typename A>
750 bool OptimizeCategories<A>::hasProperties(ld::Internal& state, const std::vector<const ld::Atom*>* categories)
751 {
752 for (std::vector<const ld::Atom*>::const_iterator it=categories->begin(); it != categories->end(); ++it) {
753 const ld::Atom* categoryAtom = *it;
754 const ld::Atom* propertyListAtom = Category<A>::getProperties(state, categoryAtom);
755 if ( propertyListAtom != NULL ) {
756 if ( PropertyList<A>::count(state, propertyListAtom) > 0 )
757 return true;
758 }
759 }
760 return false;
761 }
762
763
764
765 //
766 // Helper for std::remove_if
767 //
768 class OptimizedAway {
769 public:
770 OptimizedAway(const std::set<const ld::Atom*>& oa) : _dead(oa) {}
771 bool operator()(const ld::Atom* atom) const {
772 return ( _dead.count(atom) != 0 );
773 }
774 private:
775 const std::set<const ld::Atom*>& _dead;
776 };
777
778 template <typename A>
779 void OptimizeCategories<A>::doit(const Options& opts, ld::Internal& state)
780 {
781 // first find all categories referenced by __objc_nlcatlist section
782 std::set<const ld::Atom*> nlcatListAtoms;
783 for (std::vector<ld::Internal::FinalSection*>::iterator sit=state.sections.begin(); sit != state.sections.end(); ++sit) {
784 ld::Internal::FinalSection* sect = *sit;
785 if ( (strcmp(sect->sectionName(), "__objc_nlcatlist") == 0) && (strcmp(sect->segmentName(), "__DATA") == 0) ) {
786 for (std::vector<const ld::Atom*>::iterator ait=sect->atoms.begin(); ait != sect->atoms.end(); ++ait) {
787 const ld::Atom* categoryListElementAtom = *ait;
788 for (unsigned int offset=0; offset < categoryListElementAtom->size(); offset += sizeof(pint_t)) {
789 const ld::Atom* categoryAtom = ObjCData<A>::getPointerInContent(state, categoryListElementAtom, offset);
790 //fprintf(stderr, "offset=%d, cat=%p %s\n", offset, categoryAtom, categoryAtom->name());
791 assert(categoryAtom != NULL);
792 nlcatListAtoms.insert(categoryAtom);
793 }
794 }
795 }
796 }
797
798 // build map of all classes in this image that have categories on them
799 typedef std::map<const ld::Atom*, std::vector<const ld::Atom*>*> CatMap;
800 CatMap classToCategories;
801 std::set<const ld::Atom*> deadAtoms;
802 ld::Internal::FinalSection* methodListSection = NULL;
803 for (std::vector<ld::Internal::FinalSection*>::iterator sit=state.sections.begin(); sit != state.sections.end(); ++sit) {
804 ld::Internal::FinalSection* sect = *sit;
805 if ( sect->type() == ld::Section::typeObjC2CategoryList ) {
806 for (std::vector<const ld::Atom*>::iterator ait=sect->atoms.begin(); ait != sect->atoms.end(); ++ait) {
807 const ld::Atom* categoryListElementAtom = *ait;
808 bool hasAddend;
809 const ld::Atom* categoryAtom = ObjCData<A>::getPointerInContent(state, categoryListElementAtom, 0, &hasAddend);
810 if ( hasAddend || (categoryAtom->symbolTableInclusion() == ld::Atom::symbolTableNotIn)) {
811 //<rdar://problem/8309530> gcc-4.0 uses 'L' labels on categories which disables this optimization
812 //warning("__objc_catlist element does not point to start of category");
813 continue;
814 }
815 assert(categoryAtom != NULL);
816 assert(categoryAtom->size() == Category<A>::size());
817 // ignore categories also in __objc_nlcatlist
818 if ( nlcatListAtoms.count(categoryAtom) != 0 )
819 continue;
820 const ld::Atom* categoryOnClassAtom = Category<A>::getClass(state, categoryAtom);
821 assert(categoryOnClassAtom != NULL);
822 if ( categoryOnClassAtom->definition() != ld::Atom::definitionProxy ) {
823 // only look at classes defined in this image
824 CatMap::iterator pos = classToCategories.find(categoryOnClassAtom);
825 if ( pos == classToCategories.end() ) {
826 classToCategories[categoryOnClassAtom] = new std::vector<const ld::Atom*>();
827 }
828 classToCategories[categoryOnClassAtom]->push_back(categoryAtom);
829 // mark category atom and catlist atom as dead
830 deadAtoms.insert(categoryAtom);
831 deadAtoms.insert(categoryListElementAtom);
832 }
833 }
834 }
835 // record method list section
836 if ( (strcmp(sect->sectionName(), "__objc_const") == 0) && (strcmp(sect->segmentName(), "__DATA") == 0) )
837 methodListSection = sect;
838 }
839
840 // if found some categories
841 if ( classToCategories.size() != 0 ) {
842 assert(methodListSection != NULL);
843 // alter each class definition to have new method list which includes all category methods
844 for (CatMap::iterator it=classToCategories.begin(); it != classToCategories.end(); ++it) {
845 const ld::Atom* classAtom = it->first;
846 const std::vector<const ld::Atom*>* categories = it->second;
847 assert(categories->size() != 0);
848 // if any category adds instance methods, generate new merged method list, and replace
849 if ( OptimizeCategories<A>::hasInstanceMethods(state, categories) ) {
850 const ld::Atom* baseInstanceMethodListAtom = Class<A>::getInstanceMethodList(state, classAtom);
851 const ld::Atom* newInstanceMethodListAtom = new MethodListAtom<A>(state, baseInstanceMethodListAtom, false, categories, deadAtoms);
852 const ld::Atom* newClassRO = Class<A>::setInstanceMethodList(state, classAtom, newInstanceMethodListAtom, deadAtoms);
853 // add new method list to final sections
854 methodListSection->atoms.push_back(newInstanceMethodListAtom);
855 if ( newClassRO != NULL ) {
856 assert(strcmp(newClassRO->section().sectionName(), "__objc_const") == 0);
857 methodListSection->atoms.push_back(newClassRO);
858 }
859 }
860 // if any category adds class methods, generate new merged method list, and replace
861 if ( OptimizeCategories<A>::hasClassMethods(state, categories) ) {
862 const ld::Atom* baseClassMethodListAtom = Class<A>::getClassMethodList(state, classAtom);
863 const ld::Atom* newClassMethodListAtom = new MethodListAtom<A>(state, baseClassMethodListAtom, true, categories, deadAtoms);
864 const ld::Atom* newClassRO = Class<A>::setClassMethodList(state, classAtom, newClassMethodListAtom, deadAtoms);
865 // add new method list to final sections
866 methodListSection->atoms.push_back(newClassMethodListAtom);
867 if ( newClassRO != NULL ) {
868 assert(strcmp(newClassRO->section().sectionName(), "__objc_const") == 0);
869 methodListSection->atoms.push_back(newClassRO);
870 }
871 }
872 // if any category adds protocols, generate new merged protocol list, and replace
873 if ( OptimizeCategories<A>::hasProtocols(state, categories) ) {
874 const ld::Atom* baseProtocolListAtom = Class<A>::getInstanceProtocolList(state, classAtom);
875 const ld::Atom* newProtocolListAtom = new ProtocolListAtom<A>(state, baseProtocolListAtom, categories, deadAtoms);
876 const ld::Atom* newClassRO = Class<A>::setInstanceProtocolList(state, classAtom, newProtocolListAtom, deadAtoms);
877 const ld::Atom* newMetaClassRO = Class<A>::setClassProtocolList(state, classAtom, newProtocolListAtom, deadAtoms);
878 // add new protocol list to final sections
879 methodListSection->atoms.push_back(newProtocolListAtom);
880 if ( newClassRO != NULL ) {
881 assert(strcmp(newClassRO->section().sectionName(), "__objc_const") == 0);
882 methodListSection->atoms.push_back(newClassRO);
883 }
884 if ( newMetaClassRO != NULL ) {
885 assert(strcmp(newMetaClassRO->section().sectionName(), "__objc_const") == 0);
886 methodListSection->atoms.push_back(newMetaClassRO);
887 }
888 }
889 // if any category adds properties, generate new merged property list, and replace
890 if ( OptimizeCategories<A>::hasProperties(state, categories) ) {
891 const ld::Atom* basePropertyListAtom = Class<A>::getInstancePropertyList(state, classAtom);
892 const ld::Atom* newPropertyListAtom = new PropertyListAtom<A>(state, basePropertyListAtom, categories, deadAtoms);
893 const ld::Atom* newClassRO = Class<A>::setInstancePropertyList(state, classAtom, newPropertyListAtom, deadAtoms);
894 // add new property list to final sections
895 methodListSection->atoms.push_back(newPropertyListAtom);
896 if ( newClassRO != NULL ) {
897 assert(strcmp(newClassRO->section().sectionName(), "__objc_const") == 0);
898 methodListSection->atoms.push_back(newClassRO);
899 }
900 }
901
902 }
903
904 // remove dead atoms
905 for (std::vector<ld::Internal::FinalSection*>::iterator sit=state.sections.begin(); sit != state.sections.end(); ++sit) {
906 ld::Internal::FinalSection* sect = *sit;
907 sect->atoms.erase(std::remove_if(sect->atoms.begin(), sect->atoms.end(), OptimizedAway(deadAtoms)), sect->atoms.end());
908 }
909 }
910 }
911
912
913 template <typename A>
914 MethodListAtom<A>::MethodListAtom(ld::Internal& state, const ld::Atom* baseMethodList, bool meta,
915 const std::vector<const ld::Atom*>* categories, std::set<const ld::Atom*>& deadAtoms)
916 : ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
917 ld::Atom::scopeLinkageUnit, ld::Atom::typeUnclassified,
918 symbolTableNotIn, false, false, false, ld::Atom::Alignment(3)), _file(NULL), _methodCount(0)
919 {
920 unsigned int fixupCount = 0;
921 std::set<const ld::Atom*> baseMethodListMethodNameAtoms;
922 // if base class has method list, then associate new method list with file defining class
923 if ( baseMethodList != NULL ) {
924 _file = baseMethodList->file();
925 // calculate total size of merge method lists
926 _methodCount = MethodList<A>::count(state, baseMethodList);
927 deadAtoms.insert(baseMethodList);
928 fixupCount = baseMethodList->fixupsEnd() - baseMethodList->fixupsBegin();
929 for (ld::Fixup::iterator fit=baseMethodList->fixupsBegin(); fit != baseMethodList->fixupsEnd(); ++fit) {
930 if ( (fit->offsetInAtom - 8) % (3*sizeof(pint_t)) == 0 ) {
931 assert(fit->binding == ld::Fixup::bindingsIndirectlyBound && "malformed method list");
932 const ld::Atom* target = state.indirectBindingTable[fit->u.bindingIndex];
933 assert(target->contentType() == ld::Atom::typeCString && "malformed method list");
934 baseMethodListMethodNameAtoms.insert(target);
935 }
936 }
937 }
938 for (std::vector<const ld::Atom*>::const_iterator ait=categories->begin(); ait != categories->end(); ++ait) {
939 const ld::Atom* categoryMethodListAtom;
940 if ( meta )
941 categoryMethodListAtom = Category<A>::getClassMethods(state, *ait);
942 else
943 categoryMethodListAtom = Category<A>::getInstanceMethods(state, *ait);
944 if ( categoryMethodListAtom != NULL ) {
945 _methodCount += MethodList<A>::count(state, categoryMethodListAtom);
946 fixupCount += (categoryMethodListAtom->fixupsEnd() - categoryMethodListAtom->fixupsBegin());
947 deadAtoms.insert(categoryMethodListAtom);
948 // if base class did not have method list, associate new method list with file the defined category
949 if ( _file == NULL )
950 _file = categoryMethodListAtom->file();
951 }
952 }
953 //if ( baseMethodList != NULL )
954 // fprintf(stderr, "total merged method count=%u for baseMethodList=%s\n", _methodCount, baseMethodList->name());
955 //else
956 // fprintf(stderr, "total merged method count=%u\n", _methodCount);
957 //fprintf(stderr, "total merged fixup count=%u\n", fixupCount);
958
959 // copy fixups and adjust offsets (in reverse order to simulator objc runtime)
960 _fixups.reserve(fixupCount);
961 uint32_t slide = 0;
962 std::set<const ld::Atom*> categoryMethodNameAtoms;
963 for (std::vector<const ld::Atom*>::const_reverse_iterator rit=categories->rbegin(); rit != categories->rend(); ++rit) {
964 const ld::Atom* categoryMethodListAtom;
965 if ( meta )
966 categoryMethodListAtom = Category<A>::getClassMethods(state, *rit);
967 else
968 categoryMethodListAtom = Category<A>::getInstanceMethods(state, *rit);
969 if ( categoryMethodListAtom != NULL ) {
970 for (ld::Fixup::iterator fit=categoryMethodListAtom->fixupsBegin(); fit != categoryMethodListAtom->fixupsEnd(); ++fit) {
971 ld::Fixup fixup = *fit;
972 fixup.offsetInAtom += slide;
973 _fixups.push_back(fixup);
974 if ( (fixup.offsetInAtom - 8) % (3*sizeof(pint_t)) == 0 ) {
975 // <rdar://problem/8642343> warning when a method is overridden in a category in the same link unit
976 assert(fixup.binding == ld::Fixup::bindingsIndirectlyBound && "malformed category method list");
977 const ld::Atom* target = state.indirectBindingTable[fixup.u.bindingIndex];
978 assert(target->contentType() == ld::Atom::typeCString && "malformed method list");
979 // this objc pass happens after cstrings are coalesced, so we can just compare the atom addres instead of its content
980 if ( baseMethodListMethodNameAtoms.count(target) != 0 ) {
981 warning("%s method '%s' in category from %s overrides method from class in %s",
982 (meta ? "meta" : "instance"), target->rawContentPointer(),
983 categoryMethodListAtom->file()->path(), baseMethodList->file()->path() );
984 }
985 if ( categoryMethodNameAtoms.count(target) != 0 ) {
986 warning("%s method '%s' in category from %s conflicts with same method from another category",
987 (meta ? "meta" : "instance"), target->rawContentPointer(),
988 categoryMethodListAtom->file()->path());
989 }
990 categoryMethodNameAtoms.insert(target);
991 }
992 }
993 slide += 3*sizeof(pint_t) * MethodList<A>::count(state, categoryMethodListAtom);
994 }
995 }
996 // add method list from base class last
997 if ( baseMethodList != NULL ) {
998 for (ld::Fixup::iterator fit=baseMethodList->fixupsBegin(); fit != baseMethodList->fixupsEnd(); ++fit) {
999 ld::Fixup fixup = *fit;
1000 fixup.offsetInAtom += slide;
1001 _fixups.push_back(fixup);
1002 }
1003 }
1004 }
1005
1006
1007 template <typename A>
1008 ProtocolListAtom<A>::ProtocolListAtom(ld::Internal& state, const ld::Atom* baseProtocolList,
1009 const std::vector<const ld::Atom*>* categories, std::set<const ld::Atom*>& deadAtoms)
1010 : ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
1011 ld::Atom::scopeLinkageUnit, ld::Atom::typeUnclassified,
1012 symbolTableNotIn, false, false, false, ld::Atom::Alignment(3)), _file(NULL), _protocolCount(0)
1013 {
1014 unsigned int fixupCount = 0;
1015 if ( baseProtocolList != NULL ) {
1016 // if base class has protocol list, then associate new protocol list with file defining class
1017 _file = baseProtocolList->file();
1018 // calculate total size of merged protocol list
1019 _protocolCount = ProtocolList<A>::count(state, baseProtocolList);
1020 deadAtoms.insert(baseProtocolList);
1021 fixupCount = baseProtocolList->fixupsEnd() - baseProtocolList->fixupsBegin();
1022 }
1023 for (std::vector<const ld::Atom*>::const_iterator ait=categories->begin(); ait != categories->end(); ++ait) {
1024 const ld::Atom* categoryProtocolListAtom = Category<A>::getProtocols(state, *ait);
1025 if ( categoryProtocolListAtom != NULL ) {
1026 _protocolCount += ProtocolList<A>::count(state, categoryProtocolListAtom);
1027 fixupCount += (categoryProtocolListAtom->fixupsEnd() - categoryProtocolListAtom->fixupsBegin());
1028 deadAtoms.insert(categoryProtocolListAtom);
1029 // if base class did not have protocol list, associate new protocol list with file the defined category
1030 if ( _file == NULL )
1031 _file = categoryProtocolListAtom->file();
1032 }
1033 }
1034 //fprintf(stderr, "total merged protocol count=%u\n", _protocolCount);
1035 //fprintf(stderr, "total merged fixup count=%u\n", fixupCount);
1036
1037 // copy fixups and adjust offsets
1038 _fixups.reserve(fixupCount);
1039 uint32_t slide = 0;
1040 for (std::vector<const ld::Atom*>::const_iterator it=categories->begin(); it != categories->end(); ++it) {
1041 const ld::Atom* categoryProtocolListAtom = Category<A>::getProtocols(state, *it);
1042 if ( categoryProtocolListAtom != NULL ) {
1043 for (ld::Fixup::iterator fit=categoryProtocolListAtom->fixupsBegin(); fit != categoryProtocolListAtom->fixupsEnd(); ++fit) {
1044 ld::Fixup fixup = *fit;
1045 fixup.offsetInAtom += slide;
1046 _fixups.push_back(fixup);
1047 //if ( fixup.binding == ld::Fixup::bindingDirectlyBound )
1048 // fprintf(stderr, "offset=0x%08X, name=%s\n", fixup.offsetInAtom, fixup.u.target->name());
1049 }
1050 slide += sizeof(pint_t) * ProtocolList<A>::count(state, categoryProtocolListAtom);
1051 }
1052 }
1053 // add method list from base class last
1054 if ( baseProtocolList != NULL ) {
1055 for (ld::Fixup::iterator fit=baseProtocolList->fixupsBegin(); fit != baseProtocolList->fixupsEnd(); ++fit) {
1056 ld::Fixup fixup = *fit;
1057 fixup.offsetInAtom += slide;
1058 _fixups.push_back(fixup);
1059 }
1060 }
1061 }
1062
1063
1064 template <typename A>
1065 PropertyListAtom<A>::PropertyListAtom(ld::Internal& state, const ld::Atom* basePropertyList,
1066 const std::vector<const ld::Atom*>* categories, std::set<const ld::Atom*>& deadAtoms)
1067 : ld::Atom(_s_section, ld::Atom::definitionRegular, ld::Atom::combineNever,
1068 ld::Atom::scopeLinkageUnit, ld::Atom::typeUnclassified,
1069 symbolTableNotIn, false, false, false, ld::Atom::Alignment(3)), _file(NULL), _propertyCount(0)
1070 {
1071 unsigned int fixupCount = 0;
1072 if ( basePropertyList != NULL ) {
1073 // if base class has property list, then associate new property list with file defining class
1074 _file = basePropertyList->file();
1075 // calculate total size of merged property list
1076 _propertyCount = PropertyList<A>::count(state, basePropertyList);
1077 deadAtoms.insert(basePropertyList);
1078 fixupCount = basePropertyList->fixupsEnd() - basePropertyList->fixupsBegin();
1079 }
1080 for (std::vector<const ld::Atom*>::const_iterator ait=categories->begin(); ait != categories->end(); ++ait) {
1081 const ld::Atom* categoryPropertyListAtom = Category<A>::getProperties(state, *ait);
1082 if ( categoryPropertyListAtom != NULL ) {
1083 _propertyCount += PropertyList<A>::count(state, categoryPropertyListAtom);
1084 fixupCount += (categoryPropertyListAtom->fixupsEnd() - categoryPropertyListAtom->fixupsBegin());
1085 deadAtoms.insert(categoryPropertyListAtom);
1086 // if base class did not have property list, associate new property list with file the defined category
1087 if ( _file == NULL )
1088 _file = categoryPropertyListAtom->file();
1089 }
1090 }
1091 //fprintf(stderr, "total merged property count=%u\n", _propertyCount);
1092 //fprintf(stderr, "total merged fixup count=%u\n", fixupCount);
1093
1094 // copy fixups and adjust offsets
1095 _fixups.reserve(fixupCount);
1096 uint32_t slide = 0;
1097 for (std::vector<const ld::Atom*>::const_iterator it=categories->begin(); it != categories->end(); ++it) {
1098 const ld::Atom* categoryPropertyListAtom = Category<A>::getProperties(state, *it);
1099 if ( categoryPropertyListAtom != NULL ) {
1100 for (ld::Fixup::iterator fit=categoryPropertyListAtom->fixupsBegin(); fit != categoryPropertyListAtom->fixupsEnd(); ++fit) {
1101 ld::Fixup fixup = *fit;
1102 fixup.offsetInAtom += slide;
1103 _fixups.push_back(fixup);
1104 //fprintf(stderr, "offset=0x%08X, binding=%d\n", fixup.offsetInAtom, fixup.binding);
1105 //if ( fixup.binding == ld::Fixup::bindingDirectlyBound )
1106 // fprintf(stderr, "offset=0x%08X, name=%s\n", fixup.offsetInAtom, fixup.u.target->name());
1107 //else if ( fixup.binding == ld::Fixup::bindingsIndirectlyBound )
1108 // fprintf(stderr, "offset=0x%08X, indirect index=%u, name=%s\n", fixup.offsetInAtom, fixup.u.bindingIndex,
1109 // (char*)(state.indirectBindingTable[fixup.u.bindingIndex]->rawContentPointer()));
1110 }
1111 slide += 2*sizeof(pint_t) * PropertyList<A>::count(state, categoryPropertyListAtom);
1112 }
1113 }
1114 // add method list from base class last
1115 if ( basePropertyList != NULL ) {
1116 for (ld::Fixup::iterator fit=basePropertyList->fixupsBegin(); fit != basePropertyList->fixupsEnd(); ++fit) {
1117 ld::Fixup fixup = *fit;
1118 fixup.offsetInAtom += slide;
1119 _fixups.push_back(fixup);
1120 }
1121 }
1122 }
1123
1124
1125
1126
1127 void doPass(const Options& opts, ld::Internal& state)
1128 {
1129 // only make image info section if objc was used
1130 if ( state.objcObjectConstraint != ld::File::objcConstraintNone ) {
1131
1132 // verify dylibs are GC compatible with object files
1133 if ( state.objcObjectConstraint != state.objcDylibConstraint ) {
1134 if ( (state.objcDylibConstraint == ld::File::objcConstraintRetainRelease)
1135 && (state.objcObjectConstraint == ld::File::objcConstraintGC) ) {
1136 throw "Linked dylibs built for retain/release but object files built for GC-only";
1137 }
1138 else if ( (state.objcDylibConstraint == ld::File::objcConstraintGC)
1139 && (state.objcObjectConstraint == ld::File::objcConstraintRetainRelease) ) {
1140 throw "Linked dylibs built for GC-only but object files built for retain/release";
1141 }
1142 }
1143
1144 const bool compaction = opts.objcGcCompaction();
1145
1146 // add image info atom
1147 switch ( opts.architecture() ) {
1148 case CPU_TYPE_X86_64:
1149 state.addAtom(*new ObjCImageInfoAtom<x86_64>(state.objcObjectConstraint, compaction,
1150 state.hasObjcReplacementClasses, true));
1151 break;
1152 case CPU_TYPE_I386:
1153 state.addAtom(*new ObjCImageInfoAtom<x86>(state.objcObjectConstraint, compaction,
1154 state.hasObjcReplacementClasses, opts.objCABIVersion2POverride() ? true : false));
1155 break;
1156 case CPU_TYPE_ARM:
1157 state.addAtom(*new ObjCImageInfoAtom<arm>(state.objcObjectConstraint, compaction,
1158 state.hasObjcReplacementClasses, true));
1159 break;
1160 default:
1161 assert(0 && "unknown objc arch");
1162 }
1163 }
1164
1165 if ( opts.objcCategoryMerging() ) {
1166 // optimize classes defined in this linkage unit by merging in categories also in this linkage unit
1167 switch ( opts.architecture() ) {
1168 case CPU_TYPE_X86_64:
1169 OptimizeCategories<x86_64>::doit(opts, state);
1170 break;
1171 case CPU_TYPE_I386:
1172 // disable optimization until fully tested
1173 //if ( opts.objCABIVersion2POverride() )
1174 // OptimizeCategories<x86>::doit(opts, state);
1175 break;
1176 case CPU_TYPE_ARM:
1177 // disable optimization until fully tested
1178 //OptimizeCategories<arm>::doit(opts, state);
1179 break;
1180 default:
1181 assert(0 && "unknown objc arch");
1182 }
1183 }
1184 }
1185
1186
1187 } // namespace objc
1188 } // namespace passes
1189 } // namespace ld
mirror of ld64