Merge pull request swiftlang#39272 from atrick/unaligned-loadstore

swift-ci · web-flow · commit 155def25e8d7 · 2021-09-13T13:29:46.000-07:00
diff --git a/docs/SIL.rst b/docs/SIL.rst
@@ -6194,7 +6194,8 @@ pointer_to_address
 ``````````````````
 ::
 
-  sil-instruction ::= 'pointer_to_address' sil-operand 'to' ('[' 'strict' ']')? sil-type
+  sil-instruction ::= 'pointer_to_address' sil-operand 'to' ('[' 'strict' ']')? ('[' 'invariant' ']')? ('[' 'alignment' '=' alignment ']')? sil-type
+  alignment ::= [0-9]+
 
   %1 = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*T
   // %1 will be of type $*T
@@ -6214,6 +6215,12 @@ type. A memory access from an address that is not strict cannot have
 its address substituted with a strict address, even if other nearby
 memory accesses at the same location are strict.
 
+The ``invariant`` flag is set if loading from the returned address
+always produces the same value.
+
+The ``alignment`` integer value specifies the byte alignment of the
+address. ``alignment=0`` is the default, indicating the natural
+alignment of ``T``.
 
 unchecked_ref_cast
 ``````````````````
diff --git a/include/swift/SIL/SILBuilder.h b/include/swift/SIL/SILBuilder.h
@@ -1064,12 +1064,12 @@ class SILBuilder {
         getSILDebugLocation(Loc), Op, Ty));
   }
 
-  PointerToAddressInst *createPointerToAddress(SILLocation Loc, SILValue Op,
-                                               SILType Ty,
-                                               bool isStrict,
-                                               bool isInvariant = false){
+  PointerToAddressInst *
+  createPointerToAddress(SILLocation Loc, SILValue Op, SILType Ty,
+                         bool isStrict, bool isInvariant = false,
+                         llvm::MaybeAlign alignment = llvm::MaybeAlign()) {
     return insert(new (getModule()) PointerToAddressInst(
-                    getSILDebugLocation(Loc), Op, Ty, isStrict, isInvariant));
+        getSILDebugLocation(Loc), Op, Ty, isStrict, isInvariant, alignment));
   }
 
   UncheckedRefCastInst *createUncheckedRefCast(SILLocation Loc, SILValue Op,
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -5127,10 +5127,15 @@ class PointerToAddressInst
   friend SILBuilder;
 
   PointerToAddressInst(SILDebugLocation DebugLoc, SILValue Operand, SILType Ty,
-                       bool IsStrict, bool IsInvariant)
-    : UnaryInstructionBase(DebugLoc, Operand, Ty) {
+                       bool IsStrict, bool IsInvariant,
+                       llvm::MaybeAlign Alignment)
+      : UnaryInstructionBase(DebugLoc, Operand, Ty) {
     SILNode::Bits.PointerToAddressInst.IsStrict = IsStrict;
     SILNode::Bits.PointerToAddressInst.IsInvariant = IsInvariant;
+    unsigned encodedAlignment = llvm::encode(Alignment);
+    SILNode::Bits.PointerToAddressInst.Alignment = encodedAlignment;
+    assert(SILNode::Bits.PointerToAddressInst.Alignment == encodedAlignment
+           && "pointer_to_address alignment overflow");
   }
 
 public:
@@ -5146,6 +5151,13 @@ class PointerToAddressInst
   bool isInvariant() const {
     return SILNode::Bits.PointerToAddressInst.IsInvariant;
   }
+
+  /// The byte alignment of the address. Since the alignment of types isn't
+  /// known until IRGen (TypeInfo::getBestKnownAlignment), in SIL an unknown
+  /// alignment indicates the natural in-memory alignment of the element type.
+  llvm::MaybeAlign alignment() const {
+    return llvm::decodeMaybeAlign(SILNode::Bits.PointerToAddressInst.Alignment);
+  }
 };
 
 /// Convert a heap object reference to a different type without any runtime
diff --git a/include/swift/SIL/SILNode.h b/include/swift/SIL/SILNode.h
@@ -368,10 +368,8 @@ class alignas(8) SILNode :
   UIWTDOB_BITFIELD_EMPTY(ObjCMethodInst, MethodInst);
 
   SWIFT_INLINE_BITFIELD_EMPTY(ConversionInst, SingleValueInstruction);
