pet.cc

   1 /*
   2  * Copyright 2011 Leiden University. All rights reserved.
   3  * Copyright 2012 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 <iostream>
  40 #include <llvm/Support/raw_ostream.h>
  41 #include <llvm/Support/ManagedStatic.h>
  42 #include <llvm/Support/Host.h>
  43 #include <clang/Basic/Version.h>
  44 #include <clang/Basic/FileSystemOptions.h>
  45 #include <clang/Basic/FileManager.h>
  46 #include <clang/Basic/TargetOptions.h>
  47 #include <clang/Basic/TargetInfo.h>
  48 #include <clang/Driver/Compilation.h>
  49 #include <clang/Driver/Driver.h>
  50 #include <clang/Driver/Tool.h>
  51 #include <clang/Frontend/CompilerInstance.h>
  52 #include <clang/Frontend/CompilerInvocation.h>
  53 #ifdef HAVE_BASIC_DIAGNOSTICOPTIONS_H
  54 #include <clang/Basic/DiagnosticOptions.h>
  55 #else
  56 #include <clang/Frontend/DiagnosticOptions.h>
  57 #endif
  58 #include <clang/Frontend/TextDiagnosticPrinter.h>
  59 #ifdef HAVE_LEX_HEADERSEARCHOPTIONS_H
  60 #include <clang/Lex/HeaderSearchOptions.h>
  61 #else
  62 #include <clang/Frontend/HeaderSearchOptions.h>
  63 #endif
  64 #include <clang/Frontend/LangStandard.h>
  65 #ifdef HAVE_LEX_PREPROCESSOROPTIONS_H
  66 #include <clang/Lex/PreprocessorOptions.h>
  67 #else
  68 #include <clang/Frontend/PreprocessorOptions.h>
  69 #endif
  70 #include <clang/Frontend/FrontendOptions.h>
  71 #include <clang/Frontend/Utils.h>
  72 #include <clang/Lex/HeaderSearch.h>
  73 #include <clang/Lex/Preprocessor.h>
  74 #include <clang/Lex/Pragma.h>
  75 #include <clang/AST/ASTContext.h>
  76 #include <clang/AST/ASTConsumer.h>
  77 #include <clang/Sema/Sema.h>
  78 #include <clang/Sema/SemaDiagnostic.h>
  79 #include <clang/Parse/Parser.h>
  80 #include <clang/Parse/ParseAST.h>
  81
  82 #include <isl/ctx.h>
  83 #include <isl/constraint.h>
  84
  85 #include "options.h"
  86 #include "scan.h"
  87
  88 #define ARRAY_SIZE(array) (sizeof(array)/sizeof(*array))
  89
  90 using namespace std;
  91 using namespace clang;
  92 using namespace clang::driver;
  93
  94 /* Called if we found something we didn't expect in one of the pragmas.
  95  * We'll provide more informative warnings later.
  96  */
  97 static void unsupported(Preprocessor &PP, SourceLocation loc)
  98 {
  99         DiagnosticsEngine &diag = PP.getDiagnostics();
 100         unsigned id = diag.getCustomDiagID(DiagnosticsEngine::Warning,
 101                                            "unsupported");
 102         DiagnosticBuilder B = diag.Report(loc, id);
 103 }
 104
 105 static int get_int(const char *s)
 106 {
 107         return s[0] == '"' ? atoi(s + 1) : atoi(s);
 108 }
 109
 110 static ValueDecl *get_value_decl(Sema &sema, Token &token)
 111 {
 112         IdentifierInfo *name;
 113         Decl *decl;
 114
 115         if (token.isNot(tok::identifier))
 116                 return NULL;
 117
 118         name = token.getIdentifierInfo();
 119         decl = sema.LookupSingleName(sema.TUScope, name,
 120                                 token.getLocation(), Sema::LookupOrdinaryName);
 121         return decl ? cast_or_null<ValueDecl>(decl) : NULL;
 122 }
 123
 124 /* Handle pragmas of the form
 125  *
 126  *      #pragma value_bounds identifier lower_bound upper_bound
 127  *
 128  * For each such pragma, add a mapping
 129  *      { identifier[] -> [i] : lower_bound <= i <= upper_bound }
 130  * to value_bounds.
 131  */
 132 struct PragmaValueBoundsHandler : public PragmaHandler {
 133         Sema &sema;
 134         isl_ctx *ctx;
 135         isl_union_map *value_bounds;
 136
 137         PragmaValueBoundsHandler(isl_ctx *ctx, Sema &sema) :
 138             PragmaHandler("value_bounds"), ctx(ctx), sema(sema) {
 139                 isl_space *space = isl_space_params_alloc(ctx, 0);
 140                 value_bounds = isl_union_map_empty(space);
 141         }
 142
 143         ~PragmaValueBoundsHandler() {
 144                 isl_union_map_free(value_bounds);
 145         }
 146
 147         virtual void HandlePragma(Preprocessor &PP,
 148                                   PragmaIntroducerKind Introducer,
 149                                   Token &ScopTok) {
 150                 isl_id *id;
 151                 isl_space *dim;
 152                 isl_map *map;
 153                 ValueDecl *vd;
 154                 Token token;
 155                 int lb;
 156                 int ub;
 157
 158                 PP.Lex(token);
 159                 vd = get_value_decl(sema, token);
 160                 if (!vd) {
 161                         unsupported(PP, token.getLocation());
 162                         return;
 163                 }
 164
 165                 PP.Lex(token);
 166                 if (!token.isLiteral()) {
 167                         unsupported(PP, token.getLocation());
 168                         return;
 169                 }
 170
 171                 lb = get_int(token.getLiteralData());
 172
 173                 PP.Lex(token);
 174                 if (!token.isLiteral()) {
 175                         unsupported(PP, token.getLocation());
 176                         return;
 177                 }
 178
 179                 ub = get_int(token.getLiteralData());
 180
 181                 dim = isl_space_alloc(ctx, 0, 0, 1);
 182                 map = isl_map_universe(dim);
 183                 map = isl_map_lower_bound_si(map, isl_dim_out, 0, lb);
 184                 map = isl_map_upper_bound_si(map, isl_dim_out, 0, ub);
 185                 id = isl_id_alloc(ctx, vd->getName().str().c_str(), vd);
 186                 map = isl_map_set_tuple_id(map, isl_dim_in, id);
 187
 188                 value_bounds = isl_union_map_add_map(value_bounds, map);
 189         }
 190 };
 191
 192 /* Given a variable declaration, check if it has an integer initializer
 193  * and if so, add a parameter corresponding to the variable to "value"
 194  * with its value fixed to the integer initializer and return the result.
 195  */
 196 static __isl_give isl_set *extract_initialization(__isl_take isl_set *value,
 197         ValueDecl *decl)
 198 {
 199         VarDecl *vd;
 200         Expr *expr;
 201         IntegerLiteral *il;
 202         isl_int v;
 203         isl_ctx *ctx;
 204         isl_id *id;
 205         isl_space *space;
 206         isl_set *set;
 207
 208         vd = cast<VarDecl>(decl);
 209         if (!vd)
 210                 return value;
 211         if (!vd->getType()->isIntegerType())
 212                 return value;
 213         expr = vd->getInit();
 214         if (!expr)
 215                 return value;
 216         il = cast<IntegerLiteral>(expr);
 217         if (!il)
 218                 return value;
 219
 220         ctx = isl_set_get_ctx(value);
 221         id = isl_id_alloc(ctx, vd->getName().str().c_str(), vd);
 222         space = isl_space_params_alloc(ctx, 1);
 223         space = isl_space_set_dim_id(space, isl_dim_param, 0, id);
 224         set = isl_set_universe(space);
 225
 226         isl_int_init(v);
 227         PetScan::extract_int(il, &v);
 228         set = isl_set_fix(set, isl_dim_param, 0, v);
 229         isl_int_clear(v);
 230
 231         return isl_set_intersect(value, set);
 232 }
 233
 234 /* Handle pragmas of the form
 235  *
 236  *      #pragma parameter identifier lower_bound
 237  * and
 238  *      #pragma parameter identifier lower_bound upper_bound
 239  *
 240  * For each such pragma, intersect the context with the set
 241  * [identifier] -> { [] : lower_bound <= identifier <= upper_bound }
 242  */
 243 struct PragmaParameterHandler : public PragmaHandler {
 244         Sema &sema;
 245         isl_set *&context;
 246         isl_set *&context_value;
 247
 248         PragmaParameterHandler(Sema &sema, isl_set *&context,
 249                 isl_set *&context_value) :
 250                 PragmaHandler("parameter"), sema(sema), context(context),
 251                 context_value(context_value) {}
 252
 253         virtual void HandlePragma(Preprocessor &PP,
 254                                   PragmaIntroducerKind Introducer,
 255                                   Token &ScopTok) {
 256                 isl_id *id;
 257                 isl_ctx *ctx = isl_set_get_ctx(context);
 258                 isl_space *dim;
 259                 isl_set *set;
 260                 ValueDecl *vd;
 261                 Token token;
 262                 int lb;
 263                 int ub;
 264                 bool has_ub = false;
 265
 266                 PP.Lex(token);
 267                 vd = get_value_decl(sema, token);
 268                 if (!vd) {
 269                         unsupported(PP, token.getLocation());
 270                         return;
 271                 }
 272
 273                 PP.Lex(token);
 274                 if (!token.isLiteral()) {
 275                         unsupported(PP, token.getLocation());
 276                         return;
 277                 }
 278
 279                 lb = get_int(token.getLiteralData());
 280
 281                 PP.Lex(token);
 282                 if (token.isLiteral()) {
 283                         has_ub = true;
 284                         ub = get_int(token.getLiteralData());
 285                 } else if (token.isNot(tok::eod)) {
 286                         unsupported(PP, token.getLocation());
 287                         return;
 288                 }
 289
 290                 id = isl_id_alloc(ctx, vd->getName().str().c_str(), vd);
 291                 dim = isl_space_params_alloc(ctx, 1);
 292                 dim = isl_space_set_dim_id(dim, isl_dim_param, 0, id);
 293
 294                 set = isl_set_universe(dim);
 295
 296                 set = isl_set_lower_bound_si(set, isl_dim_param, 0, lb);
 297                 if (has_ub)
 298                         set = isl_set_upper_bound_si(set, isl_dim_param, 0, ub);
 299
 300                 context = isl_set_intersect(context, set);
 301
 302                 context_value = extract_initialization(context_value, vd);
 303         }
 304 };
 305
 306 /* Handle pragmas of the form
 307  *
 308  *      #pragma scop
 309  *
 310  * In particular, store the current location in loc.start.
 311  */
 312 struct PragmaScopHandler : public PragmaHandler {
 313         ScopLoc &loc;
 314
 315         PragmaScopHandler(ScopLoc &loc) : PragmaHandler("scop"), loc(loc) {}
 316
 317         virtual void HandlePragma(Preprocessor &PP,
 318                                   PragmaIntroducerKind Introducer,
 319                                   Token &ScopTok) {
 320                 SourceManager &SM = PP.getSourceManager();
 321                 loc.start = SM.getFileOffset(ScopTok.getLocation());
 322         }
 323 };
 324
 325 /* Handle pragmas of the form
 326  *
 327  *      #pragma endscop
 328  *
 329  * In particular, store the current location in loc.end.
 330  */
 331 struct PragmaEndScopHandler : public PragmaHandler {
 332         ScopLoc &loc;
 333
 334         PragmaEndScopHandler(ScopLoc &loc) :
 335                 PragmaHandler("endscop"), loc(loc) {}
 336
 337         virtual void HandlePragma(Preprocessor &PP,
 338                                   PragmaIntroducerKind Introducer,
 339                                   Token &EndScopTok) {
 340                 SourceManager &SM = PP.getSourceManager();
 341                 loc.end = SM.getFileOffset(EndScopTok.getLocation());
 342         }
 343 };
 344
 345 /* Handle pragmas of the form
 346  *
 347  *      #pragma live-out identifier, identifier, ...
 348  *
 349  * Each identifier on the line is stored in live_out.
 350  */
 351 struct PragmaLiveOutHandler : public PragmaHandler {
 352         Sema &sema;
 353         set<ValueDecl *> &live_out;
 354
 355         PragmaLiveOutHandler(Sema &sema, set<ValueDecl *> &live_out) :
 356                 PragmaHandler("live"), sema(sema), live_out(live_out) {}
 357
 358         virtual void HandlePragma(Preprocessor &PP,
 359                                   PragmaIntroducerKind Introducer,
 360                                   Token &ScopTok) {
 361                 Token token;
 362
 363                 PP.Lex(token);
 364                 if (token.isNot(tok::minus))
 365                         return;
 366                 PP.Lex(token);
 367                 if (token.isNot(tok::identifier) ||
 368                     !token.getIdentifierInfo()->isStr("out"))
 369                         return;
 370
 371                 PP.Lex(token);
 372                 while (token.isNot(tok::eod)) {
 373                         ValueDecl *vd;
 374
 375                         vd = get_value_decl(sema, token);
 376                         if (!vd) {
 377                                 unsupported(PP, token.getLocation());
 378                                 return;
 379                         }
 380                         live_out.insert(vd);
 381                         PP.Lex(token);
 382                         if (token.is(tok::comma))
 383                                 PP.Lex(token);
 384                 }
 385         }
 386 };
 387
 388 /* Extract a pet_scop from the appropriate function.
 389  * If "function" is not NULL, then we only extract a pet_scop if the
 390  * name of the function matches.
 391  * If "autodetect" is false, then we only extract if we have seen
 392  * scop and endscop pragmas and if these are situated inside the function
 393  * body.
 394  */
 395 struct PetASTConsumer : public ASTConsumer {
 396         Preprocessor &PP;
 397         ASTContext &ast_context;
 398         ScopLoc &loc;
 399         const char *function;
 400         pet_options *options;
 401         isl_ctx *ctx;
 402         struct pet_scop *scop;
 403         PragmaValueBoundsHandler *vb_handler;
 404
 405         PetASTConsumer(isl_ctx *ctx, Preprocessor &PP, ASTContext &ast_context,
 406                 ScopLoc &loc, const char *function, pet_options *options) :
 407                 ctx(ctx), PP(PP), ast_context(ast_context), loc(loc),
 408                 scop(NULL), function(function), options(options),
 409                 vb_handler(NULL) { }
 410
 411         void handle_value_bounds(Sema *sema) {
 412                 vb_handler = new PragmaValueBoundsHandler(ctx, *sema);
 413                 PP.AddPragmaHandler(vb_handler);
 414         }
 415
 416         __isl_give isl_union_map *get_value_bounds() {
 417                 return isl_union_map_copy(vb_handler->value_bounds);
 418         }
 419
 420         virtual HandleTopLevelDeclReturn HandleTopLevelDecl(DeclGroupRef dg) {
 421                 DeclGroupRef::iterator it;
 422
 423                 if (scop)
 424                         return HandleTopLevelDeclContinue;
 425                 for (it = dg.begin(); it != dg.end(); ++it) {
 426                         isl_union_map *vb = vb_handler->value_bounds;
 427                         FunctionDecl *fd = dyn_cast<clang::FunctionDecl>(*it);
 428                         if (!fd)
 429                                 continue;
 430                         if (!fd->hasBody())
 431                                 continue;
 432                         if (function &&
 433                             fd->getNameInfo().getAsString() != function)
 434                                 continue;
 435                         if (options->autodetect) {
 436                                 PetScan ps(PP, ast_context, loc, options,
 437                                             isl_union_map_copy(vb));
 438                                 scop = ps.scan(fd);
 439                                 if (scop)
 440                                         break;
 441                                 else
 442                                         continue;
 443                         }
 444                         if (!loc.end)
 445                                 continue;
 446                         SourceManager &SM = PP.getSourceManager();
 447                         if (SM.getFileOffset(fd->getLocStart()) > loc.end)
 448                                 continue;
 449                         if (SM.getFileOffset(fd->getLocEnd()) < loc.start)
 450                                 continue;
 451                         PetScan ps(PP, ast_context, loc, options,
 452                                     isl_union_map_copy(vb));
 453                         scop = ps.scan(fd);
 454                         break;
 455                 }
 456
 457                 return HandleTopLevelDeclContinue;
 458         }
 459 };
 460
 461 static const char *ResourceDir = CLANG_PREFIX"/lib/clang/"CLANG_VERSION_STRING;
 462
 463 static const char *implicit_functions[] = {
 464         "min", "max", "ceild", "floord"
 465 };
 466
 467 static bool is_implicit(const IdentifierInfo *ident)
 468 {
 469         const char *name = ident->getNameStart();
 470         for (int i = 0; i < ARRAY_SIZE(implicit_functions); ++i)
 471                 if (!strcmp(name, implicit_functions[i]))
 472                         return true;
 473         return false;
 474 }
 475
 476 /* Ignore implicit function declaration warnings on
 477  * "min", "max", "ceild" and "floord" as we detect and handle these
 478  * in PetScan.
 479  *
 480  * The cloned field keeps track of whether the clone method
 481  * has ever been called.  Newer clangs (by default) clone
 482  * the DiagnosticConsumer passed to createDiagnostics and
 483  * then take ownership of the clone, which means that
 484  * the original has to be deleted by the calling code.
 485  */
 486 struct MyDiagnosticPrinter : public TextDiagnosticPrinter {
 487         const DiagnosticOptions *DiagOpts;
 488         static bool cloned;
 489 #ifdef HAVE_BASIC_DIAGNOSTICOPTIONS_H
 490         MyDiagnosticPrinter(DiagnosticOptions *DO) :
 491                 TextDiagnosticPrinter(llvm::errs(), DO) {}
 492         virtual DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
 493                 cloned = true;
 494                 return new MyDiagnosticPrinter(&Diags.getDiagnosticOptions());
 495         }
 496 #else
 497         MyDiagnosticPrinter(const DiagnosticOptions &DO) :
 498                 DiagOpts(&DO), TextDiagnosticPrinter(llvm::errs(), DO) {}
 499         virtual DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
 500                 cloned = true;
 501                 return new MyDiagnosticPrinter(*DiagOpts);
 502         }
 503 #endif
 504         virtual void HandleDiagnostic(DiagnosticsEngine::Level level,
 505                                         const DiagnosticInfo &info) {
 506                 if (info.getID() == diag::ext_implicit_function_decl &&
 507                     info.getNumArgs() == 1 &&
 508                     info.getArgKind(0) == DiagnosticsEngine::ak_identifierinfo &&
 509                     is_implicit(info.getArgIdentifier(0)))
 510                         /* ignore warning */;
 511                 else
 512                         TextDiagnosticPrinter::HandleDiagnostic(level, info);
 513         }
 514 };
 515
 516 bool MyDiagnosticPrinter::cloned = false;
 517
 518 /* For each array in "scop", set its value_bounds property
 519  * based on the infofrmation in "value_bounds" and
 520  * mark it as live_out if it appears in "live_out".
 521  */
 522 static void update_arrays(struct pet_scop *scop,
 523         __isl_take isl_union_map *value_bounds, set<ValueDecl *> &live_out)
 524 {
 525         set<ValueDecl *>::iterator lo_it;
 526         isl_ctx *ctx = isl_union_map_get_ctx(value_bounds);
 527
 528         if (!scop) {
 529                 isl_union_map_free(value_bounds);
 530                 return;
 531         }
 532
 533         for (int i = 0; i < scop->n_array; ++i) {
 534                 isl_id *id;
 535                 isl_space *space;
 536                 isl_map *bounds;
 537                 ValueDecl *decl;
 538                 pet_array *array = scop->arrays[i];
 539
 540                 id = isl_set_get_tuple_id(array->extent);
 541                 decl = (ValueDecl *)isl_id_get_user(id);
 542
 543                 space = isl_space_alloc(ctx, 0, 0, 1);
 544                 space = isl_space_set_tuple_id(space, isl_dim_in, id);
 545
 546                 bounds = isl_union_map_extract_map(value_bounds, space);
 547                 if (!isl_map_plain_is_empty(bounds))
 548                         array->value_bounds = isl_map_range(bounds);
 549                 else
 550                         isl_map_free(bounds);
 551
 552                 lo_it = live_out.find(decl);
 553                 if (lo_it != live_out.end())
 554                         array->live_out = 1;
 555         }
 556
 557         isl_union_map_free(value_bounds);
 558 }
 559
 560 #ifdef USE_ARRAYREF
 561
 562 #ifdef HAVE_CXXISPRODUCTION
 563 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
 564 {
 565         return new Driver(binary, llvm::sys::getDefaultTargetTriple(),
 566                             "", false, false, Diags);
 567 }
 568 #else
 569 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
 570 {
 571         return new Driver(binary, llvm::sys::getDefaultTargetTriple(),
 572                             "", false, Diags);
 573 }
 574 #endif
 575
 576 /* Create a CompilerInvocation object that stores the command line
 577  * arguments constructed by the driver.
 578  * The arguments are mainly useful for setting up the system include
 579  * paths on newer clangs and on some platforms.
 580  */
 581 static CompilerInvocation *construct_invocation(const char *filename,
 582         DiagnosticsEngine &Diags)
 583 {
 584         const char *binary = CLANG_PREFIX"/bin/clang";
 585         const llvm::OwningPtr<Driver> driver(construct_driver(binary, Diags));
 586         std::vector<const char *> Argv;
 587         Argv.push_back(binary);
 588         Argv.push_back(filename);
 589         const llvm::OwningPtr<Compilation> compilation(
 590                 driver->BuildCompilation(llvm::ArrayRef<const char *>(Argv)));
 591         JobList &Jobs = compilation->getJobs();
 592         if (Jobs.size() < 1)
 593                 return NULL;
 594
 595         Command *cmd = cast<Command>(*Jobs.begin());
 596         if (strcmp(cmd->getCreator().getName(), "clang"))
 597                 return NULL;
 598
 599         const ArgStringList *args = &cmd->getArguments();
 600
 601         CompilerInvocation *invocation = new CompilerInvocation;
 602         CompilerInvocation::CreateFromArgs(*invocation, args->data() + 1,
 603                                                 args->data() + args->size(),
 604                                                 Diags);
 605         return invocation;
 606 }
 607
 608 #else
 609
 610 static CompilerInvocation *construct_invocation(const char *filename,
 611         DiagnosticsEngine &Diags)
 612 {
 613         return NULL;
 614 }
 615
 616 #endif
 617
 618 #ifdef HAVE_BASIC_DIAGNOSTICOPTIONS_H
 619
 620 static MyDiagnosticPrinter *construct_printer(CompilerInstance *Clang)
 621 {
 622         return new MyDiagnosticPrinter(new DiagnosticOptions());
 623 }
 624
 625 #else
 626
 627 static MyDiagnosticPrinter *construct_printer(CompilerInstance *Clang)
 628 {
 629         return new MyDiagnosticPrinter(Clang->getDiagnosticOpts());
 630 }
 631
 632 #endif
 633
 634 #ifdef CREATETARGETINFO_TAKES_POINTER
 635
 636 static TargetInfo *create_target_info(CompilerInstance *Clang,
 637         DiagnosticsEngine &Diags)
 638 {
 639         TargetOptions &TO = Clang->getTargetOpts();
 640         TO.Triple = llvm::sys::getDefaultTargetTriple();
 641         return TargetInfo::CreateTargetInfo(Diags, &TO);
 642 }
 643
 644 #else
 645
 646 static TargetInfo *create_target_info(CompilerInstance *Clang,
 647         DiagnosticsEngine &Diags)
 648 {
 649         TargetOptions &TO = Clang->getTargetOpts();
 650         TO.Triple = llvm::sys::getDefaultTargetTriple();
 651         return TargetInfo::CreateTargetInfo(Diags, TO);
 652 }
 653
 654 #endif
 655
 656 /* Extract a pet_scop from the C source file called "filename".
 657  * If "function" is not NULL, extract the pet_scop from the function
 658  * with that name.
 659  * If "autodetect" is set, extract any pet_scop we can find.
 660  * Otherwise, extract the pet_scop from the region delimited
 661  * by "scop" and "endscop" pragmas.
 662  *
 663  * We first set up the clang parser and then try to extract the
 664  * pet_scop from the appropriate function in PetASTConsumer.
 665  * If we have found a pet_scop, we add the context and value_bounds
 666  * constraints specified through pragmas.
 667  */
 668 static struct pet_scop *scop_extract_from_C_source(isl_ctx *ctx,
 669         const char *filename, const char *function, pet_options *options)
 670 {
 671         isl_space *dim;
 672         isl_set *context;
 673         isl_set *context_value;
 674         pet_scop *scop;
 675         set<ValueDecl *> live_out;
 676         isl_union_map *value_bounds;
 677
 678         CompilerInstance *Clang = new CompilerInstance();
 679         Clang->createDiagnostics(0, NULL);
 680         DiagnosticsEngine &Diags = Clang->getDiagnostics();
 681         Diags.setSuppressSystemWarnings(true);
 682         CompilerInvocation *invocation = construct_invocation(filename, Diags);
 683         if (invocation)
 684                 Clang->setInvocation(invocation);
 685         MyDiagnosticPrinter *printer = construct_printer(Clang);
 686         Diags.setClient(printer);
 687         if (printer->cloned)
 688                 delete printer;
 689         Clang->createFileManager();
 690         Clang->createSourceManager(Clang->getFileManager());
 691         TargetInfo *target = create_target_info(Clang, Diags);
 692         Clang->setTarget(target);
 693         CompilerInvocation::setLangDefaults(Clang->getLangOpts(), IK_C,
 694                                             LangStandard::lang_unspecified);
 695         HeaderSearchOptions &HSO = Clang->getHeaderSearchOpts();
 696         HSO.ResourceDir = ResourceDir;
 697         for (int i = 0; i < options->n_path; ++i)
 698                 HSO.AddPath(options->paths[i],
 699                         frontend::Angled, true, false, false);
 700         PreprocessorOptions &PO = Clang->getPreprocessorOpts();
 701         for (int i = 0; i < options->n_define; ++i)
 702                 PO.addMacroDef(options->defines[i]);
 703         Clang->createPreprocessor();
 704         Preprocessor &PP = Clang->getPreprocessor();
 705
 706         ScopLoc loc;
 707
 708         const FileEntry *file = Clang->getFileManager().getFile(filename);
 709         if (!file)
 710                 isl_die(ctx, isl_error_unknown, "unable to open file",
 711                         do { delete Clang; return NULL; } while (0));
 712         Clang->getSourceManager().createMainFileID(file);
 713
 714         Clang->createASTContext();
 715         PetASTConsumer consumer(ctx, PP, Clang->getASTContext(),
 716                                 loc, function, options);
 717         Sema *sema = new Sema(PP, Clang->getASTContext(), consumer);
 718
 719         if (!options->autodetect) {
 720                 PP.AddPragmaHandler(new PragmaScopHandler(loc));
 721                 PP.AddPragmaHandler(new PragmaEndScopHandler(loc));
 722                 PP.AddPragmaHandler(new PragmaLiveOutHandler(*sema, live_out));
 723         }
 724
 725         dim = isl_space_params_alloc(ctx, 0);
 726         context = isl_set_universe(isl_space_copy(dim));
 727         context_value = isl_set_universe(dim);
 728         PP.AddPragmaHandler(new PragmaParameterHandler(*sema, context,
 729                                                         context_value));
 730         consumer.handle_value_bounds(sema);
 731
 732         Diags.getClient()->BeginSourceFile(Clang->getLangOpts(), &PP);
 733         ParseAST(*sema);
 734         Diags.getClient()->EndSourceFile();
 735
 736         scop = consumer.scop;
 737         if (Diags.hasErrorOccurred()) {
 738                 pet_scop_free(scop);
 739                 scop = NULL;
 740         }
 741
 742         if (scop) {
 743                 scop->context = isl_set_intersect(context, scop->context);
 744                 scop->context_value = isl_set_intersect(context_value,
 745                                                 scop->context_value);
 746         } else {
 747                 isl_set_free(context);
 748                 isl_set_free(context_value);
 749         }
 750
 751         update_arrays(scop, consumer.get_value_bounds(), live_out);
 752
 753         scop = pet_scop_anonymize(scop);
 754
 755         delete sema;
 756         delete Clang;
 757
 758         return scop;
 759 }
 760
 761 struct pet_scop *pet_scop_extract_from_C_source(isl_ctx *ctx,
 762         const char *filename, const char *function)
 763 {
 764         pet_scop *scop;
 765         pet_options *options;
 766         bool allocated = false;
 767
 768         options = isl_ctx_peek_pet_options(ctx);
 769         if (!options) {
 770                 options = pet_options_new_with_defaults();
 771                 allocated = true;
 772         }
 773
 774         scop = scop_extract_from_C_source(ctx, filename, function, options);
 775         llvm::llvm_shutdown();
 776
 777         if (allocated)
 778                 pet_options_free(options);
 779
 780         return scop;
 781 }