PetScan::extract(pet_expr*): take explicit source range
[pet.git] / pet.cc
blob64c1c4b5bd487641ca01bd405c000c938fe26223
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 <vector>
40 #include <iostream>
41 #include <llvm/Support/raw_ostream.h>
42 #include <llvm/Support/ManagedStatic.h>
43 #include <llvm/Support/Host.h>
44 #include <clang/Basic/Version.h>
45 #include <clang/Basic/FileSystemOptions.h>
46 #include <clang/Basic/FileManager.h>
47 #include <clang/Basic/TargetOptions.h>
48 #include <clang/Basic/TargetInfo.h>
49 #include <clang/Driver/Compilation.h>
50 #include <clang/Driver/Driver.h>
51 #include <clang/Driver/Tool.h>
52 #include <clang/Frontend/CompilerInstance.h>
53 #include <clang/Frontend/CompilerInvocation.h>
54 #ifdef HAVE_BASIC_DIAGNOSTICOPTIONS_H
55 #include <clang/Basic/DiagnosticOptions.h>
56 #else
57 #include <clang/Frontend/DiagnosticOptions.h>
58 #endif
59 #include <clang/Frontend/TextDiagnosticPrinter.h>
60 #ifdef HAVE_LEX_HEADERSEARCHOPTIONS_H
61 #include <clang/Lex/HeaderSearchOptions.h>
62 #else
63 #include <clang/Frontend/HeaderSearchOptions.h>
64 #endif
65 #include <clang/Frontend/LangStandard.h>
66 #ifdef HAVE_LEX_PREPROCESSOROPTIONS_H
67 #include <clang/Lex/PreprocessorOptions.h>
68 #else
69 #include <clang/Frontend/PreprocessorOptions.h>
70 #endif
71 #include <clang/Frontend/FrontendOptions.h>
72 #include <clang/Frontend/Utils.h>
73 #include <clang/Lex/HeaderSearch.h>
74 #include <clang/Lex/Preprocessor.h>
75 #include <clang/Lex/Pragma.h>
76 #include <clang/AST/ASTContext.h>
77 #include <clang/AST/ASTConsumer.h>
78 #include <clang/Sema/Sema.h>
79 #include <clang/Sema/SemaDiagnostic.h>
80 #include <clang/Parse/Parser.h>
81 #include <clang/Parse/ParseAST.h>
83 #include <isl/ctx.h>
84 #include <isl/constraint.h>
86 #include <pet.h>
88 #include "options.h"
89 #include "scan.h"
90 #include "print.h"
92 #define ARRAY_SIZE(array) (sizeof(array)/sizeof(*array))
94 using namespace std;
95 using namespace clang;
96 using namespace clang::driver;
98 /* Called if we found something we didn't expect in one of the pragmas.
99 * We'll provide more informative warnings later.
101 static void unsupported(Preprocessor &PP, SourceLocation loc)
103 DiagnosticsEngine &diag = PP.getDiagnostics();
104 unsigned id = diag.getCustomDiagID(DiagnosticsEngine::Warning,
105 "unsupported");
106 DiagnosticBuilder B = diag.Report(loc, id);
109 static int get_int(const char *s)
111 return s[0] == '"' ? atoi(s + 1) : atoi(s);
114 static ValueDecl *get_value_decl(Sema &sema, Token &token)
116 IdentifierInfo *name;
117 Decl *decl;
119 if (token.isNot(tok::identifier))
120 return NULL;
122 name = token.getIdentifierInfo();
123 decl = sema.LookupSingleName(sema.TUScope, name,
124 token.getLocation(), Sema::LookupOrdinaryName);
125 return decl ? cast_or_null<ValueDecl>(decl) : NULL;
128 /* Handle pragmas of the form
130 * #pragma value_bounds identifier lower_bound upper_bound
132 * For each such pragma, add a mapping
133 * { identifier[] -> [i] : lower_bound <= i <= upper_bound }
134 * to value_bounds.
136 struct PragmaValueBoundsHandler : public PragmaHandler {
137 Sema &sema;
138 isl_ctx *ctx;
139 isl_union_map *value_bounds;
141 PragmaValueBoundsHandler(isl_ctx *ctx, Sema &sema) :
142 PragmaHandler("value_bounds"), ctx(ctx), sema(sema) {
143 isl_space *space = isl_space_params_alloc(ctx, 0);
144 value_bounds = isl_union_map_empty(space);
147 ~PragmaValueBoundsHandler() {
148 isl_union_map_free(value_bounds);
151 virtual void HandlePragma(Preprocessor &PP,
152 PragmaIntroducerKind Introducer,
153 Token &ScopTok) {
154 isl_id *id;
155 isl_space *dim;
156 isl_map *map;
157 ValueDecl *vd;
158 Token token;
159 int lb;
160 int ub;
162 PP.Lex(token);
163 vd = get_value_decl(sema, token);
164 if (!vd) {
165 unsupported(PP, token.getLocation());
166 return;
169 PP.Lex(token);
170 if (!token.isLiteral()) {
171 unsupported(PP, token.getLocation());
172 return;
175 lb = get_int(token.getLiteralData());
177 PP.Lex(token);
178 if (!token.isLiteral()) {
179 unsupported(PP, token.getLocation());
180 return;
183 ub = get_int(token.getLiteralData());
185 dim = isl_space_alloc(ctx, 0, 0, 1);
186 map = isl_map_universe(dim);
187 map = isl_map_lower_bound_si(map, isl_dim_out, 0, lb);
188 map = isl_map_upper_bound_si(map, isl_dim_out, 0, ub);
189 id = isl_id_alloc(ctx, vd->getName().str().c_str(), vd);
190 map = isl_map_set_tuple_id(map, isl_dim_in, id);
192 value_bounds = isl_union_map_add_map(value_bounds, map);
196 /* Given a variable declaration, check if it has an integer initializer
197 * and if so, add a parameter corresponding to the variable to "value"
198 * with its value fixed to the integer initializer and return the result.
200 static __isl_give isl_set *extract_initialization(__isl_take isl_set *value,
201 ValueDecl *decl)
203 VarDecl *vd;
204 Expr *expr;
205 IntegerLiteral *il;
206 isl_val *v;
207 isl_ctx *ctx;
208 isl_id *id;
209 isl_space *space;
210 isl_set *set;
212 vd = cast<VarDecl>(decl);
213 if (!vd)
214 return value;
215 if (!vd->getType()->isIntegerType())
216 return value;
217 expr = vd->getInit();
218 if (!expr)
219 return value;
220 il = cast<IntegerLiteral>(expr);
221 if (!il)
222 return value;
224 ctx = isl_set_get_ctx(value);
225 id = isl_id_alloc(ctx, vd->getName().str().c_str(), vd);
226 space = isl_space_params_alloc(ctx, 1);
227 space = isl_space_set_dim_id(space, isl_dim_param, 0, id);
228 set = isl_set_universe(space);
230 v = PetScan::extract_int(ctx, il);
231 set = isl_set_fix_val(set, isl_dim_param, 0, v);
233 return isl_set_intersect(value, set);
236 /* Handle pragmas of the form
238 * #pragma parameter identifier lower_bound
239 * and
240 * #pragma parameter identifier lower_bound upper_bound
242 * For each such pragma, intersect the context with the set
243 * [identifier] -> { [] : lower_bound <= identifier <= upper_bound }
245 struct PragmaParameterHandler : public PragmaHandler {
246 Sema &sema;
247 isl_set *&context;
248 isl_set *&context_value;
250 PragmaParameterHandler(Sema &sema, isl_set *&context,
251 isl_set *&context_value) :
252 PragmaHandler("parameter"), sema(sema), context(context),
253 context_value(context_value) {}
255 virtual void HandlePragma(Preprocessor &PP,
256 PragmaIntroducerKind Introducer,
257 Token &ScopTok) {
258 isl_id *id;
259 isl_ctx *ctx = isl_set_get_ctx(context);
260 isl_space *dim;
261 isl_set *set;
262 ValueDecl *vd;
263 Token token;
264 int lb;
265 int ub;
266 bool has_ub = false;
268 PP.Lex(token);
269 vd = get_value_decl(sema, token);
270 if (!vd) {
271 unsupported(PP, token.getLocation());
272 return;
275 PP.Lex(token);
276 if (!token.isLiteral()) {
277 unsupported(PP, token.getLocation());
278 return;
281 lb = get_int(token.getLiteralData());
283 PP.Lex(token);
284 if (token.isLiteral()) {
285 has_ub = true;
286 ub = get_int(token.getLiteralData());
287 } else if (token.isNot(tok::eod)) {
288 unsupported(PP, token.getLocation());
289 return;
292 id = isl_id_alloc(ctx, vd->getName().str().c_str(), vd);
293 dim = isl_space_params_alloc(ctx, 1);
294 dim = isl_space_set_dim_id(dim, isl_dim_param, 0, id);
296 set = isl_set_universe(dim);
298 set = isl_set_lower_bound_si(set, isl_dim_param, 0, lb);
299 if (has_ub)
300 set = isl_set_upper_bound_si(set, isl_dim_param, 0, ub);
302 context = isl_set_intersect(context, set);
304 context_value = extract_initialization(context_value, vd);
308 #ifdef HAVE_TRANSLATELINECOL
310 /* Return a SourceLocation for line "line", column "col" of file "FID".
312 SourceLocation translateLineCol(SourceManager &SM, FileID FID, unsigned line,
313 unsigned col)
315 return SM.translateLineCol(FID, line, col);
318 #else
320 /* Return a SourceLocation for line "line", column "col" of file "FID".
322 SourceLocation translateLineCol(SourceManager &SM, FileID FID, unsigned line,
323 unsigned col)
325 return SM.getLocation(SM.getFileEntryForID(FID), line, col);
328 #endif
330 /* List of pairs of #pragma scop and #pragma endscop locations.
332 struct ScopLocList {
333 std::vector<ScopLoc> list;
335 /* Add a new start (#pragma scop) location to the list.
336 * If the last #pragma scop did not have a matching
337 * #pragma endscop then overwrite it.
339 void add_start(unsigned start) {
340 ScopLoc loc;
342 loc.start = start;
343 if (list.size() == 0 || list[list.size() - 1].end != 0)
344 list.push_back(loc);
345 else
346 list[list.size() - 1] = loc;
349 /* Set the end location (#pragma endscop) of the last pair
350 * in the list.
351 * If there is no such pair of if the end of that pair
352 * is already set, then ignore the spurious #pragma endscop.
354 void add_end(unsigned end) {
355 if (list.size() == 0 || list[list.size() - 1].end != 0)
356 return;
357 list[list.size() - 1].end = end;
361 /* Handle pragmas of the form
363 * #pragma scop
365 * In particular, store the location of the line containing
366 * the pragma in the list "scops".
368 struct PragmaScopHandler : public PragmaHandler {
369 ScopLocList &scops;
371 PragmaScopHandler(ScopLocList &scops) :
372 PragmaHandler("scop"), scops(scops) {}
374 virtual void HandlePragma(Preprocessor &PP,
375 PragmaIntroducerKind Introducer,
376 Token &ScopTok) {
377 SourceManager &SM = PP.getSourceManager();
378 SourceLocation sloc = ScopTok.getLocation();
379 int line = SM.getExpansionLineNumber(sloc);
380 sloc = translateLineCol(SM, SM.getFileID(sloc), line, 1);
381 scops.add_start(SM.getFileOffset(sloc));
385 /* Handle pragmas of the form
387 * #pragma endscop
389 * In particular, store the location of the line following the one containing
390 * the pragma in the list "scops".
392 struct PragmaEndScopHandler : public PragmaHandler {
393 ScopLocList &scops;
395 PragmaEndScopHandler(ScopLocList &scops) :
396 PragmaHandler("endscop"), scops(scops) {}
398 virtual void HandlePragma(Preprocessor &PP,
399 PragmaIntroducerKind Introducer,
400 Token &EndScopTok) {
401 SourceManager &SM = PP.getSourceManager();
402 SourceLocation sloc = EndScopTok.getLocation();
403 int line = SM.getExpansionLineNumber(sloc);
404 sloc = translateLineCol(SM, SM.getFileID(sloc), line + 1, 1);
405 scops.add_end(SM.getFileOffset(sloc));
409 /* Handle pragmas of the form
411 * #pragma live-out identifier, identifier, ...
413 * Each identifier on the line is stored in live_out.
415 struct PragmaLiveOutHandler : public PragmaHandler {
416 Sema &sema;
417 set<ValueDecl *> &live_out;
419 PragmaLiveOutHandler(Sema &sema, set<ValueDecl *> &live_out) :
420 PragmaHandler("live"), sema(sema), live_out(live_out) {}
422 virtual void HandlePragma(Preprocessor &PP,
423 PragmaIntroducerKind Introducer,
424 Token &ScopTok) {
425 Token token;
427 PP.Lex(token);
428 if (token.isNot(tok::minus))
429 return;
430 PP.Lex(token);
431 if (token.isNot(tok::identifier) ||
432 !token.getIdentifierInfo()->isStr("out"))
433 return;
435 PP.Lex(token);
436 while (token.isNot(tok::eod)) {
437 ValueDecl *vd;
439 vd = get_value_decl(sema, token);
440 if (!vd) {
441 unsupported(PP, token.getLocation());
442 return;
444 live_out.insert(vd);
445 PP.Lex(token);
446 if (token.is(tok::comma))
447 PP.Lex(token);
452 /* For each array in "scop", set its value_bounds property
453 * based on the infofrmation in "value_bounds" and
454 * mark it as live_out if it appears in "live_out".
456 static void update_arrays(struct pet_scop *scop,
457 __isl_take isl_union_map *value_bounds, set<ValueDecl *> &live_out)
459 set<ValueDecl *>::iterator lo_it;
460 isl_ctx *ctx = isl_union_map_get_ctx(value_bounds);
462 if (!scop) {
463 isl_union_map_free(value_bounds);
464 return;
467 for (int i = 0; i < scop->n_array; ++i) {
468 isl_id *id;
469 isl_space *space;
470 isl_map *bounds;
471 ValueDecl *decl;
472 pet_array *array = scop->arrays[i];
474 id = isl_set_get_tuple_id(array->extent);
475 decl = (ValueDecl *)isl_id_get_user(id);
477 space = isl_space_alloc(ctx, 0, 0, 1);
478 space = isl_space_set_tuple_id(space, isl_dim_in, id);
480 bounds = isl_union_map_extract_map(value_bounds, space);
481 if (!isl_map_plain_is_empty(bounds))
482 array->value_bounds = isl_map_range(bounds);
483 else
484 isl_map_free(bounds);
486 lo_it = live_out.find(decl);
487 if (lo_it != live_out.end())
488 array->live_out = 1;
491 isl_union_map_free(value_bounds);
494 /* Extract a pet_scop (if any) from each appropriate function.
495 * Each detected scop is passed to "fn".
496 * When autodetecting, at most one scop is extracted from each function.
497 * If "function" is not NULL, then we only extract a pet_scop if the
498 * name of the function matches.
499 * If "autodetect" is false, then we only extract if we have seen
500 * scop and endscop pragmas and if these are situated inside the function
501 * body.
503 struct PetASTConsumer : public ASTConsumer {
504 Preprocessor &PP;
505 ASTContext &ast_context;
506 DiagnosticsEngine &diags;
507 ScopLocList &scops;
508 const char *function;
509 pet_options *options;
510 isl_ctx *ctx;
511 isl_set *context;
512 isl_set *context_value;
513 set<ValueDecl *> live_out;
514 PragmaValueBoundsHandler *vb_handler;
515 int (*fn)(struct pet_scop *scop, void *user);
516 void *user;
517 bool error;
519 PetASTConsumer(isl_ctx *ctx, Preprocessor &PP, ASTContext &ast_context,
520 DiagnosticsEngine &diags, ScopLocList &scops,
521 const char *function, pet_options *options,
522 int (*fn)(struct pet_scop *scop, void *user), void *user) :
523 ctx(ctx), PP(PP), ast_context(ast_context), diags(diags),
524 scops(scops), function(function), options(options),
525 vb_handler(NULL), fn(fn), user(user), error(false)
527 isl_space *space;
528 space = isl_space_params_alloc(ctx, 0);
529 context = isl_set_universe(isl_space_copy(space));
530 context_value = isl_set_universe(space);
533 ~PetASTConsumer() {
534 isl_set_free(context);
535 isl_set_free(context_value);
538 void handle_value_bounds(Sema *sema) {
539 vb_handler = new PragmaValueBoundsHandler(ctx, *sema);
540 PP.AddPragmaHandler(vb_handler);
543 __isl_give isl_union_map *get_value_bounds() {
544 return isl_union_map_copy(vb_handler->value_bounds);
547 /* Pass "scop" to "fn" after performing some postprocessing.
548 * In particular, add the context and value_bounds constraints
549 * speficied through pragmas, add reference identifiers and
550 * reset user pointers on parameters and tuple ids.
552 void call_fn(pet_scop *scop) {
553 if (!scop)
554 return;
555 if (diags.hasErrorOccurred()) {
556 pet_scop_free(scop);
557 return;
559 scop->context = isl_set_intersect(scop->context,
560 isl_set_copy(context));
561 scop->context_value = isl_set_intersect(scop->context_value,
562 isl_set_copy(context_value));
564 update_arrays(scop, get_value_bounds(), live_out);
566 scop = pet_scop_add_ref_ids(scop);
567 scop = pet_scop_anonymize(scop);
569 if (fn(scop, user) < 0)
570 error = true;
573 /* For each explicitly marked scop (using pragmas),
574 * extract the scop and call "fn" on it if it is inside "fd".
576 void scan_scops(FunctionDecl *fd) {
577 unsigned start, end;
578 vector<ScopLoc>::iterator it;
579 isl_union_map *vb = vb_handler->value_bounds;
580 SourceManager &SM = PP.getSourceManager();
581 pet_scop *scop;
583 if (scops.list.size() == 0)
584 return;
586 start = SM.getFileOffset(fd->getLocStart());
587 end = SM.getFileOffset(fd->getLocEnd());
589 for (it = scops.list.begin(); it != scops.list.end(); ++it) {
590 ScopLoc loc = *it;
591 if (!loc.end)
592 continue;
593 if (start > loc.end)
594 continue;
595 if (end < loc.start)
596 continue;
597 PetScan ps(PP, ast_context, loc, options,
598 isl_union_map_copy(vb));
599 scop = ps.scan(fd);
600 call_fn(scop);
604 virtual HandleTopLevelDeclReturn HandleTopLevelDecl(DeclGroupRef dg) {
605 DeclGroupRef::iterator it;
607 if (error)
608 return HandleTopLevelDeclContinue;
610 for (it = dg.begin(); it != dg.end(); ++it) {
611 isl_union_map *vb = vb_handler->value_bounds;
612 FunctionDecl *fd = dyn_cast<clang::FunctionDecl>(*it);
613 if (!fd)
614 continue;
615 if (!fd->hasBody())
616 continue;
617 if (function &&
618 fd->getNameInfo().getAsString() != function)
619 continue;
620 if (options->autodetect) {
621 ScopLoc loc;
622 pet_scop *scop;
623 PetScan ps(PP, ast_context, loc, options,
624 isl_union_map_copy(vb));
625 scop = ps.scan(fd);
626 call_fn(scop);
627 continue;
629 scan_scops(fd);
632 return HandleTopLevelDeclContinue;
636 static const char *ResourceDir = CLANG_PREFIX"/lib/clang/"CLANG_VERSION_STRING;
638 static const char *implicit_functions[] = {
639 "min", "max", "intMod", "intCeil", "intFloor", "ceild", "floord"
642 static bool is_implicit(const IdentifierInfo *ident)
644 const char *name = ident->getNameStart();
645 for (int i = 0; i < ARRAY_SIZE(implicit_functions); ++i)
646 if (!strcmp(name, implicit_functions[i]))
647 return true;
648 return false;
651 /* Ignore implicit function declaration warnings on
652 * "min", "max", "ceild" and "floord" as we detect and handle these
653 * in PetScan.
655 struct MyDiagnosticPrinter : public TextDiagnosticPrinter {
656 const DiagnosticOptions *DiagOpts;
657 #ifdef HAVE_BASIC_DIAGNOSTICOPTIONS_H
658 MyDiagnosticPrinter(DiagnosticOptions *DO) :
659 TextDiagnosticPrinter(llvm::errs(), DO) {}
660 virtual DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
661 return new MyDiagnosticPrinter(&Diags.getDiagnosticOptions());
663 #else
664 MyDiagnosticPrinter(const DiagnosticOptions &DO) :
665 DiagOpts(&DO), TextDiagnosticPrinter(llvm::errs(), DO) {}
666 virtual DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
667 return new MyDiagnosticPrinter(*DiagOpts);
669 #endif
670 virtual void HandleDiagnostic(DiagnosticsEngine::Level level,
671 const DiagnosticInfo &info) {
672 if (info.getID() == diag::ext_implicit_function_decl &&
673 info.getNumArgs() == 1 &&
674 info.getArgKind(0) == DiagnosticsEngine::ak_identifierinfo &&
675 is_implicit(info.getArgIdentifier(0)))
676 /* ignore warning */;
677 else
678 TextDiagnosticPrinter::HandleDiagnostic(level, info);
682 #ifdef USE_ARRAYREF
684 #ifdef HAVE_CXXISPRODUCTION
685 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
687 return new Driver(binary, llvm::sys::getDefaultTargetTriple(),
688 "", false, false, Diags);
690 #elif defined(HAVE_ISPRODUCTION)
691 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
693 return new Driver(binary, llvm::sys::getDefaultTargetTriple(),
694 "", false, Diags);
696 #else
697 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
699 return new Driver(binary, llvm::sys::getDefaultTargetTriple(),
700 "", Diags);
702 #endif
704 /* Create a CompilerInvocation object that stores the command line
705 * arguments constructed by the driver.
706 * The arguments are mainly useful for setting up the system include
707 * paths on newer clangs and on some platforms.
709 static CompilerInvocation *construct_invocation(const char *filename,
710 DiagnosticsEngine &Diags)
712 const char *binary = CLANG_PREFIX"/bin/clang";
713 const llvm::OwningPtr<Driver> driver(construct_driver(binary, Diags));
714 std::vector<const char *> Argv;
715 Argv.push_back(binary);
716 Argv.push_back(filename);
717 const llvm::OwningPtr<Compilation> compilation(
718 driver->BuildCompilation(llvm::ArrayRef<const char *>(Argv)));
719 JobList &Jobs = compilation->getJobs();
720 if (Jobs.size() < 1)
721 return NULL;
723 Command *cmd = cast<Command>(*Jobs.begin());
724 if (strcmp(cmd->getCreator().getName(), "clang"))
725 return NULL;
727 const ArgStringList *args = &cmd->getArguments();
729 CompilerInvocation *invocation = new CompilerInvocation;
730 CompilerInvocation::CreateFromArgs(*invocation, args->data() + 1,
731 args->data() + args->size(),
732 Diags);
733 return invocation;
736 #else
738 static CompilerInvocation *construct_invocation(const char *filename,
739 DiagnosticsEngine &Diags)
741 return NULL;
744 #endif
746 #ifdef HAVE_BASIC_DIAGNOSTICOPTIONS_H
748 static MyDiagnosticPrinter *construct_printer(CompilerInstance *Clang)
750 return new MyDiagnosticPrinter(new DiagnosticOptions());
753 #else
755 static MyDiagnosticPrinter *construct_printer(CompilerInstance *Clang)
757 return new MyDiagnosticPrinter(Clang->getDiagnosticOpts());
760 #endif
762 #ifdef CREATETARGETINFO_TAKES_POINTER
764 static TargetInfo *create_target_info(CompilerInstance *Clang,
765 DiagnosticsEngine &Diags)
767 TargetOptions &TO = Clang->getTargetOpts();
768 TO.Triple = llvm::sys::getDefaultTargetTriple();
769 return TargetInfo::CreateTargetInfo(Diags, &TO);
772 #else
774 static TargetInfo *create_target_info(CompilerInstance *Clang,
775 DiagnosticsEngine &Diags)
777 TargetOptions &TO = Clang->getTargetOpts();
778 TO.Triple = llvm::sys::getDefaultTargetTriple();
779 return TargetInfo::CreateTargetInfo(Diags, TO);
782 #endif
784 #ifdef CREATEDIAGNOSTICS_TAKES_ARG
786 static void create_diagnostics(CompilerInstance *Clang)
788 Clang->createDiagnostics(0, NULL);
791 #else
793 static void create_diagnostics(CompilerInstance *Clang)
795 Clang->createDiagnostics();
798 #endif
800 #ifdef ADDPATH_TAKES_4_ARGUMENTS
802 void add_path(HeaderSearchOptions &HSO, string Path)
804 HSO.AddPath(Path, frontend::Angled, false, false);
807 #else
809 void add_path(HeaderSearchOptions &HSO, string Path)
811 HSO.AddPath(Path, frontend::Angled, true, false, false);
814 #endif
816 /* Add pet specific predefines to the preprocessor.
818 * We mimic the way <command line> is handled inside clang.
820 void add_predefines(Preprocessor &PP)
822 string s;
824 s = PP.getPredefines();
825 s += "# 1 \"<pet>\" 1\n"
826 "void __pencil_assume(int assumption);\n"
827 "# 1 \"<built-in>\" 2\n";
828 PP.setPredefines(s);
831 /* Extract a pet_scop from each function in the C source file called "filename".
832 * Each detected scop is passed to "fn".
833 * If "function" is not NULL, only extract a pet_scop from the function
834 * with that name.
835 * If "autodetect" is set, extract any pet_scop we can find.
836 * Otherwise, extract the pet_scop from the region delimited
837 * by "scop" and "endscop" pragmas.
839 * We first set up the clang parser and then try to extract the
840 * pet_scop from the appropriate function(s) in PetASTConsumer.
842 static int foreach_scop_in_C_source(isl_ctx *ctx,
843 const char *filename, const char *function, pet_options *options,
844 int (*fn)(struct pet_scop *scop, void *user), void *user)
846 CompilerInstance *Clang = new CompilerInstance();
847 create_diagnostics(Clang);
848 DiagnosticsEngine &Diags = Clang->getDiagnostics();
849 Diags.setSuppressSystemWarnings(true);
850 CompilerInvocation *invocation = construct_invocation(filename, Diags);
851 if (invocation)
852 Clang->setInvocation(invocation);
853 Diags.setClient(construct_printer(Clang));
854 Clang->createFileManager();
855 Clang->createSourceManager(Clang->getFileManager());
856 TargetInfo *target = create_target_info(Clang, Diags);
857 Clang->setTarget(target);
858 CompilerInvocation::setLangDefaults(Clang->getLangOpts(), IK_C,
859 LangStandard::lang_unspecified);
860 HeaderSearchOptions &HSO = Clang->getHeaderSearchOpts();
861 HSO.ResourceDir = ResourceDir;
862 for (int i = 0; i < options->n_path; ++i)
863 add_path(HSO, options->paths[i]);
864 PreprocessorOptions &PO = Clang->getPreprocessorOpts();
865 for (int i = 0; i < options->n_define; ++i)
866 PO.addMacroDef(options->defines[i]);
867 Clang->createPreprocessor();
868 Preprocessor &PP = Clang->getPreprocessor();
869 add_predefines(PP);
871 ScopLocList scops;
873 const FileEntry *file = Clang->getFileManager().getFile(filename);
874 if (!file)
875 isl_die(ctx, isl_error_unknown, "unable to open file",
876 do { delete Clang; return -1; } while (0));
877 Clang->getSourceManager().createMainFileID(file);
879 Clang->createASTContext();
880 PetASTConsumer consumer(ctx, PP, Clang->getASTContext(), Diags,
881 scops, function, options, fn, user);
882 Sema *sema = new Sema(PP, Clang->getASTContext(), consumer);
884 if (!options->autodetect) {
885 PP.AddPragmaHandler(new PragmaScopHandler(scops));
886 PP.AddPragmaHandler(new PragmaEndScopHandler(scops));
887 PP.AddPragmaHandler(new PragmaLiveOutHandler(*sema,
888 consumer.live_out));
891 PP.AddPragmaHandler(new PragmaParameterHandler(*sema, consumer.context,
892 consumer.context_value));
893 consumer.handle_value_bounds(sema);
895 Diags.getClient()->BeginSourceFile(Clang->getLangOpts(), &PP);
896 ParseAST(*sema);
897 Diags.getClient()->EndSourceFile();
899 delete sema;
900 delete Clang;
902 return consumer.error ? -1 : 0;
905 /* Extract a pet_scop from each function in the C source file called "filename".
906 * Each detected scop is passed to "fn".
908 * This wrapper around foreach_scop_in_C_source is mainly used to ensure
909 * that all objects on the stack (of that function) are destroyed before we
910 * call llvm_shutdown.
912 static int pet_foreach_scop_in_C_source(isl_ctx *ctx,
913 const char *filename, const char *function,
914 int (*fn)(struct pet_scop *scop, void *user), void *user)
916 int r;
917 pet_options *options;
918 bool allocated = false;
920 options = isl_ctx_peek_pet_options(ctx);
921 if (!options) {
922 options = pet_options_new_with_defaults();
923 allocated = true;
926 r = foreach_scop_in_C_source(ctx, filename, function, options,
927 fn, user);
928 llvm::llvm_shutdown();
930 if (allocated)
931 pet_options_free(options);
933 return r;
936 /* Store "scop" into the address pointed to by "user".
937 * Return -1 to indicate that we are not interested in any further scops.
938 * This function should therefore not be called a second call
939 * so in principle there is no need to check if we have already set *user.
941 static int set_first_scop(pet_scop *scop, void *user)
943 pet_scop **p = (pet_scop **) user;
945 if (!*p)
946 *p = scop;
947 else
948 pet_scop_free(scop);
950 return -1;
953 /* Extract a pet_scop from the C source file called "filename".
954 * If "function" is not NULL, extract the pet_scop from the function
955 * with that name.
957 * We start extracting scops from every function and then abort
958 * as soon as we have extracted one scop.
960 struct pet_scop *pet_scop_extract_from_C_source(isl_ctx *ctx,
961 const char *filename, const char *function)
963 pet_scop *scop = NULL;
965 pet_foreach_scop_in_C_source(ctx, filename, function,
966 &set_first_scop, &scop);
968 return scop;
971 /* Internal data structure for pet_transform_C_source
973 * transform is the function that should be called to print a scop
974 * in is the input source file
975 * out is the output source file
976 * end is the offset of the end of the previous scop (zero if we have not
977 * found any scop yet)
978 * p is a printer that prints to out.
980 struct pet_transform_data {
981 __isl_give isl_printer *(*transform)(__isl_take isl_printer *p,
982 struct pet_scop *scop, void *user);
983 void *user;
985 FILE *in;
986 FILE *out;
987 unsigned end;
988 isl_printer *p;
991 /* This function is called each time a scop is detected.
993 * We first copy the input text code from the end of the previous scop
994 * until the start of "scop" and then print the scop itself through
995 * a call to data->transform.
996 * Finally, we keep track of the end of "scop" so that we can
997 * continue copying when we find the next scop.
999 * Before calling data->transform, we store a pointer to the original
1000 * input file in the extended scop in case the user wants to call
1001 * pet_scop_print_original from the callback.
1003 static int pet_transform(struct pet_scop *scop, void *user)
1005 struct pet_transform_data *data = (struct pet_transform_data *) user;
1007 if (copy(data->in, data->out, data->end, scop->start) < 0)
1008 goto error;
1009 data->end = scop->end;
1010 scop = pet_scop_set_input_file(scop, data->in);
1011 data->p = data->transform(data->p, scop, data->user);
1012 if (!data->p)
1013 return -1;
1014 return 0;
1015 error:
1016 pet_scop_free(scop);
1017 return -1;
1020 /* Transform the C source file "input" by rewriting each scop
1021 * through a call to "transform".
1022 * When autodetecting scops, at most one scop per function is rewritten.
1023 * The transformed C code is written to "output".
1025 * For each scop we find, we first copy the input text code
1026 * from the end of the previous scop (or the beginning of the file
1027 * in case of the first scop) until the start of the scop
1028 * and then print the scop itself through a call to "transform".
1029 * At the end we copy everything from the end of the final scop
1030 * until the end of the input file to "output".
1032 int pet_transform_C_source(isl_ctx *ctx, const char *input, FILE *out,
1033 __isl_give isl_printer *(*transform)(__isl_take isl_printer *p,
1034 struct pet_scop *scop, void *user), void *user)
1036 struct pet_transform_data data;
1037 int r;
1039 data.in = stdin;
1040 data.out = out;
1041 if (input && strcmp(input, "-")) {
1042 data.in = fopen(input, "r");
1043 if (!data.in)
1044 isl_die(ctx, isl_error_unknown, "unable to open file",
1045 return -1);
1048 data.p = isl_printer_to_file(ctx, data.out);
1049 data.p = isl_printer_set_output_format(data.p, ISL_FORMAT_C);
1051 data.transform = transform;
1052 data.user = user;
1053 data.end = 0;
1054 r = pet_foreach_scop_in_C_source(ctx, input, NULL,
1055 &pet_transform, &data);
1057 isl_printer_free(data.p);
1058 if (!data.p)
1059 r = -1;
1060 if (r == 0 && copy(data.in, data.out, data.end, -1) < 0)
1061 r = -1;
1063 if (data.in != stdin)
1064 fclose(data.in);
1066 return r;