-  SWIFT_INLINE_BITFIELD(PointerToAddressInst, ConversionInst, 1+1,
-    IsStrict : 1,
-    IsInvariant : 1
-  );
+  SWIFT_INLINE_BITFIELD(PointerToAddressInst, ConversionInst, 8 + 1 + 1,
+                        Alignment : 8, IsStrict : 1, IsInvariant : 1);
 
   UIWTDOB_BITFIELD(ConvertFunctionInst, ConversionInst, 1,
                    WithoutActuallyEscaping : 1);
diff --git a/lib/IRGen/IRGenSIL.cpp b/lib/IRGen/IRGenSIL.cpp
@@ -5632,9 +5632,11 @@ void IRGenSILFunction::visitPointerToAddressInst(swift::PointerToAddressInst *i)
   
   llvm::Type *destType = ti.getStorageType()->getPointerTo();
   ptrValue = Builder.CreateBitCast(ptrValue, destType);
-  
-  setLoweredAddress(i,
-                    ti.getAddressForPointer(ptrValue));
+
+  if (i->alignment())
+    setLoweredAddress(i, Address(ptrValue, Alignment(i->alignment()->value())));
+  else
+    setLoweredAddress(i, ti.getAddressForPointer(ptrValue));
 }
 
 static void emitPointerCastInst(IRGenSILFunction &IGF,
diff --git a/lib/SIL/IR/SILPrinter.cpp b/lib/SIL/IR/SILPrinter.cpp
@@ -1751,6 +1751,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
       *this << "[strict] ";
     if (CI->isInvariant())
       *this << "[invariant] ";
+    if (CI->alignment())
+      *this << "[align=" << CI->alignment()->value() << "] ";
     *this << CI->getType();
   }
   void visitUncheckedRefCastInst(UncheckedRefCastInst *CI) {
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -802,15 +802,35 @@ static SILLinkage resolveSILLinkage(Optional<SILLinkage> linkage,
   }
 }
 
