Llvm 3.2 to latest

.gitattributes

@@ -0,0 +1 @@
+*.clay linguist-language=JavaScript

CMakeLists.txt

@@ -5,6 +5,7 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
 
 find_package(Git)
@@ -35,17 +36,20 @@ if(UNIX)
     if (NOT ${LLVM_CONFIG_VERSION_RESULT} EQUAL 0)
         message(FATAL_ERROR "${LLVM_CONFIG} failed")
     endif()
+    if(LLVM_VERSION VERSION_LESS 18.0)
+        message(FATAL_ERROR "LLVM 18 or newer is required. Found ${LLVM_VERSION}")
+    endif()
 
     execute_process(
         COMMAND ${LLVM_CONFIG} --cxxflags
         OUTPUT_VARIABLE LLVM_CXXFLAGS
         OUTPUT_STRIP_TRAILING_WHITESPACE
     )
-    set(LLVM_CXXFLAGS "${LLVM_CXXFLAGS}")
+    set(LLVM_CXXFLAGS ${LLVM_CXXFLAGS})
     separate_arguments(LLVM_CXXFLAGS)
 
     if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-        set(LLVM_CXXFLAGS "${LLVM_CXXFLAGS} -O0")
+        list(APPEND LLVM_CXXFLAGS -O0)
     endif()
 
     execute_process(
@@ -79,7 +83,7 @@ if(UNIX)
         OUTPUT_VARIABLE LLVM_INCLUDEDIR
         OUTPUT_STRIP_TRAILING_WHITESPACE
     )
-    set(LLVM_INCLUDEDIR "${LLVM_INCLUDEDIR}")
+    set(LLVM_INCLUDEDIR ${LLVM_INCLUDEDIR})
 
     message("-- Using LLVM: ${LLVM_DIR}")
     message("-- LLVM include dir: ${LLVM_INCLUDEDIR}")

compiler/CMakeLists.txt

@@ -54,41 +54,56 @@ if(GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git")
         COMPILE_DEFINITIONS "GIT_ID=\"${GIT_WC_ID}\"")
 endif()
 
-# Compiler flags
+# Targets
+add_library(compiler STATIC ${COMPILER_SOURCES})
+add_executable(clay ${CLAY_SOURCES})
+add_executable(claydoc ${CLAYDOC_SOURCES})
+add_executable(ut ${UT_SOURCES})
+
+# compiler flags
+target_compile_options(compiler PRIVATE ${LLVM_CXXFLAGS})
+target_compile_options(clay     PRIVATE ${LLVM_CXXFLAGS})
+target_compile_options(claydoc  PRIVATE ${LLVM_CXXFLAGS})
+target_compile_options(ut       PRIVATE ${LLVM_CXXFLAGS})
+
+# include directories
+target_include_directories(compiler PRIVATE ${LLVM_INCLUDEDIR})
+target_include_directories(clay     PRIVATE ${LLVM_INCLUDEDIR})
+target_include_directories(claydoc  PRIVATE ${LLVM_INCLUDEDIR})
+target_include_directories(ut       PRIVATE ${LLVM_INCLUDEDIR})
+
 if(CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
-    set(CLAY_CXXFLAGS "${LLVM_CXXFLAGS} -UNDEBUG")
+    target_compile_definitions(compiler PRIVATE UNDEBUG)
+    target_compile_definitions(clay     PRIVATE UNDEBUG)
+    target_compile_definitions(claydoc  PRIVATE UNDEBUG)
+    target_compile_definitions(ut       PRIVATE UNDEBUG)
 else()
-    set(CLAY_CXXFLAGS "${LLVM_CXXFLAGS} -DNDEBUG")
+    target_compile_definitions(compiler PRIVATE NDEBUG)
+    target_compile_definitions(clay     PRIVATE NDEBUG)
+    target_compile_definitions(claydoc  PRIVATE NDEBUG)
+    target_compile_definitions(ut       PRIVATE NDEBUG)
 endif()
-if (NOT MSVC)
-    set(CLAY_CXXFLAGS "${CLAY_CXXFLAGS} -fexceptions")
+
+if(NOT MSVC)
+    target_compile_options(compiler PRIVATE -fexceptions)
+    target_compile_options(clay     PRIVATE -fexceptions)
+    target_compile_options(claydoc  PRIVATE -fexceptions)
+    target_compile_options(ut       PRIVATE -fexceptions)
 endif()
 
 set(ENABLE_PCH False CACHE BOOL
-    "Use precompiled headers when building the compiler. (experimental)")
+        "Use precompiled headers when building the compiler. (experimental)")
 
 if(ENABLE_PCH)
