[TargetSupport] Move TargetParser API in a separate LLVM component.

[fpetrogalli]

RFC at https://discourse.llvm.org/t/targetparser-auto-generation-of-riscv-cpu-definitions/66419

[arsenm]

I think this is fine, but think the name needs to be bikeshedded. "Target" and "Support" are already overloaded enough as it is. Is there anything else that would really ever go into this library?

[frasercrmck]

In D137516#3911245, @arsenm wrote:

I think this is fine, but think the name needs to be bikeshedded. "Target" and "Support" are already overloaded enough as it is. Is there anything else that would really ever go into this library?

I was wondering this new library could house MVTs in some form. I've wanted to auto-generate both the C++ and tablegen MVTs from a single source of truth for a while.

[lenary]

I'm not convinced we should be leaving any of the other Target Parser information in Support, if we are doing this, though this creates layering issues which I've been trying to unpick.

If you try to take llvm/Support/*TargetParser*, you find a few places where there are dependencies from these files to other bits of Support:

• llvm/Support/Host has lots of logic for turning cpu information into a target, to handle -mcpu=native. My opinion is that should also move into target parser. There are some parts of this file that can move into other parts of llvm/Support, like the introspection about number of cores.
• llvm/{Support/ADT}Triple depends on the Arm/AArch64 target parsers (because arm triples canonically look like armv7a-… or similar, and we use the targetparser to help canonicalise the triple). My opinion is that all this code can move into the target parser.

There are quite a few small cleanup patches to enable this. One of the biggest is that llvm/Support/CommmandLine wants to know the current triple and CPU for --version, even in e.g. tablegen. This was the change I most struggled with, but I think I have a solution that does the job fine.

I'm going to try to polish and post my patch set this week which does this split, as a comparison to this one.

Re the name: "TargetParser" seems reasonable to me, given that's what we've called the files so far anyway.

[fpetrogalli]

@arsenm @frasercrmck @lenary - thank you for the feedback

1. The library could host anything that needs to be auto-generated with tablegen. If we add MVTs, the name TargetSupport becomes obsolete.
2. Therefore we could use a name like AutoGenSupport (or similar, I am open to suggestions).
3. @lenary is saying that components like Support/Host needs to be moved together with the AArch64/ARM bits of the target parser. Do people see an issue if we add files that do not need auto-generated content in a library called AutoGenSupport?

[lenary]

In D137516#3912751, @fpetrogalli wrote:

@arsenm @frasercrmck @lenary - thank you for the feedback

1. The library could host anything that needs to be auto-generated with tablegen. If we add MVTs, the name TargetSupport becomes obsolete.

I am in favour of splitting parts of Support that could be table-gen'd out of Support, and into supplemental libraries.

2. Therefore we could use a name like AutoGenSupport (or similar, I am open to suggestions).

I actually think this is an awful name, even worse than "Support". One of the big issues with "Support" is that it's a junk-drawer that anyone throws stuff in when they need it anywhere in LLVM, when their layering questions become more difficult. This then becomes very hard to undo, because everything at this layer depends on everything else. "AutoGenSupport" to me says "we now have two bits, the junk drawer, and the junk drawer that's auto generated" and so I feel this is is worse, as you cannot differentiate which you need based on what you're doing.

I think we need to name things after what they're for, not how they're made.

3. @lenary is saying that components like Support/Host needs to be moved together with the AArch64/ARM bits of the target parser. Do people see an issue if we add files that do not need auto-generated content in a library called AutoGenSupport?

The reason I'm in favour of "TargetParser" is because we already call the classes and related files "target parsers", and most of them contain target-related parsers. I don't know why this is a bad name.

Edited to add: Once I've split out Support/Host, I'm likely to give it a less generic name, something like "HostDetection", which is more clearly what it is doing.

[fpetrogalli]

In D137516#3912842, @lenary wrote:

In D137516#3912751, @fpetrogalli wrote:

@arsenm @frasercrmck @lenary - thank you for the feedback

1. The library could host anything that needs to be auto-generated with tablegen. If we add MVTs, the name TargetSupport becomes obsolete.

I am in favour of splitting parts of Support that could be table-gen'd out of Support, and into supplemental libraries.

+1

2. Therefore we could use a name like AutoGenSupport (or similar, I am open to suggestions).

I actually think this is an awful name, even worse than "Support". One of the big issues with "Support" is that it's a junk-drawer that anyone throws stuff in when they need it anywhere in LLVM, when their layering questions become more difficult. This then becomes very hard to undo, because everything at this layer depends on everything else. "AutoGenSupport" to me says "we now have two bits, the junk drawer, and the junk drawer that's auto generated" and so I feel this is is worse, as you cannot differentiate which you need based on what you're doing.

I think we need to name things after what they're for, not how they're made.

Agree.

3. @lenary is saying that components like Support/Host needs to be moved together with the AArch64/ARM bits of the target parser. Do people see an issue if we add files that do not need auto-generated content in a library called AutoGenSupport?

The reason I'm in favour of "TargetParser" is because we already call the classes and related files "target parsers", and most of them contain target-related parsers. I don't know why this is a bad name.

I'd be very happy to use the name TargetParser. I initially used that because I knew that moving the RSCV bits of it meant we needed to move the other parsers too, together with Support/Host. Therefore I was trying to create a name that would have covered for both the target parser any other pieces that would have been moved in it. However...

Edited to add: Once I've split out Support/Host, I'm likely to give it a less generic name, something like "HostDetection", which is more clearly what it is doing.

... you seem to imply that you want to create a second component that is independent of [TargetParser|TargetSUpport]. If that's the case, I am even more convinced that TargetParser is the best name for the component introduced in this patch.

[lenary]

In D137516#3912900, @fpetrogalli wrote:

In D137516#3912842, @lenary wrote:

In D137516#3912751, @fpetrogalli wrote:

@arsenm @frasercrmck @lenary - thank you for the feedback

1. The library could host anything that needs to be auto-generated with tablegen. If we add MVTs, the name TargetSupport becomes obsolete.

I am in favour of splitting parts of Support that could be table-gen'd out of Support, and into supplemental libraries.

+1

2. Therefore we could use a name like AutoGenSupport (or similar, I am open to suggestions).

I actually think this is an awful name, even worse than "Support". One of the big issues with "Support" is that it's a junk-drawer that anyone throws stuff in when they need it anywhere in LLVM, when their layering questions become more difficult. This then becomes very hard to undo, because everything at this layer depends on everything else. "AutoGenSupport" to me says "we now have two bits, the junk drawer, and the junk drawer that's auto generated" and so I feel this is is worse, as you cannot differentiate which you need based on what you're doing.

I think we need to name things after what they're for, not how they're made.

Agree.

3. @lenary is saying that components like Support/Host needs to be moved together with the AArch64/ARM bits of the target parser. Do people see an issue if we add files that do not need auto-generated content in a library called AutoGenSupport?

The reason I'm in favour of "TargetParser" is because we already call the classes and related files "target parsers", and most of them contain target-related parsers. I don't know why this is a bad name.

I'd be very happy to use the name TargetParser. I initially used that because I knew that moving the RSCV bits of it meant we needed to move the other parsers too, together with Support/Host. Therefore I was trying to create a name that would have covered for both the target parser any other pieces that would have been moved in it. However...

Edited to add: Once I've split out Support/Host, I'm likely to give it a less generic name, something like "HostDetection", which is more clearly what it is doing.

... you seem to imply that you want to create a second component that is independent of [TargetParser|TargetSUpport]. If that's the case, I am even more convinced that TargetParser is the best name for the component introduced in this patch.

The patch that outlines my proposal for TargetParser is here: https://reviews.llvm.org/D137838 (it has dependent patches). I also added a comment to your RFC thread explaining the dependent patches.

[fpetrogalli]

Replaced by D137838

clang/lib/Analysis/CMakeLists.txt

add_clang_library(clangAnalysis
   ThreadSafetyTIL.cpp
   UninitializedValues.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
+  clangRewrite
+  clangToolingCore
   
   DEPENDS
   omp_gen
   )
 
 add_subdirectory(plugins)
 add_subdirectory(FlowSensitive)

clang/lib/Basic/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
+  TargetSupport
   )
 
 find_first_existing_vc_file("${LLVM_MAIN_SRC_DIR}" llvm_vc)
 find_first_existing_vc_file("${CLANG_SOURCE_DIR}" clang_vc)
 
 # The VC revision include that we want to generate.
 set(version_inc "${CMAKE_CURRENT_BINARY_DIR}/VCSVersion.inc")
 

clang/lib/Basic/TargetID.cpp

 //===--- TargetID.cpp - Utilities for parsing target ID -------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Basic/TargetID.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/Triple.h"
-#include "llvm/Support/TargetParser.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include <map>
 
 namespace clang {
 
 static llvm::SmallVector<llvm::StringRef, 4>
 getAllPossibleAMDGPUTargetIDFeatures(const llvm::Triple &T,
                                      llvm::StringRef Proc) {
   // Entries in returned vector should be in alphabetical order.

clang/lib/Basic/TargetInfo.cpp

 #include "clang/Basic/AddressSpaces.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticFrontend.h"
 #include "clang/Basic/LangOptions.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include <cstdlib>
 using namespace clang;
 
 static const LangASMap DefaultAddrSpaceMap = {0};
 
 // TargetInfo Constructor.
 TargetInfo::TargetInfo(const llvm::Triple &T) : Triple(T) {
   // Set defaults.  Defaults are set for a 32-bit RISC platform, like PPC or

clang/lib/Basic/Targets/AArch64.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_AARCH64_H
 #define LLVM_CLANG_LIB_BASIC_TARGETS_AARCH64_H
 
 #include "OSTargets.h"
 #include "clang/Basic/TargetBuiltins.h"
 #include "llvm/Support/AArch64TargetParser.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 namespace clang {
 namespace targets {
 
 class LLVM_LIBRARY_VISIBILITY AArch64TargetInfo : public TargetInfo {
   virtual void setDataLayout() = 0;
   static const TargetInfo::GCCRegAlias GCCRegAliases[];
   static const char *const GCCRegNames[];

clang/lib/Basic/Targets/AMDGPU.h

 #define LLVM_CLANG_LIB_BASIC_TARGETS_AMDGPU_H
 
 #include "clang/Basic/TargetID.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TargetOptions.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/Compiler.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 namespace clang {
 namespace targets {
 
 class LLVM_LIBRARY_VISIBILITY AMDGPUTargetInfo final : public TargetInfo {
 
   static const Builtin::Info BuiltinInfo[];
   static const char *const GCCRegNames[];

clang/lib/Basic/Targets/ARM.h

 
 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_ARM_H
 #define LLVM_CLANG_LIB_BASIC_TARGETS_ARM_H
 
 #include "OSTargets.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TargetOptions.h"
 #include "llvm/ADT/Triple.h"
-#include "llvm/Support/Compiler.h"
 #include "llvm/Support/ARMTargetParser.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 namespace clang {
 namespace targets {
 
 class LLVM_LIBRARY_VISIBILITY ARMTargetInfo : public TargetInfo {
   // Possible FPU choices.
   enum FPUMode {
     VFP2FPU = (1 << 0),

clang/lib/Basic/Targets/LoongArch.cpp

 //===--- LoongArch.cpp - Implement LoongArch target feature support -------===//
 //
 // 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 LoongArch TargetInfo objects.
 //
 //===----------------------------------------------------------------------===//
 
 #include "LoongArch.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/MacroBuilder.h"
 #include "clang/Basic/TargetBuiltins.h"
-#include "llvm/Support/TargetParser.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 using namespace clang;
 using namespace clang::targets;
 
 ArrayRef<const char *> LoongArchTargetInfo::getGCCRegNames() const {
   static const char *const GCCRegNames[] = {
       // General purpose registers.
       "$r0", "$r1", "$r2", "$r3", "$r4", "$r5", "$r6", "$r7", "$r8", "$r9",

clang/lib/Basic/Targets/M68k.cpp

 
 #include "M68k.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/TargetBuiltins.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include <cstdint>
 #include <cstring>
 #include <limits>
 
 namespace clang {
 namespace targets {
 
 M68kTargetInfo::M68kTargetInfo(const llvm::Triple &Triple,

clang/lib/Basic/Targets/RISCV.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "RISCV.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/MacroBuilder.h"
 #include "clang/Basic/TargetBuiltins.h"
 #include "llvm/ADT/StringSwitch.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 using namespace clang::targets;
 
 ArrayRef<const char *> RISCVTargetInfo::getGCCRegNames() const {
   static const char *const GCCRegNames[] = {
       // Integer registers

clang/lib/Driver/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   BinaryFormat
   MC
   Object
   Option
   ProfileData
   Support
+  TargetSupport
   WindowsDriver
   )
 
 if(WIN32)
   # MSVCToolChain.cpp uses version.dll.
   set(system_libs version)
 endif()
 

clang/lib/Driver/SanitizerArgs.cpp

 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/ToolChain.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/AArch64TargetParser.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SpecialCaseList.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Transforms/Instrumentation/AddressSanitizerOptions.h"
 #include <memory>
 
 using namespace clang;
 using namespace clang::driver;
 using namespace llvm::opt;
 

clang/lib/Driver/ToolChain.cpp

 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include <cassert>
 #include <cstddef>
 #include <cstring>
 #include <string>
 
 using namespace clang;

clang/lib/Driver/ToolChains/AMDGPU.h

 
 #include "Gnu.h"
 #include "ROCm.h"
 #include "clang/Basic/TargetID.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/Tool.h"
 #include "clang/Driver/ToolChain.h"
 #include "llvm/ADT/SmallString.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 #include <map>
 
 namespace clang {
 namespace driver {
 
 namespace tools {
 namespace amdgpu {

clang/lib/Driver/ToolChains/Arch/AArch64.cpp

 //===--- AArch64.cpp - AArch64 (not ARM) Helpers for Tools ------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "AArch64.h"
 #include "../CommonArgs.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/AArch64TargetParser.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Support/Host.h"
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 /// \returns true if the given triple can determine the default CPU type even

clang/lib/Driver/ToolChains/Arch/ARM.h

 //===--- ARM.h - ARM-specific (not AArch64) Tool Helpers --------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ARCH_ARM_H
 #define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ARCH_ARM_H
 
 #include "clang/Driver/ToolChain.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/ARMTargetParser.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace driver {
 namespace tools {
 namespace arm {
 

clang/lib/Driver/ToolChains/Arch/ARM.cpp

 //===--- ARM.cpp - ARM (not AArch64) Helpers for Tools ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "ARM.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/ARMTargetParser.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Support/Host.h"
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 // Get SubArch (vN).

clang/lib/Driver/ToolChains/Arch/CSKY.cpp

 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CSKYTargetParser.h"
 #include "llvm/Support/Host.h"
-#include "llvm/Support/TargetParser.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 llvm::Optional<llvm::StringRef>
 csky::getCSKYArchName(const Driver &D, const ArgList &Args,

clang/lib/Driver/ToolChains/Arch/RISCV.cpp

 #include "clang/Basic/CharInfo.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/RISCVISAInfo.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 // Returns false if an error is diagnosed.

clang/lib/Driver/ToolChains/Clang.cpp

 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Support/YAMLParser.h"
 #include <cctype>
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 

clang/lib/Driver/ToolChains/CommonArgs.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/ScopedPrinter.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/YAMLParser.h"
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;

clang/lib/Driver/ToolChains/Cuda.cpp

 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Program.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include <system_error>
 
 using namespace clang::driver;
 using namespace clang::driver::toolchains;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;

clang/lib/Driver/ToolChains/Darwin.cpp

 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/SanitizerArgs.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ScopedPrinter.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include <cstdlib> // ::getenv
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang::driver::toolchains;
 using namespace clang;

clang/lib/Driver/ToolChains/Gnu.cpp

 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/Tool.h"
 #include "clang/Driver/ToolChain.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include <system_error>
 
 using namespace clang::driver;
 using namespace clang::driver::toolchains;
 using namespace clang;
 using namespace llvm::opt;
 

clang/lib/Driver/ToolChains/HIPAMD.cpp

 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/InputInfo.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/SanitizerArgs.h"
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 using namespace clang::driver;
 using namespace clang::driver::toolchains;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 #if defined(_WIN32) || defined(_WIN64)

clang/unittests/Basic/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
+  TargetSupport
   )
 
 add_clang_unittest(BasicTests
   CharInfoTest.cpp
   DarwinSDKInfoTest.cpp
   DiagnosticTest.cpp
   FileEntryTest.cpp
   FileManagerTest.cpp

llvm/include/llvm/TargetSupport/RISCVTargetParser.def

 #ifndef PROC
 #define PROC(ENUM, NAME, FEATURES, DEFAULT_MARCH)
 #endif
 
 PROC(INVALID, {"invalid"}, FK_INVALID, {""})
 PROC(GENERIC_RV32, {"generic-rv32"}, FK_NONE, {""})
 PROC(GENERIC_RV64, {"generic-rv64"}, FK_64BIT, {""})
 PROC(ROCKET_RV32, {"rocket-rv32"}, FK_NONE, {""})
 PROC(ROCKET_RV64, {"rocket-rv64"}, FK_64BIT, {""})
 PROC(SIFIVE_E20, {"sifive-e20"}, FK_NONE, {"rv32imc"})
 PROC(SIFIVE_E21, {"sifive-e21"}, FK_NONE, {"rv32imac"})
 PROC(SIFIVE_E24, {"sifive-e24"}, FK_NONE, {"rv32imafc"})
 PROC(SIFIVE_E31, {"sifive-e31"}, FK_NONE, {"rv32imac"})
 PROC(SIFIVE_E34, {"sifive-e34"}, FK_NONE, {"rv32imafc"})
 PROC(SIFIVE_E76, {"sifive-e76"}, FK_NONE, {"rv32imafc"})
 PROC(SIFIVE_S21, {"sifive-s21"}, FK_64BIT, {"rv64imac"})
 PROC(SIFIVE_S51, {"sifive-s51"}, FK_64BIT, {"rv64imac"})
 PROC(SIFIVE_S54, {"sifive-s54"}, FK_64BIT, {"rv64gc"})
 PROC(SIFIVE_S76, {"sifive-s76"}, FK_64BIT, {"rv64gc"})
 PROC(SIFIVE_U54, {"sifive-u54"}, FK_64BIT, {"rv64gc"})
 PROC(SIFIVE_U74, {"sifive-u74"}, FK_64BIT, {"rv64gc"})
 
 #undef PROC
 
 #ifndef TUNE_PROC
 #define TUNE_PROC(ENUM, NAME)
 #endif
 
 TUNE_PROC(GENERIC, "generic")
 TUNE_PROC(ROCKET, "rocket")
 TUNE_PROC(SIFIVE_7, "sifive-7-series")
 
 #undef TUNE_PROC

llvm/include/llvm/TargetSupport/TargetParser.h

 //===-- TargetParser - Parser for 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 hardware features such as
 // FPU/CPU/ARCH names as well as specific support such as HDIV, etc.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_SUPPORT_TARGETPARSER_H
-#define LLVM_SUPPORT_TARGETPARSER_H
+#ifndef LLVM_TARGETSUPPORT_TARGETPARSER_H
+#define LLVM_TARGETSUPPORT_TARGETPARSER_H
 
 #include "llvm/ADT/StringRef.h"
 #include <cstdint>
 // FIXME: vector is used because that's what clang uses for subtarget feature
 // lists, but SmallVector would probably be better
 #include <vector>
 
 namespace llvm {
struct ParsedBranchProtection {
   StringRef Key;
   bool BranchTargetEnforcement;
 };
 
 bool parseBranchProtection(StringRef Spec, ParsedBranchProtection &PBP,
                            StringRef &Err);
 
 } // namespace ARM
-
 } // namespace llvm
 
-#endif
+#endif // LLVM_TARGETSUPPORT_TARGETPARSER_H

llvm/lib/CMakeLists.txt

 add_subdirectory(ObjectYAML)
 add_subdirectory(Option)
 add_subdirectory(Remarks)
 add_subdirectory(Debuginfod)
 add_subdirectory(DebugInfo)
 add_subdirectory(DWP)
 add_subdirectory(ExecutionEngine)
 add_subdirectory(Target)
+add_subdirectory(TargetSupport)
 add_subdirectory(AsmParser)
 add_subdirectory(LineEditor)
 add_subdirectory(ProfileData)
 add_subdirectory(Passes)
 add_subdirectory(TextAPI)
 add_subdirectory(ToolDrivers)
 add_subdirectory(XRay)
 if (LLVM_INCLUDE_TESTS)

llvm/lib/Support/CMakeLists.txt

add_llvm_component_library(LLVMSupport
   StringExtras.cpp
   StringMap.cpp
   StringSaver.cpp
   StringRef.cpp
   SuffixTree.cpp
   SymbolRemappingReader.cpp
   SystemUtils.cpp
   TarWriter.cpp
-  TargetParser.cpp
   ThreadPool.cpp
   TimeProfiler.cpp
   Timer.cpp
   ToolOutputFile.cpp
   TrigramIndex.cpp
   Triple.cpp
   Twine.cpp
   TypeSize.cpp

llvm/lib/Target/AArch64/AArch64Subtarget.cpp

 #include "GISel/AArch64LegalizerInfo.h"
 #include "GISel/AArch64RegisterBankInfo.h"
 #include "MCTargetDesc/AArch64AddressingModes.h"
 #include "llvm/CodeGen/GlobalISel/InstructionSelect.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineScheduler.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/Support/AArch64TargetParser.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "aarch64-subtarget"
 
 #define GET_SUBTARGETINFO_CTOR
 #define GET_SUBTARGETINFO_TARGET_DESC
 #include "AArch64GenSubtargetInfo.inc"

llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/AArch64TargetParser.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cctype>
 #include <cstdint>
 #include <cstdio>
 #include <string>
 #include <tuple>
 #include <utility>

llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp

 #include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/AMDHSAKernelDescriptor.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetMachine.h"
 
 using namespace llvm;
 using namespace llvm::AMDGPU;
 
 // This should get the default rounding mode from the kernel. We just set the
 // default here, but this could change if the OpenCL rounding mode pragmas are

llvm/lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp

 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/AMDGPUMetadata.h"
 #include "llvm/Support/AMDHSAKernelDescriptor.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/MachineValueType.h"
 #include "llvm/Support/MathExtras.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 using namespace llvm;
 using namespace llvm::AMDGPU;
 using namespace llvm::amdhsa;
 
 namespace {
 
 class AMDGPUAsmParser;

llvm/lib/Target/AMDGPU/AsmParser/CMakeLists.txt

 add_llvm_component_library(LLVMAMDGPUAsmParser
   AMDGPUAsmParser.cpp
 
   LINK_COMPONENTS
   MC
   MCParser
   AMDGPUDesc
   AMDGPUInfo
   AMDGPUUtils
   Support
+  TargetSupport
 
   ADD_TO_COMPONENT
   AMDGPU
   )
 
 add_dependencies(LLVMAMDGPUAsmParser LLVMAMDGPUUtils)

llvm/lib/Target/AMDGPU/CMakeLists.txt

add_llvm_target(AMDGPUCodeGen
   SelectionDAG
   Support
   Target
   TransformUtils
   Vectorize
   GlobalISel
   BinaryFormat
   MIRParser
+  TargetSupport
 
   ADD_TO_COMPONENT
   AMDGPU
   )
 
 add_subdirectory(AsmParser)
 add_subdirectory(Disassembler)
 add_subdirectory(MCA)
 add_subdirectory(MCTargetDesc)
 add_subdirectory(TargetInfo)
 add_subdirectory(Utils)

llvm/lib/Target/AMDGPU/GCNHazardRecognizer.cpp

 //===----------------------------------------------------------------------===//
 
 #include "GCNHazardRecognizer.h"
 #include "GCNSubtarget.h"
 #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
 #include "SIMachineFunctionInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/ScheduleDAG.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 using namespace llvm;
 
 namespace {
 
 struct MFMAPaddingRatioParser : public cl::parser<unsigned> {
   MFMAPaddingRatioParser(cl::Option &O) : cl::parser<unsigned>(O) {}
 

llvm/lib/Target/AMDGPU/MCA/AMDGPUCustomBehaviour.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_AMDGPU_MCA_AMDGPUCUSTOMBEHAVIOUR_H
 #define LLVM_LIB_TARGET_AMDGPU_MCA_AMDGPUCUSTOMBEHAVIOUR_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MCA/CustomBehaviour.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 namespace llvm {
 namespace mca {
 
 class AMDGPUInstrPostProcess : public InstrPostProcess {
   void processWaitCnt(std::unique_ptr<Instruction> &Inst, const MCInst &MCI);
 
 public:

llvm/lib/Target/AMDGPU/MCA/CMakeLists.txt

 add_llvm_component_library(LLVMAMDGPUTargetMCA
   AMDGPUCustomBehaviour.cpp
 
   LINK_COMPONENTS
   MC
   MCParser
   AMDGPUDesc
   AMDGPUInfo
   AMDGPUUtils
   Support
   MCA
+  TargetSupport
 
   ADD_TO_COMPONENT
   AMDGPU
   )
 
 add_dependencies(LLVMAMDGPUTargetMCA LLVMAMDGPUUtils)

llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUAsmBackend.cpp

 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/EndianStream.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 using namespace llvm;
 using namespace llvm::AMDGPU;
 
 namespace {
 
 class AMDGPUAsmBackend : public MCAsmBackend {
 public:

llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUInstPrinter.cpp

 #include "Utils/AMDGPUAsmUtils.h"
 #include "Utils/AMDGPUBaseInfo.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/CommandLine.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 using namespace llvm;
 using namespace llvm::AMDGPU;
 
 static cl::opt<bool> Keep16BitSuffixes(
   "amdgpu-keep-16-bit-reg-suffixes",
   cl::desc("Keep .l and .h suffixes in asm for debugging purposes"),
   cl::init(false),

llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp

 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCELFStreamer.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/AMDGPUMetadata.h"
 #include "llvm/Support/AMDHSAKernelDescriptor.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/FormattedStream.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 using namespace llvm;
 using namespace llvm::AMDGPU;
 
 //===----------------------------------------------------------------------===//
 // AMDGPUTargetStreamer
 //===----------------------------------------------------------------------===//
 

llvm/lib/Target/AMDGPU/MCTargetDesc/CMakeLists.txt

add_llvm_component_library(LLVMAMDGPUDesc
 
   LINK_COMPONENTS
   Core
   MC
   AMDGPUInfo
   AMDGPUUtils
   Support
   BinaryFormat
+  TargetSupport
 
   ADD_TO_COMPONENT
   AMDGPU
 )
 
 add_dependencies(LLVMAMDGPUDesc LLVMAMDGPUUtils)

llvm/lib/Target/AMDGPU/SIInsertWaitcnts.cpp

 #include "Utils/AMDGPUBaseInfo.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/CodeGen/MachineLoopInfo.h"
 #include "llvm/CodeGen/MachinePostDominators.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Support/DebugCounter.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "si-insert-waitcnts"
 
 DEBUG_COUNTER(ForceExpCounter, DEBUG_TYPE"-forceexp",
               "Force emit s_waitcnt expcnt(0) instrs");
 DEBUG_COUNTER(ForceLgkmCounter, DEBUG_TYPE"-forcelgkm",
               "Force emit s_waitcnt lgkmcnt(0) instrs");

llvm/lib/Target/AMDGPU/SIMemoryLegalizer.cpp

 #include "AMDGPUMachineModuleInfo.h"
 #include "GCNSubtarget.h"
 #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/Support/AtomicOrdering.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 using namespace llvm;
 using namespace llvm::AMDGPU;
 
 #define DEBUG_TYPE "si-memory-legalizer"
 #define PASS_NAME "SI Memory Legalizer"
 
 static cl::opt<bool> AmdgcnSkipCacheInvalidations(

llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp

 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/IntrinsicsAMDGPU.h"
 #include "llvm/IR/IntrinsicsR600.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/AMDHSAKernelDescriptor.h"
 #include "llvm/Support/CommandLine.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 #define GET_INSTRINFO_NAMED_OPS
 #define GET_INSTRMAP_INFO
 #include "AMDGPUGenInstrInfo.inc"
 
 static llvm::cl::opt<unsigned>
     AmdhsaCodeObjectVersion("amdhsa-code-object-version", llvm::cl::Hidden,
                             llvm::cl::desc("AMDHSA Code Object Version"),

llvm/lib/Target/AMDGPU/Utils/CMakeLists.txt

 add_llvm_component_library(LLVMAMDGPUUtils
   AMDGPUAsmUtils.cpp
   AMDGPUBaseInfo.cpp
   AMDGPUMemoryUtils.cpp
   AMDGPUPALMetadata.cpp
   AMDKernelCodeTUtils.cpp
 
   LINK_COMPONENTS
   Analysis
   Core
   MC
   BinaryFormat
   Support
+  TargetSupport
 
   ADD_TO_COMPONENT
   AMDGPU
   )

llvm/lib/Target/ARM/ARMAsmPrinter.cpp

 #include "llvm/MC/MCInstBuilder.h"
 #include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "asm-printer"
 
 ARMAsmPrinter::ARMAsmPrinter(TargetMachine &TM,
                              std::unique_ptr<MCStreamer> Streamer)

llvm/lib/Target/ARM/ARMSubtarget.cpp

 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ARMTargetParser.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Target/TargetOptions.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "arm-subtarget"
 
 #define GET_SUBTARGETINFO_TARGET_DESC
 #define GET_SUBTARGETINFO_CTOR

llvm/lib/Target/ARM/ARMTargetMachine.cpp

 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/ARMTargetParser.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Transforms/CFGuard.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/Scalar.h"
 #include <cassert>
 #include <memory>
 #include <string>

llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp

 #include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/ARMEHABI.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/SMLoc.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
 #include <limits>
 #include <memory>

llvm/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp

 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/MC/MCAsmLayout.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 namespace {
 class ARMELFObjectWriter : public MCELFObjectTargetWriter {
 public:
   ARMELFObjectWriter(uint8_t OSABI)
       : MCELFObjectTargetWriter(/*Is64Bit*/ false, OSABI, ELF::EM_ARM,

