[LoongArch] Support -march=native and -mtune=

[SixWeining]

Summary

As described in [1][2], -mtune= is used to select the type of target
microarchitecture, defaults to the value of -march. The set of
possible values should be a superset of -march values. Currently
possible values of -march= and -mtune= are native, loongarch64
and la464.

D136146 has supported -march={loongarch64,la464} and this patch adds
support for -march=native and -mtune=.

A new ProcessorModel called loongarch64 is defined in LoongArch.td
to support -mtune=loongarch64.

llvm::sys::getHostCPUName() returns generic on unknown or future
LoongArch CPUs, e.g. the not yet added la664, leading to
llvm::LoongArch::isValidArchName() failing to parse the arch name.
In this case, use loongarch64 as the default arch name for 64-bit
CPUs.

Two preprocessor macros are defined based on user-provided -march=
and -mtune= options and the defaults.

• __loongarch_arch
• __loongarch_tune

Note that, to work with -fno-integrated-cc1 we leverage cc1 options
-target-cpu and -tune-cpu to pass driver options -march= and
-mtune= respectively because cc1 needs these information to define
macros in LoongArchTargetInfo::getTargetDefines.

[1]: https://github.com/loongson/LoongArch-Documentation/blob/2023.04.20/docs/LoongArch-toolchain-conventions-EN.adoc
[2]: https://github.com/loongson/la-softdev-convention/blob/v0.1/la-softdev-convention.adoc

[xry111]

Do we need to convert Xuerui's label alignment change to use the -mtune framework?

[SixWeining]

In D155824#4518597, @xry111 wrote:

Do we need to convert Xuerui's label alignment change to use the -mtune framework?

How to set the numbers if TuneCPU is empty? If there is no differences among empty, loongarch64 and la464, seems it's better to do this until we support other uarchs, e.g. la[236]64.

Just like the TODO in D148622:

63   // TODO: Check TuneCPU and override defaults (that are for LA464) once we
64   // support optimizing for more uarchs.

[xry111]

In D155824#4521047, @SixWeining wrote:

In D155824#4518597, @xry111 wrote:

Do we need to convert Xuerui's label alignment change to use the -mtune framework?

How to set the numbers if TuneCPU is empty? If there is no differences among empty, loongarch64 and la464, seems it's better to do this until we support other uarchs, e.g. la[236]64.

Just like the TODO in D148622:

63   // TODO: Check TuneCPU and override defaults (that are for LA464) once we
64   // support optimizing for more uarchs.

In GCC I added the numbers for "loongarch64" and "la464" although they are the same, and GCC does not have "empty". But yes we can do things later here.

[SixWeining]

In GCC I added the numbers for "loongarch64" and "la464" although they are the same, and GCC does not have "empty". But yes we can do things later here.

Ah, I just realize TuneCPU is always not empty because:

