For some reason, on iOS 15, I am receiving lots of crashes where I have a sheet presented, and then exit the app to the home screen. The app crashes giving me the exception:
libswiftCore.dylib`:
-> 0x123c02a20 <+0>: pushq %rbp Thread 1: Fatal error: Index out of range
0x123c02a21 <+1>: movq %rsp, %rbp
0x123c02a24 <+4>: popq %rbp
0x123c02a25 <+5>: retq
0x123c02a26 <+6>: nopw %cs:(%rax,%rax)
Has anyone experienced this error before?
Thanks
After updating my Xcode a project that was fully functional and ready for launch it now breaks at runtime but gives no errors or warnings at compile time.
I suspect that my simulator or Alamofire 4 is the problem, but I can't seem to find the reason why it's misbehaving. All I can figure out is that the Alamofire files aren't parsed correctly before given to the simulator or that the simulator is skipping the parsed Alamofire files when building.
If anyone has an idea of how to fix this please help.
This is where it breaks:
dyld`__abort_with_payload:
0x599c34 <+0>: movl $0x209, %eax ; imm = 0x209
0x599c39 <+5>: calll 0x59a3f0 ; _sysenter_trap
-> 0x599c3e <+10>: jae 0x599c4e ; <+26>
0x599c40 <+12>: calll 0x599c45 ; <+17>
0x599c45 <+17>: popl %edx
0x599c46 <+18>: movl 0x10553(%edx), %edx
0x599c4c <+24>: jmpl *%edx
0x599c4e <+26>: retl
0x599c4f <+27>: nop
With a message of : "Thread 1: signal SIGABRT"
and in my console i get:
dyld: Library not loaded: #rpath/Alamofire.framework/Alamofire
Referenced from: /Users/stackle005/Library/Developer/CoreSimulator/Devices/5D244AC3-834B- 401B-BA73-0664E95327DF/data/Containers/Bundle/Application/BD754A02-4BFA- 4460-9603-51C94683A286/StackleApp.app/StackleApp
Reason: image not found
(lldb)
The explanation of your error log is : "linker found the library, but can't use it."
Check and Follow below steps :
Clear old build data from CoreSimulator,Delete apps from Simulator/device.
Go to Project Setting -> Your_Target->General -> Embedded Binaries
-> Click on + button and add your library here
Hope it helps!
I am using Map box iOS SDK 3.0.1 in my App and facing issues on slow network. It crashed very often.
libc++abi.dylib: terminating with uncaught exception of type
std::runtime_error: Failed to load
[https://a.tiles.mapbox.com/v4/mapbox.mapbox-terrain-v2,mapbox.mapbox-streets-v6/0/0/0.vector.pbf?access_token=pk.xxxx]:
and Xcode crash log is :
libsystem_kernel.dylib`__pthread_kill:
0x114edcff8 <+0>: movl $0x2000148, %eax
0x114edcffd <+5>: movq %rcx, %r10
0x114edd000 <+8>: syscall
-> 0x114edd002 <+10>: jae 0x114edd00c ; <+20>
0x114edd004 <+12>: movq %rax, %rdi
0x114edd007 <+15>: jmp 0x114ed7bdd ; cerror_nocancel
0x114edd00c <+20>: retq
0x114edd00d <+21>: nop
0x114edd00e <+22>: nop
0x114edd00f <+23>: nop
Anyone faced any such issue with map box SDK ? Let me know how it can be prevented to the error can be bought ?
Give Mapbox iOS SDK v3.1.1 a try — there have been significant networking improvements made in the v3.1.x releases.
How do I temporarily disallow selectors to be called on nil objects.
Actually I was getting a Bad access exception, hours after I learned that some where I was using array with out calling alloc-init on it.
So can I have something like
#define DISABLE_SELECTORS_ON_NIL_OBJECTS in prefix.h file
or some checkbox some where in project settings, or some exception which can disable selectors on nil objects, or
do I have to always put the code in if(object != nil) ?
The bad access exception means that your uninitialized object variable was not nil. In Objective-C, only instance variables are zeroed out for you automatically. Others hold whatever value is left in that memory location or register from the last time it was used. The only fix is to make sure the variable is initialized before you use it, even if that means setting it to nil.
Run the static analyzer on your code. It can often find issues like this and help you fix them.
Short answer: I don't beleive there is any simple way to do this in the way you suggest.
Long answer: You can catch it at runtime...
If you are using ARC all your variables of type Objective-C object reference will be initialised to nil by the runtime. However as Eric Skroch suggests a bad access is likely something other than a nil.
As a debugging aid there are various environment variables which can be set to have the Objective-C runtime print out lots of information as your code runs, see Apple's Mac OS X Debugging Magic (that document references an iOS version but its appears to be MIA). However there doesn't seem to be anything for trapping messages to nil.
If all else fails use a breakpoint... Here is the start of objc_msgsend (OS X):
libobjc.A.dylib`objc_msgSend:
0x7fff9774d240: testq %rdi, %rdi
0x7fff9774d243: je 0x7fff9774d270 ; objc_msgSend + 48
0x7fff9774d245: testb $0x1, %dil
0x7fff9774d249: jne 0x7fff9774d287 ; objc_msgSend + 71
0x7fff9774d24c: movq (%rdi), %r11
0x7fff9774d24f: pushq %rax
0x7fff9774d250: movq 0x10(%r11), %r10
0x7fff9774d254: movl %esi, %eax
0x7fff9774d256: andl (%r10), %eax
0x7fff9774d259: movq 0x10(%r10,%rax,8), %r11
0x7fff9774d25e: incl %eax
0x7fff9774d260: testq %r11, %r11
0x7fff9774d263: je 0x7fff9774d29b ; objc_msgSend + 91
0x7fff9774d265: cmpq (%r11), %rsi
0x7fff9774d268: jne 0x7fff9774d256 ; objc_msgSend + 22
0x7fff9774d26a: popq %rax
0x7fff9774d26b: jmpq *0x10(%r11)
0x7fff9774d26f: nop
0x7fff9774d270: movq -0x19eb41e7(%rip), %rdi ; _objc_nilReceiver
0x7fff9774d277: testq %rdi, %rdi
0x7fff9774d27a: jne 0x7fff9774d245 ; objc_msgSend + 5
0x7fff9774d27c: xorl %eax, %eax
The last instruction is the first one hit when its determined the receiver is definitely nil. So if you think you might have an accidental message to nil you can breakpoint on that instruction - the LLDB docs will tell you how if you don't know.
HTH.
Leanplum, Apptimize and other A/B testing platforms for iOS have the ability to download assets (nib files ,images, etc...) from the web and replace them at runtime.
The naive approach will be to download the new assets and replace them in the resource bundle directory, but it is impossible to write files to the resource directory because of permissions.
The question is, what techniques does these A/B testing platforms use to replace assets at runtime?
EDIT:
After reading the symbols on leanplum static library file (using nm) it seems that they are Swizzling cocoa file system API's.
for example: (an example line from nm -m leanplum.a)
-[NSBundle(LeanplumExtension) leanplum_URLForResource:withExtension:]
By using otool I can print the implementation:
-[NSBundle(LeanplumExtension) leanplum_URLForResource:withExtension:]:
0000000000000069 pushq %rbp
000000000000006a movq %rsp, %rbp
000000000000006d pushq %r15
000000000000006f pushq %r14
0000000000000071 pushq %r13
0000000000000073 pushq %r12
0000000000000075 pushq %rbx
0000000000000076 subq $0x18, %rsp
000000000000007a movq %rcx, %rbx
000000000000007d movq %rdi, 0xffffffffffffffc8(%rbp)
0000000000000081 movq %rdx, %rdi
0000000000000084 callq _objc_retain
0000000000000089 movq %rax, %r14
000000000000008c movq %rbx, %rdi
000000000000008f callq _objc_retain
0000000000000094 movq %rax, 0xffffffffffffffd0(%rbp)
0000000000000098 movq _originalMainBundle(%rip), %rcx
000000000000009f movq "+[NSBundle(LeanplumExtension) leanplum_mainBundle]"(%rcx), %rdi
00000000000000a2 movq 0x4487(%rip), %rsi
00000000000000a9 movq _objc_msgSend(%rip), %r12
00000000000000b0 movq %r14, %rdx
00000000000000b3 movq %rax, %rcx
00000000000000b6 callq *%r12
00000000000000b9 movq %rax, %rdi
00000000000000bc callq _objc_retainAutoreleasedReturnValue
00000000000000c1 movq %rax, %r13
00000000000000c4 movq _skippedFiles(%rip), %rax
00000000000000cb movq "+[NSBundle(LeanplumExtension) leanplum_mainBundle]"(%rax), %rbx
00000000000000ce movq 0x4463(%rip), %rsi
00000000000000d5 movq %r13, %rdi
00000000000000d8 callq *%r12
00000000000000db movq %rax, %rdi
00000000000000de callq _objc_retainAutoreleasedReturnValue
00000000000000e3 movq %rax, %r15
00000000000000e6 movq 0x4453(%rip), %rsi
00000000000000ed movq %rbx, %rdi
00000000000000f0 movq %r15, %rdx
00000000000000f3 callq *%r12
00000000000000f6 movb %al, %bl
00000000000000f8 movq %r15, %rdi
00000000000000fb callq _objc_release
0000000000000100 testb %bl, %bl
0000000000000102 je 0x115
0000000000000104 movq %r13, %rdi
0000000000000107 callq _objc_retain
000000000000010c movq %rax, %r15
000000000000010f movq 0xffffffffffffffd0(%rbp), %rbx
0000000000000113 jmp 0x13b
0000000000000115 movq 0x4414(%rip), %rsi
000000000000011c movq 0xffffffffffffffc8(%rbp), %rdi
0000000000000120 movq %r14, %rdx
0000000000000123 movq 0xffffffffffffffd0(%rbp), %rbx
0000000000000127 movq %rbx, %rcx
000000000000012a callq *_objc_msgSend(%rip)
0000000000000130 movq %rax, %rdi
0000000000000133 callq _objc_retainAutoreleasedReturnValue
0000000000000138 movq %rax, %r15
000000000000013b movq %r13, %rdi
000000000000013e callq _objc_release
0000000000000143 movq %rbx, %rdi
0000000000000146 callq _objc_release
000000000000014b movq %r14, %rdi
000000000000014e callq _objc_release
0000000000000153 movq %r15, %rdi
0000000000000156 addq $0x18, %rsp
000000000000015a popq %rbx
000000000000015b popq %r12
000000000000015d popq %r13
000000000000015f popq %r14
0000000000000161 popq %r15
0000000000000163 popq %rbp
0000000000000164 jmpq _objc_autoreleaseReturnValue
Can someone verify my findings?
I wonder how they get this entire list of API covered?
What happens if I open an image with fopen or other C lib?
How can I decipher the output of otool?
The question is, what techniques does these A/B testing platforms use to replace assets at runtime?
An educated guess is that they use method swizzling to swap the implementations of standard methods (e.g. [NSBundle URLForResource:withExtension:]) with those of their own versions of those methods (e.g. [NSBundle(LeanplumExtension) leanplum_URLForResource:withExtension:]). This means that your code uses the same method that you would otherwise, but you get different behavior -- in this case, the URL that's returned depends on which version of the resource the A/B testing framework decides to present to the user.
I wonder how they get this entire list of API covered?
By working carefully. The number of methods used to load resources isn't unmanageable.
What happens if I open an image with fopen or other C lib?
I expect that the framework wouldn't be able to swap resources in such a case. There are lots of ways to load data, and the framework can't possibly anticipate all of them. But if you're using an A/B framework, you presumably want the resources to be replaced as appropriate for your testing, so it doesn't make a lot of sense to try to defeat the framework.
How can I decipher the output of tool?
For the case you've shown, learn to read assembly language. (otool has a lot of options, though, and they don't all produce assembly.)
As an example, the company Leanplum offers a Visual Interface Editor for iOS and Android: This requires no coding, and Leanplum will automatically detect the elements and allow you to change them. No engineering or app store resubmissions are required.
Let me give you a little bit more high level insights about it:
With installing the iOS or Android SDK in your app, you enable a feature called Visual Editor. While in development mode and with the Website Dashboard open, the SDK sends information about the view hierarchy in real-time to your Browser. The view hierarchy is scanned in a similar way a DOM is built on a regular website.
You can choose any UI element on your app and change the appearance of it in real-time. This works by identifying the exact element in the view tree and sending the changes to the SDK.
This can be achieved by adding custom hooks or a technique called "swizzling". Take a look at this blog post, how it works.
To learn more about the Leanplum Visual Interface Editor, check out leanplum.com. They offer a free 30-day trial.
(Disclaimer: I'm an engineer at Leanplum)