Question

Je réalise que far est spécifique au compilateur, mais je m'attends à ce que l'emplacement du spécificateur far soit logique pour ceux qui comprennent vraiment les pointeurs.

J'ai donc deux applications qui partagent tout l'espace mémoire du processeur.

L’application A doit appeler la fonction foo qui existe dans l’application B.

Je connais l'emplacement de la mémoire de la fonction foo.

Cela devrait donc fonctionner dans l'application A:

typedef int (* __far MYFP)(int input);

void somefunc(void)
{
   int returnvalue;
   MYFP foo;

   foo = (MYFP) 0xFFFFFA;

   returnvalue = foo(39);
}
  • Le __far est-il au bon endroit dans la typedef?
  • Dois-je ajouter __far au casting (MYFP)?
  • Certaines informations suggèrent que l'appel à foo n'a pas besoin d'être supprimé, quelle est votre expérience?
  • Quoi d'autre à ce sujet semble incorrect, ou puis-je essayer d'accomplir cela?

  • Y a-t-il une meilleure façon de faire cela?

Modifier:

Il s’agit d’un périphérique intégré (périphérique Freescale S12XEQ) utilisant Code Warrior. C'est un appareil 16 bits avec une mémoire de 24 bits, donc oui, il est segmenté / mis en banque.

-Adam

Était-ce utile?

La solution

Est-ce que le __far est au bon endroit dans le typedef?

[Modifier, en réponse au commentaire de ChrisN - merci]

Il s’agit d’une fonctionnalité dépendante du compilateur, car elle ne fait pas partie de la norme ANSI C. Selon le manuel du compilateur < http://www.freescale.com/files/soft_dev_tools/doc/ref_manual/CW_Compiler_HC12_RM.pdf > ;, chapitre 8, vous l'avez placé correctement. Dans d'autres compilateurs, vous devrez peut-être inverser l'ordre. Cela devrait être assez facile à comprendre, car exactement une des deux options sera compilée avec n’importe quel compilateur donné.

Dois-je ajouter __far au casting (MYFP)?

Non, cela fait partie du type.

Certaines informations suggèrent qu'il n'est pas nécessaire de déréférencer l'appel de foo, quelle est votre expérience?

Les pointeurs de fonction peuvent être facultativement déréférencés en C. Les lignes suivantes sont valides et font exactement la même chose:

foo = (MYFP)0xFFFFFA;
returnvalue = foo(39);  // 1
returnvalue = (*foo)(39);  // 2

Quoi d'autre à ce sujet semble incorrect, ou puis-je essayer d'accomplir cela?

Vous l'avez fait exactement correctement.

Autres conseils

Le mot clé __far, du moins dans l'univers MS, a été utilisé lors de la création de fichiers binaires utilisant la mémoire segmentée. Vous devez comprendre le système de mémoire 8086 pour comprendre cela. Le 8086 divisait la mémoire en segments, chaque segment faisant 64Kh de long, chaque adresse d’un segment nécessitait donc 16 bits. Les adresses se présentaient sous deux formes: proche et lointain. Une adresse proche faisait 16 bits et correspondait à un décalage dans le segment en cours, l'une des valeurs CS, DS, ES et SS dépendant de l'instruction, une valeur éloignée à 32 bits et consistait en un segment et un décalage. Dans le 8086, l'adresse absolue était de 16 * segment + offset, ce qui donnait une plage adressable de 1 Mo.

Si vous n'utilisez pas un système de mémoire segmenté et que vous avez l'impression que vous ne l'êtes pas, toutes les adresses ont le même nombre de bits. Par conséquent, la distinction entre proximité et distance n'est pas nécessaire, ce qui signifie que le compilateur ignore probablement le mot clé. .

Ceci est un extrait de code qui fonctionne à partir d'un projet sur lequel je travaille. C'est Paradigm C ++, il utilise donc une version de Borland. Le processeur qu’il utilise est un clone 8086, donc une mémoire segmentée de 20 bits.

void softSerial0SR(unsigned16);
void (__far *softHandler)(unsigned16);

J'initialise softHandler à 0 sans réclamation.

Ensuite,

softHandler = softSerial0SR;

dans le code d'installation.

Pour l'appeler, appelez simplement softHandler comme une fonction normale.

Notez que ce code est légèrement modifié pour vous par rapport au code que j'ai.

les deux programmes ont été construits par le même compilateur / les mêmes options, ils utilisent donc le même OBI?

D’accord, le code a l’air bien. Dans ce cas, j’obtiendrais un désassemblage du code généré et je déterminerais s’il est correctement passé. Il ne devrait y avoir que 10 instructions au maximum - et vous saurez alors avec certitude si cela a fonctionné.

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