/**
* Allocate an object with n elements of a flexible array member
*/
-#define XMALLOCF(type, member, n) ((type*)xmalloc(offsetof(type, member) + sizeof(((type*)0)->member) * (n)))
+#define XMALLOCF(type, member, n) ((type*)xmalloc(offsetof(type, member) + sizeof(*((type*)0)->member) * (n)))
/**
* Allocate an object with n elements of a flexible array member and zero the
* whole object
*/
-#define XMALLOCFZ(type, member, n) ((type*)memset(xmalloc(offsetof(type, member) + sizeof(((type*)0)->member) * (n)), 0, offsetof(type, member) + sizeof(((type*)0)->member) * (n)))
+#define XMALLOCFZ(type, member, n) ((type*)memset(XMALLOCF(type, member, (n)), 0, offsetof(type, member) + sizeof(*((type*)0)->member) * (n)))
/**
* Allocate n objects of a certain type on the stack
*/
#define ALLOCANZ(type, n) ((type*)memset((type*)alloca(sizeof(type) * (n)), 0, sizeof(type) * (n)))
+/**
+ * Allocate n objects of a certain type on the given obstack
+ */
+#define OALLOCN(obst, type, n) ((type*)obstack_alloc((obst), sizeof(type) * (n)))
+
+/**
+ * Allocate n objects of a certain type on the given obstack and zero them
+ */
+#define OALLOCNZ(obst, type, n) ((type*)memset(OALLOCN((obst), type, (n)), 0, sizeof(type) * (n)))
+
+/**
+ * Allocate one object of a certain type on the given obstack
+ */
+#define OALLOC(obst, type) OALLOCN(obst, type, 1)
+
+/**
+ * Allocate one object of a certain type on the given obstack and zero it
+ */
+#define OALLOCZ(obst, type) OALLOCNZ(obst, type, 1)
+
+/**
+ * Allocate an object with n elements of a flexible array member on the given
+ * obstck
+ */
+#define OALLOCF(obst, type, member, n) ((type*)obstack_alloc((obst), offsetof(type, member) + sizeof(*((type*)0)->member) * (n)))
+
+/**
+ * Allocate an object with n elements of a flexible array member on the given
+ * obstack and zero the whole object
+ */
+#define OALLOCFZ(obst, type, member, n) ((type*)memset(OALLOCF((obst), type, member, (n)), 0, offsetof(type, member) + sizeof(*((type*)0)->member) * (n)))
+
/* Includes for alloca() */
#ifdef _WIN32
DEBUG_ONLY(firm_dbg_module_t *dbg);
};
-static inline void *get_init_mem(struct obstack *obst, size_t sz) {
- void *p = obstack_alloc(obst, sz);
- memset(p, 0, sz);
- return p;
-}
-
static void hungarian_dump_f(FILE *f, int **C, int rows, int cols, int width) {
int i, j;
}
/* allocate space for cost matrix */
- p->cost = (int **)get_init_mem(&p->obst, rows * sizeof(p->cost[0]));
+ p->cost = OALLOCNZ(&p->obst, int*, rows);
for (i = 0; i < p->num_rows; i++)
- p->cost[i] = (int *)get_init_mem(&p->obst, cols * sizeof(p->cost[0][0]));
+ p->cost[i] = OALLOCNZ(&p->obst, int, cols);
return p;
}
new_element->next = NULL;
}
else {
- new_element = obstack_alloc(list->obst, sizeof(*new_element));
+ new_element = OALLOC(list->obst, plist_element_t);
}
return new_element;
}
plist_t *plist_obstack_new(struct obstack *obst) {
- plist_t *list = obstack_alloc(obst, sizeof(*list));
+ plist_t *list = OALLOC(obst, plist_t);
list->obst = obst;
list->foreign_obstack = 1;
/* Make segments */
for (i = 0; i < nslots; ++i) {
- table->dir[i] = (Segment *)obstack_alloc (&table->obst,
- sizeof (Segment) * SEGMENT_SIZE);
-
- memset(table->dir[i], 0, sizeof (Segment) * SEGMENT_SIZE);
+ table->dir[i] = OALLOCNZ(&table->obst, Segment, SEGMENT_SIZE);
table->nseg++;
}
NewSegmentDir = NewAddress >> SEGMENT_SIZE_SHIFT;
NewSegmentIndex = NewAddress & (SEGMENT_SIZE-1);
if (NewSegmentIndex == 0) {
- table->dir[NewSegmentDir] =
- (Segment *)obstack_alloc (&table->obst,
- sizeof(Segment) * SEGMENT_SIZE);
- memset(table->dir[NewSegmentDir], 0, sizeof(Segment) * SEGMENT_SIZE);
+ table->dir[NewSegmentDir] = OALLOCNZ(&table->obst, Segment, SEGMENT_SIZE);
table->nseg++;
}
NewSegment = table->dir[NewSegmentDir];
q = table->free_list;
table->free_list = table->free_list->chain;
} else {
- q = obstack_alloc (&table->obst, sizeof (Element));
+ q = OALLOC(&table->obst, Element);
}
q->entry.dptr = (void *)key;
#else
ARR_APP1(ir_node *, arr, n);
found->call_list = arr;
} else { /* New node, add Call node and init nesting. */
- found = (cg_callee_entry *)obstack_alloc(irg->obst, sizeof(*found));
+ found = OALLOC(irg->obst, cg_callee_entry);
found->irg = callee;
found->call_list = NEW_ARR_F(ir_node *, 1);
found->call_list[0] = n;
* allocates a new scc_info on the obstack
*/
static inline scc_info *new_scc_info(struct obstack *obst) {
- scc_info *info = obstack_alloc(obst, sizeof(*info));
- memset(info, 0, sizeof(*info));
- return info;
+ return OALLOCZ(obst, scc_info);
}
/**
#endif
if (dep == NULL) {
- ir_cdep *newdep = obstack_alloc(&cdep_data->obst, sizeof(*newdep));
+ ir_cdep *newdep = OALLOC(&cdep_data->obst, ir_cdep);
newdep->node = dep_on;
newdep->next = NULL;
if (dep->next == NULL) break;
dep = dep->next;
}
- newdep = obstack_alloc(&cdep_data->obst, sizeof(*newdep));
+ newdep = OALLOC(&cdep_data->obst, ir_cdep);
newdep->node = dep_on;
newdep->next = NULL;
dep->next = newdep;
/** Allocate a new scc_info on the given obstack */
static inline scc_info *new_scc_info(struct obstack *obst) {
- scc_info *info = obstack_alloc(obst, sizeof(*info));
- memset(info, 0, sizeof(*info));
- return info;
+ return OALLOCZ(obst, scc_info);
}
/**
* allocate a new extended block header.
*/
static void allocate_extblk(ir_node *block, env_t *env) {
- ir_extblk *extblk = obstack_alloc(env->obst, sizeof(*extblk));
+ ir_extblk *extblk = OALLOC(env->obst, ir_extblk);
extblk->kind = k_ir_extblk;
extblk->visited = 1;
*/
static ir_extblk *allocate_extblk(ir_node *block, env_t *env)
{
- ir_extblk *extblk = obstack_alloc(env->obst, sizeof(*extblk));
+ ir_extblk *extblk = OALLOC(env->obst, ir_extblk);
extblk->kind = k_ir_extblk;
extblk->visited = 1;
res->n_blocks = dfs_get_n_nodes(res->dfs);
res->back_edge_src = bitset_obstack_alloc(obst, res->n_blocks);
res->back_edge_tgt = bitset_obstack_alloc(obst, res->n_blocks);
- res->map = obstack_alloc(obst, res->n_blocks * sizeof(res->map[0]));
- memset(res->map, 0, res->n_blocks * sizeof(res->map[0]));
+ res->map = OALLOCNZ(obst, bl_info_t*, res->n_blocks);
#if 0
{
ir_loop *alloc_loop(ir_loop *father, struct obstack *obst) {
ir_loop *son;
- son = obstack_alloc(obst, sizeof(*son));
- memset(son, 0, sizeof(*son));
+ son = OALLOCZ(obst, ir_loop);
son->kind = k_ir_loop;
son->children = NEW_ARR_F(loop_element, 0);
son->n_nodes = 0;
* Allocates a new SCC info on the given obstack.
*/
static inline scc_info *new_scc_info(struct obstack *obst) {
- scc_info *info = obstack_alloc(obst, sizeof(*info));
- memset(info, 0, sizeof(*info));
- return info;
+ return OALLOCZ(obst, scc_info);
}
/**
ir_region *reg;
/* Allocate a Block wrapper */
- reg = obstack_alloc(env->obst, sizeof(*reg));
+ reg = OALLOC(env->obst, ir_region);
reg->kind = k_ir_region;
reg->type = ir_rk_BasicBlock;
reg->parent = NULL;
/** Allocate a new region on an obstack */
#define ALLOC_REG(obst, reg, tp) \
do { \
- (reg) = obstack_alloc((obst), sizeof(*(reg))); \
+ (reg) = OALLOC((obst), ir_region); \
(reg)->kind = k_ir_region; \
(reg)->type = tp; \
(reg)->parent = NULL; \
ident *id = get_entity_ident(get_irg_entity(env->birg->irg));
ir_entity **map;
- *param_map = map = obstack_alloc(&env->obst, n * sizeof(ir_entity *));
+ *param_map = map = OALLOCN(&env->obst, ir_entity*, n);
res = new_type_struct(id_mangle_u(id, new_id_from_chars("arg_type", 8)));
for (i = 0; i < n; ++i, curr += inc) {
ir_type *param_type = get_method_param_type(method_type, curr);
pmap_entry *ent;
int n = pmap_count(reg_map);
int i = 0;
- reg_node_map_t *res = obstack_alloc(obst, n * sizeof(res[0]));
+ reg_node_map_t *res = OALLOCN(obst, reg_node_map_t, n);
foreach_pmap(reg_map, ent) {
res[i].reg = ent->key;
ir_node **in;
ir_node *stack;
const arch_register_t **regs;
- pmap_entry *ent ;
+ pmap_entry *ent;
/*
get the valid stack node in this block.
*/
in_max = pmap_count(reg_map) + n_res + 2;
- in = obstack_alloc(&env->obst, in_max * sizeof(in[0]));
- regs = obstack_alloc(&env->obst, in_max * sizeof(regs[0]));
+ in = OALLOCN(&env->obst, ir_node*, in_max);
+ regs = OALLOCN(&env->obst, arch_register_t const*, in_max);
in[0] = mem;
in[1] = be_abi_reg_map_get(reg_map, arch_env->sp);
env->regs = pmap_create();
n_params = get_method_n_params(method_type);
- args = obstack_alloc(&env->obst, n_params * sizeof(args[0]));
- memset(args, 0, n_params * sizeof(args[0]));
+ args = OALLOCNZ(&env->obst, ir_node*, n_params);
/*
* for inner function we must now fix access to outer frame entities.
env->dce_survivor = new_survive_dce();
env->birg = birg;
- sp_req = obstack_alloc(&env->obst, sizeof(*sp_req));
- memset(sp_req, 0, sizeof(*sp_req));
+ sp_req = OALLOCZ(&env->obst, arch_register_req_t);
env->sp_req = sp_req;
sp_req->type = arch_register_req_type_limited
memset(&edge, 0, sizeof(edge));
- entry = obstack_alloc(env->obst, sizeof(entry[0]));
- memset(entry, 0, sizeof(*entry));
+ entry = OALLOCZ(env->obst, blocksched_entry_t);
entry->block = block;
set_irn_link(block, entry);
snprintf(name, sizeof(name), "block_out_constr_%ld", get_irn_node_nr(block));
out_count = get_irn_n_edges_kind(block, EDGE_KIND_BLOCK);
- entry = obstack_alloc(env->env.obst, sizeof(entry[0]));
+ entry = OALLOC(env->env.obst, blocksched_ilp_entry_t);
entry->block = block;
entry->next = NULL;
entry->prev = NULL;
if (!is_def) {
border_t *def;
- b = obstack_alloc(env->obst, sizeof(*b));
+ b = OALLOC(env->obst, border_t);
/* also allocate the def and tie it to the use. */
- def = obstack_alloc(env->obst, sizeof(*def));
- memset(def, 0, sizeof(*def));
+ def = OALLOCZ(env->obst, border_t);
b->other_end = def;
def->other_end = b;
bitset_clear_all(live);
/* Set up the border list in the block info */
- head = obstack_alloc(env->obst, sizeof(*head));
+ head = OALLOC(env->obst, struct list_head);
INIT_LIST_HEAD(head);
assert(pmap_get(env->border_heads, block) == NULL);
pmap_insert(env->border_heads, block, head);
draw_chordal_env_t *env = data;
struct list_head *head = get_block_border_head(env->chordal_env, block);
const draw_chordal_opts_t *opts = env->opts;
- struct block_dims *dims = obstack_alloc(&env->obst, sizeof(*dims));
+ struct block_dims *dims = OALLOCZ(&env->obst, struct block_dims);
border_t *b;
- memset(dims, 0, sizeof(*dims));
dims->min_step = INT_MAX;
list_for_each_entry_reverse(border_t, b, head, list) {
int n_childs = ci->mst_n_childs;
int j;
- ci->col_costs = obstack_alloc(&cloud->obst, n_regs * sizeof(ci->col_costs[0]));
- ci->tmp_coloring = obstack_alloc(&cloud->obst, n_regs * sizeof(ci->tmp_coloring[0]));
- ci->fronts = obstack_alloc(&cloud->obst, n_regs * n_childs * sizeof(ci->fronts[0]));
- ci->color_badness = obstack_alloc(&cloud->obst, n_regs * sizeof(ci->fronts[0]));
- memset(ci->color_badness, 0, n_regs * sizeof(ci->color_badness[0]));
- memset(ci->col_costs, 0, n_regs * sizeof(ci->col_costs[0]));
- memset(ci->tmp_coloring, 0, n_regs * sizeof(ci->tmp_coloring[0]));
- memset(ci->fronts, 0, n_regs * n_childs * sizeof(ci->fronts[0]));
+ ci->col_costs = OALLOCNZ(&cloud->obst, int, n_regs);
+ ci->tmp_coloring = OALLOCNZ(&cloud->obst, col_cost_pair_t, n_regs);
+ ci->fronts = OALLOCNZ(&cloud->obst, int, n_regs * n_childs);
+ ci->color_badness = OALLOCNZ(&cloud->obst, int, n_regs);
for(j = 0; j < env->n_regs; j++)
ci->col_costs[j] = INT_MAX;
-
}
determine_color_badness(cloud->mst_root, 0);
if (!arch_register_req_is(req, limited) && !sr_is_removed(sr, irn) && !co_gs_is_optimizable(sr->co, irn)) {
if (sr_is_simplicial(sr, irn)) {
- coloring_suffix_t *cs = obstack_alloc(&sr->ob, sizeof(*cs));
+ coloring_suffix_t *cs = OALLOC(&sr->ob, coloring_suffix_t);
cs->irn = irn;
cs->next = sr->col_suff;
/* if we did not find n2 in n1's neighbourhood insert it */
if (allocnew) {
- nbr = obstack_alloc(&co->obst, sizeof(*nbr));
+ nbr = OALLOC(&co->obst, neighb_t);
nbr->irn = n2;
nbr->costs = 0;
nbr->next = node->neighbours;
if (ifg->cli_root == NULL)
{
- new_cli_head = obstack_alloc(&ifg->obst, sizeof(*new_cli_head));
+ new_cli_head = OALLOC(&ifg->obst, cli_head_t);
INIT_LIST_HEAD(&new_cli_head->list);
ifg->cli_root = new_cli_head;
}
{
cli_head = cli_head->next_cli_head;
}
- new_cli_head = obstack_alloc(&ifg->obst, sizeof(*new_cli_head));
+ new_cli_head = OALLOC(&ifg->obst, cli_head_t);
INIT_LIST_HEAD(&new_cli_head->list);
cli_head->next_cli_head = new_cli_head;
}
{
cli_element_t *cli_element;
- cli_element = obstack_alloc(&ifg->obst, sizeof(*cli_element));
+ cli_element = OALLOC(&ifg->obst, cli_element_t);
INIT_LIST_HEAD(&cli_element->list);
return cli_element;
adj_head = ifg->adj_heads[irn->node_idx];
if (!adj_head)
{
- adj_head = obstack_alloc(&ifg->obst, sizeof(*adj_head));
+ adj_head = OALLOC(&ifg->obst, adj_head_t);
adj_head->irn = irn;
adj_head->first_adj_element = NULL;
adj_head->degree = 0;
{
adj_element_t *element = NULL;
- element = obstack_alloc(&ifg->obst, sizeof(*element));
+ element = OALLOC(&ifg->obst, adj_element_t);
element->next_adj_element = NULL;
element->neighbour = irn;
static ptr_element_t *ptr_get_new_element(ifg_pointer_t *ifg)
{
- ptr_element_t *new_element = obstack_alloc(&ifg->obst, sizeof(ptr_element_t));
- memset(new_element, 0, sizeof(*new_element));
+ ptr_element_t *new_element = OALLOCZ(&ifg->obst, ptr_element_t);
return new_element;
}
static ptr_head_t *ptr_get_new_head(ifg_pointer_t *ifg)
{
- ptr_head_t *new_element = obstack_alloc(&ifg->obst, sizeof(*new_element));
+ ptr_head_t *new_element = OALLOC(&ifg->obst, ptr_head_t);
INIT_LIST_HEAD(&new_element->list);
return new_element;
}
if (get_nodes_block(pred) != block_node->irn && consider_for_sched(env->arch_env, pred)) {
be_ilpsched_set_type_info(env, pred, var_obst);
if (! na->is_dummy_node) {
- ilp_livein_node_t *entry = obstack_alloc(var_obst, sizeof(*entry));
+ ilp_livein_node_t *entry = OALLOC(var_obst, ilp_livein_node_t);
entry->irn = pred;
entry->a = NULL;
pset_insert(ba->livein_nodes, entry, (unsigned)get_irn_idx(pred));
{
struct obstack *obst;
backend_info_t *info;
- sched_info_t *sinfo;
if (is_Anchor(node))
return;
return;
obst = get_irg_obstack(current_ir_graph);
- info = obstack_alloc(obst, sizeof(*info));
- sinfo = &info->sched_info;
-
- memset(info, 0, sizeof(*info));
- sinfo->next = NULL;
- sinfo->prev = NULL;
+ info = OALLOCZ(obst, backend_info_t);
if (is_Phi(node)) {
info->out_infos = NEW_ARR_D(reg_out_info_t, obst, 1);
int i, n;
int pre_colored = 0;
- insn = obstack_alloc(obst, sizeof(insn[0]));
- memset(insn, 0, sizeof(insn[0]));
+ insn = OALLOCZ(obst, be_insn_t);
insn->irn = irn;
insn->next_insn = sched_next(irn);
/* insert the other different and it's copies into the map */
entry = ir_nodemap_get(op_set, other_different);
if (! entry) {
- entry = obstack_alloc(&env->obst, sizeof(*entry));
+ entry = OALLOC(&env->obst, op_copy_assoc_t);
entry->cls = cls;
ir_nodeset_init(&entry->copies);
{
allocation_info_t *info;
if (!irn_visited_else_mark(node)) {
- size_t size = sizeof(info[0]) + n_regs * sizeof(info->prefs[0]);
- info = obstack_alloc(&obst, size);
- memset(info, 0, size);
+ info = OALLOCFZ(&obst, allocation_info_t, prefs, n_regs);
info->current_value = node;
info->original_value = node;
set_irn_link(node, info);
assert(is_Block(block));
if (!irn_visited_else_mark(block)) {
- size_t size = sizeof(info[0]) + n_regs * sizeof(info->assignments[0]);
- info = obstack_alloc(&obst, size);
- memset(info, 0, size);
+ info = OALLOCFZ(&obst, block_info_t, assignments, n_regs);
set_irn_link(block, info);
} else {
info = get_irn_link(block);
{
if (default_cls_req == NULL) {
struct obstack *obst = get_irg_obstack(irg);
- arch_register_req_t *req = obstack_alloc(obst, sizeof(*req));
- memset(req, 0, sizeof(*req));
+ arch_register_req_t *req = OALLOCZ(obst, arch_register_req_t);
req->type = arch_register_req_type_normal;
req->cls = cls;
}
attr = get_irn_attr(irn);
-
- attr->in_entities = obstack_alloc(irg->obst, n * sizeof(attr->in_entities[0]));
- memset(attr->in_entities, 0, n * sizeof(attr->in_entities[0]));
- attr->out_entities = obstack_alloc(irg->obst, n*sizeof(attr->out_entities[0]));
- memset(attr->out_entities, 0, n*sizeof(attr->out_entities[0]));
+ attr->in_entities = OALLOCNZ(irg->obst, ir_entity*, n);
+ attr->out_entities = OALLOCNZ(irg->obst, ir_entity*, n);
return irn;
}
assert(req->cls != NULL);
if (req->type != arch_register_req_type_normal) {
- arch_register_req_t *nreq = obstack_alloc(obst, sizeof(*nreq));
- memset(nreq, 0, sizeof(*nreq));
+ arch_register_req_t *nreq = OALLOCZ(obst, arch_register_req_t);
nreq->type = arch_register_req_type_normal;
nreq->cls = req->cls;
req = nreq;
int i;
ir_node* block = get_nodes_block(irn);
- fc = obstack_alloc(&inst->obst, sizeof(*fc) + sizeof(*fc->costs) * arity);
+ fc = OALLOCF(&inst->obst, flag_and_cost, costs, arity);
fc->no_root = 0;
costs = fc->costs;
usage_stats_t *us = get_irn_link(irn);
if(!us) {
- us = obstack_alloc(&env->obst, sizeof(us[0]));
+ us = OALLOC(&env->obst, usage_stats_t);
us->irn = irn;
us->already_consumed = 0;
us->max_hops = INT_MAX;
foreach_plist(rirn->pkiller_list, k_el) {
ir_node *pkiller = plist_element_get_value(k_el);
- rss_edge_t *ke = obstack_alloc(phase_obst(&rss->ph), sizeof(*ke));
+ rss_edge_t *ke = OALLOC(phase_obst(&rss->ph), rss_edge_t);
ke->src = irn;
ke->tgt = pkiller;
DBG((rss->dbg, LEVEL_2, "\t\t%+F choosen:\n", u_irn));
- cbc = obstack_alloc(phase_obst(&rss->ph), sizeof(*cbc));
+ cbc = OALLOC(phase_obst(&rss->ph), cbc_t);
cbc->nr = cur_num++;
/* initialize S_cb */
/* while X not empty */
while (ir_nodeset_size(&x) > 0) {
- child_t *t = obstack_alloc(&obst, sizeof(*t));
- memset(t, 0, sizeof(*t));
+ child_t *t = OALLOCZ(&obst, child_t);
t = select_child_max_cost(rss, &x, &y, t, cbc);
key.tgt = (ir_node *) tgt;
if (NULL != pset_find(dvg->edges, &key, HASH_RSS_EDGE(&key))) {
/* add the edge to the DVG */
- dvg_edge = obstack_alloc(phase_obst(&rss->ph), sizeof(*dvg_edge));
+ dvg_edge = OALLOC(phase_obst(&rss->ph), rss_edge_t);
dvg_edge->src = (ir_node *) src;
dvg_edge->tgt = (ir_node *) tgt;
There is an edge (u, v) in the DVG iff v is a descendant of the killer(u).
*/
if (BSEARCH_IRN_ARR(v_irn, u_kill->descendants)) {
- rss_edge_t *dvg_edge = obstack_alloc(phase_obst(&rss->ph), sizeof(*dvg_edge));
+ rss_edge_t *dvg_edge = OALLOC(phase_obst(&rss->ph), rss_edge_t);
rss_edge_t key;
/* insert the user into the DVG and append it to the user list of u */
int xj = idx_map[j];
ir_node *xj_irn = get_idx_irn(rss->irg, xj);
rss_irn_t *xj_rss = get_rss_irn(rss, xj_irn);
- chain_t *c = obstack_alloc(phase_obst(&rss->ph), sizeof(*c));
+ chain_t *c = OALLOC(phase_obst(&rss->ph), chain_t);
int source;
/* there was no source for j -> we have a source of a new chain */
sat_vals = compute_maximal_antichain(rss, &dvg, iteration++);
while (sat_vals && (ir_nodeset_size(sat_vals) > available_regs)) {
serialization_t *ser, best_ser;
- rss_edge_t *edge = obstack_alloc(phase_obst(&rss->ph), sizeof(*edge));
+ rss_edge_t *edge = OALLOC(phase_obst(&rss->ph), rss_edge_t);
ir_node *dep_src, *dep_tgt;
best_ser.edge = edge;
*/
static workset_t *new_workset(void)
{
- workset_t *res;
- size_t size = sizeof(*res) + n_regs * sizeof(res->vals[0]);
-
- res = obstack_alloc(&obst, size);
- memset(res, 0, size);
- return res;
+ return OALLOCFZ(&obst, workset_t, vals, n_regs);
}
/**
*/
static workset_t *workset_clone(workset_t *workset)
{
- workset_t *res;
- size_t size = sizeof(*res) + n_regs * sizeof(res->vals[0]);
- res = obstack_alloc(&obst, size);
- memcpy(res, workset, size);
+ workset_t *res = OALLOCF(&obst, workset_t, vals, n_regs);
+ memcpy(res, workset, sizeof(*res) + n_regs * sizeof(res->vals[0]));
return res;
}
} block_info_t;
-static void *new_block_info(void)
+static block_info_t *new_block_info(void)
{
- block_info_t *res = obstack_alloc(&obst, sizeof(res[0]));
- memset(res, 0, sizeof(res[0]));
-
- return res;
+ return OALLOCZ(&obst, block_info_t);
}
#define get_block_info(block) ((block_info_t *)get_irn_link(block))
* Alloc a new workset on obstack @p ob with maximum size @p max
*/
static inline workset_t *new_workset(belady_env_t *env, struct obstack *ob) {
- workset_t *res;
- size_t size = sizeof(*res) + (env->n_regs)*sizeof(res->vals[0]);
- res = obstack_alloc(ob, size);
- memset(res, 0, size);
- return res;
+ return OALLOCFZ(ob, workset_t, vals, env->n_regs);
}
/**
* Alloc a new instance on obstack and make it equal to @param ws
*/
static inline workset_t *workset_clone(belady_env_t *env, struct obstack *ob, workset_t *ws) {
- workset_t *res;
- size_t size = sizeof(*res) + (env->n_regs)*sizeof(res->vals[0]);
- res = obstack_alloc(ob, size);
- memcpy(res, ws, size);
+ workset_t *res = OALLOCF(ob, workset_t, vals, env->n_regs);
+ memcpy(res, ws, sizeof(*res) + (env->n_regs)*sizeof(res->vals[0]));
return res;
}
static inline void *new_block_info(belady_env_t *bel, int id)
{
ir_node *bl = bel->blocks[id];
- block_info_t *res = obstack_alloc(&bel->ob, sizeof(*res));
- memset(res, 0, sizeof(res[0]));
+ block_info_t *res = OALLOCZ(&bel->ob, block_info_t);
res->first_non_in = NULL;
- res->last_ins = NULL;
- res->bel = bel;
- res->bl = bl;
- res->id = id;
+ res->last_ins = NULL;
+ res->bel = bel;
+ res->bl = bl;
+ res->id = id;
res->exec_freq = get_block_execfreq(bel->ef, bl);
res->reload_cost = bel->arch->reload_cost * res->exec_freq;
res->free_at_jump = bel->n_regs;
static inline bring_in_t *new_bring_in(block_info_t *bi, ir_node *irn, const next_use_t *use)
{
- bring_in_t *br = obstack_alloc(&bi->bel->ob, sizeof(br[0]));
-
+ bring_in_t *br = OALLOC(&bi->bel->ob, bring_in_t);
br->irn = irn;
br->bi = bi;
br->first_use = use->irn;
static block_state_t *new_block_state(global_end_state_t *ges, block_info_t *bi)
{
block_state_t *bs = get_block_state(ges, bi);
- block_state_t *nw = obstack_alloc(&ges->obst, sizeof(nw[0]));
+ block_state_t *nw = OALLOC(&ges->obst, block_state_t);
nw->next_intern = bs;
nw->next = ges->bs_top;
static irn_action_t *new_irn_action(global_end_state_t *ges, ir_node *irn, const ir_node *bl)
{
- irn_action_t *ia = obstack_alloc(&ges->obst, sizeof(ia[0]));
+ irn_action_t *ia = OALLOC(&ges->obst, irn_action_t);
ia->irn = irn;
ia->bl = bl;
ges.version = ver_make_newer(ver_oldest);
ges.succ_phis = bitset_irg_obstack_alloc(&ges.obst, env->irg);
ges.committed = bitset_obstack_alloc(&ges.obst, env->n_blocks);
- ges.bs_tops = obstack_alloc(&ges.obst, sizeof(ges.bs_tops[0]) * env->n_blocks);
- ges.bs_tops_vers = obstack_alloc(&ges.obst, sizeof(ges.bs_tops_vers[0]) * env->n_blocks);
+ ges.bs_tops = OALLOCN(&ges.obst, block_state_t*, env->n_blocks);
+ ges.bs_tops_vers = OALLOCN(&ges.obst, unsigned, env->n_blocks);
/* invalidate all state stack pointer versions */
for (i = 0; i < env->n_blocks; ++i) {
static worklist_t *new_worklist(void)
{
- worklist_t *worklist = obstack_alloc(&obst, sizeof(worklist[0]));
- memset(worklist, 0, sizeof(worklist[0]));
+ worklist_t *worklist = OALLOCZ(&obst, worklist_t);
INIT_LIST_HEAD(&worklist->live_values);
worklist->n_live_values = 0;
if (info != NULL)
return info;
- info = obstack_alloc(&obst, sizeof(info[0]));
- memset(info, 0, sizeof(info[0]));
+ info = OALLOCZ(&obst, block_info_t);
set_irn_link(block, info);
return info;
}
if (irn_visited_else_mark(value))
continue;
- new_entry = obstack_alloc(&obst, sizeof(new_entry[0]));
- memset(new_entry, 0, sizeof(new_entry[0]));
+ new_entry = OALLOCZ(&obst, worklist_entry_t);
new_entry->value = value;
if (reload_point != NULL) {
worklist_t *new_worklist;
struct list_head *entry;
- new_worklist = obstack_alloc(&obst, sizeof(new_worklist[0]));
- memset(new_worklist, 0, sizeof(new_worklist[0]));
+ new_worklist = OALLOCZ(&obst, worklist_t);
INIT_LIST_HEAD(&new_worklist->live_values);
new_worklist->n_live_values = worklist->n_live_values;
list_for_each(entry, &worklist->live_values) {
worklist_entry_t *wl_entry = list_entry(entry, worklist_entry_t, head);
- worklist_entry_t *new_entry
- = obstack_alloc(&obst, sizeof(new_entry[0]));
+ worklist_entry_t *new_entry = OALLOC(&obst, worklist_entry_t);
memcpy(new_entry, wl_entry, sizeof(new_entry[0]));
list_add_tail(&new_entry->head, &new_worklist->live_values);
if (info != NULL)
return info;
- info = obstack_alloc(&obst, sizeof(info[0]));
- memset(info, 0, sizeof(info[0]));
+ info = OALLOCZ(&obst, loop_info_t);
info->loop = loop;
loop->link = info;
return info;
do {
loop_info_t *l_info = get_loop_info(l);
- edge = obstack_alloc(&obst, sizeof(edge[0]));
- memset(edge, 0, sizeof(edge[0]));
+ edge = OALLOCZ(&obst, loop_edge_t);
edge->block = block;
edge->pos = i;
list_del(&entry->head);
} else {
if (entry == NULL) {
- entry = obstack_alloc(&obst, sizeof(entry[0]));
- memset(entry, 0, sizeof(entry[0]));
-
+ entry = OALLOCZ(&obst, worklist_entry_t);
entry->value = value;
set_irn_link(value, entry);
}
}
#endif
- entry = obstack_alloc(&obst, sizeof(*entry));
- memset(entry, 0, sizeof(entry[0]));
-
+ entry = OALLOCZ(&obst, worklist_entry_t);
entry->value = value;
entry->reload_point = reload_point;
entry->unused_livethrough_loop = unused_livethrough_loop;
}
/* add an affinity edge */
- affinty_edge = obstack_alloc(&env->obst, sizeof(affinty_edge[0]));
+ affinty_edge = OALLOC(&env->obst, affinity_edge_t);
affinty_edge->affinity = get_block_execfreq(exec_freq, get_nodes_block(arg));
affinty_edge->slot1 = res->spillslot;
affinty_edge->slot2 = arg_spill->spillslot;
memperm = get_memperm(env, predblock);
- entry = obstack_alloc(&env->obst, sizeof(entry[0]));
+ entry = OALLOC(&env->obst, memperm_entry_t);
entry->node = node;
entry->pos = i;
entry->in = argslot->entity;
}
}
- spill = obstack_alloc(&env->obst, sizeof(spill[0]));
+ spill = OALLOC(&env->obst, spill_t);
spill->after = after;
spill->next = spill_info->spills;
spill->spill = NULL;
spill_info = get_spillinfo(env, to_spill);
/* add the remat information */
- reloader = obstack_alloc(&env->obst, sizeof(reloader[0]));
+ reloader = OALLOC(&env->obst, reloader_t);
reloader->next = spill_info->reloaders;
reloader->reloader = before;
reloader->rematted_node = rematted_node;
assert(!is_Proj(before) && !be_is_Keep(before));
/* put reload into list */
- rel = obstack_alloc(&env->obst, sizeof(rel[0]));
+ rel = OALLOC(&env->obst, reloader_t);
rel->next = info->reloaders;
rel->reloader = before;
rel->rematted_node = NULL;
}
/* override or replace spills list... */
- spill = obstack_alloc(&env->obst, sizeof(spill[0]));
+ spill = OALLOC(&env->obst, spill_t);
spill->after = skip_keeps_phis(phi);
spill->spill = new_r_Phi(block, arity, ins, mode_M);
spill->next = NULL;
*/
if(!sched_is_scheduled(insn)) {
/* override spillinfos or create a new one */
- spill_t *spill = obstack_alloc(&env->obst, sizeof(spill[0]));
+ spill_t *spill = OALLOC(&env->obst, spill_t);
spill->after = NULL;
spill->next = NULL;
spill->spill = new_NoMem();
}
/* override spillinfos or create a new one */
- spill = obstack_alloc(&env->obst, sizeof(spill[0]));
+ spill = OALLOC(&env->obst, spill_t);
spill->after = skip_keeps_phis(to_spill);
spill->next = NULL;
spill->spill = NULL;
static inline
block_info_t *new_block_info(struct obstack *obst, ir_node *block)
{
- block_info_t *res = obstack_alloc(obst, sizeof(*res));
- memset(res, 0, sizeof(res[0]));
+ block_info_t *res = OALLOCZ(obst, block_info_t);
assert(is_Block(block));
set_irn_link(block, res);
static inline
spill_info_t *create_spill_info(minibelady_env_t *env, ir_node *state)
{
- spill_info_t *spill_info = obstack_alloc(&env->obst, sizeof(spill_info[0]));
- memset(spill_info, 0, sizeof(spill_info[0]));
+ spill_info_t *spill_info = OALLOCZ(&env->obst, spill_info_t);
spill_info->value = state;
spill_info->reloads = NEW_ARR_F(ir_node*, 0);
static void *make_msg_info(const firm_dbg_module_t *mod, const char *fmt, va_list args)
{
static const char msg_header[] = "%s(%d) %s: ";
- msg_info_t *res = obstack_alloc(&dbg_obst, sizeof(*res));
+ msg_info_t *res = OALLOC(&dbg_obst, msg_info_t);
obstack_grow(&dbg_obst, msg_header, sizeof(msg_header) - 1);
ir_obst_vprintf(&dbg_obst, fmt, args);
* emit a LEA (or an Add) instruction
*/
static instruction *emit_LEA(mul_env *env, instruction *a, instruction *b, unsigned shift) {
- instruction *res = obstack_alloc(&env->obst, sizeof(*res));
+ instruction *res = OALLOC(&env->obst, instruction);
res->kind = shift > 0 ? LEA : ADD;
res->in[0] = a;
res->in[1] = b;
* emit a SHIFT (or an Add or a Zero) instruction
*/
static instruction *emit_SHIFT(mul_env *env, instruction *a, unsigned shift) {
- instruction *res = obstack_alloc(&env->obst, sizeof(*res));
+ instruction *res = OALLOC(&env->obst, instruction);
if (shift == env->bits) {
/* a 2^bits with bits resolution is a zero */
res->kind = ZERO;
* emit a SUB instruction
*/
static instruction *emit_SUB(mul_env *env, instruction *a, instruction *b) {
- instruction *res = obstack_alloc(&env->obst, sizeof(*res));
+ instruction *res = OALLOC(&env->obst, instruction);
res->kind = SUB;
res->in[0] = a;
res->in[1] = b;
* emit the ROOT instruction
*/
static instruction *emit_ROOT(mul_env *env, ir_node *root_op) {
- instruction *res = obstack_alloc(&env->obst, sizeof(*res));
+ instruction *res = OALLOC(&env->obst, instruction);
res->kind = ROOT;
res->in[0] = NULL;
res->in[1] = NULL;
// Else generate new node name and dump the node
- node_name = obstack_alloc(&(dump_info -> node_names), MAX_NODENAME_LEN);
+ node_name = OALLOCN(&dump_info->node_names, char, MAX_NODENAME_LEN);
sprintf(node_name, "%s%ld", get_op_name(get_irn_op(n)), get_irn_node_nr(n));
fprintf(fp, "%s%s : %s;\n", indent, node_name, get_op_name(get_irn_op(n)));
if((nodes_edge_names = pmap_get(dump_info -> edge_name_map, n)) == NULL)
{
- nodes_edge_names = (char **) obstack_alloc(&(dump_info->node_names), (get_irn_arity(n) + 1) * sizeof(char *));
- memset(nodes_edge_names, 0, (get_irn_arity(n) + 1) * sizeof(char *));
+ size_t const count = get_irn_arity(n) + 1;
+ nodes_edge_names = OALLOCNZ(&dump_info->node_names, char*, count);
pmap_insert(dump_info->edge_name_map, n, nodes_edge_names);
}
char edge_name[50], *edge_name_obst;
sprintf(edge_name, "pos%d_%d", n_edge + 1, edge_counter++);
- edge_name_obst = obstack_alloc(&(dump_info->node_names), strlen(edge_name) + 1);
+ edge_name_obst = OALLOCN(&dump_info->node_names, char, strlen(edge_name) + 1);
strcpy(edge_name_obst, edge_name);
nodes_edge_names[n_edge + 1] = edge_name_obst;
if(pmap_get(dump_info->mode_edge_map, n) == NULL)
{
- char *edge_name_obst = obstack_alloc(&(dump_info->node_names), strlen(edge_name) + 1);
+ char *edge_name_obst = OALLOCN(&dump_info->node_names, char, strlen(edge_name) + 1);
strcpy(edge_name_obst, edge_name);
pmap_insert(dump_info->mode_edge_map, n, edge_name_obst);
}
if(!pmap_contains(dump_info -> mode_name_map, irn_mode))
{
// No, create a new mode-node
- mode_node_name = obstack_alloc(&(dump_info -> mode_names), MAX_NODENAME_LEN);
+ mode_node_name = OALLOCN(&dump_info->mode_names, char, MAX_NODENAME_LEN);
sprintf(mode_node_name, "mode_%s_node", mode_name);
pmap_insert(dump_info -> mode_name_map, irn_mode, mode_node_name);
fprintf(fp, "%s%s : Mode_%s;\n", indent, mode_node_name, mode_name);
if (elem)
return elem;
- elem = obstack_alloc(&ctx->obst, sizeof(*elem));
+ elem = OALLOC(&ctx->obst, block_entry_t);
elem->block = block;
elem->phi_list = NEW_ARR_F(ir_node *, 0);
#include "lc_parser_t.h"
#include "hashptr.h"
#include "lc_printf.h"
+#include "xmalloc.h"
#define ERR_STRING "In argument \"%s\": "
lc_opt_entry_t *ent = lc_opt_find_grp(parent, name, NULL);
if(!ent) {
- ent = obstack_alloc(&obst, sizeof(*ent));
+ ent = OALLOC(&obst, lc_opt_entry_t);
init_entry(ent, parent, name, "");
init_grp(ent, NULL);
}
lc_opt_entry_t *ent = lc_opt_find_opt(parent, name, NULL);
if(!ent) {
- res = obstack_alloc(&obst, sizeof(*ent));
+ res = OALLOC(&obst, lc_opt_entry_t);
init_entry(res, parent, name, desc);
init_opt(res, type, value, length, cb, dump, dump_vals, err);
} else
static cl_entry *get_Call_entry(ir_node *call, wlk_env *env) {
cl_entry *res = get_irn_link(call);
if (res == NULL) {
- cl_entry *res = obstack_alloc(&env->obst, sizeof(*res));
+ cl_entry *res = OALLOC(&env->obst, cl_entry);
res->next = env->cl_list;
res->call = call;
res->copyb = NULL;
return;
/* ok, link it in */
- entry = obstack_alloc(&env->obst, sizeof(*entry));
+ entry = OALLOC(&env->obst, entry_t);
entry->copyb = irn;
INIT_LIST_HEAD(&entry->list);
set_irn_link(irn, entry);
if (mode == lenv->params->high_signed ||
mode == lenv->params->high_unsigned) {
/* ok, found a node that will be lowered */
- link = obstack_alloc(&lenv->obst, sizeof(*link));
-
- memset(link, 0, sizeof(*link));
+ link = OALLOCZ(&lenv->obst, node_entry_t);
idx = get_irn_idx(node);
if (idx >= lenv->n_entries) {
* @return a newly allocated partition
*/
static inline partition_t *new_partition(environment_t *env) {
- partition_t *part = obstack_alloc(&env->obst, sizeof(*part));
+ partition_t *part = OALLOC(&env->obst, partition_t);
INIT_LIST_HEAD(&part->Leader);
INIT_LIST_HEAD(&part->Follower);
*/
static node_t *create_partition_node(ir_node *irn, partition_t *part, environment_t *env) {
/* create a partition node and place it in the partition */
- node_t *node = obstack_alloc(&env->obst, sizeof(*node));
+ node_t *node = OALLOC(&env->obst, node_t);
INIT_LIST_HEAD(&node->node_list);
INIT_LIST_HEAD(&node->cprop_list);
obstack_init(&obst);
elist = NULL;
- env = obstack_alloc(&obst, sizeof(*env));
+ env = OALLOC(&obst, walk_env_t);
env->found_allocs = NULL;
env->dead_allocs = NULL;
env->callback = callback;
elist = env;
- env = obstack_alloc(&obst, sizeof(*env));
+ env = OALLOC(&obst, walk_env_t);
env->found_allocs = NULL;
env->dead_allocs = NULL;
env->callback = callback;
* @param env the environment
*/
static void alloc_blk_info(ir_node *block, pre_env *env) {
- block_info *info = obstack_alloc(env->obst, sizeof(*info));
+ block_info *info = OALLOC(env->obst, block_info);
set_irn_link(block, info);
info->exp_gen = ir_valueset_new(16);
ir_node *expr = ir_valueset_lookup(bl->avail_out, value);
if (expr != NULL && expr != irn) {
- elim_pair *p = obstack_alloc(env->obst, sizeof(*p));
+ elim_pair *p = OALLOC(env->obst, elim_pair);
p->old_node = irn;
p->new_node = expr;
ldst_info_t *info = get_irn_link(node);
if (! info) {
- info = obstack_alloc(obst, sizeof(*info));
- memset(info, 0, sizeof(*info));
+ info = OALLOCZ(obst, ldst_info_t);
set_irn_link(node, info);
}
return info;
block_info_t *info = get_irn_link(node);
if (! info) {
- info = obstack_alloc(obst, sizeof(*info));
- memset(info, 0, sizeof(*info));
+ info = OALLOCZ(obst, block_info_t);
set_irn_link(node, info);
}
return info;
* @param env the environment
*/
static partition_t *create_partition(ir_node *meet_block, environment_t *env) {
- partition_t *part = obstack_alloc(&env->obst, sizeof(*part));
+ partition_t *part = OALLOC(&env->obst, partition_t);
INIT_LIST_HEAD(&part->blocks);
part->meet_block = meet_block;
* @param env the environment
*/
static block_t *create_block(ir_node *block, int meet_input, partition_t *partition, environment_t *env) {
- block_t *bl = obstack_alloc(&env->obst, sizeof(*bl));
+ block_t *bl = OALLOC(&env->obst, block_t);
set_irn_link(block, bl);
* @param env the environment
*/
static node_t *create_node(ir_node *irn, block_t *block, environment_t *env) {
- node_t *node = obstack_alloc(&env->obst, sizeof(*node));
+ node_t *node = OALLOC(&env->obst, node_t);
node->node = irn;
node->is_input = 0;
* @param env the environment
*/
static void add_pair(block_t *block, ir_node *irn, int idx, environment_t *env) {
- pair_t *pair = obstack_alloc(&env->obst, sizeof(*pair));
+ pair_t *pair = OALLOC(&env->obst, pair_t);
pair->next = block->input_pairs;
pair->irn = irn;
* @param env the environment
*/
static void add_phi(block_t *block, ir_node *phi, environment_t *env) {
- phi_t *node = obstack_alloc(&env->obst, sizeof(*node));
+ phi_t *node = OALLOC(&env->obst, phi_t);
node->next = block->phis;
node->phi = phi;
if (*place != NULL) {
ir_node *irn = *place;
survive_dce_list_t *curr = pmap_get(sd->places, irn);
- survive_dce_list_t *nw = obstack_alloc(&sd->obst, sizeof(nw[0]));
+ survive_dce_list_t *nw = OALLOC(&sd->obst, survive_dce_list_t);
nw->next = curr;
nw->place = place;
if (called_irg != NULL) {
/* The Call node calls a locally defined method. Remember to inline. */
inline_env_t *ienv = env;
- call_entry *entry = obstack_alloc(&ienv->obst, sizeof(*entry));
+ call_entry *entry = OALLOC(&ienv->obst, call_entry);
entry->call = call;
entry->callee = called_irg;
entry->loop_depth = 0;
* Allocate a new environment for inlining.
*/
static inline_irg_env *alloc_inline_irg_env(void) {
- inline_irg_env *env = obstack_alloc(&temp_obst, sizeof(*env));
+ inline_irg_env *env = OALLOC(&temp_obst, inline_irg_env);
INIT_LIST_HEAD(&env->calls);
env->local_weights = NULL;
env->n_nodes = -2; /* do not count count Start, End */
x->recursive = 1;
/* link it in the list of possible inlinable entries */
- entry = obstack_alloc(&temp_obst, sizeof(*entry));
+ entry = OALLOC(&temp_obst, call_entry);
entry->call = call;
entry->callee = callee;
entry->loop_depth = get_irn_loop(get_nodes_block(call))->depth;
*/
static call_entry *duplicate_call_entry(const call_entry *entry,
ir_node *new_call, int loop_depth_delta) {
- call_entry *nentry = obstack_alloc(&temp_obst, sizeof(*nentry));
+ call_entry *nentry = OALLOC(&temp_obst, call_entry);
nentry->call = new_call;
nentry->callee = entry->callee;
nentry->benefice = entry->benefice;
if (entry == NULL) {
/* new address */
- entry = obstack_alloc(&env.obst, sizeof(*entry));
+ entry = OALLOC(&env.obst, address_entry);
entry->id = env.curr_adr_id++;
ir_nodemap_insert(&env.adr_map, adr, entry);
(void)ctx;
if (is_Block(irn)) {
- block_t *entry = obstack_alloc(&env.obst, sizeof(*entry));
+ block_t *entry = OALLOC(&env.obst, block_t);
int n;
entry->memop_forward = NULL;
* @return the allocated memop
*/
static memop_t *alloc_memop(ir_node *irn) {
- memop_t *m = obstack_alloc(&env.obst, sizeof(*m));
+ memop_t *m = OALLOC(&env.obst, memop_t);
m->value.address = NULL;
m->value.value = NULL;
* @param phi the Phi-node representing the new value
*/
static memop_t *clone_memop_phi(memop_t *op, ir_node *phi) {
- memop_t *m = obstack_alloc(&env.obst, sizeof(*m));
+ memop_t *m = OALLOC(&env.obst, memop_t);
m->value = op->value;
m->value.value = phi;
if (bl->trans_results == NULL) {
/* allocate the translate cache */
- unsigned size = env.curr_adr_id * sizeof(bl->trans_results[0]);
- bl->trans_results = obstack_alloc(&env.obst, size);
- memset(bl->trans_results, 0, size);
+ bl->trans_results = OALLOCNZ(&env.obst, memop_t*, env.curr_adr_id);
}
/* check for partly redundant values */
node_entry *e = get_irn_link(irn);
if (e == NULL) {
- e = obstack_alloc(&env->obst, sizeof(*e));
- memset(e, 0, sizeof(*e));
+ e = OALLOCZ(&env->obst, node_entry);
set_irn_link(irn, e);
}
return e;
exchange(irn, result);
e = get_irn_ne(result, env);
if (e->pscc == NULL) {
- e->pscc = obstack_alloc(&env->obst, sizeof(*e->pscc));
- memset(e->pscc, 0, sizeof(*e->pscc));
+ e->pscc = OALLOCZ(&env->obst, scc);
update_scc(result, e, env);
}
++env->replaced;
node->low = MIN(o->DFSnum, node->low);
}
if (node->low == node->DFSnum) {
- scc *pscc = obstack_alloc(&env->obst, sizeof(*pscc));
+ scc *pscc = OALLOCZ(&env->obst, scc);
ir_node *x;
- memset(pscc, 0, sizeof(*pscc));
do {
node_entry *e;
if (! hmap->map)
hmap->map = new_pset(entry_cmp, 8);
- key = obstack_alloc(&hmap->obst, sizeof(*key));
+ key = OALLOC(&hmap->obst, entry_t);
key->q.ent = callee;
key->q.pos = i;
* Allocate a new DAG entry.
*/
static dag_entry_t *new_dag_entry(dag_env_t *dag_env, ir_node *node) {
- dag_entry_t *entry = obstack_alloc(&dag_env->obst, sizeof(*entry));
+ dag_entry_t *entry = OALLOC(&dag_env->obst, dag_entry_t);
entry->num_nodes = 1;
entry->num_roots = 1;
if (elem)
return elem;
- elem = obstack_alloc(&tbl->cnts, sizeof(*elem));
+ elem = OALLOC(&tbl->cnts, distrib_entry_t);
/* clear counter */
cnt_clr(&elem->cnt);
if (elem)
return elem;
- elem = obstack_alloc(&status->cnts, sizeof(*elem));
- memset(elem, 0, sizeof(*elem));
+ elem = OALLOCZ(&status->cnts, node_entry_t);
/* clear counter */
opcode_clear_entry(elem);
} /* if */
/* allocate a new one */
- elem = obstack_alloc(&status->cnts, sizeof(*elem));
- memset(elem, 0, sizeof(*elem));
+ elem = OALLOCZ(&status->cnts, graph_entry_t);
obstack_init(&elem->recalc_cnts);
/* clear counter */
if (elem)
return elem;
- elem = obstack_alloc(&status->cnts, sizeof(*elem));
- memset(elem, 0, sizeof(*elem));
+ elem = OALLOCZ(&status->cnts, opt_entry_t);
/* clear new counter */
opt_clear_entry(elem);
if (elem)
return elem;
- elem = obstack_alloc(obst, sizeof(*elem));
- memset(elem, 0, sizeof(*elem));
+ elem = OALLOCZ(obst, block_entry_t);
/* clear new counter */
block_clear_entry(elem);
if (elem)
return elem;
- elem = obstack_alloc(obst, sizeof(*elem));
- memset(elem, 0, sizeof(*elem));
+ elem = OALLOCZ(obst, be_block_entry_t);
/* clear new counter */
be_block_clear_entry(elem);
if (elem)
return elem;
- elem = obstack_alloc(obst, sizeof(*elem));
- memset(elem, 0, sizeof(*elem));
+ elem = OALLOCZ(obst, perm_class_entry_t);
/* clear new counter */
perm_class_clear_entry(elem);
if (elem)
return elem;
- elem = obstack_alloc(obst, sizeof(*elem));
- memset(elem, 0, sizeof(*elem));
+ elem = OALLOCZ(obst, perm_stat_entry_t);
/* clear new counter */
perm_stat_clear_entry(elem);
reg_pressure_entry_t *rp_ent;
block_ent = be_block_get_entry(&status->be_data, get_irn_node_nr(block), graph->be_block_hash);
- rp_ent = obstack_alloc(&status->be_data, sizeof(*rp_ent));
- memset(rp_ent, 0, sizeof(*rp_ent));
+ rp_ent = OALLOCZ(&status->be_data, reg_pressure_entry_t);
rp_ent->class_name = class_name;
rp_ent->pressure = pressure;
unsigned len = buf_lenght(buf);
unsigned hash;
- key = obstack_alloc(&status->obst, offsetof(pattern_entry_t, buf) + len);
- assert(key);
-
+ key = OALLOCF(&status->obst, pattern_entry_t, buf, len);
key->len = len;
memcpy(key->buf, buf_content(buf), len);
block_entry_t *entry = get_irn_link(block);
if (entry == NULL) {
- entry = obstack_alloc(&env->obst, sizeof(*entry));
+ entry = OALLOC(&env->obst, block_entry_t);
entry->live_ins = NEW_ARR_F(ir_node *, 0);
entry->live_outs = NEW_ARR_F(ir_node *, 0);
projects / libfirm / commitdiff