structure alignée passée par valeur à une fonction

**o_Nejma** · 16/10/2018, 12h41

Bonjour tout le monde,

Je suis entrain de tester le bout de code suivant:

Code :

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

1
2
3
4
5
 
                           //Initialise la donnée:
                           FonctionWritingData(&W_Data_Str);
                           //lire la donnée:
                           FonctionReadingData(W_Data_Str);

W_Data_Str est du type structuré suivant:

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
typedef enum EnumType_e
{ 
   Enum_1       ,
   Enum_2 ,
   Enum_3
}
EnumType_t;
 
 
typedef struct rxfqdc_Info_Common_s
{
   unsigned char   A[45];
 
   EnumType_t  B[45];
 
   EnumType_t  C[53];
 
   EnumType_t  D[53];
 
   EnumType_t  E[53];
 
   EnumType_t  F[53];
 
   EnumType_t  G[43];
 
   EnumType_t  H[43];
 
   EnumType_t  I[43];
 
   EnumType_t  J[2]; 
 
   EnumType_t  K[2];
 
   EnumType_t  L[2];
 
   EnumType_t  M[2];
 
   EnumType_t  N[2];
 
   EnumType_t  O[2];
 
   EnumType_t  P[2];
 
   EnumType_t  Q[2];
 
   EnumType_t  R[2];
 
   EnumType_t  S[2];
 
   EnumType_t  DataLastTable[2];
}
My_struct_t __attribute__ ((aligned (2))) ;

Le problème que j'ai c'est que; quand j'appelle la fonction FonctionReadingData et je vérifie après si ce que je lui passe en entrée est bien ce que j'initialise dans FonctionWritingData. Le dernier élément du dernier champ ne prend pas la bonne valeur!

ie: Supposons que j'initialise tous les éléments de ma structure à 2 (dans FonctionWritingData), dans FonctionReadingData je récupère le dernier élément W_Data_Str.DataLastTable[1] avec une valeur de 0 alors que tous les autres éléments de tous les champs prennent bien 2.

