[Clang][LoongArch] Add initial LoongArch target and driver support

[SixWeining]

Summary

With the initial support added, clang can compile helloworld C
to executable file for loongarch64. For example:

$ cat hello.c
#include <stdio.h>
int main() {
  printf("Hello, world!\n");
  return 0;
}
$ clang --target=loongarch64-unknown-linux-gnu --gcc-toolchain=xxx --sysroot=xxx hello.c

The output a.out can run within qemu or native machine. For example:

$ file ./a.out
./a.out: ELF 64-bit LSB pie executable, LoongArch, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-loongarch-lp64d.so.1, for GNU/Linux 5.19.0, with debug_info, not stripped
$ ./a.out
Hello, world!

Currently gcc toolchain and sysroot can be found here:
https://github.com/loongson/build-tools/releases/download/2022.08.11/loongarch64-clfs-5.1-cross-tools-gcc-glibc.tar.xz

Reference: https://github.com/loongson/LoongArch-Documentation
The last commit hash (main branch) is:
99016636af64d02dee05e39974d4c1e55875c45b

Note loongarch32 is not fully tested because there is no reference
gcc toolchain yet.

[rengolin]

This looks great, thanks!

Exciting that we can finally go all the way from C source to LoongArch binary.

The changes look good to me, other than a few nits. But please wait for a day or two for other people to review on their own time.

clang/lib/Basic/Targets/LoongArch.h

70

nit: this should use setABI. Right now, there's no difference, but once the function does more (like setting other ABI flags), you won't need to change it here. Same for the 64-bit version.

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

26

nit: comment mismatch "end"

clang/test/Driver/loongarch-abi.c

42

please, split between pass and error by adding a new loongarch-abi-error.c and adding the error tests to it.

[SixWeining]

Address @rengolin's comments.

[SixWeining]

In D130255#3668436, @rengolin wrote:

This looks great, thanks!

Exciting that we can finally go all the way from C source to LoongArch binary.

The changes look good to me, other than a few nits. But please wait for a day or two for other people to review on their own time.

Thanks, Renato.

Because relocation hasn't been added to the backend, complex code (e.g. with function call) can't been compiled currently.
But at least, as you said, we finally go all the way from C source to LoongArch binary. This is a start and further implementation will be added later.

clang/lib/Basic/Targets/LoongArch.h

70

Thanks. No problem.

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

26

Thanks.

clang/test/Driver/loongarch-abi.c

42

Thanks. No problem.

[MaskRay]

clang/lib/Basic/Targets/LoongArch.cpp

27

return {}

clang/test/Driver/frame-pointer.c

60

Use --target= for new tests. -target is a legacy syntax.

71

remove // from the otherwise empty line

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

2

-fsyntax and remove -o %t.o

clang/test/Driver/loongarch-abi.c

2

The line isn't very song, no need to break it into two.

clang/test/Preprocessor/init-loongarch.c

2

remove <

[MaskRay]

clang/lib/Driver/ToolChains/Linux.cpp

480

avoid simple variable which is only used once

clang/test/Driver/loongarch64-toolchain.c

4 ↗

