1 /* 2 * This file is part of ltrace. 3 * Copyright (C) 2011,2012,2013 Petr Machata, Red Hat Inc. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation; either version 2 of the 8 * License, or (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 18 * 02110-1301 USA 19 */ 20 21 #include <string.h> 22 #include <assert.h> 23 #include <errno.h> 24 #include <stdlib.h> 25 26 #include "expr.h" 27 28 static void 29 expr_init_common(struct expr_node *node, enum expr_node_kind kind) 30 { 31 node->kind = kind; 32 node->lhs = NULL; 33 node->own_lhs = 0; 34 memset(&node->u, 0, sizeof(node->u)); 35 } 36 37 void 38 expr_init_self(struct expr_node *node) 39 { 40 expr_init_common(node, EXPR_OP_SELF); 41 } 42 43 void 44 expr_init_named(struct expr_node *node, 45 const char *name, int own_name) 46 { 47 expr_init_common(node, EXPR_OP_NAMED); 48 node->u.name.s = name; 49 node->u.name.own = own_name; 50 } 51 52 void 53 expr_init_argno(struct expr_node *node, size_t num) 54 { 55 expr_init_common(node, EXPR_OP_ARGNO); 56 node->u.num = num; 57 } 58 59 void 60 expr_init_const(struct expr_node *node, struct value *val) 61 { 62 expr_init_common(node, EXPR_OP_CONST); 63 node->u.value = *val; 64 } 65 66 void 67 expr_init_const_word(struct expr_node *node, long l, 68 struct arg_type_info *type, int own_type) 69 { 70 struct value val; 71 value_init_detached(&val, NULL, type, own_type); 72 value_set_word(&val, l); 73 expr_init_const(node, &val); 74 } 75 76 void 77 expr_init_index(struct expr_node *node, 78 struct expr_node *lhs, int own_lhs, 79 struct expr_node *rhs, int own_rhs) 80 { 81 expr_init_common(node, EXPR_OP_INDEX); 82 node->lhs = lhs; 83 node->own_lhs = own_lhs; 84 node->u.node.n = rhs; 85 node->u.node.own = own_rhs; 86 } 87 88 void 89 expr_init_up(struct expr_node *node, struct expr_node *lhs, int own_lhs) 90 { 91 assert(lhs != NULL); 92 expr_init_common(node, EXPR_OP_UP); 93 node->lhs = lhs; 94 node->own_lhs = own_lhs; 95 } 96 97 void 98 expr_init_cb1(struct expr_node *node, 99 int (*cb)(struct value *ret_value, struct value *value, 100 struct value_dict *arguments, void *data), 101 struct expr_node *lhs, int own_lhs, void *data) 102 { 103 expr_init_common(node, EXPR_OP_CALL1); 104 node->lhs = lhs; 105 node->own_lhs = own_lhs; 106 node->u.call.u.cb1 = cb; 107 node->u.call.data = data; 108 } 109 110 void 111 expr_init_cb2(struct expr_node *node, 112 int (*cb)(struct value *ret_value, 113 struct value *lhs, struct value *rhs, 114 struct value_dict *arguments, void *data), 115 struct expr_node *lhs, int own_lhs, 116 struct expr_node *rhs, int own_rhs, void *data) 117 { 118 expr_init_common(node, EXPR_OP_CALL2); 119 node->lhs = lhs; 120 node->own_lhs = own_lhs; 121 node->u.call.rhs = rhs; 122 node->u.call.own_rhs = own_rhs; 123 node->u.call.u.cb2 = cb; 124 node->u.call.data = data; 125 } 126 127 static void 128 release_expr(struct expr_node *node, int own) 129 { 130 if (own) { 131 expr_destroy(node); 132 free(node); 133 } 134 } 135 136 void 137 expr_destroy(struct expr_node *node) 138 { 139 if (node == NULL) 140 return; 141 142 switch (node->kind) { 143 case EXPR_OP_ARGNO: 144 case EXPR_OP_SELF: 145 return; 146 147 case EXPR_OP_CONST: 148 value_destroy(&node->u.value); 149 return; 150 151 case EXPR_OP_NAMED: 152 if (node->u.name.own) 153 free((char *)node->u.name.s); 154 return; 155 156 case EXPR_OP_INDEX: 157 release_expr(node->lhs, node->own_lhs); 158 release_expr(node->u.node.n, node->u.node.own); 159 return; 160 161 case EXPR_OP_CALL2: 162 release_expr(node->u.call.rhs, node->u.call.own_rhs); 163 /* Fall through. */ 164 case EXPR_OP_UP: 165 case EXPR_OP_CALL1: 166 release_expr(node->lhs, node->own_lhs); 167 return; 168 } 169 170 assert(!"Invalid value of node kind"); 171 abort(); 172 } 173 174 static int 175 expr_alloc_and_clone(struct expr_node **retpp, struct expr_node *node, int own) 176 { 177 *retpp = node; 178 if (own) { 179 *retpp = malloc(sizeof **retpp); 180 if (*retpp == NULL || expr_clone(*retpp, node) < 0) { 181 free(*retpp); 182 return -1; 183 } 184 } 185 return 0; 186 } 187 188 int 189 expr_clone(struct expr_node *retp, const struct expr_node *node) 190 { 191 *retp = *node; 192 193 switch (node->kind) { 194 struct expr_node *nlhs; 195 struct expr_node *nrhs; 196 197 case EXPR_OP_ARGNO: 198 case EXPR_OP_SELF: 199 return 0; 200 201 case EXPR_OP_CONST: 202 return value_clone(&retp->u.value, &node->u.value); 203 204 case EXPR_OP_NAMED: 205 if (node->u.name.own 206 && (retp->u.name.s = strdup(node->u.name.s)) == NULL) 207 return -1; 208 return 0; 209 210 case EXPR_OP_INDEX: 211 if (expr_alloc_and_clone(&nlhs, node->lhs, node->own_lhs) < 0) 212 return -1; 213 214 if (expr_alloc_and_clone(&nrhs, node->u.node.n, 215 node->u.node.own) < 0) { 216 if (nlhs != node->lhs) { 217 expr_destroy(nlhs); 218 free(nlhs); 219 } 220 return -1; 221 } 222 223 retp->lhs = nlhs; 224 retp->u.node.n = nrhs; 225 return 0; 226 227 case EXPR_OP_CALL2: 228 if (expr_alloc_and_clone(&nrhs, node->u.call.rhs, 229 node->u.call.own_rhs) < 0) 230 return -1; 231 retp->u.call.rhs = nrhs; 232 /* Fall through. */ 233 234 case EXPR_OP_UP: 235 case EXPR_OP_CALL1: 236 if (expr_alloc_and_clone(&nlhs, node->lhs, node->own_lhs) < 0) { 237 if (node->kind == EXPR_OP_CALL2 238 && node->u.call.own_rhs) { 239 expr_destroy(nrhs); 240 free(nrhs); 241 return -1; 242 } 243 } 244 245 retp->lhs = nlhs; 246 return 0; 247 } 248 249 assert(!"Invalid value of node kind"); 250 abort(); 251 } 252 253 int 254 expr_is_compile_constant(struct expr_node *node) 255 { 256 return node->kind == EXPR_OP_CONST; 257 } 258 259 static int 260 eval_up(struct expr_node *node, struct value *context, 261 struct value_dict *arguments, struct value *ret_value) 262 { 263 if (expr_eval(node->lhs, context, arguments, ret_value) < 0) 264 return -1; 265 struct value *parent = value_get_parental_struct(ret_value); 266 if (parent == NULL) { 267 value_destroy(ret_value); 268 return -1; 269 } 270 *ret_value = *parent; 271 return 0; 272 } 273 274 static int 275 eval_cb1(struct expr_node *node, struct value *context, 276 struct value_dict *arguments, struct value *ret_value) 277 { 278 struct value val; 279 if (expr_eval(node->lhs, context, arguments, &val) < 0) 280 return -1; 281 282 int ret = 0; 283 if (node->u.call.u.cb1(ret_value, &val, arguments, 284 node->u.call.data) < 0) 285 ret = -1; 286 287 /* N.B. the callback must return its own value, or somehow 288 * clone the incoming argument. */ 289 value_destroy(&val); 290 return ret; 291 } 292 293 static int 294 eval_cb2(struct expr_node *node, struct value *context, 295 struct value_dict *arguments, struct value *ret_value) 296 { 297 struct value lhs; 298 if (expr_eval(node->lhs, context, arguments, &lhs) < 0) 299 return -1; 300 301 struct value rhs; 302 if (expr_eval(node->u.call.rhs, context, arguments, &rhs) < 0) { 303 value_destroy(&lhs); 304 return -1; 305 } 306 307 int ret = 0; 308 if (node->u.call.u.cb2(ret_value, &lhs, &rhs, arguments, 309 node->u.call.data) < 0) 310 ret = -1; 311 312 /* N.B. the callback must return its own value, or somehow 313 * clone the incoming argument. */ 314 value_destroy(&lhs); 315 value_destroy(&rhs); 316 return ret; 317 } 318 319 int 320 eval_index(struct expr_node *node, struct value *context, 321 struct value_dict *arguments, struct value *ret_value) 322 { 323 struct value lhs; 324 if (expr_eval(node->lhs, context, arguments, &lhs) < 0) 325 return -1; 326 327 long l; 328 if (expr_eval_word(node->u.node.n, context, arguments, &l) < 0) { 329 fail: 330 value_destroy(&lhs); 331 return -1; 332 } 333 334 if (value_init_element(ret_value, &lhs, (size_t)l) < 0) 335 goto fail; 336 return 0; 337 } 338 339 int 340 expr_eval(struct expr_node *node, struct value *context, 341 struct value_dict *arguments, struct value *ret_value) 342 { 343 switch (node->kind) { 344 struct value *valp; 345 case EXPR_OP_ARGNO: 346 valp = val_dict_get_num(arguments, node->u.num); 347 if (valp == NULL) 348 return -1; 349 *ret_value = *valp; 350 return 0; 351 352 case EXPR_OP_NAMED: 353 valp = val_dict_get_name(arguments, node->u.name.s); 354 if (valp == NULL) 355 return -1; 356 *ret_value = *valp; 357 return 0; 358 359 case EXPR_OP_SELF: 360 *ret_value = *context; 361 return 0; 362 363 case EXPR_OP_CONST: 364 *ret_value = node->u.value; 365 return 0; 366 367 case EXPR_OP_INDEX: 368 return eval_index(node, context, arguments, ret_value); 369 370 case EXPR_OP_UP: 371 return eval_up(node, context, arguments, ret_value); 372 373 case EXPR_OP_CALL1: 374 return eval_cb1(node, context, arguments, ret_value); 375 376 case EXPR_OP_CALL2: 377 return eval_cb2(node, context, arguments, ret_value); 378 } 379 380 assert(!"Unknown node kind."); 381 abort(); 382 } 383 384 int 385 expr_eval_word(struct expr_node *node, struct value *context, 386 struct value_dict *arguments, long *ret_value) 387 { 388 struct value val; 389 if (expr_eval(node, context, arguments, &val) < 0) 390 return -1; 391 int ret = 0; 392 if (value_extract_word(&val, ret_value, arguments) < 0) 393 ret = -1; 394 value_destroy(&val); 395 return ret; 396 } 397 398 int 399 expr_eval_constant(struct expr_node *node, long *valuep) 400 { 401 assert(expr_is_compile_constant(node)); 402 return expr_eval_word(node, NULL, NULL, valuep); 403 } 404 405 struct expr_node * 406 expr_self(void) 407 { 408 static struct expr_node *nodep = NULL; 409 if (nodep == NULL) { 410 static struct expr_node node; 411 expr_init_self(&node); 412 nodep = &node; 413 } 414 return nodep; 415 } 416
