debug.c revision 1.67
1 /* $NetBSD: debug.c,v 1.67 2024/01/29 21:30:24 rillig Exp $ */ 2 3 /*- 4 * Copyright (c) 2021 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Roland Illig <rillig (at) NetBSD.org>. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #if HAVE_NBTOOL_CONFIG_H 33 #include "nbtool_config.h" 34 #endif 35 36 #include <sys/cdefs.h> 37 #if defined(__RCSID) 38 __RCSID("$NetBSD: debug.c,v 1.67 2024/01/29 21:30:24 rillig Exp $"); 39 #endif 40 41 #include <stdlib.h> 42 #include <string.h> 43 44 #include "lint1.h" 45 #include "cgram.h" 46 47 48 #ifdef DEBUG 49 50 static int debug_indentation = 0; 51 static bool did_indentation; 52 53 54 static FILE * 55 debug_file(void) 56 { 57 /* 58 * Using stdout preserves the order between the debug messages and 59 * lint's diagnostics. 60 */ 61 return yflag ? stderr : stdout; 62 } 63 64 static void 65 debug_vprintf(const char *fmt, va_list va) 66 { 67 68 if (!did_indentation) { 69 did_indentation = true; 70 fprintf(debug_file(), "%s%*s", 71 yflag ? "| " : "", 2 * debug_indentation, ""); 72 } 73 74 (void)vfprintf(debug_file(), fmt, va); 75 76 did_indentation = strchr(fmt, '\n') == NULL; 77 } 78 79 void 80 debug_printf(const char *fmt, ...) 81 { 82 va_list va; 83 84 va_start(va, fmt); 85 debug_vprintf(fmt, va); 86 va_end(va); 87 } 88 89 void 90 debug_skip_indent(void) 91 { 92 93 did_indentation = true; 94 } 95 96 void 97 debug_indent_inc(void) 98 { 99 100 debug_indentation++; 101 } 102 103 void 104 debug_indent_dec(void) 105 { 106 107 lint_assert(debug_indentation > 0); 108 debug_indentation--; 109 } 110 111 bool 112 debug_push_indented(bool indented) 113 { 114 bool prev = did_indentation; 115 did_indentation = indented; 116 return prev; 117 } 118 119 void 120 debug_pop_indented(bool indented) 121 { 122 did_indentation = indented; 123 } 124 125 void 126 debug_step(const char *fmt, ...) 127 { 128 va_list va; 129 130 va_start(va, fmt); 131 debug_vprintf(fmt, va); 132 va_end(va); 133 debug_printf("\n"); 134 } 135 136 void 137 debug_enter_func(const char *func) 138 { 139 140 debug_step("+ %s", func); 141 debug_indent_inc(); 142 } 143 144 void 145 debug_leave_func(const char *func) 146 { 147 148 debug_indent_dec(); 149 debug_step("- %s", func); 150 } 151 152 static void 153 debug_type_details(const type_t *tp) 154 { 155 156 if (is_struct_or_union(tp->t_tspec)) { 157 debug_indent_inc(); 158 debug_step("size %u bits, align %u bits, %s", 159 tp->t_sou->sou_size_in_bits, tp->t_sou->sou_align_in_bits, 160 tp->t_sou->sou_incomplete ? "incomplete" : "complete"); 161 162 for (const sym_t *mem = tp->t_sou->sou_first_member; 163 mem != NULL; mem = mem->s_next) { 164 debug_sym("", mem, "\n"); 165 debug_type_details(mem->s_type); 166 } 167 debug_indent_dec(); 168 } 169 if (tp->t_is_enum) { 170 debug_indent_inc(); 171 for (const sym_t *en = tp->t_enum->en_first_enumerator; 172 en != NULL; en = en->s_next) { 173 debug_sym("", en, "\n"); 174 } 175 debug_indent_dec(); 176 } 177 } 178 179 void 180 debug_type(const type_t *tp) 181 { 182 183 debug_step("type details for '%s':", type_name(tp)); 184 debug_type_details(tp); 185 } 186 187 void 188 debug_node(const tnode_t *tn) // NOLINT(misc-no-recursion) 189 { 190 191 if (tn == NULL) { 192 debug_step("null"); 193 return; 194 } 195 196 op_t op = tn->tn_op; 197 debug_printf("'%s'", 198 op == CVT && tn->tn_cast ? "cast" : op_name(op)); 199 if (op == NAME) 200 debug_printf(" '%s' with %s", 201 tn->tn_sym->s_name, 202 scl_name(tn->tn_sym->s_scl)); 203 else 204 debug_printf(" type"); 205 debug_printf(" '%s'", type_name(tn->tn_type)); 206 if (tn->tn_lvalue) 207 debug_printf(", lvalue"); 208 if (tn->tn_parenthesized) 209 debug_printf(", parenthesized"); 210 if (tn->tn_sys) 211 debug_printf(", sys"); 212 213 switch (op) { 214 case NAME: 215 debug_printf("\n"); 216 break; 217 case CON: 218 if (is_floating(tn->tn_type->t_tspec)) 219 debug_printf(", value %Lg", tn->tn_val.u.floating); 220 else if (is_uinteger(tn->tn_type->t_tspec)) 221 debug_printf(", value %llu", 222 (unsigned long long)tn->tn_val.u.integer); 223 else if (is_integer(tn->tn_type->t_tspec)) 224 debug_printf(", value %lld", 225 (long long)tn->tn_val.u.integer); 226 else { 227 lint_assert(tn->tn_type->t_tspec == BOOL); 228 debug_printf(", value %s", 229 tn->tn_val.u.integer != 0 ? "true" : "false"); 230 } 231 if (tn->tn_val.v_unsigned_since_c90) 232 debug_printf(", unsigned_since_c90"); 233 if (tn->tn_val.v_char_constant) 234 debug_printf(", char_constant"); 235 debug_printf("\n"); 236 break; 237 case STRING: 238 if (tn->tn_string->st_char) 239 debug_printf(", length %zu, \"%s\"\n", 240 tn->tn_string->st_len, 241 tn->tn_string->st_chars); 242 else 243 debug_printf(", length %zu\n", tn->tn_string->st_len); 244 break; 245 default: 246 debug_printf("\n"); 247 248 debug_indent_inc(); 249 lint_assert(has_operands(tn)); 250 lint_assert(tn->tn_left != NULL); 251 debug_node(tn->tn_left); 252 if (op != INCBEF && op != INCAFT 253 && op != DECBEF && op != DECAFT 254 && op != CALL && op != ICALL && op != PUSH) 255 lint_assert(is_binary(tn) == (tn->tn_right != NULL)); 256 if (tn->tn_right != NULL) 257 debug_node(tn->tn_right); 258 debug_indent_dec(); 259 } 260 } 261 262 static const char * 263 def_name(def_t def) 264 { 265 static const char *const name[] = { 266 "not-declared", 267 "declared", 268 "tentative-defined", 269 "defined", 270 }; 271 272 return name[def]; 273 } 274 275 const char * 276 decl_level_kind_name(decl_level_kind kind) 277 { 278 static const char *const name[] = { 279 "extern", 280 "struct", 281 "union", 282 "enum", 283 "old-style-function-parameters", 284 "prototype-parameters", 285 "auto", 286 "abstract", 287 }; 288 289 return name[kind]; 290 } 291 292 const char * 293 scl_name(scl_t scl) 294 { 295 static const char *const name[] = { 296 "none", 297 "extern", 298 "static", 299 "auto", 300 "register", 301 "typedef", 302 "thread_local", 303 "struct", 304 "union", 305 "enum", 306 "member-of-struct", 307 "member-of-union", 308 "abstract", 309 "old-style-function-parameter", 310 "prototype-parameter", 311 }; 312 313 return name[scl]; 314 } 315 316 const char * 317 symbol_kind_name(symbol_kind kind) 318 { 319 static const char *const name[] = { 320 "var-func-type", 321 "member", 322 "tag", 323 "label", 324 }; 325 326 return name[kind]; 327 } 328 329 const char * 330 type_qualifiers_string(type_qualifiers tq) 331 { 332 static char buf[32]; 333 334 snprintf(buf, sizeof(buf), "%s%s%s%s", 335 tq.tq_const ? " const" : "", 336 tq.tq_restrict ? " restrict" : "", 337 tq.tq_volatile ? " volatile" : "", 338 tq.tq_atomic ? " atomic" : ""); 339 return buf[0] != '\0' ? buf + 1 : "none"; 340 } 341 342 const char * 343 function_specifier_name(function_specifier spec) 344 { 345 static const char *const name[] = { 346 "inline", 347 "_Noreturn", 348 }; 349 350 return name[spec]; 351 } 352 353 static void 354 debug_word(bool flag, const char *name) 355 { 356 357 if (flag) 358 debug_printf(" %s", name); 359 } 360 361 void 362 debug_sym(const char *prefix, const sym_t *sym, const char *suffix) 363 { 364 365 debug_printf("%s%s", prefix, sym->s_name); 366 if (sym->s_type != NULL) 367 debug_printf(" type='%s'", type_name(sym->s_type)); 368 if (sym->s_rename != NULL) 369 debug_printf(" rename=%s", sym->s_rename); 370 debug_printf(" %s", symbol_kind_name(sym->s_kind)); 371 debug_word(sym->s_keyword != NULL, "keyword"); 372 debug_word(sym->s_bitfield, "bit-field"); 373 debug_word(sym->s_set, "set"); 374 debug_word(sym->s_used, "used"); 375 debug_word(sym->s_param, "parameter"); 376 debug_word(sym->s_register, "register"); 377 debug_word(sym->s_defparam, "old-style-undefined"); 378 debug_word(sym->s_return_type_implicit_int, "return-int"); 379 debug_word(sym->s_osdef, "old-style"); 380 debug_word(sym->s_inline, "inline"); 381 debug_word(sym->s_ext_sym != NULL, "has-external"); 382 debug_word(sym->s_scl != NO_SCL, scl_name(sym->s_scl)); 383 debug_word(sym->s_keyword == NULL, def_name(sym->s_def)); 384 385 if (sym->s_def_pos.p_file != NULL) 386 debug_printf(" defined-at=%s:%d", 387 sym->s_def_pos.p_file, sym->s_def_pos.p_line); 388 if (sym->s_set_pos.p_file != NULL) 389 debug_printf(" set-at=%s:%d", 390 sym->s_set_pos.p_file, sym->s_set_pos.p_line); 391 if (sym->s_use_pos.p_file != NULL) 392 debug_printf(" used-at=%s:%d", 393 sym->s_use_pos.p_file, sym->s_use_pos.p_line); 394 395 if (sym->s_type != NULL && sym->s_type->t_is_enum) 396 debug_printf(" value=%d", sym->u.s_enum_constant); 397 if (sym->s_type != NULL && sym->s_type->t_tspec == BOOL) 398 debug_printf(" value=%s", 399 sym->u.s_bool_constant ? "true" : "false"); 400 401 if (is_member(sym)) { 402 struct_or_union *sou = sym->u.s_member.sm_containing_type; 403 const char *tag = sou->sou_tag->s_name; 404 const sym_t *def = sou->sou_first_typedef; 405 if (tag == unnamed && def != NULL) 406 debug_printf(" sou='typedef %s'", def->s_name); 407 else 408 debug_printf(" sou='%s'", tag); 409 } 410 411 if (sym->s_keyword != NULL) { 412 int t = sym->u.s_keyword.sk_token; 413 if (t == T_TYPE || t == T_STRUCT_OR_UNION) 414 debug_printf(" %s", 415 tspec_name(sym->u.s_keyword.u.sk_tspec)); 416 if (t == T_QUAL) 417 debug_printf(" %s", type_qualifiers_string( 418 sym->u.s_keyword.u.sk_type_qualifier)); 419 if (t == T_FUNCTION_SPECIFIER) 420 debug_printf(" %s", function_specifier_name( 421 sym->u.s_keyword.u.function_specifier)); 422 } 423 424 debug_word(sym->s_osdef && sym->u.s_old_style_params != NULL, 425 "old-style-params"); 426 427 if (strcmp(suffix, "\n") == 0) 428 debug_printf("\n"); 429 else 430 debug_printf("%s", suffix); 431 } 432 433 static void 434 debug_decl_level(const decl_level *dl) 435 { 436 437 debug_printf("kind=%s", decl_level_kind_name(dl->d_kind)); 438 if (dl->d_scl != NO_SCL) 439 debug_printf(" %s", scl_name(dl->d_scl)); 440 if (dl->d_type != NULL) 441 debug_printf(" '%s'", type_name(dl->d_type)); 442 else { 443 if (dl->d_abstract_type != NO_TSPEC) 444 debug_printf(" %s", tspec_name(dl->d_abstract_type)); 445 if (dl->d_complex_mod != NO_TSPEC) 446 debug_printf(" %s", tspec_name(dl->d_complex_mod)); 447 if (dl->d_sign_mod != NO_TSPEC) 448 debug_printf(" %s", tspec_name(dl->d_sign_mod)); 449 if (dl->d_rank_mod != NO_TSPEC) 450 debug_printf(" %s", tspec_name(dl->d_rank_mod)); 451 } 452 if (dl->d_redeclared_symbol != NULL) 453 debug_sym(" redeclared=(", dl->d_redeclared_symbol, ")"); 454 if (dl->d_sou_size_in_bits != 0) 455 debug_printf(" size=%u", dl->d_sou_size_in_bits); 456 if (dl->d_sou_align_in_bits != 0) 457 debug_printf(" align=%u", dl->d_sou_align_in_bits); 458 459 debug_word(dl->d_qual.tq_const, "const"); 460 debug_word(dl->d_qual.tq_restrict, "restrict"); 461 debug_word(dl->d_qual.tq_volatile, "volatile"); 462 debug_word(dl->d_qual.tq_atomic, "atomic"); 463 debug_word(dl->d_inline, "inline"); 464 debug_word(dl->d_multiple_storage_classes, "multiple_storage_classes"); 465 debug_word(dl->d_invalid_type_combination, "invalid_type_combination"); 466 debug_word(dl->d_nonempty_decl, "nonempty_decl"); 467 debug_word(dl->d_no_type_specifier, "no_type_specifier"); 468 debug_word(dl->d_asm, "asm"); 469 debug_word(dl->d_packed, "packed"); 470 debug_word(dl->d_used, "used"); 471 472 if (dl->d_tag_type != NULL) 473 debug_printf(" tag_type='%s'", type_name(dl->d_tag_type)); 474 for (const sym_t *p = dl->d_func_params; p != NULL; p = p->s_next) 475 debug_sym(" param(", p, ")"); 476 if (dl->d_func_def_pos.p_file != NULL) 477 debug_printf(" func_def_pos=%s:%d:%d", 478 dl->d_func_def_pos.p_file, dl->d_func_def_pos.p_line, 479 dl->d_func_def_pos.p_uniq); 480 for (const sym_t *sym = dl->d_func_proto_syms; 481 sym != NULL; sym = sym->s_next) 482 debug_sym(" func_proto_sym(", sym, ")"); 483 debug_printf("\n"); 484 } 485 486 void 487 debug_dcs(void) 488 { 489 debug_printf("dcs "); 490 debug_decl_level(dcs); 491 } 492 493 void 494 debug_dcs_all(void) 495 { 496 size_t i = 0; 497 for (const decl_level *dl = dcs; dl != NULL; dl = dl->d_enclosing) { 498 debug_printf("dcs[%zu] ", i++); 499 debug_decl_level(dl); 500 } 501 } 502 #endif 503
Indexes created Wed Oct 01 19:09:53 GMT 2025