## Coverage Report

#### Created: 2019-07-24 05:18

`/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/polly/lib/External/isl/isl_tab_lexopt_templ.c`
`Line`
`Count`
`Source (jump to first uncovered line)`
`1`
`/*`
`2`
` * Copyright 2008-2009 Katholieke Universiteit Leuven`
`3`
` * Copyright 2010      INRIA Saclay`
`4`
` * Copyright 2011      Sven Verdoolaege`
`5`
` *`
`6`
` * Use of this software is governed by the MIT license`
`7`
` *`
`8`
` * Written by Sven Verdoolaege, K.U.Leuven, Departement`
`9`
` * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium`
`10`
` * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,`
`11`
` * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France`
`12`
` */`
`13`
`14`
`16.1k`
`#define xSF(TYPE,SUFFIX) TYPE ## SUFFIX`
`15`
`16.1k`
`#define SF(TYPE,SUFFIX) xSF(TYPE,SUFFIX)`
`16`
`17`
`/* Given a basic map with at least two parallel constraints (as found`
`18`
` * by the function parallel_constraints), first look for more constraints`
`19`
` * parallel to the two constraint and replace the found list of parallel`
`20`
` * constraints by a single constraint with as "input" part the minimum`
`21`
` * of the input parts of the list of constraints.  Then, recursively call`
`22`
` * basic_map_partial_lexopt (possibly finding more parallel constraints)`
`23`
` * and plug in the definition of the minimum in the result.`
`24`
` *`
`25`
` * As in parallel_constraints, only inequality constraints that only`
`26`
` * involve input variables that do not occur in any other inequality`
`27`
` * constraints are considered.`
`28`
` *`
`29`
` * More specifically, given a set of constraints`
`30`
` *`
`31`
` *  a x + b_i(p) >= 0`
`32`
` *`
`33`
` * Replace this set by a single constraint`
`34`
` *`
`35`
` *  a x + u >= 0`
`36`
` *`
`37`
` * with u a new parameter with constraints`
`38`
` *`
`39`
` *  u <= b_i(p)`
`40`
` *`
`41`
` * Any solution to the new system is also a solution for the original system`
`42`
` * since`
`43`
` *`
`44`
` *  a x >= -u >= -b_i(p)`
`45`
` *`
`46`
` * Moreover, m = min_i(b_i(p)) satisfies the constraints on u and can`
`47`
` * therefore be plugged into the solution.`
`48`
` */`
`49`
`static TYPE *SF(basic_map_partial_lexopt_symm,SUFFIX)(`
`50`
`  __isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,`
`51`
`  __isl_give isl_set **empty, int max, int first, int second)`
`52`
`238`
`{`
`53`
`238`
`  int i, n, k;`
`54`
`238`
`  int *list = NULL;`
`55`
`238`
`  unsigned n_in, n_out, n_div;`
`56`
`238`
`  isl_ctx *ctx;`
`57`
`238`
`  isl_vec *var = NULL;`
`58`
`238`
`  isl_mat *cst = NULL;`
`59`
`238`
`  isl_space *map_space, *set_space;`
`60`
`238`
`61`
`238`
`  map_space = isl_basic_map_get_space(bmap);`
`62`
`238`
`  set_space = empty ? isl_basic_set_get_space(dom)6 : NULL;`
`63`
`238`
`64`
`238`
`  n_in = isl_basic_map_dim(bmap, isl_dim_param) +`
`65`
`238`
`         isl_basic_map_dim(bmap, isl_dim_in);`
`66`
`238`
`  n_out = isl_basic_map_dim(bmap, isl_dim_all) - n_in;`
`67`
`238`
`68`
`238`
`  ctx = isl_basic_map_get_ctx(bmap);`
`69`
`238`
`  list = isl_alloc_array(ctx, int, bmap->n_ineq);`
`70`
`238`
`  var = isl_vec_alloc(ctx, n_out);`
`71`
`238`
`  if ((bmap->n_ineq && !list) || (n_out && !var))`
`72`
`0`
`    goto error;`
`73`
`238`
`74`
`238`
`  list[0] = first;`
`75`
`238`
`  list[1] = second;`
`76`
`238`
`  isl_seq_cpy(var->el, bmap->ineq[first] + 1 + n_in, n_out);`
`77`
`462`
`  for (i = second + 1, n = 2; i < bmap->n_ineq; ++i224) {`
`78`
`224`
`    if (isl_seq_eq(var->el, bmap->ineq[i] + 1 + n_in, n_out) &&`
`79`
`224`
`        all_single_occurrence(bmap, i, n_in)3)`
`80`
`0`
`      list[n++] = i;`
`81`
`224`
`  }`
`82`
`238`
`83`
`238`
`  cst = isl_mat_alloc(ctx, n, 1 + n_in);`
`84`
`238`
`  if (!cst)`
`85`
`0`
`    goto error;`
`86`
`238`
`87`
`714`
`  for (i = 0; 238i < n; ++i476)`
`88`
`476`
`    isl_seq_cpy(cst->row[i], bmap->ineq[list[i]], 1 + n_in);`
`89`
`238`
`90`
`238`
`  bmap = isl_basic_map_cow(bmap);`
`91`
`238`
`  if (!bmap)`
`92`
`0`
`    goto error;`
`93`
`714`
`  for (i = n - 1; 238i >= 0; --i476)`
`94`
`476`
`    if (isl_basic_map_drop_inequality(bmap, list[i]) < 0)`
`95`
`0`
`      goto error;`
`96`
`238`
`97`
`238`
`  bmap = isl_basic_map_add_dims(bmap, isl_dim_in, 1);`
`98`
`238`
`  bmap = isl_basic_map_extend_constraints(bmap, 0, 1);`
`99`
`238`
`  k = isl_basic_map_alloc_inequality(bmap);`
`100`
`238`
`  if (k < 0)`
`101`
`0`
`    goto error;`
`102`
`238`
`  isl_seq_clr(bmap->ineq[k], 1 + n_in);`
`103`
`238`
`  isl_int_set_si(bmap->ineq[k][1 + n_in], 1);`
`104`
`238`
`  isl_seq_cpy(bmap->ineq[k] + 1 + n_in + 1, var->el, n_out);`
`105`
`238`
`  bmap = isl_basic_map_finalize(bmap);`
`106`
`238`
`107`
`238`
`  n_div = isl_basic_set_dim(dom, isl_dim_div);`
`108`
`238`
`  dom = isl_basic_set_add_dims(dom, isl_dim_set, 1);`
`109`
`238`
`  dom = isl_basic_set_extend_constraints(dom, 0, n);`
`110`
`714`
`  for (i = 0; i < n; ++i476) {`
`111`
`476`
`    k = isl_basic_set_alloc_inequality(dom);`
`112`
`476`
`    if (k < 0)`
`113`
`0`
`      goto error;`
`114`
`476`
`    isl_seq_cpy(dom->ineq[k], cst->row[i], 1 + n_in);`
`115`
`476`
`    isl_int_set_si(dom->ineq[k][1 + n_in], -1);`
`116`
`476`
`    isl_seq_clr(dom->ineq[k] + 1 + n_in + 1, n_div);`
`117`
`476`
`  }`
`118`
`238`
`119`
`238`
`  isl_vec_free(var);`
`120`
`238`
`  free(list);`
`121`
`238`
`122`
`238`
`  return SF(basic_map_partial_lexopt_symm_core,SUFFIX)(bmap, dom, empty,`
`123`
`238`
`            max, cst, map_space, set_space);`
`124`
`238`
`error:`
`125`
`0`
`  isl_space_free(map_space);`
`126`
`0`
`  isl_space_free(set_space);`
`127`
`0`
`  isl_mat_free(cst);`
`128`
`0`
`  isl_vec_free(var);`
`129`
`0`
`  free(list);`
`130`
`0`
`  isl_basic_set_free(dom);`
`131`
`0`
`  isl_basic_map_free(bmap);`
`132`
`0`
`  return NULL;`
`133`
`238`
`}`
`isl_tab_pip.c:basic_map_partial_lexopt_symm`
 `Line` `Count` `Source` `52` `55` `{` `53` `55` ` int i, n, k;` `54` `55` ` int *list = NULL;` `55` `55` ` unsigned n_in, n_out, n_div;` `56` `55` ` isl_ctx *ctx;` `57` `55` ` isl_vec *var = NULL;` `58` `55` ` isl_mat *cst = NULL;` `59` `55` ` isl_space *map_space, *set_space;` `60` `55` `61` `55` ` map_space = isl_basic_map_get_space(bmap);` `62` `55` ` set_space = empty ? isl_basic_set_get_space(dom)6 : NULL;` `63` `55` `64` `55` ` n_in = isl_basic_map_dim(bmap, isl_dim_param) +` `65` `55` ` isl_basic_map_dim(bmap, isl_dim_in);` `66` `55` ` n_out = isl_basic_map_dim(bmap, isl_dim_all) - n_in;` `67` `55` `68` `55` ` ctx = isl_basic_map_get_ctx(bmap);` `69` `55` ` list = isl_alloc_array(ctx, int, bmap->n_ineq);` `70` `55` ` var = isl_vec_alloc(ctx, n_out);` `71` `55` ` if ((bmap->n_ineq && !list) || (n_out && !var))` `72` `0` ` goto error;` `73` `55` `74` `55` ` list[0] = first;` `75` `55` ` list[1] = second;` `76` `55` ` isl_seq_cpy(var->el, bmap->ineq[first] + 1 + n_in, n_out);` `77` `135` ` for (i = second + 1, n = 2; i < bmap->n_ineq; ++i80) {` `78` `80` ` if (isl_seq_eq(var->el, bmap->ineq[i] + 1 + n_in, n_out) &&` `79` `80` ` all_single_occurrence(bmap, i, n_in)0)` `80` `0` ` list[n++] = i;` `81` `80` ` }` `82` `55` `83` `55` ` cst = isl_mat_alloc(ctx, n, 1 + n_in);` `84` `55` ` if (!cst)` `85` `0` ` goto error;` `86` `55` `87` `165` ` for (i = 0; 55i < n; ++i110)` `88` `110` ` isl_seq_cpy(cst->row[i], bmap->ineq[list[i]], 1 + n_in);` `89` `55` `90` `55` ` bmap = isl_basic_map_cow(bmap);` `91` `55` ` if (!bmap)` `92` `0` ` goto error;` `93` `165` ` for (i = n - 1; 55i >= 0; --i110)` `94` `110` ` if (isl_basic_map_drop_inequality(bmap, list[i]) < 0)` `95` `0` ` goto error;` `96` `55` `97` `55` ` bmap = isl_basic_map_add_dims(bmap, isl_dim_in, 1);` `98` `55` ` bmap = isl_basic_map_extend_constraints(bmap, 0, 1);` `99` `55` ` k = isl_basic_map_alloc_inequality(bmap);` `100` `55` ` if (k < 0)` `101` `0` ` goto error;` `102` `55` ` isl_seq_clr(bmap->ineq[k], 1 + n_in);` `103` `55` ` isl_int_set_si(bmap->ineq[k][1 + n_in], 1);` `104` `55` ` isl_seq_cpy(bmap->ineq[k] + 1 + n_in + 1, var->el, n_out);` `105` `55` ` bmap = isl_basic_map_finalize(bmap);` `106` `55` `107` `55` ` n_div = isl_basic_set_dim(dom, isl_dim_div);` `108` `55` ` dom = isl_basic_set_add_dims(dom, isl_dim_set, 1);` `109` `55` ` dom = isl_basic_set_extend_constraints(dom, 0, n);` `110` `165` ` for (i = 0; i < n; ++i110) {` `111` `110` ` k = isl_basic_set_alloc_inequality(dom);` `112` `110` ` if (k < 0)` `113` `0` ` goto error;` `114` `110` ` isl_seq_cpy(dom->ineq[k], cst->row[i], 1 + n_in);` `115` `110` ` isl_int_set_si(dom->ineq[k][1 + n_in], -1);` `116` `110` ` isl_seq_clr(dom->ineq[k] + 1 + n_in + 1, n_div);` `117` `110` ` }` `118` `55` `119` `55` ` isl_vec_free(var);` `120` `55` ` free(list);` `121` `55` `122` `55` ` return SF(basic_map_partial_lexopt_symm_core,SUFFIX)(bmap, dom, empty,` `123` `55` ` max, cst, map_space, set_space);` `124` `55` `error:` `125` `0` ` isl_space_free(map_space);` `126` `0` ` isl_space_free(set_space);` `127` `0` ` isl_mat_free(cst);` `128` `0` ` isl_vec_free(var);` `129` `0` ` free(list);` `130` `0` ` isl_basic_set_free(dom);` `131` `0` ` isl_basic_map_free(bmap);` `132` `0` ` return NULL;` `133` `55` `}`
