Add Builtin.assumeAlignment(RawPointer, Int64)

Author: atrick

include/swift/AST/Builtins.def

@@ -820,6 +820,24 @@ BUILTIN_MISC_OPERATION(Move, "move", "", Special)
 /// the SILVerifier.
 BUILTIN_MISC_OPERATION(Copy, "copy", "", Special)
 
+/// Unchecked pointer alignment assertion. Allows the compiler to assume
+/// alignment of the pointer to emit more efficient code.
+///
+///   %alignedPtr = builtin "assumeAlignment" (%ptr : $Builtin.RawPointer,
+///                                            %alignment : $Builtin.Int)
+///                                           : $Builtin.RawPointer
+///   %address = pointer_to_address %alignedPtr
+///              : $Builtin.RawPointer to [align=1] $*Int
+///   %val = load %address : $*Int
+///
+/// With compile-time knowledge of the value of `%alignment` the compiler can
+/// optimize any downstream 'pointer_to_address' instruction by refining its
+/// '[align=]' flag . That `[align=]` flag can be used by IRGen to refine the
+/// alignment on LLVM load instructions that use the resulting address.
+///
+/// (Builtin.RawPointer, Builtin.Word) -> Builtin.RawPointer
+BUILTIN_MISC_OPERATION(AssumeAlignment, "assumeAlignment", "n", Special)
+
 // BUILTIN_MISC_OPERATION_WITH_SILGEN - Miscellaneous operations that are
 // specially emitted during SIL generation.
 //

include/swift/SIL/SILCloner.h

@@ -1430,11 +1430,11 @@ template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitPointerToAddressInst(PointerToAddressInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
-  recordClonedInstruction(Inst, getBuilder().createPointerToAddress(
-                                    getOpLocation(Inst->getLoc()),
-                                    getOpValue(Inst->getOperand()),
-                                    getOpType(Inst->getType()),
-                                    Inst->isStrict(), Inst->isInvariant()));
+  recordClonedInstruction(
+      Inst, getBuilder().createPointerToAddress(
+                getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand()),
+                getOpType(Inst->getType()), Inst->isStrict(),
+                Inst->isInvariant(), Inst->alignment()));
 }
 
 template<typename ImplClass>

lib/AST/Builtins.cpp

@@ -861,6 +861,12 @@ static ValueDecl *getCopyOperation(ASTContext &ctx, Identifier id) {
                             _parameters(_typeparam(0)), _typeparam(0));
 }
 
+static ValueDecl *getAssumeAlignment(ASTContext &ctx, Identifier id) {
+  // This is always "(Builtin.RawPointer, Builtin.Word) -> Builtin.RawPointer"
+  return getBuiltinFunction(ctx, id, _thin, _parameters(_rawPointer, _word),
+                            _rawPointer);
+}
+
 static ValueDecl *getTransferArrayOperation(ASTContext &ctx, Identifier id) {
   return getBuiltinFunction(ctx, id, _thin,
                             _generics(_unrestricted),
@@ -2552,6 +2558,11 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
       return nullptr;
     return getCopyOperation(Context, Id);
 
+  case BuiltinValueKind::AssumeAlignment:
+    if (!Types.empty())
+      return nullptr;
+    return getAssumeAlignment(Context, Id);
+
 #define BUILTIN(id, name, Attrs)
 #define BUILTIN_BINARY_OPERATION(id, name, attrs)
 #define BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC(id, name, attrs, overload)  \

lib/IRGen/GenBuiltin.cpp

@@ -1338,6 +1338,18 @@ if (Builtin.ID == BuiltinValueKind::id) { \
     addrTI.initializeWithCopy(IGF, resultAttr, inputAttr, addrTy, false);
     return;
   }
+  if (Builtin.ID == BuiltinValueKind::AssumeAlignment) {
+    // A no-op pointer cast that passes on its first value. Common occurences of
+    // this builtin should already be removed with the alignment guarantee moved
+    // to the subsequent load or store.
+    //
+    // TODO: Consider lowering to an LLVM intrinsic if there is any benefit:
+    // 'call void @llvm.assume(i1 true) ["align"(i32* %arg0, i32 %arg1)]'
+    auto pointerSrc = args.claimNext();
+    (void)args.claimAll();
+    out.add(pointerSrc);
+    return;
+  }
 
   llvm_unreachable("IRGen unimplemented for this builtin!");
 }

lib/IRGen/LoadableByAddress.cpp

@@ -2113,7 +2113,7 @@ static void rewriteFunction(StructLoweringState &pass,
                                             currSILType);
     auto *newInstr = pointerBuilder.createPointerToAddress(
         instr->getLoc(), instr->getOperand(), newSILType.getAddressType(),
-        instr->isStrict());
+        instr->isStrict(), instr->isInvariant(), instr->alignment());
     instr->replaceAllUsesWith(newInstr);
     instr->getParent()->erase(instr);
   }

lib/SIL/IR/OperandOwnership.cpp

@@ -647,6 +647,7 @@ BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, AssignCopyArrayNoAlias)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, AssignCopyArrayFrontToBack)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, AssignCopyArrayBackToFront)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, AssignTakeArray)
+BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, AssumeAlignment)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, AssumeNonNegative)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, AssumeTrue)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, AtomicLoad)

lib/SIL/IR/ValueOwnership.cpp

@@ -393,6 +393,7 @@ CONSTANT_OWNERSHIP_BUILTIN(None, Add)
 CONSTANT_OWNERSHIP_BUILTIN(None, GenericAdd)
 CONSTANT_OWNERSHIP_BUILTIN(None, And)
 CONSTANT_OWNERSHIP_BUILTIN(None, GenericAnd)
+CONSTANT_OWNERSHIP_BUILTIN(None, AssumeAlignment)
 CONSTANT_OWNERSHIP_BUILTIN(None, AssumeNonNegative)
 CONSTANT_OWNERSHIP_BUILTIN(None, AssumeTrue)
 CONSTANT_OWNERSHIP_BUILTIN(None, BitCast)

lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -151,6 +151,7 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::DestroyTaskGroup:
     case BuiltinValueKind::StackAlloc:
     case BuiltinValueKind::StackDealloc:
+    case BuiltinValueKind::AssumeAlignment:
       return false;
 
     // Handle some rare builtins that may be sensitive to object lifetime

test/SILGen/builtins.swift

@@ -886,3 +886,10 @@ func valueToBridgeObject(_ x: UInt) -> Builtin.BridgeObject {
 func assumeTrue(_ x: Builtin.Int1) {
   Builtin.assume_Int1(x)
 }
+
+// CHECK: sil hidden [ossa] @$s8builtins15assumeAlignmentyyBp_BwtF : $@convention(thin) (Builtin.RawPointer, Builtin.Word) -> () {  
+// CHECK: builtin "assumeAlignment"(%{{.*}} : $Builtin.RawPointer, %{{.*}} : $Builtin.Word) : $Builtin.RawPointer
+// CHECK: return
+func assumeAlignment(_ p: Builtin.RawPointer, _ x: Builtin.Word) {
+  Builtin.assumeAlignment(p, x)
+}