Clang 14.0.6

.gitignore

@@ -19,6 +19,9 @@ RemoteSystemsTempFiles/
 # Custom ignores #
 ##################
 
+.vscode
+deps/temp
+
 tomJava/
 .svn/
 sf.eclipse.javacc.prefs

ClangAstDumper/CMakeLists.txt

@@ -14,9 +14,10 @@ include("../deps.cmake")
 # Add Modules
 #deps_find_package(llvm3.8 REQUIRED) # LLVM
 #deps_find_package(llvm7 REQUIRED) # LLVM
-deps_find_package(llvm12 REQUIRED) # LLVM
+#deps_find_package(llvm12 REQUIRED) # LLVM
+deps_find_package(llvm14.0.6 REQUIRED) # LLVM
 
-set(COMMON_CXX_FLAGS "-std=c++14 -O3 -Wall -Wno-unused-function")
+set(COMMON_CXX_FLAGS "-std=c++17 -O3 -Wall -Wno-unused-function")
 #-D__STDC_CONSTANT_MACROS -D__STDC_LIMIT_MACROS -DVISIT_CHECK
 
 #add_definitions(-DOLD_OUTPUT)

ClangAstDumper/ClangEnums.h

@@ -18,7 +18,7 @@ namespace clava {
     /* Clang Enums */
 
     extern const std::string CAST_KIND[];
-    extern const std::string ATTRIBUTES[];
+    extern const std::string ATTRIBUTES[]; // Deprecated, no not use. Instead, use clava::getAttrKind(const Attr* A)
     extern const std::string CALLING_CONVENTION[];
     extern const std::string REFERENCE_QUALIFIER[];
     extern const std::string EXCEPTION_SPECIFICATION_TYPE[];

ClangAstDumper/ClangNodes.cpp

@@ -11,7 +11,7 @@
 
 
 #include <bitset>
-
+#include <iostream>
 
 using namespace clang;
 
@@ -30,8 +30,28 @@ const std::string clava::getClassName(const Type* T) {
     return kindName + "Type";
 }
 
+const std::string clava::getAttrKind(const Attr* A) {
+    // Print information about Attr
+    //clava::dump(clava::ATTRIBUTES[A->getKind()]);
+    {
+        switch (A->getKind()) {
+#define ATTR(X)                                                                \
+  case attr::X:                                                                \
+    return #X;                                                                  \
+    break;
+#include "clang/Basic/AttrList.inc"
+        }
+
+    }
+
+    return "<undefined_attribute>";
+}
+
 const std::string clava::getClassName(const Attr* A) {
-    const std::string kindName =  clava::ATTRIBUTES[A->getKind()];
+
+    //const std::string kindName =  clava::ATTRIBUTES[A->getKind()];
+    const std::string kindName =  clava::getAttrKind(A);
+
     return kindName + "Attr";
 }
 
@@ -459,7 +479,10 @@ void clava::dump(NestedNameSpecifier* qualifier, int id) {
 
 
 void clava::dump(const TemplateArgument &templateArg, int id, ASTContext* Context) {
+    SmallString<0> str;
+
     clava::dump(clava::TEMPLATE_ARG_KIND[templateArg.getKind()]);
+
     switch (templateArg.getKind()) {
         case TemplateArgument::ArgKind::Type:
             clava::dump(clava::getId(templateArg.getAsType(), id));
@@ -475,10 +498,8 @@ void clava::dump(const TemplateArgument &templateArg, int id, ASTContext* Contex
             }
             break;
         case TemplateArgument::ArgKind::Integral:
-            //bool isSigned = templateArg.getAsIntegral().isSigned();
-            clava::dump(templateArg.getAsIntegral().toString(10));
-//    const std::string source = getSource(E);
-//    clava::dump(source);
+            templateArg.getAsIntegral().toString(str, 10);
+            clava::dump(str);
             break;
         case TemplateArgument::ArgKind::Template:
             clava::dump(templateArg.getAsTemplate(), id, Context);

ClangAstDumper/ClangNodes.h

@@ -46,6 +46,15 @@ namespace clava {
      */
     const std::string getClassName(const Type* T);
 
+    /**
+     * Returns the kind name of the class of the given Attribute.
+     *
+     * @param A
+     * @return
+     */
+    const std::string getAttrKind(const Attr* A);
+
+
     /**
      * Returns the name of the class of the given Attribute.
      *

ClangAstDumper/ClavaConstants.cpp

@@ -145,6 +145,7 @@ const std::string clava::getName(const AttrNode attrNode) {
         case clava::AttrNode::FORMAT: return "FormatAttr";
         case clava::AttrNode::NON_NULL: return "NonNullAttr";
         case clava::AttrNode::VISIBILITY: return "VisibilityAttr";
+        //case clava::AttrNode::TYPE_VISIBILITY: return "TypeVisibilityAttr";
 
         default: {
             std::string enumValue = std::to_string(static_cast<std::underlying_type<AttrNode>::type>(attrNode));

ClangAstDumper/ClavaConstants.h

@@ -155,6 +155,7 @@ namespace clava {
         FORMAT,
         NON_NULL,
         VISIBILITY,
+        //TYPE_VISIBILITY,
     };
 
 

ClangAstDumper/ClavaDataDumper.h

@@ -238,6 +238,7 @@ namespace clava {
         void DumpFormatAttrData(const FormatAttr *A);
         void DumpNonNullAttrData(const NonNullAttr *A);
         void DumpVisibilityAttrData(const VisibilityAttr *A);
+        //void DumpTypeVisibilityAttrData(const TypeVisibilityAttr *A);
         const std::string getDataName(DeclNode node);
         const std::string getDataName(StmtNode node);
         const std::string getDataName(TypeNode node);

ClangAstDumper/ClavaDataDumperAttrs.cpp

@@ -15,6 +15,8 @@ const std::map<const std::string, clava::AttrNode > clava::ATTR_DATA_MAP = {
         {"FormatAttr", clava::AttrNode::FORMAT},
         {"NonNullAttr", clava::AttrNode::NON_NULL},
         {"VisibilityAttr", clava::AttrNode::VISIBILITY},
+        //{"TypeVisibilityAttr", clava::AttrNode::TYPE_VISIBILITY},
+
 };
 
 
@@ -52,6 +54,8 @@ void clava::ClavaDataDumper::dump(clava::AttrNode attrNode, const Attr* A) {
             DumpNonNullAttrData(static_cast<const NonNullAttr*>(A)); break;
         case clava::AttrNode::VISIBILITY:
             DumpVisibilityAttrData(static_cast<const VisibilityAttr*>(A)); break;
+        //case clava::AttrNode::TYPE_VISIBILITY:
+        //    DumpTypeVisibilityAttrData(static_cast<const TypeVisibilityAttr*>(A)); break;
         default:
             throw std::invalid_argument("ClangDataDumper::dump(DeclNode):: Case not implemented, '" + getName(attrNode) + "'");
     }
@@ -61,8 +65,7 @@ void clava::ClavaDataDumper::dump(clava::AttrNode attrNode, const Attr* A) {
 void clava::ClavaDataDumper::DumpAttrData(const Attr *A) {
     clava::dumpSourceInfo(Context, A->getRange().getBegin(), A->getRange().getEnd());
 
-    // Print information about Attr
-    clava::dump(clava::ATTRIBUTES[A->getKind()]);
+    clava::dump(clava::getAttrKind(A));
     clava::dump(A->isImplicit());
     clava::dump(A->isInherited());
     clava::dump(A->isLateParsed());
@@ -121,4 +124,12 @@ void clava::ClavaDataDumper::DumpVisibilityAttrData(const VisibilityAttr *A) {
     DumpAttrData(A);
 
     clava::dump(clava::VISIBILITY_ATTR_TYPE[A->getVisibility()]);
-}
+}
+/*
+void clava::ClavaDataDumper::DumpTypeVisibilityAttrData(const TypeVisibilityAttr *A) {
+    // Common
+    DumpAttrData(A);
+
+    clava::dump(clava::VISIBILITY_ATTR_TYPE[A->getVisibility()]);
+}
+ */

ClangAstDumper/ClavaDataDumperStmts.cpp

@@ -386,15 +386,11 @@ void clava::ClavaDataDumper::DumpCharacterLiteralData(const CharacterLiteral *E)
 
 void clava::ClavaDataDumper::DumpIntegerLiteralData(const IntegerLiteral *E) {
     DumpLiteralData(E);
-//    DumpExprData(E);
-
-//    clava::dump(clava::getSource(Context, E->getSourceRange()));
-
     bool isSigned = E->getType()->isSignedIntegerType();
 
-//    const std::string source = getSource(E);
-//    clava::dump(source);
-    clava::dump(E->getValue().toString(10, isSigned));
+    SmallString<0> str;
+    E->getValue().toString(str, 10, isSigned);
+    clava::dump(str);
 
 /*
     const SourceManager &sm = Context->getSourceManager();

ClangAstDumper/ClavaDataDumperTypes.cpp

@@ -454,8 +454,9 @@ void clava::ClavaDataDumper::DumpConstantArrayTypeData(const ConstantArrayType *
     DumpArrayTypeData(T);
 
     //clava::dump(T->getSize().VAL);
-    clava::dump(T->getSize().toString(10, false));
-
+    SmallString<0> str;
+    T->getSize().toString(str, 10, false);
+    clava::dump(str);
 }
 
 void clava::ClavaDataDumper::DumpVariableArrayTypeData(const VariableArrayType *T) {

ClangAstDumper/clang_enums/CMakeLists.txt

@@ -7,10 +7,11 @@ include("../../deps.cmake")
 # Add Modules
 #deps_find_package(llvm3.8 REQUIRED) # LLVM
 #deps_find_package(llvm7 REQUIRED) # LLVM
-deps_find_package(llvm12 REQUIRED) # LLVM
+#deps_find_package(llvm12 REQUIRED) # LLVM
+deps_find_package(llvm14.0.6 REQUIRED) # LLVM
 
 # Set base llvm dir
-set(LLVM_DIR ${llvm12_DIR})
+set(LLVM_DIR ${llvm14.0.6_DIR})
 
 set(COMMON_CXX_FLAGS "-O3 -Wall -Wno-unused-function")
 
@@ -19,13 +20,19 @@ find_package(Clava REQUIRED)
 
 message(STATUS "LLVM DIR: ${LLVM_DIR}")
 
+# Create target for clang/AST/Type.h
+add_library(EnumGen)
+
+clava_weave(EnumGen "Main.js"  ARGS "llvmFolder:'${LLVM_DIR}', outputFolder:'${CMAKE_CURRENT_LIST_DIR}/..'" JAVA_FLAGS -Xmx8000m)
+
+
 # Make enum extractor available
-include(${CMAKE_CURRENT_LIST_DIR}/ExtractEnums.cmake)
+#include(${CMAKE_CURRENT_LIST_DIR}/ExtractEnums.cmake)
 
 #extract_enums("${LLVM_DIR}/src/include/clang/AST" "Type.h")
 #extract_enums("${LLVM_DIR}/src/include/clang/AST" "OperationKinds.h")
 #extract_enums("${LLVM_DIR}/src/include/clang/Basic" "AttrKinds.h")
-extract_enums("${LLVM_DIR}/src/include/clang/Basic" "Specifiers.h")
+#extract_enums("${LLVM_DIR}/src/include/clang/Basic" "Specifiers.h")
 #extract_enums("${LLVM_DIR}/src/include/clang/Basic" "ExceptionSpecificationType.h")
 #extract_enums("${LLVM_DIR}/src/include/clang/Basic" "Linkage.h")
 #extract_enums("${LLVM_DIR}/src/include/clang/Basic" "Visibility.h")

ClangAstDumper/clang_enums/ClangEnum.js

@@ -0,0 +1,121 @@
+laraImport("weaver.Query");
+laraImport("Extractors");
+
+/**
+ * @class
+ */
+class ClangEnum {
+  constructor(name, cppVarName, mapper, excludeArray, className) {
+    this.name = name;
+    this.cppVarName = cppVarName;
+
+    if (mapper === undefined) {
+      mapper = (element) => element;
+    }
+    this.mapper = mapper;
+
+    if (excludeArray === undefined) {
+      excludeArray = [];
+    }
+    this.excludeSet = new StringSet(excludeArray);
+    //println("Exclude set: " + this.excludeSet.values());
+
+    this.className = className;
+
+    this.enumValues = undefined;
+
+    /*
+    if (extractor == undefined) {
+      extractor = Extractors.simpleExtractor;
+    }
+    this.extractor = extractor;
+	*/
+    this.extractor = Extractors.simpleExtractor;
+    this.occurence = 1;
+  }
+
+  setOccurence(occurence) {
+    this.occurence = occurence;
+    return this;
+  }
+
+  getEnumName() {
+    return this.name;
+  }
+
+  getCompleteEnumName() {
+    if (this.className === undefined) {
+      return this.name;
+    }
+
+    return this.className + "_" + this.name;
+  }
+
+  getClassName() {
+    return this.className;
+  }
+
+  /*
+ClangEnum.prototype.getStartingNode = function() {
+	if(this.className === undefined) {
+		return Query.root();
+	}
+
+	var startingClass = Query.search("class", this.className).first();
+
+	if(startingClass === undefined) {
+		throw new Error("Clang enum specifies class '"+this.className+"', but it could not be found");
+	}
+
+	return startingClass;
+}
+*/
+
+  setEnumValues(headerLines) {
+    this.enumValues = this.extractor(this.name, headerLines, this.occurence);
+  }
+
+  /*
+  setEnumValues(enumValues) {
+    if (this.enumValues !== undefined) {
+      println("Setting enum values again for enum " + this.name);
+    }
+
+    this.enumValues = enumValues;
+  }
+  */
+
+  getCode() {
+    if (this.enumValues === undefined) {
+      println("No enum values set for enum '" + this.name + "'");
+      return undefined;
+    }
+
+    var code = "";
+
+    code += "extern const std::string clava::" + this.cppVarName + "[] = {\n";
+
+    for (var enumValue of this.enumValues) {
+      //println("Enum: " + enumValue);
+      if (this.excludeSet.has(enumValue.toString())) {
+        println("Excluded enum '" + enumValue + "'");
+        continue;
+      }
+
+      // Map enum value
+      enumValue = this.mapper(enumValue);
+
+      code += '        "' + enumValue + '",\n';
+    }
+
+    code += "};\n";
+
+    return code;
+  }
+
+  getEnumValues() {
+    return this.enumValues
+      .filter((e) => !this.excludeSet.has(e.toString()))
+      .map(this.mapper);
+  }
+}