Optimize TypeValueInst in Swift

Author: Azoy

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -24,6 +24,7 @@ swift_compiler_sources(Optimizer
   SimplifyInitEnumDataAddr.swift
   SimplifyKeyPath.swift
   SimplifyLoad.swift
+  SimplifyMisc.swift
   SimplifyPartialApply.swift
   SimplifyPointerToAddress.swift
   SimplifyRefCasts.swift

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyMisc.swift

@@ -0,0 +1,32 @@
+//===--- SimplifyMisc.swift -----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 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 TypeValueInst: OnoneSimplifyable, SILCombineSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+    // If our parameter is not known statically, then bail.
+    guard paramType.isInteger() else {
+      return
+    }
+
+    // Note: Right now, value generics only support 'Int'. If we ever expand the
+    // scope of types supported, then this should change.
+    let fieldType = type.getNominalFields(in: parentFunction)![0]
+
+    let builder = Builder(before: self, context)
+    let intLiteral = builder.createIntegerLiteral(value, type: fieldType)
+    let structInst = builder.createStruct(type: type, elements: [intLiteral])
+    uses.replaceAll(with: structInst, context)
+    context.erase(instruction: self)
+  }
+}

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -108,6 +108,7 @@ private func registerSwiftPasses() {
   registerForSILCombine(DestroyValueInst.self,     { run(DestroyValueInst.self, $0) })
   registerForSILCombine(DestructureStructInst.self, { run(DestructureStructInst.self, $0) })
   registerForSILCombine(DestructureTupleInst.self, { run(DestructureTupleInst.self, $0) })
+  registerForSILCombine(TypeValueInst.self, { run(TypeValueInst.self, $0) })
 
   // Test passes
   registerPass(aliasInfoDumper, { aliasInfoDumper.run($0) })

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -718,7 +718,15 @@ class ExistentialMetatypeInst : SingleValueInstruction, UnaryInstruction {}
 
 final public class ObjCProtocolInst : SingleValueInstruction {}
 
-final public class TypeValueInst: SingleValueInstruction, UnaryInstruction {}
+final public class TypeValueInst: SingleValueInstruction, UnaryInstruction {
+  public var paramType: BridgedASTType {
+    bridged.TypeValueInst_getParamType()
+  }
+
+  public var value: Int {
+    bridged.TypeValueInst_getValue()
+  }
+}
 
 public class GlobalAccessInstruction : SingleValueInstruction {
   final public var global: GlobalVariable {

include/swift/SIL/SILBridging.h

@@ -323,6 +323,8 @@ struct BridgedASTType {
 
   BRIDGED_INLINE bool isNoEscape() const;
 
+  BRIDGED_INLINE bool isInteger() const;
+
   inline bool mayEscape() const { return !isNoEscape() && isEscapable(); }
 
   // =========================================================================//
@@ -1019,6 +1021,8 @@ struct BridgedInstruction {
   BRIDGED_INLINE bool ApplySite_isCalleeNoReturn() const;
   BRIDGED_INLINE SwiftInt FullApplySite_numIndirectResultArguments() const;
   BRIDGED_INLINE bool ConvertFunctionInst_withoutActuallyEscaping() const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedASTType TypeValueInst_getParamType() const;
+  BRIDGED_INLINE SwiftInt TypeValueInst_getValue() const;
 
   // =========================================================================//
   //                   VarDeclInst and DebugVariableInst

include/swift/SIL/SILBridgingImpl.h

@@ -161,6 +161,10 @@ bool BridgedASTType::isNoEscape() const {
   return unbridged()->isNoEscape();
 }
 
+bool BridgedASTType::isInteger() const {
+  return unbridged()->is<swift::IntegerType>();
+}
+
 BridgedResultInfoArray
 BridgedASTType::SILFunctionType_getResultsWithError() const {
   return unbridged()->castTo<swift::SILFunctionType>()->getResultsWithError();
@@ -1410,6 +1414,23 @@ bool BridgedInstruction::ConvertFunctionInst_withoutActuallyEscaping() const {
   return getAs<swift::ConvertFunctionInst>()->withoutActuallyEscaping();
 }
 
+BridgedASTType BridgedInstruction::TypeValueInst_getParamType() const {
+  return {getAs<swift::TypeValueInst>()->getParamType().getPointer()};
+}
+
+SwiftInt BridgedInstruction::TypeValueInst_getValue() const {
+  auto tvi = getAs<swift::TypeValueInst>();
+
+  // Assume we've already checked that the parameter type is an IntegerType.
+  auto integer = tvi->getParamType()->castTo<swift::IntegerType>();
+
+  if (integer->isNegative()) {
+    return integer->getValue().getSExtValue();
+  } else {
+    return integer->getValue().getZExtValue();
+  }
+}
+
 //===----------------------------------------------------------------------===//
 //                     VarDeclInst and DebugVariableInst
 //===----------------------------------------------------------------------===//

include/swift/SILOptimizer/PassManager/Passes.def

@@ -527,6 +527,7 @@ SWIFT_SILCOMBINE_PASS(CopyValueInst)
 SWIFT_SILCOMBINE_PASS(DestroyValueInst)
 SWIFT_SILCOMBINE_PASS(DestructureStructInst)
 SWIFT_SILCOMBINE_PASS(DestructureTupleInst)
+SWIFT_SILCOMBINE_PASS(TypeValueInst)
 
 #undef IRGEN_PASS
 #undef SWIFT_MODULE_PASS

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -303,7 +303,6 @@ class SILCombiner :
   SILInstruction *visitPackElementGetInst(PackElementGetInst *PEGI);
   SILInstruction *visitTuplePackElementAddrInst(TuplePackElementAddrInst *TPEAI);
   SILInstruction *visitCopyAddrInst(CopyAddrInst *CAI);
-  SILInstruction *visitTypeValueInst(TypeValueInst *TVI);
 
   SILInstruction *legacyVisitGlobalValueInst(GlobalValueInst *globalValue);
 

lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp

@@ -2237,18 +2237,3 @@ SILCombiner::visitCopyAddrInst(CopyAddrInst *CAI) {
       CAI->getLoc(), Src->getOperand(), Dst->getOperand(),
       CAI->isTakeOfSrc(), CAI->isInitializationOfDest());
 }
-
-SILInstruction *SILCombiner::visitTypeValueInst(TypeValueInst *TVI) {
-  auto integer = TVI->getParamType()->getAs<IntegerType>();
-
-  if (!integer) {
-    return nullptr;
-  }
-
-  auto fieldType = TVI->getType().getFieldType((intptr_t)0, TVI->getFunction());
-  assert(fieldType.isBuiltinInteger());
-
-  auto intLiteral = Builder.createIntegerLiteral(TVI->getLoc(), fieldType,
-                                            integer->getValue().getZExtValue());
-  return Builder.createStruct(TVI->getLoc(), TVI->getType(), {intLiteral});
-}

lib/Sema/TypeCheckType.cpp

@@ -5156,7 +5156,8 @@ NeverNullType
 TypeResolver::resolveIntegerTypeRepr(IntegerTypeRepr *repr,
                                      TypeResolutionOptions options) {
   if (!options.is(TypeResolverContext::ValueGenericArgument) &&
-      !options.is(TypeResolverContext::SameTypeRequirement)) {
+      !options.is(TypeResolverContext::SameTypeRequirement) &&
+      !options.contains(TypeResolutionFlags::SILMode)) {
     diagnoseInvalid(repr, repr->getLoc(),
                     diag::integer_type_not_accepted);
     return ErrorType::get(getASTContext());