-static bool parseSILOptional(StringRef &Result, SourceLoc &Loc, SILParser &SP) {
-  if (SP.P.consumeIf(tok::l_square)) {
-    Identifier Id;
-    SP.parseSILIdentifier(Id, Loc, diag::expected_in_attribute_list);
-    SP.P.parseToken(tok::r_square, diag::expected_in_attribute_list);
-    Result = Id.str();
+// Returns false if no optional exists. Returns true on both success and
+// failure. On success, the Result string is nonempty. If the optional is
+// assigned to an integer value, \p value contains the parsed value. Otherwise,
+// value is set to the maximum uint64_t.
+static bool parseSILOptional(StringRef &Result, uint64_t &value, SourceLoc &Loc,
+                             SILParser &SP) {
+  if (!SP.P.consumeIf(tok::l_square))
+    return false;
+
+  value = ~uint64_t(0);
+
+  Identifier Id;
+  if (SP.parseSILIdentifier(Id, Loc, diag::expected_in_attribute_list))
     return true;
+
+  if (SP.P.consumeIf(tok::equal)) {
+    if (SP.parseInteger(value, diag::expected_in_attribute_list))
+      return true;
   }
-  return false;
+  if (SP.P.parseToken(tok::r_square, diag::expected_in_attribute_list))
+    return true;
+
+  Result = Id.str();
+  return true;
+}
+
+static bool parseSILOptional(StringRef &Result, SourceLoc &Loc, SILParser &SP) {
+  uint64_t value;
+  return parseSILOptional(Result, value, Loc, SP);
 }
 
 static bool parseSILOptional(StringRef &Result, SILParser &SP) {
@@ -3603,21 +3623,35 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
         parseSILIdentifier(ToToken, ToLoc, diag::expected_tok_in_sil_instr,
                            "to"))
       return true;
-    if (parseSILOptional(attr, *this) && attr.empty())
-      return true;
+
+    bool isStrict = false;
+    bool isInvariant = false;
+    llvm::MaybeAlign alignment;
+    uint64_t parsedValue = 0;
+    while (parseSILOptional(attr, parsedValue, ToLoc, *this)) {
+      if (attr.empty())
+        return true;
+
+      if (attr.equals("strict"))
+        isStrict = true;
+
+      if (attr.equals("invariant"))
+        isInvariant = true;
+
+      if (attr.equals("align"))
+        alignment = llvm::Align(parsedValue);
+    }
+
     if (parseSILType(Ty) || parseSILDebugLocation(InstLoc, B))
       return true;
 
-    bool isStrict = attr.equals("strict");
-    bool isInvariant = attr.equals("invariant");
-
     if (ToToken.str() != "to") {
       P.diagnose(ToLoc, diag::expected_tok_in_sil_instr, "to");
       return true;
     }
 
-    ResultVal =
-        B.createPointerToAddress(InstLoc, Val, Ty, isStrict, isInvariant);
+    ResultVal = B.createPointerToAddress(InstLoc, Val, Ty, isStrict,
+                                         isInvariant, alignment);
     break;
   }
   case SILInstructionKind::RefToBridgeObjectInst: {
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
@@ -1104,6 +1104,12 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
                                            TyID2, TyCategory2,
                                            ValID);
     break;
+  case SIL_ONE_TYPE_ONE_OPERAND_EXTRA_ATTR:
+    SILOneTypeOneOperandExtraAttributeLayout::readRecord(scratch, RawOpCode,
+                                                         Attr, TyID, TyCategory,
+                                                         TyID2, TyCategory2,
+                                                         ValID);
+    break;
   case SIL_INIT_EXISTENTIAL:
     SILInitExistentialLayout::readRecord(scratch, RawOpCode,
                                          TyID, TyCategory,
@@ -1358,16 +1364,17 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
     break;
   }
   case SILInstructionKind::PointerToAddressInst: {
-    assert(RecordKind == SIL_ONE_TYPE_ONE_OPERAND &&
+    assert(RecordKind == SIL_ONE_TYPE_ONE_OPERAND_EXTRA_ATTR &&
            "Layout should be OneTypeOneOperand.");
-    bool isStrict = Attr & 0x01;
-    bool isInvariant = Attr & 0x02;
+    auto alignment = llvm::decodeMaybeAlign(Attr & 0xFF);
+    bool isStrict = Attr & 0x100;
+    bool isInvariant = Attr & 0x200;
     ResultInst = Builder.createPointerToAddress(
         Loc,
         getLocalValue(ValID, getSILType(MF->getType(TyID2),
                                         (SILValueCategory)TyCategory2, Fn)),
         getSILType(MF->getType(TyID), (SILValueCategory)TyCategory, Fn),
-        isStrict, isInvariant);
+        isStrict, isInvariant, alignment);
     break;
   }
   case SILInstructionKind::DeallocExistentialBoxInst: {
diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h
@@ -56,7 +56,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 627; // move_value inst
+const uint16_t SWIFTMODULE_VERSION_MINOR = 628; // unaligned pointer
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
diff --git a/lib/Serialization/SILFormat.h b/lib/Serialization/SILFormat.h
@@ -149,6 +149,7 @@ namespace sil_block {
     SIL_SPECIALIZE_ATTR,
     SIL_PROPERTY,
     SIL_ONE_OPERAND_EXTRA_ATTR,
+    SIL_ONE_TYPE_ONE_OPERAND_EXTRA_ATTR,
     SIL_TWO_OPERANDS_EXTRA_ATTR,
     SIL_INST_DIFFERENTIABLE_FUNCTION,
     SIL_INST_LINEAR_FUNCTION,
@@ -333,7 +334,7 @@ namespace sil_block {
   using SILOneTypeOneOperandLayout = BCRecordLayout<
     SIL_ONE_TYPE_ONE_OPERAND,
     SILInstOpCodeField,
-    BCFixed<2>,          // Optional attributes
+    BCFixed<1>,          // Optional attribute
     TypeIDField,
     SILTypeCategoryField,
     TypeIDField,
@@ -419,6 +420,13 @@ namespace sil_block {
     TypeIDField, SILTypeCategoryField, ValueIDField
   >;
 
+  // SIL instructions with one type, one typed valueref, and extra bits.
+  using SILOneTypeOneOperandExtraAttributeLayout =
+      BCRecordLayout<SIL_ONE_TYPE_ONE_OPERAND_EXTRA_ATTR, SILInstOpCodeField,
+                     BCFixed<10>, // Optional attributes
+                     TypeIDField, SILTypeCategoryField, TypeIDField,
+                     SILTypeCategoryField, ValueIDField>;
+
   // SIL instructions with two typed values.
   using SILTwoOperandsLayout = BCRecordLayout<
     SIL_TWO_OPERANDS,
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
@@ -890,6 +890,7 @@ void Serializer::writeBlockInfoBlock() {
   BLOCK_RECORD(sil_block, SIL_INST_WITNESS_METHOD);
   BLOCK_RECORD(sil_block, SIL_SPECIALIZE_ATTR);
   BLOCK_RECORD(sil_block, SIL_ONE_OPERAND_EXTRA_ATTR);
+  BLOCK_RECORD(sil_block, SIL_ONE_TYPE_ONE_OPERAND_EXTRA_ATTR);
   BLOCK_RECORD(sil_block, SIL_TWO_OPERANDS_EXTRA_ATTR);
 
   // These layouts can exist in both decl blocks and sil blocks.
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
@@ -296,6 +296,9 @@ namespace {
                                       unsigned attrs,
                                       CanType type,
                                       SILValue operand);
+    void writeOneTypeOneOperandExtraAttributeLayout(
+      SILInstructionKind valueKind, unsigned attrs,
+      SILType type, SILValue operand);
     void writeOneOperandLayout(SILInstructionKind valueKind,
                                unsigned attrs,
                                SILValue operand);
@@ -681,6 +684,7 @@ void SILSerializer::writeOneTypeOneOperandLayout(SILInstructionKind valueKind,
         operandTypeRef, unsigned(operandType.getCategory()),
         operandRef);
 }
+
 void SILSerializer::writeOneTypeOneOperandLayout(SILInstructionKind valueKind,
                                                  unsigned attrs,
                                                  CanType type,
@@ -698,6 +702,24 @@ void SILSerializer::writeOneTypeOneOperandLayout(SILInstructionKind valueKind,
         operandRef);
 }
 
+void SILSerializer::
+writeOneTypeOneOperandExtraAttributeLayout(SILInstructionKind valueKind,
+                                           unsigned attrs,
+                                           SILType type,
+                                           SILValue operand) {
+  auto typeRef = S.addTypeRef(type.getASTType());
+  auto operandType = operand->getType();
+  auto operandTypeRef = S.addTypeRef(operandType.getASTType());
+  auto operandRef = addValueRef(operand);
+
+  SILOneTypeOneOperandExtraAttributeLayout::emitRecord(Out, ScratchRecord,
+        SILAbbrCodes[SILOneTypeOneOperandExtraAttributeLayout::Code],
+        unsigned(valueKind), attrs,
+        typeRef, unsigned(type.getCategory()),
+        operandTypeRef, unsigned(operandType.getCategory()),
+        operandRef);
+}
+
 /// Write an instruction that looks exactly like a conversion: all
 /// important information is encoded in the operand and the result type.
 void SILSerializer::writeConversionLikeInstruction(
@@ -1711,10 +1733,13 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
   case SILInstructionKind::PointerToAddressInst: {
     auto &PAI = cast<PointerToAddressInst>(SI);
     assert(PAI.getNumOperands() - PAI.getTypeDependentOperands().size() == 1);
-    unsigned attrs = (PAI.isStrict() ? 1 : 0)
-                   | (PAI.isInvariant() ? 2 : 0);
-    writeOneTypeOneOperandLayout(PAI.getKind(), attrs, PAI.getType(),
-                                 PAI.getOperand());
+    uint8_t encodedAlignment = llvm::encode(PAI.alignment());
+    assert(encodedAlignment == llvm::encode(PAI.alignment())
+           && "pointer_to_address alignment overflow");
+    unsigned attrs = encodedAlignment | (PAI.isStrict() ? 0x100 : 0)
+                     | (PAI.isInvariant() ? 0x200 : 0);
+    writeOneTypeOneOperandExtraAttributeLayout(
+      PAI.getKind(), attrs, PAI.getType(), PAI.getOperand());
     break;
   }
   case SILInstructionKind::RefToBridgeObjectInst: {
@@ -2778,6 +2803,7 @@ void SILSerializer::writeSILBlock(const SILModule *SILMod) {
   registerSILAbbr<SILOneOperandLayout>();
   registerSILAbbr<SILOneOperandExtraAttributeLayout>();
   registerSILAbbr<SILOneTypeOneOperandLayout>();
+  registerSILAbbr<SILOneTypeOneOperandExtraAttributeLayout>();
   registerSILAbbr<SILInitExistentialLayout>();
   registerSILAbbr<SILOneTypeValuesLayout>();
   registerSILAbbr<SILOneTypeOwnershipValuesLayout>();
diff --git a/test/IRGen/alignment.sil b/test/IRGen/alignment.sil
@@ -1,6 +1,7 @@
 // RUN: %target-swift-frontend -emit-ir %s | %FileCheck %s
 
 import Swift
+import Builtin
 
 @_alignment(16) struct Foo { var x, y, z, w: Float }
 @_alignment(16) enum Empty {}
@@ -9,6 +10,7 @@ import Swift
 @_alignment(16) enum SinglePayload { case A(Float), B, C }
 @_alignment(16) enum MultiPayload { case A(Float), B(Float), C }
 
+// CHECK-LABEL: define {{.*}} @test_alignment
 sil @test_alignment : $@convention(thin) () -> () {
 entry:
   // CHECK: alloca %T9alignment3FooV, align 16
@@ -76,3 +78,29 @@ entry:
   dealloc_stack %a : $*Foo
   return undef : $()
 }
+
+// CHECK-LABEL: define {{.*}} @test_unaligned
+// CHECK:   store i64 %{{.*}}, i64* %{{.*}}, align 8
+// CHECK:   %{{.*}} = load i64, i64* %{{.*}}, align 8
+// CHECK:   store i64 %{{.*}}, i64* %{{.*}}, align 1
+// CHECK:   %{{.*}} = load i64, i64* %{{.*}}, align 1
+// CHECK:   store i64 %{{.*}}, i64* %{{.*}}, align 8
+// CHECK:   %{{.*}} = load i64, i64* %{{.*}}, align 8
+// CHECK:   store i64 %{{.*}}, i64* %{{.*}}, align 536870912
+// CHECK:   %{{.*}} = load i64, i64* %{{.*}}, align 536870912
+sil @test_unaligned : $@convention(thin) (Builtin.RawPointer, Builtin.Int64) -> () {
+entry(%0 : $Builtin.RawPointer, %1 : $Builtin.Int64):
+  %2 = pointer_to_address %0 : $Builtin.RawPointer to $*Builtin.Int64
+  store %1 to %2 : $*Builtin.Int64
+  %4 = load %2 : $*Builtin.Int64
+  %5 = pointer_to_address %0 : $Builtin.RawPointer to [align=1] $*Builtin.Int64
+  store %1 to %5 : $*Builtin.Int64
+  %7 = load %5 : $*Builtin.Int64
+  %8 = pointer_to_address %0 : $Builtin.RawPointer to [align=8] $*Builtin.Int64
+  store %1 to %8 : $*Builtin.Int64
+  %10 = load %8 : $*Builtin.Int64
+  %11 = pointer_to_address %0 : $Builtin.RawPointer to [align=536870912] $*Builtin.Int64
+  store %1 to %11 : $*Builtin.Int64
+  %12 = load %11 : $*Builtin.Int64
+  return undef : $()
+}
diff --git a/test/SIL/Parser/basic.sil b/test/SIL/Parser/basic.sil
diff --git a/test/SIL/Serialization/basic.sil b/test/SIL/Serialization/basic.sil

Original file line number	Diff line number	Diff line change
`@@ -1751,6 +1751,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {`
`1751`	`1751`	`*this << "[strict] ";`
`1752`	`1752`	`if (CI->isInvariant())`
`1753`	`1753`	`*this << "[invariant] ";`
	`1754`	`+ if (CI->alignment())`
	`1755`	`+ *this << "[align=" << CI->alignment()->value() << "] ";`
`1754`	`1756`	`*this << CI->getType();`
`1755`	`1757`	`}`
`1756`	`1758`	`void visitUncheckedRefCastInst(UncheckedRefCastInst *CI) {`