[Support] Move TargetParsers to new component

[lenary]

Summary

This is a fairly large changeset, but it can be broken into a few
pieces:

• llvm/Support/*TargetParser* are all moved from the LLVM Support component into a new LLVM Component called "TargetParser". This potentially enables using tablegen to maintain this information, as is shown in https://reviews.llvm.org/D137517. This cannot currently be done, as llvm-tblgen relies on LLVM's Support component.
• This also moves two files from Support which use and depend on information in the TargetParser:
  • llvm/Support/Host.{h,cpp} which contains functions for inspecting the current Host machine for info about it, primarily to support getting the host triple, but also for -mcpu=native support in e.g. Clang. This is fairly tightly intertwined with the information in X86TargetParser.h, so keeping them in the same component makes sense.
  • llvm/ADT/Triple.h and llvm/Support/Triple.cpp, which contains the target triple parser and representation. This is very intertwined with the Arm target parser, because the arm architecture version appears in canonical triples on arm platforms.
• I moved the relevant unittests to their own directory.

And so, we end up with a single component that has all the information
about the following, which to me seems like a unified component:

• Triples that LLVM Knows about
• Architecture names and CPUs that LLVM knows about
• CPU detection logic for LLVM

Given this, I have also moved RISCVISAInfo.h into this component, as
it seems to me to be part of that same set of functionality.

If you get link errors in your components after this patch, you likely
need to add TargetParser into LLVM_LINK_COMPONENTS in CMake.

[fpetrogalli]

llvm/include/llvm/Support/Host.h

10

Explicit deprecation.

llvm/include/llvm/Support/LoongArchTargetParser.h

10

Same, explicit deprecation.

llvm/include/llvm/Support/RISCVISAInfo.h

10

Same, explicit deprecation.

llvm/include/llvm/Support/TargetParser.h

14

Explicit deprecation.

llvm/include/llvm/Support/X86TargetParser.def

10

Again, explicit deprecation.

llvm/include/llvm/Support/X86TargetParser.h

10

Guess! Explicit deprecation!

llvm/include/llvm/TargetParser/AArch64TargetParser.def

1–9

nit: The changes in this file are cosmetic and not needed as part of this change. I think you should submit them separately.

llvm/include/llvm/TargetParser/ARMTargetParser.h

85

II don't think this change is needed? AFAIU, the code will compile anyway even without it because the current folder is the folder where the compiler first looks for include headers?

I think you should revert this one (and the similar changes below).

If there is a real need to change it, you can do it with a new separate submission.

llvm/include/llvm/TargetParser/CSKYTargetParser.h

129

Nit: like before, this change doesn't seem to be needed.

llvm/lib/TargetParser/AArch64TargetParser.cpp

176

nit: unrelated.

llvm/lib/TargetParser/ARMTargetParser.cpp

187–214

Tabs? Unrelated.

216

nit: unrelated

233

nit: unrelated

llvm/lib/TargetParser/Unix/Host.inc

24–26

Why is the guard needed?

llvm/unittests/Support/CMakeLists.txt

3

Is this needed? The tests for TargetParser should not be here anymore, no?

[lenary]

clang/lib/Lex/CMakeLists.txt

3–6

Not sure, but I still think getting the case right is useful in this patch.

flang/tools/bbc/CMakeLists.txt

2–5

I've undone the re-indent here.

flang/unittests/Optimizer/CMakeLists.txt

14

That's better, done.

llvm/include/llvm/ADT/Triple.h

1

Agreed, and this needs a full LLVM header, like I did for the other forwarding headers.

llvm/lib/TargetParser/ARMTargetParser.cpp

187–214

Not tabs, just a re-dent because I clang-formatted my changes and it didn't cope with the file move. Undone.

llvm/lib/TargetParser/Unix/Host.inc

24–26

The guard is the same guard for the include that is in Unix.h in support. The problem is Unix.h in support is in a subdirectory that I cannot easily add to the include path for this file, so instead I directly copied it over.

llvm/unittests/Support/CMakeLists.txt

3

This is needed because the tests in Support still use the Triple - they are not testing the triple, they just choose whether to run the tests based on the triple.

[lenary]

As for the name TargetParser. @arsenm came up with the name SubtargetRegistry. I am fine with either names.

@fpetrogalli I'm going to stick with TargetParser, because I think this is less confusing, given that TargetRegistry is already a component.

[MaskRay]

The name llvm/lib/TargetParser LGTM.

[fpetrogalli]

Thank you for working on this @lenary - LGTM!

[MaskRay]

Please check these builds all work:

• default
• -DLLVM_LINK_LLVM_DYLIB=on
• -DBUILD_SHARED_LIBS=on

[lenary]

The most recent update is all the fixes needed after the builds @MaskRay asked me for. I think this is ready to land on Monday?

@thakis there will be GN fallout from this change. I do not intend to update GN in this patchset, but wanted to give you a heads-up.

[fpetrogalli]

In D137838#4000959, @lenary wrote:

[...] I think this is ready to land on Monday?

SGTM - thank you again!

[lenary]

This caused an issue in the libc benchmarks, fix here: https://reviews.llvm.org/rG2a261a7b5764 (committed directly to main)

[barannikov88]

llvm/include/llvm/ADT/Triple.h

11

Invalid comment.

[lenary]

llvm/include/llvm/ADT/Triple.h

11

Fixed in https://reviews.llvm.org/rG741396af16d1

[lenary]

Another fixup for the llvm examples was required, landed in https://reviews.llvm.org/rG16c4c4e04c14

[lenary]

And a fixup for the compiler-rt symbolizer: https://reviews.llvm.org/rGecaab107e4d0

[thakis]

Thanks for the heads-up. I updated the GN build in 4ac51dd53d93b8dd18c58093766483c657fe3a08 and 2aa998d22fe09191cd6c1b697e373266c1131502. The latter commit has a python script in the commit message that might be useful to others who want to port this to other build systems.

[lenary]

In D137838#4007920, @thakis wrote:

Thanks for the heads-up. I updated the GN build in 4ac51dd53d93b8dd18c58093766483c657fe3a08 and 2aa998d22fe09191cd6c1b697e373266c1131502. The latter commit has a python script in the commit message that might be useful to others who want to port this to other build systems.

Thanks! Much appreciated!

[aprantl]

Can you please update llvm/include/llvm/module.modulemap for this change or revert the patch? This is breaking all bots that build with -DLLVM_ENABLE_MODULES=On.

For example: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/lastFailedBuild/consoleFull#111065754949ba4694-19c4-4d7e-bec5-911270d8a58c

Thanks!

[lenary]

In D137838#4008443, @aprantl wrote:

Can you please update llvm/include/llvm/module.modulemap for this change or revert the patch? This is breaking all bots that build with -DLLVM_ENABLE_MODULES=On.

For example: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/lastFailedBuild/consoleFull#111065754949ba4694-19c4-4d7e-bec5-911270d8a58c

Looking at this now. Thanks for pointing it out as I didn't get a notification for this.

[aprantl]

I think I fixed it in a685bb8e333e, but please take another look.

[aprantl]

Sorry, I pasted in the wrong hash: 6bdf378dcd349d97152846bb687c1d1de511d138

[steven_wu]

Also needed a follow up fix to completely fix module 9cd6fbee7ed8

[lenary]

I'm working on a follow-up, which should make the split a bit clearer, but I'm also not a modulemap expert and the -DLLVM_ENABLE_MODULES=On configuration is broken on my linux dev box. I'll post it for review if those two patches have at least made the build greener.

[lenary]

In D137838#4008605, @lenary wrote:

I'm working on a follow-up, which should make the split a bit clearer, but I'm also not a modulemap expert and the -DLLVM_ENABLE_MODULES=On configuration is broken on my linux dev box. I'll post it for review if those two patches have at least made the build greener.

Here: https://reviews.llvm.org/D140420 - I'm not sure how urgent this is, if your patches did get your builds green. I think in e.g. the bazel build, there's still a bunch of places where TargetParser is closely entwined with Support that we can fix in the same way we intend to fix the forwarding headers.

[dblaikie]

This has introduced a circular dependency due to the forwarding header (forwarding header depends on new lib, new lib depends on support, where the forwarding header is). Generally this wouldn't be acceptable (& I'd suggest the patch be reverted on that basis) though I understand this is a complicated migration - what's the timeline for correcting this issue?

[fpetrogalli]

In D137838#4010987, @dblaikie wrote:

This has introduced a circular dependency due to the forwarding header (forwarding header depends on new lib, new lib depends on support, where the forwarding header is). Generally this wouldn't be acceptable (& I'd suggest the patch be reverted on that basis) though I understand this is a complicated migration - what's the timeline for correcting this issue?

IIUC, the fix here would be to remove the forwarding headers, right?

Francesco

[lenary]

In D137838#4010987, @dblaikie wrote:

This has introduced a circular dependency due to the forwarding header (forwarding header depends on new lib, new lib depends on support, where the forwarding header is). Generally this wouldn't be acceptable (& I'd suggest the patch be reverted on that basis) though I understand this is a complicated migration - what's the timeline for correcting this issue?

A commit was landed to add TargetParser to the module map so it looks like part of Support, which solves the circular dependency issue in the short term, I believe.

https://reviews.llvm.org/D140420 is a proposed fix which should more clearly split the TargetParser from Support, but I'm not super familiar with modules and my linux dev environment does not work with a modules build. I'd appreciate any comments or guidance though I also know it needs an update.

[paulkirth]

Hi, we're seeing some build failures after this change. Seems like the TargetParser isn't getting added to LLVMExports correctly. Can you take a look and address these?

Failing bot https://ci.chromium.org/ui/p/fuchsia/builders/prod/llvm-linux-x64/b8794232527428765009/overview

CMAKE invocation can be found here: https://logs.chromium.org/logs/fuchsia/buildbucket/cr-buildbucket/8794232527428765009/+/u/configure_x86_64-linux-gnu_llvm/execution_details

Error message:

CMake Error: install(EXPORT "LLVMExports" ...) includes target "LLVMCore" which requires target "LLVMTargetParser" that is not in the export set.
CMake Error: install(EXPORT "LLVMExports" ...) includes target "LLVMBinaryFormat" which requires target "LLVMTargetParser" that is not in the export set.
CMake Error: install(EXPORT "LLVMExports" ...) includes target "LLVMBitReader" which requires target "LLVMTargetParser" that is not in the export set.
CMake Error: install(EXPORT "LLVMExports" ...) includes target "LLVMMC" which requires target "LLVMTargetParser" that is not in the export set.
CMake Error: install(EXPORT "LLVMExports" ...) includes target "LLVMMCParser" which requires target "LLVMTargetParser" that is not in the export set.
CMake Error: install(EXPORT "LLVMExports" ...) includes target "LLVMMCDisassembler" which requires target "LLVMTargetParser" that is not in the export set.
CMake Error: install(EXPORT "LLVMExports" ...) includes target "LLVMObject" which requires target "LLVMTargetParser" that is not in the export set.
CMake Error: install(EXPORT "LLVMExports" ...) includes target "LLVMDebugInfoDWARF" which requires target "LLVMTargetParser" that is not in the export set.
CMake Error: install(EXPORT "LLVMExports" ...) includes target "LLVMSymbolize" which requires target "LLVMTargetParser" that is not in the export set.
CMake Error: install(EXPORT "LLVMExports" ...) includes target "LLVMX86Desc" which requires target "LLVMTargetParser" that is not in the export set.
CMake Error: install(EXPORT "LLVMExports" ...) includes target "LLVMAArch64Desc" which requires target "LLVMTargetParser" that is not in the export set.
CMake Error: install(EXPORT "LLVMExports" ...) includes target "LLVMProfileData" which requires target "LLVMTargetParser" that is not in the export set.
CMake Error: install(EXPORT "LLVMExports" ...) includes target "LLVMTextAPI" which requires target "LLVMTargetParser" that is not in the export set.

[paulkirth]

Sorry for the noise, I missed that that bot is setting a CMake flag that affects LLVM_EXPORTS. Please disregard my earlier message. I just need to update the CMake invocation to fix this, so I don't think there is anything required on your end.

[zixuan-wu]

llvm/include/llvm/Support/RISCVISAInfo.h

10

I think there is a typo that should be 'in favour of llvm/TargetParser/RISCVISAInfo.h '

[• pcwang-thead]

llvm/include/llvm/Support/RISCVISAInfo.h

10

I may move RISCVISAInfo back to Support and fix this in D140529.

[vitalybuka]

This bot is broken after the patch https://lab.llvm.org/buildbot/#/builders/236/builds/1480

[lenary]

In D137838#4018930, @vitalybuka wrote:

This bot is broken after the patch https://lab.llvm.org/buildbot/#/builders/236/builds/1480

Thanks for letting me know. I'm back in the office on the 3rd, and it looks like this will be top of my list to look at, not that I'm very familiar with the pass and what it's up to.

clang/lib/Lex/CMakeLists.txt

 # TODO: Add -maltivec when ARCH is PowerPC.
 
-set(LLVM_LINK_COMPONENTS support)
+set(LLVM_LINK_COMPONENTS
+  Support
+  TargetParser
+  )
 
 add_clang_library(clangLex
   DependencyDirectivesScanner.cpp
   HeaderMap.cpp
   HeaderSearch.cpp
   InitHeaderSearch.cpp
   Lexer.cpp
   LiteralSupport.cpp

clang/lib/Tooling/DumpTool/CMakeLists.txt

 
 add_clang_executable(clang-ast-dump
   ASTSrcLocProcessor.cpp
   ClangSrcLocDump.cpp
   )
 
 target_link_libraries(clang-ast-dump
   PRIVATE
   clangAST
   clangASTMatchers
   clangBasic
   clangDriver
   clangFrontend
   clangSerialization
   clangToolingCore
 )

flang/tools/bbc/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Passes
+  TargetParser
   )
 
 add_flang_tool(bbc bbc.cpp
 DEPENDS
 FIROptCodeGenPassIncGen
 )
 
 llvm_update_compile_flags(bbc)
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 target_link_libraries(bbc PRIVATE

flang/unittests/Optimizer/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  TargetParser
+)
+
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 set(LIBS
   FIRBuilder
   FIRCodeGen
   FIRDialect
   FIRSupport
   HLFIRDialect
   ${dialect_libs}
 )
 
 add_flang_unittest(FlangOptimizerTests
   Builder/CharacterTest.cpp
   Builder/ComplexTest.cpp
   Builder/DoLoopHelperTest.cpp
   Builder/FIRBuilderTest.cpp
   Builder/HLFIRToolsTest.cpp
   Builder/Runtime/AssignTest.cpp

llvm/include/llvm/TargetParser/AArch64TargetParser.def

-//===- AARCH64TargetParser.def - AARCH64 target parsing defines ---------*- C++ -*-===//
+//===- AArch64TargetParser.def - AARCH64 target parsing defines -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This file provides defines to build up the AARCH64 target parser's logic.
+// This file provides defines to build up the AArch64 target parser's logic.
 //
 //===----------------------------------------------------------------------===//
 
 // NOTE: NO INCLUDE GUARD DESIRED!
 
 #ifndef AARCH64_ARCH
 #define AARCH64_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, ARCH_BASE_EXT)
 #endif

llvm/include/llvm/TargetParser/ARMTargetParser.h

struct ExtName {
   const char *NegFeature;
 
   StringRef getName() const { return StringRef(NameCStr, NameLength); }
 };
 
 const ExtName ARCHExtNames[] = {
 #define ARM_ARCH_EXT_NAME(NAME, ID, FEATURE, NEGFEATURE)                       \
   {NAME, sizeof(NAME) - 1, ID, FEATURE, NEGFEATURE},
-#include "ARMTargetParser.def"
+#include "llvm/TargetParser/ARMTargetParser.def"
 };
 
 // List of HWDiv names (use getHWDivSynonym) and which architectural
 // features they correspond to (use getHWDivFeatures).
 // FIXME: TableGen this.
 const struct {
   const char *NameCStr;
   size_t NameLength;
   uint64_t ID;
 
   StringRef getName() const { return StringRef(NameCStr, NameLength); }
 } HWDivNames[] = {
 #define ARM_HW_DIV_NAME(NAME, ID) {NAME, sizeof(NAME) - 1, ID},
-#include "ARMTargetParser.def"
+#include "llvm/TargetParser/ARMTargetParser.def"
 };
 
 // Arch names.
 enum class ArchKind {
-#define ARM_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, ARCH_BASE_EXT) ID,
-#include "ARMTargetParser.def"
+#define ARM_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU,            \
+                 ARCH_BASE_EXT)                                                \
+  ID,
+#include "llvm/TargetParser/ARMTargetParser.def"
 };
 
 // List of CPU names and their arches.
 // The same CPU can have multiple arches and can be default on multiple arches.
 // When finding the Arch for a CPU, first-found prevails. Sort them accordingly.
 // When this becomes table-generated, we'd probably need two tables.
 // FIXME: TableGen this.
 template <typename T> struct CpuNames {
   const char *NameCStr;
   size_t NameLength;
   T ArchID;
   bool Default; // is $Name the default CPU for $ArchID ?
   uint64_t DefaultExtensions;
 
   StringRef getName() const { return StringRef(NameCStr, NameLength); }
 };
 
 const CpuNames<ArchKind> CPUNames[] = {
 #define ARM_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT)           \
   {NAME, sizeof(NAME) - 1, ARM::ArchKind::ID, IS_DEFAULT, DEFAULT_EXT},
-#include "ARMTargetParser.def"
+#include "llvm/TargetParser/ARMTargetParser.def"
 };
 
 // FPU names.
 enum FPUKind {
 #define ARM_FPU(NAME, KIND, VERSION, NEON_SUPPORT, RESTRICTION) KIND,
-#include "ARMTargetParser.def"
+#include "llvm/TargetParser/ARMTargetParser.def"
   FK_LAST
 };
 
 // FPU Version
 enum class FPUVersion {
   NONE,
   VFPV2,
   VFPV3,
struct FPUName {
   FPURestriction Restriction;
 
   StringRef getName() const { return StringRef(NameCStr, NameLength); }
 };
 
 static const FPUName FPUNames[] = {
 #define ARM_FPU(NAME, KIND, VERSION, NEON_SUPPORT, RESTRICTION)                \
   {NAME, sizeof(NAME) - 1, KIND, VERSION, NEON_SUPPORT, RESTRICTION},
-#include "llvm/Support/ARMTargetParser.def"
+#include "llvm/TargetParser/ARMTargetParser.def"
 };
 
 // List of canonical arch names (use getArchSynonym).
 // This table also provides the build attribute fields for CPU arch
 // and Arch ID, according to the Addenda to the ARM ABI, chapters
 // 2.4 and 2.3.5.2 respectively.
 // FIXME: SubArch values were simplified to fit into the expectations
 // of the triples and are not conforming with their official names.
template <typename T> struct ArchNames {
   StringRef getArchFeature() const {
     return StringRef(SubArchCStr, SubArchLength);
   }
 };
 
 static const ArchNames<ArchKind> ARCHNames[] = {
 #define ARM_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU,            \
                  ARCH_BASE_EXT)                                                \
-  {NAME,         sizeof(NAME) - 1,                                             \
-   CPU_ATTR,     sizeof(CPU_ATTR) - 1,                                         \
-   "+" SUB_ARCH, sizeof(SUB_ARCH),                                             \
-   ARCH_FPU,     ARCH_BASE_EXT,                                                \
+  {NAME,         sizeof(NAME) - 1, CPU_ATTR, sizeof(CPU_ATTR) - 1,             \
+   "+" SUB_ARCH, sizeof(SUB_ARCH), ARCH_FPU, ARCH_BASE_EXT,                    \
    ArchKind::ID, ARCH_ATTR},
-#include "llvm/Support/ARMTargetParser.def"
+#include "llvm/TargetParser/ARMTargetParser.def"
 };
 
 inline ArchKind &operator--(ArchKind &Kind) {
   assert((Kind >= ArchKind::ARMV8A && Kind <= ArchKind::ARMV9_3A) &&
          "We only expect operator-- to be called with ARMV8/V9");
   if (Kind == ArchKind::INVALID || Kind == ArchKind::ARMV8A ||
       Kind == ArchKind::ARMV8_1A || Kind == ArchKind::ARMV9A ||
       Kind == ArchKind::ARMV8R)

llvm/include/llvm/TargetParser/CSKYTargetParser.h

-//===-- CSKYTargetParser - Parser for CSKY target features --------*- C++
-//-*-===//
+//===-- CSKYTargetParser - Parser for CSKY target features ------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a target parser to recognise CSKY hardware features
 // such as FPU/CPU/ARCH/extensions and specific support such as HWDIV.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_CSKYTARGETPARSER_H
 #define LLVM_SUPPORT_CSKYTARGETPARSER_H
 
-#include "llvm/ADT/Triple.h"
+#include "llvm/TargetParser/Triple.h"
 #include <vector>
 
 namespace llvm {
 class StringRef;
 
 namespace CSKY {
 
 // Arch extension modifiers for CPUs.
struct ExtName {
   const char *NegFeature;
 
   StringRef getName() const { return StringRef(NameCStr, NameLength); }
 };
 
 const CSKY::ExtName CSKYARCHExtNames[] = {
 #define CSKY_ARCH_EXT_NAME(NAME, ID, FEATURE, NEGFEATURE)                      \
   {NAME, sizeof(NAME) - 1, ID, FEATURE, NEGFEATURE},
-#include "CSKYTargetParser.def"
+#include "llvm/TargetParser/CSKYTargetParser.def"
 };
 
 // List of CPU names and their arches.
 template <typename T> struct CpuNames {
   const char *NameCStr;
   size_t NameLength;
   T ArchID;
   uint64_t defaultExt;
 
   StringRef getName() const { return StringRef(NameCStr, NameLength); }
 };
 const CpuNames<CSKY::ArchKind> CPUNames[] = {
 #define CSKY_CPU_NAME(NAME, ARCH_ID, DEFAULT_EXT)                              \
   {NAME, sizeof(NAME) - 1, CSKY::ArchKind::ARCH_ID, DEFAULT_EXT},
-#include "llvm/Support/CSKYTargetParser.def"
+#include "llvm/TargetParser/CSKYTargetParser.def"
 };
 
 // FIXME: TableGen this.
 // The entries must appear in the order listed in CSKY::CSKYFPUKind for correct
 // indexing
 struct FPUName {
   const char *NameCStr;
   size_t NameLength;
   CSKYFPUKind ID;
   FPUVersion FPUVer;
 
   StringRef getName() const { return StringRef(NameCStr, NameLength); }
 };
 
 static const FPUName FPUNames[] = {
 #define CSKY_FPU(NAME, KIND, VERSION) {NAME, sizeof(NAME) - 1, KIND, VERSION},
-#include "llvm/Support/CSKYTargetParser.def"
+#include "llvm/TargetParser/CSKYTargetParser.def"
 };
 
 // List of canonical arch names.
 template <typename T> struct ArchNames {
   const char *NameCStr;
   size_t NameLength;
   T ID;
   uint64_t archBaseExt;
   StringRef getName() const { return StringRef(NameCStr, NameLength); }
 };
 const ArchNames<CSKY::ArchKind> ARCHNames[] = {
 #define CSKY_ARCH(NAME, ID, ARCH_BASE_EXT)                                     \
   {NAME, sizeof(NAME) - 1, CSKY::ArchKind::ID, ARCH_BASE_EXT},
-#include "llvm/Support/CSKYTargetParser.def"
+#include "llvm/TargetParser/CSKYTargetParser.def"
 };
 
 StringRef getArchName(ArchKind AK);
 StringRef getDefaultCPU(StringRef Arch);
 StringRef getArchExtName(uint64_t ArchExtKind);
 StringRef getArchExtFeature(StringRef ArchExt);
 uint64_t getDefaultExtensions(StringRef CPU);
 bool getExtensionFeatures(uint64_t Extensions,

llvm/lib/TargetParser/AArch64TargetParser.cpp

 //===-- AArch64TargetParser - Parser for AArch64 features -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a target parser to recognise AArch64 hardware features
 // such as FPU/CPU/ARCH and extension names.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Support/AArch64TargetParser.h"
+#include "llvm/TargetParser/AArch64TargetParser.h"
 #include "llvm/ADT/StringSwitch.h"
-#include "llvm/ADT/Triple.h"
+#include "llvm/TargetParser/Triple.h"
 #include <cctype>
 
 using namespace llvm;
 
 static unsigned checkArchVersion(llvm::StringRef Arch) {
   if (Arch.size() >= 2 && Arch[0] == 'v' && std::isdigit(Arch[1]))
     return (Arch[1] - 48);
   return 0;
 }
 
 unsigned AArch64::getDefaultFPU(StringRef CPU, AArch64::ArchKind AK) {
   if (CPU == "generic")
     return AArch64ARCHNames[static_cast<unsigned>(AK)].DefaultFPU;
 
   return StringSwitch<unsigned>(CPU)
 #define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT)       \
   .Case(NAME, ARM::DEFAULT_FPU)
-#include "../../include/llvm/Support/AArch64TargetParser.def"
+#include "llvm/TargetParser/AArch64TargetParser.def"
   .Default(ARM::FK_INVALID);
 }
 
 uint64_t AArch64::getDefaultExtensions(StringRef CPU, AArch64::ArchKind AK) {
   if (CPU == "generic")
     return AArch64ARCHNames[static_cast<unsigned>(AK)].ArchBaseExtensions;
 
   return StringSwitch<uint64_t>(CPU)
 #define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT)       \
   .Case(NAME, AArch64ARCHNames[static_cast<unsigned>(ArchKind::ID)]            \
                       .ArchBaseExtensions |                                    \
                   DEFAULT_EXT)
-#include "../../include/llvm/Support/AArch64TargetParser.def"
+#include "llvm/TargetParser/AArch64TargetParser.def"
   .Default(AArch64::AEK_INVALID);
 }
 
 AArch64::ArchKind AArch64::getCPUArchKind(StringRef CPU) {
   if (CPU == "generic")
     return ArchKind::ARMV8A;
 
   return StringSwitch<AArch64::ArchKind>(CPU)
 #define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT)       \
   .Case(NAME, ArchKind::ID)
-#include "../../include/llvm/Support/AArch64TargetParser.def"
+#include "llvm/TargetParser/AArch64TargetParser.def"
   .Default(ArchKind::INVALID);
 }
 
 AArch64::ArchKind AArch64::getSubArchArchKind(StringRef SubArch) {
   return StringSwitch<AArch64::ArchKind>(SubArch)
 #define AARCH64_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU,        \
                      ARCH_BASE_EXT)                                            \
   .Case(SUB_ARCH, ArchKind::ID)
-#include "../../include/llvm/Support/AArch64TargetParser.def"
+#include "llvm/TargetParser/AArch64TargetParser.def"
   .Default(ArchKind::INVALID);
 }
 
 bool AArch64::getExtensionFeatures(uint64_t Extensions,
                                    std::vector<StringRef> &Features) {
   if (Extensions == AArch64::AEK_INVALID)
     return false;
 
 #define AARCH64_ARCH_EXT_NAME(NAME, ID, FEATURE, NEGFEATURE)                   \
   if (Extensions & ID) {                                                       \
     const char *feature = FEATURE;                                             \
     /* INVALID and NONE have no feature name. */                               \
     if (feature)                                                               \
       Features.push_back(feature);                                             \
   }
