Merge remote-tracking branch 'origin/develop'

rv-auditor · rv-auditor · commit 1cf325dea8dd · 2024-08-01T17:28:32.000Z
diff --git a/.github/workflows/ci-tests.sh b/.github/workflows/ci-tests.sh
@@ -15,6 +15,7 @@ cmake ..                                                  \
   -DBUILD_TESTS=On                                        \
   -DCMAKE_INSTALL_PREFIX=install
 make -j$(nproc) install
+make test
 popd
 
 pushd matching
diff --git a/cmake/FindLLVM.cmake b/cmake/FindLLVM.cmake
@@ -29,6 +29,10 @@ find_program(LLDB lldb
   PATHS ${LLVM_TOOLS_BINARY_DIR}
   NO_DEFAULT_PATH)
 
+find_program(LLVM_DIS llvm-dis
+  PATHS ${LLVM_TOOLS_BINARY_DIR}
+  NO_DEFAULT_PATH)
+
 execute_process(
   COMMAND "${LLVM_TOOLS_BINARY_DIR}/llvm-config" "--libdir"
   OUTPUT_VARIABLE LLVM_LIBRARY_DIR
@@ -41,3 +45,7 @@ endif()
 if(NOT LLC)
   message(FATAL_ERROR "Could not find an llc binary. Is llvm installed on your PATH?")
 endif()
+
+if(NOT LLVM_DIS)
+  message(FATAL_ERROR "Could not find an llvm-dis binary. Is llvm installed on your PATH?")
+endif()
diff --git a/cmake/LLVMKompilePrelude.cmake b/cmake/LLVMKompilePrelude.cmake
@@ -1,24 +1,20 @@
+find_program(CMAKE_C_COMPILER clang-18)
+find_program(CMAKE_C_COMPILER clang-17)
 find_program(CMAKE_C_COMPILER clang-16)
 find_program(CMAKE_C_COMPILER clang-15)
-find_program(CMAKE_C_COMPILER clang-14)
-find_program(CMAKE_C_COMPILER clang-13)
-find_program(CMAKE_C_COMPILER clang-12)
 find_program(CMAKE_C_COMPILER clang)
+find_program(CMAKE_CXX_COMPILER clang++-18)
+find_program(CMAKE_CXX_COMPILER clang++-17)
 find_program(CMAKE_CXX_COMPILER clang++-16)
 find_program(CMAKE_CXX_COMPILER clang++-15)
-find_program(CMAKE_CXX_COMPILER clang++-14)
-find_program(CMAKE_CXX_COMPILER clang++-13)
-find_program(CMAKE_CXX_COMPILER clang++-12)
 find_program(CMAKE_CXX_COMPILER clang++)
+find_program(CMAKE_C_COMPILER_AR llvm-ar-18)
+find_program(CMAKE_C_COMPILER_AR llvm-ar-17)
 find_program(CMAKE_C_COMPILER_AR llvm-ar-16)
 find_program(CMAKE_C_COMPILER_AR llvm-ar-15)
-find_program(CMAKE_C_COMPILER_AR llvm-ar-14)
-find_program(CMAKE_C_COMPILER_AR llvm-ar-13)
-find_program(CMAKE_C_COMPILER_AR llvm-ar-12)
 find_program(CMAKE_C_COMPILER_AR llvm-ar)
+find_program(CMAKE_C_COMPILER_RANLIB llvm-ranlib-18)
+find_program(CMAKE_C_COMPILER_RANLIB llvm-ranlib-17)
 find_program(CMAKE_C_COMPILER_RANLIB llvm-ranlib-16)
 find_program(CMAKE_C_COMPILER_RANLIB llvm-ranlib-15)
-find_program(CMAKE_C_COMPILER_RANLIB llvm-ranlib-14)
-find_program(CMAKE_C_COMPILER_RANLIB llvm-ranlib-13)
-find_program(CMAKE_C_COMPILER_RANLIB llvm-ranlib-12)
 find_program(CMAKE_C_COMPILER_RANLIB llvm-ranlib)
diff --git a/include/kllvm/codegen/ApplyPasses.h b/include/kllvm/codegen/ApplyPasses.h
@@ -6,6 +6,8 @@
 
 namespace kllvm {
 
+void do_bitcode_linking(llvm::Module &);
+
 void apply_kllvm_opt_passes(llvm::Module &, bool hidden_visibility);
 
 void generate_object_file(llvm::Module &, llvm::raw_ostream &);
diff --git a/include/runtime/alloc_cpp.h b/include/runtime/alloc_cpp.h
@@ -0,0 +1,13 @@
+#ifndef ALLOC_CPP_H
+#define ALLOC_CPP_H
+
+/* This header file declares a string containing the textual bitcode of
+ * runtime/lto/alloc.cpp. The cpp file that defines these symbols is generated
+ * from that library by the lto library. The reason we do this is to ensure
+ * that code generation can inline the bump allocator fully into the functions
+ * that it is called from, which is quite important for performance.
+ */
+extern unsigned char alloc_cpp_o_ll[];
+extern unsigned int alloc_cpp_o_ll_len;
+
+#endif
diff --git a/include/runtime/arena.h b/include/runtime/arena.h
@@ -4,6 +4,8 @@
 #include <cstddef>
 #include <sys/types.h>
 
+#include "runtime/alloc.h"
+
 extern "C" {
 
 // An arena can be used to allocate objects that can then be deallocated all at
@@ -51,11 +53,24 @@ char get_arena_collection_semispace_id(const struct arena *);
 // allocated within an arena.
 char get_arena_semispace_id_of_object(void *);
 
+// helper function for `kore_arena_alloc`. Do not call directly.
+void *do_alloc_slow(size_t, struct arena *);
+
 // Allocates the requested number of bytes as a contiguous region and returns a
 // pointer to the first allocated byte.
 // If called with requested size greater than the maximun single allocation
 // size, the space is allocated in a general (not garbage collected pool).
-void *kore_arena_alloc(struct arena *, size_t);
+inline void *kore_arena_alloc(struct arena *arena, size_t requested) {
+  if (arena->block + requested > arena->block_end) {
+    return do_alloc_slow(requested, arena);
+  }
+  void *result = arena->block;
+  arena->block += requested;
+  MEM_LOG(
+      "Allocation at %p (size %zd), next alloc at %p (if it fits)\n", result,
+      requested, arena->block);
+  return result;
+}
 
 // Resizes the last allocation as long as the resize does not require a new
 // block allocation.
diff --git a/lib/codegen/ApplyPasses.cpp b/lib/codegen/ApplyPasses.cpp
@@ -2,6 +2,7 @@
 #include <kllvm/codegen/Options.h>
 #include <kllvm/codegen/SetVisibilityHidden.h>
 
+#include "runtime/alloc_cpp.h"
 #include "runtime/header.h"
 
 #if LLVM_VERSION_MAJOR >= 17
@@ -12,7 +13,10 @@
 #include <llvm/Support/Host.h>
 #endif
 
+#include "llvm/IRReader/IRReader.h"
+#include <llvm/Bitcode/BitcodeReader.h>
 #include <llvm/IR/LegacyPassManager.h>
+#include <llvm/Linker/Linker.h>
 #include <llvm/MC/TargetRegistry.h>
 #include <llvm/Pass.h>
 #include <llvm/Support/CommandLine.h>
@@ -145,4 +149,24 @@ void generate_object_file(llvm::Module &mod, llvm::raw_ostream &os) {
   pm.run(mod);
 }
 
+/* This function links the code generated module generated by
+ * llvm-kompile-codegen with any llvm bitcode modules we wish to place in the
+ * same translation unit as the code generated code during optimization. This
+ * is done currently with only a single file: runtime/lto/alloc.cpp. We do this
+ * so that inlining can occur across the functions in each file.
+ */
+void do_bitcode_linking(llvm::Module &mod) {
+  Linker linker(mod);
+  llvm::SMDiagnostic err;
+  auto alloc_cpp_mod = llvm::parseIR(
+      *llvm::MemoryBuffer::getMemBuffer(
+          std::string((char *)alloc_cpp_o_ll, alloc_cpp_o_ll_len)),
+      err, mod.getContext());
+  bool error = linker.linkInModule(std::move(alloc_cpp_mod));
+  if (error) {
+    throw std::runtime_error(
+        "Bitcode linking failed. Please report this as a bug.");
+  }
+}
+
 } // namespace kllvm
diff --git a/lib/codegen/CMakeLists.txt b/lib/codegen/CMakeLists.txt
@@ -13,5 +13,5 @@ add_library(Codegen
 )
 
 target_link_libraries(Codegen
-  PUBLIC  AST fmt::fmt-header-only
+  PUBLIC  AST fmt::fmt-header-only alloc-cpp
   PRIVATE base64)
diff --git a/runtime/CMakeLists.txt b/runtime/CMakeLists.txt
@@ -9,12 +9,13 @@ install(
   DESTINATION lib/kllvm/llvm/main
 )
 
-add_subdirectory(arithmetic)
-add_subdirectory(util)
-add_subdirectory(strings)
-add_subdirectory(meta)
 add_subdirectory(alloc)
+add_subdirectory(arithmetic)
 add_subdirectory(collect)
-add_subdirectory(io)
 add_subdirectory(collections)
+add_subdirectory(io)
 add_subdirectory(json)
+add_subdirectory(lto)
+add_subdirectory(meta)
+add_subdirectory(strings)
+add_subdirectory(util)
diff --git a/runtime/alloc/CMakeLists.txt b/runtime/alloc/CMakeLists.txt
@@ -1,5 +1,4 @@
 add_library(alloc STATIC
-  alloc.cpp
   arena.cpp
   register_gc_roots_enum.cpp
 )
diff --git a/runtime/alloc/arena.cpp b/runtime/alloc/arena.cpp
@@ -99,7 +99,7 @@ static void fresh_block(struct arena *arena) {
     if (!next_block) {
       MEM_LOG(
           "Allocating new block for the first time in arena %d\n",
-          Arena->allocation_semispace_id);
+          arena->allocation_semispace_id);
       next_block = (char *)megabyte_malloc();
       *(char **)arena->block_start = next_block;
       auto *next_header = (memory_block_header *)next_block;
@@ -112,17 +112,17 @@ static void fresh_block(struct arena *arena) {
   arena->block_start = next_block;
   arena->block_end = next_block + BLOCK_SIZE;
   MEM_LOG(
-      "New block at %p (remaining %zd)\n", Arena->block,
+      "New block at %p (remaining %zd)\n", arena->block,
       BLOCK_SIZE - sizeof(memory_block_header));
 }
 
 bool gc_enabled;
 
-static __attribute__((noinline)) void *
+__attribute__((noinline)) void *
 do_alloc_slow(size_t requested, struct arena *arena) {
   MEM_LOG(
-      "Block at %p too small, %zd remaining but %zd needed\n", Arena->block,
-      Arena->block_end - Arena->block, requested);
+      "Block at %p too small, %zd remaining but %zd needed\n", arena->block,
+      arena->block_end - arena->block, requested);
   if (requested > BLOCK_SIZE - sizeof(memory_block_header)) {
     return malloc(requested);
   }
@@ -131,20 +131,7 @@ do_alloc_slow(size_t requested, struct arena *arena) {
   arena->block += requested;
   MEM_LOG(
       "Allocation at %p (size %zd), next alloc at %p (if it fits)\n", result,
-      requested, Arena->block);
-  return result;
-}
-
-__attribute__((always_inline)) void *
-kore_arena_alloc(struct arena *arena, size_t requested) {
-  if (arena->block + requested > arena->block_end) {
-    return do_alloc_slow(requested, arena);
-  }
-  void *result = arena->block;
-  arena->block += requested;
-  MEM_LOG(
-      "Allocation at %p (size %zd), next alloc at %p (if it fits)\n", result,
-      requested, Arena->block);
+      requested, arena->block);
   return result;
 }
 
diff --git a/runtime/lto/CMakeLists.txt b/runtime/lto/CMakeLists.txt
@@ -0,0 +1,30 @@
+add_library(lto STATIC
+  alloc.cpp
+)
+add_library(lto-static STATIC
+  alloc.cpp
+)
+
+target_compile_options(lto PRIVATE "-flto")
+
+add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/runtime/lto/alloc.cpp.o
+	COMMAND ${CMAKE_C_COMPILER_AR} x ${CMAKE_BINARY_DIR}/runtime/lto/liblto.a alloc.cpp.o
+	DEPENDS lto
+)
+
+add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/runtime/lto/alloc.cpp.o.ll
+	COMMAND ${LLVM_DIS} ${CMAKE_BINARY_DIR}/runtime/lto/alloc.cpp.o
+	DEPENDS ${CMAKE_BINARY_DIR}/runtime/lto/alloc.cpp.o
+)
+
+add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/runtime/lto/alloc_cpp.cpp
+	COMMAND xxd -i alloc.cpp.o.ll alloc_cpp.cpp
+	DEPENDS ${CMAKE_BINARY_DIR}/runtime/lto/alloc.cpp.o.ll
+	WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/runtime/lto
+)
+
+add_library(alloc-cpp STATIC
+  ${CMAKE_BINARY_DIR}/runtime/lto/alloc_cpp.cpp
+)
+
+set_target_properties(alloc-cpp PROPERTIES EXPORT_COMPILE_COMMANDS Off)
diff --git a/runtime/lto/alloc.cpp b/runtime/lto/alloc.cpp
diff --git a/tools/llvm-kompile-codegen/main.cpp b/tools/llvm-kompile-codegen/main.cpp
@@ -236,6 +236,8 @@ int main(int argc, char **argv) {
     finalize_debug_info();
   }
 
