func.c revision 1.174 1 1.174 rillig /* $NetBSD: func.c,v 1.174 2023/08/06 19:44:50 rillig Exp $ */
2 1.2 cgd
3 1.1 cgd /*
4 1.1 cgd * Copyright (c) 1994, 1995 Jochen Pohl
5 1.1 cgd * All Rights Reserved.
6 1.1 cgd *
7 1.1 cgd * Redistribution and use in source and binary forms, with or without
8 1.1 cgd * modification, are permitted provided that the following conditions
9 1.1 cgd * are met:
10 1.1 cgd * 1. Redistributions of source code must retain the above copyright
11 1.1 cgd * notice, this list of conditions and the following disclaimer.
12 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
13 1.1 cgd * notice, this list of conditions and the following disclaimer in the
14 1.1 cgd * documentation and/or other materials provided with the distribution.
15 1.1 cgd * 3. All advertising materials mentioning features or use of this software
16 1.1 cgd * must display the following acknowledgement:
17 1.170 rillig * This product includes software developed by Jochen Pohl for
18 1.1 cgd * The NetBSD Project.
19 1.1 cgd * 4. The name of the author may not be used to endorse or promote products
20 1.1 cgd * derived from this software without specific prior written permission.
21 1.1 cgd *
22 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23 1.1 cgd * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 1.1 cgd * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25 1.1 cgd * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26 1.1 cgd * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27 1.1 cgd * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 1.1 cgd * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 1.1 cgd * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 1.1 cgd * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31 1.1 cgd * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 1.1 cgd */
33 1.1 cgd
34 1.21 jmc #if HAVE_NBTOOL_CONFIG_H
35 1.21 jmc #include "nbtool_config.h"
36 1.21 jmc #endif
37 1.21 jmc
38 1.8 christos #include <sys/cdefs.h>
39 1.136 rillig #if defined(__RCSID)
40 1.174 rillig __RCSID("$NetBSD: func.c,v 1.174 2023/08/06 19:44:50 rillig Exp $");
41 1.1 cgd #endif
42 1.1 cgd
43 1.1 cgd #include <stdlib.h>
44 1.1 cgd #include <string.h>
45 1.1 cgd
46 1.1 cgd #include "lint1.h"
47 1.10 tv #include "cgram.h"
48 1.1 cgd
49 1.1 cgd /*
50 1.1 cgd * Contains a pointer to the symbol table entry of the current function
51 1.1 cgd * definition.
52 1.1 cgd */
53 1.1 cgd sym_t *funcsym;
54 1.1 cgd
55 1.1 cgd /* Is set as long as a statement can be reached. Must be set at level 0. */
56 1.59 rillig bool reached = true;
57 1.1 cgd
58 1.1 cgd /*
59 1.94 rillig * Is true by default, can be cleared by NOTREACHED.
60 1.94 rillig * Is reset to true whenever 'reached' changes.
61 1.1 cgd */
62 1.94 rillig bool warn_about_unreachable;
63 1.1 cgd
64 1.1 cgd /*
65 1.63 rillig * In conjunction with 'reached', controls printing of "fallthrough on ..."
66 1.1 cgd * warnings.
67 1.158 rillig * Reset by each statement and set by FALLTHROUGH, stmt_switch_expr and
68 1.158 rillig * case_label.
69 1.1 cgd *
70 1.168 rillig * The control statements 'if', 'for', 'while' and 'switch' do not reset
71 1.168 rillig * suppress_fallthrough because this must be done by the controlled statement.
72 1.168 rillig * At least for 'if', this is important because ** FALLTHROUGH ** after "if
73 1.168 rillig * (expr) statement" is evaluated before the following token, which causes
74 1.168 rillig * reduction of above. This means that ** FALLTHROUGH ** after "if ..." would
75 1.168 rillig * always be ignored.
76 1.1 cgd */
77 1.168 rillig bool suppress_fallthrough;
78 1.1 cgd
79 1.48 rillig /* The innermost control statement */
80 1.150 rillig static control_statement *cstmt;
81 1.1 cgd
82 1.1 cgd /*
83 1.173 rillig * Number of parameters which will be checked for usage in following
84 1.173 rillig * function definition. -1 stands for all parameters.
85 1.1 cgd *
86 1.31 rillig * The position of the last ARGSUSED comment is stored in argsused_pos.
87 1.1 cgd */
88 1.1 cgd int nargusg = -1;
89 1.31 rillig pos_t argsused_pos;
90 1.1 cgd
91 1.1 cgd /*
92 1.173 rillig * Number of parameters of the following function definition whose types
93 1.173 rillig * shall be checked by lint2. -1 stands for all parameters.
94 1.1 cgd *
95 1.1 cgd * The position of the last VARARGS comment is stored in vapos.
96 1.1 cgd */
97 1.1 cgd int nvararg = -1;
98 1.1 cgd pos_t vapos;
99 1.1 cgd
100 1.1 cgd /*
101 1.49 rillig * Both printflike_argnum and scanflike_argnum contain the 1-based number
102 1.173 rillig * of the string parameter which shall be used to check the types of remaining
103 1.49 rillig * arguments (for PRINTFLIKE and SCANFLIKE).
104 1.1 cgd *
105 1.31 rillig * printflike_pos and scanflike_pos are the positions of the last PRINTFLIKE
106 1.31 rillig * or SCANFLIKE comment.
107 1.1 cgd */
108 1.49 rillig int printflike_argnum = -1;
109 1.49 rillig int scanflike_argnum = -1;
110 1.31 rillig pos_t printflike_pos;
111 1.31 rillig pos_t scanflike_pos;
112 1.1 cgd
113 1.1 cgd /*
114 1.28 rillig * If both plibflg and llibflg are set, prototypes are written as function
115 1.1 cgd * definitions to the output file.
116 1.1 cgd */
117 1.59 rillig bool plibflg;
118 1.1 cgd
119 1.168 rillig /* Temporarily suppress warnings about constants in conditional context. */
120 1.168 rillig bool suppress_constcond;
121 1.1 cgd
122 1.1 cgd /*
123 1.138 rillig * Whether a lint library shall be created. The effect of this flag is that
124 1.138 rillig * all defined symbols are treated as used.
125 1.1 cgd * (The LINTLIBRARY comment also resets vflag.)
126 1.1 cgd */
127 1.59 rillig bool llibflg;
128 1.1 cgd
129 1.1 cgd /*
130 1.138 rillig * Determines the warnings that are suppressed by a LINTED directive. For
131 1.138 rillig * globally suppressed warnings, see 'msgset'.
132 1.138 rillig *
133 1.138 rillig * LWARN_ALL: all warnings are enabled
134 1.138 rillig * LWARN_NONE: all warnings are suppressed
135 1.138 rillig * n >= 0: warning n is ignored, the others are active
136 1.1 cgd */
137 1.25 christos int lwarn = LWARN_ALL;
138 1.6 jpo
139 1.168 rillig /* Temporarily suppress warnings about wrong types for bit-fields. */
140 1.168 rillig bool suppress_bitfieldtype;
141 1.16 thorpej
142 1.168 rillig /* Temporarily suppress warnings about use of 'long long'. */
143 1.168 rillig bool suppress_longlong;
144 1.1 cgd
145 1.1 cgd void
146 1.96 rillig begin_control_statement(control_statement_kind kind)
147 1.1 cgd {
148 1.115 rillig control_statement *cs;
149 1.1 cgd
150 1.115 rillig cs = xcalloc(1, sizeof(*cs));
151 1.115 rillig cs->c_kind = kind;
152 1.115 rillig cs->c_surrounding = cstmt;
153 1.115 rillig cstmt = cs;
154 1.1 cgd }
155 1.1 cgd
156 1.1 cgd void
157 1.96 rillig end_control_statement(control_statement_kind kind)
158 1.1 cgd {
159 1.115 rillig control_statement *cs;
160 1.79 rillig case_label_t *cl, *next;
161 1.1 cgd
162 1.48 rillig lint_assert(cstmt != NULL);
163 1.110 rillig
164 1.110 rillig while (cstmt->c_kind != kind)
165 1.110 rillig cstmt = cstmt->c_surrounding;
166 1.1 cgd
167 1.115 rillig cs = cstmt;
168 1.115 rillig cstmt = cs->c_surrounding;
169 1.1 cgd
170 1.115 rillig for (cl = cs->c_case_labels; cl != NULL; cl = next) {
171 1.63 rillig next = cl->cl_next;
172 1.1 cgd free(cl);
173 1.1 cgd }
174 1.1 cgd
175 1.115 rillig free(cs->c_switch_type);
176 1.115 rillig free(cs);
177 1.1 cgd }
178 1.1 cgd
179 1.93 rillig static void
180 1.93 rillig set_reached(bool new_reached)
181 1.93 rillig {
182 1.118 rillig debug_step("%s -> %s",
183 1.106 rillig reached ? "reachable" : "unreachable",
184 1.106 rillig new_reached ? "reachable" : "unreachable");
185 1.93 rillig reached = new_reached;
186 1.94 rillig warn_about_unreachable = true;
187 1.93 rillig }
188 1.93 rillig
189 1.1 cgd /*
190 1.1 cgd * Prints a warning if a statement cannot be reached.
191 1.1 cgd */
192 1.1 cgd void
193 1.31 rillig check_statement_reachable(void)
194 1.1 cgd {
195 1.94 rillig if (!reached && warn_about_unreachable) {
196 1.1 cgd /* statement not reached */
197 1.1 cgd warning(193);
198 1.95 rillig warn_about_unreachable = false;
199 1.1 cgd }
200 1.1 cgd }
201 1.1 cgd
202 1.1 cgd /*
203 1.1 cgd * Called after a function declaration which introduces a function definition
204 1.173 rillig * and before an (optional) old-style parameter declaration list.
205 1.1 cgd *
206 1.173 rillig * Puts all symbols declared in the prototype or in an old-style parameter
207 1.1 cgd * list back to the symbol table.
208 1.1 cgd *
209 1.1 cgd * Does the usual checking of storage class, type (return value),
210 1.28 rillig * redeclaration, etc.
211 1.1 cgd */
212 1.1 cgd void
213 1.146 rillig begin_function(sym_t *fsym)
214 1.1 cgd {
215 1.155 rillig int n;
216 1.155 rillig bool dowarn;
217 1.173 rillig sym_t *sym, *rdsym;
218 1.1 cgd
219 1.1 cgd funcsym = fsym;
220 1.1 cgd
221 1.1 cgd /*
222 1.173 rillig * Put all symbols declared in the parameter list back to the
223 1.1 cgd * symbol table.
224 1.1 cgd */
225 1.128 rillig for (sym = dcs->d_func_proto_syms; sym != NULL;
226 1.128 rillig sym = sym->s_level_next) {
227 1.77 rillig if (sym->s_block_level != -1) {
228 1.77 rillig lint_assert(sym->s_block_level == 1);
229 1.1 cgd inssym(1, sym);
230 1.1 cgd }
231 1.1 cgd }
232 1.1 cgd
233 1.1 cgd /*
234 1.29 rillig * In old_style_function() we did not know whether it is an old
235 1.145 rillig * style function definition or only an old-style declaration,
236 1.173 rillig * if there are no parameters inside the parameter list ("f()").
237 1.1 cgd */
238 1.173 rillig if (!fsym->s_type->t_proto && fsym->u.s_old_style_params == NULL)
239 1.59 rillig fsym->s_osdef = true;
240 1.1 cgd
241 1.29 rillig check_type(fsym);
242 1.1 cgd
243 1.1 cgd /*
244 1.29 rillig * check_type() checks for almost all possible errors, but not for
245 1.1 cgd * incomplete return values (these are allowed in declarations)
246 1.1 cgd */
247 1.1 cgd if (fsym->s_type->t_subt->t_tspec != VOID &&
248 1.66 rillig is_incomplete(fsym->s_type->t_subt)) {
249 1.1 cgd /* cannot return incomplete type */
250 1.1 cgd error(67);
251 1.1 cgd }
252 1.1 cgd
253 1.4 jpo fsym->s_def = DEF;
254 1.1 cgd
255 1.1 cgd if (fsym->s_scl == TYPEDEF) {
256 1.1 cgd fsym->s_scl = EXTERN;
257 1.1 cgd /* illegal storage class */
258 1.1 cgd error(8);
259 1.1 cgd }
260 1.1 cgd
261 1.4 jpo if (dcs->d_inline)
262 1.59 rillig fsym->s_inline = true;
263 1.4 jpo
264 1.1 cgd /*
265 1.173 rillig * Parameters in new-style function declarations need a name.
266 1.173 rillig * ('void' is already removed from the list of parameters.)
267 1.1 cgd */
268 1.1 cgd n = 1;
269 1.173 rillig for (const sym_t *param = fsym->s_type->t_params;
270 1.173 rillig param != NULL; param = param->s_next) {
271 1.173 rillig if (param->s_scl == ABSTRACT) {
272 1.173 rillig lint_assert(param->s_name == unnamed);
273 1.141 rillig /* formal parameter #%d lacks name */
274 1.1 cgd error(59, n);
275 1.1 cgd } else {
276 1.173 rillig lint_assert(param->s_name != unnamed);
277 1.1 cgd }
278 1.1 cgd n++;
279 1.1 cgd }
280 1.1 cgd
281 1.1 cgd /*
282 1.35 rillig * We must also remember the position. s_def_pos is overwritten
283 1.156 rillig * if this is an old-style definition, and we had already a prototype.
284 1.1 cgd */
285 1.81 rillig dcs->d_func_def_pos = fsym->s_def_pos;
286 1.1 cgd
287 1.80 rillig if ((rdsym = dcs->d_redeclared_symbol) != NULL) {
288 1.1 cgd
289 1.59 rillig if (!check_redeclaration(fsym, (dowarn = false, &dowarn))) {
290 1.1 cgd
291 1.1 cgd /*
292 1.5 jpo * Print nothing if the newly defined function
293 1.1 cgd * is defined in old style. A better warning will
294 1.38 rillig * be printed in check_func_lint_directives().
295 1.1 cgd */
296 1.24 dholland if (dowarn && !fsym->s_osdef) {
297 1.135 rillig /* TODO: error in C99 mode as well? */
298 1.135 rillig if (!allow_trad && !allow_c99)
299 1.139 rillig /* redeclaration of '%s' */
300 1.50 rillig error(27, fsym->s_name);
301 1.50 rillig else
302 1.139 rillig /* redeclaration of '%s' */
303 1.50 rillig warning(27, fsym->s_name);
304 1.144 rillig print_previous_declaration(rdsym);
305 1.1 cgd }
306 1.1 cgd
307 1.29 rillig copy_usage_info(fsym, rdsym);
308 1.1 cgd
309 1.1 cgd /*
310 1.1 cgd * If the old symbol was a prototype and the new
311 1.1 cgd * one is none, overtake the position of the
312 1.1 cgd * declaration of the prototype.
313 1.1 cgd */
314 1.1 cgd if (fsym->s_osdef && rdsym->s_type->t_proto)
315 1.36 rillig fsym->s_def_pos = rdsym->s_def_pos;
316 1.1 cgd
317 1.29 rillig complete_type(fsym, rdsym);
318 1.1 cgd
319 1.4 jpo if (rdsym->s_inline)
320 1.59 rillig fsym->s_inline = true;
321 1.4 jpo
322 1.1 cgd }
323 1.1 cgd
324 1.1 cgd /* remove the old symbol from the symbol table */
325 1.1 cgd rmsym(rdsym);
326 1.1 cgd
327 1.1 cgd }
328 1.1 cgd
329 1.1 cgd if (fsym->s_osdef && !fsym->s_type->t_proto) {
330 1.135 rillig /* TODO: Make this an error in C99 mode as well. */
331 1.135 rillig if ((!allow_trad && !allow_c99) && hflag &&
332 1.135 rillig strcmp(fsym->s_name, "main") != 0)
333 1.28 rillig /* function definition is not a prototype */
334 1.1 cgd warning(286);
335 1.1 cgd }
336 1.1 cgd
337 1.159 rillig if (dcs->d_no_type_specifier)
338 1.69 rillig fsym->s_return_type_implicit_int = true;
339 1.1 cgd
340 1.93 rillig set_reached(true);
341 1.1 cgd }
342 1.1 cgd
343 1.72 rillig static void
344 1.72 rillig check_missing_return_value(void)
345 1.72 rillig {
346 1.72 rillig if (funcsym->s_type->t_subt->t_tspec == VOID)
347 1.72 rillig return;
348 1.72 rillig if (funcsym->s_return_type_implicit_int)
349 1.72 rillig return;
350 1.72 rillig
351 1.72 rillig /* C99 5.1.2.2.3 "Program termination" p1 */
352 1.133 rillig if (allow_c99 && strcmp(funcsym->s_name, "main") == 0)
353 1.72 rillig return;
354 1.72 rillig
355 1.142 rillig /* function '%s' falls off bottom without returning value */
356 1.72 rillig warning(217, funcsym->s_name);
357 1.72 rillig }
358 1.72 rillig
359 1.1 cgd /*
360 1.1 cgd * Called at the end of a function definition.
361 1.1 cgd */
362 1.1 cgd void
363 1.146 rillig end_function(void)
364 1.1 cgd {
365 1.1 cgd
366 1.1 cgd if (reached) {
367 1.63 rillig cstmt->c_had_return_noval = true;
368 1.72 rillig check_missing_return_value();
369 1.1 cgd }
370 1.1 cgd
371 1.1 cgd /*
372 1.22 perry * This warning is printed only if the return value was implicitly
373 1.156 rillig * declared to be int. Otherwise, the wrong return statement
374 1.1 cgd * has already printed a warning.
375 1.1 cgd */
376 1.63 rillig if (cstmt->c_had_return_noval && cstmt->c_had_return_value &&
377 1.69 rillig funcsym->s_return_type_implicit_int)
378 1.142 rillig /* function '%s' has 'return expr' and 'return' */
379 1.1 cgd warning(216, funcsym->s_name);
380 1.1 cgd
381 1.172 rillig /* Warn about unused parameters. */
382 1.172 rillig int n = nargusg;
383 1.172 rillig nargusg = -1;
384 1.173 rillig for (const sym_t *param = dcs->d_func_params;
385 1.173 rillig param != NULL && n != 0; param = param->s_next, n--)
386 1.173 rillig check_usage_sym(dcs->d_asm, param);
387 1.1 cgd
388 1.1 cgd /*
389 1.4 jpo * write the information about the function definition to the
390 1.1 cgd * output file
391 1.15 wiz * inline functions explicitly declared extern are written as
392 1.4 jpo * declarations only.
393 1.1 cgd */
394 1.4 jpo if (dcs->d_scl == EXTERN && funcsym->s_inline) {
395 1.4 jpo outsym(funcsym, funcsym->s_scl, DECL);
396 1.4 jpo } else {
397 1.81 rillig outfdef(funcsym, &dcs->d_func_def_pos,
398 1.81 rillig cstmt->c_had_return_value, funcsym->s_osdef,
399 1.173 rillig dcs->d_func_params);
400 1.1 cgd }
401 1.1 cgd
402 1.111 rillig /* clean up after syntax errors, see test stmt_for.c. */
403 1.129 rillig while (dcs->d_enclosing != NULL)
404 1.129 rillig dcs = dcs->d_enclosing;
405 1.111 rillig
406 1.1 cgd /*
407 1.173 rillig * Remove all symbols declared during the parameter declaration from
408 1.173 rillig * the symbol table.
409 1.1 cgd */
410 1.129 rillig lint_assert(dcs->d_enclosing == NULL);
411 1.160 rillig lint_assert(dcs->d_kind == DLK_EXTERN);
412 1.162 rillig symtab_remove_level(dcs->d_func_proto_syms);
413 1.1 cgd
414 1.1 cgd /* must be set on level 0 */
415 1.93 rillig set_reached(true);
416 1.147 rillig
417 1.147 rillig funcsym = NULL;
418 1.1 cgd }
419 1.1 cgd
420 1.1 cgd void
421 1.42 rillig named_label(sym_t *sym)
422 1.42 rillig {
423 1.42 rillig
424 1.42 rillig if (sym->s_set) {
425 1.142 rillig /* label '%s' redefined */
426 1.42 rillig error(194, sym->s_name);
427 1.42 rillig } else {
428 1.42 rillig mark_as_set(sym);
429 1.42 rillig }
430 1.42 rillig
431 1.149 rillig /* XXX: Assuming that each label is reachable is wrong. */
432 1.93 rillig set_reached(true);
433 1.42 rillig }
434 1.42 rillig
435 1.43 rillig static void
436 1.108 rillig check_case_label_bitand(const tnode_t *case_expr, const tnode_t *switch_expr)
437 1.108 rillig {
438 1.108 rillig
439 1.108 rillig if (switch_expr->tn_op != BITAND ||
440 1.108 rillig switch_expr->tn_right->tn_op != CON)
441 1.108 rillig return;
442 1.108 rillig
443 1.108 rillig lint_assert(case_expr->tn_op == CON);
444 1.167 rillig uint64_t case_value = (uint64_t)case_expr->tn_val.u.integer;
445 1.167 rillig uint64_t mask = (uint64_t)switch_expr->tn_right->tn_val.u.integer;
446 1.108 rillig
447 1.108 rillig if ((case_value & ~mask) != 0) {
448 1.108 rillig /* statement not reached */
449 1.108 rillig warning(193);
450 1.108 rillig }
451 1.108 rillig }
452 1.108 rillig
453 1.108 rillig static void
454 1.115 rillig check_case_label_enum(const tnode_t *tn, const control_statement *cs)
455 1.75 rillig {
456 1.75 rillig /* similar to typeok_enum in tree.c */
457 1.75 rillig
458 1.115 rillig if (!(tn->tn_type->t_is_enum || cs->c_switch_type->t_is_enum))
459 1.75 rillig return;
460 1.115 rillig if (tn->tn_type->t_is_enum && cs->c_switch_type->t_is_enum &&
461 1.115 rillig tn->tn_type->t_enum == cs->c_switch_type->t_enum)
462 1.75 rillig return;
463 1.75 rillig
464 1.76 rillig #if 0 /* not yet ready, see msg_130.c */
465 1.75 rillig /* enum type mismatch: '%s' '%s' '%s' */
466 1.115 rillig warning(130, type_name(cs->c_switch_type), op_name(EQ),
467 1.75 rillig type_name(tn->tn_type));
468 1.76 rillig #endif
469 1.75 rillig }
470 1.75 rillig
471 1.75 rillig static void
472 1.115 rillig check_case_label(tnode_t *tn, control_statement *cs)
473 1.1 cgd {
474 1.79 rillig case_label_t *cl;
475 1.155 rillig val_t *v;
476 1.155 rillig val_t nv;
477 1.155 rillig tspec_t t;
478 1.1 cgd
479 1.115 rillig if (cs == NULL) {
480 1.42 rillig /* case not in switch */
481 1.42 rillig error(195);
482 1.43 rillig return;
483 1.43 rillig }
484 1.43 rillig
485 1.149 rillig if (tn == NULL)
486 1.149 rillig return;
487 1.149 rillig
488 1.149 rillig if (tn->tn_op != CON) {
489 1.42 rillig /* non-constant case expression */
490 1.42 rillig error(197);
491 1.43 rillig return;
492 1.43 rillig }
493 1.43 rillig
494 1.149 rillig if (!is_integer(tn->tn_type->t_tspec)) {
495 1.42 rillig /* non-integral case expression */
496 1.42 rillig error(198);
497 1.43 rillig return;
498 1.42 rillig }
499 1.1 cgd
500 1.115 rillig check_case_label_bitand(tn, cs->c_switch_expr);
501 1.115 rillig check_case_label_enum(tn, cs);
502 1.75 rillig
503 1.115 rillig lint_assert(cs->c_switch_type != NULL);
504 1.1 cgd
505 1.168 rillig if (reached && !suppress_fallthrough) {
506 1.43 rillig if (hflag)
507 1.43 rillig /* fallthrough on case statement */
508 1.43 rillig warning(220);
509 1.43 rillig }
510 1.1 cgd
511 1.43 rillig t = tn->tn_type->t_tspec;
512 1.43 rillig if (t == LONG || t == ULONG ||
513 1.164 rillig t == LLONG || t == ULLONG) {
514 1.134 rillig if (!allow_c90)
515 1.120 rillig /* case label must be of type 'int' in traditional C */
516 1.43 rillig warning(203);
517 1.43 rillig }
518 1.1 cgd
519 1.43 rillig /*
520 1.43 rillig * get the value of the expression and convert it
521 1.43 rillig * to the type of the switch expression
522 1.43 rillig */
523 1.161 rillig v = integer_constant(tn, true);
524 1.101 rillig (void)memset(&nv, 0, sizeof(nv));
525 1.115 rillig convert_constant(CASE, 0, cs->c_switch_type, &nv, v);
526 1.43 rillig free(v);
527 1.43 rillig
528 1.43 rillig /* look if we had this value already */
529 1.115 rillig for (cl = cs->c_case_labels; cl != NULL; cl = cl->cl_next) {
530 1.163 rillig if (cl->cl_val.u.integer == nv.u.integer)
531 1.43 rillig break;
532 1.43 rillig }
533 1.55 rillig if (cl != NULL && is_uinteger(nv.v_tspec)) {
534 1.166 rillig /* duplicate case '%lu' in switch */
535 1.163 rillig error(200, (unsigned long)nv.u.integer);
536 1.43 rillig } else if (cl != NULL) {
537 1.166 rillig /* duplicate case '%ld' in switch */
538 1.163 rillig error(199, (long)nv.u.integer);
539 1.43 rillig } else {
540 1.163 rillig check_getopt_case_label(nv.u.integer);
541 1.68 rillig
542 1.103 rillig /* append the value to the list of case values */
543 1.101 rillig cl = xcalloc(1, sizeof(*cl));
544 1.43 rillig cl->cl_val = nv;
545 1.115 rillig cl->cl_next = cs->c_case_labels;
546 1.115 rillig cs->c_case_labels = cl;
547 1.42 rillig }
548 1.43 rillig }
549 1.43 rillig
550 1.43 rillig void
551 1.43 rillig case_label(tnode_t *tn)
552 1.43 rillig {
553 1.115 rillig control_statement *cs;
554 1.43 rillig
555 1.51 rillig /* find the innermost switch statement */
556 1.115 rillig for (cs = cstmt; cs != NULL && !cs->c_switch; cs = cs->c_surrounding)
557 1.43 rillig continue;
558 1.43 rillig
559 1.115 rillig check_case_label(tn, cs);
560 1.43 rillig
561 1.99 rillig expr_free_all();
562 1.42 rillig
563 1.93 rillig set_reached(true);
564 1.42 rillig }
565 1.42 rillig
566 1.42 rillig void
567 1.42 rillig default_label(void)
568 1.42 rillig {
569 1.115 rillig control_statement *cs;
570 1.1 cgd
571 1.51 rillig /* find the innermost switch statement */
572 1.115 rillig for (cs = cstmt; cs != NULL && !cs->c_switch; cs = cs->c_surrounding)
573 1.42 rillig continue;
574 1.1 cgd
575 1.115 rillig if (cs == NULL) {
576 1.42 rillig /* default outside switch */
577 1.42 rillig error(201);
578 1.115 rillig } else if (cs->c_default) {
579 1.42 rillig /* duplicate default in switch */
580 1.42 rillig error(202);
581 1.42 rillig } else {
582 1.168 rillig if (reached && !suppress_fallthrough) {
583 1.42 rillig if (hflag)
584 1.42 rillig /* fallthrough on default statement */
585 1.42 rillig warning(284);
586 1.1 cgd }
587 1.115 rillig cs->c_default = true;
588 1.42 rillig }
589 1.42 rillig
590 1.93 rillig set_reached(true);
591 1.1 cgd }
592 1.1 cgd
593 1.39 rillig static tnode_t *
594 1.39 rillig check_controlling_expression(tnode_t *tn)
595 1.39 rillig {
596 1.39 rillig
597 1.124 rillig tn = cconv(tn);
598 1.39 rillig if (tn != NULL)
599 1.60 rillig tn = promote(NOOP, false, tn);
600 1.39 rillig
601 1.55 rillig if (tn != NULL && !is_scalar(tn->tn_type->t_tspec)) {
602 1.39 rillig /* C99 6.5.15p4 for the ?: operator; see typeok:QUEST */
603 1.39 rillig /* C99 6.8.4.1p1 for if statements */
604 1.39 rillig /* C99 6.8.5p2 for while, do and for loops */
605 1.39 rillig /* controlling expressions must have scalar type */
606 1.39 rillig error(204);
607 1.39 rillig return NULL;
608 1.39 rillig }
609 1.39 rillig
610 1.140 rillig if (tn != NULL && Tflag && !is_typeok_bool_compares_with_zero(tn)) {
611 1.57 rillig /* controlling expression must be bool, not '%s' */
612 1.154 rillig error(333, tn->tn_type->t_is_enum ? type_name(tn->tn_type)
613 1.154 rillig : tspec_name(tn->tn_type->t_tspec));
614 1.57 rillig }
615 1.57 rillig
616 1.39 rillig return tn;
617 1.39 rillig }
618 1.39 rillig
619 1.1 cgd void
620 1.158 rillig stmt_if_expr(tnode_t *tn)
621 1.1 cgd {
622 1.14 lukem
623 1.1 cgd if (tn != NULL)
624 1.39 rillig tn = check_controlling_expression(tn);
625 1.1 cgd if (tn != NULL)
626 1.67 rillig expr(tn, false, true, false, false);
627 1.96 rillig begin_control_statement(CS_IF);
628 1.88 rillig
629 1.88 rillig if (tn != NULL && tn->tn_op == CON && !tn->tn_system_dependent) {
630 1.93 rillig /* XXX: what if inside 'if (0)'? */
631 1.93 rillig set_reached(constant_is_nonzero(tn));
632 1.93 rillig /* XXX: what about always_else? */
633 1.88 rillig cstmt->c_always_then = reached;
634 1.88 rillig }
635 1.1 cgd }
636 1.1 cgd
637 1.1 cgd void
638 1.158 rillig stmt_if_then_stmt(void)
639 1.1 cgd {
640 1.14 lukem
641 1.87 rillig cstmt->c_reached_end_of_then = reached;
642 1.93 rillig /* XXX: what if inside 'if (0)'? */
643 1.93 rillig set_reached(!cstmt->c_always_then);
644 1.1 cgd }
645 1.1 cgd
646 1.1 cgd void
647 1.158 rillig stmt_if_else_stmt(bool els)
648 1.1 cgd {
649 1.90 rillig if (cstmt->c_reached_end_of_then)
650 1.93 rillig set_reached(true);
651 1.90 rillig else if (cstmt->c_always_then)
652 1.93 rillig set_reached(false);
653 1.90 rillig else if (!els)
654 1.93 rillig set_reached(true);
655 1.14 lukem
656 1.96 rillig end_control_statement(CS_IF);
657 1.1 cgd }
658 1.1 cgd
659 1.1 cgd void
660 1.158 rillig stmt_switch_expr(tnode_t *tn)
661 1.1 cgd {
662 1.155 rillig tspec_t t;
663 1.155 rillig type_t *tp;
664 1.1 cgd
665 1.1 cgd if (tn != NULL)
666 1.1 cgd tn = cconv(tn);
667 1.1 cgd if (tn != NULL)
668 1.60 rillig tn = promote(NOOP, false, tn);
669 1.55 rillig if (tn != NULL && !is_integer(tn->tn_type->t_tspec)) {
670 1.1 cgd /* switch expression must have integral type */
671 1.1 cgd error(205);
672 1.1 cgd tn = NULL;
673 1.1 cgd }
674 1.134 rillig if (tn != NULL && !allow_c90) {
675 1.1 cgd t = tn->tn_type->t_tspec;
676 1.164 rillig if (t == LONG || t == ULONG || t == LLONG || t == ULLONG) {
677 1.123 rillig /* switch expression must be of type 'int' in ... */
678 1.1 cgd warning(271);
679 1.1 cgd }
680 1.1 cgd }
681 1.1 cgd
682 1.1 cgd /*
683 1.37 rillig * Remember the type of the expression. Because it's possible
684 1.37 rillig * that (*tp) is allocated on tree memory, the type must be
685 1.1 cgd * duplicated. This is not too complicated because it is
686 1.1 cgd * only an integer type.
687 1.1 cgd */
688 1.101 rillig tp = xcalloc(1, sizeof(*tp));
689 1.1 cgd if (tn != NULL) {
690 1.1 cgd tp->t_tspec = tn->tn_type->t_tspec;
691 1.71 rillig if ((tp->t_is_enum = tn->tn_type->t_is_enum) != false)
692 1.1 cgd tp->t_enum = tn->tn_type->t_enum;
693 1.1 cgd } else {
694 1.1 cgd tp->t_tspec = INT;
695 1.1 cgd }
696 1.1 cgd
697 1.108 rillig /* leak the memory, for check_case_label_bitand */
698 1.122 rillig (void)expr_save_memory();
699 1.108 rillig
700 1.68 rillig check_getopt_begin_switch();
701 1.108 rillig expr(tn, true, false, false, false);
702 1.1 cgd
703 1.96 rillig begin_control_statement(CS_SWITCH);
704 1.59 rillig cstmt->c_switch = true;
705 1.97 rillig cstmt->c_switch_type = tp;
706 1.108 rillig cstmt->c_switch_expr = tn;
707 1.1 cgd
708 1.93 rillig set_reached(false);
709 1.168 rillig suppress_fallthrough = true;
710 1.1 cgd }
711 1.1 cgd
712 1.1 cgd void
713 1.158 rillig stmt_switch_expr_stmt(void)
714 1.1 cgd {
715 1.155 rillig int nenum = 0, nclab = 0;
716 1.155 rillig sym_t *esym;
717 1.79 rillig case_label_t *cl;
718 1.1 cgd
719 1.97 rillig lint_assert(cstmt->c_switch_type != NULL);
720 1.1 cgd
721 1.97 rillig if (cstmt->c_switch_type->t_is_enum) {
722 1.112 rillig /*
723 1.112 rillig * Warn if the number of case labels is different from the
724 1.112 rillig * number of enumerators.
725 1.112 rillig */
726 1.1 cgd nenum = nclab = 0;
727 1.97 rillig lint_assert(cstmt->c_switch_type->t_enum != NULL);
728 1.97 rillig for (esym = cstmt->c_switch_type->t_enum->en_first_enumerator;
729 1.32 rillig esym != NULL; esym = esym->s_next) {
730 1.1 cgd nenum++;
731 1.1 cgd }
732 1.79 rillig for (cl = cstmt->c_case_labels; cl != NULL; cl = cl->cl_next)
733 1.1 cgd nclab++;
734 1.137 rillig if (hflag && eflag && nclab < nenum && !cstmt->c_default) {
735 1.1 cgd /* enumeration value(s) not handled in switch */
736 1.1 cgd warning(206);
737 1.1 cgd }
738 1.1 cgd }
739 1.1 cgd
740 1.68 rillig check_getopt_end_switch();
741 1.68 rillig
742 1.48 rillig if (cstmt->c_break) {
743 1.1 cgd /*
744 1.112 rillig * The end of the switch statement is always reached since
745 1.112 rillig * c_break is only set if a break statement can actually
746 1.112 rillig * be reached.
747 1.1 cgd */
748 1.93 rillig set_reached(true);
749 1.112 rillig } else if (cstmt->c_default ||
750 1.112 rillig (hflag && cstmt->c_switch_type->t_is_enum &&
751 1.112 rillig nenum == nclab)) {
752 1.1 cgd /*
753 1.112 rillig * The end of the switch statement is reached if the end
754 1.112 rillig * of the last statement inside it is reached.
755 1.112 rillig */
756 1.112 rillig } else {
757 1.112 rillig /*
758 1.112 rillig * There are possible values that are not handled in the
759 1.112 rillig * switch statement.
760 1.1 cgd */
761 1.93 rillig set_reached(true);
762 1.112 rillig }
763 1.1 cgd
764 1.96 rillig end_control_statement(CS_SWITCH);
765 1.1 cgd }
766 1.1 cgd
767 1.1 cgd void
768 1.158 rillig stmt_while_expr(tnode_t *tn)
769 1.1 cgd {
770 1.92 rillig bool body_reached;
771 1.14 lukem
772 1.1 cgd if (!reached) {
773 1.1 cgd /* loop not entered at top */
774 1.1 cgd warning(207);
775 1.93 rillig /* FIXME: that's plain wrong. */
776 1.93 rillig set_reached(true);
777 1.1 cgd }
778 1.1 cgd
779 1.1 cgd if (tn != NULL)
780 1.39 rillig tn = check_controlling_expression(tn);
781 1.1 cgd
782 1.96 rillig begin_control_statement(CS_WHILE);
783 1.59 rillig cstmt->c_loop = true;
784 1.92 rillig cstmt->c_maybe_endless = is_nonzero(tn);
785 1.92 rillig body_reached = !is_zero(tn);
786 1.1 cgd
787 1.68 rillig check_getopt_begin_while(tn);
788 1.67 rillig expr(tn, false, true, true, false);
789 1.92 rillig
790 1.93 rillig set_reached(body_reached);
791 1.1 cgd }
792 1.1 cgd
793 1.1 cgd void
794 1.158 rillig stmt_while_expr_stmt(void)
795 1.1 cgd {
796 1.14 lukem
797 1.1 cgd /*
798 1.1 cgd * The end of the loop can be reached if it is no endless loop
799 1.1 cgd * or there was a break statement which was reached.
800 1.1 cgd */
801 1.93 rillig set_reached(!cstmt->c_maybe_endless || cstmt->c_break);
802 1.1 cgd
803 1.68 rillig check_getopt_end_while();
804 1.96 rillig end_control_statement(CS_WHILE);
805 1.1 cgd }
806 1.1 cgd
807 1.1 cgd void
808 1.158 rillig stmt_do(void)
809 1.1 cgd {
810 1.14 lukem
811 1.1 cgd if (!reached) {
812 1.1 cgd /* loop not entered at top */
813 1.1 cgd warning(207);
814 1.93 rillig set_reached(true);
815 1.1 cgd }
816 1.1 cgd
817 1.96 rillig begin_control_statement(CS_DO_WHILE);
818 1.59 rillig cstmt->c_loop = true;
819 1.1 cgd }
820 1.1 cgd
821 1.1 cgd void
822 1.158 rillig stmt_do_while_expr(tnode_t *tn)
823 1.1 cgd {
824 1.14 lukem
825 1.1 cgd /*
826 1.28 rillig * If there was a continue statement, the expression controlling the
827 1.1 cgd * loop is reached.
828 1.1 cgd */
829 1.85 rillig if (cstmt->c_continue)
830 1.93 rillig set_reached(true);
831 1.1 cgd
832 1.1 cgd if (tn != NULL)
833 1.39 rillig tn = check_controlling_expression(tn);
834 1.1 cgd
835 1.1 cgd if (tn != NULL && tn->tn_op == CON) {
836 1.84 rillig cstmt->c_maybe_endless = constant_is_nonzero(tn);
837 1.85 rillig if (!cstmt->c_maybe_endless && cstmt->c_continue)
838 1.46 rillig /* continue in 'do ... while (0)' loop */
839 1.46 rillig error(323);
840 1.1 cgd }
841 1.1 cgd
842 1.67 rillig expr(tn, false, true, true, true);
843 1.1 cgd
844 1.84 rillig if (cstmt->c_maybe_endless)
845 1.93 rillig set_reached(false);
846 1.83 rillig if (cstmt->c_break)
847 1.93 rillig set_reached(true);
848 1.1 cgd
849 1.96 rillig end_control_statement(CS_DO_WHILE);
850 1.1 cgd }
851 1.1 cgd
852 1.1 cgd void
853 1.158 rillig stmt_for_exprs(tnode_t *tn1, tnode_t *tn2, tnode_t *tn3)
854 1.1 cgd {
855 1.14 lukem
856 1.1 cgd /*
857 1.73 rillig * If there is no initialization expression it is possible that
858 1.1 cgd * it is intended not to enter the loop at top.
859 1.1 cgd */
860 1.1 cgd if (tn1 != NULL && !reached) {
861 1.1 cgd /* loop not entered at top */
862 1.1 cgd warning(207);
863 1.93 rillig set_reached(true);
864 1.1 cgd }
865 1.1 cgd
866 1.96 rillig begin_control_statement(CS_FOR);
867 1.59 rillig cstmt->c_loop = true;
868 1.1 cgd
869 1.1 cgd /*
870 1.73 rillig * Store the tree memory for the reinitialization expression.
871 1.1 cgd * Also remember this expression itself. We must check it at
872 1.1 cgd * the end of the loop to get "used but not set" warnings correct.
873 1.1 cgd */
874 1.99 rillig cstmt->c_for_expr3_mem = expr_save_memory();
875 1.97 rillig cstmt->c_for_expr3 = tn3;
876 1.97 rillig cstmt->c_for_expr3_pos = curr_pos;
877 1.97 rillig cstmt->c_for_expr3_csrc_pos = csrc_pos;
878 1.1 cgd
879 1.1 cgd if (tn1 != NULL)
880 1.67 rillig expr(tn1, false, false, true, false);
881 1.1 cgd
882 1.1 cgd if (tn2 != NULL)
883 1.39 rillig tn2 = check_controlling_expression(tn2);
884 1.1 cgd if (tn2 != NULL)
885 1.67 rillig expr(tn2, false, true, true, false);
886 1.1 cgd
887 1.91 rillig cstmt->c_maybe_endless = tn2 == NULL || is_nonzero(tn2);
888 1.1 cgd
889 1.158 rillig /* The tn3 expression is checked in stmt_for_exprs_stmt. */
890 1.1 cgd
891 1.93 rillig set_reached(!is_zero(tn2));
892 1.1 cgd }
893 1.1 cgd
894 1.1 cgd void
895 1.158 rillig stmt_for_exprs_stmt(void)
896 1.1 cgd {
897 1.155 rillig pos_t cpos, cspos;
898 1.155 rillig tnode_t *tn3;
899 1.1 cgd
900 1.85 rillig if (cstmt->c_continue)
901 1.93 rillig set_reached(true);
902 1.1 cgd
903 1.36 rillig cpos = curr_pos;
904 1.36 rillig cspos = csrc_pos;
905 1.1 cgd
906 1.73 rillig /* Restore the tree memory for the reinitialization expression */
907 1.99 rillig expr_restore_memory(cstmt->c_for_expr3_mem);
908 1.97 rillig tn3 = cstmt->c_for_expr3;
909 1.97 rillig curr_pos = cstmt->c_for_expr3_pos;
910 1.97 rillig csrc_pos = cstmt->c_for_expr3_csrc_pos;
911 1.1 cgd
912 1.1 cgd /* simply "statement not reached" would be confusing */
913 1.94 rillig if (!reached && warn_about_unreachable) {
914 1.1 cgd /* end-of-loop code not reached */
915 1.1 cgd warning(223);
916 1.93 rillig set_reached(true);
917 1.1 cgd }
918 1.1 cgd
919 1.1 cgd if (tn3 != NULL) {
920 1.67 rillig expr(tn3, false, false, true, false);
921 1.1 cgd } else {
922 1.99 rillig expr_free_all();
923 1.1 cgd }
924 1.1 cgd
925 1.36 rillig curr_pos = cpos;
926 1.36 rillig csrc_pos = cspos;
927 1.1 cgd
928 1.1 cgd /* An endless loop without break will never terminate */
929 1.84 rillig /* TODO: What if the loop contains a 'return'? */
930 1.93 rillig set_reached(cstmt->c_break || !cstmt->c_maybe_endless);
931 1.1 cgd
932 1.96 rillig end_control_statement(CS_FOR);
933 1.1 cgd }
934 1.1 cgd
935 1.1 cgd void
936 1.158 rillig stmt_goto(sym_t *lab)
937 1.1 cgd {
938 1.14 lukem
939 1.60 rillig mark_as_used(lab, false, false);
940 1.1 cgd
941 1.31 rillig check_statement_reachable();
942 1.1 cgd
943 1.93 rillig set_reached(false);
944 1.1 cgd }
945 1.1 cgd
946 1.1 cgd void
947 1.158 rillig stmt_break(void)
948 1.1 cgd {
949 1.115 rillig control_statement *cs;
950 1.1 cgd
951 1.115 rillig cs = cstmt;
952 1.115 rillig while (cs != NULL && !cs->c_loop && !cs->c_switch)
953 1.115 rillig cs = cs->c_surrounding;
954 1.1 cgd
955 1.115 rillig if (cs == NULL) {
956 1.1 cgd /* break outside loop or switch */
957 1.1 cgd error(208);
958 1.1 cgd } else {
959 1.1 cgd if (reached)
960 1.115 rillig cs->c_break = true;
961 1.1 cgd }
962 1.1 cgd
963 1.1 cgd if (bflag)
964 1.31 rillig check_statement_reachable();
965 1.1 cgd
966 1.93 rillig set_reached(false);
967 1.1 cgd }
968 1.1 cgd
969 1.1 cgd void
970 1.158 rillig stmt_continue(void)
971 1.1 cgd {
972 1.115 rillig control_statement *cs;
973 1.1 cgd
974 1.115 rillig for (cs = cstmt; cs != NULL && !cs->c_loop; cs = cs->c_surrounding)
975 1.14 lukem continue;
976 1.1 cgd
977 1.115 rillig if (cs == NULL) {
978 1.1 cgd /* continue outside loop */
979 1.1 cgd error(209);
980 1.1 cgd } else {
981 1.85 rillig /* TODO: only if reachable, for symmetry with c_break */
982 1.115 rillig cs->c_continue = true;
983 1.1 cgd }
984 1.1 cgd
985 1.31 rillig check_statement_reachable();
986 1.1 cgd
987 1.93 rillig set_reached(false);
988 1.1 cgd }
989 1.1 cgd
990 1.153 rillig static bool
991 1.153 rillig is_parenthesized(const tnode_t *tn)
992 1.153 rillig {
993 1.153 rillig
994 1.153 rillig while (!tn->tn_parenthesized && tn->tn_op == COMMA)
995 1.153 rillig tn = tn->tn_right;
996 1.153 rillig return tn->tn_parenthesized && !tn->tn_sys;
997 1.153 rillig }
998 1.153 rillig
999 1.152 rillig static void
1000 1.152 rillig check_return_value(bool sys, tnode_t *tn)
1001 1.152 rillig {
1002 1.153 rillig
1003 1.153 rillig if (any_query_enabled && is_parenthesized(tn)) {
1004 1.153 rillig /* parenthesized return value */
1005 1.153 rillig query_message(9);
1006 1.153 rillig }
1007 1.153 rillig
1008 1.152 rillig /* Create a temporary node for the left side */
1009 1.171 rillig tnode_t *ln = expr_zero_alloc(sizeof(*ln), "tnode");
1010 1.152 rillig ln->tn_op = NAME;
1011 1.152 rillig ln->tn_type = expr_unqualified_type(funcsym->s_type->t_subt);
1012 1.152 rillig ln->tn_lvalue = true;
1013 1.152 rillig ln->tn_sym = funcsym; /* better than nothing */
1014 1.152 rillig
1015 1.152 rillig tnode_t *retn = build_binary(ln, RETURN, sys, tn);
1016 1.152 rillig
1017 1.152 rillig if (retn != NULL) {
1018 1.152 rillig const tnode_t *rn = retn->tn_right;
1019 1.152 rillig while (rn->tn_op == CVT || rn->tn_op == PLUS)
1020 1.152 rillig rn = rn->tn_left;
1021 1.152 rillig if (rn->tn_op == ADDR && rn->tn_left->tn_op == NAME &&
1022 1.152 rillig rn->tn_left->tn_sym->s_scl == AUTO) {
1023 1.152 rillig /* '%s' returns pointer to automatic object */
1024 1.152 rillig warning(302, funcsym->s_name);
1025 1.152 rillig }
1026 1.152 rillig }
1027 1.152 rillig
1028 1.152 rillig expr(retn, true, false, true, false);
1029 1.152 rillig }
1030 1.152 rillig
1031 1.1 cgd void
1032 1.158 rillig stmt_return(bool sys, tnode_t *tn)
1033 1.1 cgd {
1034 1.152 rillig control_statement *cs = cstmt;
1035 1.1 cgd
1036 1.115 rillig if (cs == NULL) {
1037 1.109 rillig /* syntax error '%s' */
1038 1.109 rillig error(249, "return outside function");
1039 1.109 rillig return;
1040 1.109 rillig }
1041 1.109 rillig
1042 1.115 rillig for (; cs->c_surrounding != NULL; cs = cs->c_surrounding)
1043 1.14 lukem continue;
1044 1.1 cgd
1045 1.82 rillig if (tn != NULL)
1046 1.115 rillig cs->c_had_return_value = true;
1047 1.82 rillig else
1048 1.115 rillig cs->c_had_return_noval = true;
1049 1.1 cgd
1050 1.1 cgd if (tn != NULL && funcsym->s_type->t_subt->t_tspec == VOID) {
1051 1.142 rillig /* void function '%s' cannot return value */
1052 1.1 cgd error(213, funcsym->s_name);
1053 1.99 rillig expr_free_all();
1054 1.1 cgd tn = NULL;
1055 1.174 rillig }
1056 1.174 rillig if (tn == NULL && funcsym->s_type->t_subt->t_tspec != VOID
1057 1.174 rillig && !funcsym->s_return_type_implicit_int) {
1058 1.174 rillig if (allow_c99)
1059 1.174 rillig /* function '%s' expects to return value */
1060 1.174 rillig error(214, funcsym->s_name);
1061 1.174 rillig else
1062 1.119 rillig /* function '%s' expects to return value */
1063 1.1 cgd warning(214, funcsym->s_name);
1064 1.1 cgd }
1065 1.1 cgd
1066 1.152 rillig if (tn != NULL)
1067 1.152 rillig check_return_value(sys, tn);
1068 1.152 rillig else
1069 1.31 rillig check_statement_reachable();
1070 1.1 cgd
1071 1.93 rillig set_reached(false);
1072 1.1 cgd }
1073 1.1 cgd
1074 1.1 cgd /*
1075 1.7 jpo * Do some cleanup after a global declaration or definition.
1076 1.28 rillig * Especially remove information about unused lint comments.
1077 1.1 cgd */
1078 1.1 cgd void
1079 1.59 rillig global_clean_up_decl(bool silent)
1080 1.1 cgd {
1081 1.1 cgd
1082 1.1 cgd if (nargusg != -1) {
1083 1.6 jpo if (!silent) {
1084 1.142 rillig /* comment ** %s ** must precede function definition */
1085 1.105 rillig warning_at(282, &argsused_pos, "ARGSUSED");
1086 1.1 cgd }
1087 1.1 cgd nargusg = -1;
1088 1.1 cgd }
1089 1.1 cgd if (nvararg != -1) {
1090 1.6 jpo if (!silent) {
1091 1.142 rillig /* comment ** %s ** must precede function definition */
1092 1.105 rillig warning_at(282, &vapos, "VARARGS");
1093 1.1 cgd }
1094 1.1 cgd nvararg = -1;
1095 1.1 cgd }
1096 1.49 rillig if (printflike_argnum != -1) {
1097 1.6 jpo if (!silent) {
1098 1.142 rillig /* comment ** %s ** must precede function definition */
1099 1.105 rillig warning_at(282, &printflike_pos, "PRINTFLIKE");
1100 1.1 cgd }
1101 1.49 rillig printflike_argnum = -1;
1102 1.1 cgd }
1103 1.49 rillig if (scanflike_argnum != -1) {
1104 1.6 jpo if (!silent) {
1105 1.143 rillig /* comment ** %s ** must precede function definition */
1106 1.105 rillig warning_at(282, &scanflike_pos, "SCANFLIKE");
1107 1.1 cgd }
1108 1.49 rillig scanflike_argnum = -1;
1109 1.1 cgd }
1110 1.1 cgd
1111 1.59 rillig dcs->d_asm = false;
1112 1.107 rillig
1113 1.107 rillig /*
1114 1.107 rillig * Needed for BSD yacc in case of parse errors; GNU Bison 3.0.4 is
1115 1.125 rillig * fine. See test gcc_attribute.c, function_with_unknown_attribute.
1116 1.107 rillig */
1117 1.125 rillig in_gcc_attribute = false;
1118 1.130 rillig while (dcs->d_enclosing != NULL)
1119 1.130 rillig end_declaration_level();
1120 1.1 cgd }
1121 1.1 cgd
1122 1.1 cgd /*
1123 1.173 rillig * Only the first n parameters of the following function are checked for usage.
1124 1.169 rillig * A missing argument is taken to be 0.
1125 1.1 cgd */
1126 1.169 rillig static void
1127 1.14 lukem argsused(int n)
1128 1.1 cgd {
1129 1.14 lukem
1130 1.1 cgd if (n == -1)
1131 1.1 cgd n = 0;
1132 1.1 cgd
1133 1.160 rillig if (dcs->d_kind != DLK_EXTERN) {
1134 1.142 rillig /* comment ** %s ** must be outside function */
1135 1.1 cgd warning(280, "ARGSUSED");
1136 1.1 cgd return;
1137 1.1 cgd }
1138 1.1 cgd if (nargusg != -1) {
1139 1.142 rillig /* duplicate comment ** %s ** */
1140 1.1 cgd warning(281, "ARGSUSED");
1141 1.1 cgd }
1142 1.1 cgd nargusg = n;
1143 1.36 rillig argsused_pos = curr_pos;
1144 1.1 cgd }
1145 1.1 cgd
1146 1.169 rillig static void
1147 1.14 lukem varargs(int n)
1148 1.1 cgd {
1149 1.14 lukem
1150 1.1 cgd if (n == -1)
1151 1.1 cgd n = 0;
1152 1.1 cgd
1153 1.160 rillig if (dcs->d_kind != DLK_EXTERN) {
1154 1.142 rillig /* comment ** %s ** must be outside function */
1155 1.1 cgd warning(280, "VARARGS");
1156 1.1 cgd return;
1157 1.1 cgd }
1158 1.1 cgd if (nvararg != -1) {
1159 1.142 rillig /* duplicate comment ** %s ** */
1160 1.1 cgd warning(281, "VARARGS");
1161 1.1 cgd }
1162 1.1 cgd nvararg = n;
1163 1.36 rillig vapos = curr_pos;
1164 1.1 cgd }
1165 1.1 cgd
1166 1.1 cgd /*
1167 1.173 rillig * Check all parameters until the (n-1)-th as usual. The n-th argument is
1168 1.173 rillig * used to check the types of the remaining arguments.
1169 1.1 cgd */
1170 1.169 rillig static void
1171 1.14 lukem printflike(int n)
1172 1.1 cgd {
1173 1.14 lukem
1174 1.1 cgd if (n == -1)
1175 1.1 cgd n = 0;
1176 1.1 cgd
1177 1.160 rillig if (dcs->d_kind != DLK_EXTERN) {
1178 1.142 rillig /* comment ** %s ** must be outside function */
1179 1.1 cgd warning(280, "PRINTFLIKE");
1180 1.1 cgd return;
1181 1.1 cgd }
1182 1.49 rillig if (printflike_argnum != -1) {
1183 1.142 rillig /* duplicate comment ** %s ** */
1184 1.1 cgd warning(281, "PRINTFLIKE");
1185 1.1 cgd }
1186 1.49 rillig printflike_argnum = n;
1187 1.36 rillig printflike_pos = curr_pos;
1188 1.1 cgd }
1189 1.1 cgd
1190 1.1 cgd /*
1191 1.173 rillig * Check all parameters until the (n-1)-th as usual. The n-th argument is
1192 1.1 cgd * used the check the types of remaining arguments.
1193 1.1 cgd */
1194 1.169 rillig static void
1195 1.14 lukem scanflike(int n)
1196 1.1 cgd {
1197 1.14 lukem
1198 1.1 cgd if (n == -1)
1199 1.1 cgd n = 0;
1200 1.1 cgd
1201 1.160 rillig if (dcs->d_kind != DLK_EXTERN) {
1202 1.142 rillig /* comment ** %s ** must be outside function */
1203 1.1 cgd warning(280, "SCANFLIKE");
1204 1.1 cgd return;
1205 1.1 cgd }
1206 1.49 rillig if (scanflike_argnum != -1) {
1207 1.142 rillig /* duplicate comment ** %s ** */
1208 1.1 cgd warning(281, "SCANFLIKE");
1209 1.1 cgd }
1210 1.49 rillig scanflike_argnum = n;
1211 1.36 rillig scanflike_pos = curr_pos;
1212 1.1 cgd }
1213 1.1 cgd
1214 1.169 rillig static void
1215 1.169 rillig lintlib(void)
1216 1.1 cgd {
1217 1.14 lukem
1218 1.160 rillig if (dcs->d_kind != DLK_EXTERN) {
1219 1.142 rillig /* comment ** %s ** must be outside function */
1220 1.1 cgd warning(280, "LINTLIBRARY");
1221 1.1 cgd return;
1222 1.1 cgd }
1223 1.59 rillig llibflg = true;
1224 1.165 rillig vflag = true;
1225 1.1 cgd }
1226 1.1 cgd
1227 1.1 cgd /*
1228 1.28 rillig * PROTOLIB in conjunction with LINTLIBRARY can be used to handle
1229 1.1 cgd * prototypes like function definitions. This is done if the argument
1230 1.156 rillig * to PROTOLIB is nonzero. Otherwise, prototypes are handled normally.
1231 1.1 cgd */
1232 1.169 rillig static void
1233 1.14 lukem protolib(int n)
1234 1.1 cgd {
1235 1.14 lukem
1236 1.160 rillig if (dcs->d_kind != DLK_EXTERN) {
1237 1.142 rillig /* comment ** %s ** must be outside function */
1238 1.1 cgd warning(280, "PROTOLIB");
1239 1.1 cgd return;
1240 1.1 cgd }
1241 1.59 rillig plibflg = n != 0;
1242 1.6 jpo }
1243 1.6 jpo
1244 1.6 jpo void
1245 1.169 rillig handle_lint_comment(lint_comment comment, int arg)
1246 1.6 jpo {
1247 1.169 rillig switch (comment) {
1248 1.169 rillig case LC_ARGSUSED: argsused(arg); break;
1249 1.169 rillig case LC_BITFIELDTYPE: suppress_bitfieldtype = true; break;
1250 1.169 rillig case LC_CONSTCOND: suppress_constcond = true; break;
1251 1.169 rillig case LC_FALLTHROUGH: suppress_fallthrough = true; break;
1252 1.169 rillig case LC_LINTLIBRARY: lintlib(); break;
1253 1.169 rillig case LC_LINTED: debug_step("set lwarn %d", arg);
1254 1.169 rillig lwarn = arg; break;
1255 1.169 rillig case LC_LONGLONG: suppress_longlong = true; break;
1256 1.169 rillig case LC_NOTREACHED: set_reached(false);
1257 1.169 rillig warn_about_unreachable = false; break;
1258 1.169 rillig case LC_PRINTFLIKE: printflike(arg); break;
1259 1.169 rillig case LC_PROTOLIB: protolib(arg); break;
1260 1.169 rillig case LC_SCANFLIKE: scanflike(arg); break;
1261 1.169 rillig case LC_VARARGS: varargs(arg); break;
1262 1.169 rillig }
1263 1.1 cgd }
1264