/* * ======== MessageQ_count ======== */ Int MessageQ_count(MessageQ_Handle handle) { Int count = 0; UInt key; List_Elem *tempMsg = NULL; List_Handle listHandle; ti_sdo_ipc_MessageQ_Object *obj = (ti_sdo_ipc_MessageQ_Object *)handle; /* lock */ key = Hwi_disable(); /* Get the list */ listHandle = ti_sdo_ipc_MessageQ_Instance_State_highList(obj); /* Loop through and count the messages */ while ((tempMsg = List_next(listHandle, tempMsg)) != NULL) { count++; } listHandle = ti_sdo_ipc_MessageQ_Instance_State_normalList(obj); /* Loop through and count the messages */ while ((tempMsg = List_next(listHandle, tempMsg)) != NULL) { count++; } /* unlock scheduler */ Hwi_restore(key); return (count); }
static int * get_exonlengths (int **exonmatches, int *nexons, List_T pairs, bool bysizep) { int *exonlengths; Intlist_T list = NULL, matchlist = NULL; Pair_T firstpair, pair; int querypos, nmatches = 0; #ifdef DEBUG int i; #endif firstpair = List_head(pairs); querypos = firstpair->querypos; while (pairs != NULL) { pair = List_head(pairs); if (pair->gapp == true && big_gap_p(pair,bysizep) == true) { list = Intlist_push(list,querypos-firstpair->querypos+1); matchlist = Intlist_push(matchlist,nmatches); pairs = List_next(pairs); if (pairs != NULL) { firstpair = List_head(pairs); querypos = firstpair->querypos; nmatches = 0; } } else { querypos = pair->querypos; if (pair->comp == MATCH_COMP || pair->comp == DYNPROG_MATCH_COMP) { nmatches++; } pairs = List_next(pairs); } } list = Intlist_push(list,querypos-firstpair->querypos+1); list = Intlist_reverse(list); matchlist = Intlist_push(matchlist,nmatches); matchlist = Intlist_reverse(matchlist); exonlengths = Intlist_to_array(&(*nexons),list); *exonmatches = Intlist_to_array(&(*nexons),matchlist); debug( printf("%d exons: ",*nexons); for (i = 0; i < *nexons; i++) { printf("%d (%d matches),",exonlengths[i],(*exonmatches)[i]); } printf("\n"); );
PSS_TarSCC PSS_Get_SCC (PSS_TarLoop tloop, Expr expr) { PSS_TarSCC scc; PSS_TarNode tnode; if (expr->opcode != OP_assign) { P_warn("Find_TarNode_Expr: searching for tnode for expr that is not OP_assign"); return NULL; } for (scc = tloop->sccs; scc; scc = scc->next) { if (scc->tnode_list == NULL) /* List might be empty */ continue; List_start (scc->tnode_list); while ((tnode = (PSS_TarNode) List_next(scc->tnode_list))) { if (expr == tnode->expr) return scc; } } return NULL; }
Int SystemCfg_detachHook(UArg userCtx, UInt16 remoteProcId) { Int status; List_Elem * elem = NULL; SystemCfg_Object * obj = NULL; IArg key; /* find object on module list */ key = GateH_enter(Mod_gate); while ((elem = List_next(Mod_objList, elem)) != NULL) { obj = (SystemCfg_Object *)elem; if (obj->remoteProcId == remoteProcId) { break; } obj = NULL; } GateH_leave(Mod_gate, key); if (obj != NULL) { status = Notify_unregisterEvent(remoteProcId, SystemCfg_NotifyLineId, SystemCfg_HostDspEvtNum, SystemCfg_notifyCB, (UArg)obj); if (status < 0) { Log_error1(FXNN": Notify_unregisterEvent() error %d", (IArg)status); } } return(status); }
static void SE_free_effects() { effect_t *effect; #if HISTORY IPA_HTAB_ITER iter; #endif #if HISTORY IPA_HTAB_START(iter, effect_htab); IPA_HTAB_LOOP(iter) { effect = IPA_HTAB_CUR(iter); free(effect); } IPA_htab_free(effect_htab); effect_htab = NULL; #else List_start(effect_hist); while ((effect = List_next(effect_hist))) { free(effect); } List_reset(effect_hist); effect_hist = NULL; #endif }
static int PD_ExprsMayAlias (Expr expr1, Expr expr2) { P_memdep_t md1, md2; List mem_obj_list1, mem_obj_list2; P_memdep_core_t mem_obj1, mem_obj2; if (!(md1 = P_GetMemDep (expr1)) || !(md2 = P_GetMemDep (expr2))) return 0; if (md1 == md2) return 1; mem_obj_list1 = md1->deps; mem_obj_list2 = md2->deps; List_start (mem_obj_list1); while ((mem_obj1 = List_next (mem_obj_list1))) { List_start (mem_obj_list2); while ((mem_obj2 = List_next (mem_obj_list2))) { if ((mem_obj1->id != mem_obj2->id) || (mem_obj1->version != mem_obj2->version)) continue; if (mem_obj1->size == -1 || mem_obj2->size == -1) { /* Sizes non-descriptive */ return 1; } else { int o1 = mem_obj1->offset, o2 = mem_obj2->offset, s1 = mem_obj1->size, s2 = mem_obj2->size; /* Determine if accesses overlap */ if ((o1 <= o2 && (o1 + s1) > o2) || (o2 < o1 && (o2 + s2) > o1)) return 1; } } } return 0; }
/** * Asteroid_update_list * Runs asteroid_update() on a list of asteroids with the given length. */ void Asteroid_update_list(List* asteroids, float screen_width) { List_start_iteration(asteroids); Asteroid* asteroid; while ((asteroid = (Asteroid*) List_next(asteroids))) { Asteroid_update(asteroid, screen_width); } }
/** * Asteroid_draw_list * Takes a list of asteroids and draws all of them. */ void Asteroid_draw_list(List* asteroids) { List_start_iteration(asteroids); Asteroid* asteroid; while ((asteroid = (Asteroid*) List_next(asteroids))) { Asteroid_draw(asteroid); } }
/*! * @brief Find a node inside the Translation Table which da matches * * @params da Device address * * @sa _SysLinkMemUtils_insertMapElement, _SysLinkMemUtils_removeMapElement */ static AddrNode * _SysLinkMemUtils_findNode (Ptr da) { AddrNode * node; GT_1trace (curTrace, GT_ENTER, "_SysLinkMemUtils_findNode", da); for (node = List_next (SysLinkMemUtils_module->addrTable, NULL); node != NULL; node = List_next (SysLinkMemUtils_module->addrTable, &node->elem)) { if (da == node->da) { break; } } GT_1trace (curTrace, GT_LEAVE, "_SysLinkMemUtils_findNode", node); return node; }
void Pairpool_free (T *old) { List_T p; struct Pair_T *pairptr; struct List_T *listcellptr; if (*old) { for (p = (*old)->pairchunks; p != NULL; p = List_next(p)) { pairptr = (struct Pair_T *) List_head(p); FREE(pairptr); } List_free(&(*old)->pairchunks); for (p = (*old)->listcellchunks; p != NULL; p = List_next(p)) { listcellptr = (struct List_T *) List_head(p); FREE(listcellptr); } List_free(&(*old)->listcellchunks); FREE(*old); } return; }
static int Pin_find_stack_size (VarList var_list) { int size = 0; VarDcl var; List_start (var_list); while ((var = (VarDcl) List_next (var_list))) size += PSI_GetTypeSize (var->type); return size; }
void Matchpool_free (T *old) { List_T p; struct Match_T *matchptr; struct List_T *listcellptr; if (*old) { for (p = (*old)->matchchunks; p != NULL; p = List_next(p)) { matchptr = (struct Match_T *) List_head(p); FREE(matchptr); } List_free(&(*old)->matchchunks); for (p = (*old)->listcellchunks; p != NULL; p = List_next(p)) { listcellptr = (struct List_T *) List_head(p); FREE(listcellptr); } List_free(&(*old)->listcellchunks); FREE(*old); } return; }
void Diagpool_free (T *old) { List_T p; struct Diag_T *diagptr; struct List_T *listcellptr; if (*old) { for (p = (*old)->diagchunks; p != NULL; p = List_next(p)) { diagptr = (struct Diag_T *) List_head(p); FREE(diagptr); } List_free(&(*old)->diagchunks); for (p = (*old)->listcellchunks; p != NULL; p = List_next(p)) { listcellptr = (struct List_T *) List_head(p); FREE(listcellptr); } List_free(&(*old)->listcellchunks); FREE(*old); } return; }
/* * ======== ti_sdo_ipc_Notify_execMany ======== */ Void ti_sdo_ipc_Notify_execMany(UInt16 procId, UInt16 lineId, UInt32 eventId, UArg arg, UInt32 payload) { ti_sdo_ipc_Notify_Object *obj = (ti_sdo_ipc_Notify_Object *)arg; List_Handle eventList; ti_sdo_ipc_Notify_EventListener *listener; /* Both loopback and the the event itself are enabled */ eventList = List_Object_get(obj->eventList, eventId); /* Use "NULL" to get the first EventListener on the list */ listener = (ti_sdo_ipc_Notify_EventListener *)List_next(eventList, NULL); while (listener != NULL) { /* Execute the callback function */ listener->callback.fnNotifyCbck(procId, lineId, eventId, listener->callback.cbckArg, payload); listener = (ti_sdo_ipc_Notify_EventListener *)List_next(eventList, (List_Elem *)listener); } }
void List_insertSorted(List list, void* ptr, List_compare ptrList_compare){ Node node, current; int beforeTail = 1; int isHead = 1; assert(list); node = Node_new(); if(node == NULL) return; node->ptr = ptr; if(list->current == NULL) { list->current = node; list->head = node; list->tail = node; return; } List_head(list); if(list->current->ptr == ptr) List_remove(list); while ((*ptrList_compare)(list->current->ptr, ptr) && beforeTail) { isHead = 0; beforeTail = List_next(list); if(list->current->ptr == ptr) List_remove(list); } current = list->current; list->size++; if(beforeTail){ node->next = current; if(isHead) list->head = node; else{ node->prev = current->prev; current->prev->next = node; } current->prev = node; } else{ current->next = node; node->prev = current; list->tail = node; } }
void PSS_PrintSCC(PSS_TarSCC scc) { PSS_TarNode tnode; fprintf(debug_file_id, "SCC (%d) - loop %d - func %s - type:", scc->id, scc->tloop->pcloop->ID, scc->tloop->cfg->func->name); PSS_PrintSCCType(debug_file_id, scc); fprintf(debug_file_id, "\n"); List_start(scc->tnode_list); while ((tnode = List_next(scc->tnode_list))) Print_TarNode(tnode); }
void DD_DependenceTest (FuncDcl func) { List expr_list; Expr expr1, expr2; /* * JWS: There is no reason to do this for the whole function at once. * Why not do it for one loop nest at a time? */ /* * Find all the expressions which access memory. The resulting list * is stored in expr_list. */ if (!(expr_list = FindAllExprWithMemAcc (func))) return; /* no expressions to examine */ if (DD_DEBUG_OMEGA) fprintf (stderr, "DD_DependenceTest func=%s\n", func->name); DD_Preprocess (func); initializeOmega (); /* do pairwise comparison between expressions which access memory. */ List_start (expr_list); while ((expr1 = List_first (expr_list))) { expr_list = List_delete_current (expr_list); while ((expr2 = List_next (expr_list))) { if ((PD_IsMemWriteExpr (expr1) || PD_IsMemWriteExpr (expr2)) && PD_ExprsMayAlias (expr1, expr2)) PD_produce_cyclic_sync_arc (expr1, expr2); } } expr_list = List_reset (expr_list); if (DD_DEBUG_OMEGA) DD_PrintFuncDepInfo (stderr, func); return; }
static int LB_mark_ncycle_regions(LB_TraceRegion_Header *header) { LB_TraceRegion *tr; int found = 0; List_start(header->traceregions); while ((tr = List_next(header->traceregions))) { Set tr_set = LB_return_cbs_region_as_set(tr); if (LB_hb_region_contains_cycle(tr_set, tr->header)) { tr->flags |= L_TRACEREGION_FLAG_NESTED_CYCLE; found++; } Set_dispose(tr_set); } return found; }
/*! \brief determine if an expression is part of an SCC in a given loop * * \param tloop * The Loop whose SCCs we want to search through * * \param expr * The Expression we want to search for. This can either be of type * OP_assign or OP_var * * \param type * The type of SCC that you want to search for. Use type ANY * if any type of SCC will do. You can also do | of different * types as PSS_TarSCC_Type is a bitfield * * \return * the linear SCC it is *first* found in or NULL if not found * * This routine searches through the SCC's in a tarloop and determines * if one of them (of type "type") contains the definition of the expression * "expr" that is passed to the function. If one is found, the scc is * returned. The expression can either be of type OP_assign or OP_var. * If an OP_assign is passed, it will be search for directly. If an * OP_var is passed, its SSA_Def will be found and that will be searched * for. If the expr is of a different type, a warning will go off and * NULL will be returned. */ static PSS_TarSCC Find_Expr_SCC(PSS_TarLoop tloop, Expr expr, PSS_TarSCC_Type type) { PSS_TarSCC scc; PSS_TarNode tnode; Expr search_expr; if (expr->opcode == OP_assign) { search_expr = expr; } else if (expr->opcode == OP_var && expr->value.var.ssa) { search_expr = expr->value.var.ssa->var->parentexpr; } else { P_warn ("Find_Expr_SCC: searching for expression that is not OP_var" " or OP_assign\n"); return NULL; } /* sanity check */ if (search_expr->opcode != OP_assign) P_punt("Find_Expr_SCC: search_expr should be of type OP_assign\n"); /* loop through the SCCs */ for (scc = tloop->sccs; scc; scc = scc->next) { if (scc->type & type) { /* loop through the SCC's expressions */ List_start(scc->tnode_list); while ((tnode = List_next(scc->tnode_list))) { if (tnode->expr == search_expr) { return scc; } } } } return NULL; }
void I_BDD_print_minterms (List mins, int terms) { char *minterm; int indx; List_start (mins); while ((minterm = (char *) List_next (mins))) { for (indx = 0; indx < terms; indx++) { if (minterm[indx] == 2) printf ("-"); else printf ("%d", (int) minterm[indx]); } printf ("\n"); } }
static void LB_clear_cb_visit_flags (L_Func * fn, LB_TraceRegion_Header * header) { L_Cb *cb; LB_TraceRegion *tr; /* Clear all the visited flags for all cbs */ for (cb = fn->first_cb; cb; cb = cb->next_cb) cb->flags = L_CLR_BIT_FLAG (cb->flags, L_CB_VISITED); List_start (header->traceregions); while ((tr = (LB_TraceRegion *) List_next (header->traceregions))) { Graph_dfs_topo_sort (tr->flow_graph); List_start (tr->flow_graph->topo_list); while ((cb = LB_next_cb_in_region (tr))) cb->flags = L_SET_BIT_FLAG (cb->flags, L_CB_VISITED); } return; }
Int SystemCfg_delete(SystemCfg_Object **objPtr) { Int bufSize; List_Elem * elem = NULL; SystemCfg_Object * obj; IArg key; Log_print0(Diags_ENTRY, "--> "FXNN": ()"); /* remove object from module list */ key = GateH_enter(Mod_gate); while ((elem = List_next(Mod_objList, elem)) != NULL) { obj = (SystemCfg_Object *)elem; if (obj == *objPtr) { List_remove(Mod_objList, elem); break; } } GateH_leave(Mod_gate, key); /* delete sync object */ if ((*objPtr)->semH != NULL) { Semaphore_destruct(&(*objPtr)->semObj); (*objPtr)->semH = NULL; } /* free the name buffer */ bufSize = strlen((*objPtr)->remoteProcName) + 1; xdc_runtime_Memory_free(NULL, (Ptr)((*objPtr)->remoteProcName), bufSize); /* free the object memory */ xdc_runtime_Memory_free(NULL, (Ptr)(*objPtr), sizeof(SystemCfg_Object)); *objPtr = NULL; Log_print1(Diags_EXIT, "<-- "FXNN": %d", (IArg)SystemCfg_S_SUCCESS); return(SystemCfg_S_SUCCESS); }
static void PD_print_mem_access (FILE * out_file, Expr expr) { P_memdep_t md; List mem_obj_list; P_memdep_core_t mem_obj; md = P_GetMemDep (expr); assert (md); mem_obj_list = md->deps; assert (List_size (mem_obj_list) > 0); fprintf (stderr, "%5s {(id, offset, size)} = { ", PD_IsMemWriteExpr (expr) ? "write" : "read"); List_start (mem_obj_list); while ((mem_obj = List_next (mem_obj_list))) fprintf (stderr, "(%5d,%5d,%5d) ", mem_obj->id, mem_obj->offset, mem_obj->size); fprintf (stderr, "}"); return; }
/* check for recursive includes, call error callback and return FALSE abort if found returns TRUE if callback not defined */ static Bool check_recursive_include( SrcFile *self, char *filename ) { ListElem *iter; FileStackElem *elem; if ( incl_recursion_err_cb != NULL ) { for ( iter = List_first( self->file_stack ) ; iter != NULL ; iter = List_next( iter ) ) { elem = iter->data; if ( elem->filename != NULL && strcmp( filename, elem->filename ) == 0 ) { incl_recursion_err_cb( filename ); return FALSE; } } } return TRUE; }
/*! \brief determine if geometric IV * * \param scc * SCC to check * * \return * 1 if classified * * SCC must be made up of additions and subtractions of loop invariants, * linear induction variables, and/or other polynomial IVs. SCC must contain * at least 1 multiplication of the sequence variable by a loop invariant. * Must contain exactly 1 mu node. */ static int Classify_Geometric(PSS_TarSCC scc) { #if 0 PSS_TarNode tnode; int arith_op, num_arith = 0; if (scc->mu_nodes != 1) return 0; /* loop through all the nodes in the SCC */ List_start(scc->tnode_list); while ((tnode = List_next(scc->tnode_list))) { arith_op = 0; if (!Geom_Expr_Test(scc, tnode->expr, &arith_op)) return 0; num_arith += (arith_op ? 1 : 0); } if (num_arith == 0) return 0; if (scc->phi_nodes == 0) { scc->type = GEOMETRIC; STATS.scc_type.geometric++; } else { scc->type = GEOMETRIC_MONOTONIC; STATS.scc_type.geometric_monotonic++; } PSS_PrintSCC(scc); return 1; #else return 0; #endif }
void IPA_funcsymbol_free (IPA_prog_info_t * info, IPA_funcsymbol_info_t * fninfo) { IPA_callsite_t *cs; IPA_interface_free (fninfo->iface); /*List_reset(fninfo->tmp_var_ids); */ List_start (fninfo->callsites); while ((cs = List_next (fninfo->callsites))) { IPA_callsite_free (info, cs); } List_reset (fninfo->callsites); /* Remove from info list */ info->fninfos = List_remove (info->fninfos, fninfo); IPA_cg_cgraph_free (fninfo->consg); if (fninfo->lsum_consg != fninfo->consg) IPA_cg_cgraph_free (fninfo->lsum_consg); { IPA_summary_info_t *sum_info; IPA_summary_info_t *nxt_info; for (sum_info = fninfo->sum_info; sum_info; sum_info = nxt_info) { nxt_info = sum_info->nxt; List_reset(sum_info->sum_nodes); free(sum_info); } fninfo->sum_info = NULL; } free (fninfo); }
/*! \brief determine if linear IV * * \param scc * SCC to check * * \return * 1 if classified * * SCC must be made up of additions and subtractoins of loop invariants * and / or other linear induction variables * * SCC must contain exactly 1 mu node * * SCC must contain 0 phi nodes or be classified as monotonic */ static int Classify_Linear(PSS_TarSCC scc) { PSS_TarNode tnode; int arith_op, num_arith = 0; if (scc->mu_nodes != 1) return 0; /* loop through all the nodes in the SCC */ List_start(scc->tnode_list); while ((tnode = List_next(scc->tnode_list))) { arith_op = 0; if (!Linear_Expr_Test(scc, tnode->expr, &arith_op)) return 0; num_arith += (arith_op ? 1 : 0); } /* If there are no arithmetic ops, can't be linear. */ if (num_arith == 0) return 0; if (scc->phi_nodes == 0) { scc->type = LINEAR; STATS.scc_type.linear++; } else { scc->type = LINEAR_MONOTONIC; STATS.scc_type.linear_monotonic++; } PSS_PrintSCC(scc); return 1; }
/*! \brief determine if pointer IV * * \param scc * SCC to check * * \return * 1 if classified * * SCC must be made up of additions and subtractions of loop invariants, * linear induction variables, and an OP_arrow */ static int Classify_Pointer(PSS_TarSCC scc) { PSS_TarNode tnode; int pointer_op, num_pointer = 0; if (scc->mu_nodes != 1) return 0; /* loop through all the nodes in the SCC */ List_start(scc->tnode_list); while ((tnode = List_next(scc->tnode_list))) { pointer_op = 0; if (!Pointer_Expr_Test(scc, tnode->expr, &pointer_op)) return 0; num_pointer += (pointer_op ? 1 : 0); } if (num_pointer == 0) return 0; if (scc->phi_nodes == 0) { scc->type = POINTER; STATS.scc_type.pointer++; } else { scc->type = POINTER_MONOTONIC; STATS.scc_type.pointer_monotonic++; } PSS_PrintSCC(scc); return 1; }
/*! \brief determine if polynomial IV * * \param scc * SCC to check * * \return * 1 if classified * * SCC must be made up of additions and subtractions of loop invariants, * linear induction variables, and/or other polynomial IVs. Must contain * exactly 1 mu node. */ static int Classify_Polynomial(PSS_TarSCC scc) { PSS_TarNode tnode; int arith_op, num_arith = 0; if (scc->mu_nodes != 1) return 0; /* loop through all the nodes in the SCC */ List_start(scc->tnode_list); while ((tnode = List_next(scc->tnode_list))) { arith_op = 0; if (!Poly_Expr_Test(scc, tnode->expr, &arith_op)) return 0; num_arith += (arith_op ? 1 : 0); } if (num_arith == 0) return 0; if (scc->phi_nodes == 0) { scc->type = POLYNOMIAL; STATS.scc_type.polynomial++; } else { scc->type = POLYNOMIAL_MONOTONIC; STATS.scc_type.polynomial_monotonic++; } PSS_PrintSCC(scc); return 1; }
void LB_superblock_formation (L_Func * fn) { LB_TraceRegion_Header *header; LB_TraceRegion *tr_index; Heap *tr_heap; int list_size, i, code_size = 0, max_code_size, growth, do_frp; if (fn->n_cb == 0) return; do_frp = !strcmp (LB_predicate_formation_type, "frp"); header = LB_function_init (fn); L_partial_dead_code_removal (fn); L_do_flow_analysis (fn, DOMINATOR_CB|SUPPRESS_PG); L_loop_detection (fn, 0); L_compute_oper_weight (fn, 0, 1); LB_convert_to_strict_basic_block_code (fn, L_CB_SUPERBLOCK | L_CB_HYPERBLOCK | L_CB_ENTRANCE_BOUNDARY | L_CB_EXIT_BOUNDARY); L_do_flow_analysis (fn, DOMINATOR_CB); L_compute_oper_weight (fn, 0, 1); LB_mark_jrg_flag (fn); LB_make_traceregions (fn, TRUE, header); LB_order_traceregions (fn, header); LB_layout_function (fn, header); tr_heap = Heap_Create (HEAP_MAX); List_start (header->traceregions); while ((tr_index = (LB_TraceRegion *) List_next (header->traceregions))) { code_size += LB_traceregion_code_size (tr_index); Graph_dfs_topo_sort (tr_index->flow_graph); if ((tr_index->weight >= LB_minimum_superblock_weight) && !(tr_index->flags & (L_TRACEREGION_HYPERBLOCK | L_TRACEREGION_SUPERBLOCK)) && (tr_index->header != LB_last_cb_in_region (tr_index))) Heap_Insert (tr_heap, tr_index, tr_index->weight); } max_code_size = (int) (LB_maximum_code_growth * code_size); LB_predicate_init (); while ((tr_heap->size > 0) && (code_size < max_code_size)) { tr_index = (LB_TraceRegion *) Heap_ExtractTop (tr_heap); growth = LB_tail_duplication (fn, tr_index, LB_DUP_INSIDE_REGION, 1); if ((code_size + growth) > max_code_size) continue; code_size += LB_tail_duplication (fn, tr_index, LB_DUP_INSIDE_REGION, 0); LB_predicate_traceregion (fn, tr_index, do_frp); L_set_hb_no_fallthru_flag (fn); L_check_func (fn); tr_index->flags |= L_TRACEREGION_SUPERBLOCK; L_rebuild_src_flow (fn); LB_mark_jrg_flag (fn); /* Make traces with the new end cb's */ list_size = List_size (header->traceregions); LB_make_traceregions (fn, FALSE, header); LB_order_traceregions (fn, header); LB_layout_function (fn, header); i = 0; while ((tr_index = (LB_TraceRegion *) List_next (header->traceregions))) { if (++i <= list_size) continue; Graph_dfs_topo_sort (tr_index->flow_graph); if ((tr_index->weight >= LB_minimum_superblock_weight) && !(tr_index->flags & (L_TRACEREGION_HYPERBLOCK | L_TRACEREGION_SUPERBLOCK)) && (tr_index->header != LB_last_cb_in_region (tr_index))) Heap_Insert (tr_heap, tr_index, tr_index->weight); } } tr_heap = Heap_Dispose (tr_heap, NULL); LB_predicate_deinit (fn); fn->flags = L_SET_BIT_FLAG (fn->flags, L_FUNC_SUPERBLOCK); L_rebuild_src_flow (fn); if (do_frp || LB_hb_do_combine_exits) { L_create_uncond_pred_defines (fn); L_combine_pred_defines (fn); } /* For each source code function we process deinit */ LB_function_deinit (header); return; }