+  do_bitcode_linking(*mod);
+
   if (!no_optimize) {
     apply_kllvm_opt_passes(*mod, hidden_visibility);
   }
diff --git a/unittests/runtime-ffi/CMakeLists.txt b/unittests/runtime-ffi/CMakeLists.txt
@@ -18,6 +18,7 @@ target_link_libraries(runtime-ffi-tests
   strings
   arithmetic
   alloc
+  lto-static
   gmp
   mpfr
   dl
diff --git a/unittests/runtime-io/CMakeLists.txt b/unittests/runtime-io/CMakeLists.txt
@@ -9,6 +9,7 @@ target_link_libraries(runtime-io-tests
   strings
   arithmetic
   alloc
+  lto-static
   gmp
   mpfr
   ${Boost_UNIT_TEST_FRAMEWORK_LIBRARIES}
diff --git a/unittests/runtime-strings/CMakeLists.txt b/unittests/runtime-strings/CMakeLists.txt
@@ -9,6 +9,7 @@ target_link_libraries(runtime-strings-tests
   strings
   arithmetic
   alloc
+  lto-static
   gmp
   mpfr
   ${Boost_UNIT_TEST_FRAMEWORK_LIBRARIES}

Original file line number	Diff line number	Diff line change
`@@ -13,5 +13,5 @@ add_library(Codegen`
`13`	`13`	`)`
`14`	`14`
`15`	`15`	`target_link_libraries(Codegen`
`16`		`- PUBLIC AST fmt::fmt-header-only`
	`16`	`+ PUBLIC AST fmt::fmt-header-only alloc-cpp`
`17`	`17`	`PRIVATE base64)`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`add_library(alloc STATIC`
`2`		`- alloc.cpp`
`3`	`2`	`arena.cpp`
`4`	`3`	`register_gc_roots_enum.cpp`
`5`	`4`	`)`