[LoongArch] Implement handling of triple-implied ABIs

[xen0n]

Summary

According to the LoongArch Toolchain Conventions
it is possible to specify the ABI modifier (the "D" part of "LP64D")
via the environment field in the target triple. This is needed for
proper support for Debian-style multiarch tuples as well, so add triple
awareness to LoongArchSubtarget via addition of
LoongArchABI::computeTargetABI. Let the explicit --target-abi
argument intuitively take precedence over the triple-implied ABI.

[xen0n]

rebase

[SixWeining]

Thanks. Overall LGTM except the handling of FeatureBits (maybe can be handled in a seperate patch) and some nits.

llvm/lib/Target/LoongArch/MCTargetDesc/LoongArchBaseInfo.cpp

24

Shall we handle FeatureBits as well?

50–52

Missing test?

llvm/test/CodeGen/LoongArch/target-abi-from-triple.ll

2

Is this test autogenerated?

3

I'm not sure whether we should add tests causing crash that may slow down testing. I remeber @MaskRay once suggested me not to do so.

81–85

Are these lines useful?

[xen0n]

llvm/lib/Target/LoongArch/MCTargetDesc/LoongArchBaseInfo.cpp

24

I saw RISCV include FeatureBits in their computeTargetABI, but right now we're not making use of it (we don't base our selection of bitness on the parsed FeatureBits). I'd say let's add it later when needed.

50–52

Thanks for checking, I'll cover this branch later.

llvm/test/CodeGen/LoongArch/target-abi-from-triple.ll

2

The generated code is, but the other isn't. Given you already hesitated on this matter, let me adjust then.

3

I vaguely remember such an occasion too, let me remove the crash assertions and replace with simple comments then. It's not like I'm not coming back to remove the TODOs ;-)

81–85

They're added automatically by the update_llc_test_checks.py script. I'll remove them.

[xen0n]

rebase and update testcase

[SixWeining]

LGTM. Thanks!

llvm/lib/Target/LoongArch/LoongArchSubtarget.cpp

 //===-- LoongArchSubtarget.cpp - LoongArch Subtarget Information -*- C++ -*--=//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the LoongArch specific subclass of TargetSubtargetInfo.
 //
 //===----------------------------------------------------------------------===//
 
 #include "LoongArchSubtarget.h"
 #include "LoongArchFrameLowering.h"
+#include "MCTargetDesc/LoongArchBaseInfo.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "loongarch-subtarget"
 
 #define GET_SUBTARGETINFO_TARGET_DESC
 #define GET_SUBTARGETINFO_CTOR
 #include "LoongArchGenSubtargetInfo.inc"
if (HasLA32 == HasLA64)
     report_fatal_error("Please use one feature of 32bit and 64bit.");
 
   if (Is64Bit && HasLA32)
     report_fatal_error("Feature 32bit should be used for loongarch32 target.");
 
   if (!Is64Bit && HasLA64)
     report_fatal_error("Feature 64bit should be used for loongarch64 target.");
 
-  // TODO: ILP32{S,F} LP64{S,F}
-  TargetABI = Is64Bit ? LoongArchABI::ABI_LP64D : LoongArchABI::ABI_ILP32D;
+  TargetABI = LoongArchABI::computeTargetABI(TT, ABIName);
+
   return *this;
 }
 
 LoongArchSubtarget::LoongArchSubtarget(const Triple &TT, StringRef CPU,
                                        StringRef TuneCPU, StringRef FS,
                                        StringRef ABIName,
                                        const TargetMachine &TM)
     : LoongArchGenSubtargetInfo(TT, CPU, TuneCPU, FS),
       FrameLowering(
           initializeSubtargetDependencies(TT, CPU, TuneCPU, FS, ABIName)),
       InstrInfo(*this), RegInfo(getHwMode()), TLInfo(TM, *this) {}

llvm/lib/Target/LoongArch/MCTargetDesc/LoongArchBaseInfo.h

enum ABI {
   ABI_ILP32F,
   ABI_ILP32D,
   ABI_LP64S,
   ABI_LP64F,
   ABI_LP64D,
   ABI_Unknown
 };
 
+ABI computeTargetABI(const Triple &TT, StringRef ABIName);
 ABI getTargetABI(StringRef ABIName);
 
 // Returns the register used to hold the stack pointer after realignment.
 MCRegister getBPReg();
 } // end namespace LoongArchABI
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_LOONGARCH_MCTARGETDESC_LOONGARCHBASEINFO_H

