Builtins: add StringObjectOr and use it in the standard library

Author: Joe Shajrawi

include/swift/AST/Builtins.def

@@ -448,6 +448,8 @@ BUILTIN_MISC_OPERATION(StaticReport, "staticReport", "", Special)
 /// Returns the selected assertion configuration.
 BUILTIN_MISC_OPERATION(AssertConf, "assert_configuration", "n", Special)
 
+/// StringObjectOr has type (T,T) -> T.
+BUILTIN_MISC_OPERATION(StringObjectOr,     "stringObjectOr",      "n", Integer)
 
 /// Special truncation builtins that check for sign and overflow errors. These
 /// take an integer as an input and return a tuple of the truncated result and

lib/AST/Builtins.cpp

@@ -265,6 +265,10 @@ static ValueDecl *getGepRawOperation(Identifier Id, Type ArgType) {
   return getBuiltinFunction(Id, ArgElts, ResultTy);
 }
 
+static ValueDecl *getStringObjectOrOperation(Identifier Id, Type ArgType) {
+  return getBuiltinFunction(Id, {ArgType, ArgType}, ArgType);
+}
+
 /// Build a binary operation declaration.
 static ValueDecl *getBinaryOperation(Identifier Id, Type ArgType) {
   return getBuiltinFunction(Id, { ArgType, ArgType }, ArgType);
@@ -1628,6 +1632,11 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
     if (Types.size() != 1) return nullptr;
     return getGepRawOperation(Id, Types[0]);
 
+  case BuiltinValueKind::StringObjectOr:
+    if (Types.size() != 1)
+      return nullptr;
+    return getStringObjectOrOperation(Id, Types[0]);
+
   case BuiltinValueKind::Gep:
     if (Types.size() != 1) return nullptr;
     return getGepOperation(Context, Id, Types[0]);

lib/IRGen/GenBuiltin.cpp

@@ -252,7 +252,14 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
-  // TODO: A linear series of ifs is suboptimal.
+  if (Builtin.ID == BuiltinValueKind::StringObjectOr) {
+    llvm::Value *lhs = args.claimNext();
+    llvm::Value *rhs = args.claimNext();
+    llvm::Value *v = IGF.Builder.CreateOr(lhs, rhs);
+    return out.add(v);
+  }
+
+    // TODO: A linear series of ifs is suboptimal.
 #define BUILTIN_SIL_OPERATION(id, name, overload) \
   if (Builtin.ID == BuiltinValueKind::id) \
     llvm_unreachable(name " builtin should be lowered away by SILGen!");

lib/SIL/SILOwnershipVerifier.cpp

@@ -1354,6 +1354,7 @@ CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, Shl)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, Sizeof)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, StaticReport)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, Strideof)
+CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, StringObjectOr)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, Sub)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, TakeArrayNoAlias)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, TakeArrayBackToFront)

lib/SIL/ValueOwnershipKindClassifier.cpp

@@ -467,6 +467,7 @@ CONSTANT_OWNERSHIP_BUILTIN(Trivial, ProjectTailElems)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, IsOptionalType)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, Sizeof)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, Strideof)
+CONSTANT_OWNERSHIP_BUILTIN(Trivial, StringObjectOr)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, IsPOD)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, IsSameMetatype)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, Alignof)

stdlib/public/core/StringObject.swift

@@ -261,7 +261,8 @@ extension _StringObject {
   internal
   static var _variantMask: UInt {
     @inline(__always)
-    get { return _isValueBit | _subVariantBit }
+    get { return UInt(Builtin.stringObjectOr_Int64(
+      _isValueBit._value, _subVariantBit._value)) }
   }
 
   @_versioned
@@ -364,7 +365,8 @@ extension _StringObject {
   internal
   static var _emptyStringBitPattern: UInt {
     @inline(__always)
-    get { return _isValueBit | _emptyStringAddressBits }
+    get { return UInt(Builtin.stringObjectOr_Int64(
+      _isValueBit._value, _emptyStringAddressBits._value)) }
   }
 
   @_versioned
@@ -784,20 +786,32 @@ extension _StringObject {
     _sanityCheck(_payloadBits & ~_StringObject._payloadMask == 0)
     var rawBits = _payloadBits & _StringObject._payloadMask
     if isValue {
-      rawBits |= _StringObject._isValueBit
-    }
-    if isSmallOrObjC {
-      rawBits |= _StringObject._subVariantBit
-    }
-    if isOpaque {
-      rawBits |= _StringObject._isOpaqueBit
-    }
-    if isTwoByte {
-      rawBits |= _StringObject._twoByteBit
-    }
-    if isValue {
+      var rawBitsBuiltin = Builtin.stringObjectOr_Int64(
+        rawBits._value, _StringObject._isValueBit._value)
+      if isSmallOrObjC {
+        rawBitsBuiltin = Builtin.stringObjectOr_Int64(
+          rawBitsBuiltin, _StringObject._subVariantBit._value)
+      }
+      if isOpaque {
+        rawBitsBuiltin = Builtin.stringObjectOr_Int64(
+          rawBitsBuiltin, _StringObject._isOpaqueBit._value)
+      }
+      if isTwoByte {
+        rawBitsBuiltin = Builtin.stringObjectOr_Int64(
+          rawBitsBuiltin, _StringObject._twoByteBit._value)
+      }
+      rawBits = UInt(rawBitsBuiltin)
       self.init(taggedRawBits: rawBits)
     } else {
+      if isSmallOrObjC {
+        rawBits |= _StringObject._subVariantBit
+      }
+      if isOpaque {
+        rawBits |= _StringObject._isOpaqueBit
+      }
+      if isTwoByte {
+        rawBits |= _StringObject._twoByteBit
+      }
       self.init(nonTaggedRawBits: rawBits)
     }
 #endif

test/IRGen/builtins.swift

@@ -840,6 +840,15 @@ func atomicload(_ p: Builtin.RawPointer) {
   Builtin.atomicstore_seqcst_volatile_FPIEEE32(p, d)
 }
 
+// CHECK-LABEL: define {{.*}} @"$S8builtins14stringObjectOryS2u_SutF"(i64, i64)
+// CHECK-NEXT: {{.*}}:
+// CHECK-NEXT: %2 = or i64 %0, %1
+// CHECK-NEXT: ret i64 %2
+func stringObjectOr(_ x: UInt, _ y: UInt) -> UInt {
+  return UInt(Builtin.stringObjectOr_Int64(
+  x._value, y._value))
+}
+
 func createInt(_ fn: () -> ()) throws {}
 // CHECK-LABEL: define {{.*}}testForceTry
 // CHECK: call swiftcc void @swift_unexpectedError(%swift.error*