-    precompile_header(clay.hpp SOURCES pch.cpp "${CLAY_CXXFLAGS}")
+    precompile_header(clay.hpp SOURCES pch.cpp ${LLVM_CXXFLAGS})
 endif(ENABLE_PCH)
 
-# Targets
-add_library(compiler STATIC ${COMPILER_SOURCES})
-add_executable(clay ${CLAY_SOURCES})
-add_executable(claydoc ${CLAYDOC_SOURCES})
-add_executable(ut ${UT_SOURCES})
-
-# compiler flags
-target_compile_options(compiler PRIVATE "${CLAY_CXXFLAGS}")
-target_compile_options(clay     PRIVATE "${CLAY_CXXFLAGS}")
-target_compile_options(claydoc  PRIVATE "${CLAY_CXXFLAGS}")
-target_compile_options(ut       PRIVATE "${CLAY_CXXFLAGS}")
-
 if (UNIX)
-    target_link_options(compiler PRIVATE "${LLVM_LDFLAGS}")
-    target_link_options(clay     PRIVATE "${LLVM_LDFLAGS}")
-    target_link_options(claydoc  PRIVATE "${LLVM_LDFLAGS}")
-    target_link_options(ut       PRIVATE "${LLVM_LDFLAGS}")
-endif(UNIX)
+    target_link_options(compiler PRIVATE ${LLVM_LDFLAGS})
+    target_link_options(clay     PRIVATE ${LLVM_LDFLAGS})
+    target_link_options(claydoc  PRIVATE ${LLVM_LDFLAGS})
+    target_link_options(ut       PRIVATE ${LLVM_LDFLAGS})
+endif()
 
 # Libraries
 target_link_libraries(clay     PRIVATE compiler ${LLVM_LIBS})

compiler/analyzer.cpp

@@ -1,4 +1,3 @@
-
 #include "clay.hpp"
 #include "evaluator.hpp"
 #include "codegen.hpp"
@@ -55,8 +54,7 @@ namespace clay {
           params(params), varParam(varParam), expr(expr) {
     }
 
-    GlobalVariable::~GlobalVariable() {
-    }
+    GlobalVariable::~GlobalVariable() = default;
 
     static StatementAnalysis analyzeStatement(StatementPtr stmt, EnvPtr env, AnalysisContext *ctx);
 
@@ -219,8 +217,7 @@ namespace clay {
     static vector<CompileContextEntry> analysisErrorCompileContext;
 
     struct ClearAnalysisError {
-        ClearAnalysisError() {
-        }
+        ClearAnalysisError() = default;
 
         ~ClearAnalysisError() {
             analysisErrorLocation = Location();
@@ -1442,7 +1439,7 @@ namespace clay {
                     }
                     return;
                 case IITDescriptor::MMX:
-                    if (!Ty->isX86_MMXTy()) {
+                    if (!Ty->isX86_AMXTy()) {
                         errors << "intrinsic argument " << (ai + 1)
                                 << " must match LLVM MMX type, but got ";
                         Ty->print(errors);
@@ -1479,11 +1476,11 @@ namespace clay {
                     return;
                 case IITDescriptor::Vector: {
                     llvm::VectorType *VT = dyn_cast<llvm::VectorType>(Ty);
-                    if (VT == 0) {
+                    if (VT == nullptr) {
                         errors << "intrinsic argument " << (ai + 1)
                                 << " must be of an LLVM vector type, but got ";
                         Ty->print(errors);
-                    } else if (VT->getNumElements() != D.Vector_Width) {
+                    } else if (VT->getElementCount() != D.Vector_Width) {
                         errors << "intrinsic argument " << (ai + 1)
                                 << " must be of an LLVM vector type with "
                                 << D.Vector_Width

compiler/analyzer.hpp

@@ -2,7 +2,6 @@
 
 #include "clay.hpp"
 
-// #include "invoketables.hpp"
 #include "types.hpp"
 
 namespace clay {
@@ -24,9 +23,9 @@ namespace clay {
     bool staticToCallingConv(ObjectPtr x, CallingConv &out);
     CallingConv staticToCallingConv(MultiStaticPtr x, unsigned index);
 
-    static inline PVData staticPValue(ObjectPtr x) {
+    static PVData staticPValue(const ObjectPtr& x) {
         const TypePtr t = staticType(x);
-        return PVData(t, true);
+        return {t, true};
     }
 
     enum BoolKind {

compiler/analyzer_op.cpp

@@ -4,10 +4,9 @@
 #include "constructors.hpp"
 #include "loader.hpp"
 #include "env.hpp"
-
 #include "analyzer.hpp"
-
 #include "analyzer_op.hpp"
+#include "invoketables.hpp"
 
 namespace clay {
     static size_t staticToSizeTOrIntValue(MultiPValue *args, size_t index) {