llvm/llvm/lib/TargetParser/ARMTargetParser.cpp

//===-- ARMTargetParser - Parser for ARM target features --------*- 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 a target parser to recognise ARM hardware features
// such as FPU/CPU/ARCH/extensions and specific support such as HWDIV.
//
//===----------------------------------------------------------------------===//

#include "llvm/TargetParser/ARMTargetParser.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/TargetParser/ARMTargetParserCommon.h"
#include "llvm/TargetParser/Triple.h"
#include <cctype>

usingnamespacellvm;

static StringRef getHWDivSynonym(StringRef HWDiv) { … }

// Allows partial match, ex. "v7a" matches "armv7a".
ARM::ArchKind ARM::parseArch(StringRef Arch) { … }

// Version number (ex. v7 = 7).
unsigned ARM::parseArchVersion(StringRef Arch) { … }

static ARM::ProfileKind getProfileKind(ARM::ArchKind AK) { … }

// Profile A/R/M
ARM::ProfileKind ARM::parseArchProfile(StringRef Arch) { … }

bool ARM::getFPUFeatures(ARM::FPUKind FPUKind,
                         std::vector<StringRef> &Features) { … }

ARM::FPUKind ARM::parseFPU(StringRef FPU) { … }

ARM::NeonSupportLevel ARM::getFPUNeonSupportLevel(ARM::FPUKind FPUKind) { … }

StringRef ARM::getFPUSynonym(StringRef FPU) { … }

StringRef ARM::getFPUName(ARM::FPUKind FPUKind) { … }

ARM::FPUVersion ARM::getFPUVersion(ARM::FPUKind FPUKind) { … }

ARM::FPURestriction ARM::getFPURestriction(ARM::FPUKind FPUKind) { … }

ARM::FPUKind ARM::getDefaultFPU(StringRef CPU, ARM::ArchKind AK) { … }

uint64_t ARM::getDefaultExtensions(StringRef CPU, ARM::ArchKind AK) { … }

bool ARM::getHWDivFeatures(uint64_t HWDivKind,
                           std::vector<StringRef> &Features) { … }

bool ARM::getExtensionFeatures(uint64_t Extensions,
                               std::vector<StringRef> &Features) { … }

StringRef ARM::getArchName(ARM::ArchKind AK) { … }

StringRef ARM::getCPUAttr(ARM::ArchKind AK) { … }

StringRef ARM::getSubArch(ARM::ArchKind AK) { … }

unsigned ARM::getArchAttr(ARM::ArchKind AK) { … }

StringRef ARM::getArchExtName(uint64_t ArchExtKind) { … }

static bool stripNegationPrefix(StringRef &Name) { … }

StringRef ARM::getArchExtFeature(StringRef ArchExt) { … }

static ARM::FPUKind findDoublePrecisionFPU(ARM::FPUKind InputFPUKind) { … }

static ARM::FPUKind findSinglePrecisionFPU(ARM::FPUKind InputFPUKind) { … }

bool ARM::appendArchExtFeatures(StringRef CPU, ARM::ArchKind AK,
                                StringRef ArchExt,
                                std::vector<StringRef> &Features,
                                ARM::FPUKind &ArgFPUKind) { … }

ARM::ArchKind ARM::convertV9toV8(ARM::ArchKind AK) { … }

StringRef ARM::getDefaultCPU(StringRef Arch) { … }

uint64_t ARM::parseHWDiv(StringRef HWDiv) { … }

uint64_t ARM::parseArchExt(StringRef ArchExt) { … }

ARM::ArchKind ARM::parseCPUArch(StringRef CPU) { … }

void ARM::fillValidCPUArchList(SmallVectorImpl<StringRef> &Values) { … }

StringRef ARM::computeDefaultTargetABI(const Triple &TT, StringRef CPU) { … }

StringRef ARM::getARMCPUForArch(const llvm::Triple &Triple, StringRef MArch) { … }

void ARM::PrintSupportedExtensions(StringMap<StringRef> DescMap) { … }