Filter functions, extern vars, defines and unused types from included headers

bindgen/CMakeLists.txt

@@ -36,8 +36,6 @@ add_executable(bindgen
   defines/DefineFinderActionFactory.h
   TypeTranslator.h
   TypeTranslator.cpp
-  HeaderManager.h
-  HeaderManager.cpp
   CycleDetection.h
   Utils.h
   ir/IR.h
@@ -72,6 +70,13 @@ add_executable(bindgen
   ir/types/FunctionPointerType.h
   ir/types/ArrayType.cpp
   ir/types/ArrayType.h
+  ir/location/Location.h
+  ir/location/ScalaLocation.cpp
+  ir/location/ScalaLocation.h
+  ir/location/SourceLocation.cpp
+  ir/location/SourceLocation.h
+  ir/location/LocationManager.cpp
+  ir/location/LocationManager.h
 )
 
 if (STATIC_LINKING)

bindgen/Main.cpp

@@ -11,19 +11,7 @@ int main(int argc, const char *argv[]) {
 
     llvm::cl::opt<std::string> LibName("name", llvm::cl::cat(Category),
                                        llvm::cl::desc("Library name"));
-    llvm::cl::opt<std::string> StdHeaders(
-        "std-headers", llvm::cl::cat(Category),
-        llvm::cl::desc("Path to a file with the list of headers for which "
-                       "bindings\n"
-                       "will not be generated. "
-                       "The list contains header files names\n"
-                       "and package names that contain bindings for these "
-                       "headers.\nExample:\n"
-                       "math.h=scala.scalanative.native.math\n"
-                       "stdlib.h=scala.scalanative.native.stdlib"));
-    llvm::cl::opt<bool> PrintHeadersLocation(
-        "location", llvm::cl::cat(Category),
-        llvm::cl::desc("Print list of parsed headers"));
+
     llvm::cl::opt<std::string> ExcludePrefix(
         "exclude-prefix", llvm::cl::cat(Category),
         llvm::cl::desc("Functions and unused typedefs will be removed if their "
@@ -64,13 +52,6 @@ int main(int argc, const char *argv[]) {
         objectName = "nativeLib";
     }
 
-    auto stdhead = StdHeaders.getValue();
-    if (!stdhead.empty()) {
-        headerMan.LoadConfig(stdhead);
-    }
-
-    locations.clear();
-
     IR ir(libName, linkName, objectName, Package.getValue());
 
     DefineFinderActionFactory defineFinderActionFactory(ir);
@@ -79,18 +60,16 @@ int main(int argc, const char *argv[]) {
         return result;
     }
 
-    ScalaFrontendActionFactory actionFactory(ir);
+    assert(op.getSourcePathList().size() == 1);
+
+    char *resolved = realpath(op.getSourcePathList()[0].c_str(), nullptr);
+    LocationManager locationManager(resolved);
+
+    ScalaFrontendActionFactory actionFactory(ir, locationManager);
     result = Tool.run(&actionFactory);
 
-    auto printLoc = PrintHeadersLocation.getValue();
-    if (printLoc) {
-        for (const auto &location : locations) {
-            llvm::outs() << location.c_str();
-        }
-    } else {
-        ir.generate(ExcludePrefix.getValue());
-        llvm::outs() << ir;
-    }
+    ir.generate(ExcludePrefix.getValue());
+    llvm::outs() << ir;
     llvm::outs().flush();
     return result;
 }

bindgen/TypeTranslator.cpp

@@ -102,7 +102,7 @@ TypeTranslator::translateStructOrUnionOrEnum(const clang::QualType &qtpe) {
     /* type is not yet defined.
      * TypeDef with nullptr will be created.
      * nullptr will be replaced by actual type when the type is declared. */
-    typeDef = ir.addTypeDef(nameWithoutSpace, nullptr);
+    typeDef = ir.addTypeDef(nameWithoutSpace, nullptr, nullptr);
     return typeDef;
 }
 

bindgen/TypeTranslator.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "ir/IR.h"
+#include "ir/location/LocationManager.h"
 #include <clang/Tooling/Tooling.h>
 
 class TypeTranslator {

bindgen/defines/DefineFinder.cpp

@@ -11,6 +11,10 @@ DefineFinder::DefineFinder(IR &ir, const clang::CompilerInstance &compiler,
 void DefineFinder::MacroDefined(const clang::Token &macroNameTok,
                                 const clang::MacroDirective *md) {
     clang::SourceManager &sm = compiler.getSourceManager();
+    if (!sm.isInMainFile(md->getLocation())) {
+        /* include defines only from the original header */
+        return;
+    }
     if (sm.isWrittenInMainFile(macroNameTok.getLocation()) && md->isDefined() &&
         !md->getMacroInfo()->isFunctionLike()) {
         /* save defines only from the given header.
@@ -100,6 +104,9 @@ void DefineFinder::MacroUndefined(const clang::Token &macroNameTok,
                                   const clang::MacroDefinition &md,
                                   const clang::MacroDirective *undef) {
     clang::SourceManager &sm = compiler.getSourceManager();
+    if (!sm.isInMainFile(undef->getLocation())) {
+        return;
+    }
     if (sm.isWrittenInMainFile(macroNameTok.getLocation()) &&
         md.getMacroInfo() && !md.getMacroInfo()->isFunctionLike()) {
         std::string macroName = macroNameTok.getIdentifierInfo()->getName();

bindgen/ir/Enum.cpp

@@ -14,9 +14,11 @@ Enum::Enum(std::string name, std::string type,
 
 bool Enum::isAnonymous() const { return name.empty(); }
 
-std::shared_ptr<TypeDef> Enum::generateTypeDef() {
+std::shared_ptr<TypeDef>
+Enum::generateTypeDef(std::shared_ptr<Location> location) {
     assert(!isAnonymous());
-    return std::make_shared<TypeDef>("enum_" + name, shared_from_this());
+    return std::make_shared<TypeDef>("enum_" + name, shared_from_this(),
+                                     std::move(location));
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const Enum &e) {

bindgen/ir/Enum.h

@@ -25,7 +25,8 @@ class Enum : public PrimitiveType, public std::enable_shared_from_this<Enum> {
 
     bool isAnonymous() const;
 
-    std::shared_ptr<TypeDef> generateTypeDef();
+    std::shared_ptr<TypeDef>
+    generateTypeDef(std::shared_ptr<Location> location);
 
     std::string getName() const;
 

bindgen/ir/IR.cpp

@@ -1,5 +1,6 @@
 #include "IR.h"
 #include "../Utils.h"
+#include "location/SourceLocation.h"
 
 IR::IR(std::string libName, std::string linkName, std::string objectName,
        std::string packageName)
@@ -13,48 +14,53 @@ void IR::addFunction(std::string name, std::vector<Parameter *> parameters,
 }
 
 std::shared_ptr<TypeDef> IR::addTypeDef(std::string name,
-                                        std::shared_ptr<Type> type) {
-    typeDefs.push_back(std::make_shared<TypeDef>(std::move(name), type));
+                                        std::shared_ptr<Type> type,
+                                        std::shared_ptr<Location> location) {
+    typeDefs.push_back(
+        std::make_shared<TypeDef>(std::move(name), type, std::move(location)));
     return typeDefs.back();
 }
 
 std::shared_ptr<Type> IR::addEnum(std::string name, const std::string &type,
-                                  std::vector<Enumerator> enumerators) {
+                                  std::vector<Enumerator> enumerators,
+                                  std::shared_ptr<Location> location) {
     std::shared_ptr<Enum> e =
         std::make_shared<Enum>(std::move(name), type, std::move(enumerators));
     enums.push_back(e);
     if (!e->isAnonymous()) {
-        typeDefs.push_back(e->generateTypeDef());
+        typeDefs.push_back(e->generateTypeDef(std::move(location)));
         return typeDefs.back();
     }
     return nullptr;
 }
 
 void IR::addStruct(std::string name, std::vector<Field *> fields,
-                   uint64_t typeSize) {
+                   uint64_t typeSize, std::shared_ptr<Location> location) {
     std::shared_ptr<Struct> s =
         std::make_shared<Struct>(name, std::move(fields), typeSize);
     structs.push_back(s);
     std::shared_ptr<TypeDef> typeDef = getTypeDefWithName("struct_" + name);
     if (typeDef) {
         /* the struct type used to be opaque type, typeDef contains nullptr */
         typeDef.get()->setType(s);
+        typeDef.get()->setLocation(location);
     } else {
-        typeDefs.push_back(s->generateTypeDef());
+        typeDefs.push_back(s->generateTypeDef(std::move(location)));
     }
 }
 
 void IR::addUnion(std::string name, std::vector<Field *> fields,
-                  uint64_t maxSize) {
+                  uint64_t maxSize, std::shared_ptr<Location> location) {
     std::shared_ptr<Union> u =
         std::make_shared<Union>(name, std::move(fields), maxSize);
     unions.push_back(u);
     std::shared_ptr<TypeDef> typeDef = getTypeDefWithName("union_" + name);
     if (typeDef) {
         /* the union type used to be opaque type, typeDef contains nullptr */
         typeDef.get()->setType(u);
+        typeDef.get()->setLocation(location);
     } else {
-        typeDefs.push_back(u->generateTypeDef());
+        typeDefs.push_back(u->generateTypeDef(std::move(location)));
     }
 }
 
@@ -171,6 +177,7 @@ void IR::generate(const std::string &excludePrefix) {
     if (!generated) {
         setScalaNames();
         filterDeclarations(excludePrefix);
+        removeUnusedExternalTypes();
         generated = true;
     }
 }
@@ -230,7 +237,7 @@ void IR::replaceTypeInTypeDefs(std::shared_ptr<Type> oldType,
 
 template <typename T>
 bool IR::isTypeUsed(const std::vector<T> &declarations,
-                    std::shared_ptr<Type> type, bool stopOnTypeDefs) {
+                    std::shared_ptr<Type> type, bool stopOnTypeDefs) const {
     for (const auto &decl : declarations) {
         if (decl->usesType(type, stopOnTypeDefs)) {
             return true;
@@ -239,7 +246,7 @@ bool IR::isTypeUsed(const std::vector<T> &declarations,
     return false;
 }
 
-bool IR::typeIsUsedOnlyInTypeDefs(std::shared_ptr<Type> type) {
+bool IR::typeIsUsedOnlyInTypeDefs(const std::shared_ptr<Type> &type) const {
     /* varDefines are not checked here because they are simply
      * aliases for variables.*/
     return !(
@@ -248,6 +255,11 @@ bool IR::typeIsUsedOnlyInTypeDefs(std::shared_ptr<Type> type) {
         isTypeUsed(literalDefines, type, true));
 }
 
+bool IR::isTypeUsed(const std::shared_ptr<Type> &type) const {
+    return !(typeIsUsedOnlyInTypeDefs(type) &&
+             !isTypeUsed(typeDefs, type, false));
+}
+
 void IR::setScalaNames() {
     /* Renaming according to Scala naming conventions
      * should happen here */
@@ -353,3 +365,47 @@ IR::~IR() {
     variables.clear();
     varDefines.clear();
 }
+
+void IR::removeUnusedExternalTypes() {
+    for (auto it = typeDefs.begin(); it != typeDefs.end();) {
+        std::shared_ptr<TypeDef> typeDef = *it;
+        std::shared_ptr<Location> location = typeDef->getLocation();
+        auto *sourceLocation = dynamic_cast<SourceLocation *>(location.get());
+        if (sourceLocation && !sourceLocation->isMainFile()) {
+            if (!isTypeUsed(typeDef)) {
+                removeStructOrUnionOrEnum(typeDef->getType());
+                it = typeDefs.erase(it);
+            } else {
+                ++it;
+            }
+        } else {
+            ++it;
+        }
+    }
+}
+
+template <typename T>
+void IR::removeDeclaration(std::vector<std::shared_ptr<T>> &declarations,
+                           T *declaration) {
+    for (auto it = declarations.begin(); it != declarations.end();) {
+        T *decl = (*it).get();
+        if (decl == declaration) {
+            it = declarations.erase(it);
+        } else {
+            ++it;
+        }
+    }
+}
+
+void IR::removeStructOrUnionOrEnum(std::shared_ptr<Type> type) {
+    if (isInstanceOf<Struct>(type.get())) {
+        auto *s = dynamic_cast<Struct *>(type.get());
+        removeDeclaration(structs, s);
+    } else if (isInstanceOf<Union>(type.get())) {
+        auto *u = dynamic_cast<Union *>(type.get());
+        removeDeclaration(unions, u);
+    } else if (isInstanceOf<Enum>(type.get())) {
+        auto *e = dynamic_cast<Enum *>(type.get());
+        removeDeclaration(enums, e);
+    }
+}