Get rid of objc blocks inside dyld callback (#10014)

Author: wowlocal

Crashlytics/Crashlytics/Components/FIRCLSBinaryImage.h

@@ -64,8 +64,7 @@ typedef struct {
   FIRCLSBinaryImageRuntimeNode nodes[CLS_BINARY_IMAGE_RUNTIME_NODE_COUNT];
 } FIRCLSBinaryImageReadWriteContext;
 
-void FIRCLSBinaryImageInit(FIRCLSBinaryImageReadOnlyContext* roContext,
-                           FIRCLSBinaryImageReadWriteContext* rwContext);
+void FIRCLSBinaryImageInit(void);
 
 #if CLS_COMPACT_UNWINDING_SUPPORTED
 bool FIRCLSBinaryImageSafeFindImageForAddress(uintptr_t address,

Crashlytics/Crashlytics/Components/FIRCLSBinaryImage.m

@@ -51,8 +51,7 @@ static void FIRCLSBinaryImageChanged(bool added,
 static void FIRCLSBinaryImageRecordSlice(bool added, const FIRCLSBinaryImageDetails imageDetails);
 
 #pragma mark - Core API
-void FIRCLSBinaryImageInit(FIRCLSBinaryImageReadOnlyContext* roContext,
-                           FIRCLSBinaryImageReadWriteContext* rwContext) {
+void FIRCLSBinaryImageInit(void) {
   // initialize our node array to all zeros
   memset(&_firclsContext.writable->binaryImage, 0, sizeof(_firclsContext.writable->binaryImage));
   _firclsContext.writable->binaryImage.file.fd = -1;
@@ -281,6 +280,37 @@ static bool FIRCLSBinaryImageMachOSliceInitSectionByName(FIRCLSMachOSliceRef sli
   return true;
 }
 
+static void FIRCLSPopulateImageDetailWithLoadCommand(uint32_t type,
+                                                     uint32_t size,
+                                                     const struct load_command* cmd,
+                                                     void* context) {
+  FIRCLSBinaryImageDetails* details = context;
+  switch (type) {
+    case LC_UUID: {
+      const uint8_t* uuid = FIRCLSMachOGetUUID(cmd);
+      FIRCLSSafeHexToString(uuid, 16, details->uuidString);
+    } break;
+    case LC_ENCRYPTION_INFO:
+      details->encrypted = FIRCLSMachOGetEncrypted(cmd);
+      break;
+    case LC_SEGMENT:
+    case LC_SEGMENT_64: {
+      FIRCLSMachOSegmentCommand segmentCommand = FIRCLSBinaryImageMachOGetSegmentCommand(cmd);
+
+      if (strncmp(segmentCommand.segname, SEG_TEXT, sizeof(SEG_TEXT)) == 0) {
+        details->node.size = segmentCommand.vmsize;
+      }
+    } break;
+    case LC_VERSION_MIN_MACOSX:
+    case LC_VERSION_MIN_IPHONEOS:
+    case LC_VERSION_MIN_TVOS:
+    case LC_VERSION_MIN_WATCHOS:
+      details->minSDK = FIRCLSMachOGetMinimumOSVersion(cmd);
+      details->builtSDK = FIRCLSMachOGetLinkedSDKVersion(cmd);
+      break;
+  }
+}
+
 static bool FIRCLSBinaryImageFillInImageDetails(FIRCLSBinaryImageDetails* details) {
   if (!FIRCLSIsValidPointer(details)) {
     return false;
@@ -299,33 +329,8 @@ static bool FIRCLSBinaryImageFillInImageDetails(FIRCLSBinaryImageDetails* detail
   // struct types in a few different places.
   details->node.baseAddress = (void* volatile)details->slice.startAddress;
 
-  FIRCLSMachOSliceEnumerateLoadCommands(
-      &details->slice, ^(uint32_t type, uint32_t size, const struct load_command* cmd) {
-        switch (type) {
-          case LC_UUID: {
-            const uint8_t* uuid = FIRCLSMachOGetUUID(cmd);
-            FIRCLSSafeHexToString(uuid, 16, details->uuidString);
-          } break;
-          case LC_ENCRYPTION_INFO:
-            details->encrypted = FIRCLSMachOGetEncrypted(cmd);
-            break;
-          case LC_SEGMENT:
-          case LC_SEGMENT_64: {
-            FIRCLSMachOSegmentCommand segmentCommand = FIRCLSBinaryImageMachOGetSegmentCommand(cmd);
-
-            if (strncmp(segmentCommand.segname, SEG_TEXT, sizeof(SEG_TEXT)) == 0) {
-              details->node.size = segmentCommand.vmsize;
-            }
-          } break;
-          case LC_VERSION_MIN_MACOSX:
-          case LC_VERSION_MIN_IPHONEOS:
-          case LC_VERSION_MIN_TVOS:
-          case LC_VERSION_MIN_WATCHOS:
-            details->minSDK = FIRCLSMachOGetMinimumOSVersion(cmd);
-            details->builtSDK = FIRCLSMachOGetLinkedSDKVersion(cmd);
-            break;
-        }
-      });
+  FIRCLSMachOSliceEnumerateLoadCommands_f(&details->slice, details,
+                                          FIRCLSPopulateImageDetailWithLoadCommand);
 
   // We look up the section we want, and we *should* be able to use:
   //
@@ -359,6 +364,19 @@ static bool FIRCLSBinaryImageFillInImageDetails(FIRCLSBinaryImageDetails* detail
   return true;
 }
 
+typedef struct {
+  FIRCLSBinaryImageDetails details;
+  bool added;
+} FIRCLSImageChange;
+
+static void FIRCLSProcessBinaryImageChange(void* context) {
+  FIRCLSImageChange* imageChange = context;
+  // this is an atomic operation
+  FIRCLSBinaryImageStoreNode(imageChange->added, imageChange->details);
+  FIRCLSBinaryImageRecordSlice(imageChange->added, imageChange->details);
+  free(context);
+}
+
 static void FIRCLSBinaryImageChanged(bool added,
                                      const struct mach_header* mh,
                                      intptr_t vmaddr_slide) {
@@ -368,14 +386,14 @@ static void FIRCLSBinaryImageChanged(bool added,
 
   imageDetails.slice = FIRCLSMachOSliceWithHeader((void*)mh);
   imageDetails.vmaddr_slide = vmaddr_slide;
+  // fill imageDetails fields using slice & vmaddr_slide
   FIRCLSBinaryImageFillInImageDetails(&imageDetails);
 
-  // Do these time-consuming operations on a background queue
-  dispatch_async(FIRCLSGetBinaryImageQueue(), ^{
-    // this is an atomic operation
-    FIRCLSBinaryImageStoreNode(added, imageDetails);
-    FIRCLSBinaryImageRecordSlice(added, imageDetails);
-  });
+  FIRCLSImageChange* change = malloc(sizeof(FIRCLSImageChange));
+  if (!change) return;
+  change->added = added;
+  change->details = imageDetails;
+  dispatch_async_f(FIRCLSGetBinaryImageQueue(), change, FIRCLSProcessBinaryImageChange);
 }
 
 #pragma mark - In-Memory Storage
@@ -390,6 +408,7 @@ static void FIRCLSBinaryImageStoreNode(bool added, FIRCLSBinaryImageDetails imag
     return;
   }
 
+  // looking for an empty space if an image added
   void* searchAddress = NULL;
   bool success = false;
   FIRCLSBinaryImageRuntimeNode* nodes = _firclsContext.writable->binaryImage.nodes;

Crashlytics/Crashlytics/Components/FIRCLSContext.m

@@ -158,8 +158,7 @@ bool FIRCLSContextInitialize(FIRCLSContextInitData* initData, FIRCLSFileManager*
     _firclsContext.readonly->binaryimage.path =
         FIRCLSContextAppendToRoot(rootPath, FIRCLSReportBinaryImageFile);
 
-    FIRCLSBinaryImageInit(&_firclsContext.readonly->binaryimage,
-                          &_firclsContext.writable->binaryImage);
+    FIRCLSBinaryImageInit();
   });
 
   dispatch_group_async(group, queue, ^{

Crashlytics/Shared/FIRCLSMachO/FIRCLSMachO.h

@@ -56,6 +56,10 @@ typedef void (^FIRCLSMachOSliceIterator)(FIRCLSMachOSliceRef slice);
 typedef void (^FIRCLSMachOLoadCommandIterator)(uint32_t type,
                                                uint32_t size,
                                                const struct load_command* cmd);
+typedef void (*FIRCLSMachOLoadCommandIteratorFunc)(uint32_t type,
+                                                   uint32_t size,
+                                                   const struct load_command* cmd,
+                                                   void* context);
 
 __BEGIN_DECLS
 
@@ -69,6 +73,9 @@ struct FIRCLSMachOSlice FIRCLSMachOFileSliceWithArchitectureName(FIRCLSMachOFile
 void FIRCLSMachOEnumerateSlicesAtAddress(void* executableData, FIRCLSMachOSliceIterator block);
 void FIRCLSMachOSliceEnumerateLoadCommands(FIRCLSMachOSliceRef slice,
                                            FIRCLSMachOLoadCommandIterator block);
+void FIRCLSMachOSliceEnumerateLoadCommands_f(FIRCLSMachOSliceRef slice,
+                                             void* context,
+                                             FIRCLSMachOLoadCommandIteratorFunc function);
 struct FIRCLSMachOSlice FIRCLSMachOSliceGetCurrent(void);
 struct FIRCLSMachOSlice FIRCLSMachOSliceWithHeader(void* machHeader);
 

Crashlytics/Shared/FIRCLSMachO/FIRCLSMachO.m

@@ -219,6 +219,25 @@ static bool FIRCLSMachOSliceIsValid(FIRCLSMachOSliceRef slice) {
   return true;
 }
 
+void FIRCLSMachOSliceEnumerateLoadCommands_f(FIRCLSMachOSliceRef slice,
+                                             void* context,
+                                             FIRCLSMachOLoadCommandIteratorFunc function) {
+  const struct load_command* cmd;
+  uint32_t cmdCount;
+
+  if (!FIRCLSMachOSliceIsValid(slice)) {
+    return;
+  }
+
+  FIRCLSMachOHeaderValues(slice, &cmd, &cmdCount);
+
+  for (uint32_t i = 0; cmd != NULL && i < cmdCount; ++i) {
+    function(cmd->cmd, cmd->cmdsize, cmd, context);
+
+    cmd = (struct load_command*)((uintptr_t)cmd + cmd->cmdsize);
+  }
+}
+
 void FIRCLSMachOSliceEnumerateLoadCommands(FIRCLSMachOSliceRef slice,
                                            FIRCLSMachOLoadCommandIterator block) {
   const struct load_command* cmd;