StringTable::Offset

UserVisibleName; // Human readable name used in -march, -cpu

// and target func attribute, e.g. "profile".

StringTable::Offset Alias; // An alias for this extension, if one exists.

ArchExtKind ID; // Corresponding to the ArchExtKind, this

// extensions representation in the bitfield.

StringTable::Offset ArchFeatureName; // The feature name defined by the

// Architecture, e.g. FEAT_AdvSIMD.

StringTable::Offset Description; // The textual description of the extension.

StringTable::Offset PosTargetFeature; // -target-feature/-mattr enable string,

// e.g. "+spe".

StringTable::Offset NegTargetFeature; // -target-feature/-mattr disable

// string, e.g. "-spe".

StringRef Name; // The target_version/target_clones spelling.

std::optional<CPUFeatures>

FeatureBit; // Index of the bit in the FMV feature bitset.

FeatPriorities PriorityBit; // Index of the bit in the FMV priority bitset.

std::optional<ArchExtKind> ID; // The architecture extension to enable.

FMVInfo(StringRef Name, std::optional<CPUFeatures> FeatureBit,

FeatPriorities PriorityBit, std::optional<ArchExtKind> ID)

: Name(Name), FeatureBit(FeatureBit), PriorityBit(PriorityBit), ID(ID) {};

VersionTuple Version; // Architecture version, major + minor.

ArchProfile Profile; // Architecuture profile

StringTable::Offset Name; // Name as supplied to -march e.g. "armv8.1-a"

StringTable::Offset

ArchFeature; // Name as supplied to -target-feature, e.g. "+v8a"

AArch64::ExtensionBitset

DefaultExts; // bitfield of default extensions ArchExtKind

bool operator==(const ArchInfo &Other) const {

return this->Name == Other.Name;

}

bool operator!=(const ArchInfo &Other) const {

return this->Name != Other.Name;

}

// Defines the following partial order, indicating when an architecture is

// a superset of another:

//

// v9.7a > v9.6a > v9.5a > v9.4a > v9.3a > v9.2a > v9.1a > v9a;

// v v v v v

// v8.9a > v8.8a > v8.7a > v8.6a > v8.5a > ... > v8a;

//

// v8r has no relation to anything. This is used to determine which

// features to enable for a given architecture. See

// AArch64TargetInfo::setFeatureEnabled.

bool implies(const ArchInfo &Other) const {

if (this->Profile != Other.Profile)

return false; // ARMV8R

if (this->Version.getMajor() == Other.Version.getMajor()) {

return this->Version > Other.Version;

}

if (this->Version.getMajor() == 9 && Other.Version.getMajor() == 8) {

assert(this->Version.getMinor() && Other.Version.getMinor() &&

"AArch64::ArchInfo should have a minor version.");

return this->Version.getMinor().value_or(0) + 5 >=

Other.Version.getMinor().value_or(0);

}

return false;

}

// True if this architecture is a superset of Other (including being equal to

// it).

bool is_superset(const ArchInfo &Other) const {

return (*this == Other) || implies(Other);

}

// Return ArchFeature without the leading "+".

StringRef getSubArch() const { return StrTab[ArchFeature].substr(1); }

// Search for ArchInfo by SubArch name

LLVM_ABI static std::optional<ArchInfo> findBySubArch(StringRef SubArch);

StringTable::Offset Name; // Name, as written for -mcpu.

unsigned ArchIdx;

AArch64::ExtensionBitset

DefaultExtensions; // Default extensions for this CPU.

// Set of extensions which are currently enabled.

ExtensionBitset Enabled;

// Set of extensions which have been enabled or disabled at any point. Used

// to avoid cluttering the cc1 command-line with lots of unneeded features.

ExtensionBitset Touched;

// Base architecture version, which we need to know because some feature

// dependencies change depending on this.

const ArchInfo *BaseArch;

ExtensionSet() : Enabled(), Touched(), BaseArch(nullptr) {}

// Enable the given architecture extension, and any other extensions it

// depends on. Does not change the base architecture, or follow dependencies

// between features which are only related by required arcitecture versions.

LLVM_ABI void enable(ArchExtKind E);

// Disable the given architecture extension, and any other extensions which

// depend on it. Does not change the base architecture, or follow

// dependencies between features which are only related by required

// arcitecture versions.

LLVM_ABI void disable(ArchExtKind E);

// Add default extensions for the given CPU. Records the base architecture,

// to later resolve dependencies which depend on it.

LLVM_ABI void addCPUDefaults(const CpuInfo &CPU);

// Add default extensions for the given architecture version. Records the

// base architecture, to later resolve dependencies which depend on it.

LLVM_ABI void addArchDefaults(const ArchInfo &Arch);

// Add or remove a feature based on a modifier string. The string must be of

// the form "<name>" to enable a feature or "no<name>" to disable it. This

// will also enable or disable any features as required by the dependencies

// between them.

LLVM_ABI bool parseModifier(StringRef Modifier,

const bool AllowNoDashForm = false);

// Constructs a new ExtensionSet by toggling the corresponding bits for every

// feature in the \p Features list without expanding their dependencies. Used

// for reconstructing an ExtensionSet from the output of toLLVMFeatures().

// Features that are not recognized are pushed back to \p NonExtensions.

LLVM_ABI void

reconstructFromParsedFeatures(const std::vector<std::string> &Features,

std::vector<std::string> &NonExtensions);

// Convert the set of enabled extension to an LLVM feature list, appending

// them to Features.

template <typename T> void toLLVMFeatureList(std::vector<T> &Features) const {

if (BaseArch && !StrTab[BaseArch->ArchFeature].empty())

Features.emplace_back(T(StrTab[BaseArch->ArchFeature]));

for (const auto &E : Extensions) {

if (!Touched.test(E.ID))

continue;

if (Enabled.test(E.ID))

Features.emplace_back(T(StrTab[E.PosTargetFeature]));

else

Features.emplace_back(T(StrTab[E.NegTargetFeature]));

}

}

LLVM_ABI void dump() const;