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 #ifdef HAVE_TRANSLATELINECOL
 307
 308 /* Return a SourceLocation for line "line", column "col" of file "FID".
 309  */
 310 SourceLocation translateLineCol(SourceManager &SM, FileID FID, unsigned line,
 311         unsigned col)
 312 {
 313         return SM.translateLineCol(FID, line, col);
 314 }
 315
 316 #else
 317
 318 /* Return a SourceLocation for line "line", column "col" of file "FID".
 319  */
 320 SourceLocation translateLineCol(SourceManager &SM, FileID FID, unsigned line,
 321         unsigned col)
 322 {
 323         return SM.getLocation(SM.getFileEntryForID(FID), line, col);
 324 }
 325
 326 #endif
 327
 328 /* Handle pragmas of the form
 329  *
 330  *      #pragma scop
 331  *
 332  * In particular, store the location of the line containing
 333  * the pragma in loc.start.
 334  */
 335 struct PragmaScopHandler : public PragmaHandler {
 336         ScopLoc &loc;
 337
 338         PragmaScopHandler(ScopLoc &loc) : PragmaHandler("scop"), loc(loc) {}
 339
 340         virtual void HandlePragma(Preprocessor &PP,
 341                                   PragmaIntroducerKind Introducer,
 342                                   Token &ScopTok) {
 343                 SourceManager &SM = PP.getSourceManager();
 344                 SourceLocation sloc = ScopTok.getLocation();
 345                 int line = SM.getExpansionLineNumber(sloc);
 346                 sloc = translateLineCol(SM, SM.getFileID(sloc), line, 1);
 347                 loc.start = SM.getFileOffset(sloc);
 348         }
 349 };
 350
 351 /* Handle pragmas of the form
 352  *
 353  *      #pragma endscop
 354  *
 355  * In particular, store the location of the line following the one containing
 356  * the pragma in loc.end.
 357  */
 358 struct PragmaEndScopHandler : public PragmaHandler {
 359         ScopLoc &loc;
 360
 361         PragmaEndScopHandler(ScopLoc &loc) :
 362                 PragmaHandler("endscop"), loc(loc) {}
 363
 364         virtual void HandlePragma(Preprocessor &PP,
 365                                   PragmaIntroducerKind Introducer,
 366                                   Token &EndScopTok) {
 367                 SourceManager &SM = PP.getSourceManager();
 368                 SourceLocation sloc = EndScopTok.getLocation();
 369                 int line = SM.getExpansionLineNumber(sloc);
 370                 sloc = translateLineCol(SM, SM.getFileID(sloc), line + 1, 1);
 371                 loc.end = SM.getFileOffset(sloc);
 372         }
 373 };
 374
 375 /* Handle pragmas of the form
 376  *
 377  *      #pragma live-out identifier, identifier, ...
 378  *
 379  * Each identifier on the line is stored in live_out.
 380  */
 381 struct PragmaLiveOutHandler : public PragmaHandler {
 382         Sema &sema;
 383         set<ValueDecl *> &live_out;
 384
 385         PragmaLiveOutHandler(Sema &sema, set<ValueDecl *> &live_out) :
 386                 PragmaHandler("live"), sema(sema), live_out(live_out) {}
 387
 388         virtual void HandlePragma(Preprocessor &PP,
 389                                   PragmaIntroducerKind Introducer,
 390                                   Token &ScopTok) {
 391                 Token token;
 392
 393                 PP.Lex(token);
 394                 if (token.isNot(tok::minus))
 395                         return;
 396                 PP.Lex(token);
 397                 if (token.isNot(tok::identifier) ||
 398                     !token.getIdentifierInfo()->isStr("out"))
 399                         return;
 400
 401                 PP.Lex(token);
 402                 while (token.isNot(tok::eod)) {
 403                         ValueDecl *vd;
 404
 405                         vd = get_value_decl(sema, token);
 406                         if (!vd) {
 407                                 unsupported(PP, token.getLocation());
 408                                 return;
 409                         }
 410                         live_out.insert(vd);
 411                         PP.Lex(token);
 412                         if (token.is(tok::comma))
 413                                 PP.Lex(token);
 414                 }
 415         }
 416 };
 417
 418 /* Extract a pet_scop from the appropriate function.
 419  * If "function" is not NULL, then we only extract a pet_scop if the
 420  * name of the function matches.
 421  * If "autodetect" is false, then we only extract if we have seen
 422  * scop and endscop pragmas and if these are situated inside the function
 423  * body.
 424  */
 425 struct PetASTConsumer : public ASTConsumer {
 426         Preprocessor &PP;
 427         ASTContext &ast_context;
 428         ScopLoc &loc;
 429         const char *function;
 430         pet_options *options;
 431         isl_ctx *ctx;
 432         struct pet_scop *scop;
 433         PragmaValueBoundsHandler *vb_handler;
 434
 435         PetASTConsumer(isl_ctx *ctx, Preprocessor &PP, ASTContext &ast_context,
 436                 ScopLoc &loc, const char *function, pet_options *options) :
 437                 ctx(ctx), PP(PP), ast_context(ast_context), loc(loc),
 438                 scop(NULL), function(function), options(options),
 439                 vb_handler(NULL) { }
 440
 441         void handle_value_bounds(Sema *sema) {
 442                 vb_handler = new PragmaValueBoundsHandler(ctx, *sema);
 443                 PP.AddPragmaHandler(vb_handler);
 444         }
 445
 446         __isl_give isl_union_map *get_value_bounds() {
 447                 return isl_union_map_copy(vb_handler->value_bounds);
 448         }
 449
 450         virtual HandleTopLevelDeclReturn HandleTopLevelDecl(DeclGroupRef dg) {
 451                 DeclGroupRef::iterator it;
 452
 453                 if (scop)
 454                         return HandleTopLevelDeclContinue;
 455                 for (it = dg.begin(); it != dg.end(); ++it) {
 456                         isl_union_map *vb = vb_handler->value_bounds;
 457                         FunctionDecl *fd = dyn_cast<clang::FunctionDecl>(*it);
 458                         if (!fd)
 459                                 continue;
 460                         if (!fd->hasBody())
 461                                 continue;
 462                         if (function &&
 463                             fd->getNameInfo().getAsString() != function)
 464                                 continue;
 465                         if (options->autodetect) {
 466                                 PetScan ps(PP, ast_context, loc, options,
 467                                             isl_union_map_copy(vb));
 468                                 scop = ps.scan(fd);
 469                                 if (scop)
 470                                         break;
 471                                 else
 472                                         continue;
 473                         }
 474                         if (!loc.end)
 475                                 continue;
 476                         SourceManager &SM = PP.getSourceManager();
 477                         if (SM.getFileOffset(fd->getLocStart()) > loc.end)
 478                                 continue;
 479                         if (SM.getFileOffset(fd->getLocEnd()) < loc.start)
 480                                 continue;
 481                         PetScan ps(PP, ast_context, loc, options,
 482                                     isl_union_map_copy(vb));
 483                         scop = ps.scan(fd);
 484                         break;
 485                 }
 486
 487                 return HandleTopLevelDeclContinue;
 488         }
 489 };
 490
 491 static const char *ResourceDir = CLANG_PREFIX"/lib/clang/"CLANG_VERSION_STRING;
 492
 493 static const char *implicit_functions[] = {
 494         "min", "max", "ceild", "floord"
 495 };
 496
 497 static bool is_implicit(const IdentifierInfo *ident)
 498 {
 499         const char *name = ident->getNameStart();
 500         for (int i = 0; i < ARRAY_SIZE(implicit_functions); ++i)
 501                 if (!strcmp(name, implicit_functions[i]))
 502                         return true;
 503         return false;
 504 }
 505
 506 /* Ignore implicit function declaration warnings on
 507  * "min", "max", "ceild" and "floord" as we detect and handle these
 508  * in PetScan.
 509  *
 510  * The cloned field keeps track of whether the clone method
 511  * has ever been called.  Newer clangs (by default) clone
 512  * the DiagnosticConsumer passed to createDiagnostics and
 513  * then take ownership of the clone, which means that
 514  * the original has to be deleted by the calling code.
 515  */
 516 struct MyDiagnosticPrinter : public TextDiagnosticPrinter {
 517         const DiagnosticOptions *DiagOpts;
 518         static bool cloned;
 519 #ifdef HAVE_BASIC_DIAGNOSTICOPTIONS_H
 520         MyDiagnosticPrinter(DiagnosticOptions *DO) :
 521                 TextDiagnosticPrinter(llvm::errs(), DO) {}
 522         virtual DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
 523                 cloned = true;
 524                 return new MyDiagnosticPrinter(&Diags.getDiagnosticOptions());
 525         }
 526 #else
 527         MyDiagnosticPrinter(const DiagnosticOptions &DO) :
 528                 DiagOpts(&DO), TextDiagnosticPrinter(llvm::errs(), DO) {}
 529         virtual DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
 530                 cloned = true;
 531                 return new MyDiagnosticPrinter(*DiagOpts);
 532         }
 533 #endif
 534         virtual void HandleDiagnostic(DiagnosticsEngine::Level level,
 535                                         const DiagnosticInfo &info) {
 536                 if (info.getID() == diag::ext_implicit_function_decl &&
 537                     info.getNumArgs() == 1 &&
 538                     info.getArgKind(0) == DiagnosticsEngine::ak_identifierinfo &&
 539                     is_implicit(info.getArgIdentifier(0)))
 540                         /* ignore warning */;
 541                 else
 542                         TextDiagnosticPrinter::HandleDiagnostic(level, info);
 543         }
 544 };
 545
 546 bool MyDiagnosticPrinter::cloned = false;
 547
 548 /* For each array in "scop", set its value_bounds property
 549  * based on the infofrmation in "value_bounds" and
 550  * mark it as live_out if it appears in "live_out".
 551  */
 552 static void update_arrays(struct pet_scop *scop,
 553         __isl_take isl_union_map *value_bounds, set<ValueDecl *> &live_out)
 554 {
 555         set<ValueDecl *>::iterator lo_it;
 556         isl_ctx *ctx = isl_union_map_get_ctx(value_bounds);
 557
 558         if (!scop) {
 559                 isl_union_map_free(value_bounds);
 560                 return;
 561         }
 562
 563         for (int i = 0; i < scop->n_array; ++i) {
 564                 isl_id *id;
 565                 isl_space *space;
 566                 isl_map *bounds;
 567                 ValueDecl *decl;
 568                 pet_array *array = scop->arrays[i];
 569
 570                 id = isl_set_get_tuple_id(array->extent);
 571                 decl = (ValueDecl *)isl_id_get_user(id);
 572
 573                 space = isl_space_alloc(ctx, 0, 0, 1);
 574                 space = isl_space_set_tuple_id(space, isl_dim_in, id);
 575
 576                 bounds = isl_union_map_extract_map(value_bounds, space);
 577                 if (!isl_map_plain_is_empty(bounds))
 578                         array->value_bounds = isl_map_range(bounds);
 579                 else
 580                         isl_map_free(bounds);
 581
 582                 lo_it = live_out.find(decl);
 583                 if (lo_it != live_out.end())
 584                         array->live_out = 1;
 585         }
 586
 587         isl_union_map_free(value_bounds);
 588 }
 589
 590 #ifdef USE_ARRAYREF
 591
 592 #ifdef HAVE_CXXISPRODUCTION
 593 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
 594 {
 595         return new Driver(binary, llvm::sys::getDefaultTargetTriple(),
 596                             "", false, false, Diags);
 597 }
 598 #elif defined(HAVE_ISPRODUCTION)
 599 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
 600 {
 601         return new Driver(binary, llvm::sys::getDefaultTargetTriple(),
 602                             "", false, Diags);
 603 }
 604 #else
 605 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
 606 {
 607         return new Driver(binary, llvm::sys::getDefaultTargetTriple(),
 608                             "", Diags);
 609 }
 610 #endif
 611
 612 /* Create a CompilerInvocation object that stores the command line
 613  * arguments constructed by the driver.
 614  * The arguments are mainly useful for setting up the system include
 615  * paths on newer clangs and on some platforms.
 616  */
 617 static CompilerInvocation *construct_invocation(const char *filename,
 618         DiagnosticsEngine &Diags)
 619 {
 620         const char *binary = CLANG_PREFIX"/bin/clang";
 621         const llvm::OwningPtr<Driver> driver(construct_driver(binary, Diags));
 622         std::vector<const char *> Argv;
 623         Argv.push_back(binary);
 624         Argv.push_back(filename);
 625         const llvm::OwningPtr<Compilation> compilation(
 626                 driver->BuildCompilation(llvm::ArrayRef<const char *>(Argv)));
 627         JobList &Jobs = compilation->getJobs();
 628         if (Jobs.size() < 1)
 629                 return NULL;
 630
 631         Command *cmd = cast<Command>(*Jobs.begin());
 632         if (strcmp(cmd->getCreator().getName(), "clang"))
 633                 return NULL;
 634
 635         const ArgStringList *args = &cmd->getArguments();
 636
 637         CompilerInvocation *invocation = new CompilerInvocation;
 638         CompilerInvocation::CreateFromArgs(*invocation, args->data() + 1,
 639                                                 args->data() + args->size(),
 640                                                 Diags);
 641         return invocation;
 642 }
 643
 644 #else
 645
 646 static CompilerInvocation *construct_invocation(const char *filename,
 647         DiagnosticsEngine &Diags)
 648 {
 649         return NULL;
 650 }
 651
 652 #endif
 653
 654 #ifdef HAVE_BASIC_DIAGNOSTICOPTIONS_H
 655
 656 static MyDiagnosticPrinter *construct_printer(CompilerInstance *Clang)
 657 {
 658         return new MyDiagnosticPrinter(new DiagnosticOptions());
 659 }
 660
 661 #else
 662
 663 static MyDiagnosticPrinter *construct_printer(CompilerInstance *Clang)
 664 {
 665         return new MyDiagnosticPrinter(Clang->getDiagnosticOpts());
 666 }
 667
 668 #endif
 669
 670 #ifdef CREATETARGETINFO_TAKES_POINTER
 671
 672 static TargetInfo *create_target_info(CompilerInstance *Clang,
 673         DiagnosticsEngine &Diags)
 674 {
 675         TargetOptions &TO = Clang->getTargetOpts();
 676         TO.Triple = llvm::sys::getDefaultTargetTriple();
 677         return TargetInfo::CreateTargetInfo(Diags, &TO);
 678 }
 679
 680 #else
 681
 682 static TargetInfo *create_target_info(CompilerInstance *Clang,
 683         DiagnosticsEngine &Diags)
 684 {
 685         TargetOptions &TO = Clang->getTargetOpts();
 686         TO.Triple = llvm::sys::getDefaultTargetTriple();
 687         return TargetInfo::CreateTargetInfo(Diags, TO);
 688 }
 689
 690 #endif
 691
 692 #ifdef CREATEDIAGNOSTICS_TAKES_ARG
 693
 694 static void create_diagnostics(CompilerInstance *Clang)
 695 {
 696         Clang->createDiagnostics(0, NULL);
 697 }
 698
 699 #else
 700
 701 static void create_diagnostics(CompilerInstance *Clang)
 702 {
 703         Clang->createDiagnostics();
 704 }
 705
 706 #endif
 707
 708 #ifdef ADDPATH_TAKES_4_ARGUMENTS
 709
 710 void add_path(HeaderSearchOptions &HSO, string Path)
 711 {
 712         HSO.AddPath(Path, frontend::Angled, false, false);
 713 }
 714
 715 #else
 716
 717 void add_path(HeaderSearchOptions &HSO, string Path)
 718 {
 719         HSO.AddPath(Path, frontend::Angled, true, false, false);
 720 }
 721
 722 #endif
 723
 724 /* Extract a pet_scop from the C source file called "filename".
 725  * If "function" is not NULL, extract the pet_scop from the function
 726  * with that name.
 727  * If "autodetect" is set, extract any pet_scop we can find.
 728  * Otherwise, extract the pet_scop from the region delimited
 729  * by "scop" and "endscop" pragmas.
 730  *
 731  * We first set up the clang parser and then try to extract the
 732  * pet_scop from the appropriate function in PetASTConsumer.
 733  * If we have found a pet_scop, we add the context and value_bounds
 734  * constraints specified through pragmas.
 735  */
 736 static struct pet_scop *scop_extract_from_C_source(isl_ctx *ctx,
 737         const char *filename, const char *function, pet_options *options)
 738 {
 739         isl_space *dim;
 740         isl_set *context;
 741         isl_set *context_value;
 742         pet_scop *scop;
 743         set<ValueDecl *> live_out;
 744         isl_union_map *value_bounds;
 745
 746         CompilerInstance *Clang = new CompilerInstance();
 747         create_diagnostics(Clang);
 748         DiagnosticsEngine &Diags = Clang->getDiagnostics();
 749         Diags.setSuppressSystemWarnings(true);
 750         CompilerInvocation *invocation = construct_invocation(filename, Diags);
 751         if (invocation)
 752                 Clang->setInvocation(invocation);
 753         MyDiagnosticPrinter *printer = construct_printer(Clang);
 754         Diags.setClient(printer);
 755         if (printer->cloned)
 756                 delete printer;
 757         Clang->createFileManager();
 758         Clang->createSourceManager(Clang->getFileManager());
 759         TargetInfo *target = create_target_info(Clang, Diags);
 760         Clang->setTarget(target);
 761         CompilerInvocation::setLangDefaults(Clang->getLangOpts(), IK_C,
 762                                             LangStandard::lang_unspecified);
 763         HeaderSearchOptions &HSO = Clang->getHeaderSearchOpts();
 764         HSO.ResourceDir = ResourceDir;
 765         for (int i = 0; i < options->n_path; ++i)
 766                 add_path(HSO, options->paths[i]);
 767         PreprocessorOptions &PO = Clang->getPreprocessorOpts();
 768         for (int i = 0; i < options->n_define; ++i)
 769                 PO.addMacroDef(options->defines[i]);
 770         Clang->createPreprocessor();
 771         Preprocessor &PP = Clang->getPreprocessor();
 772
 773         ScopLoc loc;
 774
 775         const FileEntry *file = Clang->getFileManager().getFile(filename);
 776         if (!file)
 777                 isl_die(ctx, isl_error_unknown, "unable to open file",
 778                         do { delete Clang; return NULL; } while (0));
 779         Clang->getSourceManager().createMainFileID(file);
 780
 781         Clang->createASTContext();
 782         PetASTConsumer consumer(ctx, PP, Clang->getASTContext(),
 783                                 loc, function, options);
 784         Sema *sema = new Sema(PP, Clang->getASTContext(), consumer);
 785
 786         if (!options->autodetect) {
 787                 PP.AddPragmaHandler(new PragmaScopHandler(loc));
 788                 PP.AddPragmaHandler(new PragmaEndScopHandler(loc));
 789                 PP.AddPragmaHandler(new PragmaLiveOutHandler(*sema, live_out));
 790         }
 791
 792         dim = isl_space_params_alloc(ctx, 0);
 793         context = isl_set_universe(isl_space_copy(dim));
 794         context_value = isl_set_universe(dim);
 795         PP.AddPragmaHandler(new PragmaParameterHandler(*sema, context,
 796                                                         context_value));
 797         consumer.handle_value_bounds(sema);
 798
 799         Diags.getClient()->BeginSourceFile(Clang->getLangOpts(), &PP);
 800         ParseAST(*sema);
 801         Diags.getClient()->EndSourceFile();
 802
 803         scop = consumer.scop;
 804         if (Diags.hasErrorOccurred()) {
 805                 pet_scop_free(scop);
 806                 scop = NULL;
 807         }
 808
 809         if (scop) {
 810                 scop->context = isl_set_intersect(context, scop->context);
 811                 scop->context_value = isl_set_intersect(context_value,
 812                                                 scop->context_value);
 813         } else {
 814                 isl_set_free(context);
 815                 isl_set_free(context_value);
 816         }
 817
 818         update_arrays(scop, consumer.get_value_bounds(), live_out);
 819
 820         scop = pet_scop_anonymize(scop);
 821
 822         delete sema;
 823         delete Clang;
 824
 825         return scop;
 826 }
 827
 828 struct pet_scop *pet_scop_extract_from_C_source(isl_ctx *ctx,
 829         const char *filename, const char *function)
 830 {
 831         pet_scop *scop;
 832         pet_options *options;
 833         bool allocated = false;
 834
 835         options = isl_ctx_peek_pet_options(ctx);
 836         if (!options) {
 837                 options = pet_options_new_with_defaults();
 838                 allocated = true;
 839         }
 840
 841         scop = scop_extract_from_C_source(ctx, filename, function, options);
 842         llvm::llvm_shutdown();
 843
 844         if (allocated)
 845                 pet_options_free(options);
 846
 847         return scop;
 848 }