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