-#include "../../include/llvm/Support/AArch64TargetParser.def"
+#include "llvm/TargetParser/AArch64TargetParser.def"
 
   return true;
 }
 
 StringRef AArch64::resolveCPUAlias(StringRef CPU) {
   return StringSwitch<StringRef>(CPU)
-#define AARCH64_CPU_ALIAS(ALIAS,NAME)                                          \
+#define AARCH64_CPU_ALIAS(ALIAS, NAME)                                         \
   .Case(ALIAS, NAME)
-#include "../../include/llvm/Support/AArch64TargetParser.def"
+#include "llvm/TargetParser/AArch64TargetParser.def"
   .Default(CPU);
 }
 
 bool AArch64::getArchFeatures(AArch64::ArchKind AK,
                               std::vector<StringRef> &Features) {
   if (AK == ArchKind::INVALID)
     return false;
   Features.push_back(

 }
 
 void AArch64::fillValidCPUArchList(SmallVectorImpl<StringRef> &Values) {
   for (const auto &Arch : AArch64CPUNames) {
     if (Arch.ArchID != ArchKind::INVALID)
       Values.push_back(Arch.getName());
   }
 
-  for (const auto &Alias: AArch64CPUAliases)
+  for (const auto &Alias : AArch64CPUAliases)
     Values.push_back(Alias.getAlias());
 }
 
 bool AArch64::isX18ReservedByDefault(const Triple &TT) {
   return TT.isAndroid() || TT.isOSDarwin() || TT.isOSFuchsia() ||
          TT.isOSWindows();
 }
 

llvm/lib/TargetParser/ARMTargetParser.cpp

 //===-- ARMTargetParser - Parser for ARM target features --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a target parser to recognise ARM hardware features
 // such as FPU/CPU/ARCH/extensions and specific support such as HWDIV.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Support/ARMTargetParser.h"
+#include "llvm/TargetParser/ARMTargetParser.h"
 #include "llvm/ADT/StringSwitch.h"
-#include "llvm/ADT/Triple.h"
+#include "llvm/TargetParser/Triple.h"
 #include <cctype>
 
 using namespace llvm;
 
 static StringRef getHWDivSynonym(StringRef HWDiv) {
   return StringSwitch<StringRef>(HWDiv)
       .Case("thumb,arm", "arm,thumb")
       .Default(HWDiv);
bool ARM::getFPUFeatures(unsigned FPUKind, std::vector<StringRef> &Features) {
   if (FPUKind >= FK_LAST || FPUKind == FK_INVALID)
     return false;
 
   static const struct FPUFeatureNameInfo {
     const char *PlusName, *MinusName;
     FPUVersion MinVersion;
     FPURestriction MaxRestriction;
   } FPUFeatureInfoList[] = {
       // We have to specify the + and - versions of the name in full so
       // that we can return them as static StringRefs.
       //
       // Also, the SubtargetFeatures ending in just "sp" are listed here
       // under FPURestriction::None, which is the only FPURestriction in
       // which they would be valid (since FPURestriction::SP doesn't
       // exist).
       {"+vfp2", "-vfp2", FPUVersion::VFPV2, FPURestriction::D16},
       {"+vfp2sp", "-vfp2sp", FPUVersion::VFPV2, FPURestriction::SP_D16},
       {"+vfp3", "-vfp3", FPUVersion::VFPV3, FPURestriction::None},
       {"+vfp3d16", "-vfp3d16", FPUVersion::VFPV3, FPURestriction::D16},
       {"+vfp3d16sp", "-vfp3d16sp", FPUVersion::VFPV3, FPURestriction::SP_D16},
       {"+vfp3sp", "-vfp3sp", FPUVersion::VFPV3, FPURestriction::None},
       {"+fp16", "-fp16", FPUVersion::VFPV3_FP16, FPURestriction::SP_D16},
       {"+vfp4", "-vfp4", FPUVersion::VFPV4, FPURestriction::None},
       {"+vfp4d16", "-vfp4d16", FPUVersion::VFPV4, FPURestriction::D16},
       {"+vfp4d16sp", "-vfp4d16sp", FPUVersion::VFPV4, FPURestriction::SP_D16},
       {"+vfp4sp", "-vfp4sp", FPUVersion::VFPV4, FPURestriction::None},
       {"+fp-armv8", "-fp-armv8", FPUVersion::VFPV5, FPURestriction::None},
       {"+fp-armv8d16", "-fp-armv8d16", FPUVersion::VFPV5, FPURestriction::D16},
-    {"+fp-armv8d16sp", "-fp-armv8d16sp", FPUVersion::VFPV5, FPURestriction::SP_D16},
+      {"+fp-armv8d16sp", "-fp-armv8d16sp", FPUVersion::VFPV5,
+       FPURestriction::SP_D16},
       {"+fp-armv8sp", "-fp-armv8sp", FPUVersion::VFPV5, FPURestriction::None},
-    {"+fullfp16", "-fullfp16", FPUVersion::VFPV5_FULLFP16, FPURestriction::SP_D16},
+      {"+fullfp16", "-fullfp16", FPUVersion::VFPV5_FULLFP16,
+       FPURestriction::SP_D16},
       {"+fp64", "-fp64", FPUVersion::VFPV2, FPURestriction::D16},
       {"+d32", "-d32", FPUVersion::VFPV3, FPURestriction::None},
   };
 
-  for (const auto &Info: FPUFeatureInfoList) {
+  for (const auto &Info : FPUFeatureInfoList) {
     if (FPUNames[FPUKind].FPUVer >= Info.MinVersion &&
         FPUNames[FPUKind].Restriction <= Info.MaxRestriction)
       Features.push_back(Info.PlusName);
     else
       Features.push_back(Info.MinusName);
   }
 
   static const struct NeonFeatureNameInfo {
     const char *PlusName, *MinusName;
     NeonSupportLevel MinSupportLevel;
   } NeonFeatureInfoList[] = {
       {"+neon", "-neon", NeonSupportLevel::Neon},
       {"+sha2", "-sha2", NeonSupportLevel::Crypto},
       {"+aes", "-aes", NeonSupportLevel::Crypto},
   };
 
-  for (const auto &Info: NeonFeatureInfoList) {
+  for (const auto &Info : NeonFeatureInfoList) {
     if (FPUNames[FPUKind].NeonSupport >= Info.MinSupportLevel)
       Features.push_back(Info.PlusName);
     else
       Features.push_back(Info.MinusName);
   }
 
   return true;
 }

 
 unsigned ARM::getDefaultFPU(StringRef CPU, ARM::ArchKind AK) {
   if (CPU == "generic")
     return ARM::ARCHNames[static_cast<unsigned>(AK)].DefaultFPU;
 
   return StringSwitch<unsigned>(CPU)
 #define ARM_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT)           \
   .Case(NAME, DEFAULT_FPU)
-#include "llvm/Support/ARMTargetParser.def"
+#include "llvm/TargetParser/ARMTargetParser.def"
    .Default(ARM::FK_INVALID);
 }
 
 uint64_t ARM::getDefaultExtensions(StringRef CPU, ARM::ArchKind AK) {
   if (CPU == "generic")
     return ARM::ARCHNames[static_cast<unsigned>(AK)].ArchBaseExtensions;
 
   return StringSwitch<uint64_t>(CPU)
 #define ARM_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT)           \
   .Case(NAME,                                                                  \
         ARCHNames[static_cast<unsigned>(ArchKind::ID)].ArchBaseExtensions |    \
             DEFAULT_EXT)
-#include "llvm/Support/ARMTargetParser.def"
+#include "llvm/TargetParser/ARMTargetParser.def"
   .Default(ARM::AEK_INVALID);
 }
 
 bool ARM::getHWDivFeatures(uint64_t HWDivKind,
                            std::vector<StringRef> &Features) {
 
   if (HWDivKind == AEK_INVALID)
     return false;

 }
 
 ARM::ArchKind ARM::convertV9toV8(ARM::ArchKind AK) {
   if (getProfileKind(AK) != ProfileKind::A)
     return ARM::ArchKind::INVALID;
   if (AK < ARM::ArchKind::ARMV9A || AK > ARM::ArchKind::ARMV9_3A)
     return ARM::ArchKind::INVALID;
   unsigned AK_v8 = static_cast<unsigned>(ARM::ArchKind::ARMV8_5A);
-  AK_v8 += static_cast<unsigned>(AK) -
-           static_cast<unsigned>(ARM::ArchKind::ARMV9A);
+  AK_v8 +=
+      static_cast<unsigned>(AK) - static_cast<unsigned>(ARM::ArchKind::ARMV9A);
   return static_cast<ARM::ArchKind>(AK_v8);
 }
 
 StringRef ARM::getDefaultCPU(StringRef Arch) {
   ArchKind AK = parseArch(Arch);
   if (AK == ArchKind::INVALID)
     return StringRef();
 

llvm/lib/TargetParser/Unix/Host.inc

-//===- llvm/Support/Unix/Host.inc -------------------------------*- C++ -*-===//
+//===- llvm/TargetParser/Unix/Host.inc --------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the UNIX Host support.
 //
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only generic UNIX code that
 //===          is guaranteed to work on *all* UNIX variants.
 //===----------------------------------------------------------------------===//
 
-#include "Unix.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/config.h"
 #include <cctype>
 #include <string>
 #include <sys/utsname.h>
 
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
 using namespace llvm;
 
 static std::string getOSVersion() {
   struct utsname info;
 
   if (uname(&info))
     return "";
 

llvm/unittests/Support/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
+  TargetParser
   )
 
 add_llvm_unittest(SupportTests
   AddressRangeTest.cpp
   AlignmentTest.cpp
   AlignOfTest.cpp
   AllocatorTest.cpp
   AnnotationsTest.cpp
add_llvm_unittest(SupportTests
   Casting.cpp
   CheckedArithmeticTest.cpp
   Chrono.cpp
   CommandLineTest.cpp
   CompressionTest.cpp
   ConvertUTFTest.cpp
   CRCTest.cpp
   CSKYAttributeParserTest.cpp
-  CSKYTargetParserTest.cpp
   DataExtractorTest.cpp
   DebugTest.cpp
   DebugCounterTest.cpp
   DJBTest.cpp
   EndianStreamTest.cpp
   EndianTest.cpp
   ELFAttributeParserTest.cpp
   ErrnoTest.cpp
   ErrorOrTest.cpp
   ErrorTest.cpp
   ExtensibleRTTITest.cpp
   FileCollectorTest.cpp
   FileOutputBufferTest.cpp
   FileUtilitiesTest.cpp
   FormatChkTest.cpp
   FormatVariadicTest.cpp
   FSUniqueIDTest.cpp
   GlobPatternTest.cpp
   HashBuilderTest.cpp
-  Host.cpp
   IndexedAccessorTest.cpp
   InstructionCostTest.cpp
   ItaniumManglingCanonicalizerTest.cpp
   JSONTest.cpp
   KnownBitsTest.cpp
   LEB128Test.cpp
   LinearPolyBaseTest.cpp
   LineIteratorTest.cpp
add_llvm_unittest(SupportTests
   ScopedPrinterTest.cpp
   SHA256.cpp
   SourceMgrTest.cpp
   SpecialCaseListTest.cpp
   SuffixTreeTest.cpp
   SwapByteOrderTest.cpp
   SymbolRemappingReaderTest.cpp
   TarWriterTest.cpp
-  TargetParserTest.cpp
   TaskQueueTest.cpp
   ThreadLocalTest.cpp
   ThreadPool.cpp
   Threading.cpp
   TimerTest.cpp
   TimeProfilerTest.cpp
   ToolOutputFileTest.cpp
   TypeNameTest.cpp