interface/extract_interface.cc

   1 /*
   2  * Copyright 2011 Sven Verdoolaege. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  *    1. Redistributions of source code must retain the above copyright
   9  *       notice, this list of conditions and the following disclaimer.
  10  *
  11  *    2. Redistributions in binary form must reproduce the above
  12  *       copyright notice, this list of conditions and the following
  13  *       disclaimer in the documentation and/or other materials provided
  14  *       with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY SVEN VERDOOLAEGE ''AS IS'' AND ANY
  17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SVEN VERDOOLAEGE OR
  20  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  21  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  23  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * The views and conclusions contained in the software and documentation
  29  * are those of the authors and should not be interpreted as
  30  * representing official policies, either expressed or implied, of
  31  * Sven Verdoolaege.
  32  */
  33
  34 #include "isl_config.h"
  35
  36 #include <assert.h>
  37 #include <iostream>
  38 #ifdef HAVE_ADT_OWNINGPTR_H
  39 #include <llvm/ADT/OwningPtr.h>
  40 #else
  41 #include <memory>
  42 #endif
  43 #include <llvm/Support/raw_ostream.h>
  44 #include <llvm/Support/CommandLine.h>
  45 #include <llvm/Support/Host.h>
  46 #include <llvm/Support/ManagedStatic.h>
  47 #include <clang/AST/ASTContext.h>
  48 #include <clang/AST/ASTConsumer.h>
  49 #include <clang/Basic/FileSystemOptions.h>
  50 #include <clang/Basic/FileManager.h>
  51 #include <clang/Basic/TargetOptions.h>
  52 #include <clang/Basic/TargetInfo.h>
  53 #include <clang/Basic/Version.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>
  61 #else
  62 #include <clang/Frontend/DiagnosticOptions.h>
  63 #endif
  64 #include <clang/Frontend/TextDiagnosticPrinter.h>
  65 #include <clang/Frontend/Utils.h>
  66 #include <clang/Lex/HeaderSearch.h>
  67 #include <clang/Lex/Preprocessor.h>
  68 #include <clang/Parse/ParseAST.h>
  69 #include <clang/Sema/Sema.h>
  70
  71 #include "extract_interface.h"
  72 #include "python.h"
  73
  74 using namespace std;
  75 using namespace clang;
  76 using namespace clang::driver;
  77
  78 #ifdef HAVE_ADT_OWNINGPTR_H
  79 #define unique_ptr      llvm::OwningPtr
  80 #endif
  81
  82 static llvm::cl::opt<string> InputFilename(llvm::cl::Positional,
  83                         llvm::cl::Required, llvm::cl::desc("<input file>"));
  84 static llvm::cl::list<string> Includes("I",
  85                         llvm::cl::desc("Header search path"),
  86                         llvm::cl::value_desc("path"), llvm::cl::Prefix);
  87
  88 static const char *ResourceDir =
  89         CLANG_PREFIX "/lib/clang/" CLANG_VERSION_STRING;
  90
  91 /* Does decl have an attribute of the following form?
  92  *
  93  *      __attribute__((annotate("name")))
  94  */
  95 bool has_annotation(Decl *decl, const char *name)
  96 {
  97         if (!decl->hasAttrs())
  98                 return false;
  99
 100         AttrVec attrs = decl->getAttrs();
 101         for (AttrVec::const_iterator i = attrs.begin() ; i != attrs.end(); ++i) {
 102                 const AnnotateAttr *ann = dyn_cast<AnnotateAttr>(*i);
 103                 if (!ann)
 104                         continue;
 105                 if (ann->getAnnotation().str() == name)
 106                         return true;
 107         }
 108
 109         return false;
 110 }
 111
 112 /* Is decl marked as exported?
 113  */
 114 static bool is_exported(Decl *decl)
 115 {
 116         return has_annotation(decl, "isl_export");
 117 }
 118
 119 /* Collect all types and functions that are annotated "isl_export"
 120  * in "types" and "function".
 121  *
 122  * We currently only consider single declarations.
 123  */
 124 struct MyASTConsumer : public ASTConsumer {
 125         set<RecordDecl *> types;
 126         set<FunctionDecl *> functions;
 127
 128         virtual HandleTopLevelDeclReturn HandleTopLevelDecl(DeclGroupRef D) {
 129                 Decl *decl;
 130
 131                 if (!D.isSingleDecl())
 132                         return HandleTopLevelDeclContinue;
 133                 decl = D.getSingleDecl();
 134                 if (!is_exported(decl))
 135                         return HandleTopLevelDeclContinue;
 136                 switch (decl->getKind()) {
 137                 case Decl::Record:
 138                         types.insert(cast<RecordDecl>(decl));
 139                         break;
 140                 case Decl::Function:
 141                         functions.insert(cast<FunctionDecl>(decl));
 142                         break;
 143                 default:
 144                         break;
 145                 }
 146                 return HandleTopLevelDeclContinue;
 147         }
 148 };
 149
 150 #ifdef USE_ARRAYREF
 151
 152 #ifdef HAVE_CXXISPRODUCTION
 153 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
 154 {
 155         return new Driver(binary, llvm::sys::getDefaultTargetTriple(),
 156                             "", false, false, Diags);
 157 }
 158 #elif defined(HAVE_ISPRODUCTION)
 159 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
 160 {
 161         return new Driver(binary, llvm::sys::getDefaultTargetTriple(),
 162                             "", false, Diags);
 163 }
 164 #elif defined(DRIVER_CTOR_TAKES_DEFAULTIMAGENAME)
 165 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
 166 {
 167         return new Driver(binary, llvm::sys::getDefaultTargetTriple(),
 168                             "", Diags);
 169 }
 170 #else
 171 static Driver *construct_driver(const char *binary, DiagnosticsEngine &Diags)
 172 {
 173         return new Driver(binary, llvm::sys::getDefaultTargetTriple(), Diags);
 174 }
 175 #endif
 176
 177 /* Clang changed its API from 3.5 to 3.6, we fix this with a simple overloaded
 178  * function here.
 179  */
 180 struct ClangAPI {
 181         static Job *command(Job *J) { return J; }
 182         static Job *command(Job &J) { return &J; }
 183 };
 184
 185 /* Create a CompilerInvocation object that stores the command line
 186  * arguments constructed by the driver.
 187  * The arguments are mainly useful for setting up the system include
 188  * paths on newer clangs and on some platforms.
 189  */
 190 static CompilerInvocation *construct_invocation(const char *filename,
 191         DiagnosticsEngine &Diags)
 192 {
 193         const char *binary = CLANG_PREFIX"/bin/clang";
 194         const unique_ptr<Driver> driver(construct_driver(binary, Diags));
 195         std::vector<const char *> Argv;
 196         Argv.push_back(binary);
 197         Argv.push_back(filename);
 198         const unique_ptr<Compilation> compilation(
 199                 driver->BuildCompilation(llvm::ArrayRef<const char *>(Argv)));
 200         JobList &Jobs = compilation->getJobs();
 201
 202         Command *cmd = cast<Command>(ClangAPI::command(*Jobs.begin()));
 203         if (strcmp(cmd->getCreator().getName(), "clang"))
 204                 return NULL;
 205
 206         const ArgStringList *args = &cmd->getArguments();
 207
 208         CompilerInvocation *invocation = new CompilerInvocation;
 209         CompilerInvocation::CreateFromArgs(*invocation, args->data() + 1,
 210                                                 args->data() + args->size(),
 211                                                 Diags);
 212         return invocation;
 213 }
 214
 215 #else
 216
 217 static CompilerInvocation *construct_invocation(const char *filename,
 218         DiagnosticsEngine &Diags)
 219 {
 220         return NULL;
 221 }
 222
 223 #endif
 224
 225 #ifdef HAVE_BASIC_DIAGNOSTICOPTIONS_H
 226
 227 static TextDiagnosticPrinter *construct_printer(void)
 228 {
 229         return new TextDiagnosticPrinter(llvm::errs(), new DiagnosticOptions());
 230 }
 231
 232 #else
 233
 234 static TextDiagnosticPrinter *construct_printer(void)
 235 {
 236         DiagnosticOptions DO;
 237         return new TextDiagnosticPrinter(llvm::errs(), DO);
 238 }
 239
 240 #endif
 241
 242 #ifdef CREATETARGETINFO_TAKES_SHARED_PTR
 243
 244 static TargetInfo *create_target_info(CompilerInstance *Clang,
 245         DiagnosticsEngine &Diags)
 246 {
 247         shared_ptr<TargetOptions> TO = Clang->getInvocation().TargetOpts;
 248         TO->Triple = llvm::sys::getDefaultTargetTriple();
 249         return TargetInfo::CreateTargetInfo(Diags, TO);
 250 }
 251
 252 #elif defined(CREATETARGETINFO_TAKES_POINTER)
 253
 254 static TargetInfo *create_target_info(CompilerInstance *Clang,
 255         DiagnosticsEngine &Diags)
 256 {
 257         TargetOptions &TO = Clang->getTargetOpts();
 258         TO.Triple = llvm::sys::getDefaultTargetTriple();
 259         return TargetInfo::CreateTargetInfo(Diags, &TO);
 260 }
 261
 262 #else
 263
 264 static TargetInfo *create_target_info(CompilerInstance *Clang,
 265         DiagnosticsEngine &Diags)
 266 {
 267         TargetOptions &TO = Clang->getTargetOpts();
 268         TO.Triple = llvm::sys::getDefaultTargetTriple();
 269         return TargetInfo::CreateTargetInfo(Diags, TO);
 270 }
 271
 272 #endif
 273
 274 #ifdef CREATEDIAGNOSTICS_TAKES_ARG
 275
 276 static void create_diagnostics(CompilerInstance *Clang)
 277 {
 278         Clang->createDiagnostics(0, NULL, construct_printer());
 279 }
 280
 281 #else
 282
 283 static void create_diagnostics(CompilerInstance *Clang)
 284 {
 285         Clang->createDiagnostics(construct_printer());
 286 }
 287
 288 #endif
 289
 290 #ifdef CREATEPREPROCESSOR_TAKES_TUKIND
 291
 292 static void create_preprocessor(CompilerInstance *Clang)
 293 {
 294         Clang->createPreprocessor(TU_Complete);
 295 }
 296
 297 #else
 298
 299 static void create_preprocessor(CompilerInstance *Clang)
 300 {
 301         Clang->createPreprocessor();
 302 }
 303
 304 #endif
 305
 306 #ifdef ADDPATH_TAKES_4_ARGUMENTS
 307
 308 void add_path(HeaderSearchOptions &HSO, string Path)
 309 {
 310         HSO.AddPath(Path, frontend::Angled, false, false);
 311 }
 312
 313 #else
 314
 315 void add_path(HeaderSearchOptions &HSO, string Path)
 316 {
 317         HSO.AddPath(Path, frontend::Angled, true, false, false);
 318 }
 319
 320 #endif
 321
 322 #ifdef HAVE_SETMAINFILEID
 323
 324 static void create_main_file_id(SourceManager &SM, const FileEntry *file)
 325 {
 326         SM.setMainFileID(SM.createFileID(file, SourceLocation(),
 327                                         SrcMgr::C_User));
 328 }
 329
 330 #else
 331
 332 static void create_main_file_id(SourceManager &SM, const FileEntry *file)
 333 {
 334         SM.createMainFileID(file);
 335 }
 336
 337 #endif
 338
 339 int main(int argc, char *argv[])
 340 {
 341         llvm::cl::ParseCommandLineOptions(argc, argv);
 342
 343         CompilerInstance *Clang = new CompilerInstance();
 344         create_diagnostics(Clang);
 345         DiagnosticsEngine &Diags = Clang->getDiagnostics();
 346         Diags.setSuppressSystemWarnings(true);
 347         CompilerInvocation *invocation =
 348                 construct_invocation(InputFilename.c_str(), Diags);
 349         if (invocation)
 350                 Clang->setInvocation(invocation);
 351         Clang->createFileManager();
 352         Clang->createSourceManager(Clang->getFileManager());
 353         TargetInfo *target = create_target_info(Clang, Diags);
 354         Clang->setTarget(target);
 355         CompilerInvocation::setLangDefaults(Clang->getLangOpts(), IK_C,
 356                                             LangStandard::lang_unspecified);
 357         HeaderSearchOptions &HSO = Clang->getHeaderSearchOpts();
 358         LangOptions &LO = Clang->getLangOpts();
 359         PreprocessorOptions &PO = Clang->getPreprocessorOpts();
 360         HSO.ResourceDir = ResourceDir;
 361
 362         for (int i = 0; i < Includes.size(); ++i)
 363                 add_path(HSO, Includes[i]);
 364
 365         PO.addMacroDef("__isl_give=__attribute__((annotate(\"isl_give\")))");
 366         PO.addMacroDef("__isl_keep=__attribute__((annotate(\"isl_keep\")))");
 367         PO.addMacroDef("__isl_take=__attribute__((annotate(\"isl_take\")))");
 368         PO.addMacroDef("__isl_export=__attribute__((annotate(\"isl_export\")))");
 369         PO.addMacroDef("__isl_constructor=__attribute__((annotate(\"isl_constructor\"))) __attribute__((annotate(\"isl_export\")))");
 370         PO.addMacroDef("__isl_subclass(super)=__attribute__((annotate(\"isl_subclass(\" #super \")\"))) __attribute__((annotate(\"isl_export\")))");
 371
 372         create_preprocessor(Clang);
 373         Preprocessor &PP = Clang->getPreprocessor();
 374
 375         PP.getBuiltinInfo().InitializeBuiltins(PP.getIdentifierTable(), LO);
 376
 377         const FileEntry *file = Clang->getFileManager().getFile(InputFilename);
 378         assert(file);
 379         create_main_file_id(Clang->getSourceManager(), file);
 380
 381         Clang->createASTContext();
 382         MyASTConsumer consumer;
 383         Sema *sema = new Sema(PP, Clang->getASTContext(), consumer);
 384
 385         Diags.getClient()->BeginSourceFile(LO, &PP);
 386         ParseAST(*sema);
 387         Diags.getClient()->EndSourceFile();
 388
 389         generate_python(consumer.types, consumer.functions);
 390
 391         delete sema;
 392         delete Clang;
 393         llvm::llvm_shutdown();
 394
 395         return 0;
 396 }