/* The agent expression evaluator, as specified by the GDB docs. Evaluate
agent expression AEXPR for thread TINFO. RAW_REGS points to block of
registers. TFRAME is a traceframe to get any trace data. Evaluation
result value is put in RSLT. It returns 0 if everything went OK, and
a nonzero error code otherwise. */
enum eval_result_type
agent_expr_eval (agent_thread_info_t *tinfo,
unsigned char *raw_regs,
traceframe_t *tframe,
agent_expr_t *aexpr,
uint64_t *rslt)
{
int pc = 0;
#define STACK_MAX 100
uint64_t stack[STACK_MAX] = {(uint64_t) 0};
uint64_t top;
int sp = 0;
unsigned char op;
int arg, err;
/* This union is a convenient way to convert representations. */
union
{
union
{
unsigned char bytes[1];
uint8_t val;
} u8;
union
{
unsigned char bytes[2];
uint16_t val;
} u16;
union
{
unsigned char bytes[4];
uint32_t val;
} u32;
union
{
unsigned char bytes[8];
uint64_t val;
} u64;
} cnv;
if (aexpr->length == 0)
{
gdb_verbose ("empty agent expression");
return expr_eval_empty_expression;
}
/* Cache the stack top in its own variable. Much of the time we can
operate on this variable, rather than dinking with the stack. It
needs to be copied to the stack when sp changes. */
top = stack[sp];
while (1)
{
op = aexpr->bytes[pc++];
gdb_verbose ("About to interpret byte 0x%x", op);
switch (op)
{
case gdb_agent_op_add:
top += stack[--sp];
break;
case gdb_agent_op_sub:
top = stack[--sp] - top;
break;
case gdb_agent_op_mul:
top *= stack[--sp];
break;
case gdb_agent_op_div_signed:
if (top == 0)
{
gdb_verbose ("Attempted to divide by zero");
return expr_eval_divide_by_zero;
}
top = ((int64_t) stack[--sp]) / ((int64_t) top);
break;
case gdb_agent_op_div_unsigned:
if (top == 0)
{
gdb_verbose ("Attempted to divide by zero");
return expr_eval_divide_by_zero;
}
top = stack[--sp] / top;
break;
case gdb_agent_op_rem_signed:
if (top == 0)
{
gdb_verbose ("Attempted to divide by zero");
return expr_eval_divide_by_zero;
}
top = ((int64_t) stack[--sp]) % ((int64_t) top);
break;
case gdb_agent_op_rem_unsigned:
if (top == 0)
{
gdb_verbose ("Attempted to divide by zero");
return expr_eval_divide_by_zero;
}
top = stack[--sp] % top;
break;
case gdb_agent_op_lsh:
top = stack[--sp] << top;
break;
case gdb_agent_op_rsh_signed:
top = ((int64_t) stack[--sp]) >> top;
break;
case gdb_agent_op_rsh_unsigned:
top = stack[--sp] >> top;
break;
case gdb_agent_op_trace:
err = agent_mem_read (tframe,
(gdb_addr_t) stack[--sp], (gdb_size_t) top);
if (err)
{
gdb_verbose ("Memory read error %d", err);
return expr_eval_mem_read_error;
}
if (--sp >= 0)
top = stack[sp];
break;
case gdb_agent_op_trace_quick:
arg = aexpr->bytes[pc++];
err = agent_mem_read (tframe,
(gdb_addr_t) top, (gdb_size_t) arg);
if (err)
{
gdb_verbose ("Memory read error %d", err);
return expr_eval_mem_read_error;
}
break;
case gdb_agent_op_tracenz:
err = agent_mem_read_string (tframe,
(gdb_addr_t) stack[--sp],
(gdb_size_t) top);
if (err)
{
gdb_verbose ("Memory read error %d", err);
return expr_eval_mem_read_error;
}
if (--sp >= 0)
top = stack[sp];
break;
case gdb_agent_op_log_not:
top = !top;
break;
case gdb_agent_op_bit_and:
top &= stack[--sp];
break;
case gdb_agent_op_bit_or:
top |= stack[--sp];
break;
case gdb_agent_op_bit_xor:
top ^= stack[--sp];
break;
case gdb_agent_op_bit_not:
top = ~top;
break;
case gdb_agent_op_equal:
top = (stack[--sp] == top);
break;
case gdb_agent_op_less_signed:
top = (((int64_t) stack[--sp]) < ((int64_t) top));
break;
case gdb_agent_op_less_unsigned:
top = (stack[--sp] < top);
break;
case gdb_agent_op_ext:
arg = aexpr->bytes[pc++];
if (arg < (int) (sizeof (int64_t) * 8))
{
int64_t mask = 1 << (arg - 1);
top &= ((int64_t) 1 << arg) - 1;
top = (top ^ mask) - mask;
}
break;
case gdb_agent_op_ref8:
err = agent_mem_read_to (cnv.u8.bytes, (gdb_addr_t) top, 1);
if (err)
{
gdb_verbose ("Memory read error %d", err);
return expr_eval_mem_read_error;
}
top = cnv.u8.val;
break;
case gdb_agent_op_ref16:
err = agent_mem_read_to (cnv.u16.bytes, (gdb_addr_t) top, 2);
if (err)
{
gdb_verbose ("Memory read error %d", err);
return expr_eval_mem_read_error;
}
asm volatile ("# marker3");
top = cnv.u16.val;
break;
case gdb_agent_op_ref32:
err = agent_mem_read_to (cnv.u32.bytes, (gdb_addr_t) top, 4);
if (err)
{
gdb_verbose ("Memory read error %d", err);
return expr_eval_mem_read_error;
}
top = cnv.u32.val;
break;
case gdb_agent_op_ref64:
err = agent_mem_read_to (cnv.u64.bytes, (gdb_addr_t) top, 8);
if (err)
{
gdb_verbose ("Memory read error %d", err);
return expr_eval_mem_read_error;
}
top = cnv.u64.val;
break;
case gdb_agent_op_if_goto:
if (top)
pc = (aexpr->bytes[pc] << 8) + (aexpr->bytes[pc + 1]);
else
pc += 2;
if (--sp >= 0)
top = stack[sp];
break;
case gdb_agent_op_goto:
pc = (aexpr->bytes[pc] << 8) + (aexpr->bytes[pc + 1]);
break;
case gdb_agent_op_const8:
/* Flush the cached stack top. */
stack[sp++] = top;
top = aexpr->bytes[pc++];
break;
case gdb_agent_op_const16:
/* Flush the cached stack top. */
stack[sp++] = top;
top = aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
break;
case gdb_agent_op_const32:
/* Flush the cached stack top. */
stack[sp++] = top;
top = aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
break;
case gdb_agent_op_const64:
/* Flush the cached stack top. */
stack[sp++] = top;
top = aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
break;
case gdb_agent_op_reg:
/* Flush the cached stack top. */
stack[sp++] = top;
arg = aexpr->bytes[pc++];
arg = (arg << 8) + aexpr->bytes[pc++];
if (tinfo)
top = agent_backend->reg.get_reg (tinfo, arg);
else if (raw_regs)
top = agent_backend->reg.get_raw_reg (raw_regs, arg);
else
{
gdb_verbose ("No registers available");
return expr_eval_no_registers;
}
break;
case gdb_agent_op_end:
gdb_verbose ("At end of expression, sp=%d, stack top cache=0x%"
PRIx64, sp, top);
if (rslt)
{
if (sp <= 0)
{
/* This should be an error */
gdb_verbose ("Stack is empty, nothing to return");
return expr_eval_empty_stack;
}
*rslt = top;
}
return expr_eval_no_error;
case gdb_agent_op_dup:
stack[sp++] = top;
break;
case gdb_agent_op_pop:
if (--sp >= 0)
top = stack[sp];
break;
case gdb_agent_op_zero_ext:
arg = aexpr->bytes[pc++];
if (arg < (int) (sizeof (int64_t) * 8))
top &= ((int64_t) 1 << arg) - 1;
break;
case gdb_agent_op_swap:
/* Interchange top two stack elements, making sure top gets
copied back onto stack. */
/* FIXME error if sp==0 */
stack[sp] = top;
top = stack[sp - 1];
stack[sp - 1] = stack[sp];
break;
case gdb_agent_op_getv:
stack[sp++] = top;
arg = aexpr->bytes[pc++];
arg = (arg << 8) + aexpr->bytes[pc++];
top = trace_state_variable_get_value (tinfo, arg);
break;
case gdb_agent_op_setv:
arg = aexpr->bytes[pc++];
arg = (arg << 8) + aexpr->bytes[pc++];
trace_state_variable_set_value (arg, top);
break;
case gdb_agent_op_tracev:
arg = aexpr->bytes[pc++];
arg = (arg << 8) + aexpr->bytes[pc++];
agent_tsv_read (tframe, arg);
break;
/* GDB never (currently) generates any of these ops. */
case gdb_agent_op_float:
case gdb_agent_op_ref_float:
case gdb_agent_op_ref_double:
case gdb_agent_op_ref_long_double:
case gdb_agent_op_l_to_d:
case gdb_agent_op_d_to_l:
case gdb_agent_op_trace16:
gdb_verbose ("Agent expression op 0x%x valid, but not handled", op);
/* If ever GDB generates any of these, we don't have the
option of ignoring. */
return expr_eval_unhandled_opcode;
default:
gdb_verbose ("Agent expression op 0x%x not recognized", op);
/* Don't struggle on, things will just get worse. */
return expr_eval_unrecognized_opcode;
}
/* Check for stack badness. */
if (sp >= (STACK_MAX - 1))
{
gdb_verbose ("Expression stack overflow");
return expr_eval_stack_overflow;
}
if (sp < 0)
{
gdb_verbose ("Expression stack underflow");
return expr_eval_stack_underflow;
}
gdb_verbose ("Op %s -> sp=%d, top=0x%" PRIx64,
gdb_agent_op_names[op], sp, top);
}
}
enum eval_result_type
gdb_eval_agent_expr (struct eval_agent_expr_context *ctx,
struct agent_expr *aexpr,
ULONGEST *rslt)
{
int pc = 0;
#define STACK_MAX 100
ULONGEST stack[STACK_MAX], top;
int sp = 0;
unsigned char op;
int arg;
/* This union is a convenient way to convert representations. For
now, assume a standard architecture where the hardware integer
types have 8, 16, 32, 64 bit types. A more robust solution would
be to import stdint.h from gnulib. */
union
{
union
{
unsigned char bytes[1];
unsigned char val;
} u8;
union
{
unsigned char bytes[2];
unsigned short val;
} u16;
union
{
unsigned char bytes[4];
unsigned int val;
} u32;
union
{
unsigned char bytes[8];
ULONGEST val;
} u64;
} cnv;
if (aexpr->length == 0)
{
ax_debug ("empty agent expression");
return expr_eval_empty_expression;
}
/* Cache the stack top in its own variable. Much of the time we can
operate on this variable, rather than dinking with the stack. It
needs to be copied to the stack when sp changes. */
top = 0;
while (1)
{
op = aexpr->bytes[pc++];
ax_debug ("About to interpret byte 0x%x", op);
switch (op)
{
case gdb_agent_op_add:
top += stack[--sp];
break;
case gdb_agent_op_sub:
top = stack[--sp] - top;
break;
case gdb_agent_op_mul:
top *= stack[--sp];
break;
case gdb_agent_op_div_signed:
if (top == 0)
{
ax_debug ("Attempted to divide by zero");
return expr_eval_divide_by_zero;
}
top = ((LONGEST) stack[--sp]) / ((LONGEST) top);
break;
case gdb_agent_op_div_unsigned:
if (top == 0)
{
ax_debug ("Attempted to divide by zero");
return expr_eval_divide_by_zero;
}
top = stack[--sp] / top;
break;
case gdb_agent_op_rem_signed:
if (top == 0)
{
ax_debug ("Attempted to divide by zero");
return expr_eval_divide_by_zero;
}
top = ((LONGEST) stack[--sp]) % ((LONGEST) top);
break;
case gdb_agent_op_rem_unsigned:
if (top == 0)
{
ax_debug ("Attempted to divide by zero");
return expr_eval_divide_by_zero;
}
top = stack[--sp] % top;
break;
case gdb_agent_op_lsh:
top = stack[--sp] << top;
break;
case gdb_agent_op_rsh_signed:
top = ((LONGEST) stack[--sp]) >> top;
break;
case gdb_agent_op_rsh_unsigned:
top = stack[--sp] >> top;
break;
case gdb_agent_op_trace:
agent_mem_read (ctx, NULL, (CORE_ADDR) stack[--sp],
(ULONGEST) top);
if (--sp >= 0)
top = stack[sp];
break;
case gdb_agent_op_trace_quick:
arg = aexpr->bytes[pc++];
agent_mem_read (ctx, NULL, (CORE_ADDR) top, (ULONGEST) arg);
break;
case gdb_agent_op_log_not:
top = !top;
break;
case gdb_agent_op_bit_and:
top &= stack[--sp];
break;
case gdb_agent_op_bit_or:
top |= stack[--sp];
break;
case gdb_agent_op_bit_xor:
top ^= stack[--sp];
break;
case gdb_agent_op_bit_not:
top = ~top;
break;
case gdb_agent_op_equal:
top = (stack[--sp] == top);
break;
case gdb_agent_op_less_signed:
top = (((LONGEST) stack[--sp]) < ((LONGEST) top));
break;
case gdb_agent_op_less_unsigned:
top = (stack[--sp] < top);
break;
case gdb_agent_op_ext:
arg = aexpr->bytes[pc++];
if (arg < (sizeof (LONGEST) * 8))
{
LONGEST mask = 1 << (arg - 1);
top &= ((LONGEST) 1 << arg) - 1;
top = (top ^ mask) - mask;
}
break;
case gdb_agent_op_ref8:
agent_mem_read (ctx, cnv.u8.bytes, (CORE_ADDR) top, 1);
top = cnv.u8.val;
break;
case gdb_agent_op_ref16:
agent_mem_read (ctx, cnv.u16.bytes, (CORE_ADDR) top, 2);
top = cnv.u16.val;
break;
case gdb_agent_op_ref32:
agent_mem_read (ctx, cnv.u32.bytes, (CORE_ADDR) top, 4);
top = cnv.u32.val;
break;
case gdb_agent_op_ref64:
agent_mem_read (ctx, cnv.u64.bytes, (CORE_ADDR) top, 8);
top = cnv.u64.val;
break;
case gdb_agent_op_if_goto:
if (top)
pc = (aexpr->bytes[pc] << 8) + (aexpr->bytes[pc + 1]);
else
pc += 2;
if (--sp >= 0)
top = stack[sp];
break;
case gdb_agent_op_goto:
pc = (aexpr->bytes[pc] << 8) + (aexpr->bytes[pc + 1]);
break;
case gdb_agent_op_const8:
/* Flush the cached stack top. */
stack[sp++] = top;
top = aexpr->bytes[pc++];
break;
case gdb_agent_op_const16:
/* Flush the cached stack top. */
stack[sp++] = top;
top = aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
break;
case gdb_agent_op_const32:
/* Flush the cached stack top. */
stack[sp++] = top;
top = aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
break;
case gdb_agent_op_const64:
/* Flush the cached stack top. */
stack[sp++] = top;
top = aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
top = (top << 8) + aexpr->bytes[pc++];
break;
case gdb_agent_op_reg:
/* Flush the cached stack top. */
stack[sp++] = top;
arg = aexpr->bytes[pc++];
arg = (arg << 8) + aexpr->bytes[pc++];
{
int regnum = arg;
struct regcache *regcache = ctx->regcache;
switch (register_size (regcache->tdesc, regnum))
{
case 8:
collect_register (regcache, regnum, cnv.u64.bytes);
top = cnv.u64.val;
break;
case 4:
collect_register (regcache, regnum, cnv.u32.bytes);
top = cnv.u32.val;
break;
case 2:
collect_register (regcache, regnum, cnv.u16.bytes);
top = cnv.u16.val;
break;
case 1:
collect_register (regcache, regnum, cnv.u8.bytes);
top = cnv.u8.val;
break;
default:
internal_error (__FILE__, __LINE__,
"unhandled register size");
}
}
break;
case gdb_agent_op_end:
ax_debug ("At end of expression, sp=%d, stack top cache=0x%s",
sp, pulongest (top));
if (rslt)
{
if (sp <= 0)
{
/* This should be an error */
ax_debug ("Stack is empty, nothing to return");
return expr_eval_empty_stack;
}
*rslt = top;
}
return expr_eval_no_error;
case gdb_agent_op_dup:
stack[sp++] = top;
break;
case gdb_agent_op_pop:
if (--sp >= 0)
top = stack[sp];
break;
case gdb_agent_op_pick:
arg = aexpr->bytes[pc++];
stack[sp] = top;
top = stack[sp - arg];
++sp;
break;
case gdb_agent_op_rot:
{
ULONGEST tem = stack[sp - 1];
stack[sp - 1] = stack[sp - 2];
stack[sp - 2] = top;
top = tem;
}
break;
case gdb_agent_op_zero_ext:
arg = aexpr->bytes[pc++];
if (arg < (sizeof (LONGEST) * 8))
top &= ((LONGEST) 1 << arg) - 1;
break;
case gdb_agent_op_swap:
/* Interchange top two stack elements, making sure top gets
copied back onto stack. */
stack[sp] = top;
top = stack[sp - 1];
stack[sp - 1] = stack[sp];
break;
case gdb_agent_op_getv:
/* Flush the cached stack top. */
stack[sp++] = top;
arg = aexpr->bytes[pc++];
arg = (arg << 8) + aexpr->bytes[pc++];
top = agent_get_trace_state_variable_value (arg);
break;
case gdb_agent_op_setv:
arg = aexpr->bytes[pc++];
arg = (arg << 8) + aexpr->bytes[pc++];
agent_set_trace_state_variable_value (arg, top);
/* Note that we leave the value on the stack, for the
benefit of later/enclosing expressions. */
break;
case gdb_agent_op_tracev:
arg = aexpr->bytes[pc++];
arg = (arg << 8) + aexpr->bytes[pc++];
agent_tsv_read (ctx, arg);
break;
case gdb_agent_op_tracenz:
agent_mem_read_string (ctx, NULL, (CORE_ADDR) stack[--sp],
(ULONGEST) top);
if (--sp >= 0)
top = stack[sp];
break;
case gdb_agent_op_printf:
{
int nargs, slen, i;
CORE_ADDR fn = 0, chan = 0;
/* Can't have more args than the entire size of the stack. */
ULONGEST args[STACK_MAX];
char *format;
nargs = aexpr->bytes[pc++];
slen = aexpr->bytes[pc++];
slen = (slen << 8) + aexpr->bytes[pc++];
format = (char *) &(aexpr->bytes[pc]);
pc += slen;
/* Pop function and channel. */
fn = top;
if (--sp >= 0)
top = stack[sp];
chan = top;
if (--sp >= 0)
top = stack[sp];
/* Pop arguments into a dedicated array. */
for (i = 0; i < nargs; ++i)
{
args[i] = top;
if (--sp >= 0)
top = stack[sp];
}
/* A bad format string means something is very wrong; give
up immediately. */
if (format[slen - 1] != '\0')
error (_("Unterminated format string in printf bytecode"));
ax_printf (fn, chan, format, nargs, args);
}
break;
/* GDB never (currently) generates any of these ops. */
case gdb_agent_op_float:
case gdb_agent_op_ref_float:
case gdb_agent_op_ref_double:
case gdb_agent_op_ref_long_double:
case gdb_agent_op_l_to_d:
case gdb_agent_op_d_to_l:
case gdb_agent_op_trace16:
ax_debug ("Agent expression op 0x%x valid, but not handled",
op);
/* If ever GDB generates any of these, we don't have the
option of ignoring. */
return expr_eval_unhandled_opcode;
default:
ax_debug ("Agent expression op 0x%x not recognized", op);
/* Don't struggle on, things will just get worse. */
return expr_eval_unrecognized_opcode;
}
/* Check for stack badness. */
if (sp >= (STACK_MAX - 1))
{
ax_debug ("Expression stack overflow");
return expr_eval_stack_overflow;
}
if (sp < 0)
{
ax_debug ("Expression stack underflow");
return expr_eval_stack_underflow;
}
ax_debug ("Op %s -> sp=%d, top=0x%s",
gdb_agent_op_name (op), sp, phex_nz (top, 0));
}
}
static void
tracepoint_do_action (agent_thread_info_t *tinfo,
tracepoint_t *tpoint,
traceframe_t *tframe,
tracepoint_action_t *taction)
{
int merr;
enum eval_result_type err;
gdb_verbose ("Tracepoint %d at 0x%" PRIx64 " about to do action",
tpoint->number, tpoint->addr);
switch (taction->type)
{
case 'M':
{
struct collect_memory_action *maction;
maction = (struct collect_memory_action *) taction;
gdb_verbose ("Want to collect %" PRIu64 " bytes at 0x%"
PRIx64" (basereg %d)",
maction->len, maction->addr, maction->basereg);
/* (should use basereg) */
merr = agent_mem_read (tframe,
(gdb_addr_t) maction->addr, maction->len);
if (merr)
{
gdb_verbose ("Memory read error %d while collecting", merr);
/* We don't get back useful info indicating exactly what
happened, so just record it as a generic memory read
failure. */
tracepoint_record_error (tpoint, "action expression",
expr_eval_mem_read_error);
return;
}
break;
}
case 'R':
{
unsigned char *regspace;
gdb_verbose ("Want to collect registers");
/* Collect all registers for now. */
regspace = traceframe_add_block (tframe,
1 + agent_backend->global_gbufsize);
if (regspace == NULL)
{
gdb_verbose ("Trace buffer reg block alloc of %d failed, assuming full",
1 + agent_backend->global_gbufsize);
GDB_AGENT_SYM(trace_buffer_is_full) = 1;
break;
}
/* Identify a register block. */
*regspace = 'R';
memcpy ((void *) (regspace + 1), (void *) tinfo->regblock,
agent_backend->global_gbufsize);
}
break;
case 'X':
{
struct eval_expr_action *eaction;
eaction = (struct eval_expr_action *) taction;
if (eaction->expr == NULL)
return;
gdb_verbose ("Want to evaluate expression");
err = agent_expr_eval (tinfo, NULL, tframe, eaction->expr, NULL);
if (err != expr_eval_no_error)
{
tracepoint_record_error (tpoint, "action expression", err);
return;
}
}
break;
case 'L':
{
#if defined BUILD_UST
gdb_inform ("Not implemented yet to collect ust data");
#else
gdb_verbose ("Warning: static tracepoints are not supported");
#endif
break;
}
default:
gdb_verbose ("unknown trace action '%c', ignoring", taction->type);
break;
}
}