preface
Load_image load_image load_image unmap_image Load_image Load_image Load_image Load_image Load_image Unmap_image There are some methods we didn’t cover in the previous article, but this article continues with class loading.
Loading of lazy and non-lazy classes
realizeClassWithoutSwift
We mentioned that if it’s a non-lazily loaded class, it calls realizeClassWithoutSwift, so let’s explore realizeClassWithoutSwift. Take a look at the entire method, where 2544-2554 lines of code were added to explore the helper methods written by the Person class.
We said that realizeClassWithoutSwift is the only class that is not lazily loading, so we create the Person class, add the +load method and we’re going to prepare the code.
@interface Person : NSObject
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) int age;
- (void)instanceMethod1;
- (void)instanceMethod2;
- (void)instanceMethod3;
+ (void)sayClassMethod;
@end
@implementation Person
+ (void)load{
}
- (void)instanceMethod3{
NSLog(@"%s",__func__);
}
- (void)instanceMethod1{
NSLog(@"%s",__func__);
}
- (void)instanceMethod2{
NSLog(@"%s",__func__);
}
+ (void)sayClassMethod{
NSLog(@"%s",__func__);
}
@end
Copy the codeWe run the code at the break point of line 2551
Sometimes it's better to look at the classes we've created, and adding some helper methods to quickly find the classes we need can save a lot of time. This is the idea behind the study of the source code. The break point goes down,Line 2556 If (CLS ->isRealized()) return CLS; If the class has already been classloaded, it returns directly
We operate on ro and RW
Let’s look at lines 251-2575
We see that ro has a class name, a list of methods, 8, and the first method is called instanceMethod3.
The above method is that we read data from the assembled macho file and convert it according to a certain input data format (strong conversion to class_RO_T * type). At this time, ro has no relation with our CLS. The judgment, further down line 2563, is to determine whether the current CLS is a metaclass. This is not a metaclass, so it goes down
Line 2571 is applying and opening the zalloc, which contains THE RW. At this time, the RW is empty. Let’s see what the RW has
Where ro_or_rw_ext is ro or rw_ext, ro is clean memory and rw_ext is dirty memory.
Line 2572 sets the RW we created to our RO, and line 2573 copies the class’s data back to the RW. Let’s verify that
At this point the breakpoint is line 2572, at which point we print CLS
This is because ro is a clean memory address, so why is there a clean memory address and a dirty memory address? This is because the iOS running will result in constant to add and delete memory, will be more serious to the operation of the memory, in order to prevent modification of the original data, so the original clean memory copy a to the rw, why rwe have rw (memory) dirty, this is because not all of the classes for dynamic insertion, deletion. When we add a property, a method changes a lot of memory and has a big impact on memory consumption, so when we dynamically process the class, we generate an RWE.
Let’s look at the reading of ro:
Let’s move on to the important method, as shown below:
Determine the inheritance chain relationship, there will be recursion, when the CLS does not exist, return
Further down, at line 2604, isMeta is YES because it is indeed a metaclass. cls->setInstancesRequireRawIsa(); The method is to set ISA at line 2642 to finish the inheritance chain, continuing down to line 2649
metacls = realizeClassWithoutSwift(remapClass(cls->ISA()), nil); Method takes the metaclass.So let’s verify that.
MethodizeClass method
Let’s look at the methodizeClass method
We know that realizeClassWithoutSwift is constantly recursing and re-copying data() (equal to ro), but we don't see rw, rwe processingLet’s see if this method does something to rw, rwe
We know that there is a methodList in RO, and we use binary search when we do method search, and sort SEL in the middle
Let’s look at the method list order first
At this point the list is there, so go into judgment and prepareMethodLists. PrepareMethodLists sort the methods
Let’s look at the prepareMethodLists method
The reason I made this judgment on line 1238 is to prevent metaclasses from having an effect.
As the code goes down, it comes back down
This is not in the same order as the methods we printed above, so prepareMethodLists serializes the methods. When we talked about method finding, we used dichotomies to find things
Back to the methodizeClass method
So let’s just put that out there for a second, in a non-lazy load we know when realizeClassWithoutSwift is called, so when does a non-lazy load call realizeClassWithoutSwift, we’ll say in our main function, Also remove the +load method and run the code:
We know from above that when you send a message to Person for the first time, it’s going to go realizeClassWithoutSwift. Because a class has a lot of code, a lot of sorting and temporary variables, it would take a long time to load them all in front of main. If the class is never called, it doesn’t need to be loaded in advance. So lazy loading improves performance.
This part of the code is actually shown when the message is sent 
When a class alloc, do a method lookup, and if the class isn’t loaded, load it. This means that the class has already been loaded before the class object is created and the method is called.
Here’s a diagram of lazy loading and non-lazy loading
Supplementary: Category (category)
We write the following code in the main.m function
@interface Person (C)
@property (nonatomic, copy) NSString *cate_name;
@property (nonatomic, assign) int cate_age;
- (void)cate_instanceMethod1;
- (void)cate_instanceMethod3;
- (void)cate_instanceMethod2;
+ (void)cate_sayClassMethod;
@end
@implementation Person (C)
- (void)cate_instanceMethod1{
NSLog(@"%s",__func__);
}
- (void)cate_instanceMethod3{
NSLog(@"%s",__func__);
}
- (void)cate_instanceMethod2{
NSLog(@"%s",__func__);
}
+ (void)cate_sayClassMethod{
NSLog(@"%s",__func__);
}
@end
Copy the codeAnd then using clang to generate.cpp files, let’s see what sort of.cpp looks like when we open the main. CPP file, we see something like this
The reason categories have two lists is because they do not have meta-categories, and the sorting methods are inserted into the class at run time via attachToClass
This is the same structure as our category_t modifier, where instance_methods is assigned _CATEGORY_INSTANCE_METHODS_Person_. Let’s search globally
But we found that our property does not have set and get methods in.cpp, so let’s look at the property assignment _PROP_LIST_Person_ and search for it
We found that there were attributes but no set and GET methods, so there were no set and GET attributes in the classification, and we needed to use runTime for attribute association.
We found that the category is essentially a category_T form and now let’s look at how the category is loaded into memory, okay
Classification loading
Now let’s create a classification, and write down the following method for classification
@interface Person : NSObject
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) int age;
- (void)instanceMethod1;
- (void)instanceMethod2;
- (void)instanceMethod3;
+ (void)sayClassMethod;
@end
@interface Person (A)
- (void)instanceMethod1;
- (void)cateA_1;
- (void)cateA_2;
- (void)cateA_3;
@end
@interface Person (B)
- (void)instanceMethod1;
- (void)cateB_1;
- (void)cateB_2;
- (void)cateB_3;
@end
Copy the codeMethodizeClass = methodizeClass = methodizeClass = methodizeClass = methodizeClass = methodizeClass (Because we know above that if the class is loaded, it must call the realizeClassWithoutSwift method, which in turn calls methodizeClass) 
AttachCategories method
Let’s start with a method overview
Looking at the whole method, we need to know where the research focus is. We need to study how the classification method is loaded. Look at line 1400. So let’s start with that.
So let’s break it off at the point where we write that the current class is the Person class, and let the code run in, be decisive
Remember that when we were updating the classification, we saw in the.cpp file that the name of the classification was Person, and the name of the classification was B, which means that the default assignment was Person at compile time, and the name of the classification was B at run time.
So let’s go down to line 1369, where the McOunt is not equal to ATTACH_BUFSIZ, so let’s go back to line 1374 and process the mlist, and let’s see what happens.
There are a total of 64 positions, with [ATTACH_BUFSIZ – ++ McOunt] where ATTACH_BUFSIZ is 64, the method will also subtract McOunt from 64 by a constant +1, resulting in positions equal to the list, which is reverse insertion. We see that bit 63 is 0x0000000100003360, and when we get entry. Cat, its instanceMethods = 0x0000000100003360. Reverse insertion was also demonstrated.
We see that mlist is method_list_t, which is a one-dimensional array, and we store mlist to Mlists, so mlists is a two-dimensional array
ExtAllocIfNeeded implementation
I’m going to go further and get to 1400 lines
Because we're going to add methods and protocols to this class, we're going to have to deal with clean Memory. So when will the RWE be initialized? We searched for extAllocIfNeeded and found that there are several cases in which extAllocIfNeeded will be called to initialize rWE.AddMethod 3. Class_addProtocol 4._class_addProperty(Not limited to these types)
Let’s look at the extAlloc method
At line 1283, the initialization is done, and nothing is printed because rwe is only initialized, not assigned.
If WE keep going, we’ll get to line 1294, we’ll get the List, we’ll print the List
AttachLists method is implemented
If we look at the attachLists method,PrepareMethodLists 1399 lines of code, which talks about sorting methods above. Let’s look at the attachLists method implementation
Put the newly inserted value at the front of lists and the old value at the back. This is because the value of the newly inserted value is greater than the old one, similar to the LRU algorithm of YYCache.And that tells you somethingIf a class has the same method as this class, the class method is called first.
Let’s move on to the last case where we have multiple lists inside of multiple lists
They put the new ones at the top of the table. It’s a little bit more intuitive to draw it up here
So let’s verify that
Validation process
So the Person up here came in, and I’m going to go to line 908, and I’m going to print it here
We find that only addedLists have only one method, but why p addedLists[1] has a value, the reason is that the pointer is continuous and its value is the address, but there may be nothing in it. P addedLists[0] take a pointer to the instanceMethod1 method, so this is a one-dimensional assignment.Let’s keep going
That is, the methods of this class are loaded when the initial RWE is created, and then the class loading begins
Go back to the attachCategories method, go to the mList, let’s print it out
We see attachLists passing mlists + attach_bufsiz-mcount is the last address of mlists.
So we’re going to get the else method
List_array_tt is a two-dimensional array that contains a lot of method_T, and method_T is a one-dimensional array that contains method_list_t.
If we go to the top when we add another category, we put a breakpoint, go to the Person class again, go to attachLists, and then go to the top
The first address of array() stores the instanceMethod1 method of class B. When this method completes, we are doing the same print
From the above explanation, we understandAttachCategories means to prepare the category data and insert it into the class method list.Above,The lines we studied: map_images->map_images_nolock->_read_images->realizeClassWithoutSwift->methodizeClass->attachToClass->attachCategories-> AttachLists (attach method to class()). Now let’s see if there’s another place to call attachCategories, so let’s do a global search
We see that red box 1 is attachToClass and red box 2 is the load_categories_NOLock method.So does this approach work? We print logs and run projects in the room
Another line is found: load_image->loadAllCategories-> load_categories_NOLock ->attachCategories.
Load_image load_image load_image load_image load_image load_image load_image load_image load_image load_image load_image The exploration above is that we implemented the +load method for both classes and categories. So let’s look at what happens to the class, with or without the +load method. To load the attachCategories method, we just need to look at the attachCategories method.
1. One of the classes has a +load method, and the class has a +load method
We see a category that only loads the implementation +load, but does not load the implementation
2. There is a +load method for all categories and a +load method for classes
Load implements the +load classification, does not implement the +load method
3. The class does not implement the +load method, there is a +load method
Methods with the same name are sorted, and methods without the same name are sorted through IMP from smallest to largest. Ditto aboveNote fixupMethodList handles namesames first, and then imPs from small to large, but this is the same class of methods, different classes of methods do not handle this method.
If the main class is implemented and the classification is not implemented, then the classification method is taken from data() and only handles methods with the same name.
4. The main class does not implement the +load method, nor does the class implement the +load method
There are 16 methods in ro, indicating that there are already classification and class methods. Methods are also obtained from data().
5. The main class does not implement the +load method, the classification implementation +load method, run the code:
These 8 methods are Person methods without categories_nolock. The categories_categories_nolock is applied in the "load_categories_nolock" category.
We found that when the classification is implemented and the main class is not implemented, it forces the main class to become a non-lazy loading class, loaded ahead of time.
The last
The above article and this article are to say the class of loading, content and more, this is a supplement to the previous article. Write to 2 o ‘clock in the morning, finally write almost (expand content to continue to write tomorrow). And I’ve drawn a picture at the end to sort of illustrate the whole process
expand
We broke the point while readClass, print the CLS and find bits 0x00000000.
The system call data() is equivalent to null.data(). So let's verify that bit has any value at all.
The last address printed by the X /4gx CLS is 0x0000 because the memory of the CLS is incomplete. It also suggests thatWhen the memory is not perfect, it can be identified by the address pointer.
When does a bit in memory have a value? Let’s keep going down
