Fix lld macho standalone build by including llvm/Config/llvm-config.h instead of llvm/Config/config.h

[mceier]

Summary

lld/MachO/Driver.cpp and lld/MachO/SyntheticSections.cpp include llvm/Config/config.h which doesn't exist when building standalone lld.

This patch replaces llvm/Config/config.h include with llvm/Config/llvm-config.h just like it is in lld/ELF/Driver.cpp and HAVE_LIBXAR with LLVM_HAVE_LIXAR and moves LLVM_HAVE_LIBXAR from config.h to llvm-config.h

Also it adds LLVM_HAVE_LIBXAR to LLVMConfig.cmake and links liblldMachO2.so with XAR_LIB if LLVM_HAVE_LIBXAR is set.

[int3]

Thanks!

[thakis]

Wait, this isn't right, is it? We need this for #ifndef HAVE_LIBXAR and HAVE_LIBXAR is in config.h but not in llvm-config.h. This will silently break HAVE_LIBXAR checks.

[thakis]

(ie you'll have to move HAVE_LIBXAR from config.h to llvm-config.h too)

[mceier]

In D102084#2745000, @thakis wrote:

Wait, this isn't right, is it? We need this for #ifndef HAVE_LIBXAR and HAVE_LIBXAR is in config.h but not in llvm-config.h. This will silently break HAVE_LIBXAR checks.

I think you're right, though I have no idea how to move HAVE_LIBXAR correctly - I doubt that just moving it from include/llvm/Config/config.h.cmake to include/llvm/Config/llvm-config.h.cmake is a good idea.

llvm-config.h seems to create defines with LLVM_ prefix only.

[mceier]

Moved HAVE_LIBXAR from config.h to llvm-config.h

[thakis]

Lgtm assuming you checked that the XAR ifdefs in the two files you're changing still work (with a temporary local #error in the right place or similar)

llvm/include/llvm/Config/llvm-config.h.cmake

97

Maybe fix the missing word in the comment while here :)

[mceier]

Added missing word in a comment for HAVE_LIBXAR define

[mceier]

Verified that standalone lld builds with HAVE_LIBXAR set and unset.
Added HAVE_LIBXAR to LLVMConfig.cmake and linking liblldMachO2.so with XAR_LIB if HAVE_LIBXAR is set.

[thakis]

Looks great. Do you need me to land this for you, or can you commit yourself?

[mceier]

In D102084#2747801, @thakis wrote:

Looks great. Do you need me to land this for you, or can you commit yourself?

I don't have commit rights, so I need you to land this for me, if everything looks good to you ;)

[thakis]

Sorry about the delay here.

llvm/cmake/modules/LLVMConfig.cmake.in

114

While patching this in locally to land, I noticed that this doesn't have the trailing @ that all other lines in this file have. Are you sure this does the right thing as-is?

Also, everything in this file and almost everything in llvm-config.h starts with LLVM_ which makes sense if the purpose of this file is to include it in external codebases. Maybe we should add an LLVM_ prefix to this and the other symbol in this change? (But not sure about this part.)

[mceier]

In D102084#2759574, @thakis wrote:

Sorry about the delay here.

No problem ;)

llvm/cmake/modules/LLVMConfig.cmake.in

114

While patching this in locally to land, I noticed that this doesn't have the trailing @ that all other lines in this file have. Are you sure this does the right thing as-is?

Hmm; it probably is not right - if(HAVE_LIBXAR) will always be true in this case and always link with xar, so I missed one case when xar is not available on the system when testing.

Maybe we should add an LLVM_ prefix to this and the other symbol in this change?

Ok, I can add the prefix.

Will send patches soon. Thanks for the review ;)

[mceier]

Added LLVM_ prefix to all occurrences of HAVE_LIBXAR; fixed one missing char.

lld/CMakeLists.txt

if(LLVM_LIT)
       # On Win32 hosts, provide an option to specify the path to the GnuWin32 tools.
       if(WIN32 AND NOT CYGWIN)
         set(LLVM_LIT_TOOLS_DIR "" CACHE PATH "Path to GnuWin32 tools")
       endif()
     else()
       set(LLVM_INCLUDE_TESTS OFF)
     endif()
   endif()
