1 /* $NetBSD: lint1.h,v 1.237 2025/07/11 19:03:01 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 /* 256 * Only for string initializers with automatic size. 257 * Does not take '\0' characters in the middle into account. 258 */ 259 size_t s_array_nonnull_dimension; 260 } u; 261 sym_t *s_symtab_next; /* next symbol in the same symtab bucket */ 262 sym_t **s_symtab_ref; /* pointer to s_symtab_next of the previous 263 * symbol */ 264 sym_t *s_next; /* next struct/union member, enumerator, 265 * parameter */ 266 sym_t *s_level_next; /* next symbol declared on the same level */ 267 }; 268 269 /* 270 * Used to keep some information about symbols before they are entered 271 * into the symbol table. 272 */ 273 typedef struct { 274 const char *sb_name; /* name of symbol */ 275 size_t sb_len; /* length (without '\0') */ 276 sym_t *sb_sym; /* symbol table entry */ 277 } sbuf_t; 278 279 280 typedef struct { 281 struct tnode *func; 282 struct tnode **args; 283 size_t args_len; 284 size_t args_cap; 285 } function_call; 286 287 typedef struct tnode tnode_t; 288 289 /* An expression, forming an abstract syntax tree. */ 290 struct tnode { 291 op_t tn_op; 292 type_t *tn_type; 293 bool tn_lvalue:1; 294 bool tn_cast:1; /* if tn_op == CVT, it's an explicit cast */ 295 bool tn_parenthesized:1; 296 bool tn_sys:1; /* comes from a system header */ 297 bool tn_system_dependent:1; /* depends on sizeof or offsetof */ 298 union { 299 struct { 300 tnode_t *left; /* (left) operand */ 301 tnode_t *right; /* right operand */ 302 } ops; 303 sym_t *sym; /* if NAME */ 304 val_t value; /* if CON */ 305 buffer *str_literals; /* if STRING; for 306 * character strings, 'data' points to 307 * the concatenated string literals in 308 * source form, and 'len' is the 309 * length of the concatenation; for 310 * wide strings, 'data' is NULL and 311 * 'len' is the number of resulting 312 * characters */ 313 function_call *call; /* if CALL */ 314 } u; 315 }; 316 317 struct generic_association { 318 type_t *ga_arg; /* NULL means default or error */ 319 tnode_t *ga_result; /* NULL means error */ 320 struct generic_association *ga_prev; 321 }; 322 323 typedef struct { 324 bool has_dim; 325 int dim; 326 } array_size; 327 328 typedef enum decl_level_kind { 329 DLK_EXTERN, /* global types, variables or functions */ 330 DLK_STRUCT, /* struct members */ 331 DLK_UNION, /* union members */ 332 DLK_ENUM, /* enum constants */ 333 DLK_OLD_STYLE_PARAMS, /* parameters in an old-style function 334 * definition */ 335 DLK_PROTO_PARAMS, /* parameters in a prototype function 336 * definition */ 337 DLK_AUTO, /* local types or variables */ 338 DLK_ABSTRACT /* abstract (unnamed) declaration; type name; 339 * used in casts and sizeof */ 340 } decl_level_kind; 341 342 /* 343 * A declaration level collects information for a declarator in a struct, 344 * union or enum declaration, a parameter declaration list, or a plain 345 * declaration in or outside a function body. 346 * 347 * For nested declarations, the global 'dcs' holds all information needed for 348 * the current level, the outer levels are available via 'd_enclosing'. 349 */ 350 typedef struct decl_level { 351 decl_level_kind d_kind; 352 tspec_t d_abstract_type;/* VOID, BOOL, CHAR, INT or COMPLEX */ 353 tspec_t d_complex_mod; /* FLOAT or DOUBLE */ 354 tspec_t d_sign_mod; /* SIGNED or UNSIGN */ 355 tspec_t d_rank_mod; /* SHORT, LONG or LLONG */ 356 scl_t d_scl; /* storage class */ 357 type_t *d_type; /* after dcs_end_type, the pointer to the type 358 * used for all declarators */ 359 sym_t *d_redeclared_symbol; 360 unsigned int d_sou_size_in_bits; /* size of the structure or 361 * union being built, without 362 * trailing padding */ 363 unsigned int d_sou_align; /* alignment of the structure 364 * or union being built */ 365 unsigned int d_mem_align; /* alignment of the structure 366 * or union member */ 367 type_qualifiers d_qual; /* in declaration specifiers */ 368 bool d_inline:1; /* inline in declaration specifiers */ 369 bool d_multiple_storage_classes:1; /* reported in dcs_end_type */ 370 bool d_invalid_type_combination:1; 371 bool d_nonempty_decl:1; /* in a function declaration, whether at 372 * least one tag was declared */ 373 bool d_no_type_specifier:1; 374 bool d_asm:1; /* set if d_ctx == AUTO and asm() present */ 375 bool d_packed:1; 376 bool d_used:1; 377 bool d_noreturn:1; /* function never returns normally */ 378 type_t *d_tag_type; /* during a member or enumerator declaration, 379 * the tag type to which the member belongs */ 380 sym_t *d_func_params; /* during a function declaration, the 381 * parameters, stored in the enclosing level */ 382 pos_t d_func_def_pos; /* position of the function definition */ 383 sym_t *d_first_dlsym; /* first symbol declared at this level */ 384 sym_t **d_last_dlsym; /* points to s_level_next in the last symbol 385 declaration at this level */ 386 sym_t *d_func_proto_syms; /* symbols defined in prototype, such 387 * as tagged types or parameter names, 388 * may overlap d_func_params */ 389 struct decl_level *d_enclosing; /* the enclosing declaration level */ 390 } decl_level; 391 392 typedef struct { 393 sym_t *first; 394 bool vararg:1; 395 bool prototype:1; 396 bool used:1; 397 bool noreturn:1; 398 bool identifier:1; 399 } parameter_list; 400 401 /* 402 * A sequence of asterisks and qualifiers, from right to left. For example, 403 * 'const ***volatile **const volatile' results in [c-v-, ----, --v-, ----, 404 * ----]. The leftmost 'const' is not included in this list, it is stored in 405 * dcs->d_qual instead. 406 */ 407 typedef struct qual_ptr { 408 type_qualifiers qualifiers; 409 struct qual_ptr *p_next; 410 } qual_ptr; 411 412 /* The values of the 'case' labels. */ 413 typedef struct { 414 val_t *vals; 415 size_t len; 416 size_t cap; 417 } case_labels; 418 419 typedef enum { 420 CS_DO_WHILE, 421 CS_FOR, 422 CS_FUNCTION_BODY, 423 CS_IF, 424 CS_SWITCH, 425 CS_WHILE 426 } control_statement_kind; 427 428 /* 429 * Used to keep information about nested control statements. 430 */ 431 typedef struct control_statement { 432 control_statement_kind c_kind; /* to ensure proper nesting */ 433 bool c_loop:1; /* 'continue' and 'break' are valid */ 434 bool c_switch:1; /* 'case' and 'break' are valid */ 435 bool c_break:1; /* the loop/switch has a reachable 'break' 436 * statement */ 437 bool c_continue:1; /* the loop has a reachable 'continue' 438 * statement */ 439 bool c_default:1; /* the switch has a 'default' label */ 440 bool c_maybe_endless:1; /* the controlling expression is 441 * always true (as in 'for (;;)' or 442 * 'while (1)'), there may be break 443 * statements though */ 444 bool c_always_then:1; 445 bool c_reached_end_of_then:1; 446 bool c_had_return_noval:1; /* had "return;" */ 447 bool c_had_return_value:1; /* had "return expr;" */ 448 449 type_t *c_switch_type; /* type of switch expression */ 450 tnode_t *c_switch_expr; 451 case_labels c_case_labels; /* list of case values */ 452 453 memory_pool c_for_expr3_mem; /* saved memory for end of loop 454 * expression in for() */ 455 tnode_t *c_for_expr3; /* end of loop expr in for() */ 456 pos_t c_for_expr3_pos; /* position of end of loop expr */ 457 pos_t c_for_expr3_csrc_pos; /* same for csrc_pos */ 458 459 struct control_statement *c_surrounding; 460 } control_statement; 461 462 typedef struct { 463 size_t lo; /* inclusive */ 464 size_t hi; /* inclusive */ 465 } range_t; 466 467 typedef enum designator_kind { 468 DK_MEMBER, /* .member */ 469 DK_SUBSCRIPT, /* [subscript] */ 470 DK_SCALAR /* no textual representation, not generated by 471 * the parser; used for scalar initializer 472 * expressions surrounded by braces */ 473 } designator_kind; 474 475 /* 476 * A single component on the path from the "current object" of a brace level 477 * to the sub-object that is initialized by an expression. 478 * 479 * C99 6.7.8p6, 6.7.8p7 480 */ 481 typedef struct designator { 482 designator_kind dr_kind; 483 const sym_t *dr_member; /* for DK_MEMBER */ 484 size_t dr_subscript; /* for DK_SUBSCRIPT */ 485 bool dr_done; 486 } designator; 487 488 /* 489 * The path from the "current object" of a brace level to the sub-object that 490 * is initialized by an expression. Examples of designations are '.member' 491 * or '.member[123].member.member[1][1]'. 492 * 493 * C99 6.7.8p6, 6.7.8p7 494 */ 495 typedef struct designation { 496 designator *dn_items; 497 size_t dn_len; 498 size_t dn_cap; 499 } designation; 500 501 typedef enum { 502 LC_ARGSUSED, 503 LC_BITFIELDTYPE, 504 LC_FALLTHROUGH, 505 LC_LINTLIBRARY, 506 LC_LINTED, 507 LC_LONGLONG, 508 LC_NOTREACHED, 509 LC_PRINTFLIKE, 510 LC_PROTOLIB, 511 LC_SCANFLIKE, 512 LC_VARARGS, 513 } lint_comment; 514 515 typedef struct { 516 size_t start; 517 size_t end; 518 uint64_t value; 519 bool escaped; /* \n, \003, \x24 */ 520 bool named_escape; /* \a, \n, etc. */ 521 bool literal_escape; /* \?, \\, etc. */ 522 uint8_t octal_digits; /* 1 to 3; 0 means not applicable */ 523 uint8_t hex_digits; /* 1 to 3; 0 means not applicable */ 524 bool next_literal; /* when a new string literal begins */ 525 bool invalid_escape; /* single-character escape, recoverable */ 526 bool overflow; /* for octal and hex escapes */ 527 bool missing_hex_digits; 528 bool unescaped_newline; /* stops iterating */ 529 } quoted_iterator; 530 531 typedef enum { 532 TK_IDENTIFIER, 533 TK_CONSTANT, 534 TK_STRING_LITERALS, 535 TK_PUNCTUATOR, 536 } token_kind; 537 538 typedef struct token { 539 token_kind kind; 540 union { 541 const char *identifier; 542 val_t constant; 543 buffer string_literals; 544 const char *punctuator; 545 } u; 546 } token; 547 548 typedef struct balanced_token_sequence balanced_token_sequence; 549 typedef struct balanced_token balanced_token; 550 551 struct balanced_token_sequence { 552 balanced_token *tokens; 553 size_t len; 554 size_t cap; 555 }; 556 557 struct balanced_token { 558 char kind; // '\0', '(', '[', '{' 559 union { 560 token token; 561 balanced_token_sequence tokens; 562 } u; 563 }; 564 565 typedef struct { 566 const char *prefix; 567 const char *name; 568 balanced_token_sequence *arg; 569 } attribute; 570 571 typedef struct { 572 attribute *attrs; 573 size_t len; 574 size_t cap; 575 } attribute_list; 576 577 #include "externs1.h" 578 579 #define lint_assert(cond) \ 580 do { \ 581 if (!(cond)) \ 582 assert_failed(__FILE__, __LINE__, __func__, #cond); \ 583 } while (false) 584 585 #ifdef DEBUG 586 # include "err-msgs.h" 587 588 /* ARGSUSED */ 589 static inline void __printflike(1, 2) 590 check_printf(const char *fmt, ...) 591 { 592 } 593 594 # define wrap_check_printf_at(func, msgid, pos, args...) \ 595 do { \ 596 check_printf(__CONCAT(MSG_, msgid), ##args); \ 597 (func)(msgid, pos, ##args); \ 598 } while (false) 599 600 # define error_at(msgid, pos, args...) \ 601 wrap_check_printf_at(error_at, msgid, pos, ##args) 602 # define warning_at(msgid, pos, args...) \ 603 wrap_check_printf_at(warning_at, msgid, pos, ##args) 604 # define message_at(msgid, pos, args...) \ 605 wrap_check_printf_at(message_at, msgid, pos, ##args) 606 607 # define wrap_check_printf(func, cond, msgid, args...) \ 608 ({ \ 609 if (cond) \ 610 debug_step("%s:%d: %s %d '%s' in %s", \ 611 __FILE__, __LINE__, #func, msgid, \ 612 __CONCAT(MSG_, msgid), __func__); \ 613 check_printf(__CONCAT(MSG_, msgid), ##args); \ 614 (func)(msgid, ##args); \ 615 /* LINTED 129 */ \ 616 }) 617 618 # define error(msgid, args...) wrap_check_printf(error, \ 619 true, msgid, ##args) 620 # define warning(msgid, args...) wrap_check_printf(warning, \ 621 true, msgid, ##args) 622 # define gnuism(msgid, args...) wrap_check_printf(gnuism, \ 623 !allow_gcc || (!allow_trad && !allow_c99), msgid, ##args) 624 # define c99ism(msgid, args...) wrap_check_printf(c99ism, \ 625 !allow_c99 && (!allow_gcc || !allow_trad), msgid, ##args) 626 # define c11ism(msgid, args...) wrap_check_printf(c11ism, \ 627 !allow_c11 && !allow_gcc, msgid, ##args) 628 # define c23ism(msgid, args...) wrap_check_printf(c23ism, \ 629 !allow_c23, msgid, ##args) 630 #endif 631 632 #ifdef DEBUG 633 # define query_message(query_id, args...) \ 634 do { \ 635 debug_step("%s:%d: query %d '%s' in %s", \ 636 __FILE__, __LINE__, \ 637 query_id, __CONCAT(MSG_Q, query_id), __func__); \ 638 check_printf(__CONCAT(MSG_Q, query_id), ##args); \ 639 (query_message)(query_id, ##args); \ 640 } while (false) 641 #else 642 # define query_message(...) \ 643 do { \ 644 if (any_query_enabled) \ 645 (query_message)(__VA_ARGS__); \ 646 } while (false) 647 #endif 648 649 /* Copies curr_pos, keeping things unique. */ 650 static inline pos_t 651 unique_curr_pos(void) 652 { 653 pos_t curr = curr_pos; 654 curr_pos.p_uniq++; 655 if (curr_pos.p_file == csrc_pos.p_file) 656 csrc_pos.p_uniq++; 657 return curr; 658 } 659 660 static inline bool 661 is_nonzero_val(const val_t *val) 662 { 663 return is_floating(val->v_tspec) 664 ? val->u.floating != 0.0 665 : val->u.integer != 0; 666 } 667 668 static inline bool 669 constant_is_nonzero(const tnode_t *tn) 670 { 671 lint_assert(tn->tn_op == CON); 672 lint_assert(tn->tn_type->t_tspec == tn->u.value.v_tspec); 673 return is_nonzero_val(&tn->u.value); 674 } 675 676 static inline bool 677 is_zero(const tnode_t *tn) 678 { 679 return tn != NULL && tn->tn_op == CON && !is_nonzero_val(&tn->u.value); 680 } 681 682 static inline bool 683 is_nonzero(const tnode_t *tn) 684 { 685 return tn != NULL && tn->tn_op == CON && is_nonzero_val(&tn->u.value); 686 } 687 688 static inline const char * 689 op_name(op_t op) 690 { 691 return modtab[op].m_name; 692 } 693 694 static inline bool 695 is_binary(const tnode_t *tn) 696 { 697 return modtab[tn->tn_op].m_binary; 698 } 699 700 static inline uint64_t 701 bit(unsigned i) 702 { 703 /* 704 * TODO: Add proper support for INT128. This involves changing val_t to 705 * 128 bits. 706 */ 707 if (i >= 64) 708 return 0; /* XXX: not correct for INT128 and UINT128 */ 709 710 lint_assert(i < 64); 711 return (uint64_t)1 << i; 712 } 713 714 static inline bool 715 msb(int64_t si, tspec_t t) 716 { 717 return ((uint64_t)si & bit(size_in_bits(t) - 1)) != 0; 718 } 719 720 static inline uint64_t 721 value_bits(unsigned bitsize) 722 { 723 lint_assert(bitsize > 0); 724 725 /* for long double (80 or 128), double _Complex (128) */ 726 /* 727 * XXX: double _Complex does not have 128 bits of precision, therefore 728 * it should never be necessary to query the value bits of such a type; 729 * see d_c99_complex_split.c to trigger this case. 730 */ 731 if (bitsize >= 64) 732 return ~(uint64_t)0; 733 734 return ~(~(uint64_t)0 << bitsize); 735 } 736 737 /* C99 6.7.8p7 */ 738 static inline bool 739 is_struct_or_union(tspec_t t) 740 { 741 return t == STRUCT || t == UNION; 742 } 743 744 static inline bool 745 is_member(const sym_t *sym) 746 { 747 return sym->s_scl == STRUCT_MEMBER || sym->s_scl == UNION_MEMBER; 748 } 749 750 static inline void 751 set_sym_kind(symbol_kind kind) 752 { 753 if (yflag) 754 debug_step("%s: %s -> %s", __func__, 755 symbol_kind_name(sym_kind), symbol_kind_name(kind)); 756 sym_kind = kind; 757 } 758 759 static inline type_attributes 760 merge_type_attributes(type_attributes a, type_attributes b) 761 { 762 return (type_attributes){ 763 .used = a.used || b.used, 764 .noreturn = a.noreturn || b.noreturn, 765 .bit_width = b.bit_width > 0 ? b.bit_width : a.bit_width, 766 }; 767 } 768 769 static inline type_attributes 770 no_type_attributes(void) 771 { 772 return (type_attributes){ .used = false }; 773 } 774
Indexes created Sun Sep 21 20:09:37 GMT 2025