[Clang][LoongArch] Handle -march/-m{single,double,soft}-float/-mfpu options

[SixWeining]

Summary

This patch adds options -march, -msingle-float, -mdouble-float,
-msoft-float and -mfpu for LoongArch.

Clang options msingle_float and mdouble_float are moved from
m_mips_Features_Group to m_Group because now more than one targets
use them.

Reference:
https://github.com/loongson/LoongArch-Documentation/blob/main/docs/LoongArch-toolchain-conventions-EN.adoc

TODO: add -mtune.

[xen0n]

Looks good LoongArch-wise but I'm not very familiar with Clang internals to start with. Might be okay to land since this touches little code outside LoongArch and has passed tests.

[MaskRay]

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

31

This is strange. Other architectures using -msoft-float makes it orthogonal to -mdouble-float...

Instead of having -mdouble-float/-msingle-float, can you just use -mfloat-abi=?

44

It's better to stick with just one canonical spelling. Is there time to remove support for one set of options? When -mfpu=64 -msoft-float is specified, is a -Wunused-command-line-argument warning expected?

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

2

The more common style is to place | in the end. The idea is that even without \, after typing the first line in a shell, it will wait for the second line.

clang/test/Driver/loongarch-march.c

13

Check target-feature options on one line

clang/test/Driver/loongarch-mdouble-float.c

9

Check target-feature options on one line

14

