Home | History | Annotate | Download | only in compiler

Lines Matching refs:block

40    bblock_t *block = link->block;
43    return block;
47 link(void *mem_ctx, bblock_t *block)
49    bblock_link *l = new(mem_ctx) bblock_link(block);
69 bblock_t::is_predecessor_of(const bblock_t *block) const
71    foreach_list_typed_safe (bblock_link, parent, link, &block->parents) {
72       if (parent->block == this) {
81 bblock_t::is_successor_of(const bblock_t *block) const
83    foreach_list_typed_safe (bblock_link, child, link, &block->children) {
84       if (child->block == this) {
132       assert(link->block == this);
195 	 /* Set up our immediately following block, full of "then"
218             /* New block was just created; use it. */
252 	 /* Set up the block just after the while.  Don't know when exactly
258             /* New block was just created; use it. */
392 cfg_t::remove_block(bblock_t *block)
394    foreach_list_typed_safe (bblock_link, predecessor, link, &block->parents) {
395       /* Remove block from all of its predecessors' successor lists. */
397                                &predecessor->block->children) {
398          if (block == successor->block) {
404       /* Add removed-block's successors to its predecessors' successor lists. */
405       foreach_list_typed (bblock_link, successor, link, &block->children) {
406          if (!successor->block->is_successor_of(predecessor->block)) {
407             predecessor->block->children.push_tail(link(mem_ctx,
408                                                         successor->block));
413    foreach_list_typed_safe (bblock_link, successor, link, &block->children) {
414       /* Remove block from all of its childrens' parents lists. */
416                                &successor->block->parents) {
417          if (block == predecessor->block) {
423       /* Add removed-block's predecessors to its successors' predecessor lists. */
424       foreach_list_typed (bblock_link, predecessor, link, &block->parents) {
425          if (!predecessor->block->is_predecessor_of(successor->block)) {
426             successor->block->parents.push_tail(link(mem_ctx,
427                                                      predecessor->block));
432    block->link.remove();
434    for (int b = block->num; b < this->num_blocks - 1; b++) {
447    bblock_t *block = new(mem_ctx) bblock_t(this);
449    return block;
453 cfg_t::set_next_block(bblock_t **cur, bblock_t *block, int ip)
459    block->start_ip = ip;
460    block->num = num_blocks++;
461    block_list.push_tail(&block->link);
462    *cur = block;
471    foreach_block (block, this) {
472       blocks[i++] = block;
483    foreach_block (block, this) {
484       if (block->idom)
485          fprintf(stderr, "START B%d IDOM(B%d)", block->num, block->idom->num);
487          fprintf(stderr, "START B%d IDOM(none)", block->num);
489       foreach_list_typed(bblock_link, link, link, &block->parents) {
491                  link->block->num);
495          block->dump(s);
496       fprintf(stderr, "END B%d", block->num);
497       foreach_list_typed(bblock_link, link, link, &block->children) {
499                  link->block->num);
505 /* Calculates the immediate dominator of each block, according to "A Simple,
516    foreach_block(block, this) {
517       block->idom = NULL;
525       foreach_block(block, this) {
526          if (block->num == 0)
530          foreach_list_typed(bblock_link, parent, link, &block->parents) {
531             if (parent->block->idom) {
533                   new_idom = parent->block;
534                } else if (parent->block->idom != NULL) {
535                   new_idom = intersect(parent->block, new_idom);
540          if (block->idom != new_idom) {
541             block
572       bblock_t *block = this->blocks[b];
574       foreach_list_typed_safe (bblock_link, child, link, &block->children) {
575          printf("\t%d -> %d\n", b, child->block->num);
585    foreach_block(block, this) {
586       if (block->idom) {
587          printf("\t%d -> %d\n", block->idom->num, block->num);