134 {
135 if (!__in_fake_assign)
136 return NULL;
137 return faked_expression;
138 }
139
140 static void split_fake_expr(struct expression *expr)
141 {
142 __in_fake_assign++;
143 __in_fake_struct_assign++;
144 __split_expr(expr);
145 __in_fake_struct_assign--;
146 __in_fake_assign--;
147 }
148
149 static void handle_non_struct_assignments(struct expression *left, struct expression *right)
150 {
151 struct symbol *type;
152 struct expression *assign;
153
154 type = get_type(left);
155 if (!type)
156 return;
157 if (type->type == SYM_PTR) {
158 left = deref_expression(left);
159 if (right)
160 right = deref_expression(right);
161 else
162 right = unknown_value_expression(left);
163 assign = assign_expression(left, '=', right);
164 split_fake_expr(assign);
165 return;
166 }
167 if (type->type != SYM_BASETYPE)
168 return;
169 right = strip_expr(right);
170 type = get_type(right);
171 if (!right || !type || type->type == SYM_ARRAY)
172 right = unknown_value_expression(left);
173 assign = assign_expression(left, '=', right);
217 case COPY_MEMSET:
218 right_member = right;
219 break;
220 }
221
222 assign = assign_expression(left_member, '=', right_member);
223 split_fake_expr(assign);
224 } END_FOR_EACH_PTR(tmp);
225 }
226
227 static void __struct_members_copy(int mode, struct expression *faked,
228 struct expression *left,
229 struct expression *right)
230 {
231 struct symbol *struct_type, *tmp, *type;
232 struct expression *left_member;
233 struct expression *right_member;
234 struct expression *assign;
235 int op = '.';
236
237
238 if (__in_fake_assign)
239 return;
240 faked_expression = faked;
241
242 left = strip_expr(left);
243 right = strip_expr(right);
244
245 struct_type = get_struct_type(left);
246 if (!struct_type) {
247 /*
248 * This is not a struct assignment obviously. But this is where
249 * memcpy() is handled so it feels like a good place to add this
250 * code.
251 */
252 handle_non_struct_assignments(left, right);
253 goto done;
254 }
255
256 if (is_pointer(left)) {
257 left = deref_expression(left);
258 op = '*';
259 }
260 if (mode != COPY_MEMSET)
261 right = get_right_base_expr(struct_type, right);
262
263 FOR_EACH_PTR(struct_type->symbol_list, tmp) {
264 type = get_real_base_type(tmp);
|
134 {
135 if (!__in_fake_assign)
136 return NULL;
137 return faked_expression;
138 }
139
140 static void split_fake_expr(struct expression *expr)
141 {
142 __in_fake_assign++;
143 __in_fake_struct_assign++;
144 __split_expr(expr);
145 __in_fake_struct_assign--;
146 __in_fake_assign--;
147 }
148
149 static void handle_non_struct_assignments(struct expression *left, struct expression *right)
150 {
151 struct symbol *type;
152 struct expression *assign;
153
154 while (right && right->type == EXPR_ASSIGNMENT)
155 right = strip_parens(right->left);
156
157 type = get_type(left);
158 if (!type)
159 return;
160 if (type->type == SYM_PTR) {
161 left = deref_expression(left);
162 if (right)
163 right = deref_expression(right);
164 else
165 right = unknown_value_expression(left);
166 assign = assign_expression(left, '=', right);
167 split_fake_expr(assign);
168 return;
169 }
170 if (type->type != SYM_BASETYPE)
171 return;
172 right = strip_expr(right);
173 type = get_type(right);
174 if (!right || !type || type->type == SYM_ARRAY)
175 right = unknown_value_expression(left);
176 assign = assign_expression(left, '=', right);
220 case COPY_MEMSET:
221 right_member = right;
222 break;
223 }
224
225 assign = assign_expression(left_member, '=', right_member);
226 split_fake_expr(assign);
227 } END_FOR_EACH_PTR(tmp);
228 }
229
230 static void __struct_members_copy(int mode, struct expression *faked,
231 struct expression *left,
232 struct expression *right)
233 {
234 struct symbol *struct_type, *tmp, *type;
235 struct expression *left_member;
236 struct expression *right_member;
237 struct expression *assign;
238 int op = '.';
239
240 if (__in_fake_assign)
241 return;
242 faked_expression = faked;
243
244 left = strip_expr(left);
245 right = strip_expr(right);
246
247 if (left->type == EXPR_PREOP && left->op == '*' && is_pointer(left))
248 left = preop_expression(left, '(');
249
250 struct_type = get_struct_type(left);
251 if (!struct_type) {
252 /*
253 * This is not a struct assignment obviously. But this is where
254 * memcpy() is handled so it feels like a good place to add this
255 * code.
256 */
257 handle_non_struct_assignments(left, right);
258 goto done;
259 }
260
261 if (is_pointer(left)) {
262 left = deref_expression(left);
263 op = '*';
264 }
265 if (mode != COPY_MEMSET)
266 right = get_right_base_expr(struct_type, right);
267
268 FOR_EACH_PTR(struct_type->symbol_list, tmp) {
269 type = get_real_base_type(tmp);
|