Existe-t-il des plates-formes où les pointeurs vers différents types ont des tailles différentes?

Question

La norme C permet aux pointeurs de différents types d'avoir des tailles différentes, par ex. sizeof(char*) != sizeof(int*) est autorisé. Il exige toutefois que si un pointeur est converti en void* et qu'il soit ensuite converti en son type d'origine, il doit être comparable à sa valeur d'origine. Par conséquent, il suit logiquement que sizeof(void*) >= sizeof(T*) pour tous les types T, correct? Sur la plupart des plates-formes courantes (x86, PPC, ARM et variantes 64 bits, etc.), la taille de tous les pointeurs est égale à la taille du registre natif (4 ou 8 octets), quel que soit le point taper. Existe-t-il des plates-formes ésotériques ou intégrées dans lesquelles les pointeurs vers différents types peuvent avoir des tailles différentes? Je suis spécifiquement à propos de données pointeurs, mais je serais également intéressé de savoir s'il existe des plates-formes où pointeurs fonction ont des tailles inhabituelles.

Je suis définitivement et non je me suis renseigné sur les pointeurs-membres et les fonctions pointeur-vers-membre de C++. Ceux-ci prennent des tailles inhabituelles sur des plates-formes communes et peuvent même varier au sein d'une plate-forme, selon les propriétés de la classe pointeur-vers (non-polymorphe, héritage unique, héritage multiple, héritage virtuel ou type incomplet).

Answer 1

Answer from the C FAQ:

La série premier 50 segment de 07.777 utilisé, décalage 0 pour le pointeur nul, au moins pour PL/I. Les modèles ultérieurs ont utilisé le segment 0, décalage 0 pour les pointeurs N en C, nécessitant de nouvelles instructions telles que TCNP (Test C Null Pointer), évidemment comme un sop à tout le code C mal écrit existant qui a fait des suppositions incorrectes. Les machines principales plus anciennes, adressées par un mot, étaient également connues pour exiger des pointeurs d'octets plus grands (char * 's) que des pointeurs de mots (int *' s). La série Eclipse MV de Data General a trois formats de pointeurs pris en charge par l'architecture (mots, octets et pointeurs), dont deux sont utilisés par les compilateurs C: pointeurs d'octets pour char * et void *, et pointeurs de mots pour tout autre. Pour des raisons historiques au cours de l'évolution de la ligne MV à 32 bits de la ligne Nova à 16 bits, les pointeurs de mots et les pointeurs d'octets avaient les bits de décalage, d'indirection et de protection d'anneau à différents endroits du mot. Le passage d'un format de pointeur non adapté à une fonction a entraîné des erreurs de protection. Finalement, le compilateur MV C a ajouté de nombreuses options de compatibilité pour essayer de traiter le code qui avait des erreurs d'incompatibilité de type pointeur.

Certaines unités centrales Honeywell-Bull utilisent le modèle de bits 06000 pour les pointeurs NULL (internes).

La série CDC Cyber ​​180 est dotée de pointeurs de 48 bits composés d'une bague, d'un segment et d'un décalage. La plupart des utilisateurs (dans l'anneau 11) ont des pointeurs NULL de 0xB00000000000. Il était courant sur les anciennes machines CDC à complément un d'utiliser un mot de tout-un-bit comme indicateur spécial pour toutes sortes de données, y compris les adresses invalides.

L'ancienne série HP 3000 utilise un schéma d'adressage différent pour les adresses octet que pour les adresses de mot; comme plusieurs des machines ci-dessus, elle utilise donc des représentations différentes pour les pointeurs char * et void * que pour les autres pointeurs.

La machine Lisp de Symbolics, une architecture étiquetée, n'a même pas de pointeurs numériques conventionnels; il utilise la paire (en gros un handle inexistant) en tant que pointeur C null.

Selon le `` modèle de mémoire '' en cours d'utilisation, processeurs 8086-famille (PC) peuvent utiliser Compatibles des pointeurs de données 16 bits et 32 ​​bits fonction pointeurs, ou vice versa.

