diff options
Diffstat (limited to 'gdb/ax-gdb.c')
| -rw-r--r-- | gdb/ax-gdb.c | 492 |
1 files changed, 207 insertions, 285 deletions
diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c index fc214e7..e28365e 100644 --- a/gdb/ax-gdb.c +++ b/gdb/ax-gdb.c @@ -64,8 +64,6 @@ strings. Remember, "GBD" stands for "Great Britain, Dammit!" So be careful. */ - - /* Prototypes for local functions. */ @@ -80,7 +78,6 @@ static void gen_extend (struct agent_expr *, struct type *); static void gen_fetch (struct agent_expr *, struct type *); static void gen_left_shift (struct agent_expr *, int); - static void gen_frame_args_address (struct agent_expr *); static void gen_frame_locals_address (struct agent_expr *); static void gen_offset (struct agent_expr *ax, int offset); @@ -88,26 +85,24 @@ static void gen_sym_offset (struct agent_expr *, struct symbol *); static void gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var); - -static void gen_int_literal (struct agent_expr *ax, - struct axs_value *value, +static void gen_int_literal (struct agent_expr *ax, struct axs_value *value, LONGEST k, struct type *type); static void gen_usual_unary (struct agent_expr *ax, struct axs_value *value); static int type_wider_than (struct type *type1, struct type *type2); static struct type *max_type (struct type *type1, struct type *type2); -static void gen_conversion (struct agent_expr *ax, - struct type *from, struct type *to); +static void gen_conversion (struct agent_expr *ax, struct type *from, + struct type *to); static int is_nontrivial_conversion (struct type *from, struct type *to); static void gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1, struct axs_value *value2); static void gen_integral_promotions (struct agent_expr *ax, struct axs_value *value); -static void gen_cast (struct agent_expr *ax, - struct axs_value *value, struct type *type); -static void gen_scale (struct agent_expr *ax, - enum agent_op op, struct type *type); +static void gen_cast (struct agent_expr *ax, struct axs_value *value, + struct type *type); +static void gen_scale (struct agent_expr *ax, enum agent_op op, + struct type *type); static void gen_ptradd (struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2); static void gen_ptrsub (struct agent_expr *ax, struct axs_value *value, @@ -115,13 +110,10 @@ static void gen_ptrsub (struct agent_expr *ax, struct axs_value *value, static void gen_ptrdiff (struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2, struct type *result_type); -static void gen_binop (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, - const char *name); +static void gen_binop (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, const char *name); static void gen_logical_not (struct agent_expr *ax, struct axs_value *value, struct type *result_type); static void gen_complement (struct agent_expr *ax, struct axs_value *value); @@ -130,28 +122,23 @@ static void gen_address_of (struct axs_value *); static void gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value, struct type *type, int start, int end); static void gen_primitive_field (struct agent_expr *ax, - struct axs_value *value, - int offset, int fieldno, struct type *type); + struct axs_value *value, int offset, + int fieldno, struct type *type); static int gen_struct_ref_recursive (struct agent_expr *ax, struct axs_value *value, const char *field, int offset, struct type *type); -static void gen_struct_ref (struct agent_expr *ax, - struct axs_value *value, - const char *field, - const char *operator_name, +static void gen_struct_ref (struct agent_expr *ax, struct axs_value *value, + const char *field, const char *operator_name, const char *operand_name); static void gen_static_field (struct agent_expr *ax, struct axs_value *value, struct type *type, int fieldno); -static void gen_expr_binop_rest (struct expression *exp, - enum exp_opcode op, +static void gen_expr_binop_rest (struct expression *exp, enum exp_opcode op, struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2); - - /* Generating bytecode from GDB expressions: general assumptions */ /* Here are a few general assumptions made throughout the code; if you @@ -194,14 +181,12 @@ static void gen_expr_binop_rest (struct expression *exp, 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.) */ - /* Scan for all static fields in the given class, including any base classes, and generate tracing bytecodes for each. */ static void -gen_trace_static_fields (struct agent_expr *ax, - struct type *type) +gen_trace_static_fields (struct agent_expr *ax, struct type *type) { int i, nbases = TYPE_N_BASECLASSES (type); struct axs_value value; @@ -253,8 +238,7 @@ static void gen_traced_pop (struct agent_expr *ax, struct axs_value *value) { int string_trace = 0; - if (ax->trace_string - && value->type->code () == TYPE_CODE_PTR + if (ax->trace_string && value->type->code () == TYPE_CODE_PTR && c_textual_element_type (check_typedef (value->type->target_type ()), 's')) string_trace = 1; @@ -304,7 +288,7 @@ gen_traced_pop (struct agent_expr *ax, struct axs_value *value) larger than will fit in a stack, so just mark it for collection and be done with it. */ ax_reg_mask (ax, value->u.reg); - + /* But if the register points to a string, assume the value will fit on the stack and push it anyway. */ if (string_trace) @@ -325,8 +309,6 @@ gen_traced_pop (struct agent_expr *ax, struct axs_value *value) || value->type->code () == TYPE_CODE_UNION)) gen_trace_static_fields (ax, value->type); } - - /* Generating bytecode from GDB expressions: helper functions */ @@ -340,7 +322,6 @@ gen_sign_extend (struct agent_expr *ax, struct type *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. */ @@ -353,7 +334,6 @@ gen_extend (struct agent_expr *ax, struct type *type) ((type->is_unsigned () ? 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. */ @@ -400,7 +380,7 @@ gen_fetch (struct agent_expr *ax, struct type *type) implementing something we should be (this code's fault). In any case, it's a bug the user shouldn't see. */ default: - internal_error (_("gen_fetch: strange size")); + internal_error (_ ("gen_fetch: strange size")); } gen_sign_extend (ax, type); @@ -410,12 +390,10 @@ gen_fetch (struct agent_expr *ax, struct type *type) /* Our caller requested us to dereference a pointer from an unsupported type. Error out and give callers a chance to handle the failure gracefully. */ - error (_("gen_fetch: Unsupported type code `%s'."), - type->name ()); + error (_ ("gen_fetch: Unsupported type code `%s'."), type->name ()); } } - /* 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. */ @@ -433,8 +411,6 @@ gen_left_shift (struct agent_expr *ax, int distance) ax_simple (ax, aop_rsh_unsigned); } } - - /* Generating bytecode from GDB expressions: symbol references */ @@ -446,13 +422,12 @@ gen_frame_args_address (struct agent_expr *ax) int frame_reg; LONGEST frame_offset; - gdbarch_virtual_frame_pointer (ax->gdbarch, - ax->scope, &frame_reg, &frame_offset); + gdbarch_virtual_frame_pointer (ax->gdbarch, 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 @@ -461,13 +436,12 @@ gen_frame_locals_address (struct agent_expr *ax) int frame_reg; LONGEST frame_offset; - gdbarch_virtual_frame_pointer (ax->gdbarch, - ax->scope, &frame_reg, &frame_offset); + gdbarch_virtual_frame_pointer (ax->gdbarch, 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 @@ -491,7 +465,6 @@ gen_offset (struct agent_expr *ax, int offset) } } - /* 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. */ @@ -501,12 +474,12 @@ gen_sym_offset (struct agent_expr *ax, struct symbol *var) gen_offset (ax, var->value_longest ()); } - /* 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 (struct agent_expr *ax, struct axs_value *value, struct symbol *var) +gen_var_ref (struct agent_expr *ax, struct axs_value *value, + struct symbol *var) { /* Dereference any typedefs. */ value->type = check_typedef (var->type ()); @@ -521,19 +494,19 @@ gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var) /* I'm imitating the code in read_var_value. */ switch (var->aclass ()) { - case LOC_CONST: /* A constant, like an enum value. */ + case LOC_CONST: /* A constant, like an enum value. */ ax_const_l (ax, (LONGEST) var->value_longest ()); value->kind = axs_rvalue; break; - case LOC_LABEL: /* A goto label, being used as a value. */ + case LOC_LABEL: /* A goto label, being used as a value. */ ax_const_l (ax, (LONGEST) var->value_address ()); value->kind = axs_rvalue; break; case LOC_CONST_BYTES: - internal_error (_("gen_var_ref: LOC_CONST_BYTES " - "symbols are not supported")); + internal_error (_ ("gen_var_ref: LOC_CONST_BYTES " + "symbols are not supported")); /* Variable at a fixed location in memory. Easy. */ case LOC_STATIC: @@ -542,13 +515,13 @@ gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var) value->kind = axs_lvalue_memory; break; - case LOC_ARG: /* var lives in argument area of frame */ + 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 + 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); @@ -557,15 +530,14 @@ gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var) value->kind = axs_lvalue_memory; break; - case LOC_LOCAL: /* var lives in locals area of frame */ + case LOC_LOCAL: /* var lives in locals area of frame */ gen_frame_locals_address (ax); gen_sym_offset (ax, var); value->kind = axs_lvalue_memory; break; case LOC_TYPEDEF: - error (_("Cannot compute value of typedef `%s'."), - var->print_name ()); + error (_ ("Cannot compute value of typedef `%s'."), var->print_name ()); break; case LOC_BLOCK: @@ -598,7 +570,7 @@ gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var) = lookup_minimal_symbol (var->linkage_name (), NULL, NULL); if (!msym.minsym) - error (_("Couldn't resolve symbol `%s'."), var->print_name ()); + error (_ ("Couldn't resolve symbol `%s'."), var->print_name ()); /* Push the address of the variable. */ ax_const_l (ax, msym.value_address ()); @@ -616,7 +588,7 @@ gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var) break; default: - error (_("Cannot find value of botched symbol `%s'."), + error (_ ("Cannot find value of botched symbol `%s'."), var->print_name ()); break; } @@ -627,8 +599,8 @@ gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var) the result. */ static void -gen_msym_var_ref (agent_expr *ax, axs_value *value, - minimal_symbol *msymbol, objfile *objf) +gen_msym_var_ref (agent_expr *ax, axs_value *value, minimal_symbol *msymbol, + objfile *objf) { CORE_ADDR address; type *t = find_minsym_type_and_address (msymbol, objf, &address); @@ -638,9 +610,6 @@ gen_msym_var_ref (agent_expr *ax, axs_value *value, value->kind = axs_lvalue_memory; } - - - /* Generating bytecode from GDB expressions: literals */ static void @@ -651,8 +620,6 @@ gen_int_literal (struct agent_expr *ax, struct axs_value *value, LONGEST k, value->kind = axs_rvalue; value->type = check_typedef (type); } - - /* Generating bytecode from GDB expressions: unary conversions, casts */ @@ -669,7 +636,7 @@ require_rvalue (struct agent_expr *ax, struct axs_value *value) || value->type->code () == TYPE_CODE_STRUCT || value->type->code () == TYPE_CODE_UNION || value->type->code () == TYPE_CODE_FUNC) - error (_("Value not scalar: cannot be an rvalue.")); + error (_ ("Value not scalar: cannot be an rvalue.")); switch (value->kind) { @@ -696,7 +663,6 @@ require_rvalue (struct agent_expr *ax, struct axs_value *value) 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 @@ -726,7 +692,7 @@ gen_usual_unary (struct agent_expr *ax, struct axs_value *value) /* 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. */ + value->kind = axs_rvalue; /* Should always be true, but just in case. */ break; /* Arrays get converted to a pointer to their first element, and @@ -753,19 +719,16 @@ gen_usual_unary (struct agent_expr *ax, struct axs_value *value) 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 (struct type *type1, struct type *type2) { return (type1->length () > type2->length () - || (type1->length () == type2->length () - && type1->is_unsigned () + || (type1->length () == type2->length () && type1->is_unsigned () && !type2->is_unsigned ())); } - /* Return the "wider" of the two types TYPE1 and TYPE2. */ static struct type * max_type (struct type *type1, struct type *type2) @@ -773,7 +736,6 @@ max_type (struct type *type1, struct type *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 (struct agent_expr *ax, struct type *from, struct type *to) @@ -802,7 +764,6 @@ gen_conversion (struct agent_expr *ax, struct type *from, struct type *to) } } - /* Return non-zero iff the type FROM will require any bytecodes to be emitted to be converted to the type TO. */ static int @@ -822,7 +783,6 @@ is_nontrivial_conversion (struct type *from, struct type *to) 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, @@ -861,7 +821,6 @@ gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1, } } - /* 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. */ @@ -882,7 +841,6 @@ gen_integral_promotions (struct agent_expr *ax, struct axs_value *value) } } - /* Generate code for a cast to TYPE. */ static void gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type) @@ -906,7 +864,7 @@ gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type) case TYPE_CODE_STRUCT: case TYPE_CODE_UNION: case TYPE_CODE_FUNC: - error (_("Invalid type cast: intended type must be scalar.")); + error (_ ("Invalid type cast: intended type must be scalar.")); case TYPE_CODE_ENUM: case TYPE_CODE_BOOL: @@ -929,13 +887,11 @@ gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type) break; default: - error (_("Casts to requested type are not yet implemented.")); + error (_ ("Casts to requested type are not yet implemented.")); } value->type = type; } - - /* Generating bytecode from GDB expressions: arithmetic */ @@ -953,7 +909,6 @@ gen_scale (struct agent_expr *ax, enum agent_op op, struct type *type) } } - /* Generate code for pointer arithmetic PTR + INT. */ static void gen_ptradd (struct agent_expr *ax, struct axs_value *value, @@ -964,12 +919,11 @@ gen_ptradd (struct agent_expr *ax, struct axs_value *value, gen_scale (ax, aop_mul, value1->type); ax_simple (ax, aop_add); - gen_extend (ax, value1->type); /* Catch overflow. */ + gen_extend (ax, value1->type); /* Catch overflow. */ value->type = value1->type; value->kind = axs_rvalue; } - /* Generate code for pointer arithmetic PTR - INT. */ static void gen_ptrsub (struct agent_expr *ax, struct axs_value *value, @@ -980,12 +934,11 @@ gen_ptrsub (struct agent_expr *ax, struct axs_value *value, gen_scale (ax, aop_mul, value1->type); ax_simple (ax, aop_sub); - gen_extend (ax, value1->type); /* Catch overflow. */ + gen_extend (ax, value1->type); /* Catch overflow. */ value->type = value1->type; value->kind = axs_rvalue; } - /* Generate code for pointer arithmetic PTR - PTR. */ static void gen_ptrdiff (struct agent_expr *ax, struct axs_value *value, @@ -997,7 +950,7 @@ gen_ptrdiff (struct agent_expr *ax, struct axs_value *value, if (value1->type->target_type ()->length () != value2->type->target_type ()->length ()) - error (_("\ + error (_ ("\ First argument of `-' is a pointer, but second argument is neither\n\ an integer nor a pointer of the same type.")); @@ -1012,11 +965,11 @@ gen_equal (struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2, struct type *result_type) { - if (value1->type->is_pointer_or_reference () || value2->type->is_pointer_or_reference ()) + if (value1->type->is_pointer_or_reference () + || value2->type->is_pointer_or_reference ()) ax_simple (ax, aop_equal); else - gen_binop (ax, value, value1, value2, - aop_equal, aop_equal, 0, "equal"); + gen_binop (ax, value, value1, value2, aop_equal, aop_equal, 0, "equal"); value->type = result_type; value->kind = axs_rvalue; } @@ -1026,11 +979,12 @@ gen_less (struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2, struct type *result_type) { - if (value1->type->is_pointer_or_reference () || value2->type->is_pointer_or_reference ()) + if (value1->type->is_pointer_or_reference () + || value2->type->is_pointer_or_reference ()) ax_simple (ax, aop_less_unsigned); else - gen_binop (ax, value, value1, value2, - aop_less_signed, aop_less_unsigned, 0, "less than"); + gen_binop (ax, value, value1, value2, aop_less_signed, aop_less_unsigned, + 0, "less than"); value->type = result_type; value->kind = axs_rvalue; } @@ -1044,46 +998,42 @@ gen_less (struct agent_expr *ax, struct axs_value *value, static void gen_binop (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, const char *name) + enum agent_op op, enum agent_op op_unsigned, int may_carry, + const char *name) { /* We only handle INT op INT. */ if ((value1->type->code () != TYPE_CODE_INT) || (value2->type->code () != TYPE_CODE_INT)) - error (_("Invalid combination of types in %s."), name); + error (_ ("Invalid combination of types in %s."), name); ax_simple (ax, value1->type->is_unsigned () ? op_unsigned : op); if (may_carry) - gen_extend (ax, value1->type); /* catch overflow */ + gen_extend (ax, value1->type); /* catch overflow */ value->type = value1->type; value->kind = axs_rvalue; } - static void gen_logical_not (struct agent_expr *ax, struct axs_value *value, struct type *result_type) { if (value->type->code () != TYPE_CODE_INT && value->type->code () != TYPE_CODE_PTR) - error (_("Invalid type of operand to `!'.")); + error (_ ("Invalid type of operand to `!'.")); ax_simple (ax, aop_log_not); value->type = result_type; } - static void gen_complement (struct agent_expr *ax, struct axs_value *value) { if (value->type->code () != TYPE_CODE_INT) - error (_("Invalid type of operand to `~'.")); + error (_ ("Invalid type of operand to `~'.")); ax_simple (ax, aop_bit_not); gen_extend (ax, value->type); } - - /* Generating bytecode from GDB expressions: * & . -> @ sizeof */ @@ -1094,7 +1044,7 @@ gen_deref (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->is_pointer_or_reference ()) - internal_error (_("gen_deref: expected a pointer")); + internal_error (_ ("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 @@ -1103,12 +1053,11 @@ gen_deref (struct axs_value *value) to the consumer to actually dereference it. */ value->type = check_typedef (value->type->target_type ()); if (value->type->code () == TYPE_CODE_VOID) - error (_("Attempt to dereference a generic pointer.")); - value->kind = ((value->type->code () == TYPE_CODE_FUNC) - ? axs_rvalue : axs_lvalue_memory); + error (_ ("Attempt to dereference a generic pointer.")); + 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 (struct axs_value *value) @@ -1124,10 +1073,10 @@ gen_address_of (struct axs_value *value) switch (value->kind) { case axs_rvalue: - error (_("Operand of `&' is an rvalue, which has no address.")); + 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.")); + error (_ ("Operand of `&' is in a register, and has no address.")); case axs_lvalue_memory: value->kind = axs_rvalue; @@ -1145,8 +1094,8 @@ gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value, struct type *type, int start, int end) { /* Note that ops[i] fetches 8 << i bits. */ - static enum agent_op ops[] - = {aop_ref8, aop_ref16, aop_ref32, aop_ref64}; + 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 @@ -1178,9 +1127,8 @@ gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value, /* 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); + int bound_end + = (((end + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT) * TARGET_CHAR_BIT); /* current bit offset within the structure */ int offset; @@ -1197,7 +1145,7 @@ gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value, /* Can we fetch the number of bits requested at all? */ if ((end - start) > ((1 << num_ops) * 8)) - internal_error (_("gen_bitfield_ref: bitfield too wide")); + internal_error (_ ("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. */ @@ -1218,7 +1166,7 @@ gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value, int last_frag = (offset + op_size == bound_end); if (!last_frag) - ax_simple (ax, aop_dup); /* keep a copy of the address */ + ax_simple (ax, aop_dup); /* keep a copy of the address */ /* Add the offset. */ gen_offset (ax, offset / TARGET_CHAR_BIT); @@ -1304,16 +1252,16 @@ gen_primitive_field (struct agent_expr *ax, struct axs_value *value, { /* Is this a bitfield? */ if (TYPE_FIELD_PACKED (type, fieldno)) - gen_bitfield_ref (ax, value, type->field (fieldno).type (), - (offset * TARGET_CHAR_BIT - + type->field (fieldno).loc_bitpos ()), - (offset * TARGET_CHAR_BIT - + type->field (fieldno).loc_bitpos () - + TYPE_FIELD_BITSIZE (type, fieldno))); + gen_bitfield_ref ( + ax, value, type->field (fieldno).type (), + (offset * TARGET_CHAR_BIT + type->field (fieldno).loc_bitpos ()), + (offset * TARGET_CHAR_BIT + type->field (fieldno).loc_bitpos () + + TYPE_FIELD_BITSIZE (type, fieldno))); else { - gen_offset (ax, offset - + type->field (fieldno).loc_bitpos () / TARGET_CHAR_BIT); + gen_offset (ax, + offset + + type->field (fieldno).loc_bitpos () / TARGET_CHAR_BIT); value->kind = axs_lvalue_memory; value->type = type->field (fieldno).type (); } @@ -1347,8 +1295,8 @@ gen_struct_ref_recursive (struct agent_expr *ax, struct axs_value *value, { gen_static_field (ax, value, type, i); if (value->optimized_out) - error (_("static field `%s' has been " - "optimized out, cannot use"), + error (_ ("static field `%s' has been " + "optimized out, cannot use"), field); return 1; } @@ -1368,10 +1316,9 @@ gen_struct_ref_recursive (struct agent_expr *ax, struct axs_value *value, { struct type *basetype = check_typedef (TYPE_BASECLASS (type, i)); - rslt = gen_struct_ref_recursive (ax, value, field, - offset + TYPE_BASECLASS_BITPOS (type, i) - / TARGET_CHAR_BIT, - basetype); + rslt = gen_struct_ref_recursive ( + ax, value, field, + offset + TYPE_BASECLASS_BITPOS (type, i) / TARGET_CHAR_BIT, basetype); if (rslt) return 1; } @@ -1404,30 +1351,29 @@ gen_struct_ref (struct agent_expr *ax, struct axs_value *value, type = check_typedef (value->type); /* This must yield a structure or a union. */ - if (type->code () != TYPE_CODE_STRUCT - && type->code () != TYPE_CODE_UNION) - error (_("The left operand of `%s' is not a %s."), - operator_name, operand_name); + if (type->code () != TYPE_CODE_STRUCT && type->code () != 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.")); + error (_ ("Structure does not live in memory.")); /* Search through fields and base classes recursively. */ found = gen_struct_ref_recursive (ax, value, field, 0, type); - + if (!found) - error (_("Couldn't find member named `%s' in struct/union/class `%s'"), + error (_ ("Couldn't find member named `%s' in struct/union/class `%s'"), field, type->name ()); } -static int -gen_namespace_elt (struct agent_expr *ax, struct axs_value *value, - const struct type *curtype, const char *name); -static int -gen_maybe_namespace_elt (struct agent_expr *ax, struct axs_value *value, - const struct type *curtype, const char *name); +static int gen_namespace_elt (struct agent_expr *ax, struct axs_value *value, + const struct type *curtype, const char *name); +static int gen_maybe_namespace_elt (struct agent_expr *ax, + struct axs_value *value, + const struct type *curtype, + const char *name); static void gen_static_field (struct agent_expr *ax, struct axs_value *value, @@ -1448,7 +1394,7 @@ gen_static_field (struct agent_expr *ax, struct axs_value *value, if (sym) { gen_var_ref (ax, value, sym); - + /* Don't error if the value was optimized out, we may be scanning all static fields and just want to pass over this and continue with the rest. */ @@ -1469,9 +1415,8 @@ gen_struct_elt_for_reference (struct agent_expr *ax, struct axs_value *value, struct type *t = type; int i; - if (t->code () != TYPE_CODE_STRUCT - && t->code () != TYPE_CODE_UNION) - internal_error (_("non-aggregate type to gen_struct_elt_for_reference")); + if (t->code () != TYPE_CODE_STRUCT && t->code () != TYPE_CODE_UNION) + internal_error (_ ("non-aggregate type to gen_struct_elt_for_reference")); for (i = t->num_fields () - 1; i >= TYPE_N_BASECLASSES (t); i--) { @@ -1483,17 +1428,17 @@ gen_struct_elt_for_reference (struct agent_expr *ax, struct axs_value *value, { gen_static_field (ax, value, t, i); if (value->optimized_out) - error (_("static field `%s' has been " - "optimized out, cannot use"), + error (_ ("static field `%s' has been " + "optimized out, cannot use"), fieldname); return 1; } if (TYPE_FIELD_PACKED (t, i)) - error (_("pointers to bitfield members not allowed")); + error (_ ("pointers to bitfield members not allowed")); - /* FIXME we need a way to do "want_address" equivalent */ + /* FIXME we need a way to do "want_address" equivalent */ - error (_("Cannot reference non-static field \"%s\""), fieldname); + error (_ ("Cannot reference non-static field \"%s\""), fieldname); } } @@ -1513,8 +1458,8 @@ gen_namespace_elt (struct agent_expr *ax, struct axs_value *value, int found = gen_maybe_namespace_elt (ax, value, curtype, name); if (!found) - error (_("No symbol \"%s\" in namespace \"%s\"."), - name, curtype->name ()); + error (_ ("No symbol \"%s\" in namespace \"%s\"."), name, + curtype->name ()); return found; } @@ -1533,8 +1478,7 @@ gen_maybe_namespace_elt (struct agent_expr *ax, struct axs_value *value, struct block_symbol sym; sym = cp_lookup_symbol_namespace (namespace_name, name, - block_for_pc (ax->scope), - VAR_DOMAIN); + block_for_pc (ax->scope), VAR_DOMAIN); if (sym.symbol == NULL) return 0; @@ -1542,13 +1486,12 @@ gen_maybe_namespace_elt (struct agent_expr *ax, struct axs_value *value, gen_var_ref (ax, value, sym.symbol); if (value->optimized_out) - error (_("`%s' has been optimized out, cannot use"), + error (_ ("`%s' has been optimized out, cannot use"), sym.symbol->print_name ()); return 1; } - static int gen_aggregate_elt_ref (struct agent_expr *ax, struct axs_value *value, struct type *type, const char *field) @@ -1563,22 +1506,18 @@ gen_aggregate_elt_ref (struct agent_expr *ax, struct axs_value *value, return gen_namespace_elt (ax, value, type, field); break; default: - internal_error (_("non-aggregate type in gen_aggregate_elt_ref")); + internal_error (_ ("non-aggregate type in gen_aggregate_elt_ref")); } return 0; } - - namespace expr { void -operation::generate_ax (struct expression *exp, - struct agent_expr *ax, - struct axs_value *value, - struct type *cast_type) +operation::generate_ax (struct expression *exp, struct agent_expr *ax, + struct axs_value *value, struct type *cast_type) { if (constant_p ()) { @@ -1596,8 +1535,7 @@ operation::generate_ax (struct expression *exp, } void -scope_operation::do_generate_ax (struct expression *exp, - struct agent_expr *ax, +scope_operation::do_generate_ax (struct expression *exp, struct agent_expr *ax, struct axs_value *value, struct type *cast_type) { @@ -1605,7 +1543,7 @@ scope_operation::do_generate_ax (struct expression *exp, const std::string &name = std::get<1> (m_storage); int found = gen_aggregate_elt_ref (ax, value, type, name.c_str ()); if (!found) - error (_("There is no field named %s"), name.c_str ()); + error (_ ("There is no field named %s"), name.c_str ()); } void @@ -1647,11 +1585,11 @@ register_operation::do_generate_ax (struct expression *exp, reg = user_reg_map_name_to_regnum (ax->gdbarch, name, len); if (reg == -1) - internal_error (_("Register $%s not available"), name); + internal_error (_ ("Register $%s not available"), name); /* No support for tracing user registers yet. */ if (reg >= gdbarch_num_cooked_regs (ax->gdbarch)) - error (_("'%s' is a user-register; " - "GDB cannot yet trace user-register contents."), + error (_ ("'%s' is a user-register; " + "GDB cannot yet trace user-register contents."), name); value->kind = axs_lvalue_register; value->u.reg = reg; @@ -1678,9 +1616,10 @@ internalvar_operation::do_generate_ax (struct expression *exp, value->kind = axs_rvalue; value->type = builtin_type (ax->gdbarch)->builtin_long_long; } - else if (! compile_internalvar_to_ax (var, ax, value)) - error (_("$%s is not a trace state variable; GDB agent " - "expressions cannot use convenience variables."), name); + else if (!compile_internalvar_to_ax (var, ax, value)) + error (_ ("$%s is not a trace state variable; GDB agent " + "expressions cannot use convenience variables."), + name); } void @@ -1735,36 +1674,34 @@ repeat_operation::do_generate_ax (struct expression *exp, here. */ std::get<0> (m_storage)->generate_ax (exp, ax, &value1); if (value1.kind != axs_lvalue_memory) - error (_("Left operand of `@' must be an object in memory.")); + error (_ ("Left operand of `@' must be an object in memory.")); /* Evaluate the length; it had better be a constant. */ if (!std::get<1> (m_storage)->constant_p ()) - error (_("Right operand of `@' must be a " - "constant, in agent expressions.")); + error (_ ("Right operand of `@' must be a " + "constant, in agent expressions.")); struct value *v = std::get<1> (m_storage)->evaluate (nullptr, exp, EVAL_AVOID_SIDE_EFFECTS); if (value_type (v)->code () != TYPE_CODE_INT) - error (_("Right operand of `@' must be an integer.")); + error (_ ("Right operand of `@' must be an integer.")); int length = value_as_long (v); if (length <= 0) - error (_("Right operand of `@' must be positive.")); + 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 *array - = lookup_array_range_type (value1.type, 0, length - 1); + struct type *array = lookup_array_range_type (value1.type, 0, length - 1); value->kind = axs_lvalue_memory; value->type = array; } void -comma_operation::do_generate_ax (struct expression *exp, - struct agent_expr *ax, +comma_operation::do_generate_ax (struct expression *exp, struct agent_expr *ax, struct axs_value *value, struct type *cast_type) { @@ -1828,7 +1765,7 @@ unop_extract_operation::do_generate_ax (struct expression *exp, struct type *to_type = get_type (); if (!is_scalar_type (to_type)) - error (_("can't generate agent expression to extract non-scalar type")); + error (_ ("can't generate agent expression to extract non-scalar type")); if (to_type->is_unsigned ()) gen_extend (ax, to_type); @@ -1892,13 +1829,12 @@ op_this_operation::do_generate_ax (struct expression *exp, sym = lookup_language_this (lang, b).symbol; if (!sym) - error (_("no `%s' found"), lang->name_of_this ()); + error (_ ("no `%s' found"), lang->name_of_this ()); gen_var_ref (ax, value, sym); if (value->optimized_out) - error (_("`%s' has been optimized out, cannot use"), - sym->print_name ()); + error (_ ("`%s' has been optimized out, cannot use"), sym->print_name ()); } void @@ -1909,7 +1845,7 @@ assign_operation::do_generate_ax (struct expression *exp, { operation *subop = std::get<0> (m_storage).get (); if (subop->opcode () != OP_INTERNALVAR) - error (_("May only assign to trace state variables")); + error (_ ("May only assign to trace state variables")); internalvar_operation *ivarop = gdb::checked_static_cast<internalvar_operation *> (subop); @@ -1926,8 +1862,9 @@ assign_operation::do_generate_ax (struct expression *exp, ax_tsv (ax, aop_tracev, tsv->number); } else - error (_("$%s is not a trace state variable, " - "may not assign to it"), name); + error (_ ("$%s is not a trace state variable, " + "may not assign to it"), + name); } void @@ -1938,7 +1875,7 @@ assign_modify_operation::do_generate_ax (struct expression *exp, { operation *subop = std::get<1> (m_storage).get (); if (subop->opcode () != OP_INTERNALVAR) - error (_("May only assign to trace state variables")); + error (_ ("May only assign to trace state variables")); internalvar_operation *ivarop = gdb::checked_static_cast<internalvar_operation *> (subop); @@ -1959,16 +1896,17 @@ assign_modify_operation::do_generate_ax (struct expression *exp, value1.type = builtin_type (ax->gdbarch)->builtin_long_long; /* Now do right half of expression. */ std::get<2> (m_storage)->generate_ax (exp, ax, &value2); - gen_expr_binop_rest (exp, std::get<0> (m_storage), ax, - value, &value1, &value2); + gen_expr_binop_rest (exp, std::get<0> (m_storage), ax, value, &value1, + &value2); /* We have a result of the binary op, set the tsv. */ ax_tsv (ax, aop_setv, tsv->number); if (ax->tracing) ax_tsv (ax, aop_tracev, tsv->number); } else - error (_("$%s is not a trace state variable, " - "may not assign to it"), name); + error (_ ("$%s is not a trace state variable, " + "may not assign to it"), + name); } void @@ -1992,7 +1930,7 @@ var_value_operation::do_generate_ax (struct expression *exp, gen_var_ref (ax, value, std::get<0> (m_storage).symbol); if (value->optimized_out) - error (_("`%s' has been optimized out, cannot use"), + error (_ ("`%s' has been optimized out, cannot use"), std::get<0> (m_storage).symbol->print_name ()); if (value->type->code () == TYPE_CODE_ERROR) @@ -2059,15 +1997,14 @@ logical_or_operation::do_generate_ax (struct expression *exp, value->type = builtin_type (ax->gdbarch)->builtin_int; } -} +} // namespace expr /* This handles the middle-to-right-side of code generation for binary expressions, which is shared between regular binary operations and assign-modify (+= and friends) expressions. */ static void -gen_expr_binop_rest (struct expression *exp, - enum exp_opcode op, +gen_expr_binop_rest (struct expression *exp, enum exp_opcode op, struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2) { @@ -2089,41 +2026,39 @@ gen_expr_binop_rest (struct expression *exp, && value2->type->code () == TYPE_CODE_INT) gen_ptradd (ax, value, value1, value2); else - gen_binop (ax, value, value1, value2, - aop_add, aop_add, 1, "addition"); + gen_binop (ax, value, value1, value2, aop_add, aop_add, 1, "addition"); break; case BINOP_SUB: if (value1->type->is_pointer_or_reference () && value2->type->code () == TYPE_CODE_INT) - gen_ptrsub (ax,value, value1, value2); + gen_ptrsub (ax, value, value1, value2); else if (value1->type->is_pointer_or_reference () && value2->type->is_pointer_or_reference ()) /* FIXME --- result type should be ptrdiff_t */ gen_ptrdiff (ax, value, value1, value2, builtin_type (ax->gdbarch)->builtin_long); else - gen_binop (ax, value, value1, value2, - aop_sub, aop_sub, 1, "subtraction"); + gen_binop (ax, value, value1, value2, aop_sub, aop_sub, 1, + "subtraction"); break; case BINOP_MUL: - gen_binop (ax, value, value1, value2, - aop_mul, aop_mul, 1, "multiplication"); + 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"); + 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"); + gen_binop (ax, value, value1, value2, aop_rem_signed, aop_rem_unsigned, + 1, "remainder"); break; case BINOP_LSH: - gen_binop (ax, value, value1, value2, - aop_lsh, aop_lsh, 1, "left shift"); + gen_binop (ax, value, value1, value2, aop_lsh, aop_lsh, 1, "left shift"); break; case BINOP_RSH: - gen_binop (ax, value, value1, value2, - aop_rsh_signed, aop_rsh_unsigned, 1, "right shift"); + gen_binop (ax, value, value1, value2, aop_rsh_signed, aop_rsh_unsigned, + 1, "right shift"); break; case BINOP_SUBSCRIPT: { @@ -2131,8 +2066,8 @@ gen_expr_binop_rest (struct expression *exp, if (binop_types_user_defined_p (op, value1->type, value2->type)) { - error (_("cannot subscript requested type: " - "cannot call user defined functions")); + error (_ ("cannot subscript requested type: " + "cannot call user defined functions")); } else { @@ -2144,34 +2079,34 @@ gen_expr_binop_rest (struct expression *exp, && type->code () != TYPE_CODE_PTR) { if (type->name ()) - error (_("cannot subscript something of type `%s'"), + error (_ ("cannot subscript something of type `%s'"), type->name ()); else - error (_("cannot subscript requested type")); + error (_ ("cannot subscript requested type")); } } if (!is_integral_type (value2->type)) - error (_("Argument to arithmetic operation " - "not a number or boolean.")); + error (_ ("Argument to arithmetic operation " + "not a number or boolean.")); gen_ptradd (ax, value, value1, value2); gen_deref (value); break; } case BINOP_BITWISE_AND: - gen_binop (ax, value, value1, value2, - aop_bit_and, aop_bit_and, 0, "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"); + 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"); + gen_binop (ax, value, value1, value2, aop_bit_xor, aop_bit_xor, 0, + "bitwise exclusive-or"); break; case BINOP_EQUAL: @@ -2206,15 +2141,14 @@ gen_expr_binop_rest (struct expression *exp, default: /* We should only list operators in the outer case statement that we actually handle in the inner case statement. */ - internal_error (_("gen_expr: op case sets don't match")); + internal_error (_ ("gen_expr: op case sets don't match")); } } /* A helper function that emits a binop based on two operations. */ void -gen_expr_binop (struct expression *exp, - enum exp_opcode op, +gen_expr_binop (struct expression *exp, enum exp_opcode op, expr::operation *lhs, expr::operation *rhs, struct agent_expr *ax, struct axs_value *value) { @@ -2230,31 +2164,27 @@ gen_expr_binop (struct expression *exp, member name. */ void -gen_expr_structop (struct expression *exp, - enum exp_opcode op, - expr::operation *lhs, - const char *name, +gen_expr_structop (struct expression *exp, enum exp_opcode op, + expr::operation *lhs, const char *name, struct agent_expr *ax, struct axs_value *value) { lhs->generate_ax (exp, 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"); + 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. */ - internal_error (_("gen_expr: unhandled struct case")); + internal_error (_ ("gen_expr: unhandled struct case")); } /* A helper function that emits a unary operation. */ void -gen_expr_unop (struct expression *exp, - enum exp_opcode op, - expr::operation *lhs, - struct agent_expr *ax, struct axs_value *value) +gen_expr_unop (struct expression *exp, enum exp_opcode op, + expr::operation *lhs, struct agent_expr *ax, + struct axs_value *value) { struct axs_value value1, value2; @@ -2263,7 +2193,7 @@ gen_expr_unop (struct expression *exp, case UNOP_NEG: gen_int_literal (ax, &value1, 0, builtin_type (ax->gdbarch)->builtin_int); - gen_usual_unary (ax, &value1); /* shouldn't do much */ + gen_usual_unary (ax, &value1); /* shouldn't do much */ lhs->generate_ax (exp, ax, &value2); gen_usual_unary (ax, &value2); gen_usual_arithmetic (ax, &value1, &value2); @@ -2279,7 +2209,7 @@ gen_expr_unop (struct expression *exp, case UNOP_LOGICAL_NOT: lhs->generate_ax (exp, ax, value); gen_usual_unary (ax, value); - gen_logical_not (ax, value, builtin_type (ax->gdbarch)->builtin_int); + gen_logical_not (ax, value, builtin_type (ax->gdbarch)->builtin_int); break; case UNOP_COMPLEMENT: @@ -2293,7 +2223,7 @@ gen_expr_unop (struct expression *exp, lhs->generate_ax (exp, ax, value); gen_usual_unary (ax, value); if (!value->type->is_pointer_or_reference ()) - error (_("Argument of unary `*' is not a pointer.")); + error (_ ("Argument of unary `*' is not a pointer.")); gen_deref (value); break; @@ -2307,8 +2237,6 @@ gen_expr_unop (struct expression *exp, } } - - /* Given a single variable and a scope, generate bytecodes to trace its value. This is for use in situations where we have only a variable's name, and no parsed expression; for instance, when the @@ -2348,8 +2276,7 @@ gen_trace_for_var (CORE_ADDR scope, struct gdbarch *gdbarch, registers it relies upon. */ agent_expr_up -gen_trace_for_expr (CORE_ADDR scope, struct expression *expr, - int trace_string) +gen_trace_for_expr (CORE_ADDR scope, struct expression *expr, int trace_string) { agent_expr_up ax (new agent_expr (expr->gdbarch, scope)); struct axs_value value; @@ -2419,10 +2346,9 @@ gen_trace_for_return_address (CORE_ADDR scope, struct gdbarch *gdbarch, bytecode. */ agent_expr_up -gen_printf (CORE_ADDR scope, struct gdbarch *gdbarch, - CORE_ADDR function, LONGEST channel, - const char *format, int fmtlen, - int nargs, struct expression **exprs) +gen_printf (CORE_ADDR scope, struct gdbarch *gdbarch, CORE_ADDR function, + LONGEST channel, const char *format, int fmtlen, int nargs, + struct expression **exprs) { agent_expr_up ax (new agent_expr (gdbarch, scope)); struct axs_value value; @@ -2472,8 +2398,8 @@ agent_eval_command_one (const char *exp, int eval, CORE_ADDR pc) arg = exp; if (!eval && strcmp (arg, "$_ret") == 0) { - agent = gen_trace_for_return_address (pc, get_current_arch (), - trace_string); + agent + = gen_trace_for_return_address (pc, get_current_arch (), trace_string); } else { @@ -2505,10 +2431,10 @@ maint_agent_command_1 (const char *exp, int eval) 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.")); + error (_ ("GDB can't do agent expression translation with overlays.")); if (exp == 0) - error_no_arg (_("expression to translate")); + error_no_arg (_ ("expression to translate")); if (check_for_argument (&exp, "-at", sizeof ("-at") - 1)) { @@ -2516,9 +2442,8 @@ maint_agent_command_1 (const char *exp, int eval) location_spec_up locspec = new_linespec_location_spec (&exp, symbol_name_match_type::WILD); - decode_line_full (locspec.get (), DECODE_LINE_FUNFIRSTLINE, NULL, - NULL, 0, &canonical, - NULL, NULL); + decode_line_full (locspec.get (), DECODE_LINE_FUNFIRSTLINE, NULL, NULL, + 0, &canonical, NULL, NULL); exp = skip_spaces (exp); if (exp[0] == ',') { @@ -2557,7 +2482,7 @@ maint_agent_eval_command (const char *exp, int from_tty) static void maint_agent_printf_command (const char *cmdrest, int from_tty) { - frame_info_ptr fi = get_current_frame (); /* need current scope */ + frame_info_ptr fi = get_current_frame (); /* need current scope */ const char *format_start, *format_end; /* We don't deal with overlay debugging at the moment. We need to @@ -2565,15 +2490,15 @@ maint_agent_printf_command (const char *cmdrest, int from_tty) 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.")); + error (_ ("GDB can't do agent expression translation with overlays.")); if (cmdrest == 0) - error_no_arg (_("expression to translate")); + error_no_arg (_ ("expression to translate")); cmdrest = skip_spaces (cmdrest); if (*cmdrest++ != '"') - error (_("Must start with a format string.")); + error (_ ("Must start with a format string.")); format_start = cmdrest; @@ -2582,12 +2507,12 @@ maint_agent_printf_command (const char *cmdrest, int from_tty) format_end = cmdrest; if (*cmdrest++ != '"') - error (_("Bad format string, non-terminated '\"'.")); - + error (_ ("Bad format string, non-terminated '\"'.")); + cmdrest = skip_spaces (cmdrest); if (*cmdrest != ',' && *cmdrest != 0) - error (_("Invalid argument syntax")); + error (_ ("Invalid argument syntax")); if (*cmdrest == ',') cmdrest++; @@ -2607,11 +2532,9 @@ maint_agent_printf_command (const char *cmdrest, int from_tty) /* else complain? */ } - - agent_expr_up agent = gen_printf (get_frame_pc (fi), get_current_arch (), - 0, 0, - format_start, format_end - format_start, - argvec.size (), argvec.data ()); + agent_expr_up agent + = gen_printf (get_frame_pc (fi), get_current_arch (), 0, 0, format_start, + format_end - format_start, argvec.size (), argvec.data ()); ax_reqs (agent.get ()); ax_print (gdb_stdout, agent.get ()); @@ -2624,19 +2547,18 @@ maint_agent_printf_command (const char *cmdrest, int from_tty) /* Initialization code. */ void _initialize_ax_gdb (); + void _initialize_ax_gdb () { - add_cmd ("agent", class_maintenance, maint_agent_command, - _("\ + add_cmd ("agent", class_maintenance, maint_agent_command, _ ("\ Translate an expression into remote agent bytecode for tracing.\n\ Usage: maint agent [-at LOCATION,] EXPRESSION\n\ If -at is given, generate remote agent bytecode for this location.\n\ If not, generate remote agent bytecode for current frame pc address."), &maintenancelist); - add_cmd ("agent-eval", class_maintenance, maint_agent_eval_command, - _("\ + add_cmd ("agent-eval", class_maintenance, maint_agent_eval_command, _ ("\ Translate an expression into remote agent bytecode for evaluation.\n\ Usage: maint agent-eval [-at LOCATION,] EXPRESSION\n\ If -at is given, generate remote agent bytecode for this location.\n\ @@ -2644,7 +2566,7 @@ If not, generate remote agent bytecode for current frame pc address."), &maintenancelist); add_cmd ("agent-printf", class_maintenance, maint_agent_printf_command, - _("Translate an expression into remote " - "agent bytecode for evaluation and display the bytecodes."), + _ ("Translate an expression into remote " + "agent bytecode for evaluation and display the bytecodes."), &maintenancelist); } |