Skip to content

Windows triple normalization #80

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 4 commits into from
Mar 5, 2020
Merged

Windows triple normalization #80

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
aa9c7a3
Merge pull request #11 from apple/master
sjavora Jan 19, 2020
398c57b
Merge pull request #12 from apple/master
sjavora Feb 9, 2020
59d018b
Merge pull request #13 from apple/master
sjavora Feb 17, 2020
3d096a4
Implement normalizing of Windows triples, other edge cases based on L…
sjavora Mar 1, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
95 changes: 88 additions & 7 deletions Sources/SwiftDriver/Utilities/Triple.swift
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -105,14 +105,53 @@ public struct Triple {
parser.rematch(&parsedOS, at: 2)
parser.rematch(&parsedEnv, at: 3)

// TODO: This normalization logic is a little less robust than LLVM's.
// In particular, it doesn't correct Windows triples as well as
// llvm::Triple::normalize() does.
let isCygwin = parser.componentsIndicateCygwin
let isMinGW32 = parser.componentsIndicateMinGW32

if
let parsedEnv = parsedEnv,
parsedEnv.value.environment == .android,
parsedEnv.substring.hasPrefix("androideabi") {
let androidVersion = parsedEnv.substring.dropFirst("androideabi".count)

parser.components[3] = "android\(androidVersion)"
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

There is no test for this - I didn't find one in TripleTest.cpp and I don't really know what a "valid" triple like this would look like.

}

// SUSE uses "gnueabi" to mean "gnueabihf"
if parsedVendor?.value == .suse && parsedEnv?.value.environment == .gnueabi {
parser.components[3] = "gnueabihf"
}

if parsedOS?.value == .win32 {
parser.components.resize(toCount: 4, paddingWith: "")
parser.components[2] = "windows"
if parsedEnv?.value.environment == nil {
if let objectFormat = parsedEnv?.value.objectFormat, objectFormat != .coff {
parser.components[3] = Substring(objectFormat.name)
} else {
parser.components[3] = "msvc"
}
}
} else if isMinGW32 {
parser.components.resize(toCount: 4, paddingWith: "")
parser.components[2] = "windows"
parser.components[3] = "gnu"
} else if isCygwin {
parser.components.resize(toCount: 4, paddingWith: "")
parser.components[2] = "windows"
parser.components[3] = "cygnus"
}

if isMinGW32 || isCygwin || (parsedOS?.value == .win32 && parsedEnv?.value.environment != nil) {
if let objectFormat = parsedEnv?.value.objectFormat, objectFormat != .coff {
parser.components.resize(toCount: 5, paddingWith: "")
parser.components[4] = Substring(objectFormat.name)
}
}

// Now that we've parsed everything, we construct a normalized form of the
// triple string.
triple = parser.components.map { $0 == "" ? "unknown" : $0 }
.joined(separator: "-")
triple = parser.components.map({ $0.isEmpty ? "unknown" : $0 }).joined(separator: "-")
}
else {
triple = string
Expand Down Expand Up @@ -141,6 +180,14 @@ public struct Triple {

fileprivate protocol TripleComponent {
static func parse(_ component: Substring) -> Self?

static func valueIsValid(_ value: Substring) -> Bool
}

extension TripleComponent {
static func valueIsValid(_ value: Substring) -> Bool {
parse(value) != nil
}
}

fileprivate struct ParsedComponent<Value: TripleComponent> {
Expand Down Expand Up @@ -178,6 +225,14 @@ fileprivate struct TripleParser {
var components: [Substring]
var isMatched: Set<Int> = []

var componentsIndicateCygwin: Bool {
components.count > 2 ? components[2].hasPrefix("cygwin") : false
}

var componentsIndicateMinGW32: Bool {
components.count > 2 ? components[2].hasPrefix("mingw") : false
}

init(_ string: String, allowMore: Bool) {
components = string.split(
separator: "-", maxSplits: allowMore ? Int.max : 3,
Expand Down Expand Up @@ -214,11 +269,11 @@ fileprivate struct TripleParser {
"Lost the parsed component somehow?")

for i in unmatchedIndices {
guard let parsed = ParsedComponent(components[i], as: Value.self) else {
guard Value.valueIsValid(components[i]) else {
continue
}

value = parsed
value = ParsedComponent(components[i], as: Value.self)
shiftComponent(at: i, to: correctIndex)
isMatched.insert(correctIndex)

Expand Down Expand Up @@ -1120,6 +1175,10 @@ extension Triple {
return nil
}
}

fileprivate static func valueIsValid(_ value: Substring) -> Bool {
parse(value) != nil || value.hasPrefix("cygwin") || value.hasPrefix("mingw")
}
}
}

Expand Down Expand Up @@ -1361,6 +1420,16 @@ extension Triple {
return .wasm
}
}

var name: String {
switch self {
case .coff: return "coff"
case .elf: return "elf"
case .macho: return "macho"
case .wasm: return "wasm"
case .xcoff: return "xcoff"
}
}
}
}

Expand Down Expand Up @@ -1558,3 +1627,15 @@ extension Triple {
}
}
}

