llvm/clang/lib/Basic/Targets/ARM.cpp

//===--- ARM.cpp - Implement ARM 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 ARM TargetInfo objects.
//
//===----------------------------------------------------------------------===//

#include "ARM.h"
#include "clang/Basic/Builtins.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/TargetBuiltins.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/TargetParser/ARMTargetParser.h"

usingnamespaceclang;
usingnamespaceclang::targets;

void ARMTargetInfo::setABIAAPCS() { … }

void ARMTargetInfo::setABIAPCS(bool IsAAPCS16) { … }

void ARMTargetInfo::setArchInfo() { … }

void ARMTargetInfo::setArchInfo(llvm::ARM::ArchKind Kind) { … }

void ARMTargetInfo::setAtomic() { … }

bool ARMTargetInfo::hasMVE() const { … }

bool ARMTargetInfo::hasMVEFloat() const { … }

bool ARMTargetInfo::hasCDE() const { … }

bool ARMTargetInfo::isThumb() const { … }

bool ARMTargetInfo::supportsThumb() const { … }

bool ARMTargetInfo::supportsThumb2() const { … }

StringRef ARMTargetInfo::getCPUAttr() const { … }

StringRef ARMTargetInfo::getCPUProfile() const { … }

ARMTargetInfo::ARMTargetInfo(const llvm::Triple &Triple,
                             const TargetOptions &Opts)
    : … { … }

StringRef ARMTargetInfo::getABI() const { … }

bool ARMTargetInfo::setABI(const std::string &Name) { … }

bool ARMTargetInfo::isBranchProtectionSupportedArch(StringRef Arch) const { … }

bool ARMTargetInfo::validateBranchProtection(StringRef Spec, StringRef Arch,
                                             BranchProtectionInfo &BPI,
                                             StringRef &Err) const { … }

// FIXME: This should be based on Arch attributes, not CPU names.
bool ARMTargetInfo::initFeatureMap(
    llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
    const std::vector<std::string> &FeaturesVec) const { … }


bool ARMTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
                                         DiagnosticsEngine &Diags) { … }

bool ARMTargetInfo::hasFeature(StringRef Feature) const { … }

bool ARMTargetInfo::hasBFloat16Type() const { … }

bool ARMTargetInfo::isValidCPUName(StringRef Name) const { … }

void ARMTargetInfo::fillValidCPUList(SmallVectorImpl<StringRef> &Values) const { … }

bool ARMTargetInfo::setCPU(const std::string &Name) { … }

bool ARMTargetInfo::setFPMath(StringRef Name) { … }

void ARMTargetInfo::getTargetDefinesARMV81A(const LangOptions &Opts,
                                            MacroBuilder &Builder) const { … }

void ARMTargetInfo::getTargetDefinesARMV82A(const LangOptions &Opts,
                                            MacroBuilder &Builder) const { … }

void ARMTargetInfo::getTargetDefinesARMV83A(const LangOptions &Opts,
                                            MacroBuilder &Builder) const { … }

void ARMTargetInfo::getTargetDefines(const LangOptions &Opts,
                                     MacroBuilder &Builder) const { … }

static constexpr Builtin::Info BuiltinInfo[] = …;

ArrayRef<Builtin::Info> ARMTargetInfo::getTargetBuiltins() const { … }

bool ARMTargetInfo::isCLZForZeroUndef() const { … }
TargetInfo::BuiltinVaListKind ARMTargetInfo::getBuiltinVaListKind() const { … }

const char *const ARMTargetInfo::GCCRegNames[] = …;

ArrayRef<const char *> ARMTargetInfo::getGCCRegNames() const { … }

const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = …;

ArrayRef<TargetInfo::GCCRegAlias> ARMTargetInfo::getGCCRegAliases() const { … }

bool ARMTargetInfo::validateAsmConstraint(
    const char *&Name, TargetInfo::ConstraintInfo &Info) const { … }

std::string ARMTargetInfo::convertConstraint(const char *&Constraint) const { … }

bool ARMTargetInfo::validateConstraintModifier(
    StringRef Constraint, char Modifier, unsigned Size,
    std::string &SuggestedModifier) const { … }
std::string_view ARMTargetInfo::getClobbers() const { … }

TargetInfo::CallingConvCheckResult
ARMTargetInfo::checkCallingConvention(CallingConv CC) const { … }

int ARMTargetInfo::getEHDataRegisterNumber(unsigned RegNo) const { … }

bool ARMTargetInfo::hasSjLjLowering() const { … }

ARMleTargetInfo::ARMleTargetInfo(const llvm::Triple &Triple,
                                 const TargetOptions &Opts)
    : … { … }

void ARMleTargetInfo::getTargetDefines(const LangOptions &Opts,
                                       MacroBuilder &Builder) const { … }

ARMbeTargetInfo::ARMbeTargetInfo(const llvm::Triple &Triple,
                                 const TargetOptions &Opts)
    : … { … }

void ARMbeTargetInfo::getTargetDefines(const LangOptions &Opts,
                                       MacroBuilder &Builder) const { … }

WindowsARMTargetInfo::WindowsARMTargetInfo(const llvm::Triple &Triple,
                                           const TargetOptions &Opts)
    : … { … }

void WindowsARMTargetInfo::getVisualStudioDefines(const LangOptions &Opts,
                                                  MacroBuilder &Builder) const { … }

TargetInfo::BuiltinVaListKind
WindowsARMTargetInfo::getBuiltinVaListKind() const { … }

TargetInfo::CallingConvCheckResult
WindowsARMTargetInfo::checkCallingConvention(CallingConv CC) const { … }

// Windows ARM + Itanium C++ ABI Target
ItaniumWindowsARMleTargetInfo::ItaniumWindowsARMleTargetInfo(
    const llvm::Triple &Triple, const TargetOptions &Opts)
    : … { … }

void ItaniumWindowsARMleTargetInfo::getTargetDefines(
    const LangOptions &Opts, MacroBuilder &Builder) const { … }

// Windows ARM, MS (C++) ABI
MicrosoftARMleTargetInfo::MicrosoftARMleTargetInfo(const llvm::Triple &Triple,
                                                   const TargetOptions &Opts)
    : … { … }

void MicrosoftARMleTargetInfo::getTargetDefines(const LangOptions &Opts,
                                                MacroBuilder &Builder) const { … }

MinGWARMTargetInfo::MinGWARMTargetInfo(const llvm::Triple &Triple,
                                       const TargetOptions &Opts)
    : … { … }

void MinGWARMTargetInfo::getTargetDefines(const LangOptions &Opts,
                                          MacroBuilder &Builder) const { … }

CygwinARMTargetInfo::CygwinARMTargetInfo(const llvm::Triple &Triple,
                                         const TargetOptions &Opts)
    : … { … }

void CygwinARMTargetInfo::getTargetDefines(const LangOptions &Opts,
                                           MacroBuilder &Builder) const { … }

DarwinARMTargetInfo::DarwinARMTargetInfo(const llvm::Triple &Triple,
                                         const TargetOptions &Opts)
    : … { … }

void DarwinARMTargetInfo::getOSDefines(const LangOptions &Opts,
                                       const llvm::Triple &Triple,
                                       MacroBuilder &Builder) const { … }

RenderScript32TargetInfo::RenderScript32TargetInfo(const llvm::Triple &Triple,
                                                   const TargetOptions &Opts)
    : … { … }

void RenderScript32TargetInfo::getTargetDefines(const LangOptions &Opts,
                                                MacroBuilder &Builder) const { … }