isl_multi_templ.c

   1 /*
   2  * Copyright 2011      Sven Verdoolaege
   3  * Copyright 2012      Ecole Normale Superieure
   4  *
   5  * Use of this software is governed by the MIT license
   6  *
   7  * Written by Sven Verdoolaege,
   8  * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
   9  */
  10
  11 #define xCAT(A,B) A ## B
  12 #define CAT(A,B) xCAT(A,B)
  13 #undef EL
  14 #define EL CAT(isl_,BASE)
  15 #define xFN(TYPE,NAME) TYPE ## _ ## NAME
  16 #define FN(TYPE,NAME) xFN(TYPE,NAME)
  17 #define xMULTI(BASE) isl_multi_ ## BASE
  18 #define MULTI(BASE) xMULTI(BASE)
  19 #define MULTI_NAME(BASE) "isl_multi_" #BASE
  20 #define xLIST(EL) EL ## _list
  21 #define LIST(EL) xLIST(EL)
  22
  23 isl_ctx *FN(MULTI(BASE),get_ctx)(__isl_keep MULTI(BASE) *multi)
  24 {
  25         return multi ? isl_space_get_ctx(multi->space) : NULL;
  26 }
  27
  28 __isl_give isl_space *FN(MULTI(BASE),get_space)(__isl_keep MULTI(BASE) *multi)
  29 {
  30         return multi ? isl_space_copy(multi->space) : NULL;
  31 }
  32
  33 __isl_give isl_space *FN(MULTI(BASE),get_domain_space)(
  34         __isl_keep MULTI(BASE) *multi)
  35 {
  36         return multi ? isl_space_domain(isl_space_copy(multi->space)) : NULL;
  37 }
  38
  39 __isl_give MULTI(BASE) *FN(MULTI(BASE),alloc)(__isl_take isl_space *space)
  40 {
  41         isl_ctx *ctx;
  42         int n;
  43         MULTI(BASE) *multi;
  44
  45         if (!space)
  46                 return NULL;
  47
  48         ctx = isl_space_get_ctx(space);
  49         n = isl_space_dim(space, isl_dim_out);
  50         multi = isl_calloc(ctx, MULTI(BASE),
  51                          sizeof(MULTI(BASE)) + (n - 1) * sizeof(struct EL *));
  52         if (!multi)
  53                 goto error;
  54
  55         multi->space = space;
  56         multi->n = n;
  57         multi->ref = 1;
  58         return multi;
  59 error:
  60         isl_space_free(space);
  61         return NULL;
  62 }
  63
  64 __isl_give MULTI(BASE) *FN(MULTI(BASE),dup)(__isl_keep MULTI(BASE) *multi)
  65 {
  66         int i;
  67         MULTI(BASE) *dup;
  68
  69         if (!multi)
  70                 return NULL;
  71
  72         dup = FN(MULTI(BASE),alloc)(isl_space_copy(multi->space));
  73         if (!dup)
  74                 return NULL;
  75
  76         for (i = 0; i < multi->n; ++i)
  77                 dup = FN(FN(MULTI(BASE),set),BASE)(dup, i,
  78                                                     FN(EL,copy)(multi->p[i]));
  79
  80         return dup;
  81 }
  82
  83 __isl_give MULTI(BASE) *FN(MULTI(BASE),cow)(__isl_take MULTI(BASE) *multi)
  84 {
  85         if (!multi)
  86                 return NULL;
  87
  88         if (multi->ref == 1)
  89                 return multi;
  90
  91         multi->ref--;
  92         return FN(MULTI(BASE),dup)(multi);
  93 }
  94
  95 __isl_give MULTI(BASE) *FN(MULTI(BASE),copy)(__isl_keep MULTI(BASE) *multi)
  96 {
  97         if (!multi)
  98                 return NULL;
  99
 100         multi->ref++;
 101         return multi;
 102 }
 103
 104 void *FN(MULTI(BASE),free)(__isl_take MULTI(BASE) *multi)
 105 {
 106         int i;
 107
 108         if (!multi)
 109                 return NULL;
 110
 111         if (--multi->ref > 0)
 112                 return NULL;
 113
 114         isl_space_free(multi->space);
 115         for (i = 0; i < multi->n; ++i)
 116                 FN(EL,free)(multi->p[i]);
 117         free(multi);
 118
 119         return NULL;
 120 }
 121
 122 __isl_give MULTI(BASE) *FN(MULTI(BASE),insert_dims)(
 123         __isl_take MULTI(BASE) *multi,
 124         enum isl_dim_type type, unsigned first, unsigned n)
 125 {
 126         int i;
 127
 128         if (!multi)
 129                 return NULL;
 130         if (type == isl_dim_out)
 131                 isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
 132                         "cannot insert output/set dimensions",
 133                         return FN(MULTI(BASE),free)(multi));
 134         if (n == 0 && !isl_space_is_named_or_nested(multi->space, type))
 135                 return multi;
 136
 137         multi = FN(MULTI(BASE),cow)(multi);
 138         if (!multi)
 139                 return NULL;
 140
 141         multi->space = isl_space_insert_dims(multi->space, type, first, n);
 142         if (!multi->space)
 143                 return FN(MULTI(BASE),free)(multi);
 144
 145         for (i = 0; i < multi->n; ++i) {
 146                 multi->p[i] = FN(EL,insert_dims)(multi->p[i], type, first, n);
 147                 if (!multi->p[i])
 148                         return FN(MULTI(BASE),free)(multi);
 149         }
 150
 151         return multi;
 152 }
 153
 154 __isl_give MULTI(BASE) *FN(MULTI(BASE),add_dims)(__isl_take MULTI(BASE) *multi,
 155         enum isl_dim_type type, unsigned n)
 156 {
 157         unsigned pos;
 158
 159         pos = FN(MULTI(BASE),dim)(multi, type);
 160
 161         return FN(MULTI(BASE),insert_dims)(multi, type, pos, n);
 162 }
 163
 164 unsigned FN(MULTI(BASE),dim)(__isl_keep MULTI(BASE) *multi,
 165         enum isl_dim_type type)
 166 {
 167         return multi ? isl_space_dim(multi->space, type) : 0;
 168 }
 169
 170 __isl_give MULTI(BASE) *FN(MULTI(BASE),set_dim_name)(
 171         __isl_take MULTI(BASE) *multi,
 172         enum isl_dim_type type, unsigned pos, const char *s)
 173 {
 174         int i;
 175
 176         multi = FN(MULTI(BASE),cow)(multi);
 177         if (!multi)
 178                 return NULL;
 179
 180         multi->space = isl_space_set_dim_name(multi->space, type, pos, s);
 181         if (!multi->space)
 182                 return FN(MULTI(BASE),free)(multi);
 183
 184         if (type == isl_dim_out)
 185                 return multi;
 186         for (i = 0; i < multi->n; ++i) {
 187                 multi->p[i] = FN(EL,set_dim_name)(multi->p[i], type, pos, s);
 188                 if (!multi->p[i])
 189                         return FN(MULTI(BASE),free)(multi);
 190         }
 191
 192         return multi;
 193 }
 194
 195 const char *FN(MULTI(BASE),get_tuple_name)(__isl_keep MULTI(BASE) *multi,
 196         enum isl_dim_type type)
 197 {
 198         return multi ? isl_space_get_tuple_name(multi->space, type) : NULL;
 199 }
 200
 201 __isl_give EL *FN(FN(MULTI(BASE),get),BASE)(__isl_keep MULTI(BASE) *multi,
 202         int pos)
 203 {
 204         isl_ctx *ctx;
 205
 206         if (!multi)
 207                 return NULL;
 208         ctx = FN(MULTI(BASE),get_ctx)(multi);
 209         if (pos < 0 || pos >= multi->n)
 210                 isl_die(ctx, isl_error_invalid,
 211                         "index out of bounds", return NULL);
 212         return FN(EL,copy)(multi->p[pos]);
 213 }
 214
 215 __isl_give MULTI(BASE) *FN(FN(MULTI(BASE),set),BASE)(
 216         __isl_take MULTI(BASE) *multi, int pos, __isl_take EL *el)
 217 {
 218         isl_space *multi_space = NULL;
 219         isl_space *el_space = NULL;
 220
 221         multi = FN(MULTI(BASE),cow)(multi);
 222         if (!multi || !el)
 223                 goto error;
 224
 225         multi_space = FN(MULTI(BASE),get_space)(multi);
 226         el_space = FN(EL,get_space)(el);
 227
 228         if (!isl_space_match(multi_space, isl_dim_param,
 229                             el_space, isl_dim_param))
 230                 isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
 231                         "parameters don't match", goto error);
 232         if (!isl_space_tuple_match(multi_space, isl_dim_in,
 233                             el_space, isl_dim_in))
 234                 isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
 235                         "domains don't match", goto error);
 236
 237         if (pos < 0 || pos >= multi->n)
 238                 isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
 239                         "index out of bounds", goto error);
 240
 241         FN(EL,free)(multi->p[pos]);
 242         multi->p[pos] = el;
 243
 244         isl_space_free(multi_space);
 245         isl_space_free(el_space);
 246
 247         return multi;
 248 error:
 249         FN(MULTI(BASE),free)(multi);
 250         FN(EL,free)(el);
 251         isl_space_free(multi_space);
 252         isl_space_free(el_space);
 253         return NULL;
 254 }
 255
 256 /* Reset the space of "multi".  This function is called from isl_pw_templ.c
 257  * and doesn't know if the space of an element object is represented
 258  * directly or through its domain.  It therefore passes along both,
 259  * which we pass along to the element function since we don't how
 260  * that is represented either.
 261  */
 262 __isl_give MULTI(BASE) *FN(MULTI(BASE),reset_space_and_domain)(
 263         __isl_take MULTI(BASE) *multi, __isl_take isl_space *space,
 264         __isl_take isl_space *domain)
 265 {
 266         int i;
 267
 268         multi = FN(MULTI(BASE),cow)(multi);
 269         if (!multi || !space || !domain)
 270                 goto error;
 271
 272         for (i = 0; i < multi->n; ++i) {
 273                 multi->p[i] = FN(EL,reset_domain_space)(multi->p[i],
 274                                  isl_space_copy(domain));
 275                 if (!multi->p[i])
 276                         goto error;
 277         }
 278         isl_space_free(domain);
 279         isl_space_free(multi->space);
 280         multi->space = space;
 281
 282         return multi;
 283 error:
 284         isl_space_free(domain);
 285         isl_space_free(space);
 286         FN(MULTI(BASE),free)(multi);
 287         return NULL;
 288 }
 289
 290 __isl_give MULTI(BASE) *FN(MULTI(BASE),reset_domain_space)(
 291         __isl_take MULTI(BASE) *multi, __isl_take isl_space *domain)
 292 {
 293         isl_space *space;
 294
 295         space = isl_space_extend_domain_with_range(isl_space_copy(domain),
 296                                                 isl_space_copy(multi->space));
 297         return FN(MULTI(BASE),reset_space_and_domain)(multi, space, domain);
 298 }
 299
 300 __isl_give MULTI(BASE) *FN(MULTI(BASE),reset_space)(
 301         __isl_take MULTI(BASE) *multi, __isl_take isl_space *space)
 302 {
 303         isl_space *domain;
 304
 305         domain = isl_space_domain(isl_space_copy(space));
 306         return FN(MULTI(BASE),reset_space_and_domain)(multi, space, domain);
 307 }
 308
 309 __isl_give MULTI(BASE) *FN(MULTI(BASE),set_tuple_name)(
 310         __isl_keep MULTI(BASE) *multi, enum isl_dim_type type,
 311         const char *s)
 312 {
 313         isl_space *space;
 314
 315         multi = FN(MULTI(BASE),cow)(multi);
 316         if (!multi)
 317                 return NULL;
 318
 319         space = FN(MULTI(BASE),get_space)(multi);
 320         space = isl_space_set_tuple_name(space, type, s);
 321
 322         return FN(MULTI(BASE),reset_space)(multi, space);
 323 }
 324
 325 __isl_give MULTI(BASE) *FN(MULTI(BASE),set_tuple_id)(
 326         __isl_keep MULTI(BASE) *multi, enum isl_dim_type type,
 327         __isl_take isl_id *id)
 328 {
 329         isl_space *space;
 330
 331         multi = FN(MULTI(BASE),cow)(multi);
 332         if (!multi)
 333                 return isl_id_free(id);
 334
 335         space = FN(MULTI(BASE),get_space)(multi);
 336         space = isl_space_set_tuple_id(space, type, id);
 337
 338         return FN(MULTI(BASE),reset_space)(multi, space);
 339 }
 340
 341 __isl_give MULTI(BASE) *FN(MULTI(BASE),realign_domain)(
 342         __isl_take MULTI(BASE) *multi, __isl_take isl_reordering *exp)
 343 {
 344         int i;
 345
 346         multi = FN(MULTI(BASE),cow)(multi);
 347         if (!multi || !exp)
 348                 goto error;
 349
 350         for (i = 0; i < multi->n; ++i) {
 351                 multi->p[i] = FN(EL,realign_domain)(multi->p[i],
 352                                                 isl_reordering_copy(exp));
 353                 if (!multi->p[i])
 354                         goto error;
 355         }
 356
 357         multi = FN(MULTI(BASE),reset_domain_space)(multi,
 358                                                     isl_space_copy(exp->dim));
 359
 360         isl_reordering_free(exp);
 361         return multi;
 362 error:
 363         isl_reordering_free(exp);
 364         FN(MULTI(BASE),free)(multi);
 365         return NULL;
 366 }
 367
 368 /* Align the parameters of "multi" to those of "model".
 369  */
 370 __isl_give MULTI(BASE) *FN(MULTI(BASE),align_params)(
 371         __isl_take MULTI(BASE) *multi, __isl_take isl_space *model)
 372 {
 373         isl_ctx *ctx;
 374
 375         if (!multi || !model)
 376                 goto error;
 377
 378         ctx = isl_space_get_ctx(model);
 379         if (!isl_space_has_named_params(model))
 380                 isl_die(ctx, isl_error_invalid,
 381                         "model has unnamed parameters", goto error);
 382         if (!isl_space_has_named_params(multi->space))
 383                 isl_die(ctx, isl_error_invalid,
 384                         "input has unnamed parameters", goto error);
 385         if (!isl_space_match(multi->space, isl_dim_param,
 386                              model, isl_dim_param)) {
 387                 isl_reordering *exp;
 388
 389                 model = isl_space_params(model);
 390                 exp = isl_parameter_alignment_reordering(multi->space, model);
 391                 exp = isl_reordering_extend_space(exp,
 392                                     FN(MULTI(BASE),get_domain_space)(multi));
 393                 multi = FN(MULTI(BASE),realign_domain)(multi, exp);
 394         }
 395
 396         isl_space_free(model);
 397         return multi;
 398 error:
 399         isl_space_free(model);
 400         FN(MULTI(BASE),free)(multi);
 401         return NULL;
 402 }
 403
 404 static __isl_give MULTI(BASE) *FN(MULTI(BASE),align_params_multi_set_and)(
 405         __isl_take MULTI(BASE) *multi, __isl_take isl_set *set,
 406         __isl_give MULTI(BASE) *(*fn)(__isl_take MULTI(BASE) *multi,
 407                                         __isl_take isl_set *set))
 408 {
 409         isl_ctx *ctx;
 410
 411         if (!multi || !set)
 412                 goto error;
 413         if (isl_space_match(multi->space, isl_dim_param,
 414                             set->dim, isl_dim_param))
 415                 return fn(multi, set);
 416         ctx = FN(MULTI(BASE),get_ctx)(multi);
 417         if (!isl_space_has_named_params(multi->space) ||
 418             !isl_space_has_named_params(set->dim))
 419                 isl_die(ctx, isl_error_invalid,
 420                         "unaligned unnamed parameters", goto error);
 421         multi = FN(MULTI(BASE),align_params)(multi, isl_set_get_space(set));
 422         set = isl_set_align_params(set, FN(MULTI(BASE),get_space)(multi));
 423         return fn(multi, set);
 424 error:
 425         FN(MULTI(BASE),free)(multi);
 426         isl_set_free(set);
 427         return NULL;
 428 }
 429
 430 __isl_give MULTI(BASE) *FN(MULTI(BASE),gist_aligned)(
 431         __isl_take MULTI(BASE) *multi, __isl_take isl_set *context)
 432 {
 433         int i;
 434
 435         if (!multi || !context)
 436                 goto error;
 437
 438         for (i = 0; i < multi->n; ++i) {
 439                 multi->p[i] = FN(EL,gist)(multi->p[i], isl_set_copy(context));
 440                 if (!multi->p[i])
 441                         goto error;
 442         }
 443
 444         isl_set_free(context);
 445         return multi;
 446 error:
 447         isl_set_free(context);
 448         FN(MULTI(BASE),free)(multi);
 449         return NULL;
 450 }
 451
 452 __isl_give MULTI(BASE) *FN(MULTI(BASE),gist)(__isl_take MULTI(BASE) *multi,
 453         __isl_take isl_set *context)
 454 {
 455         return FN(MULTI(BASE),align_params_multi_set_and)(multi, context,
 456                                                 &FN(MULTI(BASE),gist_aligned));
 457 }
 458
 459 __isl_give MULTI(BASE) *FN(MULTI(BASE),gist_params)(
 460         __isl_take MULTI(BASE) *multi, __isl_take isl_set *context)
 461 {
 462         isl_space *space = FN(MULTI(BASE),get_domain_space)(multi);
 463         isl_set *dom_context = isl_set_universe(space);
 464         dom_context = isl_set_intersect_params(dom_context, context);
 465         return FN(MULTI(BASE),gist)(multi, dom_context);
 466 }
 467
 468 __isl_give MULTI(BASE) *FN(FN(MULTI(BASE),from),LIST(BASE))(
 469         __isl_take isl_space *space, __isl_take LIST(EL) *list)
 470 {
 471         int i;
 472         int n;
 473         isl_ctx *ctx;
 474         MULTI(BASE) *multi;
 475
 476         if (!space || !list)
 477                 goto error;
 478
 479         ctx = isl_space_get_ctx(space);
 480         n = FN(FN(LIST(EL),n),BASE)(list);
 481         if (n != isl_space_dim(space, isl_dim_out))
 482                 isl_die(ctx, isl_error_invalid,
 483                         "invalid number of elements in list", goto error);
 484
 485         multi = FN(MULTI(BASE),alloc)(isl_space_copy(space));
 486         for (i = 0; i < n; ++i) {
 487                 multi = FN(FN(MULTI(BASE),set),BASE)(multi, i,
 488                                         FN(FN(LIST(EL),get),BASE)(list, i));
 489         }
 490
 491         isl_space_free(space);
 492         FN(LIST(EL),free)(list);
 493         return multi;
 494 error:
 495         isl_space_free(space);
 496         FN(LIST(EL),free)(list);
 497         return NULL;
 498 }
 499
 500 /* Create a multi expression in the given space that maps each
 501  * input dimension to the corresponding output dimension.
 502  */
 503 __isl_give MULTI(BASE) *FN(MULTI(BASE),identity)(__isl_take isl_space *space)
 504 {
 505         int i, n;
 506         isl_local_space *ls;
 507         MULTI(BASE) *multi;
 508
 509         if (!space)
 510                 return NULL;
 511
 512         if (isl_space_is_set(space))
 513                 isl_die(isl_space_get_ctx(space), isl_error_invalid,
 514                         "expecting map space", goto error);
 515
 516         n = isl_space_dim(space, isl_dim_out);
 517         if (n != isl_space_dim(space, isl_dim_in))
 518                 isl_die(isl_space_get_ctx(space), isl_error_invalid,
 519                         "number of input and output dimensions needs to be "
 520                         "the same", goto error);
 521
 522         multi = FN(MULTI(BASE),alloc)(isl_space_copy(space));
 523
 524         if (!n) {
 525                 isl_space_free(space);
 526                 return multi;
 527         }
 528
 529         space = isl_space_domain(space);
 530         ls = isl_local_space_from_space(space);
 531
 532         for (i = 0; i < n; ++i) {
 533                 EL *el;
 534                 el = FN(EL,var_on_domain)(isl_local_space_copy(ls),
 535                                                 isl_dim_set, i);
 536                 multi = FN(FN(MULTI(BASE),set),BASE)(multi, i, el);
 537         }
 538
 539         isl_local_space_free(ls);
 540
 541         return multi;
 542 error:
 543         isl_space_free(space);
 544         return NULL;
 545 }
 546
 547 /* Construct a multi expression in the given space with value zero in
 548  * each of the output dimensions.
 549  */
 550 __isl_give MULTI(BASE) *FN(MULTI(BASE),zero)(__isl_take isl_space *space)
 551 {
 552         int n;
 553         MULTI(BASE) *multi;
 554
 555         if (!space)
 556                 return NULL;
 557
 558         n = isl_space_dim(space , isl_dim_out);
 559         multi = FN(MULTI(BASE),alloc)(isl_space_copy(space));
 560
 561         if (!n)
 562                 isl_space_free(space);
 563         else {
 564                 int i;
 565                 isl_local_space *ls;
 566                 EL *el;
 567
 568                 space = isl_space_domain(space);
 569                 ls = isl_local_space_from_space(space);
 570                 el = FN(EL,zero_on_domain)(ls);
 571
 572                 for (i = 0; i < n; ++i)
 573                         multi = FN(FN(MULTI(BASE),set),BASE)(multi, i,
 574                                                             FN(EL,copy)(el));
 575
 576                 FN(EL,free)(el);
 577         }
 578
 579         return multi;
 580 }
 581
 582 __isl_give MULTI(BASE) *FN(FN(MULTI(BASE),from),BASE)(__isl_take EL *el)
 583 {
 584         MULTI(BASE) *multi;
 585
 586         multi = FN(MULTI(BASE),alloc)(FN(EL,get_space)(el));
 587         multi = FN(FN(MULTI(BASE),set),BASE)(multi, 0, el);
 588
 589         return multi;
 590 }
 591
 592 __isl_give MULTI(BASE) *FN(MULTI(BASE),drop_dims)(
 593         __isl_take MULTI(BASE) *multi,
 594         enum isl_dim_type type, unsigned first, unsigned n)
 595 {
 596         int i;
 597         unsigned dim;
 598
 599         multi = FN(MULTI(BASE),cow)(multi);
 600         if (!multi)
 601                 return NULL;
 602
 603         dim = FN(MULTI(BASE),dim)(multi, type);
 604         if (first + n > dim || first + n < first)
 605                 isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
 606                         "index out of bounds",
 607                         return FN(MULTI(BASE),cow)(multi));
 608
 609         multi->space = isl_space_drop_dims(multi->space, type, first, n);
 610         if (!multi->space)
 611                 return FN(MULTI(BASE),cow)(multi);
 612
 613         if (type == isl_dim_out) {
 614                 for (i = 0; i < n; ++i)
 615                         FN(EL,free)(multi->p[first + i]);
 616                 for (i = first; i + n < multi->n; ++i)
 617                         multi->p[i] = multi->p[i + n];
 618                 multi->n -= n;
 619
 620                 return multi;
 621         }
 622
 623         for (i = 0; i < multi->n; ++i) {
 624                 multi->p[i] = FN(EL,drop_dims)(multi->p[i], type, first, n);
 625                 if (!multi->p[i])
 626                         return FN(MULTI(BASE),cow)(multi);
 627         }
 628
 629         return multi;
 630 }
 631
 632 /* Given two MULTI(BASE)s A -> B and C -> D,
 633  * construct a MULTI(BASE) (A * C) -> (B, D).
 634  */
 635 __isl_give MULTI(BASE) *FN(MULTI(BASE),range_product)(
 636         __isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2)
 637 {
 638         int i, n1, n2;
 639         EL *el;
 640         isl_space *space;
 641         MULTI(BASE) *res;
 642
 643         if (!multi1 || !multi2)
 644                 goto error;
 645
 646         space = isl_space_range_product(FN(MULTI(BASE),get_space)(multi1),
 647                                         FN(MULTI(BASE),get_space)(multi2));
 648         res = FN(MULTI(BASE),alloc)(space);
 649
 650         n1 = FN(MULTI(BASE),dim)(multi1, isl_dim_out);
 651         n2 = FN(MULTI(BASE),dim)(multi2, isl_dim_out);
 652
 653         for (i = 0; i < n1; ++i) {
 654                 el = FN(FN(MULTI(BASE),get),BASE)(multi1, i);
 655                 res = FN(FN(MULTI(BASE),set),BASE)(res, i, el);
 656         }
 657
 658         for (i = 0; i < n2; ++i) {
 659                 el = FN(FN(MULTI(BASE),get),BASE)(multi2, i);
 660                 res = FN(FN(MULTI(BASE),set),BASE)(res, n1 + i, el);
 661         }
 662
 663         FN(MULTI(BASE),free)(multi1);
 664         FN(MULTI(BASE),free)(multi2);
 665         return res;
 666 error:
 667         FN(MULTI(BASE),free)(multi1);
 668         FN(MULTI(BASE),free)(multi2);
 669         return NULL;
 670 }
 671
 672 __isl_give MULTI(BASE) *FN(MULTI(BASE),flatten_range)(
 673         __isl_take MULTI(BASE) *multi)
 674 {
 675         if (!multi)
 676                 return NULL;
 677
 678         if (!multi->space->nested[1])
 679                 return multi;
 680
 681         multi = FN(MULTI(BASE),cow)(multi);
 682         if (!multi)
 683                 return NULL;
 684
 685         multi->space = isl_space_flatten_range(multi->space);
 686         if (!multi->space)
 687                 return FN(MULTI(BASE),free)(multi);
 688
 689         return multi;
 690 }
 691
 692 /* Given two MULTI(BASE)s A -> B and C -> D,
 693  * construct a MULTI(BASE) (A * C) -> [B -> D].
 694  */
 695 __isl_give MULTI(BASE) *FN(MULTI(BASE),flat_range_product)(
 696         __isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2)
 697 {
 698         MULTI(BASE) *multi;
 699
 700         multi = FN(MULTI(BASE),range_product)(multi1, multi2);
 701         multi = FN(MULTI(BASE),flatten_range)(multi);
 702         return multi;
 703 }
 704
 705 /* Given two multi expressions, "multi1"
 706  *
 707  *      [A] -> [B1 B2]
 708  *
 709  * where B2 starts at position "pos", and "multi2"
 710  *
 711  *      [A] -> [D]
 712  *
 713  * return the multi expression
 714  *
 715  *      [A] -> [B1 D B2]
 716  */
 717 __isl_give MULTI(BASE) *FN(MULTI(BASE),range_splice)(
 718         __isl_take MULTI(BASE) *multi1, unsigned pos,
 719         __isl_take MULTI(BASE) *multi2)
 720 {
 721         MULTI(BASE) *res;
 722         unsigned dim;
 723
 724         if (!multi1 || !multi2)
 725                 goto error;
 726
 727         dim = FN(MULTI(BASE),dim)(multi1, isl_dim_out);
 728         if (pos > dim)
 729                 isl_die(FN(MULTI(BASE),get_ctx)(multi1), isl_error_invalid,
 730                         "index out of bounds", goto error);
 731
 732         res = FN(MULTI(BASE),copy)(multi1);
 733         res = FN(MULTI(BASE),drop_dims)(res, isl_dim_out, pos, dim - pos);
 734         multi1 = FN(MULTI(BASE),drop_dims)(multi1, isl_dim_out, 0, pos);
 735
 736         res = FN(MULTI(BASE),flat_range_product)(res, multi2);
 737         res = FN(MULTI(BASE),flat_range_product)(res, multi1);
 738
 739         return res;
 740 error:
 741         FN(MULTI(BASE),free)(multi1);
 742         FN(MULTI(BASE),free)(multi2);
 743         return NULL;
 744 }
 745
 746 /* Given two multi expressions, "multi1"
 747  *
 748  *      [A1 A2] -> [B1 B2]
 749  *
 750  * where A2 starts at position "in_pos" and B2 starts at position "out_pos",
 751  * and "multi2"
 752  *
 753  *      [C] -> [D]
 754  *
 755  * return the multi expression
 756  *
 757  *      [A1 C A2] -> [B1 D B2]
 758  *
 759  * We first insert input dimensions to obtain
 760  *
 761  *      [A1 C A2] -> [B1 B2]
 762  *
 763  * and
 764  *
 765  *      [A1 C A2] -> [D]
 766  *
 767  * and then apply range_splice.
 768  */
 769 __isl_give MULTI(BASE) *FN(MULTI(BASE),splice)(
 770         __isl_take MULTI(BASE) *multi1, unsigned in_pos, unsigned out_pos,
 771         __isl_take MULTI(BASE) *multi2)
 772 {
 773         unsigned n_in1;
 774         unsigned n_in2;
 775
 776         if (!multi1 || !multi2)
 777                 goto error;
 778
 779         n_in1 = FN(MULTI(BASE),dim)(multi1, isl_dim_in);
 780         if (in_pos > n_in1)
 781                 isl_die(FN(MULTI(BASE),get_ctx)(multi1), isl_error_invalid,
 782                         "index out of bounds", goto error);
 783
 784         n_in2 = FN(MULTI(BASE),dim)(multi2, isl_dim_in);
 785
 786         multi1 = FN(MULTI(BASE),insert_dims)(multi1, isl_dim_in, in_pos, n_in2);
 787         multi2 = FN(MULTI(BASE),insert_dims)(multi2, isl_dim_in, n_in2,
 788                                                 n_in1 - in_pos);
 789         multi2 = FN(MULTI(BASE),insert_dims)(multi2, isl_dim_in, 0, in_pos);
 790
 791         return FN(MULTI(BASE),range_splice)(multi1, out_pos, multi2);
 792 error:
 793         FN(MULTI(BASE),free)(multi1);
 794         FN(MULTI(BASE),free)(multi2);
 795         return NULL;
 796 }
 797
 798 /* This function is currently only used from isl_aff.c
 799  */
 800 static __isl_give MULTI(BASE) *FN(MULTI(BASE),bin_op)(
 801         __isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2,
 802         __isl_give EL *(*fn)(__isl_take EL *, __isl_take EL *))
 803         __attribute__ ((unused));
 804
 805 /* Pairwise perform "fn" to the elements of "multi1" and "multi2" and
 806  * return the result.
 807  */
 808 static __isl_give MULTI(BASE) *FN(MULTI(BASE),bin_op)(
 809         __isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2,
 810         __isl_give EL *(*fn)(__isl_take EL *, __isl_take EL *))
 811 {
 812         int i;
 813         isl_ctx *ctx;
 814
 815         multi1 = FN(MULTI(BASE),cow)(multi1);
 816         if (!multi1 || !multi2)
 817                 goto error;
 818
 819         ctx = FN(MULTI(BASE),get_ctx)(multi1);
 820         if (!isl_space_is_equal(multi1->space, multi2->space))
 821                 isl_die(ctx, isl_error_invalid,
 822                         "spaces don't match", goto error);
 823
 824         for (i = 0; i < multi1->n; ++i) {
 825                 multi1->p[i] = fn(multi1->p[i], FN(EL,copy)(multi2->p[i]));
 826                 if (!multi1->p[i])
 827                         goto error;
 828         }
 829
 830         FN(MULTI(BASE),free)(multi2);
 831         return multi1;
 832 error:
 833         FN(MULTI(BASE),free)(multi1);
 834         FN(MULTI(BASE),free)(multi2);
 835         return NULL;
 836 }