Replace {{[0-9]+}} with [[#]]

16

Delete unneeded comment

18

excess space

llvm/lib/Support/LoongArchTargetParser.cpp

36

delete braces

47

delete braces

[xry111]

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

44

According to the doc, the semantics of -mfpu=64 and -mdouble-float are not exactly same. -mfpu=64 -mabi=lp64s will allow the compiler to generate 64-bit floating-point instructions but keep LP64S calling convention. -mdouble-float -mabi=lp64s will be same as -mdouble-float -mabi=lp64d (with a warning emitted, maybe).

[SixWeining]

Sorry for the late reply.

Should we choose not to implement the -mfpu= option which is not mandatory?

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

31

Sorry for the late reply.

Similar to @xry111's explanation below, -m{double,single,soft}-float are different from -mfpu={64,32,0,none}.

-m{double,single,soft}-float affect both codegen-ed instructions and the ABI while -mfpu={64,32,0,none} only affect the codegen-ed instructions.

That is to say:

• -mdouble-float implies -mfpu=64 and -mabi={lp64d,ilp32d};
• -msingle-float implies -mfpu=32 and -mabi={lp64f,ilp32f};
• -msoft-float implies -mfpu={0,none} and -mabi={lp64s,ilp32s}.

The -mfpu={64,32,0,none} clang option is like the --mattr=+{d,f} llc option. And the -mabi= clang option is like the --target-abi= llc option.

But I have to admit this introduce some complexity to clang implementation because we have to take care of the order these options appear on the command line. The doc says:

As a general rule, the effect of all LoongArch-specific compiler options that are given for one compiler invocation should be as if they are processed in the order they appear on the command line. The only exception to this rule is -m*-float: their configuration of floating-point instruction set and calling convention will not be changed by subsequent options other than -m*-float.

44

The doc says that the implementation of -mfpu is not mandatory. So maybe we can choose not to implement it? But I'm not sure whether it has been used by any programs.

-mdouble-float -mabi=lp64s will be same as -mdouble-float -mabi=lp64d (with a warning emitted, maybe).

Yes, I think so. GCC indeed emits a warning. We also should emit one.

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

2

OK. But seems both styles are used in the code base. -;)

clang/test/Driver/loongarch-march.c

13

OK.

llvm/lib/Support/LoongArchTargetParser.cpp

47

OK.

[SixWeining]

Add test for warning: argument unused during compilation. And address other comments from @MaskRay.

[MaskRay]

In D136146#3911137, @SixWeining wrote:

Sorry for the late reply.

Should we choose not to implement the -mfpu= option which is not mandatory?

OK, I accept the -mfpu= different from -m*-float. If the patch does not implement the required semantics, deferring -mfpu= implementation may be good.
We can also check how many pieces of software actually use -mfpu= and some unneeded uses may be removed?

clang/include/clang/Basic/DiagnosticDriverKinds.td

696

0, none (alias for 0) or none, 0 (alias for none)

Ideally only one spelling is retained... No need to implement an alias if -mfpu= itself is niche.

llvm/lib/Support/LoongArchTargetParser.cpp

47

for (const auto A : AllArchs) needs braces since the nested if (A.Name == Arch) { has braces.

[SixWeining]

Revise the err_drv_loongarch_invalid_mfpu_EQ diagnostic info. Add necessary braces.

[SixWeining]

This change was pushed yesterday, but it's not the last diff. I will submit a follow-up change as soon as possible.

clang/include/clang/Basic/DiagnosticDriverKinds.td

def err_drv_invalid_empty_dxil_validator_version : Error<
   "If validator major version is 0, minor version must also be 0.">;
 
 def warn_drv_sarif_format_unstable : Warning<
   "diagnostic formatting in SARIF mode is currently unstable">,
   InGroup<DiagGroup<"sarif-format-unstable">>;
 
 def err_drv_riscv_unsupported_with_linker_relaxation : Error<
   "%0 is unsupported with RISC-V linker relaxation (-mrelax)">;
+
+def err_drv_loongarch_invalid_mfpu_EQ : Error<
+  "invalid argument '%0' to -mfpu=; must be one of: 64, 32, 0, none">;
 }

clang/include/clang/Driver/Options.td

def mno_branch_likely : Flag<["-"], "mno-branch-likely">, Group<m_Group>,
   IgnoredGCCCompat;
 def mindirect_jump_EQ : Joined<["-"], "mindirect-jump=">,
   Group<m_mips_Features_Group>,
   HelpText<"Change indirect jump instructions to inhibit speculation">;
 def mdsp : Flag<["-"], "mdsp">, Group<m_mips_Features_Group>;
 def mno_dsp : Flag<["-"], "mno-dsp">, Group<m_mips_Features_Group>;
 def mdspr2 : Flag<["-"], "mdspr2">, Group<m_mips_Features_Group>;
 def mno_dspr2 : Flag<["-"], "mno-dspr2">, Group<m_mips_Features_Group>;
-def msingle_float : Flag<["-"], "msingle-float">, Group<m_mips_Features_Group>;
-def mdouble_float : Flag<["-"], "mdouble-float">, Group<m_mips_Features_Group>;
+def msingle_float : Flag<["-"], "msingle-float">, Group<m_Group>;
+def mdouble_float : Flag<["-"], "mdouble-float">, Group<m_Group>;
 def mmadd4 : Flag<["-"], "mmadd4">, Group<m_mips_Features_Group>,
   HelpText<"Enable the generation of 4-operand madd.s, madd.d and related instructions.">;
 def mno_madd4 : Flag<["-"], "mno-madd4">, Group<m_mips_Features_Group>,
   HelpText<"Disable the generation of 4-operand madd.s, madd.d and related instructions.">;
 def mmsa : Flag<["-"], "mmsa">, Group<m_mips_Features_Group>,
   HelpText<"Enable MSA ASE (MIPS only)">;
 def mno_msa : Flag<["-"], "mno-msa">, Group<m_mips_Features_Group>,
   HelpText<"Disable MSA ASE (MIPS only)">;

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

 #include "clang/Driver/Driver.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Option/Option.h"
 
 namespace clang {
 namespace driver {
 namespace tools {
 namespace loongarch {
-StringRef getLoongArchABI(const llvm::opt::ArgList &Args,
+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);
 
 void getLoongArchTargetFeatures(const Driver &D, const llvm::Triple &Triple,
                                 const llvm::opt::ArgList &Args,
                                 std::vector<llvm::StringRef> &Features);
 } // 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 "clang/Basic/DiagnosticDriver.h"
+#include "clang/Driver/Driver.h"
+#include "clang/Driver/DriverDiagnostic.h"
+#include "clang/Driver/Options.h"
+#include "llvm/Support/LoongArchTargetParser.h"
 
+using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
-StringRef loongarch::getLoongArchABI(const ArgList &Args,
+StringRef loongarch::getLoongArchABI(const Driver &D, const ArgList &Args,
                                      const llvm::Triple &Triple) {
   assert((Triple.getArch() == llvm::Triple::loongarch32 ||
           Triple.getArch() == llvm::Triple::loongarch64) &&
          "Unexpected triple");
+  bool IsLA32 = Triple.getArch() == llvm::Triple::loongarch32;
+
+  // Check -m*-float firstly since they have highest priority.
+  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))
+      return IsLA32 ? "ilp32d" : "lp64d";
+    if (A->getOption().matches(options::OPT_msingle_float))
+      return IsLA32 ? "ilp32f" : "lp64f";
+    if (A->getOption().matches(options::OPT_msoft_float))
+      return IsLA32 ? "ilp32s" : "lp64s";
+  }
 
   // If `-mabi=` is specified, use it.
   if (const Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
     return A->getValue();
 
+  // Select abi based on -mfpu=xx.
+  if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) {
+    StringRef FPU = A->getValue();
+    if (FPU == "64")
+      return IsLA32 ? "ilp32d" : "lp64d";
+    if (FPU == "32")
+      return IsLA32 ? "ilp32f" : "lp64f";
+    if (FPU == "0" || FPU == "none")
+      return IsLA32 ? "ilp32s" : "lp64s";
+    D.Diag(diag::err_drv_loongarch_invalid_mfpu_EQ) << FPU;
+  }
+
   // Choose a default based on the triple.
-  // TODO: select appropiate ABI.
-  return Triple.getArch() == llvm::Triple::loongarch32 ? "ilp32d" : "lp64d";
+  return IsLA32 ? "ilp32d" : "lp64d";
 }
 
 void loongarch::getLoongArchTargetFeatures(const Driver &D,
                                            const llvm::Triple &Triple,
                                            const ArgList &Args,
                                            std::vector<StringRef> &Features) {
-  // FIXME: hornor various clang options that may affect target features, e.g.
-  // -march/-mtune/-mdouble-float/-msingle-float/-msoft-float/-mfpu. See:
-  // https://loongson.github.io/LoongArch-Documentation/LoongArch-toolchain-conventions-EN.html
+  StringRef ArchName;
+  llvm::LoongArch::ArchKind ArchKind = llvm::LoongArch::ArchKind::AK_INVALID;
+  if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
+    ArchKind = llvm::LoongArch::parseArch(A->getValue());
+    if (ArchKind == llvm::LoongArch::ArchKind::AK_INVALID) {
+      D.Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args);
+      return;
+    }
+    ArchName = A->getValue();
+  }
+
+  // TODO: handle -march=native and -mtune=xx.
+
+  // Select a default arch name.
+  if (ArchName.empty() && Triple.getArch() == llvm::Triple::loongarch64)
+    ArchName = "loongarch64";
+
+  if (!ArchName.empty())
+    llvm::LoongArch::getArchFeatures(ArchName, Features);
+
+  // 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)) {
       Features.push_back("+f");
       Features.push_back("+d");
+    } else if (A->getOption().matches(options::OPT_msingle_float)) {
+      Features.push_back("+f");
+      Features.push_back("-d");
+    } else /*Soft-float*/ {
+      Features.push_back("-f");
+      Features.push_back("-d");
+    }
+  } else if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) {
+    StringRef FPU = A->getValue();
+    if (FPU == "64") {
+      Features.push_back("+f");
+      Features.push_back("+d");
+    } else if (FPU == "32") {
+      Features.push_back("+f");
+      Features.push_back("-d");
+    } else if (FPU == "0" || FPU == "none") {
+      Features.push_back("-f");
+      Features.push_back("-d");
+    } else {
+      D.Diag(diag::err_drv_loongarch_invalid_mfpu_EQ) << FPU;
+    }
+  }
 }

