//===--- TargetDataLayout.cpp - Map Triple to LLVM data layout string -----===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "llvm/ADT/StringRef.h"
#include "llvm/TargetParser/ARMTargetParser.h"
#include "llvm/TargetParser/Triple.h"
using namespace llvm;

static StringRef getManglingComponent(const Triple &T) {
  if (T.isOSBinFormatGOFF())
    return "-m:l";
  if (T.isOSBinFormatMachO())
    return "-m:o";
  if (T.isOSWindowsOrUEFI() && T.isOSBinFormatCOFF())
    return T.getArch() == Triple::x86 ? "-m:x" : "-m:w";
  if (T.isOSBinFormatXCOFF())
    return "-m:a";
  return "-m:e";
}

static std::string computeARMDataLayout(const Triple &TT, StringRef ABIName) {
  auto ABI = ARM::computeTargetABI(TT, ABIName);
  std::string Ret;
  Ret.reserve(128);

  Ret += TT.isLittleEndian() ? 'e' : 'E';
  Ret += getManglingComponent(TT);

  // Pointers are 32 bits and aligned to 32 bits.
  // Function pointers are aligned to 8 bits (because the LSB stores the
  // ARM/Thumb state).
  Ret += "-p:32:32-Fi8";

  // ABIs other than APCS have 64 bit integers with natural alignment.
  //
  // We have 64 bits floats. The APCS ABI requires them to be aligned to 32
  // bits, others to 64 bits. We always try to align to 64 bits.
  //
  // We have 128 and 64 bit vectors. The APCS ABI aligns them to 32 bits, others
  // to 64. We always try to give them natural alignment.
  if (ABI == ARM::ARM_ABI_APCS)
    Ret += "-f64:32:64-v64:32:64-v128:32:128";
  else if (ABI == ARM::ARM_ABI_AAPCS16)
    Ret += "-i64:64";
  else
    Ret += "-i64:64-v128:64:128";

  // Try to align aggregates to 32 bits (the default is 64 bits, which has no
  // particular hardware support on 32-bit ARM).
  Ret += "-a:0:32-n32";

  // The stack is 64 bit aligned on AAPCS and 32 bit aligned everywhere else
  if (ABI == ARM::ARM_ABI_AAPCS16)
    Ret += "-S128";
  else if (ABI == ARM::ARM_ABI_AAPCS)
    Ret += "-S64";
  else
    Ret += "-S32";

  return Ret;
}

static std::string computeAArch64DataLayout(const Triple &TT) {
  if (TT.isOSBinFormatMachO()) {
    if (TT.getArch() == Triple::aarch64_32)
      return "e-m:o-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-"
             "n32:64-S128-Fn32";
    return "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-n32:64-S128-"
           "Fn32";
  }
  if (TT.isOSBinFormatCOFF())
    return "e-m:w-p270:32:32-p271:32:32-p272:64:64-p:64:64-i32:32-i64:64-"
           "i128:128-n32:64-S128-Fn32";

  std::string Ret = TT.isLittleEndian() ? "e-m:e" : "E-m:e";
  if (TT.getEnvironment() == Triple::GNUILP32)
    Ret += "-p:32:32";
  Ret += "-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-"
         "n32:64-S128-Fn32";
  return Ret;
}

static std::string computeBPFDataLayout(const Triple &TT) {
  if (TT.getArch() == Triple::bpfeb)
    return "E-m:e-p:64:64-i64:64-i128:128-n32:64-S128";
  return "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128";
}

static std::string computeCSKYDataLayout(const Triple &TT) {
  // CSKY is always 32-bit target with the CSKYv2 ABI as prefer now.
  // It's a 4-byte aligned stack with ELF mangling only.
  // Only support little endian for now.
  // TODO: Add support for big endian.
  return "e-m:e-S32-p:32:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:32"
         "-v128:32:32-a:0:32-Fi32-n32";
}

