static void
tfile_write_status (struct trace_file_writer *self,
struct trace_status *ts)
{
struct tfile_trace_file_writer *writer
= (struct tfile_trace_file_writer *) self;
fprintf (writer->fp, "status %c;%s",
(ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
if (ts->stop_reason == tracepoint_error
|| ts->stop_reason == tstop_command)
{
char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);
bin2hex ((gdb_byte *) ts->stop_desc, buf, strlen (ts->stop_desc));
fprintf (writer->fp, ":%s", buf);
}
fprintf (writer->fp, ":%x", ts->stopping_tracepoint);
if (ts->traceframe_count >= 0)
fprintf (writer->fp, ";tframes:%x", ts->traceframe_count);
if (ts->traceframes_created >= 0)
fprintf (writer->fp, ";tcreated:%x", ts->traceframes_created);
if (ts->buffer_free >= 0)
fprintf (writer->fp, ";tfree:%x", ts->buffer_free);
if (ts->buffer_size >= 0)
fprintf (writer->fp, ";tsize:%x", ts->buffer_size);
if (ts->disconnected_tracing)
fprintf (writer->fp, ";disconn:%x", ts->disconnected_tracing);
if (ts->circular_buffer)
fprintf (writer->fp, ";circular:%x", ts->circular_buffer);
if (ts->start_time)
{
fprintf (writer->fp, ";starttime:%s",
phex_nz (ts->start_time, sizeof (ts->start_time)));
}
if (ts->stop_time)
{
fprintf (writer->fp, ";stoptime:%s",
phex_nz (ts->stop_time, sizeof (ts->stop_time)));
}
if (ts->notes != NULL)
{
char *buf = (char *) alloca (strlen (ts->notes) * 2 + 1);
bin2hex ((gdb_byte *) ts->notes, buf, strlen (ts->notes));
fprintf (writer->fp, ";notes:%s", buf);
}
if (ts->user_name != NULL)
{
char *buf = (char *) alloca (strlen (ts->user_name) * 2 + 1);
bin2hex ((gdb_byte *) ts->user_name, buf, strlen (ts->user_name));
fprintf (writer->fp, ";username:%s", buf);
}
fprintf (writer->fp, "\n");
}
static void
tfile_write_uploaded_tp (struct trace_file_writer *self,
struct uploaded_tp *utp)
{
struct tfile_trace_file_writer *writer
= (struct tfile_trace_file_writer *) self;
int a;
char *act;
char buf[MAX_TRACE_UPLOAD];
fprintf (writer->fp, "tp T%x:%s:%c:%x:%x",
utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
(utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
if (utp->type == bp_fast_tracepoint)
fprintf (writer->fp, ":F%x", utp->orig_size);
if (utp->cond)
fprintf (writer->fp,
":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
utp->cond);
fprintf (writer->fp, "\n");
for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
fprintf (writer->fp, "tp A%x:%s:%s\n",
utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
fprintf (writer->fp, "tp S%x:%s:%s\n",
utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
if (utp->at_string)
{
encode_source_string (utp->number, utp->addr,
"at", utp->at_string, buf, MAX_TRACE_UPLOAD);
fprintf (writer->fp, "tp Z%s\n", buf);
}
if (utp->cond_string)
{
encode_source_string (utp->number, utp->addr,
"cond", utp->cond_string,
buf, MAX_TRACE_UPLOAD);
fprintf (writer->fp, "tp Z%s\n", buf);
}
for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
{
encode_source_string (utp->number, utp->addr, "cmd", act,
buf, MAX_TRACE_UPLOAD);
fprintf (writer->fp, "tp Z%s\n", buf);
}
fprintf (writer->fp, "tp V%x:%s:%x:%s\n",
utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
utp->hit_count,
phex_nz (utp->traceframe_usage,
sizeof (utp->traceframe_usage)));
}
char *
pfildes (gdb_fildes_t fd)
{
#if USE_WIN32API
return phex_nz (fd, sizeof (gdb_fildes_t));
#else
return plongest (fd);
#endif
}
/* Return true if there are no commands to run at this location,
which likely means we want to report back to GDB. */
int
gdb_no_commands_at_breakpoint (CORE_ADDR where)
{
struct breakpoint *bp = find_gdb_breakpoint_at (where);
if (bp == NULL)
return 0;
if (debug_threads)
fprintf (stderr, "at 0x%s, bp command_list is 0x%s\n",
paddress (where),
phex_nz ((uintptr_t) bp->command_list, 0));
return (bp->command_list == NULL);
}
/* Report a memory error with error(): */
void ATTR_NORETURN
memory_error (int status, CORE_ADDR memaddr)
{
struct ui_file *tmp_stream = mem_fileopen();
make_cleanup_ui_file_delete(tmp_stream);
if (status == EIO)
{
/* Actually, address between memaddr and memaddr + len
was out of bounds. */
fprintf_unfiltered (tmp_stream, "Cannot access memory at address 0x%s",
phex_nz (memaddr, sizeof (CORE_ADDR)));
}
else
{
fprintf_filtered (tmp_stream, "Error accessing memory address 0x%s",
phex_nz (memaddr, sizeof (CORE_ADDR)));
fprintf_filtered (tmp_stream, ": %s.",
safe_strerror (status));
}
error_stream (tmp_stream);
}
static int
gdb_no_commands_at_breakpoint_z_type (char z_type, CORE_ADDR addr)
{
struct breakpoint *bp = find_gdb_breakpoint (z_type, addr, -1);
if (bp == NULL)
return 1;
if (debug_threads)
debug_printf ("at 0x%s, type Z%c, bp command_list is 0x%s\n",
paddress (addr), z_type,
phex_nz ((uintptr_t) bp->command_list, 0));
return (bp->command_list == NULL);
}
static void
tfile_write_uploaded_tsv (struct trace_file_writer *self,
struct uploaded_tsv *utsv)
{
char *buf = "";
struct tfile_trace_file_writer *writer
= (struct tfile_trace_file_writer *) self;
if (utsv->name)
{
buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
bin2hex ((gdb_byte *) (utsv->name), buf, strlen (utsv->name));
}
fprintf (writer->fp, "tsv %x:%s:%x:%s\n",
utsv->number, phex_nz (utsv->initial_value, 8),
utsv->builtin, buf);
if (utsv->name)
xfree (buf);
}
static void
handle_exception (struct target_waitstatus *ourstatus)
{
DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
ourstatus->kind = TARGET_WAITKIND_STOPPED;
switch (code)
{
case EXCEPTION_ACCESS_VIOLATION:
OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION"));
ourstatus->value.sig = TARGET_SIGNAL_SEGV;
break;
case STATUS_STACK_OVERFLOW:
OUTMSG2 (("STATUS_STACK_OVERFLOW"));
ourstatus->value.sig = TARGET_SIGNAL_SEGV;
break;
case STATUS_FLOAT_DENORMAL_OPERAND:
OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND"));
ourstatus->value.sig = TARGET_SIGNAL_FPE;
break;
case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));
ourstatus->value.sig = TARGET_SIGNAL_FPE;
break;
case STATUS_FLOAT_INEXACT_RESULT:
OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT"));
ourstatus->value.sig = TARGET_SIGNAL_FPE;
break;
case STATUS_FLOAT_INVALID_OPERATION:
OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION"));
ourstatus->value.sig = TARGET_SIGNAL_FPE;
break;
case STATUS_FLOAT_OVERFLOW:
OUTMSG2 (("STATUS_FLOAT_OVERFLOW"));
ourstatus->value.sig = TARGET_SIGNAL_FPE;
break;
case STATUS_FLOAT_STACK_CHECK:
OUTMSG2 (("STATUS_FLOAT_STACK_CHECK"));
ourstatus->value.sig = TARGET_SIGNAL_FPE;
break;
case STATUS_FLOAT_UNDERFLOW:
OUTMSG2 (("STATUS_FLOAT_UNDERFLOW"));
ourstatus->value.sig = TARGET_SIGNAL_FPE;
break;
case STATUS_FLOAT_DIVIDE_BY_ZERO:
OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO"));
ourstatus->value.sig = TARGET_SIGNAL_FPE;
break;
case STATUS_INTEGER_DIVIDE_BY_ZERO:
OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO"));
ourstatus->value.sig = TARGET_SIGNAL_FPE;
break;
case STATUS_INTEGER_OVERFLOW:
OUTMSG2 (("STATUS_INTEGER_OVERFLOW"));
ourstatus->value.sig = TARGET_SIGNAL_FPE;
break;
case EXCEPTION_BREAKPOINT:
OUTMSG2 (("EXCEPTION_BREAKPOINT"));
ourstatus->value.sig = TARGET_SIGNAL_TRAP;
#ifdef _WIN32_WCE
/* Remove the initial breakpoint. */
check_breakpoints ((CORE_ADDR) (long) current_event
.u.Exception.ExceptionRecord.ExceptionAddress);
#endif
break;
case DBG_CONTROL_C:
OUTMSG2 (("DBG_CONTROL_C"));
ourstatus->value.sig = TARGET_SIGNAL_INT;
break;
case DBG_CONTROL_BREAK:
OUTMSG2 (("DBG_CONTROL_BREAK"));
ourstatus->value.sig = TARGET_SIGNAL_INT;
break;
case EXCEPTION_SINGLE_STEP:
OUTMSG2 (("EXCEPTION_SINGLE_STEP"));
ourstatus->value.sig = TARGET_SIGNAL_TRAP;
break;
case EXCEPTION_ILLEGAL_INSTRUCTION:
OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION"));
ourstatus->value.sig = TARGET_SIGNAL_ILL;
break;
case EXCEPTION_PRIV_INSTRUCTION:
OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION"));
ourstatus->value.sig = TARGET_SIGNAL_ILL;
break;
case EXCEPTION_NONCONTINUABLE_EXCEPTION:
OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION"));
ourstatus->value.sig = TARGET_SIGNAL_ILL;
break;
default:
if (current_event.u.Exception.dwFirstChance)
{
ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
return;
}
OUTMSG2 (("gdbserver: unknown target exception 0x%08lx at 0x%s",
current_event.u.Exception.ExceptionRecord.ExceptionCode,
phex_nz ((uintptr_t) current_event.u.Exception.ExceptionRecord.
ExceptionAddress, sizeof (uintptr_t))));
ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
break;
}
OUTMSG2 (("\n"));
last_sig = ourstatus->value.sig;
}
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));
}
}
char *
local_hex_string_custom (LONGEST num, char *width)
{
#define RESULT_BUF_LEN 50
static char res2[RESULT_BUF_LEN];
char format[RESULT_BUF_LEN];
int field_width;
int num_len;
int num_pad_chars;
char *pad_char; /* string with one character */
int pad_on_left;
char *parse_ptr;
char temp_nbr_buf[RESULT_BUF_LEN];
/* Use phex_nz to print the number into a string, then
build the result string from local_hex_format_prefix, padding and
the hex representation as indicated by "width". */
strcpy (temp_nbr_buf, phex_nz (num, sizeof (num)));
/* parse width */
parse_ptr = width;
pad_on_left = 1;
pad_char = " ";
if (*parse_ptr == '-')
{
parse_ptr++;
pad_on_left = 0;
}
if (*parse_ptr == '0')
{
parse_ptr++;
if (pad_on_left)
pad_char = "0"; /* If padding is on the right, it is blank */
}
field_width = atoi (parse_ptr);
num_len = strlen (temp_nbr_buf);
num_pad_chars = field_width - strlen (temp_nbr_buf); /* possibly negative */
if (strlen (local_hex_format_prefix ()) + num_len + num_pad_chars
>= RESULT_BUF_LEN) /* paranoia */
internal_error (__FILE__, __LINE__,
"local_hex_string_custom: insufficient space to store result");
strcpy (res2, local_hex_format_prefix ());
if (pad_on_left)
{
while (num_pad_chars > 0)
{
strcat (res2, pad_char);
num_pad_chars--;
}
}
strcat (res2, temp_nbr_buf);
if (!pad_on_left)
{
while (num_pad_chars > 0)
{
strcat (res2, pad_char);
num_pad_chars--;
}
}
return res2;
} /* local_hex_string_custom */
char *
paddress (CORE_ADDR addr)
{
return phex_nz (addr, sizeof (CORE_ADDR));
}