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

    <tr>
        <th>Summary</th>
        <td>
            How do I embed lld into a project (WINDOWS MSVC SPECIFIC)? (Cmake) (lld)
        </td>
    </tr>

    <tr>
      <th>Labels</th>
      <td>
      </td>
    </tr>

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

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

<pre>
    I have been trying for days now. I want to break the legs of whoever made Cmake. I am completely and utterly frustrated by the lack of documentation (for lld). I can also only test by making a git commit, pushing, and then waiting 10+ minutes for results.

A single line test takes 10+ minutes for me. I cannot stand it anymore and I need help figuring this out.


# Actual info on the problem.

I am trying to embed lld and llvm into a project. I am not at familiar with CMake and have just been throwing ideas around and seeing what works (so far nothing). I also know nothing about MSVC and I have less than the most basic amount of knowledge of gcc, clang, etc. The entire building process for C/Cpp is completely foreign to me. I just want to commit to a project that I actively use (llvmlite). On linux, I succeeded, but it also needs to work on windows before the PR can be accepted.

Btw, the Cmake isn't used on linux but when I manually ran it (instead of thru a build.py file), it appeared to work perfectly normally. This ofc is after I made changes to include lld, those changes aren't shown here.

**llvm-Version:** should be llvm11.1.0

## Code, Links, and Errors
Original CMake (before I probably made some nonsense changes to it)
```cmake
cmake_minimum_required(VERSION 2.8.8)

# This will define the name of the solution file in the build directory
project(llvmlite_ffi)

include(CheckIncludeFiles)

if(NOT MSVC)
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-rtti -g")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti -g")
endif()

find_package(LLVM REQUIRED CONFIG)

message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")

# Set your project compile flags.
# E.g. if using the C++ header files
# you will need to enable C++11 support
# for your compiler.

include_directories(${LLVM_INCLUDE_DIRS})
add_definitions(${LLVM_DEFINITIONS})

# Look for SVML
set(CMAKE_REQUIRED_INCLUDES ${LLVM_INCLUDE_DIRS})

CHECK_INCLUDE_FILES("llvm/IR/SVML.inc" HAVE_SVML)
if(HAVE_SVML)
    message(STATUS "SVML found")
 add_definitions(-DHAVE_SVML)
else()
    message(STATUS "SVML not found")
endif()


# Define our shared library
add_library(llvmlite SHARED assembly.cpp bitcode.cpp core.cpp initfini.cpp
            module.cpp value.cpp executionengine.cpp transforms.cpp
            passmanagers.cpp targets.cpp dylib.cpp linker.cpp object_file.cpp
            custom_passes.cpp)

# Find the libraries that correspond to the LLVM components
# that we wish to use.
# The following line is broken with LLVM 10.0.0 due to a potential bug in
# the LLVM cmake setup, so we use the workaround instead.
# Bug reported upstream at: https://bugs.llvm.org/show_bug.cgi?id=47003
# BROKEN: llvm_map_components_to_libnames(llvm_libs all)
if ($ENV{LLVMLITE_SHARED})
    set(llvm_libs LLVM)
else()
 set(llvm_libs ${LLVM_AVAILABLE_LIBS})
endif()

# Since LLVM 8 "OptRemarks" is built as a shared library only and also appears
# under the llvm_libs for the "all" components map. This breaks static linking
# so the "OptRemarks" library is removed from this list.
list(REMOVE_ITEM llvm_libs "OptRemarks")

# Link against LLVM libraries
target_link_libraries(llvmlite ${llvm_libs})
# -flto and --exclude-libs allow us to remove those parts of LLVM we don't use
if(${CMAKE_SYSTEM_NAME} MATCHES "Linux" OR ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
    set_property(TARGET llvmlite APPEND_STRING PROPERTY LINK_FLAGS "-flto -Wl,--exclude-libs,ALL")
# On Darwin we only include the LLVMPY symbols we require and exclude
# everything else.
elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 set(LLVM_EXPORTED_SYMBOLS "-Wl,-exported_symbol,_LLVMPY_*")
 set_property(TARGET llvmlite APPEND_STRING PROPERTY LINK_FLAGS "${LLVM_EXPORTED_SYMBOLS}")
endif()
```