static std::string computeLoongArchDataLayout(const Triple &TT) {
  if (TT.isLoongArch64())
    return "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128";
  assert(TT.isLoongArch32() && "only LA32 and LA64 are currently supported");
  return "e-m:e-p:32:32-i64:64-n32-S128";
}

// The Linux m68k target uses the ABI used
// by Sun Microsystems for the old a.out-based binaries: 16-bit
// alignment of int/long/pointer.
//
// NetBSD/m68k on the other hand uses the SVR4 ABI, which
// aligns int/long/pointer/objects/stack on 32-bit boundaries.
//
// For now we just fix this for NetBSD/m68k.
//
// Ref. https://github.com/llvm/llvm-project/issues/199826

static std::string computeM68kDataLayout(const Triple &TT) {
  // FIXME how to wire it with the used object format?
  // FIXME no floats at the moment
  if (TT.isOSNetBSD()) {
    // NetBSD/m68k aligns long/pointer/stack/objects on 32-bits,
    // ref. comment above.
    // Bytes do not require special alignment,
    // 16-bit ints are 16-bit aligned and
    // 32-bit ints are 32-bit aligned
    // The registers can hold 8, 16, 32 bits
    // object and stack alignment is also 32 bits
    return "E-m:e-p:32:32:32-i8:8:8-i16:16:16-i32:32:32-n8:16:32-a:0:32-S32";
  }

  // M68k pointers are always 32 bit wide even for 16-bit CPUs.
  // The ABI only specifies 16-bit alignment.
  // On at least the 68020+ with a 32-bit bus, there is a performance benefit
  // to having 32-bit alignment.
  // Bytes do not require special alignment, words are word aligned and
  // long words are word aligned at minimum.
  // The registers can hold 8, 16, 32 bits
  return "E-m:e-p:32:16:32-i8:8:8-i16:16:16-i32:16:32-n8:16:32-a:0:16-S16";
}

namespace {
enum class MipsABI { O32, N32, N64 };
}

// FIXME: This duplicates MipsABIInfo::computeTargetABI, but duplicating this is
// preferable to violating layering rules. Ideally that information should live
// in LLVM TargetParser, but for now we just duplicate some ABI name string
// logic for simplicity.
static MipsABI getMipsABI(const Triple &TT, StringRef ABIName) {
  if (ABIName.starts_with("o32"))
    return MipsABI::O32;
  if (ABIName.starts_with("n32"))
    return MipsABI::N32;
  if (ABIName.starts_with("n64"))
    return MipsABI::N64;
  if (TT.isABIN32())
    return MipsABI::N32;
  assert(ABIName.empty() && "Unknown ABI option for MIPS");

  if (TT.isMIPS64())
    return MipsABI::N64;
  return MipsABI::O32;
}

static std::string computeMipsDataLayout(const Triple &TT, StringRef ABIName) {
  std::string Ret = TT.isLittleEndian() ? "e" : "E";

  // Pointers are 32 bit on some ABIs.
  //
  // 8 and 16 bit integers only need to have natural alignment, but try to
  // align them to 32 bits. 64 bit integers have natural alignment.
  //
  // 32 bit registers are always available and the stack is at least 64 bit
  // aligned. On N32 and N64 64 bit registers are also available and the stack
  // is 128 bit aligned.
  switch (getMipsABI(TT, ABIName)) {
  case MipsABI::O32:
    Ret += "-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
    break;
  case MipsABI::N32:
    Ret += "-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128";
    break;
  case MipsABI::N64:
    Ret += "-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128";
    break;
  }

  return Ret;
}

