Merge pull request #9627 from swiftix/is-same-metatype-builtin

Add a new builtin called is_same_metatype for checking the equality between metatypes

Author: swiftix

include/swift/AST/Builtins.def

@@ -393,6 +393,9 @@ BUILTIN_MISC_OPERATION(Strideof, "strideof", "n", Special)
 /// IsPOD has type T.Type -> Bool
 BUILTIN_MISC_OPERATION(IsPOD, "ispod", "n", Special)
 
+/// IsSameMetatype has type (Any.Type, Any.Type) -> Bool
+BUILTIN_MISC_OPERATION(IsSameMetatype, "is_same_metatype", "n", Special)
+
 /// Alignof has type T.Type -> Int
 BUILTIN_MISC_OPERATION(Alignof, "alignof", "n", Special)
 

lib/AST/Builtins.cpp

@@ -750,6 +750,12 @@ static ValueDecl *getIsOptionalOperation(ASTContext &Context, Identifier Id) {
   return builder.build(Id);
 }
 
+static ValueDecl *getIsSameMetatypeOperation(ASTContext &Context, Identifier Id) {
+  CanType anyMetatype = CanExistentialMetatypeType::get(Context.TheAnyType);
+  auto ResultTy = BuiltinIntegerType::get(1,Context);
+  return getBuiltinFunction(Id, {anyMetatype, anyMetatype}, ResultTy);
+}
+
 static ValueDecl *getAllocOperation(ASTContext &Context, Identifier Id) {
   Type PtrSizeTy = BuiltinIntegerType::getWordType(Context);
   Type ResultTy = Context.TheRawPointerType;
@@ -1664,6 +1670,9 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::IsOptionalType:
     return getIsOptionalOperation(Context, Id);
 
+  case BuiltinValueKind::IsSameMetatype:
+    return getIsSameMetatypeOperation(Context, Id);
+
   case BuiltinValueKind::AllocRaw:
     return getAllocOperation(Context, Id);
 

lib/IRGen/GenBuiltin.cpp

@@ -27,6 +27,7 @@
 
 #include "Explosion.h"
 #include "GenCall.h"
+#include "GenCast.h"
 #include "IRGenFunction.h"
 #include "IRGenModule.h"
 #include "LoadableTypeInfo.h"
@@ -876,6 +877,18 @@ if (Builtin.ID == BuiltinValueKind::id) { \
     return;
   }
 
+  if (Builtin.ID == BuiltinValueKind::IsSameMetatype) {
+    auto metatypeLHS = args.claimNext();
+    auto metatypeRHS = args.claimNext();
+    (void)args.claimAll();
+    llvm::Value *metatypeLHSCasted =
+        IGF.Builder.CreateBitCast(metatypeLHS, IGF.IGM.Int8PtrTy);
+    llvm::Value *metatypeRHSCasted =
+        IGF.Builder.CreateBitCast(metatypeRHS, IGF.IGM.Int8PtrTy);
+
+    out.add(IGF.Builder.CreateICmpEQ(metatypeLHSCasted, metatypeRHSCasted));
+    return;
+  }
 
   llvm_unreachable("IRGen unimplemented for this builtin!");
 }

lib/SIL/SILOwnershipVerifier.cpp

@@ -1110,6 +1110,7 @@ CONSTANT_OWNERSHIP_BUILTIN(Trivial, false, IntToFPWithOverflow)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, false, IntToPtr)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, false, IsOptionalType)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, false, IsPOD)
+CONSTANT_OWNERSHIP_BUILTIN(Trivial, false, IsSameMetatype)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, false, LShr)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, false, Mul)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, false, OnFastPath)

lib/SIL/ValueOwnershipKindClassifier.cpp

@@ -540,6 +540,7 @@ CONSTANT_OWNERSHIP_BUILTIN(Trivial, IsOptionalType)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, Sizeof)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, Strideof)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, IsPOD)
+CONSTANT_OWNERSHIP_BUILTIN(Trivial, IsSameMetatype)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, Alignof)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, AllocRaw)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, AssertConf)

stdlib/public/core/Builtin.swift