`isl_tab_pip.c:basic_map_partial_lexopt_symm_pw_multi_aff`
 `Line` `Count` `Source` `52` `183` `{` `53` `183` ` int i, n, k;` `54` `183` ` int *list = NULL;` `55` `183` ` unsigned n_in, n_out, n_div;` `56` `183` ` isl_ctx *ctx;` `57` `183` ` isl_vec *var = NULL;` `58` `183` ` isl_mat *cst = NULL;` `59` `183` ` isl_space *map_space, *set_space;` `60` `183` `61` `183` ` map_space = isl_basic_map_get_space(bmap);` `62` `183` ` set_space = empty ? isl_basic_set_get_space(dom)0 : NULL;` `63` `183` `64` `183` ` n_in = isl_basic_map_dim(bmap, isl_dim_param) +` `65` `183` ` isl_basic_map_dim(bmap, isl_dim_in);` `66` `183` ` n_out = isl_basic_map_dim(bmap, isl_dim_all) - n_in;` `67` `183` `68` `183` ` ctx = isl_basic_map_get_ctx(bmap);` `69` `183` ` list = isl_alloc_array(ctx, int, bmap->n_ineq);` `70` `183` ` var = isl_vec_alloc(ctx, n_out);` `71` `183` ` if ((bmap->n_ineq && !list) || (n_out && !var))` `72` `0` ` goto error;` `73` `183` `74` `183` ` list[0] = first;` `75` `183` ` list[1] = second;` `76` `183` ` isl_seq_cpy(var->el, bmap->ineq[first] + 1 + n_in, n_out);` `77` `327` ` for (i = second + 1, n = 2; i < bmap->n_ineq; ++i144) {` `78` `144` ` if (isl_seq_eq(var->el, bmap->ineq[i] + 1 + n_in, n_out) &&` `79` `144` ` all_single_occurrence(bmap, i, n_in)3)` `80` `0` ` list[n++] = i;` `81` `144` ` }` `82` `183` `83` `183` ` cst = isl_mat_alloc(ctx, n, 1 + n_in);` `84` `183` ` if (!cst)` `85` `0` ` goto error;` `86` `183` `87` `549` ` for (i = 0; 183i < n; ++i366)` `88` `366` ` isl_seq_cpy(cst->row[i], bmap->ineq[list[i]], 1 + n_in);` `89` `183` `90` `183` ` bmap = isl_basic_map_cow(bmap);` `91` `183` ` if (!bmap)` `92` `0` ` goto error;` `93` `549` ` for (i = n - 1; 183i >= 0; --i366)` `94` `366` ` if (isl_basic_map_drop_inequality(bmap, list[i]) < 0)` `95` `0` ` goto error;` `96` `183` `97` `183` ` bmap = isl_basic_map_add_dims(bmap, isl_dim_in, 1);` `98` `183` ` bmap = isl_basic_map_extend_constraints(bmap, 0, 1);` `99` `183` ` k = isl_basic_map_alloc_inequality(bmap);` `100` `183` ` if (k < 0)` `101` `0` ` goto error;` `102` `183` ` isl_seq_clr(bmap->ineq[k], 1 + n_in);` `103` `183` ` isl_int_set_si(bmap->ineq[k][1 + n_in], 1);` `104` `183` ` isl_seq_cpy(bmap->ineq[k] + 1 + n_in + 1, var->el, n_out);` `105` `183` ` bmap = isl_basic_map_finalize(bmap);` `106` `183` `107` `183` ` n_div = isl_basic_set_dim(dom, isl_dim_div);` `108` `183` ` dom = isl_basic_set_add_dims(dom, isl_dim_set, 1);` `109` `183` ` dom = isl_basic_set_extend_constraints(dom, 0, n);` `110` `549` ` for (i = 0; i < n; ++i366) {` `111` `366` ` k = isl_basic_set_alloc_inequality(dom);` `112` `366` ` if (k < 0)` `113` `0` ` goto error;` `114` `366` ` isl_seq_cpy(dom->ineq[k], cst->row[i], 1 + n_in);` `115` `366` ` isl_int_set_si(dom->ineq[k][1 + n_in], -1);` `116` `366` ` isl_seq_clr(dom->ineq[k] + 1 + n_in + 1, n_div);` `117` `366` ` }` `118` `183` `119` `183` ` isl_vec_free(var);` `120` `183` ` free(list);` `121` `183` `122` `183` ` return SF(basic_map_partial_lexopt_symm_core,SUFFIX)(bmap, dom, empty,` `123` `183` ` max, cst, map_space, set_space);` `124` `183` `error:` `125` `0` ` isl_space_free(map_space);` `126` `0` ` isl_space_free(set_space);` `127` `0` ` isl_mat_free(cst);` `128` `0` ` isl_vec_free(var);` `129` `0` ` free(list);` `130` `0` ` isl_basic_set_free(dom);` `131` `0` ` isl_basic_map_free(bmap);` `132` `0` ` return NULL;` `133` `183` `}`