Certaines machines Cray 64 bits représentent int * dans les 48 bits inférieurs d'un mot ; char * utilise en outre certains des 16 bits supérieurs pour indiquer une adresse dans un mot. Liens supplémentaires: A message from Chris Torek avec plus de détails sur certaines de ces machines.

Answer 2

De retour dans les années dorées du DOS, des 8088 et de la mémoire segmentée, il était courant de spécifier un «modèle de mémoire» dans lequel, par ex. tout le code entrerait dans 64k (un segment) mais les données pourraient s'étendre sur plusieurs segments; cela signifiait qu'un pointeur de fonction serait de 2 octets, un pointeur de données de 4 octets. Je ne sais pas si quelqu'un est encore en train de programmer des machines de ce genre, peut-être que certaines survivent encore à des utilisations intégrées.

Answer 3

Pas tout à fait ce que vous demandez, mais dans les jours DOS/Windows 16 bits, vous avez fait la distinction entre un pointeur et un pointeur éloigné, ce dernier étant 32 bits.

je pourrais avoir la syntaxe mal ...

int *pInt = malloc(sizeof(int)); 
int far *fpInt = _fmalloc(sizeof(int)); 

printf("pInt: %d, fpInt: %d\n", sizeof(pInt), sizeof(fpInt)); 

Sortie:

pInt: 2, fpInt 4

Answer 4

On pourrait facilement imaginer une machine d'architecture de Harvard ayant des tailles différentes pour des pointeurs de fonction et tous les autres pointeurs. Ne sait pas d'un exemple ...

Answer 5

Par conséquent, il suit logiquement que sizeof(void*) >= sizeof(T*) pour tous les types T, correct? Cela ne veut pas nécessairement dire que sizeof concerne la représentation de stockage et que tous les modèles de bits ne doivent pas être des valeurs valides. Je pense que vous pourriez écrire une implémentation conforme où sizeof(int*) == 8, sizeof(void*) == 4, mais il n'y a pas plus de 2^32 valeurs possibles pour un int *. Je ne sais pas pourquoi vous voudriez.

Answer 6

Des pointeurs proches et éloignés sont toujours utilisés sur certains microcontrôleurs intégrés avec pagination flash ou RAM, pour vous permettre de pointer vers la même page (pointeur proche) ou une autre page (pointeur éloigné, plus grand car inclus informations sur la page). Par exemple, le microcontrôleur HCS12 de Freescale utilise une architecture Von Neumann de 16 bits, ce qui signifie qu'aucune adresse ne peut dépasser 16 bits. En raison de la limitation que cela mettrait sur la quantité d'espace de code disponible, il y a un registre de page de 8 bits.Par conséquent, pour pointer vers des données dans la même page de code, il vous suffit de spécifier l'adresse 16 bits; c'est un pointeur proche.

Pour pointer vers des données dans une autre page de codes, vous devez inclure à la fois le numéro de page 8 bits et l'adresse 16 bits dans cette page, ce qui donne un pointeur éloigné de 24 bits.

Answer 7

Il est possible que la taille des pointeurs vers les données diffère des pointeurs vers les fonctions par exemple. Il est courant que cela se produise dans un microprocesseur pour un système embarqué. Les machines d'architecture de Harvard, comme dmckee mentionné, rendent cela facile à réaliser.

Il s'avère que ça fait mal à backcounts de gcc de se développer!:)

Edit: Je ne peux pas entrer dans les détails de la machine spécifique dont je parle mais laissez-moi ajouter pourquoi les machines Harvard rendent cela facile. L'architecture de Harvard a des capacités de stockage et des chemins différents pour les instructions et les données, donc si le bus pour les instructions est plus grand que celui pour les données, vous aurez forcément un pointeur de fonction dont la taille est plus grande qu'un pointeur! Curieux, quelle section de la norme permet les différentes tailles de pointeur?