dissect.c

   1 /*
   2  * sparse/dissect.c
   3  *
   4  * Started by Oleg Nesterov <oleg@redhat.com>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "dissect.h"
  26
  27 #define U_VOID   0x00
  28 #define U_SELF  ((1 << U_SHIFT) - 1)
  29 #define U_MASK  (U_R_VAL | U_W_VAL | U_R_AOF)
  30
  31 #define DO_LIST(l__, p__, expr__)               \
  32         do {                                    \
  33                 typeof(l__->list[0]) p__;       \
  34                 FOR_EACH_PTR(l__, p__)          \
  35                         expr__;                 \
  36                 END_FOR_EACH_PTR(p__);          \
  37         } while (0)
  38
  39 #define DO_2_LIST(l1__,l2__, p1__,p2__, expr__) \
  40         do {                                    \
  41                 typeof(l1__->list[0]) p1__;     \
  42                 typeof(l2__->list[0]) p2__;     \
  43                 PREPARE_PTR_LIST(l1__, p1__);   \
  44                 FOR_EACH_PTR(l2__, p2__)        \
  45                         expr__;                 \
  46                         NEXT_PTR_LIST(p1__);    \
  47                 END_FOR_EACH_PTR(p2__);         \
  48                 FINISH_PTR_LIST(p1__);          \
  49         } while (0)
  50
  51
  52 typedef unsigned usage_t;
  53
  54 static struct reporter *reporter;
  55 static struct symbol *return_type;
  56
  57 static void do_sym_list(struct symbol_list *list);
  58
  59 static struct symbol
  60         *base_type(struct symbol *sym),
  61         *do_initializer(struct symbol *type, struct expression *expr),
  62         *do_expression(usage_t mode, struct expression *expr),
  63         *do_statement(usage_t mode, struct statement *stmt);
  64
  65 static inline int is_ptr(struct symbol *type)
  66 {
  67         return type->type == SYM_PTR || type->type == SYM_ARRAY;
  68 }
  69
  70 static inline usage_t u_rval(usage_t mode)
  71 {
  72         return mode & (U_R_VAL | (U_MASK << U_SHIFT))
  73                 ? U_R_VAL : 0;
  74 }
  75
  76 static inline usage_t u_addr(usage_t mode)
  77 {
  78         return mode = mode & U_MASK
  79                 ? U_R_AOF | (mode & U_W_AOF) : 0;
  80 }
  81
  82 static usage_t u_lval(struct symbol *type)
  83 {
  84         int wptr = is_ptr(type) && !(type->ctype.modifiers & MOD_CONST);
  85         return wptr || type == &bad_ctype
  86                 ? U_W_AOF | U_R_VAL : U_R_VAL;
  87 }
  88
  89 static usage_t fix_mode(struct symbol *type, usage_t mode)
  90 {
  91         mode &= (U_SELF | (U_SELF << U_SHIFT));
  92
  93         switch (type->type) {
  94                 case SYM_BASETYPE:
  95                         if (!type->ctype.base_type)
  96                                 break;
  97                 case SYM_ENUM:
  98                 case SYM_BITFIELD:
  99                         if (mode & U_MASK)
 100                                 mode &= U_SELF;
 101                 default:
 102
 103                 break; case SYM_FN:
 104                         if (mode & U_R_VAL)
 105                                 mode |= U_R_AOF;
 106                         mode &= ~(U_R_VAL | U_W_AOF);
 107
 108                 break; case SYM_ARRAY:
 109                         if (mode & (U_MASK << U_SHIFT))
 110                                 mode >>= U_SHIFT;
 111                         else if (mode != U_W_VAL)
 112                                 mode = u_addr(mode);
 113         }
 114
 115         if (!(mode & U_R_AOF))
 116                 mode &= ~U_W_AOF;
 117
 118         return mode;
 119 }
 120
 121 static inline struct symbol *no_member(struct ident *name)
 122 {
 123         static struct symbol sym = {
 124                 .type = SYM_BAD,
 125         };
 126
 127         sym.ctype.base_type = &bad_ctype;
 128         sym.ident = name;
 129
 130         return &sym;
 131 }
 132
 133 static struct symbol *report_member(usage_t mode, struct position *pos,
 134                                         struct symbol *type, struct symbol *mem)
 135 {
 136         struct symbol *ret = mem->ctype.base_type;
 137
 138         if (reporter->r_member)
 139                 reporter->r_member(fix_mode(ret, mode), pos, type, mem);
 140
 141         return ret;
 142 }
 143
 144 static void report_implicit(usage_t mode, struct position *pos, struct symbol *type)
 145 {
 146         if (type->type != SYM_STRUCT && type->type != SYM_UNION)
 147                 return;
 148
 149         if (!reporter->r_member)
 150                 return;
 151
 152         if (type->ident != NULL)
 153                 reporter->r_member(mode, pos, type, NULL);
 154
 155         DO_LIST(type->symbol_list, mem,
 156                 report_implicit(mode, pos, base_type(mem)));
 157 }
 158
 159 static inline struct symbol *expr_symbol(struct expression *expr)
 160 {
 161         struct symbol *sym = expr->symbol;
 162
 163         if (!sym) {
 164                 sym = lookup_symbol(expr->symbol_name, NS_SYMBOL);
 165
 166                 if (!sym) {
 167                         sym = alloc_symbol(expr->pos, SYM_BAD);
 168                         bind_symbol(sym, expr->symbol_name, NS_SYMBOL);
 169                         sym->ctype.modifiers = MOD_EXTERN;
 170                 }
 171         }
 172
 173         if (!sym->ctype.base_type)
 174                 sym->ctype.base_type = &bad_ctype;
 175
 176         return sym;
 177 }
 178
 179 static struct symbol *report_symbol(usage_t mode, struct expression *expr)
 180 {
 181         struct symbol *sym = expr_symbol(expr);
 182         struct symbol *ret = base_type(sym);
 183
 184         if (0 && ret->type == SYM_ENUM)
 185                 return report_member(mode, &expr->pos, ret, expr->symbol);
 186
 187         if (reporter->r_symbol)
 188                 reporter->r_symbol(fix_mode(ret, mode), &expr->pos, sym);
 189
 190         return ret;
 191 }
 192
 193 static inline struct ident *mk_name(struct ident *root, struct ident *node)
 194 {
 195         char name[256];
 196
 197         snprintf(name, sizeof(name), "%.*s:%.*s",
 198                         root ? root->len : 0, root ? root->name : "",
 199                         node ? node->len : 0, node ? node->name : "");
 200
 201         return built_in_ident(name);
 202 }
 203
 204 static void examine_sym_node(struct symbol *node, struct ident *root)
 205 {
 206         struct symbol *base;
 207         struct ident *name;
 208
 209         if (node->examined)
 210                 return;
 211
 212         node->examined = 1;
 213         name = node->ident;
 214
 215         while ((base = node->ctype.base_type) != NULL)
 216                 switch (base->type) {
 217                 case SYM_TYPEOF:
 218                         node->ctype.base_type =
 219                                 do_expression(U_VOID, base->initializer);
 220                         break;
 221
 222                 case SYM_ARRAY:
 223                         do_expression(U_R_VAL, base->array_size);
 224                 case SYM_PTR: case SYM_FN:
 225                         node = base;
 226                         break;
 227
 228                 case SYM_STRUCT: case SYM_UNION: //case SYM_ENUM:
 229                         if (base->evaluated)
 230                                 return;
 231                         if (!base->symbol_list)
 232                                 return;
 233                         base->evaluated = 1;
 234
 235                         if (!base->ident && name)
 236                                 base->ident = mk_name(root, name);
 237                         if (base->ident && reporter->r_symdef)
 238                                 reporter->r_symdef(base);
 239                         DO_LIST(base->symbol_list, mem,
 240                                 examine_sym_node(mem, base->ident ?: root));
 241                 default:
 242                         return;
 243                 }
 244 }
 245
 246 static struct symbol *base_type(struct symbol *sym)
 247 {
 248         if (!sym)
 249                 return &bad_ctype;
 250
 251         if (sym->type == SYM_NODE)
 252                 examine_sym_node(sym, NULL);
 253
 254         return sym->ctype.base_type     // builtin_fn_type
 255                 ?: &bad_ctype;
 256 }
 257
 258 static struct symbol *__lookup_member(struct symbol *type, struct ident *name, int *p_addr)
 259 {
 260         struct symbol *node;
 261         int addr = 0;
 262
 263         FOR_EACH_PTR(type->symbol_list, node)
 264                 if (!name) {
 265                         if (addr == *p_addr)
 266                                 return node;
 267                 }
 268                 else if (node->ident == NULL) {
 269                         node = __lookup_member(node->ctype.base_type, name, NULL);
 270                         if (node)
 271                                 goto found;
 272                 }
 273                 else if (node->ident == name) {
 274 found:
 275                         if (p_addr)
 276                                 *p_addr = addr;
 277                         return node;
 278                 }
 279                 addr++;
 280         END_FOR_EACH_PTR(node);
 281
 282         return NULL;
 283 }
 284
 285 static struct symbol *lookup_member(struct symbol *type, struct ident *name, int *addr)
 286 {
 287         return __lookup_member(type, name, addr)
 288                 ?: no_member(name);
 289 }
 290
 291 static struct expression *peek_preop(struct expression *expr, int op)
 292 {
 293         do {
 294                 if (expr->type != EXPR_PREOP)
 295                         break;
 296                 if (expr->op == op)
 297                         return expr->unop;
 298                 if (expr->op == '(')
 299                         expr = expr->unop;
 300                 else
 301                         break;
 302         } while (expr);
 303
 304         return NULL;
 305 }
 306
 307 static struct symbol *do_expression(usage_t mode, struct expression *expr)
 308 {
 309         struct symbol *ret = &int_ctype;
 310
 311 again:
 312         if (expr) switch (expr->type) {
 313         default:
 314                 warning(expr->pos, "bad expr->type: %d", expr->type);
 315
 316         case EXPR_TYPE:         // [struct T]; Why ???
 317         case EXPR_VALUE:
 318         case EXPR_FVALUE:
 319
 320         break; case EXPR_LABEL:
 321                 ret = &label_ctype;
 322
 323         break; case EXPR_STRING:
 324                 ret = &string_ctype;
 325
 326         break; case EXPR_STATEMENT:
 327                 ret = do_statement(mode, expr->statement);
 328
 329         break; case EXPR_SIZEOF: case EXPR_ALIGNOF: case EXPR_PTRSIZEOF:
 330                 do_expression(U_VOID, expr->cast_expression);
 331
 332         break; case EXPR_COMMA:
 333                 do_expression(U_VOID, expr->left);
 334                 ret = do_expression(mode, expr->right);
 335
 336         break; case EXPR_CAST: case EXPR_FORCE_CAST: //case EXPR_IMPLIED_CAST:
 337                 ret = base_type(expr->cast_type);
 338                 do_initializer(ret, expr->cast_expression);
 339
 340         break; case EXPR_COMPARE: case EXPR_LOGICAL:
 341                 mode = u_rval(mode);
 342                 do_expression(mode, expr->left);
 343                 do_expression(mode, expr->right);
 344
 345         break; case EXPR_CONDITIONAL: //case EXPR_SELECT:
 346                 do_expression(expr->cond_true
 347                                         ? U_R_VAL : U_R_VAL | mode,
 348                                 expr->conditional);
 349                 ret = do_expression(mode, expr->cond_true);
 350                 ret = do_expression(mode, expr->cond_false);
 351
 352         break; case EXPR_CALL:
 353                 ret = do_expression(U_R_PTR, expr->fn);
 354                 if (is_ptr(ret))
 355                         ret = ret->ctype.base_type;
 356                 DO_2_LIST(ret->arguments, expr->args, arg, val,
 357                         do_expression(u_lval(base_type(arg)), val));
 358                 ret = ret->type == SYM_FN ? base_type(ret)
 359                         : &bad_ctype;
 360
 361         break; case EXPR_ASSIGNMENT:
 362                 mode |= U_W_VAL | U_R_VAL;
 363                 if (expr->op == '=')
 364                         mode &= ~U_R_VAL;
 365                 ret = do_expression(mode, expr->left);
 366                 report_implicit(mode, &expr->pos, ret);
 367                 mode = expr->op == '='
 368                         ? u_lval(ret) : U_R_VAL;
 369                 do_expression(mode, expr->right);
 370
 371         break; case EXPR_BINOP: {
 372                 struct symbol *l, *r;
 373                 mode |= u_rval(mode);
 374                 l = do_expression(mode, expr->left);
 375                 r = do_expression(mode, expr->right);
 376                 if (expr->op != '+' && expr->op != '-')
 377                         ;
 378                 else if (!is_ptr_type(r))
 379                         ret = l;
 380                 else if (!is_ptr_type(l))
 381                         ret = r;
 382         }
 383
 384         break; case EXPR_PREOP: case EXPR_POSTOP: {
 385                 struct expression *unop = expr->unop;
 386
 387                 switch (expr->op) {
 388                 case SPECIAL_INCREMENT:
 389                 case SPECIAL_DECREMENT:
 390                         mode |= U_W_VAL | U_R_VAL;
 391                 default:
 392                         mode |= u_rval(mode);
 393                 case '(':
 394                         ret = do_expression(mode, unop);
 395
 396                 break; case '&':
 397                         if ((expr = peek_preop(unop, '*')))
 398                                 goto again;
 399                         ret = alloc_symbol(unop->pos, SYM_PTR);
 400                         ret->ctype.base_type =
 401                                 do_expression(u_addr(mode), unop);
 402
 403                 break; case '*':
 404                         if ((expr = peek_preop(unop, '&')))
 405                                 goto again;
 406                         if (mode & (U_MASK << U_SHIFT))
 407                                 mode |= U_R_VAL;
 408                         mode <<= U_SHIFT;
 409                         if (mode & (U_R_AOF << U_SHIFT))
 410                                 mode |= U_R_VAL;
 411                         if (mode & (U_W_VAL << U_SHIFT))
 412                                 mode |= U_W_AOF;
 413                         ret = do_expression(mode, unop);
 414                         ret = is_ptr(ret) ? base_type(ret)
 415                                 : &bad_ctype;
 416                 }
 417         }
 418
 419         break; case EXPR_DEREF: {
 420                 struct symbol *p_type;
 421                 usage_t p_mode;
 422
 423                 p_mode = mode & U_SELF;
 424                 if (!(mode & U_MASK) && (mode & (U_MASK << U_SHIFT)))
 425                         p_mode = U_R_VAL;
 426                 p_type = do_expression(p_mode, expr->deref);
 427
 428                 ret = report_member(mode, &expr->pos, p_type,
 429                         lookup_member(p_type, expr->member, NULL));
 430         }
 431
 432         break; case EXPR_OFFSETOF: {
 433                 struct symbol *in = base_type(expr->in);
 434
 435                 do {
 436                         if (expr->op == '.') {
 437                                 in = report_member(U_VOID, &expr->pos, in,
 438                                         lookup_member(in, expr->ident, NULL));
 439                         } else {
 440                                 do_expression(U_R_VAL, expr->index);
 441                                 in = in->ctype.base_type;
 442                         }
 443                 } while ((expr = expr->down));
 444         }
 445
 446         break; case EXPR_SYMBOL:
 447                 ret = report_symbol(mode, expr);
 448         }
 449
 450         return ret;
 451 }
 452
 453 static void do_asm_xputs(usage_t mode, struct expression_list *xputs)
 454 {
 455         int nr = 0;
 456
 457         DO_LIST(xputs, expr,
 458                 if (++nr % 3 == 0)
 459                         do_expression(U_W_AOF | mode, expr));
 460 }
 461
 462 static struct symbol *do_statement(usage_t mode, struct statement *stmt)
 463 {
 464         struct symbol *ret = &void_ctype;
 465
 466         if (stmt) switch (stmt->type) {
 467         default:
 468                 warning(stmt->pos, "bad stmt->type: %d", stmt->type);
 469
 470         case STMT_NONE:
 471         case STMT_RANGE:
 472         case STMT_CONTEXT:
 473
 474         break; case STMT_DECLARATION:
 475                 do_sym_list(stmt->declaration);
 476
 477         break; case STMT_EXPRESSION:
 478                 ret = do_expression(mode, stmt->expression);
 479
 480         break; case STMT_RETURN:
 481                 do_expression(u_lval(return_type), stmt->expression);
 482
 483         break; case STMT_ASM:
 484                 do_expression(U_R_VAL, stmt->asm_string);
 485                 do_asm_xputs(U_W_VAL, stmt->asm_outputs);
 486                 do_asm_xputs(U_R_VAL, stmt->asm_inputs);
 487
 488         break; case STMT_COMPOUND: {
 489                 int count;
 490
 491                 count = statement_list_size(stmt->stmts);
 492                 DO_LIST(stmt->stmts, st,
 493                         ret = do_statement(--count ? U_VOID : mode, st));
 494         }
 495
 496         break; case STMT_ITERATOR:
 497                 do_sym_list(stmt->iterator_syms);
 498                 do_statement(U_VOID, stmt->iterator_pre_statement);
 499                 do_expression(U_R_VAL, stmt->iterator_pre_condition);
 500                 do_statement(U_VOID, stmt->iterator_post_statement);
 501                 do_statement(U_VOID, stmt->iterator_statement);
 502                 do_expression(U_R_VAL, stmt->iterator_post_condition);
 503
 504         break; case STMT_IF:
 505                 do_expression(U_R_VAL, stmt->if_conditional);
 506                 do_statement(U_VOID, stmt->if_true);
 507                 do_statement(U_VOID, stmt->if_false);
 508
 509         break; case STMT_SWITCH:
 510                 do_expression(U_R_VAL, stmt->switch_expression);
 511                 do_statement(U_VOID, stmt->switch_statement);
 512
 513         break; case STMT_CASE:
 514                 do_expression(U_R_VAL, stmt->case_expression);
 515                 do_expression(U_R_VAL, stmt->case_to);
 516                 do_statement(U_VOID, stmt->case_statement);
 517
 518         break; case STMT_GOTO:
 519                 do_expression(U_R_PTR, stmt->goto_expression);
 520
 521         break; case STMT_LABEL:
 522                 do_statement(mode, stmt->label_statement);
 523
 524         }
 525
 526         return ret;
 527 }
 528
 529 static struct symbol *do_initializer(struct symbol *type, struct expression *expr)
 530 {
 531         struct symbol *m_type;
 532         struct expression *m_expr;
 533         int m_addr;
 534
 535         if (expr) switch (expr->type) {
 536         default:
 537                 do_expression(u_lval(type), expr);
 538
 539         break; case EXPR_INDEX:
 540                 do_initializer(base_type(type), expr->idx_expression);
 541
 542         break; case EXPR_INITIALIZER:
 543                 m_addr = 0;
 544                 FOR_EACH_PTR(expr->expr_list, m_expr) {
 545                         if (type->type == SYM_ARRAY) {
 546                                 m_type = base_type(type);
 547                                 if (m_expr->type == EXPR_INDEX)
 548                                         m_expr = m_expr->idx_expression;
 549                         } else {
 550                                 int *m_atop = &m_addr;
 551
 552                                 m_type = type;
 553                                 while (m_expr->type == EXPR_IDENTIFIER) {
 554                                         m_type = report_member(U_W_VAL, &m_expr->pos, m_type,
 555                                                         lookup_member(m_type, m_expr->expr_ident, m_atop));
 556                                         m_expr = m_expr->ident_expression;
 557                                         m_atop = NULL;
 558                                 }
 559
 560                                 if (m_atop) {
 561                                         m_type = report_member(U_W_VAL, &m_expr->pos, m_type,
 562                                                         lookup_member(m_type, NULL, m_atop));
 563                                 }
 564
 565                                 if (m_expr->type != EXPR_INITIALIZER)
 566                                         report_implicit(U_W_VAL, &m_expr->pos, m_type);
 567                         }
 568                         do_initializer(m_type, m_expr);
 569                         m_addr++;
 570                 } END_FOR_EACH_PTR(m_expr);
 571         }
 572
 573         return type;
 574 }
 575
 576 static inline struct symbol *do_symbol(struct symbol *sym)
 577 {
 578         struct symbol *type;
 579
 580         type = base_type(sym);
 581
 582         if (reporter->r_symdef)
 583                 reporter->r_symdef(sym);
 584
 585         switch (type->type) {
 586         default:
 587                 if (!sym->initializer)
 588                         break;
 589                 if (reporter->r_symbol)
 590                         reporter->r_symbol(U_W_VAL, &sym->pos, sym);
 591                 do_initializer(type, sym->initializer);
 592
 593         break; case SYM_FN:
 594                 do_sym_list(type->arguments);
 595                 return_type = base_type(type);
 596                 do_statement(U_VOID, sym->ctype.modifiers & MOD_INLINE
 597                                         ? type->inline_stmt
 598                                         : type->stmt);
 599         }
 600
 601         return type;
 602 }
 603
 604 static void do_sym_list(struct symbol_list *list)
 605 {
 606         DO_LIST(list, sym, do_symbol(sym));
 607 }
 608
 609 void dissect(struct symbol_list *list, struct reporter *rep)
 610 {
 611         reporter = rep;
 612         do_sym_list(list);
 613 }