How to symbolicate crash log Xcode?

Question

Xcode 5 organizer had a view which would list all the crash logs. and we could drag drop crash logs here. But since Xcode 6, I know they have moved devices out of organize and have a new window for the same. But I do not find a place where I view the crash logs which i drag-dropped in Xcode 5 after upping to Xcode 6. Anybody knows the answer ?

Answer 1

From Apple's docs:

Symbolicating Crash Reports With Xcode Xcode will automatically attempt to symbolicate all crash reports that it encounters. All you need to do for symbolication is to add the crash report to the Xcode Organizer.

• Connect an iOS device to your Mac
• Choose "Devices" from the "Window" menu
• Under the "DEVICES" section in the left column, choose a device
• Click the "View Device Logs" button under the "Device Information" section on the right hand panel
• Drag your crash report onto the left column of the presented panel

• Xcode will automatically symbolicate the crash report and display the results To symbolicate a crash report, Xcode needs to be able to locate the following:

  1. The crashing application's binary and dSYM file.

  2. The binaries and dSYM files for all custom frameworks that the application links against. For frameworks that were built from source with the application, their dSYM files are copied into the archive alongside the application's dSYM file. For frameworks that were built by a third-party, you will need to ask the author for the dSYM file.

  3. Symbols for the OS that the that application was running on when it crashed. These symbols contain debug information for the frameworks included in a specific OS release (e.g, iOS 9.3.3). OS symbols are architecture specific - a release of iOS for 64-bit devices won't include armv7 symbols. Xcode will automatically copy OS symbols from each device that you connect to your Mac.

If any of these are missing Xcode may not be able to symbolicate the crash report, or may only partially symbolicate the crash report.

Answer 2

Ok I realised that you can do this:

1. In Xcode > Window > Devices, select a connected iPhone/iPad/etc top left.
2. View Device Logs
3. All Logs

You probably have a lot of logs there, and to make it easier to find your imported log later, you could just go ahead and delete all logs at this point... unless they mean money to you. Or unless you know the exact point of time the crash happened - it should be written in the file anyway... I'm lazy so I just delete all old logs (this actually took a while).

4. Just drag and drop your file into that list. It worked for me.

Answer 3

If you have the .dSYM and the .crash file in the same sub-folder, these are the steps you can take:

1. Looking at the backtrace in the .crash file, note the name of the binary image in the second column, and the address in the third column (e.g. 0x00000001000effdc in the example below).
2. Just under the backtrace, in the "Binary Images" section, note the image name, the architecture (e.g. arm64) and load address (0x1000e4000 in the example below) of the binary image (e.g. TheElements).
3. Execute the following:

$ atos -arch arm64 -o TheElements.app.dSYM/Contents/Resources/DWARF/TheElements -l 0x1000e4000 0x00000001000effdc -[AtomicElementViewController myTransitionDidStop:finished:context:]

Authoritative source: https://developer.apple.com/library/content/technotes/tn2151/_index.html#//apple_ref/doc/uid/DTS40008184-CH1-SYMBOLICATE_WITH_ATOS

Answer 4

The easiest process to symbolicate crash logs:

1. preserve the xcarchive file from the organizer during IPA building process for future use.
2. When the crash occurs, collect the crash logs from affected device. The extension should be .crash. If the crash log is in .ips format, just rename it to .crash.
3. Double click the xcarchive from the stored path to make it appear in organizer(if not present already).
4. open in xcode window->devices and simulators -> view device logs -> all logs -> drag and drop the .crash file.

Wait for 5secs. Bang! the application calls in stack trace will be symbolicated! You may still see a lot of symbols though! those are internal library and framework calls.

This is the easiest one, tried and tested!

Answer 5

There is an easier way using Xcode (without using command line tools and looking up addresses one at a time)

1. Take any .xcarchive file. If you have one from before you can use that. If you don't have one, create one by running the Product > Archive from Xcode.

2. Right click on the .xcarchive file and select 'Show Package Contents'

3. Copy the dsym file (of the version of the app that crashed) to the dSYMs folder

4. Copy the .app file (of the version of the app that crashed) to the Products > Applications folder

5. Edit the Info.plist and edit the CFBundleShortVersionString and CFBundleVersion under the ApplicationProperties dictionary. This will help you identify the archive later

6. Double click the .xcarchive to import it to Xcode. It should open Organizer.

7. Go back to the crash log (in Devices window in Xcode)

8. Drag your .crash file there (if not already present)

9. The entire crash log should now be symbolicated. If not, then right click and select 'Re-symbolicate crash log'

Answer 6

Writing this answer as much for the community as for myself.

If there ever are problems symbolicating a crash report, one can overcome them as follows:

1. Create a separate folder, copy Foo.app and Foo.app.dSYM from the corresponding .xcarchive into the folder. Also copy the .crash report into the folder.

2. Open the crash report in TextEdit or elsewhere, go to the Binary Images: section, and copy the first address there (e.g. 0xd7000).

3. cd into the folder. Now you can run the following command:

   xcrun atos -o Foo.app/Foo -arch arm64 -l 0xd7000 0x0033f9bb

This will symbolicate the symbol at address 0x0033f9bb. Please make sure to pick the correct value for the -arch option (can be obtaned from the first line in the Binary Images: section, or figured out from the Hardware Model: in the crash report and the app's supported archs).

You can also copy the necessary addresses (e.g. a thread call stack) from the crash report directly into a text file (in TextEdit, hold Option and select the necessary text block, or copy and cut), to get something like this:

0x000f12fb
0x002726b7
0x0026d415
0x001f933b
0x001f86d3

Now you can save this into a text file, e.g. addr.txt, and run the following command:

xcrun atos -o Foo.app/Foo -arch arm64 -l 0xd7000 -f addr.txt

This will give a nice symbolication for all the addresses at once.

P.S.

Before doing the above, it's worth checking that everything is set up correctly (as atos will happily report something for basically any supplied address).

To do the checking, open the crash report, and go to the end of the call stack for Thread 0. The first line from the end to list your app (usually the second one), e.g.:

34  Foo                    0x0033f9bb 0xd7000 + 2525627

should be the main() call. Symbolicating the address (0x0033f9bb in this case) as described above should confirm that this is indeed main() and not some random method or function.

If the address is not that of main(), check your load address (-l option) and arch (-arch option).

P.P.S.

If the above doesn't work due to bitcode, download the dSYM for your build from iTunes Connect, extract the executable binary from the dSYM (Finder > Show Package Contents), copy it into the directory, and use it (i.e. Foo) as the argument to atos, instead of the Foo.app/Foo.