static int
memrange_cmp (const void *va, const void *vb)
{
- const struct memrange *a = va, *b = vb;
+ const struct memrange *a = (const struct memrange *) va;
+ const struct memrange *b = (const struct memrange *) vb;
if (a->type < b->type)
return -1;
if (memranges->next_memrange >= memranges->listsize)
{
memranges->listsize *= 2;
- memranges->list = xrealloc (memranges->list,
- memranges->listsize);
+ memranges->list = (struct memrange *) xrealloc (memranges->list,
+ memranges->listsize);
}
if (type != memrange_absolute) /* Better collect the base register! */
struct symbol *sym,
void *cb_data)
{
- struct add_local_symbols_data *p = cb_data;
+ struct add_local_symbols_data *p = (struct add_local_symbols_data *) cb_data;
collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
p->frame_offset, p->pc, p->trace_string);
static void
do_clear_collection_list (void *list)
{
- struct collection_list *l = list;
+ struct collection_list *l = (struct collection_list *) list;
clear_collection_list (l);
}
memset (clist, 0, sizeof *clist);
clist->listsize = 128;
- clist->list = xcalloc (clist->listsize,
- sizeof (struct memrange));
+ clist->list = XCNEWVEC (struct memrange, clist->listsize);
clist->aexpr_listsize = 128;
- clist->aexpr_list = xcalloc (clist->aexpr_listsize,
- sizeof (struct agent_expr *));
+ clist->aexpr_list = XCNEWVEC (struct agent_expr *, clist->aexpr_listsize);
}
/* Reduce a collection list to string form (for gdb protocol). */
{
if (collect->next_aexpr_elt >= collect->aexpr_listsize)
{
- collect->aexpr_list =
- xrealloc (collect->aexpr_list,
- 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
+ collect->aexpr_list = XRESIZEVEC (struct agent_expr *,
+ collect->aexpr_list,
+ 2 * collect->aexpr_listsize);
collect->aexpr_listsize *= 2;
}
collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
{
sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
sals.nelts = 1;
- sals.sals = (struct symtab_and_line *)
- xmalloc (sizeof (struct symtab_and_line));
+ sals.sals = XNEW (struct symtab_and_line);
sals.sals[0] = sal;
}
else
{
size_t len = next_comma - action_exp;
- cmd = xrealloc (cmd, len + 1);
+ cmd = (char *) xrealloc (cmd, len + 1);
memcpy (cmd, action_exp, len);
cmd[len] = 0;
}
{
size_t len = strlen (action_exp);
- cmd = xrealloc (cmd, len + 1);
+ cmd = (char *) xrealloc (cmd, len + 1);
memcpy (cmd, action_exp, len + 1);
}
make_cleanup (xfree, default_collect_line);
validate_actionline (default_collect_line, t);
- default_collect_action = xmalloc (sizeof (struct command_line));
+ default_collect_action = XNEW (struct command_line);
make_cleanup (xfree, default_collect_action);
default_collect_action->next = actions;
default_collect_action->line = default_collect_line;
static void
do_restore_current_traceframe_cleanup (void *arg)
{
- struct current_traceframe_cleanup *old = arg;
+ struct current_traceframe_cleanup *old
+ = (struct current_traceframe_cleanup *) arg;
set_current_traceframe (old->traceframe_number);
}
static void
restore_current_traceframe_cleanup_dtor (void *arg)
{
- struct current_traceframe_cleanup *old = arg;
+ struct current_traceframe_cleanup *old
+ = (struct current_traceframe_cleanup *) arg;
xfree (old);
}
struct cleanup *
make_cleanup_restore_current_traceframe (void)
{
- struct current_traceframe_cleanup *old;
+ struct current_traceframe_cleanup *old =
+ XNEW (struct current_traceframe_cleanup);
- old = xmalloc (sizeof (struct current_traceframe_cleanup));
old->traceframe_number = traceframe_number;
return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
for (utp = *utpp; utp; utp = utp->next)
if (utp->number == num && utp->addr == addr)
return utp;
- utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
- memset (utp, 0, sizeof (struct uploaded_tp));
+
+ utp = XCNEW (struct uploaded_tp);
utp->number = num;
utp->addr = addr;
utp->actions = NULL;
utp->cmd_strings = NULL;
utp->next = *utpp;
*utpp = utp;
+
return utp;
}
for (utsv = *utsvp; utsv; utsv = utsv->next)
if (utsv->number == num)
return utsv;
- utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
- memset (utsv, 0, sizeof (struct uploaded_tsv));
+
+ utsv = XCNEW (struct uploaded_tsv);
utsv->number = num;
utsv->next = *utsvp;
*utsvp = utsv;
+
return utsv;
}
}
else if (p2 != p1)
{
- ts->stop_desc = xmalloc (strlen (line));
+ ts->stop_desc = (char *) xmalloc (strlen (line));
end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
ts->stop_desc[end] = '\0';
}
p2 = strchr (++p1, ':');
if (p2 != p1)
{
- ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
+ ts->stop_desc = (char *) xmalloc ((p2 - p1) / 2 + 1);
end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
ts->stop_desc[end] = '\0';
}
else if (strncmp (p, "username", p1 - p) == 0)
{
++p1;
- ts->user_name = xmalloc (strlen (p) / 2);
+ ts->user_name = (char *) xmalloc (strlen (p) / 2);
end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
ts->user_name[end] = '\0';
p = p3;
else if (strncmp (p, "notes", p1 - p) == 0)
{
++p1;
- ts->notes = xmalloc (strlen (p) / 2);
+ ts->notes = (char *) xmalloc (strlen (p) / 2);
end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
ts->notes[end] = '\0';
p = p3;
p = unpack_varlen_hex (p, &xlen);
p++; /* skip a colon */
- buf = alloca (strlen (line));
+ buf = (char *) alloca (strlen (line));
end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
buf[end] = '\0';
int end;
struct uploaded_tsv *utsv = NULL;
- buf = alloca (strlen (line));
+ buf = (char *) alloca (strlen (line));
p = line;
p = unpack_varlen_hex (p, &num);
void
free_current_marker (void *arg)
{
- struct static_tracepoint_marker **marker_p = arg;
+ struct static_tracepoint_marker **marker_p
+ = (struct static_tracepoint_marker **) arg;
if (*marker_p != NULL)
{
if (endp == NULL)
error (_("bad marker definition: %s"), line);
- marker->str_id = xmalloc (endp - p + 1);
+ marker->str_id = (char *) xmalloc (endp - p + 1);
end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
marker->str_id[end] = '\0';
p += 2 * end;
p++; /* skip a colon */
- marker->extra = xmalloc (strlen (p) + 1);
+ marker->extra = (char *) xmalloc (strlen (p) + 1);
end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
marker->extra[end] = '\0';
const struct gdb_xml_element *element,
void *user_data, VEC(gdb_xml_value_s) *attributes)
{
- struct traceframe_info *info = user_data;
+ struct traceframe_info *info = (struct traceframe_info *) user_data;
struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
ULONGEST *start_p, *length_p;
- start_p = xml_find_attribute (attributes, "start")->value;
- length_p = xml_find_attribute (attributes, "length")->value;
+ start_p
+ = (ULONGEST *) xml_find_attribute (attributes, "start")->value;
+ length_p
+ = (ULONGEST *) xml_find_attribute (attributes, "length")->value;
r->start = *start_p;
r->length = *length_p;
void *user_data,
VEC(gdb_xml_value_s) *attributes)
{
- struct traceframe_info *info = user_data;
- const char *id_attrib = xml_find_attribute (attributes, "id")->value;
+ struct traceframe_info *info = (struct traceframe_info *) user_data;
+ const char *id_attrib
+ = (const char *) xml_find_attribute (attributes, "id")->value;
int id = gdb_xml_parse_ulongest (parser, id_attrib);
VEC_safe_push (int, info->tvars, id);
static void
free_result (void *p)
{
- struct traceframe_info *result = p;
+ struct traceframe_info *result = (struct traceframe_info *) p;
free_traceframe_info (result);
}