Discussion :

[Kannagi]

j'obtienne une chaine de 0 et 1 de 32bits,

Je trouve la formulation étrange c'est comme si je disais "j’obtiens une chaine de 0 à 9" , ça s'appelle un nombre
Et dans ton cas c'est un nombre (binaire) , sauf si tu parle de chaine de caractère ?


Tu as fait quel vérification ?
Parce que je viens de tester a l'instant :

Code :

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

1
2
3
4
5
6
7
 
int i=0 ;
i= i | (0x20 << 26);
 
printf("%x\n",i);
 
// résultat : 80000000

Testé sur un processeur MIPS en plus :p
(le int fait 4 octet)

[ternel]

0x20 est un le nombre binaire 0100 0000 (chaque caractère hexadécimal correspond à un entier à 4 bits).
le décalage de 26 bits donne:
0100 0000 suivi de 0000 0000 0000 0000 0000 0000 00
et un nombre 32 bits n'a que 32 bits, c'est à dire les 32 "0" de valeur faible. C'est parfaitement normale d'obtenir 0.
(32 = 26 + 6, et 0x20 a ses six premiers bits nuls)

[fearyourself]

0x20 est un le nombre binaire 0100 0000 (chaque caractère hexadécimal correspond à un entier à 4 bits).

Hmm... 0x20, ce n'est pas 0010 0000?

[ternel]

si.

[fearyourself]

si.

Ok , c' est ce que je pensais ;-)

Donc 0x20 << 26 est acceptable dans un nombre à 32 bits. Du coup, montre nous un code complet où tu vois que cela te donne quand même un 0. Il y a quelque chose d'autre qui se passe ;-)

[Kannagi]

En gros ça donne 0x80000000 x)

Je vois pas pourquoi on doute autant de mon résultat
Donnait par mon ordinateur en plus

[fearyourself]

En gros ça donne 0x80000000 x)

Je vois pas pourquoi on doute autant de mon résultat
Donnait par mon ordinateur en plus

J'avais fait le même test sur le mien . Mais c'est à cause du résultat que je me demande pourquoi da_latifa obtient 0

[da_latifa]

oui vous avez raison, j'avais fait une erreur, mais là ça fonctionne, Merci beaucoup.

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
 
donc si j'ai l'instruction suivante:
 
sub $t0,$zero,$t2
 
selon le tableau 
		opcode rs  rt  rd  shamt  funct
		0x00   0   10  8   0x00   0x22 
décalage	26     21  16  11   6      0
 
en faisant le décalage de tout ça, j'aurais
 
0
0
a0000
4000
0
22
 
comment je fais pour avoir un résultat de 4 octets seulement avec ces nombres obtenus?

Merci à vous

[fearyourself]

C'est une question de décalages et masques en fait:

Code :

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

1
2
 
int instruction = ((opcode & 0x3F) << 25) | ((rs & 0x1F) << 20) | ((rt &0x1F) <<  15) | ((rd & 0x1F) <<< 10) | ((shamt & 0x3F) << 5) | (funct & 0x3F);

Il faudrait vérifier mes décalages et mes masques, je fais cela dans le bus

Jc

[da_latifa]

Merci pour ta réponse rapide,

pourrais tu juste m'expliquer

1) pourquoi tu as fait 25 au lieu de 26 et 20 au lieu de 21 ....

2) les 0x3F et 0x1F pour quelle raison

3) je penses que pour le shamt , c'est 0x1F au lieu de 0x3F puisuqe c'est sur 5bits, même c'est pas clair pour moi pourquoi tu l'as fait

Merci beaucoup

[fearyourself]

J'ai fait cela trop vite

Quand j'ai regardé la page:
https://www.d.umn.edu/~gshute/mips/i...n-coding.xhtml

J'ai vu le nombre de bits pour chaque partie:
opcode: 6 bits
rs: 5 bits
rt: 5 bits
rd: 5 bits
shamt: 5 bits
funct: 6 bits

