<table border="1" cellspacing="0" cellpadding="8">
    <tr>
        <th>Issue</th>
        <td>
            <a href=https://github.com/llvm/llvm-project/issues/58652>58652</a>
        </td>
    </tr>

    <tr>
        <th>Summary</th>
        <td>
            [RISCV] Unsupported CPU type at RuntimeDyldELF::resolveRelocation
        </td>
    </tr>

    <tr>
      <th>Labels</th>
      <td>
            new issue
      </td>
    </tr>

    <tr>
      <th>Assignees</th>
      <td>
      </td>
    </tr>

    <tr>
      <th>Reporter</th>
      <td>
          dkurt
      </td>
    </tr>
</table>

<pre>
    Hi there!

I'm trying compile and run Halide project based on LLVM on `riscv64`. Specifically for Halide, there are two options: Ahead-Of-Time (AOT) and JIT. AOT works fine when I compile on x86 and use `riscv64` binaries in QEMU or T-Head C906 CPU. Unfortunately, for JIT pipeline, there is an error "Unsupported CPU type!" at `RuntimeDyldELF::resolveRelocation`: https://github.com/llvm/llvm-project/blob/de9d80c1c579e39cc658a508f1d4ba1cd792e4d5/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp#L1076 

Not sure that it might be helpful, but these are steps to reproduce:

<details>
<summary>Steps to reproduce</summary>

Application for test:

```
/opt/riscv/bin/riscv64-unknown-linux-gnu-g++ -I$HOME/halide_install_riscv64/include/ -L$HOME/halide_install_riscv64/lib/ -lHalide ./main.cpp -o app
export LD_LIBRARY_PATH=$HOME/halide_install_riscv64/lib/:$LD_LIBRARY_PATH
/opt/riscv/bin/qemu-riscv64 ./app
```

<details>
<summary>Application code</summary>

```cpp
#include "Halide.h"

using namespace Halide;

int main(int argc, char** argv) {
    Func brighter;
    Var x, y;

    Param<uint8_t> myoffset("myoffset");
    ImageParam input(type_of<uint8_t>(), 2);
    std::vector<Argument> args(2);
    args[0] = input;
    args[1] = myoffset;

    brighter(x, y) = input(x, y) * myoffset;

    brighter.bound(x, 0, 64).bound(y, 0, 64);

    Target target = get_host_target();
    std::cout << target << std::endl;

    std::vector<Target::Feature> features;
    target.set_features(features);

    brighter.print_loop_nest();

    Buffer<uint8_t> output(64, 64);
    brighter.realize(output);
}
```
 
</details>

1. Prepare toolchain
```bash
git clone --depth 1 https://github.com/riscv-collab/riscv-gnu-toolchain
./configure --prefix=/opt/riscv
sudo make linux -j$(nproc --all)
sudo make build-qemu -j$(nproc --all)
```

2. Build LLVM

<details>
<summary>riscv64.toolchain.cmake</summary>

```cmake
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR riscv64)

set(CMAKE_C_COMPILER riscv64-unknown-linux-gnu-gcc)
set(CMAKE_CXX_COMPILER riscv64-unknown-linux-gnu-g++)

set(CMAKE_SYSROOT /opt/riscv/sysroot CACHE PATH "RISC-V sysroot")

set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT})
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

find_program(QEMU_RISCV64 qemu-riscv64)
if (QEMU_RISCV64)
    set(CMAKE_CROSSCOMPILING_EMULATOR ${QEMU_RISCV64})
endif ()
```

</details>

```bash
git clone --depth 1 --branch llvmorg-15.0.2 https://github.com/llvm/llvm-project.git

export PATH=/opt/riscv/bin:$PATH

cmake -DCMAKE_BUILD_TYPE=Release \
      -DCMAKE_TOOLCHAIN_FILE=$(realpath riscv64.toolchain.cmake) \
      -DLLVM_ENABLE_PROJECTS="clang;lld;clang-tools-extra" \
      -DLLVM_TARGETS_TO_BUILD="RISCV" \
      -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_ASSERTIONS=ON \
      -DLLVM_ENABLE_EH=ON -DLLVM_ENABLE_RTTI=ON -DLLVM_BUILD_32_BITS=OFF \
      -S llvm-project/llvm -B llvm-build

cmake --build llvm-build -j$(nproc --all)
cmake --install llvm-build --prefix llvm-install
```

