This seems to be a new option in newer XCode - instead of "armv6 armv7" under Valid architectures I now see "armv7 armv7s". What is armv7s and do I need to build for it as well as armv7?
The iPhone 5 will ship with and only run iOS 6.0. To coincide with the launch of iOS 6.0, Apple has seeded developers with a newer version of its development tools. Xcode 4.5 makes two major changes: it drops support for the ARMv6 ISA (used by the ARM11 core in the iPhone 2G and iPhone 3G), keeps support for ARMv7 (used by modern ARM cores) and it adds support for a new architecture target designed to support the new A6 SoC: armv7s.
You do not have to build for armv7s to add support for the iPhone 5. The iPhone 5 can run armv7 compiled code as well. My app has just been submitted to the store and it is build on armv7 only and working perfect!
armv7s is the architecture of the A6 processor in the iPhone 5. And yes, you need to include this as well. With the latest version of Xcode, support for armv6 is dropped.
Related
I tried debugging my ios 6.1 project on the new iPad 4 (A6X, armv7s instruction set). However the build failed with
No architectures to compile for (ONLY_ACTIVE_ARCH=YES, active arch=armv7s, VALID_ARCHS=armv6 armv7 i386).
I'm using XCode5-DP6. App debugs on the latest iPod touch (armv7) and on both iPad and iPhone simulators (both iOS 6.1 and 7.0).
It was my understanding that code built for arm7 should build and run on arm7s, since apps between iPad3 and iPad4 are the same? Any clue what I'm doing wrong?
The last product I know of with armv6 is iPhone 3G, even iPhone 3GS is with armv7.
Apple has removed the support for armv6 in a way you cannot compile to that processor architecture and even if you would successfully compile you would have a problem submitting the app to Apple (the build won't be accepted automatically). Moreover, You cannot compile to an OS below 4.3 (it would give you errors also) so there are some restrictions - I'm saying that because I think old devices also can't support new OS. So, it is just a matter of days that there won't be any old iPhone with an OS you can support with Apple's platform.
So, my recommendation is to change the build and valid architectures to armv7, armv7s & i386 (if you need it).
This shall work and you really don't have a choice. you should know that most users doesn't own those old devices. If you still want to support those maybe you should consider add a new app specific for "new" devices, but know that you couldn't update the old version because of what explained earlier.
I am using Xcode 4.5.2 and have a project which cannot be compiled for an iPhone running iOS 6.0.1 though other projects compile fine with the same settings as shown in the picture below.
Any ideas on how to solve this?
You're probably using some third party lib that doesn't yet support armv7s architecture. You can just remove armv7s from your settings. Your app will still be able to run on iPhone 5 although it might not be taking full advantage of the new architecture.
If on XCODE 12 just goto Build Settings search for VALID_ARCHS. Under the User-Defined section select Valid Architectures and click Delete.
Set valid architecture for iOs simulator to armv7 and armv7s.( simulators are 32 bit ).
for device set to arm64 (64 bit all new ios device).
I'm using OpenCV for one of my project for which I cannot afford to drop the armv6 devices. For some reason, the official framework built for iOS seems to only support armv7 and x86. Would it be possible to build this lib for armv6 + armv7?
Thanks in advance for any hints or help.
As Andrey mentioned there is no official ARMv6 support.
But take a look at this blog post (it's pretty old): Computer vision with iOS Part 1: Building an OpenCV framework, which will give you a good starting point. Also check out an older Version of the buildscript to see what has changed since ARMv6 support was dropped.
Another thing you should take into account is your deployment target, because iOS 4.3+ requires ARMv7. Should that be the case just go with the official build.
ARMv7s = iPhone 5
ARMv7 = iPhone 3GS, iPhone 4, iPhone 4S, iPod 3G/4G/5G, iPad, iPad 2, iPad 3
ARMv6 = iPhone 2G/3G, iPod 1G/2G
Official distribution does not support armv6. But it should be possible to hack and rebuild the framework with armv6 support.
While submitting my iOS App to the App Store, validation fails with the message:
iPhone/iPod Touch: application executable is missing a required architecture.
At least one of the following architectures(s) must be present: armv6
I'm using Xcode 4.5 (4G182), currently the latest. Some of my build settings:
Architectures: armv6 armv7
Base SDK: Latest iOS (iOS 6.0)
Valid Architectures: armv7 armv7s
iOS Deployment Target: 4.0
What's going wrong here?
Set the iOS Deployment Target to iOS 4.3.
If you're using Xcode 4.5 there is no armv6 any longer
Then you need to use an earlier Xcode version to still support iOS 4.3
(various ways doing this are listed here http://blog.chpwn.com/post/31824877081)
If this is not necessary you could cut out armv6 and just support iOS 5+
Cutting out armv6 goes by -> Build Settings->Architectures->Select Standard
Can someone tell me why creating a new project with an iOS Deployment Target of iOS 5.0 includes armv6 as a Valid Architecture in Project > Build Settings by default? The default info.plist file only lists armv7 in the Required Device Capabilities.
As I understand it, if I am building for iOS 5 or later that will only run on armv7 devices (i.e. iPhone 3GS or later, iPod 3G or later, and the iPads). Thus I should be able to remove all the armv6 references, and set Build Active Architecture Only to YES.
Can anyone confirm or clarify? Thanks.
XCode v4.3.2, Base SDK 5.1, iOS Deployment Target iOS 5.0, iPhone Device Family
PS - I understand that removing armv6 will reduce the size of the binary.
$(VALID_ARCHS) defines the set of architectures that an Xcode target supports. $(ARCHS) tells Xcode what architectures to build. What actually gets built for each target is the intersection of $(VALID_ARCHS) and $(ARCHS).
$(VALID_ARCHS) is typically used to avoid building a target for some architecture that the project as a whole otherwise supports. If you don't need to do that, you can safely ignore it.