2 * Copyright 2011 Leiden University. All rights reserved.
3 * Copyright 2012-2014 Ecole Normale Superieure. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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
41 #ifdef HAVE_ADT_OWNINGPTR_H
42 #include <llvm/ADT/OwningPtr.h>
46 #include <llvm/Support/raw_ostream.h>
47 #include <llvm/Support/ManagedStatic.h>
48 #include <llvm/Support/Host.h>
49 #include <clang/Basic/Version.h>
50 #include <clang/Basic/FileSystemOptions.h>
51 #include <clang/Basic/FileManager.h>
52 #include <clang/Basic/TargetOptions.h>
53 #include <clang/Basic/TargetInfo.h>
54 #include <clang/Driver/Compilation.h>
55 #include <clang/Driver/Driver.h>
56 #include <clang/Driver/Tool.h>
57 #include <clang/Frontend/CompilerInstance.h>
58 #include <clang/Frontend/CompilerInvocation.h>
59 #ifdef HAVE_BASIC_DIAGNOSTICOPTIONS_H
60 #include <clang/Basic/DiagnosticOptions.h>
62 #include <clang/Frontend/DiagnosticOptions.h>
64 #include <clang/Frontend/TextDiagnosticPrinter.h>
65 #ifdef HAVE_LEX_HEADERSEARCHOPTIONS_H
66 #include <clang/Lex/HeaderSearchOptions.h>
68 #include <clang/Frontend/HeaderSearchOptions.h>
70 #include <clang/Frontend/LangStandard.h>
71 #ifdef HAVE_LEX_PREPROCESSOROPTIONS_H
72 #include <clang/Lex/PreprocessorOptions.h>
74 #include <clang/Frontend/PreprocessorOptions.h>
76 #include <clang/Frontend/FrontendOptions.h>
77 #include <clang/Frontend/Utils.h>
78 #include <clang/Lex/HeaderSearch.h>
79 #include <clang/Lex/Preprocessor.h>
80 #include <clang/Lex/Pragma.h>
81 #include <clang/AST/ASTContext.h>
82 #include <clang/AST/ASTConsumer.h>
83 #include <clang/Sema/Sema.h>
84 #include <clang/Sema/SemaDiagnostic.h>
85 #include <clang/Parse/Parser.h>
86 #include <clang/Parse/ParseAST.h>
89 #include <isl/constraint.h>
97 #define ARRAY_SIZE(array) (sizeof(array)/sizeof(*array))
100 using namespace clang
;
101 using namespace clang::driver
;
103 #ifdef HAVE_ADT_OWNINGPTR_H
104 #define unique_ptr llvm::OwningPtr
107 /* Called if we found something we didn't expect in one of the pragmas.
108 * We'll provide more informative warnings later.
110 static void unsupported(Preprocessor
&PP
, SourceLocation loc
)
112 DiagnosticsEngine
&diag
= PP
.getDiagnostics();
113 unsigned id
= diag
.getCustomDiagID(DiagnosticsEngine::Warning
,
115 DiagnosticBuilder B
= diag
.Report(loc
, id
);
118 static int get_int(const char *s
)
120 return s
[0] == '"' ? atoi(s
+ 1) : atoi(s
);
123 static ValueDecl
*get_value_decl(Sema
&sema
, Token
&token
)
125 IdentifierInfo
*name
;
128 if (token
.isNot(tok::identifier
))
131 name
= token
.getIdentifierInfo();
132 decl
= sema
.LookupSingleName(sema
.TUScope
, name
,
133 token
.getLocation(), Sema::LookupOrdinaryName
);
134 return decl
? cast_or_null
<ValueDecl
>(decl
) : NULL
;
137 /* Handle pragmas of the form
139 * #pragma value_bounds identifier lower_bound upper_bound
141 * For each such pragma, add a mapping
142 * { identifier[] -> [i] : lower_bound <= i <= upper_bound }
145 struct PragmaValueBoundsHandler
: public PragmaHandler
{
148 isl_union_map
*value_bounds
;
150 PragmaValueBoundsHandler(isl_ctx
*ctx
, Sema
&sema
) :
151 PragmaHandler("value_bounds"), ctx(ctx
), sema(sema
) {
152 isl_space
*space
= isl_space_params_alloc(ctx
, 0);
153 value_bounds
= isl_union_map_empty(space
);
156 ~PragmaValueBoundsHandler() {
157 isl_union_map_free(value_bounds
);
160 virtual void HandlePragma(Preprocessor
&PP
,
161 PragmaIntroducerKind Introducer
,
172 vd
= get_value_decl(sema
, token
);
174 unsupported(PP
, token
.getLocation());
179 if (!token
.isLiteral()) {
180 unsupported(PP
, token
.getLocation());
184 lb
= get_int(token
.getLiteralData());
187 if (!token
.isLiteral()) {
188 unsupported(PP
, token
.getLocation());
192 ub
= get_int(token
.getLiteralData());
194 dim
= isl_space_alloc(ctx
, 0, 0, 1);
195 map
= isl_map_universe(dim
);
196 map
= isl_map_lower_bound_si(map
, isl_dim_out
, 0, lb
);
197 map
= isl_map_upper_bound_si(map
, isl_dim_out
, 0, ub
);
198 id
= isl_id_alloc(ctx
, vd
->getName().str().c_str(), vd
);
199 map
= isl_map_set_tuple_id(map
, isl_dim_in
, id
);
201 value_bounds
= isl_union_map_add_map(value_bounds
, map
);
205 /* Given a variable declaration, check if it has an integer initializer
206 * and if so, add a parameter corresponding to the variable to "value"
207 * with its value fixed to the integer initializer and return the result.
209 static __isl_give isl_set
*extract_initialization(__isl_take isl_set
*value
,
221 vd
= cast
<VarDecl
>(decl
);
224 if (!vd
->getType()->isIntegerType())
226 expr
= vd
->getInit();
229 il
= cast
<IntegerLiteral
>(expr
);
233 ctx
= isl_set_get_ctx(value
);
234 id
= isl_id_alloc(ctx
, vd
->getName().str().c_str(), vd
);
235 space
= isl_space_params_alloc(ctx
, 1);
236 space
= isl_space_set_dim_id(space
, isl_dim_param
, 0, id
);
237 set
= isl_set_universe(space
);
239 v
= PetScan::extract_int(ctx
, il
);
240 set
= isl_set_fix_val(set
, isl_dim_param
, 0, v
);
242 return isl_set_intersect(value
, set
);
245 /* Handle pragmas of the form
247 * #pragma parameter identifier lower_bound
249 * #pragma parameter identifier lower_bound upper_bound
251 * For each such pragma, intersect the context with the set
252 * [identifier] -> { [] : lower_bound <= identifier <= upper_bound }
254 struct PragmaParameterHandler
: public PragmaHandler
{
257 isl_set
*&context_value
;
259 PragmaParameterHandler(Sema
&sema
, isl_set
*&context
,
260 isl_set
*&context_value
) :
261 PragmaHandler("parameter"), sema(sema
), context(context
),
262 context_value(context_value
) {}
264 virtual void HandlePragma(Preprocessor
&PP
,
265 PragmaIntroducerKind Introducer
,
268 isl_ctx
*ctx
= isl_set_get_ctx(context
);
278 vd
= get_value_decl(sema
, token
);
280 unsupported(PP
, token
.getLocation());
285 if (!token
.isLiteral()) {
286 unsupported(PP
, token
.getLocation());
290 lb
= get_int(token
.getLiteralData());
293 if (token
.isLiteral()) {
295 ub
= get_int(token
.getLiteralData());
296 } else if (token
.isNot(tok::eod
)) {
297 unsupported(PP
, token
.getLocation());
301 id
= isl_id_alloc(ctx
, vd
->getName().str().c_str(), vd
);
302 dim
= isl_space_params_alloc(ctx
, 1);
303 dim
= isl_space_set_dim_id(dim
, isl_dim_param
, 0, id
);
305 set
= isl_set_universe(dim
);
307 set
= isl_set_lower_bound_si(set
, isl_dim_param
, 0, lb
);
309 set
= isl_set_upper_bound_si(set
, isl_dim_param
, 0, ub
);
311 context
= isl_set_intersect(context
, set
);
313 context_value
= extract_initialization(context_value
, vd
);
317 /* Handle pragmas of the form
319 * #pragma pencil independent
321 * For each such pragma, add an entry to the "independent" vector.
323 struct PragmaPencilHandler
: public PragmaHandler
{
324 std::vector
<Independent
> &independent
;
326 PragmaPencilHandler(std::vector
<Independent
> &independent
) :
327 PragmaHandler("pencil"), independent(independent
) {}
329 virtual void HandlePragma(Preprocessor
&PP
,
330 PragmaIntroducerKind Introducer
,
333 IdentifierInfo
*info
;
336 if (token
.isNot(tok::identifier
))
339 info
= token
.getIdentifierInfo();
340 if (!info
->isStr("independent"))
344 if (token
.isNot(tok::eod
))
347 SourceManager
&SM
= PP
.getSourceManager();
348 SourceLocation sloc
= PencilTok
.getLocation();
349 unsigned line
= SM
.getExpansionLineNumber(sloc
);
350 independent
.push_back(Independent(line
));
354 #ifdef HAVE_TRANSLATELINECOL
356 /* Return a SourceLocation for line "line", column "col" of file "FID".
358 SourceLocation
translateLineCol(SourceManager
&SM
, FileID FID
, unsigned line
,
361 return SM
.translateLineCol(FID
, line
, col
);
366 /* Return a SourceLocation for line "line", column "col" of file "FID".
368 SourceLocation
translateLineCol(SourceManager
&SM
, FileID FID
, unsigned line
,
371 return SM
.getLocation(SM
.getFileEntryForID(FID
), line
, col
);
376 /* List of pairs of #pragma scop and #pragma endscop locations.
379 std::vector
<ScopLoc
> list
;
381 /* Add a new start (#pragma scop) location to the list.
382 * If the last #pragma scop did not have a matching
383 * #pragma endscop then overwrite it.
385 void add_start(unsigned line
, unsigned start
) {
388 loc
.start_line
= line
;
390 if (list
.size() == 0 || list
[list
.size() - 1].end
!= 0)
393 list
[list
.size() - 1] = loc
;
396 /* Set the end location (#pragma endscop) of the last pair
398 * If there is no such pair of if the end of that pair
399 * is already set, then ignore the spurious #pragma endscop.
401 void add_end(unsigned end
) {
402 if (list
.size() == 0 || list
[list
.size() - 1].end
!= 0)
404 list
[list
.size() - 1].end
= end
;
408 /* Handle pragmas of the form
412 * In particular, store the location of the line containing
413 * the pragma in the list "scops".
415 struct PragmaScopHandler
: public PragmaHandler
{
418 PragmaScopHandler(ScopLocList
&scops
) :
419 PragmaHandler("scop"), scops(scops
) {}
421 virtual void HandlePragma(Preprocessor
&PP
,
422 PragmaIntroducerKind Introducer
,
424 SourceManager
&SM
= PP
.getSourceManager();
425 SourceLocation sloc
= ScopTok
.getLocation();
426 int line
= SM
.getExpansionLineNumber(sloc
);
427 sloc
= translateLineCol(SM
, SM
.getFileID(sloc
), line
, 1);
428 scops
.add_start(line
, SM
.getFileOffset(sloc
));
432 /* Handle pragmas of the form
436 * In particular, store the location of the line following the one containing
437 * the pragma in the list "scops".
439 struct PragmaEndScopHandler
: public PragmaHandler
{
442 PragmaEndScopHandler(ScopLocList
&scops
) :
443 PragmaHandler("endscop"), scops(scops
) {}
445 virtual void HandlePragma(Preprocessor
&PP
,
446 PragmaIntroducerKind Introducer
,
448 SourceManager
&SM
= PP
.getSourceManager();
449 SourceLocation sloc
= EndScopTok
.getLocation();
450 int line
= SM
.getExpansionLineNumber(sloc
);
451 sloc
= translateLineCol(SM
, SM
.getFileID(sloc
), line
+ 1, 1);
452 scops
.add_end(SM
.getFileOffset(sloc
));
456 /* Handle pragmas of the form
458 * #pragma live-out identifier, identifier, ...
460 * Each identifier on the line is stored in live_out.
462 struct PragmaLiveOutHandler
: public PragmaHandler
{
464 set
<ValueDecl
*> &live_out
;
466 PragmaLiveOutHandler(Sema
&sema
, set
<ValueDecl
*> &live_out
) :
467 PragmaHandler("live"), sema(sema
), live_out(live_out
) {}
469 virtual void HandlePragma(Preprocessor
&PP
,
470 PragmaIntroducerKind Introducer
,
475 if (token
.isNot(tok::minus
))
478 if (token
.isNot(tok::identifier
) ||
479 !token
.getIdentifierInfo()->isStr("out"))
483 while (token
.isNot(tok::eod
)) {
486 vd
= get_value_decl(sema
, token
);
488 unsupported(PP
, token
.getLocation());
493 if (token
.is(tok::comma
))
499 /* For each array in "scop", set its value_bounds property
500 * based on the infofrmation in "value_bounds" and
501 * mark it as live_out if it appears in "live_out".
503 static void update_arrays(struct pet_scop
*scop
,
504 __isl_take isl_union_map
*value_bounds
, set
<ValueDecl
*> &live_out
)
506 set
<ValueDecl
*>::iterator lo_it
;
507 isl_ctx
*ctx
= isl_union_map_get_ctx(value_bounds
);
510 isl_union_map_free(value_bounds
);
514 for (int i
= 0; i
< scop
->n_array
; ++i
) {
519 pet_array
*array
= scop
->arrays
[i
];
521 id
= isl_set_get_tuple_id(array
->extent
);
522 decl
= (ValueDecl
*)isl_id_get_user(id
);
524 space
= isl_space_alloc(ctx
, 0, 0, 1);
525 space
= isl_space_set_tuple_id(space
, isl_dim_in
, id
);
527 bounds
= isl_union_map_extract_map(value_bounds
, space
);
528 if (!isl_map_plain_is_empty(bounds
))
529 array
->value_bounds
= isl_map_range(bounds
);
531 isl_map_free(bounds
);
533 lo_it
= live_out
.find(decl
);
534 if (lo_it
!= live_out
.end())
538 isl_union_map_free(value_bounds
);
541 /* Extract a pet_scop (if any) from each appropriate function.
542 * Each detected scop is passed to "fn".
543 * When autodetecting, at most one scop is extracted from each function.
544 * If "function" is not NULL, then we only extract a pet_scop if the
545 * name of the function matches.
546 * If "autodetect" is false, then we only extract if we have seen
547 * scop and endscop pragmas and if these are situated inside the function
550 struct PetASTConsumer
: public ASTConsumer
{
552 ASTContext
&ast_context
;
553 DiagnosticsEngine
&diags
;
555 std::vector
<Independent
> independent
;
556 const char *function
;
557 pet_options
*options
;
560 isl_set
*context_value
;
561 set
<ValueDecl
*> live_out
;
562 PragmaValueBoundsHandler
*vb_handler
;
563 int (*fn
)(struct pet_scop
*scop
, void *user
);
567 PetASTConsumer(isl_ctx
*ctx
, Preprocessor
&PP
, ASTContext
&ast_context
,
568 DiagnosticsEngine
&diags
, ScopLocList
&scops
,
569 const char *function
, pet_options
*options
,
570 int (*fn
)(struct pet_scop
*scop
, void *user
), void *user
) :
571 ctx(ctx
), PP(PP
), ast_context(ast_context
), diags(diags
),
572 scops(scops
), function(function
), options(options
),
573 vb_handler(NULL
), fn(fn
), user(user
), error(false)
576 space
= isl_space_params_alloc(ctx
, 0);
577 context
= isl_set_universe(isl_space_copy(space
));
578 context_value
= isl_set_universe(space
);
582 isl_set_free(context
);
583 isl_set_free(context_value
);
586 void handle_value_bounds(Sema
*sema
) {
587 vb_handler
= new PragmaValueBoundsHandler(ctx
, *sema
);
588 PP
.AddPragmaHandler(vb_handler
);
591 /* Add all pragma handlers to this->PP.
593 void add_pragma_handlers(Sema
*sema
) {
594 PP
.AddPragmaHandler(new PragmaParameterHandler(*sema
, context
,
596 PP
.AddPragmaHandler(new PragmaPencilHandler(independent
));
597 handle_value_bounds(sema
);
600 __isl_give isl_union_map
*get_value_bounds() {
601 return isl_union_map_copy(vb_handler
->value_bounds
);
604 /* Pass "scop" to "fn" after performing some postprocessing.
605 * In particular, add the context and value_bounds constraints
606 * speficied through pragmas, add reference identifiers and
607 * reset user pointers on parameters and tuple ids.
609 * If "scop" does not contain any statements and autodetect
610 * is turned on, then skip it.
612 void call_fn(pet_scop
*scop
) {
615 if (diags
.hasErrorOccurred()) {
619 if (options
->autodetect
&& scop
->n_stmt
== 0) {
623 scop
->context
= isl_set_intersect(scop
->context
,
624 isl_set_copy(context
));
625 scop
->context_value
= isl_set_intersect(scop
->context_value
,
626 isl_set_copy(context_value
));
628 update_arrays(scop
, get_value_bounds(), live_out
);
630 scop
= pet_scop_add_ref_ids(scop
);
631 scop
= pet_scop_anonymize(scop
);
633 if (fn(scop
, user
) < 0)
637 /* For each explicitly marked scop (using pragmas),
638 * extract the scop and call "fn" on it if it is inside "fd".
640 void scan_scops(FunctionDecl
*fd
) {
642 vector
<ScopLoc
>::iterator it
;
643 isl_union_map
*vb
= vb_handler
->value_bounds
;
644 SourceManager
&SM
= PP
.getSourceManager();
647 if (scops
.list
.size() == 0)
650 start
= SM
.getFileOffset(fd
->getLocStart());
651 end
= SM
.getFileOffset(fd
->getLocEnd());
653 for (it
= scops
.list
.begin(); it
!= scops
.list
.end(); ++it
) {
661 PetScan
ps(PP
, ast_context
, loc
, options
,
662 isl_union_map_copy(vb
), independent
);
668 virtual HandleTopLevelDeclReturn
HandleTopLevelDecl(DeclGroupRef dg
) {
669 DeclGroupRef::iterator it
;
672 return HandleTopLevelDeclContinue
;
674 for (it
= dg
.begin(); it
!= dg
.end(); ++it
) {
675 isl_union_map
*vb
= vb_handler
->value_bounds
;
676 FunctionDecl
*fd
= dyn_cast
<clang::FunctionDecl
>(*it
);
682 fd
->getNameInfo().getAsString() != function
)
684 if (options
->autodetect
) {
687 PetScan
ps(PP
, ast_context
, loc
, options
,
688 isl_union_map_copy(vb
),
697 return HandleTopLevelDeclContinue
;
701 static const char *ResourceDir
=
702 CLANG_PREFIX
"/lib/clang/" CLANG_VERSION_STRING
;
704 static const char *implicit_functions
[] = {
705 "min", "imin", "umin", "max", "imax", "umax",
706 "intMod", "intCeil", "intFloor", "ceild", "floord",
710 static bool is_implicit(const IdentifierInfo
*ident
)
712 const char *name
= ident
->getNameStart();
713 for (int i
= 0; i
< ARRAY_SIZE(implicit_functions
); ++i
)
714 if (!strcmp(name
, implicit_functions
[i
]))
719 /* Ignore implicit function declaration warnings on
720 * "min", "max", "ceild" and "floord" as we detect and handle these
723 struct MyDiagnosticPrinter
: public TextDiagnosticPrinter
{
724 const DiagnosticOptions
*DiagOpts
;
725 #ifdef HAVE_BASIC_DIAGNOSTICOPTIONS_H
726 MyDiagnosticPrinter(DiagnosticOptions
*DO
) :
727 TextDiagnosticPrinter(llvm::errs(), DO
) {}
728 virtual DiagnosticConsumer
*clone(DiagnosticsEngine
&Diags
) const {
729 return new MyDiagnosticPrinter(&Diags
.getDiagnosticOptions());
732 MyDiagnosticPrinter(const DiagnosticOptions
&DO
) :
733 DiagOpts(&DO
), TextDiagnosticPrinter(llvm::errs(), DO
) {}
734 virtual DiagnosticConsumer
*clone(DiagnosticsEngine
&Diags
) const {
735 return new MyDiagnosticPrinter(*DiagOpts
);
738 virtual void HandleDiagnostic(DiagnosticsEngine::Level level
,
739 const DiagnosticInfo
&info
) {
740 if (info
.getID() == diag::ext_implicit_function_decl
&&
741 info
.getNumArgs() == 1 &&
742 info
.getArgKind(0) == DiagnosticsEngine::ak_identifierinfo
&&
743 is_implicit(info
.getArgIdentifier(0)))
744 /* ignore warning */;
746 TextDiagnosticPrinter::HandleDiagnostic(level
, info
);
752 #ifdef HAVE_CXXISPRODUCTION
753 static Driver
*construct_driver(const char *binary
, DiagnosticsEngine
&Diags
)
755 return new Driver(binary
, llvm::sys::getDefaultTargetTriple(),
756 "", false, false, Diags
);
758 #elif defined(HAVE_ISPRODUCTION)
759 static Driver
*construct_driver(const char *binary
, DiagnosticsEngine
&Diags
)
761 return new Driver(binary
, llvm::sys::getDefaultTargetTriple(),
764 #elif defined(DRIVER_CTOR_TAKES_DEFAULTIMAGENAME)
765 static Driver
*construct_driver(const char *binary
, DiagnosticsEngine
&Diags
)
767 return new Driver(binary
, llvm::sys::getDefaultTargetTriple(),
771 static Driver
*construct_driver(const char *binary
, DiagnosticsEngine
&Diags
)
773 return new Driver(binary
, llvm::sys::getDefaultTargetTriple(), Diags
);
777 /* Clang changed its API from 3.5 to 3.6, we fix this with a simple overloaded
781 static Job
*command(Job
*J
) { return J
; }
782 static Job
*command(Job
&J
) { return &J
; }
785 /* Create a CompilerInvocation object that stores the command line
786 * arguments constructed by the driver.
787 * The arguments are mainly useful for setting up the system include
788 * paths on newer clangs and on some platforms.
790 static CompilerInvocation
*construct_invocation(const char *filename
,
791 DiagnosticsEngine
&Diags
)
793 const char *binary
= CLANG_PREFIX
"/bin/clang";
794 const unique_ptr
<Driver
> driver(construct_driver(binary
, Diags
));
795 std::vector
<const char *> Argv
;
796 Argv
.push_back(binary
);
797 Argv
.push_back(filename
);
798 const unique_ptr
<Compilation
> compilation(
799 driver
->BuildCompilation(llvm::ArrayRef
<const char *>(Argv
)));
800 JobList
&Jobs
= compilation
->getJobs();
804 Command
*cmd
= cast
<Command
>(ClangAPI::command(*Jobs
.begin()));
805 if (strcmp(cmd
->getCreator().getName(), "clang"))
808 const ArgStringList
*args
= &cmd
->getArguments();
810 CompilerInvocation
*invocation
= new CompilerInvocation
;
811 CompilerInvocation::CreateFromArgs(*invocation
, args
->data() + 1,
812 args
->data() + args
->size(),
819 static CompilerInvocation
*construct_invocation(const char *filename
,
820 DiagnosticsEngine
&Diags
)
827 #ifdef HAVE_BASIC_DIAGNOSTICOPTIONS_H
829 static MyDiagnosticPrinter
*construct_printer(CompilerInstance
*Clang
)
831 return new MyDiagnosticPrinter(new DiagnosticOptions());
836 static MyDiagnosticPrinter
*construct_printer(CompilerInstance
*Clang
)
838 return new MyDiagnosticPrinter(Clang
->getDiagnosticOpts());
843 #ifdef CREATETARGETINFO_TAKES_SHARED_PTR
845 static TargetInfo
*create_target_info(CompilerInstance
*Clang
,
846 DiagnosticsEngine
&Diags
)
848 shared_ptr
<TargetOptions
> TO
= Clang
->getInvocation().TargetOpts
;
849 TO
->Triple
= llvm::sys::getDefaultTargetTriple();
850 return TargetInfo::CreateTargetInfo(Diags
, TO
);
853 #elif defined(CREATETARGETINFO_TAKES_POINTER)
855 static TargetInfo
*create_target_info(CompilerInstance
*Clang
,
856 DiagnosticsEngine
&Diags
)
858 TargetOptions
&TO
= Clang
->getTargetOpts();
859 TO
.Triple
= llvm::sys::getDefaultTargetTriple();
860 return TargetInfo::CreateTargetInfo(Diags
, &TO
);
865 static TargetInfo
*create_target_info(CompilerInstance
*Clang
,
866 DiagnosticsEngine
&Diags
)
868 TargetOptions
&TO
= Clang
->getTargetOpts();
869 TO
.Triple
= llvm::sys::getDefaultTargetTriple();
870 return TargetInfo::CreateTargetInfo(Diags
, TO
);
875 #ifdef CREATEDIAGNOSTICS_TAKES_ARG
877 static void create_diagnostics(CompilerInstance
*Clang
)
879 Clang
->createDiagnostics(0, NULL
);
884 static void create_diagnostics(CompilerInstance
*Clang
)
886 Clang
->createDiagnostics();
891 #ifdef CREATEPREPROCESSOR_TAKES_TUKIND
893 static void create_preprocessor(CompilerInstance
*Clang
)
895 Clang
->createPreprocessor(TU_Complete
);
900 static void create_preprocessor(CompilerInstance
*Clang
)
902 Clang
->createPreprocessor();
907 #ifdef ADDPATH_TAKES_4_ARGUMENTS
909 void add_path(HeaderSearchOptions
&HSO
, string Path
)
911 HSO
.AddPath(Path
, frontend::Angled
, false, false);
916 void add_path(HeaderSearchOptions
&HSO
, string Path
)
918 HSO
.AddPath(Path
, frontend::Angled
, true, false, false);
923 #ifdef HAVE_SETMAINFILEID
925 static void create_main_file_id(SourceManager
&SM
, const FileEntry
*file
)
927 SM
.setMainFileID(SM
.createFileID(file
, SourceLocation(),
933 static void create_main_file_id(SourceManager
&SM
, const FileEntry
*file
)
935 SM
.createMainFileID(file
);
940 /* Add pet specific predefines to the preprocessor.
942 * We mimic the way <command line> is handled inside clang.
944 void add_predefines(Preprocessor
&PP
)
948 s
= PP
.getPredefines();
949 s
+= "# 1 \"<pet>\" 1\n"
950 "void __pencil_assume(int assumption);\n"
951 "#define pencil_access(f) annotate(\"pencil_access(\" #f \")\")\n"
952 "# 1 \"<built-in>\" 2\n";
956 /* Extract a pet_scop from each function in the C source file called "filename".
957 * Each detected scop is passed to "fn".
958 * If "function" is not NULL, only extract a pet_scop from the function
960 * If "autodetect" is set, extract any pet_scop we can find.
961 * Otherwise, extract the pet_scop from the region delimited
962 * by "scop" and "endscop" pragmas.
964 * We first set up the clang parser and then try to extract the
965 * pet_scop from the appropriate function(s) in PetASTConsumer.
967 static int foreach_scop_in_C_source(isl_ctx
*ctx
,
968 const char *filename
, const char *function
, pet_options
*options
,
969 int (*fn
)(struct pet_scop
*scop
, void *user
), void *user
)
971 CompilerInstance
*Clang
= new CompilerInstance();
972 create_diagnostics(Clang
);
973 DiagnosticsEngine
&Diags
= Clang
->getDiagnostics();
974 Diags
.setSuppressSystemWarnings(true);
975 CompilerInvocation
*invocation
= construct_invocation(filename
, Diags
);
977 Clang
->setInvocation(invocation
);
978 Diags
.setClient(construct_printer(Clang
));
979 Clang
->createFileManager();
980 Clang
->createSourceManager(Clang
->getFileManager());
981 TargetInfo
*target
= create_target_info(Clang
, Diags
);
982 Clang
->setTarget(target
);
983 CompilerInvocation::setLangDefaults(Clang
->getLangOpts(), IK_C
,
984 LangStandard::lang_unspecified
);
985 HeaderSearchOptions
&HSO
= Clang
->getHeaderSearchOpts();
986 HSO
.ResourceDir
= ResourceDir
;
987 for (int i
= 0; i
< options
->n_path
; ++i
)
988 add_path(HSO
, options
->paths
[i
]);
989 PreprocessorOptions
&PO
= Clang
->getPreprocessorOpts();
990 for (int i
= 0; i
< options
->n_define
; ++i
)
991 PO
.addMacroDef(options
->defines
[i
]);
992 create_preprocessor(Clang
);
993 Preprocessor
&PP
= Clang
->getPreprocessor();
998 const FileEntry
*file
= Clang
->getFileManager().getFile(filename
);
1000 isl_die(ctx
, isl_error_unknown
, "unable to open file",
1001 do { delete Clang
; return -1; } while (0));
1002 create_main_file_id(Clang
->getSourceManager(), file
);
1004 Clang
->createASTContext();
1005 PetASTConsumer
consumer(ctx
, PP
, Clang
->getASTContext(), Diags
,
1006 scops
, function
, options
, fn
, user
);
1007 Sema
*sema
= new Sema(PP
, Clang
->getASTContext(), consumer
);
1009 if (!options
->autodetect
) {
1010 PP
.AddPragmaHandler(new PragmaScopHandler(scops
));
1011 PP
.AddPragmaHandler(new PragmaEndScopHandler(scops
));
1012 PP
.AddPragmaHandler(new PragmaLiveOutHandler(*sema
,
1013 consumer
.live_out
));
1016 consumer
.add_pragma_handlers(sema
);
1018 Diags
.getClient()->BeginSourceFile(Clang
->getLangOpts(), &PP
);
1020 Diags
.getClient()->EndSourceFile();
1025 return consumer
.error
? -1 : 0;
1028 /* Extract a pet_scop from each function in the C source file called "filename".
1029 * Each detected scop is passed to "fn".
1031 * This wrapper around foreach_scop_in_C_source is mainly used to ensure
1032 * that all objects on the stack (of that function) are destroyed before we
1033 * call llvm_shutdown.
1035 static int pet_foreach_scop_in_C_source(isl_ctx
*ctx
,
1036 const char *filename
, const char *function
,
1037 int (*fn
)(struct pet_scop
*scop
, void *user
), void *user
)
1040 pet_options
*options
;
1041 bool allocated
= false;
1043 options
= isl_ctx_peek_pet_options(ctx
);
1045 options
= pet_options_new_with_defaults();
1049 r
= foreach_scop_in_C_source(ctx
, filename
, function
, options
,
1051 llvm::llvm_shutdown();
1054 pet_options_free(options
);
1059 /* Store "scop" into the address pointed to by "user".
1060 * Return -1 to indicate that we are not interested in any further scops.
1061 * This function should therefore not be called a second call
1062 * so in principle there is no need to check if we have already set *user.
1064 static int set_first_scop(pet_scop
*scop
, void *user
)
1066 pet_scop
**p
= (pet_scop
**) user
;
1071 pet_scop_free(scop
);
1076 /* Extract a pet_scop from the C source file called "filename".
1077 * If "function" is not NULL, extract the pet_scop from the function
1080 * We start extracting scops from every function and then abort
1081 * as soon as we have extracted one scop.
1083 struct pet_scop
*pet_scop_extract_from_C_source(isl_ctx
*ctx
,
1084 const char *filename
, const char *function
)
1086 pet_scop
*scop
= NULL
;
1088 pet_foreach_scop_in_C_source(ctx
, filename
, function
,
1089 &set_first_scop
, &scop
);
1094 /* Internal data structure for pet_transform_C_source
1096 * transform is the function that should be called to print a scop
1097 * in is the input source file
1098 * out is the output source file
1099 * end is the offset of the end of the previous scop (zero if we have not
1100 * found any scop yet)
1101 * p is a printer that prints to out.
1103 struct pet_transform_data
{
1104 __isl_give isl_printer
*(*transform
)(__isl_take isl_printer
*p
,
1105 struct pet_scop
*scop
, void *user
);
1114 /* This function is called each time a scop is detected.
1116 * We first copy the input text code from the end of the previous scop
1117 * until the start of "scop" and then print the scop itself through
1118 * a call to data->transform. We set up the printer to print
1119 * the transformed code with the same (initial) indentation as
1120 * the original code.
1121 * Finally, we keep track of the end of "scop" so that we can
1122 * continue copying when we find the next scop.
1124 * Before calling data->transform, we store a pointer to the original
1125 * input file in the extended scop in case the user wants to call
1126 * pet_scop_print_original from the callback.
1128 static int pet_transform(struct pet_scop
*scop
, void *user
)
1130 struct pet_transform_data
*data
= (struct pet_transform_data
*) user
;
1133 start
= pet_loc_get_start(scop
->loc
);
1134 if (copy(data
->in
, data
->out
, data
->end
, start
) < 0)
1136 data
->end
= pet_loc_get_end(scop
->loc
);
1137 scop
= pet_scop_set_input_file(scop
, data
->in
);
1138 data
->p
= isl_printer_set_indent_prefix(data
->p
,
1139 pet_loc_get_indent(scop
->loc
));
1140 data
->p
= data
->transform(data
->p
, scop
, data
->user
);
1145 pet_scop_free(scop
);
1149 /* Transform the C source file "input" by rewriting each scop
1150 * through a call to "transform".
1151 * When autodetecting scops, at most one scop per function is rewritten.
1152 * The transformed C code is written to "output".
1154 * For each scop we find, we first copy the input text code
1155 * from the end of the previous scop (or the beginning of the file
1156 * in case of the first scop) until the start of the scop
1157 * and then print the scop itself through a call to "transform".
1158 * At the end we copy everything from the end of the final scop
1159 * until the end of the input file to "output".
1161 int pet_transform_C_source(isl_ctx
*ctx
, const char *input
, FILE *out
,
1162 __isl_give isl_printer
*(*transform
)(__isl_take isl_printer
*p
,
1163 struct pet_scop
*scop
, void *user
), void *user
)
1165 struct pet_transform_data data
;
1170 if (input
&& strcmp(input
, "-")) {
1171 data
.in
= fopen(input
, "r");
1173 isl_die(ctx
, isl_error_unknown
, "unable to open file",
1177 data
.p
= isl_printer_to_file(ctx
, data
.out
);
1178 data
.p
= isl_printer_set_output_format(data
.p
, ISL_FORMAT_C
);
1180 data
.transform
= transform
;
1183 r
= pet_foreach_scop_in_C_source(ctx
, input
, NULL
,
1184 &pet_transform
, &data
);
1186 isl_printer_free(data
.p
);
1189 if (r
== 0 && copy(data
.in
, data
.out
, data
.end
, -1) < 0)
1192 if (data
.in
!= stdin
)