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