Détecter CPU d'exécution Architecture (32 bits / 64 bits) en Objective C (Mac OS X)

StackOverflow https://stackoverflow.com/questions/1988996

Était-ce utile?

La solution

Il existe un moyen très facile. Compiler deux versions de l'exécutable, un pour 32 bits et une 64 bits et les combiner avec des lipo. De cette façon, la bonne version sera toujours été exécutée. 

gcc -lobjc somefile.m -o somefile -m32 -march=i686
gcc -lobjc somefile.m -o somefile2 -m64 -march=x86_64
lipo -create -arch i686 somefile -arch x86_64 somefile2 -output somefileUniversal

Edit: ou tout simplement compiler un binaire universel en premier lieu avec gcc -arch i686 -arch x86_64

En réponse au commentaire de l'OP: 

if(sizeof(int*) == 4)
    //system is 32-bit
else if(sizeof(int*) == 8)
    //system is 64-bit

EDIT: D'oh! Je ne savais pas que vous auriez besoin d'une vérification d'exécution ... En passant par la sortie de sysctl -A, deux variables semblent potentiellement utiles. Essayez la sortie de l'analyse syntaxique sysctl hw.optional.x86_64 et sysctl hw.cpu64bit_capable. Je n'ai pas un Mac 32 bits autour de tester, mais ces deux sont mis à 1 dans Snow Leopard sur un Mac Core2Duo.

Autres conseils

Utilisation [[NSRunningApplication currentApplication] executableArchitecture] qui renvoie une des constantes suivantes:

  • NSBundleExecutableArchitectureI386
  • NSBundleExecutableArchitectureX86_64
  • NSBundleExecutableArchitecturePPC
  • NSBundleExecutableArchitecturePPC64

Par exemple: 

switch ([[NSRunningApplication currentApplication] executableArchitecture]) {
  case NSBundleExecutableArchitectureI386:
    // TODO: i386
    break;

  case NSBundleExecutableArchitectureX86_64:
    // TODO: x86_64
    break;

  case NSBundleExecutableArchitecturePPC:
    // TODO: ppc
    break;

  case NSBundleExecutableArchitecturePPC64:
    // TODO: ppc64
    break;

  default:
    // TODO: unknown arch
    break;
}

Vous n'avez pas à détecter manuellement pour obtenir cet effet. Un fichier exécutable Mach-O peut contenir des binaires 32 bits et 64 bits Intel et le noyau exécute automatiquement les plus appropriés. Si vous utilisez XCode, il y a un paramètre dans l'inspecteur de projet où vous pouvez définir les architectures (ppc, i386, x86_64) vous voulez avoir dans un seul binaire universel.

De plus, rappelez-vous que sur OS X, l'exécution d'un noyau 64 bits (avec Snow Leopard) et d'être en mesure d'exécuter une application terrestre utilisateur 64 bits sont deux concepts orthogonaux. Si vous avez une machine avec 64 cpu bits, vous pouvez exécuter un programme-terrain utilisateur en mode 64 bits, même lorsque le noyau est en cours d'exécution en mode 32 bits (avec Leopard ou Snow Leopard), aussi longtemps que toutes les bibliothèques vous établissez un lien avec sont disponibles avec 64 bits. Il est donc pas utile de vérifier si le système d'exploitation est capable 64 bits.

En règle générale, vous ne devriez pas besoin d'être en mesure de vérifier lors de l'exécution si vous êtes sur 64 ou 32 bits. Si votre application hôte (qui est ce que j'appelle l'application qui lance les 64 ou 32 outils de bits) est un binaire gras, la vérification de la compilation est suffisant. Comme il va se compilé deux fois (une fois pour la partie 32 bits du binaire gras, une fois pour la partie 64 bits), et celui de droite sera lancé par le système, vous compilez dans le code de lancement droit en tout écriture STH. comme 

#if __LP64__
    NSString    *vExecutablePath = [[NSBundle mainBundle] pathForResource: @"tool64" ofType: @""];
#else
    NSString    *vExecutablePath = [[NSBundle mainBundle] pathForResource: @"tool32" ofType: @""];
#endif
[NSTask launchedTaskWithLaunchPath: vExecutableName ...];

Si l'utilisateur lance en quelque sorte explicitement votre application en 32 bits sur un Mac 64 bits, leur faire confiance qu'ils savent ce qu'ils font. Il est un cas limite de toute façon, et pourquoi briser les choses pour les utilisateurs d'un mauvais sens de la perfection. Vous pouvez même être heureux vous-même si vous découvrez un bug seulement 64 bits si vous pouvez indiquer aux utilisateurs la solution de contournement lance en 32 bits.

Vous avez seulement besoin d'un réel contrôle d'exécution si votre application elle-même est seulement 32 bits (par exemple GUI carbone avec aide en ligne de commande). Dans ce cas, host_processor_info ou sysctl ou similaires sont probablement votre seule voie si pour une raison bizarre, vous ne pouvez pas lipo les deux executables ensemble.

Si vous êtes sur l'utilisation Snow Leopard de executableArchitecture de NSRunningApplication.

Dans le cas contraire, je ferais ce qui suit: 

-(BOOL) is64Bit
{
#if __LP64__
  return YES;
#else
  return NO;
#endif
}

Pour obtenir une chaîne avec programmation le nom de l'architecture du processeur: 

#include <sys/types.h>
#include <sys/sysctl.h>

// Determine the machine name, e.g. "x86_64".
size_t size;
sysctlbyname("hw.machine", NULL, &size, NULL, 0); // Get size of data to be returned.
char *name = malloc(size);
sysctlbyname("hw.machine", name, &size, NULL, 0);

// Do stuff...

free(name);

Pour faire la même chose dans un script shell: 

set name=`sysctl -n hw.machine`

La méthode standard de vérification de la version OS (et donc si son léopard des neiges, un os 64 bits) est détaillé ici .

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top