Get rid of sil instruction and use a builtin for addressOfRawLayout

Author: Azoy

include/swift/AST/Builtins.def

@@ -1112,7 +1112,7 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(DistributedActorAsAnyActor, "distributedActor
 /// Returns a raw pointer to the address of the raw layout type. This address is
 /// only valid during a borrow access of the raw layout type or until the value
 /// is either moved or consumed.
-BUILTIN_SIL_OPERATION(AddressOfRawLayout, "addressOfRawLayout", Special)
+BUILTIN_MISC_OPERATION_WITH_SILGEN(AddressOfRawLayout, "addressOfRawLayout", "n", Special)
 
 /// Builtins for instrumentation added by sanitizers during SILGen.
 #ifndef BUILTIN_SANITIZER_OPERATION

include/swift/SIL/AddressWalker.h

@@ -276,6 +276,7 @@ TransitiveAddressWalker<Impl>::walk(SILValue projectedAddress) && {
         case BuiltinValueKind::ZeroInitializer:
         case BuiltinValueKind::GetEnumTag:
         case BuiltinValueKind::InjectEnumTag:
+        case BuiltinValueKind::AddressOfRawLayout:
           callVisitUse(op);
           continue;
         default:

lib/IRGen/GenBuiltin.cpp

@@ -1477,5 +1477,12 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
+  if (Builtin.ID == BuiltinValueKind::AddressOfRawLayout) {
+    auto addr = args.claimNext();
+    auto value = IGF.Builder.CreateBitCast(addr, IGF.IGM.Int8PtrTy);
+    out.add(value);
+    return;
+  }
+
   llvm_unreachable("IRGen unimplemented for this builtin!");
 }

lib/SIL/IR/OperandOwnership.cpp

@@ -892,6 +892,7 @@ BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, TargetOSVersionAtLeast)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, GetEnumTag)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, InjectEnumTag)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, DistributedActorAsAnyActor)
+BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, AddressOfRawLayout)
 OperandOwnership OperandOwnershipBuiltinClassifier::visitCopy(BuiltinInst *bi,
                                                               StringRef) {
   if (bi->getFunction()->getConventions().useLoweredAddresses()) {

lib/SIL/IR/ValueOwnership.cpp

@@ -620,6 +620,7 @@ CONSTANT_OWNERSHIP_BUILTIN(None, GetEnumTag)
 CONSTANT_OWNERSHIP_BUILTIN(None, InjectEnumTag)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, DistributedActorAsAnyActor)
 CONSTANT_OWNERSHIP_BUILTIN(Guaranteed, ExtractFunctionIsolation) // unreachable
+CONSTANT_OWNERSHIP_BUILTIN(None, AddressOfRawLayout)
 
 #undef CONSTANT_OWNERSHIP_BUILTIN
 

lib/SIL/Utils/MemAccessUtils.cpp

@@ -2667,6 +2667,7 @@ static void visitBuiltinAddress(BuiltinInst *builtin,
     // These builtins take a generic 'T' as their operand.
     case BuiltinValueKind::GetEnumTag:
     case BuiltinValueKind::InjectEnumTag:
+    case BuiltinValueKind::AddressOfRawLayout:
       visitor(&builtin->getAllOperands()[0]);
       return;
 

lib/SIL/Verifier/SILVerifier.cpp

@@ -600,6 +600,12 @@ struct ImmutableAddressUseVerifier {
           if (builtinKind == BuiltinValueKind::GetEnumTag) {
             return false;
           }
+
+          // The optimizer cannot reason about a raw layout type's address due
+          // to it not respecting formal access scopes.
+          if (builtinKind == BuiltinValueKind::AddressOfRawLayout) {
+            return false;
+          }
         }
 
         // Otherwise this is a builtin that we are not expecting to see, so bail

lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -159,6 +159,7 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::GetEnumTag:
     case BuiltinValueKind::InjectEnumTag:
     case BuiltinValueKind::ExtractFunctionIsolation:
+    case BuiltinValueKind::AddressOfRawLayout:
       return false;
 
     // Handle some rare builtins that may be sensitive to object lifetime

test/IRGen/raw_layout.swift

@@ -160,12 +160,12 @@ entry(%K: $*Keymaster):
     return undef : $()
 }
 
-// CHECK: define swiftcc ptr @get_cell_addr(ptr %"Cell<T>", ptr {{.*}} swiftself [[SELF:%.*]])
+// CHECK: define {{.*}}swiftcc ptr @get_cell_addr(ptr %"Cell<T>", ptr {{.*}} swiftself [[SELF:%.*]])
 // CHECK-NEXT:   entry:
 // CHECK-NEXT:     ret ptr [[SELF]]
 sil @get_cell_addr : $@convention(method) <T> (@in_guaranteed Cell<T>) -> UnsafeMutablePointer<T> {
 entry(%0 : $*Cell<T>):
-    %1 = raw_layout_address_to_pointer %0 : $*Cell<T> to $Builtin.RawPointer
+    %1 = builtin "addressOfRawLayout"(%0 : $*Cell<T>) : $Builtin.RawPointer
     %2 = struct $UnsafeMutablePointer<T> (%1 : $Builtin.RawPointer)
     return %2 : $UnsafeMutablePointer<T>
 }

test/SILGen/raw_layout.swift

@@ -26,7 +26,7 @@ struct Lock: ~Copyable {
 @_rawLayout(like: T)
 struct Cell<T>: ~Copyable {
     // CHECK-LABEL: sil {{.*}} @$s10raw_layout4CellV7addressSpyxGvg : $@convention(method) <T> (@in_guaranteed Cell<T>) -> UnsafeMutablePointer<T> {
-    // CHECK:         [[RAW_LAYOUT_ADDR:%.*]] = raw_layout_address_to_pointer {{%.*}} : $*Cell<T> to $Builtin.RawPointer
+    // CHECK:         {{%.*}} = builtin "addressOfRawLayout"<Cell<T>>({{%.*}} : $*Cell<T>) : $Builtin.RawPointer
     // CHECK-LABEL: } // end sil function '$s10raw_layout4CellV7addressSpyxGvg'
     var address: UnsafeMutablePointer<T> {
         .init(Builtin.addressOfRawLayout(self))

test/SILOptimizer/stdlib/Cell.swift

@@ -7,7 +7,7 @@ import Builtin
 public struct Cell<T: ~Copyable>: ~Copyable {
   // CHECK-LABEL: sil {{.*}} @$s4CellAAVAARiczrlE7addressSpyxGvg : $@convention(method) <T where T : ~Copyable> (@in_guaranteed Cell<T>) -> UnsafeMutablePointer<T> {
   // CHECK:       bb0([[SELF:%.*]] : $*Cell<T>):
-  // CHECK:         [[RAW_LAYOUT_ADDR:%.*]] = raw_layout_address_to_pointer [[SELF]] : $*Cell<T> to $Builtin.RawPointer
+  // CHECK:         [[RAW_LAYOUT_ADDR:%.*]] = builtin "addressOfRawLayout"<Cell<T>>([[SELF]] : $*Cell<T>) : $Builtin.RawPointer
   // CHECK-NEXT:    [[POINTER:%.*]] = struct $UnsafeMutablePointer<T> ([[RAW_LAYOUT_ADDR]] : $Builtin.RawPointer)
   // CHECK-NEXT:    return [[POINTER]] : $UnsafeMutablePointer<T>
   // CHECK-LABEL: } // end sil function '$s4CellAAVAARiczrlE7addressSpyxGvg'
@@ -17,9 +17,9 @@ public struct Cell<T: ~Copyable>: ~Copyable {
   }
 
   // CHECK-LABEL: sil {{.*}} @$s4CellAAVAARiczrlEyAByxGxcfC : $@convention(method) <T where T : ~Copyable> (@in T, @thin Cell<T>.Type) -> @out Cell<T> {
-  // CHECK:       bb0([[SELF:%.*]] : $*Cell<T>, [[VALUE:%.*]] : $*T, {{%.*}} : $@thin Cell<T>.Type):
-  // CHECK-NEXT:    {{%.*}} = builtin "zeroInitializer"<Cell<T>>([[SELF]] : $*Cell<T>) : $()
-  // CHECK-NEXT:    [[RAW_LAYOUT_ADDR:%.*]] = raw_layout_address_to_pointer [[SELF]] : $*Cell<T> to $Builtin.RawPointer
+  // CHECK:       bb0({{%.*}} : $*Cell<T>, [[VALUE:%.*]] : $*T, {{%.*}} : $@thin Cell<T>.Type):
+  // CHECK:         {{%.*}} = builtin "zeroInitializer"<Cell<T>>([[SELF:%.*]] : $*Cell<T>) : $()
+  // CHECK-NEXT:    [[RAW_LAYOUT_ADDR:%.*]] = builtin "addressOfRawLayout"<Cell<T>>([[SELF]] : $*Cell<T>) : $Builtin.RawPointer
   // CHECK-NEXT:    [[POINTER:%.*]] = struct $UnsafeMutablePointer<T> ([[RAW_LAYOUT_ADDR]] : $Builtin.RawPointer)
   //                Calling 'UnsafeMutablePointer<T>.initialize(to:)'
   // CHECK:         {{%.*}} = apply {{%.*}}<T>([[VALUE]], [[POINTER]])