clang/lib/Driver/ToolChains/Clang.cpp

void Clang::AddAArch64TargetArgs(const ArgList &Args,
   }
 
   AddUnalignedAccessWarning(CmdArgs);
 }
 
 void Clang::AddLoongArchTargetArgs(const ArgList &Args,
                                    ArgStringList &CmdArgs) const {
   CmdArgs.push_back("-target-abi");
-  CmdArgs.push_back(
-      loongarch::getLoongArchABI(Args, getToolChain().getTriple()).data());
+  CmdArgs.push_back(loongarch::getLoongArchABI(getToolChain().getDriver(), Args,
+                                               getToolChain().getTriple())
+                        .data());
 }
 
 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/Linux.cpp

const bool HF =
         tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard;
 
     LibDir = "lib";
     Loader = HF ? "ld-linux-armhf.so.3" : "ld-linux.so.3";
     break;
   }
   case llvm::Triple::loongarch32: {
     LibDir = "lib32";
-    Loader = ("ld-linux-loongarch-" +
-              tools::loongarch::getLoongArchABI(Args, Triple) + ".so.1")
-                 .str();
+    Loader =
+        ("ld-linux-loongarch-" +
+         tools::loongarch::getLoongArchABI(getDriver(), Args, Triple) + ".so.1")
     break;
   }
   case llvm::Triple::loongarch64: {
     LibDir = "lib64";
-    Loader = ("ld-linux-loongarch-" +
-              tools::loongarch::getLoongArchABI(Args, Triple) + ".so.1")
-                 .str();
+    Loader =
+        ("ld-linux-loongarch-" +
+         tools::loongarch::getLoongArchABI(getDriver(), Args, Triple) + ".so.1")
     break;
   }
   case llvm::Triple::m68k:
     LibDir = "lib";
     Loader = "ld.so.1";
     break;
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:

