1 /* Functions for manipulating expressions designed to be executed on the agent 2 Copyright (C) 1998-2000, 2007-2012 Free Software Foundation, Inc. 3 4 This file is part of GDB. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19 /* Despite what the above comment says about this file being part of 20 GDB, we would like to keep these functions free of GDB 21 dependencies, since we want to be able to use them in contexts 22 outside of GDB (test suites, the stub, etc.) */ 23 24 #include "defs.h" 25 #include "ax.h" 26 27 #include "value.h" 28 #include "gdb_string.h" 29 30 #include "user-regs.h" 31 32 static void grow_expr (struct agent_expr *x, int n); 33 34 static void append_const (struct agent_expr *x, LONGEST val, int n); 35 36 static LONGEST read_const (struct agent_expr *x, int o, int n); 37 38 static void generic_ext (struct agent_expr *x, enum agent_op op, int n); 39 40 /* Functions for building expressions. */ 41 42 /* Allocate a new, empty agent expression. */ 43 struct agent_expr * 44 new_agent_expr (struct gdbarch *gdbarch, CORE_ADDR scope) 45 { 46 struct agent_expr *x = xmalloc (sizeof (*x)); 47 48 x->len = 0; 49 x->size = 1; /* Change this to a larger value once 50 reallocation code is tested. */ 51 x->buf = xmalloc (x->size); 52 53 x->gdbarch = gdbarch; 54 x->scope = scope; 55 56 /* Bit vector for registers used. */ 57 x->reg_mask_len = 1; 58 x->reg_mask = xmalloc (x->reg_mask_len * sizeof (x->reg_mask[0])); 59 memset (x->reg_mask, 0, x->reg_mask_len * sizeof (x->reg_mask[0])); 60 61 return x; 62 } 63 64 /* Free a agent expression. */ 65 void 66 free_agent_expr (struct agent_expr *x) 67 { 68 xfree (x->buf); 69 xfree (x->reg_mask); 70 xfree (x); 71 } 72 73 static void 74 do_free_agent_expr_cleanup (void *x) 75 { 76 free_agent_expr (x); 77 } 78 79 struct cleanup * 80 make_cleanup_free_agent_expr (struct agent_expr *x) 81 { 82 return make_cleanup (do_free_agent_expr_cleanup, x); 83 } 84 85 86 /* Make sure that X has room for at least N more bytes. This doesn't 87 affect the length, just the allocated size. */ 88 static void 89 grow_expr (struct agent_expr *x, int n) 90 { 91 if (x->len + n > x->size) 92 { 93 x->size *= 2; 94 if (x->size < x->len + n) 95 x->size = x->len + n + 10; 96 x->buf = xrealloc (x->buf, x->size); 97 } 98 } 99 100 101 /* Append the low N bytes of VAL as an N-byte integer to the 102 expression X, in big-endian order. */ 103 static void 104 append_const (struct agent_expr *x, LONGEST val, int n) 105 { 106 int i; 107 108 grow_expr (x, n); 109 for (i = n - 1; i >= 0; i--) 110 { 111 x->buf[x->len + i] = val & 0xff; 112 val >>= 8; 113 } 114 x->len += n; 115 } 116 117 118 /* Extract an N-byte big-endian unsigned integer from expression X at 119 offset O. */ 120 static LONGEST 121 read_const (struct agent_expr *x, int o, int n) 122 { 123 int i; 124 LONGEST accum = 0; 125 126 /* Make sure we're not reading off the end of the expression. */ 127 if (o + n > x->len) 128 error (_("GDB bug: ax-general.c (read_const): incomplete constant")); 129 130 for (i = 0; i < n; i++) 131 accum = (accum << 8) | x->buf[o + i]; 132 133 return accum; 134 } 135 136 137 /* Append a simple operator OP to EXPR. */ 138 void 139 ax_simple (struct agent_expr *x, enum agent_op op) 140 { 141 grow_expr (x, 1); 142 x->buf[x->len++] = op; 143 } 144 145 /* Append a pick operator to EXPR. DEPTH is the stack item to pick, 146 with 0 being top of stack. */ 147 148 void 149 ax_pick (struct agent_expr *x, int depth) 150 { 151 if (depth < 0 || depth > 255) 152 error (_("GDB bug: ax-general.c (ax_pick): stack depth out of range")); 153 ax_simple (x, aop_pick); 154 append_const (x, 1, depth); 155 } 156 157 158 /* Append a sign-extension or zero-extension instruction to EXPR, to 159 extend an N-bit value. */ 160 static void 161 generic_ext (struct agent_expr *x, enum agent_op op, int n) 162 { 163 /* N must fit in a byte. */ 164 if (n < 0 || n > 255) 165 error (_("GDB bug: ax-general.c (generic_ext): bit count out of range")); 166 /* That had better be enough range. */ 167 if (sizeof (LONGEST) * 8 > 255) 168 error (_("GDB bug: ax-general.c (generic_ext): " 169 "opcode has inadequate range")); 170 171 grow_expr (x, 2); 172 x->buf[x->len++] = op; 173 x->buf[x->len++] = n; 174 } 175 176 177 /* Append a sign-extension instruction to EXPR, to extend an N-bit value. */ 178 void 179 ax_ext (struct agent_expr *x, int n) 180 { 181 generic_ext (x, aop_ext, n); 182 } 183 184 185 /* Append a zero-extension instruction to EXPR, to extend an N-bit value. */ 186 void 187 ax_zero_ext (struct agent_expr *x, int n) 188 { 189 generic_ext (x, aop_zero_ext, n); 190 } 191 192 193 /* Append a trace_quick instruction to EXPR, to record N bytes. */ 194 void 195 ax_trace_quick (struct agent_expr *x, int n) 196 { 197 /* N must fit in a byte. */ 198 if (n < 0 || n > 255) 199 error (_("GDB bug: ax-general.c (ax_trace_quick): " 200 "size out of range for trace_quick")); 201 202 grow_expr (x, 2); 203 x->buf[x->len++] = aop_trace_quick; 204 x->buf[x->len++] = n; 205 } 206 207 208 /* Append a goto op to EXPR. OP is the actual op (must be aop_goto or 209 aop_if_goto). We assume we don't know the target offset yet, 210 because it's probably a forward branch, so we leave space in EXPR 211 for the target, and return the offset in EXPR of that space, so we 212 can backpatch it once we do know the target offset. Use ax_label 213 to do the backpatching. */ 214 int 215 ax_goto (struct agent_expr *x, enum agent_op op) 216 { 217 grow_expr (x, 3); 218 x->buf[x->len + 0] = op; 219 x->buf[x->len + 1] = 0xff; 220 x->buf[x->len + 2] = 0xff; 221 x->len += 3; 222 return x->len - 2; 223 } 224 225 /* Suppose a given call to ax_goto returns some value PATCH. When you 226 know the offset TARGET that goto should jump to, call 227 ax_label (EXPR, PATCH, TARGET) 228 to patch TARGET into the ax_goto instruction. */ 229 void 230 ax_label (struct agent_expr *x, int patch, int target) 231 { 232 /* Make sure the value is in range. Don't accept 0xffff as an 233 offset; that's our magic sentinel value for unpatched branches. */ 234 if (target < 0 || target >= 0xffff) 235 error (_("GDB bug: ax-general.c (ax_label): label target out of range")); 236 237 x->buf[patch] = (target >> 8) & 0xff; 238 x->buf[patch + 1] = target & 0xff; 239 } 240 241 242 /* Assemble code to push a constant on the stack. */ 243 void 244 ax_const_l (struct agent_expr *x, LONGEST l) 245 { 246 static enum agent_op ops[] 247 = 248 {aop_const8, aop_const16, aop_const32, aop_const64}; 249 int size; 250 int op; 251 252 /* How big is the number? 'op' keeps track of which opcode to use. 253 Notice that we don't really care whether the original number was 254 signed or unsigned; we always reproduce the value exactly, and 255 use the shortest representation. */ 256 for (op = 0, size = 8; size < 64; size *= 2, op++) 257 { 258 LONGEST lim = ((LONGEST) 1) << (size - 1); 259 260 if (-lim <= l && l <= lim - 1) 261 break; 262 } 263 264 /* Emit the right opcode... */ 265 ax_simple (x, ops[op]); 266 267 /* Emit the low SIZE bytes as an unsigned number. We know that 268 sign-extending this will yield l. */ 269 append_const (x, l, size / 8); 270 271 /* Now, if it was negative, and not full-sized, sign-extend it. */ 272 if (l < 0 && size < 64) 273 ax_ext (x, size); 274 } 275 276 277 void 278 ax_const_d (struct agent_expr *x, LONGEST d) 279 { 280 /* FIXME: floating-point support not present yet. */ 281 error (_("GDB bug: ax-general.c (ax_const_d): " 282 "floating point not supported yet")); 283 } 284 285 286 /* Assemble code to push the value of register number REG on the 287 stack. */ 288 void 289 ax_reg (struct agent_expr *x, int reg) 290 { 291 if (reg >= gdbarch_num_regs (x->gdbarch)) 292 { 293 /* This is a pseudo-register. */ 294 if (!gdbarch_ax_pseudo_register_push_stack_p (x->gdbarch)) 295 error (_("'%s' is a pseudo-register; " 296 "GDB cannot yet trace its contents."), 297 user_reg_map_regnum_to_name (x->gdbarch, reg)); 298 if (gdbarch_ax_pseudo_register_push_stack (x->gdbarch, x, reg)) 299 error (_("Trace '%s' failed."), 300 user_reg_map_regnum_to_name (x->gdbarch, reg)); 301 } 302 else 303 { 304 /* Make sure the register number is in range. */ 305 if (reg < 0 || reg > 0xffff) 306 error (_("GDB bug: ax-general.c (ax_reg): " 307 "register number out of range")); 308 grow_expr (x, 3); 309 x->buf[x->len] = aop_reg; 310 x->buf[x->len + 1] = (reg >> 8) & 0xff; 311 x->buf[x->len + 2] = (reg) & 0xff; 312 x->len += 3; 313 } 314 } 315 316 /* Assemble code to operate on a trace state variable. */ 317 318 void 319 ax_tsv (struct agent_expr *x, enum agent_op op, int num) 320 { 321 /* Make sure the tsv number is in range. */ 322 if (num < 0 || num > 0xffff) 323 internal_error (__FILE__, __LINE__, 324 _("ax-general.c (ax_tsv): variable " 325 "number is %d, out of range"), num); 326 327 grow_expr (x, 3); 328 x->buf[x->len] = op; 329 x->buf[x->len + 1] = (num >> 8) & 0xff; 330 x->buf[x->len + 2] = (num) & 0xff; 331 x->len += 3; 332 } 333 334 335 336 /* Functions for disassembling agent expressions, and otherwise 337 debugging the expression compiler. */ 338 339 struct aop_map aop_map[] = 340 { 341 {0, 0, 0, 0, 0} 342 #define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE) \ 343 , { # NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED } 344 #include "ax.def" 345 #undef DEFOP 346 }; 347 348 349 /* Disassemble the expression EXPR, writing to F. */ 350 void 351 ax_print (struct ui_file *f, struct agent_expr *x) 352 { 353 int i; 354 int is_float = 0; 355 356 fprintf_filtered (f, _("Scope: %s\n"), paddress (x->gdbarch, x->scope)); 357 fprintf_filtered (f, _("Reg mask:")); 358 for (i = 0; i < x->reg_mask_len; ++i) 359 fprintf_filtered (f, _(" %02x"), x->reg_mask[i]); 360 fprintf_filtered (f, _("\n")); 361 362 /* Check the size of the name array against the number of entries in 363 the enum, to catch additions that people didn't sync. */ 364 if ((sizeof (aop_map) / sizeof (aop_map[0])) 365 != aop_last) 366 error (_("GDB bug: ax-general.c (ax_print): opcode map out of sync")); 367 368 for (i = 0; i < x->len;) 369 { 370 enum agent_op op = x->buf[i]; 371 372 if (op >= (sizeof (aop_map) / sizeof (aop_map[0])) 373 || !aop_map[op].name) 374 { 375 fprintf_filtered (f, _("%3d <bad opcode %02x>\n"), i, op); 376 i++; 377 continue; 378 } 379 if (i + 1 + aop_map[op].op_size > x->len) 380 { 381 fprintf_filtered (f, _("%3d <incomplete opcode %s>\n"), 382 i, aop_map[op].name); 383 break; 384 } 385 386 fprintf_filtered (f, "%3d %s", i, aop_map[op].name); 387 if (aop_map[op].op_size > 0) 388 { 389 fputs_filtered (" ", f); 390 391 print_longest (f, 'd', 0, 392 read_const (x, i + 1, aop_map[op].op_size)); 393 } 394 fprintf_filtered (f, "\n"); 395 i += 1 + aop_map[op].op_size; 396 397 is_float = (op == aop_float); 398 } 399 } 400 401 /* Add register REG to the register mask for expression AX. */ 402 void 403 ax_reg_mask (struct agent_expr *ax, int reg) 404 { 405 if (reg >= gdbarch_num_regs (ax->gdbarch)) 406 { 407 /* This is a pseudo-register. */ 408 if (!gdbarch_ax_pseudo_register_collect_p (ax->gdbarch)) 409 error (_("'%s' is a pseudo-register; " 410 "GDB cannot yet trace its contents."), 411 user_reg_map_regnum_to_name (ax->gdbarch, reg)); 412 if (gdbarch_ax_pseudo_register_collect (ax->gdbarch, ax, reg)) 413 error (_("Trace '%s' failed."), 414 user_reg_map_regnum_to_name (ax->gdbarch, reg)); 415 } 416 else 417 { 418 int byte = reg / 8; 419 420 /* Grow the bit mask if necessary. */ 421 if (byte >= ax->reg_mask_len) 422 { 423 /* It's not appropriate to double here. This isn't a 424 string buffer. */ 425 int new_len = byte + 1; 426 unsigned char *new_reg_mask = xrealloc (ax->reg_mask, 427 new_len 428 * sizeof (ax->reg_mask[0])); 429 memset (new_reg_mask + ax->reg_mask_len, 0, 430 (new_len - ax->reg_mask_len) * sizeof (ax->reg_mask[0])); 431 ax->reg_mask_len = new_len; 432 ax->reg_mask = new_reg_mask; 433 } 434 435 ax->reg_mask[byte] |= 1 << (reg % 8); 436 } 437 } 438 439 /* Given an agent expression AX, fill in requirements and other descriptive 440 bits. */ 441 void 442 ax_reqs (struct agent_expr *ax) 443 { 444 int i; 445 int height; 446 447 /* Jump target table. targets[i] is non-zero iff we have found a 448 jump to offset i. */ 449 char *targets = (char *) alloca (ax->len * sizeof (targets[0])); 450 451 /* Instruction boundary table. boundary[i] is non-zero iff our scan 452 has reached an instruction starting at offset i. */ 453 char *boundary = (char *) alloca (ax->len * sizeof (boundary[0])); 454 455 /* Stack height record. If either targets[i] or boundary[i] is 456 non-zero, heights[i] is the height the stack should have before 457 executing the bytecode at that point. */ 458 int *heights = (int *) alloca (ax->len * sizeof (heights[0])); 459 460 /* Pointer to a description of the present op. */ 461 struct aop_map *op; 462 463 memset (targets, 0, ax->len * sizeof (targets[0])); 464 memset (boundary, 0, ax->len * sizeof (boundary[0])); 465 466 ax->max_height = ax->min_height = height = 0; 467 ax->flaw = agent_flaw_none; 468 ax->max_data_size = 0; 469 470 for (i = 0; i < ax->len; i += 1 + op->op_size) 471 { 472 if (ax->buf[i] > (sizeof (aop_map) / sizeof (aop_map[0]))) 473 { 474 ax->flaw = agent_flaw_bad_instruction; 475 return; 476 } 477 478 op = &aop_map[ax->buf[i]]; 479 480 if (!op->name) 481 { 482 ax->flaw = agent_flaw_bad_instruction; 483 return; 484 } 485 486 if (i + 1 + op->op_size > ax->len) 487 { 488 ax->flaw = agent_flaw_incomplete_instruction; 489 return; 490 } 491 492 /* If this instruction is a forward jump target, does the 493 current stack height match the stack height at the jump 494 source? */ 495 if (targets[i] && (heights[i] != height)) 496 { 497 ax->flaw = agent_flaw_height_mismatch; 498 return; 499 } 500 501 boundary[i] = 1; 502 heights[i] = height; 503 504 height -= op->consumed; 505 if (height < ax->min_height) 506 ax->min_height = height; 507 height += op->produced; 508 if (height > ax->max_height) 509 ax->max_height = height; 510 511 if (op->data_size > ax->max_data_size) 512 ax->max_data_size = op->data_size; 513 514 /* For jump instructions, check that the target is a valid 515 offset. If it is, record the fact that that location is a 516 jump target, and record the height we expect there. */ 517 if (aop_goto == op - aop_map 518 || aop_if_goto == op - aop_map) 519 { 520 int target = read_const (ax, i + 1, 2); 521 if (target < 0 || target >= ax->len) 522 { 523 ax->flaw = agent_flaw_bad_jump; 524 return; 525 } 526 527 /* Do we have any information about what the stack height 528 should be at the target? */ 529 if (targets[target] || boundary[target]) 530 { 531 if (heights[target] != height) 532 { 533 ax->flaw = agent_flaw_height_mismatch; 534 return; 535 } 536 } 537 538 /* Record the target, along with the stack height we expect. */ 539 targets[target] = 1; 540 heights[target] = height; 541 } 542 543 /* For unconditional jumps with a successor, check that the 544 successor is a target, and pick up its stack height. */ 545 if (aop_goto == op - aop_map 546 && i + 3 < ax->len) 547 { 548 if (!targets[i + 3]) 549 { 550 ax->flaw = agent_flaw_hole; 551 return; 552 } 553 554 height = heights[i + 3]; 555 } 556 557 /* For reg instructions, record the register in the bit mask. */ 558 if (aop_reg == op - aop_map) 559 { 560 int reg = read_const (ax, i + 1, 2); 561 562 ax_reg_mask (ax, reg); 563 } 564 } 565 566 /* Check that all the targets are on boundaries. */ 567 for (i = 0; i < ax->len; i++) 568 if (targets[i] && !boundary[i]) 569 { 570 ax->flaw = agent_flaw_bad_jump; 571 return; 572 } 573 574 ax->final_height = height; 575 } 576