(On Diff #446688)

Just remove -no-canonical-prefixes and clang{{.*}} below. "-cc1" is sufficient to anchor a cc1 line.

clang/test/Preprocessor/init-loongarch.c

22

Consider using -NEXT for related values

[SixWeining]

Address @MaskRay's comments. Thanks.

[SixWeining]

clang/lib/Basic/Targets/LoongArch.cpp

27

Thanks.

[SixWeining]

rebase

[MaskRay]

clang/lib/Basic/Targets/LoongArch.h

25

LLVM_LIBRARY_VISIBILITY

36

Define WCharType

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

16

Delete unused <string> <vector>

clang/lib/Driver/ToolChains/Gnu.cpp

309

Can be added before mips. Seems that some cases are unsorted. Just ignore them.

2226

I don't know which of /lib64, /lib has been used. For purity, I'd hope that we just have /lib, no multilib style /lib64

2478

Just add loongarch32 in this patch. It is trivial

clang/test/Driver/loongarch64-toolchain.c

20 ↗

(On Diff #446736)

Not using NEXT is somewhat brittle.

Perhaps add loongarch-toolchain.c instead. riscv*-toolchain.c are not good examples to follow. You may check out linux-cross.cpp

[SixWeining]

Continue to address @MaskRay's comments: LLVM_LIBRARY_VISIBILITY ...

clang/lib/Driver/ToolChains/Gnu.cpp

2226

I also don't know the actual usage of /lib64 but I just tried and it works fine if I remove /lib64.

2478

But I don't know how to handle loongarch32 because there isn't a loongarch32 gcc toolchain available yet.

clang/test/Driver/loongarch64-toolchain.c

20 ↗

(On Diff #446736)

Thanks.

[xry111]

clang/lib/Driver/ToolChains/Gnu.cpp

2226

I don't like lib64 too. But for LoongArch LP64D, the path to ELF interpreter is hard coded /lib64/ld-linux-loongarch-lp64d.so.1 and it seems too late to change it. And LoongArch GCC installs libstdc++ etc. for LP64D into $PREFIX/lib64 by default (like x86_64).

As a distro (LFS) maintainer: we are already hacking GCC code to get rid of /usr/lib64.

[SixWeining]

clang/lib/Driver/ToolChains/Gnu.cpp

2226

Thanks for the quick reply. So I should keep the /lib64 here?

[xry111]

clang/lib/Driver/ToolChains/Gnu.cpp

2226

I think you should keep it. A multilib distro may have /usr/lib64, /usr/lib32, and /usr/lib32sf (sf for soft float or whatever) and make /usr/lib a symlink. A "mostly 32-bit distro" may have symlink /usr/lib -> /usr/lib32, but still capable to build & run LA64 programs with libraries in /usr/lib64. Removing lib64 will break clang on such distros with -mabi=64.

Personally, I don't like lib64. But we can't really predict what the distro maintainers will do (unless you say something explicitly like "a LP64D capable distro SHALL have LP64D libraries in /usr/lib" in a spec).

[SixWeining]

keep /lib64

[MaskRay]

clang/lib/Driver/ToolChains/Gnu.cpp

2226

Dynamic loader selection is orthogonal to the LibDirs variable here. You can use /lib64/ld-linux-loongarch-lp64d.so.1 while the library paths are from /lib .

If anything, riscv multilib support is quite broken at this point so probably don't use it as a reference.
If there is ever a 32-bit distro which wants to do 64-bit compilation, you can leverage multiarch, which is less broken. https://maskray.me/blog/2021-03-28-compiler-driver-and-cross-compilation

[SixWeining]

rebase

[SixWeining]

rebase

[xen0n]

clang/lib/Driver/ToolChains/Gnu.cpp

2226

FWIW this is actually beneficial for Gentoo (which consistently uses lib64 for its 64-bit-capable profiles since forever, at least for all of the 64-bit arches/profiles I have used). Otherwise the libdir is really more-or-less freely chosen. And I think most if not all distros already patch downstream for this libdir tweaking...

The ELF interpreter path is indeed hardcoded, and I'll admit I referred to many lib64-using precedents when reviewing the initial proposal. I think many ideas were thrown around and every of them was strictly better than the MIPS carryover /lib/ld.so.1 I think. That ship has long sailed though, and even a lib64 just for housing the symlink to the real ld.so seems okay to me.

So overall personally I don't feel this is too problematic; sorry if I sounded like a grumpy old guy defending his favorite /lib64 (and all its old split-usr glory ;-)

[MaskRay]

clang/test/Preprocessor/init-loongarch.c

2

-triple . The CC1 option is a Separate (yes, inconsistent).

[SixWeining]

-triple= to -triple

[SixWeining]

Use -fsyntax-only; -check-prefix to --check-prefix.

clang/lib/Basic/CMakeLists.txt

add_clang_library(clangBasic
   Targets/ARM.cpp
   Targets/AVR.cpp
   Targets/BPF.cpp
   Targets/CSKY.cpp
   Targets/DirectX.cpp
   Targets/Hexagon.cpp
   Targets/Lanai.cpp
   Targets/Le64.cpp
+  Targets/LoongArch.cpp
   Targets/M68k.cpp
   Targets/MSP430.cpp
   Targets/Mips.cpp
   Targets/NVPTX.cpp
   Targets/OSTargets.cpp
   Targets/PNaCl.cpp
   Targets/PPC.cpp
   Targets/RISCV.cpp

clang/lib/Basic/Targets.cpp

 #include "Targets/ARM.h"
 #include "Targets/AVR.h"
 #include "Targets/BPF.h"
 #include "Targets/CSKY.h"
 #include "Targets/DirectX.h"
 #include "Targets/Hexagon.h"
 #include "Targets/Lanai.h"
 #include "Targets/Le64.h"
+#include "Targets/LoongArch.h"
 #include "Targets/M68k.h"
 #include "Targets/MSP430.h"
 #include "Targets/Mips.h"
 #include "Targets/NVPTX.h"
 #include "Targets/OSTargets.h"
 #include "Targets/PNaCl.h"
 #include "Targets/PPC.h"
 #include "Targets/RISCV.h"
TargetInfo *AllocateTarget(const llvm::Triple &Triple,
 
   case llvm::Triple::csky:
     switch (os) {
     case llvm::Triple::Linux:
       return new LinuxTargetInfo<CSKYTargetInfo>(Triple, Opts);
     default:
       return new CSKYTargetInfo(Triple, Opts);
     }
+  case llvm::Triple::loongarch32:
+    switch (os) {
+    case llvm::Triple::Linux:
+      return new LinuxTargetInfo<LoongArch32TargetInfo>(Triple, Opts);
+    default:
+      return new LoongArch32TargetInfo(Triple, Opts);
+    }
+  case llvm::Triple::loongarch64:
+    switch (os) {
+    case llvm::Triple::Linux:
+      return new LinuxTargetInfo<LoongArch64TargetInfo>(Triple, Opts);
+    default:
+      return new LoongArch64TargetInfo(Triple, Opts);
+    }
   }
 }
 } // namespace targets
 } // namespace clang
 
 using namespace clang::targets;
 /// CreateTargetInfo - Return the target info object for the specified target
 /// options.

clang/lib/Basic/Targets/LoongArch.h

+//===-- LoongArch.h - Declare LoongArch target feature support --*- 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 declares LoongArch TargetInfo objects.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_BASIC_TARGETS_LOONGARCH_H
+#define LLVM_CLANG_LIB_BASIC_TARGETS_LOONGARCH_H
+
+#include "clang/Basic/TargetInfo.h"
+#include "clang/Basic/TargetOptions.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/Support/Compiler.h"
+
+namespace clang {
+namespace targets {
+
+class LLVM_LIBRARY_VISIBILITY LoongArchTargetInfo : public TargetInfo {
+protected:
+  std::string ABI;
+
+public:
+  LoongArchTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
+      : TargetInfo(Triple) {
+    LongDoubleWidth = 128;
+    LongDoubleAlign = 128;
+    LongDoubleFormat = &llvm::APFloat::IEEEquad();
+    SuitableAlign = 128;
+    WCharType = SignedInt;
+    WIntType = UnsignedInt;
+  }
+
+  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 {
+    return TargetInfo::VoidPtrBuiltinVaList;
+  }
+
+  const char *getClobbers() const override { return ""; }
+
+  ArrayRef<const char *> getGCCRegNames() const override;
+
+  ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
+
+  bool validateAsmConstraint(const char *&Name,
+                             TargetInfo::ConstraintInfo &Info) const override;
+};
+
+class LLVM_LIBRARY_VISIBILITY LoongArch32TargetInfo
+    : public LoongArchTargetInfo {
+public:
+  LoongArch32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
+      : LoongArchTargetInfo(Triple, Opts) {
+    IntPtrType = SignedInt;
+    PtrDiffType = SignedInt;
+    SizeType = UnsignedInt;
+    resetDataLayout("e-m:e-p:32:32-i64:64-n32-S128");
+    // TODO: select appropriate ABI.
+    setABI("ilp32d");
+  }
+
+  bool setABI(const std::string &Name) override {
+    if (Name == "ilp32d" || Name == "ilp32f" || Name == "ilp32s") {
+      ABI = Name;
+      return true;
+    }
+    return false;
+  }
+};
+
+class LLVM_LIBRARY_VISIBILITY LoongArch64TargetInfo
+    : public LoongArchTargetInfo {
+public:
+  LoongArch64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
+      : LoongArchTargetInfo(Triple, Opts) {
+    LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
+    IntMaxType = Int64Type = SignedLong;
+    resetDataLayout("e-m:e-p:64:64-i64:64-i128:128-n64-S128");
+    // TODO: select appropriate ABI.
+    setABI("lp64d");
+  }
+
+  bool setABI(const std::string &Name) override {
+    if (Name == "lp64d" || Name == "lp64f" || Name == "lp64s") {
+      ABI = Name;
+      return true;
+    }
+    return false;
+  }
+};
+} // namespace targets
+} // namespace clang
+
+#endif // LLVM_CLANG_LIB_BASIC_TARGETS_LOONGARCH_H

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/ADT/StringSwitch.h"
+#include "llvm/Support/TargetParser.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace clang;
+using namespace clang::targets;
+
+ArrayRef<const char *> LoongArchTargetInfo::getGCCRegNames() const {
+  // TODO: To be implemented in future.
+  return {};
+}
+
+ArrayRef<TargetInfo::GCCRegAlias>
+LoongArchTargetInfo::getGCCRegAliases() const {
+  // TODO: To be implemented in future.
+  return {};
+}
+
+bool LoongArchTargetInfo::validateAsmConstraint(
+    const char *&Name, TargetInfo::ConstraintInfo &Info) const {
+  // TODO: To be implemented in future.
+  return false;
+}
+
+void LoongArchTargetInfo::getTargetDefines(const LangOptions &Opts,
+                                           MacroBuilder &Builder) const {
+  Builder.defineMacro("__loongarch__");
+  // TODO: Define more macros.
+}
+
+ArrayRef<Builtin::Info> LoongArchTargetInfo::getTargetBuiltins() const {
+  // TODO: To be implemented in future.
+  return {};
+}

clang/lib/Driver/CMakeLists.txt

add_clang_library(clangDriver
   OptionUtils.cpp
   Phases.cpp
   SanitizerArgs.cpp
   Tool.cpp
   ToolChain.cpp
   ToolChains/Arch/AArch64.cpp
   ToolChains/Arch/ARM.cpp
   ToolChains/Arch/CSKY.cpp
+  ToolChains/Arch/LoongArch.cpp
   ToolChains/Arch/M68k.cpp
   ToolChains/Arch/Mips.cpp
   ToolChains/Arch/PPC.cpp
   ToolChains/Arch/RISCV.cpp
   ToolChains/Arch/Sparc.cpp
   ToolChains/Arch/SystemZ.cpp
   ToolChains/Arch/VE.cpp
   ToolChains/Arch/X86.cpp

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

+//===--- LoongArch.h - LoongArch-specific 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_LOONGARCH_H
+#define LLVM_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,
+                          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"
+
+using namespace clang::driver::tools;
+using namespace clang;
+using namespace llvm::opt;
+
+StringRef loongarch::getLoongArchABI(const ArgList &Args,
+                                     const llvm::Triple &Triple) {
+  assert((Triple.getArch() == llvm::Triple::loongarch32 ||
+          Triple.getArch() == llvm::Triple::loongarch64) &&
+         "Unexpected triple");
+
+  // If `-mabi=` is specified, use it.
+  if (const Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
+    return A->getValue();
+
+  // Choose a default based on the triple.
+  // TODO: select appropiate ABI.
+  return Triple.getArch() == llvm::Triple::loongarch32 ? "ilp32d" : "lp64d";
+}

clang/lib/Driver/ToolChains/Clang.h

private:
   void AddAArch64TargetArgs(const llvm::opt::ArgList &Args,
                             llvm::opt::ArgStringList &CmdArgs) const;
   void AddARMTargetArgs(const llvm::Triple &Triple,
                         const llvm::opt::ArgList &Args,
                         llvm::opt::ArgStringList &CmdArgs,
                         bool KernelOrKext) const;
   void AddARM64TargetArgs(const llvm::opt::ArgList &Args,
                           llvm::opt::ArgStringList &CmdArgs) const;
+  void AddLoongArchTargetArgs(const llvm::opt::ArgList &Args,
+                              llvm::opt::ArgStringList &CmdArgs) const;
   void AddMIPSTargetArgs(const llvm::opt::ArgList &Args,
                          llvm::opt::ArgStringList &CmdArgs) const;
   void AddPPCTargetArgs(const llvm::opt::ArgList &Args,
                         llvm::opt::ArgStringList &CmdArgs) const;
   void AddR600TargetArgs(const llvm::opt::ArgList &Args,
                          llvm::opt::ArgStringList &CmdArgs) const;
   void AddRISCVTargetArgs(const llvm::opt::ArgList &Args,
                           llvm::opt::ArgStringList &CmdArgs) const;

clang/lib/Driver/ToolChains/Clang.cpp

 //===-- Clang.cpp - Clang+LLVM ToolChain Implementations --------*- 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 "Clang.h"
 #include "AMDGPU.h"
 #include "Arch/AArch64.h"
 #include "Arch/ARM.h"
 #include "Arch/CSKY.h"
+#include "Arch/LoongArch.h"
 #include "Arch/M68k.h"
 #include "Arch/Mips.h"
 #include "Arch/PPC.h"
 #include "Arch/RISCV.h"
 #include "Arch/Sparc.h"
 #include "Arch/SystemZ.h"
 #include "Arch/VE.h"
 #include "Arch/X86.h"
static bool useFramePointerForTargetByDefault(const ArgList &Args,
   case llvm::Triple::ppcle:
   case llvm::Triple::ppc64:
   case llvm::Triple::ppc64le:
   case llvm::Triple::riscv32:
   case llvm::Triple::riscv64:
   case llvm::Triple::amdgcn:
   case llvm::Triple::r600:
   case llvm::Triple::csky:
+  case llvm::Triple::loongarch32:
+  case llvm::Triple::loongarch64:
     return !areOptimizationsEnabled(Args);
   default:
     break;
   }
 
   if (Triple.isOSFuchsia() || Triple.isOSNetBSD()) {
     return !areOptimizationsEnabled(Args);
   }
void Clang::RenderTargetOptions(const llvm::Triple &EffectiveTriple,
 
   case llvm::Triple::aarch64:
   case llvm::Triple::aarch64_32:
   case llvm::Triple::aarch64_be:
     AddAArch64TargetArgs(Args, CmdArgs);
     CmdArgs.push_back("-fallow-half-arguments-and-returns");
     break;
 
+  case llvm::Triple::loongarch32:
+  case llvm::Triple::loongarch64:
+    AddLoongArchTargetArgs(Args, CmdArgs);
+    break;
+
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el:
     AddMIPSTargetArgs(Args, CmdArgs);
     break;
 
   case llvm::Triple::ppc:
if (!TuneCPU.empty()) {
       CmdArgs.push_back("-tune-cpu");
       CmdArgs.push_back(Args.MakeArgString(TuneCPU));
     }
   }
 
   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());
+}
+
 void Clang::AddMIPSTargetArgs(const ArgList &Args,
                               ArgStringList &CmdArgs) const {
   const Driver &D = getToolChain().getDriver();
   StringRef CPUName;
   StringRef ABIName;
   const llvm::Triple &Triple = getToolChain().getTriple();
   mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
 

clang/lib/Driver/ToolChains/Gnu.cpp

case llvm::Triple::riscv32:
     return "elf32lriscv";
   case llvm::Triple::riscv64:
     return "elf64lriscv";
   case llvm::Triple::sparc:
   case llvm::Triple::sparcel:
     return "elf32_sparc";
   case llvm::Triple::sparcv9:
     return "elf64_sparc";
+  case llvm::Triple::loongarch32:
+    return "elf32loongarch";
+  case llvm::Triple::loongarch64:
+    return "elf64loongarch";
   case llvm::Triple::mips:
     return "elf32btsmip";
   case llvm::Triple::mipsel:
     return "elf32ltsmip";
   case llvm::Triple::mips64:
     if (tools::mips::hasMipsAbiArg(Args, "n32") ||
         T.getEnvironment() == llvm::Triple::GNUABIN32)
       return "elf32btsmipn32";
     return "elf64btsmip";
   case llvm::Triple::mips64el:
     if (tools::mips::hasMipsAbiArg(Args, "n32") ||
         T.getEnvironment() == llvm::Triple::GNUABIN32)
       return "elf32ltsmipn32";
     return "elf64ltsmip";
   case llvm::Triple::systemz:
     return "elf64_s390";
   case llvm::Triple::x86_64:
     if (T.isX32())
       return "elf32_x86_64";
     return "elf_x86_64";
   case llvm::Triple::ve:
     return "elf64ve";
   case llvm::Triple::csky:
     return "cskyelf_linux";
   default:
     return nullptr;
   }
 }
 
 static bool getPIE(const ArgList &Args, const ToolChain &TC) {
   if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_static) ||
       Args.hasArg(options::OPT_r) || Args.hasArg(options::OPT_static_pie))
     return false;