llvm/lib/Target/LoongArch/MCTargetDesc/LoongArchBaseInfo.cpp

 // compiler back-end and the MC libraries.
 //
 //===----------------------------------------------------------------------===//
 
 #include "LoongArchBaseInfo.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
 namespace LoongArchABI {
 
+ABI computeTargetABI(const Triple &TT, StringRef ABIName) {
+  ABI ArgProvidedABI = getTargetABI(ABIName);
+  bool Is64Bit = TT.isArch64Bit();
+  ABI TripleABI;
+
+  // Figure out the ABI explicitly requested via the triple's environment type.
+  switch (TT.getEnvironment()) {
+  case llvm::Triple::EnvironmentType::GNUSF:
+    TripleABI = Is64Bit ? LoongArchABI::ABI_LP64S : LoongArchABI::ABI_ILP32S;
+    break;
+  case llvm::Triple::EnvironmentType::GNUF32:
+    TripleABI = Is64Bit ? LoongArchABI::ABI_LP64F : LoongArchABI::ABI_ILP32F;
+    break;
+
+  // Let the fallback case behave like {ILP32,LP64}D.
+  case llvm::Triple::EnvironmentType::GNUF64:
+  default:
+    TripleABI = Is64Bit ? LoongArchABI::ABI_LP64D : LoongArchABI::ABI_ILP32D;
+    break;
+  }
+
+  switch (ArgProvidedABI) {
+  case LoongArchABI::ABI_Unknown:
+    // Fallback to the triple-implied ABI if ABI name is not specified or
+    // invalid.
+    if (!ABIName.empty())
+      errs() << "'" << ABIName
+             << "' is not a recognized ABI for this target, ignoring and using "
+                "triple-implied ABI\n";
+    return TripleABI;
+
+  case LoongArchABI::ABI_ILP32S:
+  case LoongArchABI::ABI_ILP32F:
+  case LoongArchABI::ABI_ILP32D:
+    if (Is64Bit) {
+      errs() << "32-bit ABIs are not supported for 64-bit targets, ignoring "
+                "target-abi and using triple-implied ABI\n";
+      return TripleABI;
+    }
+    break;
+
+  case LoongArchABI::ABI_LP64S:
+  case LoongArchABI::ABI_LP64F:
+  case LoongArchABI::ABI_LP64D:
+    if (!Is64Bit) {
+      errs() << "64-bit ABIs are not supported for 32-bit targets, ignoring "
+                "target-abi and using triple-implied ABI\n";
+      return TripleABI;
+    }
+    break;
+  }
+
+  if (!ABIName.empty() && ArgProvidedABI != TripleABI)
+    errs() << "warning: triple-implied ABI conflicts with provided target-abi '"
+           << ABIName << "', using target-abi\n";
+
+  return ArgProvidedABI;
+}
+
 ABI getTargetABI(StringRef ABIName) {
   auto TargetABI = StringSwitch<ABI>(ABIName)
                        .Case("ilp32s", ABI_ILP32S)
                        .Case("ilp32f", ABI_ILP32F)
                        .Case("ilp32d", ABI_ILP32D)
                        .Case("lp64s", ABI_LP64S)
                        .Case("lp64f", ABI_LP64F)
                        .Case("lp64d", ABI_LP64D)

llvm/test/CodeGen/LoongArch/target-abi-from-triple-edge-cases.ll

+;; Check that an unknown --target-abi is ignored and the triple-implied ABI is
+;; used.
+; RUN: llc --mtriple=loongarch32-linux-gnu --target-abi=foo --mattr=+d < %s 2>&1 \
+; RUN:   | FileCheck %s --check-prefixes=ILP32D,UNKNOWN
+; RUN: llc --mtriple=loongarch64-linux-gnu --target-abi=foo --mattr=+d < %s 2>&1 \
+; RUN:   | FileCheck %s --check-prefixes=LP64D,UNKNOWN
+
+; UNKNOWN: 'foo' is not a recognized ABI for this target, ignoring and using triple-implied ABI
+
+;; Check that --target-abi takes precedence over triple-supplied ABI modifiers.
+; RUN: llc --mtriple=loongarch32-linux-gnusf --target-abi=ilp32d --mattr=+d < %s 2>&1 \
+; RUN:   | FileCheck %s --check-prefixes=ILP32D,CONFLICT-ILP32D
+; RUN: llc --mtriple=loongarch64-linux-gnusf --target-abi=lp64d --mattr=+d < %s 2>&1 \
+; RUN:   | FileCheck %s --check-prefixes=LP64D,CONFLICT-LP64D
+
+; CONFLICT-ILP32D: warning: triple-implied ABI conflicts with provided target-abi 'ilp32d', using target-abi
+; CONFLICT-LP64D:  warning: triple-implied ABI conflicts with provided target-abi 'lp64d', using target-abi
+
+;; Check that ILP32-on-LA64 and LP64-on-LA32 combinations are handled properly.
+; RUN: llc --mtriple=loongarch64 --target-abi=ilp32d --mattr=+d < %s 2>&1 \
+; RUN:   | FileCheck %s --check-prefixes=LP64D,32ON64
+; RUN: llc --mtriple=loongarch32 --target-abi=lp64d --mattr=+d < %s 2>&1 \
+; RUN:   | FileCheck %s --check-prefixes=ILP32D,64ON32
+
+; 32ON64: 32-bit ABIs are not supported for 64-bit targets, ignoring target-abi and using triple-implied ABI
+; 64ON32: 64-bit ABIs are not supported for 32-bit targets, ignoring target-abi and using triple-implied ABI
+
+define float @f(float %a) {
+; ILP32D-LABEL: f:
+; ILP32D:       # %bb.0:
+; ILP32D-NEXT:    addi.w $a0, $zero, 1
+; ILP32D-NEXT:    movgr2fr.w $fa1, $a0
+; ILP32D-NEXT:    ffint.s.w $fa1, $fa1
+; ILP32D-NEXT:    fadd.s $fa0, $fa0, $fa1
+; ILP32D-NEXT:    ret
+;
+; LP64D-LABEL: f:
+; LP64D:       # %bb.0:
+; LP64D-NEXT:    addi.w $a0, $zero, 1
+; LP64D-NEXT:    movgr2fr.w $fa1, $a0
+; LP64D-NEXT:    ffint.s.w $fa1, $fa1
+; LP64D-NEXT:    fadd.s $fa0, $fa0, $fa1
+; LP64D-NEXT:    ret
+  %1 = fadd float %a, 1.0
+  ret float %1
+}
+
+define double @g(double %a) {
+; ILP32D-LABEL: g:
+; ILP32D:       # %bb.0:
+; ILP32D-NEXT:    addi.w $a0, $zero, 1
+; ILP32D-NEXT:    movgr2fr.w $fa1, $a0
+; ILP32D-NEXT:    ffint.s.w $fa1, $fa1
+; ILP32D-NEXT:    fcvt.d.s $fa1, $fa1
+; ILP32D-NEXT:    fadd.d $fa0, $fa0, $fa1
+; ILP32D-NEXT:    ret
+;
+; LP64D-LABEL: g:
+; LP64D:       # %bb.0:
+; LP64D-NEXT:    addi.d $a0, $zero, 1
+; LP64D-NEXT:    movgr2fr.d $fa1, $a0
+; LP64D-NEXT:    ffint.d.l $fa1, $fa1
+; LP64D-NEXT:    fadd.d $fa0, $fa0, $fa1
+; LP64D-NEXT:    ret
+  %1 = fadd double %a, 1.0
+  ret double %1
+}

llvm/test/CodeGen/LoongArch/target-abi-from-triple.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+
+;; Check that the correct ABI is chosen based on the triple given.
+;; TODO: enable the S and F ABIs once support is wired up.
+; RUN: llc --mtriple=loongarch32-linux-gnuf64 --mattr=+d < %s \
+; RUN:   | FileCheck %s --check-prefix=ILP32D
+; RUN: llc --mtriple=loongarch64-linux-gnuf64 --mattr=+d < %s \
+; RUN:   | FileCheck %s --check-prefix=LP64D
+
+define float @f(float %a) {
+; ILP32D-LABEL: f:
+; ILP32D:       # %bb.0:
+; ILP32D-NEXT:    addi.w $a0, $zero, 1
+; ILP32D-NEXT:    movgr2fr.w $fa1, $a0
+; ILP32D-NEXT:    ffint.s.w $fa1, $fa1
+; ILP32D-NEXT:    fadd.s $fa0, $fa0, $fa1
+; ILP32D-NEXT:    ret
+;
+; LP64D-LABEL: f:
+; LP64D:       # %bb.0:
+; LP64D-NEXT:    addi.w $a0, $zero, 1
+; LP64D-NEXT:    movgr2fr.w $fa1, $a0
+; LP64D-NEXT:    ffint.s.w $fa1, $fa1
+; LP64D-NEXT:    fadd.s $fa0, $fa0, $fa1
+; LP64D-NEXT:    ret
+  %1 = fadd float %a, 1.0
+  ret float %1
+}
+
+define double @g(double %a) {
+; ILP32D-LABEL: g:
+; ILP32D:       # %bb.0:
+; ILP32D-NEXT:    addi.w $a0, $zero, 1
+; ILP32D-NEXT:    movgr2fr.w $fa1, $a0
+; ILP32D-NEXT:    ffint.s.w $fa1, $fa1
+; ILP32D-NEXT:    fcvt.d.s $fa1, $fa1
+; ILP32D-NEXT:    fadd.d $fa0, $fa0, $fa1
+; ILP32D-NEXT:    ret
+;
+; LP64D-LABEL: g:
+; LP64D:       # %bb.0:
+; LP64D-NEXT:    addi.d $a0, $zero, 1
+; LP64D-NEXT:    movgr2fr.d $fa1, $a0
+; LP64D-NEXT:    ffint.d.l $fa1, $fa1
+; LP64D-NEXT:    fadd.d $fa0, $fa0, $fa1
+; LP64D-NEXT:    ret
+  %1 = fadd double %a, 1.0
+  ret double %1
+}