Error:
```
lld.obj : error LNK2019: unresolved external symbol "bool __cdecl lld::elf::link(class llvm::ArrayRef<char const *>,bool,class llvm::raw_ostream &,class llvm::raw_ostream &)" (?link@elf@lld@@YA_NV?$ArrayRef@PEBD@llvm@@_NAEAVraw_ostream@4@2@Z) referenced in function lld_main [D:\a\1\s\ffi\build\llvmlite.vcxproj]
D:\a\1\s\ffi\build\Release\llvmlite.dll : fatal error LNK1120: 1 unresolved externals [D:\a\1\s\ffi\build\llvmlite.vcxproj]
```

lld.cpp:
```cpp
// this code could be awful. Idk, I don't write cpp. 
// My PR was originally based on another 5yr old PR from someone much smarter
#include "core.h"
#include "lld/Common/Driver.h"
#include "llvm/Support/raw_ostream.h"

extern "C" {

bool lld_main(int Argc, const char **Argv, const char **outstr) {
    //InitLLVM X(Argc, Argv);
    std::string command_output;
    llvm::raw_string_ostream command_stream(command_output);
    std::vector<const char *> Args(Argv, Argv + Argc);

    #if defined __linux__ || __unix__
        bool linker_output = !lld::elf::link(Args, false, command_stream, command_stream);
    #elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
        bool linker_output = !lld::coff::link(Args, false, command_stream, command_stream);
    #else
        bool linker_output = !lld::macho::link(Args, false, command_stream, command_stream);
    #endif

    *outstr = LLVMPY_CreateString(command_output.c_str());

    return linker_output;
}

} // end extern "C"
```

Link to more files (if needed): https://github.com/numba/llvmlite/tree/main/ffi

