1 /* GDB-specific functions for operating on agent expressions. 2 3 Copyright (C) 1998-2013 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 #include "defs.h" 21 #include "symtab.h" 22 #include "symfile.h" 23 #include "gdbtypes.h" 24 #include "language.h" 25 #include "value.h" 26 #include "expression.h" 27 #include "command.h" 28 #include "gdbcmd.h" 29 #include "frame.h" 30 #include "target.h" 31 #include "ax.h" 32 #include "ax-gdb.h" 33 #include "gdb_string.h" 34 #include "block.h" 35 #include "regcache.h" 36 #include "user-regs.h" 37 #include "language.h" 38 #include "dictionary.h" 39 #include "breakpoint.h" 40 #include "tracepoint.h" 41 #include "cp-support.h" 42 #include "arch-utils.h" 43 #include "cli/cli-utils.h" 44 #include "linespec.h" 45 46 #include "valprint.h" 47 #include "c-lang.h" 48 49 #include "format.h" 50 51 /* To make sense of this file, you should read doc/agentexpr.texi. 52 Then look at the types and enums in ax-gdb.h. For the code itself, 53 look at gen_expr, towards the bottom; that's the main function that 54 looks at the GDB expressions and calls everything else to generate 55 code. 56 57 I'm beginning to wonder whether it wouldn't be nicer to internally 58 generate trees, with types, and then spit out the bytecode in 59 linear form afterwards; we could generate fewer `swap', `ext', and 60 `zero_ext' bytecodes that way; it would make good constant folding 61 easier, too. But at the moment, I think we should be willing to 62 pay for the simplicity of this code with less-than-optimal bytecode 63 strings. 64 65 Remember, "GBD" stands for "Great Britain, Dammit!" So be careful. */ 66 67 68 69 /* Prototypes for local functions. */ 70 71 /* There's a standard order to the arguments of these functions: 72 union exp_element ** --- pointer into expression 73 struct agent_expr * --- agent expression buffer to generate code into 74 struct axs_value * --- describes value left on top of stack */ 75 76 static struct value *const_var_ref (struct symbol *var); 77 static struct value *const_expr (union exp_element **pc); 78 static struct value *maybe_const_expr (union exp_element **pc); 79 80 static void gen_traced_pop (struct gdbarch *, struct agent_expr *, 81 struct axs_value *); 82 83 static void gen_sign_extend (struct agent_expr *, struct type *); 84 static void gen_extend (struct agent_expr *, struct type *); 85 static void gen_fetch (struct agent_expr *, struct type *); 86 static void gen_left_shift (struct agent_expr *, int); 87 88 89 static void gen_frame_args_address (struct gdbarch *, struct agent_expr *); 90 static void gen_frame_locals_address (struct gdbarch *, struct agent_expr *); 91 static void gen_offset (struct agent_expr *ax, int offset); 92 static void gen_sym_offset (struct agent_expr *, struct symbol *); 93 static void gen_var_ref (struct gdbarch *, struct agent_expr *ax, 94 struct axs_value *value, struct symbol *var); 95 96 97 static void gen_int_literal (struct agent_expr *ax, 98 struct axs_value *value, 99 LONGEST k, struct type *type); 100 101 static void gen_usual_unary (struct expression *exp, struct agent_expr *ax, 102 struct axs_value *value); 103 static int type_wider_than (struct type *type1, struct type *type2); 104 static struct type *max_type (struct type *type1, struct type *type2); 105 static void gen_conversion (struct agent_expr *ax, 106 struct type *from, struct type *to); 107 static int is_nontrivial_conversion (struct type *from, struct type *to); 108 static void gen_usual_arithmetic (struct expression *exp, 109 struct agent_expr *ax, 110 struct axs_value *value1, 111 struct axs_value *value2); 112 static void gen_integral_promotions (struct expression *exp, 113 struct agent_expr *ax, 114 struct axs_value *value); 115 static void gen_cast (struct agent_expr *ax, 116 struct axs_value *value, struct type *type); 117 static void gen_scale (struct agent_expr *ax, 118 enum agent_op op, struct type *type); 119 static void gen_ptradd (struct agent_expr *ax, struct axs_value *value, 120 struct axs_value *value1, struct axs_value *value2); 121 static void gen_ptrsub (struct agent_expr *ax, struct axs_value *value, 122 struct axs_value *value1, struct axs_value *value2); 123 static void gen_ptrdiff (struct agent_expr *ax, struct axs_value *value, 124 struct axs_value *value1, struct axs_value *value2, 125 struct type *result_type); 126 static void gen_binop (struct agent_expr *ax, 127 struct axs_value *value, 128 struct axs_value *value1, 129 struct axs_value *value2, 130 enum agent_op op, 131 enum agent_op op_unsigned, int may_carry, char *name); 132 static void gen_logical_not (struct agent_expr *ax, struct axs_value *value, 133 struct type *result_type); 134 static void gen_complement (struct agent_expr *ax, struct axs_value *value); 135 static void gen_deref (struct agent_expr *, struct axs_value *); 136 static void gen_address_of (struct agent_expr *, struct axs_value *); 137 static void gen_bitfield_ref (struct expression *exp, struct agent_expr *ax, 138 struct axs_value *value, 139 struct type *type, int start, int end); 140 static void gen_primitive_field (struct expression *exp, 141 struct agent_expr *ax, 142 struct axs_value *value, 143 int offset, int fieldno, struct type *type); 144 static int gen_struct_ref_recursive (struct expression *exp, 145 struct agent_expr *ax, 146 struct axs_value *value, 147 char *field, int offset, 148 struct type *type); 149 static void gen_struct_ref (struct expression *exp, struct agent_expr *ax, 150 struct axs_value *value, 151 char *field, 152 char *operator_name, char *operand_name); 153 static void gen_static_field (struct gdbarch *gdbarch, 154 struct agent_expr *ax, struct axs_value *value, 155 struct type *type, int fieldno); 156 static void gen_repeat (struct expression *exp, union exp_element **pc, 157 struct agent_expr *ax, struct axs_value *value); 158 static void gen_sizeof (struct expression *exp, union exp_element **pc, 159 struct agent_expr *ax, struct axs_value *value, 160 struct type *size_type); 161 static void gen_expr_binop_rest (struct expression *exp, 162 enum exp_opcode op, union exp_element **pc, 163 struct agent_expr *ax, 164 struct axs_value *value, 165 struct axs_value *value1, 166 struct axs_value *value2); 167 168 static void agent_command (char *exp, int from_tty); 169 170 171 /* Detecting constant expressions. */ 172 173 /* If the variable reference at *PC is a constant, return its value. 174 Otherwise, return zero. 175 176 Hey, Wally! How can a variable reference be a constant? 177 178 Well, Beav, this function really handles the OP_VAR_VALUE operator, 179 not specifically variable references. GDB uses OP_VAR_VALUE to 180 refer to any kind of symbolic reference: function names, enum 181 elements, and goto labels are all handled through the OP_VAR_VALUE 182 operator, even though they're constants. It makes sense given the 183 situation. 184 185 Gee, Wally, don'cha wonder sometimes if data representations that 186 subvert commonly accepted definitions of terms in favor of heavily 187 context-specific interpretations are really just a tool of the 188 programming hegemony to preserve their power and exclude the 189 proletariat? */ 190 191 static struct value * 192 const_var_ref (struct symbol *var) 193 { 194 struct type *type = SYMBOL_TYPE (var); 195 196 switch (SYMBOL_CLASS (var)) 197 { 198 case LOC_CONST: 199 return value_from_longest (type, (LONGEST) SYMBOL_VALUE (var)); 200 201 case LOC_LABEL: 202 return value_from_pointer (type, (CORE_ADDR) SYMBOL_VALUE_ADDRESS (var)); 203 204 default: 205 return 0; 206 } 207 } 208 209 210 /* If the expression starting at *PC has a constant value, return it. 211 Otherwise, return zero. If we return a value, then *PC will be 212 advanced to the end of it. If we return zero, *PC could be 213 anywhere. */ 214 static struct value * 215 const_expr (union exp_element **pc) 216 { 217 enum exp_opcode op = (*pc)->opcode; 218 struct value *v1; 219 220 switch (op) 221 { 222 case OP_LONG: 223 { 224 struct type *type = (*pc)[1].type; 225 LONGEST k = (*pc)[2].longconst; 226 227 (*pc) += 4; 228 return value_from_longest (type, k); 229 } 230 231 case OP_VAR_VALUE: 232 { 233 struct value *v = const_var_ref ((*pc)[2].symbol); 234 235 (*pc) += 4; 236 return v; 237 } 238 239 /* We could add more operators in here. */ 240 241 case UNOP_NEG: 242 (*pc)++; 243 v1 = const_expr (pc); 244 if (v1) 245 return value_neg (v1); 246 else 247 return 0; 248 249 default: 250 return 0; 251 } 252 } 253 254 255 /* Like const_expr, but guarantee also that *PC is undisturbed if the 256 expression is not constant. */ 257 static struct value * 258 maybe_const_expr (union exp_element **pc) 259 { 260 union exp_element *tentative_pc = *pc; 261 struct value *v = const_expr (&tentative_pc); 262 263 /* If we got a value, then update the real PC. */ 264 if (v) 265 *pc = tentative_pc; 266 267 return v; 268 } 269 270 271 /* Generating bytecode from GDB expressions: general assumptions */ 272 273 /* Here are a few general assumptions made throughout the code; if you 274 want to make a change that contradicts one of these, then you'd 275 better scan things pretty thoroughly. 276 277 - We assume that all values occupy one stack element. For example, 278 sometimes we'll swap to get at the left argument to a binary 279 operator. If we decide that void values should occupy no stack 280 elements, or that synthetic arrays (whose size is determined at 281 run time, created by the `@' operator) should occupy two stack 282 elements (address and length), then this will cause trouble. 283 284 - We assume the stack elements are infinitely wide, and that we 285 don't have to worry what happens if the user requests an 286 operation that is wider than the actual interpreter's stack. 287 That is, it's up to the interpreter to handle directly all the 288 integer widths the user has access to. (Woe betide the language 289 with bignums!) 290 291 - We don't support side effects. Thus, we don't have to worry about 292 GCC's generalized lvalues, function calls, etc. 293 294 - We don't support floating point. Many places where we switch on 295 some type don't bother to include cases for floating point; there 296 may be even more subtle ways this assumption exists. For 297 example, the arguments to % must be integers. 298 299 - We assume all subexpressions have a static, unchanging type. If 300 we tried to support convenience variables, this would be a 301 problem. 302 303 - All values on the stack should always be fully zero- or 304 sign-extended. 305 306 (I wasn't sure whether to choose this or its opposite --- that 307 only addresses are assumed extended --- but it turns out that 308 neither convention completely eliminates spurious extend 309 operations (if everything is always extended, then you have to 310 extend after add, because it could overflow; if nothing is 311 extended, then you end up producing extends whenever you change 312 sizes), and this is simpler.) */ 313 314 315 /* Generating bytecode from GDB expressions: the `trace' kludge */ 316 317 /* The compiler in this file is a general-purpose mechanism for 318 translating GDB expressions into bytecode. One ought to be able to 319 find a million and one uses for it. 320 321 However, at the moment it is HOPELESSLY BRAIN-DAMAGED for the sake 322 of expediency. Let he who is without sin cast the first stone. 323 324 For the data tracing facility, we need to insert `trace' bytecodes 325 before each data fetch; this records all the memory that the 326 expression touches in the course of evaluation, so that memory will 327 be available when the user later tries to evaluate the expression 328 in GDB. 329 330 This should be done (I think) in a post-processing pass, that walks 331 an arbitrary agent expression and inserts `trace' operations at the 332 appropriate points. But it's much faster to just hack them 333 directly into the code. And since we're in a crunch, that's what 334 I've done. 335 336 Setting the flag trace_kludge to non-zero enables the code that 337 emits the trace bytecodes at the appropriate points. */ 338 int trace_kludge; 339 340 /* Inspired by trace_kludge, this indicates that pointers to chars 341 should get an added tracenz bytecode to record nonzero bytes, up to 342 a length that is the value of trace_string_kludge. */ 343 int trace_string_kludge; 344 345 /* Scan for all static fields in the given class, including any base 346 classes, and generate tracing bytecodes for each. */ 347 348 static void 349 gen_trace_static_fields (struct gdbarch *gdbarch, 350 struct agent_expr *ax, 351 struct type *type) 352 { 353 int i, nbases = TYPE_N_BASECLASSES (type); 354 struct axs_value value; 355 356 CHECK_TYPEDEF (type); 357 358 for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--) 359 { 360 if (field_is_static (&TYPE_FIELD (type, i))) 361 { 362 gen_static_field (gdbarch, ax, &value, type, i); 363 if (value.optimized_out) 364 continue; 365 switch (value.kind) 366 { 367 case axs_lvalue_memory: 368 { 369 /* Initialize the TYPE_LENGTH if it is a typedef. */ 370 check_typedef (value.type); 371 ax_const_l (ax, TYPE_LENGTH (value.type)); 372 ax_simple (ax, aop_trace); 373 } 374 break; 375 376 case axs_lvalue_register: 377 /* We don't actually need the register's value to be pushed, 378 just note that we need it to be collected. */ 379 ax_reg_mask (ax, value.u.reg); 380 381 default: 382 break; 383 } 384 } 385 } 386 387 /* Now scan through base classes recursively. */ 388 for (i = 0; i < nbases; i++) 389 { 390 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i)); 391 392 gen_trace_static_fields (gdbarch, ax, basetype); 393 } 394 } 395 396 /* Trace the lvalue on the stack, if it needs it. In either case, pop 397 the value. Useful on the left side of a comma, and at the end of 398 an expression being used for tracing. */ 399 static void 400 gen_traced_pop (struct gdbarch *gdbarch, 401 struct agent_expr *ax, struct axs_value *value) 402 { 403 int string_trace = 0; 404 if (trace_string_kludge 405 && TYPE_CODE (value->type) == TYPE_CODE_PTR 406 && c_textual_element_type (check_typedef (TYPE_TARGET_TYPE (value->type)), 407 's')) 408 string_trace = 1; 409 410 if (trace_kludge) 411 switch (value->kind) 412 { 413 case axs_rvalue: 414 if (string_trace) 415 { 416 ax_const_l (ax, trace_string_kludge); 417 ax_simple (ax, aop_tracenz); 418 } 419 else 420 /* We don't trace rvalues, just the lvalues necessary to 421 produce them. So just dispose of this value. */ 422 ax_simple (ax, aop_pop); 423 break; 424 425 case axs_lvalue_memory: 426 { 427 if (string_trace) 428 ax_simple (ax, aop_dup); 429 430 /* Initialize the TYPE_LENGTH if it is a typedef. */ 431 check_typedef (value->type); 432 433 /* There's no point in trying to use a trace_quick bytecode 434 here, since "trace_quick SIZE pop" is three bytes, whereas 435 "const8 SIZE trace" is also three bytes, does the same 436 thing, and the simplest code which generates that will also 437 work correctly for objects with large sizes. */ 438 ax_const_l (ax, TYPE_LENGTH (value->type)); 439 ax_simple (ax, aop_trace); 440 441 if (string_trace) 442 { 443 ax_simple (ax, aop_ref32); 444 ax_const_l (ax, trace_string_kludge); 445 ax_simple (ax, aop_tracenz); 446 } 447 } 448 break; 449 450 case axs_lvalue_register: 451 /* We don't actually need the register's value to be on the 452 stack, and the target will get heartburn if the register is 453 larger than will fit in a stack, so just mark it for 454 collection and be done with it. */ 455 ax_reg_mask (ax, value->u.reg); 456 457 /* But if the register points to a string, assume the value 458 will fit on the stack and push it anyway. */ 459 if (string_trace) 460 { 461 ax_reg (ax, value->u.reg); 462 ax_const_l (ax, trace_string_kludge); 463 ax_simple (ax, aop_tracenz); 464 } 465 break; 466 } 467 else 468 /* If we're not tracing, just pop the value. */ 469 ax_simple (ax, aop_pop); 470 471 /* To trace C++ classes with static fields stored elsewhere. */ 472 if (trace_kludge 473 && (TYPE_CODE (value->type) == TYPE_CODE_STRUCT 474 || TYPE_CODE (value->type) == TYPE_CODE_UNION)) 475 gen_trace_static_fields (gdbarch, ax, value->type); 476 } 477 478 479 480 /* Generating bytecode from GDB expressions: helper functions */ 481 482 /* Assume that the lower bits of the top of the stack is a value of 483 type TYPE, and the upper bits are zero. Sign-extend if necessary. */ 484 static void 485 gen_sign_extend (struct agent_expr *ax, struct type *type) 486 { 487 /* Do we need to sign-extend this? */ 488 if (!TYPE_UNSIGNED (type)) 489 ax_ext (ax, TYPE_LENGTH (type) * TARGET_CHAR_BIT); 490 } 491 492 493 /* Assume the lower bits of the top of the stack hold a value of type 494 TYPE, and the upper bits are garbage. Sign-extend or truncate as 495 needed. */ 496 static void 497 gen_extend (struct agent_expr *ax, struct type *type) 498 { 499 int bits = TYPE_LENGTH (type) * TARGET_CHAR_BIT; 500 501 /* I just had to. */ 502 ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits)); 503 } 504 505 506 /* Assume that the top of the stack contains a value of type "pointer 507 to TYPE"; generate code to fetch its value. Note that TYPE is the 508 target type, not the pointer type. */ 509 static void 510 gen_fetch (struct agent_expr *ax, struct type *type) 511 { 512 if (trace_kludge) 513 { 514 /* Record the area of memory we're about to fetch. */ 515 ax_trace_quick (ax, TYPE_LENGTH (type)); 516 } 517 518 if (TYPE_CODE (type) == TYPE_CODE_RANGE) 519 type = TYPE_TARGET_TYPE (type); 520 521 switch (TYPE_CODE (type)) 522 { 523 case TYPE_CODE_PTR: 524 case TYPE_CODE_REF: 525 case TYPE_CODE_ENUM: 526 case TYPE_CODE_INT: 527 case TYPE_CODE_CHAR: 528 case TYPE_CODE_BOOL: 529 /* It's a scalar value, so we know how to dereference it. How 530 many bytes long is it? */ 531 switch (TYPE_LENGTH (type)) 532 { 533 case 8 / TARGET_CHAR_BIT: 534 ax_simple (ax, aop_ref8); 535 break; 536 case 16 / TARGET_CHAR_BIT: 537 ax_simple (ax, aop_ref16); 538 break; 539 case 32 / TARGET_CHAR_BIT: 540 ax_simple (ax, aop_ref32); 541 break; 542 case 64 / TARGET_CHAR_BIT: 543 ax_simple (ax, aop_ref64); 544 break; 545 546 /* Either our caller shouldn't have asked us to dereference 547 that pointer (other code's fault), or we're not 548 implementing something we should be (this code's fault). 549 In any case, it's a bug the user shouldn't see. */ 550 default: 551 internal_error (__FILE__, __LINE__, 552 _("gen_fetch: strange size")); 553 } 554 555 gen_sign_extend (ax, type); 556 break; 557 558 default: 559 /* Our caller requested us to dereference a pointer from an unsupported 560 type. Error out and give callers a chance to handle the failure 561 gracefully. */ 562 error (_("gen_fetch: Unsupported type code `%s'."), 563 TYPE_NAME (type)); 564 } 565 } 566 567 568 /* Generate code to left shift the top of the stack by DISTANCE bits, or 569 right shift it by -DISTANCE bits if DISTANCE < 0. This generates 570 unsigned (logical) right shifts. */ 571 static void 572 gen_left_shift (struct agent_expr *ax, int distance) 573 { 574 if (distance > 0) 575 { 576 ax_const_l (ax, distance); 577 ax_simple (ax, aop_lsh); 578 } 579 else if (distance < 0) 580 { 581 ax_const_l (ax, -distance); 582 ax_simple (ax, aop_rsh_unsigned); 583 } 584 } 585 586 587 588 /* Generating bytecode from GDB expressions: symbol references */ 589 590 /* Generate code to push the base address of the argument portion of 591 the top stack frame. */ 592 static void 593 gen_frame_args_address (struct gdbarch *gdbarch, struct agent_expr *ax) 594 { 595 int frame_reg; 596 LONGEST frame_offset; 597 598 gdbarch_virtual_frame_pointer (gdbarch, 599 ax->scope, &frame_reg, &frame_offset); 600 ax_reg (ax, frame_reg); 601 gen_offset (ax, frame_offset); 602 } 603 604 605 /* Generate code to push the base address of the locals portion of the 606 top stack frame. */ 607 static void 608 gen_frame_locals_address (struct gdbarch *gdbarch, struct agent_expr *ax) 609 { 610 int frame_reg; 611 LONGEST frame_offset; 612 613 gdbarch_virtual_frame_pointer (gdbarch, 614 ax->scope, &frame_reg, &frame_offset); 615 ax_reg (ax, frame_reg); 616 gen_offset (ax, frame_offset); 617 } 618 619 620 /* Generate code to add OFFSET to the top of the stack. Try to 621 generate short and readable code. We use this for getting to 622 variables on the stack, and structure members. If we were 623 programming in ML, it would be clearer why these are the same 624 thing. */ 625 static void 626 gen_offset (struct agent_expr *ax, int offset) 627 { 628 /* It would suffice to simply push the offset and add it, but this 629 makes it easier to read positive and negative offsets in the 630 bytecode. */ 631 if (offset > 0) 632 { 633 ax_const_l (ax, offset); 634 ax_simple (ax, aop_add); 635 } 636 else if (offset < 0) 637 { 638 ax_const_l (ax, -offset); 639 ax_simple (ax, aop_sub); 640 } 641 } 642 643 644 /* In many cases, a symbol's value is the offset from some other 645 address (stack frame, base register, etc.) Generate code to add 646 VAR's value to the top of the stack. */ 647 static void 648 gen_sym_offset (struct agent_expr *ax, struct symbol *var) 649 { 650 gen_offset (ax, SYMBOL_VALUE (var)); 651 } 652 653 654 /* Generate code for a variable reference to AX. The variable is the 655 symbol VAR. Set VALUE to describe the result. */ 656 657 static void 658 gen_var_ref (struct gdbarch *gdbarch, struct agent_expr *ax, 659 struct axs_value *value, struct symbol *var) 660 { 661 /* Dereference any typedefs. */ 662 value->type = check_typedef (SYMBOL_TYPE (var)); 663 value->optimized_out = 0; 664 665 /* I'm imitating the code in read_var_value. */ 666 switch (SYMBOL_CLASS (var)) 667 { 668 case LOC_CONST: /* A constant, like an enum value. */ 669 ax_const_l (ax, (LONGEST) SYMBOL_VALUE (var)); 670 value->kind = axs_rvalue; 671 break; 672 673 case LOC_LABEL: /* A goto label, being used as a value. */ 674 ax_const_l (ax, (LONGEST) SYMBOL_VALUE_ADDRESS (var)); 675 value->kind = axs_rvalue; 676 break; 677 678 case LOC_CONST_BYTES: 679 internal_error (__FILE__, __LINE__, 680 _("gen_var_ref: LOC_CONST_BYTES " 681 "symbols are not supported")); 682 683 /* Variable at a fixed location in memory. Easy. */ 684 case LOC_STATIC: 685 /* Push the address of the variable. */ 686 ax_const_l (ax, SYMBOL_VALUE_ADDRESS (var)); 687 value->kind = axs_lvalue_memory; 688 break; 689 690 case LOC_ARG: /* var lives in argument area of frame */ 691 gen_frame_args_address (gdbarch, ax); 692 gen_sym_offset (ax, var); 693 value->kind = axs_lvalue_memory; 694 break; 695 696 case LOC_REF_ARG: /* As above, but the frame slot really 697 holds the address of the variable. */ 698 gen_frame_args_address (gdbarch, ax); 699 gen_sym_offset (ax, var); 700 /* Don't assume any particular pointer size. */ 701 gen_fetch (ax, builtin_type (gdbarch)->builtin_data_ptr); 702 value->kind = axs_lvalue_memory; 703 break; 704 705 case LOC_LOCAL: /* var lives in locals area of frame */ 706 gen_frame_locals_address (gdbarch, ax); 707 gen_sym_offset (ax, var); 708 value->kind = axs_lvalue_memory; 709 break; 710 711 case LOC_TYPEDEF: 712 error (_("Cannot compute value of typedef `%s'."), 713 SYMBOL_PRINT_NAME (var)); 714 break; 715 716 case LOC_BLOCK: 717 ax_const_l (ax, BLOCK_START (SYMBOL_BLOCK_VALUE (var))); 718 value->kind = axs_rvalue; 719 break; 720 721 case LOC_REGISTER: 722 /* Don't generate any code at all; in the process of treating 723 this as an lvalue or rvalue, the caller will generate the 724 right code. */ 725 value->kind = axs_lvalue_register; 726 value->u.reg = SYMBOL_REGISTER_OPS (var)->register_number (var, gdbarch); 727 break; 728 729 /* A lot like LOC_REF_ARG, but the pointer lives directly in a 730 register, not on the stack. Simpler than LOC_REGISTER 731 because it's just like any other case where the thing 732 has a real address. */ 733 case LOC_REGPARM_ADDR: 734 ax_reg (ax, SYMBOL_REGISTER_OPS (var)->register_number (var, gdbarch)); 735 value->kind = axs_lvalue_memory; 736 break; 737 738 case LOC_UNRESOLVED: 739 { 740 struct minimal_symbol *msym 741 = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL); 742 743 if (!msym) 744 error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var)); 745 746 /* Push the address of the variable. */ 747 ax_const_l (ax, SYMBOL_VALUE_ADDRESS (msym)); 748 value->kind = axs_lvalue_memory; 749 } 750 break; 751 752 case LOC_COMPUTED: 753 /* FIXME: cagney/2004-01-26: It should be possible to 754 unconditionally call the SYMBOL_COMPUTED_OPS method when available. 755 Unfortunately DWARF 2 stores the frame-base (instead of the 756 function) location in a function's symbol. Oops! For the 757 moment enable this when/where applicable. */ 758 SYMBOL_COMPUTED_OPS (var)->tracepoint_var_ref (var, gdbarch, ax, value); 759 break; 760 761 case LOC_OPTIMIZED_OUT: 762 /* Flag this, but don't say anything; leave it up to callers to 763 warn the user. */ 764 value->optimized_out = 1; 765 break; 766 767 default: 768 error (_("Cannot find value of botched symbol `%s'."), 769 SYMBOL_PRINT_NAME (var)); 770 break; 771 } 772 } 773 774 775 776 /* Generating bytecode from GDB expressions: literals */ 777 778 static void 779 gen_int_literal (struct agent_expr *ax, struct axs_value *value, LONGEST k, 780 struct type *type) 781 { 782 ax_const_l (ax, k); 783 value->kind = axs_rvalue; 784 value->type = check_typedef (type); 785 } 786 787 788 789 /* Generating bytecode from GDB expressions: unary conversions, casts */ 790 791 /* Take what's on the top of the stack (as described by VALUE), and 792 try to make an rvalue out of it. Signal an error if we can't do 793 that. */ 794 void 795 require_rvalue (struct agent_expr *ax, struct axs_value *value) 796 { 797 /* Only deal with scalars, structs and such may be too large 798 to fit in a stack entry. */ 799 value->type = check_typedef (value->type); 800 if (TYPE_CODE (value->type) == TYPE_CODE_ARRAY 801 || TYPE_CODE (value->type) == TYPE_CODE_STRUCT 802 || TYPE_CODE (value->type) == TYPE_CODE_UNION 803 || TYPE_CODE (value->type) == TYPE_CODE_FUNC) 804 error (_("Value not scalar: cannot be an rvalue.")); 805 806 switch (value->kind) 807 { 808 case axs_rvalue: 809 /* It's already an rvalue. */ 810 break; 811 812 case axs_lvalue_memory: 813 /* The top of stack is the address of the object. Dereference. */ 814 gen_fetch (ax, value->type); 815 break; 816 817 case axs_lvalue_register: 818 /* There's nothing on the stack, but value->u.reg is the 819 register number containing the value. 820 821 When we add floating-point support, this is going to have to 822 change. What about SPARC register pairs, for example? */ 823 ax_reg (ax, value->u.reg); 824 gen_extend (ax, value->type); 825 break; 826 } 827 828 value->kind = axs_rvalue; 829 } 830 831 832 /* Assume the top of the stack is described by VALUE, and perform the 833 usual unary conversions. This is motivated by ANSI 6.2.2, but of 834 course GDB expressions are not ANSI; they're the mishmash union of 835 a bunch of languages. Rah. 836 837 NOTE! This function promises to produce an rvalue only when the 838 incoming value is of an appropriate type. In other words, the 839 consumer of the value this function produces may assume the value 840 is an rvalue only after checking its type. 841 842 The immediate issue is that if the user tries to use a structure or 843 union as an operand of, say, the `+' operator, we don't want to try 844 to convert that structure to an rvalue; require_rvalue will bomb on 845 structs and unions. Rather, we want to simply pass the struct 846 lvalue through unchanged, and let `+' raise an error. */ 847 848 static void 849 gen_usual_unary (struct expression *exp, struct agent_expr *ax, 850 struct axs_value *value) 851 { 852 /* We don't have to generate any code for the usual integral 853 conversions, since values are always represented as full-width on 854 the stack. Should we tweak the type? */ 855 856 /* Some types require special handling. */ 857 switch (TYPE_CODE (value->type)) 858 { 859 /* Functions get converted to a pointer to the function. */ 860 case TYPE_CODE_FUNC: 861 value->type = lookup_pointer_type (value->type); 862 value->kind = axs_rvalue; /* Should always be true, but just in case. */ 863 break; 864 865 /* Arrays get converted to a pointer to their first element, and 866 are no longer an lvalue. */ 867 case TYPE_CODE_ARRAY: 868 { 869 struct type *elements = TYPE_TARGET_TYPE (value->type); 870 871 value->type = lookup_pointer_type (elements); 872 value->kind = axs_rvalue; 873 /* We don't need to generate any code; the address of the array 874 is also the address of its first element. */ 875 } 876 break; 877 878 /* Don't try to convert structures and unions to rvalues. Let the 879 consumer signal an error. */ 880 case TYPE_CODE_STRUCT: 881 case TYPE_CODE_UNION: 882 return; 883 } 884 885 /* If the value is an lvalue, dereference it. */ 886 require_rvalue (ax, value); 887 } 888 889 890 /* Return non-zero iff the type TYPE1 is considered "wider" than the 891 type TYPE2, according to the rules described in gen_usual_arithmetic. */ 892 static int 893 type_wider_than (struct type *type1, struct type *type2) 894 { 895 return (TYPE_LENGTH (type1) > TYPE_LENGTH (type2) 896 || (TYPE_LENGTH (type1) == TYPE_LENGTH (type2) 897 && TYPE_UNSIGNED (type1) 898 && !TYPE_UNSIGNED (type2))); 899 } 900 901 902 /* Return the "wider" of the two types TYPE1 and TYPE2. */ 903 static struct type * 904 max_type (struct type *type1, struct type *type2) 905 { 906 return type_wider_than (type1, type2) ? type1 : type2; 907 } 908 909 910 /* Generate code to convert a scalar value of type FROM to type TO. */ 911 static void 912 gen_conversion (struct agent_expr *ax, struct type *from, struct type *to) 913 { 914 /* Perhaps there is a more graceful way to state these rules. */ 915 916 /* If we're converting to a narrower type, then we need to clear out 917 the upper bits. */ 918 if (TYPE_LENGTH (to) < TYPE_LENGTH (from)) 919 gen_extend (ax, from); 920 921 /* If the two values have equal width, but different signednesses, 922 then we need to extend. */ 923 else if (TYPE_LENGTH (to) == TYPE_LENGTH (from)) 924 { 925 if (TYPE_UNSIGNED (from) != TYPE_UNSIGNED (to)) 926 gen_extend (ax, to); 927 } 928 929 /* If we're converting to a wider type, and becoming unsigned, then 930 we need to zero out any possible sign bits. */ 931 else if (TYPE_LENGTH (to) > TYPE_LENGTH (from)) 932 { 933 if (TYPE_UNSIGNED (to)) 934 gen_extend (ax, to); 935 } 936 } 937 938 939 /* Return non-zero iff the type FROM will require any bytecodes to be 940 emitted to be converted to the type TO. */ 941 static int 942 is_nontrivial_conversion (struct type *from, struct type *to) 943 { 944 struct agent_expr *ax = new_agent_expr (NULL, 0); 945 int nontrivial; 946 947 /* Actually generate the code, and see if anything came out. At the 948 moment, it would be trivial to replicate the code in 949 gen_conversion here, but in the future, when we're supporting 950 floating point and the like, it may not be. Doing things this 951 way allows this function to be independent of the logic in 952 gen_conversion. */ 953 gen_conversion (ax, from, to); 954 nontrivial = ax->len > 0; 955 free_agent_expr (ax); 956 return nontrivial; 957 } 958 959 960 /* Generate code to perform the "usual arithmetic conversions" (ANSI C 961 6.2.1.5) for the two operands of an arithmetic operator. This 962 effectively finds a "least upper bound" type for the two arguments, 963 and promotes each argument to that type. *VALUE1 and *VALUE2 964 describe the values as they are passed in, and as they are left. */ 965 static void 966 gen_usual_arithmetic (struct expression *exp, struct agent_expr *ax, 967 struct axs_value *value1, struct axs_value *value2) 968 { 969 /* Do the usual binary conversions. */ 970 if (TYPE_CODE (value1->type) == TYPE_CODE_INT 971 && TYPE_CODE (value2->type) == TYPE_CODE_INT) 972 { 973 /* The ANSI integral promotions seem to work this way: Order the 974 integer types by size, and then by signedness: an n-bit 975 unsigned type is considered "wider" than an n-bit signed 976 type. Promote to the "wider" of the two types, and always 977 promote at least to int. */ 978 struct type *target = max_type (builtin_type (exp->gdbarch)->builtin_int, 979 max_type (value1->type, value2->type)); 980 981 /* Deal with value2, on the top of the stack. */ 982 gen_conversion (ax, value2->type, target); 983 984 /* Deal with value1, not on the top of the stack. Don't 985 generate the `swap' instructions if we're not actually going 986 to do anything. */ 987 if (is_nontrivial_conversion (value1->type, target)) 988 { 989 ax_simple (ax, aop_swap); 990 gen_conversion (ax, value1->type, target); 991 ax_simple (ax, aop_swap); 992 } 993 994 value1->type = value2->type = check_typedef (target); 995 } 996 } 997 998 999 /* Generate code to perform the integral promotions (ANSI 6.2.1.1) on 1000 the value on the top of the stack, as described by VALUE. Assume 1001 the value has integral type. */ 1002 static void 1003 gen_integral_promotions (struct expression *exp, struct agent_expr *ax, 1004 struct axs_value *value) 1005 { 1006 const struct builtin_type *builtin = builtin_type (exp->gdbarch); 1007 1008 if (!type_wider_than (value->type, builtin->builtin_int)) 1009 { 1010 gen_conversion (ax, value->type, builtin->builtin_int); 1011 value->type = builtin->builtin_int; 1012 } 1013 else if (!type_wider_than (value->type, builtin->builtin_unsigned_int)) 1014 { 1015 gen_conversion (ax, value->type, builtin->builtin_unsigned_int); 1016 value->type = builtin->builtin_unsigned_int; 1017 } 1018 } 1019 1020 1021 /* Generate code for a cast to TYPE. */ 1022 static void 1023 gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type) 1024 { 1025 /* GCC does allow casts to yield lvalues, so this should be fixed 1026 before merging these changes into the trunk. */ 1027 require_rvalue (ax, value); 1028 /* Dereference typedefs. */ 1029 type = check_typedef (type); 1030 1031 switch (TYPE_CODE (type)) 1032 { 1033 case TYPE_CODE_PTR: 1034 case TYPE_CODE_REF: 1035 /* It's implementation-defined, and I'll bet this is what GCC 1036 does. */ 1037 break; 1038 1039 case TYPE_CODE_ARRAY: 1040 case TYPE_CODE_STRUCT: 1041 case TYPE_CODE_UNION: 1042 case TYPE_CODE_FUNC: 1043 error (_("Invalid type cast: intended type must be scalar.")); 1044 1045 case TYPE_CODE_ENUM: 1046 case TYPE_CODE_BOOL: 1047 /* We don't have to worry about the size of the value, because 1048 all our integral values are fully sign-extended, and when 1049 casting pointers we can do anything we like. Is there any 1050 way for us to know what GCC actually does with a cast like 1051 this? */ 1052 break; 1053 1054 case TYPE_CODE_INT: 1055 gen_conversion (ax, value->type, type); 1056 break; 1057 1058 case TYPE_CODE_VOID: 1059 /* We could pop the value, and rely on everyone else to check 1060 the type and notice that this value doesn't occupy a stack 1061 slot. But for now, leave the value on the stack, and 1062 preserve the "value == stack element" assumption. */ 1063 break; 1064 1065 default: 1066 error (_("Casts to requested type are not yet implemented.")); 1067 } 1068 1069 value->type = type; 1070 } 1071 1072 1073 1074 /* Generating bytecode from GDB expressions: arithmetic */ 1075 1076 /* Scale the integer on the top of the stack by the size of the target 1077 of the pointer type TYPE. */ 1078 static void 1079 gen_scale (struct agent_expr *ax, enum agent_op op, struct type *type) 1080 { 1081 struct type *element = TYPE_TARGET_TYPE (type); 1082 1083 if (TYPE_LENGTH (element) != 1) 1084 { 1085 ax_const_l (ax, TYPE_LENGTH (element)); 1086 ax_simple (ax, op); 1087 } 1088 } 1089 1090 1091 /* Generate code for pointer arithmetic PTR + INT. */ 1092 static void 1093 gen_ptradd (struct agent_expr *ax, struct axs_value *value, 1094 struct axs_value *value1, struct axs_value *value2) 1095 { 1096 gdb_assert (pointer_type (value1->type)); 1097 gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_INT); 1098 1099 gen_scale (ax, aop_mul, value1->type); 1100 ax_simple (ax, aop_add); 1101 gen_extend (ax, value1->type); /* Catch overflow. */ 1102 value->type = value1->type; 1103 value->kind = axs_rvalue; 1104 } 1105 1106 1107 /* Generate code for pointer arithmetic PTR - INT. */ 1108 static void 1109 gen_ptrsub (struct agent_expr *ax, struct axs_value *value, 1110 struct axs_value *value1, struct axs_value *value2) 1111 { 1112 gdb_assert (pointer_type (value1->type)); 1113 gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_INT); 1114 1115 gen_scale (ax, aop_mul, value1->type); 1116 ax_simple (ax, aop_sub); 1117 gen_extend (ax, value1->type); /* Catch overflow. */ 1118 value->type = value1->type; 1119 value->kind = axs_rvalue; 1120 } 1121 1122 1123 /* Generate code for pointer arithmetic PTR - PTR. */ 1124 static void 1125 gen_ptrdiff (struct agent_expr *ax, struct axs_value *value, 1126 struct axs_value *value1, struct axs_value *value2, 1127 struct type *result_type) 1128 { 1129 gdb_assert (pointer_type (value1->type)); 1130 gdb_assert (pointer_type (value2->type)); 1131 1132 if (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type)) 1133 != TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type))) 1134 error (_("\ 1135 First argument of `-' is a pointer, but second argument is neither\n\ 1136 an integer nor a pointer of the same type.")); 1137 1138 ax_simple (ax, aop_sub); 1139 gen_scale (ax, aop_div_unsigned, value1->type); 1140 value->type = result_type; 1141 value->kind = axs_rvalue; 1142 } 1143 1144 static void 1145 gen_equal (struct agent_expr *ax, struct axs_value *value, 1146 struct axs_value *value1, struct axs_value *value2, 1147 struct type *result_type) 1148 { 1149 if (pointer_type (value1->type) || pointer_type (value2->type)) 1150 ax_simple (ax, aop_equal); 1151 else 1152 gen_binop (ax, value, value1, value2, 1153 aop_equal, aop_equal, 0, "equal"); 1154 value->type = result_type; 1155 value->kind = axs_rvalue; 1156 } 1157 1158 static void 1159 gen_less (struct agent_expr *ax, struct axs_value *value, 1160 struct axs_value *value1, struct axs_value *value2, 1161 struct type *result_type) 1162 { 1163 if (pointer_type (value1->type) || pointer_type (value2->type)) 1164 ax_simple (ax, aop_less_unsigned); 1165 else 1166 gen_binop (ax, value, value1, value2, 1167 aop_less_signed, aop_less_unsigned, 0, "less than"); 1168 value->type = result_type; 1169 value->kind = axs_rvalue; 1170 } 1171 1172 /* Generate code for a binary operator that doesn't do pointer magic. 1173 We set VALUE to describe the result value; we assume VALUE1 and 1174 VALUE2 describe the two operands, and that they've undergone the 1175 usual binary conversions. MAY_CARRY should be non-zero iff the 1176 result needs to be extended. NAME is the English name of the 1177 operator, used in error messages */ 1178 static void 1179 gen_binop (struct agent_expr *ax, struct axs_value *value, 1180 struct axs_value *value1, struct axs_value *value2, 1181 enum agent_op op, enum agent_op op_unsigned, 1182 int may_carry, char *name) 1183 { 1184 /* We only handle INT op INT. */ 1185 if ((TYPE_CODE (value1->type) != TYPE_CODE_INT) 1186 || (TYPE_CODE (value2->type) != TYPE_CODE_INT)) 1187 error (_("Invalid combination of types in %s."), name); 1188 1189 ax_simple (ax, 1190 TYPE_UNSIGNED (value1->type) ? op_unsigned : op); 1191 if (may_carry) 1192 gen_extend (ax, value1->type); /* catch overflow */ 1193 value->type = value1->type; 1194 value->kind = axs_rvalue; 1195 } 1196 1197 1198 static void 1199 gen_logical_not (struct agent_expr *ax, struct axs_value *value, 1200 struct type *result_type) 1201 { 1202 if (TYPE_CODE (value->type) != TYPE_CODE_INT 1203 && TYPE_CODE (value->type) != TYPE_CODE_PTR) 1204 error (_("Invalid type of operand to `!'.")); 1205 1206 ax_simple (ax, aop_log_not); 1207 value->type = result_type; 1208 } 1209 1210 1211 static void 1212 gen_complement (struct agent_expr *ax, struct axs_value *value) 1213 { 1214 if (TYPE_CODE (value->type) != TYPE_CODE_INT) 1215 error (_("Invalid type of operand to `~'.")); 1216 1217 ax_simple (ax, aop_bit_not); 1218 gen_extend (ax, value->type); 1219 } 1220 1221 1222 1223 /* Generating bytecode from GDB expressions: * & . -> @ sizeof */ 1224 1225 /* Dereference the value on the top of the stack. */ 1226 static void 1227 gen_deref (struct agent_expr *ax, struct axs_value *value) 1228 { 1229 /* The caller should check the type, because several operators use 1230 this, and we don't know what error message to generate. */ 1231 if (!pointer_type (value->type)) 1232 internal_error (__FILE__, __LINE__, 1233 _("gen_deref: expected a pointer")); 1234 1235 /* We've got an rvalue now, which is a pointer. We want to yield an 1236 lvalue, whose address is exactly that pointer. So we don't 1237 actually emit any code; we just change the type from "Pointer to 1238 T" to "T", and mark the value as an lvalue in memory. Leave it 1239 to the consumer to actually dereference it. */ 1240 value->type = check_typedef (TYPE_TARGET_TYPE (value->type)); 1241 if (TYPE_CODE (value->type) == TYPE_CODE_VOID) 1242 error (_("Attempt to dereference a generic pointer.")); 1243 value->kind = ((TYPE_CODE (value->type) == TYPE_CODE_FUNC) 1244 ? axs_rvalue : axs_lvalue_memory); 1245 } 1246 1247 1248 /* Produce the address of the lvalue on the top of the stack. */ 1249 static void 1250 gen_address_of (struct agent_expr *ax, struct axs_value *value) 1251 { 1252 /* Special case for taking the address of a function. The ANSI 1253 standard describes this as a special case, too, so this 1254 arrangement is not without motivation. */ 1255 if (TYPE_CODE (value->type) == TYPE_CODE_FUNC) 1256 /* The value's already an rvalue on the stack, so we just need to 1257 change the type. */ 1258 value->type = lookup_pointer_type (value->type); 1259 else 1260 switch (value->kind) 1261 { 1262 case axs_rvalue: 1263 error (_("Operand of `&' is an rvalue, which has no address.")); 1264 1265 case axs_lvalue_register: 1266 error (_("Operand of `&' is in a register, and has no address.")); 1267 1268 case axs_lvalue_memory: 1269 value->kind = axs_rvalue; 1270 value->type = lookup_pointer_type (value->type); 1271 break; 1272 } 1273 } 1274 1275 /* Generate code to push the value of a bitfield of a structure whose 1276 address is on the top of the stack. START and END give the 1277 starting and one-past-ending *bit* numbers of the field within the 1278 structure. */ 1279 static void 1280 gen_bitfield_ref (struct expression *exp, struct agent_expr *ax, 1281 struct axs_value *value, struct type *type, 1282 int start, int end) 1283 { 1284 /* Note that ops[i] fetches 8 << i bits. */ 1285 static enum agent_op ops[] 1286 = {aop_ref8, aop_ref16, aop_ref32, aop_ref64}; 1287 static int num_ops = (sizeof (ops) / sizeof (ops[0])); 1288 1289 /* We don't want to touch any byte that the bitfield doesn't 1290 actually occupy; we shouldn't make any accesses we're not 1291 explicitly permitted to. We rely here on the fact that the 1292 bytecode `ref' operators work on unaligned addresses. 1293 1294 It takes some fancy footwork to get the stack to work the way 1295 we'd like. Say we're retrieving a bitfield that requires three 1296 fetches. Initially, the stack just contains the address: 1297 addr 1298 For the first fetch, we duplicate the address 1299 addr addr 1300 then add the byte offset, do the fetch, and shift and mask as 1301 needed, yielding a fragment of the value, properly aligned for 1302 the final bitwise or: 1303 addr frag1 1304 then we swap, and repeat the process: 1305 frag1 addr --- address on top 1306 frag1 addr addr --- duplicate it 1307 frag1 addr frag2 --- get second fragment 1308 frag1 frag2 addr --- swap again 1309 frag1 frag2 frag3 --- get third fragment 1310 Notice that, since the third fragment is the last one, we don't 1311 bother duplicating the address this time. Now we have all the 1312 fragments on the stack, and we can simply `or' them together, 1313 yielding the final value of the bitfield. */ 1314 1315 /* The first and one-after-last bits in the field, but rounded down 1316 and up to byte boundaries. */ 1317 int bound_start = (start / TARGET_CHAR_BIT) * TARGET_CHAR_BIT; 1318 int bound_end = (((end + TARGET_CHAR_BIT - 1) 1319 / TARGET_CHAR_BIT) 1320 * TARGET_CHAR_BIT); 1321 1322 /* current bit offset within the structure */ 1323 int offset; 1324 1325 /* The index in ops of the opcode we're considering. */ 1326 int op; 1327 1328 /* The number of fragments we generated in the process. Probably 1329 equal to the number of `one' bits in bytesize, but who cares? */ 1330 int fragment_count; 1331 1332 /* Dereference any typedefs. */ 1333 type = check_typedef (type); 1334 1335 /* Can we fetch the number of bits requested at all? */ 1336 if ((end - start) > ((1 << num_ops) * 8)) 1337 internal_error (__FILE__, __LINE__, 1338 _("gen_bitfield_ref: bitfield too wide")); 1339 1340 /* Note that we know here that we only need to try each opcode once. 1341 That may not be true on machines with weird byte sizes. */ 1342 offset = bound_start; 1343 fragment_count = 0; 1344 for (op = num_ops - 1; op >= 0; op--) 1345 { 1346 /* number of bits that ops[op] would fetch */ 1347 int op_size = 8 << op; 1348 1349 /* The stack at this point, from bottom to top, contains zero or 1350 more fragments, then the address. */ 1351 1352 /* Does this fetch fit within the bitfield? */ 1353 if (offset + op_size <= bound_end) 1354 { 1355 /* Is this the last fragment? */ 1356 int last_frag = (offset + op_size == bound_end); 1357 1358 if (!last_frag) 1359 ax_simple (ax, aop_dup); /* keep a copy of the address */ 1360 1361 /* Add the offset. */ 1362 gen_offset (ax, offset / TARGET_CHAR_BIT); 1363 1364 if (trace_kludge) 1365 { 1366 /* Record the area of memory we're about to fetch. */ 1367 ax_trace_quick (ax, op_size / TARGET_CHAR_BIT); 1368 } 1369 1370 /* Perform the fetch. */ 1371 ax_simple (ax, ops[op]); 1372 1373 /* Shift the bits we have to their proper position. 1374 gen_left_shift will generate right shifts when the operand 1375 is negative. 1376 1377 A big-endian field diagram to ponder: 1378 byte 0 byte 1 byte 2 byte 3 byte 4 byte 5 byte 6 byte 7 1379 +------++------++------++------++------++------++------++------+ 1380 xxxxAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCxxxxxxxxxxx 1381 ^ ^ ^ ^ 1382 bit number 16 32 48 53 1383 These are bit numbers as supplied by GDB. Note that the 1384 bit numbers run from right to left once you've fetched the 1385 value! 1386 1387 A little-endian field diagram to ponder: 1388 byte 7 byte 6 byte 5 byte 4 byte 3 byte 2 byte 1 byte 0 1389 +------++------++------++------++------++------++------++------+ 1390 xxxxxxxxxxxAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCxxxx 1391 ^ ^ ^ ^ ^ 1392 bit number 48 32 16 4 0 1393 1394 In both cases, the most significant end is on the left 1395 (i.e. normal numeric writing order), which means that you 1396 don't go crazy thinking about `left' and `right' shifts. 1397 1398 We don't have to worry about masking yet: 1399 - If they contain garbage off the least significant end, then we 1400 must be looking at the low end of the field, and the right 1401 shift will wipe them out. 1402 - If they contain garbage off the most significant end, then we 1403 must be looking at the most significant end of the word, and 1404 the sign/zero extension will wipe them out. 1405 - If we're in the interior of the word, then there is no garbage 1406 on either end, because the ref operators zero-extend. */ 1407 if (gdbarch_byte_order (exp->gdbarch) == BFD_ENDIAN_BIG) 1408 gen_left_shift (ax, end - (offset + op_size)); 1409 else 1410 gen_left_shift (ax, offset - start); 1411 1412 if (!last_frag) 1413 /* Bring the copy of the address up to the top. */ 1414 ax_simple (ax, aop_swap); 1415 1416 offset += op_size; 1417 fragment_count++; 1418 } 1419 } 1420 1421 /* Generate enough bitwise `or' operations to combine all the 1422 fragments we left on the stack. */ 1423 while (fragment_count-- > 1) 1424 ax_simple (ax, aop_bit_or); 1425 1426 /* Sign- or zero-extend the value as appropriate. */ 1427 ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, end - start)); 1428 1429 /* This is *not* an lvalue. Ugh. */ 1430 value->kind = axs_rvalue; 1431 value->type = type; 1432 } 1433 1434 /* Generate bytecodes for field number FIELDNO of type TYPE. OFFSET 1435 is an accumulated offset (in bytes), will be nonzero for objects 1436 embedded in other objects, like C++ base classes. Behavior should 1437 generally follow value_primitive_field. */ 1438 1439 static void 1440 gen_primitive_field (struct expression *exp, 1441 struct agent_expr *ax, struct axs_value *value, 1442 int offset, int fieldno, struct type *type) 1443 { 1444 /* Is this a bitfield? */ 1445 if (TYPE_FIELD_PACKED (type, fieldno)) 1446 gen_bitfield_ref (exp, ax, value, TYPE_FIELD_TYPE (type, fieldno), 1447 (offset * TARGET_CHAR_BIT 1448 + TYPE_FIELD_BITPOS (type, fieldno)), 1449 (offset * TARGET_CHAR_BIT 1450 + TYPE_FIELD_BITPOS (type, fieldno) 1451 + TYPE_FIELD_BITSIZE (type, fieldno))); 1452 else 1453 { 1454 gen_offset (ax, offset 1455 + TYPE_FIELD_BITPOS (type, fieldno) / TARGET_CHAR_BIT); 1456 value->kind = axs_lvalue_memory; 1457 value->type = TYPE_FIELD_TYPE (type, fieldno); 1458 } 1459 } 1460 1461 /* Search for the given field in either the given type or one of its 1462 base classes. Return 1 if found, 0 if not. */ 1463 1464 static int 1465 gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax, 1466 struct axs_value *value, 1467 char *field, int offset, struct type *type) 1468 { 1469 int i, rslt; 1470 int nbases = TYPE_N_BASECLASSES (type); 1471 1472 CHECK_TYPEDEF (type); 1473 1474 for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--) 1475 { 1476 const char *this_name = TYPE_FIELD_NAME (type, i); 1477 1478 if (this_name) 1479 { 1480 if (strcmp (field, this_name) == 0) 1481 { 1482 /* Note that bytecodes for the struct's base (aka 1483 "this") will have been generated already, which will 1484 be unnecessary but not harmful if the static field is 1485 being handled as a global. */ 1486 if (field_is_static (&TYPE_FIELD (type, i))) 1487 { 1488 gen_static_field (exp->gdbarch, ax, value, type, i); 1489 if (value->optimized_out) 1490 error (_("static field `%s' has been " 1491 "optimized out, cannot use"), 1492 field); 1493 return 1; 1494 } 1495 1496 gen_primitive_field (exp, ax, value, offset, i, type); 1497 return 1; 1498 } 1499 #if 0 /* is this right? */ 1500 if (this_name[0] == '\0') 1501 internal_error (__FILE__, __LINE__, 1502 _("find_field: anonymous unions not supported")); 1503 #endif 1504 } 1505 } 1506 1507 /* Now scan through base classes recursively. */ 1508 for (i = 0; i < nbases; i++) 1509 { 1510 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i)); 1511 1512 rslt = gen_struct_ref_recursive (exp, ax, value, field, 1513 offset + TYPE_BASECLASS_BITPOS (type, i) 1514 / TARGET_CHAR_BIT, 1515 basetype); 1516 if (rslt) 1517 return 1; 1518 } 1519 1520 /* Not found anywhere, flag so caller can complain. */ 1521 return 0; 1522 } 1523 1524 /* Generate code to reference the member named FIELD of a structure or 1525 union. The top of the stack, as described by VALUE, should have 1526 type (pointer to a)* struct/union. OPERATOR_NAME is the name of 1527 the operator being compiled, and OPERAND_NAME is the kind of thing 1528 it operates on; we use them in error messages. */ 1529 static void 1530 gen_struct_ref (struct expression *exp, struct agent_expr *ax, 1531 struct axs_value *value, char *field, 1532 char *operator_name, char *operand_name) 1533 { 1534 struct type *type; 1535 int found; 1536 1537 /* Follow pointers until we reach a non-pointer. These aren't the C 1538 semantics, but they're what the normal GDB evaluator does, so we 1539 should at least be consistent. */ 1540 while (pointer_type (value->type)) 1541 { 1542 require_rvalue (ax, value); 1543 gen_deref (ax, value); 1544 } 1545 type = check_typedef (value->type); 1546 1547 /* This must yield a structure or a union. */ 1548 if (TYPE_CODE (type) != TYPE_CODE_STRUCT 1549 && TYPE_CODE (type) != TYPE_CODE_UNION) 1550 error (_("The left operand of `%s' is not a %s."), 1551 operator_name, operand_name); 1552 1553 /* And it must be in memory; we don't deal with structure rvalues, 1554 or structures living in registers. */ 1555 if (value->kind != axs_lvalue_memory) 1556 error (_("Structure does not live in memory.")); 1557 1558 /* Search through fields and base classes recursively. */ 1559 found = gen_struct_ref_recursive (exp, ax, value, field, 0, type); 1560 1561 if (!found) 1562 error (_("Couldn't find member named `%s' in struct/union/class `%s'"), 1563 field, TYPE_TAG_NAME (type)); 1564 } 1565 1566 static int 1567 gen_namespace_elt (struct expression *exp, 1568 struct agent_expr *ax, struct axs_value *value, 1569 const struct type *curtype, char *name); 1570 static int 1571 gen_maybe_namespace_elt (struct expression *exp, 1572 struct agent_expr *ax, struct axs_value *value, 1573 const struct type *curtype, char *name); 1574 1575 static void 1576 gen_static_field (struct gdbarch *gdbarch, 1577 struct agent_expr *ax, struct axs_value *value, 1578 struct type *type, int fieldno) 1579 { 1580 if (TYPE_FIELD_LOC_KIND (type, fieldno) == FIELD_LOC_KIND_PHYSADDR) 1581 { 1582 ax_const_l (ax, TYPE_FIELD_STATIC_PHYSADDR (type, fieldno)); 1583 value->kind = axs_lvalue_memory; 1584 value->type = TYPE_FIELD_TYPE (type, fieldno); 1585 value->optimized_out = 0; 1586 } 1587 else 1588 { 1589 const char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno); 1590 struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0); 1591 1592 if (sym) 1593 { 1594 gen_var_ref (gdbarch, ax, value, sym); 1595 1596 /* Don't error if the value was optimized out, we may be 1597 scanning all static fields and just want to pass over this 1598 and continue with the rest. */ 1599 } 1600 else 1601 { 1602 /* Silently assume this was optimized out; class printing 1603 will let the user know why the data is missing. */ 1604 value->optimized_out = 1; 1605 } 1606 } 1607 } 1608 1609 static int 1610 gen_struct_elt_for_reference (struct expression *exp, 1611 struct agent_expr *ax, struct axs_value *value, 1612 struct type *type, char *fieldname) 1613 { 1614 struct type *t = type; 1615 int i; 1616 1617 if (TYPE_CODE (t) != TYPE_CODE_STRUCT 1618 && TYPE_CODE (t) != TYPE_CODE_UNION) 1619 internal_error (__FILE__, __LINE__, 1620 _("non-aggregate type to gen_struct_elt_for_reference")); 1621 1622 for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--) 1623 { 1624 const char *t_field_name = TYPE_FIELD_NAME (t, i); 1625 1626 if (t_field_name && strcmp (t_field_name, fieldname) == 0) 1627 { 1628 if (field_is_static (&TYPE_FIELD (t, i))) 1629 { 1630 gen_static_field (exp->gdbarch, ax, value, t, i); 1631 if (value->optimized_out) 1632 error (_("static field `%s' has been " 1633 "optimized out, cannot use"), 1634 fieldname); 1635 return 1; 1636 } 1637 if (TYPE_FIELD_PACKED (t, i)) 1638 error (_("pointers to bitfield members not allowed")); 1639 1640 /* FIXME we need a way to do "want_address" equivalent */ 1641 1642 error (_("Cannot reference non-static field \"%s\""), fieldname); 1643 } 1644 } 1645 1646 /* FIXME add other scoped-reference cases here */ 1647 1648 /* Do a last-ditch lookup. */ 1649 return gen_maybe_namespace_elt (exp, ax, value, type, fieldname); 1650 } 1651 1652 /* C++: Return the member NAME of the namespace given by the type 1653 CURTYPE. */ 1654 1655 static int 1656 gen_namespace_elt (struct expression *exp, 1657 struct agent_expr *ax, struct axs_value *value, 1658 const struct type *curtype, char *name) 1659 { 1660 int found = gen_maybe_namespace_elt (exp, ax, value, curtype, name); 1661 1662 if (!found) 1663 error (_("No symbol \"%s\" in namespace \"%s\"."), 1664 name, TYPE_TAG_NAME (curtype)); 1665 1666 return found; 1667 } 1668 1669 /* A helper function used by value_namespace_elt and 1670 value_struct_elt_for_reference. It looks up NAME inside the 1671 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE 1672 is a class and NAME refers to a type in CURTYPE itself (as opposed 1673 to, say, some base class of CURTYPE). */ 1674 1675 static int 1676 gen_maybe_namespace_elt (struct expression *exp, 1677 struct agent_expr *ax, struct axs_value *value, 1678 const struct type *curtype, char *name) 1679 { 1680 const char *namespace_name = TYPE_TAG_NAME (curtype); 1681 struct symbol *sym; 1682 1683 sym = cp_lookup_symbol_namespace (namespace_name, name, 1684 block_for_pc (ax->scope), 1685 VAR_DOMAIN); 1686 1687 if (sym == NULL) 1688 return 0; 1689 1690 gen_var_ref (exp->gdbarch, ax, value, sym); 1691 1692 if (value->optimized_out) 1693 error (_("`%s' has been optimized out, cannot use"), 1694 SYMBOL_PRINT_NAME (sym)); 1695 1696 return 1; 1697 } 1698 1699 1700 static int 1701 gen_aggregate_elt_ref (struct expression *exp, 1702 struct agent_expr *ax, struct axs_value *value, 1703 struct type *type, char *field, 1704 char *operator_name, char *operand_name) 1705 { 1706 switch (TYPE_CODE (type)) 1707 { 1708 case TYPE_CODE_STRUCT: 1709 case TYPE_CODE_UNION: 1710 return gen_struct_elt_for_reference (exp, ax, value, type, field); 1711 break; 1712 case TYPE_CODE_NAMESPACE: 1713 return gen_namespace_elt (exp, ax, value, type, field); 1714 break; 1715 default: 1716 internal_error (__FILE__, __LINE__, 1717 _("non-aggregate type in gen_aggregate_elt_ref")); 1718 } 1719 1720 return 0; 1721 } 1722 1723 /* Generate code for GDB's magical `repeat' operator. 1724 LVALUE @ INT creates an array INT elements long, and whose elements 1725 have the same type as LVALUE, located in memory so that LVALUE is 1726 its first element. For example, argv[0]@argc gives you the array 1727 of command-line arguments. 1728 1729 Unfortunately, because we have to know the types before we actually 1730 have a value for the expression, we can't implement this perfectly 1731 without changing the type system, having values that occupy two 1732 stack slots, doing weird things with sizeof, etc. So we require 1733 the right operand to be a constant expression. */ 1734 static void 1735 gen_repeat (struct expression *exp, union exp_element **pc, 1736 struct agent_expr *ax, struct axs_value *value) 1737 { 1738 struct axs_value value1; 1739 1740 /* We don't want to turn this into an rvalue, so no conversions 1741 here. */ 1742 gen_expr (exp, pc, ax, &value1); 1743 if (value1.kind != axs_lvalue_memory) 1744 error (_("Left operand of `@' must be an object in memory.")); 1745 1746 /* Evaluate the length; it had better be a constant. */ 1747 { 1748 struct value *v = const_expr (pc); 1749 int length; 1750 1751 if (!v) 1752 error (_("Right operand of `@' must be a " 1753 "constant, in agent expressions.")); 1754 if (TYPE_CODE (value_type (v)) != TYPE_CODE_INT) 1755 error (_("Right operand of `@' must be an integer.")); 1756 length = value_as_long (v); 1757 if (length <= 0) 1758 error (_("Right operand of `@' must be positive.")); 1759 1760 /* The top of the stack is already the address of the object, so 1761 all we need to do is frob the type of the lvalue. */ 1762 { 1763 /* FIXME-type-allocation: need a way to free this type when we are 1764 done with it. */ 1765 struct type *array 1766 = lookup_array_range_type (value1.type, 0, length - 1); 1767 1768 value->kind = axs_lvalue_memory; 1769 value->type = array; 1770 } 1771 } 1772 } 1773 1774 1775 /* Emit code for the `sizeof' operator. 1776 *PC should point at the start of the operand expression; we advance it 1777 to the first instruction after the operand. */ 1778 static void 1779 gen_sizeof (struct expression *exp, union exp_element **pc, 1780 struct agent_expr *ax, struct axs_value *value, 1781 struct type *size_type) 1782 { 1783 /* We don't care about the value of the operand expression; we only 1784 care about its type. However, in the current arrangement, the 1785 only way to find an expression's type is to generate code for it. 1786 So we generate code for the operand, and then throw it away, 1787 replacing it with code that simply pushes its size. */ 1788 int start = ax->len; 1789 1790 gen_expr (exp, pc, ax, value); 1791 1792 /* Throw away the code we just generated. */ 1793 ax->len = start; 1794 1795 ax_const_l (ax, TYPE_LENGTH (value->type)); 1796 value->kind = axs_rvalue; 1797 value->type = size_type; 1798 } 1799 1800 1801 /* Generating bytecode from GDB expressions: general recursive thingy */ 1802 1803 /* XXX: i18n */ 1804 /* A gen_expr function written by a Gen-X'er guy. 1805 Append code for the subexpression of EXPR starting at *POS_P to AX. */ 1806 void 1807 gen_expr (struct expression *exp, union exp_element **pc, 1808 struct agent_expr *ax, struct axs_value *value) 1809 { 1810 /* Used to hold the descriptions of operand expressions. */ 1811 struct axs_value value1, value2, value3; 1812 enum exp_opcode op = (*pc)[0].opcode, op2; 1813 int if1, go1, if2, go2, end; 1814 struct type *int_type = builtin_type (exp->gdbarch)->builtin_int; 1815 1816 /* If we're looking at a constant expression, just push its value. */ 1817 { 1818 struct value *v = maybe_const_expr (pc); 1819 1820 if (v) 1821 { 1822 ax_const_l (ax, value_as_long (v)); 1823 value->kind = axs_rvalue; 1824 value->type = check_typedef (value_type (v)); 1825 return; 1826 } 1827 } 1828 1829 /* Otherwise, go ahead and generate code for it. */ 1830 switch (op) 1831 { 1832 /* Binary arithmetic operators. */ 1833 case BINOP_ADD: 1834 case BINOP_SUB: 1835 case BINOP_MUL: 1836 case BINOP_DIV: 1837 case BINOP_REM: 1838 case BINOP_LSH: 1839 case BINOP_RSH: 1840 case BINOP_SUBSCRIPT: 1841 case BINOP_BITWISE_AND: 1842 case BINOP_BITWISE_IOR: 1843 case BINOP_BITWISE_XOR: 1844 case BINOP_EQUAL: 1845 case BINOP_NOTEQUAL: 1846 case BINOP_LESS: 1847 case BINOP_GTR: 1848 case BINOP_LEQ: 1849 case BINOP_GEQ: 1850 (*pc)++; 1851 gen_expr (exp, pc, ax, &value1); 1852 gen_usual_unary (exp, ax, &value1); 1853 gen_expr_binop_rest (exp, op, pc, ax, value, &value1, &value2); 1854 break; 1855 1856 case BINOP_LOGICAL_AND: 1857 (*pc)++; 1858 /* Generate the obvious sequence of tests and jumps. */ 1859 gen_expr (exp, pc, ax, &value1); 1860 gen_usual_unary (exp, ax, &value1); 1861 if1 = ax_goto (ax, aop_if_goto); 1862 go1 = ax_goto (ax, aop_goto); 1863 ax_label (ax, if1, ax->len); 1864 gen_expr (exp, pc, ax, &value2); 1865 gen_usual_unary (exp, ax, &value2); 1866 if2 = ax_goto (ax, aop_if_goto); 1867 go2 = ax_goto (ax, aop_goto); 1868 ax_label (ax, if2, ax->len); 1869 ax_const_l (ax, 1); 1870 end = ax_goto (ax, aop_goto); 1871 ax_label (ax, go1, ax->len); 1872 ax_label (ax, go2, ax->len); 1873 ax_const_l (ax, 0); 1874 ax_label (ax, end, ax->len); 1875 value->kind = axs_rvalue; 1876 value->type = int_type; 1877 break; 1878 1879 case BINOP_LOGICAL_OR: 1880 (*pc)++; 1881 /* Generate the obvious sequence of tests and jumps. */ 1882 gen_expr (exp, pc, ax, &value1); 1883 gen_usual_unary (exp, ax, &value1); 1884 if1 = ax_goto (ax, aop_if_goto); 1885 gen_expr (exp, pc, ax, &value2); 1886 gen_usual_unary (exp, ax, &value2); 1887 if2 = ax_goto (ax, aop_if_goto); 1888 ax_const_l (ax, 0); 1889 end = ax_goto (ax, aop_goto); 1890 ax_label (ax, if1, ax->len); 1891 ax_label (ax, if2, ax->len); 1892 ax_const_l (ax, 1); 1893 ax_label (ax, end, ax->len); 1894 value->kind = axs_rvalue; 1895 value->type = int_type; 1896 break; 1897 1898 case TERNOP_COND: 1899 (*pc)++; 1900 gen_expr (exp, pc, ax, &value1); 1901 gen_usual_unary (exp, ax, &value1); 1902 /* For (A ? B : C), it's easiest to generate subexpression 1903 bytecodes in order, but if_goto jumps on true, so we invert 1904 the sense of A. Then we can do B by dropping through, and 1905 jump to do C. */ 1906 gen_logical_not (ax, &value1, int_type); 1907 if1 = ax_goto (ax, aop_if_goto); 1908 gen_expr (exp, pc, ax, &value2); 1909 gen_usual_unary (exp, ax, &value2); 1910 end = ax_goto (ax, aop_goto); 1911 ax_label (ax, if1, ax->len); 1912 gen_expr (exp, pc, ax, &value3); 1913 gen_usual_unary (exp, ax, &value3); 1914 ax_label (ax, end, ax->len); 1915 /* This is arbitary - what if B and C are incompatible types? */ 1916 value->type = value2.type; 1917 value->kind = value2.kind; 1918 break; 1919 1920 case BINOP_ASSIGN: 1921 (*pc)++; 1922 if ((*pc)[0].opcode == OP_INTERNALVAR) 1923 { 1924 char *name = internalvar_name ((*pc)[1].internalvar); 1925 struct trace_state_variable *tsv; 1926 1927 (*pc) += 3; 1928 gen_expr (exp, pc, ax, value); 1929 tsv = find_trace_state_variable (name); 1930 if (tsv) 1931 { 1932 ax_tsv (ax, aop_setv, tsv->number); 1933 if (trace_kludge) 1934 ax_tsv (ax, aop_tracev, tsv->number); 1935 } 1936 else 1937 error (_("$%s is not a trace state variable, " 1938 "may not assign to it"), name); 1939 } 1940 else 1941 error (_("May only assign to trace state variables")); 1942 break; 1943 1944 case BINOP_ASSIGN_MODIFY: 1945 (*pc)++; 1946 op2 = (*pc)[0].opcode; 1947 (*pc)++; 1948 (*pc)++; 1949 if ((*pc)[0].opcode == OP_INTERNALVAR) 1950 { 1951 char *name = internalvar_name ((*pc)[1].internalvar); 1952 struct trace_state_variable *tsv; 1953 1954 (*pc) += 3; 1955 tsv = find_trace_state_variable (name); 1956 if (tsv) 1957 { 1958 /* The tsv will be the left half of the binary operation. */ 1959 ax_tsv (ax, aop_getv, tsv->number); 1960 if (trace_kludge) 1961 ax_tsv (ax, aop_tracev, tsv->number); 1962 /* Trace state variables are always 64-bit integers. */ 1963 value1.kind = axs_rvalue; 1964 value1.type = builtin_type (exp->gdbarch)->builtin_long_long; 1965 /* Now do right half of expression. */ 1966 gen_expr_binop_rest (exp, op2, pc, ax, value, &value1, &value2); 1967 /* We have a result of the binary op, set the tsv. */ 1968 ax_tsv (ax, aop_setv, tsv->number); 1969 if (trace_kludge) 1970 ax_tsv (ax, aop_tracev, tsv->number); 1971 } 1972 else 1973 error (_("$%s is not a trace state variable, " 1974 "may not assign to it"), name); 1975 } 1976 else 1977 error (_("May only assign to trace state variables")); 1978 break; 1979 1980 /* Note that we need to be a little subtle about generating code 1981 for comma. In C, we can do some optimizations here because 1982 we know the left operand is only being evaluated for effect. 1983 However, if the tracing kludge is in effect, then we always 1984 need to evaluate the left hand side fully, so that all the 1985 variables it mentions get traced. */ 1986 case BINOP_COMMA: 1987 (*pc)++; 1988 gen_expr (exp, pc, ax, &value1); 1989 /* Don't just dispose of the left operand. We might be tracing, 1990 in which case we want to emit code to trace it if it's an 1991 lvalue. */ 1992 gen_traced_pop (exp->gdbarch, ax, &value1); 1993 gen_expr (exp, pc, ax, value); 1994 /* It's the consumer's responsibility to trace the right operand. */ 1995 break; 1996 1997 case OP_LONG: /* some integer constant */ 1998 { 1999 struct type *type = (*pc)[1].type; 2000 LONGEST k = (*pc)[2].longconst; 2001 2002 (*pc) += 4; 2003 gen_int_literal (ax, value, k, type); 2004 } 2005 break; 2006 2007 case OP_VAR_VALUE: 2008 gen_var_ref (exp->gdbarch, ax, value, (*pc)[2].symbol); 2009 2010 if (value->optimized_out) 2011 error (_("`%s' has been optimized out, cannot use"), 2012 SYMBOL_PRINT_NAME ((*pc)[2].symbol)); 2013 2014 (*pc) += 4; 2015 break; 2016 2017 case OP_REGISTER: 2018 { 2019 const char *name = &(*pc)[2].string; 2020 int reg; 2021 2022 (*pc) += 4 + BYTES_TO_EXP_ELEM ((*pc)[1].longconst + 1); 2023 reg = user_reg_map_name_to_regnum (exp->gdbarch, name, strlen (name)); 2024 if (reg == -1) 2025 internal_error (__FILE__, __LINE__, 2026 _("Register $%s not available"), name); 2027 /* No support for tracing user registers yet. */ 2028 if (reg >= gdbarch_num_regs (exp->gdbarch) 2029 + gdbarch_num_pseudo_regs (exp->gdbarch)) 2030 error (_("'%s' is a user-register; " 2031 "GDB cannot yet trace user-register contents."), 2032 name); 2033 value->kind = axs_lvalue_register; 2034 value->u.reg = reg; 2035 value->type = register_type (exp->gdbarch, reg); 2036 } 2037 break; 2038 2039 case OP_INTERNALVAR: 2040 { 2041 struct internalvar *var = (*pc)[1].internalvar; 2042 const char *name = internalvar_name (var); 2043 struct trace_state_variable *tsv; 2044 2045 (*pc) += 3; 2046 tsv = find_trace_state_variable (name); 2047 if (tsv) 2048 { 2049 ax_tsv (ax, aop_getv, tsv->number); 2050 if (trace_kludge) 2051 ax_tsv (ax, aop_tracev, tsv->number); 2052 /* Trace state variables are always 64-bit integers. */ 2053 value->kind = axs_rvalue; 2054 value->type = builtin_type (exp->gdbarch)->builtin_long_long; 2055 } 2056 else if (! compile_internalvar_to_ax (var, ax, value)) 2057 error (_("$%s is not a trace state variable; GDB agent " 2058 "expressions cannot use convenience variables."), name); 2059 } 2060 break; 2061 2062 /* Weirdo operator: see comments for gen_repeat for details. */ 2063 case BINOP_REPEAT: 2064 /* Note that gen_repeat handles its own argument evaluation. */ 2065 (*pc)++; 2066 gen_repeat (exp, pc, ax, value); 2067 break; 2068 2069 case UNOP_CAST: 2070 { 2071 struct type *type = (*pc)[1].type; 2072 2073 (*pc) += 3; 2074 gen_expr (exp, pc, ax, value); 2075 gen_cast (ax, value, type); 2076 } 2077 break; 2078 2079 case UNOP_CAST_TYPE: 2080 { 2081 int offset; 2082 struct value *val; 2083 struct type *type; 2084 2085 ++*pc; 2086 offset = *pc - exp->elts; 2087 val = evaluate_subexp (NULL, exp, &offset, EVAL_AVOID_SIDE_EFFECTS); 2088 type = value_type (val); 2089 *pc = &exp->elts[offset]; 2090 2091 gen_expr (exp, pc, ax, value); 2092 gen_cast (ax, value, type); 2093 } 2094 break; 2095 2096 case UNOP_MEMVAL: 2097 { 2098 struct type *type = check_typedef ((*pc)[1].type); 2099 2100 (*pc) += 3; 2101 gen_expr (exp, pc, ax, value); 2102 2103 /* If we have an axs_rvalue or an axs_lvalue_memory, then we 2104 already have the right value on the stack. For 2105 axs_lvalue_register, we must convert. */ 2106 if (value->kind == axs_lvalue_register) 2107 require_rvalue (ax, value); 2108 2109 value->type = type; 2110 value->kind = axs_lvalue_memory; 2111 } 2112 break; 2113 2114 case UNOP_MEMVAL_TYPE: 2115 { 2116 int offset; 2117 struct value *val; 2118 struct type *type; 2119 2120 ++*pc; 2121 offset = *pc - exp->elts; 2122 val = evaluate_subexp (NULL, exp, &offset, EVAL_AVOID_SIDE_EFFECTS); 2123 type = value_type (val); 2124 *pc = &exp->elts[offset]; 2125 2126 gen_expr (exp, pc, ax, value); 2127 2128 /* If we have an axs_rvalue or an axs_lvalue_memory, then we 2129 already have the right value on the stack. For 2130 axs_lvalue_register, we must convert. */ 2131 if (value->kind == axs_lvalue_register) 2132 require_rvalue (ax, value); 2133 2134 value->type = type; 2135 value->kind = axs_lvalue_memory; 2136 } 2137 break; 2138 2139 case UNOP_PLUS: 2140 (*pc)++; 2141 /* + FOO is equivalent to 0 + FOO, which can be optimized. */ 2142 gen_expr (exp, pc, ax, value); 2143 gen_usual_unary (exp, ax, value); 2144 break; 2145 2146 case UNOP_NEG: 2147 (*pc)++; 2148 /* -FOO is equivalent to 0 - FOO. */ 2149 gen_int_literal (ax, &value1, 0, 2150 builtin_type (exp->gdbarch)->builtin_int); 2151 gen_usual_unary (exp, ax, &value1); /* shouldn't do much */ 2152 gen_expr (exp, pc, ax, &value2); 2153 gen_usual_unary (exp, ax, &value2); 2154 gen_usual_arithmetic (exp, ax, &value1, &value2); 2155 gen_binop (ax, value, &value1, &value2, aop_sub, aop_sub, 1, "negation"); 2156 break; 2157 2158 case UNOP_LOGICAL_NOT: 2159 (*pc)++; 2160 gen_expr (exp, pc, ax, value); 2161 gen_usual_unary (exp, ax, value); 2162 gen_logical_not (ax, value, int_type); 2163 break; 2164 2165 case UNOP_COMPLEMENT: 2166 (*pc)++; 2167 gen_expr (exp, pc, ax, value); 2168 gen_usual_unary (exp, ax, value); 2169 gen_integral_promotions (exp, ax, value); 2170 gen_complement (ax, value); 2171 break; 2172 2173 case UNOP_IND: 2174 (*pc)++; 2175 gen_expr (exp, pc, ax, value); 2176 gen_usual_unary (exp, ax, value); 2177 if (!pointer_type (value->type)) 2178 error (_("Argument of unary `*' is not a pointer.")); 2179 gen_deref (ax, value); 2180 break; 2181 2182 case UNOP_ADDR: 2183 (*pc)++; 2184 gen_expr (exp, pc, ax, value); 2185 gen_address_of (ax, value); 2186 break; 2187 2188 case UNOP_SIZEOF: 2189 (*pc)++; 2190 /* Notice that gen_sizeof handles its own operand, unlike most 2191 of the other unary operator functions. This is because we 2192 have to throw away the code we generate. */ 2193 gen_sizeof (exp, pc, ax, value, 2194 builtin_type (exp->gdbarch)->builtin_int); 2195 break; 2196 2197 case STRUCTOP_STRUCT: 2198 case STRUCTOP_PTR: 2199 { 2200 int length = (*pc)[1].longconst; 2201 char *name = &(*pc)[2].string; 2202 2203 (*pc) += 4 + BYTES_TO_EXP_ELEM (length + 1); 2204 gen_expr (exp, pc, ax, value); 2205 if (op == STRUCTOP_STRUCT) 2206 gen_struct_ref (exp, ax, value, name, ".", "structure or union"); 2207 else if (op == STRUCTOP_PTR) 2208 gen_struct_ref (exp, ax, value, name, "->", 2209 "pointer to a structure or union"); 2210 else 2211 /* If this `if' chain doesn't handle it, then the case list 2212 shouldn't mention it, and we shouldn't be here. */ 2213 internal_error (__FILE__, __LINE__, 2214 _("gen_expr: unhandled struct case")); 2215 } 2216 break; 2217 2218 case OP_THIS: 2219 { 2220 struct symbol *sym, *func; 2221 struct block *b; 2222 const struct language_defn *lang; 2223 2224 b = block_for_pc (ax->scope); 2225 func = block_linkage_function (b); 2226 lang = language_def (SYMBOL_LANGUAGE (func)); 2227 2228 sym = lookup_language_this (lang, b); 2229 if (!sym) 2230 error (_("no `%s' found"), lang->la_name_of_this); 2231 2232 gen_var_ref (exp->gdbarch, ax, value, sym); 2233 2234 if (value->optimized_out) 2235 error (_("`%s' has been optimized out, cannot use"), 2236 SYMBOL_PRINT_NAME (sym)); 2237 2238 (*pc) += 2; 2239 } 2240 break; 2241 2242 case OP_SCOPE: 2243 { 2244 struct type *type = (*pc)[1].type; 2245 int length = longest_to_int ((*pc)[2].longconst); 2246 char *name = &(*pc)[3].string; 2247 int found; 2248 2249 found = gen_aggregate_elt_ref (exp, ax, value, type, name, 2250 "?", "??"); 2251 if (!found) 2252 error (_("There is no field named %s"), name); 2253 (*pc) += 5 + BYTES_TO_EXP_ELEM (length + 1); 2254 } 2255 break; 2256 2257 case OP_TYPE: 2258 case OP_TYPEOF: 2259 case OP_DECLTYPE: 2260 error (_("Attempt to use a type name as an expression.")); 2261 2262 default: 2263 error (_("Unsupported operator %s (%d) in expression."), 2264 op_name (exp, op), op); 2265 } 2266 } 2267 2268 /* This handles the middle-to-right-side of code generation for binary 2269 expressions, which is shared between regular binary operations and 2270 assign-modify (+= and friends) expressions. */ 2271 2272 static void 2273 gen_expr_binop_rest (struct expression *exp, 2274 enum exp_opcode op, union exp_element **pc, 2275 struct agent_expr *ax, struct axs_value *value, 2276 struct axs_value *value1, struct axs_value *value2) 2277 { 2278 struct type *int_type = builtin_type (exp->gdbarch)->builtin_int; 2279 2280 gen_expr (exp, pc, ax, value2); 2281 gen_usual_unary (exp, ax, value2); 2282 gen_usual_arithmetic (exp, ax, value1, value2); 2283 switch (op) 2284 { 2285 case BINOP_ADD: 2286 if (TYPE_CODE (value1->type) == TYPE_CODE_INT 2287 && pointer_type (value2->type)) 2288 { 2289 /* Swap the values and proceed normally. */ 2290 ax_simple (ax, aop_swap); 2291 gen_ptradd (ax, value, value2, value1); 2292 } 2293 else if (pointer_type (value1->type) 2294 && TYPE_CODE (value2->type) == TYPE_CODE_INT) 2295 gen_ptradd (ax, value, value1, value2); 2296 else 2297 gen_binop (ax, value, value1, value2, 2298 aop_add, aop_add, 1, "addition"); 2299 break; 2300 case BINOP_SUB: 2301 if (pointer_type (value1->type) 2302 && TYPE_CODE (value2->type) == TYPE_CODE_INT) 2303 gen_ptrsub (ax,value, value1, value2); 2304 else if (pointer_type (value1->type) 2305 && pointer_type (value2->type)) 2306 /* FIXME --- result type should be ptrdiff_t */ 2307 gen_ptrdiff (ax, value, value1, value2, 2308 builtin_type (exp->gdbarch)->builtin_long); 2309 else 2310 gen_binop (ax, value, value1, value2, 2311 aop_sub, aop_sub, 1, "subtraction"); 2312 break; 2313 case BINOP_MUL: 2314 gen_binop (ax, value, value1, value2, 2315 aop_mul, aop_mul, 1, "multiplication"); 2316 break; 2317 case BINOP_DIV: 2318 gen_binop (ax, value, value1, value2, 2319 aop_div_signed, aop_div_unsigned, 1, "division"); 2320 break; 2321 case BINOP_REM: 2322 gen_binop (ax, value, value1, value2, 2323 aop_rem_signed, aop_rem_unsigned, 1, "remainder"); 2324 break; 2325 case BINOP_LSH: 2326 gen_binop (ax, value, value1, value2, 2327 aop_lsh, aop_lsh, 1, "left shift"); 2328 break; 2329 case BINOP_RSH: 2330 gen_binop (ax, value, value1, value2, 2331 aop_rsh_signed, aop_rsh_unsigned, 1, "right shift"); 2332 break; 2333 case BINOP_SUBSCRIPT: 2334 { 2335 struct type *type; 2336 2337 if (binop_types_user_defined_p (op, value1->type, value2->type)) 2338 { 2339 error (_("cannot subscript requested type: " 2340 "cannot call user defined functions")); 2341 } 2342 else 2343 { 2344 /* If the user attempts to subscript something that is not 2345 an array or pointer type (like a plain int variable for 2346 example), then report this as an error. */ 2347 type = check_typedef (value1->type); 2348 if (TYPE_CODE (type) != TYPE_CODE_ARRAY 2349 && TYPE_CODE (type) != TYPE_CODE_PTR) 2350 { 2351 if (TYPE_NAME (type)) 2352 error (_("cannot subscript something of type `%s'"), 2353 TYPE_NAME (type)); 2354 else 2355 error (_("cannot subscript requested type")); 2356 } 2357 } 2358 2359 if (!is_integral_type (value2->type)) 2360 error (_("Argument to arithmetic operation " 2361 "not a number or boolean.")); 2362 2363 gen_ptradd (ax, value, value1, value2); 2364 gen_deref (ax, value); 2365 break; 2366 } 2367 case BINOP_BITWISE_AND: 2368 gen_binop (ax, value, value1, value2, 2369 aop_bit_and, aop_bit_and, 0, "bitwise and"); 2370 break; 2371 2372 case BINOP_BITWISE_IOR: 2373 gen_binop (ax, value, value1, value2, 2374 aop_bit_or, aop_bit_or, 0, "bitwise or"); 2375 break; 2376 2377 case BINOP_BITWISE_XOR: 2378 gen_binop (ax, value, value1, value2, 2379 aop_bit_xor, aop_bit_xor, 0, "bitwise exclusive-or"); 2380 break; 2381 2382 case BINOP_EQUAL: 2383 gen_equal (ax, value, value1, value2, int_type); 2384 break; 2385 2386 case BINOP_NOTEQUAL: 2387 gen_equal (ax, value, value1, value2, int_type); 2388 gen_logical_not (ax, value, int_type); 2389 break; 2390 2391 case BINOP_LESS: 2392 gen_less (ax, value, value1, value2, int_type); 2393 break; 2394 2395 case BINOP_GTR: 2396 ax_simple (ax, aop_swap); 2397 gen_less (ax, value, value1, value2, int_type); 2398 break; 2399 2400 case BINOP_LEQ: 2401 ax_simple (ax, aop_swap); 2402 gen_less (ax, value, value1, value2, int_type); 2403 gen_logical_not (ax, value, int_type); 2404 break; 2405 2406 case BINOP_GEQ: 2407 gen_less (ax, value, value1, value2, int_type); 2408 gen_logical_not (ax, value, int_type); 2409 break; 2410 2411 default: 2412 /* We should only list operators in the outer case statement 2413 that we actually handle in the inner case statement. */ 2414 internal_error (__FILE__, __LINE__, 2415 _("gen_expr: op case sets don't match")); 2416 } 2417 } 2418 2419 2420 /* Given a single variable and a scope, generate bytecodes to trace 2421 its value. This is for use in situations where we have only a 2422 variable's name, and no parsed expression; for instance, when the 2423 name comes from a list of local variables of a function. */ 2424 2425 struct agent_expr * 2426 gen_trace_for_var (CORE_ADDR scope, struct gdbarch *gdbarch, 2427 struct symbol *var) 2428 { 2429 struct cleanup *old_chain = 0; 2430 struct agent_expr *ax = new_agent_expr (gdbarch, scope); 2431 struct axs_value value; 2432 2433 old_chain = make_cleanup_free_agent_expr (ax); 2434 2435 trace_kludge = 1; 2436 gen_var_ref (gdbarch, ax, &value, var); 2437 2438 /* If there is no actual variable to trace, flag it by returning 2439 an empty agent expression. */ 2440 if (value.optimized_out) 2441 { 2442 do_cleanups (old_chain); 2443 return NULL; 2444 } 2445 2446 /* Make sure we record the final object, and get rid of it. */ 2447 gen_traced_pop (gdbarch, ax, &value); 2448 2449 /* Oh, and terminate. */ 2450 ax_simple (ax, aop_end); 2451 2452 /* We have successfully built the agent expr, so cancel the cleanup 2453 request. If we add more cleanups that we always want done, this 2454 will have to get more complicated. */ 2455 discard_cleanups (old_chain); 2456 return ax; 2457 } 2458 2459 /* Generating bytecode from GDB expressions: driver */ 2460 2461 /* Given a GDB expression EXPR, return bytecode to trace its value. 2462 The result will use the `trace' and `trace_quick' bytecodes to 2463 record the value of all memory touched by the expression. The 2464 caller can then use the ax_reqs function to discover which 2465 registers it relies upon. */ 2466 struct agent_expr * 2467 gen_trace_for_expr (CORE_ADDR scope, struct expression *expr) 2468 { 2469 struct cleanup *old_chain = 0; 2470 struct agent_expr *ax = new_agent_expr (expr->gdbarch, scope); 2471 union exp_element *pc; 2472 struct axs_value value; 2473 2474 old_chain = make_cleanup_free_agent_expr (ax); 2475 2476 pc = expr->elts; 2477 trace_kludge = 1; 2478 value.optimized_out = 0; 2479 gen_expr (expr, &pc, ax, &value); 2480 2481 /* Make sure we record the final object, and get rid of it. */ 2482 gen_traced_pop (expr->gdbarch, ax, &value); 2483 2484 /* Oh, and terminate. */ 2485 ax_simple (ax, aop_end); 2486 2487 /* We have successfully built the agent expr, so cancel the cleanup 2488 request. If we add more cleanups that we always want done, this 2489 will have to get more complicated. */ 2490 discard_cleanups (old_chain); 2491 return ax; 2492 } 2493 2494 /* Given a GDB expression EXPR, return a bytecode sequence that will 2495 evaluate and return a result. The bytecodes will do a direct 2496 evaluation, using the current data on the target, rather than 2497 recording blocks of memory and registers for later use, as 2498 gen_trace_for_expr does. The generated bytecode sequence leaves 2499 the result of expression evaluation on the top of the stack. */ 2500 2501 struct agent_expr * 2502 gen_eval_for_expr (CORE_ADDR scope, struct expression *expr) 2503 { 2504 struct cleanup *old_chain = 0; 2505 struct agent_expr *ax = new_agent_expr (expr->gdbarch, scope); 2506 union exp_element *pc; 2507 struct axs_value value; 2508 2509 old_chain = make_cleanup_free_agent_expr (ax); 2510 2511 pc = expr->elts; 2512 trace_kludge = 0; 2513 value.optimized_out = 0; 2514 gen_expr (expr, &pc, ax, &value); 2515 2516 require_rvalue (ax, &value); 2517 2518 /* Oh, and terminate. */ 2519 ax_simple (ax, aop_end); 2520 2521 /* We have successfully built the agent expr, so cancel the cleanup 2522 request. If we add more cleanups that we always want done, this 2523 will have to get more complicated. */ 2524 discard_cleanups (old_chain); 2525 return ax; 2526 } 2527 2528 struct agent_expr * 2529 gen_trace_for_return_address (CORE_ADDR scope, struct gdbarch *gdbarch) 2530 { 2531 struct cleanup *old_chain = 0; 2532 struct agent_expr *ax = new_agent_expr (gdbarch, scope); 2533 struct axs_value value; 2534 2535 old_chain = make_cleanup_free_agent_expr (ax); 2536 2537 trace_kludge = 1; 2538 2539 gdbarch_gen_return_address (gdbarch, ax, &value, scope); 2540 2541 /* Make sure we record the final object, and get rid of it. */ 2542 gen_traced_pop (gdbarch, ax, &value); 2543 2544 /* Oh, and terminate. */ 2545 ax_simple (ax, aop_end); 2546 2547 /* We have successfully built the agent expr, so cancel the cleanup 2548 request. If we add more cleanups that we always want done, this 2549 will have to get more complicated. */ 2550 discard_cleanups (old_chain); 2551 return ax; 2552 } 2553 2554 /* Given a collection of printf-style arguments, generate code to 2555 evaluate the arguments and pass everything to a special 2556 bytecode. */ 2557 2558 struct agent_expr * 2559 gen_printf (CORE_ADDR scope, struct gdbarch *gdbarch, 2560 CORE_ADDR function, LONGEST channel, 2561 const char *format, int fmtlen, 2562 struct format_piece *frags, 2563 int nargs, struct expression **exprs) 2564 { 2565 struct cleanup *old_chain = 0; 2566 struct agent_expr *ax = new_agent_expr (gdbarch, scope); 2567 union exp_element *pc; 2568 struct axs_value value; 2569 int tem; 2570 2571 old_chain = make_cleanup_free_agent_expr (ax); 2572 2573 /* Evaluate and push the args on the stack in reverse order, 2574 for simplicity of collecting them on the target side. */ 2575 for (tem = nargs - 1; tem >= 0; --tem) 2576 { 2577 pc = exprs[tem]->elts; 2578 /* We're computing values, not doing side effects. */ 2579 trace_kludge = 0; 2580 value.optimized_out = 0; 2581 gen_expr (exprs[tem], &pc, ax, &value); 2582 require_rvalue (ax, &value); 2583 } 2584 2585 /* Push function and channel. */ 2586 ax_const_l (ax, channel); 2587 ax_const_l (ax, function); 2588 2589 /* Issue the printf bytecode proper. */ 2590 ax_simple (ax, aop_printf); 2591 ax_simple (ax, nargs); 2592 ax_string (ax, format, fmtlen); 2593 2594 /* And terminate. */ 2595 ax_simple (ax, aop_end); 2596 2597 /* We have successfully built the agent expr, so cancel the cleanup 2598 request. If we add more cleanups that we always want done, this 2599 will have to get more complicated. */ 2600 discard_cleanups (old_chain); 2601 2602 return ax; 2603 } 2604 2605 static void 2606 agent_eval_command_one (char *exp, int eval, CORE_ADDR pc) 2607 { 2608 struct cleanup *old_chain = 0; 2609 struct expression *expr; 2610 struct agent_expr *agent; 2611 const char *arg; 2612 2613 if (!eval) 2614 { 2615 trace_string_kludge = 0; 2616 if (*exp == '/') 2617 exp = decode_agent_options (exp); 2618 } 2619 2620 arg = exp; 2621 if (!eval && strcmp (arg, "$_ret") == 0) 2622 { 2623 agent = gen_trace_for_return_address (pc, get_current_arch ()); 2624 old_chain = make_cleanup_free_agent_expr (agent); 2625 } 2626 else 2627 { 2628 expr = parse_exp_1 (&arg, pc, block_for_pc (pc), 0); 2629 old_chain = make_cleanup (free_current_contents, &expr); 2630 if (eval) 2631 agent = gen_eval_for_expr (pc, expr); 2632 else 2633 agent = gen_trace_for_expr (pc, expr); 2634 make_cleanup_free_agent_expr (agent); 2635 } 2636 2637 ax_reqs (agent); 2638 ax_print (gdb_stdout, agent); 2639 2640 /* It would be nice to call ax_reqs here to gather some general info 2641 about the expression, and then print out the result. */ 2642 2643 do_cleanups (old_chain); 2644 dont_repeat (); 2645 } 2646 2647 static void 2648 agent_command_1 (char *exp, int eval) 2649 { 2650 /* We don't deal with overlay debugging at the moment. We need to 2651 think more carefully about this. If you copy this code into 2652 another command, change the error message; the user shouldn't 2653 have to know anything about agent expressions. */ 2654 if (overlay_debugging) 2655 error (_("GDB can't do agent expression translation with overlays.")); 2656 2657 if (exp == 0) 2658 error_no_arg (_("expression to translate")); 2659 2660 if (check_for_argument (&exp, "-at", sizeof ("-at") - 1)) 2661 { 2662 struct linespec_result canonical; 2663 int ix; 2664 struct linespec_sals *iter; 2665 struct cleanup *old_chain; 2666 2667 exp = skip_spaces (exp); 2668 init_linespec_result (&canonical); 2669 decode_line_full (&exp, DECODE_LINE_FUNFIRSTLINE, 2670 (struct symtab *) NULL, 0, &canonical, 2671 NULL, NULL); 2672 old_chain = make_cleanup_destroy_linespec_result (&canonical); 2673 exp = skip_spaces (exp); 2674 if (exp[0] == ',') 2675 { 2676 exp++; 2677 exp = skip_spaces (exp); 2678 } 2679 for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix) 2680 { 2681 int i; 2682 2683 for (i = 0; i < iter->sals.nelts; i++) 2684 agent_eval_command_one (exp, eval, iter->sals.sals[i].pc); 2685 } 2686 do_cleanups (old_chain); 2687 } 2688 else 2689 agent_eval_command_one (exp, eval, get_frame_pc (get_current_frame ())); 2690 2691 dont_repeat (); 2692 } 2693 2694 static void 2695 agent_command (char *exp, int from_tty) 2696 { 2697 agent_command_1 (exp, 0); 2698 } 2699 2700 /* Parse the given expression, compile it into an agent expression 2701 that does direct evaluation, and display the resulting 2702 expression. */ 2703 2704 static void 2705 agent_eval_command (char *exp, int from_tty) 2706 { 2707 agent_command_1 (exp, 1); 2708 } 2709 2710 /* Parse the given expression, compile it into an agent expression 2711 that does a printf, and display the resulting expression. */ 2712 2713 static void 2714 maint_agent_printf_command (char *exp, int from_tty) 2715 { 2716 struct cleanup *old_chain = 0; 2717 struct expression *expr; 2718 struct expression *argvec[100]; 2719 struct agent_expr *agent; 2720 struct frame_info *fi = get_current_frame (); /* need current scope */ 2721 const char *cmdrest; 2722 const char *format_start, *format_end; 2723 struct format_piece *fpieces; 2724 int nargs; 2725 2726 /* We don't deal with overlay debugging at the moment. We need to 2727 think more carefully about this. If you copy this code into 2728 another command, change the error message; the user shouldn't 2729 have to know anything about agent expressions. */ 2730 if (overlay_debugging) 2731 error (_("GDB can't do agent expression translation with overlays.")); 2732 2733 if (exp == 0) 2734 error_no_arg (_("expression to translate")); 2735 2736 cmdrest = exp; 2737 2738 cmdrest = skip_spaces_const (cmdrest); 2739 2740 if (*cmdrest++ != '"') 2741 error (_("Must start with a format string.")); 2742 2743 format_start = cmdrest; 2744 2745 fpieces = parse_format_string (&cmdrest); 2746 2747 old_chain = make_cleanup (free_format_pieces_cleanup, &fpieces); 2748 2749 format_end = cmdrest; 2750 2751 if (*cmdrest++ != '"') 2752 error (_("Bad format string, non-terminated '\"'.")); 2753 2754 cmdrest = skip_spaces_const (cmdrest); 2755 2756 if (*cmdrest != ',' && *cmdrest != 0) 2757 error (_("Invalid argument syntax")); 2758 2759 if (*cmdrest == ',') 2760 cmdrest++; 2761 cmdrest = skip_spaces_const (cmdrest); 2762 2763 nargs = 0; 2764 while (*cmdrest != '\0') 2765 { 2766 const char *cmd1; 2767 2768 cmd1 = cmdrest; 2769 expr = parse_exp_1 (&cmd1, 0, (struct block *) 0, 1); 2770 argvec[nargs] = expr; 2771 ++nargs; 2772 cmdrest = cmd1; 2773 if (*cmdrest == ',') 2774 ++cmdrest; 2775 /* else complain? */ 2776 } 2777 2778 2779 agent = gen_printf (get_frame_pc (fi), get_current_arch (), 0, 0, 2780 format_start, format_end - format_start, 2781 fpieces, nargs, argvec); 2782 make_cleanup_free_agent_expr (agent); 2783 ax_reqs (agent); 2784 ax_print (gdb_stdout, agent); 2785 2786 /* It would be nice to call ax_reqs here to gather some general info 2787 about the expression, and then print out the result. */ 2788 2789 do_cleanups (old_chain); 2790 dont_repeat (); 2791 } 2792 2793 2794 /* Initialization code. */ 2795 2796 void _initialize_ax_gdb (void); 2797 void 2798 _initialize_ax_gdb (void) 2799 { 2800 add_cmd ("agent", class_maintenance, agent_command, 2801 _("\ 2802 Translate an expression into remote agent bytecode for tracing.\n\ 2803 Usage: maint agent [-at location,] EXPRESSION\n\ 2804 If -at is given, generate remote agent bytecode for this location.\n\ 2805 If not, generate remote agent bytecode for current frame pc address."), 2806 &maintenancelist); 2807 2808 add_cmd ("agent-eval", class_maintenance, agent_eval_command, 2809 _("\ 2810 Translate an expression into remote agent bytecode for evaluation.\n\ 2811 Usage: maint agent-eval [-at location,] EXPRESSION\n\ 2812 If -at is given, generate remote agent bytecode for this location.\n\ 2813 If not, generate remote agent bytecode for current frame pc address."), 2814 &maintenancelist); 2815 2816 add_cmd ("agent-printf", class_maintenance, maint_agent_printf_command, 2817 _("Translate an expression into remote " 2818 "agent bytecode for evaluation and display the bytecodes."), 2819 &maintenancelist); 2820 } 2821