libclang_wrapper

Author: hongxuchen

x/libclang_wrapper/.gitignore

@@ -0,0 +1 @@
+build/

x/libclang_wrapper/CMakeLists.txt

@@ -0,0 +1,52 @@
+cmake_minimum_required(VERSION 2.8)
+project(IRONY)
+
+set (CMAKE_C_COMPILER             "clang")
+set (CMAKE_CXX_COMPILER           "clang++")
+set (CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE)
+  message(FATAL_ERROR "In-source builds are not allowed.")
+endif()
+
+set (CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
+
+# libclang in non standard locations can cause some troubles.
+option(USE_RPATH "Enable rpath for shared libraries (such as libclang.so)." OFF)
+
+if (USE_RPATH)
+  set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+endif()
+
+if (CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_CLANGCXX)
+  include(CheckCXXCompilerFlag)
+  set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wextra -Wall -Wshadow -std=c++11 -fno-rtti -fno-exceptions -O3")
+
+  if (${CMAKE_GENERATOR} MATCHES "Ninja")
+    check_cxx_compiler_flag("-fcolor-diagnostics" HAS_FCOLOR_DIAGNOSTICS_FLAG)
+    if (HAS_FCOLOR_DIAGNOSTICS_FLAG)
+      set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcolor-diagnostics")
+    endif()
+  endif ()
+endif ()
+
+set(LLVM_SUFFIX "-3.4")
+find_package(Llvm REQUIRED)
+
+include_directories(${LLVM_INCLUDE_DIR})
+
+add_definitions("-O3 -fno-rtti -fno-exceptions -Wextra -Wno-unused-parameter -std=c++11")
+add_definitions("${LLVM_CFLAGS}")
+if(UNIX)
+  add_definitions("-DLLVM_ON_UNIX")
+endif()
+include(LLVMTools)
+link_directories(${LLVM_LIBRARY_DIR})
+
+set(BASE_LIBS pthread m dl ncurses)
+set(LLVM_BASIC_LIBS LLVMIRReader LLVMAsmParser LLVMBitWriter LLVMLinker LLVMTransformUtils LLVMipa LLVMAnalysis LLVMTarget LLVMMC LLVMBitReader LLVMCore LLVMSupport)
+set(CLANG_BASIC_LIBS clang clangFrontend clangFrontendTool clangDriver clangSerialization clangCodeGen clangParse clangSema clangEdit clangAnalysis clangAST clangLex clangBasic clangRewriteCore clangRewriteFrontend clangStaticAnalyzerFrontend clangStaticAnalyzerCheckers clangStaticAnalyzerCore clangARCMigrate)
+
+file(GLOB TU *.cc)
+add_executable(libclang_wrapper.out ${TU})
+target_link_libraries(libclang_wrapper.out ${LLVM_BASIC_LIBS} ${CLANG_BASIC_LIBS} ${BASE_LIBS})

x/libclang_wrapper/Common.cc

@@ -0,0 +1,9 @@
+#include "Common.hpp"
+
+std::string getStrFromCXString(CXString const &cxstring) {
+  std::string str;
+  char const *cstr = clang_getCString(cxstring);
+  if (cstr != nullptr) str = cstr;
+  clang_disposeString(cxstring);
+  return str;
+}

x/libclang_wrapper/Common.hpp

@@ -0,0 +1,16 @@
+#ifndef COMMON_HPP
+#define COMMON_HPP
+
+#include <string>
+#include <clang-c/Index.h>
+
+#define WITH_COLOR(color, x)         \
+  {                                  \
+    llvm::errs().changeColor(color); \
+    x;                               \
+    llvm::errs().resetColor();       \
+  }
+
+std::string getStrFromCXString(CXString const &cxstring);
+
+#endif

x/libclang_wrapper/CursorCounter.cc

@@ -0,0 +1,45 @@
+#include "CursorCounter.hpp"
+#include "llvm/Support/raw_ostream.h"
+
+extern char const *filename;
+
+CXChildVisitResult statsVisitor(CXCursor cursor, CXCursor parent,
+                                CXClientData client_data) {
+  CursorCounter &counter = CursorCounter::getInstance();
+  std::string file = CursorCounter::getCursorFileName(cursor);
+  if (file == filename) {
+    counter.insert(cursor.kind);
+  }
+  return CXChildVisit_Recurse;
+}
+
+bool CursorCounter::insert(CXCursorKind kind) {
+  auto search = cursor2counter_.find(kind);
+  if (search != cursor2counter_.end()) {
+    ++search->second;
+    return true;
+  }
+  cursor2counter_.insert(std::make_pair(kind, 1));
+  return false;
+}
+
+std::string CursorCounter::getCursorFileName(CXCursor cursor) {
+  CXFile file;
+  clang_getSpellingLocation(clang_getCursorLocation(cursor), &file, nullptr,
+                            nullptr, nullptr);
+  CXString fileCXStr = clang_getFileName(file);
+  return getStrFromCXString(fileCXStr);
+}
+
+void CursorCounter::visit(CXTranslationUnit const &TU) {
+  clang_visitChildren(clang_getTranslationUnitCursor(TU), statsVisitor,
+                      nullptr);
+}
+
+void CursorCounter::dump() {
+  for (auto const &ele : cursor2counter_) {
+    CXString cursorCXStr = clang_getCursorKindSpelling(ele.first);
+    llvm::errs() << getStrFromCXString(cursorCXStr) << ": " << ele.second
+                 << "\n";
+  }
+}

x/libclang_wrapper/CursorCounter.hpp

@@ -0,0 +1,26 @@
+#ifndef CURSORCOUNTER_HPP
+#define CURSORCOUNTER_HPP
+
+#include "Common.hpp"
+#include <map>
+
+class CursorCounter {
+  std::string filename_;
+  typedef std::map<CXCursorKind, unsigned> CursorCounterMap;
+  CursorCounterMap cursor2counter_;
+  CursorCounter() {}
+  CursorCounter(CursorCounter const&) = delete;
+  CursorCounter& operator=(CursorCounter const&) = delete;
+
+ public:
+  static CursorCounter& getInstance(void) {
+    static CursorCounter counter;
+    return counter;
+  }
+  bool insert(CXCursorKind kind);
+  static std::string getCursorFileName(CXCursor cursor);
+  void visit(CXTranslationUnit const& TU);
+  void dump();
+};
+
+#endif

x/libclang_wrapper/CursorInfo.cc

@@ -0,0 +1,47 @@
+#include "CursorInfo.hpp"
+#include "CursorCounter.hpp"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+
+LocPoint LocPoint::getLocPoint(
+    CXSourceLocation location,
+    std::function<void(CXSourceLocation, CXFile *, unsigned *, unsigned *,
+                       unsigned *)> genenerator) {
+  CXFile file;
+  unsigned line, column, offset;
+  genenerator(location, &file, &line, &column, &offset);
+  CXString fileCXStr = clang_getFileName(file);
+  return LocPoint(getStrFromCXString(fileCXStr), line, column, offset);
+}
+
+LocPoint LocPoint::getPresumedPoint(CXSourceLocation location) {
+  CXString fileCXStr;
+  unsigned line, column;
+  unsigned offset = 0;
+  clang_getPresumedLocation(location, &fileCXStr, &line, &column);
+  LocPoint presumed(getStrFromCXString(fileCXStr), line, column, offset);
+  clang_disposeString(fileCXStr);
+  return presumed;
+}
+
+void LocPoint::dump() {
+  errs() << filename_ << " [" << line_ << ", " << column_ << "]\n";
+}
+
+CursorInfo CursorInfo::getCursorInfo(CXCursor cursor) {
+  std::string &&cursorStr = getStrFromCXString(clang_getCursorSpelling(cursor));
+  CXSourceLocation location = clang_getCursorLocation(cursor);
+  LocPoint &&expandPoint =
+      LocPoint::getLocPoint(location, clang_getExpansionLocation);
+  LocPoint &&presumedPoint = LocPoint::getPresumedPoint(location);
+  LocPoint &&instantiationPoint =
+      LocPoint::getLocPoint(location, clang_getInstantiationLocation);
+  LocPoint &&spellingPoint =
+      LocPoint::getLocPoint(location, clang_getSpellingLocation);
+  expandPoint.dump();
+  presumedPoint.dump();
+  instantiationPoint.dump();
+  spellingPoint.dump();
+  return CursorInfo(cursorStr, expandPoint, presumedPoint, instantiationPoint);
+}

x/libclang_wrapper/CursorInfo.hpp

@@ -0,0 +1,44 @@
+#ifndef CURSORINFO_HPP
+#define CURSORINFO_HPP
+
+#include <functional>
+
+#include "Common.hpp"
+
+class LocPoint {
+  std::string filename_;
+  unsigned line_, column_, offset_;
+
+ public:
+  static LocPoint getLocPoint(
+      CXSourceLocation location,
+      std::function<void(CXSourceLocation, CXFile *, unsigned *, unsigned *,
+                         unsigned *)> genenerator);
+  static LocPoint getPresumedPoint(CXSourceLocation location);
+  LocPoint(std::string &&filename, unsigned line, unsigned column,
+           unsigned offset = 0)
+      : filename_(std::move(filename)),
+        line_(line),
+        column_(column),
+        offset_(offset) {}
+  void dump();
+  LocPoint &operator=(LocPoint const &) = delete;
+};
+
+class CursorInfo {
+  std::string cursorStr_;
+  LocPoint expand_, presumed_, instantantiation_;
+
+ public:
+  static CursorInfo getCursorInfo(CXCursor cursor);
+  CursorInfo(std::string const &cursorStr, LocPoint const &expand,
+             LocPoint const &presumed, LocPoint const &instantantiation)
+      : cursorStr_(std::move(cursorStr)),
+        expand_(std::move(expand)),
+        presumed_(std::move(presumed)),
+        instantantiation_(std::move(instantantiation)) {}
+  CursorInfo &operator=(CursorInfo const &) = delete;
+  void dump();
+};
+
+#endif

x/libclang_wrapper/cmake/Common.cmake

@@ -0,0 +1,17 @@
+function(replace_compiler_option var old new)
+  # Replaces a compiler option or switch `old' in `var' by `new'.
+  # If `old' is not in `var', appends `new' to `var'.
+  # Example: replace_compiler_option(CMAKE_CXX_FLAGS_RELEASE "-O3" "-O2")
+  # If the option already is on the variable, don't add it:
+  if( "${${var}}" MATCHES "(^| )${new}($| )" )
+    set(n "")
+  else()
+    set(n "${new}")
+  endif()
+  if( "${${var}}" MATCHES "(^| )${old}($| )" )
+    string( REGEX REPLACE "(^| )${old}($| )" " ${n} " ${var} "${${var}}" )
+  else()
+    set( ${var} "${${var}} ${n}" )
+  endif()
+  set( ${var} "${${var}}" PARENT_SCOPE )
+endfunction(replace_compiler_option)

x/libclang_wrapper/cmake/FindLlvm.cmake

@@ -0,0 +1,64 @@
+# Find the native LLVM includes and library
+#
+# LLVM_INCLUDE_DIR - where to find llvm include files
+# LLVM_LIBRARY_DIR - where to find llvm libs
+# LLVM_CFLAGS - llvm compiler flags
+# LLVM_LDFLAGS - llvm linker flags
+# LLVM_MODULE_LIBS - list of llvm libs for working with modules.
+# LLVM_FOUND - True if llvm found.
+
+find_program(LLVM_CONFIG_EXECUTABLE llvm-config${LLVM_SUFFIX})
+
+if (NOT LLVM_CONFIG_EXECUTABLE)
+  message(FATAL_ERROR "Could not find llvm-config")
+endif (NOT LLVM_CONFIG_EXECUTABLE)
+
+execute_process(
+  COMMAND ${LLVM_CONFIG_EXECUTABLE} --includedir
+  OUTPUT_VARIABLE LLVM_INCLUDE_DIR
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+
+execute_process(
+  COMMAND ${LLVM_CONFIG_EXECUTABLE} --libdir
+  OUTPUT_VARIABLE LLVM_LIBRARY_DIR
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+
+execute_process(
+  COMMAND ${LLVM_CONFIG_EXECUTABLE} --cflags
+  OUTPUT_VARIABLE LLVM_CFLAGS
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+
+execute_process(
+  COMMAND ${LLVM_CONFIG_EXECUTABLE} --ldflags
+  OUTPUT_VARIABLE LLVM_LDFLAGS
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+
+execute_process(
+  COMMAND ${LLVM_CONFIG_EXECUTABLE} --version
+  OUTPUT_VARIABLE LLVM_VERSION
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+STRING(REGEX MATCH "[0-9]+\\.[0-9]+" LLVM_VERSION ${LLVM_VERSION})
+
+execute_process(
+  COMMAND ${LLVM_CONFIG_EXECUTABLE} --bindir
+  OUTPUT_VARIABLE LLVM_BINARY_DIR
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+
+include(Common)
+replace_compiler_option(LLVM_CFLAGS "-DNDEBUG" "-UNDEBUG")
+foreach(OPTLEVEL "-O" "-O0" "-O1" "O2" "-O3" "-O4" "-Os")
+  replace_compiler_option(LLVM_CFLAGS ${OPTLEVEL} "")
+endforeach()
+
+message(STATUS "LLVM-config version: ${LLVM_VERSION}")
+message(STATUS "LLVM lib dir: ${LLVM_LIBRARY_DIR}")
+message(STATUS "LLVM bin dir: ${LLVM_BINARY_DIR}")
+message(STATUS "LLVM compile flags: ${LLVM_CFLAGS}")
+# message(STATUS "LLVM include dir: ${LLVM_INCLUDE_DIR}")
+# message(STATUS "LLVM ldflags: ${LLVM_LDFLAGS}")