configure.ac: check if TargetInfo::CreateTargetInfo takes TargetOptions pointer
[pet.git] / pet.cc
blob3ac73ab4dd79b6b1ec350143eb916eb06d486f30
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.
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.
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.
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 */
35 #include "config.h"
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>
82 #include <isl/ctx.h>
83 #include <isl/constraint.h>
85 #include "options.h"
86 #include "scan.h"
88 #define ARRAY_SIZE(array) (sizeof(array)/sizeof(*array))
90 using namespace std;
91 using namespace clang;
92 using namespace clang::driver;
94 /* Called if we found something we didn't expect in one of the pragmas.
95 * We'll provide more informative warnings later.
97 static void unsupported(Preprocessor &PP, SourceLocation loc)
99 DiagnosticsEngine &diag = PP.getDiagnostics();
100 unsigned id = diag.getCustomDiagID(DiagnosticsEngine::Warning,
101 "unsupported");
102 DiagnosticBuilder B = diag.Report(loc, id);
105 static int get_int(const char *s)
107 return s[0] == '"' ? atoi(s + 1) : atoi(s);
110 static ValueDecl *get_value_decl(Sema &sema, Token &token)
112 IdentifierInfo *name;
113 Decl *decl;
115 if (token.isNot(tok::identifier))
116 return NULL;
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;
124 /* Handle pragmas of the form
126 * #pragma value_bounds identifier lower_bound upper_bound
128 * For each such pragma, add a mapping
129 * { identifier[] -> [i] : lower_bound <= i <= upper_bound }
130 * to value_bounds.
132 struct PragmaValueBoundsHandler : public PragmaHandler {
133 Sema &sema;
134 isl_ctx *ctx;
135 isl_union_map *value_bounds;
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);
143 ~PragmaValueBoundsHandler() {
144 isl_union_map_free(value_bounds);
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;
158 PP.Lex(token);
159 vd = get_value_decl(sema, token);
160 if (!vd) {
161 unsupported(PP, token.getLocation());
162 return;
165 PP.Lex(token);
166 if (!token.isLiteral()) {
167 unsupported(PP, token.getLocation());
168 return;
171 lb = get_int(token.getLiteralData());
173 PP.Lex(token);
174 if (!token.isLiteral()) {
175 unsupported(PP, token.getLocation());
176 return;
179 ub = get_int(token.getLiteralData());
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);
188 value_bounds = isl_union_map_add_map(value_bounds, map);
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.
196 static __isl_give isl_set *extract_initialization(__isl_take isl_set *value,
197 ValueDecl *decl)
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;
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;
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);
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);
231 return isl_set_intersect(value, set);
234 /* Handle pragmas of the form
236 * #pragma parameter identifier lower_bound
237 * and
238 * #pragma parameter identifier lower_bound upper_bound
240 * For each such pragma, intersect the context with the set
241 * [identifier] -> { [] : lower_bound <= identifier <= upper_bound }
243 struct PragmaParameterHandler : public PragmaHandler {
244 Sema &sema;
245 isl_set *&context;
246 isl_set *&context_value;
248 PragmaParameterHandler(Sema &sema, isl_set *&context,
249 isl_set *&context_value) :
250 PragmaHandler("parameter"), sema(sema), context(context),
251 context_value(context_value) {}
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;
266 PP.Lex(token);
267 vd = get_value_decl(sema, token);
268 if (!vd) {
269 unsupported(PP, token.getLocation());
270 return;
273 PP.Lex(token);
274 if (!token.isLiteral()) {
275 unsupported(PP, token.getLocation());
276 return;
279 lb = get_int(token.getLiteralData());
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;
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);
294 set = isl_set_universe(dim);
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);
300 context = isl_set_intersect(context, set);
302 context_value = extract_initialization(context_value, vd);
306 /* Handle pragmas of the form
308 * #pragma scop
310 * In particular, store the current location in loc.start.
312 struct PragmaScopHandler : public PragmaHandler {
313 ScopLoc &loc;
315 PragmaScopHandler(ScopLoc &loc) : PragmaHandler("scop"), loc(loc) {}
317 virtual void HandlePragma(Preprocessor &PP,
318 PragmaIntroducerKind Introducer,
319 Token &ScopTok) {
320 SourceManager &SM = PP.getSourceManager();
321 loc.start = SM.getFileOffset(ScopTok.getLocation());
325 /* Handle pragmas of the form
327 * #pragma endscop
329 * In particular, store the current location in loc.end.
331 struct PragmaEndScopHandler : public PragmaHandler {
332 ScopLoc &loc;
334 PragmaEndScopHandler(ScopLoc &loc) :
335 PragmaHandler("endscop"), loc(loc) {}
337 virtual void HandlePragma(Preprocessor &PP,
338 PragmaIntroducerKind Introducer,
339 Token &EndScopTok) {
340 SourceManager &SM = PP.getSourceManager();
341 loc.end = SM.getFileOffset(EndScopTok.getLocation());
345 /* Handle pragmas of the form
347 * #pragma live-out identifier, identifier, ...
349 * Each identifier on the line is stored in live_out.
351 struct PragmaLiveOutHandler : public PragmaHandler {
352 Sema &sema;
353 set<ValueDecl *> &live_out;
355 PragmaLiveOutHandler(Sema &sema, set<ValueDecl *> &live_out) :
356 PragmaHandler("live"), sema(sema), live_out(live_out) {}
358 virtual void HandlePragma(Preprocessor &PP,
359 PragmaIntroducerKind Introducer,
360 Token &ScopTok) {
361 Token token;
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;
371 PP.Lex(token);
372 while (token.isNot(tok::eod)) {
373 ValueDecl *vd;
375 vd = get_value_decl(sema, token);
376 if (!vd) {
377 unsupported(PP, token.getLocation());
378 return;
380 live_out.insert(vd);
381 PP.Lex(token);
382 if (token.is(tok::comma))
383 PP.Lex(token);
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.
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;
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) { }
411 void handle_value_bounds(Sema *sema) {
412 vb_handler = new PragmaValueBoundsHandler(ctx, *sema);
413 PP.AddPragmaHandler(vb_handler);
416 __isl_give isl_union_map *get_value_bounds() {
417 return isl_union_map_copy(vb_handler->value_bounds);
420 virtual HandleTopLevelDeclReturn HandleTopLevelDecl(DeclGroupRef dg) {
421 DeclGroupRef::iterator it;
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;
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;
457 return HandleTopLevelDeclContinue;
461 static const char *ResourceDir = CLANG_PREFIX"/lib/clang/"CLANG_VERSION_STRING;
463 static const char *implicit_functions[] = {
464 "min", "max", "ceild", "floord"
467 static bool is_implicit(const IdentifierInfo *ident)
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;
476 /* Ignore implicit function declaration warnings on
477 * "min", "max", "ceild" and "floord" as we detect and handle these
478 * in PetScan.
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.
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());
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);
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);
516 bool MyDiagnosticPrinter::cloned = false;
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".
522 static void update_arrays(struct pet_scop *scop,
523 __isl_take isl_union_map *value_bounds, set<ValueDecl *> &live_out)
525 set<ValueDecl *>::iterator lo_it;
526 isl_ctx *ctx = isl_union_map_get_ctx(value_bounds);
528 if (!scop) {
529 isl_union_map_free(value_bounds);
530 return;
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];
540 id = isl_set_get_tuple_id(array->extent);
541 decl = (ValueDecl *)isl_id_get_user(id);
543 space = isl_space_alloc(ctx, 0, 0, 1);
544 space = isl_space_set_tuple_id(space, isl_dim_in, id);
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);
552 lo_it = live_out.find(decl);
553 if (lo_it != live_out.end())
554 array->live_out = 1;
557 isl_union_map_free(value_bounds);
560 #ifdef USE_ARRAYREF
562 #ifdef HAVE_CXXISPRODUCTION
563 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
565 return new Driver(binary, llvm::sys::getDefaultTargetTriple(),
566 "", false, false, Diags);
568 #else
569 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
571 return new Driver(binary, llvm::sys::getDefaultTargetTriple(),
572 "", false, Diags);
574 #endif
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.
581 static CompilerInvocation *construct_invocation(const char *filename,
582 DiagnosticsEngine &Diags)
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;
595 Command *cmd = cast<Command>(*Jobs.begin());
596 if (strcmp(cmd->getCreator().getName(), "clang"))
597 return NULL;
599 const ArgStringList *args = &cmd->getArguments();
601 CompilerInvocation *invocation = new CompilerInvocation;
602 CompilerInvocation::CreateFromArgs(*invocation, args->data() + 1,
603 args->data() + args->size(),
604 Diags);
605 return invocation;
608 #else
610 static CompilerInvocation *construct_invocation(const char *filename,
611 DiagnosticsEngine &Diags)
613 return NULL;
616 #endif
618 #ifdef HAVE_BASIC_DIAGNOSTICOPTIONS_H
620 static MyDiagnosticPrinter *construct_printer(CompilerInstance *Clang)
622 return new MyDiagnosticPrinter(new DiagnosticOptions());
625 #else
627 static MyDiagnosticPrinter *construct_printer(CompilerInstance *Clang)
629 return new MyDiagnosticPrinter(Clang->getDiagnosticOpts());
632 #endif
634 #ifdef CREATETARGETINFO_TAKES_POINTER
636 static TargetInfo *create_target_info(CompilerInstance *Clang,
637 DiagnosticsEngine &Diags)
639 TargetOptions &TO = Clang->getTargetOpts();
640 TO.Triple = llvm::sys::getDefaultTargetTriple();
641 return TargetInfo::CreateTargetInfo(Diags, &TO);
644 #else
646 static TargetInfo *create_target_info(CompilerInstance *Clang,
647 DiagnosticsEngine &Diags)
649 TargetOptions &TO = Clang->getTargetOpts();
650 TO.Triple = llvm::sys::getDefaultTargetTriple();
651 return TargetInfo::CreateTargetInfo(Diags, TO);
654 #endif
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.
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.
668 static struct pet_scop *scop_extract_from_C_source(isl_ctx *ctx,
669 const char *filename, const char *function, pet_options *options)
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;
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();
706 ScopLoc loc;
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);
714 Clang->createASTContext();
715 PetASTConsumer consumer(ctx, PP, Clang->getASTContext(),
716 loc, function, options);
717 Sema *sema = new Sema(PP, Clang->getASTContext(), consumer);
719 if (!options->autodetect) {
720 PP.AddPragmaHandler(new PragmaScopHandler(loc));
721 PP.AddPragmaHandler(new PragmaEndScopHandler(loc));
722 PP.AddPragmaHandler(new PragmaLiveOutHandler(*sema, live_out));
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);
732 Diags.getClient()->BeginSourceFile(Clang->getLangOpts(), &PP);
733 ParseAST(*sema);
734 Diags.getClient()->EndSourceFile();
736 scop = consumer.scop;
737 if (Diags.hasErrorOccurred()) {
738 pet_scop_free(scop);
739 scop = NULL;
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);
751 update_arrays(scop, consumer.get_value_bounds(), live_out);
753 scop = pet_scop_anonymize(scop);
755 delete sema;
756 delete Clang;
758 return scop;
761 struct pet_scop *pet_scop_extract_from_C_source(isl_ctx *ctx,
762 const char *filename, const char *function)
764 pet_scop *scop;
765 pet_options *options;
766 bool allocated = false;
768 options = isl_ctx_peek_pet_options(ctx);
769 if (!options) {
770 options = pet_options_new_with_defaults();
771 allocated = true;
774 scop = scop_extract_from_C_source(ctx, filename, function, options);
775 llvm::llvm_shutdown();
777 if (allocated)
778 pet_options_free(options);
780 return scop;