static std::string computePowerDataLayout(const Triple &T, StringRef ABIName) {
  bool is64Bit = T.isPPC64();
  std::string Ret;
  Ret.reserve(128);

  Ret += T.isLittleEndian() ? 'e' : 'E';
  Ret += getManglingComponent(T);

  // PPC32 has 32 bit pointers. The PS3 (OS Lv2) is a PPC64 machine with 32 bit
  // pointers.
  if (!is64Bit || T.getOS() == Triple::Lv2)
    Ret += "-p:32:32";

  // If the target ABI uses function descriptors, then the alignment of function
  // pointers depends on the alignment used to emit the descriptor. Otherwise,
  // function pointers are aligned to 32 bits because the instructions must be.
  if ((T.getArch() == Triple::ppc64 &&
       (!T.isPPC64ELFv2ABI() && ABIName != "elfv2"))) {
    Ret += "-Fi64";
  } else if (T.isOSAIX()) {
    Ret += is64Bit ? "-Fi64" : "-Fi32";
  } else {
    Ret += "-Fn32";
  }

  // Note, the alignment values for f64 and i64 on ppc64 in Darwin
  // documentation are wrong; these are correct (i.e. "what gcc does").
  // PPC64 has 32 and 64 bit registers, PPC32 has only 32 bit ones.
  Ret += is64Bit ? "-i64:64-i128:128-n32:64" : "-i64:64-n32";

  // The ABI alignment for doubles on AIX is 4 bytes.
  if (T.isOSAIX())
    Ret += "-f64:32:64";

  // Specify the vector alignment explicitly. For v256i1 and v512i1, the
  // calculated alignment would be 256*alignment(i1) and 512*alignment(i1),
  // which is 256 and 512 bytes - way over aligned.
  if (is64Bit && (T.isOSAIX() || T.isOSLinux()))
    Ret += "-S128-v256:256:256-v512:512:512";

  return Ret;
}

static std::string computeAMDDataLayout(const Triple &TT) {
  if (TT.getArch() == Triple::r600)
    return "e-m:e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
           "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1";

  // 32-bit private, local, and region pointers. 64-bit global, constant and
  // flat. 160-bit non-integral fat buffer pointers that include a 128-bit
  // buffer descriptor and a 32-bit offset, which are indexed by 32-bit values
  // (address space 7), and 128-bit non-integral buffer resourcees (address
  // space 8) which cannot be non-trivilally accessed by LLVM memory operations
  // like getelementptr.
  return "e-m:e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32"
         "-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-p10:32:32"
         "-p11:32:32-p12:32:32-p13:32:32-p14:32:32-p15:32:32"
         "-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256"
         "-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9";
}

static std::string computeRISCVDataLayout(const Triple &TT, StringRef ABIName) {
  if (TT.isOSBinFormatMachO()) {
    assert(TT.isLittleEndian() && "Invalid endianness");
    assert(TT.isArch32Bit() && "Invalid triple");
    assert((ABIName != "ilp32e") && "Invalid ABI.");
    return "e-m:o-p:32:32-i64:64-n32-S128";
  }

  std::string Ret;
  Ret.reserve(128);
  Ret += TT.isLittleEndian() ? "e-m:e" : "E-m:e";

  // TODO: Maybe we should move RISCVABI to TargetParser, so we can reuse that
  // logic here instead of duplicating the string handling?
  bool IsPureCapABI = ABIName.starts_with("il32pc64") ||
                      ABIName.starts_with("l64pc128") ||
                      ABIName.starts_with("cheriot");

  if (TT.isRISCV64()) {
    Ret += "-p:64:64";
    if (IsPureCapABI)
      Ret += "-pe200:128:128:128:64";
    Ret += "-i64:64-i128:128-n32:64";
  } else {
    assert(TT.isRISCV32() && "only RV32 and RV64 are currently supported");
    Ret += "-p:32:32";
    if (IsPureCapABI)
      Ret += "-pe200:64:64:64:32";
    Ret += "-i64:64-n32";
  }

  if (ABIName == "ilp32e")
    Ret += "-S32";
  else if (ABIName == "lp64e")
    Ret += "-S64";
  else
    Ret += "-S128";

  // TODO: Support non-purecap CHERI ABIs.
  if (IsPureCapABI)
    Ret += "-A200-P200-G200";

  return Ret;
}

