Triple.cpp | Explore in Territory

//===--- Triple.cpp - Target triple helper class --------------------------===//
//
// 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/TargetParser/Triple.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/SwapByteOrder.h"
#include "llvm/Support/VersionTuple.h"
#include "llvm/TargetParser/ARMTargetParser.h"
#include "llvm/TargetParser/ARMTargetParserCommon.h"
#include "llvm/TargetParser/Host.h"
#include <cassert>
#include <cstring>
usingnamespacellvm;

StringRef Triple::getArchTypeName(ArchType Kind) { … }

StringRef Triple::getArchName(ArchType Kind, SubArchType SubArch) { … }

StringRef Triple::getArchTypePrefix(ArchType Kind) { … }

StringRef Triple::getVendorTypeName(VendorType Kind) { … }

StringRef Triple::getOSTypeName(OSType Kind) { … }

StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) { … }

StringRef Triple::getObjectFormatTypeName(ObjectFormatType Kind) { … }

static Triple::ArchType parseBPFArch(StringRef ArchName) { … }

Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) { … }

static Triple::ArchType parseARMArch(StringRef ArchName) { … }

static Triple::ArchType parseArch(StringRef ArchName) { … }

static Triple::VendorType parseVendor(StringRef VendorName) { … }

static Triple::OSType parseOS(StringRef OSName) { … }

static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) { … }

static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) { … }

static Triple::SubArchType parseSubArch(StringRef SubArchName) { … }

static Triple::ObjectFormatType getDefaultFormat(const Triple &T) { … }

/// Construct a triple from the string representation provided.
///
/// This stores the string representation and parses the various pieces into
/// enum members.
Triple::Triple(const Twine &Str)
    : … { … }

/// Construct a triple from string representations of the architecture,
/// vendor, and OS.
///
/// This joins each argument into a canonical string representation and parses
/// them into enum members. It leaves the environment unknown and omits it from
/// the string representation.
Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
    : … { … }

/// Construct a triple from string representations of the architecture,
/// vendor, OS, and environment.
///
/// This joins each argument into a canonical string representation and parses
/// them into enum members.
Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
               const Twine &EnvironmentStr)
    : … { … }

static VersionTuple parseVersionFromName(StringRef Name);

static StringRef getDXILArchNameFromShaderModel(StringRef ShaderModelStr) { … }

std::string Triple::normalize(StringRef Str) { … }

StringRef Triple::getArchName() const { … }

StringRef Triple::getVendorName() const { … }

StringRef Triple::getOSName() const { … }

StringRef Triple::getEnvironmentName() const { … }

StringRef Triple::getOSAndEnvironmentName() const { … }

static VersionTuple parseVersionFromName(StringRef Name) { … }

VersionTuple Triple::getEnvironmentVersion() const { … }

StringRef Triple::getEnvironmentVersionString() const { … }

VersionTuple Triple::getOSVersion() const { … }

bool Triple::getMacOSXVersion(VersionTuple &Version) const { … }

VersionTuple Triple::getiOSVersion() const { … }

VersionTuple Triple::getWatchOSVersion() const { … }

VersionTuple Triple::getDriverKitVersion() const { … }

VersionTuple Triple::getVulkanVersion() const { … }

VersionTuple Triple::getDXILVersion() const { … }

void Triple::setTriple(const Twine &Str) { … }

void Triple::setArch(ArchType Kind, SubArchType SubArch) { … }

void Triple::setVendor(VendorType Kind) { … }

void Triple::setOS(OSType Kind) { … }

void Triple::setEnvironment(EnvironmentType Kind) { … }

void Triple::setObjectFormat(ObjectFormatType Kind) { … }

void Triple::setArchName(StringRef Str) { … }

void Triple::setVendorName(StringRef Str) { … }

void Triple::setOSName(StringRef Str) { … }

void Triple::setEnvironmentName(StringRef Str) { … }

void Triple::setOSAndEnvironmentName(StringRef Str) { … }

unsigned Triple::getArchPointerBitWidth(llvm::Triple::ArchType Arch) { … }

bool Triple::isArch64Bit() const { … }

bool Triple::isArch32Bit() const { … }

bool Triple::isArch16Bit() const { … }

Triple Triple::get32BitArchVariant() const { … }

Triple Triple::get64BitArchVariant() const { … }

Triple Triple::getBigEndianArchVariant() const { … }

Triple Triple::getLittleEndianArchVariant() const { … }

bool Triple::isLittleEndian() const { … }

bool Triple::isCompatibleWith(const Triple &Other) const { … }

std::string Triple::merge(const Triple &Other) const { … }

bool Triple::isMacOSXVersionLT(unsigned Major, unsigned Minor,
                               unsigned Micro) const { … }

VersionTuple Triple::getMinimumSupportedOSVersion() const { … }

VersionTuple Triple::getCanonicalVersionForOS(OSType OSKind,
                                              const VersionTuple &Version) { … }

// HLSL triple environment orders are relied on in the front end
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
llvm/llvm/lib/TargetParser/Triple.cpp