/*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
   static const char *const X32LibDirs[] = {"/libx32", "/lib"};
   static const char *const X86LibDirs[] = {"/lib32", "/lib"};
   static const char *const X86Triples[] = {
       "i586-linux-gnu",      "i686-linux-gnu",        "i686-pc-linux-gnu",
       "i386-redhat-linux6E", "i686-redhat-linux",     "i386-redhat-linux",
       "i586-suse-linux",     "i686-montavista-linux", "i686-gnu",
   };
 
+  static const char *const LoongArch64LibDirs[] = {"lib"};
+  static const char *const LoongArch64Triples[] = {
+      "loongarch64-linux-gnu", "loongarch64-unknown-linux-gnu"};
+
   static const char *const M68kLibDirs[] = {"/lib"};
   static const char *const M68kTriples[] = {
       "m68k-linux-gnu", "m68k-unknown-linux-gnu", "m68k-suse-linux"};
 
   static const char *const MIPSLibDirs[] = {"/libo32", "/lib"};
   static const char *const MIPSTriples[] = {
       "mips-linux-gnu", "mips-mti-linux", "mips-mti-linux-gnu",
       "mips-img-linux-gnu", "mipsisa32r6-linux-gnu"};
case llvm::Triple::x86:
     if (!TargetTriple.isOSIAMCU()) {
       TripleAliases.append(begin(X86Triples), end(X86Triples));
       BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
       BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
       BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
       BiarchTripleAliases.append(begin(X32Triples), end(X32Triples));
     }
     break;
+  // TODO: Handle loongarch32.
+  case llvm::Triple::loongarch64:
+    LibDirs.append(begin(LoongArch64LibDirs), end(LoongArch64LibDirs));
+    TripleAliases.append(begin(LoongArch64Triples), end(LoongArch64Triples));
+    break;
   case llvm::Triple::m68k:
     LibDirs.append(begin(M68kLibDirs), end(M68kLibDirs));
     TripleAliases.append(begin(M68kTriples), end(M68kTriples));
     break;
   case llvm::Triple::mips:
     LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
     TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
     BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
bool Generic_GCC::IsIntegratedAssemblerDefault() const {
   case llvm::Triple::arm:
   case llvm::Triple::armeb:
   case llvm::Triple::avr:
   case llvm::Triple::bpfel:
   case llvm::Triple::bpfeb:
   case llvm::Triple::csky:
   case llvm::Triple::hexagon:
   case llvm::Triple::lanai:
+  case llvm::Triple::loongarch32:
+  case llvm::Triple::loongarch64:
   case llvm::Triple::m68k:
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el:
   case llvm::Triple::msp430:
   case llvm::Triple::ppc:
   case llvm::Triple::ppcle:

clang/lib/Driver/ToolChains/Linux.cpp

 //===--- Linux.h - Linux ToolChain Implementations --------------*- 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 "Linux.h"
 #include "Arch/ARM.h"
+#include "Arch/LoongArch.h"
 #include "Arch/Mips.h"
 #include "Arch/PPC.h"
 #include "Arch/RISCV.h"
 #include "CommonArgs.h"
 #include "clang/Config/config.h"
 #include "clang/Driver/Distro.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/Options.h"
case llvm::Triple::thumbeb: {
     const bool HF =
         Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||
         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();
+    break;
+  }
+  case llvm::Triple::loongarch64: {
+    LibDir = "lib64";
+    Loader = ("ld-linux-loongarch-" +
+              tools::loongarch::getLoongArchABI(Args, Triple) + ".so.1")
+                 .str();
+    break;
+  }
   case llvm::Triple::m68k:
     LibDir = "lib";
     Loader = "ld.so.1";
     break;
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el: {

clang/test/Driver/Inputs/multilib_loongarch_linux_sdk/loongarch64-unknown-linux-gnu/bin/ld

+#!/bin/true

clang/test/Driver/frame-pointer.c

 // RUN: %clang -target riscv32-unknown-linux-gnu -### -S -Os %s -o %t.s 2>&1 | FileCheck -check-prefix=CHECKs-32 %s
 
 // RUN: %clang -target riscv64-unknown-linux-gnu -### -S -O0 %s -o %t.s 2>&1 | FileCheck -check-prefix=CHECK0-64 %s
 // RUN: %clang -target riscv64-unknown-linux-gnu -### -S -O1 %s -o %t.s 2>&1 | FileCheck -check-prefix=CHECK1-64 %s
 // RUN: %clang -target riscv64-unknown-linux-gnu -### -S -O2 %s -o %t.s 2>&1 | FileCheck -check-prefix=CHECK2-64 %s
 // RUN: %clang -target riscv64-unknown-linux-gnu -### -S -O3 %s -o %t.s 2>&1 | FileCheck -check-prefix=CHECK3-64 %s
 // RUN: %clang -target riscv64-unknown-linux-gnu -### -S -Os %s -o %t.s 2>&1 | FileCheck -check-prefix=CHECKs-64 %s
 
+// RUN: %clang --target=loongarch32 -### -S -O0 %s -o %t.s 2>&1 | FileCheck -check-prefix=CHECK0-32 %s
+// RUN: %clang --target=loongarch32 -### -S -O1 %s -o %t.s 2>&1 | FileCheck -check-prefix=CHECK1-32 %s
+// RUN: %clang --target=loongarch32 -### -S -O2 %s -o %t.s 2>&1 | FileCheck -check-prefix=CHECK2-32 %s
+// RUN: %clang --target=loongarch32 -### -S -O3 %s -o %t.s 2>&1 | FileCheck -check-prefix=CHECK3-32 %s
+// RUN: %clang --target=loongarch32 -### -S -Os %s -o %t.s 2>&1 | FileCheck -check-prefix=CHECKs-32 %s
+
+// RUN: %clang --target=loongarch64 -### -S -O0 %s -o %t.s 2>&1 | FileCheck -check-prefix=CHECK0-64 %s
+// RUN: %clang --target=loongarch64 -### -S -O1 %s -o %t.s 2>&1 | FileCheck -check-prefix=CHECK1-64 %s
+// RUN: %clang --target=loongarch64 -### -S -O2 %s -o %t.s 2>&1 | FileCheck -check-prefix=CHECK2-64 %s
+// RUN: %clang --target=loongarch64 -### -S -O3 %s -o %t.s 2>&1 | FileCheck -check-prefix=CHECK3-64 %s
+// RUN: %clang --target=loongarch64 -### -S -Os %s -o %t.s 2>&1 | FileCheck -check-prefix=CHECKs-64 %s
+
 // CHECK0-32: -mframe-pointer=all
 // CHECK1-32-NOT: -mframe-pointer=all
 // CHECK2-32-NOT: -mframe-pointer=all
 // CHECK3-32-NOT: -mframe-pointer=all
 // CHECKs-32-NOT: -mframe-pointer=all
 
 // CHECK0-64: -mframe-pointer=all
 // CHECK1-64-NOT: -mframe-pointer=all
 // CHECK2-64-NOT: -mframe-pointer=all
 // CHECK3-64-NOT: -mframe-pointer=all
 // CHECKs-64-NOT: -mframe-pointer=all
 // CHECK-MACHO-64: -mframe-pointer=all

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

+// RUN: not %clang --target=loongarch32-unknown-elf %s -fsyntax-only -mabi=lp64s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-LA32-LP64S %s
+// RUN: not %clang --target=loongarch32-unknown-elf %s -fsyntax-only -mabi=lp64f 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-LA32-LP64F %s
+// RUN: not %clang --target=loongarch32-unknown-elf %s -fsyntax-only -mabi=lp64d 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-LA32-LP64D %s
+
+// RUN: not %clang --target=loongarch64-unknown-elf %s -fsyntax-only -mabi=ilp32s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-LA64-ILP32S %s
+// RUN: not %clang --target=loongarch64-unknown-elf %s -fsyntax-only -mabi=ilp32f 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-LA64-ILP32F %s
+// RUN: not %clang --target=loongarch64-unknown-elf %s -fsyntax-only -mabi=ilp32d 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-LA64-ILP32D %s
+
+// CHECK-LA32-LP64S: error: unknown target ABI 'lp64s'
+// CHECK-LA32-LP64F: error: unknown target ABI 'lp64f'
+// CHECK-LA32-LP64D: error: unknown target ABI 'lp64d'
+
+// CHECK-LA64-ILP32S: error: unknown target ABI 'ilp32s'
+// CHECK-LA64-ILP32F: error: unknown target ABI 'ilp32f'
+// CHECK-LA64-ILP32D: error: unknown target ABI 'ilp32d'

clang/test/Driver/loongarch-abi.c

+// RUN: %clang --target=loongarch32-unknown-elf %s -### 2>&1 | FileCheck --check-prefix=ILP32D %s
+// RUN: %clang --target=loongarch32-unknown-elf %s -### -mabi=ilp32s 2>&1 \
+// RUN:   | FileCheck --check-prefix=ILP32S %s
+// RUN: %clang --target=loongarch32-unknown-elf %s -### -mabi=ilp32f 2>&1 \
+// RUN:   | FileCheck --check-prefix=ILP32F %s
+// RUN: %clang --target=loongarch32-unknown-elf %s -### -mabi=ilp32d 2>&1 \
+// RUN:   | FileCheck --check-prefix=ILP32D %s
+
+// RUN: %clang --target=loongarch64-unknown-elf %s -### 2>&1 | FileCheck --check-prefix=LP64D %s
+// RUN: %clang --target=loongarch64-unknown-elf %s -### -mabi=lp64s 2>&1 \
+// RUN:   | FileCheck --check-prefix=LP64S %s
+// RUN: %clang --target=loongarch64-unknown-elf %s -### -mabi=lp64f 2>&1 \
+// RUN:   | FileCheck --check-prefix=LP64F %s
+// RUN: %clang --target=loongarch64-unknown-elf %s -### -mabi=lp64d 2>&1 \
+// RUN:   | FileCheck --check-prefix=LP64D %s
+
+// ILP32S: "-target-abi" "ilp32s"
+// ILP32F: "-target-abi" "ilp32f"
+// ILP32D: "-target-abi" "ilp32d"
+
+// LP64S: "-target-abi" "lp64s"
+// LP64F: "-target-abi" "lp64f"
+// LP64D: "-target-abi" "lp64d"

clang/test/Driver/loongarch-toolchain.c

+// UNSUPPORTED: system-windows
+/// A basic clang -cc1 command-line, and simple environment check.
+
+// RUN: %clang %s -### --target=loongarch32 2>&1 | FileCheck --check-prefix=CC1 %s -DTRIPLE=loongarch32
+// RUN: %clang %s -### --target=loongarch64 2>&1 | FileCheck --check-prefix=CC1 %s -DTRIPLE=loongarch64
+
+// CC1: "-cc1" "-triple" "[[TRIPLE]]"
+
+/// In the below tests, --rtlib=platform is used so that the driver ignores
+/// the configure-time CLANG_DEFAULT_RTLIB option when choosing the runtime lib.
+
+// RUN: env "PATH=" %clang -### %s -fuse-ld=ld -no-pie -mabi=lp64d \
+// RUN:   --target=loongarch64-unknown-linux-gnu --rtlib=platform \
+// RUN:   --gcc-toolchain=%S/Inputs/multilib_loongarch_linux_sdk \
+// RUN:   --sysroot=%S/Inputs/multilib_loongarch_linux_sdk/sysroot 2>&1 \
+// RUN:   | FileCheck --check-prefix=LA64 %s
+
+// LA64: "{{.*}}/Inputs/multilib_loongarch_linux_sdk/lib/gcc/loongarch64-unknown-linux-gnu/12.1.0/../../../../loongarch64-unknown-linux-gnu/bin/ld"
+// LA64-SAME: {{^}} "--sysroot={{.*}}/Inputs/multilib_loongarch_linux_sdk/sysroot"
+// LA64-SAME: "-m" "elf64loongarch"
+// LA64-SAME: "-dynamic-linker" "/lib64/ld-linux-loongarch-lp64d.so.1"
+// LA64-SAME: "{{.*}}/Inputs/multilib_loongarch_linux_sdk/lib/gcc/loongarch64-unknown-linux-gnu/12.1.0/crtbegin.o"
+// LA64-SAME: "-L{{.*}}/Inputs/multilib_loongarch_linux_sdk/lib/gcc/loongarch64-unknown-linux-gnu/12.1.0"
+// LA64-SAME: {{^}} "-L{{.*}}/Inputs/multilib_loongarch_linux_sdk/lib/gcc/loongarch64-unknown-linux-gnu/12.1.0/../../../../loongarch64-unknown-linux-gnu/lib/../lib64"
+// LA64-SAME: {{^}} "-L{{.*}}/Inputs/multilib_loongarch_linux_sdk/sysroot/usr/lib/../lib64"
+// LA64-SAME: {{^}} "-L{{.*}}/Inputs/multilib_loongarch_linux_sdk/lib/gcc/loongarch64-unknown-linux-gnu/12.1.0/../../../../loongarch64-unknown-linux-gnu/lib"
+// LA64-SAME: {{^}} "-L{{.*}}/Inputs/multilib_loongarch_linux_sdk/sysroot/usr/lib"

clang/test/Preprocessor/init-loongarch.c

+// RUN: %clang_cc1 -E -dM -ffreestanding -fgnuc-version=4.2.1 -triple=loongarch32 /dev/null \
+// RUN:   | FileCheck --match-full-lines --check-prefix=LA32 %s
+// RUN: %clang_cc1 -E -dM -ffreestanding -fgnuc-version=4.2.1 -triple=loongarch32-unknown-linux /dev/null \
+// RUN:   | FileCheck --match-full-lines --check-prefixes=LA32,LA32-LINUX %s
+// RUN: %clang_cc1 -E -dM -ffreestanding -fgnuc-version=4.2.1 -triple=loongarch32 \
+// RUN: -fforce-enable-int128 /dev/null | FileCheck --match-full-lines \
+// RUN: --check-prefixes=LA32,LA32-INT128 %s
+
+// RUN: %clang_cc1 -E -dM -ffreestanding -fgnuc-version=4.2.1 -triple=loongarch64 /dev/null \
+// RUN:   | FileCheck --match-full-lines --check-prefix=LA64 %s
+// RUN: %clang_cc1 -E -dM -ffreestanding -fgnuc-version=4.2.1 -triple=loongarch64-unknown-linux /dev/null \
+// RUN:   | FileCheck --match-full-lines --check-prefixes=LA64,LA64-LINUX %s
+// RUN: %clang_cc1 -E -dM -ffreestanding -fgnuc-version=4.2.1 -triple=loongarch64 \
+// RUN: -fforce-enable-int128 /dev/null | FileCheck --match-full-lines \
+// RUN: --check-prefixes=LA64,LA64-INT128 %s
+
+//// Note that common macros are tested in init.c, such as __VERSION__. So they're not listed here.
+
+// LA32: #define _ILP32 1
+// LA32: #define __ATOMIC_ACQUIRE 2
+// LA32-NEXT: #define __ATOMIC_ACQ_REL 4
+// LA32-NEXT: #define __ATOMIC_CONSUME 1
+// LA32-NEXT: #define __ATOMIC_RELAXED 0
+// LA32-NEXT: #define __ATOMIC_RELEASE 3
+// LA32-NEXT: #define __ATOMIC_SEQ_CST 5
+// LA32: #define __BIGGEST_ALIGNMENT__ 16
+// LA32: #define __BITINT_MAXWIDTH__ 128
+// LA32: #define __BOOL_WIDTH__ 8
+// LA32: #define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
+// LA32: #define __CHAR16_TYPE__ unsigned short
+// LA32: #define __CHAR32_TYPE__ unsigned int
+// LA32: #define __CHAR_BIT__ 8
+// LA32: #define __CLANG_ATOMIC_BOOL_LOCK_FREE 1
+// LA32: #define __CLANG_ATOMIC_CHAR16_T_LOCK_FREE 1
+// LA32: #define __CLANG_ATOMIC_CHAR32_T_LOCK_FREE 1
+// LA32: #define __CLANG_ATOMIC_CHAR_LOCK_FREE 1
+// LA32: #define __CLANG_ATOMIC_INT_LOCK_FREE 1
+// LA32: #define __CLANG_ATOMIC_LLONG_LOCK_FREE 1
+// LA32: #define __CLANG_ATOMIC_LONG_LOCK_FREE 1
+// LA32: #define __CLANG_ATOMIC_POINTER_LOCK_FREE 1
+// LA32: #define __CLANG_ATOMIC_SHORT_LOCK_FREE 1
+// LA32: #define __CLANG_ATOMIC_WCHAR_T_LOCK_FREE 1
+// LA32: #define __DBL_DECIMAL_DIG__ 17
+// LA32: #define __DBL_DENORM_MIN__ 4.9406564584124654e-324
+// LA32: #define __DBL_DIG__ 15
+// LA32: #define __DBL_EPSILON__ 2.2204460492503131e-16
+// LA32: #define __DBL_HAS_DENORM__ 1
+// LA32: #define __DBL_HAS_INFINITY__ 1
+// LA32: #define __DBL_HAS_QUIET_NAN__ 1
+// LA32: #define __DBL_MANT_DIG__ 53
+// LA32: #define __DBL_MAX_10_EXP__ 308
+// LA32: #define __DBL_MAX_EXP__ 1024
+// LA32: #define __DBL_MAX__ 1.7976931348623157e+308
+// LA32: #define __DBL_MIN_10_EXP__ (-307)
+// LA32: #define __DBL_MIN_EXP__ (-1021)
+// LA32: #define __DBL_MIN__ 2.2250738585072014e-308
+// LA32: #define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
+// LA32: #define __FLT_DECIMAL_DIG__ 9
+// LA32: #define __FLT_DENORM_MIN__ 1.40129846e-45F
+// LA32: #define __FLT_DIG__ 6
+// LA32: #define __FLT_EPSILON__ 1.19209290e-7F
+// LA32: #define __FLT_HAS_DENORM__ 1
+// LA32: #define __FLT_HAS_INFINITY__ 1
+// LA32: #define __FLT_HAS_QUIET_NAN__ 1
+// LA32: #define __FLT_MANT_DIG__ 24
+// LA32: #define __FLT_MAX_10_EXP__ 38
+// LA32: #define __FLT_MAX_EXP__ 128
+// LA32: #define __FLT_MAX__ 3.40282347e+38F
+// LA32: #define __FLT_MIN_10_EXP__ (-37)
+// LA32: #define __FLT_MIN_EXP__ (-125)
+// LA32: #define __FLT_MIN__ 1.17549435e-38F
+// LA32: #define __FLT_RADIX__ 2
+// LA32: #define __GCC_ATOMIC_BOOL_LOCK_FREE 1
+// LA32: #define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 1
+// LA32: #define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 1
+// LA32: #define __GCC_ATOMIC_CHAR_LOCK_FREE 1
+// LA32: #define __GCC_ATOMIC_INT_LOCK_FREE 1
+// LA32: #define __GCC_ATOMIC_LLONG_LOCK_FREE 1
+// LA32: #define __GCC_ATOMIC_LONG_LOCK_FREE 1
+// LA32: #define __GCC_ATOMIC_POINTER_LOCK_FREE 1
+// LA32: #define __GCC_ATOMIC_SHORT_LOCK_FREE 1
+// LA32: #define __GCC_ATOMIC_TEST_AND_SET_TRUEVAL 1
+// LA32: #define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 1
+// LA32: #define __ILP32__ 1
+// LA32: #define __INT16_C_SUFFIX__
+// LA32: #define __INT16_FMTd__ "hd"
+// LA32: #define __INT16_FMTi__ "hi"
+// LA32: #define __INT16_MAX__ 32767
+// LA32: #define __INT16_TYPE__ short
+// LA32: #define __INT32_C_SUFFIX__
+// LA32: #define __INT32_FMTd__ "d"
+// LA32: #define __INT32_FMTi__ "i"
+// LA32: #define __INT32_MAX__ 2147483647
+// LA32: #define __INT32_TYPE__ int
+// LA32: #define __INT64_C_SUFFIX__ LL
+// LA32: #define __INT64_FMTd__ "lld"
+// LA32: #define __INT64_FMTi__ "lli"
+// LA32: #define __INT64_MAX__ 9223372036854775807LL
+// LA32: #define __INT64_TYPE__ long long int
+// LA32: #define __INT8_C_SUFFIX__
+// LA32: #define __INT8_FMTd__ "hhd"
+// LA32: #define __INT8_FMTi__ "hhi"
+// LA32: #define __INT8_MAX__ 127
+// LA32: #define __INT8_TYPE__ signed char
+// LA32: #define __INTMAX_C_SUFFIX__ LL
+// LA32: #define __INTMAX_FMTd__ "lld"
+// LA32: #define __INTMAX_FMTi__ "lli"
+// LA32: #define __INTMAX_MAX__ 9223372036854775807LL
+// LA32: #define __INTMAX_TYPE__ long long int
+// LA32: #define __INTMAX_WIDTH__ 64
+// LA32: #define __INTPTR_FMTd__ "d"
+// LA32: #define __INTPTR_FMTi__ "i"
+// LA32: #define __INTPTR_MAX__ 2147483647
+// LA32: #define __INTPTR_TYPE__ int
+// LA32: #define __INTPTR_WIDTH__ 32
+// LA32: #define __INT_FAST16_FMTd__ "hd"
+// LA32: #define __INT_FAST16_FMTi__ "hi"
+// LA32: #define __INT_FAST16_MAX__ 32767
+// LA32: #define __INT_FAST16_TYPE__ short
+// LA32: #define __INT_FAST16_WIDTH__ 16
+// LA32: #define __INT_FAST32_FMTd__ "d"
+// LA32: #define __INT_FAST32_FMTi__ "i"
+// LA32: #define __INT_FAST32_MAX__ 2147483647
+// LA32: #define __INT_FAST32_TYPE__ int
+// LA32: #define __INT_FAST32_WIDTH__ 32
+// LA32: #define __INT_FAST64_FMTd__ "lld"
+// LA32: #define __INT_FAST64_FMTi__ "lli"
+// LA32: #define __INT_FAST64_MAX__ 9223372036854775807LL
+// LA32: #define __INT_FAST64_TYPE__ long long int
+// LA32: #define __INT_FAST64_WIDTH__ 64
+// LA32: #define __INT_FAST8_FMTd__ "hhd"
+// LA32: #define __INT_FAST8_FMTi__ "hhi"
+// LA32: #define __INT_FAST8_MAX__ 127
+// LA32: #define __INT_FAST8_TYPE__ signed char
+// LA32: #define __INT_FAST8_WIDTH__ 8
+// LA32: #define __INT_LEAST16_FMTd__ "hd"
+// LA32: #define __INT_LEAST16_FMTi__ "hi"
+// LA32: #define __INT_LEAST16_MAX__ 32767
+// LA32: #define __INT_LEAST16_TYPE__ short
+// LA32: #define __INT_LEAST16_WIDTH__ 16
+// LA32: #define __INT_LEAST32_FMTd__ "d"
+// LA32: #define __INT_LEAST32_FMTi__ "i"
+// LA32: #define __INT_LEAST32_MAX__ 2147483647
+// LA32: #define __INT_LEAST32_TYPE__ int
+// LA32: #define __INT_LEAST32_WIDTH__ 32
+// LA32: #define __INT_LEAST64_FMTd__ "lld"
+// LA32: #define __INT_LEAST64_FMTi__ "lli"
+// LA32: #define __INT_LEAST64_MAX__ 9223372036854775807LL
+// LA32: #define __INT_LEAST64_TYPE__ long long int
+// LA32: #define __INT_LEAST64_WIDTH__ 64
+// LA32: #define __INT_LEAST8_FMTd__ "hhd"
+// LA32: #define __INT_LEAST8_FMTi__ "hhi"
+// LA32: #define __INT_LEAST8_MAX__ 127
+// LA32: #define __INT_LEAST8_TYPE__ signed char
+// LA32: #define __INT_LEAST8_WIDTH__ 8
+// LA32: #define __INT_MAX__ 2147483647
+// LA32: #define __INT_WIDTH__ 32
+// LA32: #define __LDBL_DECIMAL_DIG__ 36
+// LA32: #define __LDBL_DENORM_MIN__ 6.47517511943802511092443895822764655e-4966L
+// LA32: #define __LDBL_DIG__ 33
+// LA32: #define __LDBL_EPSILON__ 1.92592994438723585305597794258492732e-34L
+// LA32: #define __LDBL_HAS_DENORM__ 1
+// LA32: #define __LDBL_HAS_INFINITY__ 1
+// LA32: #define __LDBL_HAS_QUIET_NAN__ 1
+// LA32: #define __LDBL_MANT_DIG__ 113
+// LA32: #define __LDBL_MAX_10_EXP__ 4932
+// LA32: #define __LDBL_MAX_EXP__ 16384
+// LA32: #define __LDBL_MAX__ 1.18973149535723176508575932662800702e+4932L
+// LA32: #define __LDBL_MIN_10_EXP__ (-4931)
+// LA32: #define __LDBL_MIN_EXP__ (-16381)
+// LA32: #define __LDBL_MIN__ 3.36210314311209350626267781732175260e-4932L
+// LA32: #define __LITTLE_ENDIAN__ 1
+// LA32: #define __LLONG_WIDTH__ 64
+// LA32: #define __LONG_LONG_MAX__ 9223372036854775807LL
+// LA32: #define __LONG_MAX__ 2147483647L
+// LA32: #define __LONG_WIDTH__ 32
+// LA32: #define __NO_INLINE__ 1
+// LA32: #define __NO_MATH_ERRNO__ 1
+// LA32: #define __OBJC_BOOL_IS_BOOL 0
+// LA32: #define __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES 3
+// LA32: #define __OPENCL_MEMORY_SCOPE_DEVICE 2
+// LA32: #define __OPENCL_MEMORY_SCOPE_SUB_GROUP 4
+// LA32: #define __OPENCL_MEMORY_SCOPE_WORK_GROUP 1
+// LA32: #define __OPENCL_MEMORY_SCOPE_WORK_ITEM 0
+// LA32: #define __POINTER_WIDTH__ 32
+// LA32: #define __PRAGMA_REDEFINE_EXTNAME 1
+// LA32: #define __PTRDIFF_FMTd__ "d"
+// LA32: #define __PTRDIFF_FMTi__ "i"
+// LA32: #define __PTRDIFF_MAX__ 2147483647
+// LA32: #define __PTRDIFF_TYPE__ int
+// LA32: #define __PTRDIFF_WIDTH__ 32
+// LA32: #define __SCHAR_MAX__ 127
+// LA32: #define __SHRT_MAX__ 32767
+// LA32: #define __SHRT_WIDTH__ 16
+// LA32: #define __SIG_ATOMIC_MAX__ 2147483647
+// LA32: #define __SIG_ATOMIC_WIDTH__ 32
+// LA32: #define __SIZEOF_DOUBLE__ 8
+// LA32: #define __SIZEOF_FLOAT__ 4
+// LA32-INT128: #define __SIZEOF_INT128__ 16
+// LA32: #define __SIZEOF_INT__ 4
+// LA32: #define __SIZEOF_LONG_DOUBLE__ 16
+// LA32: #define __SIZEOF_LONG_LONG__ 8
+// LA32: #define __SIZEOF_LONG__ 4
+// LA32: #define __SIZEOF_POINTER__ 4
+// LA32: #define __SIZEOF_PTRDIFF_T__ 4
+// LA32: #define __SIZEOF_SHORT__ 2
+// LA32: #define __SIZEOF_SIZE_T__ 4
+// LA32: #define __SIZEOF_WCHAR_T__ 4
+// LA32: #define __SIZEOF_WINT_T__ 4
+// LA32: #define __SIZE_FMTX__ "X"
+// LA32: #define __SIZE_FMTo__ "o"
+// LA32: #define __SIZE_FMTu__ "u"
+// LA32: #define __SIZE_FMTx__ "x"
+// LA32: #define __SIZE_MAX__ 4294967295U
+// LA32: #define __SIZE_TYPE__ unsigned int
+// LA32: #define __SIZE_WIDTH__ 32
+// LA32: #define __STDC_HOSTED__ 0
+// LA32: #define __STDC_UTF_16__ 1
+// LA32: #define __STDC_UTF_32__ 1
+// LA32: #define __STDC_VERSION__ 201710L
+// LA32: #define __STDC__ 1
+// LA32: #define __UINT16_C_SUFFIX__
+// LA32: #define __UINT16_FMTX__ "hX"
+// LA32: #define __UINT16_FMTo__ "ho"
+// LA32: #define __UINT16_FMTu__ "hu"
+// LA32: #define __UINT16_FMTx__ "hx"
+// LA32: #define __UINT16_MAX__ 65535
+// LA32: #define __UINT16_TYPE__ unsigned short
+// LA32: #define __UINT32_C_SUFFIX__ U
+// LA32: #define __UINT32_FMTX__ "X"
+// LA32: #define __UINT32_FMTo__ "o"
+// LA32: #define __UINT32_FMTu__ "u"
+// LA32: #define __UINT32_FMTx__ "x"
+// LA32: #define __UINT32_MAX__ 4294967295U
+// LA32: #define __UINT32_TYPE__ unsigned int
+// LA32: #define __UINT64_C_SUFFIX__ ULL
+// LA32: #define __UINT64_FMTX__ "llX"
+// LA32: #define __UINT64_FMTo__ "llo"
+// LA32: #define __UINT64_FMTu__ "llu"
+// LA32: #define __UINT64_FMTx__ "llx"
+// LA32: #define __UINT64_MAX__ 18446744073709551615ULL
+// LA32: #define __UINT64_TYPE__ long long unsigned int
+// LA32: #define __UINT8_C_SUFFIX__
+// LA32: #define __UINT8_FMTX__ "hhX"
+// LA32: #define __UINT8_FMTo__ "hho"
+// LA32: #define __UINT8_FMTu__ "hhu"
+// LA32: #define __UINT8_FMTx__ "hhx"
+// LA32: #define __UINT8_MAX__ 255
+// LA32: #define __UINT8_TYPE__ unsigned char
+// LA32: #define __UINTMAX_C_SUFFIX__ ULL
+// LA32: #define __UINTMAX_FMTX__ "llX"
+// LA32: #define __UINTMAX_FMTo__ "llo"
+// LA32: #define __UINTMAX_FMTu__ "llu"
+// LA32: #define __UINTMAX_FMTx__ "llx"
+// LA32: #define __UINTMAX_MAX__ 18446744073709551615ULL
+// LA32: #define __UINTMAX_TYPE__ long long unsigned int
+// LA32: #define __UINTMAX_WIDTH__ 64
+// LA32: #define __UINTPTR_FMTX__ "X"
+// LA32: #define __UINTPTR_FMTo__ "o"
+// LA32: #define __UINTPTR_FMTu__ "u"
+// LA32: #define __UINTPTR_FMTx__ "x"
+// LA32: #define __UINTPTR_MAX__ 4294967295U
+// LA32: #define __UINTPTR_TYPE__ unsigned int
+// LA32: #define __UINTPTR_WIDTH__ 32
+// LA32: #define __UINT_FAST16_FMTX__ "hX"
+// LA32: #define __UINT_FAST16_FMTo__ "ho"
+// LA32: #define __UINT_FAST16_FMTu__ "hu"
+// LA32: #define __UINT_FAST16_FMTx__ "hx"
+// LA32: #define __UINT_FAST16_MAX__ 65535
+// TODO: LoongArch GCC defines UINT_FAST16 to be long unsigned int
+// LA32: #define __UINT_FAST16_TYPE__ unsigned short
+// LA32: #define __UINT_FAST32_FMTX__ "X"
+// LA32: #define __UINT_FAST32_FMTo__ "o"
+// LA32: #define __UINT_FAST32_FMTu__ "u"
+// LA32: #define __UINT_FAST32_FMTx__ "x"
+// LA32: #define __UINT_FAST32_MAX__ 4294967295U
+// LA32: #define __UINT_FAST32_TYPE__ unsigned int
+// LA32: #define __UINT_FAST64_FMTX__ "llX"
+// LA32: #define __UINT_FAST64_FMTo__ "llo"
+// LA32: #define __UINT_FAST64_FMTu__ "llu"
+// LA32: #define __UINT_FAST64_FMTx__ "llx"
+// LA32: #define __UINT_FAST64_MAX__ 18446744073709551615ULL
+// LA32: #define __UINT_FAST64_TYPE__ long long unsigned int
+// LA32: #define __UINT_FAST8_FMTX__ "hhX"
+// LA32: #define __UINT_FAST8_FMTo__ "hho"
+// LA32: #define __UINT_FAST8_FMTu__ "hhu"
+// LA32: #define __UINT_FAST8_FMTx__ "hhx"
+// LA32: #define __UINT_FAST8_MAX__ 255
+// LA32: #define __UINT_FAST8_TYPE__ unsigned char
+// LA32: #define __UINT_LEAST16_FMTX__ "hX"
+// LA32: #define __UINT_LEAST16_FMTo__ "ho"
+// LA32: #define __UINT_LEAST16_FMTu__ "hu"
+// LA32: #define __UINT_LEAST16_FMTx__ "hx"
+// LA32: #define __UINT_LEAST16_MAX__ 65535
+// LA32: #define __UINT_LEAST16_TYPE__ unsigned short
+// LA32: #define __UINT_LEAST32_FMTX__ "X"
+// LA32: #define __UINT_LEAST32_FMTo__ "o"
+// LA32: #define __UINT_LEAST32_FMTu__ "u"
+// LA32: #define __UINT_LEAST32_FMTx__ "x"
+// LA32: #define __UINT_LEAST32_MAX__ 4294967295U
+// LA32: #define __UINT_LEAST32_TYPE__ unsigned int
+// LA32: #define __UINT_LEAST64_FMTX__ "llX"
+// LA32: #define __UINT_LEAST64_FMTo__ "llo"
+// LA32: #define __UINT_LEAST64_FMTu__ "llu"
+// LA32: #define __UINT_LEAST64_FMTx__ "llx"
+// LA32: #define __UINT_LEAST64_MAX__ 18446744073709551615ULL
+// LA32: #define __UINT_LEAST64_TYPE__ long long unsigned int
+// LA32: #define __UINT_LEAST8_FMTX__ "hhX"
+// LA32: #define __UINT_LEAST8_FMTo__ "hho"
+// LA32: #define __UINT_LEAST8_FMTu__ "hhu"
+// LA32: #define __UINT_LEAST8_FMTx__ "hhx"
+// LA32: #define __UINT_LEAST8_MAX__ 255
+// LA32: #define __UINT_LEAST8_TYPE__ unsigned char
+// LA32: #define __USER_LABEL_PREFIX__
+// LA32: #define __WCHAR_MAX__ 2147483647
+// LA32: #define __WCHAR_TYPE__ int
+// LA32: #define __WCHAR_WIDTH__ 32
+// LA32: #define __WINT_MAX__ 4294967295U
+// LA32: #define __WINT_TYPE__ unsigned int
+// LA32: #define __WINT_UNSIGNED__ 1
+// LA32: #define __WINT_WIDTH__ 32
+// LA32-LINUX: #define __gnu_linux__ 1
+// LA32-LINUX: #define __linux 1
+// LA32-LINUX: #define __linux__ 1
+// LA32: #define __loongarch__ 1
+// LA32-LINUX: #define __unix 1
+// LA32-LINUX: #define __unix__ 1
+// LA32-LINUX: #define linux 1
+// LA32-LINUX: #define unix 1
+
+// LA64: #define _LP64 1
+// LA64: #define __ATOMIC_ACQUIRE 2
+// LA64-NEXT: #define __ATOMIC_ACQ_REL 4
+// LA64-NEXT: #define __ATOMIC_CONSUME 1
+// LA64-NEXT: #define __ATOMIC_RELAXED 0
+// LA64-NEXT: #define __ATOMIC_RELEASE 3
+// LA64-NEXT: #define __ATOMIC_SEQ_CST 5
+// LA64: #define __BIGGEST_ALIGNMENT__ 16
+// LA64: #define __BITINT_MAXWIDTH__ 128
+// LA64: #define __BOOL_WIDTH__ 8
+// LA64: #define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
+// LA64: #define __CHAR16_TYPE__ unsigned short
+// LA64: #define __CHAR32_TYPE__ unsigned int
+// LA64: #define __CHAR_BIT__ 8
+// LA64: #define __CLANG_ATOMIC_BOOL_LOCK_FREE 1
+// LA64: #define __CLANG_ATOMIC_CHAR16_T_LOCK_FREE 1
+// LA64: #define __CLANG_ATOMIC_CHAR32_T_LOCK_FREE 1
+// LA64: #define __CLANG_ATOMIC_CHAR_LOCK_FREE 1
+// LA64: #define __CLANG_ATOMIC_INT_LOCK_FREE 1
+// LA64: #define __CLANG_ATOMIC_LLONG_LOCK_FREE 1
+// LA64: #define __CLANG_ATOMIC_LONG_LOCK_FREE 1
+// LA64: #define __CLANG_ATOMIC_POINTER_LOCK_FREE 1
+// LA64: #define __CLANG_ATOMIC_SHORT_LOCK_FREE 1
+// LA64: #define __CLANG_ATOMIC_WCHAR_T_LOCK_FREE 1
+// LA64: #define __DBL_DECIMAL_DIG__ 17
+// LA64: #define __DBL_DENORM_MIN__ 4.9406564584124654e-324
+// LA64: #define __DBL_DIG__ 15
+// LA64: #define __DBL_EPSILON__ 2.2204460492503131e-16
+// LA64: #define __DBL_HAS_DENORM__ 1
+// LA64: #define __DBL_HAS_INFINITY__ 1
+// LA64: #define __DBL_HAS_QUIET_NAN__ 1
+// LA64: #define __DBL_MANT_DIG__ 53
+// LA64: #define __DBL_MAX_10_EXP__ 308
+// LA64: #define __DBL_MAX_EXP__ 1024
+// LA64: #define __DBL_MAX__ 1.7976931348623157e+308
+// LA64: #define __DBL_MIN_10_EXP__ (-307)
+// LA64: #define __DBL_MIN_EXP__ (-1021)
+// LA64: #define __DBL_MIN__ 2.2250738585072014e-308
+// LA64: #define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
+// LA64: #define __FLT_DECIMAL_DIG__ 9
+// LA64: #define __FLT_DENORM_MIN__ 1.40129846e-45F
+// LA64: #define __FLT_DIG__ 6
+// LA64: #define __FLT_EPSILON__ 1.19209290e-7F
+// LA64: #define __FLT_HAS_DENORM__ 1
+// LA64: #define __FLT_HAS_INFINITY__ 1
+// LA64: #define __FLT_HAS_QUIET_NAN__ 1
+// LA64: #define __FLT_MANT_DIG__ 24
+// LA64: #define __FLT_MAX_10_EXP__ 38
+// LA64: #define __FLT_MAX_EXP__ 128
+// LA64: #define __FLT_MAX__ 3.40282347e+38F
+// LA64: #define __FLT_MIN_10_EXP__ (-37)
+// LA64: #define __FLT_MIN_EXP__ (-125)
+// LA64: #define __FLT_MIN__ 1.17549435e-38F
+// LA64: #define __FLT_RADIX__ 2
+// LA64: #define __GCC_ATOMIC_BOOL_LOCK_FREE 1
+// LA64: #define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 1
+// LA64: #define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 1
+// LA64: #define __GCC_ATOMIC_CHAR_LOCK_FREE 1
+// LA64: #define __GCC_ATOMIC_INT_LOCK_FREE 1
+// LA64: #define __GCC_ATOMIC_LLONG_LOCK_FREE 1
+// LA64: #define __GCC_ATOMIC_LONG_LOCK_FREE 1
+// LA64: #define __GCC_ATOMIC_POINTER_LOCK_FREE 1
+// LA64: #define __GCC_ATOMIC_SHORT_LOCK_FREE 1
+// LA64: #define __GCC_ATOMIC_TEST_AND_SET_TRUEVAL 1
+// LA64: #define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 1
+// LA64: #define __INT16_C_SUFFIX__
+// LA64: #define __INT16_FMTd__ "hd"
+// LA64: #define __INT16_FMTi__ "hi"
+// LA64: #define __INT16_MAX__ 32767
+// LA64: #define __INT16_TYPE__ short
+// LA64: #define __INT32_C_SUFFIX__
+// LA64: #define __INT32_FMTd__ "d"
+// LA64: #define __INT32_FMTi__ "i"
+// LA64: #define __INT32_MAX__ 2147483647
+// LA64: #define __INT32_TYPE__ int
+// LA64: #define __INT64_C_SUFFIX__ L
+// LA64: #define __INT64_FMTd__ "ld"
+// LA64: #define __INT64_FMTi__ "li"
+// LA64: #define __INT64_MAX__ 9223372036854775807L
+// LA64: #define __INT64_TYPE__ long int
+// LA64: #define __INT8_C_SUFFIX__
+// LA64: #define __INT8_FMTd__ "hhd"
+// LA64: #define __INT8_FMTi__ "hhi"
+// LA64: #define __INT8_MAX__ 127
+// LA64: #define __INT8_TYPE__ signed char
+// LA64: #define __INTMAX_C_SUFFIX__ L
+// LA64: #define __INTMAX_FMTd__ "ld"
+// LA64: #define __INTMAX_FMTi__ "li"
+// LA64: #define __INTMAX_MAX__ 9223372036854775807L
+// LA64: #define __INTMAX_TYPE__ long int
+// LA64: #define __INTMAX_WIDTH__ 64
+// LA64: #define __INTPTR_FMTd__ "ld"
+// LA64: #define __INTPTR_FMTi__ "li"
+// LA64: #define __INTPTR_MAX__ 9223372036854775807L
+// LA64: #define __INTPTR_TYPE__ long int
+// LA64: #define __INTPTR_WIDTH__ 64
+// LA64: #define __INT_FAST16_FMTd__ "hd"
+// LA64: #define __INT_FAST16_FMTi__ "hi"
+// LA64: #define __INT_FAST16_MAX__ 32767
+// LA64: #define __INT_FAST16_TYPE__ short
+// LA64: #define __INT_FAST16_WIDTH__ 16
+// LA64: #define __INT_FAST32_FMTd__ "d"
+// LA64: #define __INT_FAST32_FMTi__ "i"
+// LA64: #define __INT_FAST32_MAX__ 2147483647
+// LA64: #define __INT_FAST32_TYPE__ int
+// LA64: #define __INT_FAST32_WIDTH__ 32
+// LA64: #define __INT_FAST64_FMTd__ "ld"
+// LA64: #define __INT_FAST64_FMTi__ "li"
+// LA64: #define __INT_FAST64_MAX__ 9223372036854775807L
+// LA64: #define __INT_FAST64_TYPE__ long int
+// LA64: #define __INT_FAST64_WIDTH__ 64
+// LA64: #define __INT_FAST8_FMTd__ "hhd"
+// LA64: #define __INT_FAST8_FMTi__ "hhi"
+// LA64: #define __INT_FAST8_MAX__ 127
+// LA64: #define __INT_FAST8_TYPE__ signed char
+// LA64: #define __INT_FAST8_WIDTH__ 8
+// LA64: #define __INT_LEAST16_FMTd__ "hd"
+// LA64: #define __INT_LEAST16_FMTi__ "hi"
+// LA64: #define __INT_LEAST16_MAX__ 32767
+// LA64: #define __INT_LEAST16_TYPE__ short
+// LA64: #define __INT_LEAST16_WIDTH__ 16
+// LA64: #define __INT_LEAST32_FMTd__ "d"
+// LA64: #define __INT_LEAST32_FMTi__ "i"
+// LA64: #define __INT_LEAST32_MAX__ 2147483647
+// LA64: #define __INT_LEAST32_TYPE__ int
+// LA64: #define __INT_LEAST32_WIDTH__ 32
+// LA64: #define __INT_LEAST64_FMTd__ "ld"
+// LA64: #define __INT_LEAST64_FMTi__ "li"
+// LA64: #define __INT_LEAST64_MAX__ 9223372036854775807L
+// LA64: #define __INT_LEAST64_TYPE__ long int
+// LA64: #define __INT_LEAST64_WIDTH__ 64
+// LA64: #define __INT_LEAST8_FMTd__ "hhd"
+// LA64: #define __INT_LEAST8_FMTi__ "hhi"
+// LA64: #define __INT_LEAST8_MAX__ 127
+// LA64: #define __INT_LEAST8_TYPE__ signed char
+// LA64: #define __INT_LEAST8_WIDTH__ 8
+// LA64: #define __INT_MAX__ 2147483647
+// LA64: #define __INT_WIDTH__ 32
+// LA64: #define __LDBL_DECIMAL_DIG__ 36
+// LA64: #define __LDBL_DENORM_MIN__ 6.47517511943802511092443895822764655e-4966L
+// LA64: #define __LDBL_DIG__ 33
+// LA64: #define __LDBL_EPSILON__ 1.92592994438723585305597794258492732e-34L
+// LA64: #define __LDBL_HAS_DENORM__ 1
+// LA64: #define __LDBL_HAS_INFINITY__ 1
+// LA64: #define __LDBL_HAS_QUIET_NAN__ 1
+// LA64: #define __LDBL_MANT_DIG__ 113
+// LA64: #define __LDBL_MAX_10_EXP__ 4932
+// LA64: #define __LDBL_MAX_EXP__ 16384
+// LA64: #define __LDBL_MAX__ 1.18973149535723176508575932662800702e+4932L
+// LA64: #define __LDBL_MIN_10_EXP__ (-4931)
+// LA64: #define __LDBL_MIN_EXP__ (-16381)
+// LA64: #define __LDBL_MIN__ 3.36210314311209350626267781732175260e-4932L
+// LA64: #define __LITTLE_ENDIAN__ 1
+// LA64: #define __LLONG_WIDTH__ 64
+// LA64: #define __LONG_LONG_MAX__ 9223372036854775807LL
+// LA64: #define __LONG_MAX__ 9223372036854775807L
+// LA64: #define __LONG_WIDTH__ 64
+// LA64: #define __LP64__ 1
+// LA64: #define __NO_INLINE__ 1
+// LA64: #define __NO_MATH_ERRNO__ 1
+// LA64: #define __OBJC_BOOL_IS_BOOL 0
+// LA64: #define __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES 3
+// LA64: #define __OPENCL_MEMORY_SCOPE_DEVICE 2
+// LA64: #define __OPENCL_MEMORY_SCOPE_SUB_GROUP 4
+// LA64: #define __OPENCL_MEMORY_SCOPE_WORK_GROUP 1
+// LA64: #define __OPENCL_MEMORY_SCOPE_WORK_ITEM 0
+// LA64: #define __POINTER_WIDTH__ 64
+// LA64: #define __PRAGMA_REDEFINE_EXTNAME 1
+// LA64: #define __PTRDIFF_FMTd__ "ld"
+// LA64: #define __PTRDIFF_FMTi__ "li"
+// LA64: #define __PTRDIFF_MAX__ 9223372036854775807L
+// LA64: #define __PTRDIFF_TYPE__ long int
+// LA64: #define __PTRDIFF_WIDTH__ 64
+// LA64: #define __SCHAR_MAX__ 127
+// LA64: #define __SHRT_MAX__ 32767
+// LA64: #define __SHRT_WIDTH__ 16
+// LA64: #define __SIG_ATOMIC_MAX__ 2147483647
+// LA64: #define __SIG_ATOMIC_WIDTH__ 32
+// LA64: #define __SIZEOF_DOUBLE__ 8
+// LA64: #define __SIZEOF_FLOAT__ 4
+// LA64-INT128: #define __SIZEOF_INT128__ 16
+// LA64: #define __SIZEOF_INT__ 4
+// LA64: #define __SIZEOF_LONG_DOUBLE__ 16
+// LA64: #define __SIZEOF_LONG_LONG__ 8
+// LA64: #define __SIZEOF_LONG__ 8
+// LA64: #define __SIZEOF_POINTER__ 8
+// LA64: #define __SIZEOF_PTRDIFF_T__ 8
+// LA64: #define __SIZEOF_SHORT__ 2
+// LA64: #define __SIZEOF_SIZE_T__ 8
+// LA64: #define __SIZEOF_WCHAR_T__ 4
+// LA64: #define __SIZEOF_WINT_T__ 4
+// LA64: #define __SIZE_FMTX__ "lX"
+// LA64: #define __SIZE_FMTo__ "lo"
+// LA64: #define __SIZE_FMTu__ "lu"
+// LA64: #define __SIZE_FMTx__ "lx"
+// LA64: #define __SIZE_MAX__ 18446744073709551615UL
+// LA64: #define __SIZE_TYPE__ long unsigned int
+// LA64: #define __SIZE_WIDTH__ 64
+// LA64: #define __STDC_HOSTED__ 0
+// LA64: #define __STDC_UTF_16__ 1
+// LA64: #define __STDC_UTF_32__ 1
+// LA64: #define __STDC_VERSION__ 201710L
+// LA64: #define __STDC__ 1
+// LA64: #define __UINT16_C_SUFFIX__
+// LA64: #define __UINT16_FMTX__ "hX"
+// LA64: #define __UINT16_FMTo__ "ho"
+// LA64: #define __UINT16_FMTu__ "hu"
+// LA64: #define __UINT16_FMTx__ "hx"
+// LA64: #define __UINT16_MAX__ 65535
+// LA64: #define __UINT16_TYPE__ unsigned short
+// LA64: #define __UINT32_C_SUFFIX__ U
+// LA64: #define __UINT32_FMTX__ "X"
+// LA64: #define __UINT32_FMTo__ "o"
+// LA64: #define __UINT32_FMTu__ "u"
+// LA64: #define __UINT32_FMTx__ "x"
+// LA64: #define __UINT32_MAX__ 4294967295U
+// LA64: #define __UINT32_TYPE__ unsigned int
+// LA64: #define __UINT64_C_SUFFIX__ UL
+// LA64: #define __UINT64_FMTX__ "lX"
+// LA64: #define __UINT64_FMTo__ "lo"
+// LA64: #define __UINT64_FMTu__ "lu"
+// LA64: #define __UINT64_FMTx__ "lx"
+// LA64: #define __UINT64_MAX__ 18446744073709551615UL
+// LA64: #define __UINT64_TYPE__ long unsigned int
+// LA64: #define __UINT8_C_SUFFIX__
+// LA64: #define __UINT8_FMTX__ "hhX"
+// LA64: #define __UINT8_FMTo__ "hho"
+// LA64: #define __UINT8_FMTu__ "hhu"
+// LA64: #define __UINT8_FMTx__ "hhx"
+// LA64: #define __UINT8_MAX__ 255
+// LA64: #define __UINT8_TYPE__ unsigned char
+// LA64: #define __UINTMAX_C_SUFFIX__ UL
+// LA64: #define __UINTMAX_FMTX__ "lX"
+// LA64: #define __UINTMAX_FMTo__ "lo"
+// LA64: #define __UINTMAX_FMTu__ "lu"
+// LA64: #define __UINTMAX_FMTx__ "lx"
+// LA64: #define __UINTMAX_MAX__ 18446744073709551615UL
+// LA64: #define __UINTMAX_TYPE__ long unsigned int
+// LA64: #define __UINTMAX_WIDTH__ 64
+// LA64: #define __UINTPTR_FMTX__ "lX"
+// LA64: #define __UINTPTR_FMTo__ "lo"
+// LA64: #define __UINTPTR_FMTu__ "lu"
+// LA64: #define __UINTPTR_FMTx__ "lx"
+// LA64: #define __UINTPTR_MAX__ 18446744073709551615UL
+// LA64: #define __UINTPTR_TYPE__ long unsigned int
+// LA64: #define __UINTPTR_WIDTH__ 64
+// LA64: #define __UINT_FAST16_FMTX__ "hX"
+// LA64: #define __UINT_FAST16_FMTo__ "ho"
+// LA64: #define __UINT_FAST16_FMTu__ "hu"
+// LA64: #define __UINT_FAST16_FMTx__ "hx"
+// LA64: #define __UINT_FAST16_MAX__ 65535
+// TODO: LoongArch GCC defines UINT_FAST16 to be long unsigned int
+// LA64: #define __UINT_FAST16_TYPE__ unsigned short
+// LA64: #define __UINT_FAST32_FMTX__ "X"
+// LA64: #define __UINT_FAST32_FMTo__ "o"
+// LA64: #define __UINT_FAST32_FMTu__ "u"
+// LA64: #define __UINT_FAST32_FMTx__ "x"
+// LA64: #define __UINT_FAST32_MAX__ 4294967295U
+// LA64: #define __UINT_FAST32_TYPE__ unsigned int
+// LA64: #define __UINT_FAST64_FMTX__ "lX"
+// LA64: #define __UINT_FAST64_FMTo__ "lo"
+// LA64: #define __UINT_FAST64_FMTu__ "lu"
+// LA64: #define __UINT_FAST64_FMTx__ "lx"
+// LA64: #define __UINT_FAST64_MAX__ 18446744073709551615UL
+// LA64: #define __UINT_FAST64_TYPE__ long unsigned int
+// LA64: #define __UINT_FAST8_FMTX__ "hhX"
+// LA64: #define __UINT_FAST8_FMTo__ "hho"
+// LA64: #define __UINT_FAST8_FMTu__ "hhu"
+// LA64: #define __UINT_FAST8_FMTx__ "hhx"
+// LA64: #define __UINT_FAST8_MAX__ 255
+// LA64: #define __UINT_FAST8_TYPE__ unsigned char
+// LA64: #define __UINT_LEAST16_FMTX__ "hX"
+// LA64: #define __UINT_LEAST16_FMTo__ "ho"
+// LA64: #define __UINT_LEAST16_FMTu__ "hu"
+// LA64: #define __UINT_LEAST16_FMTx__ "hx"
+// LA64: #define __UINT_LEAST16_MAX__ 65535
+// LA64: #define __UINT_LEAST16_TYPE__ unsigned short
+// LA64: #define __UINT_LEAST32_FMTX__ "X"
+// LA64: #define __UINT_LEAST32_FMTo__ "o"
+// LA64: #define __UINT_LEAST32_FMTu__ "u"
+// LA64: #define __UINT_LEAST32_FMTx__ "x"
+// LA64: #define __UINT_LEAST32_MAX__ 4294967295U
+// LA64: #define __UINT_LEAST32_TYPE__ unsigned int
+// LA64: #define __UINT_LEAST64_FMTX__ "lX"
+// LA64: #define __UINT_LEAST64_FMTo__ "lo"
+// LA64: #define __UINT_LEAST64_FMTu__ "lu"
+// LA64: #define __UINT_LEAST64_FMTx__ "lx"
+// LA64: #define __UINT_LEAST64_MAX__ 18446744073709551615UL
+// LA64: #define __UINT_LEAST64_TYPE__ long unsigned int
+// LA64: #define __UINT_LEAST8_FMTX__ "hhX"
+// LA64: #define __UINT_LEAST8_FMTo__ "hho"
+// LA64: #define __UINT_LEAST8_FMTu__ "hhu"
+// LA64: #define __UINT_LEAST8_FMTx__ "hhx"
+// LA64: #define __UINT_LEAST8_MAX__ 255
+// LA64: #define __UINT_LEAST8_TYPE__ unsigned char
+// LA64: #define __USER_LABEL_PREFIX__
+// LA64: #define __WCHAR_MAX__ 2147483647
+// LA64: #define __WCHAR_TYPE__ int
+// LA64: #define __WCHAR_WIDTH__ 32
+// LA64: #define __WINT_MAX__ 4294967295U
+// LA64: #define __WINT_TYPE__ unsigned int
+// LA64: #define __WINT_UNSIGNED__ 1
+// LA64: #define __WINT_WIDTH__ 32
+// LA64-LINUX: #define __gnu_linux__ 1
+// LA64-LINUX: #define __linux 1
+// LA64-LINUX: #define __linux__ 1
+// LA64: #define __loongarch__ 1
+// LA64-LINUX: #define __unix 1
+// LA64-LINUX: #define __unix__ 1
+// LA64-LINUX: #define linux 1
+// LA64-LINUX: #define unix 1