fileprivate extension Array {

mutating func resize(toCount desiredCount: Int, paddingWith element: Element) {

if desiredCount > count {
append(contentsOf: repeatElement(element, count: desiredCount - count))
} else if desiredCount < count {
removeLast(count - desiredCount)
}
}
}
102 changes: 51 additions & 51 deletions Tests/SwiftDriverTests/TripleTests.swift
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -712,8 +712,8 @@ final class TripleTests: XCTestCase {
func testNormalizeSpecialCases() {
// Various real-world funky triples. The value returned by GCC's config.sub
// is given in the comment.
// assertNormalizesEqual("i386-mingw32",
// "i386-unknown-windows-gnu") // i386-pc-mingw32
assertNormalizesEqual("i386-mingw32",
"i386-unknown-windows-gnu") // i386-pc-mingw32
assertNormalizesEqual("x86_64-linux-gnu",
"x86_64-unknown-linux-gnu") // x86_64-pc-linux-gnu
assertNormalizesEqual("i486-linux-gnu",
Expand All @@ -731,37 +731,37 @@ final class TripleTests: XCTestCase {
}

func testNormalizeWindows() {
// assertNormalizesEqual("i686-pc-win32", "i686-pc-windows-msvc")
// assertNormalizesEqual("i686-win32", "i686-unknown-windows-msvc")
// assertNormalizesEqual("i686-pc-mingw32", "i686-pc-windows-gnu")
// assertNormalizesEqual("i686-mingw32", "i686-unknown-windows-gnu")
// assertNormalizesEqual("i686-pc-mingw32-w64", "i686-pc-windows-gnu")
// assertNormalizesEqual("i686-mingw32-w64", "i686-unknown-windows-gnu")
// assertNormalizesEqual("i686-pc-cygwin", "i686-pc-windows-cygnus")
// assertNormalizesEqual("i686-cygwin", "i686-unknown-windows-cygnus")
//
// assertNormalizesEqual("x86_64-pc-win32", "x86_64-pc-windows-msvc")
// assertNormalizesEqual("x86_64-win32", "x86_64-unknown-windows-msvc")
// assertNormalizesEqual("x86_64-pc-mingw32", "x86_64-pc-windows-gnu")
// assertNormalizesEqual("x86_64-mingw32", "x86_64-unknown-windows-gnu")
// assertNormalizesEqual("x86_64-pc-mingw32-w64",
// "x86_64-pc-windows-gnu")
// assertNormalizesEqual("x86_64-mingw32-w64",
// "x86_64-unknown-windows-gnu")
//
// assertNormalizesEqual("i686-pc-win32-elf", "i686-pc-windows-elf")
// assertNormalizesEqual("i686-win32-elf", "i686-unknown-windows-elf")
// assertNormalizesEqual("i686-pc-win32-macho", "i686-pc-windows-macho")
// assertNormalizesEqual("i686-win32-macho",
// "i686-unknown-windows-macho")
//
// assertNormalizesEqual("x86_64-pc-win32-elf", "x86_64-pc-windows-elf")
// assertNormalizesEqual("x86_64-win32-elf",
// "x86_64-unknown-windows-elf")
// assertNormalizesEqual("x86_64-pc-win32-macho",
// "x86_64-pc-windows-macho")
// assertNormalizesEqual("x86_64-win32-macho",
// "x86_64-unknown-windows-macho")
assertNormalizesEqual("i686-pc-win32", "i686-pc-windows-msvc")
assertNormalizesEqual("i686-win32", "i686-unknown-windows-msvc")
assertNormalizesEqual("i686-pc-mingw32", "i686-pc-windows-gnu")
assertNormalizesEqual("i686-mingw32", "i686-unknown-windows-gnu")
assertNormalizesEqual("i686-pc-mingw32-w64", "i686-pc-windows-gnu")
assertNormalizesEqual("i686-mingw32-w64", "i686-unknown-windows-gnu")
assertNormalizesEqual("i686-pc-cygwin", "i686-pc-windows-cygnus")
assertNormalizesEqual("i686-cygwin", "i686-unknown-windows-cygnus")

assertNormalizesEqual("x86_64-pc-win32", "x86_64-pc-windows-msvc")
assertNormalizesEqual("x86_64-win32", "x86_64-unknown-windows-msvc")
assertNormalizesEqual("x86_64-pc-mingw32", "x86_64-pc-windows-gnu")
assertNormalizesEqual("x86_64-mingw32", "x86_64-unknown-windows-gnu")
assertNormalizesEqual("x86_64-pc-mingw32-w64",
"x86_64-pc-windows-gnu")
assertNormalizesEqual("x86_64-mingw32-w64",
"x86_64-unknown-windows-gnu")

assertNormalizesEqual("i686-pc-win32-elf", "i686-pc-windows-elf")
assertNormalizesEqual("i686-win32-elf", "i686-unknown-windows-elf")
assertNormalizesEqual("i686-pc-win32-macho", "i686-pc-windows-macho")
assertNormalizesEqual("i686-win32-macho",
"i686-unknown-windows-macho")

assertNormalizesEqual("x86_64-pc-win32-elf", "x86_64-pc-windows-elf")
assertNormalizesEqual("x86_64-win32-elf",
"x86_64-unknown-windows-elf")
assertNormalizesEqual("x86_64-pc-win32-macho",
"x86_64-pc-windows-macho")
assertNormalizesEqual("x86_64-win32-macho",
"x86_64-unknown-windows-macho")

assertNormalizesEqual("i686-pc-windows-cygnus",
"i686-pc-windows-cygnus")
Expand All @@ -770,8 +770,8 @@ final class TripleTests: XCTestCase {
"i686-pc-windows-itanium")
assertNormalizesEqual("i686-pc-windows-msvc", "i686-pc-windows-msvc")

// assertNormalizesEqual("i686-pc-windows-elf-elf",
// "i686-pc-windows-elf")
assertNormalizesEqual("i686-pc-windows-elf-elf",
"i686-pc-windows-elf")
}

func testNormalizeARM() {
Expand All @@ -792,8 +792,8 @@ final class TripleTests: XCTestCase {
assertNormalizesEqual("armv7eb-netbsd-eabihf",
"armv7eb-unknown-netbsd-eabihf")

// assertNormalizesEqual("armv7-suse-linux-gnueabi",
// "armv7-suse-linux-gnueabihf")
assertNormalizesEqual("armv7-suse-linux-gnueabi",
"armv7-suse-linux-gnueabihf")

var T: Triple
T = Triple("armv6--netbsd-eabi")
Expand All @@ -815,9 +815,9 @@ final class TripleTests: XCTestCase {
T = Triple("i386-apple-darwin9")
XCTAssertTrue(T.os?.isMacOSX)
XCTAssertFalse(T.os?.isiOS)
// XCTAssertFalse(T.isArch16Bit())
// XCTAssertTrue(T.isArch32Bit())
// XCTAssertFalse(T.isArch64Bit())
XCTAssertFalse(T.arch?.is16Bit)
XCTAssertTrue(T.arch?.is32Bit)
XCTAssertFalse(T.arch?.is64Bit)
V = T._macOSVersion
XCTAssertEqual(V?.major, 10)
XCTAssertEqual(V?.minor, 5)
Expand All @@ -830,9 +830,9 @@ final class TripleTests: XCTestCase {
T = Triple("x86_64-apple-darwin9")
XCTAssertTrue(T.os?.isMacOSX)
XCTAssertFalse(T.os?.isiOS)
// XCTAssertFalse(T.isArch16Bit())
// XCTAssertFalse(T.isArch32Bit())
// XCTAssertTrue(T.isArch64Bit())
XCTAssertFalse(T.arch?.is16Bit)
XCTAssertFalse(T.arch?.is32Bit)
XCTAssertTrue(T.arch?.is64Bit)
V = T._macOSVersion
XCTAssertEqual(V?.major, 10)
XCTAssertEqual(V?.minor, 5)
Expand All @@ -845,9 +845,9 @@ final class TripleTests: XCTestCase {
T = Triple("x86_64-apple-macosx")
XCTAssertTrue(T.os?.isMacOSX)
XCTAssertFalse(T.os?.isiOS)
// XCTAssertFalse(T.isArch16Bit())
// XCTAssertFalse(T.isArch32Bit())
// XCTAssertTrue(T.isArch64Bit())
XCTAssertFalse(T.arch?.is16Bit)
XCTAssertFalse(T.arch?.is32Bit)
XCTAssertTrue(T.arch?.is64Bit)
V = T._macOSVersion
XCTAssertEqual(V?.major, 10)
XCTAssertEqual(V?.minor, 4)
Expand All @@ -860,9 +860,9 @@ final class TripleTests: XCTestCase {
T = Triple("x86_64-apple-macosx10.7")
XCTAssertTrue(T.os?.isMacOSX)
XCTAssertFalse(T.os?.isiOS)
// XCTAssertFalse(T.isArch16Bit())
// XCTAssertFalse(T.isArch32Bit())
// XCTAssertTrue(T.isArch64Bit())
XCTAssertFalse(T.arch?.is16Bit)
XCTAssertFalse(T.arch?.is32Bit)
XCTAssertTrue(T.arch?.is64Bit)
V = T._macOSVersion
XCTAssertEqual(V?.major, 10)
XCTAssertEqual(V?.minor, 7)
Expand Down Expand Up @@ -970,8 +970,8 @@ final class TripleTests: XCTestCase {
// let GNUWindowsNormalized = Triple("i686-pc-windows-gnu-elf", normalizing: true)
// XCTAssertEqual(.elf, GNUWindowsNormalized.objectFormat)

// let CygnusNormalised = Triple("i686-pc-windows-cygnus-elf", normalizing: true)
// XCTAssertEqual(.elf, CygnusNormalised.objectFormat)
// let CygnusNormalized = Triple("i686-pc-windows-cygnus-elf", normalizing: true)
// XCTAssertEqual(.elf, CygnusNormalized.objectFormat)

let CygwinNormalized = Triple("i686-pc-cygwin-elf", normalizing: true)
XCTAssertEqual(.elf, CygwinNormalized.objectFormat)
Expand Down