static std::string computeSparcDataLayout(const Triple &T) {
  // Sparc is typically big endian, but some are little.
  // Some ABIs have 32bit pointers.
  // The alignment of 128 bit integers is not specified in the ABI document but
  // is the de facto standard.
  // On SparcV9 128 floats are aligned to 128 bits, on others only to 64.
  // On SparcV9 registers can hold 64 or 32 bits, on others only 32.
  if (T.isSPARC64())
    return "E-m:e-i64:64-i128:128-n32:64-S128";
  if (T.getArch() == Triple::sparcel)
    return "e-m:e-p:32:32-i64:64-i128:128-f128:64-n32-S64";
  return "E-m:e-p:32:32-i64:64-i128:128-f128:64-n32-S64";
}

static std::string computeSystemZDataLayout(const Triple &TT) {
  // Big endian. The natural stack alignment is 64 bits.
  std::string Ret = "E-S64";

  Ret += getManglingComponent(TT);

  // Special features for z/OS.
  if (TT.isOSzOS()) {
    // Custom address space for ptr32.
    Ret += "-p1:32:32";
  }

  // Make sure that global data has at least 16 bits of alignment by
  // default, so that we can refer to it using LARL.  We don't have any
  // special requirements for stack variables though.
  //
  // 64-bit integers are naturally aligned. 128-bit floats are aligned only to
  // 64 bits.
  //
  // The DataLayout string always holds a vector alignment of 64 bits, see
  // comment in clang/lib/Basic/Targets/SystemZ.h.
  //
  // We prefer 16 bits of aligned for all globals; see above.
  //
  // Integer registers are 32 or 64 bits.
  Ret += "-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64";

  return Ret;
}

static std::string computeX86DataLayout(const Triple &TT) {
  bool Is64Bit = TT.isX86_64();
  std::string Ret;
  Ret.reserve(128);

  // X86 is little endian
  Ret += 'e';
  Ret += getManglingComponent(TT);

  // X86 and x32 have 32 bit pointers.
  if (!Is64Bit || TT.isX32())
    Ret += "-p:32:32";

  // Address spaces for 32 bit signed, 32 bit unsigned, and 64 bit pointers.
  Ret += "-p270:32:32-p271:32:32-p272:64:64";

  // Some ABIs align 64 bit integers and doubles to 64 bits, others to 32.
  // 128 bit integers are not specified in the 32-bit ABIs but are used
  // internally for lowering f128, so we match the alignment to that.
  if (Is64Bit || TT.isOSWindows())
    Ret += "-i64:64-i128:128";
  else if (TT.isOSIAMCU())
    Ret += "-i64:32-f64:32";
  else
    Ret += "-i128:128-f64:32:64";

  // Some ABIs align long double to 128 bits, others to 32. IAMCU has no f80.
  if (TT.isOSIAMCU())
    Ret += "-f128:32";
  else if (Is64Bit || TT.isOSDarwin() || TT.isWindowsMSVCEnvironment())
    Ret += "-f80:128";
  else
    Ret += "-f80:32";

  // The registers can hold 8, 16, 32 or, in x86-64, 64 bits.
  Ret += Is64Bit ? "-n8:16:32:64" : "-n8:16:32";

  // The stack is aligned to 32 bits on some ABIs and 128 bits on others.
  if ((!Is64Bit && TT.isOSWindows()) || TT.isOSIAMCU())
    Ret += "-a:0:32-S32";
  else
    Ret += "-S128";

  return Ret;
}

static std::string computeNVPTXDataLayout(const Triple &T, StringRef ABIName) {
  if (T.getArch() == Triple::nvptx)
    return "e-p:32:32-i64:64-i128:128-i256:256-v16:16-v32:32-n16:32:64";

  // Keep the pointer specifications sorted by address space.
  //
  // In shortptr mode, specify the following address spaces as 32-bits:
  // - shared (addrspace:3)
  // - constant (addrspace:4)
  // - local (addrspace:5)
  // - shared cluster (addrspace:7)
  // - entry parameter (addrspace:101)
  //
  // Tensor Memory (addrspace:6) is always 32-bits.
  if (ABIName == "shortptr")
    return "e-p3:32:32-p4:32:32-p5:32:32-p6:32:32-p7:32:32-p101:32:32-i64:64-"
           "i128:128-i256:256-v16:16-v32:32-n16:32:64";
  return "e-p6:32:32-i64:64-i128:128-i256:256-v16:16-v32:32-n16:32:64";
}

