diff options
Diffstat (limited to 'contrib/gdb/gdb/ax-gdb.c')
| -rw-r--r-- | contrib/gdb/gdb/ax-gdb.c | 1942 |
1 files changed, 1942 insertions, 0 deletions
diff --git a/contrib/gdb/gdb/ax-gdb.c b/contrib/gdb/gdb/ax-gdb.c new file mode 100644 index 0000000..55cc856 --- /dev/null +++ b/contrib/gdb/gdb/ax-gdb.c @@ -0,0 +1,1942 @@ +/* GDB-specific functions for operating on agent expressions + Copyright 1998 Free Software Foundation, Inc. + +This file is part of GDB. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +/* $Id: ax-gdb.c,v 1.8 1998/12/03 05:34:24 cagney Exp $ */ + +#include "defs.h" +#include "symtab.h" +#include "symfile.h" +#include "gdbtypes.h" +#include "value.h" +#include "expression.h" +#include "command.h" +#include "gdbcmd.h" +#include "frame.h" +#include "target.h" +#include "ax.h" +#include "ax-gdb.h" + +/* Probably the best way to read this file is to start with the types + and enums in ax-gdb.h, and then look at gen_expr, towards the + bottom; that's the main function that looks at the GDB expressions + and calls everything else to generate code. + + I'm beginning to wonder whether it wouldn't be nicer to internally + generate trees, with types, and then spit out the bytecode in + linear form afterwards; we could generate fewer `swap', `ext', and + `zero_ext' bytecodes that way; it would make good constant folding + easier, too. But at the moment, I think we should be willing to + pay for the simplicity of this code with less-than-optimal bytecode + strings. + + Remember, "GBD" stands for "Great Britain, Dammit!" So be careful. */ + + + +/* Prototypes for local functions. */ + +/* There's a standard order to the arguments of these functions: + union exp_element ** --- pointer into expression + struct agent_expr * --- agent expression buffer to generate code into + struct axs_value * --- describes value left on top of stack */ + +static struct value *const_var_ref PARAMS ((struct symbol *var)); +static struct value *const_expr PARAMS ((union exp_element **pc)); +static struct value *maybe_const_expr PARAMS ((union exp_element **pc)); + +static void gen_traced_pop PARAMS ((struct agent_expr *, struct axs_value *)); + +static void gen_sign_extend PARAMS ((struct agent_expr *, struct type *)); +static void gen_extend PARAMS ((struct agent_expr *, struct type *)); +static void gen_fetch PARAMS ((struct agent_expr *, struct type *)); +static void gen_left_shift PARAMS ((struct agent_expr *, int)); + + +static void gen_frame_args_address PARAMS ((struct agent_expr *)); +static void gen_frame_locals_address PARAMS ((struct agent_expr *)); +static void gen_offset PARAMS ((struct agent_expr *ax, int offset)); +static void gen_sym_offset PARAMS ((struct agent_expr *, struct symbol *)); +static void gen_var_ref PARAMS ((struct agent_expr *ax, + struct axs_value *value, + struct symbol *var)); + + +static void gen_int_literal PARAMS ((struct agent_expr *ax, + struct axs_value *value, + LONGEST k, struct type *type)); + + +static void require_rvalue PARAMS ((struct agent_expr *ax, + struct axs_value *value)); +static void gen_usual_unary PARAMS ((struct agent_expr *ax, + struct axs_value *value)); +static int type_wider_than PARAMS ((struct type *type1, + struct type *type2)); +static struct type *max_type PARAMS ((struct type *type1, + struct type *type2)); +static void gen_conversion PARAMS ((struct agent_expr *ax, + struct type *from, + struct type *to)); +static int is_nontrivial_conversion PARAMS ((struct type *from, + struct type *to)); +static void gen_usual_arithmetic PARAMS ((struct agent_expr *ax, + struct axs_value *value1, + struct axs_value *value2)); +static void gen_integral_promotions PARAMS ((struct agent_expr *ax, + struct axs_value *value)); +static void gen_cast PARAMS ((struct agent_expr *ax, + struct axs_value *value, + struct type *type)); +static void gen_scale PARAMS ((struct agent_expr *ax, + enum agent_op op, + struct type *type)); +static void gen_add PARAMS ((struct agent_expr *ax, + struct axs_value *value, + struct axs_value *value1, + struct axs_value *value2, + char *name)); +static void gen_sub PARAMS ((struct agent_expr *ax, + struct axs_value *value, + struct axs_value *value1, + struct axs_value *value2)); +static void gen_binop PARAMS ((struct agent_expr *ax, + struct axs_value *value, + struct axs_value *value1, + struct axs_value *value2, + enum agent_op op, + enum agent_op op_unsigned, + int may_carry, + char *name)); +static void gen_logical_not PARAMS ((struct agent_expr *ax, + struct axs_value *value)); +static void gen_complement PARAMS ((struct agent_expr *ax, + struct axs_value *value)); +static void gen_deref PARAMS ((struct agent_expr *, struct axs_value *)); +static void gen_address_of PARAMS ((struct agent_expr *, struct axs_value *)); +static int find_field PARAMS ((struct type *type, char *name)); +static void gen_bitfield_ref PARAMS ((struct agent_expr *ax, + struct axs_value *value, + struct type *type, + int start, int end)); +static void gen_struct_ref PARAMS ((struct agent_expr *ax, + struct axs_value *value, + char *field, + char *operator_name, + char *operand_name)); +static void gen_repeat PARAMS ((union exp_element **pc, + struct agent_expr *ax, + struct axs_value *value)); +static void gen_sizeof PARAMS ((union exp_element **pc, + struct agent_expr *ax, + struct axs_value *value)); +static void gen_expr PARAMS ((union exp_element **pc, + struct agent_expr *ax, + struct axs_value *value)); + +static void print_axs_value PARAMS ((GDB_FILE *f, struct axs_value *value)); +static void agent_command PARAMS ((char *exp, int from_tty)); + + +/* Detecting constant expressions. */ + +/* If the variable reference at *PC is a constant, return its value. + Otherwise, return zero. + + Hey, Wally! How can a variable reference be a constant? + + Well, Beav, this function really handles the OP_VAR_VALUE operator, + not specifically variable references. GDB uses OP_VAR_VALUE to + refer to any kind of symbolic reference: function names, enum + elements, and goto labels are all handled through the OP_VAR_VALUE + operator, even though they're constants. It makes sense given the + situation. + + Gee, Wally, don'cha wonder sometimes if data representations that + subvert commonly accepted definitions of terms in favor of heavily + context-specific interpretations are really just a tool of the + programming hegemony to preserve their power and exclude the + proletariat? */ + +static struct value * +const_var_ref (var) + struct symbol *var; +{ + struct type *type = SYMBOL_TYPE (var); + + switch (SYMBOL_CLASS (var)) + { + case LOC_CONST: + return value_from_longest (type, (LONGEST) SYMBOL_VALUE (var)); + + case LOC_LABEL: + return value_from_longest (type, (LONGEST) SYMBOL_VALUE_ADDRESS (var)); + + default: + return 0; + } +} + + +/* If the expression starting at *PC has a constant value, return it. + Otherwise, return zero. If we return a value, then *PC will be + advanced to the end of it. If we return zero, *PC could be + anywhere. */ +static struct value * +const_expr (pc) + union exp_element **pc; +{ + enum exp_opcode op = (*pc)->opcode; + struct value *v1; + + switch (op) + { + case OP_LONG: + { + struct type *type = (*pc)[1].type; + LONGEST k = (*pc)[2].longconst; + (*pc) += 4; + return value_from_longest (type, k); + } + + case OP_VAR_VALUE: + { + struct value *v = const_var_ref ((*pc)[2].symbol); + (*pc) += 4; + return v; + } + + /* We could add more operators in here. */ + + case UNOP_NEG: + (*pc)++; + v1 = const_expr (pc); + if (v1) + return value_neg (v1); + else + return 0; + + default: + return 0; + } +} + + +/* Like const_expr, but guarantee also that *PC is undisturbed if the + expression is not constant. */ +static struct value * +maybe_const_expr (pc) + union exp_element **pc; +{ + union exp_element *tentative_pc = *pc; + struct value *v = const_expr (&tentative_pc); + + /* If we got a value, then update the real PC. */ + if (v) + *pc = tentative_pc; + + return v; +} + + +/* Generating bytecode from GDB expressions: general assumptions */ + +/* Here are a few general assumptions made throughout the code; if you + want to make a change that contradicts one of these, then you'd + better scan things pretty thoroughly. + + - We assume that all values occupy one stack element. For example, + sometimes we'll swap to get at the left argument to a binary + operator. If we decide that void values should occupy no stack + elements, or that synthetic arrays (whose size is determined at + run time, created by the `@' operator) should occupy two stack + elements (address and length), then this will cause trouble. + + - We assume the stack elements are infinitely wide, and that we + don't have to worry what happens if the user requests an + operation that is wider than the actual interpreter's stack. + That is, it's up to the interpreter to handle directly all the + integer widths the user has access to. (Woe betide the language + with bignums!) + + - We don't support side effects. Thus, we don't have to worry about + GCC's generalized lvalues, function calls, etc. + + - We don't support floating point. Many places where we switch on + some type don't bother to include cases for floating point; there + may be even more subtle ways this assumption exists. For + example, the arguments to % must be integers. + + - We assume all subexpressions have a static, unchanging type. If + we tried to support convenience variables, this would be a + problem. + + - All values on the stack should always be fully zero- or + sign-extended. + + (I wasn't sure whether to choose this or its opposite --- that + only addresses are assumed extended --- but it turns out that + neither convention completely eliminates spurious extend + operations (if everything is always extended, then you have to + extend after add, because it could overflow; if nothing is + extended, then you end up producing extends whenever you change + sizes), and this is simpler.) */ + + +/* Generating bytecode from GDB expressions: the `trace' kludge */ + +/* The compiler in this file is a general-purpose mechanism for + translating GDB expressions into bytecode. One ought to be able to + find a million and one uses for it. + + However, at the moment it is HOPELESSLY BRAIN-DAMAGED for the sake + of expediency. Let he who is without sin cast the first stone. + + For the data tracing facility, we need to insert `trace' bytecodes + before each data fetch; this records all the memory that the + expression touches in the course of evaluation, so that memory will + be available when the user later tries to evaluate the expression + in GDB. + + This should be done (I think) in a post-processing pass, that walks + an arbitrary agent expression and inserts `trace' operations at the + appropriate points. But it's much faster to just hack them + directly into the code. And since we're in a crunch, that's what + I've done. + + Setting the flag trace_kludge to non-zero enables the code that + emits the trace bytecodes at the appropriate points. */ +static int trace_kludge; + +/* Trace the lvalue on the stack, if it needs it. In either case, pop + the value. Useful on the left side of a comma, and at the end of + an expression being used for tracing. */ +static void +gen_traced_pop (ax, value) + struct agent_expr *ax; + struct axs_value *value; +{ + if (trace_kludge) + switch (value->kind) + { + case axs_rvalue: + /* We don't trace rvalues, just the lvalues necessary to + produce them. So just dispose of this value. */ + ax_simple (ax, aop_pop); + break; + + case axs_lvalue_memory: + { + int length = TYPE_LENGTH (value->type); + + /* There's no point in trying to use a trace_quick bytecode + here, since "trace_quick SIZE pop" is three bytes, whereas + "const8 SIZE trace" is also three bytes, does the same + thing, and the simplest code which generates that will also + work correctly for objects with large sizes. */ + ax_const_l (ax, length); + ax_simple (ax, aop_trace); + } + break; + + case axs_lvalue_register: + /* We need to mention the register somewhere in the bytecode, + so ax_reqs will pick it up and add it to the mask of + registers used. */ + ax_reg (ax, value->u.reg); + ax_simple (ax, aop_pop); + break; + } + else + /* If we're not tracing, just pop the value. */ + ax_simple (ax, aop_pop); +} + + + +/* Generating bytecode from GDB expressions: helper functions */ + +/* Assume that the lower bits of the top of the stack is a value of + type TYPE, and the upper bits are zero. Sign-extend if necessary. */ +static void +gen_sign_extend (ax, type) + struct agent_expr *ax; + struct type *type; +{ + /* Do we need to sign-extend this? */ + if (! TYPE_UNSIGNED (type)) + ax_ext (ax, type->length * TARGET_CHAR_BIT); +} + + +/* Assume the lower bits of the top of the stack hold a value of type + TYPE, and the upper bits are garbage. Sign-extend or truncate as + needed. */ +static void +gen_extend (ax, type) + struct agent_expr *ax; + struct type *type; +{ + int bits = type->length * TARGET_CHAR_BIT; + /* I just had to. */ + ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits)); +} + + +/* Assume that the top of the stack contains a value of type "pointer + to TYPE"; generate code to fetch its value. Note that TYPE is the + target type, not the pointer type. */ +static void +gen_fetch (ax, type) + struct agent_expr *ax; + struct type *type; +{ + if (trace_kludge) + { + /* Record the area of memory we're about to fetch. */ + ax_trace_quick (ax, TYPE_LENGTH (type)); + } + + switch (type->code) + { + case TYPE_CODE_PTR: + case TYPE_CODE_ENUM: + case TYPE_CODE_INT: + case TYPE_CODE_CHAR: + /* It's a scalar value, so we know how to dereference it. How + many bytes long is it? */ + switch (type->length) + { + case 8 / TARGET_CHAR_BIT: ax_simple (ax, aop_ref8 ); break; + case 16 / TARGET_CHAR_BIT: ax_simple (ax, aop_ref16); break; + case 32 / TARGET_CHAR_BIT: ax_simple (ax, aop_ref32); break; + case 64 / TARGET_CHAR_BIT: ax_simple (ax, aop_ref64); break; + + /* Either our caller shouldn't have asked us to dereference + that pointer (other code's fault), or we're not + implementing something we should be (this code's fault). + In any case, it's a bug the user shouldn't see. */ + default: + error ("GDB bug: ax-gdb.c (gen_fetch): strange size"); + } + + gen_sign_extend (ax, type); + break; + + default: + /* Either our caller shouldn't have asked us to dereference that + pointer (other code's fault), or we're not implementing + something we should be (this code's fault). In any case, + it's a bug the user shouldn't see. */ + error ("GDB bug: ax-gdb.c (gen_fetch): bad type code"); + } +} + + +/* Generate code to left shift the top of the stack by DISTANCE bits, or + right shift it by -DISTANCE bits if DISTANCE < 0. This generates + unsigned (logical) right shifts. */ +static void +gen_left_shift (ax, distance) + struct agent_expr *ax; + int distance; +{ + if (distance > 0) + { + ax_const_l (ax, distance); + ax_simple (ax, aop_lsh); + } + else if (distance < 0) + { + ax_const_l (ax, -distance); + ax_simple (ax, aop_rsh_unsigned); + } +} + + + +/* Generating bytecode from GDB expressions: symbol references */ + +/* Generate code to push the base address of the argument portion of + the top stack frame. */ +static void +gen_frame_args_address (ax) + struct agent_expr *ax; +{ + long frame_reg, frame_offset; + + TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset); + ax_reg (ax, frame_reg); + gen_offset (ax, frame_offset); +} + + +/* Generate code to push the base address of the locals portion of the + top stack frame. */ +static void +gen_frame_locals_address (ax) + struct agent_expr *ax; +{ + long frame_reg, frame_offset; + + TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset); + ax_reg (ax, frame_reg); + gen_offset (ax, frame_offset); +} + + +/* Generate code to add OFFSET to the top of the stack. Try to + generate short and readable code. We use this for getting to + variables on the stack, and structure members. If we were + programming in ML, it would be clearer why these are the same + thing. */ +static void +gen_offset (ax, offset) + struct agent_expr *ax; + int offset; +{ + /* It would suffice to simply push the offset and add it, but this + makes it easier to read positive and negative offsets in the + bytecode. */ + if (offset > 0) + { + ax_const_l (ax, offset); + ax_simple (ax, aop_add); + } + else if (offset < 0) + { + ax_const_l (ax, -offset); + ax_simple (ax, aop_sub); + } +} + + +/* In many cases, a symbol's value is the offset from some other + address (stack frame, base register, etc.) Generate code to add + VAR's value to the top of the stack. */ +static void +gen_sym_offset (ax, var) + struct agent_expr *ax; + struct symbol *var; +{ + gen_offset (ax, SYMBOL_VALUE (var)); +} + + +/* Generate code for a variable reference to AX. The variable is the + symbol VAR. Set VALUE to describe the result. */ + +static void +gen_var_ref (ax, value, var) + struct agent_expr *ax; + struct axs_value *value; + struct symbol *var; +{ + /* Dereference any typedefs. */ + value->type = check_typedef (SYMBOL_TYPE (var)); + + /* I'm imitating the code in read_var_value. */ + switch (SYMBOL_CLASS (var)) + { + case LOC_CONST: /* A constant, like an enum value. */ + ax_const_l (ax, (LONGEST) SYMBOL_VALUE (var)); + value->kind = axs_rvalue; + break; + + case LOC_LABEL: /* A goto label, being used as a value. */ + ax_const_l (ax, (LONGEST) SYMBOL_VALUE_ADDRESS (var)); + value->kind = axs_rvalue; + break; + + case LOC_CONST_BYTES: + error ("GDB bug: ax-gdb.c (gen_var_ref): LOC_CONST_BYTES symbols are not supported"); + + /* Variable at a fixed location in memory. Easy. */ + case LOC_STATIC: + /* Push the address of the variable. */ + ax_const_l (ax, SYMBOL_VALUE_ADDRESS (var)); + value->kind = axs_lvalue_memory; + break; + + case LOC_ARG: /* var lives in argument area of frame */ + gen_frame_args_address (ax); + gen_sym_offset (ax, var); + value->kind = axs_lvalue_memory; + break; + + case LOC_REF_ARG: /* As above, but the frame slot really + holds the address of the variable. */ + gen_frame_args_address (ax); + gen_sym_offset (ax, var); + /* Don't assume any particular pointer size. */ + gen_fetch (ax, lookup_pointer_type (builtin_type_void)); + value->kind = axs_lvalue_memory; + break; + + case LOC_LOCAL: /* var lives in locals area of frame */ + case LOC_LOCAL_ARG: + gen_frame_locals_address (ax); + gen_sym_offset (ax, var); + value->kind = axs_lvalue_memory; + break; + + case LOC_BASEREG: /* relative to some base register */ + case LOC_BASEREG_ARG: + ax_reg (ax, SYMBOL_BASEREG (var)); + gen_sym_offset (ax, var); + value->kind = axs_lvalue_memory; + break; + + case LOC_TYPEDEF: + error ("Cannot compute value of typedef `%s'.", + SYMBOL_SOURCE_NAME (var)); + break; + + case LOC_BLOCK: + ax_const_l (ax, BLOCK_START (SYMBOL_BLOCK_VALUE (var))); + value->kind = axs_rvalue; + break; + + case LOC_REGISTER: + case LOC_REGPARM: + /* Don't generate any code at all; in the process of treating + this as an lvalue or rvalue, the caller will generate the + right code. */ + value->kind = axs_lvalue_register; + value->u.reg = SYMBOL_VALUE (var); + break; + + /* A lot like LOC_REF_ARG, but the pointer lives directly in a + register, not on the stack. Simpler than LOC_REGISTER and + LOC_REGPARM, because it's just like any other case where the + thing has a real address. */ + case LOC_REGPARM_ADDR: + ax_reg (ax, SYMBOL_VALUE (var)); + value->kind = axs_lvalue_memory; + break; + + case LOC_UNRESOLVED: + { + struct minimal_symbol *msym + = lookup_minimal_symbol (SYMBOL_NAME (var), NULL, NULL); + if (! msym) + error ("Couldn't resolve symbol `%s'.", SYMBOL_SOURCE_NAME (var)); + + /* Push the address of the variable. */ + ax_const_l (ax, SYMBOL_VALUE_ADDRESS (msym)); + value->kind = axs_lvalue_memory; + } + break; + + case LOC_OPTIMIZED_OUT: + error ("The variable `%s' has been optimized out.", + SYMBOL_SOURCE_NAME (var)); + break; + + default: + error ("Cannot find value of botched symbol `%s'.", + SYMBOL_SOURCE_NAME (var)); + break; + } +} + + + +/* Generating bytecode from GDB expressions: literals */ + +static void +gen_int_literal (ax, value, k, type) + struct agent_expr *ax; + struct axs_value *value; + LONGEST k; + struct type *type; +{ + ax_const_l (ax, k); + value->kind = axs_rvalue; + value->type = type; +} + + + +/* Generating bytecode from GDB expressions: unary conversions, casts */ + +/* Take what's on the top of the stack (as described by VALUE), and + try to make an rvalue out of it. Signal an error if we can't do + that. */ +static void +require_rvalue (ax, value) + struct agent_expr *ax; + struct axs_value *value; +{ + switch (value->kind) + { + case axs_rvalue: + /* It's already an rvalue. */ + break; + + case axs_lvalue_memory: + /* The top of stack is the address of the object. Dereference. */ + gen_fetch (ax, value->type); + break; + + case axs_lvalue_register: + /* There's nothing on the stack, but value->u.reg is the + register number containing the value. + + When we add floating-point support, this is going to have to + change. What about SPARC register pairs, for example? */ + ax_reg (ax, value->u.reg); + gen_extend (ax, value->type); + break; + } + + value->kind = axs_rvalue; +} + + +/* Assume the top of the stack is described by VALUE, and perform the + usual unary conversions. This is motivated by ANSI 6.2.2, but of + course GDB expressions are not ANSI; they're the mishmash union of + a bunch of languages. Rah. + + NOTE! This function promises to produce an rvalue only when the + incoming value is of an appropriate type. In other words, the + consumer of the value this function produces may assume the value + is an rvalue only after checking its type. + + The immediate issue is that if the user tries to use a structure or + union as an operand of, say, the `+' operator, we don't want to try + to convert that structure to an rvalue; require_rvalue will bomb on + structs and unions. Rather, we want to simply pass the struct + lvalue through unchanged, and let `+' raise an error. */ + +static void +gen_usual_unary (ax, value) + struct agent_expr *ax; + struct axs_value *value; +{ + /* We don't have to generate any code for the usual integral + conversions, since values are always represented as full-width on + the stack. Should we tweak the type? */ + + /* Some types require special handling. */ + switch (value->type->code) + { + /* Functions get converted to a pointer to the function. */ + case TYPE_CODE_FUNC: + value->type = lookup_pointer_type (value->type); + value->kind = axs_rvalue; /* Should always be true, but just in case. */ + break; + + /* Arrays get converted to a pointer to their first element, and + are no longer an lvalue. */ + case TYPE_CODE_ARRAY: + { + struct type *elements = TYPE_TARGET_TYPE (value->type); + value->type = lookup_pointer_type (elements); + value->kind = axs_rvalue; + /* We don't need to generate any code; the address of the array + is also the address of its first element. */ + } + break; + + /* Don't try to convert structures and unions to rvalues. Let the + consumer signal an error. */ + case TYPE_CODE_STRUCT: + case TYPE_CODE_UNION: + return; + + /* If the value is an enum, call it an integer. */ + case TYPE_CODE_ENUM: + value->type = builtin_type_int; + break; + } + + /* If the value is an lvalue, dereference it. */ + require_rvalue (ax, value); +} + + +/* Return non-zero iff the type TYPE1 is considered "wider" than the + type TYPE2, according to the rules described in gen_usual_arithmetic. */ +static int +type_wider_than (type1, type2) + struct type *type1, *type2; +{ + return (TYPE_LENGTH (type1) > TYPE_LENGTH (type2) + || (TYPE_LENGTH (type1) == TYPE_LENGTH (type2) + && TYPE_UNSIGNED (type1) + && ! TYPE_UNSIGNED (type2))); +} + + +/* Return the "wider" of the two types TYPE1 and TYPE2. */ +static struct type * +max_type (type1, type2) + struct type *type1, *type2; +{ + return type_wider_than (type1, type2) ? type1 : type2; +} + + +/* Generate code to convert a scalar value of type FROM to type TO. */ +static void +gen_conversion (ax, from, to) + struct agent_expr *ax; + struct type *from, *to; +{ + /* Perhaps there is a more graceful way to state these rules. */ + + /* If we're converting to a narrower type, then we need to clear out + the upper bits. */ + if (TYPE_LENGTH (to) < TYPE_LENGTH (from)) + gen_extend (ax, from); + + /* If the two values have equal width, but different signednesses, + then we need to extend. */ + else if (TYPE_LENGTH (to) == TYPE_LENGTH (from)) + { + if (TYPE_UNSIGNED (from) != TYPE_UNSIGNED (to)) + gen_extend (ax, to); + } + + /* If we're converting to a wider type, and becoming unsigned, then + we need to zero out any possible sign bits. */ + else if (TYPE_LENGTH (to) > TYPE_LENGTH (from)) + { + if (TYPE_UNSIGNED (to)) + gen_extend (ax, to); + } +} + + +/* Return non-zero iff the type FROM will require any bytecodes to be + emitted to be converted to the type TO. */ +static int +is_nontrivial_conversion (from, to) + struct type *from, *to; +{ + struct agent_expr *ax = new_agent_expr (0); + int nontrivial; + + /* Actually generate the code, and see if anything came out. At the + moment, it would be trivial to replicate the code in + gen_conversion here, but in the future, when we're supporting + floating point and the like, it may not be. Doing things this + way allows this function to be independent of the logic in + gen_conversion. */ + gen_conversion (ax, from, to); + nontrivial = ax->len > 0; + free_agent_expr (ax); + return nontrivial; +} + + +/* Generate code to perform the "usual arithmetic conversions" (ANSI C + 6.2.1.5) for the two operands of an arithmetic operator. This + effectively finds a "least upper bound" type for the two arguments, + and promotes each argument to that type. *VALUE1 and *VALUE2 + describe the values as they are passed in, and as they are left. */ +static void +gen_usual_arithmetic (ax, value1, value2) + struct agent_expr *ax; + struct axs_value *value1, *value2; +{ + /* Do the usual binary conversions. */ + if (TYPE_CODE (value1->type) == TYPE_CODE_INT + && TYPE_CODE (value2->type) == TYPE_CODE_INT) + { + /* The ANSI integral promotions seem to work this way: Order the + integer types by size, and then by signedness: an n-bit + unsigned type is considered "wider" than an n-bit signed + type. Promote to the "wider" of the two types, and always + promote at least to int. */ + struct type *target = max_type (builtin_type_int, + max_type (value1->type, value2->type)); + + /* Deal with value2, on the top of the stack. */ + gen_conversion (ax, value2->type, target); + + /* Deal with value1, not on the top of the stack. Don't + generate the `swap' instructions if we're not actually going + to do anything. */ + if (is_nontrivial_conversion (value1->type, target)) + { + ax_simple (ax, aop_swap); + gen_conversion (ax, value1->type, target); + ax_simple (ax, aop_swap); + } + + value1->type = value2->type = target; + } +} + + +/* Generate code to perform the integral promotions (ANSI 6.2.1.1) on + the value on the top of the stack, as described by VALUE. Assume + the value has integral type. */ +static void +gen_integral_promotions (ax, value) + struct agent_expr *ax; + struct axs_value *value; +{ + if (! type_wider_than (value->type, builtin_type_int)) + { + gen_conversion (ax, value->type, builtin_type_int); + value->type = builtin_type_int; + } + else if (! type_wider_than (value->type, builtin_type_unsigned_int)) + { + gen_conversion (ax, value->type, builtin_type_unsigned_int); + value->type = builtin_type_unsigned_int; + } +} + + +/* Generate code for a cast to TYPE. */ +static void +gen_cast (ax, value, type) + struct agent_expr *ax; + struct axs_value *value; + struct type *type; +{ + /* GCC does allow casts to yield lvalues, so this should be fixed + before merging these changes into the trunk. */ + require_rvalue (ax, value); + /* Dereference typedefs. */ + type = check_typedef (type); + + switch (type->code) + { + case TYPE_CODE_PTR: + /* It's implementation-defined, and I'll bet this is what GCC + does. */ + break; + + case TYPE_CODE_ARRAY: + case TYPE_CODE_STRUCT: + case TYPE_CODE_UNION: + case TYPE_CODE_FUNC: + error ("Illegal type cast: intended type must be scalar."); + + case TYPE_CODE_ENUM: + /* We don't have to worry about the size of the value, because + all our integral values are fully sign-extended, and when + casting pointers we can do anything we like. Is there any + way for us to actually know what GCC actually does with a + cast like this? */ + value->type = type; + break; + + case TYPE_CODE_INT: + gen_conversion (ax, value->type, type); + break; + + case TYPE_CODE_VOID: + /* We could pop the value, and rely on everyone else to check + the type and notice that this value doesn't occupy a stack + slot. But for now, leave the value on the stack, and + preserve the "value == stack element" assumption. */ + break; + + default: + error ("Casts to requested type are not yet implemented."); + } + + value->type = type; +} + + + +/* Generating bytecode from GDB expressions: arithmetic */ + +/* Scale the integer on the top of the stack by the size of the target + of the pointer type TYPE. */ +static void +gen_scale (ax, op, type) + struct agent_expr *ax; + enum agent_op op; + struct type *type; +{ + struct type *element = TYPE_TARGET_TYPE (type); + + if (element->length != 1) + { + ax_const_l (ax, element->length); + ax_simple (ax, op); + } +} + + +/* Generate code for an addition; non-trivial because we deal with + pointer arithmetic. We set VALUE to describe the result value; we + assume VALUE1 and VALUE2 describe the two operands, and that + they've undergone the usual binary conversions. Used by both + BINOP_ADD and BINOP_SUBSCRIPT. NAME is used in error messages. */ +static void +gen_add (ax, value, value1, value2, name) + struct agent_expr *ax; + struct axs_value *value, *value1, *value2; + char *name; +{ + /* Is it INT+PTR? */ + if (value1->type->code == TYPE_CODE_INT + && value2->type->code == TYPE_CODE_PTR) + { + /* Swap the values and proceed normally. */ + ax_simple (ax, aop_swap); + gen_scale (ax, aop_mul, value2->type); + ax_simple (ax, aop_add); + gen_extend (ax, value2->type); /* Catch overflow. */ + value->type = value2->type; + } + + /* Is it PTR+INT? */ + else if (value1->type->code == TYPE_CODE_PTR + && value2->type->code == TYPE_CODE_INT) + { + gen_scale (ax, aop_mul, value1->type); + ax_simple (ax, aop_add); + gen_extend (ax, value1->type); /* Catch overflow. */ + value->type = value1->type; + } + + /* Must be number + number; the usual binary conversions will have + brought them both to the same width. */ + else if (value1->type->code == TYPE_CODE_INT + && value2->type->code == TYPE_CODE_INT) + { + ax_simple (ax, aop_add); + gen_extend (ax, value1->type); /* Catch overflow. */ + value->type = value1->type; + } + + else + error ("Illegal combination of types in %s.", name); + + value->kind = axs_rvalue; +} + + +/* Generate code for an addition; non-trivial because we have to deal + with pointer arithmetic. We set VALUE to describe the result + value; we assume VALUE1 and VALUE2 describe the two operands, and + that they've undergone the usual binary conversions. */ +static void +gen_sub (ax, value, value1, value2) + struct agent_expr *ax; + struct axs_value *value, *value1, *value2; +{ + struct type *element; + + if (value1->type->code == TYPE_CODE_PTR) + { + /* Is it PTR - INT? */ + if (value2->type->code == TYPE_CODE_INT) + { + gen_scale (ax, aop_mul, value1->type); + ax_simple (ax, aop_sub); + gen_extend (ax, value1->type); /* Catch overflow. */ + value->type = value1->type; + } + + /* Is it PTR - PTR? Strictly speaking, the types ought to + match, but this is what the normal GDB expression evaluator + tests for. */ + else if (value2->type->code == TYPE_CODE_PTR + && (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type)) + == TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type)))) + { + ax_simple (ax, aop_sub); + gen_scale (ax, aop_div_unsigned, value1->type); + value->type = builtin_type_long; /* FIXME --- should be ptrdiff_t */ + } + else + error ("\ +First argument of `-' is a pointer, but second argument is neither\n\ +an integer nor a pointer of the same type."); + } + + /* Must be number + number. */ + else if (value1->type->code == TYPE_CODE_INT + && value2->type->code == TYPE_CODE_INT) + { + ax_simple (ax, aop_sub); + gen_extend (ax, value1->type); /* Catch overflow. */ + value->type = value1->type; + } + + else + error ("Illegal combination of types in subtraction."); + + value->kind = axs_rvalue; +} + +/* Generate code for a binary operator that doesn't do pointer magic. + We set VALUE to describe the result value; we assume VALUE1 and + VALUE2 describe the two operands, and that they've undergone the + usual binary conversions. MAY_CARRY should be non-zero iff the + result needs to be extended. NAME is the English name of the + operator, used in error messages */ +static void +gen_binop (ax, value, value1, value2, op, op_unsigned, may_carry, name) + struct agent_expr *ax; + struct axs_value *value, *value1, *value2; + enum agent_op op, op_unsigned; + int may_carry; + char *name; +{ + /* We only handle INT op INT. */ + if ((value1->type->code != TYPE_CODE_INT) + || (value2->type->code != TYPE_CODE_INT)) + error ("Illegal combination of types in %s.", name); + + ax_simple (ax, + TYPE_UNSIGNED (value1->type) ? op_unsigned : op); + if (may_carry) + gen_extend (ax, value1->type); /* catch overflow */ + value->type = value1->type; + value->kind = axs_rvalue; +} + + +static void +gen_logical_not (ax, value) + struct agent_expr *ax; + struct axs_value *value; +{ + if (TYPE_CODE (value->type) != TYPE_CODE_INT + && TYPE_CODE (value->type) != TYPE_CODE_PTR) + error ("Illegal type of operand to `!'."); + + gen_usual_unary (ax, value); + ax_simple (ax, aop_log_not); + value->type = builtin_type_int; +} + + +static void +gen_complement (ax, value) + struct agent_expr *ax; + struct axs_value *value; +{ + if (TYPE_CODE (value->type) != TYPE_CODE_INT) + error ("Illegal type of operand to `~'."); + + gen_usual_unary (ax, value); + gen_integral_promotions (ax, value); + ax_simple (ax, aop_bit_not); + gen_extend (ax, value->type); +} + + + +/* Generating bytecode from GDB expressions: * & . -> @ sizeof */ + +/* Dereference the value on the top of the stack. */ +static void +gen_deref (ax, value) + struct agent_expr *ax; + struct axs_value *value; +{ + /* The caller should check the type, because several operators use + this, and we don't know what error message to generate. */ + if (value->type->code != TYPE_CODE_PTR) + error ("GDB bug: ax-gdb.c (gen_deref): expected a pointer"); + + /* We've got an rvalue now, which is a pointer. We want to yield an + lvalue, whose address is exactly that pointer. So we don't + actually emit any code; we just change the type from "Pointer to + T" to "T", and mark the value as an lvalue in memory. Leave it + to the consumer to actually dereference it. */ + value->type = check_typedef (TYPE_TARGET_TYPE (value->type)); + value->kind = ((value->type->code == TYPE_CODE_FUNC) + ? axs_rvalue : axs_lvalue_memory); +} + + +/* Produce the address of the lvalue on the top of the stack. */ +static void +gen_address_of (ax, value) + struct agent_expr *ax; + struct axs_value *value; +{ + /* Special case for taking the address of a function. The ANSI + standard describes this as a special case, too, so this + arrangement is not without motivation. */ + if (value->type->code == TYPE_CODE_FUNC) + /* The value's already an rvalue on the stack, so we just need to + change the type. */ + value->type = lookup_pointer_type (value->type); + else + switch (value->kind) + { + case axs_rvalue: + error ("Operand of `&' is an rvalue, which has no address."); + + case axs_lvalue_register: + error ("Operand of `&' is in a register, and has no address."); + + case axs_lvalue_memory: + value->kind = axs_rvalue; + value->type = lookup_pointer_type (value->type); + break; + } +} + + +/* A lot of this stuff will have to change to support C++. But we're + not going to deal with that at the moment. */ + +/* Find the field in the structure type TYPE named NAME, and return + its index in TYPE's field array. */ +static int +find_field (type, name) + struct type *type; + char *name; +{ + int i; + + CHECK_TYPEDEF (type); + + /* Make sure this isn't C++. */ + if (TYPE_N_BASECLASSES (type) != 0) + error ("GDB bug: ax-gdb.c (find_field): derived classes supported"); + + for (i = 0; i < TYPE_NFIELDS (type); i++) + { + char *this_name = TYPE_FIELD_NAME (type, i); + + if (this_name && STREQ (name, this_name)) + return i; + + if (this_name[0] == '\0') + error ("GDB bug: ax-gdb.c (find_field): anonymous unions not supported"); + } + + error ("Couldn't find member named `%s' in struct/union `%s'", + name, type->tag_name); + + return 0; +} + + +/* Generate code to push the value of a bitfield of a structure whose + address is on the top of the stack. START and END give the + starting and one-past-ending *bit* numbers of the field within the + structure. */ +static void +gen_bitfield_ref (ax, value, type, start, end) + struct agent_expr *ax; + struct axs_value *value; + struct type *type; + int start, end; +{ + /* Note that ops[i] fetches 8 << i bits. */ + static enum agent_op ops[] + = { aop_ref8, aop_ref16, aop_ref32, aop_ref64 }; + static int num_ops = (sizeof (ops) / sizeof (ops[0])); + + /* We don't want to touch any byte that the bitfield doesn't + actually occupy; we shouldn't make any accesses we're not + explicitly permitted to. We rely here on the fact that the + bytecode `ref' operators work on unaligned addresses. + + It takes some fancy footwork to get the stack to work the way + we'd like. Say we're retrieving a bitfield that requires three + fetches. Initially, the stack just contains the address: + addr + For the first fetch, we duplicate the address + addr addr + then add the byte offset, do the fetch, and shift and mask as + needed, yielding a fragment of the value, properly aligned for + the final bitwise or: + addr frag1 + then we swap, and repeat the process: + frag1 addr --- address on top + frag1 addr addr --- duplicate it + frag1 addr frag2 --- get second fragment + frag1 frag2 addr --- swap again + frag1 frag2 frag3 --- get third fragment + Notice that, since the third fragment is the last one, we don't + bother duplicating the address this time. Now we have all the + fragments on the stack, and we can simply `or' them together, + yielding the final value of the bitfield. */ + + /* The first and one-after-last bits in the field, but rounded down + and up to byte boundaries. */ + int bound_start = (start / TARGET_CHAR_BIT) * TARGET_CHAR_BIT; + int bound_end = (((end + TARGET_CHAR_BIT - 1) + / TARGET_CHAR_BIT) + * TARGET_CHAR_BIT); + + /* current bit offset within the structure */ + int offset; + + /* The index in ops of the opcode we're considering. */ + int op; + + /* The number of fragments we generated in the process. Probably + equal to the number of `one' bits in bytesize, but who cares? */ + int fragment_count; + + /* Dereference any typedefs. */ + type = check_typedef (type); + + /* Can we fetch the number of bits requested at all? */ + if ((end - start) > ((1 << num_ops) * 8)) + error ("GDB bug: ax-gdb.c (gen_bitfield_ref): bitfield too wide"); + + /* Note that we know here that we only need to try each opcode once. + That may not be true on machines with weird byte sizes. */ + offset = bound_start; + fragment_count = 0; + for (op = num_ops - 1; op >= 0; op--) + { + /* number of bits that ops[op] would fetch */ + int op_size = 8 << op; + + /* The stack at this point, from bottom to top, contains zero or + more fragments, then the address. */ + + /* Does this fetch fit within the bitfield? */ + if (offset + op_size <= bound_end) + { + /* Is this the last fragment? */ + int last_frag = (offset + op_size == bound_end); + + if (! last_frag) + ax_simple (ax, aop_dup); /* keep a copy of the address */ + + /* Add the offset. */ + gen_offset (ax, offset / TARGET_CHAR_BIT); + + if (trace_kludge) + { + /* Record the area of memory we're about to fetch. */ + ax_trace_quick (ax, op_size / TARGET_CHAR_BIT); + } + + /* Perform the fetch. */ + ax_simple (ax, ops[op]); + + /* Shift the bits we have to their proper position. + gen_left_shift will generate right shifts when the operand + is negative. + + A big-endian field diagram to ponder: + byte 0 byte 1 byte 2 byte 3 byte 4 byte 5 byte 6 byte 7 + +------++------++------++------++------++------++------++------+ + xxxxAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCxxxxxxxxxxx + ^ ^ ^ ^ + bit number 16 32 48 53 + These are bit numbers as supplied by GDB. Note that the + bit numbers run from right to left once you've fetched the + value! + + A little-endian field diagram to ponder: + byte 7 byte 6 byte 5 byte 4 byte 3 byte 2 byte 1 byte 0 + +------++------++------++------++------++------++------++------+ + xxxxxxxxxxxAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCxxxx + ^ ^ ^ ^ ^ + bit number 48 32 16 4 0 + + In both cases, the most significant end is on the left + (i.e. normal numeric writing order), which means that you + don't go crazy thinking about `left' and `right' shifts. + + We don't have to worry about masking yet: + - If they contain garbage off the least significant end, then we + must be looking at the low end of the field, and the right + shift will wipe them out. + - If they contain garbage off the most significant end, then we + must be looking at the most significant end of the word, and + the sign/zero extension will wipe them out. + - If we're in the interior of the word, then there is no garbage + on either end, because the ref operators zero-extend. */ + if (TARGET_BYTE_ORDER == BIG_ENDIAN) + gen_left_shift (ax, end - (offset + op_size)); + else + gen_left_shift (ax, offset - start); + + if (! last_frag) + /* Bring the copy of the address up to the top. */ + ax_simple (ax, aop_swap); + + offset += op_size; + fragment_count++; + } + } + + /* Generate enough bitwise `or' operations to combine all the + fragments we left on the stack. */ + while (fragment_count-- > 1) + ax_simple (ax, aop_bit_or); + + /* Sign- or zero-extend the value as appropriate. */ + ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, end - start)); + + /* This is *not* an lvalue. Ugh. */ + value->kind = axs_rvalue; + value->type = type; +} + + +/* Generate code to reference the member named FIELD of a structure or + union. The top of the stack, as described by VALUE, should have + type (pointer to a)* struct/union. OPERATOR_NAME is the name of + the operator being compiled, and OPERAND_NAME is the kind of thing + it operates on; we use them in error messages. */ +static void +gen_struct_ref (ax, value, field, operator_name, operand_name) + struct agent_expr *ax; + struct axs_value *value; + char *field; + char *operator_name; + char *operand_name; +{ + struct type *type; + int i; + + /* Follow pointers until we reach a non-pointer. These aren't the C + semantics, but they're what the normal GDB evaluator does, so we + should at least be consistent. */ + while (value->type->code == TYPE_CODE_PTR) + { + gen_usual_unary (ax, value); + gen_deref (ax, value); + } + type = value->type; + + /* This must yield a structure or a union. */ + if (TYPE_CODE (type) != TYPE_CODE_STRUCT + && TYPE_CODE (type) != TYPE_CODE_UNION) + error ("The left operand of `%s' is not a %s.", + operator_name, operand_name); + + /* And it must be in memory; we don't deal with structure rvalues, + or structures living in registers. */ + if (value->kind != axs_lvalue_memory) + error ("Structure does not live in memory."); + + i = find_field (type, field); + + /* Is this a bitfield? */ + if (TYPE_FIELD_PACKED (type, i)) + gen_bitfield_ref (ax, value, TYPE_FIELD_TYPE (type, i), + TYPE_FIELD_BITPOS (type, i), + (TYPE_FIELD_BITPOS (type, i) + + TYPE_FIELD_BITSIZE (type, i))); + else + { + gen_offset (ax, TYPE_FIELD_BITPOS (type, i) / TARGET_CHAR_BIT); + value->kind = axs_lvalue_memory; + value->type = TYPE_FIELD_TYPE (type, i); + } +} + + +/* Generate code for GDB's magical `repeat' operator. + LVALUE @ INT creates an array INT elements long, and whose elements + have the same type as LVALUE, located in memory so that LVALUE is + its first element. For example, argv[0]@argc gives you the array + of command-line arguments. + + Unfortunately, because we have to know the types before we actually + have a value for the expression, we can't implement this perfectly + without changing the type system, having values that occupy two + stack slots, doing weird things with sizeof, etc. So we require + the right operand to be a constant expression. */ +static void +gen_repeat (pc, ax, value) + union exp_element **pc; + struct agent_expr *ax; + struct axs_value *value; +{ + struct axs_value value1; + /* We don't want to turn this into an rvalue, so no conversions + here. */ + gen_expr (pc, ax, &value1); + if (value1.kind != axs_lvalue_memory) + error ("Left operand of `@' must be an object in memory."); + + /* Evaluate the length; it had better be a constant. */ + { + struct value *v = const_expr (pc); + int length; + + if (! v) + error ("Right operand of `@' must be a constant, in agent expressions."); + if (v->type->code != TYPE_CODE_INT) + error ("Right operand of `@' must be an integer."); + length = value_as_long (v); + if (length <= 0) + error ("Right operand of `@' must be positive."); + + /* The top of the stack is already the address of the object, so + all we need to do is frob the type of the lvalue. */ + { + /* FIXME-type-allocation: need a way to free this type when we are + done with it. */ + struct type *range + = create_range_type (0, builtin_type_int, 0, length - 1); + struct type *array = create_array_type (0, value1.type, range); + + value->kind = axs_lvalue_memory; + value->type = array; + } + } +} + + +/* Emit code for the `sizeof' operator. + *PC should point at the start of the operand expression; we advance it + to the first instruction after the operand. */ +static void +gen_sizeof (pc, ax, value) + union exp_element **pc; + struct agent_expr *ax; + struct axs_value *value; +{ + /* We don't care about the value of the operand expression; we only + care about its type. However, in the current arrangement, the + only way to find an expression's type is to generate code for it. + So we generate code for the operand, and then throw it away, + replacing it with code that simply pushes its size. */ + int start = ax->len; + gen_expr (pc, ax, value); + + /* Throw away the code we just generated. */ + ax->len = start; + + ax_const_l (ax, TYPE_LENGTH (value->type)); + value->kind = axs_rvalue; + value->type = builtin_type_int; +} + + +/* Generating bytecode from GDB expressions: general recursive thingy */ + +/* A gen_expr function written by a Gen-X'er guy. + Append code for the subexpression of EXPR starting at *POS_P to AX. */ +static void +gen_expr (pc, ax, value) + union exp_element **pc; + struct agent_expr *ax; + struct axs_value *value; +{ + /* Used to hold the descriptions of operand expressions. */ + struct axs_value value1, value2; + enum exp_opcode op = (*pc)[0].opcode; + + /* If we're looking at a constant expression, just push its value. */ + { + struct value *v = maybe_const_expr (pc); + + if (v) + { + ax_const_l (ax, value_as_long (v)); + value->kind = axs_rvalue; + value->type = check_typedef (VALUE_TYPE (v)); + return; + } + } + + /* Otherwise, go ahead and generate code for it. */ + switch (op) + { + /* Binary arithmetic operators. */ + case BINOP_ADD: + case BINOP_SUB: + case BINOP_MUL: + case BINOP_DIV: + case BINOP_REM: + case BINOP_SUBSCRIPT: + case BINOP_BITWISE_AND: + case BINOP_BITWISE_IOR: + case BINOP_BITWISE_XOR: + (*pc)++; + gen_expr (pc, ax, &value1); + gen_usual_unary (ax, &value1); + gen_expr (pc, ax, &value2); + gen_usual_unary (ax, &value2); + gen_usual_arithmetic (ax, &value1, &value2); + switch (op) + { + case BINOP_ADD: + gen_add (ax, value, &value1, &value2, "addition"); + break; + case BINOP_SUB: + gen_sub (ax, value, &value1, &value2); + break; + case BINOP_MUL: + gen_binop (ax, value, &value1, &value2, + aop_mul, aop_mul, 1, "multiplication"); + break; + case BINOP_DIV: + gen_binop (ax, value, &value1, &value2, + aop_div_signed, aop_div_unsigned, 1, "division"); + break; + case BINOP_REM: + gen_binop (ax, value, &value1, &value2, + aop_rem_signed, aop_rem_unsigned, 1, "remainder"); + break; + case BINOP_SUBSCRIPT: + gen_add (ax, value, &value1, &value2, "array subscripting"); + if (TYPE_CODE (value->type) != TYPE_CODE_PTR) + error ("Illegal combination of types in array subscripting."); + gen_deref (ax, value); + break; + case BINOP_BITWISE_AND: + gen_binop (ax, value, &value1, &value2, + aop_bit_and, aop_bit_and, 0, "bitwise and"); + break; + + case BINOP_BITWISE_IOR: + gen_binop (ax, value, &value1, &value2, + aop_bit_or, aop_bit_or, 0, "bitwise or"); + break; + + case BINOP_BITWISE_XOR: + gen_binop (ax, value, &value1, &value2, + aop_bit_xor, aop_bit_xor, 0, "bitwise exclusive-or"); + break; + + default: + /* We should only list operators in the outer case statement + that we actually handle in the inner case statement. */ + error ("GDB bug: ax-gdb.c (gen_expr): op case sets don't match"); + } + break; + + /* Note that we need to be a little subtle about generating code + for comma. In C, we can do some optimizations here because + we know the left operand is only being evaluated for effect. + However, if the tracing kludge is in effect, then we always + need to evaluate the left hand side fully, so that all the + variables it mentions get traced. */ + case BINOP_COMMA: + (*pc)++; + gen_expr (pc, ax, &value1); + /* Don't just dispose of the left operand. We might be tracing, + in which case we want to emit code to trace it if it's an + lvalue. */ + gen_traced_pop (ax, &value1); + gen_expr (pc, ax, value); + /* It's the consumer's responsibility to trace the right operand. */ + break; + + case OP_LONG: /* some integer constant */ + { + struct type *type = (*pc)[1].type; + LONGEST k = (*pc)[2].longconst; + (*pc) += 4; + gen_int_literal (ax, value, k, type); + } + break; + + case OP_VAR_VALUE: + gen_var_ref (ax, value, (*pc)[2].symbol); + (*pc) += 4; + break; + + case OP_REGISTER: + { + int reg = (int) (*pc)[1].longconst; + (*pc) += 3; + value->kind = axs_lvalue_register; + value->u.reg = reg; + value->type = REGISTER_VIRTUAL_TYPE (reg); + } + break; + + case OP_INTERNALVAR: + error ("GDB agent expressions cannot use convenience variables."); + + /* Weirdo operator: see comments for gen_repeat for details. */ + case BINOP_REPEAT: + /* Note that gen_repeat handles its own argument evaluation. */ + (*pc)++; + gen_repeat (pc, ax, value); + break; + + case UNOP_CAST: + { + struct type *type = (*pc)[1].type; + (*pc) += 3; + gen_expr (pc, ax, value); + gen_cast (ax, value, type); + } + break; + + case UNOP_MEMVAL: + { + struct type *type = check_typedef ((*pc)[1].type); + (*pc) += 3; + gen_expr (pc, ax, value); + /* I'm not sure I understand UNOP_MEMVAL entirely. I think + it's just a hack for dealing with minsyms; you take some + integer constant, pretend it's the address of an lvalue of + the given type, and dereference it. */ + if (value->kind != axs_rvalue) + /* This would be weird. */ + error ("GDB bug: ax-gdb.c (gen_expr): OP_MEMVAL operand isn't an rvalue???"); + value->type = type; + value->kind = axs_lvalue_memory; + } + break; + + case UNOP_NEG: + (*pc)++; + /* -FOO is equivalent to 0 - FOO. */ + gen_int_literal (ax, &value1, (LONGEST) 0, builtin_type_int); + gen_usual_unary (ax, &value1); /* shouldn't do much */ + gen_expr (pc, ax, &value2); + gen_usual_unary (ax, &value2); + gen_usual_arithmetic (ax, &value1, &value2); + gen_sub (ax, value, &value1, &value2); + break; + + case UNOP_LOGICAL_NOT: + (*pc)++; + gen_expr (pc, ax, value); + gen_logical_not (ax, value); + break; + + case UNOP_COMPLEMENT: + (*pc)++; + gen_expr (pc, ax, value); + gen_complement (ax, value); + break; + + case UNOP_IND: + (*pc)++; + gen_expr (pc, ax, value); + gen_usual_unary (ax, value); + if (TYPE_CODE (value->type) != TYPE_CODE_PTR) + error ("Argument of unary `*' is not a pointer."); + gen_deref (ax, value); + break; + + case UNOP_ADDR: + (*pc)++; + gen_expr (pc, ax, value); + gen_address_of (ax, value); + break; + + case UNOP_SIZEOF: + (*pc)++; + /* Notice that gen_sizeof handles its own operand, unlike most + of the other unary operator functions. This is because we + have to throw away the code we generate. */ + gen_sizeof (pc, ax, value); + break; + + case STRUCTOP_STRUCT: + case STRUCTOP_PTR: + { + int length = (*pc)[1].longconst; + char *name = &(*pc)[2].string; + + (*pc) += 4 + BYTES_TO_EXP_ELEM (length + 1); + gen_expr (pc, ax, value); + if (op == STRUCTOP_STRUCT) + gen_struct_ref (ax, value, name, ".", "structure or union"); + else if (op == STRUCTOP_PTR) + gen_struct_ref (ax, value, name, "->", + "pointer to a structure or union"); + else + /* If this `if' chain doesn't handle it, then the case list + shouldn't mention it, and we shouldn't be here. */ + error ("GDB bug: ax-gdb.c (gen_expr): unhandled struct case"); + } + break; + + case OP_TYPE: + error ("Attempt to use a type name as an expression."); + + default: + error ("Unsupported operator in expression."); + } +} + + + +#if 0 /* not used */ +/* Generating bytecode from GDB expressions: driver */ + +/* Given a GDB expression EXPR, produce a string of agent bytecode + which computes its value. Return the agent expression, and set + *VALUE to describe its type, and whether it's an lvalue or rvalue. */ +struct agent_expr * +expr_to_agent (expr, value) + struct expression *expr; + struct axs_value *value; +{ + struct cleanup *old_chain = 0; + struct agent_expr *ax = new_agent_expr (); + union exp_element *pc; + + old_chain = make_cleanup ((make_cleanup_func) free_agent_expr, ax); + + pc = expr->elts; + trace_kludge = 0; + gen_expr (&pc, ax, value); + + /* We have successfully built the agent expr, so cancel the cleanup + request. If we add more cleanups that we always want done, this + will have to get more complicated. */ + discard_cleanups (old_chain); + return ax; +} + + +/* Given a GDB expression EXPR denoting an lvalue in memory, produce a + string of agent bytecode which will leave its address and size on + the top of stack. Return the agent expression. + + Not sure this function is useful at all. */ +struct agent_expr * +expr_to_address_and_size (expr) + struct expression *expr; +{ + struct axs_value value; + struct agent_expr *ax = expr_to_agent (expr, &value); + + /* Complain if the result is not a memory lvalue. */ + if (value.kind != axs_lvalue_memory) + { + free_agent_expr (ax); + error ("Expression does not denote an object in memory."); + } + + /* Push the object's size on the stack. */ + ax_const_l (ax, TYPE_LENGTH (value.type)); + + return ax; +} +#endif /* 0 */ + +/* Given a GDB expression EXPR, return bytecode to trace its value. + The result will use the `trace' and `trace_quick' bytecodes to + record the value of all memory touched by the expression. The + caller can then use the ax_reqs function to discover which + registers it relies upon. */ +struct agent_expr * +gen_trace_for_expr (scope, expr) + CORE_ADDR scope; + struct expression *expr; +{ + struct cleanup *old_chain = 0; + struct agent_expr *ax = new_agent_expr (scope); + union exp_element *pc; + struct axs_value value; + + old_chain = make_cleanup ((make_cleanup_func) free_agent_expr, ax); + + pc = expr->elts; + trace_kludge = 1; + gen_expr (&pc, ax, &value); + + /* Make sure we record the final object, and get rid of it. */ + gen_traced_pop (ax, &value); + + /* Oh, and terminate. */ + ax_simple (ax, aop_end); + + /* We have successfully built the agent expr, so cancel the cleanup + request. If we add more cleanups that we always want done, this + will have to get more complicated. */ + discard_cleanups (old_chain); + return ax; +} + + + +/* The "agent" command, for testing: compile and disassemble an expression. */ + +static void +print_axs_value (f, value) + GDB_FILE *f; + struct axs_value *value; +{ + switch (value->kind) + { + case axs_rvalue: + fputs_filtered ("rvalue", f); + break; + + case axs_lvalue_memory: + fputs_filtered ("memory lvalue", f); + break; + + case axs_lvalue_register: + fprintf_filtered (f, "register %d lvalue", value->u.reg); + break; + } + + fputs_filtered (" : ", f); + type_print (value->type, "", f, -1); +} + + +static void +agent_command (exp, from_tty) + char *exp; + int from_tty; +{ + struct cleanup *old_chain = 0; + struct expression *expr; + struct agent_expr *agent; + struct agent_reqs reqs; + struct frame_info *fi = get_current_frame (); /* need current scope */ + + /* We don't deal with overlay debugging at the moment. We need to + think more carefully about this. If you copy this code into + another command, change the error message; the user shouldn't + have to know anything about agent expressions. */ + if (overlay_debugging) + error ("GDB can't do agent expression translation with overlays."); + + if (exp == 0) + error_no_arg ("expression to translate"); + + expr = parse_expression (exp); + old_chain = make_cleanup ((make_cleanup_func) free_current_contents, &expr); + agent = gen_trace_for_expr (fi->pc, expr); + make_cleanup ((make_cleanup_func) free_agent_expr, agent); + ax_print (gdb_stdout, agent); + ax_reqs (agent, &reqs); + + do_cleanups (old_chain); + dont_repeat (); +} + + +/* Initialization code. */ + +void _initialize_ax_gdb PARAMS ((void)); +void +_initialize_ax_gdb () +{ + struct cmd_list_element *c; + + add_cmd ("agent", class_maintenance, agent_command, + "Translate an expression into remote agent bytecode.", + &maintenancelist); +} |
