Merge pull request #5317 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEscapeEffects.swift

@@ -209,7 +209,7 @@ private struct IsExclusiveReturnEscapeVisitor : EscapeVisitorWithResult {
   var result = false
 
   func isExclusiveEscape(returnInst: ReturnInst, _ context: FunctionPassContext) -> Bool {
-    return returnInst.operand.at(returnPath).visit(using: self, context) ?? false
+    return returnInst.returnedValue.at(returnPath).visit(using: self, context) ?? false
   }
 
   mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -98,7 +98,7 @@ private struct CollectedEffects {
       addDestroyEffects(ofValue: inst.operands[0].value)
 
     case let da as DestroyAddrInst:
-      addDestroyEffects(ofAddress: da.operand)
+      addDestroyEffects(ofAddress: da.destroyedAddress)
 
     case let copy as CopyAddrInst:
       addEffects(.read, to: copy.source)
@@ -146,7 +146,7 @@ private struct CollectedEffects {
     case let fl as FixLifetimeInst:
       // A fix_lifetime instruction acts like a read on the operand to prevent
       // releases moving above the fix_lifetime.
-      addEffects(.read, to: fl.operand)
+      addEffects(.read, to: fl.operand.value)
 
       // Instructions which have effects defined in SILNodes.def, but those effects are
       // not relevant for our purpose.

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/MergeCondFails.swift

@@ -17,8 +17,8 @@ let mergeCondFailsPass = FunctionPass(name: "merge-cond_fails", runMergeCondFail
 /// Return true if the operand of the cond_fail instruction looks like
 /// the overflow bit of an arithmetic instruction.
 private func hasOverflowConditionOperand(_ cfi: CondFailInst) -> Bool {
-  if let tei = cfi.operand as? TupleExtractInst {
-    return tei.operand is BuiltinInst
+  if let tei = cfi.condition as? TupleExtractInst {
+    return tei.operand.value is BuiltinInst
   }
   return false
 }
@@ -73,10 +73,10 @@ private func mergeCondFails(_ condFailToMerge: inout Stack<CondFailInst>,
       mergedCond = builder.createBuiltinBinaryFunction(name: "or",
                                         operandType: prevCond.type,
                                         resultType: prevCond.type,
-                                        arguments: [prevCond, cfi.operand])
+                                        arguments: [prevCond, cfi.condition])
       didMerge = true
     } else {
-      mergedCond = cfi.operand
+      mergedCond = cfi.condition
     }
   }
   if !didMerge {

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjCBridgingOptimization.swift

@@ -237,9 +237,9 @@ private func removeBridgingCodeInPredecessors(of block: BasicBlock, _ context: F
 
     let en = branch.operands[0].value as! EnumInst
     context.erase(instruction: branch)
-    let op = en.operand
+    let payload = en.payload
     context.erase(instruction: en)
-    if let bridgingCall = op {
+    if let bridgingCall = payload {
       context.erase(instruction: bridgingCall as! ApplyInst)
     }
   }
@@ -249,7 +249,7 @@ private func lookThroughOwnershipInsts(_ value: Value) -> Value {
   // Looks like it's sufficient to support begin_borrow for now.
   // TODO: add copy_value if needed.
   if let bbi = value as? BeginBorrowInst {
-    return bbi.operand
+    return bbi.borrowedValue
   }
   return value
 }
@@ -286,10 +286,10 @@ private func isOptionalBridging(of value: Value, isBridging: (Value) -> ApplyIns
           singleEnumUse.instruction is BranchInst else {
       return nil
     }
-    if let enumOp = enumInst.operand {
+    if let payload = enumInst.payload {
       // The some-case
       if someSwitch != nil { return nil }
-      guard let bridgingCall = isBridging(enumOp),
+      guard let bridgingCall = isBridging(payload),
             bridgingCall.uses.isSingleUse else {
         return nil
       }
@@ -298,8 +298,8 @@ private func isOptionalBridging(of value: Value, isBridging: (Value) -> ApplyIns
       // If it's an ObjC -> Swift bridging call the argument is wrapped into an optional enum.
       if callArgument.type.isEnum {
         guard let sourceEnum = callArgument as? EnumInst,
-              let sourceEnumOp = sourceEnum.operand,
-              let (se, someCase) = isPayloadOfSwitchEnum(sourceEnumOp),
+              let sourcePayload = sourceEnum.payload,
+              let (se, someCase) = isPayloadOfSwitchEnum(sourcePayload),
               enumInst.caseIndex == someCase,
               sourceEnum.caseIndex == someCase,
               sourceEnum.type == se.enumOp.type else {

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ReleaseDevirtualizer.swift

@@ -78,7 +78,7 @@ private func tryDevirtualizeReleaseOfObject(
   // Check if the release instruction right before the `dealloc_stack_ref` really releases
   // the allocated object (and not something else).
   var finder = FindAllocationOfRelease(allocation: allocRefInstruction)
-  if !finder.allocationIsRoot(of: release.operand) {
+  if !finder.allocationIsRoot(of: release.operand.value) {
     return
   }
 

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBeginCOWMutation.swift

@@ -56,7 +56,7 @@ extension BeginCOWMutationInst : Simplifyable, SILCombineSimplifyable {
 private extension BeginCOWMutationInst {
 
   func optimizeEmptySingleton(_ context: SimplifyContext) {
-    if !isEmptyCOWSingleton(operand) {
+    if !isEmptyCOWSingleton(instance) {
       return
     }
     if uniquenessResult.nonDebugUses.isEmpty {
@@ -73,14 +73,14 @@ private extension BeginCOWMutationInst {
     if !uniquenessResult.nonDebugUses.isEmpty {
       return false
     }
-    let buffer = bufferResult
+    let buffer = instanceResult
     if buffer.nonDebugUses.contains(where: { !($0.instruction is EndCOWMutationInst) }) {
       return false
     }
 
     for use in buffer.nonDebugUses {
       let endCOW = use.instruction as! EndCOWMutationInst
-      endCOW.uses.replaceAll(with: operand, context)
+      endCOW.uses.replaceAll(with: instance, context)
       context.erase(instruction: endCOW)
     }
     context.erase(instructionIncludingDebugUses: self)
@@ -91,14 +91,14 @@ private extension BeginCOWMutationInst {
     if !uniquenessResult.nonDebugUses.isEmpty {
       return false
     }
-    guard let endCOW = operand as? EndCOWMutationInst else {
+    guard let endCOW = instance as? EndCOWMutationInst else {
       return false
     }
     if endCOW.nonDebugUses.contains(where: { $0.instruction != self }) {
       return false
     }
 
-    bufferResult.uses.replaceAll(with: endCOW.operand, context)
+    instanceResult.uses.replaceAll(with: endCOW.instance, context)
     context.erase(instructionIncludingDebugUses: self)
     context.erase(instructionIncludingDebugUses: endCOW)
     return true
@@ -114,7 +114,7 @@ private func isEmptyCOWSingleton(_ value: Value) -> Bool {
            is RawPointerToRefInst,
            is AddressToPointerInst,
            is CopyValueInst:
-        v = (v as! UnaryInstruction).operand
+        v = (v as! UnaryInstruction).operand.value
       case let globalAddr as GlobalAddrInst:
         let name = globalAddr.global.name
         return name == "_swiftEmptyArrayStorage" ||

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBuiltin.swift

@@ -76,13 +76,13 @@ private func typesOfValuesAreEqual(_ lhs: Value, _ rhs: Value, in function: Func
     return nil
   }
 
-  let lhsTy = lhsExistential.operand.type.instanceTypeOfMetatype(in: function)
-  let rhsTy = rhsExistential.operand.type.instanceTypeOfMetatype(in: function)
+  let lhsTy = lhsExistential.metatype.type.instanceTypeOfMetatype(in: function)
+  let rhsTy = rhsExistential.metatype.type.instanceTypeOfMetatype(in: function)
 
   // Do we know the exact types? This is not the case e.g. if a type is passed as metatype
   // to the function.
-  let typesAreExact = lhsExistential.operand is MetatypeInst &&
-                      rhsExistential.operand is MetatypeInst
+  let typesAreExact = lhsExistential.metatype is MetatypeInst &&
+                      rhsExistential.metatype is MetatypeInst
 
   switch (lhsTy.typeKind, rhsTy.typeKind) {
   case (_, .unknown), (.unknown, _):

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyStrongRetainRelease.swift

@@ -14,7 +14,7 @@ import SIL
 
 extension StrongRetainInst : Simplifyable, SILCombineSimplifyable {
   func simplify(_ context: SimplifyContext) {
-    if isNotReferenceCounted(value: operand) {
+    if isNotReferenceCounted(value: instance) {
       context.erase(instruction: self)
       return
     }
@@ -34,7 +34,7 @@ extension StrongRetainInst : Simplifyable, SILCombineSimplifyable {
     // peephole.
     if let prev = previous {
       if let release = prev as? StrongReleaseInst {
-        if release.operand == operand {
+        if release.instance == self.instance {
           context.erase(instruction: self)
           context.erase(instruction: release)
           return
@@ -46,7 +46,7 @@ extension StrongRetainInst : Simplifyable, SILCombineSimplifyable {
 
 extension StrongReleaseInst : Simplifyable, SILCombineSimplifyable {
   func simplify(_ context: SimplifyContext) {
-    let op = operand
+    let op = instance
     if isNotReferenceCounted(value: op) {
       context.erase(instruction: self)
       return
@@ -56,7 +56,7 @@ extension StrongReleaseInst : Simplifyable, SILCombineSimplifyable {
     // release of the class, squish the conversion.
     if let ier = op as? InitExistentialRefInst {
       if ier.uses.isSingleUse {
-        setOperand(at: 0, to: ier.operand, context)
+        setOperand(at: 0, to: ier.instance, context)
         context.erase(instruction: ier)
         return
       }
@@ -69,11 +69,11 @@ extension StrongReleaseInst : Simplifyable, SILCombineSimplifyable {
 private func isNotReferenceCounted(value: Value) -> Bool {
   switch value {
     case let cfi as ConvertFunctionInst:
-      return isNotReferenceCounted(value: cfi.operand)
+      return isNotReferenceCounted(value: cfi.fromFunction)
     case let uci as UpcastInst:
-      return isNotReferenceCounted(value: uci.operand)
+      return isNotReferenceCounted(value: uci.fromInstance)
     case let urc as UncheckedRefCastInst:
-      return isNotReferenceCounted(value: urc.operand)
+      return isNotReferenceCounted(value: urc.fromInstance)
     case let gvi as GlobalValueInst:
       // Since Swift 5.1, statically allocated objects have "immortal" reference
       // counts. Therefore we can safely eliminate unbalanced retains and
@@ -90,8 +90,8 @@ private func isNotReferenceCounted(value: Value) -> Bool {
         //     %0 = global_addr @_swiftEmptyArrayStorage
         //     %1 = address_to_pointer %0
         //     %2 = raw_pointer_to_ref %1
-        if let atp = rptr.operand as? AddressToPointerInst {
-          return atp.operand is GlobalAddrInst
+        if let atp = rptr.pointer as? AddressToPointerInst {
+          return atp.address is GlobalAddrInst
         }
       }
       return false

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyStructExtract.swift

@@ -14,7 +14,7 @@ import SIL
 
 extension StructExtractInst : OnoneSimplifyable {
   func simplify(_ context: SimplifyContext) {
-    guard let structInst = operand as? StructInst else {
+    guard let structInst = self.struct as? StructInst else {
       return
     }
     context.tryReplaceRedundantInstructionPair(first: structInst, second: self,

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyUncheckedEnumData.swift

@@ -14,12 +14,12 @@ import SIL
 
 extension UncheckedEnumDataInst : OnoneSimplifyable {
   func simplify(_ context: SimplifyContext) {
-    guard let enumInst = operand as? EnumInst else {
+    guard let enumInst = self.enum as? EnumInst else {
       return
     }
     if caseIndex != enumInst.caseIndex {
       return
     }
-    context.tryReplaceRedundantInstructionPair(first: enumInst, second: self, with: enumInst.operand)
+    context.tryReplaceRedundantInstructionPair(first: enumInst, second: self, with: enumInst.payload!)
   }
 }