</pre>
<img width="1px" height="1px" alt="" src="http://email.email.llvm.org/o/eJy0WV9z4rqS_zTKS1coY0JCHvJADMxQQ_4s5OTM7ItL2G3QQZa8khyGb7_Vkg0myczOrbt3KsUYudX69f9uwa0VG4V4x4b3bDi54LXbanNnK5GjcQeJJo6i4cVa54e7OWz5G8IaUYEzB6E2UGgDOT9YUHrfgznsuXLgNKwN8h24LYLEjQVdwH6r8Q0NlDxHSEq-Q6LnJWS6rCQ6lAfgKofaOTTyAIWprTPcYQ7rQ-DEsx1xynVWl6gcd0IrYPGIQEiZs_iWWGZcAZdWg1byAA6tIwYl3xFeDhvh6MhSOBYnUNV2K9SGHulwt0UFey4c0fYjFt9DKVTt0HpJDdpaOttj0YRF4_A5BivURiJIoTAc5_gO7SfbS2zwKe3AOjpQOODqUGqD_vw5KMQctigrKMSmNoTDbYUFXbuzY5vPeADjzNVcglAFiew1VRm9lliebfC6bqzmNGC5xpy05s-V8q0EoZwGTpv_wcw11iGo3EHBSyEFN7AXbgvJA98FwN4h_qlJx94rtkbv6QSRI7fAja5VOMEi0vp-yx3stdlZMpzVUHBDZwQjePt52-2U3rfrwNe6dvCwek0aJflTJVoLbsuDyKUmDNyKDHipa-XIU4iLxHyD9GWTZWTmTPJgb3RZD162CKicMAjrWsicjquMzog3mSxh8SypKhC266eFNig2ivQYbOo10Pp-8C7oKpNwOpItc-KNONQWSQGkdykcetGfFPlQ_ZPAzcHWWYaYY05f17XzrkKqIQ-xxJ3USBbfC5XrvYU1Ei6vjeelD4M1As8yrBzmZ75w7_bElSh9JIKwisU3jmDlxNLj8KfuKSLmUHJVcykPYLgiJCweCWUd8pxU67amBh402KsOUAhJItEZhLqqkBvMj5grNAVmTh5AaVMSWzIEOXmRkaZ54dD4Q3OEbMvVBr3AQmWyzjHEOsHX9vSeGwwy2K3eK9iiwfOAiemPFH75isYKrdigWaQttcxJXfS-3-_1e9G7MKNIS3SOdPBCqJ1tU8bUGG1soHsyYiMUl02AsHjU2GTuQ5Kv5SEIZXWJoLSyqOy5iI70Fg69jsJfRiYKa_4xLYUSZV2mBv-nFoY8ZPQ6Xa7mT48Q90a90YnFMUl49e6FlJBj4RPVFkHxEoP5CJGsfT4l24EIQeUNCrkwmDltDoFd49Id702LQrw7szEVi0fJFrPdPHydCYn2PWXB4tHj04uP7-M7AIt0RPIw_jZNk3S2GH9ZAYtjFl-xm_uzZXYzgctC6UvjnIDLjadq-Zyx-f79F4zaF79jhSr3WN_hL4TK04pnO74hcReL1wdYTv_rr_lyOoHk6XE2__JuR4nWBuLVy_jlL49m5hOl3xyA0WP6PE6-jb9M08a67GbSBfQZn7-oGHk-iVaF2PSyEN_k7F3Ok_nyHbeTr6zQwUHX5pi8KPORVxSSb47FLx7AtLfpgSigtqFMIaXLe6p6W-Q5Gu9L9kR_0HXwQV_kqAgpvpbHXf0-2LqqtHGnLZSDPZYGg-l94mVp66GCvGvUEXP-mCz-mkxJ3JWXtxGW53nqA0GQz7_bNJnO5o_zl_nT49meE6iF1juPbPX6sAjLXTdrrd-evoI_QBQ-k6_T5NuRZjZfTFceW0yhxuLZfMniGZ3aEypjcQxfx6_T1MNoGXkf_bgMAPCZwxARFOR9Z2HzUUGXk49MUVrsRsRvD6FO4sNBvwiqk64nIV2RC9itryJSrA1vkxHhbBdOCQlWX8cUftxaLNfy0MuqCtbCZTpH_5xpEx5IQJKSvpxkaP-VOq9lIHzjsg5P-BMznypRbYQKa85wZQttSvs5o4pbW3LFN2hs2MDNBl14zg9SrP2TFGqHxj_qNYVeShH0Ocustk6XKXHGcOpHR52J0NM2OhNoQyOSaWPQVlr5KCQCn3koxkgs14lZT79H2Au7JeLaYq9bVhAKLWVo-nwHLCysjd5RH02tomfcj3pRL4K8xqYr0o6aLi5hXW8oOXWOa7H4vGXR1RVVWqsJBHVNREFdRNNbNl1IB9N9vQGDlEYwh7qyziAvgTvKgFvnKuvr_ozFs3W9sT3ymZ42GxbPqHNI1_Wml20EG8xEzgaTq5soGnSYL5--TR-JFe1LS16lJ62lTpMzUlm1jTfSdwtcyk58Qkg308fXJiks5i_TNLhsNyWQlUNeOXEi8l-H33vqTt4Zv47ni_H9Ypou5vdnmedXIUiVQKissceI4vipckssuaHuJ_aWroV0QJ3-u-gMwxf1R75nDS1gx61qRfXBu-YRLWVUWmFx7BUWdxwSSl41TaIfLS3NT05kPmRodjhytrplco62BSYsGCz1G-ZQGF2G6UoK245X9Mji0XL68PQ6Tecv0wfoKvSc62fFQagd8A0nxwyqOwZfIAqhnxLw9PSqk7yC1Y6HnlWJeACXhaQgUjlcXuJPXwAvWy_Te6h9HxlEbFrkihvnZ3APZ4-Q62O73yka3Y5o9WP1Mn1IH8cPU-qJHsYvyVdfyOJFGFFieFrCn-2YGcT71Vmz0bh2WhldoXGUu1_Gyy_TFzhqYfz8PH2cpKuX5fzxCzwvn56ny5cfsJg_fjs1cUEXl39LFifn2mBxMl4szkwUD2jEmnCzF4q04F20nSnaxPP8A-yhXGtpiaTpsL22G-4nZviG5hAmVIrE3iko_wV1BjiftKw-aqffn5-WL9NJuvrxcP-0CDIHafFnSHFpgMviJA34Uz_UnPP7txXdySTvMb3rIz-mk3aO6UaKn5ooEX9GImXe0-t_gNIsEiEsHr_FUf-WFmpl0GpJ8Ys_HRoat4IKCOdaawlpmuWYST8nDsZsMEZZhAcKOhaPMsmt9RoIy2Nj-GGJBRsk2ZZTs0nBS3ocTFmcEFMWJ-93Gb5PdVNeWHz9JxS3FDiknMHMQ7mKCNpVREivInYV_Rinj69sMGPx1RHUVfQ8vZ94qrcykKWP4-n4tcOeXUVX7CqK2VX03yy-BYMFGlQZUoWEolaZH-6kzNOSCwVseD8hjMOEs2HSZ8PEsmFCc9ww8VMfGyath_Tesp80CrDhJNjn_9y5RIncYpdHLqW3Z8Edlyer9vtxRMv9z-xq_z2Ynzoe-RY1Sx9c79hkhd4g1AVqGCFrLwf4vqhlD-b5LlzRtGl0byiOsqrqwRmLhwM8L2HPLejmYkAeYM2bOxautNuigeHBgJY5kfqCZHWJWiGUdbYFW3Lj0ByTTpuuWBz7HnZLoffJS39FMkt0WRLG2cSINzS_ofbTxaqZvuJZx7O6m0KAe-vQtsR78819960PwNbN_C2Rg7HZhKs3H1Y-wsLFy9hs3j59oWtnnSFHPrKnkhH0OlfC-Ur2ncWjlndgdcsGHXLrmvi3zl-kZrosucpTXbuqdmek5zEb6I-h2-5rQi0evWP0q2Pf_FBKSeVcvsGU4NqA_q1FDzQ4B3FO_LqyD0TR3N7kkKb-ii5Ngd0k7CaBNK2V-Jmm54NCsIafKhqwwAYTYHH_l7kxIEug4L67TD5I_3HlXHwWD1CeoLJ49Pf8cRAHY3qspzfpb16Fd2l61jT8oVCZLv4TUrXt0r-ApOTZVv__Q_FF9oOHNHHjQTTNQGKQO1x5h_7gub0s9WHmi_WnXmfQ1Uady3giu5mcdb83kyZCAVWbxds88ZuU7Dtmp8H_CuKvjPz1cuGvicgXbj-ObhvhtvW6l2nKW6ou15zFs9Nt-swZpP9CEppRwfBHXeR3g_x2cMsv8K5_fTMY3kbD69HF9q4f8cGA3-T8lo-i2z6_yvIo68drjDheD6ObC3EXR_Eg6vcH0XX_Ohr1htfrPIp5fn01KG5urqn6YsmFPA6UF8LaGu-Gt7ej4YXka5S2_ZHN3Pl7aJo_qawL605z6IUTTuLdV72HXMO880PN-e8zEAJr8vT3Kvw0snqeJvPZ3N-hDmb02t_t--Ci6YIUeVEbefcbTTaFwKM73vPOvCCWxTMvy_8GAAD__3wFtB0">