Print this page
12724 update smatch to 0.6.1-rc1-il-5
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/tools/smatch/src/smatch_type.c
+++ new/usr/src/tools/smatch/src/smatch_type.c
1 1 /*
2 2 * Copyright (C) 2009 Dan Carpenter.
3 3 *
4 4 * This program is free software; you can redistribute it and/or
5 5 * modify it under the terms of the GNU General Public License
6 6 * as published by the Free Software Foundation; either version 2
7 7 * of the License, or (at your option) any later version.
8 8 *
9 9 * This program is distributed in the hope that it will be useful,
10 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 12 * GNU General Public License for more details.
13 13 *
14 14 * You should have received a copy of the GNU General Public License
15 15 * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
16 16 */
17 17
18 18 /*
19 19 * The idea here is that you have an expression and you
20 20 * want to know what the type is for that.
21 21 */
22 22
23 23 #include "smatch.h"
24 24 #include "smatch_slist.h"
25 25
26 26 struct symbol *get_real_base_type(struct symbol *sym)
27 27 {
28 28 struct symbol *ret;
29 29
30 30 if (!sym)
31 31 return NULL;
32 32 if (sym->type == SYM_BASETYPE)
33 33 return sym;
34 34 ret = get_base_type(sym);
35 35 if (!ret)
36 36 return NULL;
37 37 if (ret->type == SYM_RESTRICT || ret->type == SYM_NODE)
38 38 return get_real_base_type(ret);
39 39 return ret;
40 40 }
41 41
42 42 int type_bytes(struct symbol *type)
43 43 {
44 44 int bits;
45 45
46 46 if (type && type->type == SYM_ARRAY)
47 47 return array_bytes(type);
48 48
49 49 bits = type_bits(type);
50 50 if (bits < 0)
51 51 return 0;
52 52 return bits_to_bytes(bits);
53 53 }
54 54
55 55 int array_bytes(struct symbol *type)
56 56 {
57 57 if (!type || type->type != SYM_ARRAY)
58 58 return 0;
59 59 return bits_to_bytes(type->bit_size);
60 60 }
61 61
62 62 static struct symbol *get_binop_type(struct expression *expr)
63 63 {
64 64 struct symbol *left, *right;
65 65
66 66 left = get_type(expr->left);
67 67 if (!left)
68 68 return NULL;
69 69
70 70 if (expr->op == SPECIAL_LEFTSHIFT ||
71 71 expr->op == SPECIAL_RIGHTSHIFT) {
72 72 if (type_positive_bits(left) < 31)
73 73 return &int_ctype;
74 74 return left;
75 75 }
76 76 right = get_type(expr->right);
77 77 if (!right)
78 78 return NULL;
79 79
80 80 if (type_is_fp(left)) {
81 81 if (type_is_fp(right)) {
82 82 if (type_bits(left) > type_bits(right))
83 83 return left;
84 84 return right;
85 85 }
86 86 return left;
87 87 }
88 88
89 89 if (type_is_fp(right)) {
90 90 if (type_is_fp(left)) {
91 91 if (type_bits(right) > type_bits(left))
92 92 return right;
93 93 return left;
94 94 }
95 95 return right;
96 96 }
97 97
98 98 if (expr->op == '-' &&
99 99 (is_ptr_type(left) && is_ptr_type(right)))
100 100 return ssize_t_ctype;
101 101
102 102 if (left->type == SYM_PTR || left->type == SYM_ARRAY)
103 103 return left;
104 104 if (right->type == SYM_PTR || right->type == SYM_ARRAY)
105 105 return right;
106 106
107 107 if (type_positive_bits(left) < 31 && type_positive_bits(right) < 31)
108 108 return &int_ctype;
109 109
110 110 if (type_positive_bits(left) > type_positive_bits(right))
111 111 return left;
112 112 return right;
113 113 }
114 114
115 115 static struct symbol *get_type_symbol(struct expression *expr)
116 116 {
117 117 if (!expr || expr->type != EXPR_SYMBOL || !expr->symbol)
118 118 return NULL;
119 119
120 120 return get_real_base_type(expr->symbol);
121 121 }
122 122
123 123 static struct symbol *get_member_symbol(struct symbol_list *symbol_list, struct ident *member)
124 124 {
125 125 struct symbol *tmp, *sub;
126 126
127 127 FOR_EACH_PTR(symbol_list, tmp) {
128 128 if (!tmp->ident) {
129 129 sub = get_real_base_type(tmp);
130 130 sub = get_member_symbol(sub->symbol_list, member);
131 131 if (sub)
132 132 return sub;
133 133 continue;
134 134 }
135 135 if (tmp->ident == member)
136 136 return tmp;
137 137 } END_FOR_EACH_PTR(tmp);
138 138
139 139 return NULL;
140 140 }
141 141
142 142 static struct symbol *get_symbol_from_deref(struct expression *expr)
143 143 {
144 144 struct ident *member;
145 145 struct symbol *sym;
146 146
147 147 if (!expr || expr->type != EXPR_DEREF)
148 148 return NULL;
149 149
150 150 member = expr->member;
151 151 sym = get_type(expr->deref);
152 152 if (!sym) {
153 153 // sm_msg("could not find struct type");
154 154 return NULL;
155 155 }
156 156 if (sym->type == SYM_PTR)
157 157 sym = get_real_base_type(sym);
158 158 sym = get_member_symbol(sym->symbol_list, member);
159 159 if (!sym)
160 160 return NULL;
161 161 return get_real_base_type(sym);
162 162 }
163 163
164 164 static struct symbol *handle__builtin_choose_expr(struct expression *expr)
165 165 {
166 166 struct expression *const_expr, *expr1, *expr2;
167 167 sval_t sval;
168 168
169 169 const_expr = get_argument_from_call_expr(expr->args, 0);
170 170 expr1 = get_argument_from_call_expr(expr->args, 1);
171 171 expr2 = get_argument_from_call_expr(expr->args, 2);
172 172
173 173 if (!get_value(const_expr, &sval) || !expr1 || !expr2)
174 174 return NULL;
175 175 if (sval.value)
176 176 return get_type(expr1);
177 177 else
178 178 return get_type(expr2);
179 179 }
180 180
181 181 static struct symbol *get_return_type(struct expression *expr)
182 182 {
183 183 struct symbol *tmp;
184 184
185 185 if (sym_name_is("__builtin_choose_expr", expr->fn))
186 186 return handle__builtin_choose_expr(expr);
187 187
188 188 tmp = get_type(expr->fn);
189 189 if (!tmp)
190 190 return NULL;
191 191 /* this is to handle __builtin_constant_p() */
192 192 if (tmp->type != SYM_FN)
193 193 tmp = get_base_type(tmp);
194 194 return get_real_base_type(tmp);
195 195 }
196 196
197 197 static struct symbol *get_expr_stmt_type(struct statement *stmt)
198 198 {
199 199 if (stmt->type != STMT_COMPOUND)
200 200 return NULL;
201 201 stmt = last_ptr_list((struct ptr_list *)stmt->stmts);
202 202 if (stmt->type == STMT_LABEL)
203 203 stmt = stmt->label_statement;
204 204 if (stmt->type != STMT_EXPRESSION)
205 205 return NULL;
206 206 return get_type(stmt->expression);
207 207 }
208 208
209 209 static struct symbol *get_select_type(struct expression *expr)
210 210 {
211 211 struct symbol *one, *two;
212 212
213 213 one = get_type(expr->cond_true);
214 214 two = get_type(expr->cond_false);
215 215 if (!one || !two)
216 216 return NULL;
217 217 /*
218 218 * This is a hack. If the types are not equiv then we
219 219 * really don't know the type. But I think guessing is
220 220 * probably Ok here.
221 221 */
222 222 if (type_positive_bits(one) > type_positive_bits(two))
223 223 return one;
224 224 return two;
225 225 }
226 226
227 227 struct symbol *get_pointer_type(struct expression *expr)
228 228 {
229 229 struct symbol *sym;
230 230
231 231 sym = get_type(expr);
232 232 if (!sym)
233 233 return NULL;
234 234 if (sym->type == SYM_NODE) {
235 235 sym = get_real_base_type(sym);
236 236 if (!sym)
237 237 return NULL;
238 238 }
239 239 if (sym->type != SYM_PTR && sym->type != SYM_ARRAY)
240 240 return NULL;
241 241 return get_real_base_type(sym);
242 242 }
243 243
244 244 static struct symbol *fake_pointer_sym(struct expression *expr)
245 245 {
246 246 struct symbol *sym;
247 247 struct symbol *base;
248 248
249 249 sym = alloc_symbol(expr->pos, SYM_PTR);
250 250 expr = expr->unop;
251 251 base = get_type(expr);
252 252 if (!base)
253 253 return NULL;
254 254 sym->ctype.base_type = base;
255 255 return sym;
256 256 }
257 257
258 258 static struct symbol *get_type_helper(struct expression *expr)
259 259 {
260 260 struct symbol *ret;
261 261
262 262 expr = strip_parens(expr);
263 263 if (!expr)
264 264 return NULL;
265 265
266 266 if (expr->ctype)
267 267 return expr->ctype;
268 268
269 269 switch (expr->type) {
270 270 case EXPR_STRING:
271 271 ret = &string_ctype;
272 272 break;
273 273 case EXPR_SYMBOL:
274 274 ret = get_type_symbol(expr);
275 275 break;
276 276 case EXPR_DEREF:
277 277 ret = get_symbol_from_deref(expr);
278 278 break;
279 279 case EXPR_PREOP:
280 280 case EXPR_POSTOP:
281 281 if (expr->op == '&')
282 282 ret = fake_pointer_sym(expr);
283 283 else if (expr->op == '*')
284 284 ret = get_pointer_type(expr->unop);
285 285 else
286 286 ret = get_type(expr->unop);
287 287 break;
288 288 case EXPR_ASSIGNMENT:
289 289 ret = get_type(expr->left);
290 290 break;
291 291 case EXPR_CAST:
292 292 case EXPR_FORCE_CAST:
293 293 case EXPR_IMPLIED_CAST:
294 294 ret = get_real_base_type(expr->cast_type);
295 295 break;
296 296 case EXPR_COMPARE:
297 297 case EXPR_BINOP:
298 298 ret = get_binop_type(expr);
299 299 break;
300 300 case EXPR_CALL:
301 301 ret = get_return_type(expr);
302 302 break;
303 303 case EXPR_STATEMENT:
304 304 ret = get_expr_stmt_type(expr->statement);
305 305 break;
306 306 case EXPR_CONDITIONAL:
307 307 case EXPR_SELECT:
308 308 ret = get_select_type(expr);
309 309 break;
310 310 case EXPR_SIZEOF:
311 311 ret = &ulong_ctype;
312 312 break;
313 313 case EXPR_LOGICAL:
314 314 ret = &int_ctype;
315 315 break;
316 316 case EXPR_OFFSETOF:
317 317 ret = &ulong_ctype;
318 318 break;
319 319 default:
320 320 return NULL;
321 321 }
322 322
323 323 if (ret && ret->type == SYM_TYPEOF)
324 324 ret = get_type(ret->initializer);
325 325
326 326 expr->ctype = ret;
327 327 return ret;
328 328 }
329 329
330 330 static struct symbol *get_final_type_helper(struct expression *expr)
331 331 {
332 332 /*
333 333 * The problem is that I wrote a bunch of Smatch to think that
334 334 * you could do get_type() on an expression and it would give
335 335 * you what the comparison was type promoted to. This is wrong
336 336 * but fixing it is a big of work... Hence this horrible hack.
337 337 *
338 338 */
339 339
340 340 expr = strip_parens(expr);
341 341 if (!expr)
342 342 return NULL;
343 343
344 344 if (expr->type == EXPR_COMPARE)
345 345 return &int_ctype;
346 346
347 347 return NULL;
348 348 }
349 349
350 350 struct symbol *get_type(struct expression *expr)
351 351 {
352 352 return get_type_helper(expr);
353 353 }
354 354
355 355 struct symbol *get_final_type(struct expression *expr)
356 356 {
357 357 struct symbol *ret;
358 358
359 359 ret = get_final_type_helper(expr);
360 360 if (ret)
361 361 return ret;
362 362 return get_type_helper(expr);
363 363 }
364 364
365 365 struct symbol *get_promoted_type(struct symbol *left, struct symbol *right)
366 366 {
367 367 struct symbol *ret = &int_ctype;
368 368
369 369 if (type_positive_bits(left) > type_positive_bits(ret))
370 370 ret = left;
371 371 if (type_positive_bits(right) > type_positive_bits(ret))
372 372 ret = right;
373 373
374 374 if (type_is_ptr(left))
375 375 ret = left;
376 376 if (type_is_ptr(right))
377 377 ret = right;
378 378
379 379 return ret;
380 380 }
381 381
382 382 int type_signed(struct symbol *base_type)
383 383 {
384 384 if (!base_type)
385 385 return 0;
386 386 if (base_type->ctype.modifiers & MOD_SIGNED)
387 387 return 1;
388 388 return 0;
389 389 }
390 390
391 391 int expr_unsigned(struct expression *expr)
392 392 {
393 393 struct symbol *sym;
394 394
395 395 sym = get_type(expr);
396 396 if (!sym)
397 397 return 0;
398 398 if (type_unsigned(sym))
399 399 return 1;
400 400 return 0;
401 401 }
402 402
403 403 int expr_signed(struct expression *expr)
404 404 {
405 405 struct symbol *sym;
406 406
407 407 sym = get_type(expr);
408 408 if (!sym)
409 409 return 0;
410 410 if (type_signed(sym))
411 411 return 1;
412 412 return 0;
413 413 }
414 414
415 415 int returns_unsigned(struct symbol *sym)
416 416 {
417 417 if (!sym)
418 418 return 0;
419 419 sym = get_base_type(sym);
420 420 if (!sym || sym->type != SYM_FN)
421 421 return 0;
422 422 sym = get_base_type(sym);
423 423 return type_unsigned(sym);
424 424 }
425 425
426 426 int is_pointer(struct expression *expr)
427 427 {
428 428 return type_is_ptr(get_type(expr));
429 429 }
430 430
431 431 int returns_pointer(struct symbol *sym)
432 432 {
433 433 if (!sym)
434 434 return 0;
435 435 sym = get_base_type(sym);
436 436 if (!sym || sym->type != SYM_FN)
437 437 return 0;
438 438 sym = get_base_type(sym);
439 439 if (sym && sym->type == SYM_PTR)
440 440 return 1;
441 441 return 0;
442 442 }
443 443
444 444 static sval_t fp_max(struct symbol *type)
445 445 {
446 446 sval_t ret = { .type = type };
447 447
448 448 if (type == &float_ctype)
449 449 ret.fvalue = FLT_MAX;
450 450 else if (type == &double_ctype)
451 451 ret.dvalue = DBL_MAX;
452 452 else
453 453 ret.ldvalue = LDBL_MAX;
454 454
455 455 return ret;
456 456 }
457 457
458 458 sval_t sval_type_max(struct symbol *base_type)
459 459 {
460 460 sval_t ret;
461 461
462 462 if (type_is_fp(base_type))
463 463 return fp_max(base_type);
464 464
465 465 if (!base_type || !type_bits(base_type))
466 466 base_type = &llong_ctype;
467 467 ret.type = base_type;
468 468
469 469 ret.value = (~0ULL) >> (64 - type_positive_bits(base_type));
470 470 return ret;
471 471 }
472 472
473 473 static sval_t fp_min(struct symbol *type)
474 474 {
475 475 sval_t ret = { .type = type };
476 476
477 477 if (type == &float_ctype)
478 478 ret.fvalue = -FLT_MAX;
479 479 else if (type == &double_ctype)
480 480 ret.dvalue = -DBL_MAX;
481 481 else
482 482 ret.ldvalue = -LDBL_MAX;
483 483
484 484 return ret;
485 485 }
486 486
487 487 sval_t sval_type_min(struct symbol *base_type)
488 488 {
489 489 sval_t ret;
490 490
491 491 if (type_is_fp(base_type))
492 492 return fp_min(base_type);
493 493
494 494 if (!base_type || !type_bits(base_type))
495 495 base_type = &llong_ctype;
496 496 ret.type = base_type;
497 497
498 498 if (type_unsigned(base_type) || is_ptr_type(base_type)) {
499 499 ret.value = 0;
500 500 return ret;
501 501 }
502 502
503 503 ret.value = (~0ULL) << type_positive_bits(base_type);
504 504
505 505 return ret;
506 506 }
507 507
508 508 int nr_bits(struct expression *expr)
509 509 {
510 510 struct symbol *type;
511 511
512 512 type = get_type(expr);
513 513 if (!type)
514 514 return 0;
515 515 return type_bits(type);
516 516 }
517 517
518 518 int is_void_pointer(struct expression *expr)
519 519 {
520 520 struct symbol *type;
521 521
522 522 type = get_type(expr);
523 523 if (!type || type->type != SYM_PTR)
524 524 return 0;
525 525 type = get_real_base_type(type);
526 526 if (type == &void_ctype)
527 527 return 1;
528 528 return 0;
529 529 }
530 530
531 531 int is_char_pointer(struct expression *expr)
532 532 {
533 533 struct symbol *type;
534 534
535 535 type = get_type(expr);
536 536 if (!type || type->type != SYM_PTR)
537 537 return 0;
538 538 type = get_real_base_type(type);
539 539 if (type == &char_ctype)
540 540 return 1;
541 541 return 0;
542 542 }
543 543
|
↓ open down ↓ |
543 lines elided |
↑ open up ↑ |
544 544 int is_string(struct expression *expr)
545 545 {
546 546 expr = strip_expr(expr);
547 547 if (!expr || expr->type != EXPR_STRING)
548 548 return 0;
549 549 if (expr->string)
550 550 return 1;
551 551 return 0;
552 552 }
553 553
554 +bool is_struct_ptr(struct symbol *type)
555 +{
556 + if (!type || type->type != SYM_PTR)
557 + return false;
558 + type = get_real_base_type(type);
559 + if (!type || type->type != SYM_STRUCT)
560 + return false;
561 + return true;
562 +}
563 +
554 564 int is_static(struct expression *expr)
555 565 {
556 566 char *name;
557 567 struct symbol *sym;
558 568 int ret = 0;
559 569
560 570 name = expr_to_str_sym(expr, &sym);
561 571 if (!name || !sym)
562 572 goto free;
563 573
564 574 if (sym->ctype.modifiers & MOD_STATIC)
565 575 ret = 1;
566 576 free:
567 577 free_string(name);
568 578 return ret;
569 579 }
570 580
571 581 bool is_local_variable(struct expression *expr)
572 582 {
573 583 struct symbol *sym;
574 584
575 585 if (!expr || expr->type != EXPR_SYMBOL || !expr->symbol)
576 586 return false;
577 587 sym = expr->symbol;
578 588 if (!(sym->ctype.modifiers & MOD_TOPLEVEL))
579 589 return true;
580 590 return false;
581 591 }
582 592
583 593 int types_equiv(struct symbol *one, struct symbol *two)
584 594 {
585 595 if (!one && !two)
586 596 return 1;
587 597 if (!one || !two)
|
↓ open down ↓ |
24 lines elided |
↑ open up ↑ |
588 598 return 0;
589 599 if (one->type != two->type)
590 600 return 0;
591 601 if (one->type == SYM_PTR)
592 602 return types_equiv(get_real_base_type(one), get_real_base_type(two));
593 603 if (type_positive_bits(one) != type_positive_bits(two))
594 604 return 0;
595 605 return 1;
596 606 }
597 607
608 +bool type_fits(struct symbol *type, struct symbol *test)
609 +{
610 + if (!type || !test)
611 + return false;
612 +
613 + if (type == test)
614 + return true;
615 +
616 + if (type_bits(test) > type_bits(type))
617 + return false;
618 + if (type_signed(test) && !type_signed(type))
619 + return false;
620 + if (type_positive_bits(test) > type_positive_bits(type))
621 + return false;
622 + return true;
623 +}
624 +
598 625 int fn_static(void)
599 626 {
600 627 return !!(cur_func_sym->ctype.modifiers & MOD_STATIC);
601 628 }
602 629
603 630 const char *global_static(void)
604 631 {
605 632 if (cur_func_sym->ctype.modifiers & MOD_STATIC)
606 633 return "static";
607 634 else
608 635 return "global";
609 636 }
610 637
611 638 struct symbol *cur_func_return_type(void)
612 639 {
613 640 struct symbol *sym;
614 641
615 642 sym = get_real_base_type(cur_func_sym);
616 643 if (!sym || sym->type != SYM_FN)
617 644 return NULL;
618 645 sym = get_real_base_type(sym);
619 646 return sym;
620 647 }
621 648
622 649 struct symbol *get_arg_type(struct expression *fn, int arg)
623 650 {
624 651 struct symbol *fn_type;
625 652 struct symbol *tmp;
626 653 struct symbol *arg_type;
627 654 int i;
628 655
629 656 fn_type = get_type(fn);
630 657 if (!fn_type)
631 658 return NULL;
632 659 if (fn_type->type == SYM_PTR)
633 660 fn_type = get_real_base_type(fn_type);
634 661 if (fn_type->type != SYM_FN)
635 662 return NULL;
636 663
637 664 i = 0;
638 665 FOR_EACH_PTR(fn_type->arguments, tmp) {
639 666 arg_type = get_real_base_type(tmp);
640 667 if (i == arg) {
641 668 return arg_type;
642 669 }
643 670 i++;
644 671 } END_FOR_EACH_PTR(tmp);
645 672
646 673 return NULL;
647 674 }
648 675
649 676 static struct symbol *get_member_from_string(struct symbol_list *symbol_list, const char *name)
650 677 {
651 678 struct symbol *tmp, *sub;
652 679 int chunk_len;
653 680
654 681 if (strncmp(name, ".", 1) == 0)
655 682 name += 1;
656 683 else if (strncmp(name, "->", 2) == 0)
657 684 name += 2;
658 685
659 686 FOR_EACH_PTR(symbol_list, tmp) {
660 687 if (!tmp->ident) {
661 688 sub = get_real_base_type(tmp);
662 689 sub = get_member_from_string(sub->symbol_list, name);
663 690 if (sub)
664 691 return sub;
665 692 continue;
666 693 }
667 694
668 695 if (strcmp(tmp->ident->name, name) == 0)
669 696 return tmp;
670 697
671 698 chunk_len = tmp->ident->len;
672 699 if (strncmp(tmp->ident->name, name, chunk_len) == 0 &&
673 700 (name[chunk_len] == '.' || name[chunk_len] == '-')) {
674 701 sub = get_real_base_type(tmp);
675 702 if (sub->type == SYM_PTR)
676 703 sub = get_real_base_type(sub);
677 704 return get_member_from_string(sub->symbol_list, name + chunk_len);
|
↓ open down ↓ |
70 lines elided |
↑ open up ↑ |
678 705 }
679 706
680 707 } END_FOR_EACH_PTR(tmp);
681 708
682 709 return NULL;
683 710 }
684 711
685 712 struct symbol *get_member_type_from_key(struct expression *expr, const char *key)
686 713 {
687 714 struct symbol *sym;
715 + int star = 0;
716 + int i;
688 717
689 718 if (strcmp(key, "$") == 0)
690 719 return get_type(expr);
691 720
692 721 if (strcmp(key, "*$") == 0) {
693 722 sym = get_type(expr);
694 723 if (!sym || sym->type != SYM_PTR)
695 724 return NULL;
696 725 return get_real_base_type(sym);
697 726 }
698 727
699 728 sym = get_type(expr);
700 729 if (!sym)
701 730 return NULL;
702 731 if (sym->type == SYM_PTR)
703 732 sym = get_real_base_type(sym);
704 733
705 - key = key + 1;
734 + while (*key == '*') {
735 + key++;
736 + star++;
737 + }
738 +
739 + if (*key != '$')
740 + return NULL;
741 + key++;
742 +
706 743 sym = get_member_from_string(sym->symbol_list, key);
707 744 if (!sym)
708 745 return NULL;
709 - return get_real_base_type(sym);
746 + if (sym->type == SYM_RESTRICT || sym->type == SYM_NODE)
747 + sym = get_real_base_type(sym);
748 + for (i = 0; i < star; i++) {
749 + if (!sym || sym->type != SYM_PTR)
750 + return NULL;
751 + sym = get_real_base_type(sym);
752 + }
753 + return sym;
710 754 }
711 755
712 756 struct symbol *get_arg_type_from_key(struct expression *fn, int param, struct expression *arg, const char *key)
713 757 {
714 758 struct symbol *type;
715 759
716 760 if (!key)
717 761 return NULL;
718 762 if (strcmp(key, "$") == 0)
719 763 return get_arg_type(fn, param);
720 764 if (strcmp(key, "*$") == 0) {
721 765 type = get_arg_type(fn, param);
722 766 if (!type || type->type != SYM_PTR)
723 767 return NULL;
724 768 return get_real_base_type(type);
725 769 }
726 770 return get_member_type_from_key(arg, key);
727 771 }
728 772
729 773 int is_struct(struct expression *expr)
730 774 {
731 775 struct symbol *type;
732 776
733 777 type = get_type(expr);
734 778 if (type && type->type == SYM_STRUCT)
735 779 return 1;
736 780 return 0;
737 781 }
738 782
739 783 static struct {
740 784 struct symbol *sym;
741 785 const char *name;
742 786 } base_types[] = {
743 787 {&bool_ctype, "bool"},
744 788 {&void_ctype, "void"},
745 789 {&type_ctype, "type"},
746 790 {&char_ctype, "char"},
747 791 {&schar_ctype, "schar"},
748 792 {&uchar_ctype, "uchar"},
749 793 {&short_ctype, "short"},
750 794 {&sshort_ctype, "sshort"},
751 795 {&ushort_ctype, "ushort"},
752 796 {&int_ctype, "int"},
753 797 {&sint_ctype, "sint"},
754 798 {&uint_ctype, "uint"},
755 799 {&long_ctype, "long"},
756 800 {&slong_ctype, "slong"},
757 801 {&ulong_ctype, "ulong"},
758 802 {&llong_ctype, "llong"},
759 803 {&sllong_ctype, "sllong"},
760 804 {&ullong_ctype, "ullong"},
761 805 {&lllong_ctype, "lllong"},
762 806 {&slllong_ctype, "slllong"},
763 807 {&ulllong_ctype, "ulllong"},
764 808 {&float_ctype, "float"},
765 809 {&double_ctype, "double"},
766 810 {&ldouble_ctype, "ldouble"},
767 811 {&string_ctype, "string"},
768 812 {&ptr_ctype, "ptr"},
769 813 {&lazy_ptr_ctype, "lazy_ptr"},
770 814 {&incomplete_ctype, "incomplete"},
771 815 {&label_ctype, "label"},
772 816 {&bad_ctype, "bad"},
773 817 {&null_ctype, "null"},
774 818 };
775 819
776 820 static const char *base_type_str(struct symbol *sym)
777 821 {
778 822 int i;
779 823
780 824 for (i = 0; i < ARRAY_SIZE(base_types); i++) {
781 825 if (sym == base_types[i].sym)
782 826 return base_types[i].name;
783 827 }
784 828 return "<unknown>";
785 829 }
786 830
787 831 static int type_str_helper(char *buf, int size, struct symbol *type)
788 832 {
789 833 int n;
790 834
791 835 if (!type)
792 836 return snprintf(buf, size, "<null type>");
793 837
794 838 if (type->type == SYM_BASETYPE) {
795 839 return snprintf(buf, size, "%s", base_type_str(type));
796 840 } else if (type->type == SYM_PTR) {
797 841 type = get_real_base_type(type);
798 842 n = type_str_helper(buf, size, type);
799 843 if (n > size)
800 844 return n;
801 845 return n + snprintf(buf + n, size - n, "*");
802 846 } else if (type->type == SYM_ARRAY) {
803 847 type = get_real_base_type(type);
804 848 n = type_str_helper(buf, size, type);
805 849 if (n > size)
806 850 return n;
807 851 return n + snprintf(buf + n, size - n, "[]");
808 852 } else if (type->type == SYM_STRUCT) {
809 853 return snprintf(buf, size, "struct %s", type->ident ? type->ident->name : "");
810 854 } else if (type->type == SYM_UNION) {
811 855 if (type->ident)
812 856 return snprintf(buf, size, "union %s", type->ident->name);
813 857 else
814 858 return snprintf(buf, size, "anonymous union");
815 859 } else if (type->type == SYM_FN) {
816 860 struct symbol *arg, *return_type, *arg_type;
817 861 int i;
818 862
819 863 return_type = get_real_base_type(type);
820 864 n = type_str_helper(buf, size, return_type);
821 865 if (n > size)
822 866 return n;
823 867 n += snprintf(buf + n, size - n, "(*)(");
824 868 if (n > size)
825 869 return n;
826 870
827 871 i = 0;
828 872 FOR_EACH_PTR(type->arguments, arg) {
829 873 if (i++)
830 874 n += snprintf(buf + n, size - n, ", ");
831 875 if (n > size)
832 876 return n;
833 877 arg_type = get_real_base_type(arg);
834 878 n += type_str_helper(buf + n, size - n, arg_type);
835 879 if (n > size)
836 880 return n;
837 881 } END_FOR_EACH_PTR(arg);
838 882
839 883 return n + snprintf(buf + n, size - n, ")");
840 884 } else if (type->type == SYM_NODE) {
841 885 n = snprintf(buf, size, "node {");
842 886 if (n > size)
843 887 return n;
844 888 type = get_real_base_type(type);
845 889 n += type_str_helper(buf + n, size - n, type);
846 890 if (n > size)
847 891 return n;
848 892 return n + snprintf(buf + n, size - n, "}");
849 893 } else if (type->type == SYM_ENUM) {
850 894 return snprintf(buf, size, "enum %s", type->ident ? type->ident->name : "<unknown>");
851 895 } else {
852 896 return snprintf(buf, size, "<type %d>", type->type);
853 897 }
854 898 }
855 899
856 900 char *type_to_str(struct symbol *type)
857 901 {
858 902 static char buf[256];
859 903
860 904 buf[0] = '\0';
861 905 type_str_helper(buf, sizeof(buf), type);
862 906 return buf;
863 907 }
|
↓ open down ↓ |
144 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX