expression.h

   1 #ifndef EXPRESSION_H
   2 #define EXPRESSION_H
   3 /*
   4  * sparse/expression.h
   5  *
   6  * Copyright (C) 2003 Transmeta Corp.
   7  *               2003 Linus Torvalds
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a copy
  10  * of this software and associated documentation files (the "Software"), to deal
  11  * in the Software without restriction, including without limitation the rights
  12  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  13  * copies of the Software, and to permit persons to whom the Software is
  14  * furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included in
  17  * all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  22  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  24  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  25  * THE SOFTWARE.
  26  *
  27  * Declarations and helper functions for expression parsing.
  28  */
  29
  30 #include "allocate.h"
  31 #include "lib.h"
  32 #include "symbol.h"
  33
  34 struct expression_list;
  35
  36 enum expression_type {
  37         EXPR_VALUE = 1,
  38         EXPR_STRING,
  39         EXPR_SYMBOL,
  40         EXPR_TYPE,
  41         EXPR_BINOP,
  42         EXPR_ASSIGNMENT,
  43         EXPR_LOGICAL,
  44         EXPR_DEREF,
  45         EXPR_PREOP,
  46         EXPR_POSTOP,
  47         EXPR_CAST,
  48         EXPR_FORCE_CAST,
  49         EXPR_IMPLIED_CAST,
  50         EXPR_SIZEOF,
  51         EXPR_ALIGNOF,
  52         EXPR_PTRSIZEOF,
  53         EXPR_CONDITIONAL,
  54         EXPR_SELECT,            // a "safe" conditional expression
  55         EXPR_STATEMENT,
  56         EXPR_CALL,
  57         EXPR_COMMA,
  58         EXPR_COMPARE,
  59         EXPR_LABEL,
  60         EXPR_INITIALIZER,       // initializer list
  61         EXPR_IDENTIFIER,        // identifier in initializer
  62         EXPR_INDEX,             // index in initializer
  63         EXPR_POS,               // position in initializer
  64         EXPR_FVALUE,
  65         EXPR_SLICE,
  66         EXPR_OFFSETOF,
  67 };
  68
  69 enum {
  70         Int_const_expr = 1,
  71         Float_literal = 2,
  72 }; /* for expr->flags */
  73
  74 enum {
  75         Handled = 1,
  76 }; /* for expr->flags */
  77
  78 enum {
  79         Taint_comma = 1,
  80 }; /* for expr->taint */
  81
  82 struct expression {
  83         enum expression_type type:8;
  84         unsigned flags:8;
  85         unsigned smatch_flags:16;
  86         int op;
  87         struct position pos;
  88         struct symbol *ctype;
  89         unsigned long parent;
  90         union {
  91                 // EXPR_VALUE
  92                 struct {
  93                         unsigned long long value;
  94                         unsigned taint;
  95                 };
  96
  97                 // EXPR_FVALUE
  98                 long double fvalue;
  99
 100                 // EXPR_STRING
 101                 struct {
 102                         int wide;
 103                         struct string *string;
 104                 };
 105
 106                 // EXPR_UNOP, EXPR_PREOP and EXPR_POSTOP
 107                 struct /* unop */ {
 108                         struct expression *unop;
 109                         unsigned long op_value;
 110                 };
 111
 112                 // EXPR_SYMBOL, EXPR_TYPE
 113                 struct /* symbol_arg */ {
 114                         struct symbol *symbol;
 115                         struct ident *symbol_name;
 116                 };
 117
 118                 // EXPR_STATEMENT
 119                 struct statement *statement;
 120
 121                 // EXPR_BINOP, EXPR_COMMA, EXPR_COMPARE, EXPR_LOGICAL and EXPR_ASSIGNMENT
 122                 struct /* binop_arg */ {
 123                         struct expression *left, *right;
 124                 };
 125                 // EXPR_DEREF
 126                 struct /* deref_arg */ {
 127                         struct expression *deref;
 128                         struct ident *member;
 129                         int member_offset;
 130                 };
 131                 // EXPR_SLICE
 132                 struct /* slice */ {
 133                         struct expression *base;
 134                         unsigned r_bitpos, r_nrbits;
 135                 };
 136                 // EXPR_CAST and EXPR_SIZEOF
 137                 struct /* cast_arg */ {
 138                         struct symbol *cast_type;
 139                         struct expression *cast_expression;
 140                 };
 141                 // EXPR_CONDITIONAL
 142                 // EXPR_SELECT
 143                 struct /* conditional_expr */ {
 144                         struct expression *conditional, *cond_true, *cond_false;
 145                 };
 146                 // EXPR_CALL
 147                 struct /* call_expr */ {
 148                         struct expression *fn;
 149                         struct expression_list *args;
 150                 };
 151                 // EXPR_LABEL
 152                 struct /* label_expr */ {
 153                         struct symbol *label_symbol;
 154                 };
 155                 // EXPR_INITIALIZER
 156                 struct expression_list *expr_list;
 157                 // EXPR_IDENTIFIER
 158                 struct /* ident_expr */ {
 159                         int offset;
 160                         struct ident *expr_ident;
 161                         struct symbol *field;
 162                         struct expression *ident_expression;
 163                 };
 164                 // EXPR_INDEX
 165                 struct /* index_expr */ {
 166                         unsigned int idx_from, idx_to;
 167                         struct expression *idx_expression;
 168                 };
 169                 // EXPR_POS
 170                 struct /* initpos_expr */ {
 171                         unsigned int init_offset, init_nr;
 172                         struct expression *init_expr;
 173                 };
 174                 // EXPR_OFFSETOF
 175                 struct {
 176                         struct symbol *in;
 177                         struct expression *down;
 178                         union {
 179                                 struct ident *ident;
 180                                 struct expression *index;
 181                         };
 182                 };
 183         };
 184 };
 185
 186 /* Constant expression values */
 187 int is_zero_constant(struct expression *);
 188 long long get_expression_value(struct expression *);
 189 long long const_expression_value(struct expression *);
 190 long long get_expression_value_silent(struct expression *expr);
 191
 192 /* Expression parsing */
 193 struct token *parse_expression(struct token *token, struct expression **tree);
 194 struct token *conditional_expression(struct token *token, struct expression **tree);
 195 struct token *primary_expression(struct token *token, struct expression **tree);
 196 struct token *parens_expression(struct token *token, struct expression **expr, const char *where);
 197 struct token *assignment_expression(struct token *token, struct expression **tree);
 198
 199 extern void evaluate_symbol_list(struct symbol_list *list);
 200 extern struct symbol *evaluate_statement(struct statement *stmt);
 201 extern struct symbol *evaluate_expression(struct expression *);
 202
 203 extern int expand_symbol(struct symbol *);
 204
 205 static inline struct expression *alloc_expression(struct position pos, int type)
 206 {
 207         struct expression *expr = __alloc_expression(0);
 208         expr->type = type;
 209         expr->pos = pos;
 210         return expr;
 211 }
 212
 213 static inline struct expression *alloc_const_expression(struct position pos, int value)
 214 {
 215         struct expression *expr = __alloc_expression(0);
 216         expr->type = EXPR_VALUE;
 217         expr->pos = pos;
 218         expr->value = value;
 219         expr->ctype = &int_ctype;
 220         return expr;
 221 }
 222
 223 /* Type name parsing */
 224 struct token *typename(struct token *, struct symbol **, int *);
 225
 226 static inline int lookup_type(struct token *token)
 227 {
 228         if (token->pos.type == TOKEN_IDENT) {
 229                 struct symbol *sym = lookup_symbol(token->ident, NS_SYMBOL | NS_TYPEDEF);
 230                 return sym && (sym->namespace & NS_TYPEDEF);
 231         }
 232         return 0;
 233 }
 234
 235 /* Statement parsing */
 236 struct statement *alloc_statement(struct position pos, int type);
 237 struct token *initializer(struct expression **tree, struct token *token);
 238 struct token *compound_statement(struct token *, struct statement *);
 239
 240 /* The preprocessor calls this 'constant_expression()' */
 241 #define constant_expression(token,tree) conditional_expression(token, tree)
 242
 243 /* Cast folding of constant values.. */
 244 void cast_value(struct expression *expr, struct symbol *newtype,
 245         struct expression *old, struct symbol *oldtype);
 246
 247 static inline void expr_set_parent_expr(struct expression *expr, struct expression *parent)
 248 {
 249         if (!expr)
 250                 return;
 251         expr->parent = (unsigned long)parent | 0x1UL;
 252 }
 253
 254 static inline void expr_set_parent_stmt(struct expression *expr, struct statement *parent)
 255 {
 256         if (!expr)
 257                 return;
 258         expr->parent = (unsigned long)parent;
 259 }
 260
 261 static inline struct expression *expr_get_parent_expr(struct expression *expr)
 262 {
 263         if (!expr)
 264                 return NULL;
 265         if (!(expr->parent & 0x1UL))
 266                 return NULL;
 267         return (struct expression *)(expr->parent & ~0x1UL);
 268 }
 269
 270 static inline struct statement *expr_get_parent_stmt(struct expression *expr)
 271 {
 272         if (!expr)
 273                 return NULL;
 274         if (expr->parent & 0x1UL)
 275                 return NULL;
 276         return (struct statement *)expr->parent;
 277 }
 278
 279 #endif