NOTE: Please take care with this. I obviously cannot test if this will actually work on a new iPhone 5 device! I provide no warranty if you submit having used this and it doesn’t actually work on the new device. Please think twice before submitting an app which you have used this method to create. You don’t have to submit an
armv7s binary. Just set your “Architectures” build setting to
armv7 only and submit the resulting binary.
UPDATE: It worked! I tested an app that I’d used this method to build an
armv7s slice with. It ran fine on my iPhone 5 :-D.
Well the iPhone 5 has been announced and it just so happens that the architecture it uses is what they’re calling
armv7s. This brings in yet another architecture to the mix alongside
armv7. And I bet you are wondering why you’re getting linker errors when building for
armv7s when using external libraries. It’s because those external libraries do not have
If you run
file on the library then you’ll see that there is no
armv7s version. For example:
1 2 3 4 5
So what can you do? You could wait for the library to be updated, or you could just follow these steps…
So what’s the deal?
Well, the problem is that when the linker does its merry business linking together all your object files, it is told what architecture to link for. Each of your libraries’
.a files will most likely be what are called “fat” meaning they have more than one architecture in them. But the linker won’t be able to find the
armv7s version since it doesn’t exist in there.
But, we know that
armv7s is a superset of
armv7 (it’s just got a new version of the floating point unit so only adds new instructions). So what we can do is to copy the
armv7 part of the library and add it again but tell it that it’s for
armv7s. That sounds simple, but there’s more to it than that.
Inside each architecture’s portion of the fat library is something called an object file archive. This contains a collection of
.o files that were combined together to form the library. Inside each
.o is the code for each method. The linker uses these to build the final app binary, picking all the methods it needs to create the app. The problem is that these
.o files also have a header to say what architecture they’re for.
Inside this header (called a Mach-O header) is a field for the CPU type and the CPU subtype. ARM is CPU type 12, armv7 is CPU subtype 9 and armv7s is CPU subtype 11. So, all we need to do is toggle all the 9s to 11s, right? Yup! But that’s easier said than done.
My solution is a script that strips out the
armv7 portion of the fat library and then unpacks the archive into its constituent
.o files. Then I wrote a little C program to do the 9 => 11 toggling which is run on each of the
.o files. Then finally the new
.o files are packaged up into a new portion which is re-added to the fat library.
So, if you’re ready to get going then read on…
Do you need this to submit an app?
Do not use this unless you really understand what you’re doing. You do not need to submit with an
armv7s binary. Just set your Architectures build setting to
armv7 only and submit the resulting binary.
A program you’ll need
The first thing you’ll need is the following program written in C:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85
Copy it, and save it as
armv7sconvert.c. Then compile it with:
Then add this to
~/bin and add
~/bin to your path by editing
~/.profile and adding:
Now you’ll want the script which does the hard work of unpacking the library, running the
armv7sconvert over the object files and repacking it. Copy and paste the following into a file called
armv7sconvert.sh also in
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
What this does is a bit magical. I’ll explain later when I get chance. But now put this in your path somewhere and call it
armv7sconvert.sh. Then run this command on it:
Convert those libraries!
Now go to where your library is located and do this:
That should now have the
armv7s portion added to it. To confirm, do:
1 2 3 4 5 6
You should then see
armv7s (or it might just say CPU type 12 and CPU sub-type 11 — just another name for
And the verdict is…
I had an app that I’d done this little hack on for 4 libraries it used. I created just an armv7s binary and had it ready and waiting for my iPhone 5 to test on. I tested it and it worked like a dream. No problems what-so-ever. So, I would say that it’s a success!