1 /* $NetBSD: lint1.h,v 1.235 2025/04/10 20:37:48 rillig Exp $ */
2
3 /*
4 * Copyright (c) 1996 Christopher G. Demetriou. All Rights Reserved.
5 * Copyright (c) 1994, 1995 Jochen Pohl
6 * All Rights Reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by Jochen Pohl for
19 * The NetBSD Project.
20 * 4. The name of the author may not be used to endorse or promote products
21 * derived from this software without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 */
34
35 #include "lint.h"
36 #include "op.h"
37
38 /*
39 * A memory pool collects allocated objects that must be available until:
40 * - the end of a block,
41 * - the end of an expression, or
42 * - the end of the translation unit.
43 */
44 typedef struct memory_pool {
45 struct memory_pool_item {
46 void *p;
47 #ifdef DEBUG_MEM
48 size_t size;
49 const char *descr;
50 #endif
51 } *items;
52 size_t len;
53 size_t cap;
54 } memory_pool;
55
56 /* See saved_lwarn in cgram.y. */
57 #define LWARN_ALL (-2)
58 #define LWARN_NONE (-1)
59
60 /*
61 * Describes the position of a declaration or anything else.
62 *
63 * FIXME: Just a single file:lineno pair is not enough to accurately describe
64 * the position of a symbol. The whole inclusion path at that point must be
65 * stored as well. This makes a difference for symbols from included
66 * headers, see print_stack_trace.
67 */
68 typedef struct {
69 const char *p_file;
70 int p_line;
71 int p_uniq; /* uniquifier */
72 } pos_t;
73
74 typedef struct {
75 bool tq_const;
76 bool tq_restrict;
77 bool tq_volatile;
78 bool tq_atomic;
79 } type_qualifiers;
80
81 typedef struct {
82 bool used;
83 bool noreturn;
84 unsigned bit_width;
85 } type_attributes;
86
87 /* A bool, integer or floating-point value. */
88 typedef struct {
89 tspec_t v_tspec;
90 /*
91 * Set if an integer constant is unsigned only in C90 and later, but
92 * not in traditional C.
93 *
94 * See the operators table in oper.c, columns "l r".
95 */
96 bool v_unsigned_since_c90;
97 bool v_char_constant;
98 union {
99 int64_t integer;
100 long double floating;
101 } u;
102 } val_t;
103
104 typedef struct sym sym_t;
105
106 /*
107 * Structures of type struct_or_union uniquely identify structures. This can't
108 * be done in structures of type type_t, because these are copied if they must
109 * be modified. So it would not be possible to check if two structures are
110 * identical by comparing the pointers to the type structures.
111 *
112 * If the structure has no tag name, its first typedef name is used to identify
113 * the structure in lint2.
114 */
115 typedef struct {
116 unsigned int sou_size_in_bits;
117 unsigned int sou_align;
118 bool sou_incomplete:1;
119 sym_t *sou_first_member;
120 sym_t *sou_tag;
121 sym_t *sou_first_typedef;
122 } struct_or_union;
123
124 /* The same as in struct_or_union, only for enums. */
125 typedef struct {
126 bool en_incomplete:1;
127 sym_t *en_first_enumerator;
128 sym_t *en_tag;
129 sym_t *en_first_typedef;
130 } enumeration;
131
132 /* The type of an expression, object or function. */
133 struct lint1_type {
134 tspec_t t_tspec; /* type specifier */
135 bool t_incomplete_array:1;
136 bool t_const:1;
137 bool t_volatile:1;
138 bool t_proto:1; /* function prototype (u.params valid) */
139 bool t_vararg:1; /* prototype with '...' */
140 bool t_noreturn:1; /* function never returns normally */
141 bool t_typedef:1; /* type defined with typedef */
142 bool t_typeof:1; /* type defined with GCC's __typeof__ */
143 bool t_bitfield:1;
144 /*
145 * Either the type is currently an enum (having t_tspec ENUM), or it
146 * is an integer type (typically INT) that has been implicitly
147 * converted from an enum type. In both cases, u.enumer is valid.
148 */
149 bool t_is_enum:1;
150 bool t_packed:1;
151 union {
152 int dimension; /* if ARRAY */
153 struct_or_union *sou;
154 enumeration *enumer;
155 sym_t *params; /* if t_proto */
156 } u;
157 unsigned int t_bit_field_width:8;
158 unsigned int t_bit_field_offset:24;
159 struct lint1_type *t_subt; /*- element type (if ARRAY),
160 * return value (if FUNC),
161 * target type (if PTR) */
162 };
163
164 typedef enum {
165 SK_VCFT, /* variable, constant, function, type */
166 SK_MEMBER, /* member of a struct or union */
167 SK_TAG,
168 SK_LABEL
169 } symbol_kind;
170
171 /* storage classes and related things */
172 typedef enum {
173 NO_SCL,
174 EXTERN, /* external symbols (independent of decl_t) */
175 STATIC, /* static symbols (local and global) */
176 AUTO, /* automatic symbols (except register) */
177 REG, /* register */
178 TYPEDEF,
179 THREAD_LOCAL,
180 STRUCT_TAG,
181 UNION_TAG,
182 ENUM_TAG,
183 STRUCT_MEMBER,
184 UNION_MEMBER,
185 BOOL_CONST,
186 ENUM_CONST,
187 ABSTRACT, /* abstract symbol (sizeof, casts, unnamed
188 * argument) */
189 } scl_t;
190
191 /* C23 6.7.4 */
192 typedef enum {
193 FS_INLINE, /* since C99 */
194 FS_NORETURN, /* since C11 */
195 } function_specifier;
196
197 typedef enum {
198 NC_FALSE, /* since C23 */
199 NC_TRUE, /* since C23 */
200 NC_NULLPTR, /* since C23 */
201 } named_constant;
202
203 /* A type, variable, keyword; basically anything that has a name. */
204 struct sym {
205 const char *s_name;
206 const char *s_rename; /* renamed symbol's given name */
207 pos_t s_def_pos; /* position of last (prototype) definition,
208 * prototype declaration, no-prototype-def.,
209 * tentative definition or declaration, in this
210 * order */
211 pos_t s_set_pos; /* position of first initialization */
212 pos_t s_use_pos; /* position of first use */
213 symbol_kind s_kind;
214 const struct keyword *s_keyword;
215 bool s_bitfield:1;
216 bool s_set:1;
217 bool s_used:1;
218 bool s_param:1;
219 bool s_register:1;
220 bool s_defparam:1; /* undefined symbol in old-style function
221 * definition */
222 bool s_return_type_implicit_int:1;
223 bool s_osdef:1; /* symbol stems from old-style function def. */
224 bool s_inline:1;
225 sym_t *s_ext_sym; /* for locally declared external symbols, the
226 * pointer to the external symbol with the same
227 * name */
228 def_t s_def; /* declared, tentative defined, defined */
229 scl_t s_scl;
230 int s_block_level; /* level of declaration, -1 if not in symbol
231 * table */
232 type_t *s_type;
233 union {
234 bool s_bool_constant;
235 int s_enum_constant;
236 struct {
237 struct_or_union *sm_containing_type;
238 unsigned int sm_offset_in_bits;
239 } s_member;
240 struct {
241 int sk_token;
242 union {
243 /* if T_TYPE or T_STRUCT_OR_UNION */
244 tspec_t sk_tspec;
245 /* if T_QUAL */
246 type_qualifiers sk_type_qualifier;
247 /* if T_FUNCTION_SPECIFIER */
248 function_specifier function_specifier;
249 /* if T_CON */
250 named_constant named_constant;
251 } u;
252 } s_keyword;
253 sym_t *s_old_style_params; /* parameters in an old-style
254 * function definition */
255 } u;
256 sym_t *s_symtab_next; /* next symbol in the same symtab bucket */
257 sym_t **s_symtab_ref; /* pointer to s_symtab_next of the previous
258 * symbol */
259 sym_t *s_next; /* next struct/union member, enumerator,
260 * parameter */
261 sym_t *s_level_next; /* next symbol declared on the same level */
262 };
263
264 /*
265 * Used to keep some information about symbols before they are entered
266 * into the symbol table.
267 */
268 typedef struct {
269 const char *sb_name; /* name of symbol */
270 size_t sb_len; /* length (without '\0') */
271 sym_t *sb_sym; /* symbol table entry */
272 } sbuf_t;
273
274
275 typedef struct {
276 struct tnode *func;
277 struct tnode **args;
278 size_t args_len;
279 size_t args_cap;
280 } function_call;
281
282 typedef struct tnode tnode_t;
283
284 /* An expression, forming an abstract syntax tree. */
285 struct tnode {
286 op_t tn_op;
287 type_t *tn_type;
288 bool tn_lvalue:1;
289 bool tn_cast:1; /* if tn_op == CVT, it's an explicit cast */
290 bool tn_parenthesized:1;
291 bool tn_sys:1; /* comes from a system header */
292 bool tn_system_dependent:1; /* depends on sizeof or offsetof */
293 union {
294 struct {
295 tnode_t *left; /* (left) operand */
296 tnode_t *right; /* right operand */
297 } ops;
298 sym_t *sym; /* if NAME */
299 val_t value; /* if CON */
300 buffer *str_literals; /* if STRING; for
301 * character strings, 'data' points to
302 * the concatenated string literals in
303 * source form, and 'len' is the
304 * length of the concatenation; for
305 * wide strings, 'data' is NULL and
306 * 'len' is the number of resulting
307 * characters */
308 function_call *call; /* if CALL */
309 } u;
310 };
311
312 struct generic_association {
313 type_t *ga_arg; /* NULL means default or error */
314 tnode_t *ga_result; /* NULL means error */
315 struct generic_association *ga_prev;
316 };
317
318 typedef struct {
319 bool has_dim;
320 int dim;
321 } array_size;
322
323 typedef enum decl_level_kind {
324 DLK_EXTERN, /* global types, variables or functions */
325 DLK_STRUCT, /* struct members */
326 DLK_UNION, /* union members */
327 DLK_ENUM, /* enum constants */
328 DLK_OLD_STYLE_PARAMS, /* parameters in an old-style function
329 * definition */
330 DLK_PROTO_PARAMS, /* parameters in a prototype function
331 * definition */
332 DLK_AUTO, /* local types or variables */
333 DLK_ABSTRACT /* abstract (unnamed) declaration; type name;
334 * used in casts and sizeof */
335 } decl_level_kind;
336
337 /*
338 * A declaration level collects information for a declarator in a struct,
339 * union or enum declaration, a parameter declaration list, or a plain
340 * declaration in or outside a function body.
341 *
342 * For nested declarations, the global 'dcs' holds all information needed for
343 * the current level, the outer levels are available via 'd_enclosing'.
344 */
345 typedef struct decl_level {
346 decl_level_kind d_kind;
347 tspec_t d_abstract_type;/* VOID, BOOL, CHAR, INT or COMPLEX */
348 tspec_t d_complex_mod; /* FLOAT or DOUBLE */
349 tspec_t d_sign_mod; /* SIGNED or UNSIGN */
350 tspec_t d_rank_mod; /* SHORT, LONG or LLONG */
351 scl_t d_scl; /* storage class */
352 type_t *d_type; /* after dcs_end_type, the pointer to the type
353 * used for all declarators */
354 sym_t *d_redeclared_symbol;
355 unsigned int d_sou_size_in_bits; /* size of the structure or
356 * union being built, without
357 * trailing padding */
358 unsigned int d_sou_align; /* alignment of the structure
359 * or union being built */
360 unsigned int d_mem_align; /* alignment of the structure
361 * or union member */
362 type_qualifiers d_qual; /* in declaration specifiers */
363 bool d_inline:1; /* inline in declaration specifiers */
364 bool d_multiple_storage_classes:1; /* reported in dcs_end_type */
365 bool d_invalid_type_combination:1;
366 bool d_nonempty_decl:1; /* in a function declaration, whether at
367 * least one tag was declared */
368 bool d_no_type_specifier:1;
369 bool d_asm:1; /* set if d_ctx == AUTO and asm() present */
370 bool d_packed:1;
371 bool d_used:1;
372 bool d_noreturn:1; /* function never returns normally */
373 type_t *d_tag_type; /* during a member or enumerator declaration,
374 * the tag type to which the member belongs */
375 sym_t *d_func_params; /* during a function declaration, the
376 * parameters, stored in the enclosing level */
377 pos_t d_func_def_pos; /* position of the function definition */
378 sym_t *d_first_dlsym; /* first symbol declared at this level */
379 sym_t **d_last_dlsym; /* points to s_level_next in the last symbol
380 declaration at this level */
381 sym_t *d_func_proto_syms; /* symbols defined in prototype, such
382 * as tagged types or parameter names,
383 * may overlap d_func_params */
384 struct decl_level *d_enclosing; /* the enclosing declaration level */
385 } decl_level;
386
387 typedef struct {
388 sym_t *first;
389 bool vararg:1;
390 bool prototype:1;
391 bool used:1;
392 bool noreturn:1;
393 bool identifier:1;
394 } parameter_list;
395
396 /*
397 * A sequence of asterisks and qualifiers, from right to left. For example,
398 * 'const ***volatile **const volatile' results in [c-v-, ----, --v-, ----,
399 * ----]. The leftmost 'const' is not included in this list, it is stored in
400 * dcs->d_qual instead.
401 */
402 typedef struct qual_ptr {
403 type_qualifiers qualifiers;
404 struct qual_ptr *p_next;
405 } qual_ptr;
406
407 /* The values of the 'case' labels. */
408 typedef struct {
409 val_t *vals;
410 size_t len;
411 size_t cap;
412 } case_labels;
413
414 typedef enum {
415 CS_DO_WHILE,
416 CS_FOR,
417 CS_FUNCTION_BODY,
418 CS_IF,
419 CS_SWITCH,
420 CS_WHILE
421 } control_statement_kind;
422
423 /*
424 * Used to keep information about nested control statements.
425 */
426 typedef struct control_statement {
427 control_statement_kind c_kind; /* to ensure proper nesting */
428 bool c_loop:1; /* 'continue' and 'break' are valid */
429 bool c_switch:1; /* 'case' and 'break' are valid */
430 bool c_break:1; /* the loop/switch has a reachable 'break'
431 * statement */
432 bool c_continue:1; /* the loop has a reachable 'continue'
433 * statement */
434 bool c_default:1; /* the switch has a 'default' label */
435 bool c_maybe_endless:1; /* the controlling expression is
436 * always true (as in 'for (;;)' or
437 * 'while (1)'), there may be break
438 * statements though */
439 bool c_always_then:1;
440 bool c_reached_end_of_then:1;
441 bool c_had_return_noval:1; /* had "return;" */
442 bool c_had_return_value:1; /* had "return expr;" */
443
444 type_t *c_switch_type; /* type of switch expression */
445 tnode_t *c_switch_expr;
446 case_labels c_case_labels; /* list of case values */
447
448 memory_pool c_for_expr3_mem; /* saved memory for end of loop
449 * expression in for() */
450 tnode_t *c_for_expr3; /* end of loop expr in for() */
451 pos_t c_for_expr3_pos; /* position of end of loop expr */
452 pos_t c_for_expr3_csrc_pos; /* same for csrc_pos */
453
454 struct control_statement *c_surrounding;
455 } control_statement;
456
457 typedef struct {
458 size_t lo; /* inclusive */
459 size_t hi; /* inclusive */
460 } range_t;
461
462 typedef enum designator_kind {
463 DK_MEMBER, /* .member */
464 DK_SUBSCRIPT, /* [subscript] */
465 DK_SCALAR /* no textual representation, not generated by
466 * the parser; used for scalar initializer
467 * expressions surrounded by braces */
468 } designator_kind;
469
470 /*
471 * A single component on the path from the "current object" of a brace level
472 * to the sub-object that is initialized by an expression.
473 *
474 * C99 6.7.8p6, 6.7.8p7
475 */
476 typedef struct designator {
477 designator_kind dr_kind;
478 const sym_t *dr_member; /* for DK_MEMBER */
479 size_t dr_subscript; /* for DK_SUBSCRIPT */
480 bool dr_done;
481 } designator;
482
483 /*
484 * The path from the "current object" of a brace level to the sub-object that
485 * is initialized by an expression. Examples of designations are '.member'
486 * or '.member[123].member.member[1][1]'.
487 *
488 * C99 6.7.8p6, 6.7.8p7
489 */
490 typedef struct designation {
491 designator *dn_items;
492 size_t dn_len;
493 size_t dn_cap;
494 } designation;
495
496 typedef enum {
497 LC_ARGSUSED,
498 LC_BITFIELDTYPE,
499 LC_FALLTHROUGH,
500 LC_LINTLIBRARY,
501 LC_LINTED,
502 LC_LONGLONG,
503 LC_NOTREACHED,
504 LC_PRINTFLIKE,
505 LC_PROTOLIB,
506 LC_SCANFLIKE,
507 LC_VARARGS,
508 } lint_comment;
509
510 typedef struct {
511 size_t start;
512 size_t end;
513 uint64_t value;
514 bool escaped; /* \n, \003, \x24 */
515 bool named_escape; /* \a, \n, etc. */
516 bool literal_escape; /* \?, \\, etc. */
517 uint8_t octal_digits; /* 1 to 3; 0 means not applicable */
518 uint8_t hex_digits; /* 1 to 3; 0 means not applicable */
519 bool next_literal; /* when a new string literal begins */
520 bool invalid_escape; /* single-character escape, recoverable */
521 bool overflow; /* for octal and hex escapes */
522 bool missing_hex_digits;
523 bool unescaped_newline; /* stops iterating */
524 } quoted_iterator;
525
526 typedef enum {
527 TK_IDENTIFIER,
528 TK_CONSTANT,
529 TK_STRING_LITERALS,
530 TK_PUNCTUATOR,
531 } token_kind;
532
533 typedef struct token {
534 token_kind kind;
535 union {
536 const char *identifier;
537 val_t constant;
538 buffer string_literals;
539 const char *punctuator;
540 } u;
541 } token;
542
543 typedef struct balanced_token_sequence balanced_token_sequence;
544 typedef struct balanced_token balanced_token;
545
546 struct balanced_token_sequence {
547 balanced_token *tokens;
548 size_t len;
549 size_t cap;
550 };
551
552 struct balanced_token {
553 char kind; // '\0', '(', '[', '{'
554 union {
555 token token;
556 balanced_token_sequence tokens;
557 } u;
558 };
559
560 typedef struct {
561 const char *prefix;
562 const char *name;
563 balanced_token_sequence *arg;
564 } attribute;
565
566 typedef struct {
567 attribute *attrs;
568 size_t len;
569 size_t cap;
570 } attribute_list;
571
572 #include "externs1.h"
573
574 #define lint_assert(cond) \
575 do { \
576 if (!(cond)) \
577 assert_failed(__FILE__, __LINE__, __func__, #cond); \
578 } while (false)
579
580 #ifdef DEBUG
581 # include "err-msgs.h"
582
583 /* ARGSUSED */
584 static inline void __printflike(1, 2)
check_printf(const char * fmt,...)585 check_printf(const char *fmt, ...)
586 {
587 }
588
589 # define wrap_check_printf_at(func, msgid, pos, args...) \
590 do { \
591 check_printf(__CONCAT(MSG_, msgid), ##args); \
592 (func)(msgid, pos, ##args); \
593 } while (false)
594
595 # define error_at(msgid, pos, args...) \
596 wrap_check_printf_at(error_at, msgid, pos, ##args)
597 # define warning_at(msgid, pos, args...) \
598 wrap_check_printf_at(warning_at, msgid, pos, ##args)
599 # define message_at(msgid, pos, args...) \
600 wrap_check_printf_at(message_at, msgid, pos, ##args)
601
602 # define wrap_check_printf(func, cond, msgid, args...) \
603 ({ \
604 if (cond) \
605 debug_step("%s:%d: %s %d '%s' in %s", \
606 __FILE__, __LINE__, #func, msgid, \
607 __CONCAT(MSG_, msgid), __func__); \
608 check_printf(__CONCAT(MSG_, msgid), ##args); \
609 (func)(msgid, ##args); \
610 /* LINTED 129 */ \
611 })
612
613 # define error(msgid, args...) wrap_check_printf(error, \
614 true, msgid, ##args)
615 # define warning(msgid, args...) wrap_check_printf(warning, \
616 true, msgid, ##args)
617 # define gnuism(msgid, args...) wrap_check_printf(gnuism, \
618 !allow_gcc || (!allow_trad && !allow_c99), msgid, ##args)
619 # define c99ism(msgid, args...) wrap_check_printf(c99ism, \
620 !allow_c99 && (!allow_gcc || !allow_trad), msgid, ##args)
621 # define c11ism(msgid, args...) wrap_check_printf(c11ism, \
622 !allow_c11 && !allow_gcc, msgid, ##args)
623 # define c23ism(msgid, args...) wrap_check_printf(c23ism, \
624 !allow_c23, msgid, ##args)
625 #endif
626
627 #ifdef DEBUG
628 # define query_message(query_id, args...) \
629 do { \
630 debug_step("%s:%d: query %d '%s' in %s", \
631 __FILE__, __LINE__, \
632 query_id, __CONCAT(MSG_Q, query_id), __func__); \
633 check_printf(__CONCAT(MSG_Q, query_id), ##args); \
634 (query_message)(query_id, ##args); \
635 } while (false)
636 #else
637 # define query_message(...) \
638 do { \
639 if (any_query_enabled) \
640 (query_message)(__VA_ARGS__); \
641 } while (false)
642 #endif
643
644 /* Copies curr_pos, keeping things unique. */
645 static inline pos_t
unique_curr_pos(void)646 unique_curr_pos(void)
647 {
648 pos_t curr = curr_pos;
649 curr_pos.p_uniq++;
650 if (curr_pos.p_file == csrc_pos.p_file)
651 csrc_pos.p_uniq++;
652 return curr;
653 }
654
655 static inline bool
is_nonzero_val(const val_t * val)656 is_nonzero_val(const val_t *val)
657 {
658 return is_floating(val->v_tspec)
659 ? val->u.floating != 0.0
660 : val->u.integer != 0;
661 }
662
663 static inline bool
constant_is_nonzero(const tnode_t * tn)664 constant_is_nonzero(const tnode_t *tn)
665 {
666 lint_assert(tn->tn_op == CON);
667 lint_assert(tn->tn_type->t_tspec == tn->u.value.v_tspec);
668 return is_nonzero_val(&tn->u.value);
669 }
670
671 static inline bool
is_zero(const tnode_t * tn)672 is_zero(const tnode_t *tn)
673 {
674 return tn != NULL && tn->tn_op == CON && !is_nonzero_val(&tn->u.value);
675 }
676
677 static inline bool
is_nonzero(const tnode_t * tn)678 is_nonzero(const tnode_t *tn)
679 {
680 return tn != NULL && tn->tn_op == CON && is_nonzero_val(&tn->u.value);
681 }
682
683 static inline const char *
op_name(op_t op)684 op_name(op_t op)
685 {
686 return modtab[op].m_name;
687 }
688
689 static inline bool
is_binary(const tnode_t * tn)690 is_binary(const tnode_t *tn)
691 {
692 return modtab[tn->tn_op].m_binary;
693 }
694
695 static inline uint64_t
bit(unsigned i)696 bit(unsigned i)
697 {
698 /*
699 * TODO: Add proper support for INT128. This involves changing val_t to
700 * 128 bits.
701 */
702 if (i >= 64)
703 return 0; /* XXX: not correct for INT128 and UINT128 */
704
705 lint_assert(i < 64);
706 return (uint64_t)1 << i;
707 }
708
709 static inline bool
msb(int64_t si,tspec_t t)710 msb(int64_t si, tspec_t t)
711 {
712 return ((uint64_t)si & bit(size_in_bits(t) - 1)) != 0;
713 }
714
715 static inline uint64_t
value_bits(unsigned bitsize)716 value_bits(unsigned bitsize)
717 {
718 lint_assert(bitsize > 0);
719
720 /* for long double (80 or 128), double _Complex (128) */
721 /*
722 * XXX: double _Complex does not have 128 bits of precision, therefore
723 * it should never be necessary to query the value bits of such a type;
724 * see d_c99_complex_split.c to trigger this case.
725 */
726 if (bitsize >= 64)
727 return ~(uint64_t)0;
728
729 return ~(~(uint64_t)0 << bitsize);
730 }
731
732 /* C99 6.7.8p7 */
733 static inline bool
is_struct_or_union(tspec_t t)734 is_struct_or_union(tspec_t t)
735 {
736 return t == STRUCT || t == UNION;
737 }
738
739 static inline bool
is_member(const sym_t * sym)740 is_member(const sym_t *sym)
741 {
742 return sym->s_scl == STRUCT_MEMBER || sym->s_scl == UNION_MEMBER;
743 }
744
745 static inline void
set_sym_kind(symbol_kind kind)746 set_sym_kind(symbol_kind kind)
747 {
748 if (yflag)
749 debug_step("%s: %s -> %s", __func__,
750 symbol_kind_name(sym_kind), symbol_kind_name(kind));
751 sym_kind = kind;
752 }
753