static std::string computeSPIRVDataLayout(const Triple &TT) {
  const auto Arch = TT.getArch();
  // TODO: this probably needs to be revisited:
  // Logical SPIR-V has no pointer size, so any fixed pointer size would be
  // wrong. The choice to default to 32 or 64 is just motivated by another
  // memory model used for graphics: PhysicalStorageBuffer64. But it shouldn't
  // mean anything.
  if (Arch == Triple::spirv32)
    return "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-"
           "v256:256-v512:512-v1024:1024-n8:16:32:64-G1";
  if (Arch == Triple::spirv)
    return "e-ve-i64:64-n8:16:32:64-G10";
  if (TT.getVendor() == Triple::VendorType::AMD &&
      TT.getOS() == Triple::OSType::AMDHSA)
    return "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-"
           "v512:512-v1024:1024-n32:64-S32-G1-P4-A0";
  if (TT.getVendor() == Triple::VendorType::Intel)
    return "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-"
           "v512:512-v1024:1024-n8:16:32:64-G1-P9-A0";
  return "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-"
         "v512:512-v1024:1024-n8:16:32:64-G1";
}

static std::string computeLanaiDataLayout() {
  // Data layout (keep in sync with clang/lib/Basic/Targets.cpp)
  return "E"        // Big endian
         "-m:e"     // ELF name manging
         "-p:32:32" // 32-bit pointers, 32 bit aligned
         "-i64:64"  // 64 bit integers, 64 bit aligned
         "-a:0:32"  // 32 bit alignment of objects of aggregate type
         "-n32"     // 32 bit native integer width
         "-S64";    // 64 bit natural stack alignment
}

static std::string computeWebAssemblyDataLayout(const Triple &TT) {
  return TT.getArch() == Triple::wasm64
             ? (TT.isOSEmscripten() ? "e-m:e-p:64:64-p10:8:8-p20:8:8-i64:64-"
                                      "i128:128-f128:64-n32:64-S128-ni:1:10:20"
                                    : "e-m:e-p:64:64-p10:8:8-p20:8:8-i64:64-"
                                      "i128:128-n32:64-S128-ni:1:10:20")
             : (TT.isOSEmscripten() ? "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-"
                                      "i128:128-f128:64-n32:64-S128-ni:1:10:20"
                                    : "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-"
                                      "i128:128-n32:64-S128-ni:1:10:20");
}

static std::string computeVEDataLayout(const Triple &T) {
  // Aurora VE is little endian with ELF mangling. 64 bit integers are 64 bit
  // aligned. VE supports 32 bit and 64 bits integer on registers. Stack
  // alignment is 128 bits.
  //
  // Vector alignments are 64 bits, from v64 (v2f32) to v16384 (v256f64).
  // Need to define all of them.  Otherwise, each alignment becomes the size of
  // each data by default.
  return "e-m:e-i64:64-n32:64-S128-v64:64:64-v128:64:64-v256:64:64-v512:64:64-"
         "v1024:64:64-v2048:64:64-v4096:64:64-v8192:64:64-v16384:64:64";
}