@@ -152,7 +152,12 @@ func != (lhs: Builtin.RawPointer, rhs: Builtin.RawPointer) -> Bool {
 /// `nil` or they both represent the same type.
 @_inlineable
 public func == (t0: Any.Type?, t1: Any.Type?) -> Bool {
-  return unsafeBitCast(t0, to: Int.self) == unsafeBitCast(t1, to: Int.self)
+  switch (t0, t1) {
+  case (.none, .none): return true
+  case let (.some(ty0), .some(ty1)):
+    return Bool(Builtin.is_same_metatype(ty0, ty1))
+  default: return false
+  }
 }
 
 /// Returns `false` iff `t0` is identical to `t1`; i.e. if they are both

test/IRGen/builtins.swift

@@ -745,6 +745,14 @@ func ispod_test() {
   var f = Builtin.ispod(Builtin.NativeObject)
 }
 
+// CHECK-LABEL: define {{.*}} @{{.*}}is_same_metatype
+func is_same_metatype_test(_ t1: Any.Type, _ t2: Any.Type) {
+  // CHECK: [[MT1_AS_PTR:%.*]] = bitcast %swift.type* %0 to i8*
+  // CHECK: [[MT2_AS_PTR:%.*]] = bitcast %swift.type* %1 to i8*
+  // CHECK: icmp eq i8* [[MT1_AS_PTR]], [[MT2_AS_PTR]]
+  var t = Builtin.is_same_metatype(t1, t2)
+}
+
 // CHECK-LABEL: define {{.*}} @{{.*}}generic_unsafeGuaranteed_test
 // CHECK:  call void @{{.*}}swift_{{.*}}etain({{.*}}* %0)
 // CHECK:  call void @{{.*}}swift_{{.*}}elease({{.*}}* %0)

test/SILOptimizer/compare_types.swift

@@ -0,0 +1,87 @@
+// RUN: %target-swift-frontend -O -emit-sil %s | %FileCheck %s
+
+// Check type equality related optimizations.
+
+// CHECK-LABEL: sil @{{.*}}areEqualTypes1{{.*}} : $@convention(thin)
+// CHECK: builtin "is_same_metatype"
+// CHECK: // end sil function '{{.*}}areEqualTypes1{{.*}}'
+public func areEqualTypes1<T1, T2>(_ t1: T1.Type, _ t2: T2.Type) -> Bool {
+    return t1 == t2
+}
+
+// CHECK-LABEL: sil @{{.*}}areEqualTypes2{{.*}} : $@convention(thin)
+// CHECK: builtin "is_same_metatype"
+// CHECK: // end sil function '{{.*}}areEqualTypes2{{.*}}'
+public func areEqualTypes2<T1, T2>(_ t1: T1.Type, _ t2o: T2.Type?) -> Bool {
+    return t1 == t2o
+}
+
+// CHECK-LABEL: sil @{{.*}}areEqualTypes3{{.*}} : $@convention(thin)
+// CHECK: builtin "is_same_metatype"
+// CHECK: // end sil function '{{.*}}areEqualTypes3{{.*}}'
+public func areEqualTypes3<T1, T2>(_ t1o: T1.Type?, _ t2: T2.Type) -> Bool {
+    return t1o == t2
+}
+
+// CHECK-LABEL: sil @{{.*}}areEqualTypes4{{.*}} : $@convention(thin)
+// CHECK: builtin "is_same_metatype"
+// CHECK: // end sil function '{{.*}}areEqualTypes4{{.*}}'
+public func areEqualTypes4<T1, T2>(_ t1o: T1.Type?, _ t2o: T2.Type?) -> Bool {
+    return t1o == t2o
+}
+
+// CHECK-LABEL: sil @{{.*}}areEqualTypes5{{.*}} : $@convention(thin)
+// CHECK-NOT: builtin "is_same_metatype"
+// CHECK: // end sil function '{{.*}}areEqualTypes5{{.*}}'
+public func areEqualTypes5<T1>(_ t1o: T1.Type?) -> Bool {
+    return t1o == nil
+}
+
+// CHECK-LABEL: sil @{{.*}}areEqualTypes6{{.*}} : $@convention(thin)
+// CHECK-NOT: builtin "is_same_metatype"
+// CHECK: // end sil function '{{.*}}areEqualTypes6{{.*}}'
+public func areEqualTypes6<T1>(_ t1o: T1.Type?) -> Bool {
+    return nil == t1o
+}
+
+// CHECK-LABEL: sil @{{.*}}areNotEqualTypes1{{.*}} : $@convention(thin)
+// CHECK: builtin "is_same_metatype"
+// CHECK: // end sil function '{{.*}}areNotEqualTypes1{{.*}}'
+public func areNotEqualTypes1<T1, T2>(_ t1: T1.Type, _ t2: T2.Type) -> Bool {
+    return t1 != t2
+}
+
+// CHECK-LABEL: sil @{{.*}}areNotEqualTypes2{{.*}} : $@convention(thin)
+// CHECK: builtin "is_same_metatype"
+// CHECK: // end sil function '{{.*}}areNotEqualTypes2{{.*}}'
+public func areNotEqualTypes2<T1, T2>(_ t1: T1.Type, _ t2o: T2.Type?) -> Bool {
+    return t1 != t2o
+}
+
+// CHECK-LABEL: sil @{{.*}}areNotEqualTypes3{{.*}} : $@convention(thin)
+// CHECK: builtin "is_same_metatype"
+// CHECK: // end sil function '{{.*}}areNotEqualTypes3{{.*}}'
+public func areNotEqualTypes3<T1, T2>(_ t1o: T1.Type?, _ t2: T2.Type) -> Bool {
+    return t1o != t2
+}
+
+// CHECK-LABEL: sil @{{.*}}areNotEqualTypes4{{.*}} : $@convention(thin)
+// CHECK: builtin "is_same_metatype"
+// CHECK: // end sil function '{{.*}}areNotEqualTypes4{{.*}}'
+public func areNotEqualTypes4<T1, T2>(_ t1o: T1.Type?, _ t2o: T2.Type?) -> Bool {
+    return t1o != t2o
+}
+
+// CHECK-LABEL: sil @{{.*}}areNotEqualTypes5{{.*}} : $@convention(thin)
+// CHECK-NOT: builtin "is_same_metatype"
+// CHECK: // end sil function '{{.*}}areNotEqualTypes5{{.*}}'
+public func areNotEqualTypes5<T1>(_ t1o: T1.Type?) -> Bool {
+    return t1o != nil
+}
+
+// CHECK-LABEL: sil @{{.*}}areNotEqualTypes6{{.*}} : $@convention(thin)
+// CHECK-NOT: builtin "is_same_metatype"
+// CHECK: // end sil function '{{.*}}areNotEqualTypes6{{.*}}'
+public func areNotEqualTypes6<T1>(_ t1o: T1.Type?) -> Bool {
+    return nil != t1o
+}