[Build] LLVM-18

.github/workflows/scripts/ti_build/llvm.py

@@ -7,7 +7,6 @@
 # -- third party --
 # -- own --
 from .bootstrap import get_cache_home
-from .cmake import cmake_args
 from .dep import download_dep
 from .misc import banner, get_cache_home
 
@@ -20,8 +19,8 @@ def setup_llvm() -> str:
     """
     u = platform.uname()
 
-    llvm_version = "15.0.7"
-    build_version = "202510071403"
+    llvm_version = "18.1.8"
+    build_version = "202511140159"
     release_url_template = "https://github.com/Genesis-Embodied-AI/gstaichi-sdk-builds/releases/download/llvm-{llvm_version}-{build_version}/taichi-llvm-{llvm_version}-{platform}.zip".format(
         llvm_version=llvm_version,
         build_version=build_version,
@@ -30,12 +29,8 @@ def setup_llvm() -> str:
 
     match (u.system, u.machine):
         case ("Linux", "x86_64"):
-            if cmake_args.get_effective("TI_WITH_AMDGPU"):
-                out = get_cache_home() / f"llvm-{llvm_version}-amdgpu-{build_version}"
-                url = "https://github.com/GaleSeLee/assets/releases/download/v0.0.5/taichi-llvm-15.0.0-linux.zip"
-            else:
-                out = get_cache_home() / f"llvm-{llvm_version}-x86-{build_version}"
-                url = release_url_template.format(platform="linux-x86_64")
+            out = get_cache_home() / f"llvm-{llvm_version}-x86-{build_version}"
+            url = release_url_template.format(platform="linux-x86_64")
             download_dep(url, out, strip=1)
         case ("Linux", "arm64") | ("Linux", "aarch64"):
             out = get_cache_home() / f"llvm-{llvm_version}-aarch64-{build_version}"

CMakeLists.txt

@@ -8,15 +8,6 @@ project(gstaichi)
 
 include("cmake/utils.cmake")
 
-if (NOT DEFINED TI_VERSION_MAJOR)
-    message(WARNING "It seems that you are running cmake manually, which may cause issues. Please use setup.py to build gstaichi from source, see https://docs.taichi-lang.org/docs/dev_install for more details.")
-    file(READ "${CMAKE_CURRENT_LIST_DIR}/version.txt" TI_VERSION_LITERAL)
-    string(REGEX MATCH "v([0-9]+)\\.([0-9]+)\\.([0-9]+)" TI_VERSION_LITERAL ${TI_VERSION_LITERAL})
-    set(TI_VERSION_MAJOR ${CMAKE_MATCH_1})
-    set(TI_VERSION_MINOR ${CMAKE_MATCH_2})
-    set(TI_VERSION_PATCH ${CMAKE_MATCH_3})
-endif()
-
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
 set(CMAKE_EXPORT_COMPILECOMMANDS ON)

gstaichi/codegen/cpu/codegen_cpu.cpp

@@ -12,12 +12,14 @@
 #include "gstaichi/ir/analysis.h"
 #include "gstaichi/analysis/offline_cache_util.h"
 
-#include "llvm/Support/Host.h"
+#include "llvm/TargetParser/Host.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Transforms/IPO.h"
-#include "llvm/Transforms/IPO/PassManagerBuilder.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
+#include "llvm/Passes/PassBuilder.h"
+#include "llvm/Passes/StandardInstrumentations.h"
+#include "llvm/Transforms/Scalar/LoopPassManager.h"
 
 namespace gstaichi::lang {
 
@@ -53,7 +55,7 @@ class TaskCodeGenCPU : public TaskCodeGenLLVM {
     {
       auto guard = get_function_creation_guard(
           {llvm::PointerType::get(get_runtime_type("RuntimeContext"), 0),
-           llvm::Type::getInt8PtrTy(*llvm_context),
+           llvm::PointerType::getUnqual(*llvm_context),
            tlctx->get_data_type<int>()});
 
       auto loop_var = create_entry_block_alloca(PrimitiveType::i32);
@@ -81,7 +83,7 @@ class TaskCodeGenCPU : public TaskCodeGenLLVM {
     {
       auto guard = get_function_creation_guard(
           {llvm::PointerType::get(get_runtime_type("RuntimeContext"), 0),
-           llvm::Type::getInt8PtrTy(*llvm_context),
+           llvm::PointerType::getUnqual(*llvm_context),
            tlctx->get_data_type<int>()});
 
       for (int i = 0; i < stmt->mesh_prologue->size(); i++) {
@@ -266,69 +268,53 @@ void KernelCodeGenCPU::optimize_module(llvm::Module *module) {
   options.NoZerosInBSS = false;
   options.GuaranteedTailCallOpt = false;
 
-  llvm::legacy::FunctionPassManager function_pass_manager(module);
-  llvm::legacy::PassManager module_pass_manager;
-
   llvm::StringRef mcpu = llvm::sys::getHostCPUName();
   std::unique_ptr<llvm::TargetMachine> target_machine(
       target->createTargetMachine(triple.str(), mcpu.str(), "", options,
                                   llvm::Reloc::PIC_, llvm::CodeModel::Small,
-                                  llvm::CodeGenOpt::Aggressive));
+                                  llvm::CodeGenOptLevel::Aggressive));
 
   TI_ERROR_UNLESS(target_machine.get(), "Could not allocate target machine!");
 
   module->setDataLayout(target_machine->createDataLayout());
 
-  module_pass_manager.add(llvm::createTargetTransformInfoWrapperPass(
-      target_machine->getTargetIRAnalysis()));
-  function_pass_manager.add(llvm::createTargetTransformInfoWrapperPass(
-      target_machine->getTargetIRAnalysis()));
+  llvm::LoopAnalysisManager lam;
+  llvm::FunctionAnalysisManager fam;
+  llvm::CGSCCAnalysisManager cgam;
+  llvm::ModuleAnalysisManager mam;
 
-  llvm::PassManagerBuilder b;
-  b.OptLevel = 3;
-  b.Inliner = llvm::createFunctionInliningPass(b.OptLevel, 0, false);
-  b.LoopVectorize = true;
-  b.SLPVectorize = true;
+  llvm::PassBuilder pb(target_machine.get());
+  pb.registerModuleAnalyses(mam);
+  pb.registerCGSCCAnalyses(cgam);
+  pb.registerFunctionAnalyses(fam);
+  pb.registerLoopAnalyses(lam);
+  pb.crossRegisterProxies(lam, fam, cgam, mam);
 
-  target_machine->adjustPassManager(b);
+  llvm::ModulePassManager mpm =
+      pb.buildPerModuleDefaultPipeline(llvm::OptimizationLevel::O3);
 
-  b.populateFunctionPassManager(function_pass_manager);
-  b.populateModulePassManager(module_pass_manager);
+  mpm.run(*module, mam);
 
-  {
-    TI_PROFILER("llvm_function_pass");
-    function_pass_manager.doInitialization();
-    for (llvm::Module::iterator i = module->begin(); i != module->end(); i++)
-      function_pass_manager.run(*i);
+  llvm::legacy::PassManager legacy_pm;
+  legacy_pm.add(llvm::createTargetTransformInfoWrapperPass(
+      target_machine->getTargetIRAnalysis()));
+  legacy_pm.add(llvm::createLoopStrengthReducePass());
+  legacy_pm.add(llvm::createSeparateConstOffsetFromGEPPass(false));
+  legacy_pm.add(llvm::createEarlyCSEPass(true));
 
-    function_pass_manager.doFinalization();
+  {
+    TI_PROFILER("llvm_module_pass");
+    legacy_pm.run(*module);
   }
 
-  /*
-    Optimization for llvm::GetElementPointer:
-    https://github.com/taichi-dev/gstaichi/issues/5472 The three other passes
-    "loop-reduce", "ind-vars", "cse" serves as preprocessing for
-    "separate-const-offset-gep".
-
-    Note there's an update for "separate-const-offset-gep" in llvm-12.
-  */
-  module_pass_manager.add(llvm::createLoopStrengthReducePass());
-  module_pass_manager.add(llvm::createIndVarSimplifyPass());
-  module_pass_manager.add(llvm::createSeparateConstOffsetFromGEPPass(false));
-  module_pass_manager.add(llvm::createEarlyCSEPass(true));
-
   llvm::SmallString<8> outstr;
   llvm::raw_svector_ostream ostream(outstr);
   ostream.SetUnbuffered();
   if (compile_config.print_kernel_asm) {
-    // Generate assembly code if neccesary
-    target_machine->addPassesToEmitFile(module_pass_manager, ostream, nullptr,
-                                        llvm::CGFT_AssemblyFile);
-  }
-
-  {
-    TI_PROFILER("llvm_module_pass");
-    module_pass_manager.run(*module);
+    llvm::legacy::PassManager asm_pm;
+    target_machine->addPassesToEmitFile(asm_pm, ostream, nullptr,
+                                        llvm::CodeGenFileType::AssemblyFile);
+    asm_pm.run(*module);
   }
 
   if (compile_config.print_kernel_asm) {

gstaichi/codegen/cuda/codegen_cuda.cpp

@@ -74,7 +74,7 @@ class TaskCodeGenCUDA : public TaskCodeGenLLVM {
         builder.get(), "vprintf",
         builder->CreateGlobalStringPtr(format, "format_string"),
         builder->CreateBitCast(value_arr,
-                               llvm::Type::getInt8PtrTy(*llvm_context)));
+                               llvm::PointerType::getUnqual(*llvm_context)));
   }
 
   std::tuple<llvm::Value *, llvm::Type *> create_value_and_type(

gstaichi/codegen/llvm/codegen_llvm.cpp

@@ -1469,7 +1469,7 @@ llvm::Value *TaskCodeGenLLVM::atomic_op_using_cas(
 
   {
     int bits = data_type_bits(type);
-    llvm::PointerType *typeIntPtr = get_integer_ptr_type(bits);
+    llvm::PointerType *typeIntPtr = llvm::PointerType::getUnqual(*llvm_context);
     llvm::IntegerType *typeIntTy = get_integer_type(bits);
 
     old_val = builder->CreateLoad(val->getType(), dest);
@@ -1677,10 +1677,10 @@ llvm::Value *TaskCodeGenLLVM::call(
   auto prefix = get_runtime_snode_name(snode);
   auto s = emit_struct_meta(snode);
   auto s_ptr =
-      builder->CreateBitCast(s, llvm::Type::getInt8PtrTy(*llvm_context));
+      builder->CreateBitCast(s, llvm::PointerType::getUnqual(*llvm_context));
 
-  node_ptr =
-      builder->CreateBitCast(node_ptr, llvm::Type::getInt8PtrTy(*llvm_context));
+  node_ptr = builder->CreateBitCast(
+      node_ptr, llvm::PointerType::getUnqual(*llvm_context));
 
   std::vector<llvm::Value *> func_arguments{s_ptr, node_ptr};
 
@@ -1797,8 +1797,9 @@ void TaskCodeGenLLVM::visit(SNodeLookupStmt *stmt) {
     llvm::Type *parent_ty = builder->getInt8Ty();
     if (auto bit_cast = llvm::dyn_cast<llvm::BitCastInst>(parent)) {
       parent_ty = bit_cast->getDestTy();
-      if (auto ptr_ty = llvm::dyn_cast<llvm::PointerType>(parent_ty))
-        parent_ty = ptr_ty->getPointerElementType();
+      if (auto ptr_ty = llvm::dyn_cast<llvm::PointerType>(parent_ty)) {
+        TI_NOT_IMPLEMENTED;
+      }
     }
     llvm_val[stmt] =
         builder->CreateGEP(parent_ty, parent, llvm_val[stmt->input_index]);
@@ -1840,7 +1841,7 @@ void TaskCodeGenLLVM::visit(GetChStmt *stmt) {
         stmt->output_snode->get_snode_tree_id(),
         stmt->output_snode->get_ch_from_parent_func_name(),
         builder->CreateBitCast(llvm_val[stmt->input_ptr],
-                               llvm::PointerType::getInt8PtrTy(*llvm_context)));
+                               llvm::PointerType::getUnqual(*llvm_context)));
     llvm_val[stmt] = builder->CreateBitCast(
         ch, llvm::PointerType::get(StructCompilerLLVM::get_llvm_node_type(
                                        module.get(), stmt->output_snode),
@@ -2436,7 +2437,7 @@ void TaskCodeGenLLVM::visit(AdStackAllocaStmt *stmt) {
                                    stmt->size_in_bytes());
   auto alloca = create_entry_block_alloca(type, sizeof(int64));
   llvm_val[stmt] = builder->CreateBitCast(
-      alloca, llvm::PointerType::getInt8PtrTy(*llvm_context));
+      alloca, llvm::PointerType::getUnqual(*llvm_context));
   call("stack_init", llvm_val[stmt]);
 }
 
@@ -2628,7 +2629,7 @@ llvm::Value *TaskCodeGenLLVM::get_tls_base_ptr() {
 }
 
 llvm::Type *TaskCodeGenLLVM::get_tls_buffer_type() {
-  return llvm::Type::getInt8PtrTy(*llvm_context);
+  return llvm::PointerType::getUnqual(*llvm_context);
 }
 
 std::vector<llvm::Type *> TaskCodeGenLLVM::get_xlogue_argument_types() {
@@ -2651,23 +2652,6 @@ llvm::Type *TaskCodeGenLLVM::get_mesh_xlogue_function_type() {
                                  get_mesh_xlogue_argument_types(), false);
 }
 
-llvm::PointerType *TaskCodeGenLLVM::get_integer_ptr_type(int bits) {
-  switch (bits) {
-    case 8:
-      return llvm::Type::getInt8PtrTy(*llvm_context);
-    case 16:
-      return llvm::Type::getInt16PtrTy(*llvm_context);
-    case 32:
-      return llvm::Type::getInt32PtrTy(*llvm_context);
-    case 64:
-      return llvm::Type::getInt64PtrTy(*llvm_context);
-    default:
-      break;
-  }
-  TI_ERROR("No compatible " + std::to_string(bits) + " bits integer ptr type.");
-  return nullptr;
-}
-
 llvm::IntegerType *TaskCodeGenLLVM::get_integer_type(int bits) {
   switch (bits) {
     case 8:

gstaichi/codegen/llvm/codegen_llvm.h

@@ -107,8 +107,6 @@ class TaskCodeGenLLVM : public IRVisitor, public LLVMModuleBuilder {
 
   llvm::Type *get_mesh_xlogue_function_type();
 
-  llvm::PointerType *get_integer_ptr_type(int bits);
-
   llvm::IntegerType *get_integer_type(int bits);
 
   llvm::Value *get_root(int snode_tree_id);

gstaichi/codegen/llvm/llvm_codegen_utils.cpp

@@ -29,7 +29,9 @@ bool is_same_type(llvm::Type *a, llvm::Type *b) {
     return false;
   }
   if (a->isPointerTy()) {
-    return is_same_type(a->getPointerElementType(), b->getPointerElementType());
+    auto ptr_a = llvm::cast<llvm::PointerType>(a);
+    auto ptr_b = llvm::cast<llvm::PointerType>(b);
+    return ptr_a->getAddressSpace() == ptr_b->getAddressSpace();
   }
   if (a->isFunctionTy() != b->isFunctionTy()) {
     return false;

gstaichi/codegen/llvm/struct_llvm.cpp

@@ -105,14 +105,14 @@ void StructCompilerLLVM::generate_types(SNode &snode) {
     // mutex
     aux_type = llvm::ArrayType::get(llvm::PointerType::getInt64Ty(*ctx),
                                     snode.max_num_elements());
-    body_type = llvm::ArrayType::get(llvm::PointerType::getInt8PtrTy(*ctx),
+    body_type = llvm::ArrayType::get(llvm::PointerType::getUnqual(*ctx),
                                      snode.max_num_elements());
   } else if (type == SNodeType::dynamic) {
     // mutex and n (number of elements)
     aux_type =
         llvm::StructType::get(*ctx, {llvm::PointerType::getInt32Ty(*ctx),
                                      llvm::PointerType::getInt32Ty(*ctx)});
-    body_type = llvm::PointerType::getInt8PtrTy(*ctx);
+    body_type = llvm::PointerType::getUnqual(*ctx);
   } else {
     TI_P(snode.type_name());
     TI_NOT_IMPLEMENTED;
@@ -208,9 +208,9 @@ void StructCompilerLLVM::generate_child_accessors(SNode &snode) {
     auto inp_type =
         llvm::PointerType::get(get_llvm_element_type(module.get(), parent), 0);
 
-    auto ft =
-        llvm::FunctionType::get(llvm::Type::getInt8PtrTy(*llvm_ctx_),
-                                {llvm::Type::getInt8PtrTy(*llvm_ctx_)}, false);
+    auto ft = llvm::FunctionType::get(
+        llvm::PointerType::getUnqual(*llvm_ctx_),
+        {llvm::PointerType::getUnqual(*llvm_ctx_)}, false);
 
     auto func = create_function(ft, snode.get_ch_from_parent_func_name());
 
@@ -230,7 +230,7 @@ void StructCompilerLLVM::generate_child_accessors(SNode &snode) {
                             "getch");
 
     builder.CreateRet(
-        builder.CreateBitCast(ret, llvm::Type::getInt8PtrTy(*llvm_ctx_)));
+        builder.CreateBitCast(ret, llvm::PointerType::getUnqual(*llvm_ctx_)));
   }
 
   for (auto &ch : snode.ch) {

gstaichi/rhi/cuda/cuda_context.cpp

@@ -72,8 +72,11 @@ CUDAContext::CUDAContext()
 
   compute_capability_ = cc_major * 10 + cc_minor;
 
-  if (compute_capability_ > 86) {
-    compute_capability_ = 86;
+  // from
+  // https://github.com/llvm/llvm-project/blob/llvmorg-18.1.8/clang/lib/Basic/Targets/NVPTX.cpp
+  // looks like up to 90 is ok?
+  if (compute_capability_ > 90) {
+    compute_capability_ = 90;
   }
 
   driver_.device_get_attribute(

gstaichi/runtime/amdgpu/jit_amdgpu.cpp

@@ -123,7 +123,6 @@ std::string JITSessionAMDGPU::compile_module_to_hsaco(
   builder.OptLevel = 3;
   builder.Inliner =
       llvm::createFunctionInliningPass(builder.OptLevel, 0, false);
-  machine->adjustPassManager(builder);
   builder.populateFunctionPassManager(function_pass_manager);
   builder.populateModulePassManager(module_pass_manager);
 

gstaichi/runtime/cpu/jit_cpu.cpp

@@ -32,14 +32,13 @@
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Target/TargetMachine.h"
-#include "llvm/Transforms/IPO/PassManagerBuilder.h"
 #include "llvm/Transforms/InstCombine/InstCombine.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Scalar/GVN.h"
 #include "llvm/Transforms/IPO.h"
 
 #include "llvm/MC/TargetRegistry.h"
-#include "llvm/Support/Host.h"
+#include "llvm/TargetParser/Host.h"
 
 #endif
 
@@ -192,7 +191,7 @@ class JITSessionCPU : public JITSession {
 #endif
     if (!symbol)
       TI_ERROR("Function \"{}\" not found", Name);
-    return (void *)(symbol->getAddress());
+    return symbol->getAddress().toPtr<void *>();
   }
 
   void *lookup_in_module(JITDylib *lib, const std::string Name) {
@@ -204,7 +203,7 @@ class JITSessionCPU : public JITSession {
 #endif
     if (!symbol)
       TI_ERROR("Function \"{}\" not found", Name);
-    return (void *)(symbol->getAddress());
+    return symbol->getAddress().toPtr<void *>();
   }
 };