clang/test/Driver/loongarch-default-features.c

 // RUN: %clang --target=loongarch32 -S -emit-llvm %s -o - | FileCheck %s --check-prefix=LA32
 // RUN: %clang --target=loongarch64 -S -emit-llvm %s -o - | FileCheck %s --check-prefix=LA64
 
-// LA32: "target-features"="+d,+f"
-// LA64: "target-features"="+d,+f"
+// LA32-NOT: "target-features"=
+// LA64: "target-features"="+64bit,+d,+f"
 
 /// Dummy function
 int foo(void) {
   return  3;
 }

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: 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'

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-NOT: "-target-feature"
+// CC1-LOONGARCH64: "-target-feature" "+64bit"
+// CC1-LOONGARCH64-SAME: {{^}} "-target-feature" "+f"
+// CC1-LOONGARCH64-SAME: {{^}} "-target-feature" "+d"
+// CC1-LOONGARCH64-NOT: "-target-feature"
+// CC1-LOONGARCH64: "-target-abi" "lp64d"
+
+// CC1-LA464-NOT: "-target-feature"
+// CC1-LA464: "-target-feature" "+64bit"
+// CC1-LA464-SAME: {{^}} "-target-feature" "+f"
+// CC1-LA464-SAME: {{^}} "-target-feature" "+d"
+// CC1-LA464-SAME: {{^}} "-target-feature" "+lsx"
+// CC1-LA464-SAME: {{^}} "-target-feature" "+lasx"
+// CC1-LA464-NOT: "-target-feature"
+// CC1-LA464: "-target-abi" "lp64d"
+
+// IR-LOONGARCH64: attributes #{{[0-9]+}} ={{.*}}"target-features"="+64bit,+d,+f"
+// IR-LA464: attributes #{{[0-9]+}} ={{.*}}"target-features"="+64bit,+d,+f,+lasx,+lsx"
+
+/// Dummy function
+int foo(void) {
+  return  3;
+}

