pet.cc

   1 /*
   2  * Copyright 2011      Leiden University. All rights reserved.
   3  * Copyright 2012-2014 Ecole Normale Superieure. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  *    1. Redistributions of source code must retain the above copyright
  10  *       notice, this list of conditions and the following disclaimer.
  11  *
  12  *    2. Redistributions in binary form must reproduce the above
  13  *       copyright notice, this list of conditions and the following
  14  *       disclaimer in the documentation and/or other materials provided
  15  *       with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY LEIDEN UNIVERSITY ''AS IS'' AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  20  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL LEIDEN UNIVERSITY OR
  21  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  24  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * The views and conclusions contained in the software and documentation
  30  * are those of the authors and should not be interpreted as
  31  * representing official policies, either expressed or implied, of
  32  * Leiden University.
  33  */
  34
  35 #include "config.h"
  36
  37 #include <stdlib.h>
  38 #include <map>
  39 #include <vector>
  40 #include <iostream>
  41 #ifdef HAVE_ADT_OWNINGPTR_H
  42 #include <llvm/ADT/OwningPtr.h>
  43 #else
  44 #include <memory>
  45 #endif
  46 #include <llvm/Support/raw_ostream.h>
  47 #include <llvm/Support/ManagedStatic.h>
  48 #include <llvm/Support/Host.h>
  49 #include <clang/Basic/Version.h>
  50 #include <clang/Basic/FileSystemOptions.h>
  51 #include <clang/Basic/FileManager.h>
  52 #include <clang/Basic/TargetOptions.h>
  53 #include <clang/Basic/TargetInfo.h>
  54 #include <clang/Driver/Compilation.h>
  55 #include <clang/Driver/Driver.h>
  56 #include <clang/Driver/Tool.h>
  57 #include <clang/Frontend/CompilerInstance.h>
  58 #include <clang/Frontend/CompilerInvocation.h>
  59 #ifdef HAVE_BASIC_DIAGNOSTICOPTIONS_H
  60 #include <clang/Basic/DiagnosticOptions.h>
  61 #else
  62 #include <clang/Frontend/DiagnosticOptions.h>
  63 #endif
  64 #include <clang/Frontend/TextDiagnosticPrinter.h>
  65 #ifdef HAVE_LEX_HEADERSEARCHOPTIONS_H
  66 #include <clang/Lex/HeaderSearchOptions.h>
  67 #else
  68 #include <clang/Frontend/HeaderSearchOptions.h>
  69 #endif
  70 #include <clang/Frontend/LangStandard.h>
  71 #ifdef HAVE_LEX_PREPROCESSOROPTIONS_H
  72 #include <clang/Lex/PreprocessorOptions.h>
  73 #else
  74 #include <clang/Frontend/PreprocessorOptions.h>
  75 #endif
  76 #include <clang/Frontend/FrontendOptions.h>
  77 #include <clang/Frontend/Utils.h>
  78 #include <clang/Lex/HeaderSearch.h>
  79 #include <clang/Lex/Preprocessor.h>
  80 #include <clang/Lex/Pragma.h>
  81 #include <clang/AST/ASTContext.h>
  82 #include <clang/AST/ASTConsumer.h>
  83 #include <clang/Sema/Sema.h>
  84 #include <clang/Sema/SemaDiagnostic.h>
  85 #include <clang/Parse/Parser.h>
  86 #include <clang/Parse/ParseAST.h>
  87
  88 #include <isl/ctx.h>
  89 #include <isl/constraint.h>
  90
  91 #include <pet.h>
  92
  93 #include "id.h"
  94 #include "options.h"
  95 #include "scan.h"
  96 #include "print.h"
  97
  98 #define ARRAY_SIZE(array) (sizeof(array)/sizeof(*array))
  99
 100 using namespace std;
 101 using namespace clang;
 102 using namespace clang::driver;
 103
 104 #ifdef HAVE_ADT_OWNINGPTR_H
 105 #define unique_ptr      llvm::OwningPtr
 106 #endif
 107
 108 /* Called if we found something we didn't expect in one of the pragmas.
 109  * We'll provide more informative warnings later.
 110  */
 111 static void unsupported(Preprocessor &PP, SourceLocation loc)
 112 {
 113         DiagnosticsEngine &diag = PP.getDiagnostics();
 114         unsigned id = diag.getCustomDiagID(DiagnosticsEngine::Warning,
 115                                            "unsupported");
 116         DiagnosticBuilder B = diag.Report(loc, id);
 117 }
 118
 119 static int get_int(const char *s)
 120 {
 121         return s[0] == '"' ? atoi(s + 1) : atoi(s);
 122 }
 123
 124 static ValueDecl *get_value_decl(Sema &sema, Token &token)
 125 {
 126         IdentifierInfo *name;
 127         Decl *decl;
 128
 129         if (token.isNot(tok::identifier))
 130                 return NULL;
 131
 132         name = token.getIdentifierInfo();
 133         decl = sema.LookupSingleName(sema.TUScope, name,
 134                                 token.getLocation(), Sema::LookupOrdinaryName);
 135         return decl ? cast_or_null<ValueDecl>(decl) : NULL;
 136 }
 137
 138 /* Handle pragmas of the form
 139  *
 140  *      #pragma value_bounds identifier lower_bound upper_bound
 141  *
 142  * For each such pragma, add a mapping
 143  *      { identifier[] -> [i] : lower_bound <= i <= upper_bound }
 144  * to value_bounds.
 145  */
 146 struct PragmaValueBoundsHandler : public PragmaHandler {
 147         Sema &sema;
 148         isl_ctx *ctx;
 149         isl_union_map *value_bounds;
 150
 151         PragmaValueBoundsHandler(isl_ctx *ctx, Sema &sema) :
 152             PragmaHandler("value_bounds"), sema(sema), ctx(ctx) {
 153                 isl_space *space = isl_space_params_alloc(ctx, 0);
 154                 value_bounds = isl_union_map_empty(space);
 155         }
 156
 157         ~PragmaValueBoundsHandler() {
 158                 isl_union_map_free(value_bounds);
 159         }
 160
 161         virtual void HandlePragma(Preprocessor &PP,
 162                                   PragmaIntroducerKind Introducer,
 163                                   Token &ScopTok) {
 164                 isl_id *id;
 165                 isl_space *dim;
 166                 isl_map *map;
 167                 ValueDecl *vd;
 168                 Token token;
 169                 int lb;
 170                 int ub;
 171
 172                 PP.Lex(token);
 173                 vd = get_value_decl(sema, token);
 174                 if (!vd) {
 175                         unsupported(PP, token.getLocation());
 176                         return;
 177                 }
 178
 179                 PP.Lex(token);
 180                 if (!token.isLiteral()) {
 181                         unsupported(PP, token.getLocation());
 182                         return;
 183                 }
 184
 185                 lb = get_int(token.getLiteralData());
 186
 187                 PP.Lex(token);
 188                 if (!token.isLiteral()) {
 189                         unsupported(PP, token.getLocation());
 190                         return;
 191                 }
 192
 193                 ub = get_int(token.getLiteralData());
 194
 195                 dim = isl_space_alloc(ctx, 0, 0, 1);
 196                 map = isl_map_universe(dim);
 197                 map = isl_map_lower_bound_si(map, isl_dim_out, 0, lb);
 198                 map = isl_map_upper_bound_si(map, isl_dim_out, 0, ub);
 199                 id = isl_id_alloc(ctx, vd->getName().str().c_str(), vd);
 200                 map = isl_map_set_tuple_id(map, isl_dim_in, id);
 201
 202                 value_bounds = isl_union_map_add_map(value_bounds, map);
 203         }
 204 };
 205
 206 /* Given a variable declaration, check if it has an integer initializer
 207  * and if so, add a parameter corresponding to the variable to "value"
 208  * with its value fixed to the integer initializer and return the result.
 209  */
 210 static __isl_give isl_set *extract_initialization(__isl_take isl_set *value,
 211         ValueDecl *decl)
 212 {
 213         VarDecl *vd;
 214         Expr *expr;
 215         IntegerLiteral *il;
 216         isl_val *v;
 217         isl_ctx *ctx;
 218         isl_id *id;
 219         isl_space *space;
 220         isl_set *set;
 221
 222         vd = cast<VarDecl>(decl);
 223         if (!vd)
 224                 return value;
 225         if (!vd->getType()->isIntegerType())
 226                 return value;
 227         expr = vd->getInit();
 228         if (!expr)
 229                 return value;
 230         il = cast<IntegerLiteral>(expr);
 231         if (!il)
 232                 return value;
 233
 234         ctx = isl_set_get_ctx(value);
 235         id = isl_id_alloc(ctx, vd->getName().str().c_str(), vd);
 236         space = isl_space_params_alloc(ctx, 1);
 237         space = isl_space_set_dim_id(space, isl_dim_param, 0, id);
 238         set = isl_set_universe(space);
 239
 240         v = PetScan::extract_int(ctx, il);
 241         set = isl_set_fix_val(set, isl_dim_param, 0, v);
 242
 243         return isl_set_intersect(value, set);
 244 }
 245
 246 /* Handle pragmas of the form
 247  *
 248  *      #pragma parameter identifier lower_bound
 249  * and
 250  *      #pragma parameter identifier lower_bound upper_bound
 251  *
 252  * For each such pragma, intersect the context with the set
 253  * [identifier] -> { [] : lower_bound <= identifier <= upper_bound }
 254  */
 255 struct PragmaParameterHandler : public PragmaHandler {
 256         Sema &sema;
 257         isl_set *&context;
 258         isl_set *&context_value;
 259
 260         PragmaParameterHandler(Sema &sema, isl_set *&context,
 261                 isl_set *&context_value) :
 262                 PragmaHandler("parameter"), sema(sema), context(context),
 263                 context_value(context_value) {}
 264
 265         virtual void HandlePragma(Preprocessor &PP,
 266                                   PragmaIntroducerKind Introducer,
 267                                   Token &ScopTok) {
 268                 isl_id *id;
 269                 isl_ctx *ctx = isl_set_get_ctx(context);
 270                 isl_space *dim;
 271                 isl_set *set;
 272                 ValueDecl *vd;
 273                 Token token;
 274                 int lb;
 275                 int ub;
 276                 bool has_ub = false;
 277
 278                 PP.Lex(token);
 279                 vd = get_value_decl(sema, token);
 280                 if (!vd) {
 281                         unsupported(PP, token.getLocation());
 282                         return;
 283                 }
 284
 285                 PP.Lex(token);
 286                 if (!token.isLiteral()) {
 287                         unsupported(PP, token.getLocation());
 288                         return;
 289                 }
 290
 291                 lb = get_int(token.getLiteralData());
 292
 293                 PP.Lex(token);
 294                 if (token.isLiteral()) {
 295                         has_ub = true;
 296                         ub = get_int(token.getLiteralData());
 297                 } else if (token.isNot(tok::eod)) {
 298                         unsupported(PP, token.getLocation());
 299                         return;
 300                 }
 301
 302                 id = isl_id_alloc(ctx, vd->getName().str().c_str(), vd);
 303                 dim = isl_space_params_alloc(ctx, 1);
 304                 dim = isl_space_set_dim_id(dim, isl_dim_param, 0, id);
 305
 306                 set = isl_set_universe(dim);
 307
 308                 set = isl_set_lower_bound_si(set, isl_dim_param, 0, lb);
 309                 if (has_ub)
 310                         set = isl_set_upper_bound_si(set, isl_dim_param, 0, ub);
 311
 312                 context = isl_set_intersect(context, set);
 313
 314                 context_value = extract_initialization(context_value, vd);
 315         }
 316 };
 317
 318 /* Handle pragmas of the form
 319  *
 320  *      #pragma pencil independent
 321  *
 322  * For each such pragma, add an entry to the "independent" vector.
 323  */
 324 struct PragmaPencilHandler : public PragmaHandler {
 325         std::vector<Independent> &independent;
 326
 327         PragmaPencilHandler(std::vector<Independent> &independent) :
 328                 PragmaHandler("pencil"), independent(independent) {}
 329
 330         virtual void HandlePragma(Preprocessor &PP,
 331                                   PragmaIntroducerKind Introducer,
 332                                   Token &PencilTok) {
 333                 Token token;
 334                 IdentifierInfo *info;
 335
 336                 PP.Lex(token);
 337                 if (token.isNot(tok::identifier))
 338                         return;
 339
 340                 info = token.getIdentifierInfo();
 341                 if (!info->isStr("independent"))
 342                         return;
 343
 344                 PP.Lex(token);
 345                 if (token.isNot(tok::eod))
 346                         return;
 347
 348                 SourceManager &SM = PP.getSourceManager();
 349                 SourceLocation sloc = PencilTok.getLocation();
 350                 unsigned line = SM.getExpansionLineNumber(sloc);
 351                 independent.push_back(Independent(line));
 352         }
 353 };
 354
 355 #ifdef HAVE_TRANSLATELINECOL
 356
 357 /* Return a SourceLocation for line "line", column "col" of file "FID".
 358  */
 359 SourceLocation translateLineCol(SourceManager &SM, FileID FID, unsigned line,
 360         unsigned col)
 361 {
 362         return SM.translateLineCol(FID, line, col);
 363 }
 364
 365 #else
 366
 367 /* Return a SourceLocation for line "line", column "col" of file "FID".
 368  */
 369 SourceLocation translateLineCol(SourceManager &SM, FileID FID, unsigned line,
 370         unsigned col)
 371 {
 372         return SM.getLocation(SM.getFileEntryForID(FID), line, col);
 373 }
 374
 375 #endif
 376
 377 /* List of pairs of #pragma scop and #pragma endscop locations.
 378  */
 379 struct ScopLocList {
 380         std::vector<ScopLoc> list;
 381
 382         /* Add a new start (#pragma scop) location to the list.
 383          * If the last #pragma scop did not have a matching
 384          * #pragma endscop then overwrite it.
 385          * "start" points to the location of the scop pragma.
 386          */
 387         void add_start(SourceManager &SM, SourceLocation start) {
 388                 ScopLoc loc;
 389
 390                 loc.scop = start;
 391                 int line = SM.getExpansionLineNumber(start);
 392                 start = translateLineCol(SM, SM.getFileID(start), line, 1);
 393                 loc.start_line = line;
 394                 loc.start = SM.getFileOffset(start);
 395                 if (list.size() == 0 || list[list.size() - 1].end != 0)
 396                         list.push_back(loc);
 397                 else
 398                         list[list.size() - 1] = loc;
 399         }
 400
 401         /* Set the end location (#pragma endscop) of the last pair
 402          * in the list.
 403          * If there is no such pair of if the end of that pair
 404          * is already set, then ignore the spurious #pragma endscop.
 405          * "end" points to the location of the endscop pragma.
 406          */
 407         void add_end(SourceManager &SM, SourceLocation end) {
 408                 if (list.size() == 0 || list[list.size() - 1].end != 0)
 409                         return;
 410                 list[list.size() - 1].endscop = end;
 411                 int line = SM.getExpansionLineNumber(end);
 412                 end = translateLineCol(SM, SM.getFileID(end), line + 1, 1);
 413                 list[list.size() - 1].end = SM.getFileOffset(end);
 414         }
 415 };
 416
 417 /* Handle pragmas of the form
 418  *
 419  *      #pragma scop
 420  *
 421  * In particular, store the location of the line containing
 422  * the pragma in the list "scops".
 423  */
 424 struct PragmaScopHandler : public PragmaHandler {
 425         ScopLocList &scops;
 426
 427         PragmaScopHandler(ScopLocList &scops) :
 428                 PragmaHandler("scop"), scops(scops) {}
 429
 430         virtual void HandlePragma(Preprocessor &PP,
 431                                   PragmaIntroducerKind Introducer,
 432                                   Token &ScopTok) {
 433                 SourceManager &SM = PP.getSourceManager();
 434                 SourceLocation sloc = ScopTok.getLocation();
 435                 scops.add_start(SM, sloc);
 436         }
 437 };
 438
 439 /* Handle pragmas of the form
 440  *
 441  *      #pragma endscop
 442  *
 443  * In particular, store the location of the line following the one containing
 444  * the pragma in the list "scops".
 445  */
 446 struct PragmaEndScopHandler : public PragmaHandler {
 447         ScopLocList &scops;
 448
 449         PragmaEndScopHandler(ScopLocList &scops) :
 450                 PragmaHandler("endscop"), scops(scops) {}
 451
 452         virtual void HandlePragma(Preprocessor &PP,
 453                                   PragmaIntroducerKind Introducer,
 454                                   Token &EndScopTok) {
 455                 SourceManager &SM = PP.getSourceManager();
 456                 SourceLocation sloc = EndScopTok.getLocation();
 457                 scops.add_end(SM, sloc);
 458         }
 459 };
 460
 461 /* Handle pragmas of the form
 462  *
 463  *      #pragma live-out identifier, identifier, ...
 464  *
 465  * Each identifier on the line is stored in live_out.
 466  */
 467 struct PragmaLiveOutHandler : public PragmaHandler {
 468         Sema &sema;
 469         set<ValueDecl *> &live_out;
 470
 471         PragmaLiveOutHandler(Sema &sema, set<ValueDecl *> &live_out) :
 472                 PragmaHandler("live"), sema(sema), live_out(live_out) {}
 473
 474         virtual void HandlePragma(Preprocessor &PP,
 475                                   PragmaIntroducerKind Introducer,
 476                                   Token &ScopTok) {
 477                 Token token;
 478
 479                 PP.Lex(token);
 480                 if (token.isNot(tok::minus))
 481                         return;
 482                 PP.Lex(token);
 483                 if (token.isNot(tok::identifier) ||
 484                     !token.getIdentifierInfo()->isStr("out"))
 485                         return;
 486
 487                 PP.Lex(token);
 488                 while (token.isNot(tok::eod)) {
 489                         ValueDecl *vd;
 490
 491                         vd = get_value_decl(sema, token);
 492                         if (!vd) {
 493                                 unsupported(PP, token.getLocation());
 494                                 return;
 495                         }
 496                         live_out.insert(vd);
 497                         PP.Lex(token);
 498                         if (token.is(tok::comma))
 499                                 PP.Lex(token);
 500                 }
 501         }
 502 };
 503
 504 /* For each array in "scop", set its value_bounds property
 505  * based on the information in "value_bounds" and
 506  * mark it as live_out if it appears in "live_out".
 507  */
 508 static void update_arrays(struct pet_scop *scop,
 509         __isl_take isl_union_map *value_bounds, set<ValueDecl *> &live_out)
 510 {
 511         set<ValueDecl *>::iterator lo_it;
 512         isl_ctx *ctx = isl_union_map_get_ctx(value_bounds);
 513
 514         if (!scop) {
 515                 isl_union_map_free(value_bounds);
 516                 return;
 517         }
 518
 519         for (int i = 0; i < scop->n_array; ++i) {
 520                 isl_id *id;
 521                 isl_space *space;
 522                 isl_map *bounds;
 523                 ValueDecl *decl;
 524                 pet_array *array = scop->arrays[i];
 525
 526                 id = isl_set_get_tuple_id(array->extent);
 527                 decl = pet_id_get_decl(id);
 528
 529                 space = isl_space_alloc(ctx, 0, 0, 1);
 530                 space = isl_space_set_tuple_id(space, isl_dim_in, id);
 531
 532                 bounds = isl_union_map_extract_map(value_bounds, space);
 533                 if (!isl_map_plain_is_empty(bounds))
 534                         array->value_bounds = isl_map_range(bounds);
 535                 else
 536                         isl_map_free(bounds);
 537
 538                 lo_it = live_out.find(decl);
 539                 if (lo_it != live_out.end())
 540                         array->live_out = 1;
 541         }
 542
 543         isl_union_map_free(value_bounds);
 544 }
 545
 546 /* Extract a pet_scop (if any) from each appropriate function.
 547  * Each detected scop is passed to "fn".
 548  * When autodetecting, at most one scop is extracted from each function.
 549  * If "function" is not NULL, then we only extract a pet_scop if the
 550  * name of the function matches.
 551  * If "autodetect" is false, then we only extract if we have seen
 552  * scop and endscop pragmas and if these are situated inside the function
 553  * body.
 554  */
 555 struct PetASTConsumer : public ASTConsumer {
 556         Preprocessor &PP;
 557         ASTContext &ast_context;
 558         DiagnosticsEngine &diags;
 559         ScopLocList &scops;
 560         std::vector<Independent> independent;
 561         const char *function;
 562         pet_options *options;
 563         isl_ctx *ctx;
 564         isl_set *context;
 565         isl_set *context_value;
 566         set<ValueDecl *> live_out;
 567         PragmaValueBoundsHandler *vb_handler;
 568         isl_stat (*fn)(struct pet_scop *scop, void *user);
 569         void *user;
 570         bool error;
 571
 572         PetASTConsumer(isl_ctx *ctx, Preprocessor &PP, ASTContext &ast_context,
 573                 DiagnosticsEngine &diags, ScopLocList &scops,
 574                 const char *function, pet_options *options,
 575                 isl_stat (*fn)(struct pet_scop *scop, void *user), void *user) :
 576                 PP(PP), ast_context(ast_context), diags(diags),
 577                 scops(scops), function(function), options(options),
 578                 ctx(ctx),
 579                 vb_handler(NULL), fn(fn), user(user), error(false)
 580         {
 581                 isl_space *space;
 582                 space = isl_space_params_alloc(ctx, 0);
 583                 context = isl_set_universe(isl_space_copy(space));
 584                 context_value = isl_set_universe(space);
 585         }
 586
 587         ~PetASTConsumer() {
 588                 isl_set_free(context);
 589                 isl_set_free(context_value);
 590         }
 591
 592         void handle_value_bounds(Sema *sema) {
 593                 vb_handler = new PragmaValueBoundsHandler(ctx, *sema);
 594                 PP.AddPragmaHandler(vb_handler);
 595         }
 596
 597         /* Add all pragma handlers to this->PP.
 598          * The pencil pragmas are only handled if the pencil option is set.
 599          */
 600         void add_pragma_handlers(Sema *sema) {
 601                 PP.AddPragmaHandler(new PragmaParameterHandler(*sema, context,
 602                                                                 context_value));
 603                 if (options->pencil) {
 604                         PragmaHandler *PH;
 605                         PH = new PragmaPencilHandler(independent);
 606                         PP.AddPragmaHandler(PH);
 607                 }
 608                 handle_value_bounds(sema);
 609         }
 610
 611         __isl_give isl_union_map *get_value_bounds() {
 612                 return isl_union_map_copy(vb_handler->value_bounds);
 613         }
 614
 615         /* Pass "scop" to "fn" after performing some postprocessing.
 616          * In particular, add the context and value_bounds constraints
 617          * speficied through pragmas, add reference identifiers and
 618          * reset user pointers on parameters and tuple ids.
 619          *
 620          * If "scop" does not contain any statements and autodetect
 621          * is turned on, then skip it.
 622          */
 623         void call_fn(pet_scop *scop) {
 624                 if (!scop) {
 625                         error = true;
 626                         return;
 627                 }
 628                 if (diags.hasErrorOccurred()) {
 629                         error = true;
 630                         pet_scop_free(scop);
 631                         return;
 632                 }
 633                 if (options->autodetect && scop->n_stmt == 0) {
 634                         pet_scop_free(scop);
 635                         return;
 636                 }
 637                 scop->context = isl_set_intersect(scop->context,
 638                                                 isl_set_copy(context));
 639                 scop->context_value = isl_set_intersect(scop->context_value,
 640                                                 isl_set_copy(context_value));
 641
 642                 update_arrays(scop, get_value_bounds(), live_out);
 643
 644                 scop = pet_scop_add_ref_ids(scop);
 645                 scop = pet_scop_anonymize(scop);
 646
 647                 if (fn(scop, user) < 0)
 648                         error = true;
 649         }
 650
 651         /* For each explicitly marked scop (using pragmas),
 652          * extract the scop and call "fn" on it if it is inside "fd".
 653          */
 654         void scan_scops(FunctionDecl *fd) {
 655                 unsigned start, end;
 656                 vector<ScopLoc>::iterator it;
 657                 isl_union_map *vb = vb_handler->value_bounds;
 658                 SourceManager &SM = PP.getSourceManager();
 659                 pet_scop *scop;
 660
 661                 if (scops.list.size() == 0)
 662                         return;
 663
 664                 start = SM.getFileOffset(fd->getLocStart());
 665                 end = SM.getFileOffset(fd->getLocEnd());
 666
 667                 for (it = scops.list.begin(); it != scops.list.end(); ++it) {
 668                         ScopLoc loc = *it;
 669                         if (!loc.end)
 670                                 continue;
 671                         if (start > loc.end)
 672                                 continue;
 673                         if (end < loc.start)
 674                                 continue;
 675                         PetScan ps(PP, ast_context, fd, loc, options,
 676                                     isl_union_map_copy(vb), independent);
 677                         scop = ps.scan(fd);
 678                         call_fn(scop);
 679                 }
 680         }
 681
 682         virtual HandleTopLevelDeclReturn HandleTopLevelDecl(DeclGroupRef dg) {
 683                 DeclGroupRef::iterator it;
 684
 685                 if (error)
 686                         return HandleTopLevelDeclContinue;
 687
 688                 for (it = dg.begin(); it != dg.end(); ++it) {
 689                         isl_union_map *vb = vb_handler->value_bounds;
 690                         FunctionDecl *fd = dyn_cast<clang::FunctionDecl>(*it);
 691                         if (!fd)
 692                                 continue;
 693                         if (!fd->hasBody())
 694                                 continue;
 695                         if (function &&
 696                             fd->getNameInfo().getAsString() != function)
 697                                 continue;
 698                         if (options->autodetect) {
 699                                 ScopLoc loc;
 700                                 pet_scop *scop;
 701                                 PetScan ps(PP, ast_context, fd, loc, options,
 702                                             isl_union_map_copy(vb),
 703                                             independent);
 704                                 scop = ps.scan(fd);
 705                                 call_fn(scop);
 706                                 continue;
 707                         }
 708                         scan_scops(fd);
 709                 }
 710
 711                 return HandleTopLevelDeclContinue;
 712         }
 713 };
 714
 715 static const char *ResourceDir =
 716         CLANG_PREFIX "/lib/clang/" CLANG_VERSION_STRING;
 717
 718 static const char *implicit_functions[] = {
 719         "min", "max", "intMod", "intCeil", "intFloor", "ceild", "floord"
 720 };
 721 static const char *pencil_implicit_functions[] = {
 722         "imin", "umin", "imax", "umax", "__pencil_kill"
 723 };
 724
 725 /* Should "ident" be treated as an implicit function?
 726  * If "pencil" is set, then also allow pencil specific builtins.
 727  */
 728 static bool is_implicit(const IdentifierInfo *ident, int pencil)
 729 {
 730         const char *name = ident->getNameStart();
 731         for (size_t i = 0; i < ARRAY_SIZE(implicit_functions); ++i)
 732                 if (!strcmp(name, implicit_functions[i]))
 733                         return true;
 734         if (!pencil)
 735                 return false;
 736         for (size_t i = 0; i < ARRAY_SIZE(pencil_implicit_functions); ++i)
 737                 if (!strcmp(name, pencil_implicit_functions[i]))
 738                         return true;
 739         return false;
 740 }
 741
 742 /* Ignore implicit function declaration warnings on
 743  * "min", "max", "ceild" and "floord" as we detect and handle these
 744  * in PetScan.
 745  * If "pencil" is set, then also ignore them on pencil specific
 746  * builtins.
 747  */
 748 struct MyDiagnosticPrinter : public TextDiagnosticPrinter {
 749         const DiagnosticOptions *DiagOpts;
 750         int pencil;
 751 #ifdef HAVE_BASIC_DIAGNOSTICOPTIONS_H
 752         MyDiagnosticPrinter(DiagnosticOptions *DO, int pencil) :
 753                 TextDiagnosticPrinter(llvm::errs(), DO), pencil(pencil) {}
 754         virtual DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
 755                 return new MyDiagnosticPrinter(&Diags.getDiagnosticOptions(),
 756                                                 pencil);
 757         }
 758 #else
 759         MyDiagnosticPrinter(const DiagnosticOptions &DO, int pencil) :
 760                 DiagOpts(&DO), TextDiagnosticPrinter(llvm::errs(), DO),
 761                 pencil(pencil) {}
 762         virtual DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
 763                 return new MyDiagnosticPrinter(*DiagOpts, pencil);
 764         }
 765 #endif
 766         virtual void HandleDiagnostic(DiagnosticsEngine::Level level,
 767                                         const DiagnosticInfo &info) {
 768                 if (info.getID() == diag::ext_implicit_function_decl &&
 769                     info.getNumArgs() == 1 &&
 770                     info.getArgKind(0) == DiagnosticsEngine::ak_identifierinfo &&
 771                     is_implicit(info.getArgIdentifier(0), pencil))
 772                         /* ignore warning */;
 773                 else
 774                         TextDiagnosticPrinter::HandleDiagnostic(level, info);
 775         }
 776 };
 777
 778 #ifdef USE_ARRAYREF
 779
 780 #ifdef HAVE_CXXISPRODUCTION
 781 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
 782 {
 783         return new Driver(binary, llvm::sys::getDefaultTargetTriple(),
 784                             "", false, false, Diags);
 785 }
 786 #elif defined(HAVE_ISPRODUCTION)
 787 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
 788 {
 789         return new Driver(binary, llvm::sys::getDefaultTargetTriple(),
 790                             "", false, Diags);
 791 }
 792 #elif defined(DRIVER_CTOR_TAKES_DEFAULTIMAGENAME)
 793 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
 794 {
 795         return new Driver(binary, llvm::sys::getDefaultTargetTriple(),
 796                             "", Diags);
 797 }
 798 #else
 799 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
 800 {
 801         return new Driver(binary, llvm::sys::getDefaultTargetTriple(), Diags);
 802 }
 803 #endif
 804
 805 namespace clang { namespace driver { class Job; } }
 806
 807 /* Clang changed its API from 3.5 to 3.6 and once more in 3.7.
 808  * We fix this with a simple overloaded function here.
 809  */
 810 struct ClangAPI {
 811         static Job *command(Job *J) { return J; }
 812         static Job *command(Job &J) { return &J; }
 813         static Command *command(Command &C) { return &C; }
 814 };
 815
 816 /* Create a CompilerInvocation object that stores the command line
 817  * arguments constructed by the driver.
 818  * The arguments are mainly useful for setting up the system include
 819  * paths on newer clangs and on some platforms.
 820  */
 821 static CompilerInvocation *construct_invocation(const char *filename,
 822         DiagnosticsEngine &Diags)
 823 {
 824         const char *binary = CLANG_PREFIX"/bin/clang";
 825         const unique_ptr<Driver> driver(construct_driver(binary, Diags));
 826         std::vector<const char *> Argv;
 827         Argv.push_back(binary);
 828         Argv.push_back(filename);
 829         const unique_ptr<Compilation> compilation(
 830                 driver->BuildCompilation(llvm::ArrayRef<const char *>(Argv)));
 831         JobList &Jobs = compilation->getJobs();
 832         if (Jobs.size() < 1)
 833                 return NULL;
 834
 835         Command *cmd = cast<Command>(ClangAPI::command(*Jobs.begin()));
 836         if (strcmp(cmd->getCreator().getName(), "clang"))
 837                 return NULL;
 838
 839         const ArgStringList *args = &cmd->getArguments();
 840
 841         CompilerInvocation *invocation = new CompilerInvocation;
 842         CompilerInvocation::CreateFromArgs(*invocation, args->data() + 1,
 843                                                 args->data() + args->size(),
 844                                                 Diags);
 845         return invocation;
 846 }
 847
 848 #else
 849
 850 static CompilerInvocation *construct_invocation(const char *filename,
 851         DiagnosticsEngine &Diags)
 852 {
 853         return NULL;
 854 }
 855
 856 #endif
 857
 858 #ifdef HAVE_BASIC_DIAGNOSTICOPTIONS_H
 859
 860 static MyDiagnosticPrinter *construct_printer(CompilerInstance *Clang,
 861         int pencil)
 862 {
 863         return new MyDiagnosticPrinter(new DiagnosticOptions(), pencil);
 864 }
 865
 866 #else
 867
 868 static MyDiagnosticPrinter *construct_printer(CompilerInstance *Clang,
 869         int pencil)
 870 {
 871         return new MyDiagnosticPrinter(Clang->getDiagnosticOpts(), pencil);
 872 }
 873
 874 #endif
 875
 876 #ifdef CREATETARGETINFO_TAKES_SHARED_PTR
 877
 878 static TargetInfo *create_target_info(CompilerInstance *Clang,
 879         DiagnosticsEngine &Diags)
 880 {
 881         shared_ptr<TargetOptions> TO = Clang->getInvocation().TargetOpts;
 882         TO->Triple = llvm::sys::getDefaultTargetTriple();
 883         return TargetInfo::CreateTargetInfo(Diags, TO);
 884 }
 885
 886 #elif defined(CREATETARGETINFO_TAKES_POINTER)
 887
 888 static TargetInfo *create_target_info(CompilerInstance *Clang,
 889         DiagnosticsEngine &Diags)
 890 {
 891         TargetOptions &TO = Clang->getTargetOpts();
 892         TO.Triple = llvm::sys::getDefaultTargetTriple();
 893         return TargetInfo::CreateTargetInfo(Diags, &TO);
 894 }
 895
 896 #else
 897
 898 static TargetInfo *create_target_info(CompilerInstance *Clang,
 899         DiagnosticsEngine &Diags)
 900 {
 901         TargetOptions &TO = Clang->getTargetOpts();
 902         TO.Triple = llvm::sys::getDefaultTargetTriple();
 903         return TargetInfo::CreateTargetInfo(Diags, TO);
 904 }
 905
 906 #endif
 907
 908 #ifdef CREATEDIAGNOSTICS_TAKES_ARG
 909
 910 static void create_diagnostics(CompilerInstance *Clang)
 911 {
 912         Clang->createDiagnostics(0, NULL);
 913 }
 914
 915 #else
 916
 917 static void create_diagnostics(CompilerInstance *Clang)
 918 {
 919         Clang->createDiagnostics();
 920 }
 921
 922 #endif
 923
 924 #ifdef CREATEPREPROCESSOR_TAKES_TUKIND
 925
 926 static void create_preprocessor(CompilerInstance *Clang)
 927 {
 928         Clang->createPreprocessor(TU_Complete);
 929 }
 930
 931 #else
 932
 933 static void create_preprocessor(CompilerInstance *Clang)
 934 {
 935         Clang->createPreprocessor();
 936 }
 937
 938 #endif
 939
 940 #ifdef ADDPATH_TAKES_4_ARGUMENTS
 941
 942 void add_path(HeaderSearchOptions &HSO, string Path)
 943 {
 944         HSO.AddPath(Path, frontend::Angled, false, false);
 945 }
 946
 947 #else
 948
 949 void add_path(HeaderSearchOptions &HSO, string Path)
 950 {
 951         HSO.AddPath(Path, frontend::Angled, true, false, false);
 952 }
 953
 954 #endif
 955
 956 #ifdef HAVE_SETMAINFILEID
 957
 958 static void create_main_file_id(SourceManager &SM, const FileEntry *file)
 959 {
 960         SM.setMainFileID(SM.createFileID(file, SourceLocation(),
 961                                         SrcMgr::C_User));
 962 }
 963
 964 #else
 965
 966 static void create_main_file_id(SourceManager &SM, const FileEntry *file)
 967 {
 968         SM.createMainFileID(file);
 969 }
 970
 971 #endif
 972
 973 #ifdef SETLANGDEFAULTS_TAKES_5_ARGUMENTS
 974
 975 static void set_lang_defaults(CompilerInstance *Clang)
 976 {
 977         PreprocessorOptions &PO = Clang->getPreprocessorOpts();
 978         TargetOptions &TO = Clang->getTargetOpts();
 979         llvm::Triple T(TO.Triple);
 980         CompilerInvocation::setLangDefaults(Clang->getLangOpts(), IK_C, T, PO,
 981                                             LangStandard::lang_unspecified);
 982 }
 983
 984 #else
 985
 986 static void set_lang_defaults(CompilerInstance *Clang)
 987 {
 988         CompilerInvocation::setLangDefaults(Clang->getLangOpts(), IK_C,
 989                                             LangStandard::lang_unspecified);
 990 }
 991
 992 #endif
 993
 994 #ifdef SETINVOCATION_TAKES_SHARED_PTR
 995
 996 static void set_invocation(CompilerInstance *Clang,
 997         CompilerInvocation *invocation)
 998 {
 999         Clang->setInvocation(std::shared_ptr<CompilerInvocation>(invocation));
1000 }
1001
1002 #else
1003
1004 static void set_invocation(CompilerInstance *Clang,
1005         CompilerInvocation *invocation)
1006 {
1007         Clang->setInvocation(invocation);
1008 }
1009
1010 #endif
1011
1012 /* Add pet specific predefines to the preprocessor.
1013  * Currently, these are all pencil specific, so they are only
1014  * added if "pencil" is set.
1015  *
1016  * We mimic the way <command line> is handled inside clang.
1017  */
1018 void add_predefines(Preprocessor &PP, int pencil)
1019 {
1020         string s;
1021
1022         if (!pencil)
1023                 return;
1024
1025         s = PP.getPredefines();
1026         s += "# 1 \"<pet>\" 1\n"
1027              "void __pencil_assume(int assumption);\n"
1028              "#define pencil_access(f) annotate(\"pencil_access(\" #f \")\")\n"
1029              "# 1 \"<built-in>\" 2\n";
1030         PP.setPredefines(s);
1031 }
1032
1033 /* Extract a pet_scop from each function in the C source file called "filename".
1034  * Each detected scop is passed to "fn".
1035  * If "function" is not NULL, only extract a pet_scop from the function
1036  * with that name.
1037  * If "autodetect" is set, extract any pet_scop we can find.
1038  * Otherwise, extract the pet_scop from the region delimited
1039  * by "scop" and "endscop" pragmas.
1040  *
1041  * We first set up the clang parser and then try to extract the
1042  * pet_scop from the appropriate function(s) in PetASTConsumer.
1043  */
1044 static isl_stat foreach_scop_in_C_source(isl_ctx *ctx,
1045         const char *filename, const char *function, pet_options *options,
1046         isl_stat (*fn)(struct pet_scop *scop, void *user), void *user)
1047 {
1048         CompilerInstance *Clang = new CompilerInstance();
1049         create_diagnostics(Clang);
1050         DiagnosticsEngine &Diags = Clang->getDiagnostics();
1051         Diags.setSuppressSystemWarnings(true);
1052         CompilerInvocation *invocation = construct_invocation(filename, Diags);
1053         if (invocation)
1054                 set_invocation(Clang, invocation);
1055         Diags.setClient(construct_printer(Clang, options->pencil));
1056         Clang->createFileManager();
1057         Clang->createSourceManager(Clang->getFileManager());
1058         TargetInfo *target = create_target_info(Clang, Diags);
1059         Clang->setTarget(target);
1060         set_lang_defaults(Clang);
1061         HeaderSearchOptions &HSO = Clang->getHeaderSearchOpts();
1062         HSO.ResourceDir = ResourceDir;
1063         for (int i = 0; i < options->n_path; ++i)
1064                 add_path(HSO, options->paths[i]);
1065         PreprocessorOptions &PO = Clang->getPreprocessorOpts();
1066         for (int i = 0; i < options->n_define; ++i)
1067                 PO.addMacroDef(options->defines[i]);
1068         create_preprocessor(Clang);
1069         Preprocessor &PP = Clang->getPreprocessor();
1070         add_predefines(PP, options->pencil);
1071         PP.getBuiltinInfo().initializeBuiltins(PP.getIdentifierTable(),
1072                 PP.getLangOpts());
1073
1074         ScopLocList scops;
1075
1076         const FileEntry *file = Clang->getFileManager().getFile(filename);
1077         if (!file)
1078                 isl_die(ctx, isl_error_unknown, "unable to open file",
1079                         do { delete Clang; return isl_stat_error; } while (0));
1080         create_main_file_id(Clang->getSourceManager(), file);
1081
1082         Clang->createASTContext();
1083         PetASTConsumer consumer(ctx, PP, Clang->getASTContext(), Diags,
1084                                 scops, function, options, fn, user);
1085         Sema *sema = new Sema(PP, Clang->getASTContext(), consumer);
1086
1087         if (!options->autodetect) {
1088                 PP.AddPragmaHandler(new PragmaScopHandler(scops));
1089                 PP.AddPragmaHandler(new PragmaEndScopHandler(scops));
1090                 PP.AddPragmaHandler(new PragmaLiveOutHandler(*sema,
1091                                                         consumer.live_out));
1092         }
1093
1094         consumer.add_pragma_handlers(sema);
1095
1096         Diags.getClient()->BeginSourceFile(Clang->getLangOpts(), &PP);
1097         ParseAST(*sema);
1098         Diags.getClient()->EndSourceFile();
1099
1100         delete sema;
1101         delete Clang;
1102
1103         return consumer.error ? isl_stat_error : isl_stat_ok;
1104 }
1105
1106 /* Extract a pet_scop from each function in the C source file called "filename".
1107  * Each detected scop is passed to "fn".
1108  *
1109  * This wrapper around foreach_scop_in_C_source is mainly used to ensure
1110  * that all objects on the stack (of that function) are destroyed before we
1111  * call llvm_shutdown.
1112  */
1113 static isl_stat pet_foreach_scop_in_C_source(isl_ctx *ctx,
1114         const char *filename, const char *function,
1115         isl_stat (*fn)(struct pet_scop *scop, void *user), void *user)
1116 {
1117         isl_stat r;
1118         pet_options *options;
1119         bool allocated = false;
1120
1121         options = isl_ctx_peek_pet_options(ctx);
1122         if (!options) {
1123                 options = pet_options_new_with_defaults();
1124                 allocated = true;
1125         }
1126
1127         r = foreach_scop_in_C_source(ctx, filename, function, options,
1128                                         fn, user);
1129         llvm::llvm_shutdown();
1130
1131         if (allocated)
1132                 pet_options_free(options);
1133
1134         return r;
1135 }
1136
1137 /* Store "scop" into the address pointed to by "user".
1138  * Return -1 to indicate that we are not interested in any further scops.
1139  * This function should therefore not be called a second call
1140  * so in principle there is no need to check if we have already set *user.
1141  */
1142 static isl_stat set_first_scop(pet_scop *scop, void *user)
1143 {
1144         pet_scop **p = (pet_scop **) user;
1145
1146         if (!*p)
1147                 *p = scop;
1148         else
1149                 pet_scop_free(scop);
1150
1151         return isl_stat_error;
1152 }
1153
1154 /* Extract a pet_scop from the C source file called "filename".
1155  * If "function" is not NULL, extract the pet_scop from the function
1156  * with that name.
1157  *
1158  * We start extracting scops from every function and then abort
1159  * as soon as we have extracted one scop.
1160  */
1161 struct pet_scop *pet_scop_extract_from_C_source(isl_ctx *ctx,
1162         const char *filename, const char *function)
1163 {
1164         pet_scop *scop = NULL;
1165
1166         pet_foreach_scop_in_C_source(ctx, filename, function,
1167                                         &set_first_scop, &scop);
1168
1169         return scop;
1170 }
1171
1172 /* Internal data structure for pet_transform_C_source
1173  *
1174  * transform is the function that should be called to print a scop
1175  * in is the input source file
1176  * out is the output source file
1177  * end is the offset of the end of the previous scop (zero if we have not
1178  *      found any scop yet)
1179  * p is a printer that prints to out.
1180  */
1181 struct pet_transform_data {
1182         __isl_give isl_printer *(*transform)(__isl_take isl_printer *p,
1183                 struct pet_scop *scop, void *user);
1184         void *user;
1185
1186         FILE *in;
1187         FILE *out;
1188         unsigned end;
1189         isl_printer *p;
1190 };
1191
1192 /* This function is called each time a scop is detected.
1193  *
1194  * We first copy the input text code from the end of the previous scop
1195  * until the start of "scop" and then print the scop itself through
1196  * a call to data->transform.  We set up the printer to print
1197  * the transformed code with the same (initial) indentation as
1198  * the original code.
1199  * Finally, we keep track of the end of "scop" so that we can
1200  * continue copying when we find the next scop.
1201  *
1202  * Before calling data->transform, we store a pointer to the original
1203  * input file in the extended scop in case the user wants to call
1204  * pet_scop_print_original from the callback.
1205  */
1206 static isl_stat pet_transform(struct pet_scop *scop, void *user)
1207 {
1208         struct pet_transform_data *data = (struct pet_transform_data *) user;
1209         unsigned start;
1210
1211         if (!scop)
1212                 return isl_stat_error;
1213         start = pet_loc_get_start(scop->loc);
1214         if (copy(data->in, data->out, data->end, start) < 0)
1215                 goto error;
1216         data->end = pet_loc_get_end(scop->loc);
1217         scop = pet_scop_set_input_file(scop, data->in);
1218         data->p = isl_printer_set_indent_prefix(data->p,
1219                                         pet_loc_get_indent(scop->loc));
1220         data->p = data->transform(data->p, scop, data->user);
1221         if (!data->p)
1222                 return isl_stat_error;
1223         return isl_stat_ok;
1224 error:
1225         pet_scop_free(scop);
1226         return isl_stat_error;
1227 }
1228
1229 /* Transform the C source file "input" by rewriting each scop
1230  * through a call to "transform".
1231  * When autodetecting scops, at most one scop per function is rewritten.
1232  * The transformed C code is written to "output".
1233  *
1234  * For each scop we find, we first copy the input text code
1235  * from the end of the previous scop (or the beginning of the file
1236  * in case of the first scop) until the start of the scop
1237  * and then print the scop itself through a call to "transform".
1238  * At the end we copy everything from the end of the final scop
1239  * until the end of the input file to "output".
1240  */
1241 int pet_transform_C_source(isl_ctx *ctx, const char *input, FILE *out,
1242         __isl_give isl_printer *(*transform)(__isl_take isl_printer *p,
1243                 struct pet_scop *scop, void *user), void *user)
1244 {
1245         struct pet_transform_data data;
1246         int r;
1247
1248         data.in = stdin;
1249         data.out = out;
1250         if (input && strcmp(input, "-")) {
1251                 data.in = fopen(input, "r");
1252                 if (!data.in)
1253                         isl_die(ctx, isl_error_unknown, "unable to open file",
1254                                 return -1);
1255         }
1256
1257         data.p = isl_printer_to_file(ctx, data.out);
1258         data.p = isl_printer_set_output_format(data.p, ISL_FORMAT_C);
1259
1260         data.transform = transform;
1261         data.user = user;
1262         data.end = 0;
1263         r = pet_foreach_scop_in_C_source(ctx, input, NULL,
1264                                         &pet_transform, &data);
1265
1266         isl_printer_free(data.p);
1267         if (!data.p)
1268                 r = -1;
1269         if (r == 0 && copy(data.in, data.out, data.end, -1) < 0)
1270                 r = -1;
1271
1272         if (data.in != stdin)
1273                 fclose(data.in);
1274
1275         return r;
1276 }