Discussion :

[Mindiell]

Bonjour à tou(te)s,

Je cherche à simuler les registres d'un processeur.
J'ai donc imaginé des registres un peu comme dans un processeur intel :
AH
AL
AX
AEX

Je souhaite obtenir ce genre de modèle en mémoire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
AEX
AY                AX
                  AH       AL
00000000 00000000 00000000 00000000

Où AY est un "registre" non utilisable, et j'ai naturellement pensé aux structures. Mais je n'arrive pas à bien poser tout ca. En fait, j'ai essayé quelques trucs, mais j'obtiens des trucs vraiment bizarres ou des erreurs de compilo. Quelqu'un a déjà fait ca ? Sinon je poserai le problème bien à plat, parce que là je n'arrive pas trop à me concentrer

PS : un essai infructueux, ne grondez pas, je n'arrive plus à réfléchir

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
union x_register
{
    unsigned short int x;
    struct sub
    {
        unsigned char l;
        unsigned char h;
    };
};

EDIT : Je vais voir si l'utilisation d'un objet ne serait pas plus simple, et tant pis pour la "perte" de mémoire.

[Twindruff]

Je ne sais pas si tu connais les "union", c'est exactement ce dont tu as besoin. Une petite recherche devrait te donner des exemples.

[screetch]

il me semblait que le coup des unions, c'etait pas loin
un probleme, c'est que les unions n'ont qu'une garantie, c'est de n'offrir aucune garantie
du coup il me semble qu'une classe C++ serait mieux

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
class Register
{
private:
  unsigned int m_value;
public:
  unsigned int ex() { return m_value; }
  unsigned short y() { return (m_value >> 16) & 0xffff; }
  unsigned short x() { return m_value & 0xffff; }
  unsigned char h() { return (m_value >> 8) & 0xff; }
  unsigned char l() { return m_value & 0xff; }
};

a priori tout sera optimisé au mieux

[Twindruff]

j'aurais fait un truc du genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
struct reg
{
	union
	{
		__int32 eax;
		struct
		{
			__int16 ay;
			union
			{
				__int16 ax;
				struct
				{
					__int8 ah;
					__int8 al;
				};
			};
		};
	};
};

Il me semble que le seul problème c'est si le compilateur pad pas les champs des structures octet par octet.

Après dans les deux cas tout ça ne va pas si tu fais tourner ton programme sur une architecture non little-endian.

[Mindiell]

J'avais pensé aux unions, mais j'avais du mal faire un truc car je suis revenu aux structures... Je vous ai dit que j'étais fatigué

Sinon, sur les archi types Intel, en effet, le contenu des struct est à mettre à l'envers.
Je vais regarder ta solution Twindruff, merci

[Mindiell]

Bon, la solution semble intéressante, mais pour manipuler ca, ca va pas forcément être simple, non ?

un petit "reg a;" ne me permet pas facilement de manipuler le ax ou les ah et al... Va falloir que je me plonge sérieusement là-dedans moi.

[Twindruff]

De rien .
En fait contrairement à ce qu'on pourrait croire on peut accéder à tous les champs directement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
reg r;
r.eax = 1;
r.ay = 2;
r.ax = 3;
r.al = 4;
r.ah = 5;