+
+  if(LLVM_HAVE_LIBXAR)
+    set(XAR_LIB xar)
+  endif()
 endif()
 
 set(LLD_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(LLD_INCLUDE_DIR ${LLD_SOURCE_DIR}/include )
 set(LLD_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 
 set(LLD_VENDOR ${PACKAGE_VENDOR} CACHE STRING
   "Vendor-specific text for showing with version information.")

lld/MachO/CMakeLists.txt

add_lld_library(lldMachO2
   Option
   Passes
   Support
   TextAPI
 
   LINK_LIBS
   lldCommon
   ${LLVM_PTHREAD_LIB}
+  ${XAR_LIB}
 
   DEPENDS
   MachOOptionsTableGen
   ${tablegen_deps}
   )

lld/MachO/Driver.cpp

 #include "lld/Common/Memory.h"
 #include "lld/Common/Reproduce.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/BinaryFormat/Magic.h"
-#include "llvm/Config/config.h"
+#include "llvm/Config/llvm-config.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Parallel.h"
bool macho::link(ArrayRef<const char *> argsArr, bool canExitEarly,
   config->emitBitcodeBundle = args.hasArg(OPT_bitcode_bundle);
 
   std::array<PlatformKind, 3> encryptablePlatforms{
       PlatformKind::iOS, PlatformKind::watchOS, PlatformKind::tvOS};
   config->emitEncryptionInfo =
       args.hasFlag(OPT_encryptable, OPT_no_encryption,
                    is_contained(encryptablePlatforms, config->platform()));
 
-#ifndef HAVE_LIBXAR
+#ifndef LLVM_HAVE_LIBXAR
   if (config->emitBitcodeBundle)
     error("-bitcode_bundle unsupported because LLD wasn't built with libxar");
 #endif
 
   if (const Arg *arg = args.getLastArg(OPT_install_name)) {
     if (config->outputType != MH_DYLIB)
       warn(arg->getAsString(args) + ": ignored, only has effect with -dylib");
     else

lld/MachO/SyntheticSections.cpp

 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Writer.h"
 
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/Config/config.h"
+#include "llvm/Config/llvm-config.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SHA256.h"
 
 #if defined(__APPLE__)
 #include <sys/mman.h>
 #endif
 
-#ifdef HAVE_LIBXAR
+#ifdef LLVM_HAVE_LIBXAR
 #include <fcntl.h>
 #include <xar/xar.h>
 #endif
 
 using namespace llvm;
 using namespace llvm::MachO;
 using namespace llvm::support;
 using namespace llvm::support::endian;
#define CHECK_EC(exp)                                                          \
   do {                                                                         \
     ErrorCodeWrapper ec(exp);                                                  \
     if (ec)                                                                    \
       fatal(Twine("operation failed with error code ") + Twine(ec) + ": " +    \
             #exp);                                                             \
   } while (0);
 
 void BitcodeBundleSection::finalize() {
-#ifdef HAVE_LIBXAR
+#ifdef LLVM_HAVE_LIBXAR
   using namespace llvm::sys::fs;
   CHECK_EC(createTemporaryFile("bitcode-bundle", "xar", xarPath));
 
   xar_t xar(xar_open(xarPath.data(), O_RDWR));
   if (!xar)
     fatal("failed to open XAR temporary file at " + xarPath);
   CHECK_EC(xar_opt_set(xar, XAR_OPT_COMPRESSION, XAR_OPT_VAL_NONE));
   // FIXME: add more data to XAR
   CHECK_EC(xar_close(xar));
 
   file_size(xarPath, xarSize);
-#endif // defined(HAVE_LIBXAR)
+#endif // defined(LLVM_HAVE_LIBXAR)
 }
 
 void BitcodeBundleSection::writeTo(uint8_t *buf) const {
   using namespace llvm::sys::fs;
   file_t handle =
       CHECK(openNativeFile(xarPath, CD_OpenExisting, FA_Read, OF_None),
             "failed to open XAR file");
   std::error_code ec;

lld/test/CMakeLists.txt

 if (CMAKE_CFG_INTDIR STREQUAL ".")
   set(LLVM_BUILD_MODE ".")
 else ()
   set(LLVM_BUILD_MODE "%(build_mode)s")
 endif ()
 
 string(REPLACE "${CMAKE_CFG_INTDIR}" "${LLVM_BUILD_MODE}" LLD_LIBS_DIR "${LLVM_LIBRARY_OUTPUT_INTDIR}")
 string(REPLACE "${CMAKE_CFG_INTDIR}" "${LLVM_BUILD_MODE}" LLD_TOOLS_DIR "${LLVM_RUNTIME_OUTPUT_INTDIR}")
 
 llvm_canonicalize_cmake_booleans(
   LLVM_ENABLE_ZLIB
   LLVM_ENABLE_LIBXML2
   LLD_DEFAULT_LD_LLD_IS_MINGW
-  HAVE_LIBXAR
+  LLVM_HAVE_LIBXAR
   )
 
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
   ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py
   MAIN_CONFIG
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.cfg.py
   )

lld/test/lit.site.cfg.py.in

 config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
 config.errc_messages = "@LLVM_LIT_ERRC_MESSAGES@"
 config.lld_obj_root = "@LLD_BINARY_DIR@"
 config.lld_libs_dir = "@LLD_LIBS_DIR@"
 config.lld_tools_dir = "@LLD_TOOLS_DIR@"
 config.target_triple = "@TARGET_TRIPLE@"
 config.python_executable = "@Python3_EXECUTABLE@"
 config.have_zlib = @LLVM_ENABLE_ZLIB@
-config.have_libxar = @HAVE_LIBXAR@
+config.have_libxar = @LLVM_HAVE_LIBXAR@
 config.have_libxml2 = @LLVM_ENABLE_LIBXML2@
 config.sizeof_void_p = @CMAKE_SIZEOF_VOID_P@
 config.ld_lld_default_mingw = @LLD_DEFAULT_LD_LLD_IS_MINGW@
 
 # Support substitution of the tools and libs dirs with user parameters. This is
 # used when we can't determine the tool dir at configuration time.
 try:
     config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params

lld/tools/lld/CMakeLists.txt

target_link_libraries(lld
   lldCOFF
   lldDriver
   lldELF
   lldMachO2
   lldMinGW
   lldWasm
   )
 
-if(HAVE_LIBXAR)
+if(LLVM_HAVE_LIBXAR)
   target_link_libraries(lld PRIVATE ${XAR_LIB})
 endif()
 
 install(TARGETS lld
   RUNTIME DESTINATION bin)
 
 if(NOT LLD_SYMLINKS_TO_CREATE)
   set(LLD_SYMLINKS_TO_CREATE
       lld-link ld.lld ld64.lld ld64.lld.darwinnew ld64.lld.darwinold wasm-ld)
 endif()
 
 foreach(link ${LLD_SYMLINKS_TO_CREATE})
   add_lld_symlink(${link} lld)
 endforeach()

llvm/cmake/config-ix.cmake

if (NOT PURE_WINDOWS)
     endif()
   else()
     set(LLVM_ENABLE_TERMINFO 0)
   endif()
 else()
   set(LLVM_ENABLE_TERMINFO 0)
 endif()
 
-check_library_exists(xar xar_open "" HAVE_LIBXAR)
-if(HAVE_LIBXAR)
+check_library_exists(xar xar_open "" LLVM_HAVE_LIBXAR)
+if(LLVM_HAVE_LIBXAR)
   set(XAR_LIB xar)
 endif()
 
 # function checks
 check_symbol_exists(arc4random "stdlib.h" HAVE_DECL_ARC4RANDOM)
 find_package(Backtrace)
 set(HAVE_BACKTRACE ${Backtrace_FOUND})
 set(BACKTRACE_HEADER ${Backtrace_HEADER})

llvm/cmake/modules/LLVMConfig.cmake.in

 set(LLVM_TOOLS_INSTALL_DIR "@LLVM_TOOLS_INSTALL_DIR@")
 set(LLVM_HAVE_OPT_VIEWER_MODULES @LLVM_HAVE_OPT_VIEWER_MODULES@)
 set(LLVM_CONFIGURATION_TYPES @CMAKE_CONFIGURATION_TYPES@)
 set(LLVM_ENABLE_SHARED_LIBS @BUILD_SHARED_LIBS@)
 
 set(LLVM_DEFAULT_EXTERNAL_LIT "@LLVM_CONFIG_DEFAULT_EXTERNAL_LIT@")
 set(LLVM_LIT_ARGS "@LLVM_LIT_ARGS@")
 
+set(LLVM_HAVE_LIBXAR "@LLVM_HAVE_LIBXAR@")
+
 if(NOT TARGET LLVMSupport)
   @LLVM_CONFIG_INCLUDE_EXPORTS@
   @llvm_config_include_buildtree_only_exports@
 endif()
 
 # By creating intrinsics_gen, omp_gen and acc_gen here, subprojects that depend
 # on LLVM's tablegen-generated headers can always depend on this target whether
 # building in-tree with LLVM or not.

llvm/include/llvm/Config/config.h.cmake

 #cmakedefine HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC ${HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC}
 
 /* Define to 1 if you have the <sys/types.h> header file. */
 #cmakedefine HAVE_SYS_TYPES_H ${HAVE_SYS_TYPES_H}
 
 /* Define if the setupterm() function is supported this platform. */
 #cmakedefine LLVM_ENABLE_TERMINFO ${LLVM_ENABLE_TERMINFO}
 
-/* Define if the xar_open() function is supported this platform. */
-#cmakedefine HAVE_LIBXAR ${HAVE_LIBXAR}
-
 /* Define to 1 if you have the <termios.h> header file. */
 #cmakedefine HAVE_TERMIOS_H ${HAVE_TERMIOS_H}
 
 /* Define to 1 if you have the <unistd.h> header file. */
 #cmakedefine HAVE_UNISTD_H ${HAVE_UNISTD_H}
 
 /* Define to 1 if you have the <valgrind/valgrind.h> header file. */
 #cmakedefine HAVE_VALGRIND_VALGRIND_H ${HAVE_VALGRIND_VALGRIND_H}

llvm/include/llvm/Config/llvm-config.h.cmake

 #cmakedefine LLVM_HAVE_TF_AOT
 
 /* Define to 1 if you have the <sysexits.h> header file. */
 #cmakedefine HAVE_SYSEXITS_H ${HAVE_SYSEXITS_H}
 
 /* Define to 1 to enable the experimental new pass manager by default */
 #cmakedefine01 LLVM_ENABLE_NEW_PASS_MANAGER
 
+/* Define if the xar_open() function is supported on this platform. */
+#cmakedefine LLVM_HAVE_LIBXAR ${LLVM_HAVE_LIBXAR}
+
 #endif

llvm/test/CMakeLists.txt

 llvm_canonicalize_cmake_booleans(
   BUILD_SHARED_LIBS
-  HAVE_LIBXAR
+  LLVM_HAVE_LIBXAR
   HAVE_OCAMLOPT
   HAVE_OCAML_OUNIT
   LLVM_ENABLE_DIA_SDK
   LLVM_ENABLE_FFI
   LLVM_ENABLE_THREADS
   LLVM_ENABLE_ZLIB
   LLVM_ENABLE_LIBXML2
   LLVM_INCLUDE_GO_TESTS

llvm/test/lit.site.cfg.py.in

 config.host_os = "@HOST_OS@"
 config.host_cc = "@HOST_CC@"
 config.host_cxx = "@HOST_CXX@"
 # Note: ldflags can contain double-quoted paths, so must use single quotes here.
 config.host_ldflags = '@HOST_LDFLAGS@'
 config.llvm_use_intel_jitevents = @LLVM_USE_INTEL_JITEVENTS@
 config.llvm_use_sanitizer = "@LLVM_USE_SANITIZER@"
 config.have_zlib = @LLVM_ENABLE_ZLIB@
-config.have_libxar = @HAVE_LIBXAR@
+config.have_libxar = @LLVM_HAVE_LIBXAR@
 config.have_libxml2 = @LLVM_ENABLE_LIBXML2@
 config.have_dia_sdk = @LLVM_ENABLE_DIA_SDK@
 config.enable_ffi = @LLVM_ENABLE_FFI@
 config.build_examples = @LLVM_BUILD_EXAMPLES@
 config.enable_threads = @LLVM_ENABLE_THREADS@
 config.build_shared_libs = @BUILD_SHARED_LIBS@
 config.link_llvm_dylib = @LLVM_LINK_LLVM_DYLIB@
 config.llvm_host_triple = '@LLVM_HOST_TRIPLE@'

llvm/tools/llvm-objdump/CMakeLists.txt

add_llvm_tool(llvm-objdump
   MachODump.cpp
   WasmDump.cpp
   XCOFFDump.cpp
   DEPENDS
   ObjdumpOptsTableGen
   OtoolOptsTableGen
   )
 
-if(HAVE_LIBXAR)
+if(LLVM_HAVE_LIBXAR)
   target_link_libraries(llvm-objdump PRIVATE ${XAR_LIB})
 endif()
 
 add_llvm_tool_symlink(llvm-otool llvm-objdump)
 
 if(LLVM_INSTALL_BINUTILS_SYMLINKS)
   add_llvm_tool_symlink(objdump llvm-objdump)
 endif()

llvm/tools/llvm-objdump/MachODump.cpp

 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstring>
 #include <system_error>
 
-#ifdef HAVE_LIBXAR
+#ifdef LLVM_HAVE_LIBXAR
 extern "C" {
 #include <xar/xar.h>
 }
 #endif
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::objdump;

 } // namespace
 
 // Types for the storted data in code table that is built before disassembly
 // and the predicate function to sort them.
 typedef std::pair<uint64_t, DiceRef> DiceTableEntry;
 typedef std::vector<DiceTableEntry> DiceTable;
 typedef DiceTable::iterator dice_table_iterator;
 
-#ifdef HAVE_LIBXAR
+#ifdef LLVM_HAVE_LIBXAR
 namespace {
 struct ScopedXarFile {
   xar_t xar;
   ScopedXarFile(const char *filename, int32_t flags)
       : xar(xar_open(filename, flags)) {}
   ~ScopedXarFile() {
     if (xar)
       xar_close(xar);
~ScopedXarIter() {
     if (iter)
       xar_iter_free(iter);
   }
   ScopedXarIter(const ScopedXarIter &) = delete;
   ScopedXarIter &operator=(const ScopedXarIter &) = delete;
   operator xar_iter_t() { return iter; }
 };
 } // namespace
-#endif // defined(HAVE_LIBXAR)
+#endif // defined(LLVM_HAVE_LIBXAR)
 
 // This is used to search for a data in code table entry for the PC being
 // disassembled.  The j parameter has the PC in j.first.  A single data in code
 // table entry can cover many bytes for each of its Kind's.  So if the offset,
 // aka the i.first value, of the data in code table entry plus its Length
 // covers the PC being searched for this will return true.  If not it will
 // return false.
 static bool compareDiceTableEntries(const DiceTableEntry &i,
if (cputype == MachO::CPU_TYPE_I386 || cputype == MachO::CPU_TYPE_X86_64) {
     }
   }
 }
 
 static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
                              StringRef DisSegName, StringRef DisSectName);
 static void DumpProtocolSection(MachOObjectFile *O, const char *sect,
                                 uint32_t size, uint32_t addr);
-#ifdef HAVE_LIBXAR
+#ifdef LLVM_HAVE_LIBXAR
 static void DumpBitcodeSection(MachOObjectFile *O, const char *sect,
                                 uint32_t size, bool verbose,
                                 bool PrintXarHeader, bool PrintXarFileHeaders,
                                 std::string XarMemberName);
-#endif // defined(HAVE_LIBXAR)
+#endif // defined(LLVM_HAVE_LIBXAR)
 
 static void DumpSectionContents(StringRef Filename, MachOObjectFile *O,
                                 bool verbose) {
   SymbolAddressMap AddrMap;
   if (verbose)
     CreateSymbolAddressMap(O, &AddrMap);
 
   for (unsigned i = 0; i < FilterSections.size(); ++i) {
for (const SectionRef &Section : O->sections()) {
           if (SegName == "__TEXT" && SectName == "__info_plist") {
             outs() << sect;
             continue;
           }
           if (SegName == "__OBJC" && SectName == "__protocol") {
             DumpProtocolSection(O, sect, sect_size, sect_addr);
             continue;
           }
-#ifdef HAVE_LIBXAR
+#ifdef LLVM_HAVE_LIBXAR
           if (SegName == "__LLVM" && SectName == "__bundle") {
             DumpBitcodeSection(O, sect, sect_size, verbose, SymbolicOperands,
                                ArchiveHeaders, "");
             continue;
           }
-#endif // defined(HAVE_LIBXAR)
+#endif // defined(LLVM_HAVE_LIBXAR)
           switch (section_type) {
           case MachO::S_REGULAR:
             DumpRawSectionContents(O, sect, sect_size, sect_addr);
             break;
           case MachO::S_ZEROFILL:
             outs() << "zerofill section and has no contents in the file\n";
             break;
           case MachO::S_CSTRING_LITERALS:
if (O->isLittleEndian() != sys::IsLittleEndianHost)
       swapStruct(protocol);
     paddr = addr + (p - sect);
     outs() << "Protocol " << format("0x%" PRIx32, paddr);
     if (print_protocol(paddr, 0, &info))
       outs() << "(not in an __OBJC section)\n";
   }
 }
 
-#ifdef HAVE_LIBXAR
+#ifdef LLVM_HAVE_LIBXAR
 static inline void swapStruct(struct xar_header &xar) {
   sys::swapByteOrder(xar.magic);
   sys::swapByteOrder(xar.size);
   sys::swapByteOrder(xar.version);
   sys::swapByteOrder(xar.toc_length_compressed);
   sys::swapByteOrder(xar.toc_length_uncompressed);
   sys::swapByteOrder(xar.cksum_alg);
 }
#endif
           }
           XarMemberName = OldXarMemberName;
           delete buffer;
         }
       }
     }
   }
 }
