1 /* $NetBSD: msg_247.c,v 1.35 2025/04/12 15:49:50 rillig Exp $ */
2 # 3 "msg_247.c"
3
4 // Test for message: pointer cast from '%s' to unrelated '%s' [247]
5
6 //
7 // The word 'may' in the message text means that the trouble is not necessarily
8 // on this platform with its specific type sizes, but on other platforms.
9 //
10 // See also:
11 // msg_247_ilp32_ldbl64.c
12 // msg_247_lp64_ldbl128.c
13 // msg_247_portable.c
14 // msg_247_portable_int.c
15
16 /* lint1-extra-flags: -c -X 351 */
17
18 /* example taken from Xlib.h */
19 typedef struct {
20 int id;
21 } *PDisplay;
22
23 struct Other {
24 int id;
25 };
26
27 PDisplay
example(struct Other * arg)28 example(struct Other *arg)
29 {
30 /*
31 * Before tree.c 1.461 from 2022-06-24, lint warned about the cast
32 * between the structs.
33 *
34 * XXX: The target type was reported as 'struct <unnamed>'. In cases
35 * like these, it would be helpful to print at least the type name
36 * of the pointer. This type name though is discarded immediately
37 * in the grammar rule 'typespec: T_TYPENAME'.
38 * After that, the target type of the cast is just an unnamed struct,
39 * with no hint at all that there is a typedef for a pointer to the
40 * struct.
41 */
42 return (PDisplay)arg;
43 }
44
45 /*
46 * C code with a long history that has existed in pre-C90 times already often
47 * uses 'pointer to char' where modern code would use 'pointer to void'.
48 * Since 'char' is the most general underlying type, there is nothing wrong
49 * with casting to it. An example for this type of code is X11.
50 *
51 * Casting to 'pointer to char' may also be used by programmers who don't know
52 * about endianness, but that's not something lint can do anything about. The
53 * code for these two use cases looks exactly the same, so lint errs on the
54 * side of fewer false positive warnings here.
55 */
56 char *
cast_to_char_pointer(struct Other * arg)57 cast_to_char_pointer(struct Other *arg)
58 {
59 return (char *)arg;
60 }
61
62 /*
63 * In traditional C, there was 'unsigned char' as well, so the same reasoning
64 * as for plain 'char' applies here.
65 */
66 unsigned char *
cast_to_unsigned_char_pointer(struct Other * arg)67 cast_to_unsigned_char_pointer(struct Other *arg)
68 {
69 return (unsigned char *)arg;
70 }
71
72 /*
73 * Traditional C does not have the type specifier 'signed', which means that
74 * this type cannot be used by old code. Therefore warn about this. All code
75 * that triggers this warning should do the intermediate cast via 'void
76 * pointer'.
77 */
78 signed char *
cast_to_signed_char_pointer(struct Other * arg)79 cast_to_signed_char_pointer(struct Other *arg)
80 {
81 /* expect+1: warning: pointer cast from 'struct Other' to unrelated 'signed char' [247] */
82 return (signed char *)arg;
83 }
84
85 char *
cast_to_void_pointer_then_to_char_pointer(struct Other * arg)86 cast_to_void_pointer_then_to_char_pointer(struct Other *arg)
87 {
88 return (char *)(void *)arg;
89 }
90
91
92 /*
93 * When implementing types that have a public part that is exposed to the user
94 * (in this case 'struct counter') and a private part that is only visible to
95 * the implementation (in this case 'struct counter_impl'), a common
96 * implementation technique is to use a struct in which the public part is the
97 * first member. C guarantees that the pointer to the first member is at the
98 * same address as the pointer to the whole struct.
99 *
100 * Seen in external/mpl/bind/dist/lib/isc/mem.c for 'struct isc_mem' and
101 * 'struct isc__mem'.
102 */
103
104 struct counter {
105 int count;
106 };
107
108 struct counter_impl {
109 struct counter public_part;
110 int saved_count;
111 };
112
113 void *allocate(void);
114
115 struct counter *
counter_new_typesafe(void)116 counter_new_typesafe(void)
117 {
118 struct counter_impl *impl = allocate();
119 impl->public_part.count = 12345;
120 impl->saved_count = 12346;
121 return &impl->public_part;
122 }
123
124 struct counter *
counter_new_cast(void)125 counter_new_cast(void)
126 {
127 struct counter_impl *impl = allocate();
128 impl->public_part.count = 12345;
129 impl->saved_count = 12346;
130 /* Before tree.c 1.462 from 2022-06-24, lint warned about this cast. */
131 return (struct counter *)impl;
132 }
133
134 void
counter_increment(struct counter * counter)135 counter_increment(struct counter *counter)
136 {
137 /*
138 * Before tree.c 1.272 from 2021-04-08, lint warned about the cast
139 * from 'struct counter' to 'struct counter_impl'.
140 */
141 struct counter_impl *impl = (struct counter_impl *)counter;
142 impl->saved_count = impl->public_part.count;
143 impl->public_part.count++;
144 }
145
146
147 /*
148 * In OpenSSL, the hashing API uses the incomplete 'struct lhash_st' for their
149 * type-generic hashing API while defining a separate struct for each type to
150 * be hashed.
151 *
152 * Before 2021-04-09, in a typical NetBSD build this led to about 38,000 lint
153 * warnings about possibly troublesome pointer casts.
154 */
155
156 /* expect+1: warning: struct 'lhash_st' never defined [233] */
157 struct lhash_st;
158
159 struct lhash_st *OPENSSL_LH_new(void);
160
161 struct lhash_st_OPENSSL_STRING {
162 union lh_OPENSSL_STRING_dummy {
163 void *d1;
164 unsigned long d2;
165 int d3;
166 } dummy;
167 };
168
169 # 196 "lhash.h" 1 3 4
170 struct lhash_st_OPENSSL_STRING *
lh_OPENSSL_STRING_new(void)171 lh_OPENSSL_STRING_new(void)
172 {
173 /*
174 * Since tree.c 1.274 from 2021-04-09, lint does not warn about casts
175 * to or from incomplete structs anymore.
176 */
177 return (struct lhash_st_OPENSSL_STRING *)OPENSSL_LH_new();
178 }
179 # 180 "msg_247.c" 2
180
181 void sink(const void *);
182
183 /*
184 * Before tree.c 1.316 from 2021-07-15, lint warned about pointer casts from
185 * unsigned char or plain char to another type. These casts often occur in
186 * traditional code that does not use void pointers, even 30 years after C90
187 * introduced 'void'.
188 */
189 void
unsigned_char_to_unsigned_type(unsigned char * ucp)190 unsigned_char_to_unsigned_type(unsigned char *ucp)
191 {
192 unsigned short *usp;
193
194 usp = (unsigned short *)ucp;
195 sink(usp);
196 }
197
198 /*
199 * Before tree.c 1.316 from 2021-07-15, lint warned about pointer casts from
200 * unsigned char or plain char to another type. These casts often occur in
201 * traditional code that does not use void pointers, even 30 years after C90
202 * introduced 'void'.
203 */
204 void
plain_char_to_unsigned_type(char * cp)205 plain_char_to_unsigned_type(char *cp)
206 {
207 unsigned short *usp;
208
209 usp = (unsigned short *)cp;
210 sink(usp);
211 }
212
213 /*
214 * Before tree.c 1.460 from 2022-06-24, lint warned about pointer casts from
215 * unsigned char or plain char to a struct or union type. These casts often
216 * occur in traditional code that does not use void pointers, even 30 years
217 * after C90 introduced 'void'.
218 */
219 void
char_to_struct(void * ptr)220 char_to_struct(void *ptr)
221 {
222
223 sink((struct counter *)(char *)ptr);
224
225 sink((struct counter *)(unsigned char *)ptr);
226
227 /* expect+1: warning: pointer cast from 'signed char' to unrelated 'struct counter' [247] */
228 sink((struct counter *)(signed char *)ptr);
229 }
230
231
232 // The following data types are simplified from various system headers.
233
234 typedef unsigned char uint8_t;
235 typedef unsigned short uint16_t;
236 typedef unsigned int uint32_t;
237
238 typedef uint16_t in_port_t;
239 typedef uint8_t sa_family_t;
240
241 struct sockaddr {
242 uint8_t sa_len;
243 sa_family_t sa_family;
244 char sa_data[14];
245 };
246
247 struct in_addr {
248 uint32_t s_addr;
249 };
250
251 struct sockaddr_in {
252 uint8_t sin_len;
253 sa_family_t sin_family;
254 in_port_t sin_port;
255 struct in_addr sin_addr;
256 uint8_t sin_zero[8];
257 };
258
259 struct sockaddr_in6 {
260 uint8_t sin6_len;
261 sa_family_t sin6_family;
262 in_port_t sin6_port;
263 uint32_t sin6_flowinfo;
264 union {
265 uint8_t u6_addr8[16];
266 uint16_t u6_addr16[8];
267 uint32_t u6_addr32[4];
268 } sin6_addr;
269 uint32_t sin6_scope_id;
270 };
271
272 /*
273 * Before tree.c 1.461 from 2022-06-24, lint warned about the cast between the
274 * sockaddr variants. Since then, lint allows casts between pointers to
275 * structs if the initial members have compatible types and either of the
276 * struct types continues with a byte array.
277 */
278 void *
cast_between_sockaddr_variants(void * ptr)279 cast_between_sockaddr_variants(void *ptr)
280 {
281
282 void *t1 = (struct sockaddr_in *)(struct sockaddr *)ptr;
283 void *t2 = (struct sockaddr *)(struct sockaddr_in *)t1;
284 void *t3 = (struct sockaddr_in6 *)(struct sockaddr *)t2;
285 void *t4 = (struct sockaddr *)(struct sockaddr_in6 *)t3;
286
287 /* expect+1: warning: pointer cast from 'struct sockaddr_in6' to unrelated 'struct sockaddr_in' [247] */
288 void *t5 = (struct sockaddr_in *)(struct sockaddr_in6 *)t4;
289
290 /* expect+1: warning: pointer cast from 'struct sockaddr_in' to unrelated 'struct sockaddr_in6' [247] */
291 void *t6 = (struct sockaddr_in6 *)(struct sockaddr_in *)t5;
292
293 return t6;
294 }
295
296
297 // From jemalloc.
298
299 typedef struct ctl_node_s {
300 _Bool named;
301 } ctl_node_t;
302
303 typedef struct ctl_named_node_s {
304 ctl_node_t node;
305 const char *name;
306 } ctl_named_node_t;
307
308 void *
cast_between_first_member_struct(void * ptr)309 cast_between_first_member_struct(void *ptr)
310 {
311 /* Before tree.c 1.462 from 2022-06-24, lint warned about this cast. */
312 /* expect+1: warning: 't1' set but not used in function 'cast_between_first_member_struct' [191] */
313 void *t1 = (ctl_node_t *)(ctl_named_node_t *)ptr;
314
315 void *t2 = (ctl_named_node_t *)(ctl_node_t *)ptr;
316
317 return t2;
318 }
319
320 double *
unnecessary_cast_from_array_to_pointer(int dim)321 unnecessary_cast_from_array_to_pointer(int dim)
322 {
323 static double storage_1d[10];
324 static double storage_2d[10][5];
325
326 if (dim == 1)
327 return (double *)storage_1d;
328
329 if (dim == -1)
330 return storage_1d;
331
332 if (dim == 2)
333 /* expect+1: warning: invalid combination of 'pointer to double' and 'pointer to array[5] of double' [184] */
334 return storage_2d;
335
336 /*
337 * C11 6.3.2.1p3 says that an array is converted to a pointer to its
338 * first element. That paragraph doesn't say 'recursively', that
339 * word is only used two paragraphs above, in 6.3.2.1p1.
340 */
341 if (dim == -2)
342 return storage_2d[0];
343
344 return (double *)storage_2d;
345 }
346
347
348 typedef void (*function)(void);
349
350 typedef struct {
351 function m_function_array[5];
352 } struct_function_array;
353
354 typedef union {
355 int um_int;
356 double um_double;
357 struct_function_array um_function_array;
358 } anything;
359
360 static int *p_int;
361 static double *p_double;
362 static function p_function;
363 static struct_function_array *p_function_array;
364 static anything *p_anything;
365
366 void
conversions_from_and_to_union(void)367 conversions_from_and_to_union(void)
368 {
369 /* Self-assignment, disguised by a cast to its own type. */
370 p_int = (int *)p_int;
371 /* Self-assignment, disguised by a cast to a pointer. */
372 p_int = (void *)p_int;
373
374 /* expect+1: warning: invalid combination of 'pointer to int' and 'pointer to double', op '=' [124] */
375 p_int = p_double;
376 /* expect+1: warning: pointer cast from 'double' to unrelated 'int' [247] */
377 p_int = (int *)p_double;
378
379 /* expect+1: warning: invalid combination of 'pointer to union typedef anything' and 'pointer to double', op '=' [124] */
380 p_anything = p_double;
381 /* OK, since the union 'anything' has a 'double' member. */
382 p_anything = (anything *)p_double;
383 /* expect+1: warning: invalid combination of 'pointer to double' and 'pointer to union typedef anything', op '=' [124] */
384 p_double = p_anything;
385 /* OK, since the union 'anything' has a 'double' member. */
386 p_double = (double *)p_anything;
387
388 /*
389 * Casting to an intermediate union does not make casting between two
390 * incompatible types better.
391 */
392 /* expect+1: warning: invalid combination of 'pointer to function(void) returning void' and 'pointer to union typedef anything', op '=' [124] */
393 p_function = (anything *)p_int;
394
395 /* expect+2: warning: converting 'pointer to function(void) returning void' to 'pointer to union typedef anything' is questionable [229] */
396 /* expect+1: warning: invalid combination of 'pointer to function(void) returning void' and 'pointer to union typedef anything', op '=' [124] */
397 p_function = (anything *)p_function_array->m_function_array[0];
398
399 /* expect+1: warning: invalid combination of 'pointer to int' and 'pointer to function(void) returning void', op '=' [124] */
400 p_int = p_function;
401 }
402