- Pour 6 bits, ce sera donc 0x3F et 0x1F pour 5 bits (donc oui pour shamt c'est 0x1F ).
- Ensuite c'est une question de décalage. Prenons le cas de shamt qui commence en fait au 6ème bit et va jusqu'au 10ème.

Du coup, pour arriver au 6ème bit, si tu voulais mettre juste un 1 au bit de poids faible. Tu vas vouloir avoir:
1 000000 et donc ce serait 1 << 6 (et non le 5 que j'avais mis).

Donc, tu as raison, la bonne opération serait:

Code :

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

1
2
 
int instruction = ((opcode & 0x3F) << 26) | ((rs & 0x1F) << 21) | ((rt &0x1F) <<  16) | ((rd & 0x1F) <<< 11) | ((shamt & 0x1F) << 6) | (funct & 0x3F);

[da_latifa]

Parfait

donc juste pour être sûre, les variables opcode , rs ... que tu as mis dans l'orépration est ce que ce sont les variables
que j'ai obtenues en haut avec le 1er décalage fait ? (et qui m'a donné 0, 0, a0000, 4000, 0, 22) ?

Merci

[fearyourself]

Exactement, je te conseille de faire des petites fonctions qui tu font cela via des paramètres. Ce sera plus facile à gérer après

[da_latifa]

ok, puisque je vais lire des instructions mips différents, et que je ne sais pas si il va s,agir de add ou sub ou lw ou lb ....., je dois faire le traitement pour toutes les opérations
et donc j'ai pensé à faire une boucle de ce genre, pour traiter tous les registres , il ne faut pas oublier que je suis débutante en C
s1 contient l'opération et s2 contient la liste de tous ses registres , j'avoue que je suis un peu perdue sur le comment les extraire

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
21
22
23
24
25
 
 
 if (strcmp(s1, "add")==0){
		   opcode = opcode | (0x00<<21);
		   shamt= 0x00;
		   funct=0x20;
}
 
for (k=0 ; s2[k] != ' '; k++){
			{
			a= a + s2[k];
 
			if (strcmp(s2[k], ',')==0){
 
				k=k+1;
 
				if (a== "$t3"){
		  			 instruction = instruction | (11<<20);
				}else if (a== "$s3"){
		  			 instruction = instruction | (19<<15);
				}else if (a== "$s5"){
		  			 instruction = instruction | (21<<10);					
				}
			}
		}

[gerald3d]

Tu peux effectivement faire comme ca mais ton code va être long, pas forcément très facile à lire et les instructions mips seront codées en dure (dans le code source donc non modifiable par un utilisateur lambda).

Si je peux me permettre, même si tu es débutante en C, regarde le principe des tables de HASH. Ca te permettra d'avoir un code bien plus simple. Tes tables pourront être remplies via des fichiers textes qui eux contiendront les instructions/registres mips. Il sera alors simple d'en modifier les informations.

• https://fr.wikipedia.org/wiki/Table_de_hachage
• http://jipe.developpez.com/articles/...e/?page=page_1

[da_latifa]

J'ai fait cela trop vite

Quand j'ai regardé la page:
https://www.d.umn.edu/~gshute/mips/i...n-coding.xhtml

J'ai vu le nombre de bits pour chaque partie:
opcode: 6 bits
rs: 5 bits
rt: 5 bits
rd: 5 bits
shamt: 5 bits
funct: 6 bits

- Pour 6 bits, ce sera donc 0x3F et 0x1F pour 5 bits (donc oui pour shamt c'est 0x1F ).
- Ensuite c'est une question de décalage. Prenons le cas de shamt qui commence en fait au 6ème bit et va jusqu'au 10ème.

Du coup, pour arriver au 6ème bit, si tu voulais mettre juste un 1 au bit de poids faible. Tu vas vouloir avoir:
1 000000 et donc ce serait 1 << 6 (et non le 5 que j'avais mis).

Donc, tu as raison, la bonne opération serait:

Code :

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

1
2
 
int instruction = ((opcode & 0x3F) << 26) | ((rs & 0x1F) << 21) | ((rt &0x1F) <<  16) | ((rd & 0x1F) <<< 11) | ((shamt & 0x1F) << 6) | (funct & 0x3F);

Bonjour fearyourself,

J'imagine que quand j'ai une valeur immédiate qui est sur 16bits je doits utiliser 0xFFFF et pour 26bits mettre 0x3FFFFFF c'est bien ça ???? Merci d'avance

Tu peux effectivement faire comme ca mais ton code va être long, pas forcément très facile à lire et les instructions mips seront codées en dure (dans le code source donc non modifiable par un utilisateur lambda).

Si je peux me permettre, même si tu es débutante en C, regarde le principe des tables de HASH. Ca te permettra d'avoir un code bien plus simple. Tes tables pourront être remplies via des fichiers textes qui eux contiendront les instructions/registres mips. Il sera alors simple d'en modifier les informations.

• https://fr.wikipedia.org/wiki/Table_de_hachage
• http://jipe.developpez.com/articles/...e/?page=page_1

Bonjour gerald3d ,

Merci pour ta réponse, oui j'ai pensé à l'utilisation d'une fonction avec paramètre et qui me retourne le bon numéro de registre, je ne sais pas si c'est faisable en C, comme je suis débutante et en plus j'ai pas assez de temps car je dois rendre ce projet ce lundi qui s'en vient

Merci