27 LoongArchSubtarget &LoongArchSubtarget::initializeSubtargetDependencies(
28     const Triple &TT, StringRef CPU, StringRef TuneCPU, StringRef FS,
29     StringRef ABIName) {
30   bool Is64Bit = TT.isArch64Bit();
31   if (CPU.empty() || CPU == "generic")
32     CPU = Is64Bit ? "generic-la64" : "generic-la32"; // empty CPU will be converted to generic-la{64,32}
33 
34   if (TuneCPU.empty())
35     TuneCPU = CPU; // empty TuneCPU will be converted to CPU, so TuneCPU is not empty when we all initializeProperties below
36 
37   ParseSubtargetFeatures(CPU, TuneCPU, FS);
38   initializeProperties(TuneCPU);

So, the problem is how to set numbers for generic-la{64,32} ? Currenly if we directly use clang hello.c, TuneCPU is generic-la64.

[SixWeining]

@xen0n Do you have any inputs? I think supporting these options can improve compatibility with gcc (although there is no ScheduleModel difference among currently supported processors) and I hope it can be merged into LLVM17.

[xen0n]

In D155824#4530474, @SixWeining wrote:

@xen0n Do you have any inputs? I think supporting these options can improve compatibility with gcc (although there is no ScheduleModel difference among currently supported processors) and I hope it can be merged into LLVM17.

Sorry for the late reply (busy with rewriting the doc comments for D138135). I'm in support of adding those flags, and for now I think defaulting to LA464 values would suffice.

[SixWeining]

update clang release notes

[xen0n]

Overall LGTM except one small nit, thanks!

clang/docs/ReleaseNotes.rst

902 ↗

(On Diff #543902)

"Added"? Or rephrase like "The ... options and ... macros are now supported".

[SixWeining]

Address @xen0n's comments.

[SixWeining]

add missing .

[SixWeining]

clang/docs/ReleaseNotes.rst

138–143 ↗

(On Diff #543942)

These are not for this change. (They have be cleaned up after the llvm18-init tag). I will revert it.

[steven_wu]

llvm/lib/TargetParser/LoongArchTargetParser.cpp

19

Why do we store Arch and TuneCPU as globals? We should not have as little global state in compiler as possible. Any reason why they are not stored in LoongArchTargetInfo instead like other Targets?

[steven_wu]

After another look, I will need to request to revert this because this implementation doesn't work with -fno-integrated-cc1 at all. You can't setCPU/Tune in the driver into a global variable and expect that will work during compilation.

You can reproduce with -fno-integrated-cc1 option or build clang with cmake option -DCLANG_SPAWN_CC1=On.

[SixWeining]

In D155824#4548677, @steven_wu wrote:

After another look, I will need to request to revert this because this implementation doesn't work with -fno-integrated-cc1 at all. You can't setCPU/Tune in the driver into a global variable and expect that will work during compilation.

You can reproduce with -fno-integrated-cc1 option or build clang with cmake option -DCLANG_SPAWN_CC1=On.

Thanks. I’ll investigate as soon as possible. BTW, did it break any buildbot?

[steven_wu]

In D155824#4548921, @SixWeining wrote:

In D155824#4548677, @steven_wu wrote:

After another look, I will need to request to revert this because this implementation doesn't work with -fno-integrated-cc1 at all. You can't setCPU/Tune in the driver into a global variable and expect that will work during compilation.

You can reproduce with -fno-integrated-cc1 option or build clang with cmake option -DCLANG_SPAWN_CC1=On.

Thanks. I’ll investigate as soon as possible. BTW, did it break any buildbot?

Yes, I only know this bootstrap job (has CMAKE configuration that sets CLANG_SPAWN_CC1). https://green.lab.llvm.org/green/job/clang-stage2-Rthinlto

My local revert is clean and all tests passed. I will just go ahead and revert that.

[SixWeining]

• work with -fno-integrated-cc1
• add mingsing "s in macros

[xen0n]

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

187–192

This part is identical between -march= and -mtune= handling. I'd suggest extracting out a common helper for this, or making this function generic over options::OPT_m*_EQ (whichever more suitable for you and the Clang maintainers; I don't have a particular preference).

[SixWeining]

Add a common helper for -m{arch,tune}=native handling.

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

187–192

Thanks. Just added.

[SixWeining]

rename the common helper to postProcessTargetCPUString

[xen0n]

This still LGTM, @steven_wu would you please take another look so this can get re-landed if confirmed working?

[steven_wu]

In D155824#4568904, @xen0n wrote:

This still LGTM, @steven_wu would you please take another look so this can get re-landed if confirmed working?

The driver part LGTM.

[MaskRay]

Some test suggestions

clang/lib/Basic/Targets/LoongArch.cpp

203

Use the Twine(char) constructor.

clang/test/Driver/loongarch-mtune-error.c

1

Use -### to test the driver. Consider merging this test into the loongarch-mtune.c.

[SixWeining]

Address @MaskRay's comments.

[SixWeining]

clang/lib/Basic/Targets/LoongArch.cpp

203

Thanks.

clang/test/Driver/loongarch-mtune-error.c

1

Done. Thanks.

clang/lib/Basic/Targets/LoongArch.h

 #include "llvm/TargetParser/Triple.h"
 
 namespace clang {
 namespace targets {
 
 class LLVM_LIBRARY_VISIBILITY LoongArchTargetInfo : public TargetInfo {
 protected:
   std::string ABI;
+  std::string CPU;
   bool HasFeatureD;
   bool HasFeatureF;
 
 public:
   LoongArchTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
       : TargetInfo(Triple) {
     HasFeatureD = false;
     HasFeatureF = false;
     LongDoubleWidth = 128;
     LongDoubleAlign = 128;
     LongDoubleFormat = &llvm::APFloat::IEEEquad();
     SuitableAlign = 128;
     WCharType = SignedInt;
     WIntType = UnsignedInt;
   }
 
+  bool setCPU(const std::string &Name) override {
+    if (!isValidCPUName(Name))
+      return false;
+    CPU = Name;
+    return true;
+  }
+
+  StringRef getCPU() const { return CPU; }
+
   StringRef getABI() const override { return ABI; }
 
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
 
   ArrayRef<Builtin::Info> getTargetBuiltins() const override;
 
   BuiltinVaListKind getBuiltinVaListKind() const override {
bool handleTargetFeatures(std::vector<std::string> &Features,
                             DiagnosticsEngine &Diags) override;
 
   bool
   initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
                  StringRef CPU,
                  const std::vector<std::string> &FeaturesVec) const override;
 
   bool hasFeature(StringRef Feature) const override;
+
+  bool isValidCPUName(StringRef Name) const override;
+  void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;
 };
 
 class LLVM_LIBRARY_VISIBILITY LoongArch32TargetInfo
     : public LoongArchTargetInfo {
 public:
   LoongArch32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : LoongArchTargetInfo(Triple, Opts) {
     IntPtrType = SignedInt;

clang/lib/Basic/Targets/LoongArch.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "LoongArch.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/MacroBuilder.h"
 #include "clang/Basic/TargetBuiltins.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/TargetParser/TargetParser.h"
+#include "llvm/TargetParser/LoongArchTargetParser.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",
void LoongArchTargetInfo::getTargetDefines(const LangOptions &Opts,
 
   if (HasFeatureD)
     Builder.defineMacro("__loongarch_frlen", "64");
   else if (HasFeatureF)
     Builder.defineMacro("__loongarch_frlen", "32");
   else
     Builder.defineMacro("__loongarch_frlen", "0");
 
-  // TODO: define __loongarch_arch and __loongarch_tune.
+  // Define __loongarch_arch.
+  StringRef ArchName = getCPU();
+  Builder.defineMacro("__loongarch_arch", Twine("\"") + ArchName + Twine("\""));
+
+  // Define __loongarch_tune.
+  StringRef TuneCPU = getTargetOpts().TuneCPU;
+  if (TuneCPU.empty())
+    TuneCPU = ArchName;
+  Builder.defineMacro("__loongarch_tune", Twine("\"") + TuneCPU + Twine("\""));
 
   StringRef ABI = getABI();
   if (ABI == "lp64d" || ABI == "lp64f" || ABI == "lp64s")
     Builder.defineMacro("__loongarch_lp64");
 
   if (ABI == "lp64d" || ABI == "ilp32d") {
     Builder.defineMacro("__loongarch_hard_float");
     Builder.defineMacro("__loongarch_double_float");
if (Feature == "+d" || Feature == "+f") {
       HasFeatureF = true;
       if (Feature == "+d") {
         HasFeatureD = true;
       }
     }
   }
   return true;
 }
+
+bool LoongArchTargetInfo::isValidCPUName(StringRef Name) const {
+  return llvm::LoongArch::isValidCPUName(Name);
+}
+
+void LoongArchTargetInfo::fillValidCPUList(
+    SmallVectorImpl<StringRef> &Values) const {
+  llvm::LoongArch::fillValidCPUList(Values);
+}

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

 namespace tools {
 namespace loongarch {
 void getLoongArchTargetFeatures(const Driver &D, const llvm::Triple &Triple,
                                 const llvm::opt::ArgList &Args,
                                 std::vector<llvm::StringRef> &Features);
 
 StringRef getLoongArchABI(const Driver &D, const llvm::opt::ArgList &Args,
                           const llvm::Triple &Triple);
+
+std::string postProcessTargetCPUString(const std::string &CPU,
+                                       const llvm::Triple &Triple);
+
+std::string getLoongArchTargetCPU(const llvm::opt::ArgList &Args,
+                                  const llvm::Triple &Triple);
 } // end namespace loongarch
 } // end namespace tools
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ARCH_LOONGARCH_H

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

 //===--- LoongArch.cpp - LoongArch 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 "LoongArch.h"
 #include "ToolChains/CommonArgs.h"
 #include "clang/Basic/DiagnosticDriver.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
+#include "llvm/TargetParser/Host.h"
 #include "llvm/TargetParser/LoongArchTargetParser.h"
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 StringRef loongarch::getLoongArchABI(const Driver &D, const ArgList &Args,
default:
     return IsLA32 ? "ilp32d" : "lp64d";
   }
 }
 
 void loongarch::getLoongArchTargetFeatures(const Driver &D,
                                            const llvm::Triple &Triple,
                                            const ArgList &Args,
                                            std::vector<StringRef> &Features) {
-  StringRef ArchName;
-  if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
-    if (!llvm::LoongArch::isValidArchName(A->getValue())) {
-      D.Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args);
-      return;
-    }
+  std::string ArchName;
+  if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
     ArchName = A->getValue();
-  }
-
-  // TODO: handle -march=native and -mtune=xx.
-
-  // Select a default arch name.
-  if (ArchName.empty() && Triple.isLoongArch64())
-    ArchName = "loongarch64";
-
-  if (!ArchName.empty())
-    llvm::LoongArch::getArchFeatures(ArchName, Features);
+  ArchName = postProcessTargetCPUString(ArchName, Triple);
 
   // Select floating-point features determined by -mdouble-float,
   // -msingle-float, -msoft-float and -mfpu.
   // Note: -m*-float wins any other options.
   if (const Arg *A = Args.getLastArg(options::OPT_mdouble_float,
                                      options::OPT_msingle_float,
                                      options::OPT_msoft_float)) {
     if (A->getOption().matches(options::OPT_mdouble_float)) {
AddTargetFeature(Args, Features, options::OPT_munaligned_access,
                    options::OPT_mno_unaligned_access, "ual");
 
   // Accept but warn about these TargetSpecific options.
   if (Arg *A = Args.getLastArgNoClaim(options::OPT_mabi_EQ))
     A->ignoreTargetSpecific();
   if (Arg *A = Args.getLastArgNoClaim(options::OPT_mfpu_EQ))
     A->ignoreTargetSpecific();
 }
+
+std::string loongarch::postProcessTargetCPUString(const std::string &CPU,
+                                                  const llvm::Triple &Triple) {
+  std::string CPUString = CPU;
+  if (CPUString == "native") {
+    CPUString = llvm::sys::getHostCPUName();
+    if (CPUString == "generic")
+      CPUString = llvm::LoongArch::getDefaultArch(Triple.isLoongArch64());
+  }
+  if (CPUString.empty())
+    CPUString = llvm::LoongArch::getDefaultArch(Triple.isLoongArch64());
+  return CPUString;
+}
+
+std::string loongarch::getLoongArchTargetCPU(const llvm::opt::ArgList &Args,
+                                             const llvm::Triple &Triple) {
+  std::string CPU;
+  // If we have -march, use that.
+  if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
+    CPU = A->getValue();
+  return postProcessTargetCPUString(CPU, Triple);
+}

clang/lib/Driver/ToolChains/Clang.cpp

 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/RISCVISAInfo.h"
 #include "llvm/Support/YAMLParser.h"
 #include "llvm/TargetParser/ARMTargetParserCommon.h"
 #include "llvm/TargetParser/Host.h"
+#include "llvm/TargetParser/LoongArchTargetParser.h"
 #include "llvm/TargetParser/RISCVTargetParser.h"
 #include <cctype>
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
else
       CmdArgs.push_back(A->getValue());
   }
 
   AddUnalignedAccessWarning(CmdArgs);
 }
 
 void Clang::AddLoongArchTargetArgs(const ArgList &Args,
                                    ArgStringList &CmdArgs) const {
+  const llvm::Triple &Triple = getToolChain().getTriple();
+
   CmdArgs.push_back("-target-abi");
-  CmdArgs.push_back(loongarch::getLoongArchABI(getToolChain().getDriver(), Args,
-                                               getToolChain().getTriple())
-                        .data());
+  CmdArgs.push_back(
+      loongarch::getLoongArchABI(getToolChain().getDriver(), Args, Triple)
+
+  // Handle -mtune.
+  if (const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
+    std::string TuneCPU = A->getValue();
+    TuneCPU = loongarch::postProcessTargetCPUString(TuneCPU, Triple);
+    CmdArgs.push_back("-tune-cpu");
+    CmdArgs.push_back(Args.MakeArgString(TuneCPU));
+  }
 }
 
 void Clang::AddMIPSTargetArgs(const ArgList &Args,
                               ArgStringList &CmdArgs) const {
   const Driver &D = getToolChain().getDriver();
   StringRef CPUName;
   StringRef ABIName;
   const llvm::Triple &Triple = getToolChain().getTriple();

clang/lib/Driver/ToolChains/CommonArgs.cpp

std::string tools::getCPUName(const Driver &D, const ArgList &Args,
 
   case llvm::Triple::r600:
   case llvm::Triple::amdgcn:
     return getAMDGPUTargetGPU(T, Args);
 
   case llvm::Triple::wasm32:
   case llvm::Triple::wasm64:
     return std::string(getWebAssemblyTargetCPU(Args));
+
+  case llvm::Triple::loongarch32:
+  case llvm::Triple::loongarch64:
+    return loongarch::getLoongArchTargetCPU(Args, T);
   }
 }
 
 static void getWebAssemblyTargetFeatures(const Driver &D,
                                          const llvm::Triple &Triple,
                                          const ArgList &Args,
                                          std::vector<StringRef> &Features) {
   handleTargetFeaturesGroup(D, Triple, Args, Features,

clang/test/Driver/loongarch-march-error.c

 // RUN: not %clang --target=loongarch64 -march=loongarch -fsyntax-only %s 2>&1 | \
-// RUN:   FileCheck --check-prefix=LOONGARCH %s
-// LOONGARCH: error: invalid arch name '-march=loongarch'
-
+// RUN:   FileCheck -DCPU=loongarch %s
 // RUN: not %clang --target=loongarch64 -march=LA464 -fsyntax-only %s 2>&1 | \
-// RUN:   FileCheck --check-prefix=LA464-UPPER %s
-// LA464-UPPER: error: invalid arch name '-march=LA464'
+// RUN:   FileCheck -DCPU=LA464 %s
+
+// CHECK: error: unknown target CPU '[[CPU]]'
+// CHECK-NEXT: note: valid target CPU values are: {{.*}}

clang/test/Driver/loongarch-march.c

 // RUN: %clang --target=loongarch64 -march=loongarch64 -fsyntax-only %s -### 2>&1 | \
 // RUN:   FileCheck %s --check-prefix=CC1-LOONGARCH64
 // RUN: %clang --target=loongarch64 -march=la464 -fsyntax-only %s -### 2>&1 | \
 // RUN:   FileCheck %s --check-prefix=CC1-LA464
 // RUN: %clang --target=loongarch64 -march=loongarch64 -S -emit-llvm %s -o - | \
 // RUN:   FileCheck %s --check-prefix=IR-LOONGARCH64
 // RUN: %clang --target=loongarch64 -march=la464 -S -emit-llvm %s -o - | \
 // RUN:   FileCheck %s --check-prefix=IR-LA464
 
+// CC1-LOONGARCH64: "-target-cpu" "loongarch64"
 // CC1-LOONGARCH64-NOT: "-target-feature"
 // CC1-LOONGARCH64: "-target-feature" "+64bit" "-target-feature" "+f" "-target-feature" "+d" "-target-feature" "+ual"
 // CC1-LOONGARCH64-NOT: "-target-feature"
 // CC1-LOONGARCH64: "-target-abi" "lp64d"
 
+// CC1-LA464: "-target-cpu" "la464"
 // CC1-LA464-NOT: "-target-feature"
 // CC1-LA464: "-target-feature" "+64bit" "-target-feature" "+f" "-target-feature" "+d" "-target-feature" "+lsx" "-target-feature" "+lasx" "-target-feature" "+ual"
 // CC1-LA464-NOT: "-target-feature"
 // CC1-LA464: "-target-abi" "lp64d"
 
-// IR-LOONGARCH64: attributes #[[#]] ={{.*}}"target-features"="+64bit,+d,+f,+ual"
-// IR-LA464: attributes #[[#]] ={{.*}}"target-features"="+64bit,+d,+f,+lasx,+lsx,+ual"
+// IR-LOONGARCH64: attributes #[[#]] ={{.*}}"target-cpu"="loongarch64" {{.*}}"target-features"="+64bit,+d,+f,+ual"
+// IR-LA464: attributes #[[#]] ={{.*}}"target-cpu"="la464" {{.*}}"target-features"="+64bit,+d,+f,+lasx,+lsx,+ual"
 
 int foo(void) {
   return 3;
 }

clang/test/Driver/loongarch-mtune-error.c

+// RUN: not %clang --target=loongarch64 -mtune=invalidcpu -fsyntax-only %s 2>&1 | FileCheck %s
+// RUN: not %clang --target=loongarch64 -mtune=generic -fsyntax-only %s 2>&1 | FileCheck %s
+// RUN: not %clang --target=loongarch64 -mtune=generic-la64 -fsyntax-only %s 2>&1 | FileCheck %s
+
+// CHECK: error: unknown target CPU '{{.*}}'
+// CHECK-NEXT: note: valid target CPU values are: {{.*}}

clang/test/Driver/loongarch-mtune.c

+// RUN: %clang --target=loongarch64 -mtune=loongarch64 -fsyntax-only %s -### 2>&1 | \
+// RUN:   FileCheck %s --check-prefix=CC1ARG -DCPU=loongarch64
+// RUN: %clang --target=loongarch64 -mtune=loongarch64 -S -emit-llvm %s -o - | \
+// RUN:   FileCheck %s --check-prefix=IRATTR -DCPU=loongarch64
+//
+// RUN: %clang --target=loongarch64 -mtune=la464 -fsyntax-only %s -### 2>&1 | \
+// RUN:   FileCheck %s --check-prefix=CC1ARG -DCPU=la464
+// RUN: %clang --target=loongarch64 -mtune=la464 -S -emit-llvm %s -o - | \
+// RUN:   FileCheck %s --check-prefix=IRATTR -DCPU=la464
+
+// CC1ARG: "-tune-cpu" "[[CPU]]"
+// IRATTR: "tune-cpu"="[[CPU]]"
+
+int foo(void) {
+  return 3;
+}

clang/test/Preprocessor/init-loongarch.c

 // RUN:   | FileCheck --match-full-lines --check-prefix=LA64-FPU0-LP64S %s
 // LA64-FPU0-LP64S-NOT: #define __loongarch_double_float
 // LA64-FPU0-LP64S: #define __loongarch_frlen 0
 // LA64-FPU0-LP64S: #define __loongarch_grlen 64
 // LA64-FPU0-LP64S-NOT: #define __loongarch_hard_float
 // LA64-FPU0-LP64S: #define __loongarch_lp64 1
 // LA64-FPU0-LP64S-NOT: #define __loongarch_single_float
 // LA64-FPU0-LP64S: #define __loongarch_soft_float 1
+
+/// Check __loongarch_arch and __loongarch_tune.
+
+// RUN: %clang --target=loongarch64 -x c -E -dM %s -o - | \
+// RUN:   FileCheck --match-full-lines --check-prefix=ARCH-TUNE -DARCH=loongarch64 -DTUNE=loongarch64 %s
+// RUN: %clang --target=loongarch64 -x c -E -dM %s -o - -march=loongarch64 | \
+// RUN:   FileCheck --match-full-lines --check-prefix=ARCH-TUNE -DARCH=loongarch64 -DTUNE=loongarch64 %s
+// RUN: %clang --target=loongarch64 -x c -E -dM %s -o - -march=la464 | \
+// RUN:   FileCheck --match-full-lines --check-prefix=ARCH-TUNE -DARCH=la464 -DTUNE=la464 %s
+// RUN: %clang --target=loongarch64 -x c -E -dM %s -o - -mtune=loongarch64 | \
+// RUN:   FileCheck --match-full-lines --check-prefix=ARCH-TUNE -DARCH=loongarch64 -DTUNE=loongarch64 %s
+// RUN: %clang --target=loongarch64 -x c -E -dM %s -o - -mtune=la464 | \
+// RUN:   FileCheck --match-full-lines --check-prefix=ARCH-TUNE -DARCH=loongarch64 -DTUNE=la464 %s
+// RUN: %clang --target=loongarch64 -x c -E -dM %s -o - -march=loongarch64 -mtune=la464 | \
+// RUN:   FileCheck --match-full-lines --check-prefix=ARCH-TUNE -DARCH=loongarch64 -DTUNE=la464 %s
+// RUN: %clang --target=loongarch64 -x c -E -dM %s -o - -march=la464 -mtune=loongarch64 | \
+// RUN:   FileCheck --match-full-lines --check-prefix=ARCH-TUNE -DARCH=la464 -DTUNE=loongarch64 %s
+
+// ARCH-TUNE: #define __loongarch_arch "[[ARCH]]"
+// ARCH-TUNE: #define __loongarch_tune "[[TUNE]]"

llvm/include/llvm/TargetParser/LoongArchTargetParser.h

 struct ArchInfo {
   StringRef Name;
   ArchKind Kind;
   uint32_t Features;
 };
 
 bool isValidArchName(StringRef Arch);
 bool getArchFeatures(StringRef Arch, std::vector<StringRef> &Features);
+bool isValidCPUName(StringRef TuneCPU);
+void fillValidCPUList(SmallVectorImpl<StringRef> &Values);
+StringRef getDefaultArch(bool Is64Bit);
 
 } // namespace LoongArch
 
 } // namespace llvm
 
-#endif // LLVM_SUPPORT_LOONGARCHTARGETPARSER_H
+#endif // LLVM_TARGETPARSER_LOONGARCHTARGETPARSER_H

llvm/lib/Target/LoongArch/LoongArch.td

 
 //===----------------------------------------------------------------------===//
 // LoongArch processors supported.
 //===----------------------------------------------------------------------===//
 
 def : ProcessorModel<"generic-la32", NoSchedModel, [Feature32Bit]>;
 def : ProcessorModel<"generic-la64", NoSchedModel, [Feature64Bit, FeatureUAL]>;
 
+// Generic 64-bit processor with double-precision floating-point support.
+def : ProcessorModel<"loongarch64", NoSchedModel, [Feature64Bit,
+                                                   FeatureUAL,
+                                                   FeatureBasicD]>;
+
 // Support generic for compatibility with other targets. The triple will be used
 // to change to the appropriate la32/la64 version.
 def : ProcessorModel<"generic", NoSchedModel, []>;
 
 def : ProcessorModel<"la464", NoSchedModel, [Feature64Bit,
                                              FeatureUAL,
                                              FeatureExtLASX,
                                              FeatureExtLVZ,

llvm/lib/TargetParser/LoongArchTargetParser.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/TargetParser/LoongArchTargetParser.h"
 
 using namespace llvm;
 using namespace llvm::LoongArch;
 
 const FeatureInfo AllFeatures[] = {
 #define LOONGARCH_FEATURE(NAME, KIND) {NAME, KIND},
 #include "llvm/TargetParser/LoongArchTargetParser.def"
 };
 
 const ArchInfo AllArchs[] = {
 #define LOONGARCH_ARCH(NAME, KIND, FEATURES)                                   \
   {NAME, LoongArch::ArchKind::KIND, FEATURES},
 #include "llvm/TargetParser/LoongArchTargetParser.def"
if (A.Name == Arch) {
       for (const auto F : AllFeatures)
         if ((A.Features & F.Kind) == F.Kind)
           Features.push_back(F.Name);
       return true;
     }
   }
   return false;
 }
+
+bool LoongArch::isValidCPUName(StringRef Name) { return isValidArchName(Name); }
+
+void LoongArch::fillValidCPUList(SmallVectorImpl<StringRef> &Values) {
+  for (const auto A : AllArchs)
+    Values.emplace_back(A.Name);
+}
+
+StringRef LoongArch::getDefaultArch(bool Is64Bit) {
+  // TODO: use a real 32-bit arch name.
+  return Is64Bit ? "loongarch64" : "";
+}

llvm/test/CodeGen/LoongArch/cpus-invalid.ll

+; RUN: llc < %s --mtriple=loongarch64 --mattr=+64bit --mcpu=invalidcpu 2>&1 | FileCheck %s
+
+; CHECK: {{.*}} is not a recognized processor for this target
+
+define void @f() {
+  ret void
+}

llvm/test/CodeGen/LoongArch/cpus.ll

+;; This tests that llc accepts all valid LoongArch CPUs.
+;; Note the 'generic' names have been tested in cpu-name-generic.ll.
+
+; RUN: llc < %s --mtriple=loongarch64 --mcpu=loongarch64 2>&1 | FileCheck %s
+; RUN: llc < %s --mtriple=loongarch64 --mcpu=la464 2>&1 | FileCheck %s
+; RUN: llc < %s --mtriple=loongarch64 2>&1 | FileCheck %s
+
+; CHECK-NOT: {{.*}} is not a recognized processor for this target
+
+define void @f() {
+  ret void
+}
+
+define void @tune_cpu_loongarch64() "tune-cpu"="loongarch64" {
+  ret void
+}
+
+define void @tune_cpu_la464() "tune-cpu"="la464" {
+  ret void
+}