clang/test/Driver/loongarch-mdouble-float.c

+// RUN: %clang --target=loongarch64 -mdouble-float -fsyntax-only %s -### 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CC1
+// RUN: %clang --target=loongarch64 -mdouble-float -S -emit-llvm %s -o - \
+// RUN:   | FileCheck %s --check-prefix=IR
+
+// CC1-NOT: "-target-feature"
+// CC1: "-target-feature" "+64bit"
+// CC1-SAME: {{^}} "-target-feature" "+f"
+// CC1-SAME: {{^}} "-target-feature" "+d"
+// CC1-NOT: "-target-feature"
+// CC1: "-target-abi" "lp64d"
+
+// IR: attributes #{{[0-9]+}} ={{.*}}"target-features"="+64bit,+d,+f"
+
+/// Dummy function
+int foo(void) {
+  return  3;
+}

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

+// RUN: %clang --target=loongarch64 -mfpu=xxx -fsyntax-only %s -### 2>&1 \
+// RUN:   | FileCheck %s
+
+// CHECK: invalid argument 'xxx' to -mfpu=; must be one of: 64, 32, 0, none

clang/test/Driver/loongarch-mfpu.c

+// RUN: %clang --target=loongarch64 -mfpu=64 -fsyntax-only %s -### 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CC1-FPU64
+// RUN: %clang --target=loongarch64 -mfpu=32 -fsyntax-only %s -### 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CC1-FPU32
+// RUN: %clang --target=loongarch64 -mfpu=0 -fsyntax-only %s -### 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CC1-FPU0
+// RUN: %clang --target=loongarch64 -mfpu=none -fsyntax-only %s -### 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CC1-FPU0
+
+// RUN: %clang --target=loongarch64 -mfpu=64 -S -emit-llvm %s -o - \
+// RUN:   | FileCheck %s --check-prefix=IR-FPU64
+// RUN: %clang --target=loongarch64 -mfpu=32 -S -emit-llvm %s -o - \
+// RUN:   | FileCheck %s --check-prefix=IR-FPU32
+// RUN: %clang --target=loongarch64 -mfpu=0 -S -emit-llvm %s -o - \
+// RUN:   | FileCheck %s --check-prefix=IR-FPU0
+// RUN: %clang --target=loongarch64 -mfpu=none -S -emit-llvm %s -o - \
+// RUN:   | FileCheck %s --check-prefix=IR-FPU0
+
+// CC1-FPU64-NOT: "-target-feature"
+// CC1-FPU64: "-target-feature" "+64bit"
+// CC1-FPU64-SAME: "-target-feature" "+f"
+// CC1-FPU64-SAME: "-target-feature" "+d"
+// CC1-FPU64-NOT: "-target-feature"
+// CC1-FPU64: "-target-abi" "lp64d"
+
+// CC1-FPU32-NOT: "-target-feature"
+// CC1-FPU32: "-target-feature" "+64bit"
+// CC1-FPU32-SAME: "-target-feature" "+f"
+// CC1-FPU32-SAME: "-target-feature" "-d"
+// CC1-FPU32-NOT: "-target-feature"
+// CC1-FPU32: "-target-abi" "lp64f"
+
+// CC1-FPU0-NOT: "-target-feature"
+// CC1-FPU0: "-target-feature" "+64bit"
+// CC1-FPU0-SAME: "-target-feature" "-f"
+// CC1-FPU0-SAME: "-target-feature" "-d"
+// CC1-FPU0-NOT: "-target-feature"
+// CC1-FPU0: "-target-abi" "lp64s"
+
+// IR-FPU64: attributes #{{[0-9]+}} ={{.*}}"target-features"="+64bit,+d,+f"
+// IR-FPU32: attributes #{{[0-9]+}} ={{.*}}"target-features"="+64bit,+f,-d"
+// IR-FPU0: attributes #{{[0-9]+}} ={{.*}}"target-features"="+64bit,-d,-f"
+
+/// Dummy function
+int foo(void) {
+  return  3;
+}