`134`
`135`
`/* Recursive part of isl_tab_basic_map_partial_lexopt*, after detecting`
`136`
` * equalities and removing redundant constraints.`
`137`
` *`
`138`
` * We first check if there are any parallel constraints (left).`
`139`
` * If not, we are in the base case.`
`140`
` * If there are parallel constraints, we replace them by a single`
`141`
` * constraint in basic_map_partial_lexopt_symm_pma and then call`
`142`
` * this function recursively to look for more parallel constraints.`
`143`
` */`
`144`
`static __isl_give TYPE *SF(basic_map_partial_lexopt,SUFFIX)(`
`145`
`  __isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,`
`146`
`  __isl_give isl_set **empty, int max)`
`147`
`8.09k`
`{`
`148`
`8.09k`
`  isl_bool par = isl_bool_false;`
`149`
`8.09k`
`  int first, second;`
`150`
`8.09k`
`151`
`8.09k`
`  if (!bmap)`
`152`
`0`
`    goto error;`
`153`
`8.09k`
`154`
`8.09k`
`  if (bmap->ctx->opt->pip_symmetry)`
`155`
`8.09k`
`    par = parallel_constraints(bmap, &first, &second);`
`156`
`8.09k`
`  if (par < 0)`
`157`
`0`
`    goto error;`
`158`
`8.09k`
`  if (!par)`
`159`
`7.85k`
`    return SF(basic_map_partial_lexopt_base,SUFFIX)(bmap, dom,`
`160`
`7.85k`
`                empty, max);`
`161`
`238`
`162`
`238`
`  return SF(basic_map_partial_lexopt_symm,SUFFIX)(bmap, dom, empty, max,`
`163`
`238`
`               first, second);`
`164`
`238`
`error:`
`165`
`0`
`  isl_basic_set_free(dom);`
`166`
`0`
`  isl_basic_map_free(bmap);`
`167`
`0`
`  return NULL;`
`168`
`238`
`}`
`isl_tab_pip.c:basic_map_partial_lexopt`
 `Line` `Count` `Source` `147` `3.70k` `{` `148` `3.70k` ` isl_bool par = isl_bool_false;` `149` `3.70k` ` int first, second;` `150` `3.70k` `151` `3.70k` ` if (!bmap)` `152` `0` ` goto error;` `153` `3.70k` `154` `3.70k` ` if (bmap->ctx->opt->pip_symmetry)` `155` `3.70k` ` par = parallel_constraints(bmap, &first, &second);` `156` `3.70k` ` if (par < 0)` `157` `0` ` goto error;` `158` `3.70k` ` if (!par)` `159` `3.64k` ` return SF(basic_map_partial_lexopt_base,SUFFIX)(bmap, dom,` `160` `3.64k` ` empty, max);` `161` `55` `162` `55` ` return SF(basic_map_partial_lexopt_symm,SUFFIX)(bmap, dom, empty, max,` `163` `55` ` first, second);` `164` `55` `error:` `165` `0` ` isl_basic_set_free(dom);` `166` `0` ` isl_basic_map_free(bmap);` `167` `0` ` return NULL;` `168` `55` `}`
