[IRGen] Record generic environment associated with accessible function

Without this piece of information it wouldn't be possible to form
a call to the recorded function at runtime if it's generic.

Author: xedin

include/swift/ABI/Metadata.h

@@ -3096,6 +3096,8 @@ class TargetGenericEnvironment
   }
 };
 
+using GenericEnvironmentDescriptor = TargetGenericEnvironment<InProcess>;
+
 /// CRTP class for a context descriptor that includes trailing generic
 /// context description.
 template<class Self,
@@ -5145,6 +5147,10 @@ struct TargetAccessibleFunctionRecord final {
   /// function so it can be looked up later.
   RelativeDirectPointer<const char, /*nullable*/ false> Name;
 
+  /// The generic environment associated with this accessor function.
+  RelativeDirectPointer<GenericEnvironmentDescriptor, /*nullable*/ true>
+      GenericEnvironment;
+
   /// The Swift function type, encoded as a mangled name.
   RelativeDirectPointer<const char, /*nullable*/ false> FunctionType;
 

lib/IRGen/GenDecl.cpp

@@ -4152,21 +4152,31 @@ void IRGenModule::emitAccessibleFunctions() {
         llvm::GlobalValue::PrivateLinkage, /*initializer*/ nullptr,
         mangledRecordName);
 
+    ConstantInitBuilder builder(*this);
+    ConstantStructBuilder fields =
+        builder.beginStruct(AccessibleFunctionRecordTy);
+
     std::string mangledFunctionName =
         LinkEntity::forSILFunction(func).mangleAsString();
     llvm::Constant *name = getAddrOfGlobalString(
         mangledFunctionName, /*willBeRelativelyAddressed*/ true);
-    llvm::Constant *relativeName = emitDirectRelativeReference(name, var, {});
+    fields.addRelativeAddress(name);
+
+    llvm::Constant *genericEnvironment = nullptr;
 
     GenericSignature signature;
     if (auto *env = func->getGenericEnvironment()) {
       signature = env->getGenericSignature();
+      genericEnvironment =
+          getAddrOfGenericEnvironment(signature.getCanonicalSignature());
     }
 
+    fields.addRelativeAddressOrNull(genericEnvironment);
+
     llvm::Constant *type = getTypeRef(func->getLoweredFunctionType(), signature,
                                       MangledTypeRefRole::Metadata)
                                .first;
-    llvm::Constant *relativeType = emitDirectRelativeReference(type, var, {1});
+    fields.addRelativeAddress(type);
 
     llvm::Constant *funcAddr = nullptr;
     if (func->isDistributed()) {
@@ -4178,20 +4188,13 @@ void IRGenModule::emitAccessibleFunctions() {
       funcAddr = getAddrOfSILFunction(func, NotForDefinition);
     }
 
-    llvm::Constant *relativeFuncAddr =
-        emitDirectRelativeReference(funcAddr, var, {2});
-
-    AccessibleFunctionFlags flagsVal;
-    flagsVal.setDistributed(func->isDistributed());
+    fields.addRelativeAddress(funcAddr);
 
-    llvm::Constant *flags =
-        llvm::ConstantInt::get(Int32Ty, flagsVal.getOpaqueValue());
+    AccessibleFunctionFlags flags;
+    flags.setDistributed(func->isDistributed());
+    fields.addInt32(flags.getOpaqueValue());
 
-    llvm::Constant *recordFields[] = {relativeName, relativeType,
-                                      relativeFuncAddr, flags};
-    auto record =
-        llvm::ConstantStruct::get(AccessibleFunctionRecordTy, recordFields);
-    var->setInitializer(record);
+    fields.finishAndSetAsInitializer(var);
     var->setSection(sectionName);
     var->setAlignment(llvm::MaybeAlign(4));
     disableAddressSanitizer(*this, var);

lib/IRGen/IRGenModule.cpp

@@ -600,9 +600,10 @@ IRGenModule::IRGenModule(IRGenerator &irgen,
   DynamicReplacementKeyTy = createStructType(*this, "swift.dyn_repl_key",
                                              {RelativeAddressTy, Int32Ty});
 
-  AccessibleFunctionRecordTy = createStructType(
-      *this, "swift.accessible_function",
-      {RelativeAddressTy, RelativeAddressTy, RelativeAddressTy, Int32Ty});
+  AccessibleFunctionRecordTy =
+      createStructType(*this, "swift.accessible_function",
+                       {RelativeAddressTy, RelativeAddressTy, RelativeAddressTy,
+                        RelativeAddressTy, Int32Ty});
 
   AsyncFunctionPointerTy = createStructType(*this, "swift.async_func_pointer",
                                             {RelativeAddressTy, Int32Ty}, true);

lib/IRGen/IRGenModule.h

@@ -732,7 +732,7 @@ class IRGenModule {
       *DynamicReplacementLinkEntryPtrTy; // %link_entry*
   llvm::StructType *DynamicReplacementKeyTy; // { i32, i32}
 
-  llvm::StructType *AccessibleFunctionRecordTy; // { i32*, i32*, i32}
+  llvm::StructType *AccessibleFunctionRecordTy; // { i32*, i32*, i32*, i32}
 
   llvm::StructType *AsyncFunctionPointerTy; // { i32, i32 }
   llvm::StructType *SwiftContextTy;