3. Clone Halide (use custom branch as recommended in https://github.com/halide/Halide/issues/7070)

```bash
git clone --depth 1 -b riscv_update https://github.com/halide/Halide
```

5. Apply Halide patch (see discussion at https://github.com/halide/Halide/pull/7073)

<details>
<summary>patch</summary>

```patch
index cc9f6805b..9b3c25751 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -541,7 +541,7 @@ endif ()
 
 if (BUILD_SHARED_LIBS)
     message(STATUS "Building autoschedulers enabled")
-    add_subdirectory(autoschedulers)
+    # add_subdirectory(autoschedulers)
 else ()
     message(STATUS "Building autoschedulers disabled (static Halide)")
 endif ()
diff --git a/src/runtime/CMakeLists.txt b/src/runtime/CMakeLists.txt
index b4888c82e..a1ae1e205 100644
--- a/src/runtime/CMakeLists.txt
+++ b/src/runtime/CMakeLists.txt
@@ -243,14 +243,14 @@ foreach (i IN LISTS RUNTIME_CPP)
                 target_compile_definitions(${basename} PRIVATE ${RUNTIME_DEFINES})
             else()
                 add_custom_command(OUTPUT "${LL}"
-                                   COMMAND ${CMAKE_C_COMPILER_LAUNCHER} $<TARGET_FILE:clang> ${clang_flags} -o "${LL}" "$<SHELL_PATH:${SOURCE}>"
+                                   COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} ${CMAKE_C_COMPILER_LAUNCHER} $<TARGET_FILE:clang> ${clang_flags} -o "${LL}" "$<SHELL_PATH:${SOURCE}>"
                                    DEPENDS "${SOURCE}"
                                    DEPFILE "${basename}.d"
                                    VERBATIM)
             endif()
 
             add_custom_command(OUTPUT "${BC}"
-                               COMMAND llvm-as "${LL}" -o "${BC}"
+                               COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:llvm-as> "${LL}" -o "${BC}"
                                DEPENDS "${LL}"
                                VERBATIM)
 
@@ -294,7 +294,7 @@ foreach (i IN LISTS RUNTIME_LL)
     endif ()
 
     add_custom_command(OUTPUT "${BC}"
-                       COMMAND llvm-as "${LL_TRANSFORMED}" -o "${BC}"
+                       COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:llvm-as> "${LL_TRANSFORMED}" -o "${BC}"
                        DEPENDS "${LL_TRANSFORMED}"
                        VERBATIM)
     add_custom_command(OUTPUT "${INITMOD}"
```

</details>

5. Build Halide

```bash
export PATH=/opt/riscv/bin:$PATH

cmake -DLLVM_DIR=$(realpath llvm-install/lib/cmake/llvm) \
      -DClang_DIR=$(realpath llvm-install/lib/cmake/clang) \
      -DCMAKE_BUILD_TYPE=Release \
      -DZLIB_INCLUDE_DIR=/usr/include \
      -DZLIB_LIBRARY=/usr/lib/riscv64-linux-gnu/libz.so \
      -DCMAKE_TOOLCHAIN_FILE=$(realpath riscv64.toolchain.cmake) \
      -DWITH_TESTS=OFF \
      -DWITH_TUTORIALS=OFF \
      -DWITH_PYTHON_BINDINGS=OFF \
      -S Halide -B halide-build

cmake --build halide-build -j$(nproc --all)
cmake --install halide-build --prefix halide-install
```

</details>

So my main question if LLVM supports RISC-V JIT at this moment (is that OK to use 15.0.2 or need switch to the main branch).

Also, I've tried add `-DLLVM_TARGET_ARCH="riscv64"` which is [mentioned](https://github.com/llvm/llvm-project/blob/c3e073bcbdc523b0f758d44a89a6333e38bff863/llvm/docs/CMake.rst) as required for JIT, However, the error is the same.
</pre>
<img width="1px" height="1px" alt="" src="http://email.email.llvm.org/o/eJzNGtmWqkjya6yXPHAUXPChHhDxarfbCN7pOy8cllTpi2CTUFX2109EJiKoZWn3zJzxWBYksWdkLJl4SXB8HYck29GUNpRWozlsNHXxO2kovT3J0mMYb4mf7A9hRIkbByTNYzJ2ozCg5JAmv1M_I57LaECSmEyn32f4v9FtpiHz37ptuJKJdaB-uAl9N4qOZJOkBX5DMQRr4sJf9p6Q5JCFScwaqk70HXUDabGR7HBPSUPR9IXdUPpchF8mtkzgnrwn6U9GNmFMyfuOxmRSSgpCfGhdDp0zWheIeGHspiFlJIzJP8zZmoBItjQGhsToN7vEWK5lso5B0iyP3YxGRxQVBQfO5BAeaAQsz-KHDBgRmqYA0VCUdczywwGQwShAimTHA7euohA3Q1FWeZyBVsNjFJjTEWgL35SyJHqjKxolvotWADi0wy7LDmiQhjKC7zbMdrkng5ZwE0Vvp39SMRVw60WJB_8C2g-0pt_yO70-Vfu-3-1obqepbVpB23NbftDrK7QddCp0QsQzP6ifI38z3nIlRxVp63cgu-wfDg1FnbaavS6pus88yQjLcVp3oHOYkX243YGnULKj0WGTR2g9L8_Qgkw4AMvogZEsISkFbYLcp6h2hWZDNQKauWEE9jDLIZbv9256hCHrBgEDRD5DVKnph0MUClPzqc0oyy4ZwhSIr7hVRuCg8MtdCU0dxqe7blvK459x8h5L4Bv5h7SNc2nbUAbwJRIspvZ4MTMBesdd3wljlsFycE5eqYzC2I9yXBQjIk0fgBfTRaSoWIwy3O3dMMYpIVJCXJgZLjb9QF8k06EznQxW-uqHs9TtcUMdPsyEu1_7ksA9m_xB97lUkOGSldJc2vShma3OlZ8Ed-e1ZOCXLBW1MC6uTmEueQeXVbScYaCL3T1lB9enpxClDqpAYQyO7KKGGl666dZHP_Z3btpQgI-OQ28Yphq9ApHAZ5THPvFSXAE0LUnik-9uSj6QxPGCEz5cuqm7B1Vz4KU54Jwm2R-TzYZRMLgG8p_vFOBZIzzZu1vKCUCQO-SIgGHISTY1gpxOHwW4osCyQESmN4grCYht6Ok239OYCwJ6MkC-wuLjnUGz0RkScLGC-Q2I1gmiVOLaAKXJFK0wElq2pFobBds_QEn2kjwOTphN_EE_75fjx_r4DVI2KEAhbol_KA38d3YJyxwxVtj0pi39JEccA75nCvyuBKFxEN1gez0dQhAxOKJuBtEWZ2YjLllNAMFLBuM45XNFO1_eUrS02SEFf3GiJDk4MQbJun5nhEG-2aB_Vx0W9BVThea8NGqNS0phxf0J8U874VR49IY3o8cp5fBwcBVB-G9LJkvIB7zCSJIIlios3zotKF92YgjSK_GjBMoJSQroIduR1r0EzAOc5CdR5HrlLQb-C04YAP0k3oRbzIgSJGu6CT94BK5FTw7M8iCBIPOTEp5IiPQ7xF6wSgw5zQdkCNBomgtYLw-jQMKwexfhZvRVZJg6QOfl2zNhuQjwcqmu7KMwj0VnDim04GvGmOm_mo71w7LNmTPXZyaZov5nXa-hlquFYVrWYkXKjNWvMquiGI6xmC0nU7MEvpWwff8mP-O33x5CF_n-jhQg-GoBhetV2mRHliZQMxm6MTYJ5lfMVauJZUjfSfGwCPOfkB5N5kMHiTsFdhtyUI0rrqJb2tUxndliaKJpv630GZmb383Vw1hFfUAW8-mPh5Emc2O6HprPIS1141f92wWS-IV2IHDA97eYPRUNC3wHDfkdSpFqXVKihRtyAVc-4pG36girhWUJT5jMvzmAMtVt8D9h7RqJirEhpAse99fhvTD2YLCSJC91Y39HsKZP0q3U6shNWXmyi5ABoMq8qCDLsvFGyccrxEpZyH_5GifSUNhusJ5ACWn_WJpABPoc6mJj1jHOliYlrL1YTI2xPpnD5E9NUauC_TBHHFzQ9LPIg5XAJUWMao451wdT7ta_mIZtcYqKH7nxFpJMBJ2NOuB3PHQziX5kqYsN221qtr76ZtoWiCm0EuT4zH-OVIhgm6vZZD5aAM5iNLp4qFuWubInizlKuJjfp2SOBVB9dGXbk9q4sLuqOIMJVxy5XtK1yEUXibdEGohhnlxuTKx4UIG5m3tOSEWXUUMrUqIYKwDurBRVJgb3_KL3AY7Y5fs5y5I9KZaAy6ARBB-HkjWAThx6_TurYFfsSIxOWxOjkLEcS6NRr9lrXoSYR1ejJxzVyQ-Bm9Fn-H-ue0cm2A4dy00YNwNlwQKMUhIAu5wx7JOg7X5K30OOc4XaqpfaflEGcAkeSvoCsmilAvpBfL-_6WrNjifLfU_1lU6v0yKtZrPbbgswSZKIi4RTyMwjYwYuNA1ZxuTs4xSiipw7IN59uHYTvkTqtFtQifbAYoPyUjy6DtNFfUnEsFhI1lhfmbwVtmppgkDnyKDpAkDL1u21hQmc11XYWLp5ljB_R4M8oikDVq4X0aCa0SXeHAWBw3IvCFNe5UM3otUxz1MDCsMHetsnkAiNGK1r-Kzk4GFcdO5xGbTkfrmb16-qc8OacL-B1YEr5TylqdhPupq0ymx-BlJ1JK-taZqvKVSW3ZZLW1Rpdu440n2St1zqC4zCuZQ2LB6j1UbvOl-Lh5sE0pdYqiGZzMl0YtkWWa3n9mQGlcVyWZ-U6ke0b06xuekEECvjUGyVon2x9sA9WNy9gLqDLFeT77ptFlXJicPQhELKtKqFSY0J-saVa1Q_6GcixKIke5c3zIu1vVxjQasIbtMpZ6BUnPqLD5RTM30-rFWs52rdmerrOdTEK1QMQaDx5dm3qAz0IomftOW3ziZytwwxpORatNOIalhjczottsN0AWQt1ivDREDcHVFqi-2vKHK7YDwp83-q7wPKkqG5NOdD68zuTOlJMqjYmUzFkeXgKVLQqQx0cPVP3Bvj0a3gXv085OID4xkXP3kFL22gJrmenuqc1Wl_7Xd_wecuHaoQTLjU47J9NRtX_lGPDF-hX0_mRaTtt09pvLx8JM6CFDX3-Dzp_4f94Y4fOPZKn1ujxWpmDv-GT_zXfOEp-Z7wh2u690ncXuAPzdFkPrFnixqXp3vwzmmfrFajf9YQ_N2mmfduw8nquvmtNUmnM5qi_y3a-RttsMETxfMERb65SfGJtv5fUC-fdnpKIUY5S88nX58gFXtKVQQh4Gkfrtx_E0_-lFnyv9hW-OfEHkMzb33aUxcQa1huE316H2r5wx4v5tChz4ewTD_v0oueDxpz0cB91ZpXoZ5qzuuIp_a8GP26Qb-3jKyE7I_8GI38AR02P9SDEMzfHSgOzhkpdj7xvN3FQ-KQkX2Ch088rDNxrLz4FU97sfMvtrmSlMQUehP2HmJTDA-zHRWsxKYAHvVUZdEjluC5BL7t8EZJloaADQEFT-lrez2OvjLEOlbK7UMF3yV434XACSRqdAYoH2gDfV0HALW_enTvqxSacM_3Ar-jqF5z0-toQbvtan23q6oqVTVvs9G66plOkPjs1JnIKR7R9MX2xx85NIXB6dUF1HScvNM3PFLjLy8ULy1wg1LCoOySX-hrq9vtaprSV_ovwasa9NW--5KFWURfQUmxy9UZkluvOeBkPfR2w0ueRq9PG6jck-lo3Y7ysnvdeF6Put2e6_W0TivQNsqmqQZUa_Wopqgb7yVyPehrUG6Yr5i-E04C564zfAlflaaitJpKr9VpKs2-rPaCoKUFPSXQ2i212YVygoL3RDLKISfp9iV9LbatoNxuNyPeBZYPXcbCLTggZwf0oXXeJelr8DNPsxfO-JUL_m9tA_dB">