1 /* Functions for manipulating expressions designed to be executed on the agent 2 Copyright (C) 1998-2013 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 /* Append a string to the expression. Note that the string is going 335 into the bytecodes directly, not on the stack. As a precaution, 336 include both length as prefix, and terminate with a NUL. (The NUL 337 is counted in the length.) */ 338 339 void 340 ax_string (struct agent_expr *x, const char *str, int slen) 341 { 342 int i; 343 344 /* Make sure the string length is reasonable. */ 345 if (slen < 0 || slen > 0xffff) 346 internal_error (__FILE__, __LINE__, 347 _("ax-general.c (ax_string): string " 348 "length is %d, out of allowed range"), slen); 349 350 grow_expr (x, 2 + slen + 1); 351 x->buf[x->len++] = ((slen + 1) >> 8) & 0xff; 352 x->buf[x->len++] = (slen + 1) & 0xff; 353 for (i = 0; i < slen; ++i) 354 x->buf[x->len++] = str[i]; 355 x->buf[x->len++] = '\0'; 356 } 357 358 359 360 /* Functions for disassembling agent expressions, and otherwise 361 debugging the expression compiler. */ 362 363 struct aop_map aop_map[] = 364 { 365 {0, 0, 0, 0, 0} 366 #define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE) \ 367 , { # NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED } 368 #include "ax.def" 369 #undef DEFOP 370 }; 371 372 373 /* Disassemble the expression EXPR, writing to F. */ 374 void 375 ax_print (struct ui_file *f, struct agent_expr *x) 376 { 377 int i; 378 379 fprintf_filtered (f, _("Scope: %s\n"), paddress (x->gdbarch, x->scope)); 380 fprintf_filtered (f, _("Reg mask:")); 381 for (i = 0; i < x->reg_mask_len; ++i) 382 fprintf_filtered (f, _(" %02x"), x->reg_mask[i]); 383 fprintf_filtered (f, _("\n")); 384 385 /* Check the size of the name array against the number of entries in 386 the enum, to catch additions that people didn't sync. */ 387 if ((sizeof (aop_map) / sizeof (aop_map[0])) 388 != aop_last) 389 error (_("GDB bug: ax-general.c (ax_print): opcode map out of sync")); 390 391 for (i = 0; i < x->len;) 392 { 393 enum agent_op op = x->buf[i]; 394 395 if (op >= (sizeof (aop_map) / sizeof (aop_map[0])) 396 || !aop_map[op].name) 397 { 398 fprintf_filtered (f, _("%3d <bad opcode %02x>\n"), i, op); 399 i++; 400 continue; 401 } 402 if (i + 1 + aop_map[op].op_size > x->len) 403 { 404 fprintf_filtered (f, _("%3d <incomplete opcode %s>\n"), 405 i, aop_map[op].name); 406 break; 407 } 408 409 fprintf_filtered (f, "%3d %s", i, aop_map[op].name); 410 if (aop_map[op].op_size > 0) 411 { 412 fputs_filtered (" ", f); 413 414 print_longest (f, 'd', 0, 415 read_const (x, i + 1, aop_map[op].op_size)); 416 } 417 /* Handle the complicated printf arguments specially. */ 418 else if (op == aop_printf) 419 { 420 int slen, nargs; 421 422 i++; 423 nargs = x->buf[i++]; 424 slen = x->buf[i++]; 425 slen = slen * 256 + x->buf[i++]; 426 fprintf_filtered (f, _(" \"%s\", %d args"), 427 &(x->buf[i]), nargs); 428 i += slen - 1; 429 } 430 fprintf_filtered (f, "\n"); 431 i += 1 + aop_map[op].op_size; 432 } 433 } 434 435 /* Add register REG to the register mask for expression AX. */ 436 void 437 ax_reg_mask (struct agent_expr *ax, int reg) 438 { 439 if (reg >= gdbarch_num_regs (ax->gdbarch)) 440 { 441 /* This is a pseudo-register. */ 442 if (!gdbarch_ax_pseudo_register_collect_p (ax->gdbarch)) 443 error (_("'%s' is a pseudo-register; " 444 "GDB cannot yet trace its contents."), 445 user_reg_map_regnum_to_name (ax->gdbarch, reg)); 446 if (gdbarch_ax_pseudo_register_collect (ax->gdbarch, ax, reg)) 447 error (_("Trace '%s' failed."), 448 user_reg_map_regnum_to_name (ax->gdbarch, reg)); 449 } 450 else 451 { 452 int byte = reg / 8; 453 454 /* Grow the bit mask if necessary. */ 455 if (byte >= ax->reg_mask_len) 456 { 457 /* It's not appropriate to double here. This isn't a 458 string buffer. */ 459 int new_len = byte + 1; 460 unsigned char *new_reg_mask = xrealloc (ax->reg_mask, 461 new_len 462 * sizeof (ax->reg_mask[0])); 463 memset (new_reg_mask + ax->reg_mask_len, 0, 464 (new_len - ax->reg_mask_len) * sizeof (ax->reg_mask[0])); 465 ax->reg_mask_len = new_len; 466 ax->reg_mask = new_reg_mask; 467 } 468 469 ax->reg_mask[byte] |= 1 << (reg % 8); 470 } 471 } 472 473 /* Given an agent expression AX, fill in requirements and other descriptive 474 bits. */ 475 void 476 ax_reqs (struct agent_expr *ax) 477 { 478 int i; 479 int height; 480 481 /* Jump target table. targets[i] is non-zero iff we have found a 482 jump to offset i. */ 483 char *targets = (char *) alloca (ax->len * sizeof (targets[0])); 484 485 /* Instruction boundary table. boundary[i] is non-zero iff our scan 486 has reached an instruction starting at offset i. */ 487 char *boundary = (char *) alloca (ax->len * sizeof (boundary[0])); 488 489 /* Stack height record. If either targets[i] or boundary[i] is 490 non-zero, heights[i] is the height the stack should have before 491 executing the bytecode at that point. */ 492 int *heights = (int *) alloca (ax->len * sizeof (heights[0])); 493 494 /* Pointer to a description of the present op. */ 495 struct aop_map *op; 496 497 memset (targets, 0, ax->len * sizeof (targets[0])); 498 memset (boundary, 0, ax->len * sizeof (boundary[0])); 499 500 ax->max_height = ax->min_height = height = 0; 501 ax->flaw = agent_flaw_none; 502 ax->max_data_size = 0; 503 504 for (i = 0; i < ax->len; i += 1 + op->op_size) 505 { 506 if (ax->buf[i] > (sizeof (aop_map) / sizeof (aop_map[0]))) 507 { 508 ax->flaw = agent_flaw_bad_instruction; 509 return; 510 } 511 512 op = &aop_map[ax->buf[i]]; 513 514 if (!op->name) 515 { 516 ax->flaw = agent_flaw_bad_instruction; 517 return; 518 } 519 520 if (i + 1 + op->op_size > ax->len) 521 { 522 ax->flaw = agent_flaw_incomplete_instruction; 523 return; 524 } 525 526 /* If this instruction is a forward jump target, does the 527 current stack height match the stack height at the jump 528 source? */ 529 if (targets[i] && (heights[i] != height)) 530 { 531 ax->flaw = agent_flaw_height_mismatch; 532 return; 533 } 534 535 boundary[i] = 1; 536 heights[i] = height; 537 538 height -= op->consumed; 539 if (height < ax->min_height) 540 ax->min_height = height; 541 height += op->produced; 542 if (height > ax->max_height) 543 ax->max_height = height; 544 545 if (op->data_size > ax->max_data_size) 546 ax->max_data_size = op->data_size; 547 548 /* For jump instructions, check that the target is a valid 549 offset. If it is, record the fact that that location is a 550 jump target, and record the height we expect there. */ 551 if (aop_goto == op - aop_map 552 || aop_if_goto == op - aop_map) 553 { 554 int target = read_const (ax, i + 1, 2); 555 if (target < 0 || target >= ax->len) 556 { 557 ax->flaw = agent_flaw_bad_jump; 558 return; 559 } 560 561 /* Do we have any information about what the stack height 562 should be at the target? */ 563 if (targets[target] || boundary[target]) 564 { 565 if (heights[target] != height) 566 { 567 ax->flaw = agent_flaw_height_mismatch; 568 return; 569 } 570 } 571 572 /* Record the target, along with the stack height we expect. */ 573 targets[target] = 1; 574 heights[target] = height; 575 } 576 577 /* For unconditional jumps with a successor, check that the 578 successor is a target, and pick up its stack height. */ 579 if (aop_goto == op - aop_map 580 && i + 3 < ax->len) 581 { 582 if (!targets[i + 3]) 583 { 584 ax->flaw = agent_flaw_hole; 585 return; 586 } 587 588 height = heights[i + 3]; 589 } 590 591 /* For reg instructions, record the register in the bit mask. */ 592 if (aop_reg == op - aop_map) 593 { 594 int reg = read_const (ax, i + 1, 2); 595 596 ax_reg_mask (ax, reg); 597 } 598 } 599 600 /* Check that all the targets are on boundaries. */ 601 for (i = 0; i < ax->len; i++) 602 if (targets[i] && !boundary[i]) 603 { 604 ax->flaw = agent_flaw_bad_jump; 605 return; 606 } 607 608 ax->final_height = height; 609 } 610