std::string Triple::computeDataLayout(StringRef ABIName) const {
  switch (getArch()) {
  case Triple::arm:
  case Triple::armeb:
  case Triple::thumb:
  case Triple::thumbeb:
    return computeARMDataLayout(*this, ABIName);
  case Triple::aarch64:
  case Triple::aarch64_be:
  case Triple::aarch64_32:
    return computeAArch64DataLayout(*this);
  case Triple::arc:
    return "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
           "f32:32:32-i64:32-f64:32-a:0:32-n32";
  case Triple::avr:
    return "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8:16-a:8";
  case Triple::bpfel:
  case Triple::bpfeb:
    return computeBPFDataLayout(*this);
  case Triple::csky:
    return computeCSKYDataLayout(*this);
  case Triple::dxil:
    return "e-m:e-ve-p:32:32-i1:32-i8:8-i16:16-i32:32-i64:64-f16:16-"
           "f32:32-f64:64-n8:16:32:64";
  case Triple::hexagon:
    return "e-m:e-p:32:32:32-a:0-n16:32-"
           "i64:64:64-i32:32:32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-"
           "v32:32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048:2048:2048";
  case Triple::loongarch32:
  case Triple::loongarch64:
    return computeLoongArchDataLayout(*this);
  case Triple::m68k:
    return computeM68kDataLayout(*this);
  case Triple::mips:
  case Triple::mipsel:
  case Triple::mips64:
  case Triple::mips64el:
    return computeMipsDataLayout(*this, ABIName);
  case Triple::msp430:
    return "e-m:e-p:16:16-i32:16-i64:16-f32:16-f64:16-a:8-n8:16-S16";
  case Triple::ppc:
  case Triple::ppcle:
  case Triple::ppc64:
  case Triple::ppc64le:
    return computePowerDataLayout(*this, ABIName);
  case Triple::amdgpu:
  case Triple::r600:
    return computeAMDDataLayout(*this);
  case Triple::riscv32:
  case Triple::riscv64:
  case Triple::riscv32be:
  case Triple::riscv64be:
    return computeRISCVDataLayout(*this, ABIName);
  case Triple::sparc:
  case Triple::sparcv9:
  case Triple::sparcel:
    return computeSparcDataLayout(*this);
  case Triple::systemz:
    return computeSystemZDataLayout(*this);
  case Triple::tce:
    return "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-i64:32:32-"
           "f16:16:16-f32:32:32-f64:32:32-v64:64:64-i128:128-v128:128:128-"
           "v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048-"
           "v4096:4096:4096-a0:0:32-n32";
  case Triple::tcele:
    return "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-i64:32:32-"
           "f16:16:16-f32:32:32-f64:32:32-v64:64:64-i128:128-v128:128:128-"
           "v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048-"
           "v4096:4096:4096-a0:0:32-n32";
  case Triple::tcele64:
    return "e-p:64:64:64-i1:8:64-i8:8:64-i16:16:64-i32:32:64-i64:64:64-"
           "f16:16:64-f32:32:64-f64:64:64-v64:64:64-i128:128-v128:128:128-"
           "v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048-"
           "v4096:4096:4096-a0:0:64-n64";
  case Triple::x86:
  case Triple::x86_64:
    return computeX86DataLayout(*this);
  case Triple::xcore:
    return "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32-f64:32-a:0:32-n32";
  case Triple::xtensa:
    return "e-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-n32";
  case Triple::nvptx:
  case Triple::nvptx64:
    return computeNVPTXDataLayout(*this, ABIName);
  case Triple::spir:
  case Triple::spir64:
  case Triple::spirv:
  case Triple::spirv32:
  case Triple::spirv64:
    return computeSPIRVDataLayout(*this);
  case Triple::lanai:
    return computeLanaiDataLayout();
  case Triple::wasm32:
  case Triple::wasm64:
    return computeWebAssemblyDataLayout(*this);
  case Triple::ve:
    return computeVEDataLayout(*this);

  case Triple::amdil:
  case Triple::amdil64:
  case Triple::hsail:
  case Triple::hsail64:
  case Triple::kalimba:
  case Triple::shave:
  case Triple::renderscript32:
  case Triple::renderscript64:
    // These are all virtual ISAs with no LLVM backend, and therefore no fixed
    // LLVM data layout.
    return "";

  case Triple::UnknownArch:
    return "";
  }
  llvm_unreachable("Invalid arch");
}