Vérifiez le type de CPU lors de l'exécution du programme C sur MAC

Question

Comment un programme C déterminer, au moment RUN (compilation pas le temps), si elle est en cours d'exécution sur Little-Endian ou CPU Big-Endian?

La raison pour laquelle il doit être « run-time » vérifier, pas « complie temps », parce que je construis le programme au format Universal Binary de MAC OS X, en utilisant mon MAC avec Intel CPU. Et ce programme devrait fonctionner à la fois Intel et CPU Power-PC. à-dire, par le format Universal Binary sur MAC, je veux construire un programme utilisant Intel CPU et l'exécuter sous CPU PPC.

La logique dans mon programme qui a besoin de la vérification de la CPU est la fonction de changement d'ordre-hôte à réseau octets pour les entiers de 64 bits. En ce moment, je l'ai échanger aveuglément les ordres d'octets, qui fonctionne sur Intel ok CPU, mais les pauses sur PPC. Voici la fonction C:

unsigned long long
hton64b (const unsigned long long h64bits) {
   // Low-order 32 bits in front, followed by high-order 32 bits.
   return (
       (
        (unsigned long long)
        ( htonl((unsigned long) (h64bits & 0xFFFFFFFF)) )
       ) << 32
      )
      |
      (
       htonl((unsigned long) (((h64bits) >> 32) & 0xFFFFFFFF))
      );
}; // hton64b()

une meilleure façon de le faire d'une manière multi-plateforme?

Merci

Answer 1

• Il y aura des macros préprocesseur disponible pour les tests, il est wether grand / petit-boutiste. par exemple.

   #ifdef LITTLE_ENDIAN
   do it little endian way
   #else 
   do it big endian way
   #endif.

est la compilation, mais la source de graisse    binaires compilés séparement pour obtient    chaque architecture, ce n'est pas    problème.

• Je ne suis pas sûr si MacOSX a betoh64 fonction () dans sys / endian.h - si elle ne - utiliser que ça va faire la bonne chose.

• La dernière approche est de faire simplement le déballage des octets individuels d'une manière qui n'est pas sensible à l'hôte endian - il vous suffit de connaître le commander les octets sont de la la source.

  uint64_t unpack64(uint8_t *src)
  {
     uint64_t val;
  
     val  = (uint64_t)src[0] << 56;
     val |= (uint64_t)src[1] << 48;
     val |= (uint64_t)src[2] << 40;
     val |= (uint64_t)src[3] << 32;
     val |= (uint64_t)src[4] << 24;
     val |= (uint64_t)src[5] << 16;
     val |= (uint64_t)src[6] <<  8;
     val |= (uint64_t)src[7]      ;
  
     return val;
  }
  

Answer 2

Ne pas déranger la vérification; il suffit d'utiliser Hton * où vous avez besoin d'une valeur de réseau indépendant. Avec une bonne conception, qui devrait être limité à un module qui assure l'interface entre votre programme et quoi que ce soit qui a besoin des entiers indépendants du réseau.

Sur les systèmes big-endian qui sont déjà en ordre de réseau, Hton * est probablement juste une macro, il est donc libre. Sur les systèmes little-endian, vous allez avoir besoin de le faire de toute façon, donc vérifier si vous avez besoin de le faire est tout simplement vous ralentir.

Si cela ne suffit pas, alors vous devrez fournir une meilleure explication de ce que vous essayez d'accomplir et pourquoi vous avez besoin de connaître le boutisme du système lors de l'exécution.

Answer 3

Savez-vous que les binaires universels sur le Mac sont compilés à plusieurs reprises, une fois pour chaque architecture? Je suppose que lorsque vous parlez de compiler temps, vous faites référence à l'aide de votre configure / make système pour informer la source .... Il suffit d'utiliser des constantes gcc (comme LITTLE_ENDIAN)

Answer 4

Vous n'avez pas besoin de vérifier le boutisme lors de l'exécution. Lorsque vous compilez une application comme binaire universel, il est compilé plusieurs fois avec les macros définit et appropriées, même si vous construisez sur une machine Intel. Lors de l'exécution, le chargeur mach-o choisira la meilleure architecture pour exécuter à partir de votre binaire universel (à savoir ppc sur PowerPC ou Intel i386).

binaire universel ne signifie pas un binaire pour l'architecture multiple. Cela signifie un binaire gras contenant un binaire d'une architecture.

S'il vous plaît se référer à http: //developer.apple.com/legacy/mac/library/documentation/MacOSX/Conceptual/universal_binary/universal_binary_intro/universal_binary_intro.html pour plus de détails.