clang/test/Driver/loongarch-msingle-float.c

+// RUN: %clang --target=loongarch64 -msingle-float -fsyntax-only %s -### 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CC1
+// RUN: %clang --target=loongarch64 -msingle-float -S -emit-llvm %s -o - \
+// RUN:   | FileCheck %s --check-prefix=IR
+
+// CC1-NOT: "-target-feature"
+// CC1: "-target-feature" "+64bit"
+// CC1-SAME: {{^}} "-target-feature" "+f"
+// CC1-SAME: {{^}} "-target-feature" "-d"
+// CC1-NOT: "-target-feature"
+// CC1: "-target-abi" "lp64f"
+
+// IR: attributes #{{[0-9]+}} ={{.*}}"target-features"="+64bit,+f,-d"
+
+/// Dummy function
+int foo(void) {
+  return  3;
+}

clang/test/Driver/loongarch-msoft-float.c

+// RUN: %clang --target=loongarch64 -msoft-float -fsyntax-only %s -### 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CC1
+// RUN: %clang --target=loongarch64 -msoft-float -S -emit-llvm %s -o - \
+// RUN:   | FileCheck %s --check-prefix=IR
+
+// CC1-NOT: "-target-feature"
+// CC1: "-target-feature" "+64bit"
+// CC1-SAME: {{^}} "-target-feature" "-f"
+// CC1-SAME: {{^}} "-target-feature" "-d"
+// CC1-NOT: "-target-feature"
+// CC1: "-target-abi" "lp64s"
+
+// IR: attributes #{{[0-9]+}} ={{.*}}"target-features"="+64bit,-d,-f"
+
+/// Dummy function
+int foo(void) {
+  return  3;
+}

llvm/include/llvm/Support/LoongArchTargetParser.h

+//==-- LoongArch64TargetParser - Parser for LoongArch64 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 LoongArch hardware features
+// such as CPU/ARCH and extension names.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_LOONGARCHTARGETPARSER_H
+#define LLVM_SUPPORT_LOONGARCHTARGETPARSER_H
+
+#include "llvm/ADT/Triple.h"
+#include <vector>
+
+namespace llvm {
+class StringRef;
+
+namespace LoongArch {
+
+enum FeatureKind : uint32_t {
+  FK_INVALID = 0,
+  FK_NONE = 1,
+
+  // 64-bit ISA is available.
+  FK_64BIT = 1 << 1,
+
+  // Single-precision floating-point instructions are available.
+  FK_FP32 = 1 << 2,
+
+  // Double-precision floating-point instructions are available.
+  FK_FP64 = 1 << 3,
+
+  // Loongson SIMD Extension is available.
+  FK_LSX = 1 << 4,
+
+  // Loongson Advanced SIMD Extension is available.
+  FK_LASX = 1 << 5,
+
+  // Loongson Binary Translation Extension is available.
+  FK_LBT = 1 << 6,
+
+  // Loongson Virtualization Extension is available.
+  FK_LVZ = 1 << 7,
+};
+
+struct FeatureInfo {
+  StringRef Name;
+  FeatureKind Kind;
+};
+
+enum class ArchKind {
+#define LOONGARCH_ARCH(NAME, KIND, FEATURES) KIND,
+#include "LoongArchTargetParser.def"
+};
+
+struct ArchInfo {
+  StringRef Name;
+  ArchKind Kind;
+  uint32_t Features;
+};
+
+ArchKind parseArch(StringRef Arch);
+bool getArchFeatures(StringRef Arch, std::vector<StringRef> &Features);
+
+} // namespace LoongArch
+
+} // namespace llvm
+
+#endif // LLVM_SUPPORT_LOONGARCHTARGETPARSER_H