Sachant que:
1- Quand je fais pas d'alignement (je supprime le __attribute__ ((aligned (2))) ) le problème disparaît!
2- Quand je passe la sortie de la premiere fonction à la deuxieme par adresse (FonctionReadingData)là aussi le problème disparaît! (en gardant l'alignement)

Je n'arrive pas à trouver une explication à:
- ce qui arrive avec et sans l'instruction d'alignement.
- et avec le passage de la donnée par adresse et par valeur.

S'il vous plaît pouvez vous m'éclaircir un peu.
Par avance, je vous remercie énormément!

Cordialement,

**Matt_Houston** · 16/10/2018, 12h59

Comment est allouée la variable en question (W_Data_Str) ?

**o_Nejma** · 16/10/2018, 13h02

Envoyé par Matt_Houston

Comment est allouée la variable en question (W_Data_Str) ?

Elle est déclarée comme variable local dans la fonction appelante des deux fonctions FonctionWritingData(&W_Data_Str) et FonctionReadingData(W_Data_Str).

**Bktero** · 17/10/2018, 08h28

Tu peux nous donner un code minimaliste reproduisant le problème stp ? Le but est qu'on puisse l'essayer et constater le problème.

**o_Nejma** · 17/10/2018, 13h05

Bonjour,

Désolée pour ma réponse un peu tardive.

Je ne pense pas que ce soit évident de reproduire le problème car je travaille avec un compilateur diab (wind river) et j'utilise un outils de test (de ibm), et il me semble que ce soit un problème très lié au compilateur.

Mais je mets un code que j'ai développé pour tester sur gcc et effectivement je n'ai pas eu le même problème.

Le fichier source:

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
 
#include <stdio.h>
#include "Header.h"
 
 
 
//Declare data For writing test:
My_struct_t * R_Data_Ptr;
My_struct_t   R_Data_Str;
 
//Declare data For reading test:
My_struct_t * W_Data_Ptr;
My_struct_t   W_Data_Str;
My_struct_t   test_str;
 
 
 
//functions stubbing:
void FonctionReadingData(My_struct_t My_Data)
{ 
               R_Data_Str =  My_Data;
               R_Data_Ptr = (My_struct_t *)(&My_Data);
}
 
void FonctionWritingData(My_struct_t *  const My_Data)
{
               unsigned char i;
 
               for(i=0;i<45;i++)
               {
                              My_Data->A[i]             	=   W_Data_Str.A[i]   ;
               }                                                            
               for(i=0;i<45;i++)                                            
               {                                                            
                              My_Data->B[i]	               =   W_Data_Str.B[i]    ;
               }                                                            
               for(i=0;i<53;i++)                                            
               {                                                               
                              My_Data->C[i]                 =   W_Data_Str.C[i]    ;
               }  		                  										       
               for(i=0;i<53;i++)	                  								       
               {              	                  								       
                              My_Data->D[i]                 =   W_Data_Str.D[i]     ;
               }  		                  										       
               for(i=0;i<53;i++)	                  								       
               {                 	                  							       
                              My_Data->E[i]                 =   W_Data_Str.E[i]  ; 
               }  		                  										       
               for(i=0;i<53;i++)	                  								       
               {              	                  								       
                              My_Data->F[i]                 =   W_Data_Str.F[i]  ;
               }  													       
               for(i=0;i<43;i++)										       
               {                										       
                              My_Data->G[i]           	=   W_Data_Str.G[i]   ;
               }  													       
               for(i=0;i<43;i++)										       
               {  													       
                              My_Data->H[i]          	=   W_Data_Str.H[i]   ;
               }  			              								       
               for(i=0;i<43;i++)									       
               {  												       
                              My_Data->I[i]         	=   W_Data_Str.I[i]   ; 
               }  												       
               for(i=0;i<2;i++)									       
               { 												       
                              My_Data->J[i]    	=  W_Data_Str.J[i]   ; 
               }                                             
               for(i=0;i<2;i++)                              
               {                                             
                              My_Data->K[i]         	=   W_Data_Str.K[i]         ;
               }  												             
               for(i=0;i<2;i++)									             
               {													             
                              My_Data->L[i]           	=   W_Data_Str.L[i]         ;
               }  													             
               for(i=0;i<2;i++)										             
               {														             
                              My_Data->M[i]             	=   W_Data_Str.M[i]         ;
               }  													             
               for(i=0;i<2;i++)										             
               {														             
                              My_Data->N[i]             	=   W_Data_Str.N[i]         ;
               }  													             
               for(i=0;i<2;i++)										             
               {														             
                              My_Data->O[i]             	=   W_Data_Str.O[i]         ;
               }  													             
               for(i=0;i<2;i++)										             
               {														             
                              My_Data->P[i]           	=   W_Data_Str.P[i]         ;
               }  													             
               for(i=0;i<2;i++)										             
               {														             
                              My_Data->Q[i]             	=   W_Data_Str.Q[i]         ;
               }  													             
               for(i=0;i<2;i++)										             
               {														             
                              My_Data->R[i]            	=   W_Data_Str.R[i]         ;
               }  													             
               for(i=0;i<2;i++)										             
               {														             
                              My_Data->S[i]            	=   W_Data_Str.S[i]         ;
               }  																					              
               for(i=0;i<2;i++)																		              
               {																						              
                              My_Data->DataLastTable[i]     =   W_Data_Str.DataLastTable[i] ;
               }   
               test_str = *My_Data;
               *((&test_str.S[1])+2)  = *(&(My_Data->S[1]) +2) ;
}
 
 
 
//main program:
void main(void)
{
               unsigned char i;
 
 
 
               for(i=0;i<45;i++)
               {
                              W_Data_Str.A[i] =1  ;
               }                                                                
               for(i=0;i<45;i++)                                                
               {                                                                
                              W_Data_Str.B[i] =2   ;
               }                                                                
               for(i=0;i<53;i++)                                                
               {                                                                   
                              W_Data_Str.C[i] =1        ;
               }  		                      										       
               for(i=0;i<53;i++)	                      								       
               {              	                      								       
                              W_Data_Str.D[i] =2         ;
               }  		                      										       
               for(i=0;i<53;i++)	                      								       
               {                 	                      							       
                              W_Data_Str.E[i] =1      ; 
               }  		                      										       
               for(i=0;i<53;i++)	                      								       
               {              	                      								       
                              W_Data_Str.F[i] =2      ;
               }  		                   										       
               for(i=0;i<43;i++)	                   								       
               {                	                   								       
                              W_Data_Str.G[i] =1       ;
               }  		                   										       
               for(i=0;i<43;i++)	                   								       
               {  		                   										       
                              W_Data_Str.H[i] =2       ;
               }  		                                 								       
               for(i=0;i<43;i++)	                   							       
               {  		                   									       
                              W_Data_Str.I[i] =1       ; 
               }  		                   									       
               for(i=0;i<2;i++)	                   							       
               { 		                   									       
                              W_Data_Str.J[i] =2       ; 
               }                                                 
               for(i=0;i<2;i++)                                  
               {                                                 
                              W_Data_Str.K[i] =3             ;
               }  		                   									             
               for(i=0;i<2;i++)	                   							             
               {		                   										             
                              W_Data_Str.L[i] =1             ;
               }  		                   										             
               for(i=0;i<2;i++)	                   								             
               {		                   											             
                              W_Data_Str.M[i] =2             ;
               }  		                   										             
               for(i=0;i<2;i++)	                   								             
               {		                   											             
                              W_Data_Str.N[i] =1             ;
               }  		                   										             
               for(i=0;i<2;i++)	                   								             
               {		                   											             
                              W_Data_Str.O[i] =2             ;
               }  		                   										             
               for(i=0;i<2;i++)	                   								             
               {		                   											             
                              W_Data_Str.P[i] =1             ;
               }  		                   										             
               for(i=0;i<2;i++)	                   								             
               {		                   											             
                              W_Data_Str.Q[i] =2            ;
               }  		                   										             
               for(i=0;i<2;i++)	                   								             
               {		                   											             
                              W_Data_Str.R[i] =1             ;
               }  		                   										             
               for(i=0;i<2;i++)	                   								             
               {		                   											             
                              W_Data_Str.S[i] =2             ;
               }  																					              
               for(i=0;i<2;i++)																		              
               {																						              
                              W_Data_Str.DataLastTable[i]=1  ;
               }   
 
               FonctionWritingData(&W_Data_Str);
               FonctionReadingData(W_Data_Str);
 
               printf("Print the last item value of the last struct filed:\n");
               printf("After Reading: %d \n",R_Data_Str.DataLastTable[1]);
               printf("After Writing (read inside writing function): %d \n ",test_str.DataLastTable[1]);
               system("pause");
}

Le fichier header:

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
typedef enum EnumType_e
{ 
   Enum_1       ,
   Enum_2 ,
   Enum_3
}
EnumType_t;
 
 
typedef struct rxfqdc_Info_Common_s
{
   unsigned char   A[45];
 
   EnumType_t  B[45];
 
   EnumType_t  C[53];
 
   EnumType_t  D[53];
 
   EnumType_t  E[53];
 
   EnumType_t  F[53];
 
   EnumType_t  G[43];
 
   EnumType_t  H[43];
 
   EnumType_t  I[43];
 
   EnumType_t  J[2]; 
 
   EnumType_t  K[2];
 
   EnumType_t  L[2];
 
   EnumType_t  M[2];
 
   EnumType_t  N[2];
 
   EnumType_t  O[2];
 
   EnumType_t  P[2];
 
   EnumType_t  Q[2];
 
   EnumType_t  R[2];
 
   EnumType_t  S[2];
 
   EnumType_t  DataLastTable[2];
}
My_struct_t __attribute__ ((aligned (2))) ; 
 
 
 
//functions prototypes:
 
void FonctionWritingData( My_struct_t *  const My_Data) ;
 
void FonctionReadingData(My_struct_t My_Data) ;

Merci d'avance.

**Bousk** · 17/10/2018, 14h31

Code :

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

1
2
3
4
5
6
//functions stubbing:
void FonctionReadingData(My_struct_t My_Data)
{ 
               R_Data_Str =  My_Data;
               R_Data_Ptr = (My_struct_t *)(&My_Data);
}

Tu assignes un pointeur local dans R_Data_Ptr, peu de chance qu'il soit encore valide par la suite.

structure alignée passée par valeur à une fonction

C

Vue hybride

Discussions similaires

Partager

Partager