}
static Triple::ArchType parseARMArch(StringRef ArchName) {
- unsigned ISA = ARMTargetParser::parseArchISA(ArchName);
- unsigned ENDIAN = ARMTargetParser::parseArchEndian(ArchName);
+ unsigned ISA = ARM::parseArchISA(ArchName);
+ unsigned ENDIAN = ARM::parseArchEndian(ArchName);
Triple::ArchType arch = Triple::UnknownArch;
switch (ENDIAN) {
}
}
- ArchName = ARMTargetParser::getCanonicalArchName(ArchName);
+ ArchName = ARM::getCanonicalArchName(ArchName);
if (ArchName.empty())
return Triple::UnknownArch;
return Triple::UnknownArch;
// Thumb only for v6m
- unsigned Profile = ARMTargetParser::parseArchProfile(ArchName);
- unsigned Version = ARMTargetParser::parseArchVersion(ArchName);
+ unsigned Profile = ARM::parseArchProfile(ArchName);
+ unsigned Version = ARM::parseArchVersion(ArchName);
if (Profile == ARM::PK_M && Version == 6) {
if (ENDIAN == ARM::EK_BIG)
return Triple::thumbeb;
}
static Triple::ArchType parseArch(StringRef ArchName) {
- Triple::ArchType ARMArch(parseARMArch(ArchName));
- Triple::ArchType BPFArch(parseBPFArch(ArchName));
-
- return StringSwitch<Triple::ArchType>(ArchName)
+ auto AT = StringSwitch<Triple::ArchType>(ArchName)
.Cases("i386", "i486", "i586", "i686", Triple::x86)
// FIXME: Do we need to support these?
.Cases("i786", "i886", "i986", Triple::x86)
.Case("powerpc64le", Triple::ppc64le)
.Case("xscale", Triple::arm)
.Case("xscaleeb", Triple::armeb)
- .StartsWith("arm", ARMArch)
- .StartsWith("thumb", ARMArch)
- .StartsWith("aarch64", ARMArch)
+ .Case("aarch64", Triple::aarch64)
+ .Case("aarch64_be", Triple::aarch64_be)
+ .Case("arm64", Triple::aarch64)
+ .Case("arm", Triple::arm)
+ .Case("armeb", Triple::armeb)
+ .Case("thumb", Triple::thumb)
+ .Case("thumbeb", Triple::thumbeb)
.Case("msp430", Triple::msp430)
.Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
.Cases("mipsel", "mipsallegrexel", Triple::mipsel)
.Case("mips64el", Triple::mips64el)
.Case("r600", Triple::r600)
.Case("amdgcn", Triple::amdgcn)
- .StartsWith("bpf", BPFArch)
.Case("hexagon", Triple::hexagon)
.Case("s390x", Triple::systemz)
.Case("sparc", Triple::sparc)
.Case("wasm32", Triple::wasm32)
.Case("wasm64", Triple::wasm64)
.Default(Triple::UnknownArch);
+
+ // Some architectures require special parsing logic just to compute the
+ // ArchType result.
+ if (AT == Triple::UnknownArch) {
+ if (ArchName.startswith("arm") || ArchName.startswith("thumb") ||
+ ArchName.startswith("aarch64"))
+ return parseARMArch(ArchName);
+ if (ArchName.startswith("bpf"))
+ return parseBPFArch(ArchName);
+ }
+
+ return AT;
}
static Triple::VendorType parseVendor(StringRef VendorName) {
}
static Triple::SubArchType parseSubArch(StringRef SubArchName) {
- StringRef ARMSubArch = ARMTargetParser::getCanonicalArchName(SubArchName);
+ StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);
// For now, this is the small part. Early return.
if (ARMSubArch.empty())
.Default(Triple::NoSubArch);
// ARM sub arch.
- switch(ARMTargetParser::parseArch(ARMSubArch)) {
+ switch(ARM::parseArch(ARMSubArch)) {
case ARM::AK_ARMV4:
return Triple::NoSubArch;
case ARM::AK_ARMV4T:
if (T.isOSDarwin())
return Triple::MachO;
return Triple::ELF;
+
+ case Triple::wasm32:
+ case Triple::wasm64:
+ // Unknown for now, until an object format is specified.
+ return Triple::UnknownObjectFormat;
}
if (T.isOSDarwin())
return T;
}
-const char *Triple::getARMCPUForArch(StringRef MArch) const {
+StringRef Triple::getARMCPUForArch(StringRef MArch) const {
if (MArch.empty())
MArch = getArchName();
- MArch = ARMTargetParser::getCanonicalArchName(MArch);
+ MArch = ARM::getCanonicalArchName(MArch);
// Some defaults are forced.
switch (getOS()) {
}
if (MArch.empty())
- return nullptr;
+ return StringRef();
- const char *CPU = ARMTargetParser::getDefaultCPU(MArch);
- if (CPU)
+ StringRef CPU = ARM::getDefaultCPU(MArch);
+ if (!CPU.empty())
return CPU;
// If no specific architecture version is requested, return the minimum CPU