Swift SIL: invert Type.isNonTrivialOrContainsRawPointer to Type.isTrivialNonPointer

This is consistent with `Type.isTrivial`.
Also, introduce corresponding properties in `Value`: `hasTrivialType` and `hasTrivialNonPointerType`, because
1. It's less to type than `Type.isTrivial(in: function)` because `Value` knows in which function it is.
2. It fixes the corner case where value is an `Undef`, which has not parent function.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEscapeEffects.swift

@@ -35,8 +35,8 @@ let computeEscapeEffects = FunctionPass(name: "compute-escape-effects", {
 
   for arg in function.arguments {
     // We are not interested in arguments with trivial types.
-    if !arg.type.isNonTrivialOrContainsRawPointer(in: function) { continue }
-
+    if arg.hasTrivialNonPointerType { continue }
+    
     // Also, we don't want to override defined effects.
     if argsWithDefinedEffects.contains(arg.index) { continue }
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -376,7 +376,7 @@ private struct ArgumentEscapingWalker : ValueDefUseWalker, AddressDefUseWalker {
   mutating func hasUnknownUses(argument: FunctionArgument) -> Bool {
     if argument.type.isAddress {
       return walkDownUses(ofAddress: argument, path: UnusedWalkingPath()) == .abortWalk
-    } else if argument.type.isTrivial(in: argument.function) {
+    } else if argument.hasTrivialType {
       return false
     } else {
       return walkDownUses(ofValue: argument, path: UnusedWalkingPath()) == .abortWalk
@@ -415,22 +415,22 @@ private struct ArgumentEscapingWalker : ValueDefUseWalker, AddressDefUseWalker {
     switch inst {
     case let copy as CopyAddrInst:
       if address == copy.sourceOperand &&
-          !address.value.type.isTrivial(in: inst.function) &&
+          !address.value.hasTrivialType &&
           (!function.hasOwnership || copy.isTakeOfSrc) {
         foundTakingLoad = true
       }
       return .continueWalk
 
     case let load as LoadInst:
-      if !address.value.type.isTrivial(in: function) &&
+      if !address.value.hasTrivialType &&
           // In non-ossa SIL we don't know if a load is taking.
           (!function.hasOwnership || load.ownership == .take) {
         foundTakingLoad = true
       }
       return .continueWalk
 
     case is LoadWeakInst, is LoadUnownedInst, is LoadBorrowInst:
-      if !function.hasOwnership && !address.value.type.isTrivial(in: function) {
+      if !function.hasOwnership && !address.value.hasTrivialType {
         foundTakingLoad = true
       }
       return .continueWalk

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ReleaseDevirtualizer.swift

@@ -149,7 +149,7 @@ private struct FindAllocationOfRelease : ValueUseDefWalker {
     //
     var nonTrivialOperandFound = false
     for operand in def.operands {
-      if !operand.value.type.isTrivial(in: def.function) {
+      if !operand.value.hasTrivialType {
         if nonTrivialOperandFound {
           return .abortWalk
         }

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -197,12 +197,11 @@ extension EscapeVisitor {
   }
 
   func hasRelevantType(_ value: Value, at path: SmallProjectionPath, analyzeAddresses: Bool) -> Bool {
-    let type = value.type
-    if type.isNonTrivialOrContainsRawPointer(in: value.function) { return true }
+    if !value.hasTrivialNonPointerType { return true }
 
     // For selected addresses we also need to consider trivial types (`value`
     // is a selected address if the path does not contain any class projections).
-    if analyzeAddresses && type.isAddress && !path.hasClassProjection { return true }
+    if analyzeAddresses && value.type.isAddress && !path.hasClassProjection { return true }
     return false
   }
 }
@@ -542,7 +541,7 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
       let svi = instruction as! SingleValueInstruction
 
       // Even when analyzing addresses, a loaded trivial value can be ignored.
-      if !svi.type.isNonTrivialOrContainsRawPointer(in: svi.function) { return .continueWalk }
+      if svi.hasTrivialNonPointerType { return .continueWalk }
       return walkDownUses(ofValue: svi, path: path.with(knownType: nil))
     case let atp as AddressToPointerInst:
       return walkDownUses(ofValue: atp, path: path.with(knownType: nil))

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -23,12 +23,13 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
     return SILType_isTrivial(bridged, function.bridged) != 0
   }
 
-  public func isReferenceCounted(in function: Function) -> Bool {
-    return SILType_isReferenceCounted(bridged, function.bridged) != 0
+  /// Returns true if the type is a trivial type and is and does not contain a Builtin.RawPointer.
+  public func isTrivialNonPointer(in function: Function) -> Bool {
+    return SILType_isNonTrivialOrContainsRawPointer(bridged, function.bridged) == 0
   }
 
-  public func isNonTrivialOrContainsRawPointer(in function: Function) -> Bool {
-    return SILType_isNonTrivialOrContainsRawPointer(bridged, function.bridged) != 0
+  public func isReferenceCounted(in function: Function) -> Bool {
+    return SILType_isReferenceCounted(bridged, function.bridged) != 0
   }
 
   public var isNominal: Bool { SILType_isNominal(bridged) != 0 }

SwiftCompilerSources/Sources/SIL/Value.swift

@@ -27,6 +27,12 @@ public protocol Value : AnyObject, CustomStringConvertible {
   ///
   /// It's not legal to get the definingBlock of an `Undef` value.
   var definingBlock: BasicBlock { get }
+
+  /// True if the value has a trivial type.
+  var hasTrivialType: Bool { get }
+
+  /// True if the value has a trivial type which is and does not contain a Builtin.RawPointer.
+  var hasTrivialNonPointerType: Bool { get }
 }
 
 public enum Ownership {
@@ -93,6 +99,12 @@ extension Value {
 
   public var type: Type { SILValue_getType(bridged).type }
 
+  /// True if the value has a trivial type.
+  public var hasTrivialType: Bool { type.isTrivial(in: function) }
+
+  /// True if the value has a trivial type which is and does not contain a Builtin.RawPointer.
+  public var hasTrivialNonPointerType: Bool { type.isTrivialNonPointer(in: function) }
+
   public var ownership: Ownership { SILValue_getOwnership(bridged).ownership }
 
   public var hashable: HashableValue { ObjectIdentifier(self) }
@@ -165,9 +177,18 @@ extension BridgedValue {
 
 final class Undef : Value {
   public var definingInstruction: Instruction? { nil }
+
   public var definingBlock: BasicBlock {
     fatalError("undef has no defining block")
   }
+
+  /// Undef has not parent function, therefore the default `hasTrivialType` does not work.
+  /// Return the conservative default in this case.
+  public var hasTrivialType: Bool { false }
+
+  /// Undef has not parent function, therefore the default `hasTrivialNonPointerType` does not work.
+  /// Return the conservative default in this case.
+  public var hasTrivialNonPointerType: Bool { false }
 }
 
 final class PlaceholderValue : Value {