llvm/include/llvm/Support/LoongArchTargetParser.def

+#ifndef LOONGARCH_FEATURE
+#define LOONGARCH_FEATURE(NAME, KIND)
+#endif
+
+LOONGARCH_FEATURE("invalid", FK_INVALID)
+LOONGARCH_FEATURE("none", FK_NONE)
+LOONGARCH_FEATURE("+64bit", FK_64BIT)
+LOONGARCH_FEATURE("+f", FK_FP32)
+LOONGARCH_FEATURE("+d", FK_FP64)
+LOONGARCH_FEATURE("+lsx", FK_LSX)
+LOONGARCH_FEATURE("+lasx", FK_LASX)
+LOONGARCH_FEATURE("+lbt", FK_LBT)
+LOONGARCH_FEATURE("+lvz", FK_LVZ)
+
+#undef LOONGARCH_FEATURE
+
+#ifndef LOONGARCH_ARCH
+#define LOONGARCH_ARCH(NAME, KIND, FEATURES)
+#endif
+
+LOONGARCH_ARCH("invalid", AK_INVALID, FK_INVALID)
+LOONGARCH_ARCH("loongarch64", AK_LOONGARCH64, FK_64BIT | FK_FP32 | FK_FP64)
+LOONGARCH_ARCH("la464", AK_LA464, FK_64BIT | FK_FP32 | FK_FP64 | FK_LSX | FK_LASX)
+
+#undef LOONGARCH_ARCH

llvm/lib/Support/CMakeLists.txt

add_llvm_component_library(LLVMSupport
   IntervalMap.cpp
   ItaniumManglingCanonicalizer.cpp
   JSON.cpp
   KnownBits.cpp
   LEB128.cpp
   LineIterator.cpp
   Locale.cpp
   LockFileManager.cpp
+  LoongArchTargetParser.cpp
   LowLevelType.cpp
   ManagedStatic.cpp
   MathExtras.cpp
   MemAlloc.cpp
   MemoryBuffer.cpp
   MemoryBufferRef.cpp
   MD5.cpp
   MSP430Attributes.cpp

llvm/lib/Support/LoongArchTargetParser.cpp

+//==-- LoongArch64TargetParser - Parser for LoongArch64 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 LoongArch hardware features
+// such as CPU/ARCH and extension names.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/LoongArchTargetParser.h"
+#include "llvm/ADT/StringSwitch.h"
+
+using namespace llvm;
+using namespace llvm::LoongArch;
+
+const FeatureInfo AllFeatures[] = {
+#define LOONGARCH_FEATURE(NAME, KIND) {NAME, KIND},
+#include "llvm/Support/LoongArchTargetParser.def"
+};
+
+const ArchInfo AllArchs[] = {
+#define LOONGARCH_ARCH(NAME, KIND, FEATURES)                                   \
+  {NAME, LoongArch::ArchKind::KIND, FEATURES},
+#include "llvm/Support/LoongArchTargetParser.def"
+};
+
+LoongArch::ArchKind LoongArch::parseArch(StringRef Arch) {
+  for (const auto A : AllArchs) {
+    if (A.Name == Arch)
+      return A.Kind;
+  }
+
+  return LoongArch::ArchKind::AK_INVALID;
+}
+
+bool LoongArch::getArchFeatures(StringRef Arch,
+                                std::vector<StringRef> &Features) {
+  for (const auto A : AllArchs) {
+    if (A.Name == Arch) {
+      for (const auto F : AllFeatures) {
+        if ((A.Features & F.Kind) == F.Kind && F.Kind != FK_INVALID) {
+          Features.push_back(F.Name);
+        }
+      }
+      return true;
+    }
+  }
+  return false;
+}