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