Add virtual methods to TypeInfo to do all the buffer operations.

Use them to generate value witnesses when the type has dynamic packing.
Regularize the interface for calling value witnesses.

Not a huge difference yet, although we do re-use local type data
a little more effectively now.

Author: rjmccall

lib/IRGen/GenArchetype.cpp

@@ -19,7 +19,6 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Types.h"
 #include "swift/AST/Decl.h"
-#include "swift/AST/IRGenOptions.h"
 #include "swift/SIL/SILValue.h"
 #include "swift/SIL/TypeLowering.h"
 #include "llvm/ADT/SmallString.h"

lib/IRGen/GenEnum.cpp

@@ -4342,7 +4342,7 @@ namespace {
     void destructiveProjectDataForLoad(IRGenFunction &IGF,
                                        SILType T,
                                        Address enumAddr) const override {
-      emitDestructiveProjectEnumDataCall(IGF, T, enumAddr.getAddress());
+      emitDestructiveProjectEnumDataCall(IGF, T, enumAddr);
     }
 
     void storeTag(IRGenFunction &IGF,
@@ -4351,14 +4351,14 @@ namespace {
                   EnumElementDecl *Case) const override {
       emitDestructiveInjectEnumTagCall(IGF, T,
                                        getTagIndex(Case),
-                                       enumAddr.getAddress());
+                                       enumAddr);
     }
 
     llvm::Value *
     emitIndirectCaseTest(IRGenFunction &IGF, SILType T,
                          Address enumAddr,
                          EnumElementDecl *Case) const override {
-      llvm::Value *tag = emitGetEnumTagCall(IGF, T, enumAddr.getAddress());
+      llvm::Value *tag = emitGetEnumTagCall(IGF, T, enumAddr);
       llvm::Value *expectedTag = llvm::ConstantInt::get(IGF.IGM.Int32Ty,
                                                         getTagIndex(Case));
       return IGF.Builder.CreateICmpEQ(tag, expectedTag);
@@ -4371,7 +4371,7 @@ namespace {
                                                llvm::BasicBlock*>> dests,
                             llvm::BasicBlock *defaultDest) const override {
       // Switch on the tag value.
-      llvm::Value *tag = emitGetEnumTagCall(IGF, T, enumAddr.getAddress());
+      llvm::Value *tag = emitGetEnumTagCall(IGF, T, enumAddr);
 
       // Create a map of the destination blocks for quicker lookup.
       llvm::DenseMap<EnumElementDecl*,llvm::BasicBlock*> destMap(dests.begin(),
@@ -4426,33 +4426,33 @@ namespace {
                         SILType T)
     const override {
       emitAssignWithCopyCall(IGF, T,
-                             dest.getAddress(), src.getAddress());
+                             dest, src);
     }
 
     void assignWithTake(IRGenFunction &IGF, Address dest, Address src,
                         SILType T)
     const override {
       emitAssignWithTakeCall(IGF, T,
-                             dest.getAddress(), src.getAddress());
+                             dest, src);
     }
 
     void initializeWithCopy(IRGenFunction &IGF, Address dest, Address src,
                             SILType T)
     const override {
       emitInitializeWithCopyCall(IGF, T,
-                                 dest.getAddress(), src.getAddress());
+                                 dest, src);
     }
 
     void initializeWithTake(IRGenFunction &IGF, Address dest, Address src,
                             SILType T)
     const override {
       emitInitializeWithTakeCall(IGF, T,
-                                 dest.getAddress(), src.getAddress());
+                                 dest, src);
     }
 
     void destroy(IRGenFunction &IGF, Address addr, SILType T)
     const override {
-      emitDestroyCall(IGF, T, addr.getAddress());
+      emitDestroyCall(IGF, T, addr);
     }
 
     void getSchema(ExplosionSchema &schema) const override {
@@ -4602,14 +4602,14 @@ namespace {
     llvm::Value *getExtraInhabitantIndex(IRGenFunction &IGF,
                                          Address src,
                                          SILType T) const override {
-      return emitGetExtraInhabitantIndexCall(IGF, T, src.getAddress());
+      return emitGetExtraInhabitantIndexCall(IGF, T, src);
     }
 
     void storeExtraInhabitant(IRGenFunction &IGF,
                               llvm::Value *index,
                               Address dest,
                               SILType T) const override {
-      emitStoreExtraInhabitantCall(IGF, T, index, dest.getAddress());
+      emitStoreExtraInhabitantCall(IGF, T, index, dest);
     }
 
     APInt

lib/IRGen/GenExistential.cpp

@@ -334,7 +334,8 @@ class OpaqueExistentialTypeInfo :
     Address srcBuffer = layout.projectExistentialBuffer(IGF, src);
     Address destBuffer = layout.projectExistentialBuffer(IGF, dest);
     emitInitializeBufferWithCopyOfBufferCall(IGF, metadata,
-                                             destBuffer, srcBuffer);
+                                             destBuffer,
+                                             srcBuffer);
   }
 
   void initializeWithTake(IRGenFunction &IGF,
@@ -349,7 +350,8 @@ class OpaqueExistentialTypeInfo :
     Address srcBuffer = layout.projectExistentialBuffer(IGF, src);
     Address destBuffer = layout.projectExistentialBuffer(IGF, dest);
     emitInitializeBufferWithTakeOfBufferCall(IGF, metadata,
-                                             destBuffer, srcBuffer);
+                                             destBuffer,
+                                             srcBuffer);
   }
 
   void destroy(IRGenFunction &IGF, Address addr, SILType T) const {
@@ -1524,7 +1526,9 @@ static llvm::Constant *getAssignExistentialsFunction(IRGenModule &IGM,
         emitProjectBufferCall(IGF, destMetadata, destBuffer);
       llvm::Value *srcObject =
         emitProjectBufferCall(IGF, destMetadata, srcBuffer);
-      emitAssignWithCopyCall(IGF, destMetadata, destObject, srcObject);
+      emitAssignWithCopyCall(IGF, destMetadata,
+                             Address(destObject, Alignment(1)),
+                             Address(srcObject, Alignment(1)));
       IGF.Builder.CreateBr(doneBB);
     }
 
@@ -1559,7 +1563,8 @@ static llvm::Constant *getAssignExistentialsFunction(IRGenModule &IGM,
       // witness table from the source metadata if we can't use a
       // protocol witness table.
       emitInitializeBufferWithCopyOfBufferCall(IGF, srcMetadata,
-                                               destBuffer, srcBuffer);
+                                               destBuffer,
+                                               srcBuffer);
       IGF.Builder.CreateBr(doneBB);
     }
 
@@ -1848,7 +1853,8 @@ void irgen::emitMetatypeOfOpaqueExistential(IRGenFunction &IGF, Address addr,
 
   // Project the buffer and apply the 'typeof' value witness.
   Address buffer = existLayout.projectExistentialBuffer(IGF, addr);
-  llvm::Value *object = emitProjectBufferCall(IGF, metadata, buffer);
+  llvm::Value *object =
+    emitProjectBufferCall(IGF, metadata, buffer);
   llvm::Value *dynamicType =
     IGF.Builder.CreateCall(IGF.IGM.getGetDynamicTypeFn(),
                            {object, metadata});
@@ -1984,7 +1990,8 @@ irgen::emitIndirectExistentialProjectionWithMetadata(IRGenFunction &IGF,
 
     llvm::Value *metadata = layout.loadMetadataRef(IGF, base);
     Address buffer = layout.projectExistentialBuffer(IGF, base);
-    llvm::Value *object = emitProjectBufferCall(IGF, metadata, buffer);
+    llvm::Value *object =
+      emitProjectBufferCall(IGF, metadata, buffer);
 
     // If we are projecting into an opened archetype, capture the
     // witness tables.