1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
|
//===--- SimplifyTuple.swift ---------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
import SIL
extension TupleInst : OnoneSimplifyable {
func simplify(_ context: SimplifyContext) {
// Eliminate the redundant instruction pair
// ```
// (%3, %4, %5) = destructure_tuple %input
// %output = tuple (%3, %4, %5)
// ```
// and replace the result %output with %input
//
var destructure: DestructureTupleInst?
for operand in operands {
guard let def = operand.value.definingInstruction as? DestructureTupleInst else {
return
}
guard let destructure else {
destructure = def
continue
}
if destructure != def {
return
}
}
guard let destructure else {
return
}
guard destructure.operand.value.type == type else {
return
}
// The destructure's operand having the same type as the tuple ensures that
// the count of results of the destructure is equal to the count of operands
// of the tuple.
assert(destructure.results.count == operands.count)
for (result, operand) in zip(destructure.results, operands) {
if result != operand.value {
return
}
}
tryReplaceDestructConstructPair(destruct: destructure, construct: self, context)
}
}
private func tryReplaceDestructConstructPair(destruct: MultipleValueInstruction & UnaryInstruction,
construct: SingleValueInstruction,
_ context: SimplifyContext) {
let everyResultUsedOnce = context.preserveDebugInfo
? destruct.results.allSatisfy { $0.uses.singleUse != nil }
: destruct.results.allSatisfy { $0.uses.ignoreDebugUses.singleUse != nil }
let anyOwned = destruct.results.contains { $0.ownership == .owned }
if !everyResultUsedOnce && construct.parentFunction.hasOwnership && anyOwned {
// We cannot add more uses to this destructure without inserting a copy.
return
}
construct.uses.replaceAll(with: destruct.operand.value, context)
if everyResultUsedOnce {
context.erase(instructionIncludingDebugUses: construct)
}
}
|