llvm/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp

 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/ARMEHABI.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormattedStream.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <climits>
 #include <cstddef>
 #include <cstdint>
 #include <string>
 

llvm/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp

 #include "llvm/MC/MCInstrAnalysis.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 using namespace llvm;
 
 #define GET_REGINFO_MC_DESC
 #include "ARMGenRegisterInfo.inc"
 
 static bool getMCRDeprecationInfo(MCInst &MI, const MCSubtargetInfo &STI,
                                   std::string &Info) {

llvm/lib/Target/ARM/MCTargetDesc/ARMTargetStreamer.cpp

 #include "MCTargetDesc/ARMMCTargetDesc.h"
 #include "llvm/MC/ConstantPools.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/ARMBuildAttributes.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 using namespace llvm;
 
 //
 // ARMTargetStreamer Implemenation
 //
 
 ARMTargetStreamer::ARMTargetStreamer(MCStreamer &S)

llvm/lib/Target/RISCV/MCTargetDesc/CMakeLists.txt

add_llvm_component_library(LLVMRISCVDesc
   RISCVMatInt.cpp
   RISCVTargetStreamer.cpp
   RISCVELFStreamer.cpp
 
   LINK_COMPONENTS
   MC
   RISCVInfo
   Support
+  MCDisassembler
+  TargetSupport
+  BinaryFormat
   
   ADD_TO_COMPONENT
   RISCV
 )

llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "RISCVBaseInfo.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/RISCVISAInfo.h"
-#include "llvm/Support/TargetParser.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 namespace llvm {
 
 extern const SubtargetFeatureKV RISCVFeatureKV[RISCV::NumSubtargetFeatures];
 
 namespace RISCVSysReg {
 #define GET_SysRegsList_IMPL
 #include "RISCVGenSearchableTables.inc"

llvm/lib/Target/RISCV/RISCVISelLowering.h

 
 #ifndef LLVM_LIB_TARGET_RISCV_RISCVISELLOWERING_H
 #define LLVM_LIB_TARGET_RISCV_RISCVISELLOWERING_H
 
 #include "RISCV.h"
 #include "llvm/CodeGen/CallingConvLower.h"
 #include "llvm/CodeGen/SelectionDAG.h"
 #include "llvm/CodeGen/TargetLowering.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 
 namespace llvm {
 class RISCVSubtarget;
 struct RISCVRegisterInfo;
 namespace RISCVISD {
 enum NodeType : unsigned {
   FIRST_NUMBER = ISD::BUILTIN_OP_END,
   RET_FLAG,

llvm/lib/Target/X86/MCA/X86CustomBehaviour.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_X86_MCA_X86CUSTOMBEHAVIOUR_H
 #define LLVM_LIB_TARGET_X86_MCA_X86CUSTOMBEHAVIOUR_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MCA/CustomBehaviour.h"
-#include "llvm/Support/TargetParser.h"
 
 namespace llvm {
 namespace mca {
 
 class X86InstrPostProcess : public InstrPostProcess {
   /// Called within X86InstrPostProcess to specify certain instructions
   /// as load and store barriers.
   void setMemBarriers(std::unique_ptr<Instruction> &Inst, const MCInst &MCI);

llvm/lib/TargetSupport/CMakeLists.txt

+add_llvm_component_library(LLVMTargetSupport
+  TargetParser.cpp
+  LINK_COMPONENTS
+  Support
+)

llvm/lib/TargetSupport/TargetParser.cpp

 //===-- TargetParser - Parser for 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 hardware features such as
 // FPU/CPU/ARCH names as well as specific support such as HDIV, etc.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 
 using namespace llvm;
 using namespace AMDGPU;
 
 namespace {
struct CPUInfo {
   unsigned Features;
   StringLiteral DefaultMarch;
   bool is64Bit() const { return (Features & FK_64BIT); }
 };
 
 constexpr CPUInfo RISCVCPUInfo[] = {
 #define PROC(ENUM, NAME, FEATURES, DEFAULT_MARCH)                              \
   {NAME, CK_##ENUM, FEATURES, DEFAULT_MARCH},
-#include "llvm/Support/RISCVTargetParser.def"
+#include "llvm/TargetSupport/RISCVTargetParser.def"
 };
 
 bool checkCPUKind(CPUKind Kind, bool IsRV64) {
   if (Kind == CK_INVALID)
     return false;
   return RISCVCPUInfo[static_cast<unsigned>(Kind)].is64Bit() == IsRV64;
 }
 
 bool checkTuneCPUKind(CPUKind Kind, bool IsRV64) {
   if (Kind == CK_INVALID)
     return false;
 #define TUNE_PROC(ENUM, NAME) if (Kind == CK_##ENUM) return true;
-#include "llvm/Support/RISCVTargetParser.def"
+#include "llvm/TargetSupport/RISCVTargetParser.def"
   return RISCVCPUInfo[static_cast<unsigned>(Kind)].is64Bit() == IsRV64;
 }
 
 CPUKind parseCPUKind(StringRef CPU) {
   return llvm::StringSwitch<CPUKind>(CPU)
 #define PROC(ENUM, NAME, FEATURES, DEFAULT_MARCH) .Case(NAME, CK_##ENUM)
-#include "llvm/Support/RISCVTargetParser.def"
+#include "llvm/TargetSupport/RISCVTargetParser.def"
       .Default(CK_INVALID);
 }
 
 CPUKind parseTuneCPUKind(StringRef TuneCPU, bool IsRV64) {
   return llvm::StringSwitch<CPUKind>(TuneCPU)
 #define PROC(ENUM, NAME, FEATURES, DEFAULT_MARCH) .Case(NAME, CK_##ENUM)
 #define TUNE_PROC(ENUM, NAME) .Case(NAME, CK_##ENUM)
-#include "llvm/Support/RISCVTargetParser.def"
+#include "llvm/TargetSupport/RISCVTargetParser.def"
       .Default(CK_INVALID);
 }
 
 StringRef getMArchFromMcpu(StringRef CPU) {
   CPUKind Kind = parseCPUKind(CPU);
   return RISCVCPUInfo[static_cast<unsigned>(Kind)].DefaultMarch;
 }
 
 void fillValidCPUArchList(SmallVectorImpl<StringRef> &Values, bool IsRV64) {
   for (const auto &C : RISCVCPUInfo) {
     if (C.Kind != CK_INVALID && IsRV64 == C.is64Bit())
       Values.emplace_back(C.Name);
   }
 }
 
 void fillValidTuneCPUArchList(SmallVectorImpl<StringRef> &Values, bool IsRV64) {
   for (const auto &C : RISCVCPUInfo) {
     if (C.Kind != CK_INVALID && IsRV64 == C.is64Bit())
       Values.emplace_back(C.Name);
   }
 #define TUNE_PROC(ENUM, NAME) Values.emplace_back(StringRef(NAME));
-#include "llvm/Support/RISCVTargetParser.def"
+#include "llvm/TargetSupport/RISCVTargetParser.def"
 }
 
 // Get all features except standard extension feature
 bool getCPUFeaturesExceptStdExt(CPUKind Kind,
                                 std::vector<StringRef> &Features) {
   unsigned CPUFeatures = RISCVCPUInfo[static_cast<unsigned>(Kind)].Features;
 
   if (CPUFeatures == FK_INVALID)

llvm/unittests/CMakeLists.txt

 add_subdirectory(ObjectYAML)
 add_subdirectory(Option)
 add_subdirectory(Remarks)
 add_subdirectory(Passes)
 add_subdirectory(ProfileData)
 add_subdirectory(Support)
 add_subdirectory(TableGen)
 add_subdirectory(Target)
+add_subdirectory(TargetSupport)
 add_subdirectory(Testing)
 add_subdirectory(TextAPI)
 add_subdirectory(Transforms)
 add_subdirectory(XRay)
 add_subdirectory(tools)

llvm/unittests/Support/CMakeLists.txt

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

llvm/unittests/Support/CSKYTargetParserTest.cpp

 //===-------- CSKYTargetParser.cpp - CSKY Target Parser -------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/CSKYTargetParser.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/CSKYAttributes.h"
 #include "llvm/Support/FormatVariadic.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "gtest/gtest.h"
 #include <string>
 
 using namespace llvm;
 
 namespace {
 
 std::string FormatExtensionFlags(uint64_t Flags) {

llvm/unittests/TargetSupport/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  TargetSupport
+  )
+
+add_llvm_unittest(TargetSupportTests
+  TargetParserTest.cpp
+  )
+
+target_link_libraries(TargetSupportTests PRIVATE LLVMTestingSupport)

llvm/unittests/TargetSupport/TargetParserTest.cpp

 //===----------- TargetParser.cpp - Target Parser -------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/AArch64TargetParser.h"
 #include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/FormatVariadic.h"
-#include "llvm/Support/TargetParser.h"
+#include "llvm/TargetSupport/TargetParser.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <string>
 
 using namespace llvm;
 
 namespace {
 const char *ARMArch[] = {