-#endif // defined(HAVE_LIBXAR)
+#endif // defined(LLVM_HAVE_LIBXAR)
 
 static void printObjcMetaData(MachOObjectFile *O, bool verbose) {
   if (O->is64Bit())
     printObjc2_64bit_MetaData(O, verbose);
   else {
     MachO::mach_header H;
     H = O->getHeader();
     if (H.cputype == MachO::CPU_TYPE_ARM)

llvm/utils/gn/secondary/lld/test/BUILD.gn

write_lit_cfg("lit_site_cfg") {
 
   if (llvm_enable_dia_sdk) {
     extra_values += [ "LLVM_ENABLE_DIA_SDK=1" ]
   } else {
     extra_values += [ "LLVM_ENABLE_DIA_SDK=0" ]  # Must be 0.
   }
 
   if (llvm_enable_libxar) {
-    extra_values += [ "HAVE_LIBXAR=1" ]
+    extra_values += [ "LLVM_HAVE_LIBXAR=1" ]
   } else {
-    extra_values += [ "HAVE_LIBXAR=0" ]  # Must be 0.
+    extra_values += [ "LLVM_HAVE_LIBXAR=0" ]  # Must be 0.
   }
 
   if (llvm_enable_libxml2) {
     extra_values += [ "LLVM_ENABLE_LIBXML2=1" ]
   } else {
     extra_values += [ "LLVM_ENABLE_LIBXML2=0" ]  # Must be 0.
   }
 

llvm/utils/gn/secondary/llvm/include/llvm/Config/BUILD.gn

write_cmake_config("config") {
   ]
 
   if (llvm_enable_libedit) {
     values += [ "HAVE_LIBEDIT=1" ]
   } else {
     values += [ "HAVE_LIBEDIT=" ]
   }
 
-  if (llvm_enable_libxar) {
-    values += [ "HAVE_LIBXAR=1" ]
-  } else {
-    values += [ "HAVE_LIBXAR=" ]
-  }
-
   if (llvm_enable_terminfo) {
     values += [ "LLVM_ENABLE_TERMINFO=1" ]
   } else {
     values += [ "LLVM_ENABLE_TERMINFO=" ]
   }
 
   if (llvm_enable_dia_sdk) {
     values += [ "LLVM_ENABLE_DIA_SDK=1" ]
if (current_os == "win") {
     ]
   } else {
     values += [
       "HAVE_SYSEXITS_H=1",
       "LLVM_ON_UNIX=1",
     ]
   }
 
+  if (llvm_enable_libxar) {
+    values += [ "LLVM_HAVE_LIBXAR=1" ]
+  } else {
+    values += [ "LLVM_HAVE_LIBXAR=" ]
+  }
+
   if (llvm_enable_threads) {
     values += [ "LLVM_ENABLE_THREADS=1" ]
   } else {
     values += [ "LLVM_ENABLE_THREADS=" ]
   }
 }
 
 ##############################################################################

llvm/utils/gn/secondary/llvm/test/BUILD.gn

write_lit_config("lit_site_cfg") {
 
   if (llvm_enable_assertions) {
     extra_values += [ "ENABLE_ASSERTIONS=1" ]
   } else {
     extra_values += [ "ENABLE_ASSERTIONS=0" ]  # Must be 0.
   }
 
   if (llvm_enable_libxar) {
-    extra_values += [ "HAVE_LIBXAR=1" ]
+    extra_values += [ "LLVM_HAVE_LIBXAR=1" ]
   } else {
-    extra_values += [ "HAVE_LIBXAR=0" ]  # Must be 0.
+    extra_values += [ "LLVM_HAVE_LIBXAR=0" ]  # Must be 0.
   }
 
   if (llvm_enable_dia_sdk) {
     extra_values += [ "LLVM_ENABLE_DIA_SDK=1" ]
   } else {
     extra_values += [ "LLVM_ENABLE_DIA_SDK=0" ]  # Must be 0.
   }