`isl_tab_pip.c:basic_map_partial_lexopt_pw_multi_aff`
 `Line` `Count` `Source` `147` `4.39k` `{` `148` `4.39k` ` isl_bool par = isl_bool_false;` `149` `4.39k` ` int first, second;` `150` `4.39k` `151` `4.39k` ` if (!bmap)` `152` `0` ` goto error;` `153` `4.39k` `154` `4.39k` ` if (bmap->ctx->opt->pip_symmetry)` `155` `4.39k` ` par = parallel_constraints(bmap, &first, &second);` `156` `4.39k` ` if (par < 0)` `157` `0` ` goto error;` `158` `4.39k` ` if (!par)` `159` `4.20k` ` return SF(basic_map_partial_lexopt_base,SUFFIX)(bmap, dom,` `160` `4.20k` ` empty, max);` `161` `183` `162` `183` ` return SF(basic_map_partial_lexopt_symm,SUFFIX)(bmap, dom, empty, max,` `163` `183` ` first, second);` `164` `183` `error:` `165` `0` ` isl_basic_set_free(dom);` `166` `0` ` isl_basic_map_free(bmap);` `167` `0` ` return NULL;` `168` `183` `}`
`169`
`170`
`/* Compute the lexicographic minimum (or maximum if "flags" includes`
`171`
` * ISL_OPT_MAX) of "bmap" over the domain "dom" and return the result as`
`172`
` * either a map or a piecewise multi-affine expression depending on TYPE.`
`173`
` * If "empty" is not NULL, then *empty is assigned a set that`
`174`
` * contains those parts of the domain where there is no solution.`
`175`
` * If "flags" includes ISL_OPT_FULL, then "dom" is NULL and the optimum`
`176`
` * should be computed over the domain of "bmap".  "empty" is also NULL`
`177`
` * in this case.`
`178`
` * If "bmap" is marked as rational (ISL_BASIC_MAP_RATIONAL),`
`179`
` * then we compute the rational optimum.  Otherwise, we compute`
`180`
` * the integral optimum.`
`181`
` *`
`182`
` * We perform some preprocessing.  As the PILP solver does not`
`183`
` * handle implicit equalities very well, we first make sure all`
`184`
` * the equalities are explicitly available.`
`185`
` *`
`186`
` * We also add context constraints to the basic map and remove`
`187`
` * redundant constraints.  This is only needed because of the`
`188`
` * way we handle simple symmetries.  In particular, we currently look`
`189`
` * for symmetries on the constraints, before we set up the main tableau.`
`190`
` * It is then no good to look for symmetries on possibly redundant constraints.`
`191`
` * If the domain was extracted from the basic map, then there is`
`192`
` * no need to add back those constraints again.`
`193`
` */`
`194`
`__isl_give TYPE *SF(isl_tab_basic_map_partial_lexopt,SUFFIX)(`
`195`
`  __isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,`
`196`
`  __isl_give isl_set **empty, unsigned flags)`
`197`
`7.85k`
`{`
`198`
`7.85k`
`  int max, full;`
`199`
`7.85k`
`  isl_bool compatible;`
`200`
`7.85k`
`201`
`7.85k`
`  if (empty)`
`202`
`3.31k`
`    *empty = NULL;`
`203`
`7.85k`
`204`
`7.85k`
`  full = ISL_FL_ISSET(flags, ISL_OPT_FULL);`
`205`
`7.85k`
`  if (full)`
`206`
`4.53k`
`    dom = extract_domain(bmap, flags);`
`207`
`7.85k`
`  compatible = isl_basic_map_compatible_domain(bmap, dom);`
`208`
`7.85k`
`  if (compatible < 0)`
`209`
`0`
`    goto error;`
`210`
`7.85k`
`  if (!compatible)`
`211`
`7.85k`
`    isl_die0(isl_basic_map_get_ctx(bmap), isl_error_invalid,`
`212`
`7.85k`
`      "domain does not match input", goto error);`
`213`
`7.85k`
`214`
`7.85k`
`  max = ISL_FL_ISSET(flags, ISL_OPT_MAX);`
`215`
`7.85k`
`  if (isl_basic_set_dim(dom, isl_dim_all) == 0)`
`216`
`1.48k`
`    return SF(basic_map_partial_lexopt,SUFFIX)(bmap, dom, empty,`
`217`
`1.48k`
`                  max);`
`218`
`6.37k`
`219`
`6.37k`
`  if (!full)`
`220`
`3.29k`
`    bmap = isl_basic_map_intersect_domain(bmap,`
`221`
`3.29k`
`                isl_basic_set_copy(dom));`
`222`
`6.37k`
`  bmap = isl_basic_map_detect_equalities(bmap);`
`223`
`6.37k`
`  bmap = isl_basic_map_remove_redundancies(bmap);`
`224`
`6.37k`
`225`
`6.37k`
`  return SF(basic_map_partial_lexopt,SUFFIX)(bmap, dom, empty, max);`
`226`
`6.37k`
`error:`
`227`
`0`
`  isl_basic_set_free(dom);`
`228`
`0`
`  isl_basic_map_free(bmap);`
`229`
`0`
`  return NULL;`
`230`
`6.37k`
`}`
`isl_tab_basic_map_partial_lexopt`
 `Line` `Count` `Source` `197` `3.64k` `{` `198` `3.64k` ` int max, full;` `199` `3.64k` ` isl_bool compatible;` `200` `3.64k` `201` `3.64k` ` if (empty)` `202` `2.75k` ` *empty = NULL;` `203` `3.64k` `204` `3.64k` ` full = ISL_FL_ISSET(flags, ISL_OPT_FULL);` `205` `3.64k` ` if (full)` `206` `894` ` dom = extract_domain(bmap, flags);` `207` `3.64k` ` compatible = isl_basic_map_compatible_domain(bmap, dom);` `208` `3.64k` ` if (compatible < 0)` `209` `0` ` goto error;` `210` `3.64k` ` if (!compatible)` `211` `3.64k` ` isl_die0(isl_basic_map_get_ctx(bmap), isl_error_invalid,` `212` `3.64k` ` "domain does not match input", goto error);` `213` `3.64k` `214` `3.64k` ` max = ISL_FL_ISSET(flags, ISL_OPT_MAX);` `215` `3.64k` ` if (isl_basic_set_dim(dom, isl_dim_all) == 0)` `216` `95` ` return SF(basic_map_partial_lexopt,SUFFIX)(bmap, dom, empty,` `217` `95` ` max);` `218` `3.55k` `219` `3.55k` ` if (!full)` `220` `2.73k` ` bmap = isl_basic_map_intersect_domain(bmap,` `221` `2.73k` ` isl_basic_set_copy(dom));` `222` `3.55k` ` bmap = isl_basic_map_detect_equalities(bmap);` `223` `3.55k` ` bmap = isl_basic_map_remove_redundancies(bmap);` `224` `3.55k` `225` `3.55k` ` return SF(basic_map_partial_lexopt,SUFFIX)(bmap, dom, empty, max);` `226` `3.55k` `error:` `227` `0` ` isl_basic_set_free(dom);` `228` `0` ` isl_basic_map_free(bmap);` `229` `0` ` return NULL;` `230` `3.55k` `}`
`isl_tab_basic_map_partial_lexopt_pw_multi_aff`
 `Line` `Count` `Source` `197` `4.20k` `{` `198` `4.20k` ` int max, full;` `199` `4.20k` ` isl_bool compatible;` `200` `4.20k` `201` `4.20k` ` if (empty)` `202` `567` ` *empty = NULL;` `203` `4.20k` `204` `4.20k` ` full = ISL_FL_ISSET(flags, ISL_OPT_FULL);` `205` `4.20k` ` if (full)` `206` `3.64k` ` dom = extract_domain(bmap, flags);` `207` `4.20k` ` compatible = isl_basic_map_compatible_domain(bmap, dom);` `208` `4.20k` ` if (compatible < 0)` `209` `0` ` goto error;` `210` `4.20k` ` if (!compatible)` `211` `4.20k` ` isl_die0(isl_basic_map_get_ctx(bmap), isl_error_invalid,` `212` `4.20k` ` "domain does not match input", goto error);` `213` `4.20k` `214` `4.20k` ` max = ISL_FL_ISSET(flags, ISL_OPT_MAX);` `215` `4.20k` ` if (isl_basic_set_dim(dom, isl_dim_all) == 0)` `216` `1.38k` ` return SF(basic_map_partial_lexopt,SUFFIX)(bmap, dom, empty,` `217` `1.38k` ` max);` `218` `2.82k` `219` `2.82k` ` if (!full)` `220` `567` ` bmap = isl_basic_map_intersect_domain(bmap,` `221` `567` ` isl_basic_set_copy(dom));` `222` `2.82k` ` bmap = isl_basic_map_detect_equalities(bmap);` `223` `2.82k` ` bmap = isl_basic_map_remove_redundancies(bmap);` `224` `2.82k` `225` `2.82k` ` return SF(basic_map_partial_lexopt,SUFFIX)(bmap, dom, empty, max);` `226` `2.82k` `error:` `227` `0` ` isl_basic_set_free(dom);` `228` `0` ` isl_basic_map_free(bmap);` `229` `0` ` return NULL;` `230` `2.82k` `}`