From aecea0519fd7fcbb2d4d5425c539e3818042d26f Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Tue, 22 Aug 2023 11:43:43 +0200
Subject: [PATCH 01/48] TODODROP. DISABLE TESTS

---
 unittests/CMakeLists.txt | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/unittests/CMakeLists.txt b/unittests/CMakeLists.txt
index eee4941f23..fa937b1229 100644
--- a/unittests/CMakeLists.txt
+++ b/unittests/CMakeLists.txt
@@ -1,8 +1,8 @@
 if (NOT MINGW_BUILD)
   add_subdirectory(APITests/)
   add_subdirectory(IR/)
-  add_subdirectory(POSIX/)
-  add_subdirectory(gvisor-tests/)
+  #add_subdirectory(POSIX/)
+  #add_subdirectory(gvisor-tests/)
   add_subdirectory(gcc-target-tests-32/)
   add_subdirectory(gcc-target-tests-64/)
   add_subdirectory(Utilities/)
@@ -17,8 +17,8 @@ if (NOT MINGW_BUILD)
   endif()
 endif()
 
-add_subdirectory(ASM/)
-add_subdirectory(32Bit_ASM/)
+#add_subdirectory(ASM/)
+#add_subdirectory(32Bit_ASM/)
 if (ENABLE_VIXL_DISASSEMBLER AND (ENABLE_JIT_ARM64 OR CMAKE_SYSTEM_PROCESSOR MATCHES "^aarch64|^arm64|^armv8\.*") AND NOT ENABLE_JIT_X86_64)
   # Tests are only valid to run if the vixl disassembler is enabled and the active JIT is the ARM64 JIT.
   add_subdirectory(InstructionCountCI/)

From 34fce6413cbe494cd8db0de719c37593597a94fe Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Thu, 24 Aug 2023 11:04:20 +0200
Subject: [PATCH 02/48] Thunks/gen: Track data types passed across architecture
 boundaries

The set of these types is tracked in AnalysisAction, to which extensive
verification logic is added to detect potential incompatibilities and to
enforce use of annotatations where needed.
---
 ThunkLibs/Generator/analysis.cpp              | 288 ++++++++++++++----
 ThunkLibs/Generator/analysis.h                |  21 ++
 ThunkLibs/include/common/GeneratorInterface.h |  20 ++
 3 files changed, 264 insertions(+), 65 deletions(-)

diff --git a/ThunkLibs/Generator/analysis.cpp b/ThunkLibs/Generator/analysis.cpp
index 39f02577c9..4c6a49aa16 100644
--- a/ThunkLibs/Generator/analysis.cpp
+++ b/ThunkLibs/Generator/analysis.cpp
@@ -128,6 +128,7 @@ void AnalysisAction::ExecuteAction() {
 
     try {
         ParseInterface(context);
+        CoverReferencedTypes(context);
         EmitOutput(context);
     } catch (ClangDiagnosticAsException& exception) {
         exception.Report(context.getDiagnostics());
@@ -149,9 +150,25 @@ FindClassTemplateDeclByName(clang::DeclContext& decl_context, std::string_view s
     }
 }
 
+static ParameterAnnotations GetParameterAnnotations(clang::ASTContext& context, clang::CXXRecordDecl* decl) {
+    if (!decl->hasDefinition()) {
+        return {};
+    }
+
+    ErrorReporter report_error { context };
+    ParameterAnnotations ret;
+
+    for (const clang::CXXBaseSpecifier& base : decl->bases()) {
+        throw report_error(base.getSourceRange().getBegin(), "Unknown parameter annotation");
+    }
+
+    return ret;
+}
+
 void AnalysisAction::ParseInterface(clang::ASTContext& context) {
     ErrorReporter report_error { context };
 
+    // TODO: Assert fex_gen_type is not declared at non-global namespaces
     if (auto template_decl = FindClassTemplateDeclByName(*context.getTranslationUnitDecl(), "fex_gen_type")) {
         for (auto* decl : template_decl->specializations()) {
             const auto& template_args = decl->getTemplateArgs();
@@ -161,8 +178,45 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
             //       named types (e.g. GLuint/GLenum) are represented by
             //       different Type instances. The canonical type they refer
             //       to is unique, however.
-            auto type = context.getCanonicalType(template_args[0].getAsType()).getTypePtr();
-            funcptr_types.insert(type);
+            clang::QualType type = context.getCanonicalType(template_args[0].getAsType());
+            type = type->getLocallyUnqualifiedSingleStepDesugaredType();
+
+            {
+                if (type->isFunctionPointerType() || type->isFunctionType()) {
+                    funcptr_types.insert(type.getTypePtr());
+                } else {
+                    // TODO: Unify this with the is_opaque path above
+                    auto [it, inserted] = types.emplace(context.getCanonicalType(type.getTypePtr()), RepackedType { });
+                    assert(inserted);
+                }
+            }
+        }
+    }
+
+    // Process function parameter annotations
+    std::unordered_map<const clang::FunctionDecl*, std::unordered_map<unsigned, ParameterAnnotations>> param_annotations;
+    for (auto& decl_context : decl_contexts) {
+        if (auto template_decl = FindClassTemplateDeclByName(*decl_context, "fex_gen_param")) {
+            for (auto* decl : template_decl->specializations()) {
+                const auto& template_args = decl->getTemplateArgs();
+                assert(/*template_args.size() == 2 || */template_args.size() == 3);
+
+                auto function = llvm::dyn_cast<clang::FunctionDecl>(template_args[0].getAsDecl())/*->getCanonicalDecl()*/;
+                auto param_idx = template_args[1].getAsIntegral().getZExtValue();
+                clang::QualType type = context.getCanonicalType(template_args[2].getAsType());
+                type = type->getLocallyUnqualifiedSingleStepDesugaredType();
+
+                if (param_idx >= function->getNumParams()) {
+                    throw report_error(decl->getTypeAsWritten()->getTypeLoc().getAs<clang::TemplateSpecializationTypeLoc>().getArgLoc(1).getLocation(), "Out-of-bounds parameter index passed to fex_gen_param");
+                }
+
+                if (!type->isVoidType() && !context.hasSameType(type, function->getParamDecl(param_idx)->getType())) {
+                    throw report_error(decl->getTypeAsWritten()->getTypeLoc().getAs<clang::TemplateSpecializationTypeLoc>().getArgLoc(2).getLocation(), "Type passed to fex_gen_param doesn't match the function signature")
+                              .addNote(report_error(function->getParamDecl(param_idx)->getTypeSourceInfo()->getTypeLoc().getBeginLoc(), "Expected this type instead"));
+                }
+
+                param_annotations[function][param_idx] = GetParameterAnnotations(context, decl);
+            }
         }
     }
 
@@ -220,94 +274,198 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
 
                 const auto template_arg_loc = decl->getTypeAsWritten()->getTypeLoc().castAs<clang::TemplateSpecializationTypeLoc>().getArgLoc(0).getLocation();
 
-                auto emitted_function = llvm::dyn_cast<clang::FunctionDecl>(template_args[0].getAsDecl());
-                assert(emitted_function && "Argument is not a function");
-                auto return_type = emitted_function->getReturnType();
+                if (auto emitted_function = llvm::dyn_cast<clang::FunctionDecl>(template_args[0].getAsDecl())) {
+                    auto return_type = emitted_function->getReturnType();
 
-                const auto annotations = GetAnnotations(context, decl);
-                if (return_type->isFunctionPointerType() && !annotations.returns_guest_pointer) {
-                    throw report_error( template_arg_loc,
-                                        "Function pointer return types require explicit annotation\n");
-                }
+                    const auto annotations = GetAnnotations(context, decl);
+                    if (return_type->isFunctionPointerType() && !annotations.returns_guest_pointer) {
+                        throw report_error( template_arg_loc,
+                                            "Function pointer return types require explicit annotation\n");
+                    }
+
+                    // TODO: Use the types as written in the signature instead?
+                    ThunkedFunction data;
+                    data.function_name = emitted_function->getName().str();
+                    data.return_type = return_type;
+                    data.is_variadic = emitted_function->isVariadic();
 
-                // TODO: Use the types as written in the signature instead?
-                ThunkedFunction data;
-                data.function_name = emitted_function->getName().str();
-                data.return_type = return_type;
-                data.is_variadic = emitted_function->isVariadic();
+                    data.decl = emitted_function;
 
-                data.decl = emitted_function;
+                    data.custom_host_impl = annotations.custom_host_impl;
 
-                data.custom_host_impl = annotations.custom_host_impl;
+                    data.param_annotations = param_annotations[emitted_function];
 
-                for (std::size_t param_idx = 0; param_idx < emitted_function->param_size(); ++param_idx) {
-                    auto* param = emitted_function->getParamDecl(param_idx);
-                    data.param_types.push_back(param->getType());
+                    const int retval_index = -1;
+                    for (int param_idx = retval_index; param_idx < (int)emitted_function->param_size(); ++param_idx) {
+                        auto param_type = param_idx == retval_index ? emitted_function->getReturnType() : emitted_function->getParamDecl(param_idx)->getType();
+                        auto param_loc = param_idx == retval_index ? emitted_function->getReturnTypeSourceRange().getBegin() : emitted_function->getParamDecl(param_idx)->getBeginLoc();
 
-                    if (param->getType()->isFunctionPointerType()) {
-                        auto funcptr = param->getFunctionType()->getAs<clang::FunctionProtoType>();
-                        ThunkedCallback callback;
-                        callback.return_type = funcptr->getReturnType();
-                        for (auto& cb_param : funcptr->getParamTypes()) {
-                            callback.param_types.push_back(cb_param);
+                        if (param_idx != retval_index) {
+                            data.param_types.push_back(param_type);
+                        } else if (param_type->isVoidType()) {
+                            continue;
                         }
-                        callback.is_stub = annotations.callback_strategy == CallbackStrategy::Stub;
-                        callback.is_guest = annotations.callback_strategy == CallbackStrategy::Guest;
-                        callback.is_variadic = funcptr->isVariadic();
 
-                        if (callback.is_guest && !data.custom_host_impl) {
-                            throw report_error(template_arg_loc, "callback_guest can only be used with custom_host_impl");
+                        auto check_struct_type = [&](const clang::Type* type) {
+                            if (type->isIncompleteType()) {
+                                throw report_error(type->getAsTagDecl()->getBeginLoc(), "Unannotated pointer with incomplete struct type; consider using an opaque_type annotation")
+                                      .addNote(report_error(emitted_function->getNameInfo().getLoc(), "in function", clang::DiagnosticsEngine::Note))
+                                      .addNote(report_error(template_arg_loc, "used in annotation here", clang::DiagnosticsEngine::Note));
+                            }
+
+                            for (auto* member : type->getAsStructureType()->getDecl()->fields()) {
+                                  /*if (!member->getType()->isPointerType())*/ {
+                                      // TODO: Perform more elaborate validation for non-pointers to ensure ABI compatibility
+                                      continue;
+                                  }
+
+                                  throw report_error(member->getBeginLoc(), "Unannotated pointer member")
+                                        .addNote(report_error(param_loc, "in struct type", clang::DiagnosticsEngine::Note))
+                                        .addNote(report_error(template_arg_loc, "used in annotation here", clang::DiagnosticsEngine::Note));
+                            }
+                        };
+
+                        if (param_type->isFunctionPointerType()) {
+                            if (param_idx == retval_index) {
+                                // TODO: We already rely on this in a few places...
+//                                throw report_error(template_arg_loc, "Support for returning function pointers is not implemented");
+                                continue;
+                            }
+                            auto funcptr = emitted_function->getParamDecl(param_idx)->getFunctionType()->getAs<clang::FunctionProtoType>();
+                            ThunkedCallback callback;
+                            callback.return_type = funcptr->getReturnType();
+                            for (auto& cb_param : funcptr->getParamTypes()) {
+                                callback.param_types.push_back(cb_param);
+                            }
+                            callback.is_stub = annotations.callback_strategy == CallbackStrategy::Stub;
+                            callback.is_guest = annotations.callback_strategy == CallbackStrategy::Guest;
+                            callback.is_variadic = funcptr->isVariadic();
+
+                            if (callback.is_guest && !data.custom_host_impl) {
+                                throw report_error(template_arg_loc, "callback_guest can only be used with custom_host_impl");
+                            }
+
+                            data.callbacks.emplace(param_idx, callback);
+                            if (!callback.is_stub && !callback.is_guest && !data.custom_host_impl) {
+                                funcptr_types.insert(context.getCanonicalType(funcptr));
+                            }
+
+                            if (data.callbacks.size() != 1) {
+                                throw report_error(template_arg_loc, "Support for more than one callback is untested");
+                            }
+                            if (funcptr->isVariadic() && !callback.is_stub) {
+                                throw report_error(template_arg_loc, "Variadic callbacks are not supported");
+                            }
+                        } else if (param_type->isBuiltinType()) {
+                            // NOTE: Intentionally not using getCanonicalType here since that would turn e.g. size_t into platform-specific types
+                            // TODO: Still, we may want to de-duplicate some of these...
+                            types.emplace(param_type.getTypePtr(), RepackedType { });
+                        } else if (param_type->isEnumeralType()) {
+                            types.emplace(context.getCanonicalType(param_type.getTypePtr()), RepackedType { });
+                        } else if ( param_type->isStructureType()) {
+                            check_struct_type(param_type.getTypePtr());
+                            types.emplace(context.getCanonicalType(param_type.getTypePtr()), RepackedType { });
+                        } else if (param_type->isPointerType()) {
+                            auto pointee_type = param_type->getPointeeType()->getLocallyUnqualifiedSingleStepDesugaredType();
+                            if ( pointee_type->isStructureType()) {
+                                check_struct_type(pointee_type.getTypePtr());
+                                types.emplace(context.getCanonicalType(pointee_type.getTypePtr()), RepackedType { });
+                            } else if (false /* TODO: Can't check if this is unsupported until data layout analysis is complete */) {
+                                fprintf(stderr, "NAME: %s\n", pointee_type.getAsString().c_str());
+                                throw report_error(param_loc, "Unsupported parameter type")
+                                              .addNote(report_error(emitted_function->getNameInfo().getLoc(), "in function", clang::DiagnosticsEngine::Note))
+                                              .addNote(report_error(template_arg_loc, "used in definition here", clang::DiagnosticsEngine::Note));
+                            }
+                        } else {
+                            // TODO: For non-pointer parameters, perform more elaborate validation to ensure ABI compatibility
                         }
+                    }
+
+                    thunked_api.push_back(ThunkedAPIFunction { (const FunctionParams&)data, data.function_name, data.return_type,
+                                                                namespace_info.host_loader.empty() ? "dlsym_default" : namespace_info.host_loader,
+                                                                data.is_variadic || annotations.custom_guest_entrypoint,
+                                                                data.is_variadic,
+                                                                std::nullopt });
+                    if (namespace_info.generate_guest_symtable) {
+                        thunked_api.back().symtable_namespace = namespace_idx;
+                    }
 
-                        data.callbacks.emplace(param_idx, callback);
-                        if (!callback.is_stub && !callback.is_guest) {
-                            funcptr_types.insert(context.getCanonicalType(funcptr));
+                    if (data.is_variadic) {
+                        if (!annotations.uniform_va_type) {
+                            throw report_error(decl->getBeginLoc(), "Variadic functions must be annotated with parameter type using uniform_va_type");
                         }
 
-                        if (data.callbacks.size() != 1) {
-                            throw report_error(template_arg_loc, "Support for more than one callback is untested");
+                        // Convert variadic argument list into a count + pointer pair
+                        data.param_types.push_back(context.getSizeType());
+                        data.param_types.push_back(context.getPointerType(*annotations.uniform_va_type));
+                        types.emplace(context.getSizeType()->getTypePtr(), RepackedType { });
+                        if (!annotations.uniform_va_type.value()->isVoidPointerType()) {
+                            types.emplace(annotations.uniform_va_type->getTypePtr(), RepackedType { });
                         }
-                        if (funcptr->isVariadic() && !callback.is_stub) {
-                            throw report_error(template_arg_loc, "Variadic callbacks are not supported");
+                    }
+
+                    if (data.is_variadic) {
+                        // This function is thunked through an "_internal" symbol since its signature
+                        // is different from the one in the native host/guest libraries.
+                        data.function_name = data.function_name + "_internal";
+                        if (data.custom_host_impl) {
+                            throw report_error(decl->getBeginLoc(), "Custom host impl requested but this is implied by the function signature already");
                         }
+                        data.custom_host_impl = true;
                     }
-                }
 
-                thunked_api.push_back(ThunkedAPIFunction { (const FunctionParams&)data, data.function_name, data.return_type,
-                                                            namespace_info.host_loader.empty() ? "dlsym_default" : namespace_info.host_loader,
-                                                            data.is_variadic || annotations.custom_guest_entrypoint,
-                                                            data.is_variadic,
-                                                            std::nullopt });
-                if (namespace_info.generate_guest_symtable) {
-                    thunked_api.back().symtable_namespace = namespace_idx;
+                    // For indirect calls, register the function signature as a function pointer type
+                    if (namespace_info.indirect_guest_calls) {
+                        funcptr_types.insert(context.getCanonicalType(emitted_function->getFunctionType()));
+                    }
+
+                    thunks.push_back(std::move(data));
                 }
+            }
+        }
+    }
+}
 
-                if (data.is_variadic) {
-                    if (!annotations.uniform_va_type) {
-                        throw report_error(decl->getBeginLoc(), "Variadic functions must be annotated with parameter type using uniform_va_type");
-                    }
+void AnalysisAction::CoverReferencedTypes(clang::ASTContext& context) {
+    // Repeat until no more children are appended
+    for (bool changed = true; std::exchange(changed, false);) {
+        for ( auto next_type_it = types.begin(), type_it = next_type_it;
+              type_it != types.end();
+              type_it = next_type_it) {
+            ++next_type_it;
+            const auto& [type, type_repack_info] = *type_it;
+            if (!type->isStructureType()) {
+                continue;
+            }
 
-                    // Convert variadic argument list into a count + pointer pair
-                    data.param_types.push_back(context.getSizeType());
-                    data.param_types.push_back(context.getPointerType(*annotations.uniform_va_type));
+            for (auto* member : type->getAsStructureType()->getDecl()->fields()) {
+                auto member_type = member->getType().getTypePtr();
+                while (member_type->isArrayType()) {
+                    member_type = member_type->getArrayElementTypeNoTypeQual();
+                }
+                while (member_type->isPointerType()) {
+                    member_type = member_type->getPointeeType().getTypePtr();
                 }
 
-                if (data.is_variadic) {
-                    // This function is thunked through an "_internal" symbol since its signature
-                    // is different from the one in the native host/guest libraries.
-                    data.function_name = data.function_name + "_internal";
-                    if (data.custom_host_impl) {
-                        throw report_error(decl->getBeginLoc(), "Custom host impl requested but this is implied by the function signature already");
-                    }
-                    data.custom_host_impl = true;
+                if (!member_type->isBuiltinType()) {
+                    member_type = context.getCanonicalType(member_type);
+                }
+                if (member_type->isUnionType() && !types.contains(member_type)) {
+                    throw std::runtime_error(fmt::format("\"{}\" has unannotated member \"{}\" of union type \"{}\"",
+                                                         clang::QualType { type, 0 }.getAsString(),
+                                                         member->getNameAsString(),
+                                                         clang::QualType { member_type, 0 }.getAsString()));
                 }
 
-                // For indirect calls, register the function signature as a function pointer type
-                if (namespace_info.indirect_guest_calls) {
-                    funcptr_types.insert(context.getCanonicalType(emitted_function->getFunctionType()));
+                if (!member_type->isStructureType() && !(member_type->isBuiltinType() && !member_type->isVoidType()) && !member_type->isEnumeralType()) {
+                    continue;
                 }
 
-                thunks.push_back(std::move(data));
+                auto [new_type_it, inserted] = types.emplace(member_type, RepackedType { });
+                if (inserted) {
+                    changed = true;
+                    next_type_it = new_type_it;
+                }
             }
         }
     }
diff --git a/ThunkLibs/Generator/analysis.h b/ThunkLibs/Generator/analysis.h
index 7aeaa9d77a..9805507d14 100644
--- a/ThunkLibs/Generator/analysis.h
+++ b/ThunkLibs/Generator/analysis.h
@@ -21,6 +21,10 @@ struct ThunkedCallback : FunctionParams {
     bool is_variadic = false;
 };
 
+struct ParameterAnnotations {
+    bool operator==(const ParameterAnnotations&) const = default;
+};
+
 /**
  * Guest<->Host transition point.
  *
@@ -52,6 +56,10 @@ struct ThunkedFunction : FunctionParams {
     // Maps parameter index to ThunkedCallback
     std::unordered_map<unsigned, ThunkedCallback> callbacks;
 
+    // Maps parameter index to ParameterAnnotations
+    // TODO: Use index -1 for the return value?
+    std::unordered_map<unsigned, ParameterAnnotations> param_annotations;
+
     clang::FunctionDecl* decl;
 };
 
@@ -109,6 +117,9 @@ class AnalysisAction : public clang::ASTFrontendAction {
     // Build the internal API representation by processing fex_gen_config and other annotated entities
     void ParseInterface(clang::ASTContext&);
 
+    // Recursively extend the type set to include types of struct members
+    void CoverReferencedTypes(clang::ASTContext&);
+
     // Called from ExecuteAction() after parsing is complete
     virtual void EmitOutput(clang::ASTContext&) {};
 
@@ -116,8 +127,18 @@ class AnalysisAction : public clang::ASTFrontendAction {
 
     std::vector<ThunkedFunction> thunks;
     std::vector<ThunkedAPIFunction> thunked_api;
+
     std::unordered_set<const clang::Type*> funcptr_types;
 
+public: // TODO: Remove, make only RepackedType public
+    struct RepackedType {
+    };
+
+    std::unordered_map<const clang::Type*, RepackedType> types;
     std::optional<unsigned> lib_version;
     std::vector<NamespaceInfo> namespaces;
+
+    RepackedType& LookupType(clang::ASTContext& context, const clang::Type* type) {
+      return types.at(context.getCanonicalType(type));
+    }
 };
diff --git a/ThunkLibs/include/common/GeneratorInterface.h b/ThunkLibs/include/common/GeneratorInterface.h
index f3cd082db9..29c4f4eb4d 100644
--- a/ThunkLibs/include/common/GeneratorInterface.h
+++ b/ThunkLibs/include/common/GeneratorInterface.h
@@ -13,4 +13,24 @@ struct callback_annotation_base {
 struct callback_stub : callback_annotation_base {};
 struct callback_guest : callback_annotation_base {};
 
+// If used, fex_custom_repack must be specialized for the annotated struct member
+struct custom_repack {};
+
+struct type_annotation_base { bool prevent_multiple; };
+
+// Pointers to types annotated with this will be passed through without change
+struct opaque_type : type_annotation_base {};
+
+// Function parameter annotation.
+// Pointers are passed through to host (extending to 64-bit if needed) without modifying the pointee.
+// The type passed to Host is guest_layout<PointeeType>*.
+// TODO: Update description. "The raw guest_layout<type>* will be passed to the host"
+struct ptr_passthrough {};
+
+// Type / Function parameter annotation.
+// Assume objects of the given type are compatible across architectures,
+// even if the generator can't automatically prove this. For pointers, this refers to the pointee type.
+// NOTE: In contrast to opaque_type, this allows for non-pointer members with the annotated type to be repacked automatically.
+struct assume_compatible_data_layout : type_annotation_base {};
+
 } // namespace fexgen

From 89cf47446e61d2348537c45d0e40e8dec23df4ab Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Thu, 24 Aug 2023 11:21:13 +0200
Subject: [PATCH 03/48] Thunks/gen: Add data layout analysis

This adds a ComputeDataLayout function that maps a set of clang::Types
to an internal representation of their data layout (size, member list, ...).
---
 ThunkLibs/Generator/CMakeLists.txt  |   2 +-
 ThunkLibs/Generator/analysis.h      |  37 +++++++++
 ThunkLibs/Generator/data_layout.cpp | 119 ++++++++++++++++++++++++++++
 ThunkLibs/Generator/data_layout.h   |  82 +++++++++++++++++++
 ThunkLibs/Generator/gen.cpp         |   5 ++
 5 files changed, 244 insertions(+), 1 deletion(-)
 create mode 100644 ThunkLibs/Generator/data_layout.cpp
 create mode 100644 ThunkLibs/Generator/data_layout.h

diff --git a/ThunkLibs/Generator/CMakeLists.txt b/ThunkLibs/Generator/CMakeLists.txt
index 55f27216b8..f628db6874 100644
--- a/ThunkLibs/Generator/CMakeLists.txt
+++ b/ThunkLibs/Generator/CMakeLists.txt
@@ -1,7 +1,7 @@
 find_package(Clang REQUIRED CONFIG)
 find_package(OpenSSL REQUIRED COMPONENTS Crypto)
 
-add_library(thunkgenlib analysis.cpp gen.cpp)
+add_library(thunkgenlib analysis.cpp data_layout.cpp gen.cpp)
 target_include_directories(thunkgenlib INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
 target_include_directories(thunkgenlib SYSTEM PUBLIC ${CLANG_INCLUDE_DIRS})
 target_link_libraries(thunkgenlib PUBLIC clang-cpp LLVM)
diff --git a/ThunkLibs/Generator/analysis.h b/ThunkLibs/Generator/analysis.h
index 9805507d14..4c625d8529 100644
--- a/ThunkLibs/Generator/analysis.h
+++ b/ThunkLibs/Generator/analysis.h
@@ -142,3 +142,40 @@ class AnalysisAction : public clang::ASTFrontendAction {
       return types.at(context.getCanonicalType(type));
     }
 };
+
+inline std::string get_type_name(const clang::ASTContext& context, const clang::Type* type) {
+    if (type->isBuiltinType()) {
+        // Skip canonicalization
+        return clang::QualType { type, 0 }.getAsString();
+    }
+
+    if (auto decl = type->getAsTagDecl()) {
+        // Replace unnamed types with a placeholder. This will fail to compile if referenced
+        // anywhere in generated code, but at least it will point to a useful location.
+        //
+        // A notable exception are C-style struct declarations like "typedef struct (unnamed) { ... } MyStruct;".
+        // A typedef name is associated with these for linking purposes, so
+        // getAsString() will produce a usable identifier.
+        // TODO: Consider turning this into a hard error instead of replacing the name
+        if (!decl->getDeclName() && !decl->getTypedefNameForAnonDecl()) {
+            auto loc = context.getSourceManager().getPresumedLoc(decl->getLocation());
+            std::string filename = loc.getFilename();
+            filename = std::move(filename).substr(filename.rfind("/"));
+            filename = std::move(filename).substr(1);
+            std::replace(filename.begin(), filename.end(), '.', '_');
+            return "unnamed_type_" + filename + "_" + std::to_string(loc.getLine());
+        }
+    }
+
+    auto type_name = clang::QualType { context.getCanonicalType(type), 0 }.getAsString();
+    if (type_name.starts_with("struct ")) {
+        type_name = type_name.substr(7);
+    }
+    if (type_name.starts_with("class ") || type_name.starts_with("union ")) {
+        type_name = type_name.substr(6);
+    }
+    if (type_name.starts_with("enum ")) {
+        type_name = type_name.substr(5);
+    }
+    return type_name;
+}
diff --git a/ThunkLibs/Generator/data_layout.cpp b/ThunkLibs/Generator/data_layout.cpp
new file mode 100644
index 0000000000..220a9681b6
--- /dev/null
+++ b/ThunkLibs/Generator/data_layout.cpp
@@ -0,0 +1,119 @@
+#include "analysis.h"
+#include "data_layout.h"
+#include "interface.h"
+
+#include <fmt/format.h> // TODO: Drop
+
+#include <openssl/sha.h>
+
+std::unordered_map<const clang::Type*, TypeInfo> ComputeDataLayout(const clang::ASTContext& context, const std::unordered_map<const clang::Type*, AnalysisAction::RepackedType>& types) {
+    std::unordered_map<const clang::Type*, TypeInfo> layout;
+
+    // First, add all types directly used in function signatures of the library API to the meta set
+    for (const auto& [type, type_repack_info] : types) {
+        if (type->isIncompleteType()) {
+            throw std::runtime_error("Cannot compute data layout of incomplete type \"" + clang::QualType { type, 0 }.getAsString() + "\". Did you forget any annotations?");
+        }
+
+        if (type->isStructureType()) {
+            StructInfo info;
+            info.size_bits = context.getTypeSize(type);
+            info.alignment_bits = context.getTypeAlign(type);
+
+            auto [_, inserted] = layout.insert(std::pair { context.getCanonicalType(type), info });
+            if (!inserted) {
+                throw std::runtime_error("Failed to gather type metadata: Type \"" + clang::QualType { type, 0 }.getAsString() + "\" already registered");
+            }
+        } else if (type->isBuiltinType() || type->isEnumeralType()) {
+            SimpleTypeInfo info;
+            info.size_bits = context.getTypeSize(type);
+            info.alignment_bits = context.getTypeAlign(type);
+
+            // NOTE: Non-enum types are intentionally not canonicalized since that would turn e.g. size_t into platform-specific types
+            auto [_, inserted] = layout.insert(std::pair { type->isEnumeralType() ? context.getCanonicalType(type) : type, info });
+            if (!inserted) {
+                throw std::runtime_error("Failed to gather type metadata: Type \"" + clang::QualType { type, 0 }.getAsString() + "\" already registered");
+            }
+        }
+    }
+
+    // Then, add information about members
+    for (const auto& [type, type_repack_info] : types) {
+        if (!type->isStructureType()) {
+            continue;
+        }
+
+        auto& info = *layout.at(context.getCanonicalType(type)).get_if_struct();
+
+        for (auto* field : type->getAsStructureType()->getDecl()->fields()) {
+            auto field_type = field->getType().getTypePtr();
+            std::optional<uint64_t> array_size;
+            if (auto array_type = llvm::dyn_cast<clang::ConstantArrayType>(field->getType())) {
+                array_size = array_type->getSize().getZExtValue();
+                field_type = array_type->getElementType().getTypePtr();
+                if (llvm::isa<clang::ConstantArrayType>(field_type)) {
+                    throw std::runtime_error("Unsupported multi-dimensional array member \"" + field->getNameAsString() + "\" in type \"" + clang::QualType { type, 0 }.getAsString() + "\"");
+                }
+            }
+
+            StructInfo::MemberInfo member_info {
+                .size_bits = context.getTypeSize(field->getType()), // Total size even for arrays
+                .offset_bits = context.getFieldOffset(field),
+                .type_name = get_type_name(context, field_type),
+                .member_name = field->getNameAsString(),
+                .array_size = array_size,
+            };
+
+            // TODO: Process types in dependency-order. Currently we skip this
+            //       check if we haven't processed the member type already,
+            //       which is only safe since this is a consistency check
+            if (field_type->isStructureType() && layout.contains(context.getCanonicalType(field_type))) {
+                // Assert for self-consistency
+                auto field_meta = layout.at(context.getCanonicalType(field_type));
+                (void)types.at(context.getCanonicalType(field_type));
+                if (auto field_info = field_meta.get_if_simple_or_struct()) {
+                    if (field_info->size_bits != member_info.size_bits / member_info.array_size.value_or(1)) {
+                        throw std::runtime_error("Inconsistent type size detected");
+                    }
+                }
+            }
+
+            // Add built-in types, even if referenced through a pointer
+            for (auto* inner_field_type = field_type; inner_field_type; inner_field_type = inner_field_type->getPointeeType().getTypePtrOrNull()) {
+                if (inner_field_type->isBuiltinType() || inner_field_type->isEnumeralType()) {
+                    // The analysis pass doesn't explicitly register built-in types, so add them manually here
+                    SimpleTypeInfo info {
+                        .size_bits = context.getTypeSize(inner_field_type),
+                        .alignment_bits = context.getTypeAlign(inner_field_type),
+                    };
+                    if (!inner_field_type->isBuiltinType()) {
+                        inner_field_type = context.getCanonicalType(inner_field_type);
+                    }
+                    auto [prev, inserted] = layout.insert(std::pair { inner_field_type, info });
+//                    if (!inserted && prev->second != TypeInfo { info }) {
+//                        // TODO: Throw error since consistency check failed
+//                    }
+                }
+            }
+
+            info.members.push_back(member_info);
+        }
+    }
+
+    for (const auto& [type, info] : layout) {
+        auto basic_info = info.get_if_simple_or_struct();
+        if (!basic_info) {
+            continue;
+        }
+
+        fprintf(stderr, "  Host entry %s: %lu (%lu)\n", clang::QualType { type, 0 }.getAsString().c_str(), basic_info->size_bits / 8, basic_info->alignment_bits / 8);
+
+        if (auto struct_info = info.get_if_struct()) {
+            for (const auto& member : struct_info->members) {
+                fprintf(stderr, "    Offset %lu-%lu: %s %s%s\n", member.offset_bits / 8, (member.offset_bits + member.size_bits - 1) / 8, member.type_name.c_str(), member.member_name.c_str(), member.array_size ? fmt::format("[{}]", member.array_size.value()).c_str() : "");
+            }
+        }
+    }
+
+    return layout;
+}
diff --git a/ThunkLibs/Generator/data_layout.h b/ThunkLibs/Generator/data_layout.h
new file mode 100644
index 0000000000..046cf54b57
--- /dev/null
+++ b/ThunkLibs/Generator/data_layout.h
@@ -0,0 +1,82 @@
+#pragma once
+
+#include "analysis.h" // TODO: Drop include
+
+#include <clang/Frontend/FrontendAction.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+struct SimpleTypeInfo {
+    uint64_t size_bits;
+    uint64_t alignment_bits;
+
+    bool operator==(const SimpleTypeInfo& other) const {
+        return  size_bits == other.size_bits &&
+                alignment_bits == other.alignment_bits;
+    }
+};
+
+struct StructInfo : SimpleTypeInfo {
+    struct MemberInfo {
+        uint64_t size_bits; // size of this member. For arrays, total size of all elements
+        uint64_t offset_bits;
+        std::string type_name;
+        std::string member_name;
+        std::optional<uint64_t> array_size;
+
+        bool operator==(const MemberInfo& other) const {
+            return  size_bits == other.size_bits &&
+                    offset_bits == other.offset_bits &&
+                    type_name == other.type_name &&
+                    member_name == other.member_name &&
+                    array_size == other.array_size;
+        }
+    };
+
+    std::vector<MemberInfo> members;
+
+    bool operator==(const StructInfo& other) const {
+        return (const SimpleTypeInfo&)*this == (const SimpleTypeInfo&)other &&
+                std::equal(members.begin(), members.end(), other.members.begin(), other.members.end());
+    }
+};
+
+struct TypeInfo : std::variant<std::monostate, SimpleTypeInfo, StructInfo> {
+    using Parent = std::variant<std::monostate, SimpleTypeInfo, StructInfo>;
+
+    TypeInfo() = default;
+    TypeInfo(const SimpleTypeInfo& info) : Parent(info) {}
+    TypeInfo(const StructInfo& info) : Parent(info) {}
+
+    // Opaque declaration with no full definition.
+    // Pointers to these can still be passed along ABI boundaries assuming
+    // implementation details are only ever accessed on one side.
+    bool is_opaque() const {
+        return std::holds_alternative<std::monostate>(*this);
+    }
+
+    const StructInfo* get_if_struct() const {
+        return std::get_if<StructInfo>(this);
+    }
+
+    StructInfo* get_if_struct() {
+        return std::get_if<StructInfo>(this);
+    }
+
+    const SimpleTypeInfo* get_if_simple_or_struct() const {
+        auto as_struct = std::get_if<StructInfo>(this);
+        if (as_struct) {
+            return as_struct;
+        }
+        return std::get_if<SimpleTypeInfo>(this);
+    }
+};
+
+std::unordered_map<const clang::Type*, TypeInfo>
+ComputeDataLayout(const clang::ASTContext& context, const std::unordered_map<const clang::Type*, AnalysisAction::RepackedType>& types);
+
diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index bef050da23..70386d95a4 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -1,4 +1,5 @@
 #include "analysis.h"
+#include "data_layout.h"
 #include "interface.h"
 
 #include <clang/Frontend/CompilerInstance.h>
@@ -48,6 +49,10 @@ static std::string format_function_args(const FunctionParams& params, Fn&& forma
 };
 
 void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
+    {
+        const auto host_abi = ComputeDataLayout(context, types);
+    }
+
     static auto format_decl = [](clang::QualType type, const std::string_view& name) {
         clang::QualType innermostPointee = type;
         while (innermostPointee->isPointerType()) {

From c0ba993dda29c8b5084881b2424ee37744b65a48 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Thu, 24 Aug 2023 11:23:52 +0200
Subject: [PATCH 04/48] Thunks/gen: Add detection logic for data layout
 differences

This runs the data layout analysis pass added in the previous change twice:
Once for the host architecture and once for the guest architecture. This
allows the new DataLayoutCompareAction to query architecture differences for
each type, which can then be used to instruct code generation accordingly.

Currently, type compatibility is classified into 3 categories:
* Fully compatible (same size/alignment for the type itself and any members)
* Repackable (incompatibility can be resolved with emission of automatable
  repacking code, e.g. when struct members are located at differing offsets
  due to padding bytes)
* Incompatible
---
 ThunkLibs/Generator/data_layout.cpp | 192 ++++++++++++++++++++++++++++
 ThunkLibs/Generator/data_layout.h   |  40 +++++-
 ThunkLibs/Generator/gen.cpp         |  25 ++--
 ThunkLibs/Generator/interface.h     |  33 ++++-
 ThunkLibs/Generator/main.cpp        |  34 ++++-
 ThunkLibs/GuestLibs/CMakeLists.txt  |  13 +-
 ThunkLibs/HostLibs/CMakeLists.txt   |  12 +-
 unittests/ThunkLibs/generator.cpp   |  18 ++-
 8 files changed, 343 insertions(+), 24 deletions(-)

diff --git a/ThunkLibs/Generator/data_layout.cpp b/ThunkLibs/Generator/data_layout.cpp
index 220a9681b6..af5ba5cd81 100644
--- a/ThunkLibs/Generator/data_layout.cpp
+++ b/ThunkLibs/Generator/data_layout.cpp
@@ -6,6 +6,20 @@
 
 #include <openssl/sha.h>
 
+// Visitor for gathering data layout information that can be passed across libclang invocations
+class AnalyzeDataLayoutAction : public AnalysisAction {
+    ABI& type_abi;
+
+    // TODO: Needs a different name now
+    void EmitOutput(clang::ASTContext&) override;
+
+public:
+    AnalyzeDataLayoutAction(ABI&);
+};
+
+AnalyzeDataLayoutAction::AnalyzeDataLayoutAction(ABI& abi_) : type_abi(abi_) {
+}
+
 std::unordered_map<const clang::Type*, TypeInfo> ComputeDataLayout(const clang::ASTContext& context, const std::unordered_map<const clang::Type*, AnalysisAction::RepackedType>& types) {
     std::unordered_map<const clang::Type*, TypeInfo> layout;
 
@@ -117,3 +131,181 @@ std::unordered_map<const clang::Type*, TypeInfo> ComputeDataLayout(const clang::
 
     return layout;
 }
+
+ABI GetStableLayout(const clang::ASTContext& context, const std::unordered_map<const clang::Type*, TypeInfo>& data_layout) {
+    ABI stable_layout;
+
+    for (auto [type, type_info] : data_layout) {
+        auto type_name = get_type_name(context, type);
+        auto [it, inserted] = stable_layout.insert(std::pair { type_name, type_info });
+        if (!inserted && it->second != type_info) {
+            throw std::runtime_error("Duplicate type information: Tried to re-register type \"" + type_name + "\"");
+        }
+    }
+
+    stable_layout.pointer_size = context.getTypeSize(context.getUIntPtrType()) / 8;
+
+    return stable_layout;
+}
+
+void AnalyzeDataLayoutAction::EmitOutput(clang::ASTContext& context) {
+    type_abi = GetStableLayout(context, ComputeDataLayout(context, types));
+}
+
+TypeCompatibility DataLayoutCompareAction::GetTypeCompatibility(
+        const clang::ASTContext& context,
+        const clang::Type* type,
+        const std::unordered_map<const clang::Type*, TypeInfo> host_abi,
+        std::unordered_map<const clang::Type*, TypeCompatibility>& type_compat) {
+    assert(type->isCanonicalUnqualified() || type->isBuiltinType() || type->isEnumeralType());
+
+    {
+        // Reserve a slot to be filled later. The placeholder value is used
+        // to detect infinite recursions.
+        constexpr auto placeholder_compat = TypeCompatibility { 100 };
+        auto [existing_compat_it, is_new_type] = type_compat.emplace(type, placeholder_compat);
+        if (!is_new_type) {
+            if (existing_compat_it->second == placeholder_compat) {
+                throw std::runtime_error("Found recursive reference to type \"" + clang::QualType { type, 0 }.getAsString() + "\"");
+            }
+
+            return existing_compat_it->second;
+        }
+    }
+
+    const auto& guest_abi = abi;
+    auto type_name = get_type_name(context, type);
+    auto& guest_info = guest_abi.at(type_name);
+    auto& host_info = host_abi.at(type->isBuiltinType() ? type : context.getCanonicalType(type));
+
+    const bool is_32bit = (guest_abi.pointer_size == 4);
+
+    // Assume full compatibility, then downgrade as needed
+    auto compat = TypeCompatibility::Full;
+
+    if (guest_info != host_info) {
+        // Non-matching data layout... downgrade to Repackable
+        // TODO: Even for non-structs, this only works if the types are reasonably similar (e.g. uint32_t -> uint64_t)
+        compat = TypeCompatibility::Repackable;
+    }
+
+    if (auto guest_struct_info = guest_info.get_if_struct()) {
+        const AnalysisAction::RepackedType& type_repack_info = types.at(type);
+
+        std::vector<TypeCompatibility> member_compat;
+        for (std::size_t member_idx = 0; member_idx < guest_struct_info->members.size(); ++member_idx) {
+            // Look up the corresponding member in the host struct definition.
+            // The members may be listed in a different order, so we can't
+            // directly use member_idx for this
+            auto* host_member_field = [&]() -> clang::FieldDecl* {
+                auto struct_decl = type->getAsStructureType()->getDecl();
+                auto it = std::find_if(struct_decl->field_begin(), struct_decl->field_end(), [&](auto* field) {
+                    return field->getName() == guest_struct_info->members.at(member_idx).member_name;
+                });
+                if (it == struct_decl->field_end()) {
+                    return nullptr;
+                }
+                return *it;
+            }();
+            if (!host_member_field) {
+                // No corresponding host struct member
+                // TODO: Also detect host members that are missing from the guest struct
+                member_compat.push_back(TypeCompatibility::None);
+                break;
+            }
+
+            auto host_member_type = context.getCanonicalType(host_member_field->getType().getTypePtr());
+            if (auto array_type = llvm::dyn_cast<clang::ConstantArrayType>(host_member_type)) {
+                // Compare array element type only. The array size is already considered by the layout information of the containing struct.
+                host_member_type = context.getCanonicalType(array_type->getElementType().getTypePtr());
+            }
+
+            if (host_member_type->isPointerType()) {
+                // Automatic repacking of pointers to non-compatible types is only possible if:
+                // * Pointee is fully compatible, or
+                // * Pointer member is annotated
+                // TODO: Don't restrict this to structure types. it applies to pointers to builtin types too!
+                auto host_member_pointee_type = context.getCanonicalType(host_member_type->getPointeeType().getTypePtr());
+                if (host_member_pointee_type->isPointerType()) {
+                    // This is a nested pointer, e.g. void**
+
+                    if (is_32bit) {
+                        // Nested pointers can't be repacked on 32-bit
+                        member_compat.push_back(TypeCompatibility::None);
+                    } else {
+                        // Check the innermost type's compatibility on 64-bit
+                        auto pointee_pointee_type = host_member_pointee_type->getPointeeType().getTypePtr();
+                        // TODO: Not sure how to handle void here. Probably should require an annotation instead of "just working"
+                        auto pointee_pointee_compat = pointee_pointee_type->isVoidType() ? TypeCompatibility::Full : GetTypeCompatibility(context, pointee_pointee_type, host_abi, type_compat);
+                        if (pointee_pointee_compat == TypeCompatibility::Full) {
+                            member_compat.push_back(TypeCompatibility::Full);
+                        } else {
+                            member_compat.push_back(TypeCompatibility::None);
+                        }
+                    }
+                } else if (!host_member_pointee_type->isVoidType() && (host_member_pointee_type->isBuiltinType() || host_member_pointee_type->isEnumeralType())) {
+                    // TODO: What are good heuristics for this?
+                    // size_t should yield TypeCompatibility::Repackable
+                    // inconsistent types should probably default to TypeCompatibility::None
+                    // For now, just always assume compatible... (will degrade to Repackable below)
+                    member_compat.push_back(TypeCompatibility::Full);
+                } else if (!host_member_pointee_type->isVoidType() && (host_member_pointee_type->isStructureType() || types.contains(host_member_pointee_type))) {
+                    auto pointee_compat = GetTypeCompatibility(context, host_member_pointee_type, host_abi, type_compat);
+                    if (pointee_compat == TypeCompatibility::Full) {
+                        // Pointee is fully compatible, so automatic repacking only requires converting the pointers themselves
+                        member_compat.push_back(is_32bit ? TypeCompatibility::Repackable : TypeCompatibility::Full);
+                    } else {
+                        // If the pointee is incompatible (even if repackable), automatic repacking isn't possible
+                        member_compat.push_back(TypeCompatibility::None);
+                    }
+                } else if (!is_32bit && host_member_pointee_type->isVoidType()) {
+                    // TODO: Not sure how to handle void here. Probably should require an annotation instead of "just working"
+                    member_compat.push_back(TypeCompatibility::Full);
+                } else {
+                    member_compat.push_back(TypeCompatibility::None);
+                }
+                continue;
+            }
+
+            if (guest_abi.at(guest_struct_info->members[member_idx].type_name).get_if_struct()) {
+                auto host_type_info = host_abi.at(host_member_type);
+                member_compat.push_back(GetTypeCompatibility(context, host_member_type, host_abi, type_compat));
+            } else {
+                // Member was checked for size/alignment above already
+            }
+        }
+
+        if (std::all_of(member_compat.begin(), member_compat.end(), [](auto compat) { return compat == TypeCompatibility::Full; })) {
+            // TypeCompatibility::Full or ::Repackable
+        } else if (std::none_of(member_compat.begin(), member_compat.end(), [](auto compat) { return compat == TypeCompatibility::None; })) {
+            // Downgrade to Repackable
+            compat = TypeCompatibility::Repackable;
+        } else {
+            // Downgrade to None
+            compat = TypeCompatibility::None;
+        }
+    }
+
+    type_compat.at(type) = compat;
+    return compat;
+}
+
+DataLayoutCompareActionFactory::DataLayoutCompareActionFactory(const ABI& abi) : abi(abi) {
+
+}
+
+DataLayoutCompareActionFactory::~DataLayoutCompareActionFactory() = default;
+
+std::unique_ptr<clang::FrontendAction> DataLayoutCompareActionFactory::create() {
+    return std::make_unique<DataLayoutCompareAction>(abi);
+}
+
+AnalyzeDataLayoutActionFactory::AnalyzeDataLayoutActionFactory() : abi(std::make_unique<ABI>()) {
+
+}
+
+AnalyzeDataLayoutActionFactory::~AnalyzeDataLayoutActionFactory() = default;
+
+std::unique_ptr<clang::FrontendAction> AnalyzeDataLayoutActionFactory::create() {
+    return std::make_unique<AnalyzeDataLayoutAction>(*abi);
+}
diff --git a/ThunkLibs/Generator/data_layout.h b/ThunkLibs/Generator/data_layout.h
index 046cf54b57..6d0546ad93 100644
--- a/ThunkLibs/Generator/data_layout.h
+++ b/ThunkLibs/Generator/data_layout.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "analysis.h" // TODO: Drop include
+#include "analysis.h" // TODO: Drop include. Currently needed for ParameterAnnotations though
 
 #include <clang/Frontend/FrontendAction.h>
 
@@ -77,6 +77,44 @@ struct TypeInfo : std::variant<std::monostate, SimpleTypeInfo, StructInfo> {
     }
 };
 
+struct FuncPtrInfo {
+    std::array<uint8_t, 32> sha256;
+    std::string result;
+    std::vector<std::string> args;
+
+    // TODO: Do we actually need these here? Instead, we can fixup the parameters in-place!
+    std::unordered_map<unsigned, ParameterAnnotations> param_annotations;
+};
+
+struct ABI : std::unordered_map<std::string, TypeInfo> {
+    int pointer_size; // in bytes
+};
+
 std::unordered_map<const clang::Type*, TypeInfo>
 ComputeDataLayout(const clang::ASTContext& context, const std::unordered_map<const clang::Type*, AnalysisAction::RepackedType>& types);
 
+// Convert the output of ComputeDataLayout to a format that isn't tied to a libclang session.
+// As a consequence, type information is indexed by type name instead of clang::Type.
+ABI GetStableLayout(const clang::ASTContext& context, const std::unordered_map<const clang::Type*, TypeInfo>& data_layout);
+
+enum class TypeCompatibility {
+    Full,       // Type has matching data layout across architectures
+    Repackable, // Type has different data layout but can be repacked automatically
+    None,       // Type has different data layout and cannot be repacked automatically
+};
+
+class DataLayoutCompareAction : public AnalysisAction {
+public:
+    DataLayoutCompareAction(const ABI& abi) : abi(abi) {
+    }
+
+    TypeCompatibility GetTypeCompatibility(
+            const clang::ASTContext&,
+            const clang::Type*,
+            const std::unordered_map<const clang::Type*, TypeInfo> host_abi,
+            std::unordered_map<const clang::Type*, TypeCompatibility>& type_compat);
+
+protected: // TODO: Should probably be private
+    // TODO: Make it clearer that this is the guest ABI
+    const ABI& abi;
+};
diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index 70386d95a4..2d2260b53f 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -1,7 +1,7 @@
 #include "analysis.h"
 #include "data_layout.h"
+#include "diagnostics.h"
 #include "interface.h"
-
 #include <clang/Frontend/CompilerInstance.h>
 
 #include <fstream>
@@ -9,15 +9,16 @@
 #include <iostream>
 #include <string_view>
 #include <unordered_map>
+#include <variant>
 
 #include <fmt/format.h>
 #include <fmt/ostream.h>
 
 #include <openssl/sha.h>
 
-class GenerateThunkLibsAction : public AnalysisAction {
+class GenerateThunkLibsAction : public DataLayoutCompareAction {
 public:
-    GenerateThunkLibsAction(const std::string& libname, const OutputFilenames&);
+    GenerateThunkLibsAction(const std::string& libname, const OutputFilenames&, const ABI& abi);
 
 private:
     // Generate helper code for thunk libraries and write them to the output file
@@ -28,8 +29,8 @@ class GenerateThunkLibsAction : public AnalysisAction {
     const OutputFilenames& output_filenames;
 };
 
-GenerateThunkLibsAction::GenerateThunkLibsAction(const std::string& libname_, const OutputFilenames& output_filenames_)
-    : libfilename(libname_), libname(libname_), output_filenames(output_filenames_) {
+GenerateThunkLibsAction::GenerateThunkLibsAction(const std::string& libname_, const OutputFilenames& output_filenames_, const ABI& abi)
+    : DataLayoutCompareAction(abi), libfilename(libname_), libname(libname_), output_filenames(output_filenames_) {
     for (auto& c : libname) {
         if (c == '-') {
             c = '_';
@@ -49,9 +50,17 @@ static std::string format_function_args(const FunctionParams& params, Fn&& forma
 };
 
 void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
-    {
+    ErrorReporter report_error { context };
+
+    // Compute data layout differences between host and guest
+    auto type_compat = [&]() {
+        std::unordered_map<const clang::Type*, TypeCompatibility> ret;
         const auto host_abi = ComputeDataLayout(context, types);
-    }
+        for (const auto& [type, type_repack_info] : types) {
+            GetTypeCompatibility(context, type, host_abi, ret);
+        }
+        return ret;
+    }();
 
     static auto format_decl = [](clang::QualType type, const std::string_view& name) {
         clang::QualType innermostPointee = type;
@@ -376,7 +385,7 @@ bool GenerateThunkLibsActionFactory::runInvocation(
   Compiler.setInvocation(std::move(Invocation));
   Compiler.setFileManager(Files);
 
-  GenerateThunkLibsAction Action(libname, output_filenames);
+  GenerateThunkLibsAction Action(libname, output_filenames, abi);
 
   Compiler.createDiagnostics(DiagConsumer, false);
   if (!Compiler.hasDiagnostics())
diff --git a/ThunkLibs/Generator/interface.h b/ThunkLibs/Generator/interface.h
index 62883670ac..86768d34f4 100644
--- a/ThunkLibs/Generator/interface.h
+++ b/ThunkLibs/Generator/interface.h
@@ -8,10 +8,38 @@ struct OutputFilenames {
     std::string guest;
 };
 
+class AnalyzeDataLayoutActionFactory : public clang::tooling::FrontendActionFactory {
+    std::unique_ptr<struct ABI> abi;
+
+public:
+    AnalyzeDataLayoutActionFactory();
+    ~AnalyzeDataLayoutActionFactory();
+
+    std::unique_ptr<clang::FrontendAction> create() override;
+
+    const ABI& GetDataLayout() {
+        return *abi;
+    }
+
+    std::unique_ptr<ABI> TakeDataLayout() {
+        return std::move(abi);
+    }
+};
+
+class DataLayoutCompareActionFactory : public clang::tooling::FrontendActionFactory {
+    const ABI& abi;
+
+public:
+    DataLayoutCompareActionFactory(const ABI&);
+    ~DataLayoutCompareActionFactory();
+
+    std::unique_ptr<clang::FrontendAction> create() override;
+};
+
 class GenerateThunkLibsActionFactory : public clang::tooling::ToolAction {
 public:
-    GenerateThunkLibsActionFactory(std::string_view libname_, OutputFilenames output_filenames_)
-        : libname(std::move(libname_)), output_filenames(std::move(output_filenames_)) {
+    GenerateThunkLibsActionFactory(std::string_view libname_, OutputFilenames output_filenames_, const ABI& abi_)
+        : libname(std::move(libname_)), output_filenames(std::move(output_filenames_)), abi(abi_) {
     }
 
     bool runInvocation(
@@ -22,4 +50,5 @@ class GenerateThunkLibsActionFactory : public clang::tooling::ToolAction {
 private:
     std::string libname;
     OutputFilenames output_filenames;
+    const ABI& abi;
 };
diff --git a/ThunkLibs/Generator/main.cpp b/ThunkLibs/Generator/main.cpp
index ecc32bd684..726e5cbfa4 100644
--- a/ThunkLibs/Generator/main.cpp
+++ b/ThunkLibs/Generator/main.cpp
@@ -14,10 +14,10 @@ void print_usage(const char* program_name) {
     std::cerr << "Usage: " << program_name << " <filename> <libname> <gen_target> <output_filename> -- <clang_flags>\n";
 }
 
-int main(int argc, char* argv[]) {
+int main(int argc, char* const argv[]) {
     llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
 
-    if (argc < 6) {
+    if (argc < 5) {
         print_usage(argv[0]);
         return EXIT_FAILURE;
     }
@@ -32,12 +32,12 @@ int main(int argc, char* argv[]) {
     }
 
     // Process arguments before the "--" separator
-    if (argc != 5) {
+    if (argc != 5 && argc != 6) {
         print_usage(argv[0]);
         return EXIT_FAILURE;
     }
 
-    char** arg = argv + 1;
+    char* const* arg = argv + 1;
     const auto filename = *arg++;
     const std::string libname = *arg++;
     const std::string target_abi = *arg++;
@@ -62,5 +62,29 @@ int main(int argc, char* argv[]) {
         };
         Tool.appendArgumentsAdjuster(set_resource_directory);
     }
-    return Tool.run(std::make_unique<GenerateThunkLibsActionFactory>(std::move(libname), std::move(output_filenames)).get());
+
+    ClangTool GuestTool = Tool;
+
+    {
+        const bool is_32bit_guest = (argv[5] == std::string_view { "-for-32bit-guest" });
+        auto append_guest_args = [is_32bit_guest](const clang::tooling::CommandLineArguments &Args, clang::StringRef) {
+            clang::tooling::CommandLineArguments AdjustedArgs = Args;
+            const char* platform = is_32bit_guest ? "i686" : "x86_64";
+            if (is_32bit_guest) {
+                AdjustedArgs.push_back("-m32");
+                AdjustedArgs.push_back("-DIS_32BIT_THUNK");
+            }
+            AdjustedArgs.push_back(std::string { "--target=" } + platform + "-linux-unknown");
+            AdjustedArgs.push_back("-isystem");
+            AdjustedArgs.push_back(std::string { "/usr/" } + platform + "-linux-gnu/include/");
+            return AdjustedArgs;
+        };
+        GuestTool.appendArgumentsAdjuster(append_guest_args);
+    }
+
+    auto data_layout_analysis_factory = std::make_unique<AnalyzeDataLayoutActionFactory>();
+    GuestTool.run(data_layout_analysis_factory.get());
+    auto& data_layout = data_layout_analysis_factory->GetDataLayout();
+
+    return Tool.run(std::make_unique<GenerateThunkLibsActionFactory>(std::move(libname), std::move(output_filenames), data_layout).get());
 }
diff --git a/ThunkLibs/GuestLibs/CMakeLists.txt b/ThunkLibs/GuestLibs/CMakeLists.txt
index 69223e8a4d..579998bf82 100644
--- a/ThunkLibs/GuestLibs/CMakeLists.txt
+++ b/ThunkLibs/GuestLibs/CMakeLists.txt
@@ -17,7 +17,7 @@ endif()
 
 if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
   # We've been included using ExternalProject_add, so set up the actual thunk libraries to be cross-compiled
-  set(CMAKE_CXX_STANDARD 17)
+  set(CMAKE_CXX_STANDARD 20)
 
   # This gets passed in from the main cmake project
   set (DATA_DIRECTORY "${CMAKE_INSTALL_PREFIX}/share/fex-emu" CACHE PATH "global data directory")
@@ -52,6 +52,9 @@ function(generate NAME SOURCE_FILE)
   add_library(${NAME}-guest-deps INTERFACE)
   target_include_directories(${NAME}-guest-deps INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/../include")
   target_compile_definitions(${NAME}-guest-deps INTERFACE GUEST_THUNK_LIBRARY)
+  if (BITNESS EQUAL 32)
+    target_compile_definitions(${NAME}-guest-deps INTERFACE IS_32BIT_THUNK)
+  endif ()
   # Shorthand for the include directories added after calling this function.
   # This is not evaluated directly, hence directories added after return are still picked up
   set(prop "$<TARGET_PROPERTY:${NAME}-guest-deps,INTERFACE_INCLUDE_DIRECTORIES>")
@@ -64,16 +67,18 @@ function(generate NAME SOURCE_FILE)
   file(MAKE_DIRECTORY "${OUTFOLDER}")
 
   if (BITNESS EQUAL 32)
-    set (BITNESS_FLAGS "-m32" "--target=i686-linux-unknown" "-isystem" "/usr/i686-linux-gnu/include/")
+    set (BITNESS_FLAGS "-for-32bit-guest")
+    set (BITNESS_FLAGS2 "-m32" "--target=i686-linux-unknown" "-isystem" "/usr/i686-linux-gnu/include/")
   else()
-    set (BITNESS_FLAGS "--target=x86_64-linux-unknown" "-isystem" "/usr/x86_64-linux-gnu/include/")
+    set (BITNESS_FLAGS "")
+    set (BITNESS_FLAGS2 "--target=x86_64-linux-unknown" "-isystem" "/usr/x86_64-linux-gnu/include/")
   endif()
 
   add_custom_command(
     OUTPUT "${OUTFILE}"
     DEPENDS "${GENERATOR_EXE}"
     DEPENDS "${SOURCE_FILE}"
-    COMMAND "${GENERATOR_EXE}" "${SOURCE_FILE}" "${NAME}" "-guest" "${OUTFILE}" -- -std=c++17 ${BITNESS_FLAGS}
+    COMMAND "${GENERATOR_EXE}" "${SOURCE_FILE}" "${NAME}" "-guest" "${OUTFILE}" ${BITNESS_FLAGS} -- -std=c++20 ${BITNESS_FLAGS2}
       # Expand compile definitions to space-separated list of -D parameters
       "$<$<BOOL:${compile_prop}>:;-D$<JOIN:${compile_prop},;-D>>"
       # Expand include directories to space-separated list of -isystem parameters
diff --git a/ThunkLibs/HostLibs/CMakeLists.txt b/ThunkLibs/HostLibs/CMakeLists.txt
index cc2a5dceef..9c89a30e4d 100644
--- a/ThunkLibs/HostLibs/CMakeLists.txt
+++ b/ThunkLibs/HostLibs/CMakeLists.txt
@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.14)
 project(host-thunks)
 include(${FEX_PROJECT_SOURCE_DIR}/CMakeFiles/version_to_variables.cmake)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set (HOSTLIBS_DATA_DIRECTORY "${CMAKE_INSTALL_PREFIX}/lib/fex-emu" CACHE PATH "global data directory")
 option(ENABLE_CLANG_THUNKS "Enable building thunks with clang" FALSE)
 
@@ -21,6 +21,9 @@ function(generate NAME SOURCE_FILE GUEST_BITNESS)
   add_library(${NAME}-${GUEST_BITNESS}-deps INTERFACE)
   target_include_directories(${NAME}-${GUEST_BITNESS}-deps INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/../include")
   target_link_libraries(${NAME}-${GUEST_BITNESS}-deps INTERFACE FEXLoader)
+  if (GUEST_BITNESS EQUAL 32)
+    target_compile_definitions(${NAME}-${GUEST_BITNESS}-deps INTERFACE IS_32BIT_THUNK)
+  endif ()
   # Shorthand for the include directories added after calling this function.
   # This is not evaluated directly, hence directories added after return are still picked up
   set(prop "$<TARGET_PROPERTY:${NAME}-${GUEST_BITNESS}-deps,INTERFACE_INCLUDE_DIRECTORIES>")
@@ -41,11 +44,16 @@ function(generate NAME SOURCE_FILE GUEST_BITNESS)
 
   file(MAKE_DIRECTORY "${OUTFOLDER}")
 
+  set (BITNESS_FLAGS "")
+  if (GUEST_BITNESS EQUAL 32)
+    set (BITNESS_FLAGS "-for-32bit-guest")
+  endif()
+
   add_custom_command(
     OUTPUT "${OUTFILE}"
     DEPENDS "${SOURCE_FILE}"
     DEPENDS thunkgen
-    COMMAND thunkgen "${SOURCE_FILE}" "${NAME}" "-host" "${OUTFILE}" -- -std=c++17
+    COMMAND thunkgen "${SOURCE_FILE}" "${NAME}" "-host" "${OUTFILE}" ${BITNESS_FLAGS} -- -std=c++20
       # Expand compile definitions to space-separated list of -D parameters
       "$<$<BOOL:${compile_prop}>:;-D$<JOIN:${compile_prop},;-D>>"
       # Expand include directories to space-separated list of -isystem parameters
diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index 4958d957eb..ae07a82fe1 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -202,7 +202,14 @@ SourceWithAST::SourceWithAST(std::string_view input) : code(input) {
  */
 SourceWithAST Fixture::run_thunkgen_guest(std::string_view prelude, std::string_view code, bool silent) {
     const std::string full_code = std::string { prelude } + std::string { code };
-    run_tool(std::make_unique<GenerateThunkLibsActionFactory>(libname, output_filenames), full_code, silent);
+
+    // These tests don't deal with data layout differences, so just run data
+    // layout analysis with host configuration
+    auto data_layout_analysis_factory = std::make_unique<AnalyzeDataLayoutActionFactory>();
+    run_tool(*data_layout_analysis_factory, full_code, silent);
+    auto& data_layout = data_layout_analysis_factory->GetDataLayout();
+
+    run_tool(std::make_unique<GenerateThunkLibsActionFactory>(libname, output_filenames, data_layout), full_code, silent);
 
     std::string result =
         "#include <cstdint>\n"
@@ -231,7 +238,14 @@ SourceWithAST Fixture::run_thunkgen_guest(std::string_view prelude, std::string_
  */
 SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_view code, bool silent) {
     const std::string full_code = std::string { prelude } + std::string { code };
-    run_tool(std::make_unique<GenerateThunkLibsActionFactory>(libname, output_filenames), full_code, silent);
+
+    // These tests don't deal with data layout differences, so just run data
+    // layout analysis with host configuration
+    auto data_layout_analysis_factory = std::make_unique<AnalyzeDataLayoutActionFactory>();
+    run_tool(*data_layout_analysis_factory, full_code, silent);
+    auto& data_layout = data_layout_analysis_factory->GetDataLayout();
+
+    run_tool(std::make_unique<GenerateThunkLibsActionFactory>(libname, output_filenames, data_layout), full_code, silent);
 
     std::string result =
         "#include <cstdint>\n"

From 561fa3fb265185f31068a25c1ac0dd6aed22c7b4 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Thu, 3 Aug 2023 11:07:19 +0200
Subject: [PATCH 05/48] TODOFINISH. Add new annotations everywhere

---
 ThunkLibs/HostLibs/CMakeLists.txt             |   3 +-
 ThunkLibs/libGL/libGL_interface.cpp           |  37 ++-
 ThunkLibs/libX11/libX11_Guest.cpp             |   2 +
 ThunkLibs/libX11/libX11_Host.cpp              |   8 +
 ThunkLibs/libX11/libX11_interface.cpp         |  63 ++++++
 ThunkLibs/libXext/libXext_Guest.cpp           |   2 +
 ThunkLibs/libXext/libXext_Host.cpp            |   7 +
 ThunkLibs/libXext/libXext_interface.cpp       |  41 ++++
 ThunkLibs/libXfixes/libXfixes_Host.cpp        |   5 +
 ThunkLibs/libXfixes/libXfixes_interface.cpp   |  12 +
 ThunkLibs/libXrender/libXrender_Host.cpp      |   6 +
 ThunkLibs/libXrender/libXrender_interface.cpp |  17 ++
 ThunkLibs/libasound/libasound_interface.cpp   |  85 ++++++-
 ThunkLibs/libdrm/libdrm_interface.cpp         |  21 +-
 ThunkLibs/libvulkan/Guest.cpp                 |   2 +
 ThunkLibs/libvulkan/Host.cpp                  |   4 +
 ThunkLibs/libvulkan/libvulkan_interface.cpp   | 210 +++++++++++++++++-
 .../libwayland-client_interface.cpp           |  23 +-
 .../libxcb-dri2/libxcb-dri2_interface.cpp     |   6 +
 .../libxcb-dri3/libxcb-dri3_interface.cpp     |   6 +
 ThunkLibs/libxcb-glx/libxcb-glx_interface.cpp |   6 +
 .../libxcb-present_interface.cpp              |   6 +
 .../libxcb-randr/libxcb-randr_interface.cpp   |  11 +
 ThunkLibs/libxcb-shm/libxcb-shm_interface.cpp |   7 +
 .../libxcb-sync/libxcb-sync_interface.cpp     |   6 +
 .../libxcb-xfixes/libxcb-xfixes_interface.cpp |   6 +
 ThunkLibs/libxcb/libxcb_interface.cpp         |   9 +
 .../libxshmfence/libxshmfence_interface.cpp   |   5 +
 28 files changed, 601 insertions(+), 15 deletions(-)

diff --git a/ThunkLibs/HostLibs/CMakeLists.txt b/ThunkLibs/HostLibs/CMakeLists.txt
index 9c89a30e4d..a98c819a6a 100644
--- a/ThunkLibs/HostLibs/CMakeLists.txt
+++ b/ThunkLibs/HostLibs/CMakeLists.txt
@@ -96,7 +96,8 @@ function(add_host_lib NAME GUEST_BITNESS)
   endif()
 endfunction()
 
-set (BITNESS_LIST "32;64")
+#set (BITNESS_LIST "32;64")
+set (BITNESS_LIST "64")
 foreach(GUEST_BITNESS IN LISTS BITNESS_LIST)
   #add_host_lib(fex_malloc_symbols ${GUEST_BITNESS})
 
diff --git a/ThunkLibs/libGL/libGL_interface.cpp b/ThunkLibs/libGL/libGL_interface.cpp
index e292b2e053..c01f3808fb 100644
--- a/ThunkLibs/libGL/libGL_interface.cpp
+++ b/ThunkLibs/libGL/libGL_interface.cpp
@@ -11,6 +11,8 @@
 #undef GL_ARB_viewport_array
 #include "glcorearb.h"
 
+#include <type_traits>
+
 template<auto>
 struct fex_gen_config {
     unsigned version = 1;
@@ -18,6 +20,25 @@ struct fex_gen_config {
 
 template<> struct fex_gen_config<glXGetProcAddress> : fexgen::custom_guest_entrypoint, fexgen::returns_guest_pointer {};
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<std::remove_pointer_t<GLXContext>> : fexgen::opaque_type {};
+template<> struct fex_gen_type<std::remove_pointer_t<GLXFBConfig>> : fexgen::opaque_type {};
+template<> struct fex_gen_type<std::remove_pointer_t<GLsync>> : fexgen::opaque_type {};
+
+// NOTE: These should be opaque, but actually aren't because the respective libraries aren't thunked
+template<> struct fex_gen_type<_cl_context> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_cl_event> : fexgen::opaque_type {};
+
+// Opaque for the purpose of libGL
+template<> struct fex_gen_type<_XDisplay> : fexgen::opaque_type {};
+
+#ifndef IS_32BIT_THUNK
+// TODO: These are largely compatible, *but* contain function pointer members that need adjustment!
+template<> struct fex_gen_type<XExtData> : fexgen::assume_compatible_data_layout {};
+#endif
+
 // Symbols queryable through glXGetProcAddr
 namespace internal {
 template<auto>
@@ -88,7 +109,7 @@ template<> struct fex_gen_config<glXDestroyGLXPixmap> {};
 template<> struct fex_gen_config<glXDestroyPbuffer> {};
 template<> struct fex_gen_config<glXDestroyPixmap> {};
 template<> struct fex_gen_config<glXDestroyWindow> {};
-template<> struct fex_gen_config<glXFreeMemoryNV> {};
+//template<> struct fex_gen_config<glXFreeMemoryNV> {};
 template<> struct fex_gen_config<glXGetSelectedEvent> {};
 template<> struct fex_gen_config<glXQueryDrawable> {};
 template<> struct fex_gen_config<glXSelectEvent> {};
@@ -698,9 +719,9 @@ template<> struct fex_gen_config<glCullFace> {};
 template<> struct fex_gen_config<glCullParameterdvEXT> {};
 template<> struct fex_gen_config<glCullParameterfvEXT> {};
 template<> struct fex_gen_config<glCurrentPaletteMatrixARB> {};
-template<> struct fex_gen_config<glDebugMessageCallbackAMD> : fexgen::callback_stub {};
-template<> struct fex_gen_config<glDebugMessageCallbackARB> : fexgen::callback_stub {};
-template<> struct fex_gen_config<glDebugMessageCallback> : fexgen::callback_stub {};
+//template<> struct fex_gen_config<glDebugMessageCallbackAMD> : fexgen::callback_stub {};
+//template<> struct fex_gen_config<glDebugMessageCallbackARB> : fexgen::callback_stub {};
+//template<> struct fex_gen_config<glDebugMessageCallback> : fexgen::callback_stub {};
 template<> struct fex_gen_config<glDebugMessageControlARB> {};
 template<> struct fex_gen_config<glDebugMessageControl> {};
 template<> struct fex_gen_config<glDebugMessageEnableAMD> {};
@@ -2379,10 +2400,10 @@ template<> struct fex_gen_config<glTexCoord4sv> {};
 template<> struct fex_gen_config<glTexCoord4xOES> {};
 template<> struct fex_gen_config<glTexCoord4xvOES> {};
 template<> struct fex_gen_config<glTexCoordFormatNV> {};
-template<> struct fex_gen_config<glTexCoordPointerEXT> {};
-template<> struct fex_gen_config<glTexCoordPointer> {};
-template<> struct fex_gen_config<glTexCoordPointerListIBM> {};
-template<> struct fex_gen_config<glTexCoordPointervINTEL> {};
+//template<> struct fex_gen_config<glTexCoordPointerEXT> {};
+//template<> struct fex_gen_config<glTexCoordPointer> {};
+//template<> struct fex_gen_config<glTexCoordPointerListIBM> {};
+//template<> struct fex_gen_config<glTexCoordPointervINTEL> {};
 template<> struct fex_gen_config<glTexEnvf> {};
 template<> struct fex_gen_config<glTexEnvfv> {};
 template<> struct fex_gen_config<glTexEnvi> {};
diff --git a/ThunkLibs/libX11/libX11_Guest.cpp b/ThunkLibs/libX11/libX11_Guest.cpp
index b32ad9228a..3a2547a769 100644
--- a/ThunkLibs/libX11/libX11_Guest.cpp
+++ b/ThunkLibs/libX11/libX11_Guest.cpp
@@ -14,6 +14,8 @@ extern "C" {
 #include <X11/Xproto.h>
 #include <X11/XKBlib.h>
 
+#include <X11/extensions/extutil.h>
+
 // Include Xlibint.h and undefine some of its macros that clash with the standard library
 #include <X11/Xlibint.h>
 #undef min
diff --git a/ThunkLibs/libX11/libX11_Host.cpp b/ThunkLibs/libX11/libX11_Host.cpp
index c73d7a6ea4..568543a708 100644
--- a/ThunkLibs/libX11/libX11_Host.cpp
+++ b/ThunkLibs/libX11/libX11_Host.cpp
@@ -20,12 +20,20 @@ extern "C" {
 #undef min
 #undef max
 
+#define XTRANS_SEND_FDS 1
+#include <X11/Xtrans/Xtransint.h>
+
 #include <X11/Xutil.h>
+#include <X11/Xregion.h>
 #include <X11/Xresource.h>
 
 #include <X11/Xproto.h>
 
+#include <X11/extensions/extutil.h>
 #include <X11/extensions/XKBstr.h>
+#include <X11/extensions/XKBgeom.h>
+
+#include <X11/Xtrans/Xtransint.h>
 }
 
 #include "common/Host.h"
diff --git a/ThunkLibs/libX11/libX11_interface.cpp b/ThunkLibs/libX11/libX11_interface.cpp
index 188826056c..15675e4fc5 100644
--- a/ThunkLibs/libX11/libX11_interface.cpp
+++ b/ThunkLibs/libX11/libX11_interface.cpp
@@ -10,11 +10,15 @@ extern "C" {
 
 #include <X11/ImUtil.h>
 
+#include <X11/extensions/extutil.h>
 #include <X11/extensions/Xext.h>
+#include <X11/extensions/XKBgeom.h>
 
 #include <X11/Xlibint.h>
 #include <X11/XKBlib.h>
 
+#include <X11/Xtrans/Xtransint.h>
+
 #include <X11/Xutil.h>
 }
 
@@ -28,6 +32,10 @@ struct fex_gen_config {
 template<typename>
 struct fex_gen_type {};
 
+// Function, parameter index, parameter type [optional]
+template<auto, int, typename = void>
+struct fex_gen_param {};
+
 template<> struct fex_gen_type<XID(Display*)> {}; // XDisplay::resource_alloc
 
 // NOTE: only indirect calls to this are allowed
@@ -54,6 +62,61 @@ template<> struct fex_gen_type<unsigned long(XImage*, int, int)> {};      // XIm
 template<> struct fex_gen_type<int(XImage*, int, int, unsigned long)> {}; // XImage::f.put_pixel
 template<> struct fex_gen_type<int(XImage*, long)> {};                    // XImage::f.add_pixel
 
+template<> struct fex_gen_type<std::remove_pointer_t<XIC>> : fexgen::opaque_type {};
+template<> struct fex_gen_type<std::remove_pointer_t<XIM>> : fexgen::opaque_type {};
+template<> struct fex_gen_type<std::remove_pointer_t<XOC>> : fexgen::opaque_type {};
+template<> struct fex_gen_type<std::remove_pointer_t<XOM>> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XrmHashBucketRec> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XkbInfoRec> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XContextDB> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XDisplayAtoms> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XLockInfo> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XIMFilter> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XErrorThreadInfo> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XKeytrans> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_X11XCBPrivate> : fexgen::opaque_type {};
+
+
+#ifndef IS_32BIT_THUNK
+// This has a public definition but is used as an opaque type in most APIs
+template<> struct fex_gen_type<std::remove_pointer_t<Region>> : fexgen::assume_compatible_data_layout {};
+
+// Union types
+template<> struct fex_gen_type<XEvent> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<xEvent> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<XkbDoodadRec> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<xReply> : fexgen::assume_compatible_data_layout {};
+
+// Union type of all sorts of different X objects... Further, XEHeadOfExtensionList casts this to XExtData**.
+// This is likely highly unsafe to assume compatible.
+template<> struct fex_gen_type<XEDataObject> : fexgen::assume_compatible_data_layout {};
+
+// Linked-list types
+template<> struct fex_gen_type<_XtransConnFd> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XkbDeviceLedChanges> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XQEvent> : fexgen::assume_compatible_data_layout {};
+
+// Contains nontrivial circular pointer relationships
+template<> struct fex_gen_type<XkbOverlayRec> : fexgen::assume_compatible_data_layout {};
+
+// TODO: These are largely compatible, *but* contain function pointer members that need adjustment!
+template<> struct fex_gen_type<_XConnWatchInfo> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<XExtData> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XLockPtrs> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XFreeFuncRec> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XExtension> : fexgen::assume_compatible_data_layout {}; // Also contains linked-list pointers
+template<> struct fex_gen_type<_XConnectionInfo> : fexgen::assume_compatible_data_layout {}; // Also contains linked-list pointers
+template<> struct fex_gen_type<_XInternalAsync> : fexgen::assume_compatible_data_layout {}; // Also contains linked-list pointers
+template<> struct fex_gen_type<_XDisplay> : fexgen::assume_compatible_data_layout {};
+
+// TODO: This contains a nested struct type of function pointer members
+template<> struct fex_gen_type<XImage> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<XExtensionHooks> : fexgen::assume_compatible_data_layout {};
+#endif
+
+// Union type (each member is defined in terms of char members)
+template<> struct fex_gen_type<XkbAction> : fexgen::assume_compatible_data_layout {};
+
 // Xlibint
 template<> struct fex_gen_config<_XGetRequest> {};
 template<> struct fex_gen_config<_XFlushGCCache> {};
diff --git a/ThunkLibs/libXext/libXext_Guest.cpp b/ThunkLibs/libXext/libXext_Guest.cpp
index 0db7e4dab7..e8684b83fb 100644
--- a/ThunkLibs/libXext/libXext_Guest.cpp
+++ b/ThunkLibs/libXext/libXext_Guest.cpp
@@ -35,6 +35,8 @@ extern "C" {
 #include <X11/extensions/syncconst.h>
 #include <X11/extensions/syncproto.h>
 //#include <X11/extensions/XTest.h>
+#undef min
+#undef max
 
 
 #include "common/Guest.h"
diff --git a/ThunkLibs/libXext/libXext_Host.cpp b/ThunkLibs/libXext/libXext_Host.cpp
index 94caa6be09..076087b806 100644
--- a/ThunkLibs/libXext/libXext_Host.cpp
+++ b/ThunkLibs/libXext/libXext_Host.cpp
@@ -8,6 +8,7 @@ tags: thunklibs|X11
 
 #include <X11/Xlib.h>
 #include <X11/Xlibint.h>
+#include <X11/Xregion.h>
 #include <X11/Xutil.h>
 #include <X11/Xproto.h>
 #include <X11/extensions/Xext.h>
@@ -38,6 +39,12 @@ extern "C" {
 #include <X11/extensions/syncproto.h>
 //#include <X11/extensions/XTest.h>
 
+#define XTRANS_SEND_FDS 1
+#include <X11/Xtrans/Xtransint.h>
+
+#undef min
+#undef max
+
 #include "common/Host.h"
 #include <dlfcn.h>
 
diff --git a/ThunkLibs/libXext/libXext_interface.cpp b/ThunkLibs/libXext/libXext_interface.cpp
index 87b0666bb5..18f6ccf1e4 100644
--- a/ThunkLibs/libXext/libXext_interface.cpp
+++ b/ThunkLibs/libXext/libXext_interface.cpp
@@ -2,6 +2,7 @@
 
 #include <X11/Xlib.h>
 #include <X11/Xlibint.h>
+#include <X11/Xregion.h>
 #include <X11/extensions/Xext.h>
 #include <X11/extensions/dpms.h>
 #include <X11/extensions/XEVI.h>
@@ -16,12 +17,52 @@
 extern "C" {
 #include <X11/extensions/extutil.h>
 }
+#include <X11/Xtrans/Xtransint.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 6;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<_X11XCBPrivate> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XContextDB> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XDisplayAtoms> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XErrorThreadInfo> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XIMFilter> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XkbInfoRec> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XKeytrans> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XLockInfo> : fexgen::opaque_type {};
+template<> struct fex_gen_type<_XrmHashBucketRec> : fexgen::opaque_type {};
+
+#ifndef IS_32BIT_THUNK
+// Union types
+template<> struct fex_gen_type<XEvent> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<xEvent> : fexgen::assume_compatible_data_layout {};
+
+// Linked-list types
+template<> struct fex_gen_type<_XtransConnFd> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XQEvent> : fexgen::assume_compatible_data_layout {};
+
+// TODO: These are largely compatible, *but* contain function pointer members that need adjustment!
+template<> struct fex_gen_type<_XConnectionInfo> : fexgen::assume_compatible_data_layout {}; // Also contains linked-list pointers
+template<> struct fex_gen_type<_XConnWatchInfo> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XDisplay> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<XExtData> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<XExtDisplayInfo> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XExtension> : fexgen::assume_compatible_data_layout {}; // Also contains linked-list pointers
+template<> struct fex_gen_type<_XInternalAsync> : fexgen::assume_compatible_data_layout {}; // Also contains linked-list pointers
+
+// Contains nontrivial circular pointer relationships
+template<> struct fex_gen_type<Screen> : fexgen::assume_compatible_data_layout {};
+
+// TODO: This contains a nested struct type of function pointer members
+template<> struct fex_gen_type<XImage> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<XExtensionHooks> : fexgen::assume_compatible_data_layout {};
+#endif
+
 template<> struct fex_gen_config<DPMSCapable> {};
 template<> struct fex_gen_config<DPMSDisable> {};
 template<> struct fex_gen_config<DPMSEnable> {};
diff --git a/ThunkLibs/libXfixes/libXfixes_Host.cpp b/ThunkLibs/libXfixes/libXfixes_Host.cpp
index b6a0a5ca92..0712fb90a7 100644
--- a/ThunkLibs/libXfixes/libXfixes_Host.cpp
+++ b/ThunkLibs/libXfixes/libXfixes_Host.cpp
@@ -6,9 +6,14 @@ tags: thunklibs|X11
 
 #include <stdio.h>
 
+extern "C" {
 #include <X11/Xlib.h>
+#include <X11/Xlibint.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xfixes.h>
+}
+#undef min
+#undef max
 
 #include "common/Host.h"
 #include <dlfcn.h>
diff --git a/ThunkLibs/libXfixes/libXfixes_interface.cpp b/ThunkLibs/libXfixes/libXfixes_interface.cpp
index 1bd6df682a..24c2227a4b 100644
--- a/ThunkLibs/libXfixes/libXfixes_interface.cpp
+++ b/ThunkLibs/libXfixes/libXfixes_interface.cpp
@@ -1,12 +1,24 @@
 #include <common/GeneratorInterface.h>
 
+extern "C" {
 #include <X11/extensions/Xfixes.h>
+#include <X11/Xlibint.h>
+}
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 3;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+#ifndef IS_32BIT_THUNK
+// TODO: These are largely compatible, *but* contain function pointer members that need adjustment!
+template<> struct fex_gen_type<XExtData> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XDisplay> : fexgen::assume_compatible_data_layout {};
+#endif
+
 template<> struct fex_gen_config<XFixesGetCursorName> {};
 template<> struct fex_gen_config<XFixesQueryExtension> {};
 template<> struct fex_gen_config<XFixesQueryVersion> {};
diff --git a/ThunkLibs/libXrender/libXrender_Host.cpp b/ThunkLibs/libXrender/libXrender_Host.cpp
index 49d01d88c8..04dbb4a778 100644
--- a/ThunkLibs/libXrender/libXrender_Host.cpp
+++ b/ThunkLibs/libXrender/libXrender_Host.cpp
@@ -6,9 +6,15 @@ tags: thunklibs|X11
 
 #include <stdio.h>
 
+extern "C" {
 #include <X11/Xlib.h>
+#include <X11/Xlibint.h>
+#include <X11/Xregion.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xrender.h>
+}
+#undef min
+#undef max
 
 #include "common/Host.h"
 #include <dlfcn.h>
diff --git a/ThunkLibs/libXrender/libXrender_interface.cpp b/ThunkLibs/libXrender/libXrender_interface.cpp
index e884c286e6..12424de422 100644
--- a/ThunkLibs/libXrender/libXrender_interface.cpp
+++ b/ThunkLibs/libXrender/libXrender_interface.cpp
@@ -2,11 +2,28 @@
 
 #include <X11/extensions/Xrender.h>
 
+#include <type_traits>
+
 template<auto>
 struct fex_gen_config {
     unsigned version = 1;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+// Struct with multi-dimensional array member. Compatible data layout across all architectures
+template<> struct fex_gen_type<_XTransform> : fexgen::assume_compatible_data_layout {};
+
+#ifndef IS_32BIT_THUNK
+// This has a public definition but is used as an opaque type in most APIs
+template<> struct fex_gen_type<std::remove_pointer_t<Region>> : fexgen::assume_compatible_data_layout {};
+
+// TODO: These are largely compatible, *but* contain function pointer members that need adjustment!
+template<> struct fex_gen_type<XExtData> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<_XDisplay> : fexgen::assume_compatible_data_layout {};
+#endif
+
 template<> struct fex_gen_config<XRenderCreateAnimCursor> {};
 template<> struct fex_gen_config<XRenderCreateCursor> {};
 template<> struct fex_gen_config<XRenderCreateGlyphSet> {};
diff --git a/ThunkLibs/libasound/libasound_interface.cpp b/ThunkLibs/libasound/libasound_interface.cpp
index 7e34d5ce47..a5fe6647a1 100644
--- a/ThunkLibs/libasound/libasound_interface.cpp
+++ b/ThunkLibs/libasound/libasound_interface.cpp
@@ -3,11 +3,94 @@
 #include <alsa/asoundlib.h>
 #include <alsa/version.h>
 
+#include <type_traits>
+
 template<auto>
 struct fex_gen_config {
     unsigned version = 2;
 };
 
+// Function, parameter index, parameter type [optional]
+template<auto, int, typename = void>
+struct fex_gen_param {};
+
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<snd_pcm_status_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_shm_area> : fexgen::opaque_type {};
+
+template<> struct fex_gen_type<snd_async_handler_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<std::remove_pointer_t<snd_config_iterator_t>> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_config_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_config_update_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_ctl_card_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_ctl_elem_id_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_ctl_elem_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_ctl_elem_list_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_ctl_elem_value_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_ctl_event_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_ctl_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_devname_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_hctl_elem_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_hctl_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_hwdep_dsp_image_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_hwdep_dsp_status_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_hwdep_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_hwdep_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_input_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_midi_event_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_mixer_class_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_mixer_elem_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_mixer_selem_id_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_mixer_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_output_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_access_mask_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_format_mask_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_hook_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_hw_params_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_scope_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_subformat_mask_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_sw_params_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_pcm_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_rawmidi_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_rawmidi_params_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_rawmidi_status_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_rawmidi_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_sctl_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_client_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_client_pool_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_ev_ext_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_port_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_port_subscribe_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_query_subscribe_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_queue_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_queue_status_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_queue_tempo_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_queue_timer_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_remove_events_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_system_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_seq_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_ginfo_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_gparams_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_gstatus_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_id_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_info_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_params_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_query_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_status_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timer_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<snd_timestamp_t> : fexgen::opaque_type {};
+
+template<> struct fex_gen_type<FILE> : fexgen::opaque_type {};
+
+// Union types with compatible data layout
+template<> struct fex_gen_type<snd_pcm_sync_id_t> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<snd_seq_timestamp> : fexgen::assume_compatible_data_layout {};
+// Has anonymous union member
+template<> struct fex_gen_type<snd_seq_event> : fexgen::assume_compatible_data_layout {};
+
 template<> struct fex_gen_config<snd_asoundlib_version> {};
 #if SND_LIB_VERSION < ((1 << 16) | (2 << 8) | (6))
 // Exists on 1.2.6
@@ -445,7 +528,7 @@ template<> struct fex_gen_config<snd_pcm_meter_get_boundary> {};
 template<> struct fex_gen_config<snd_pcm_meter_add_scope> {};
 template<> struct fex_gen_config<snd_pcm_meter_search_scope> {};
 template<> struct fex_gen_config<snd_pcm_scope_malloc> {};
-template<> struct fex_gen_config<snd_pcm_scope_set_ops> {};
+//template<> struct fex_gen_config<snd_pcm_scope_set_ops> {}; // TODO: Support snd_pcm_scope_ops_t vtable
 template<> struct fex_gen_config<snd_pcm_scope_set_name> {};
 template<> struct fex_gen_config<snd_pcm_scope_get_name> {};
 template<> struct fex_gen_config<snd_pcm_scope_get_callback_private> {};
diff --git a/ThunkLibs/libdrm/libdrm_interface.cpp b/ThunkLibs/libdrm/libdrm_interface.cpp
index a8075531eb..42128e3e3a 100644
--- a/ThunkLibs/libdrm/libdrm_interface.cpp
+++ b/ThunkLibs/libdrm/libdrm_interface.cpp
@@ -7,6 +7,18 @@ struct fex_gen_config {
     unsigned version = 2;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+#ifndef IS_32BIT_THUNK
+// Union types with compatible data layout
+template<> struct fex_gen_type<drmDevice> : fexgen::assume_compatible_data_layout {};
+
+// Anonymous sub-structs
+template<> struct fex_gen_type<drmStatsT> : fexgen::assume_compatible_data_layout {};
+
+#endif
+
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
 
@@ -14,7 +26,8 @@ template<> struct fex_gen_config<FEX_usable_size> : fexgen::custom_host_impl, fe
 template<> struct fex_gen_config<FEX_free_on_host> : fexgen::custom_host_impl, fexgen::custom_guest_entrypoint {};
 template<> struct fex_gen_config<drmIoctl> {};
 template<> struct fex_gen_config<drmGetHashTable> {};
-template<> struct fex_gen_config<drmGetEntry> {};
+// TODO: returns struct containing a function pointer
+//template<> struct fex_gen_config<drmGetEntry> {};
 template<> struct fex_gen_config<drmAvailable> {};
 template<> struct fex_gen_config<drmOpen> {};
 template<> struct fex_gen_config<drmOpenWithType> {};
@@ -76,7 +89,8 @@ template<> struct fex_gen_config<drmGetContextPrivateMapping> {};
 template<> struct fex_gen_config<drmScatterGatherAlloc> {};
 template<> struct fex_gen_config<drmScatterGatherFree> {};
 template<> struct fex_gen_config<drmWaitVBlank> {};
-template<> struct fex_gen_config<drmSetServerInfo> {};
+// TODO: Needs vtable support
+//template<> struct fex_gen_config<drmSetServerInfo> {};
 template<> struct fex_gen_config<drmError> {};
 template<> struct fex_gen_config<drmMalloc> {};
 template<> struct fex_gen_config<drmFree> {};
@@ -106,7 +120,8 @@ template<> struct fex_gen_config<drmCloseOnce> {};
 template<> struct fex_gen_config<drmSetMaster> {};
 template<> struct fex_gen_config<drmDropMaster> {};
 template<> struct fex_gen_config<drmIsMaster> {};
-template<> struct fex_gen_config<drmHandleEvent> {};
+// TODO: Needs vtable support
+//template<> struct fex_gen_config<drmHandleEvent> {};
 template<> struct fex_gen_config<drmGetDeviceNameFromFd> : fexgen::custom_guest_entrypoint {};
 template<> struct fex_gen_config<drmGetDeviceNameFromFd2> : fexgen::custom_guest_entrypoint {};
 
diff --git a/ThunkLibs/libvulkan/Guest.cpp b/ThunkLibs/libvulkan/Guest.cpp
index 066e1a6b42..cbad026a19 100644
--- a/ThunkLibs/libvulkan/Guest.cpp
+++ b/ThunkLibs/libvulkan/Guest.cpp
@@ -4,6 +4,8 @@ tags: thunklibs|Vulkan
 $end_info$
 */
 
+#define VK_USE_64_BIT_PTR_DEFINES 0
+
 #define VK_USE_PLATFORM_XLIB_XRANDR_EXT
 #define VK_USE_PLATFORM_XLIB_KHR
 #define VK_USE_PLATFORM_XCB_KHR
diff --git a/ThunkLibs/libvulkan/Host.cpp b/ThunkLibs/libvulkan/Host.cpp
index deda37d3d4..7339335780 100644
--- a/ThunkLibs/libvulkan/Host.cpp
+++ b/ThunkLibs/libvulkan/Host.cpp
@@ -4,6 +4,8 @@ tags: thunklibs|Vulkan
 $end_info$
 */
 
+#define VK_USE_64_BIT_PTR_DEFINES 0
+
 #define VK_USE_PLATFORM_XLIB_XRANDR_EXT
 #define VK_USE_PLATFORM_XLIB_KHR
 #define VK_USE_PLATFORM_XCB_KHR
@@ -91,6 +93,7 @@ static void FEXFN_IMPL(vkFreeMemory)(VkDevice a_0, VkDeviceMemory a_1, const VkA
   LDR_PTR(vkFreeMemory)(a_0, a_1, nullptr);
 }
 
+#if 0
 static VkResult FEXFN_IMPL(vkCreateDebugReportCallbackEXT)(VkInstance a_0, const VkDebugReportCallbackCreateInfoEXT* a_1, const VkAllocationCallbacks* a_2, VkDebugReportCallbackEXT* a_3) {
   VkDebugReportCallbackCreateInfoEXT overridden_callback = *a_1;
   overridden_callback.pfnCallback = DummyVkDebugReportCallback;
@@ -102,6 +105,7 @@ static void FEXFN_IMPL(vkDestroyDebugReportCallbackEXT)(VkInstance a_0, VkDebugR
   (void*&)LDR_PTR(vkDestroyDebugReportCallbackEXT) = (void*)LDR_PTR(vkGetInstanceProcAddr)(a_0, "vkDestroyDebugReportCallbackEXT");
   LDR_PTR(vkDestroyDebugReportCallbackEXT)(a_0, a_1, nullptr);
 }
+#endif
 
 static PFN_vkVoidFunction FEXFN_IMPL(vkGetDeviceProcAddr)(VkDevice a_0, const char* a_1) {
   // Just return the host facing function pointer
diff --git a/ThunkLibs/libvulkan/libvulkan_interface.cpp b/ThunkLibs/libvulkan/libvulkan_interface.cpp
index ea307856d2..5c16b242ea 100644
--- a/ThunkLibs/libvulkan/libvulkan_interface.cpp
+++ b/ThunkLibs/libvulkan/libvulkan_interface.cpp
@@ -1,10 +1,19 @@
 #include <common/GeneratorInterface.h>
 
+#include <type_traits>
+
 template<auto>
 struct fex_gen_config {
     unsigned version = 1;
 };
 
+// Some of Vulkan's handle types are so-called "non-dispatchable handles".
+// On 64-bit, these are defined as dedicated types by default, which makes
+// annotating these handle types unnecessarily complicated. Instead, setting
+// the following define will make the Vulkan headers alias all handle types
+// to uint64_t.
+#define VK_USE_64_BIT_PTR_DEFINES 0
+
 #define VK_USE_PLATFORM_XLIB_XRANDR_EXT
 #define VK_USE_PLATFORM_XLIB_KHR
 #define VK_USE_PLATFORM_XCB_KHR
@@ -14,18 +23,178 @@ struct fex_gen_config {
 template<> struct fex_gen_config<vkGetDeviceProcAddr> : fexgen::custom_host_impl, fexgen::custom_guest_entrypoint, fexgen::returns_guest_pointer {};
 template<> struct fex_gen_config<vkGetInstanceProcAddr> : fexgen::custom_host_impl, fexgen::custom_guest_entrypoint, fexgen::returns_guest_pointer {};
 
+template<typename>
+struct fex_gen_type {};
+
+// So-called "dispatchable" handles are represented as opaque pointers.
+// In addition to marking them as such, API functions that create these objects
+// need special care since they wrap these handles in another pointer, which
+// the thunk generator can't automatically handle.
+//
+// So-called "non-dispatchable" handles don't need this extra treatment, since
+// they are uint64_t IDs on both 32-bit and 64-bit systems.
+template<> struct fex_gen_type<VkCommandBuffer_T> : fexgen::opaque_type {};
+template<> struct fex_gen_type<VkDevice_T> : fexgen::opaque_type {};
+template<> struct fex_gen_type<VkInstance_T> : fexgen::opaque_type {};
+template<> struct fex_gen_type<VkPhysicalDevice_T> : fexgen::opaque_type {};
+template<> struct fex_gen_type<VkQueue_T> : fexgen::opaque_type {};
+
+// Mark union types with compatible layout as such
+// TODO: These may still have different alignment requirements!
+template<> struct fex_gen_type<VkClearValue> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<VkClearColorValue> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_type<VkPipelineExecutableStatisticValueKHR> : fexgen::assume_compatible_data_layout {};
+
+#ifdef IS_32BIT_THUNK
+// TODO: These are nested structures that should be detected automatically
+//template<> struct fex_gen_type<VkApplicationInfo> {};
+template<> struct fex_gen_config<&VkApplicationInfo::pNext> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkInstanceCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkInstanceCreateInfo::pApplicationInfo> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkInstanceCreateInfo::ppEnabledLayerNames> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkInstanceCreateInfo::ppEnabledExtensionNames> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkDeviceQueueCreateInfo::pNext> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkDeviceCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceCreateInfo::pQueueCreateInfos> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceCreateInfo::ppEnabledLayerNames> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceCreateInfo::ppEnabledExtensionNames> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkSemaphoreCreateInfo::pNext> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkSemaphoreTypeCreateInfo::pNext> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkImageViewCreateInfo::pNext> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkAttachmentDescription2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkAttachmentReference2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBaseOutStructure::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBufferMemoryBarrier2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDependencyInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorUpdateTemplateCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageMemoryBarrier2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageFormatListCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageMemoryRequirementsInfo2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryAllocateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryAllocateFlagsInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryBarrier2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryDedicatedAllocateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryDedicatedRequirements::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryRequirements2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineRenderingCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassAttachmentBeginInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassBeginInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassCreateInfo2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSemaphoreWaitInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubmitInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubpassBeginInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubpassDependency2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubpassDescription2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSwapchainCreateInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkTimelineSemaphoreSubmitInfo::pNext> : fexgen::custom_repack {};
+
+
+template<> struct fex_gen_config<&VkDescriptorSetLayoutCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorSetLayoutCreateInfo::pBindings> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkRenderPassCreateInfo::pSubpasses> : fexgen::custom_repack {};
+// NOTE: pDependencies and pAttachments point to ABI-compatible data
+
+template<> struct fex_gen_config<&VkRenderPassCreateInfo2::pAttachments> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassCreateInfo2::pSubpasses> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassCreateInfo2::pDependencies> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkPipelineShaderStageCreateInfo::pSpecializationInfo> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkSpecializationInfo::pMapEntries> : fexgen::custom_repack {};
+
+
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pStages> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pVertexInputState> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pInputAssemblyState> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pTessellationState> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pViewportState> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pRasterizationState> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pMultisampleState> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pDepthStencilState> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pColorBlendState> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pDynamicState> : fexgen::custom_repack {};
+
+// Command buffers are dispatchable handles, so on 32-bit they need to be repacked
+template<> struct fex_gen_config<&VkSubmitInfo::pCommandBuffers> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkRenderingInfo::pColorAttachments> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderingInfo::pDepthAttachment> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderingInfo::pStencilAttachment> : fexgen::custom_repack {};
+
+//template<> struct fex_gen_config<&VkSubpassDescription2::pInputAttachments> : fexgen::assume_compatible_data_layout {};
+//template<> struct fex_gen_config<&VkSubpassDescription2::pColorAttachments> : fexgen::assume_compatible_data_layout {};
+//template<> struct fex_gen_config<&VkSubpassDescription2::pResolveAttachments> : fexgen::assume_compatible_data_layout {};
+//template<> struct fex_gen_config<&VkSubpassDescription2::pDepthStencilAttachment> : fexgen::assume_compatible_data_layout {};
+
+template<> struct fex_gen_config<&VkDependencyInfo::pMemoryBarriers> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDependencyInfo::pBufferMemoryBarriers> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDependencyInfo::pImageMemoryBarriers> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkDescriptorUpdateTemplateCreateInfo::pDescriptorUpdateEntries> : fexgen::custom_repack {};
+#else
+// The pNext member of this is a pointer to another VkBaseOutStructure, so data layout compatibility can't be inferred automatically
+template<> struct fex_gen_type<VkBaseOutStructure> : fexgen::assume_compatible_data_layout {};
+#endif
+
+
+// TODO: Should not be opaque, but it's usually NULL anyway. Supporting the contained function pointers will need more work.
+template<> struct fex_gen_type<VkAllocationCallbacks> : fexgen::opaque_type {};
+
+// X11 interop
+template<> struct fex_gen_type<Display> : fexgen::opaque_type {};
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+
+// Wayland interop
+template<> struct fex_gen_type<wl_display> : fexgen::opaque_type {};
+template<> struct fex_gen_type<wl_surface> : fexgen::opaque_type {};
+
 namespace internal {
 
+// Function, parameter index, parameter type [optional]
+template<auto, int, typename = void>
+struct fex_gen_param {};
+
 template<auto>
 struct fex_gen_config : fexgen::generate_guest_symtable, fexgen::indirect_guest_calls {
 };
 
+#ifdef IS_32BIT_THUNK
+//template<> struct fex_gen_config<&VkInstanceCreateInfo::pNext> : fexgen::custom_repack {};
+
+//template<> struct fex_gen_config<&VkCommandBufferBeginInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCommandBufferBeginInfo::pInheritanceInfo> : fexgen::custom_repack {};
+
+// TODO: Should have per-member compatibility annotation
+template<> struct fex_gen_config<&VkPipelineCacheCreateInfo::pInitialData> : fexgen::custom_repack {};
+
+// TODO: Should have per-member compatibility annotation
+template<> struct fex_gen_config<&VkRenderPassBeginInfo::pClearValues> : fexgen::custom_repack {};
+#endif
+
 template<> struct fex_gen_config<vkCreateInstance> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkCreateInstance, 2, VkInstance*> : fexgen::ptr_passthrough {};
 template<> struct fex_gen_config<vkDestroyInstance> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkEnumeratePhysicalDevices> {};
+#else
+template<> struct fex_gen_config<vkEnumeratePhysicalDevices> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkEnumeratePhysicalDevices, 2, VkPhysicalDevice*> : fexgen::ptr_passthrough {};
+#endif
+
+
 template<> struct fex_gen_config<vkGetPhysicalDeviceFeatures> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceFormatProperties> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceImageFormatProperties> {};
+// TODO: Output parameter must repack on exit!
 template<> struct fex_gen_config<vkGetPhysicalDeviceProperties> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceQueueFamilyProperties> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceMemoryProperties> {};
@@ -33,6 +202,7 @@ template<> struct fex_gen_config<vkGetPhysicalDeviceMemoryProperties> {};
 // template<> struct fex_gen_config<vkGetInstanceProcAddr> {};
 // template<> struct fex_gen_config<vkGetDeviceProcAddr> {};
 template<> struct fex_gen_config<vkCreateDevice> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkCreateDevice, 3, VkDevice*> : fexgen::ptr_passthrough {};
 template<> struct fex_gen_config<vkDestroyDevice> {};
 template<> struct fex_gen_config<vkEnumerateInstanceExtensionProperties> {};
 template<> struct fex_gen_config<vkEnumerateDeviceExtensionProperties> {};
@@ -71,6 +241,7 @@ template<> struct fex_gen_config<vkResetEvent> {};
 template<> struct fex_gen_config<vkCreateQueryPool> {};
 template<> struct fex_gen_config<vkDestroyQueryPool> {};
 template<> struct fex_gen_config<vkGetQueryPoolResults> {};
+template<> struct fex_gen_param<vkGetQueryPoolResults, 5, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCreateBuffer> {};
 template<> struct fex_gen_config<vkDestroyBuffer> {};
 template<> struct fex_gen_config<vkCreateBufferView> {};
@@ -80,7 +251,7 @@ template<> struct fex_gen_config<vkDestroyImage> {};
 template<> struct fex_gen_config<vkGetImageSubresourceLayout> {};
 template<> struct fex_gen_config<vkCreateImageView> {};
 template<> struct fex_gen_config<vkDestroyImageView> {};
-template<> struct fex_gen_config<vkCreateShaderModule> : fexgen::custom_host_impl {};
+template<> struct fex_gen_config<vkCreateShaderModule> /*: fexgen::custom_host_impl*/ {};
 template<> struct fex_gen_config<vkDestroyShaderModule> {};
 template<> struct fex_gen_config<vkCreatePipelineCache> {};
 template<> struct fex_gen_config<vkDestroyPipelineCache> {};
@@ -182,6 +353,7 @@ template<> struct fex_gen_config<vkDestroySamplerYcbcrConversion> {};
 template<> struct fex_gen_config<vkCreateDescriptorUpdateTemplate> {};
 template<> struct fex_gen_config<vkDestroyDescriptorUpdateTemplate> {};
 template<> struct fex_gen_config<vkUpdateDescriptorSetWithTemplate> {};
+template<> struct fex_gen_param<vkUpdateDescriptorSetWithTemplate, 3, const void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceExternalBufferProperties> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceExternalFenceProperties> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceExternalSemaphoreProperties> {};
@@ -280,9 +452,11 @@ template<> struct fex_gen_config<vkImportSemaphoreFdKHR> {};
 template<> struct fex_gen_config<vkGetSemaphoreFdKHR> {};
 template<> struct fex_gen_config<vkCmdPushDescriptorSetKHR> {};
 template<> struct fex_gen_config<vkCmdPushDescriptorSetWithTemplateKHR> {};
+template<> struct fex_gen_param<vkCmdPushDescriptorSetWithTemplateKHR, 4, const void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCreateDescriptorUpdateTemplateKHR> {};
 template<> struct fex_gen_config<vkDestroyDescriptorUpdateTemplateKHR> {};
 template<> struct fex_gen_config<vkUpdateDescriptorSetWithTemplateKHR> {};
+template<> struct fex_gen_param<vkUpdateDescriptorSetWithTemplateKHR, 3, const void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCreateRenderPass2KHR> {};
 template<> struct fex_gen_config<vkCmdBeginRenderPass2KHR> {};
 template<> struct fex_gen_config<vkCmdNextSubpass2KHR> {};
@@ -346,8 +520,11 @@ template<> struct fex_gen_config<vkCmdTraceRaysIndirect2KHR> {};
 template<> struct fex_gen_config<vkGetDeviceBufferMemoryRequirementsKHR> {};
 template<> struct fex_gen_config<vkGetDeviceImageMemoryRequirementsKHR> {};
 template<> struct fex_gen_config<vkGetDeviceImageSparseMemoryRequirementsKHR> {};
+#if TODO_FUNCPTRS
+// Pointee structs contain function pointers. We should be able to use ptr_passthrough on individual members
 template<> struct fex_gen_config<vkCreateDebugReportCallbackEXT> : fexgen::custom_host_impl {};
 template<> struct fex_gen_config<vkDestroyDebugReportCallbackEXT> : fexgen::custom_host_impl {};
+#endif
 template<> struct fex_gen_config<vkDebugReportMessageEXT> {};
 template<> struct fex_gen_config<vkDebugMarkerSetObjectTagEXT> {};
 template<> struct fex_gen_config<vkDebugMarkerSetObjectNameEXT> {};
@@ -370,6 +547,7 @@ template<> struct fex_gen_config<vkGetImageViewAddressNVX> {};
 template<> struct fex_gen_config<vkCmdDrawIndirectCountAMD> {};
 template<> struct fex_gen_config<vkCmdDrawIndexedIndirectCountAMD> {};
 template<> struct fex_gen_config<vkGetShaderInfoAMD> {};
+template<> struct fex_gen_param<vkGetShaderInfoAMD, 5, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceExternalImageFormatPropertiesNV> {};
 template<> struct fex_gen_config<vkCmdBeginConditionalRenderingEXT> {};
 template<> struct fex_gen_config<vkCmdEndConditionalRenderingEXT> {};
@@ -392,7 +570,10 @@ template<> struct fex_gen_config<vkQueueInsertDebugUtilsLabelEXT> {};
 template<> struct fex_gen_config<vkCmdBeginDebugUtilsLabelEXT> {};
 template<> struct fex_gen_config<vkCmdEndDebugUtilsLabelEXT> {};
 template<> struct fex_gen_config<vkCmdInsertDebugUtilsLabelEXT> {};
+#if TODO_FUNCPTRS
+// Pointee structs contain function pointers. We should be able to use ptr_passthrough on individual members
 template<> struct fex_gen_config<vkCreateDebugUtilsMessengerEXT> {};
+#endif
 template<> struct fex_gen_config<vkDestroyDebugUtilsMessengerEXT> {};
 template<> struct fex_gen_config<vkSubmitDebugUtilsMessageEXT> {};
 template<> struct fex_gen_config<vkCmdSetSampleLocationsEXT> {};
@@ -402,6 +583,7 @@ template<> struct fex_gen_config<vkCreateValidationCacheEXT> {};
 template<> struct fex_gen_config<vkDestroyValidationCacheEXT> {};
 template<> struct fex_gen_config<vkMergeValidationCachesEXT> {};
 template<> struct fex_gen_config<vkGetValidationCacheDataEXT> {};
+template<> struct fex_gen_param<vkGetValidationCacheDataEXT, 3, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCmdBindShadingRateImageNV> {};
 template<> struct fex_gen_config<vkCmdSetViewportShadingRatePaletteNV> {};
 template<> struct fex_gen_config<vkCmdSetCoarseSampleOrderNV> {};
@@ -414,11 +596,15 @@ template<> struct fex_gen_config<vkCmdCopyAccelerationStructureNV> {};
 template<> struct fex_gen_config<vkCmdTraceRaysNV> {};
 template<> struct fex_gen_config<vkCreateRayTracingPipelinesNV> {};
 template<> struct fex_gen_config<vkGetRayTracingShaderGroupHandlesKHR> {};
+template<> struct fex_gen_param<vkGetRayTracingShaderGroupHandlesKHR, 5, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkGetRayTracingShaderGroupHandlesNV> {};
+template<> struct fex_gen_param<vkGetRayTracingShaderGroupHandlesNV, 5, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkGetAccelerationStructureHandleNV> {};
+template<> struct fex_gen_param<vkGetAccelerationStructureHandleNV, 3, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCmdWriteAccelerationStructuresPropertiesNV> {};
 template<> struct fex_gen_config<vkCompileDeferredNV> {};
 template<> struct fex_gen_config<vkGetMemoryHostPointerPropertiesEXT> {};
+template<> struct fex_gen_param<vkGetMemoryHostPointerPropertiesEXT, 2, const void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCmdWriteBufferMarkerAMD> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> {};
 template<> struct fex_gen_config<vkGetCalibratedTimestampsEXT> {};
@@ -427,6 +613,7 @@ template<> struct fex_gen_config<vkCmdDrawMeshTasksIndirectNV> {};
 template<> struct fex_gen_config<vkCmdDrawMeshTasksIndirectCountNV> {};
 template<> struct fex_gen_config<vkCmdSetExclusiveScissorNV> {};
 template<> struct fex_gen_config<vkCmdSetCheckpointNV> {};
+template<> struct fex_gen_param<vkCmdSetCheckpointNV, 1, const void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkGetQueueCheckpointDataNV> {};
 template<> struct fex_gen_config<vkInitializePerformanceApiINTEL> {};
 template<> struct fex_gen_config<vkUninitializePerformanceApiINTEL> {};
@@ -436,7 +623,9 @@ template<> struct fex_gen_config<vkCmdSetPerformanceOverrideINTEL> {};
 template<> struct fex_gen_config<vkAcquirePerformanceConfigurationINTEL> {};
 template<> struct fex_gen_config<vkReleasePerformanceConfigurationINTEL> {};
 template<> struct fex_gen_config<vkQueueSetPerformanceConfigurationINTEL> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkPerformanceValueDataINTEL
 template<> struct fex_gen_config<vkGetPerformanceParameterINTEL> {};
+#endif
 template<> struct fex_gen_config<vkSetLocalDimmingAMD> {};
 template<> struct fex_gen_config<vkGetBufferDeviceAddressEXT> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceToolPropertiesEXT> {};
@@ -490,18 +679,27 @@ template<> struct fex_gen_config<vkCmdDrawMultiEXT> {};
 template<> struct fex_gen_config<vkCmdDrawMultiIndexedEXT> {};
 template<> struct fex_gen_config<vkCreateMicromapEXT> {};
 template<> struct fex_gen_config<vkDestroyMicromapEXT> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkDeviceOrHostAddressKHR
 template<> struct fex_gen_config<vkCmdBuildMicromapsEXT> {};
 template<> struct fex_gen_config<vkBuildMicromapsEXT> {};
+#endif
 template<> struct fex_gen_config<vkCopyMicromapEXT> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkDeviceOrHostAddressKHR
 template<> struct fex_gen_config<vkCopyMicromapToMemoryEXT> {};
 template<> struct fex_gen_config<vkCopyMemoryToMicromapEXT> {};
+#endif
 template<> struct fex_gen_config<vkWriteMicromapsPropertiesEXT> {};
+template<> struct fex_gen_param<vkWriteMicromapsPropertiesEXT, 5, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCmdCopyMicromapEXT> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkDeviceOrHostAddressKHR
 template<> struct fex_gen_config<vkCmdCopyMicromapToMemoryEXT> {};
 template<> struct fex_gen_config<vkCmdCopyMemoryToMicromapEXT> {};
+#endif
 template<> struct fex_gen_config<vkCmdWriteMicromapsPropertiesEXT> {};
 template<> struct fex_gen_config<vkGetDeviceMicromapCompatibilityEXT> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkDeviceOrHostAddressKHR
 template<> struct fex_gen_config<vkGetMicromapBuildSizesEXT> {};
+#endif
 template<> struct fex_gen_config<vkSetDeviceMemoryPriorityEXT> {};
 template<> struct fex_gen_config<vkGetDescriptorSetLayoutHostMappingInfoVALVE> {};
 template<> struct fex_gen_config<vkGetDescriptorSetHostMappingVALVE> {};
@@ -547,23 +745,33 @@ template<> struct fex_gen_config<vkGetFramebufferTilePropertiesQCOM> {};
 template<> struct fex_gen_config<vkGetDynamicRenderingTilePropertiesQCOM> {};
 template<> struct fex_gen_config<vkCreateAccelerationStructureKHR> {};
 template<> struct fex_gen_config<vkDestroyAccelerationStructureKHR> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkDeviceOrHostAddressKHR
 template<> struct fex_gen_config<vkCmdBuildAccelerationStructuresKHR> {};
 template<> struct fex_gen_config<vkCmdBuildAccelerationStructuresIndirectKHR> {};
 template<> struct fex_gen_config<vkBuildAccelerationStructuresKHR> {};
+#endif
 template<> struct fex_gen_config<vkCopyAccelerationStructureKHR> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkDeviceOrHostAddressKHR
 template<> struct fex_gen_config<vkCopyAccelerationStructureToMemoryKHR> {};
 template<> struct fex_gen_config<vkCopyMemoryToAccelerationStructureKHR> {};
+#endif
 template<> struct fex_gen_config<vkWriteAccelerationStructuresPropertiesKHR> {};
+template<> struct fex_gen_param<vkWriteAccelerationStructuresPropertiesKHR, 5, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCmdCopyAccelerationStructureKHR> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkDeviceOrHostAddressKHR
 template<> struct fex_gen_config<vkCmdCopyAccelerationStructureToMemoryKHR> {};
 template<> struct fex_gen_config<vkCmdCopyMemoryToAccelerationStructureKHR> {};
+#endif
 template<> struct fex_gen_config<vkGetAccelerationStructureDeviceAddressKHR> {};
 template<> struct fex_gen_config<vkCmdWriteAccelerationStructuresPropertiesKHR> {};
 template<> struct fex_gen_config<vkGetDeviceAccelerationStructureCompatibilityKHR> {};
+#if TODO_ADD_CUSTOM_REPACK_FOR_VkDeviceOrHostAddressKHR
 template<> struct fex_gen_config<vkGetAccelerationStructureBuildSizesKHR> {};
+#endif
 template<> struct fex_gen_config<vkCmdTraceRaysKHR> {};
 template<> struct fex_gen_config<vkCreateRayTracingPipelinesKHR> {};
 template<> struct fex_gen_config<vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> {};
+template<> struct fex_gen_param<vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, 5, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCmdTraceRaysIndirectKHR> {};
 template<> struct fex_gen_config<vkGetRayTracingShaderGroupStackSizeKHR> {};
 template<> struct fex_gen_config<vkCmdSetRayTracingPipelineStackSizeKHR> {};
diff --git a/ThunkLibs/libwayland-client/libwayland-client_interface.cpp b/ThunkLibs/libwayland-client/libwayland-client_interface.cpp
index 7371653bc7..80b86debfe 100644
--- a/ThunkLibs/libwayland-client/libwayland-client_interface.cpp
+++ b/ThunkLibs/libwayland-client/libwayland-client_interface.cpp
@@ -10,6 +10,20 @@ struct fex_gen_config {
 template<typename>
 struct fex_gen_type {};
 
+// Function, parameter index, parameter type [optional]
+template<auto, int, typename = void>
+struct fex_gen_param {};
+
+template<> struct fex_gen_type<wl_display> : fexgen::opaque_type {};
+template<> struct fex_gen_type<wl_proxy> : fexgen::opaque_type {};
+template<> struct fex_gen_type<wl_interface> : fexgen::opaque_type {};
+
+template<> struct fex_gen_type<wl_event_queue> : fexgen::opaque_type {};
+
+// Passed over Wayland's wire protocol for some functions
+template<> struct fex_gen_type<wl_array> {};
+
+
 template<> struct fex_gen_config<wl_proxy_destroy> : fexgen::custom_guest_entrypoint {};
 
 template<> struct fex_gen_config<wl_display_cancel_read> {};
@@ -31,13 +45,18 @@ template<> struct fex_gen_config<wl_display_get_fd> {};
 template<> struct fex_gen_config<wl_event_queue_destroy> {};
 
 template<> struct fex_gen_config<wl_proxy_add_listener> : fexgen::custom_host_impl, fexgen::custom_guest_entrypoint {};
+template<> struct fex_gen_param<wl_proxy_add_listener, 1, void(**)()> : fexgen::ptr_passthrough {};
+// TODO: Assume compatible
+template<> struct fex_gen_param<wl_proxy_add_listener, 2, void*> : fexgen::ptr_passthrough {};
 template<> struct fex_gen_config<wl_proxy_create> {};
 template<> struct fex_gen_config<wl_proxy_create_wrapper> {};
 template<> struct fex_gen_config<wl_proxy_get_tag> {};
 template<> struct fex_gen_config<wl_proxy_get_user_data> {};
 template<> struct fex_gen_config<wl_proxy_get_version> {};
 template<> struct fex_gen_config<wl_proxy_set_queue> {};
+//template<> struct fex_gen_param<wl_proxy_set_queue, 1, wl_event_queue *> : fexgen::ptr_passthrough {};
 template<> struct fex_gen_config<wl_proxy_set_tag> {};
+// TODO: This has a void* parameter. Why does 32-bit accept this without annotations?
 template<> struct fex_gen_config<wl_proxy_set_user_data> {};
 template<> struct fex_gen_config<wl_proxy_wrapper_destroy> {};
 
@@ -49,4 +68,6 @@ template<> struct fex_gen_config<wl_proxy_marshal_array_flags> {};
 
 // Guest notifies host about its interface. Host returns its corresponding interface pointer
 wl_interface* fex_wl_exchange_interface_pointer(wl_interface*, const char* name);
-template<> struct fex_gen_config<fex_wl_exchange_interface_pointer> : fexgen::custom_host_impl {};
+template<> struct fex_gen_config<fex_wl_exchange_interface_pointer> : fexgen::custom_host_impl/*, fexgen::custom_guest_entrypoint*/ {};
+//template<> struct fex_gen_param<fex_wl_exchange_interface_pointer, 0, wl_interface*> : fexgen::ptr_passthrough {};
+template<> struct fex_gen_param<fex_wl_exchange_interface_pointer, 1, const char*> : fexgen::ptr_passthrough {};
diff --git a/ThunkLibs/libxcb-dri2/libxcb-dri2_interface.cpp b/ThunkLibs/libxcb-dri2/libxcb-dri2_interface.cpp
index 07f93f48d3..5a3349c557 100644
--- a/ThunkLibs/libxcb-dri2/libxcb-dri2_interface.cpp
+++ b/ThunkLibs/libxcb-dri2/libxcb-dri2_interface.cpp
@@ -1,12 +1,18 @@
 #include <common/GeneratorInterface.h>
 
 #include <xcb/dri2.h>
+#include <xcb/xcbext.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 0;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+
 void FEX_xcb_dri2_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxcb-dri3/libxcb-dri3_interface.cpp b/ThunkLibs/libxcb-dri3/libxcb-dri3_interface.cpp
index 0708baf232..07d20da645 100644
--- a/ThunkLibs/libxcb-dri3/libxcb-dri3_interface.cpp
+++ b/ThunkLibs/libxcb-dri3/libxcb-dri3_interface.cpp
@@ -1,12 +1,18 @@
 #include <common/GeneratorInterface.h>
 
 #include <xcb/dri3.h>
+#include <xcb/xcbext.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 0;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+
 void FEX_xcb_dri3_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxcb-glx/libxcb-glx_interface.cpp b/ThunkLibs/libxcb-glx/libxcb-glx_interface.cpp
index 28f76fccee..64160def59 100644
--- a/ThunkLibs/libxcb-glx/libxcb-glx_interface.cpp
+++ b/ThunkLibs/libxcb-glx/libxcb-glx_interface.cpp
@@ -1,12 +1,18 @@
 #include <common/GeneratorInterface.h>
 
 #include <xcb/glx.h>
+#include <xcb/xcbext.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 0;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+
 void FEX_xcb_glx_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxcb-present/libxcb-present_interface.cpp b/ThunkLibs/libxcb-present/libxcb-present_interface.cpp
index b1e32b7557..69481998b4 100644
--- a/ThunkLibs/libxcb-present/libxcb-present_interface.cpp
+++ b/ThunkLibs/libxcb-present/libxcb-present_interface.cpp
@@ -1,12 +1,18 @@
 #include <common/GeneratorInterface.h>
 
 #include <xcb/present.h>
+#include <xcb/xcbext.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 0;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+
 void FEX_xcb_present_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxcb-randr/libxcb-randr_interface.cpp b/ThunkLibs/libxcb-randr/libxcb-randr_interface.cpp
index 4f00b47133..f8eb585cea 100644
--- a/ThunkLibs/libxcb-randr/libxcb-randr_interface.cpp
+++ b/ThunkLibs/libxcb-randr/libxcb-randr_interface.cpp
@@ -1,12 +1,23 @@
 #include <common/GeneratorInterface.h>
 
 #include <xcb/randr.h>
+#include <xcb/xcbext.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 0;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+
+// Union type (includes pointers, so only compatible across 64-bit architectures)
+#ifndef IS_32BIT_THUNK
+template<> struct fex_gen_type<xcb_randr_notify_data_t> : fexgen::assume_compatible_data_layout {};
+#endif
+
 void FEX_xcb_randr_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxcb-shm/libxcb-shm_interface.cpp b/ThunkLibs/libxcb-shm/libxcb-shm_interface.cpp
index 246c0abee4..46ab5d4fdf 100644
--- a/ThunkLibs/libxcb-shm/libxcb-shm_interface.cpp
+++ b/ThunkLibs/libxcb-shm/libxcb-shm_interface.cpp
@@ -1,12 +1,19 @@
 #include <common/GeneratorInterface.h>
 
 #include <xcb/shm.h>
+#include <xcb/xcbext.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 0;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+//template<> struct fex_gen_type<xcb_extension_t> : fexgen::opaque_type {};
+
 void FEX_xcb_shm_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxcb-sync/libxcb-sync_interface.cpp b/ThunkLibs/libxcb-sync/libxcb-sync_interface.cpp
index e810ec0195..5fe072f760 100644
--- a/ThunkLibs/libxcb-sync/libxcb-sync_interface.cpp
+++ b/ThunkLibs/libxcb-sync/libxcb-sync_interface.cpp
@@ -1,12 +1,18 @@
 #include <common/GeneratorInterface.h>
 
 #include <xcb/sync.h>
+#include <xcb/xcbext.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 1;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+
 void FEX_xcb_sync_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxcb-xfixes/libxcb-xfixes_interface.cpp b/ThunkLibs/libxcb-xfixes/libxcb-xfixes_interface.cpp
index 3f5c9c1fc1..947da6c19e 100644
--- a/ThunkLibs/libxcb-xfixes/libxcb-xfixes_interface.cpp
+++ b/ThunkLibs/libxcb-xfixes/libxcb-xfixes_interface.cpp
@@ -1,12 +1,18 @@
 #include <common/GeneratorInterface.h>
 
 #include <xcb/xfixes.h>
+#include <xcb/xcbext.h>
 
 template<auto>
 struct fex_gen_config {
     unsigned version = 0;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+
 void FEX_xcb_xfixes_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxcb/libxcb_interface.cpp b/ThunkLibs/libxcb/libxcb_interface.cpp
index feeff49407..ede74e44b5 100644
--- a/ThunkLibs/libxcb/libxcb_interface.cpp
+++ b/ThunkLibs/libxcb/libxcb_interface.cpp
@@ -11,6 +11,15 @@ struct fex_gen_config {
     unsigned version = 1;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xcb_connection_t> : fexgen::opaque_type {};
+template<> struct fex_gen_type<xcb_special_event> : fexgen::opaque_type {};
+
+// Union type with consistent data layout across host/x86/x86-64
+template<> struct fex_gen_type<xcb_client_message_data_t> : fexgen::assume_compatible_data_layout {};
+
 void FEX_xcb_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
diff --git a/ThunkLibs/libxshmfence/libxshmfence_interface.cpp b/ThunkLibs/libxshmfence/libxshmfence_interface.cpp
index cf396ef6d0..5b2433da4f 100644
--- a/ThunkLibs/libxshmfence/libxshmfence_interface.cpp
+++ b/ThunkLibs/libxshmfence/libxshmfence_interface.cpp
@@ -9,6 +9,11 @@ struct fex_gen_config {
     unsigned version = 1;
 };
 
+template<typename>
+struct fex_gen_type {};
+
+template<> struct fex_gen_type<xshmfence> : fexgen::opaque_type {};
+
 template<> struct fex_gen_config<xshmfence_trigger> {};
 template<> struct fex_gen_config<xshmfence_await> {};
 template<> struct fex_gen_config<xshmfence_query> {};

From dc3588ddf3ee975ffded0ce0c886bb44e15a2d3d Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Thu, 10 Aug 2023 17:05:12 +0200
Subject: [PATCH 06/48] unittests/ThunkLibs: Add data layout tests

---
 unittests/ThunkLibs/CMakeLists.txt |   3 +-
 unittests/ThunkLibs/abi.cpp        | 636 +++++++++++++++++++++++++++++
 unittests/ThunkLibs/common.h       |  61 ++-
 3 files changed, 695 insertions(+), 5 deletions(-)
 create mode 100644 unittests/ThunkLibs/abi.cpp

diff --git a/unittests/ThunkLibs/CMakeLists.txt b/unittests/ThunkLibs/CMakeLists.txt
index f05b641599..c5a6c14ebe 100644
--- a/unittests/ThunkLibs/CMakeLists.txt
+++ b/unittests/ThunkLibs/CMakeLists.txt
@@ -1,5 +1,6 @@
-add_executable(thunkgentest generator.cpp)
+add_executable(thunkgentest generator.cpp abi.cpp)
 target_link_libraries(thunkgentest PRIVATE Catch2::Catch2WithMain)
+target_link_libraries(thunkgentest PRIVATE fmt::fmt)
 target_link_libraries(thunkgentest PRIVATE thunkgenlib)
 catch_discover_tests(thunkgentest TEST_SUFFIX ".ThunkGen")
 
diff --git a/unittests/ThunkLibs/abi.cpp b/unittests/ThunkLibs/abi.cpp
new file mode 100644
index 0000000000..c9a8345853
--- /dev/null
+++ b/unittests/ThunkLibs/abi.cpp
@@ -0,0 +1,636 @@
+#include <clang/Frontend/CompilerInstance.h>
+#include <catch2/catch.hpp>
+
+#include <data_layout.h>
+#include <interface.h>
+#include "common.h"
+
+#include <fmt/format.h>
+
+#include <string_view>
+
+inline std::ostream& operator<<(std::ostream& os, TypeCompatibility compat) {
+    if (compat == TypeCompatibility::Full) {
+        os << "Compatible";
+    } else if (compat == TypeCompatibility::Repackable) {
+        os << "Repackable";
+    } else if (compat == TypeCompatibility::None) {
+        os << "Incompatible";
+    } else {
+        os << "(INVALID)";
+    }
+    return os;
+}
+
+class DataLayoutCompareActionForTest;
+
+namespace {
+
+struct Fixture {
+    Fixture() {
+    }
+
+    ~Fixture() {
+    }
+
+    /**
+     * Parses annotations from the input source and generates data layout descriptions from it.
+     *
+     * Input code with common definitions (types, functions, ...) should be specified in "prelude".
+     * It will be prepended to "code" before processing and also to the generator output.
+     */
+    std::unique_ptr<DataLayoutCompareActionForTest> compute_data_layout(std::string_view prelude, std::string_view code, GuestABI);
+};
+
+}
+
+class DataLayoutCompareActionForTest : public DataLayoutCompareAction {
+    std::unordered_map<const clang::Type*, TypeCompatibility> type_compat_cache;
+
+    // Persistent reference taken to enable accessing the ASTContext after CompilerInstance::ExecuteAction returns
+    llvm::IntrusiveRefCntPtr<clang::ASTContext> ast_context;
+
+public:
+    DataLayoutCompareActionForTest(std::unique_ptr<ABI> guest_layout) : DataLayoutCompareAction(*guest_layout), guest_layout(std::move(guest_layout)) {
+    }
+
+    void ExecuteAction() override {
+        AnalysisAction::ExecuteAction();
+
+        ast_context = &getCompilerInstance().getASTContext();
+        host_layout = ComputeDataLayout(*ast_context, types);
+    }
+
+    std::unique_ptr<ABI> guest_layout;
+    std::unordered_map<const clang::Type*, TypeInfo> host_layout;
+
+    TypeCompatibility GetTypeCompatibility(std::string_view type_name) {
+        for (const auto& [type, _] : host_layout) {
+            if (clang::QualType { type, 0 }.getAsString() == type_name) {
+                return DataLayoutCompareAction::GetTypeCompatibility(*ast_context, type, host_layout, type_compat_cache);
+            }
+        }
+
+        throw std::runtime_error("No data layout information recorded for type \"" + std::string { type_name } + "\"");
+    }
+};
+
+/**
+ * Same as clang::FrontendActionFactory but takes an external FrontendAction
+ * reference instead of constructing an internal one. Since the FrontendAction
+ * lifetime may extend past this ToolAction, state captured by the
+ * FrontendAction can be accessed after the ToolAction returns.
+ */
+class ThunkTestToolAction : public clang::tooling::ToolAction {
+public:
+    clang::FrontendAction& ScopedToolAction;
+
+public:
+    ThunkTestToolAction(clang::FrontendAction& action) : ScopedToolAction(action) {
+    }
+    ~ThunkTestToolAction() = default;
+
+    // Same as FrontendActionFactory but keeps ScopedToolAction alive when returning
+    bool runInvocation( std::shared_ptr<clang::CompilerInvocation> invocation, clang::FileManager *files,
+                        std::shared_ptr<clang::PCHContainerOperations> pch,
+                        clang::DiagnosticConsumer *diag_consumer) override {
+
+        auto diagnostics = clang::CompilerInstance::createDiagnostics(&invocation->getDiagnosticOpts(), diag_consumer, false);
+
+        clang::CompilerInstance Compiler(std::move(pch));
+        Compiler.setInvocation(std::move(invocation));
+        Compiler.setFileManager(files);
+        Compiler.createDiagnostics(diag_consumer, false);
+        if (!Compiler.hasDiagnostics())
+          return false;
+        Compiler.createSourceManager(*files);
+
+        const bool Success = Compiler.ExecuteAction(ScopedToolAction);
+
+        files->clearStatCache();
+        return Success;
+    }
+};
+
+std::unique_ptr<DataLayoutCompareActionForTest> Fixture::compute_data_layout(std::string_view prelude, std::string_view code, GuestABI guest_abi) {
+    const std::string full_code = std::string { prelude } + std::string { code };
+
+    // Compute guest data layout
+    auto data_layout_analysis_factory = std::make_unique<AnalyzeDataLayoutActionFactory>();
+    run_tool(*data_layout_analysis_factory, full_code, false, guest_abi);
+
+    // Compute host data layout
+    auto ScopedToolAction = std::make_unique<DataLayoutCompareActionForTest>(data_layout_analysis_factory->TakeDataLayout());
+    run_tool(std::make_unique<ThunkTestToolAction>(*ScopedToolAction), full_code, false, std::nullopt);
+
+    return ScopedToolAction;
+}
+
+static std::string FormatDataLayout(const std::unordered_map<const clang::Type*, TypeInfo>& layout) {
+     std::string ret;
+
+    for (const auto& [type, info] : layout) {
+        auto basic_info = info.get_if_simple_or_struct();
+        if (!basic_info) {
+            continue;
+        }
+
+        ret += fmt::format("  Host entry {}: {} ({})\n", clang::QualType { type, 0 }.getAsString().c_str(), basic_info->size_bits / 8, basic_info->alignment_bits / 8);
+
+        if (auto struct_info = info.get_if_struct()) {
+            for (const auto& member : struct_info->members) {
+                ret += fmt::format("    Offset {}-{}: {} {}{}\n", member.offset_bits / 8, (member.offset_bits + member.size_bits - 1) / 8, member.type_name.c_str(), member.member_name.c_str(), member.array_size ? fmt::format("[{}]", member.array_size.value()).c_str() : "");
+            }
+        }
+    }
+
+    return ret;
+}
+
+TEST_CASE_METHOD(Fixture, "DataLayout") {
+    auto guest_abi = GENERATE(GuestABI::X86_32, GuestABI::X86_64);
+    INFO(guest_abi);
+
+    SECTION("Trivial") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n",
+            "struct A { int a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        REQUIRE(action->guest_layout->contains("A"));
+
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Full);
+    }
+
+    SECTION("Builtin types") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n",
+            "struct A { char a; short b; int c; float d; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        REQUIRE(action->guest_layout->contains("A"));
+
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Full);
+        CHECK(action->GetTypeCompatibility("char") == TypeCompatibility::Full);
+        CHECK(action->GetTypeCompatibility("short") == TypeCompatibility::Full);
+        CHECK(action->GetTypeCompatibility("int") == TypeCompatibility::Full);
+        CHECK(action->GetTypeCompatibility("float") == TypeCompatibility::Full);
+    }
+
+    SECTION("Padding after int16_t") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { int16_t a; int32_t b; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Full);
+    }
+
+    SECTION("Array of int16_t") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { int16_t a[64]; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Full);
+    }
+
+    const auto compat_full64_repackable32 = (guest_abi == GuestABI::X86_32 ? TypeCompatibility::Repackable : TypeCompatibility::Full);
+
+    SECTION("Type with platform-dependent size (size_t)") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdlib>\n",
+            "struct A { size_t a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == (guest_abi == GuestABI::X86_32 ? TypeCompatibility::Repackable : TypeCompatibility::Full));
+    }
+
+    SECTION("int64_t has stricter alignment requirements on 64-bit platforms") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { int64_t a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->guest_layout->at("A").get_if_struct()->alignment_bits == (guest_abi == GuestABI::X86_32 ? 32 : 64));
+        CHECK(action->GetTypeCompatibility("struct A") == (guest_abi == GuestABI::X86_32 ? TypeCompatibility::Repackable : TypeCompatibility::Full));
+    }
+
+    SECTION("Array of int64_t") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { int64_t a[64]; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
+    }
+
+// TODO: Currently unsupported by the generator
+//    SECTION("int64_t with explicit alignment specification") {
+//        auto action = compute_data_layout(
+//            "#include <thunks_common.h>\n"
+//            "#include <cstdint>\n",
+//            "struct alignas(8) A { int64_t a; };\n"
+//            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+//        INFO(FormatDataLayout(action->host_layout));
+
+//        REQUIRE(action->guest_layout->contains("A"));
+//        CHECK(action->guest_layout->at("A").get_if_struct()->alignment_bits == 64);
+//        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Full);
+//    }
+
+    SECTION("int64_t alignment requirements propagate to parent struct") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { int32_t a; int32_t b; int64_t c; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->guest_layout->at("A").get_if_struct()->alignment_bits == (guest_abi == GuestABI::X86_32 ? 32 : 64));
+        CHECK(action->GetTypeCompatibility("struct A") == (guest_abi == GuestABI::X86_32 ? TypeCompatibility::Repackable : TypeCompatibility::Full));
+    }
+
+    SECTION("Padding before int64_t member") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { int32_t a; int64_t b; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->guest_layout->at("A").get_if_struct()->members[1].offset_bits == (guest_abi == GuestABI::X86_32 ? 32 : 64));
+
+        CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
+    }
+
+    SECTION("Padding at end of struct due to int64_t alignment (like VkMemoryHeap)") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { int64_t a; int32_t b; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->guest_layout->at("A").get_if_struct()->size_bits == (guest_abi == GuestABI::X86_32 ? 96 : 128));
+
+        CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
+    }
+
+    SECTION("Different struct definition between guest and host; different member order") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "#ifdef HOST\n"
+            "struct A { int32_t a; int32_t b; };\n"
+            "#else\n"
+            "struct A { int32_t b; int32_t a; };\n"
+            "#endif\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->guest_layout->at("A").get_if_struct()->members.at(0).member_name == "b");
+        CHECK(action->guest_layout->at("A").get_if_struct()->members.at(1).member_name == "a");
+
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Repackable);
+    }
+
+    SECTION("Different struct definition between guest and host; different member size") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "#ifdef HOST\n"
+            "struct A { int32_t a; int32_t b; };\n"
+            "#else\n"
+            "struct A { int32_t a; int64_t b; };\n"
+            "#endif\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->guest_layout->at("A").get_if_struct()->members.at(0).size_bits == 32);
+        CHECK(action->guest_layout->at("A").get_if_struct()->members.at(1).size_bits == 64);
+
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Repackable);
+    }
+
+    SECTION("Different struct definition between guest and host; completely different members") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "#ifdef HOST\n"
+            "struct A { int32_t a; int32_t b; };\n"
+            "#else\n"
+            "struct A { int32_t c; int32_t d; };\n"
+            "#endif\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::None);
+    }
+
+if (false) // TODO: Currently fails
+    SECTION("Different struct definition between guest and host; member missing from guest") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "#ifdef HOST\n"
+            "struct A { int32_t a; int32_t b; };\n"
+            "#else\n"
+            "struct A { int32_t a; };\n"
+            "#endif\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::None);
+    }
+
+    SECTION("Different struct definition between guest and host; member missing from host") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "#ifdef HOST\n"
+            "struct A { int32_t a; };\n"
+            "#else\n"
+            "struct A { int32_t a; int32_t b; };\n"
+            "#endif\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::None);
+    }
+
+    SECTION("Nesting structs of consistent data layout") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct C { int32_t a; int16_t b; };\n"
+            "struct B { C a; int16_t b; };\n"
+            "struct A { int32_t a; B b; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        REQUIRE(action->guest_layout->contains("B"));
+        REQUIRE(action->guest_layout->contains("C"));
+        CHECK(action->guest_layout->at("A").get_if_struct()->members.at(0).size_bits == 32);
+
+        CHECK(action->GetTypeCompatibility("struct C") == TypeCompatibility::Full);
+        CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::Full);
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Full);
+    }
+
+    SECTION("Nesting repackable structs by embedding") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "#ifdef HOST\n"
+            "struct C { int32_t a; int32_t b; };\n"
+            "#else\n"
+            "struct C { int32_t b; int32_t a; };\n"
+            "#endif\n"
+            "struct B { C a; int16_t b; };\n"
+            "struct A { int32_t a; B b; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        REQUIRE(action->guest_layout->contains("B"));
+        REQUIRE(action->guest_layout->contains("C"));
+        CHECK(action->guest_layout->at("A").get_if_struct()->size_bits == 128);
+        CHECK(action->guest_layout->at("A").get_if_struct()->alignment_bits == 32);
+
+        CHECK(action->GetTypeCompatibility("struct C") == TypeCompatibility::Repackable);
+        CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::Repackable);
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Repackable);
+    }
+
+    SECTION("Embedded union type (like VkRenderingAttachmentInfo)") {
+        SECTION("without annotation") {
+            CHECK_THROWS_WITH(compute_data_layout(
+                "#include <thunks_common.h>\n"
+                "#include <cstdint>\n",
+                "union B { int32_t a; uint32_t b; };\n"
+                "struct A { B a; };\n"
+                "template<> struct fex_gen_type<A> {};\n", guest_abi),
+                Catch::Contains("unannotated member") && Catch::Contains("union type"));
+        }
+    }
+}
+
+TEST_CASE_METHOD(Fixture, "DataLayoutPointers") {
+    auto guest_abi = GENERATE(GuestABI::X86_32, GuestABI::X86_64);
+    INFO(guest_abi);
+
+    const auto compat_full64_repackable32 = (guest_abi == GuestABI::X86_32 ? TypeCompatibility::Repackable : TypeCompatibility::Full);
+
+    SECTION("Pointer to data with consistent layout") {
+        std::string type = GENERATE("char", "short", "int", "float", "struct B { int a; }");
+        INFO(type);
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { " + type + "* a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        // The pointer itself needs repacking on 32-bit. On 64-bit, no repacking is needed at all.
+        CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
+        if (!type.starts_with("struct B")) {
+            CHECK(action->GetTypeCompatibility(type) == TypeCompatibility::Full);
+        }
+    }
+
+    SECTION("Pointer to struct with consistent layout") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct B { int32_t a; };\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("B"));
+        CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::Full);
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
+    }
+
+    SECTION("Unannotated pointer to incomplete type") {
+        CHECK_THROWS_WITH(compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct B;\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi),
+            Catch::Contains("incomplete type"));
+    }
+
+    SECTION("Unannotated pointer to repackable type") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "#ifdef HOST\n"
+            "struct B { int32_t a; int32_t b; };\n"
+            "#else\n"
+            "struct B { int32_t a; int64_t b; };\n"
+            "#endif\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::None);
+    }
+
+    SECTION("Nesting repackable structs by pointers") {
+        SECTION("Innermost struct is compatible") {
+            auto action = compute_data_layout(
+                "#include <thunks_common.h>\n"
+                "#include <cstdint>\n",
+                "struct C { int32_t a; int32_t b; };\n"
+                "struct B { C* a; int16_t b; };\n"
+                "struct A { int32_t a; B b; };\n"
+                "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+            INFO(FormatDataLayout(action->host_layout));
+
+            REQUIRE(action->guest_layout->contains("A"));
+            REQUIRE(action->guest_layout->contains("B"));
+            REQUIRE(action->guest_layout->contains("C"));
+
+            // 64-bit is fully compatible, but 32-bit needs to zero-extend the pointer itself
+            CHECK(action->GetTypeCompatibility("struct C") == TypeCompatibility::Full);
+            CHECK(action->GetTypeCompatibility("struct B") == compat_full64_repackable32);
+            CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
+        }
+
+        SECTION("Innermost struct is incompatible") {
+            auto action = compute_data_layout(
+                "#include <thunks_common.h>\n"
+                "#include <cstdint>\n",
+                "#ifdef HOST\n"
+                "struct C { int32_t a; int32_t b; };\n"
+                "#else\n"
+                "struct C { int32_t b; int32_t a; };\n"
+                "#endif\n"
+                "struct B { C* a; int16_t b; };\n"
+                "struct A { int32_t a; B b; };\n"
+                "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+            INFO(FormatDataLayout(action->host_layout));
+
+            REQUIRE(action->guest_layout->contains("A"));
+            REQUIRE(action->guest_layout->contains("B"));
+            REQUIRE(action->guest_layout->contains("C"));
+
+            CHECK(action->GetTypeCompatibility("struct C") == TypeCompatibility::Repackable);
+            CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::None);
+            CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::None);
+        }
+    }
+
+    SECTION("Unannotated pointer to union type") {
+        CHECK_THROWS_WITH(compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "union B { int32_t a; uint32_t b; };\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi),
+            Catch::Contains("unannotated member") && Catch::Contains("union type"));
+    }
+
+    SECTION("Self-referencing struct (like VkBaseOutStructure)") {
+        // Without annotation
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { A* a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK_THROWS_WITH(action->GetTypeCompatibility("struct A"), Catch::Contains("recursive reference"));
+    }
+
+    SECTION("Circularly referencing structs") {
+        // Without annotation
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct B;\n"
+            "struct A { B* a; };\n"
+            "struct B { A* a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        REQUIRE(action->guest_layout->contains("B"));
+        CHECK_THROWS_WITH(action->GetTypeCompatibility("struct A"), Catch::Contains("recursive reference"));
+        CHECK_THROWS_WITH(action->GetTypeCompatibility("struct B"), Catch::Contains("recursive reference"));
+    }
+
+    // TODO: Double pointers to compatible data: struct B { int a ; }; struct A { B** b; };
+
+if (guest_abi == GuestABI::X86_32) // TODO
+    SECTION("TODO") {
+        // Without annotation
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct A { void* a; };\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::None);
+    }
+}
diff --git a/unittests/ThunkLibs/common.h b/unittests/ThunkLibs/common.h
index 47c83bd9bd..1534b13aab 100644
--- a/unittests/ThunkLibs/common.h
+++ b/unittests/ThunkLibs/common.h
@@ -42,24 +42,77 @@ class TestDiagnosticConsumer : public clang::TextDiagnosticPrinter {
     }
 };
 
+enum class GuestABI {
+    X86_32,
+    X86_64,
+};
+
+inline std::ostream& operator<<(std::ostream& os, GuestABI abi) {
+    if (abi == GuestABI::X86_32) {
+        os << "X86_32";
+    } else if (abi == GuestABI::X86_64) {
+        os << "X86_64";
+    }
+    return os;
+}
+
 /**
  * Run the given ToolAction on the input code.
  *
  * The "silent" parameter is used to suppress non-fatal diagnostics in tests that expect failure
  */
-inline void run_tool(clang::tooling::ToolAction& action, std::string_view code, bool silent = false) {
+inline void run_tool(clang::tooling::ToolAction& action, std::string_view code, bool silent = false, std::optional<GuestABI> guest_abi = std::nullopt) {
     const char* memory_filename = "gen_input.cpp";
     auto adjuster = clang::tooling::getClangStripDependencyFileAdjuster();
     std::vector<std::string> args = { "clang-tool", "-fsyntax-only", "-std=c++17", "-Werror", "-I.", memory_filename };
+    if (guest_abi == GuestABI::X86_64) {
+        args.push_back("-target");
+        args.push_back("x86_64-linux-gnu");
+    } else if (guest_abi == GuestABI::X86_32) {
+        args.push_back("-target");
+        args.push_back("i686-linux-gnu");
+    } else {
+        args.push_back("-DHOST");
+    }
 
     // Corresponds to the content of GeneratorInterface.h
     const char* common_header_code = R"(namespace fexgen {
-struct returns_guest_pointer {};
+// function annotations: fex_gen_config<MyFunc>
+struct returns_guest_pointer {}; // TODO: Deprecate in favor of pointer_passthrough
 struct custom_host_impl {};
 struct callback_annotation_base { bool prevent_multiple; };
 struct callback_stub : callback_annotation_base {};
 struct callback_guest : callback_annotation_base {};
+
+// type annotations: fex_gen_config<MyStruct>
+//struct opaque_to_guest {};
+//struct opaque_to_host {};
+
+// If used, fex_custom_repack must be specialized for the annotated struct member
+struct custom_repack {};
+
+// struct member annotations: fex_gen_config<&MyStruct::member>
+struct is_padding_member {};
+
+// function parameter annotations: fex_gen_config<fexgen::annotate_parameter<MyFunc, 2>>
+struct ptr_in {};
+struct ptr_out {};
+struct ptr_inout {};
+struct ptr_pointer_passthrough {};
+struct ptr_is_untyped_address {};
+
+template<auto, int, typename = decltype(nullptr)>
+struct annotate_parameter {};
 } // namespace fexgen
+
+template<typename> struct fex_gen_type {};
+template<auto, int, typename = void> struct fex_gen_param {};
+
+template<typename>
+struct fex_gen_type;
+template<auto>
+struct fex_gen_config;
+
 )";
 
     llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> overlay_fs(new llvm::vfs::OverlayFileSystem(llvm::vfs::getRealFileSystem()));
@@ -80,6 +133,6 @@ struct callback_guest : callback_annotation_base {};
     }
 }
 
-inline void run_tool(std::unique_ptr<clang::tooling::ToolAction> action, std::string_view code, bool silent = false) {
-    return run_tool(*action, code, silent);
+inline void run_tool(std::unique_ptr<clang::tooling::ToolAction> action, std::string_view code, bool silent = false, std::optional<GuestABI> guest_abi = std::nullopt) {
+    return run_tool(*action, code, silent, guest_abi);
 }

From fa53e2a91cc8eb088c5aac35b613424ee3b780cf Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Tue, 22 Aug 2023 11:18:57 +0200
Subject: [PATCH 07/48] TODO APPLY TO OTHER TESTS TOO. TODOSQUASH: Also check
 host layout in test

---
 unittests/ThunkLibs/abi.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/unittests/ThunkLibs/abi.cpp b/unittests/ThunkLibs/abi.cpp
index c9a8345853..cca586368f 100644
--- a/unittests/ThunkLibs/abi.cpp
+++ b/unittests/ThunkLibs/abi.cpp
@@ -321,6 +321,10 @@ TEST_CASE_METHOD(Fixture, "DataLayout") {
         CHECK(action->guest_layout->at("A").get_if_struct()->members.at(0).member_name == "b");
         CHECK(action->guest_layout->at("A").get_if_struct()->members.at(1).member_name == "a");
 
+        REQUIRE(!action->host_layout.empty());
+        CHECK(action->host_layout.begin()->second.get_if_struct()->members.at(0).member_name == "a");
+        CHECK(action->host_layout.begin()->second.get_if_struct()->members.at(1).member_name == "b");
+
         CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Repackable);
     }
 

From 1dcdc5319094ef32e8f4cb9a0dabbb276096dc76 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Tue, 22 Aug 2023 12:15:25 +0200
Subject: [PATCH 08/48] unittests/Thunks: Bump libclang requirement to C++20

---
 unittests/ThunkLibs/common.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/unittests/ThunkLibs/common.h b/unittests/ThunkLibs/common.h
index 1534b13aab..87a5f47c5d 100644
--- a/unittests/ThunkLibs/common.h
+++ b/unittests/ThunkLibs/common.h
@@ -64,7 +64,7 @@ inline std::ostream& operator<<(std::ostream& os, GuestABI abi) {
 inline void run_tool(clang::tooling::ToolAction& action, std::string_view code, bool silent = false, std::optional<GuestABI> guest_abi = std::nullopt) {
     const char* memory_filename = "gen_input.cpp";
     auto adjuster = clang::tooling::getClangStripDependencyFileAdjuster();
-    std::vector<std::string> args = { "clang-tool", "-fsyntax-only", "-std=c++17", "-Werror", "-I.", memory_filename };
+    std::vector<std::string> args = { "clang-tool", "-fsyntax-only", "-std=c++20", "-Werror", "-I.", memory_filename };
     if (guest_abi == GuestABI::X86_64) {
         args.push_back("-target");
         args.push_back("x86_64-linux-gnu");

From cd798a50c78219c01b5557f0a1a0ff46d07be532 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Wed, 6 Sep 2023 15:33:27 +0200
Subject: [PATCH 09/48] TODOSPLIT test cases. unittests/ThunkLibs: Add struct
 repacking tests; Add tests for void pointer parameters

---
 unittests/ThunkLibs/generator.cpp | 100 ++++++++++++++++++++++++++++--
 1 file changed, 94 insertions(+), 6 deletions(-)

diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index ae07a82fe1..489966c565 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -73,7 +73,7 @@ struct Fixture {
      * It will be prepended to "code" before processing and also to the generator output.
      */
     SourceWithAST run_thunkgen_guest(std::string_view prelude, std::string_view code, bool silent = false);
-    SourceWithAST run_thunkgen_host(std::string_view prelude, std::string_view code, bool silent = false);
+    SourceWithAST run_thunkgen_host(std::string_view prelude, std::string_view code, GuestABI = GuestABI::X86_64, bool silent = false);
     GenOutput run_thunkgen(std::string_view prelude, std::string_view code, bool silent = false);
 
     const std::string libname = "libtest";
@@ -236,13 +236,13 @@ SourceWithAST Fixture::run_thunkgen_guest(std::string_view prelude, std::string_
 /**
  * Generates host thunk library code from the given input
  */
-SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_view code, bool silent) {
+SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_view code, GuestABI guest_abi, bool silent) {
     const std::string full_code = std::string { prelude } + std::string { code };
 
     // These tests don't deal with data layout differences, so just run data
     // layout analysis with host configuration
     auto data_layout_analysis_factory = std::make_unique<AnalyzeDataLayoutActionFactory>();
-    run_tool(*data_layout_analysis_factory, full_code, silent);
+    run_tool(*data_layout_analysis_factory, full_code, silent, guest_abi);
     auto& data_layout = data_layout_analysis_factory->GetDataLayout();
 
     run_tool(std::make_unique<GenerateThunkLibsActionFactory>(libname, output_filenames, data_layout), full_code, silent);
@@ -282,17 +282,27 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
     auto& filename = output_filenames.host;
     {
         std::ifstream file(filename);
-        const auto current_size = result.size();
+        const auto prelude_size = result.size();
         const auto new_data_size = std::filesystem::file_size(filename);
         result.resize(result.size() + new_data_size);
-        file.read(result.data() + current_size, result.size());
+        file.read(result.data() + prelude_size, result.size());
+
+        // Force all functions to be non-static, since having to define them
+        // would add a lot of noise to simple tests.
+        while (true) {
+            auto pos = result.find("static ", prelude_size);
+            if (pos == std::string::npos) {
+                break;
+            }
+            result.replace(pos, 6, "      "); // Replace "static" with 6 spaces (avoiding reallocation)
+        }
     }
     return SourceWithAST { std::string { prelude } + result };
 }
 
 Fixture::GenOutput Fixture::run_thunkgen(std::string_view prelude, std::string_view code, bool silent) {
     return { run_thunkgen_guest(prelude, code, silent),
-             run_thunkgen_host(prelude, code, silent) };
+             run_thunkgen_host(prelude, code, GuestABI::X86_64, silent) };
 }
 
 TEST_CASE_METHOD(Fixture, "Trivial") {
@@ -525,3 +535,81 @@ TEST_CASE_METHOD(Fixture, "VariadicFunctionsWithoutAnnotation") {
         "template<auto> struct fex_gen_config {};\n"
         "template<> struct fex_gen_config<func> {};\n", true));
 }
+
+TEST_CASE_METHOD(Fixture, "StructRepacking") {
+    auto guest_abi = GENERATE(GuestABI::X86_32, GuestABI::X86_64);
+    INFO(guest_abi);
+
+    // All tests use the same function, but the prelude defining its parameter type "A" varies
+    const std::string code =
+        "#include <thunks_common.h>\n"
+        "void func(A*);\n"
+        "template<auto> struct fex_gen_config {};\n"
+        "template<> struct fex_gen_config<func> : fexgen::custom_host_impl {};\n";
+
+    SECTION("Pointer to struct with consistent data layout") {
+        CHECK_NOTHROW(run_thunkgen_host("struct A { int a; };\n", code, guest_abi));
+    }
+
+    SECTION("Pointer to struct with unannotated pointer member with inconsistent data layout") {
+        const auto prelude =
+            "#ifdef HOST\n"
+            "struct B { int a; };\n"
+            "#else\n"
+            "struct B { int b; };\n"
+            "#endif\n"
+            "struct A { B* a; };\n";
+
+        SECTION("Parameter unannotated") {
+            // TODO
+            CHECK_THROWS(run_thunkgen_host(prelude, code, guest_abi, true));
+        }
+    }
+
+    SECTION("Pointer to struct with pointer member of consistent data layout") {
+        std::string type = GENERATE("char", "short", "int", "float");
+        REQUIRE_NOTHROW(run_thunkgen_host("struct A { " + type + "* a; };\n", code, guest_abi));
+    }
+
+    SECTION("Pointer to struct with pointer member of opaque type") {
+        const auto prelude =
+            "struct B;\n"
+            "struct A { B* a; };\n";
+
+        // Unannotated
+        REQUIRE_THROWS_WITH(run_thunkgen_host(prelude, code, guest_abi), Catch::Contains("incomplete type"));
+    }
+}
+
+TEST_CASE_METHOD(Fixture, "VoidPointerParameter") {
+    auto guest_abi = GENERATE(GuestABI::X86_32, GuestABI::X86_64);
+    INFO(guest_abi);
+
+    SECTION("Unannotated") {
+        const char* code =
+            "#include <thunks_common.h>\n"
+            "void func(void*);\n"
+            "template<> struct fex_gen_config<func> {};\n";
+        if (guest_abi == GuestABI::X86_32) {
+//            CHECK_THROWS_WITH(run_thunkgen_host("", code, guest_abi, true), Catch::Contains("unsupported parameter type", Catch::CaseSensitive::No));
+        } else {
+            // Pointee data is assumed to be compatible on 64-bit
+            CHECK_NOTHROW(run_thunkgen_host("", code, guest_abi));
+        }
+    }
+
+    SECTION("Unannotated in struct") {
+        const char* prelude =
+            "struct A { void* a; };\n";
+        const char* code =
+            "#include <thunks_common.h>\n"
+            "void func(A*);\n"
+            "template<> struct fex_gen_config<func> {};\n";
+        if (guest_abi == GuestABI::X86_32) {
+            // TODO
+            CHECK_THROWS_WITH(run_thunkgen_host(prelude, code, guest_abi, true), Catch::Contains("unsupported parameter type", Catch::CaseSensitive::No));
+        } else {
+            CHECK_NOTHROW(run_thunkgen_host(prelude, code, guest_abi));
+        }
+    }
+}

From 307deedb9f8d170fae06e02fac6a92662b1a41ff Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Tue, 8 Aug 2023 14:41:12 +0200
Subject: [PATCH 10/48] Thunks: Carry annotations in callback wrappers of host
 functions

Previously, two functions with the same signature would always be wrapped
in the same logic. This change allows customizing one function with
annotations while leaving the other one unchanged.
---
 ThunkLibs/Generator/analysis.cpp           |  8 +++--
 ThunkLibs/Generator/analysis.h             |  3 +-
 ThunkLibs/Generator/data_layout.cpp        | 30 ++++++++++++++++
 ThunkLibs/Generator/data_layout.h          |  3 ++
 ThunkLibs/Generator/gen.cpp                | 40 ++++++++++++++++------
 ThunkLibs/include/common/Host.h            | 28 +++++++++++++--
 ThunkLibs/include/common/PackedArguments.h |  4 +--
 unittests/ThunkLibs/generator.cpp          |  9 ++---
 8 files changed, 103 insertions(+), 22 deletions(-)

diff --git a/ThunkLibs/Generator/analysis.cpp b/ThunkLibs/Generator/analysis.cpp
index 4c6a49aa16..f57f00421b 100644
--- a/ThunkLibs/Generator/analysis.cpp
+++ b/ThunkLibs/Generator/analysis.cpp
@@ -168,6 +168,8 @@ static ParameterAnnotations GetParameterAnnotations(clang::ASTContext& context,
 void AnalysisAction::ParseInterface(clang::ASTContext& context) {
     ErrorReporter report_error { context };
 
+    const std::unordered_map<unsigned, ParameterAnnotations> no_param_annotations {};
+
     // TODO: Assert fex_gen_type is not declared at non-global namespaces
     if (auto template_decl = FindClassTemplateDeclByName(*context.getTranslationUnitDecl(), "fex_gen_type")) {
         for (auto* decl : template_decl->specializations()) {
@@ -183,7 +185,7 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
 
             {
                 if (type->isFunctionPointerType() || type->isFunctionType()) {
-                    funcptr_types.insert(type.getTypePtr());
+                    funcptr_types["TODO_FUNC_NAME_FOR_ANNOTATED_TYPES_" + type.getAsString()] = std::pair { type.getTypePtr(), no_param_annotations };
                 } else {
                     // TODO: Unify this with the is_opaque path above
                     auto [it, inserted] = types.emplace(context.getCanonicalType(type.getTypePtr()), RepackedType { });
@@ -347,7 +349,7 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
 
                             data.callbacks.emplace(param_idx, callback);
                             if (!callback.is_stub && !callback.is_guest && !data.custom_host_impl) {
-                                funcptr_types.insert(context.getCanonicalType(funcptr));
+                                funcptr_types[emitted_function->getNameAsString() + "_cb" + std::to_string(param_idx)] = std::pair { context.getCanonicalType(funcptr), no_param_annotations };
                             }
 
                             if (data.callbacks.size() != 1) {
@@ -416,7 +418,7 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
 
                     // For indirect calls, register the function signature as a function pointer type
                     if (namespace_info.indirect_guest_calls) {
-                        funcptr_types.insert(context.getCanonicalType(emitted_function->getFunctionType()));
+                        funcptr_types[emitted_function->getNameAsString()] = std::pair { context.getCanonicalType(emitted_function->getFunctionType()), data.param_annotations };
                     }
 
                     thunks.push_back(std::move(data));
diff --git a/ThunkLibs/Generator/analysis.h b/ThunkLibs/Generator/analysis.h
index 4c625d8529..f9ba6a5451 100644
--- a/ThunkLibs/Generator/analysis.h
+++ b/ThunkLibs/Generator/analysis.h
@@ -128,7 +128,8 @@ class AnalysisAction : public clang::ASTFrontendAction {
     std::vector<ThunkedFunction> thunks;
     std::vector<ThunkedAPIFunction> thunked_api;
 
-    std::unordered_set<const clang::Type*> funcptr_types;
+    // TODO: Rename, since this is now not just per type but also per set of annotations
+    std::unordered_map<std::string, std::pair<const clang::Type*, std::unordered_map<unsigned, ParameterAnnotations>>> funcptr_types;
 
 public: // TODO: Remove, make only RepackedType public
     struct RepackedType {
diff --git a/ThunkLibs/Generator/data_layout.cpp b/ThunkLibs/Generator/data_layout.cpp
index af5ba5cd81..f6cff339ad 100644
--- a/ThunkLibs/Generator/data_layout.cpp
+++ b/ThunkLibs/Generator/data_layout.cpp
@@ -148,8 +148,34 @@ ABI GetStableLayout(const clang::ASTContext& context, const std::unordered_map<c
     return stable_layout;
 }
 
+// TODO: Turn into static local function
+auto get_sha256 = [](const std::string& function_name) {
+    std::array<uint8_t, 32> sha256;
+    SHA256(reinterpret_cast<const unsigned char*>(function_name.data()),
+           function_name.size(),
+           sha256.data());
+    return sha256;
+};
+
 void AnalyzeDataLayoutAction::EmitOutput(clang::ASTContext& context) {
     type_abi = GetStableLayout(context, ComputeDataLayout(context, types));
+
+    // Register functions that must be guest-callable through host function pointers
+    for (auto funcptr_type_it = funcptr_types.begin(); funcptr_type_it != funcptr_types.end(); ++funcptr_type_it) {
+        auto& funcptr_id = funcptr_type_it->first;
+        auto& [type, param_annotations] = funcptr_type_it->second;
+        auto func_type = type->getAs<clang::FunctionProtoType>();
+        std::string mangled_name = clang::QualType { type, 0 }.getAsString();
+        auto cb_sha256 = get_sha256("fexcallback_" + mangled_name);
+        FuncPtrInfo info = { cb_sha256 };
+
+        info.result = func_type->getReturnType().getAsString();
+        info.param_annotations = param_annotations;
+        for (auto arg : func_type->getParamTypes()) {
+            info.args.push_back(arg.getAsString());
+        }
+        type_abi.funcptr_types[funcptr_id] = std::move(info);
+    }
 }
 
 TypeCompatibility DataLayoutCompareAction::GetTypeCompatibility(
@@ -290,6 +316,10 @@ TypeCompatibility DataLayoutCompareAction::GetTypeCompatibility(
     return compat;
 }
 
+FuncPtrInfo DataLayoutCompareAction::LookupGuestFuncPtrInfo(const char* funcptr_id) {
+    return abi.funcptr_types.at(funcptr_id);
+}
+
 DataLayoutCompareActionFactory::DataLayoutCompareActionFactory(const ABI& abi) : abi(abi) {
 
 }
diff --git a/ThunkLibs/Generator/data_layout.h b/ThunkLibs/Generator/data_layout.h
index 6d0546ad93..dac58e7f1c 100644
--- a/ThunkLibs/Generator/data_layout.h
+++ b/ThunkLibs/Generator/data_layout.h
@@ -87,6 +87,7 @@ struct FuncPtrInfo {
 };
 
 struct ABI : std::unordered_map<std::string, TypeInfo> {
+    std::unordered_map<std::string, FuncPtrInfo> funcptr_types;
     int pointer_size; // in bytes
 };
 
@@ -114,6 +115,8 @@ class DataLayoutCompareAction : public AnalysisAction {
             const std::unordered_map<const clang::Type*, TypeInfo> host_abi,
             std::unordered_map<const clang::Type*, TypeCompatibility>& type_compat);
 
+    FuncPtrInfo LookupGuestFuncPtrInfo(const char* funcptr_id);
+
 protected: // TODO: Should probably be private
     // TODO: Make it clearer that this is the guest ABI
     const ABI& abi;
diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index 2d2260b53f..b1941c06ba 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -118,8 +118,8 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
         return ret;
     };
 
-    auto get_sha256 = [this](const std::string& function_name) {
-        std::string sha256_message = libname + ":" + function_name;
+    auto get_sha256 = [this](const std::string& function_name, bool include_libname) {
+        std::string sha256_message = (include_libname ? libname + ":" : "") + function_name;
         std::vector<unsigned char> sha256(SHA256_DIGEST_LENGTH);
         SHA256(reinterpret_cast<const unsigned char*>(sha256_message.data()),
                sha256_message.size(),
@@ -139,18 +139,26 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
         file << "extern \"C\" {\n";
         for (auto& thunk : thunks) {
             const auto& function_name = thunk.function_name;
-            auto sha256 = get_sha256(function_name);
+            auto sha256 = get_sha256(function_name, true);
             fmt::print( file, "MAKE_THUNK({}, {}, \"{:#02x}\")\n",
                         libname, function_name, fmt::join(sha256, ", "));
         }
         file << "}\n";
 
         // Guest->Host transition points for invoking runtime host-function pointers based on their signature
+        std::vector<std::vector<unsigned char>> sha256s;
         for (auto type_it = funcptr_types.begin(); type_it != funcptr_types.end(); ++type_it) {
-            auto* type = *type_it;
+            auto* type = type_it->second.first;
             std::string funcptr_signature = clang::QualType { type, 0 }.getAsString();
 
-            auto cb_sha256 = get_sha256("fexcallback_" + funcptr_signature);
+            auto cb_sha256 = get_sha256("fexcallback_" + funcptr_signature, false);
+            auto it = std::find(sha256s.begin(), sha256s.end(), cb_sha256);
+            if (it != sha256s.end()) {
+                // TODO: Avoid this ugly way of avoiding duplicates
+                continue;
+            } else {
+                sha256s.push_back(cb_sha256);
+            }
 
             // Thunk used for guest-side calls to host function pointers
             file << "  // " << funcptr_signature << "\n";
@@ -337,18 +345,30 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
         file << "static ExportEntry exports[] = {\n";
         for (auto& thunk : thunks) {
             const auto& function_name = thunk.function_name;
-            auto sha256 = get_sha256(function_name);
+            auto sha256 = get_sha256(function_name, true);
             fmt::print( file, "  {{(uint8_t*)\"\\x{:02x}\", (void(*)(void *))&fexfn_unpack_{}_{}}}, // {}:{}\n",
                         fmt::join(sha256, "\\x"), libname, function_name, libname, function_name);
         }
 
         // Endpoints for Guest->Host invocation of runtime host-function pointers
-        for (auto& type : funcptr_types) {
+        for (auto& host_funcptr_entry : funcptr_types) {
+            auto& [type, param_annotations] = host_funcptr_entry.second;
             std::string mangled_name = clang::QualType { type, 0 }.getAsString();
-            auto cb_sha256 = get_sha256("fexcallback_" + mangled_name);
-            fmt::print( file, "  {{(uint8_t*)\"\\x{:02x}\", (void(*)(void *))&CallbackUnpack<{}>::ForIndirectCall}},\n",
-                        fmt::join(cb_sha256, "\\x"), mangled_name);
+            auto info = LookupGuestFuncPtrInfo(host_funcptr_entry.first.c_str());
+
+            std::string annotations;
+            for (int param_idx = 0; param_idx < info.args.size(); ++param_idx) {
+                if (param_idx != 0) {
+                    annotations += ", ";
+                }
+
+                // TODO: Add annotations as needed
+                annotations += "ParameterAnnotations {}";
+            }
+            fmt::print( file, "  {{(uint8_t*)\"\\x{:02x}\", (void(*)(void *))&GuestWrapperForHostFunction<{}({})>::Call<{}>}}, // {}\n",
+                        fmt::join(info.sha256, "\\x"), info.result, fmt::join(info.args, ", "), annotations, host_funcptr_entry.first);
         }
+
         file << "  { nullptr, nullptr }\n";
         file << "};\n";
 
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index f4fa32c414..bb4c9d69c3 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -103,6 +103,9 @@ struct GuestcallInfo {
   asm volatile("mov %0, x11" : "=r" (target_variable))
 #endif
 
+struct ParameterAnnotations {
+};
+
 template<typename>
 struct CallbackUnpack;
 
@@ -120,8 +123,23 @@ struct CallbackUnpack<Result(Args...)> {
       return packed_args.rv;
     }
   }
+};
+
+template<ParameterAnnotations Annotation, typename T>
+auto Projection(T& data) {
+  return data;
+}
+
+template<typename>
+struct GuestWrapperForHostFunction;
+
+template<typename Result, typename... Args>
+struct GuestWrapperForHostFunction<Result(Args...)> {
+  // Host functions called from Guest
+  template<ParameterAnnotations... Annotations>
+  static void Call(void* argsv) {
+    static_assert(sizeof...(Annotations) == sizeof...(Args));
 
-  static void ForIndirectCall(void* argsv) {
     auto args = reinterpret_cast<PackedArguments<Result, Args..., uintptr_t>*>(argsv);
     constexpr auto CBIndex = sizeof...(Args);
     uintptr_t cb;
@@ -168,8 +186,14 @@ struct CallbackUnpack<Result(Args...)> {
       cb = args->a23;
     }
 
+    // This is almost the same type as "Result func(Args..., uintptr_t)", but
+    // individual parameters annotated as passthrough are replaced by guest_layout<GuestArgs>
     auto callback = reinterpret_cast<Result(*)(Args..., uintptr_t)>(cb);
-    Invoke(callback, *args);
+
+    auto f = [&callback](Args... args, uintptr_t target) -> Result {
+      return callback(Projection<Annotations, Args>(args)..., target);
+    };
+    Invoke(f, *args);
   }
 };
 
diff --git a/ThunkLibs/include/common/PackedArguments.h b/ThunkLibs/include/common/PackedArguments.h
index 14531db2ac..17af2f41c5 100644
--- a/ThunkLibs/include/common/PackedArguments.h
+++ b/ThunkLibs/include/common/PackedArguments.h
@@ -113,8 +113,8 @@ T&& operator,(T&& t, Regularize) {
     return std::forward<T>(t);
 }
 
-template<typename Result, typename... Args>
-void Invoke(Result(*func)(Args...), PackedArguments<Result, Args...>& args) {
+template<typename Result, typename... Args, typename Func>
+void Invoke(Func&& func, PackedArguments<Result, Args...>& args) requires(std::is_invocable_r_v<Result, Func, Args...>) {
     constexpr auto NumArgs = sizeof...(Args);
     static_assert(NumArgs <= 19 || NumArgs == 24);
 
diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index 489966c565..5c889a01fa 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -270,9 +270,10 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
         "  uintptr_t GuestUnpacker;\n"
         "  uintptr_t GuestTarget;\n"
         "};\n"
+        "struct ParameterAnnotations {};\n"
         "template<typename>\n"
-        "struct CallbackUnpack {\n"
-        "  static void ForIndirectCall(void* argsv);\n"
+        "struct GuestWrapperForHostFunction {\n"
+        "  template<ParameterAnnotations...> static void Call(void*);\n"
         "};\n"
         "template<typename F>\n"
         "void FinalizeHostTrampolineForGuestFunction(F*);\n"
@@ -377,7 +378,7 @@ TEST_CASE_METHOD(Fixture, "FunctionPointerViaType") {
         matches(varDecl(
             hasName("exports"),
             hasType(constantArrayType(hasElementType(asString("struct ExportEntry")), hasSize(2))),
-            hasInitializer(hasDescendant(declRefExpr(to(cxxMethodDecl(hasName("ForIndirectCall"), ofClass(hasName("CallbackUnpack"))).bind("funcptr")))))
+            hasInitializer(hasDescendant(declRefExpr(to(cxxMethodDecl(hasName("Call"), ofClass(hasName("GuestWrapperForHostFunction"))).bind("funcptr")))))
             )).check_binding("funcptr", +[](const clang::CXXMethodDecl* decl) {
                 auto parent = llvm::cast<clang::ClassTemplateSpecializationDecl>(decl->getParent());
                 return parent->getTemplateArgs().get(0).getAsType().getAsString() == "int (char, char)";
@@ -415,7 +416,7 @@ TEST_CASE_METHOD(Fixture, "FunctionPointerParameter") {
         matches(varDecl(
             hasName("exports"),
             hasType(constantArrayType(hasElementType(asString("struct ExportEntry")), hasSize(3))),
-            hasInitializer(hasDescendant(declRefExpr(to(cxxMethodDecl(hasName("ForIndirectCall"), ofClass(hasName("CallbackUnpack")))))))
+            hasInitializer(hasDescendant(declRefExpr(to(cxxMethodDecl(hasName("Call"), ofClass(hasName("GuestWrapperForHostFunction")))))))
             )));
 }
 

From 0c5e4f730f1d01830f4352155f1ed84a3e6621d8 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Tue, 8 Aug 2023 14:55:38 +0200
Subject: [PATCH 11/48] Thunks: Introduce an intermediate guest_layout wrapper
 to unpack callback arguments

This will be used later to aid automatic struct repacking.
---
 ThunkLibs/include/common/Host.h | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index bb4c9d69c3..8828711570 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -106,6 +106,12 @@ struct GuestcallInfo {
 struct ParameterAnnotations {
 };
 
+// Placeholder type to indicate the given data is in guest-layout
+template<typename T>
+struct guest_layout {
+  T data;
+};
+
 template<typename>
 struct CallbackUnpack;
 
@@ -126,8 +132,8 @@ struct CallbackUnpack<Result(Args...)> {
 };
 
 template<ParameterAnnotations Annotation, typename T>
-auto Projection(T& data) {
-  return data;
+auto Projection(guest_layout<T>& data) {
+  return data.data;
 }
 
 template<typename>
@@ -140,7 +146,7 @@ struct GuestWrapperForHostFunction<Result(Args...)> {
   static void Call(void* argsv) {
     static_assert(sizeof...(Annotations) == sizeof...(Args));
 
-    auto args = reinterpret_cast<PackedArguments<Result, Args..., uintptr_t>*>(argsv);
+    auto args = reinterpret_cast<PackedArguments<Result, guest_layout<Args>..., uintptr_t>*>(argsv);
     constexpr auto CBIndex = sizeof...(Args);
     uintptr_t cb;
     static_assert(CBIndex <= 18 || CBIndex == 23);
@@ -190,7 +196,8 @@ struct GuestWrapperForHostFunction<Result(Args...)> {
     // individual parameters annotated as passthrough are replaced by guest_layout<GuestArgs>
     auto callback = reinterpret_cast<Result(*)(Args..., uintptr_t)>(cb);
 
-    auto f = [&callback](Args... args, uintptr_t target) -> Result {
+    auto f = [&callback](guest_layout<Args>... args, uintptr_t target) -> Result {
+      // Fold over each of Annotations, Args, and args. This will match up the elements in triplets.
       return callback(Projection<Annotations, Args>(args)..., target);
     };
     Invoke(f, *args);

From 1639db5d2c0d79609f5c7c3779c9edd2f8abce72 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Tue, 19 Sep 2023 15:44:45 +0200
Subject: [PATCH 12/48] Thunks: Implement ptr_passthrough annotation

This annotation can be used for data types that can't be repacked
automatically even with custom repack annotations. With ptr_passthrough,
the types are wrapped in guest_layout and passed to the host like that.
---
 ThunkLibs/Generator/analysis.cpp              | 16 ++++-
 ThunkLibs/Generator/analysis.h                |  2 +
 ThunkLibs/Generator/gen.cpp                   | 30 +++++---
 ThunkLibs/include/common/Host.h               |  9 ++-
 ThunkLibs/libvulkan/Host.cpp                  |  8 +--
 ThunkLibs/libwayland-client/Host.cpp          | 68 ++++++++++---------
 .../libwayland-client_interface.cpp           |  1 -
 unittests/ThunkLibs/generator.cpp             | 20 ++++--
 8 files changed, 97 insertions(+), 57 deletions(-)

diff --git a/ThunkLibs/Generator/analysis.cpp b/ThunkLibs/Generator/analysis.cpp
index f57f00421b..761026aeee 100644
--- a/ThunkLibs/Generator/analysis.cpp
+++ b/ThunkLibs/Generator/analysis.cpp
@@ -159,7 +159,12 @@ static ParameterAnnotations GetParameterAnnotations(clang::ASTContext& context,
     ParameterAnnotations ret;
 
     for (const clang::CXXBaseSpecifier& base : decl->bases()) {
-        throw report_error(base.getSourceRange().getBegin(), "Unknown parameter annotation");
+        auto annotation = base.getType().getAsString();
+        if (annotation == "fexgen::ptr_passthrough") {
+            ret.is_passthrough = true;
+        } else {
+            throw report_error(base.getSourceRange().getBegin(), "Unknown parameter annotation");
+        }
     }
 
     return ret;
@@ -358,6 +363,9 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
                             if (funcptr->isVariadic() && !callback.is_stub) {
                                 throw report_error(template_arg_loc, "Variadic callbacks are not supported");
                             }
+
+                            // Force treatment as passthrough-pointer
+                            data.param_annotations[param_idx].is_passthrough = true;
                         } else if (param_type->isBuiltinType()) {
                             // NOTE: Intentionally not using getCanonicalType here since that would turn e.g. size_t into platform-specific types
                             // TODO: Still, we may want to de-duplicate some of these...
@@ -372,6 +380,12 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
                             if ( pointee_type->isStructureType()) {
                                 check_struct_type(pointee_type.getTypePtr());
                                 types.emplace(context.getCanonicalType(pointee_type.getTypePtr()), RepackedType { });
+                            } else if (data.param_annotations[param_idx].is_passthrough) {
+                                if (!data.custom_host_impl) {
+                                    throw report_error(param_loc, "Passthrough annotation requires custom host implementation");
+                                }
+
+                                // Nothing to do
                             } else if (false /* TODO: Can't check if this is unsupported until data layout analysis is complete */) {
                                 fprintf(stderr, "NAME: %s\n", pointee_type.getAsString().c_str());
                                 throw report_error(param_loc, "Unsupported parameter type")
diff --git a/ThunkLibs/Generator/analysis.h b/ThunkLibs/Generator/analysis.h
index f9ba6a5451..aaa51cdcf0 100644
--- a/ThunkLibs/Generator/analysis.h
+++ b/ThunkLibs/Generator/analysis.h
@@ -22,6 +22,8 @@ struct ThunkedCallback : FunctionParams {
 };
 
 struct ParameterAnnotations {
+    bool is_passthrough = false;
+
     bool operator==(const ParameterAnnotations&) const = default;
 };
 
diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index b1941c06ba..f92d212a40 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -284,8 +284,10 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                     auto cb = thunk.callbacks.find(idx);
                     if (cb != thunk.callbacks.end() && cb->second.is_guest) {
                         file << "fex_guest_function_ptr a_" << idx;
+                    } else if (thunk.param_annotations[idx].is_passthrough) {
+                        fmt::print(file, "guest_layout<{}> a_{}", type.getAsString(), idx);
                     } else {
-                      file << format_decl(type, fmt::format("a_{}", idx));
+                        file << format_decl(type, fmt::format("a_{}", idx));
                     }
                 }
                 // Using trailing return type as it makes handling function pointer returns much easier
@@ -293,11 +295,13 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
             }
 
             // Packed argument structs used in fexfn_unpack_*
-            auto GeneratePackedArgs = [&](const auto &function_name, const auto &thunk) -> std::string {
+            auto GeneratePackedArgs = [&](const auto &function_name, const ThunkedFunction &thunk) -> std::string {
                 std::string struct_name = "fexfn_packed_args_" + libname + "_" + function_name;
                 file << "struct " << struct_name << " {\n";
 
-                file << format_struct_members(thunk, "  ");
+                for (std::size_t idx = 0; idx < thunk.param_types.size(); ++idx) {
+                    fmt::print(file, "  guest_layout<{}> a_{};\n", get_type_name(context, thunk.param_types[idx].getTypePtr()), idx);
+                }
                 if (!thunk.return_type->isVoidType()) {
                     file << "  " << format_decl(thunk.return_type, "rv") << ";\n";
                 } else if (thunk.param_types.size() == 0) {
@@ -319,18 +323,22 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
             file << (thunk.return_type->isVoidType() ? "  " : "  args->rv = ") << function_to_call << "(";
             {
                 auto format_param = [&](std::size_t idx) {
+                    std::string raw_arg = fmt::format("args->a_{}.data", idx);
+
                     auto cb = thunk.callbacks.find(idx);
                     if (cb != thunk.callbacks.end() && cb->second.is_stub) {
                         return "fexfn_unpack_" + get_callback_name(function_name, cb->first) + "_stub";
                     } else if (cb != thunk.callbacks.end() && cb->second.is_guest) {
-                        return fmt::format("fex_guest_function_ptr {{ args->a_{} }}", idx);
+                        return fmt::format("fex_guest_function_ptr {{ {} }}", raw_arg);
                     } else if (cb != thunk.callbacks.end()) {
-                        auto arg_name = fmt::format("args->a_{}", idx);
+                        auto arg_name = fmt::format("args->a_{}.data", idx);
                         // Use comma operator to inject a function call before returning the argument
                         return "(FinalizeHostTrampolineForGuestFunction(" + arg_name + "), " + arg_name + ")";
-
-                    } else {
+                    } else if (thunk.param_annotations[idx].is_passthrough) {
+                        // Pass raw guest_layout<T*>
                         return fmt::format("args->a_{}", idx);
+                    } else {
+                        return raw_arg;
                     }
                 };
 
@@ -362,8 +370,12 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                     annotations += ", ";
                 }
 
-                // TODO: Add annotations as needed
-                annotations += "ParameterAnnotations {}";
+                annotations += "ParameterAnnotations {";
+                if (param_annotations.contains(param_idx) && param_annotations.at(param_idx).is_passthrough) {
+                    // TODO: Rename annotation in Host.h?
+                    annotations += ".is_passthrough=true,";
+                }
+                annotations += "}";
             }
             fmt::print( file, "  {{(uint8_t*)\"\\x{:02x}\", (void(*)(void *))&GuestWrapperForHostFunction<{}({})>::Call<{}>}}, // {}\n",
                         fmt::join(info.sha256, "\\x"), info.result, fmt::join(info.args, ", "), annotations, host_funcptr_entry.first);
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index 8828711570..09a9f77167 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -104,6 +104,7 @@ struct GuestcallInfo {
 #endif
 
 struct ParameterAnnotations {
+    bool is_passthrough = false;
 };
 
 // Placeholder type to indicate the given data is in guest-layout
@@ -133,7 +134,11 @@ struct CallbackUnpack<Result(Args...)> {
 
 template<ParameterAnnotations Annotation, typename T>
 auto Projection(guest_layout<T>& data) {
-  return data.data;
+  if constexpr (Annotation.is_passthrough) {
+    return data;
+  } else {
+    return data.data;
+  }
 }
 
 template<typename>
@@ -194,7 +199,7 @@ struct GuestWrapperForHostFunction<Result(Args...)> {
 
     // This is almost the same type as "Result func(Args..., uintptr_t)", but
     // individual parameters annotated as passthrough are replaced by guest_layout<GuestArgs>
-    auto callback = reinterpret_cast<Result(*)(Args..., uintptr_t)>(cb);
+    auto callback = reinterpret_cast<Result(*)(std::conditional_t<Annotations.is_passthrough, guest_layout<Args>, Args>..., uintptr_t)>(cb);
 
     auto f = [&callback](guest_layout<Args>... args, uintptr_t target) -> Result {
       // Fold over each of Annotations, Args, and args. This will match up the elements in triplets.
diff --git a/ThunkLibs/libvulkan/Host.cpp b/ThunkLibs/libvulkan/Host.cpp
index 7339335780..45f6049a0a 100644
--- a/ThunkLibs/libvulkan/Host.cpp
+++ b/ThunkLibs/libvulkan/Host.cpp
@@ -62,7 +62,7 @@ static VkBool32 DummyVkDebugReportCallback(VkDebugReportFlagsEXT, VkDebugReportO
   return VK_FALSE;
 }
 
-static VkResult FEXFN_IMPL(vkCreateInstance)(const VkInstanceCreateInfo* a_0, const VkAllocationCallbacks* a_1, VkInstance* a_2) {
+static VkResult FEXFN_IMPL(vkCreateInstance)(const VkInstanceCreateInfo* a_0, const VkAllocationCallbacks* a_1, guest_layout<VkInstance*> a_2) {
   const VkInstanceCreateInfo* vk_struct_base = a_0;
   for (const VkBaseInStructure* vk_struct = reinterpret_cast<const VkBaseInStructure*>(vk_struct_base); vk_struct->pNext; vk_struct = vk_struct->pNext) {
     // Override guest callbacks used for VK_EXT_debug_report
@@ -76,11 +76,11 @@ static VkResult FEXFN_IMPL(vkCreateInstance)(const VkInstanceCreateInfo* a_0, co
     }
   }
 
-  return LDR_PTR(vkCreateInstance)(vk_struct_base, nullptr, a_2);
+  return LDR_PTR(vkCreateInstance)(vk_struct_base, nullptr, a_2.data);
 }
 
-static VkResult FEXFN_IMPL(vkCreateDevice)(VkPhysicalDevice a_0, const VkDeviceCreateInfo* a_1, const VkAllocationCallbacks* a_2, VkDevice* a_3){
-  return LDR_PTR(vkCreateDevice)(a_0, a_1, nullptr, a_3);
+static VkResult FEXFN_IMPL(vkCreateDevice)(VkPhysicalDevice a_0, const VkDeviceCreateInfo* a_1, const VkAllocationCallbacks* a_2, guest_layout<VkDevice*> a_3){
+  return LDR_PTR(vkCreateDevice)(a_0, a_1, nullptr, a_3.data);
 }
 
 static VkResult FEXFN_IMPL(vkAllocateMemory)(VkDevice a_0, const VkMemoryAllocateInfo* a_1, const VkAllocationCallbacks* a_2, VkDeviceMemory* a_3){
diff --git a/ThunkLibs/libwayland-client/Host.cpp b/ThunkLibs/libwayland-client/Host.cpp
index 84ba5e5571..8cfcb4693a 100644
--- a/ThunkLibs/libwayland-client/Host.cpp
+++ b/ThunkLibs/libwayland-client/Host.cpp
@@ -46,7 +46,7 @@ static void WaylandFinalizeHostTrampolineForGuestListener(void (*callback)()) {
 }
 
 extern "C" int fexfn_impl_libwayland_client_wl_proxy_add_listener(struct wl_proxy *proxy,
-      void (**callback)(void), void *data) {
+      guest_layout<void (**)(void)> callback_raw, guest_layout<void*> data) {
   auto guest_interface = ((wl_proxy_private*)proxy)->interface;
 
   for (int i = 0; i < guest_interface->event_count; ++i) {
@@ -60,99 +60,101 @@ extern "C" int fexfn_impl_libwayland_client_wl_proxy_add_listener(struct wl_prox
     // ? just indicates that the argument may be null, so it doesn't change the signature
     signature.erase(std::remove(signature.begin(), signature.end(), '?'), signature.end());
 
+    auto callback = callback_raw.data[i];
+
     if (signature == "") {
       // E.g. xdg_toplevel::close
-      WaylandFinalizeHostTrampolineForGuestListener<>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<>(callback);
     } else if (signature == "a") {
       // E.g. xdg_toplevel::wm_capabilities
-      WaylandFinalizeHostTrampolineForGuestListener<'a'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'a'>(callback);
     } else if (signature == "hu") {
       // E.g. zwp_linux_dmabuf_feedback_v1::format_table
-      WaylandFinalizeHostTrampolineForGuestListener<'h', 'u'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'h', 'u'>(callback);
     } else if (signature == "i") {
       // E.g. wl_output_listener::scale
-      WaylandFinalizeHostTrampolineForGuestListener<'i'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'i'>(callback);
     } else if (signature == "if") {
       // E.g. wl_touch_listener::orientation
-      WaylandFinalizeHostTrampolineForGuestListener<'i', 'f'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'i', 'f'>(callback);
     } else if (signature == "iff") {
       // E.g. wl_touch_listener::shape
-      WaylandFinalizeHostTrampolineForGuestListener<'i', 'f', 'f'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'i', 'f', 'f'>(callback);
     } else if (signature == "ii") {
       // E.g. xdg_toplevel::configure_bounds
-      WaylandFinalizeHostTrampolineForGuestListener<'i', 'i'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'i', 'i'>(callback);
     } else if (signature == "iia") {
       // E.g. xdg_toplevel::configure
-      WaylandFinalizeHostTrampolineForGuestListener<'i', 'i', 'a'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'i', 'i', 'a'>(callback);
     } else if (signature == "iiiiissi") {
       // E.g. wl_output_listener::geometry
-      WaylandFinalizeHostTrampolineForGuestListener<'i', 'i', 'i', 'i', 'i', 's', 's', 'i'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'i', 'i', 'i', 'i', 'i', 's', 's', 'i'>(callback);
     } else if (signature == "n") {
       // E.g. wl_data_device_listener::data_offer
-      WaylandFinalizeHostTrampolineForGuestListener<'n'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'n'>(callback);
     } else if (signature == "o") {
       // E.g. wl_data_device_listener::selection
-      WaylandFinalizeHostTrampolineForGuestListener<'o'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'o'>(callback);
     } else if (signature == "u") {
       // E.g. wl_registry::global_remove
-      WaylandFinalizeHostTrampolineForGuestListener<'u'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u'>(callback);
     } else if (signature == "uff") {
       // E.g. wl_pointer_listener::motion
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'f', 'f'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'f', 'f'>(callback);
     } else if (signature == "uhu") {
       // E.g. wl_keyboard_listener::keymap
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'h', 'u'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'h', 'u'>(callback);
     } else if (signature == "ui") {
       // E.g. wl_pointer_listener::axis_discrete
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'i'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'i'>(callback);
     } else if (signature == "uiff") {
       // E.g. wl_touch_listener::motion
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'i', 'f', 'f'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'i', 'f', 'f'>(callback);
     } else if (signature == "uiii") {
       // E.g. wl_output_listener::mode
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'i', 'i', 'i'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'i', 'i', 'i'>(callback);
     } else if (signature == "uo") {
       // E.g. wl_pointer_listener::leave
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'o'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'o'>(callback);
     } else if (signature == "uoa") {
       // E.g. wl_keyboard_listener::enter
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'o', 'a'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'o', 'a'>(callback);
     } else if (signature == "uoff") {
       // E.g. wl_pointer_listener::enter
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'o', 'f', 'f'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'o', 'f', 'f'>(callback);
     } else if (signature == "uoffo") {
       // E.g. wl_data_device_listener::enter
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'o', 'f', 'f', 'o'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'o', 'f', 'f', 'o'>(callback);
     } else if (signature == "usu") {
       // E.g. wl_registry::global
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 's', 'u'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 's', 'u'>(callback);
     } else if (signature == "uu") {
       // E.g. wl_pointer_listener::axis_stop
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u'>(callback);
     } else if (signature == "uuf") {
       // E.g. wl_pointer_listener::axis
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'f'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'f'>(callback);
     } else if (signature == "uui") {
       // E.g. wl_touch_listener::up
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'i'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'i'>(callback);
     } else if (signature == "uuoiff") {
       // E.g. wl_touch_listener::down
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'o', 'i', 'f', 'f'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'o', 'i', 'f', 'f'>(callback);
     } else if (signature == "uuu") {
       // E.g. zwp_linux_dmabuf_v1::modifier
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'u'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'u'>(callback);
     } else if (signature == "uuuu") {
       // E.g. wl_pointer_listener::button
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'u', 'u'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'u', 'u'>(callback);
     } else if (signature == "uuuuu") {
       // E.g. wl_keyboard_listener::modifiers
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'u', 'u', 'u'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'u', 'u', 'u', 'u', 'u'>(callback);
     } else if (signature == "s") {
       // E.g. wl_seat::name
-      WaylandFinalizeHostTrampolineForGuestListener<'s'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'s'>(callback);
     } else if (signature == "sii") {
       // E.g. zwp_text_input_v3::preedit_string
-      WaylandFinalizeHostTrampolineForGuestListener<'s', 'i', 'i'>(callback[i]);
+      WaylandFinalizeHostTrampolineForGuestListener<'s', 'i', 'i'>(callback);
     } else {
       fprintf(stderr, "TODO: Unknown wayland event signature descriptor %s\n", signature.data());
       std::abort();
@@ -160,7 +162,7 @@ extern "C" int fexfn_impl_libwayland_client_wl_proxy_add_listener(struct wl_prox
   }
 
   // Pass the original function pointer table to the host wayland library. This ensures the table is valid until the listener is unregistered.
-  return fexldr_ptr_libwayland_client_wl_proxy_add_listener(proxy, callback, data);
+  return fexldr_ptr_libwayland_client_wl_proxy_add_listener(proxy, callback_raw.data, data.data);
 }
 
 wl_interface* fexfn_impl_libwayland_client_fex_wl_exchange_interface_pointer(wl_interface* guest_interface, char const* name) {
diff --git a/ThunkLibs/libwayland-client/libwayland-client_interface.cpp b/ThunkLibs/libwayland-client/libwayland-client_interface.cpp
index 80b86debfe..babccd4373 100644
--- a/ThunkLibs/libwayland-client/libwayland-client_interface.cpp
+++ b/ThunkLibs/libwayland-client/libwayland-client_interface.cpp
@@ -70,4 +70,3 @@ template<> struct fex_gen_config<wl_proxy_marshal_array_flags> {};
 wl_interface* fex_wl_exchange_interface_pointer(wl_interface*, const char* name);
 template<> struct fex_gen_config<fex_wl_exchange_interface_pointer> : fexgen::custom_host_impl/*, fexgen::custom_guest_entrypoint*/ {};
 //template<> struct fex_gen_param<fex_wl_exchange_interface_pointer, 0, wl_interface*> : fexgen::ptr_passthrough {};
-template<> struct fex_gen_param<fex_wl_exchange_interface_pointer, 1, const char*> : fexgen::ptr_passthrough {};
diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index 5c889a01fa..0b4eb47e29 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -248,8 +248,10 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
     run_tool(std::make_unique<GenerateThunkLibsActionFactory>(libname, output_filenames, data_layout), full_code, silent);
 
     std::string result =
+        "#include <array>\n"
         "#include <cstdint>\n"
         "#include <dlfcn.h>\n"
+        "#include <type_traits>\n"
         "template<typename Fn>\n"
         "struct function_traits;\n"
         "template<typename Result, typename Arg>\n"
@@ -275,10 +277,14 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
         "struct GuestWrapperForHostFunction {\n"
         "  template<ParameterAnnotations...> static void Call(void*);\n"
         "};\n"
-        "template<typename F>\n"
-        "void FinalizeHostTrampolineForGuestFunction(F*);\n"
         "struct ExportEntry { uint8_t* sha256; void(*fn)(void *); };\n"
-        "void *dlsym_default(void* handle, const char* symbol);\n";
+        "void *dlsym_default(void* handle, const char* symbol);\n"
+        "template<typename T>\n"
+        "struct guest_layout {\n"
+        "  T data;\n"
+        "};\n"
+        "\n"
+        "template<typename F> void FinalizeHostTrampolineForGuestFunction(F*);\n";
 
     auto& filename = output_filenames.host;
     {
@@ -486,10 +492,10 @@ TEST_CASE_METHOD(Fixture, "MultipleParameters") {
             parameterCountIs(1),
             hasParameter(0, hasType(pointerType(pointee(
                 recordType(hasDeclaration(decl(
-                    has(fieldDecl(hasType(asString("int")))),
-                    has(fieldDecl(hasType(asString("char")))),
-                    has(fieldDecl(hasType(asString("unsigned long")))),
-                    has(fieldDecl(hasType(asString("struct TestStruct"))))
+                    has(fieldDecl(hasType(asString("guest_layout<int>")))),
+                    has(fieldDecl(hasType(asString("guest_layout<char>")))),
+                    has(fieldDecl(hasType(asString("guest_layout<unsigned long>")))),
+                    has(fieldDecl(hasType(asString("guest_layout<struct TestStruct>"))))
                     )))))))
             )));
 }

From 5b3c97746768ce6bd26cc82330e651698ab61df2 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Wed, 6 Sep 2023 15:54:12 +0200
Subject: [PATCH 13/48] unittests/thunks: Add ptr_passthrough tests

---
 unittests/ThunkLibs/common.h      |  2 ++
 unittests/ThunkLibs/generator.cpp | 13 +++++++++++++
 2 files changed, 15 insertions(+)

diff --git a/unittests/ThunkLibs/common.h b/unittests/ThunkLibs/common.h
index 87a5f47c5d..f9ce959199 100644
--- a/unittests/ThunkLibs/common.h
+++ b/unittests/ThunkLibs/common.h
@@ -91,6 +91,8 @@ struct callback_guest : callback_annotation_base {};
 // If used, fex_custom_repack must be specialized for the annotated struct member
 struct custom_repack {};
 
+struct ptr_passthrough {};
+
 // struct member annotations: fex_gen_config<&MyStruct::member>
 struct is_padding_member {};
 
diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index 0b4eb47e29..4f78f26908 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -571,6 +571,10 @@ TEST_CASE_METHOD(Fixture, "StructRepacking") {
             // TODO
             CHECK_THROWS(run_thunkgen_host(prelude, code, guest_abi, true));
         }
+
+        SECTION("Parameter annotated as ptr_passthrough") {
+            CHECK_NOTHROW(run_thunkgen_host(prelude, code + "template<> struct fex_gen_param<func, 0, A*> : fexgen::ptr_passthrough {};\n", guest_abi));
+        }
     }
 
     SECTION("Pointer to struct with pointer member of consistent data layout") {
@@ -605,6 +609,15 @@ TEST_CASE_METHOD(Fixture, "VoidPointerParameter") {
         }
     }
 
+    SECTION("Passthrough") {
+        const char* code =
+            "#include <thunks_common.h>\n"
+            "void func(void*);\n"
+            "template<> struct fex_gen_config<func> : fexgen::custom_host_impl {};\n"
+            "template<> struct fex_gen_param<func, 0, void*> : fexgen::ptr_passthrough {};\n";
+        CHECK_NOTHROW(run_thunkgen_host("", code, guest_abi));
+    }
+
     SECTION("Unannotated in struct") {
         const char* prelude =
             "struct A { void* a; };\n";

From 5d7da3080160084c69c5a549e1f535c8111be658 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Tue, 22 Aug 2023 15:32:02 +0200
Subject: [PATCH 14/48] TODOFINISH. Disable this test for now

---
 unittests/ThunkLibs/generator.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index 4f78f26908..aa80340316 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -426,6 +426,8 @@ TEST_CASE_METHOD(Fixture, "FunctionPointerParameter") {
             )));
 }
 
+// TODO: Decide what to do with this
+#if 0
 // Parameter is a guest function pointer
 TEST_CASE_METHOD(Fixture, "GuestFunctionPointerParameter") {
     const std::string prelude =
@@ -451,6 +453,7 @@ TEST_CASE_METHOD(Fixture, "GuestFunctionPointerParameter") {
                          hasArgument(0, hasType(asString("struct fex_guest_function_ptr")))
             )));
 }
+#endif
 
 TEST_CASE_METHOD(Fixture, "MultipleParameters") {
     const std::string prelude =

From bee6537fbc7bf06600dc44d21cce0e2b860bc75f Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Thu, 24 Aug 2023 11:50:36 +0200
Subject: [PATCH 15/48] Thunks/gen: Add assume_compatible/is_opaque annotations

These annotations allow for a given type or parameter to be treated as
"compatible" even if data layout analysis can't infer this automatically.

assume_compatible_data_layout is more powerful than is_opaque, since it
allows for structs containing members of a certain type to be automatically
inferred as "compatible".

Conversely however, is_opaque enforces that the underlying data is never
accessed directly, since non-pointer uses of the type would still be
detected as "incompatible".
---
 ThunkLibs/Generator/analysis.cpp    | 68 ++++++++++++++++++++++++--
 ThunkLibs/Generator/analysis.h      |  3 ++
 ThunkLibs/Generator/data_layout.cpp | 27 ++++++++++-
 ThunkLibs/Generator/gen.cpp         |  8 ++-
 ThunkLibs/include/common/Host.h     |  1 +
 unittests/ThunkLibs/abi.cpp         | 75 +++++++++++++++++++++++++++++
 unittests/ThunkLibs/common.h        |  5 ++
 7 files changed, 180 insertions(+), 7 deletions(-)

diff --git a/ThunkLibs/Generator/analysis.cpp b/ThunkLibs/Generator/analysis.cpp
index 761026aeee..a103dec094 100644
--- a/ThunkLibs/Generator/analysis.cpp
+++ b/ThunkLibs/Generator/analysis.cpp
@@ -150,6 +150,33 @@ FindClassTemplateDeclByName(clang::DeclContext& decl_context, std::string_view s
     }
 }
 
+struct TypeAnnotations {
+    bool is_opaque = false;
+    bool assumed_compatible = false;
+};
+
+static TypeAnnotations GetTypeAnnotations(clang::ASTContext& context, clang::CXXRecordDecl* decl) {
+    if (!decl->hasDefinition()) {
+        return {};
+    }
+
+    ErrorReporter report_error { context };
+    TypeAnnotations ret;
+
+    for (const clang::CXXBaseSpecifier& base : decl->bases()) {
+        auto annotation = base.getType().getAsString();
+        if (annotation == "fexgen::opaque_type") {
+            ret.is_opaque = true;
+        } else if (annotation == "fexgen::assume_compatible_data_layout") {
+            ret.assumed_compatible = true;
+        } else {
+            throw report_error(base.getSourceRange().getBegin(), "Unknown type annotation");
+        }
+    }
+
+    return ret;
+}
+
 static ParameterAnnotations GetParameterAnnotations(clang::ASTContext& context, clang::CXXRecordDecl* decl) {
     if (!decl->hasDefinition()) {
         return {};
@@ -162,6 +189,9 @@ static ParameterAnnotations GetParameterAnnotations(clang::ASTContext& context,
         auto annotation = base.getType().getAsString();
         if (annotation == "fexgen::ptr_passthrough") {
             ret.is_passthrough = true;
+        } else if (annotation == "fexgen::assume_compatible_data_layout") {
+            // TODO: Rename?
+            ret.is_opaque = true;
         } else {
             throw report_error(base.getSourceRange().getBegin(), "Unknown parameter annotation");
         }
@@ -188,12 +218,19 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
             clang::QualType type = context.getCanonicalType(template_args[0].getAsType());
             type = type->getLocallyUnqualifiedSingleStepDesugaredType();
 
-            {
+            auto annotations = GetTypeAnnotations(context, decl);
+            if (annotations.is_opaque) {
+                auto [it, inserted] = types.emplace(context.getCanonicalType(type.getTypePtr()), RepackedType { true });
+                assert(inserted);
+            } else if (annotations.assumed_compatible) {
+                auto [it, inserted] = types.emplace(context.getCanonicalType(type.getTypePtr()), RepackedType { true, false });
+                assert(inserted);
+            } else {
                 if (type->isFunctionPointerType() || type->isFunctionType()) {
                     funcptr_types["TODO_FUNC_NAME_FOR_ANNOTATED_TYPES_" + type.getAsString()] = std::pair { type.getTypePtr(), no_param_annotations };
                 } else {
                     // TODO: Unify this with the is_opaque path above
-                    auto [it, inserted] = types.emplace(context.getCanonicalType(type.getTypePtr()), RepackedType { });
+                    auto [it, inserted] = types.emplace(context.getCanonicalType(type.getTypePtr()), RepackedType { false });
                     assert(inserted);
                 }
             }
@@ -372,12 +409,19 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
                             types.emplace(param_type.getTypePtr(), RepackedType { });
                         } else if (param_type->isEnumeralType()) {
                             types.emplace(context.getCanonicalType(param_type.getTypePtr()), RepackedType { });
-                        } else if ( param_type->isStructureType()) {
+                        } else if ( param_type->isStructureType() &&
+                                    !(types.contains(context.getCanonicalType(param_type.getTypePtr())) &&
+                                      LookupType(context, param_type.getTypePtr()).is_opaque)) {
                             check_struct_type(param_type.getTypePtr());
                             types.emplace(context.getCanonicalType(param_type.getTypePtr()), RepackedType { });
                         } else if (param_type->isPointerType()) {
                             auto pointee_type = param_type->getPointeeType()->getLocallyUnqualifiedSingleStepDesugaredType();
-                            if ( pointee_type->isStructureType()) {
+                            if ((types.contains(context.getCanonicalType(pointee_type.getTypePtr())) && LookupType(context, pointee_type.getTypePtr()).is_opaque)) {
+                                // Nothing to do
+                                data.param_annotations[param_idx].is_opaque = true; // TODO: is having this member good design?
+                            } else if ( pointee_type->isStructureType() &&
+                                        !(types.contains(context.getCanonicalType(pointee_type.getTypePtr())) &&
+                                          LookupType(context, pointee_type.getTypePtr()).is_opaque)) {
                                 check_struct_type(pointee_type.getTypePtr());
                                 types.emplace(context.getCanonicalType(pointee_type.getTypePtr()), RepackedType { });
                             } else if (data.param_annotations[param_idx].is_passthrough) {
@@ -385,6 +429,8 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
                                     throw report_error(param_loc, "Passthrough annotation requires custom host implementation");
                                 }
 
+                                // Nothing to do
+                            } else if (data.param_annotations[param_idx].is_opaque /* TODO: Actually is assume_compatible_data_layout'ed */) {
                                 // Nothing to do
                             } else if (false /* TODO: Can't check if this is unsupported until data layout analysis is complete */) {
                                 fprintf(stderr, "NAME: %s\n", pointee_type.getAsString().c_str());
@@ -454,6 +500,11 @@ void AnalysisAction::CoverReferencedTypes(clang::ASTContext& context) {
                 continue;
             }
 
+            if (type_repack_info.is_opaque) {
+                // If assumed compatible, we don't need the member definitions
+                continue;
+            }
+
             for (auto* member : type->getAsStructureType()->getDecl()->fields()) {
                 auto member_type = member->getType().getTypePtr();
                 while (member_type->isArrayType()) {
@@ -466,6 +517,15 @@ void AnalysisAction::CoverReferencedTypes(clang::ASTContext& context) {
                 if (!member_type->isBuiltinType()) {
                     member_type = context.getCanonicalType(member_type);
                 }
+                if (types.contains(member_type) && types.at(member_type).pointers_only) {
+                    if (member_type == context.getCanonicalType(member->getType().getTypePtr())) {
+                        throw std::runtime_error(fmt::format("\"{}\" references opaque type \"{}\" via non-pointer member \"{}\"",
+                                                             clang::QualType { type, 0 }.getAsString(),
+                                                             clang::QualType { member_type, 0 }.getAsString(),
+                                                             member->getNameAsString()));
+                    }
+                    continue;
+                }
                 if (member_type->isUnionType() && !types.contains(member_type)) {
                     throw std::runtime_error(fmt::format("\"{}\" has unannotated member \"{}\" of union type \"{}\"",
                                                          clang::QualType { type, 0 }.getAsString(),
diff --git a/ThunkLibs/Generator/analysis.h b/ThunkLibs/Generator/analysis.h
index aaa51cdcf0..110e252955 100644
--- a/ThunkLibs/Generator/analysis.h
+++ b/ThunkLibs/Generator/analysis.h
@@ -23,6 +23,7 @@ struct ThunkedCallback : FunctionParams {
 
 struct ParameterAnnotations {
     bool is_passthrough = false;
+    bool is_opaque = false;
 
     bool operator==(const ParameterAnnotations&) const = default;
 };
@@ -135,6 +136,8 @@ class AnalysisAction : public clang::ASTFrontendAction {
 
 public: // TODO: Remove, make only RepackedType public
     struct RepackedType {
+        bool is_opaque = false; // opaque or assumed_compatible (TODO: Rename to the latter)
+        bool pointers_only = is_opaque; // if true, only pointers to this type may be used
     };
 
     std::unordered_map<const clang::Type*, RepackedType> types;
diff --git a/ThunkLibs/Generator/data_layout.cpp b/ThunkLibs/Generator/data_layout.cpp
index f6cff339ad..bb5d05b8aa 100644
--- a/ThunkLibs/Generator/data_layout.cpp
+++ b/ThunkLibs/Generator/data_layout.cpp
@@ -25,6 +25,14 @@ std::unordered_map<const clang::Type*, TypeInfo> ComputeDataLayout(const clang::
 
     // First, add all types directly used in function signatures of the library API to the meta set
     for (const auto& [type, type_repack_info] : types) {
+        if (type_repack_info.is_opaque) {
+            auto [_, inserted] = layout.insert(std::pair { context.getCanonicalType(type), TypeInfo {} });
+            if (!inserted) {
+                throw std::runtime_error("Failed to gather type metadata: Opaque type \"" + clang::QualType { type, 0 }.getAsString() + "\" already registered");
+            }
+            continue;
+        }
+
         if (type->isIncompleteType()) {
             throw std::runtime_error("Cannot compute data layout of incomplete type \"" + clang::QualType { type, 0 }.getAsString() + "\". Did you forget any annotations?");
         }
@@ -53,7 +61,7 @@ std::unordered_map<const clang::Type*, TypeInfo> ComputeDataLayout(const clang::
 
     // Then, add information about members
     for (const auto& [type, type_repack_info] : types) {
-        if (!type->isStructureType()) {
+        if (!type->isStructureType() || type_repack_info.is_opaque) {
             continue;
         }
 
@@ -199,6 +207,15 @@ TypeCompatibility DataLayoutCompareAction::GetTypeCompatibility(
         }
     }
 
+    // TODO: This is also used by the assume_compatible_data_layout path now
+    if (types.contains(type) && types.at(type).is_opaque) {
+        if (types.at(type).pointers_only && !type->isPointerType()) {
+            throw std::runtime_error("Tried to dereference opaque type \"" + clang::QualType { type, 0 }.getAsString() + "\" when querying data layout compatibility");
+        }
+        type_compat.at(type) = TypeCompatibility::Full;
+        return TypeCompatibility::Full;
+    }
+
     const auto& guest_abi = abi;
     auto type_name = get_type_name(context, type);
     auto& guest_info = guest_abi.at(type_name);
@@ -252,12 +269,18 @@ TypeCompatibility DataLayoutCompareAction::GetTypeCompatibility(
                 // * Pointer member is annotated
                 // TODO: Don't restrict this to structure types. it applies to pointers to builtin types too!
                 auto host_member_pointee_type = context.getCanonicalType(host_member_type->getPointeeType().getTypePtr());
-                if (host_member_pointee_type->isPointerType()) {
+                if (types.contains(host_member_pointee_type) && types.at(host_member_pointee_type).is_opaque) {
+                    // Pointee doesn't need repacking, but pointer needs extending on 32-bit
+                    member_compat.push_back(is_32bit ? TypeCompatibility::Repackable : TypeCompatibility::Full);
+                } else if (host_member_pointee_type->isPointerType()) {
                     // This is a nested pointer, e.g. void**
 
                     if (is_32bit) {
                         // Nested pointers can't be repacked on 32-bit
                         member_compat.push_back(TypeCompatibility::None);
+                    } else if (types.contains(host_member_pointee_type->getPointeeType().getTypePtr()) && types.at(host_member_pointee_type->getPointeeType().getTypePtr()).is_opaque) {
+                        // Pointers to opaque types are fine
+                        member_compat.push_back(TypeCompatibility::Full);
                     } else {
                         // Check the innermost type's compatibility on 64-bit
                         auto pointee_pointee_type = host_member_pointee_type->getPointeeType().getTypePtr();
diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index f92d212a40..94ec13f580 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -57,7 +57,9 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
         std::unordered_map<const clang::Type*, TypeCompatibility> ret;
         const auto host_abi = ComputeDataLayout(context, types);
         for (const auto& [type, type_repack_info] : types) {
-            GetTypeCompatibility(context, type, host_abi, ret);
+            if (!type_repack_info.pointers_only) {
+                GetTypeCompatibility(context, type, host_abi, ret);
+            }
         }
         return ret;
     }();
@@ -375,6 +377,10 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                     // TODO: Rename annotation in Host.h?
                     annotations += ".is_passthrough=true,";
                 }
+                if (param_annotations.contains(param_idx) && param_annotations.at(param_idx).is_opaque) {
+                    // TODO: Rename annotation in Host.h?
+                    annotations += ".is_opaque=true,";
+                }
                 annotations += "}";
             }
             fmt::print( file, "  {{(uint8_t*)\"\\x{:02x}\", (void(*)(void *))&GuestWrapperForHostFunction<{}({})>::Call<{}>}}, // {}\n",
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index 09a9f77167..a3b2e565d7 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -105,6 +105,7 @@ struct GuestcallInfo {
 
 struct ParameterAnnotations {
     bool is_passthrough = false;
+    bool is_opaque = false;
 };
 
 // Placeholder type to indicate the given data is in guest-layout
diff --git a/unittests/ThunkLibs/abi.cpp b/unittests/ThunkLibs/abi.cpp
index cca586368f..302d8ef9e1 100644
--- a/unittests/ThunkLibs/abi.cpp
+++ b/unittests/ThunkLibs/abi.cpp
@@ -460,6 +460,21 @@ if (false) // TODO: Currently fails
                 "template<> struct fex_gen_type<A> {};\n", guest_abi),
                 Catch::Contains("unannotated member") && Catch::Contains("union type"));
         }
+
+        SECTION("with annotation") {
+            auto action = compute_data_layout(
+                "#include <thunks_common.h>\n"
+                "#include <cstdint>\n",
+                "union B { int32_t a; uint32_t b; };\n"
+                "struct A { B a; };\n"
+                "template<> struct fex_gen_type<B> : fexgen::assume_compatible_data_layout {};\n"
+                "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+            INFO(FormatDataLayout(action->host_layout));
+
+            REQUIRE(action->guest_layout->contains("A"));
+            CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Full);
+        }
     }
 }
 
@@ -589,6 +604,36 @@ TEST_CASE_METHOD(Fixture, "DataLayoutPointers") {
             Catch::Contains("unannotated member") && Catch::Contains("union type"));
     }
 
+    SECTION("Pointer to union type with assume_compatible_data_layout annotation") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "union B { int32_t a; uint32_t b; };\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_type<B> : fexgen::assume_compatible_data_layout {};\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
+    }
+
+    SECTION("Pointer to opaque type") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct B;\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_type<B> : fexgen::opaque_type {};\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
+    }
+
     SECTION("Self-referencing struct (like VkBaseOutStructure)") {
         // Without annotation
         auto action = compute_data_layout(
@@ -601,6 +646,20 @@ TEST_CASE_METHOD(Fixture, "DataLayoutPointers") {
 
         REQUIRE(action->guest_layout->contains("A"));
         CHECK_THROWS_WITH(action->GetTypeCompatibility("struct A"), Catch::Contains("recursive reference"));
+
+        // With annotation
+        if (guest_abi == GuestABI::X86_64) {
+            auto action = compute_data_layout(
+                "#include <thunks_common.h>\n"
+                "#include <cstdint>\n",
+                "struct A { A* a; };\n"
+                "template<> struct fex_gen_type<A> : fexgen::assume_compatible_data_layout {};\n", guest_abi);
+
+            INFO(FormatDataLayout(action->host_layout));
+
+            REQUIRE(action->guest_layout->contains("A"));
+            CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Full);
+        }
     }
 
     SECTION("Circularly referencing structs") {
@@ -619,6 +678,22 @@ TEST_CASE_METHOD(Fixture, "DataLayoutPointers") {
         REQUIRE(action->guest_layout->contains("B"));
         CHECK_THROWS_WITH(action->GetTypeCompatibility("struct A"), Catch::Contains("recursive reference"));
         CHECK_THROWS_WITH(action->GetTypeCompatibility("struct B"), Catch::Contains("recursive reference"));
+
+        // With annotation
+        if (guest_abi == GuestABI::X86_64) {
+            auto action = compute_data_layout(
+                "#include <thunks_common.h>\n"
+                "#include <cstdint>\n",
+                "struct B;\n"
+                "struct A { B* a; };\n"
+                "struct B { A* a; };\n"
+                "template<> struct fex_gen_type<B> : fexgen::assume_compatible_data_layout {};\n", guest_abi);
+
+            INFO(FormatDataLayout(action->host_layout));
+
+            REQUIRE(action->guest_layout->contains("B"));
+            CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::Full);
+        }
     }
 
     // TODO: Double pointers to compatible data: struct B { int a ; }; struct A { B** b; };
diff --git a/unittests/ThunkLibs/common.h b/unittests/ThunkLibs/common.h
index f9ce959199..b7ee25a410 100644
--- a/unittests/ThunkLibs/common.h
+++ b/unittests/ThunkLibs/common.h
@@ -91,6 +91,11 @@ struct callback_guest : callback_annotation_base {};
 // If used, fex_custom_repack must be specialized for the annotated struct member
 struct custom_repack {};
 
+// Pointers to types annotated with this will be passed through without change
+struct opaque_type {};
+
+struct assume_compatible_data_layout {};
+
 struct ptr_passthrough {};
 
 // struct member annotations: fex_gen_config<&MyStruct::member>

From 42cc08629c7684d708944fe4416c5db01ce902cf Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Wed, 6 Sep 2023 15:57:42 +0200
Subject: [PATCH 16/48] unittests/thunks: Add tests for
 assume_compatible/is_opaque annotations

---
 unittests/ThunkLibs/generator.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index aa80340316..cc1f974a1a 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -592,6 +592,10 @@ TEST_CASE_METHOD(Fixture, "StructRepacking") {
 
         // Unannotated
         REQUIRE_THROWS_WITH(run_thunkgen_host(prelude, code, guest_abi), Catch::Contains("incomplete type"));
+
+        // Annotated as opaque_type
+        CHECK_NOTHROW(run_thunkgen_host(prelude,
+              code + "template<> struct fex_gen_type<B> : fexgen::opaque_type {};\n", guest_abi));
     }
 }
 
@@ -621,6 +625,15 @@ TEST_CASE_METHOD(Fixture, "VoidPointerParameter") {
         CHECK_NOTHROW(run_thunkgen_host("", code, guest_abi));
     }
 
+    SECTION("Assumed compatible") {
+        const char* code =
+            "#include <thunks_common.h>\n"
+            "void func(void*);\n"
+            "template<> struct fex_gen_config<func> {};\n"
+            "template<> struct fex_gen_param<func, 0, void*> : fexgen::assume_compatible_data_layout {};\n";
+        CHECK_NOTHROW(run_thunkgen_host("", code, guest_abi));
+    }
+
     SECTION("Unannotated in struct") {
         const char* prelude =
             "struct A { void* a; };\n";

From ba0aec0346c82a8599aa3e165accc8c54df5a4d5 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Tue, 8 Aug 2023 17:21:13 +0200
Subject: [PATCH 17/48] TODO FIX BUILD. Thunks/gen: Enforce type compatibility
 for function parameters

---
 ThunkLibs/Generator/gen.cpp | 51 +++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index 94ec13f580..aa68285f42 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -296,6 +296,24 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                 file << ") -> " << thunk.return_type.getAsString() << ";\n";
             }
 
+            // Check data layout compatibility of parameter types
+            // TODO: Also check non-struct/non-pointer types
+            // TODO: Also check return type
+            for (size_t param_idx = 0; param_idx != thunk.param_types.size(); ++param_idx) {
+                const auto& param_type = thunk.param_types[param_idx];
+                if (!param_type->isPointerType() || !param_type->getPointeeType()->isStructureType()) {
+                    continue;
+                }
+                auto type = param_type->getPointeeType();
+                if (!types.at(context.getCanonicalType(type.getTypePtr())).is_opaque && type_compat.at(context.getCanonicalType(type.getTypePtr())) == TypeCompatibility::None) {
+                    // TODO: Factor in "assume_compatible_layout" annotations here
+                    //       That annotation should cause the type to be treated as TypeCompatibility::Full
+                    if (!thunk.param_annotations[param_idx].is_passthrough) {
+                        throw report_error(thunk.decl->getLocation(), "Unsupported parameter type %0").AddTaggedVal(param_type);
+                    }
+                }
+            }
+
             // Packed argument structs used in fexfn_unpack_*
             auto GeneratePackedArgs = [&](const auto &function_name, const ThunkedFunction &thunk) -> std::string {
                 std::string struct_name = "fexfn_packed_args_" + libname + "_" + function_name;
@@ -323,6 +341,39 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
 
             file << "static void fexfn_unpack_" << libname << "_" << function_name << "(" << struct_name << "* args) {\n";
             file << (thunk.return_type->isVoidType() ? "  " : "  args->rv = ") << function_to_call << "(";
+
+            for (unsigned param_idx = 0; param_idx != thunk.param_types.size(); ++param_idx) {
+                if (thunk.callbacks.contains(param_idx) && thunk.callbacks.at(param_idx).is_stub) {
+                    continue;
+                }
+
+                auto& param_type = thunk.param_types[param_idx];
+                const bool is_opaque = param_type->isPointerType() &&
+                          (thunk.param_annotations[param_idx].is_opaque || ((param_type->getPointeeType()->isStructureType() || (param_type->getPointeeType()->isPointerType() && param_type->getPointeeType()->getPointeeType()->isStructureType())) &&
+                          (types.contains(context.getCanonicalType(param_type->getPointeeType()->getLocallyUnqualifiedSingleStepDesugaredType().getTypePtr())) && LookupType(context, context.getCanonicalType(param_type->getPointeeType()->getLocallyUnqualifiedSingleStepDesugaredType().getTypePtr())).is_opaque)));
+
+                std::optional<TypeCompatibility> pointee_compat;
+                if (param_type->isPointerType()) {
+                    // Get TypeCompatibility from existing entry, or register TypeCompatibility::None if no entry exists
+                    // TODO: Currently needs TypeCompatibility::Full workaround...
+                    pointee_compat = type_compat.emplace(context.getCanonicalType(param_type->getPointeeType().getTypePtr()), TypeCompatibility::Full).first->second;
+                }
+
+                if (thunk.param_annotations[param_idx].is_passthrough) {
+                    // args are passed directly to function, no need to use `unpacked` wrappers
+                    continue;
+                }
+
+                if (!param_type->isPointerType() || (is_opaque || pointee_compat == TypeCompatibility::Full) ||
+                    param_type->getPointeeType()->isBuiltinType() /* TODO: handle size_t. Actually, properly check for data layout compatibility */) {
+                    // Fully compatible
+                } else if (pointee_compat == TypeCompatibility::Repackable) {
+                    throw report_error(thunk.decl->getLocation(), "Pointer parameter %1 of function %0 requires automatic repacking, which is not implemented yet").AddString(function_name).AddTaggedVal(param_type);
+                } else {
+                    throw report_error(thunk.decl->getLocation(), "Cannot generate unpacking function for function %0 with unannotated pointer parameter %1").AddString(function_name).AddTaggedVal(param_type);
+                }
+            }
+
             {
                 auto format_param = [&](std::size_t idx) {
                     std::string raw_arg = fmt::format("args->a_{}.data", idx);

From a80c60ced4acb89e624aea33783f9760bc6b2a65 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Thu, 24 Aug 2023 11:11:05 +0200
Subject: [PATCH 18/48] TODOMOVE. Various 32-bit fixes

---
 .../Core/Dispatcher/Arm64Dispatcher.cpp       |  3 +-
 FEXCore/Source/Interface/Core/GdbServer.cpp   | 42 +++++++++++++++----
 .../Source/Interface/HLE/Thunks/Thunks.cpp    | 38 +++++++++++++----
 FEXCore/Source/Utils/Allocator.cpp            |  7 +++-
 Source/Tools/FEXLoader/FEXLoader.cpp          |  2 -
 ThunkLibs/include/common/Guest.h              | 30 +++++++------
 6 files changed, 89 insertions(+), 33 deletions(-)

diff --git a/FEXCore/Source/Interface/Core/Dispatcher/Arm64Dispatcher.cpp b/FEXCore/Source/Interface/Core/Dispatcher/Arm64Dispatcher.cpp
index 8d052aa26e..991a731b5d 100644
--- a/FEXCore/Source/Interface/Core/Dispatcher/Arm64Dispatcher.cpp
+++ b/FEXCore/Source/Interface/Core/Dispatcher/Arm64Dispatcher.cpp
@@ -368,7 +368,8 @@ void Arm64Dispatcher::EmitDispatcher() {
     LoadConstant(ARMEmitter::Size::i64Bit, ARMEmitter::Reg::r0, CTX->X86CodeGen.CallbackReturn);
 
     ldr(ARMEmitter::XReg::x2, STATE_PTR(CpuStateFrame, State.gregs[X86State::REG_RSP]));
-    sub(ARMEmitter::Size::i64Bit, ARMEmitter::Reg::r2, ARMEmitter::Reg::r2, 16);
+    // TODO: Is this right for 32-bit?
+    sub(ARMEmitter::Size::i64Bit, ARMEmitter::Reg::r2, ARMEmitter::Reg::r2, CTX->Config.Is64BitMode ? 16 : 12);
     str(ARMEmitter::XReg::x2, STATE_PTR(CpuStateFrame, State.gregs[X86State::REG_RSP]));
 
     // Store the trampoline to the guest stack
diff --git a/FEXCore/Source/Interface/Core/GdbServer.cpp b/FEXCore/Source/Interface/Core/GdbServer.cpp
index ec16e2804d..0455fda925 100644
--- a/FEXCore/Source/Interface/Core/GdbServer.cpp
+++ b/FEXCore/Source/Interface/Core/GdbServer.cpp
@@ -247,9 +247,22 @@ void GdbServer::SendACK(std::ostream &stream, bool NACK) {
   }
 }
 
+constexpr std::array<std::string_view const, 8> RegNames32 = {
+  "eax",
+  "ecx",
+  "edx",
+  "ebx",
+  "esp",
+  "ebp",
+  "esi",
+  "edi",
+};
+
 struct FEX_PACKED GDBContextDefinition {
-  uint64_t gregs[Core::CPUState::NUM_GPRS];
-  uint64_t rip;
+//  uint64_t gregs[Core::CPUState::NUM_GPRS];
+//  uint64_t rip;
+  uint32_t gregs[8];
+  uint32_t rip;
   uint32_t eflags;
   uint32_t cs, ss, ds, es, fs, gs;
   X80SoftFloat mm[Core::CPUState::NUM_MMS];
@@ -284,8 +297,12 @@ fextl::string GdbServer::readRegs() {
   }
 
   // Encode the GDB context definition
-  memcpy(&GDB.gregs[0], &state.gregs[0], sizeof(GDB.gregs));
-  memcpy(&GDB.rip, &state.rip, sizeof(GDB.rip));
+//  memcpy(&GDB.gregs[0], &state.gregs[0], sizeof(GDB.gregs));
+for (int i = 0; i < std::size(RegNames32); ++i) {
+  memcpy(&GDB.gregs[i], &state.gregs[i], 4);
+}
+//  memcpy(&GDB.rip, &state.rip, sizeof(GDB.rip));
+  memcpy(&GDB.rip, &state.rip, 4);
 
   GDB.eflags = CTX->ReconstructCompactedEFLAGS(CurrentThread);
 
@@ -334,7 +351,7 @@ GdbServer::HandledPacketType GdbServer::readReg(const fextl::string& packet) {
     memcpy(&state, CTX->ParentThread->CurrentFrame, sizeof(state));
   }
 
-
+// TODO: 32 bit?
   if (addr >= offsetof(GDBContextDefinition, gregs[0]) &&
       addr < offsetof(GDBContextDefinition, gregs[16])) {
     return {encodeHex((unsigned char *)(&state.gregs[addr / sizeof(uint64_t)]), sizeof(uint64_t)), HandledPacketType::TYPE_ACK};
@@ -396,7 +413,8 @@ fextl::string buildTargetXML() {
   xml << "<?xml version='1.0'?>\n";
   xml << "<!DOCTYPE target SYSTEM 'gdb-target.dtd'>\n";
   xml << "<target>\n";
-  xml << "<architecture>i386:x86-64</architecture>\n";
+//  xml << "<architecture>i386:x86-64</architecture>\n";
+  xml << "<architecture>i386</architecture>\n";
   xml << "<osabi>GNU/Linux</osabi>\n";
     xml << "<feature name='org.gnu.gdb.i386.core'>\n";
 
@@ -421,11 +439,16 @@ fextl::string buildTargetXML() {
       // We want to just memcpy our x86 state to gdb, so we tell it the ordering.
 
       // GPRs
-      for (uint32_t i = 0; i < Core::CPUState::NUM_GPRS; i++) {
-        reg(FEXCore::Core::GetGRegName(i), "int64", 64);
+//      for (uint32_t i = 0; i < Core::CPUState::NUM_GPRS; i++) {
+//        reg(FEXCore::Core::GetGRegName(i), "int64", 64);
+//      }
+
+      for (uint32_t i = 0; i < std::size(RegNames32); i++) {
+        reg(RegNames32[i], "int32", 32);
       }
 
-      reg("rip", "code_ptr", 64);
+//      reg("rip", "code_ptr", 64);
+      reg("eip", "code_ptr", 32);
 
       reg("eflags", "fex_eflags", 32);
 
@@ -478,6 +501,7 @@ fextl::string buildTargetXML() {
         )";
 
       // SSE regs
+      // TODO: Only up to incl xmm7 on 32-bit?
       for (size_t i = 0; i < Core::CPUState::NUM_XMMS; i++) {
           reg(fextl::fmt::format("xmm{}", i), "vec128", 128);
       }
diff --git a/FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp b/FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp
index 0af9bc3ca9..d3a58dca1b 100644
--- a/FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp
+++ b/FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp
@@ -167,14 +167,38 @@ namespace FEXCore {
         size_t HostTrampolineInstanceDataAvailable = 0;
 
 
-        /*
-            Set arg0/1 to arg regs, use CTX::HandleCallback to handle the callback
-        */
+        /**
+         * Set arg0/1 to arg regs, use CTX::HandleCallback to handle the callback.
+         *
+         * If the callback is called asynchronously from the host-side, a
+         * guest worker thread to inject the call into must be provided.
+         * Otherwise, this may only be used from a guest thread (including
+         * synchronous uses from the host-side).
+         */
         static void CallCallback(void *callback, void *arg0, void* arg1) {
-          Thread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RDI] = (uintptr_t)arg0;
-          Thread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RSI] = (uintptr_t)arg1;
+            auto CTX = static_cast<Context::ContextImpl*>(Thread->CTX);
+            if (CTX->Config.Is64BitMode) {
+              Thread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RDI] = (uintptr_t)arg0;
+              Thread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RSI] = (uintptr_t)arg1;
+              fprintf(stderr, "Calling guest callback %p with args %p\n", callback, arg1);
+            } else {
+              // Args was allocated on stack, so it's not actually in 32-bit address space... relocate it to an appropriate location here
+              // TODO: Use a location that's representable in the first place!
+              static void* local_args = []() -> void* {
+                return (uint8_t *)mmap(
+                    0, 1000,
+                    PROT_READ | PROT_WRITE | PROT_EXEC,
+                    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+              }();
+
+              memcpy(local_args, arg1, 100);
+
+              Thread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RCX] = (uintptr_t)arg0;
+              Thread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RDX] = (uintptr_t)/*arg1*/ local_args;
+              fprintf(stderr, "Calling guest callback %p with args %p (-> %p)\n", callback, arg1, local_args);
+            }
 
-          Thread->CTX->HandleCallback(Thread, (uintptr_t)callback);
+            Thread->CTX->HandleCallback(Thread, (uintptr_t)callback);
         }
 
         /**
@@ -220,7 +244,7 @@ namespace FEXCore {
                           emit->_StoreRegister(emit->_Constant(Entrypoint), false, offsetof(Core::CPUState, gregs[X86State::REG_R11]), IR::GPRClass, IR::GPRFixedClass, GPRSize);
                         }
                         else {
-                          emit->_StoreRegister(emit->_Constant(Entrypoint), false, offsetof(Core::CPUState, mm[0][0]), IR::GPRClass, IR::GPRFixedClass, GPRSize);
+                          emit->_StoreContext(GPRSize, IR::FPRClass, emit->_VCastFromGPR(8, 8, emit->_Constant(Entrypoint)), offsetof(Core::CPUState, mm[0][0]));
                         }
                         emit->_ExitFunction(emit->_Constant(GuestThunkEntrypoint));
                     }, CTX->ThunkHandler.get(), (void*)args->target_addr);
diff --git a/FEXCore/Source/Utils/Allocator.cpp b/FEXCore/Source/Utils/Allocator.cpp
index b4a4d55388..44415ec7ff 100644
--- a/FEXCore/Source/Utils/Allocator.cpp
+++ b/FEXCore/Source/Utils/Allocator.cpp
@@ -121,10 +121,15 @@ namespace FEXCore::Allocator {
     }
   }
 
+extern "C" void BigYolo() {
+    Alloc64 = Alloc::OSAllocator::Create64BitAllocator();
+}
+
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   void SetupHooks() {
-    Alloc64 = Alloc::OSAllocator::Create64BitAllocator();
+//    Alloc64 = Alloc::OSAllocator::Create64BitAllocator();
+
 #ifdef ENABLE_JEMALLOC
     je___mmap_hook   = FEX_mmap;
     je___munmap_hook = FEX_munmap;
diff --git a/Source/Tools/FEXLoader/FEXLoader.cpp b/Source/Tools/FEXLoader/FEXLoader.cpp
index 685bdaa956..1a371d91fe 100644
--- a/Source/Tools/FEXLoader/FEXLoader.cpp
+++ b/Source/Tools/FEXLoader/FEXLoader.cpp
@@ -249,7 +249,6 @@ namespace FEX::TSO {
 }
 
 int main(int argc, char **argv, char **const envp) {
-  auto SBRKPointer = FEXCore::Allocator::DisableSBRKAllocations();
   FEXCore::Allocator::GLIBCScopedFault GLIBFaultScope;
   const bool IsInterpreter = RanAsInterpreter(argv[0]);
 
@@ -566,7 +565,6 @@ int main(int argc, char **argv, char **const envp) {
   FEXCore::Telemetry::Shutdown(Program.ProgramName);
   FEXCore::Profiler::Shutdown();
 
-  FEXCore::Allocator::ReenableSBRKAllocations(SBRKPointer);
 
   if (ShutdownReason == FEXCore::Context::ExitReason::EXIT_SHUTDOWN) {
     return ProgramStatus;
diff --git a/ThunkLibs/include/common/Guest.h b/ThunkLibs/include/common/Guest.h
index 9954c197de..13021c34e1 100644
--- a/ThunkLibs/include/common/Guest.h
+++ b/ThunkLibs/include/common/Guest.h
@@ -10,7 +10,8 @@
 #ifdef __clang__
 #define THUNK_ABI __fastcall
 #else
-#define THUNK_ABI [[gnu::fastcall]]
+// TODO: [[gnu::fastcall]] doesn't seem to work?
+#define THUNK_ABI __attribute__((fastcall)) // [[gnu::fastcall]]
 #endif
 #endif
 
@@ -75,8 +76,8 @@ MAKE_THUNK(fex, allocate_host_trampoline_for_guest_function, "0x9b, 0xb2, 0xf4,
 
 inline void LinkAddressToFunction(uintptr_t addr, uintptr_t target) {
     struct args_t {
-        uintptr_t original_callee;
-        uintptr_t target_addr; // Function to call when branching to replaced_addr
+        uint64_t original_callee;
+        uint64_t target_addr; // Function to call when branching to replaced_addr
     };
     args_t args = { addr, target };
     fexthunks_fex_link_address_to_function(&args);
@@ -126,14 +127,17 @@ inline Result CallHostFunction(Args... args) {
   // Use mm0 to pass in host_addr (chosen to avoid conflicts with vectorcall).
   // Note this register overlaps the x87 st(0) register (used to return float values),
   // so applications that expect this register to be preserved could run into problems.
-  register uintptr_t host_addr asm ("mm0");
-  asm volatile("" : "=r" (host_addr));
+//  register uintptr_t host_addr asm ("mm0");
+//  asm volatile("" : "=r" (host_addr));
+
+    uintptr_t host_addr; \
+    asm volatile("movd %%mm0, %0" : "=r" (host_addr));
 #endif
 #else
   uintptr_t host_addr = 0;
 #endif
 
-  PackedArguments<Result, Args..., uintptr_t> packed_args = {
+  PackedArguments<Result, Args..., uint64_t> packed_args = {
     args...,
     host_addr
     // Return value not explicitly initialized since an initializer would fail to compile for the void case
@@ -162,20 +166,20 @@ inline void MakeHostFunctionGuestCallable(THUNK_ABI Result (*host_func)(Args...)
 }
 
 template<typename Target>
-inline Target *AllocateHostTrampolineForGuestFunction(void (*GuestUnpacker)(uintptr_t, void*), Target *GuestTarget) {
+inline Target* AllocateHostTrampolineForGuestFunction(void THUNK_ABI (*GuestUnpacker)(uintptr_t, void*), Target *GuestTarget) {
   if (!GuestTarget) {
-    return nullptr;
+    return 0;
   }
 
   struct {
-    uintptr_t GuestUnpacker;
-    uintptr_t GuestTarget;
-    uintptr_t rv;
+    uint64_t GuestUnpacker;
+    uint64_t GuestTarget;
+    uint64_t rv;
   } argsrv = { (uintptr_t)GuestUnpacker, (uintptr_t)GuestTarget };
 
   fexthunks_fex_allocate_host_trampoline_for_guest_function((void*)&argsrv);
 
-  return (Target *)argsrv.rv;
+  return (Target*)argsrv.rv;
 }
 
 template<typename F>
@@ -183,7 +187,7 @@ struct CallbackUnpack;
 
 template<typename Result, typename... Args>
 struct CallbackUnpack<Result(Args...)> {
-    static void Unpack(uintptr_t cb, void* argsv) {
+    static void THUNK_ABI Unpack(uintptr_t cb, void* argsv) {
         using fn_t = Result(Args...);
         auto callback = reinterpret_cast<fn_t*>(cb);
         auto args = reinterpret_cast<PackedArguments<Result, Args...>*>(argsv);

From 7425f7e3cccc638f9fb9fab2224ae909090659f4 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Mon, 7 Aug 2023 18:08:29 +0200
Subject: [PATCH 19/48] TODOMOVE. Add support for asynchronous callbacks

---
 .../Source/Interface/HLE/Thunks/Thunks.cpp    | 113 +++++++++++++++++-
 ThunkLibs/include/common/Guest.h              |   7 ++
 ThunkLibs/include/common/Host.h               |   7 +-
 3 files changed, 121 insertions(+), 6 deletions(-)

diff --git a/FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp b/FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp
index d3a58dca1b..4034b106a4 100644
--- a/FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp
+++ b/FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp
@@ -50,7 +50,7 @@ static __attribute__((aligned(16), naked, section("HostToGuestTrampolineTemplate
     "jmpq *0f(%rip) \n"
     ".align 8 \n"
     "0: \n"
-    ".quad 0, 0, 0, 0 \n" // TrampolineInstanceInfo
+    ".quad 0, 0, 0, 0, 0 \n" // TrampolineInstanceInfo
   );
 #elif defined(_M_ARM_64)
   asm(
@@ -59,10 +59,9 @@ static __attribute__((aligned(16), naked, section("HostToGuestTrampolineTemplate
     "adr x11, 0f \n"
     "br x16 \n"
     // Manually align to the next 8-byte boundary
-    // NOTE: GCC over-aligns to a full page when using .align directives on ARM (last tested on GCC 11.2)
     "nop \n"
     "0: \n"
-    ".quad 0, 0, 0, 0 \n" // TrampolineInstanceInfo
+    ".quad 0, 0, 0, 0, 0 \n" // TrampolineInstanceInfo
   );
 #else
 #error Unsupported host architecture
@@ -81,6 +80,13 @@ namespace FEXCore {
 
   static thread_local FEXCore::Core::InternalThreadState *Thread;
 
+    struct AsyncCallbackState {
+      FEXCore::Core::InternalThreadState *Thread { nullptr };
+
+      std::mutex m;
+      std::condition_variable var;
+      std::atomic<bool> done { false };
+    };
 
     struct ExportEntry { uint8_t *sha256; ThunkedFunction* Fn; };
 
@@ -89,6 +95,7 @@ namespace FEXCore {
       uintptr_t CallCallback;
       uintptr_t GuestUnpacker;
       uintptr_t GuestTarget;
+      AsyncCallbackState *AsyncWorkerThread;
     };
 
     // Opaque type pointing to an instance of HostToGuestTrampolineTemplate and its
@@ -155,6 +162,16 @@ namespace FEXCore {
                 { 0x9b, 0xb2, 0xf4, 0xb4, 0x83, 0x7d, 0x28, 0x93, 0x40, 0xcb, 0xf4, 0x7a, 0x0b, 0x47, 0x85, 0x87, 0xf9, 0xbc, 0xb5, 0x27, 0xca, 0xa6, 0x93, 0xa5, 0xc0, 0x73, 0x27, 0x24, 0xae, 0xc8, 0xb8, 0x5a },
                 &AllocateHostTrampolineForGuestFunction
             },
+            {
+                // TODO: sha256(fex:register_async_worker_thread)
+                { 0x9c, 0xb2, 0xf4, 0xb4, 0x83, 0x7d, 0x28, 0x93, 0x40, 0xcb, 0xf4, 0x7a, 0x0b, 0x47, 0x85, 0x87, 0xf9, 0xbc, 0xb5, 0x27, 0xca, 0xa6, 0x93, 0xa5, 0xc0, 0x73, 0x27, 0x24, 0xae, 0xc8, 0xb8, 0x5a },
+                &RegisterAsyncWorkerThread
+            },
+            {
+                // TODO: sha256(fex:unregister_async_worker_thread)
+                { 0x9d, 0xb2, 0xf4, 0xb4, 0x83, 0x7d, 0x28, 0x93, 0x40, 0xcb, 0xf4, 0x7a, 0x0b, 0x47, 0x85, 0x87, 0xf9, 0xbc, 0xb5, 0x27, 0xca, 0xa6, 0x93, 0xa5, 0xc0, 0x73, 0x27, 0x24, 0xae, 0xc8, 0xb8, 0x5a },
+                &UnregisterAsyncWorkerThread
+            },
         };
 
         // Can't be a string_view. We need to keep a copy of the library name in-case string_view pointer goes away.
@@ -166,6 +183,64 @@ namespace FEXCore {
         uint8_t *HostTrampolineInstanceDataPtr;
         size_t HostTrampolineInstanceDataAvailable = 0;
 
+        std::unordered_map<unsigned, AsyncCallbackState> AsyncWorkerThreads;
+        std::mutex AsyncWorkerThreadsMutex;
+
+        /**
+         * Registers the calling thread as a worker thread for callback
+         * functions that are asynchronously invoked in a host context.
+         *
+         * Such a worker thread must be designated since otherwise there is no
+         * x86 context to run the callback in. Most importantly, this would
+         * prevent TLS from working.
+         *
+         * Before the worker thread shuts down, UnregisterAsyncWorkerThread
+         * must be called.
+         */
+        static void RegisterAsyncWorkerThread(void* argsv) {
+          struct args_t {
+              unsigned id;
+          } args = *reinterpret_cast<args_t*>(argsv);
+
+          auto ThunkHandler = reinterpret_cast<ThunkHandler_impl*>(static_cast<Context::ContextImpl*>(Thread->CTX)->ThunkHandler.get());
+
+          AsyncCallbackState *WorkerState = nullptr;
+          {
+            // Create and initialize new entry
+            std::unique_lock lock(ThunkHandler->AsyncWorkerThreadsMutex);
+            WorkerState = &ThunkHandler->AsyncWorkerThreads[args.id];
+            WorkerState->Thread = Thread;
+          }
+
+          pthread_setname_np(pthread_self(), "ThunkAsyncWorkerThread");
+
+          // Pause thread until woken up by UnregisterAsyncWorkerThread
+          {
+            std::unique_lock lock(WorkerState->m);
+            WorkerState->var.wait(lock, [WorkerState]() -> bool { return WorkerState->done; });
+            fprintf(stderr, "EXITING ASYNC THUNK WORKER THREAD\n");
+          }
+
+        }
+
+        static void UnregisterAsyncWorkerThread(void* argsv) {
+          struct args_t {
+              unsigned id;
+          } args = *reinterpret_cast<args_t*>(argsv);
+
+          auto ThunkHandler = reinterpret_cast<ThunkHandler_impl*>(static_cast<Context::ContextImpl*>(Thread->CTX)->ThunkHandler.get());
+
+          std::unique_lock lock(ThunkHandler->AsyncWorkerThreadsMutex);
+
+          auto WorkerState = ThunkHandler->AsyncWorkerThreads.find(args.id);
+
+          {
+            WorkerState->second.done = true;
+            WorkerState->second.var.notify_one();
+          }
+
+          ThunkHandler->AsyncWorkerThreads.erase(WorkerState);
+        }
 
         /**
          * Set arg0/1 to arg regs, use CTX::HandleCallback to handle the callback.
@@ -175,7 +250,8 @@ namespace FEXCore {
          * Otherwise, this may only be used from a guest thread (including
          * synchronous uses from the host-side).
          */
-        static void CallCallback(void *callback, void *arg0, void* arg1) {
+        static void CallCallback(void *callback, void *arg0, void* arg1, AsyncCallbackState *AsyncWorkerThread) {
+          if (!AsyncWorkerThread) {
             auto CTX = static_cast<Context::ContextImpl*>(Thread->CTX);
             if (CTX->Config.Is64BitMode) {
               Thread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RDI] = (uintptr_t)arg0;
@@ -199,6 +275,19 @@ namespace FEXCore {
             }
 
             Thread->CTX->HandleCallback(Thread, (uintptr_t)callback);
+          } else {
+            auto* ActiveThread = AsyncWorkerThread->Thread;
+            auto ThunksHandler = reinterpret_cast<ThunkHandler_impl*>(static_cast<Context::ContextImpl*>(AsyncWorkerThread->Thread->CTX)->ThunkHandler.get());
+
+            std::unique_lock lock(ThunksHandler->AsyncWorkerThreadsMutex);
+            ActiveThread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RDI] = (uintptr_t)arg0;
+            ActiveThread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RSI] = (uintptr_t)arg1;
+
+            // TODO: Instead of registering new TLS state for this, re-use the TLS state from the asynchronous worker thread
+            static_cast<Context::ContextImpl*>(ActiveThread->CTX)->SignalDelegation->RegisterTLSState(ActiveThread);
+            ActiveThread->CTX->HandleCallback(ActiveThread, (uintptr_t)callback);
+            static_cast<Context::ContextImpl*>(ActiveThread->CTX)->SignalDelegation->UninstallTLSState(ActiveThread);
+          }
         }
 
         /**
@@ -497,10 +586,24 @@ namespace FEXCore {
       }
     }
 
+    FEX_DEFAULT_VISIBILITY
+    void MakeHostTrampolineForGuestFunctionAsyncCallable(HostToGuestTrampolinePtr* TrampolineAddress, unsigned AsyncWorkerThreadId) {
+      if (!TrampolineAddress) {
+        return;
+      }
+
+      auto& Trampoline = GetInstanceInfo(TrampolineAddress);
+
+      LOGMAN_THROW_A_FMT(Trampoline.CallCallback == (uintptr_t)&ThunkHandler_impl::CallCallback,
+                        "Invalid trampoline at {} passed to {}", fmt::ptr(TrampolineAddress), __FUNCTION__);
+
+      auto ThunksHandler = reinterpret_cast<ThunkHandler_impl*>(static_cast<Context::ContextImpl*>(Thread->CTX)->ThunkHandler.get());
+      Trampoline.AsyncWorkerThread = &ThunksHandler->AsyncWorkerThreads.at(AsyncWorkerThreadId);
+    }
+
 #else
     fextl::unique_ptr<ThunkHandler> ThunkHandler::Create() {
       ERROR_AND_DIE_FMT("Unsupported");
     }
 #endif
-
 }
diff --git a/ThunkLibs/include/common/Guest.h b/ThunkLibs/include/common/Guest.h
index 13021c34e1..27bfa19997 100644
--- a/ThunkLibs/include/common/Guest.h
+++ b/ThunkLibs/include/common/Guest.h
@@ -62,13 +62,20 @@ MAKE_THUNK(fex, is_lib_loaded, "0xee, 0x57, 0xba, 0x0c, 0x5f, 0x6e, 0xef, 0x2a,
 MAKE_THUNK(fex, is_host_heap_allocation, "0xf5, 0x77, 0x68, 0x43, 0xbb, 0x6b, 0x28, 0x18, 0x40, 0xb0, 0xdb, 0x8a, 0x66, 0xfb, 0x0e, 0x2d, 0x98, 0xc2, 0xad, 0xe2, 0x5a, 0x18, 0x5a, 0x37, 0x2e, 0x13, 0xc9, 0xe7, 0xb9, 0x8c, 0xa9, 0x3e")
 MAKE_THUNK(fex, link_address_to_function, "0xe6, 0xa8, 0xec, 0x1c, 0x7b, 0x74, 0x35, 0x27, 0xe9, 0x4f, 0x5b, 0x6e, 0x2d, 0xc9, 0xa0, 0x27, 0xd6, 0x1f, 0x2b, 0x87, 0x8f, 0x2d, 0x35, 0x50, 0xea, 0x16, 0xb8, 0xc4, 0x5e, 0x42, 0xfd, 0x77")
 MAKE_THUNK(fex, allocate_host_trampoline_for_guest_function, "0x9b, 0xb2, 0xf4, 0xb4, 0x83, 0x7d, 0x28, 0x93, 0x40, 0xcb, 0xf4, 0x7a, 0x0b, 0x47, 0x85, 0x87, 0xf9, 0xbc, 0xb5, 0x27, 0xca, 0xa6, 0x93, 0xa5, 0xc0, 0x73, 0x27, 0x24, 0xae, 0xc8, 0xb8, 0x5a")
+MAKE_THUNK(fex, register_async_worker_thread, "0x9c, 0xb2, 0xf4, 0xb4, 0x83, 0x7d, 0x28, 0x93, 0x40, 0xcb, 0xf4, 0x7a, 0x0b, 0x47, 0x85, 0x87, 0xf9, 0xbc, 0xb5, 0x27, 0xca, 0xa6, 0x93, 0xa5, 0xc0, 0x73, 0x27, 0x24, 0xae, 0xc8, 0xb8, 0x5a")
+MAKE_THUNK(fex, unregister_async_worker_thread, "0x9d, 0xb2, 0xf4, 0xb4, 0x83, 0x7d, 0x28, 0x93, 0x40, 0xcb, 0xf4, 0x7a, 0x0b, 0x47, 0x85, 0x87, 0xf9, 0xbc, 0xb5, 0x27, 0xca, 0xa6, 0x93, 0xa5, 0xc0, 0x73, 0x27, 0x24, 0xae, 0xc8, 0xb8, 0x5a")
 
 #define LOAD_LIB_BASE(name, init_fn) \
   __attribute__((constructor)) static void loadlib() \
   { \
+    static bool inited = false; \
+    if (inited) { \
+      return; \
+    } \
     LoadlibArgs args =  { #name }; \
     fexthunks_fex_loadlib(&args); \
     if ((init_fn)) ((void(*)())init_fn)(); \
+    inited = true; \
   }
 
 #define LOAD_LIB(name) LOAD_LIB_BASE(name, nullptr)
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index a3b2e565d7..5cee521f91 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -27,6 +27,9 @@ namespace FEXCore {
   __attribute__((weak))
   HostToGuestTrampolinePtr*
   FinalizeHostTrampolineForGuestFunction(HostToGuestTrampolinePtr*, void* HostPacker);
+
+  __attribute__((weak))
+  void MakeHostTrampolineForGuestFunctionAsyncCallable(HostToGuestTrampolinePtr*, unsigned AsyncWorkerThreadId);
 }
 
 template<typename Fn>
@@ -85,11 +88,13 @@ struct fex_guest_function_ptr {
     init_fn (); \
   }
 
+// Same as TrampolineInstanceInfo in Thunks.cpp
 struct GuestcallInfo {
   uintptr_t HostPacker;
-  void (*CallCallback)(uintptr_t GuestUnpacker, uintptr_t GuestTarget, void* argsrv);
+  void (*CallCallback)(uintptr_t GuestUnpacker, uintptr_t GuestTarget, void* argsrv, uintptr_t AsyncWorkerThread);
   uintptr_t GuestUnpacker;
   uintptr_t GuestTarget;
+  uintptr_t AsyncWorkerThread;
 };
 
 // Helper macro for reading an internal argument passed through the `r11`

From cd70f0431edf27ad85cfa9b8f81e003ce1de25f3 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Mon, 7 Aug 2023 22:10:49 +0200
Subject: [PATCH 20/48] TODODROP. Partially revert "Add support for
 asynchronous callbacks"

---
 FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp | 8 ++++----
 ThunkLibs/include/common/Host.h                | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp b/FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp
index 4034b106a4..4fa5bab992 100644
--- a/FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp
+++ b/FEXCore/Source/Interface/HLE/Thunks/Thunks.cpp
@@ -250,8 +250,8 @@ namespace FEXCore {
          * Otherwise, this may only be used from a guest thread (including
          * synchronous uses from the host-side).
          */
-        static void CallCallback(void *callback, void *arg0, void* arg1, AsyncCallbackState *AsyncWorkerThread) {
-          if (!AsyncWorkerThread) {
+        static void CallCallback(void *callback, void *arg0, void* arg1) {
+          if (true) {
             auto CTX = static_cast<Context::ContextImpl*>(Thread->CTX);
             if (CTX->Config.Is64BitMode) {
               Thread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RDI] = (uintptr_t)arg0;
@@ -276,8 +276,8 @@ namespace FEXCore {
 
             Thread->CTX->HandleCallback(Thread, (uintptr_t)callback);
           } else {
-            auto* ActiveThread = AsyncWorkerThread->Thread;
-            auto ThunksHandler = reinterpret_cast<ThunkHandler_impl*>(static_cast<Context::ContextImpl*>(AsyncWorkerThread->Thread->CTX)->ThunkHandler.get());
+            FEXCore::Core::InternalThreadState* ActiveThread = nullptr;
+            auto ThunksHandler = reinterpret_cast<ThunkHandler_impl*>(static_cast<Context::ContextImpl*>(ActiveThread->CTX)->ThunkHandler.get());
 
             std::unique_lock lock(ThunksHandler->AsyncWorkerThreadsMutex);
             ActiveThread->CurrentFrame->State.gregs[FEXCore::X86State::REG_RDI] = (uintptr_t)arg0;
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index 5cee521f91..dba2d065af 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -91,7 +91,7 @@ struct fex_guest_function_ptr {
 // Same as TrampolineInstanceInfo in Thunks.cpp
 struct GuestcallInfo {
   uintptr_t HostPacker;
-  void (*CallCallback)(uintptr_t GuestUnpacker, uintptr_t GuestTarget, void* argsrv, uintptr_t AsyncWorkerThread);
+  void (*CallCallback)(uintptr_t GuestUnpacker, uintptr_t GuestTarget, void* argsrv);
   uintptr_t GuestUnpacker;
   uintptr_t GuestTarget;
   uintptr_t AsyncWorkerThread;

From d5f5f43ed658527bb19634635780bc2b061223c3 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Tue, 15 Aug 2023 15:49:47 +0200
Subject: [PATCH 21/48] Thunks/xcb: Drop unused and incomplete support for
 asynchous callbacks

---
 ThunkLibs/include/common/CrossArchEvent.h | 119 ----------------------
 ThunkLibs/libxcb/WorkEventData.h          |  16 ---
 ThunkLibs/libxcb/libxcb_Guest.cpp         |  91 +----------------
 ThunkLibs/libxcb/libxcb_Host.cpp          |  53 ----------
 ThunkLibs/libxcb/libxcb_interface.cpp     |   7 +-
 5 files changed, 2 insertions(+), 284 deletions(-)
 delete mode 100644 ThunkLibs/include/common/CrossArchEvent.h
 delete mode 100644 ThunkLibs/libxcb/WorkEventData.h

diff --git a/ThunkLibs/include/common/CrossArchEvent.h b/ThunkLibs/include/common/CrossArchEvent.h
deleted file mode 100644
index d2b92c17ac..0000000000
--- a/ThunkLibs/include/common/CrossArchEvent.h
+++ /dev/null
@@ -1,119 +0,0 @@
-#pragma once
-
-#include <linux/futex.h>
-#include <sys/syscall.h>
-#include <atomic>
-#include <condition_variable>
-#include <mutex>
-#include <unistd.h>
-
-struct CrossArchEvent final {
-  std::atomic<uint32_t> Futex;
-};
-
-static void WaitForWorkFunc(CrossArchEvent *Event) {
-
-  // Wait for Futex value to become 1
-  while (true) {
-
-    // First step compare it with 1 already and see if we can early out
-    uint32_t One = 1;
-    if (Event->Futex.compare_exchange_strong(One, 0)) {
-      return;
-    }
-
-    int Op = FUTEX_WAIT | FUTEX_PRIVATE_FLAG;
-    [[maybe_unused]] int Res = syscall(SYS_futex,
-        &Event->Futex,
-        Op,
-        nullptr, // Timeout
-        nullptr, // Addr
-        0);
-  }
-}
-
-static void NotifyWorkFunc(CrossArchEvent *Event) {
-  uint32_t Zero = 0;
-  if (Event->Futex.compare_exchange_strong(Zero, 1)) {
-    int Op = FUTEX_WAKE | FUTEX_PRIVATE_FLAG;
-    syscall(SYS_futex,
-      &Event->Futex,
-      Op,
-      nullptr, // Timeout
-      nullptr, // Addr
-      0);
-  }
-}
-
-//class CrossArchEvent final {
-//  private:
-//  /**
-//   * @brief Literally just an atomic bool that we are using for this class
-//   */
-//  class Flag final {
-//  public:
-//    bool TestAndSet(bool SetValue = true) {
-//      bool Expected = !SetValue;
-//      return Value.compare_exchange_strong(Expected, SetValue);
-//    }
-//
-//    bool TestAndClear() {
-//      return TestAndSet(false);
-//    }
-//
-//    bool Get() {
-//      return Value.load();
-//    }
-//
-//  private:
-//    std::atomic_bool Value {false};
-//  };
-//
-//  public:
-//    ~CrossArchEvent() {
-//      NotifyAll();
-//    }
-//    void NotifyOne() {
-//      if (FlagObject.TestAndSet()) {
-//        std::lock_guard<std::mutex> lk(MutexObject);
-//        CondObject.notify_one();
-//      }
-//    }
-//
-//    void NotifyAll() {
-//      if (FlagObject.TestAndSet()) {
-//        std::lock_guard<std::mutex> lk(MutexObject);
-//        CondObject.notify_all();
-//      }
-//    }
-//
-//    void Wait() {
-//      // Have we signaled before we started waiting?
-//      if (FlagObject.TestAndClear())
-//        return;
-//
-//      std::unique_lock<std::mutex> lk(MutexObject);
-//      CondObject.wait(lk, [this]{ return FlagObject.TestAndClear(); });
-//    }
-//
-//    template<class Rep, class Period>
-//    bool WaitFor(std::chrono::duration<Rep, Period> const& time) {
-//      // Have we signaled before we started waiting?
-//      if (FlagObject.TestAndClear())
-//        return true;
-//
-//      std::unique_lock<std::mutex> lk(MutexObject);
-//      bool DidSignal = CondObject.wait_for(lk, time, [this]{ return FlagObject.TestAndClear(); });
-//      return DidSignal;
-//    }
-//    void BusyWaitForWork() {
-//      while (!FlagObject.Get());
-//    }
-//
-//  private:
-//    std::mutex MutexObject;
-//    std::condition_variable CondObject;
-//    Flag FlagObject;
-//};
-
-
diff --git a/ThunkLibs/libxcb/WorkEventData.h b/ThunkLibs/libxcb/WorkEventData.h
deleted file mode 100644
index c2c09b8e58..0000000000
--- a/ThunkLibs/libxcb/WorkEventData.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-#include <cstdint>
-
-#ifndef GUEST_THUNK_LIBRARY
-#include "../include/common/Host.h"
-#endif
-
-struct CBWork {
-#ifdef GUEST_THUNK_LIBRARY
-  uintptr_t cb;
-#else
-  fex_guest_function_ptr cb;
-#endif
-  void *argsv;
-};
-
diff --git a/ThunkLibs/libxcb/libxcb_Guest.cpp b/ThunkLibs/libxcb/libxcb_Guest.cpp
index c9add3c72c..0241e3068f 100644
--- a/ThunkLibs/libxcb/libxcb_Guest.cpp
+++ b/ThunkLibs/libxcb/libxcb_Guest.cpp
@@ -21,85 +21,12 @@ tags: thunklibs|xcb
 #include <sys/syscall.h>
 
 #include "common/Guest.h"
-#include "WorkEventData.h"
-#include "common/CrossArchEvent.h"
 
 #include <stdarg.h>
 
 #include "thunkgen_guest_libxcb.inl"
 
-static std::thread CBThread{};
-static std::atomic<bool> CBDone{false};
-static std::mutex CBThreadMutex;
-static uint32_t ScreenRefCount;
-
-static CrossArchEvent WaitForWork{};
-static CrossArchEvent WorkDone{};
-static CBWork CBWorkData{};
-
-void FEX_Helper_GiveEvents() {
-  struct {
-    CrossArchEvent *WaitForWork;
-    CrossArchEvent *WorkDone;
-    CBWork *Work;
-  } args;
-
-  args.WaitForWork = &WaitForWork;
-  args.WorkDone = &WorkDone;
-  args.Work = &CBWorkData;
-
-  fexthunks_libxcb_FEX_GiveEvents(&args);
-}
-
-static void CallbackThreadFunc() {
-  // Set the thread name to make it easy to know what thread this is
-  pthread_setname_np(pthread_self(), "xcb:take_socket");
-
-  // Hand the host our helpers
-  FEX_Helper_GiveEvents();
-  while (!CBDone) {
-    WaitForWorkFunc(&WaitForWork);
-    if (CBDone) {
-      return;
-    }
-    typedef void take_xcb_fn_t (void* a_0);
-    auto callback = reinterpret_cast<take_xcb_fn_t*>(CBWorkData.cb);
-
-    // On shutdown then callback can change to nullptr
-    if (callback) {
-      callback(CBWorkData.argsv);
-    }
-    NotifyWorkFunc(&WorkDone);
-  }
-}
-
 extern "C" {
-  void CreateCallback() {
-    std::unique_lock lk{CBThreadMutex};
-    ++ScreenRefCount;
-
-    // Start a guest side thread that allows us to do callbacks from xcb safely
-    if (!CBThread.joinable()) {
-      CBDone = false;
-      CBThread = std::thread(CallbackThreadFunc);
-    }
-  }
-
-  void RemoveCallback() {
-    std::unique_lock lk{CBThreadMutex};
-    --ScreenRefCount;
-
-    // If the new value is 0 then shutdown the work thread.
-    if (ScreenRefCount == 0) {
-      if (CBThread.joinable()) {
-        CBDone = true;
-        NotifyWorkFunc(&WaitForWork);
-        NotifyWorkFunc(&WorkDone);
-        CBThread.join();
-      }
-    }
-  }
-
   xcb_extension_t xcb_big_requests_id = {
     .name = "BIG-REQUESTS",
     .global_id = 0,
@@ -134,7 +61,7 @@ extern "C" {
     if (xcb_get_file_descriptor(ret) != -1) {
       // Only create callback on valid xcb connections.
       // Checking for FD is the easiest way to do this.
-      CreateCallback();
+      //CreateCallback();
     }
     InitializeExtensions(ret);
     return ret;
@@ -142,33 +69,17 @@ extern "C" {
 
   xcb_connection_t * xcb_connect(const char * a_0,int * a_1){
     auto ret = fexfn_pack_xcb_connect(a_0, a_1);
-
-    if (xcb_get_file_descriptor(ret) != -1) {
-      // Only create callback on valid xcb connections.
-      // Checking for FD is the easiest way to do this.
-      CreateCallback();
-    }
     InitializeExtensions(ret);
     return ret;
   }
 
   xcb_connection_t * xcb_connect_to_display_with_auth_info(const char * a_0,xcb_auth_info_t * a_1,int * a_2){
     auto ret = fexfn_pack_xcb_connect_to_display_with_auth_info(a_0, a_1, a_2);
-    if (xcb_get_file_descriptor(ret) != -1) {
-      // Only create callback on valid xcb connections.
-      // Checking for FD is the easiest way to do this.
-      CreateCallback();
-    }
     InitializeExtensions(ret);
     return ret;
   }
 
   void xcb_disconnect(xcb_connection_t * a_0){
-    if (a_0 != nullptr && xcb_get_file_descriptor(a_0) != -1) {
-      // Only decrement callback reference on valid displays.
-      // Checking for FD and nullptr is the easiest way to do this.
-      RemoveCallback();
-    }
     fexfn_pack_xcb_disconnect(a_0);
   }
 
diff --git a/ThunkLibs/libxcb/libxcb_Host.cpp b/ThunkLibs/libxcb/libxcb_Host.cpp
index d634725f1c..8d5083f089 100644
--- a/ThunkLibs/libxcb/libxcb_Host.cpp
+++ b/ThunkLibs/libxcb/libxcb_Host.cpp
@@ -16,33 +16,15 @@ tags: thunklibs|xcb
 #include <xcb/xcb.h>
 #include <xcb/xcbext.h>
 
-#include "common/CrossArchEvent.h"
 #include "common/Host.h"
 #include <dlfcn.h>
 #include <unordered_map>
 
-#include "WorkEventData.h"
-
 #include "thunkgen_host_libxcb.inl"
 
 static void fexfn_impl_libxcb_FEX_xcb_init_extension(xcb_connection_t*, xcb_extension_t*);
 static size_t fexfn_impl_libxcb_FEX_usable_size(void*);
 static void fexfn_impl_libxcb_FEX_free_on_host(void*);
-static void fexfn_impl_libxcb_FEX_GiveEvents(CrossArchEvent*, CrossArchEvent*, CBWork*);
-
-static int fexfn_impl_libxcb_xcb_take_socket(xcb_connection_t * a_0, fex_guest_function_ptr a_1, void * a_2, int a_3, uint64_t * a_4);
-
-struct xcb_take_socket_CB_args {
-  xcb_connection_t * conn;
-  fex_guest_function_ptr CBFunction;
-  void *closure;
-};
-
-CrossArchEvent *WaitForWork{};
-CrossArchEvent *WorkDone{};
-CBWork *Work{};
-
-static std::unordered_map<xcb_connection_t*, xcb_take_socket_CB_args> CBArgs{};
 
 static size_t fexfn_impl_libxcb_FEX_usable_size(void *a_0){
   return malloc_usable_size(a_0);
@@ -52,41 +34,6 @@ static void fexfn_impl_libxcb_FEX_free_on_host(void *a_0){
   free(a_0);
 }
 
-static void fexfn_impl_libxcb_FEX_GiveEvents(CrossArchEvent* a_0, CrossArchEvent* a_1, CBWork* a_2){
-  WaitForWork = a_0;
-  WorkDone = a_1;
-  Work = a_2;
-}
-
-static void xcb_take_socket_cb(void *closure) {
-  xcb_take_socket_CB_args *Args = (xcb_take_socket_CB_args *)closure;
-
-  // Signalling to the guest thread like this allows us to call the callback function from any thread without
-  // creating spurious thread objects inside of FEX
-  Work->cb = Args->CBFunction;
-  Work->argsv = Args->closure;
-  // Tell the thread it has work
-  NotifyWorkFunc(WaitForWork);
-  // Wait for the work to be done
-  WaitForWorkFunc(WorkDone);
-}
-
-static int fexfn_impl_libxcb_xcb_take_socket(xcb_connection_t * a_0, fex_guest_function_ptr a_1, void * a_2, int a_3, uint64_t * a_4){
-  xcb_take_socket_CB_args Args{};
-  Args.conn = a_0;
-  Args.CBFunction = a_1;
-  Args.closure = a_2;
-
-  auto Res = CBArgs.insert_or_assign(a_0, Args);
-
-  return fexldr_ptr_libxcb_xcb_take_socket
-    (a_0,
-     xcb_take_socket_cb,
-     &Res.first->second,
-     a_3,
-     a_4);
-}
-
 static void fexfn_impl_libxcb_FEX_xcb_init_extension(xcb_connection_t * a_0, xcb_extension_t * a_1){
   xcb_extension_t *ext{};
 
diff --git a/ThunkLibs/libxcb/libxcb_interface.cpp b/ThunkLibs/libxcb/libxcb_interface.cpp
index ede74e44b5..6ac46b0ee0 100644
--- a/ThunkLibs/libxcb/libxcb_interface.cpp
+++ b/ThunkLibs/libxcb/libxcb_interface.cpp
@@ -3,9 +3,6 @@
 #include <xcb/xcb.h>
 #include <xcb/xcbext.h>
 
-#include <common/CrossArchEvent.h>
-#include "WorkEventData.h"
-
 template<auto>
 struct fex_gen_config {
     unsigned version = 1;
@@ -23,12 +20,10 @@ template<> struct fex_gen_type<xcb_client_message_data_t> : fexgen::assume_compa
 void FEX_xcb_init_extension(xcb_connection_t*, xcb_extension_t*);
 size_t FEX_usable_size(void*);
 void FEX_free_on_host(void*);
-void FEX_GiveEvents(CrossArchEvent*, CrossArchEvent*, CBWork*);
 
 template<> struct fex_gen_config<FEX_xcb_init_extension> : fexgen::custom_host_impl {};
 template<> struct fex_gen_config<FEX_usable_size> : fexgen::custom_host_impl, fexgen::custom_guest_entrypoint {};
 template<> struct fex_gen_config<FEX_free_on_host> : fexgen::custom_host_impl, fexgen::custom_guest_entrypoint {};
-template<> struct fex_gen_config<FEX_GiveEvents> : fexgen::custom_host_impl, fexgen::custom_guest_entrypoint {};
 
 template<> struct fex_gen_config<xcb_flush> {};
 template<> struct fex_gen_config<xcb_get_maximum_request_length> {};
@@ -71,7 +66,7 @@ template<> struct fex_gen_config<xcb_send_request_with_fds> {};
 template<> struct fex_gen_config<xcb_send_request64> {};
 template<> struct fex_gen_config<xcb_send_request_with_fds64> {};
 template<> struct fex_gen_config<xcb_send_fd> {};
-template<> struct fex_gen_config<xcb_take_socket> : fexgen::callback_guest, fexgen::custom_host_impl {};
+template<> struct fex_gen_config<xcb_take_socket> {};
 
 template<> struct fex_gen_config<xcb_writev> {};
 template<> struct fex_gen_config<xcb_wait_for_reply> : fexgen::custom_guest_entrypoint {};

From a108aeb4929f19d3cd41acef6ff44cbac6caa2f8 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Mon, 14 Aug 2023 17:22:58 +0200
Subject: [PATCH 22/48] Thunks/gen: Emit layout information for types passed
 across thunk boundaries

---
 ThunkLibs/Generator/gen.cpp       | 191 ++++++++++++++++++++++++
 ThunkLibs/include/common/Host.h   | 237 ++++++++++++++++++++++++++++++
 unittests/ThunkLibs/generator.cpp |   7 +
 3 files changed, 435 insertions(+)

diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index aa68285f42..cb45eab6f6 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -49,6 +49,93 @@ static std::string format_function_args(const FunctionParams& params, Fn&& forma
     return ret;
 };
 
+// Custom sort algorithm that works with partial orders.
+//
+// In contrast, std::sort requires that any two different elements A and B of
+// the input range compare either A<B or B<A. This requirement is violated e.g.
+// for dependency relations: Elements A and B might not depend on each other,
+// but they both might depend on some third element C. BubbleSort then ensures
+// C preceeds both A and B in the sorted range, while leaving the relative
+// order of A and B undetermined. In effect when iterating over the sorted
+// range, each dependency is visited before any of its dependees.
+template<std::forward_iterator It>
+void BubbleSort(It begin, It end,
+                std::relation<std::iter_value_t<It>, std::iter_value_t<It>> auto compare) {
+    repeat:
+    while (true) {
+        bool fixpoint = true;
+        for (auto it = begin; it != end; ++it) {
+            for (auto it2 = std::next(it); it2 != end; ++it2) {
+                if (compare(*it2, *it)) {
+                    std::swap(*it, *it2);
+                    fixpoint = false;
+                    goto repeat; // TODO: Drop. Instead, wind back to it
+                }
+            }
+        }
+
+        if (fixpoint) {
+            return;
+        }
+    }
+}
+
+// Compares such that A < B if B contains A as a member and requires A to be completely defined (i.e. non-pointer/non-reference).
+// This applies recursively to structs contained by B.
+struct compare_by_struct_dependency {
+    clang::ASTContext& context;
+
+    bool operator()(const std::pair<const clang::Type*, GenerateThunkLibsAction::RepackedType>& a,
+                    const std::pair<const clang::Type*, GenerateThunkLibsAction::RepackedType>& b) const {
+      return (*this)(a.first, b.first);
+    }
+
+    bool operator()(const clang::Type* a, const clang::Type* b) const {
+        auto* b_as_array = llvm::dyn_cast<clang::ConstantArrayType>(b);
+        if (b_as_array) {
+            // TODO: Why do we register array types like VkMemoryHeap[16] to begin with?
+            return context.hasSameType(b_as_array->getArrayElementTypeNoTypeQual(), a);
+        }
+
+        auto* b_as_struct = b->getAsStructureType();
+        if (!b_as_struct) {
+            // Not a struct => no dependency
+            return false;
+        }
+
+        for (auto* child : b_as_struct->getDecl()->fields()) {
+            if (child->getType()->isPointerType()) {
+                // Pointers don't need the definition to be available
+                continue;
+            }
+
+            auto element_type = a->isArrayType() ? a->getArrayElementTypeNoTypeQual() : a;
+            if (context.hasSameType(child->getType().getTypePtr(), element_type)) {
+                return true;
+            }
+
+//            if (context.hasSameType(child->getType().getTypePtr(), b)) {
+//                // Pointer to the struct itself, no need to recurse
+//                continue;
+//            }
+
+//                    // If this is a pointer (and not a fixed-size array), we don't need a complete definition
+//                    if (!child.pointer_chain.empty() && std::none_of(child.pointer_chain.begin(), child.pointer_chain.end(),
+//                                                                      [](const PointerInfo& ptr) { return ptr.array_size.has_value(); })) {
+//                         continue;
+//                    }
+
+            if ((*this)(a, child->getType().getTypePtr())) {
+                // Child depends on A => transitive dependency
+                return true;
+            }
+        }
+
+        // No dependency found
+        return false;
+    }
+};
+
 void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
     ErrorReporter report_error { context };
 
@@ -248,6 +335,110 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
     if (!output_filenames.host.empty()) {
         std::ofstream file(output_filenames.host);
 
+    // TODO: Move to dedicated function
+    {
+        // Sort struct types by dependency so that repacking code is emitted in an order that compiles file
+        auto& types2 = types;
+        std::vector<std::pair<const clang::Type*, RepackedType>> types { types2.begin(), types2.end() };
+        BubbleSort(types.begin(), types.end(), compare_by_struct_dependency { context });
+
+        for (const auto& [type, type_repack_info] : types) {
+            auto struct_name = get_type_name(context, type);
+
+            // Opaque types don't need layout definitions
+            if (type_repack_info.is_opaque && type_repack_info.pointers_only) {
+                if (abi.pointer_size != 4) {
+                    fmt::print(file, "template<> inline constexpr bool has_compatible_data_layout<{}*> = true;\n", struct_name);
+                }
+                continue;
+            } else if (type_repack_info.is_opaque) {
+                // TODO: Handle more cleanly
+                type_compat[type] = TypeCompatibility::Full;
+            }
+
+            // These must be handled later since they are not canonicalized and hence must be de-duplicated first
+            if (type->isBuiltinType()) {
+                continue;
+            }
+
+            // TODO: Instead, map these names back to *some* type that's named?
+            if (struct_name.starts_with("unnamed_")) {
+                continue;
+            }
+
+            if (type->isEnumeralType()) {
+                fmt::print(file, "template<>\nstruct guest_layout<{}> {{\n", struct_name);
+                fmt::print(file, "  using type = {}int{}_t;\n",
+                           type->isUnsignedIntegerOrEnumerationType() ? "u" : "",
+                           abi.at(struct_name).get_if_simple_or_struct()->size_bits);
+                fmt::print(file, "  type data;\n");
+                fmt::print(file, "}};\n");
+                continue;
+            }
+
+            // Guest layout definition
+            fmt::print(file, "template<>\nstruct guest_layout<{}> {{\n", struct_name);
+            if (type_compat.at(type) == TypeCompatibility::Full) {
+                fmt::print(file, "  using type = {};\n", struct_name);
+            } else {
+                fmt::print(file, "  struct type {{\n");
+                // TODO: Insert any required padding bytes
+                for (auto& member : abi.at(struct_name).get_if_struct()->members) {
+                    fmt::print(file, "    guest_layout<{}> {};\n", member.type_name, member.member_name);
+                }
+                fmt::print(file, "  }};\n");
+            }
+            fmt::print(file, "  type data;\n");
+            fmt::print(file, "}};\n");
+
+            fmt::print(file, "template<>\nstruct guest_layout<const {}> : guest_layout<{}> {{\n", struct_name, struct_name);
+            fmt::print(file, "  guest_layout& operator=(const guest_layout<{}>& other) {{ memcpy(this, &other, sizeof(other)); return *this; }}\n", struct_name);
+            fmt::print(file, "}};\n");
+
+            // Host layout definition
+            fmt::print(file, "template<>\n");
+            fmt::print(file, "struct host_layout<{}> {{\n", struct_name);
+            fmt::print(file, "  using type = {};\n", struct_name);
+            fmt::print(file, "  type data;\n");
+            fmt::print(file, "\n");
+            fmt::print(file, "  host_layout(const guest_layout<{}>& from) :\n", struct_name);
+            if (type_compat.at(type) == TypeCompatibility::Full) {
+                fmt::print(file, "    data {{ from.data }} {{\n");
+            } else {
+                fmt::print(file, "    data {{\n");
+                fmt::print(file, "      // Constructor performs layout repacking.\n");
+                fmt::print(file, "      // Each initializer itself is wrapped in host_layout<> to enable recursive layout repacking\n");
+                auto map_field = [&file](clang::FieldDecl* member, bool skip_arrays) {
+                    auto decl_name = member->getNameAsString();
+                    auto type_name = member->getType().getAsString();
+                    auto array_type = llvm::dyn_cast<clang::ConstantArrayType>(member->getType());
+                    if (!array_type && skip_arrays) {
+                        fmt::print(file, "      .{} = host_layout<{}> {{ from.data.{} }}.data,\n", decl_name, type_name, decl_name);
+                    } else if (array_type && !skip_arrays) {
+                        // Copy element-wise below
+                        fmt::print(file, "      for (size_t i = 0; i < {}; ++i) {{\n", array_type->getSize().getZExtValue());
+                        fmt::print(file, "        data.{}[i] = host_layout<{}> {{ from.data.{} }}.data[i];\n", decl_name, type_name, decl_name);
+                        fmt::print(file, "      }}\n");
+                    }
+                };
+                // Prefer initialization via the constructor's initializer list if possible (to detect unintended narrowing), otherwise initialize in the body
+                for (auto* member : type->getAsStructureType()->getDecl()->fields()) {
+                    map_field(member, true);
+                }
+                fmt::print(file, "    }} {{\n");
+                for (auto* member : type->getAsStructureType()->getDecl()->fields()) {
+                    map_field(member, false);
+                }
+            }
+            fmt::print(file, "  }}\n");
+            fmt::print(file, "}};\n\n");
+
+            if (type_compat.at(type) == TypeCompatibility::Full) {
+                fmt::print(file, "template<> inline constexpr bool has_compatible_data_layout<{}> = true;\n", struct_name);
+            }
+        }
+    }
+
         // Forward declarations for symbols loaded from the native host library
         for (auto& import : thunked_api) {
             const auto& function_name = import.function_name;
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index dba2d065af..50a61b3141 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -5,6 +5,7 @@ category: thunklibs ~ These are generated + glue logic 1:1 thunks unless noted o
 */
 
 #pragma once
+#include <array>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
@@ -113,10 +114,246 @@ struct ParameterAnnotations {
     bool is_opaque = false;
 };
 
+// Generator emits specializations for this for each type that has compatible layout
+template<typename T>
+inline constexpr bool has_compatible_data_layout =
+  std::is_integral_v<T> || std::is_enum_v<T> || std::is_floating_point_v<T>
+#ifndef IS_32BIT_THUNK
+  // If none of the previous predicates matched, the thunk generator did *not* emit a specialization for T.
+  // This should not happen on 64-bit with the currently thunked libraries, since their types
+  // * either have fully consistent data layout across 64-bit architectures.
+  // * or use custom repacking, in which case has_compatible_data_layout isn't used
+  //
+  // Throwing a fake exception here will trigger a build failure.
+  || (throw "Instantiated on a type that was expected to be compatible", true)
+#endif
+;
+
+#ifndef IS_32BIT_THUNK
+// Pointers have the same size, hence data layout compatibility only depends on the pointee type
+template<typename T>
+inline constexpr bool has_compatible_data_layout<T*> = has_compatible_data_layout<std::remove_cv_t<T>>;
+template<typename T>
+inline constexpr bool has_compatible_data_layout<T* const> = has_compatible_data_layout<std::remove_cv_t<T>*>;
+
+// void* and void** are assumed to be compatible to simplify handling of libraries that use them ubiquitously
+template<> inline constexpr bool has_compatible_data_layout<void*> = true;
+template<> inline constexpr bool has_compatible_data_layout<const void*> = true;
+template<> inline constexpr bool has_compatible_data_layout<void**> = true;
+template<> inline constexpr bool has_compatible_data_layout<const void**> = true;
+#endif
+
 // Placeholder type to indicate the given data is in guest-layout
 template<typename T>
 struct guest_layout {
+  static_assert(!std::is_class_v<T>, "No guest layout defined for this non-opaque struct type. This may be a bug in the thunk generator.");
+  static_assert(!std::is_union_v<T>, "No guest layout defined for this non-opaque union type. This may be a bug in the thunk generator.");
+  static_assert(!std::is_enum_v<T>, "No guest layout defined for this enum type. This is a bug in the thunk generator.");
+  static_assert(!std::is_void_v<T>, "Attempted to get guest layout of void. Missing annotation for void pointer?");
+
+  static_assert(std::is_fundamental_v<T> || has_compatible_data_layout<T>, "Default guest_layout may not be used for non-compatible data");
+
+  using type = std::enable_if_t<!std::is_pointer_v<T>, T>;
+  type data;
+
+  // TODO: Make this conversion explicit
+  guest_layout& operator=(const T from) {
+    data = from;
+    return *this;
+  }
+
+  // Allow conversion of integral types of same size and sign to each other.
+  // This is useful for handling "long"/"long long" on 64-bit, as well as uint8_t/char.
+  // TODO: Make this conversion explicit
+  template<typename U>
+  guest_layout& operator=(const guest_layout<U>& from) requires (std::is_integral_v<U> && sizeof(U) == sizeof(T) && std::is_convertible_v<T, U> && std::is_signed_v<T> == std::is_signed_v<U>) {
+    data = static_cast<T>(from.data);
+    return *this;
+  }
+};
+
+#if IS_32BIT_THUNK
+// Specialized for uint32_t so that members annotated as "size_t" can automatically be converted from 64-bit to 32-bit
+template<>
+struct guest_layout<uint32_t> {
+  using type = uint32_t;
+  type data;
+
+  // TODO: Make this conversion explicit
+  guest_layout& operator=(const uint32_t from) {
+    data = from;
+    return *this;
+  }
+  guest_layout& operator=(const guest_layout<size_t>& from) {
+    if (from.data > 0xffffffff) {
+      fprintf(stderr, "ERROR: Tried to truncate large size_t value passed across thunk boundaries\n");
+      std::abort();
+    }
+    data = (uint32_t)from.data;
+    return *this;
+  }
+
+  guest_layout() = default;
+  guest_layout(const guest_layout<size_t>& from) {
+    if (from.data > 0xffffffff) {
+      fprintf(stderr, "ERROR: Tried to truncate large size_t value passed across thunk boundaries\n");
+      std::abort();
+    }
+    data = (uint32_t)from.data;
+  }
+  guest_layout(const guest_layout& from) : data { from.data } {
+  }
+  guest_layout(uint32_t from) : data { from } {
+  }
+};
+#endif
+
+template<typename T, std::size_t N>
+struct guest_layout<T[N]> {
+  // TODO: Check that the underlying type is ABI compatible
+//  static_assert(!std::is_class_v<T>, "No guest layout defined for this non-opaque struct type. This may be a bug in the thunk generator.");
+
+  using type = std::enable_if_t<!std::is_pointer_v<T>, T>;
+  std::array<guest_layout<type>, N> data;
+};
+
+template<typename T>
+struct host_layout;
+
+template<typename T>
+struct guest_layout<T*> {
+#ifdef IS_32BIT_THUNK
+  using type = uint32_t;
+#else
+  using type = uint64_t;
+#endif
+  type data;
+
+  // TODO: Make this conversion explicit
+  guest_layout& operator=(const T* from) {
+    // TODO: Assert upper 32 bits are zero
+    data = reinterpret_cast<uintptr_t>(from);
+    return *this;
+  }
+
+  guest_layout<T>* get_pointer() {
+    return reinterpret_cast<guest_layout<T>*>(uintptr_t { data });
+  }
+
+  const guest_layout<T>* get_pointer() const {
+    return reinterpret_cast<const guest_layout<T>*>(uintptr_t { data });
+  }
+};
+
+template<typename T>
+struct guest_layout<T* const> {
+#ifdef IS_32BIT_THUNK
+  using type = uint32_t;
+#else
+  using type = uint64_t;
+#endif
+  type data;
+
+  // TODO: Make this conversion explicit
+  guest_layout& operator=(const T* from) {
+    // TODO: Assert upper 32 bits are zero
+    data = reinterpret_cast<uintptr_t>(from);
+    return *this;
+  }
+
+  guest_layout<T>* get_pointer() {
+    return reinterpret_cast<guest_layout<T>*>(uintptr_t { data });
+  }
+
+  const guest_layout<T>* get_pointer() const {
+    return reinterpret_cast<const guest_layout<T>*>(uintptr_t { data });
+  }
+};
+
+template<typename T>
+struct host_layout {
+  static_assert(!std::is_class_v<T>, "No host_layout specialization generated for struct/class type");
+  static_assert(!std::is_union_v<T>, "No host_layout specialization generated for union type");
+  static_assert(!std::is_void_v<T>, "Attempted to get host layout of void. Missing annotation for void pointer?");
+
+  // TODO: This generic implementation shouldn't be needed. Instead, auto-specialize host_layout for all types used as members.
+
   T data;
+
+  host_layout(const guest_layout<T>& from) requires (!std::is_enum_v<T>) : data { from.data } {
+    // NOTE: This is not strictly neccessary since differently sized types may
+    //       be used across architectures. It's important that the host type
+    //       can represent all guest values without loss, however.
+    static_assert(sizeof(data) == sizeof(from));
+  }
+
+  host_layout(const guest_layout<T>& from) requires (std::is_enum_v<T>) : data { static_cast<T>(from.data) } {
+  }
+
+  // Allow conversion of integral types of same size and sign to each other.
+  // This is useful for handling "long"/"long long" on 64-bit, as well as uint8_t/char.
+  template<typename U>
+  host_layout(const guest_layout<U>& from) requires (std::is_integral_v<U> && sizeof(U) == sizeof(T) && std::is_convertible_v<T, U> && std::is_signed_v<T> == std::is_signed_v<U>) : data { static_cast<T>(from.data) } {
+  }
+
+  host_layout(T from) requires (std::is_enum_v<T>) : data { from } {
+  }
+};
+
+// Explicitly turn a host type into its corresponding host_layout
+template<typename T>
+const host_layout<T>& to_host_layout(const T& t) {
+  static_assert(std::is_same_v<decltype(host_layout<T>::data), T>);
+  return reinterpret_cast<const host_layout<T>&>(t);
+}
+
+// Specialization for size_t, which is 64-bit on 64-bit but 32-bit on 32-bit
+template<>
+struct host_layout<size_t> {
+  size_t data;
+
+  host_layout(const guest_layout<uint32_t>& from) : data { from.data } {
+  }
+
+  // TODO: Shouldn't be needed
+  host_layout(const guest_layout<size_t>& from) : data { from.data } {
+  }
+};
+
+template<typename T, size_t N>
+struct host_layout<T[N]> {
+  std::array<T, N> data;
+
+  host_layout(const guest_layout<T[N]>& from) {
+    for (size_t i = 0; i < N; ++i) {
+      data[i] = host_layout<T> { from.data[i] }.data;
+    }
+  }
+};
+
+template<typename T>
+struct host_layout<T*> {
+  T* data;
+
+  static_assert(!std::is_function_v<T>, "Function types must be handled separately");
+
+  // Assume underlying data is compatible and just convert the guest-sized pointer to 64-bit
+  host_layout(const guest_layout<T*>& from) : data { (T*)(uintptr_t)from.data } {
+  }
+
+  // TODO: Make this explicit?
+  host_layout() = default;
+};
+
+template<typename T>
+struct host_layout<T* const> {
+  T* data;
+
+  static_assert(!std::is_function_v<T>, "Function types must be handled separately");
+
+  // Assume underlying data is compatible and just convert the guest-sized pointer to 64-bit
+  host_layout(const guest_layout<T* const>& from) : data { (T*)(uintptr_t)from.data } {
+  }
 };
 
 template<typename>
diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index cc1f974a1a..a05a13130d 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -250,6 +250,7 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
     std::string result =
         "#include <array>\n"
         "#include <cstdint>\n"
+        "#include <cstring>\n"
         "#include <dlfcn.h>\n"
         "#include <type_traits>\n"
         "template<typename Fn>\n"
@@ -279,11 +280,17 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
         "};\n"
         "struct ExportEntry { uint8_t* sha256; void(*fn)(void *); };\n"
         "void *dlsym_default(void* handle, const char* symbol);\n"
+        "template<typename T> inline constexpr bool has_compatible_data_layout = std::is_integral_v<T> || std::is_enum_v<T>;\n"
         "template<typename T>\n"
         "struct guest_layout {\n"
         "  T data;\n"
         "};\n"
         "\n"
+        "template<typename T>\n"
+        "struct host_layout {\n"
+        "  T data;\n"
+        "};\n"
+        "\n"
         "template<typename F> void FinalizeHostTrampolineForGuestFunction(F*);\n";
 
     auto& filename = output_filenames.host;

From cf41a021d101d019ba55d63cc5d3c7177459ba64 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Tue, 15 Aug 2023 15:34:52 +0200
Subject: [PATCH 23/48] TODO CONSIDER SQUASHING, or avoid introducing
 guest_layout placeholders. Thunks/gen: Adapt for new metadata definitions

---
 ThunkLibs/Generator/gen.cpp          | 21 ++++++++++++++++-----
 ThunkLibs/include/common/Host.h      | 19 ++++++++++++++-----
 ThunkLibs/libvulkan/Host.cpp         | 14 ++++++++++++--
 ThunkLibs/libwayland-client/Host.cpp |  6 ++++--
 unittests/ThunkLibs/generator.cpp    | 17 +++++++++++++++--
 5 files changed, 61 insertions(+), 16 deletions(-)

diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index cb45eab6f6..1e0c13f98e 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -531,7 +531,6 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
             }
 
             file << "static void fexfn_unpack_" << libname << "_" << function_name << "(" << struct_name << "* args) {\n";
-            file << (thunk.return_type->isVoidType() ? "  " : "  args->rv = ") << function_to_call << "(";
 
             for (unsigned param_idx = 0; param_idx != thunk.param_types.size(); ++param_idx) {
                 if (thunk.callbacks.contains(param_idx) && thunk.callbacks.at(param_idx).is_stub) {
@@ -558,6 +557,7 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                 if (!param_type->isPointerType() || (is_opaque || pointee_compat == TypeCompatibility::Full) ||
                     param_type->getPointeeType()->isBuiltinType() /* TODO: handle size_t. Actually, properly check for data layout compatibility */) {
                     // Fully compatible
+                    fmt::print(file, "  host_layout<{}> a_{} {{ args->a_{} }};\n", get_type_name(context, param_type.getTypePtr()), param_idx, param_idx);
                 } else if (pointee_compat == TypeCompatibility::Repackable) {
                     throw report_error(thunk.decl->getLocation(), "Pointer parameter %1 of function %0 requires automatic repacking, which is not implemented yet").AddString(function_name).AddTaggedVal(param_type);
                 } else {
@@ -565,19 +565,30 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                 }
             }
 
+            file << (thunk.return_type->isVoidType() ? "  " : "  args->rv = ") << function_to_call << "(";
             {
                 auto format_param = [&](std::size_t idx) {
-                    std::string raw_arg = fmt::format("args->a_{}.data", idx);
+                    std::string raw_arg = fmt::format("a_{}.data", idx);
 
                     auto cb = thunk.callbacks.find(idx);
                     if (cb != thunk.callbacks.end() && cb->second.is_stub) {
                         return "fexfn_unpack_" + get_callback_name(function_name, cb->first) + "_stub";
                     } else if (cb != thunk.callbacks.end() && cb->second.is_guest) {
-                        return fmt::format("fex_guest_function_ptr {{ {} }}", raw_arg);
+                        auto arg_name = fmt::format("args->a_{}.data", idx); // Use parameter directly
+                        if (thunk.custom_host_impl) {
+                            return fmt::format("({})", arg_name);
+                        } else {
+                            return fmt::format("(({})(uint64_t {{ {}.data }}))", get_type_name(context, thunk.param_types[idx].getTypePtr()), arg_name);
+                        }
                     } else if (cb != thunk.callbacks.end()) {
-                        auto arg_name = fmt::format("args->a_{}.data", idx);
+                        auto arg_name = fmt::format("args->a_{}", idx); // Use parameter directly
                         // Use comma operator to inject a function call before returning the argument
-                        return "(FinalizeHostTrampolineForGuestFunction(" + arg_name + "), " + arg_name + ")";
+                        // TODO: Avoid casting away the guest_layout
+                        if (thunk.custom_host_impl) {
+                            return fmt::format("(FinalizeHostTrampolineForGuestFunction({}), {})", arg_name, arg_name);
+                        } else {
+                            return fmt::format("(FinalizeHostTrampolineForGuestFunction({}), ({})(uint64_t {{ {}.data }}))", arg_name, get_type_name(context, thunk.param_types[idx].getTypePtr()), arg_name);
+                        }
                     } else if (thunk.param_annotations[idx].is_passthrough) {
                         // Pass raw guest_layout<T*>
                         return fmt::format("args->a_{}", idx);
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index 50a61b3141..d56e11a25a 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -9,6 +9,7 @@ category: thunklibs ~ These are generated + glue logic 1:1 thunks unless noted o
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
+#include <cstring>
 #include <dlfcn.h>
 
 #include "PackedArguments.h"
@@ -58,7 +59,7 @@ typedef void fex_call_callback_t(uintptr_t callback, void *arg0, void* arg1);
  * This prevents accidental calls to foreign function pointers while still
  * allowing us to label function pointers as such.
  */
-struct fex_guest_function_ptr {
+struct [[deprecated]] fex_guest_function_ptr {
 private:
     void* value = nullptr;
 
@@ -217,9 +218,6 @@ struct guest_layout<T[N]> {
   std::array<guest_layout<type>, N> data;
 };
 
-template<typename T>
-struct host_layout;
-
 template<typename T>
 struct guest_layout<T*> {
 #ifdef IS_32BIT_THUNK
@@ -270,6 +268,9 @@ struct guest_layout<T* const> {
   }
 };
 
+template<typename T>
+struct host_layout;
+
 template<typename T>
 struct host_layout {
   static_assert(!std::is_class_v<T>, "No host_layout specialization generated for struct/class type");
@@ -380,7 +381,7 @@ auto Projection(guest_layout<T>& data) {
   if constexpr (Annotation.is_passthrough) {
     return data;
   } else {
-    return data.data;
+    return host_layout<T> { data }.data;
   }
 }
 
@@ -452,6 +453,14 @@ struct GuestWrapperForHostFunction<Result(Args...)> {
   }
 };
 
+// TODO: Move?
+template<typename F>
+void FinalizeHostTrampolineForGuestFunction(const guest_layout<F*>& PreallocatedTrampolineForGuestFunction) {
+  FEXCore::FinalizeHostTrampolineForGuestFunction(
+      (FEXCore::HostToGuestTrampolinePtr*)PreallocatedTrampolineForGuestFunction.data,
+      (void*)&CallbackUnpack<F>::CallGuestPtr);
+}
+
 template<typename FuncType>
 void MakeHostTrampolineForGuestFunctionAt(uintptr_t GuestTarget, uintptr_t GuestUnpacker, FuncType **Func) {
     *Func = (FuncType*)FEXCore::MakeHostTrampolineForGuestFunction(
diff --git a/ThunkLibs/libvulkan/Host.cpp b/ThunkLibs/libvulkan/Host.cpp
index 45f6049a0a..a5f924c323 100644
--- a/ThunkLibs/libvulkan/Host.cpp
+++ b/ThunkLibs/libvulkan/Host.cpp
@@ -76,11 +76,21 @@ static VkResult FEXFN_IMPL(vkCreateInstance)(const VkInstanceCreateInfo* a_0, co
     }
   }
 
-  return LDR_PTR(vkCreateInstance)(vk_struct_base, nullptr, a_2.data);
+  VkInstance out;
+  auto ret = LDR_PTR(vkCreateInstance)(vk_struct_base, nullptr, &out);
+  if (ret == VK_SUCCESS) {
+    *a_2.get_pointer() = out;
+  }
+  return ret;
 }
 
 static VkResult FEXFN_IMPL(vkCreateDevice)(VkPhysicalDevice a_0, const VkDeviceCreateInfo* a_1, const VkAllocationCallbacks* a_2, guest_layout<VkDevice*> a_3){
-  return LDR_PTR(vkCreateDevice)(a_0, a_1, nullptr, a_3.data);
+  VkDevice out;
+  auto ret = LDR_PTR(vkCreateDevice)(a_0, a_1, nullptr, &out);
+  if (ret == VK_SUCCESS) {
+    *a_3.get_pointer() = out;
+  }
+  return ret;
 }
 
 static VkResult FEXFN_IMPL(vkAllocateMemory)(VkDevice a_0, const VkMemoryAllocateInfo* a_1, const VkAllocationCallbacks* a_2, VkDeviceMemory* a_3){
diff --git a/ThunkLibs/libwayland-client/Host.cpp b/ThunkLibs/libwayland-client/Host.cpp
index 8cfcb4693a..dd0b5b763c 100644
--- a/ThunkLibs/libwayland-client/Host.cpp
+++ b/ThunkLibs/libwayland-client/Host.cpp
@@ -60,7 +60,7 @@ extern "C" int fexfn_impl_libwayland_client_wl_proxy_add_listener(struct wl_prox
     // ? just indicates that the argument may be null, so it doesn't change the signature
     signature.erase(std::remove(signature.begin(), signature.end(), '?'), signature.end());
 
-    auto callback = callback_raw.data[i];
+    auto callback = reinterpret_cast<void(*)()>(uintptr_t { callback_raw.get_pointer()[i].data });
 
     if (signature == "") {
       // E.g. xdg_toplevel::close
@@ -162,7 +162,9 @@ extern "C" int fexfn_impl_libwayland_client_wl_proxy_add_listener(struct wl_prox
   }
 
   // Pass the original function pointer table to the host wayland library. This ensures the table is valid until the listener is unregistered.
-  return fexldr_ptr_libwayland_client_wl_proxy_add_listener(proxy, callback_raw.data, data.data);
+  return fexldr_ptr_libwayland_client_wl_proxy_add_listener(proxy,
+                                                            reinterpret_cast<void(**)(void)>(callback_raw.get_pointer()),
+                                                            reinterpret_cast<void*>(uintptr_t { data.data }));
 }
 
 wl_interface* fexfn_impl_libwayland_client_fex_wl_exchange_interface_pointer(wl_interface* guest_interface, char const* name) {
diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index a05a13130d..651a723f42 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -287,11 +287,24 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
         "};\n"
         "\n"
         "template<typename T>\n"
+        "struct guest_layout<T*> {\n"
+        "#ifdef IS_32BIT_THUNK\n"
+        "  using type = uint32_t;\n"
+        "#else\n"
+        "  using type = uint64_t;\n"
+        "#endif\n"
+        "  type data;\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
         "struct host_layout {\n"
         "  T data;\n"
+        "\n"
+        "  host_layout(const guest_layout<T>& from);\n"
         "};\n"
         "\n"
-        "template<typename F> void FinalizeHostTrampolineForGuestFunction(F*);\n";
+        "template<typename F> void FinalizeHostTrampolineForGuestFunction(F*);\n"
+        "template<typename F> void FinalizeHostTrampolineForGuestFunction(const guest_layout<F*>&);\n";
 
     auto& filename = output_filenames.host;
     {
@@ -421,7 +434,7 @@ TEST_CASE_METHOD(Fixture, "FunctionPointerParameter") {
             hasDescendant(callExpr(callee(functionDecl(hasName("FinalizeHostTrampolineForGuestFunction"))), hasArgument(0, expr().bind("funcptr"))))
         )).check_binding("funcptr", +[](const clang::Expr* funcptr) {
             // Check that the argument type matches the function pointer
-            return funcptr->getType().getAsString() == "int (*)(char, char)";
+            return funcptr->getType().getAsString() == "guest_layout<int (*)(char, char)>";
         }));
 
     // Host should export the unpacking function for function pointer arguments

From b3695eb8b00026d741d8469efb4d4c77a42f0d8f Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Fri, 22 Sep 2023 15:58:48 +0200
Subject: [PATCH 24/48] TODOMOVE. Thunks: Avoid recompiling thunk interfaces on
 FEXLoader changes

The interface files themselves don't use FEXLoader. Only the final library
does.
---
 ThunkLibs/HostLibs/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ThunkLibs/HostLibs/CMakeLists.txt b/ThunkLibs/HostLibs/CMakeLists.txt
index a98c819a6a..f153ccd92b 100644
--- a/ThunkLibs/HostLibs/CMakeLists.txt
+++ b/ThunkLibs/HostLibs/CMakeLists.txt
@@ -20,7 +20,6 @@ function(generate NAME SOURCE_FILE GUEST_BITNESS)
   # Interface target for the user to add include directories
   add_library(${NAME}-${GUEST_BITNESS}-deps INTERFACE)
   target_include_directories(${NAME}-${GUEST_BITNESS}-deps INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/../include")
-  target_link_libraries(${NAME}-${GUEST_BITNESS}-deps INTERFACE FEXLoader)
   if (GUEST_BITNESS EQUAL 32)
     target_compile_definitions(${NAME}-${GUEST_BITNESS}-deps INTERFACE IS_32BIT_THUNK)
   endif ()
@@ -83,6 +82,7 @@ function(add_host_lib NAME GUEST_BITNESS)
   target_include_directories(${NAME}-host-${GUEST_BITNESS} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/gen_${GUEST_BITNESS}/")
   target_link_libraries(${NAME}-host-${GUEST_BITNESS} PRIVATE dl)
   target_link_libraries(${NAME}-host-${GUEST_BITNESS} PRIVATE lib${NAME}-${GUEST_BITNESS}-deps)
+  target_link_libraries(${NAME}-host-${GUEST_BITNESS} PRIVATE FEXLoader)
   ## Make signed overflow well defined 2's complement overflow
   target_compile_options(${NAME}-host-${GUEST_BITNESS} PRIVATE -fwrapv)
 

From 59f0de0675d84d6eb8bc24cb3c6cb1f42b1d92c9 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Thu, 24 Aug 2023 12:15:34 +0200
Subject: [PATCH 25/48] Thunks/gen: Also use guest_layout for return values

---
 ThunkLibs/Generator/gen.cpp     | 52 ++++++++++++++++++++++++++++++---
 ThunkLibs/include/common/Host.h | 20 +++++++++++++
 2 files changed, 68 insertions(+), 4 deletions(-)

diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index 1e0c13f98e..13e7047fec 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -433,6 +433,40 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
             fmt::print(file, "  }}\n");
             fmt::print(file, "}};\n\n");
 
+            fmt::print(file, "// Constructor performs layout repacking.\n");
+            fmt::print(file, "// Each initializer itself is wrapped in host_layout<> to enable recursive layout repacking\n");
+            fmt::print(file, "inline guest_layout<{}> to_guest(const host_layout<{}>& from) {{\n", struct_name, struct_name);
+            if (type_compat.at(type) == TypeCompatibility::Full) {
+                fmt::print(file, "  guest_layout<{}> ret;\n", struct_name);
+                fmt::print(file, "  static_assert(sizeof(from) == sizeof(ret));\n");
+                fmt::print(file, "  memcpy(&ret, &from, sizeof(from));\n");
+            } else {
+                fmt::print(file, "  guest_layout<{}> ret {{ .data {{\n", struct_name);
+                auto map_field2 = [&file](const StructInfo::MemberInfo& member, bool skip_arrays) {
+                    auto& decl_name = member.member_name;
+                    auto& array_size = member.array_size;
+                    if (!array_size && skip_arrays) {
+                        fmt::print(file, "    .{} = to_guest(to_host_layout(from.data.{})),\n", decl_name, decl_name);
+                    } else if (array_size && !skip_arrays) {
+                        // Copy element-wise below
+                        fmt::print(file, "    for (size_t i = 0; i < {}; ++i) {{\n", array_size.value());
+                        fmt::print(file, "      ret.data.{}.data[i] = to_guest(to_host_layout(from.data.{}[i]));\n", decl_name, decl_name);
+                        fmt::print(file, "    }}\n");
+                    }
+                };
+
+                // Prefer initialization via the constructor's initializer list if possible (to detect unintended narrowing), otherwise initialize in the body
+                for (auto& member : abi.at(struct_name).get_if_struct()->members) {
+                    map_field2(member, true);
+                }
+                fmt::print(file, "  }} }};\n");
+                for (auto& member : abi.at(struct_name).get_if_struct()->members) {
+                    map_field2(member, false);
+                }
+            }
+            fmt::print(file, "  return ret;\n");
+            fmt::print(file, "}}\n\n");
+
             if (type_compat.at(type) == TypeCompatibility::Full) {
                 fmt::print(file, "template<> inline constexpr bool has_compatible_data_layout<{}> = true;\n", struct_name);
             }
@@ -514,7 +548,7 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                     fmt::print(file, "  guest_layout<{}> a_{};\n", get_type_name(context, thunk.param_types[idx].getTypePtr()), idx);
                 }
                 if (!thunk.return_type->isVoidType()) {
-                    file << "  " << format_decl(thunk.return_type, "rv") << ";\n";
+                    fmt::print(file, "  guest_layout<{}> rv;\n", get_type_name(context, thunk.return_type.getTypePtr()));
                 } else if (thunk.param_types.size() == 0) {
                     // Avoid "empty struct has size 0 in C, size 1 in C++" warning
                     file << "    char force_nonempty;\n";
@@ -565,7 +599,13 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                 }
             }
 
-            file << (thunk.return_type->isVoidType() ? "  " : "  args->rv = ") << function_to_call << "(";
+            if (!thunk.return_type->isVoidType()) {
+                fmt::print(file, "  args->rv = ");
+                if (!thunk.return_type->isFunctionPointerType()) {
+                    fmt::print(file, "to_guest(to_host_layout<{}>(", thunk.return_type.getAsString());
+                }
+            }
+            fmt::print(file, "{}(", function_to_call);
             {
                 auto format_param = [&](std::size_t idx) {
                     std::string raw_arg = fmt::format("a_{}.data", idx);
@@ -597,9 +637,13 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                     }
                 };
 
-                file << format_function_args(thunk, format_param);
+                fmt::print(file, "{}", format_function_args(thunk, format_param));
             }
-            file << ");\n";
+            if (!thunk.return_type->isVoidType() && !thunk.return_type->isFunctionPointerType()) {
+                fmt::print(file, "))");
+            }
+            fmt::print(file, ");\n");
+
             file << "}\n";
         }
         file << "}\n";
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index d56e11a25a..077db7b2e5 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -357,6 +357,26 @@ struct host_layout<T* const> {
   }
 };
 
+template<typename T>
+inline guest_layout<T> to_guest(const host_layout<T>& from) requires(!std::is_pointer_v<T>) {
+  if constexpr (std::is_enum_v<T>) {
+    // enums are represented by fixed-size integers in guest_layout, so explicitly cast them
+    return guest_layout<T> { static_cast<std::underlying_type_t<T>>(from.data) };
+  } else if constexpr (!std::is_same_v<T, uint32_t>) {
+    guest_layout<T> ret { .data = from.data };
+    return ret;
+  } else {
+    return guest_layout<uint32_t> { from.data };
+  }
+}
+
+template<typename T>
+inline guest_layout<T*> to_guest(const host_layout<T*>& from) {
+  guest_layout<T*> ret;
+  ret = from.data;
+  return ret;
+}
+
 template<typename>
 struct CallbackUnpack;
 

From f204124ee8dc807a899ffe8ad5bf082072295708 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Tue, 15 Aug 2023 17:35:00 +0200
Subject: [PATCH 26/48] Thunks/gen: Implement automatic struct repacking

---
 ThunkLibs/Generator/gen.cpp     |   4 +-
 ThunkLibs/include/common/Host.h | 148 ++++++++++++++++++++++++++++++--
 2 files changed, 142 insertions(+), 10 deletions(-)

diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index 13e7047fec..33c4558d5f 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -593,7 +593,9 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                     // Fully compatible
                     fmt::print(file, "  host_layout<{}> a_{} {{ args->a_{} }};\n", get_type_name(context, param_type.getTypePtr()), param_idx, param_idx);
                 } else if (pointee_compat == TypeCompatibility::Repackable) {
-                    throw report_error(thunk.decl->getLocation(), "Pointer parameter %1 of function %0 requires automatic repacking, which is not implemented yet").AddString(function_name).AddTaggedVal(param_type);
+                    // TODO: Require opt-in for this to be emitted since it's single-element only; otherwise, pointers-to-arrays arguments will cause stack trampling
+                    // TODO: Rename to repacked_arg
+                    fmt::print(file, "  unpacked_arg_with_storage<{}> a_{} {{ args->a_{} }};\n", get_type_name(context, param_type.getTypePtr()), param_idx, param_idx);
                 } else {
                     throw report_error(thunk.decl->getLocation(), "Cannot generate unpacking function for function %0 with unannotated pointer parameter %1").AddString(function_name).AddTaggedVal(param_type);
                 }
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index 077db7b2e5..d29486067f 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -357,6 +357,83 @@ struct host_layout<T* const> {
   }
 };
 
+// Storage for unpacked parameters. May carry additional data for aiding conversion (such as short-lived, stack-allocated data instances to repoint pointer arguments to).
+// Not suitable for nested struct repacking
+// TODO: Update this comment. Originally it was written for unpacked_arg!
+template<typename T>
+struct unpacked_arg_base;
+template<typename T>
+struct unpacked_arg_base<T*> {
+  unpacked_arg_base(host_layout<T>* data_) : data(data_) {
+  }
+
+  unpacked_arg_base(host_layout<const T>* data_) : data(data_) {
+  }
+
+  T* get() {
+    static_assert(sizeof(T) == sizeof(host_layout<T>));
+    static_assert(alignof(T) == alignof(host_layout<T>));
+    return &data->data;
+  }
+
+  host_layout<T>* data;
+};
+
+// TODO: This shouldn't hold temporary storage for pointers that don't need repacking!
+template<typename T>
+struct unpacked_arg_with_storage;
+template<typename T>
+struct unpacked_arg_with_storage<T*> : unpacked_arg_base<T*> {
+  // Silence -Wuninitialized warning from taking a pointer to opt
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wuninitialized"
+  unpacked_arg_with_storage(const guest_layout<T*>& data_) : unpacked_arg_base<T*>(data_.get_pointer() ? &opt.extra : nullptr),
+    opt {
+      data_.get_pointer() ? Opt { *data_.get_pointer() }
+      : Opt { .uninit = {} }
+    } {
+  }
+
+  unpacked_arg_with_storage(const guest_layout<const T*>& data_) : unpacked_arg_base<T*>(data_.get_pointer() ? &opt.extra : nullptr),
+  #pragma GCC diagnostic pop
+    opt {
+      data_.get_pointer() ? Opt { *data_.get_pointer() }
+      : Opt { .uninit = {} }
+    } {
+  }
+
+  // NOTE: Copying/moving this type would invalidate the reference to opt.extra,
+  //       so disallow these operations altogether.
+  unpacked_arg_with_storage(const unpacked_arg_with_storage& other) = delete;
+  unpacked_arg_with_storage(unpacked_arg_with_storage&&) = delete;
+  unpacked_arg_with_storage& operator=(const unpacked_arg_with_storage&) = delete;
+  unpacked_arg_with_storage& operator=(unpacked_arg_with_storage&&) = delete;
+
+  // Crude hack to allow leaving this uninitialized for nullptrs
+  // NOTE: We can't use std::optional here since the storage must always be valid (even before initialization)
+  union Opt {
+    host_layout<T> extra; // Temporary storage for layout-repacked data
+    char uninit;
+  } opt;
+};
+
+
+template<>
+struct unpacked_arg_with_storage<char*> {
+  using type = char*;
+
+  unpacked_arg_with_storage(/*const */guest_layout<const char*>& data) : data(reinterpret_cast<uint64_t>(data.get_pointer())) {
+  }
+  unpacked_arg_with_storage(/*const */guest_layout<char*>& data) : data(reinterpret_cast<uint64_t>(data.get_pointer())) {
+  }
+
+  type get() {
+    return reinterpret_cast<type>(data);
+  }
+
+  uint64_t data;
+};
+
 template<typename T>
 inline guest_layout<T> to_guest(const host_layout<T>& from) requires(!std::is_pointer_v<T>) {
   if constexpr (std::is_enum_v<T>) {
@@ -380,6 +457,68 @@ inline guest_layout<T*> to_guest(const host_layout<T*>& from) {
 template<typename>
 struct CallbackUnpack;
 
+// Wrapper around unpacked_arg (for on-stack repacked argument structs) that implicitly converts to the represented type
+template<typename T, typename GuestT>
+struct unpacked_arg_wrapper {
+  static_assert(std::is_pointer_v<T>);
+
+  // Strip "const" from pointee type. Managing const-correctness would be a pain otherwise.
+  using ActualT = std::add_pointer_t<std::remove_cv_t<std::remove_pointer_t<T>>>;
+
+  unpacked_arg_with_storage<ActualT> data;
+  guest_layout<T>& orig_arg;
+
+  unpacked_arg_wrapper(guest_layout<GuestT>& orig_arg_) : data(orig_arg_), orig_arg(orig_arg_) {
+  }
+
+  ~unpacked_arg_wrapper() {
+    // TODO: Properly detect opaque types
+    if constexpr (requires(guest_layout<T> t, decltype(data) h) { t.get_pointer(); (bool)h.data; *data.data; }) {
+      if constexpr (!std::is_const_v<std::remove_pointer_t<T>>) { // Skip exit-repacking for const pointees
+        if (data.data) {
+          constexpr bool is_compatible = has_compatible_data_layout<T> && std::is_same_v<T, GuestT>;
+          if constexpr (!is_compatible && std::is_class_v<std::remove_pointer_t<T>>) {
+            *orig_arg.get_pointer() = to_guest(*data.data); // TODO: Only if annotated as out-parameter
+          }
+        }
+      }
+    }
+  }
+
+  operator ActualT() {
+    return data.get();
+  }
+};
+
+template<typename T, ParameterAnnotations Annotation>
+constexpr bool IsCompatible() {
+  if constexpr (Annotation.is_opaque) {
+    return true;
+  } else if constexpr (has_compatible_data_layout<T>) {
+    return true;
+  } else {
+    if constexpr (std::is_pointer_v<T>) {
+      return has_compatible_data_layout<std::remove_cv_t<std::remove_pointer_t<T>>>;
+    } else {
+      return false;
+    }
+  }
+}
+
+template<ParameterAnnotations Annotation, typename HostT, typename T>
+auto Projection(guest_layout<T>& data) {
+  constexpr bool is_compatible = IsCompatible<T, Annotation>() && std::is_same_v<T, HostT>;
+  if constexpr (Annotation.is_passthrough) {
+    return data;
+  } else if constexpr (is_compatible || !std::is_pointer_v<T>) {
+    return host_layout<HostT> { data }.data;
+  } else {
+    // This argument requires temporary storage for repacked data
+    // *and* it needs to call custom repack functions (if any)
+    return unpacked_arg_wrapper<HostT, T> { data };
+  }
+}
+
 template<typename Result, typename... Args>
 struct CallbackUnpack<Result(Args...)> {
   static Result CallGuestPtr(Args... args) {
@@ -396,15 +535,6 @@ struct CallbackUnpack<Result(Args...)> {
   }
 };
 
-template<ParameterAnnotations Annotation, typename T>
-auto Projection(guest_layout<T>& data) {
-  if constexpr (Annotation.is_passthrough) {
-    return data;
-  } else {
-    return host_layout<T> { data }.data;
-  }
-}
-
 template<typename>
 struct GuestWrapperForHostFunction;
 

From f6796a4234e8b5510298c373418c9f196b66f86b Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Tue, 15 Aug 2023 20:39:19 +0200
Subject: [PATCH 27/48] Thunks: Handle type differences for Guest->Host calls
 through function pointers

---
 ThunkLibs/Generator/gen.cpp       | 20 +++++++++++++++++---
 ThunkLibs/include/common/Host.h   | 16 +++++++++-------
 unittests/ThunkLibs/generator.cpp |  2 +-
 3 files changed, 27 insertions(+), 11 deletions(-)

diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index 33c4558d5f..f7c63d1dc2 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -660,10 +660,22 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
         }
 
         // Endpoints for Guest->Host invocation of runtime host-function pointers
+        // NOTE: The function parameters may differ slightly between guest and host,
+        //       e.g. due to differing sizes or due to data layout differences.
+        //       Hence, two separate parameter lists are managed here.
         for (auto& host_funcptr_entry : funcptr_types) {
             auto& [type, param_annotations] = host_funcptr_entry.second;
+            auto func_type = type->getAs<clang::FunctionProtoType>();
             std::string mangled_name = clang::QualType { type, 0 }.getAsString();
-            auto info = LookupGuestFuncPtrInfo(host_funcptr_entry.first.c_str());
+            FuncPtrInfo info = { };
+
+            info.result = func_type->getReturnType().getAsString();
+            info.param_annotations = param_annotations;
+
+            // TODO: Respect param_annotations
+            for (auto arg : func_type->getParamTypes()) {
+                info.args.push_back(arg.getAsString());
+            }
 
             std::string annotations;
             for (int param_idx = 0; param_idx < info.args.size(); ++param_idx) {
@@ -682,8 +694,10 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                 }
                 annotations += "}";
             }
-            fmt::print( file, "  {{(uint8_t*)\"\\x{:02x}\", (void(*)(void *))&GuestWrapperForHostFunction<{}({})>::Call<{}>}}, // {}\n",
-                        fmt::join(info.sha256, "\\x"), info.result, fmt::join(info.args, ", "), annotations, host_funcptr_entry.first);
+            auto guest_info = LookupGuestFuncPtrInfo(host_funcptr_entry.first.c_str());
+            // TODO: Consider differences in guest/host return types
+            fmt::print( file, "  {{(uint8_t*)\"\\x{:02x}\", (void(*)(void *))&GuestWrapperForHostFunction<{}({}){}{}>::Call<{}>}}, // {}\n",
+                        fmt::join(guest_info.sha256, "\\x"), guest_info.result, fmt::join(info.args, ", "), guest_info.args.empty() ? "" : ", ", fmt::join(guest_info.args, ", "), annotations, host_funcptr_entry.first);
         }
 
         file << "  { nullptr, nullptr }\n";
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index d29486067f..a9d1f93937 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -535,18 +535,20 @@ struct CallbackUnpack<Result(Args...)> {
   }
 };
 
-template<typename>
+template<typename, typename...>
 struct GuestWrapperForHostFunction;
 
-template<typename Result, typename... Args>
-struct GuestWrapperForHostFunction<Result(Args...)> {
+template<typename Result, typename... Args, typename... GuestArgs>
+struct GuestWrapperForHostFunction<Result(Args...), GuestArgs...> {
   // Host functions called from Guest
+  // NOTE: GuestArgs typically matches up with Args, however there may be exceptions (e.g. size_t)
   template<ParameterAnnotations... Annotations>
   static void Call(void* argsv) {
     static_assert(sizeof...(Annotations) == sizeof...(Args));
+    static_assert(sizeof...(GuestArgs) == sizeof...(Args));
 
-    auto args = reinterpret_cast<PackedArguments<Result, guest_layout<Args>..., uintptr_t>*>(argsv);
-    constexpr auto CBIndex = sizeof...(Args);
+    auto args = reinterpret_cast<PackedArguments<Result, guest_layout<GuestArgs>..., uintptr_t>*>(argsv);
+    constexpr auto CBIndex = sizeof...(GuestArgs);
     uintptr_t cb;
     static_assert(CBIndex <= 18 || CBIndex == 23);
     if constexpr(CBIndex == 0) {
@@ -593,9 +595,9 @@ struct GuestWrapperForHostFunction<Result(Args...)> {
 
     // This is almost the same type as "Result func(Args..., uintptr_t)", but
     // individual parameters annotated as passthrough are replaced by guest_layout<GuestArgs>
-    auto callback = reinterpret_cast<Result(*)(std::conditional_t<Annotations.is_passthrough, guest_layout<Args>, Args>..., uintptr_t)>(cb);
+    auto callback = reinterpret_cast<Result(*)(std::conditional_t<Annotations.is_passthrough, guest_layout<GuestArgs>, Args>..., uintptr_t)>(cb);
 
-    auto f = [&callback](guest_layout<Args>... args, uintptr_t target) -> Result {
+    auto f = [&callback](guest_layout<GuestArgs>... args, uintptr_t target) -> Result {
       // Fold over each of Annotations, Args, and args. This will match up the elements in triplets.
       return callback(Projection<Annotations, Args>(args)..., target);
     };
diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index 651a723f42..3726538bce 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -274,7 +274,7 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
         "  uintptr_t GuestTarget;\n"
         "};\n"
         "struct ParameterAnnotations {};\n"
-        "template<typename>\n"
+        "template<typename, typename...>\n"
         "struct GuestWrapperForHostFunction {\n"
         "  template<ParameterAnnotations...> static void Call(void*);\n"
         "};\n"

From af5d765d69be5acb8089a3f9c38642e981183cc6 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Tue, 22 Aug 2023 11:40:36 +0200
Subject: [PATCH 28/48] Thunks/gen: Implement assisted struct repacking

This can be used to allow automatically handling structures that require
special behavior for one member but are automatically repackable otherwise.
The feature is enabled using the new custom_repack annotation and requires
additional repacking functions to be defined in the host file for each
customized member.
---
 ThunkLibs/Generator/analysis.cpp    | 39 ++++++++++---
 ThunkLibs/Generator/analysis.h      | 10 ++++
 ThunkLibs/Generator/data_layout.cpp |  4 +-
 ThunkLibs/Generator/gen.cpp         | 89 +++++++++++++++++++++++++++--
 ThunkLibs/include/common/Host.h     | 16 ++++++
 unittests/ThunkLibs/abi.cpp         | 86 ++++++++++++++++++++++++++++
 unittests/ThunkLibs/generator.cpp   |  7 +++
 7 files changed, 237 insertions(+), 14 deletions(-)

diff --git a/ThunkLibs/Generator/analysis.cpp b/ThunkLibs/Generator/analysis.cpp
index a103dec094..c25920810c 100644
--- a/ThunkLibs/Generator/analysis.cpp
+++ b/ThunkLibs/Generator/analysis.cpp
@@ -302,6 +302,24 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
 
                 if (auto emitted_function = llvm::dyn_cast<clang::FunctionDecl>(template_args[0].getAsDecl())) {
                     // Process later
+                } else if (auto annotated_member = llvm::dyn_cast<clang::FieldDecl>(template_args[0].getAsDecl())) {
+                    {
+                        if (decl->getNumBases() != 1 || decl->bases_begin()->getType().getAsString() != "fexgen::custom_repack") {
+                            throw report_error(template_arg_loc, "Unsupported member annotation(s)");
+                        }
+                        // TODO: Check for fexgen::custom_repack annotation
+                        if (!annotated_member->getType()->isPointerType() && !annotated_member->getType()->isArrayType()) {
+                            throw report_error(template_arg_loc, "custom_repack annotation requires pointer member");
+                        }
+                    }
+
+                    // Get or add parent type to list of structure types
+                    auto repack_info_it = types.emplace(context.getCanonicalType(annotated_member->getParent()->getTypeForDecl()), RepackedType {}).first;
+                    if (repack_info_it->second.is_opaque) {
+                        throw report_error(template_arg_loc, "May not annotate members of opaque types");
+                    }
+                    // Add member to its list of members
+                    repack_info_it->second.custom_repacked_members.insert(annotated_member->getNameAsString());
                 } else {
                     throw report_error(template_arg_loc, "Cannot annotate this kind of symbol");
                 }
@@ -358,14 +376,17 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
                             }
 
                             for (auto* member : type->getAsStructureType()->getDecl()->fields()) {
-                                  /*if (!member->getType()->isPointerType())*/ {
-                                      // TODO: Perform more elaborate validation for non-pointers to ensure ABI compatibility
-                                      continue;
-                                  }
-
-                                  throw report_error(member->getBeginLoc(), "Unannotated pointer member")
-                                        .addNote(report_error(param_loc, "in struct type", clang::DiagnosticsEngine::Note))
-                                        .addNote(report_error(template_arg_loc, "used in annotation here", clang::DiagnosticsEngine::Note));
+                                auto annotated_type = types.find(type->getCanonicalTypeUnqualified().getTypePtr());
+                                if (annotated_type == types.end() || !annotated_type->second.UsesCustomRepackFor(member)) {
+                                    /*if (!member->getType()->isPointerType())*/ {
+                                        // TODO: Perform more elaborate validation for non-pointers to ensure ABI compatibility
+                                        continue;
+                                    }
+
+                                    throw report_error(member->getBeginLoc(), "Unannotated pointer member")
+                                          .addNote(report_error(param_loc, "in struct type", clang::DiagnosticsEngine::Note))
+                                          .addNote(report_error(template_arg_loc, "used in annotation here", clang::DiagnosticsEngine::Note));
+                                }
                             }
                         };
 
@@ -526,7 +547,7 @@ void AnalysisAction::CoverReferencedTypes(clang::ASTContext& context) {
                     }
                     continue;
                 }
-                if (member_type->isUnionType() && !types.contains(member_type)) {
+                if (member_type->isUnionType() && !types.contains(member_type) && !type_repack_info.UsesCustomRepackFor(member)) {
                     throw std::runtime_error(fmt::format("\"{}\" has unannotated member \"{}\" of union type \"{}\"",
                                                          clang::QualType { type, 0 }.getAsString(),
                                                          member->getNameAsString(),
diff --git a/ThunkLibs/Generator/analysis.h b/ThunkLibs/Generator/analysis.h
index 110e252955..b2651104b2 100644
--- a/ThunkLibs/Generator/analysis.h
+++ b/ThunkLibs/Generator/analysis.h
@@ -138,6 +138,16 @@ class AnalysisAction : public clang::ASTFrontendAction {
     struct RepackedType {
         bool is_opaque = false; // opaque or assumed_compatible (TODO: Rename to the latter)
         bool pointers_only = is_opaque; // if true, only pointers to this type may be used
+
+        // Set of members (identified by their field name) with custom repacking
+        std::unordered_set<std::string> custom_repacked_members;
+
+        bool UsesCustomRepackFor(const clang::FieldDecl* member) const {
+            return custom_repacked_members.contains(member->getNameAsString());
+        }
+        bool UsesCustomRepackFor(const std::string& member_name) const {
+            return custom_repacked_members.contains(member_name);
+        }
     };
 
     std::unordered_map<const clang::Type*, RepackedType> types;
diff --git a/ThunkLibs/Generator/data_layout.cpp b/ThunkLibs/Generator/data_layout.cpp
index bb5d05b8aa..fc45267a21 100644
--- a/ThunkLibs/Generator/data_layout.cpp
+++ b/ThunkLibs/Generator/data_layout.cpp
@@ -269,7 +269,9 @@ TypeCompatibility DataLayoutCompareAction::GetTypeCompatibility(
                 // * Pointer member is annotated
                 // TODO: Don't restrict this to structure types. it applies to pointers to builtin types too!
                 auto host_member_pointee_type = context.getCanonicalType(host_member_type->getPointeeType().getTypePtr());
-                if (types.contains(host_member_pointee_type) && types.at(host_member_pointee_type).is_opaque) {
+                if (type_repack_info.UsesCustomRepackFor(host_member_field)) {
+                    member_compat.push_back(TypeCompatibility::Repackable);
+                } else if (types.contains(host_member_pointee_type) && types.at(host_member_pointee_type).is_opaque) {
                     // Pointee doesn't need repacking, but pointer needs extending on 32-bit
                     member_compat.push_back(is_32bit ? TypeCompatibility::Repackable : TypeCompatibility::Full);
                 } else if (host_member_pointee_type->isPointerType()) {
diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index f7c63d1dc2..77d07e28bc 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -337,6 +337,12 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
 
     // TODO: Move to dedicated function
     {
+        fmt::print(file, "template<auto PMD>\n");
+        fmt::print(file, "static inline void fex_custom_repack(host_layout<typename pmd_traits<decltype(PMD)>::parent_t>& into, const guest_layout<typename pmd_traits<decltype(PMD)>::parent_t>& from);\n");
+
+        fmt::print(file, "template<auto PMD>\n");
+        fmt::print(file, "static inline void fex_custom_repack_postcall(const typename pmd_traits<decltype(PMD)>::member_t& from);\n\n");
+
         // Sort struct types by dependency so that repacking code is emitted in an order that compiles file
         auto& types2 = types;
         std::vector<std::pair<const clang::Type*, RepackedType>> types { types2.begin(), types2.end() };
@@ -423,11 +429,19 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                 };
                 // Prefer initialization via the constructor's initializer list if possible (to detect unintended narrowing), otherwise initialize in the body
                 for (auto* member : type->getAsStructureType()->getDecl()->fields()) {
-                    map_field(member, true);
+                    if (!type_repack_info.UsesCustomRepackFor(member)) {
+                        map_field(member, true);
+                    } else {
+                      // Leave field uninitialized
+                    }
                 }
                 fmt::print(file, "    }} {{\n");
                 for (auto* member : type->getAsStructureType()->getDecl()->fields()) {
-                    map_field(member, false);
+                    if (!type_repack_info.UsesCustomRepackFor(member)) {
+                        map_field(member, false);
+                    } else {
+                      // Leave field uninitialized
+                    }
                 }
             }
             fmt::print(file, "  }}\n");
@@ -457,16 +471,49 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
 
                 // Prefer initialization via the constructor's initializer list if possible (to detect unintended narrowing), otherwise initialize in the body
                 for (auto& member : abi.at(struct_name).get_if_struct()->members) {
-                    map_field2(member, true);
+                    if (!type_repack_info.UsesCustomRepackFor(member.member_name)) {
+                        map_field2(member, true);
+                    } else {
+                      // Leave field uninitialized
+                    }
                 }
                 fmt::print(file, "  }} }};\n");
                 for (auto& member : abi.at(struct_name).get_if_struct()->members) {
-                    map_field2(member, false);
+                    if (!type_repack_info.UsesCustomRepackFor(member.member_name)) {
+                        map_field2(member, false);
+                    } else {
+                      // Leave field uninitialized
+                    }
                 }
             }
             fmt::print(file, "  return ret;\n");
             fmt::print(file, "}}\n\n");
 
+            // Forward-declare user-provided repacking functions
+            for (const auto& member_name : type_repack_info.custom_repacked_members) {
+                fmt::print(file, "template<>\n");
+                fmt::print(file, "void fex_custom_repack<&{}::{}>(host_layout<{}>& into, const guest_layout<{}>& from);\n",
+                           struct_name, member_name, struct_name, struct_name);
+                fmt::print(file, "template<>\n");
+                // TODO: Consider adapting the fex_custom_repack interface changes to this function, too
+                fmt::print(file, "void fex_custom_repack_postcall<&{}::{}>(const typename pmd_traits<decltype(&{}::{})>::member_t& from);\n\n",
+                           struct_name, member_name, struct_name, member_name);
+            }
+
+            // TODO: Generate wrappers to call all custom repack functions for children
+            fmt::print(file, "void fex_apply_custom_repacking(host_layout<{}>& source, const guest_layout<{}>& from) {{\n", struct_name, struct_name);
+            for (const auto& member_name : type_repack_info.custom_repacked_members) {
+                fmt::print(file, "  fex_custom_repack<&{}::{}>(source, from);\n",
+                           /*member_name, */struct_name, member_name);
+            }
+            fmt::print(file, "}}\n");
+            fmt::print(file, "void fex_apply_custom_repacking_postcall(host_layout<{}>& source) {{\n", struct_name);
+            for (const auto& member_name : type_repack_info.custom_repacked_members) {
+                fmt::print(file, "  fex_custom_repack_postcall<&{}::{}>(source.data.{});\n",
+                           struct_name, member_name, member_name);
+            }
+            fmt::print(file, "}}\n");
+
             if (type_compat.at(type) == TypeCompatibility::Full) {
                 fmt::print(file, "template<> inline constexpr bool has_compatible_data_layout<{}> = true;\n", struct_name);
             }
@@ -588,6 +635,7 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                     continue;
                 }
 
+                // Layout repacking happens here
                 if (!param_type->isPointerType() || (is_opaque || pointee_compat == TypeCompatibility::Full) ||
                     param_type->getPointeeType()->isBuiltinType() /* TODO: handle size_t. Actually, properly check for data layout compatibility */) {
                     // Fully compatible
@@ -599,6 +647,14 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                 } else {
                     throw report_error(thunk.decl->getLocation(), "Cannot generate unpacking function for function %0 with unannotated pointer parameter %1").AddString(function_name).AddTaggedVal(param_type);
                 }
+
+                // Custom repacking happens here
+                if (param_type->isPointerType() && param_type->getPointeeType()->isStructureType() &&
+                    !is_opaque && pointee_compat != TypeCompatibility::Full) {
+                    fmt::print(file, "  if (args->a_{}.get_pointer()) {{\n", param_idx);
+                    fmt::print(file, "    fex_apply_custom_repacking(*a_{}.data, *args->a_{}.get_pointer());\n", param_idx, param_idx);
+                    fmt::print(file, "  }}\n");
+                }
             }
 
             if (!thunk.return_type->isVoidType()) {
@@ -646,6 +702,31 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
             }
             fmt::print(file, ");\n");
 
+            for (unsigned param_idx = 0; param_idx != thunk.param_types.size(); ++param_idx) {
+                if (thunk.callbacks.contains(param_idx) && thunk.callbacks.at(param_idx).is_stub) {
+                    continue;
+                }
+
+                auto& param_type = thunk.param_types[param_idx];
+
+                const bool is_compatible = param_type->isPointerType() && type_compat.at(context.getCanonicalType(param_type->getPointeeType().getTypePtr())) == TypeCompatibility::Full;
+
+                if (thunk.param_annotations[param_idx].is_passthrough) {
+                    // args are passed directly to function, no need to use `unpacked` wrappers
+                    continue;
+                }
+
+                if (param_type->isPointerType() && param_type->getPointeeType()->isStructureType() &&
+                      !is_compatible &&
+                      !LookupType(context, param_type->getPointeeType()->getLocallyUnqualifiedSingleStepDesugaredType().getTypePtr()).is_opaque &&
+                      !param_type->getPointeeType().isConstQualified()) {
+                    fmt::print(file, "  if (a_{}.data) {{\n", param_idx);
+                    fmt::print(file, "    *args->a_{}.get_pointer() = to_guest(*a_{}.data);\n", param_idx, param_idx); // TODO: Only if annotated as out-parameter
+                    fmt::print(file, "    fex_apply_custom_repacking_postcall(*a_{}.data);\n", param_idx);
+                    fmt::print(file, "  }}\n");
+                }
+            }
+
             file << "}\n";
         }
         file << "}\n";
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index a9d1f93937..603f9d6273 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -457,6 +457,15 @@ inline guest_layout<T*> to_guest(const host_layout<T*>& from) {
 template<typename>
 struct CallbackUnpack;
 
+// Helper to extract information from a pointer-to-member (e.g. &MyClass::data_member)
+template<typename>
+struct pmd_traits;
+template<typename Parent, typename Data>
+struct pmd_traits<Data Parent::*> {
+    using parent_t = Parent;
+    using member_t = Data;
+};
+
 // Wrapper around unpacked_arg (for on-stack repacked argument structs) that implicitly converts to the represented type
 template<typename T, typename GuestT>
 struct unpacked_arg_wrapper {
@@ -469,6 +478,12 @@ struct unpacked_arg_wrapper {
   guest_layout<T>& orig_arg;
 
   unpacked_arg_wrapper(guest_layout<GuestT>& orig_arg_) : data(orig_arg_), orig_arg(orig_arg_) {
+    if (data.data && !std::is_enum_v<T>) {
+      constexpr bool is_compatible = has_compatible_data_layout<T> && std::is_same_v<T, GuestT>;
+      if constexpr (!is_compatible && std::is_class_v<std::remove_pointer_t<T>>) {
+        fex_apply_custom_repacking(*data.data, *orig_arg_.get_pointer());
+      }
+    }
   }
 
   ~unpacked_arg_wrapper() {
@@ -479,6 +494,7 @@ struct unpacked_arg_wrapper {
           constexpr bool is_compatible = has_compatible_data_layout<T> && std::is_same_v<T, GuestT>;
           if constexpr (!is_compatible && std::is_class_v<std::remove_pointer_t<T>>) {
             *orig_arg.get_pointer() = to_guest(*data.data); // TODO: Only if annotated as out-parameter
+            fex_apply_custom_repacking_postcall(*data.data);
           }
         }
       }
diff --git a/unittests/ThunkLibs/abi.cpp b/unittests/ThunkLibs/abi.cpp
index 302d8ef9e1..8ecb843af5 100644
--- a/unittests/ThunkLibs/abi.cpp
+++ b/unittests/ThunkLibs/abi.cpp
@@ -592,6 +592,31 @@ TEST_CASE_METHOD(Fixture, "DataLayoutPointers") {
             CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::None);
             CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::None);
         }
+
+        SECTION("Innermost struct is incompatible but the pointer member is annotated") {
+            auto action = compute_data_layout(
+                "#include <thunks_common.h>\n"
+                "#include <cstdint>\n",
+                "#ifdef HOST\n"
+                "struct C { int32_t a; int32_t b; };\n"
+                "#else\n"
+                "struct C { int32_t b; int32_t a; };\n"
+                "#endif\n"
+                "struct B { C* a; int16_t b; };\n"
+                "struct A { int32_t a; B b; };\n"
+                "template<> struct fex_gen_config<&B::a> : fexgen::custom_repack {};\n"
+                "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+            INFO(FormatDataLayout(action->host_layout));
+
+            REQUIRE(action->guest_layout->contains("A"));
+            REQUIRE(action->guest_layout->contains("B"));
+            REQUIRE(action->guest_layout->contains("C"));
+
+            CHECK(action->GetTypeCompatibility("struct C") == TypeCompatibility::Repackable);
+            CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::Repackable);
+            CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Repackable);
+        }
     }
 
     SECTION("Unannotated pointer to union type") {
@@ -619,6 +644,21 @@ TEST_CASE_METHOD(Fixture, "DataLayoutPointers") {
         CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
     }
 
+    SECTION("Pointer to union type with custom_repack annotation") {
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "union B { int32_t a; uint32_t b; };\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_config<&A::a> : fexgen::custom_repack {};\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Repackable);
+    }
+
     SECTION("Pointer to opaque type") {
         auto action = compute_data_layout(
             "#include <thunks_common.h>\n"
@@ -634,6 +674,52 @@ TEST_CASE_METHOD(Fixture, "DataLayoutPointers") {
         CHECK(action->GetTypeCompatibility("struct A") == compat_full64_repackable32);
     }
 
+    SECTION("Pointer member with custom repacking code") {
+        // Data layout analysis only needs to know about the custom_repack
+        // annotation. The actual custom repacking code isn't needed for the
+        // test.
+
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "#ifdef HOST\n"
+            "struct B { int32_t a; };\n"
+            "#else\n"
+            "struct B { int32_t b; };\n"
+            "#endif\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_config<&A::a> : fexgen::custom_repack {};\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        REQUIRE(action->guest_layout->contains("B"));
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Repackable);
+        CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::None);
+    }
+
+    SECTION("Custom repacking induces repacking requirement") {
+        // Data layout analysis only needs to know about the custom_repack
+        // annotation. The actual custom repacking code isn't needed for the
+        // test.
+
+        auto action = compute_data_layout(
+            "#include <thunks_common.h>\n"
+            "#include <cstdint>\n",
+            "struct B {};\n"
+            "struct A { B* a; };\n"
+            "template<> struct fex_gen_config<&A::a> : fexgen::custom_repack {};\n"
+            "template<> struct fex_gen_type<A> {};\n", guest_abi);
+
+        INFO(FormatDataLayout(action->host_layout));
+
+        REQUIRE(action->guest_layout->contains("A"));
+        REQUIRE(action->guest_layout->contains("B"));
+        CHECK(action->GetTypeCompatibility("struct B") == TypeCompatibility::Full);
+        CHECK(action->GetTypeCompatibility("struct A") == TypeCompatibility::Repackable);
+    }
+
     SECTION("Self-referencing struct (like VkBaseOutStructure)") {
         // Without annotation
         auto action = compute_data_layout(
diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index 3726538bce..4fc97c7d9b 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -280,6 +280,13 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
         "};\n"
         "struct ExportEntry { uint8_t* sha256; void(*fn)(void *); };\n"
         "void *dlsym_default(void* handle, const char* symbol);\n"
+        "template<typename>\n"
+        "struct pmd_traits;\n"
+        "template<typename Parent, typename Data>\n"
+        "struct pmd_traits<Data Parent::*> {\n"
+        "    using parent_t = Parent;\n"
+        "    using member_t = Data;\n"
+        "};\n"
         "template<typename T> inline constexpr bool has_compatible_data_layout = std::is_integral_v<T> || std::is_enum_v<T>;\n"
         "template<typename T>\n"
         "struct guest_layout {\n"

From c4900fde964909d2b940b6b2d058a189e1b53887 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Tue, 22 Aug 2023 11:20:44 +0200
Subject: [PATCH 29/48] TODOSQUASH. Add unwrap_host helper

---
 ThunkLibs/Generator/gen.cpp       |  5 ++---
 ThunkLibs/include/common/Host.h   | 10 ++++++++++
 unittests/ThunkLibs/generator.cpp |  3 ++-
 3 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index 77d07e28bc..395c9640d3 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -666,8 +666,6 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
             fmt::print(file, "{}(", function_to_call);
             {
                 auto format_param = [&](std::size_t idx) {
-                    std::string raw_arg = fmt::format("a_{}.data", idx);
-
                     auto cb = thunk.callbacks.find(idx);
                     if (cb != thunk.callbacks.end() && cb->second.is_stub) {
                         return "fexfn_unpack_" + get_callback_name(function_name, cb->first) + "_stub";
@@ -691,7 +689,8 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                         // Pass raw guest_layout<T*>
                         return fmt::format("args->a_{}", idx);
                     } else {
-                        return raw_arg;
+                        // Unwrap host_layout/unpacked_arg_with_storage layer
+                        return fmt::format("unwrap_host(a_{})", idx);
                     }
                 };
 
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index 603f9d6273..042ebc259b 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -434,6 +434,16 @@ struct unpacked_arg_with_storage<char*> {
   uint64_t data;
 };
 
+template<typename T>
+T& unwrap_host(host_layout<T>& val) {
+  return val.data;
+}
+
+template<typename T>
+T* unwrap_host(unpacked_arg_base<T*>& val) {
+  return val.get();
+}
+
 template<typename T>
 inline guest_layout<T> to_guest(const host_layout<T>& from) requires(!std::is_pointer_v<T>) {
   if constexpr (std::is_enum_v<T>) {
diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index 4fc97c7d9b..ea0bcd480d 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -311,7 +311,8 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
         "};\n"
         "\n"
         "template<typename F> void FinalizeHostTrampolineForGuestFunction(F*);\n"
-        "template<typename F> void FinalizeHostTrampolineForGuestFunction(const guest_layout<F*>&);\n";
+        "template<typename F> void FinalizeHostTrampolineForGuestFunction(const guest_layout<F*>&);\n"
+        "template<typename T> T& unwrap_host(host_layout<T>&);\n";
 
     auto& filename = output_filenames.host;
     {

From cea56ebe0714fe424d3d4196d0fad65bdbaf09fe Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Tue, 22 Aug 2023 15:56:22 +0200
Subject: [PATCH 30/48] TODOSQUASH. Fix things that turned up during testing

---
 unittests/ThunkLibs/generator.cpp | 127 +++++++++++++++++++++++++++++-
 1 file changed, 124 insertions(+), 3 deletions(-)

diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index ea0bcd480d..cd67d53212 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -273,7 +273,10 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
         "  uintptr_t GuestUnpacker;\n"
         "  uintptr_t GuestTarget;\n"
         "};\n"
-        "struct ParameterAnnotations {};\n"
+        "struct ParameterAnnotations {\n"
+        "    bool is_passthrough = false;\n"
+        "    bool is_opaque = false;\n"
+        "};\n"
         "template<typename, typename...>\n"
         "struct GuestWrapperForHostFunction {\n"
         "  template<ParameterAnnotations...> static void Call(void*);\n"
@@ -290,10 +293,25 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
         "template<typename T> inline constexpr bool has_compatible_data_layout = std::is_integral_v<T> || std::is_enum_v<T>;\n"
         "template<typename T>\n"
         "struct guest_layout {\n"
-        "  T data;\n"
+        "  static_assert(!std::is_class_v<T>, \"No guest layout defined for this non-opaque struct type. This may be a bug in the thunk generator.\");\n"
+        "  static_assert(!std::is_union_v<T>, \"No guest layout defined for this non-opaque union type. This may be a bug in the thunk generator.\");\n"
+        "\n"
+        "  using type = std::enable_if_t<!std::is_pointer_v<T>, T>;\n"
+        "  type data;\n"
+        "\n"
+        "  guest_layout& operator=(const T from);\n"
+        "};\n"
+        "\n"
+        "template<typename T, std::size_t N>\n"
+        "struct guest_layout<T[N]> {\n"
+        "  using type = std::enable_if_t<!std::is_pointer_v<T>, T>;\n"
+        "  std::array<guest_layout<type>, N> data;\n"
         "};\n"
         "\n"
         "template<typename T>\n"
+        "struct host_layout;\n"
+        "\n"
+        "template<typename T>\n"
         "struct guest_layout<T*> {\n"
         "#ifdef IS_32BIT_THUNK\n"
         "  using type = uint32_t;\n"
@@ -301,6 +319,25 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
         "  using type = uint64_t;\n"
         "#endif\n"
         "  type data;\n"
+        "\n"
+        "  guest_layout& operator=(const T* from);\n"
+        "  guest_layout<T>* get_pointer();\n"
+        "  const guest_layout<T>* get_pointer() const;\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
+        "struct guest_layout<T* const> {\n"
+        "#ifdef IS_32BIT_THUNK\n"
+        "  using type = uint32_t;\n"
+        "#else\n"
+        "  using type = uint64_t;\n"
+        "#endif\n"
+        "  type data;\n"
+        "\n"
+        "  guest_layout& operator=(const T* from);\n"
+        "\n"
+        "  guest_layout<T>* get_pointer();\n"
+        "  const guest_layout<T>* get_pointer() const;\n"
         "};\n"
         "\n"
         "template<typename T>\n"
@@ -310,9 +347,93 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
         "  host_layout(const guest_layout<T>& from);\n"
         "};\n"
         "\n"
+        "// Specialization for size_t, which is 64-bit on 64-bit but 32-bit on 32-bit\n"
+        "template<>\n"
+        "struct host_layout<size_t> {\n"
+        "  size_t data;\n"
+        "\n"
+        "  host_layout(const guest_layout<uint32_t>& from);\n"
+        "  host_layout(const guest_layout<size_t>& from);\n"
+        "};\n"
+        "\n"
+        "template<typename T, size_t N>\n"
+        "struct host_layout<T[N]> {\n"
+        "  std::array<T, N> data;\n"
+        "  host_layout(const guest_layout<T[N]>& from);\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
+        "struct host_layout<T*> {\n"
+        "  T* data;\n"
+        "\n"
+        "  static_assert(!std::is_function_v<T>, \"Function types must be handled separately\");\n"
+        "\n"
+        "  host_layout(const guest_layout<T*>& from);\n"
+        "\n"
+        "  host_layout() = default;\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
+        "struct host_layout<T* const> {\n"
+        "  T* data;\n"
+        "\n"
+        "  static_assert(!std::is_function_v<T>, \"Function types must be handled separately\");\n"
+        "\n"
+        "  // Assume underlying data is compatible and just convert the guest-sized pointer to 64-bit\n"
+        "  host_layout(const guest_layout<T* const>& from);\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
+        "struct unpacked_arg {\n"
+        "  using type = std::enable_if_t<!std::is_pointer_v<T>, T>;\n"
+        "  host_layout<type> data;\n"
+        "  type get();\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
+        "struct unpacked_arg<T*> {\n"
+        "  unpacked_arg(const guest_layout<T*>&);\n"
+        "  unpacked_arg(const guest_layout<const T*>&);\n"
+        "\n"
+        "  T* get();\n"
+        "  host_layout<T*> data;\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
+        "struct unpacked_arg_base;\n"
+        "template<typename T>\n"
+        "struct unpacked_arg_base<T*> {\n"
+        "  unpacked_arg_base(host_layout<T>*);\n"
+        "  unpacked_arg_base(host_layout<const T>*);\n"
+        "\n"
+        "  T* get();\n"
+        "  host_layout<T>* data;\n"
+        "};\n"
+        "\n"
+        "template<typename T>\n"
+        "struct unpacked_arg_with_storage;\n"
+        "template<typename T>\n"
+        "struct unpacked_arg_with_storage<T*> : unpacked_arg_base<T*> {\n"
+        "  unpacked_arg_with_storage(const guest_layout<T*>&);\n"
+        "  unpacked_arg_with_storage(const guest_layout<const T*>&);\n"
+        "};\n"
+        "template<>\n"
+        "struct unpacked_arg_with_storage<char*> {\n"
+        "  using type = char*;\n"
+        "\n"
+        "  unpacked_arg_with_storage(guest_layout<const char*>& data);\n"
+        "  unpacked_arg_with_storage(guest_layout<char*>& data);\n"
+        "\n"
+        "  type get();\n"
+        "  uint64_t data;\n"
+        "};\n"
+        "\n"
+        "template<typename T> guest_layout<T> to_guest(const host_layout<T>& from) requires(!std::is_pointer_v<T>);\n"
+        "template<typename T> guest_layout<T*> to_guest(const host_layout<T*>& from);\n"
         "template<typename F> void FinalizeHostTrampolineForGuestFunction(F*);\n"
         "template<typename F> void FinalizeHostTrampolineForGuestFunction(const guest_layout<F*>&);\n"
-        "template<typename T> T& unwrap_host(host_layout<T>&);\n";
+        "template<typename T> T& unwrap_host(host_layout<T>&);\n"
+        "template<typename T> T* unwrap_host(unpacked_arg_base<T*>&);\n";
 
     auto& filename = output_filenames.host;
     {

From 1b3cea416b587d14b024a6064fd3b5476a6688fc Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Wed, 23 Aug 2023 17:05:31 +0200
Subject: [PATCH 31/48] TODOSQUASH: unittests: Clean up automatic struct
 repacking tests

---
 ThunkLibs/libfex_thunk_test/api.h             | 21 +++++++++++++++
 ThunkLibs/libfex_thunk_test/lib.cpp           | 17 ++++++++++++
 .../libfex_thunk_test_interface.cpp           |  7 +++++
 .../tests/thunks/thunk_testlib.cpp            | 26 +++++++++++++++++++
 4 files changed, 71 insertions(+)

diff --git a/ThunkLibs/libfex_thunk_test/api.h b/ThunkLibs/libfex_thunk_test/api.h
index 293ba29451..e86d49fdcf 100644
--- a/ThunkLibs/libfex_thunk_test/api.h
+++ b/ThunkLibs/libfex_thunk_test/api.h
@@ -10,4 +10,25 @@ extern "C" {
 
 uint32_t GetDoubledValue(uint32_t);
 
+
+/// Interfaces used to test automatic struct repacking
+
+// A simple struct with data layout that differs between guest and host.
+// The thunk generator should emit code that swaps the member data into
+// correct position.
+struct ReorderingType {
+#if defined(__aarch64__) || defined(_M_ARM64) // TODO: Use proper host check
+    uint32_t a;
+    uint32_t b;
+#else
+    uint32_t b;
+    uint32_t a;
+#endif
+};
+
+ReorderingType MakeReorderingType(uint32_t a, uint32_t b);
+uint32_t GetReorderingTypeMember(ReorderingType*, int index);
+void ModifyReorderingTypeMembers(ReorderingType* data);
+uint32_t QueryOffsetOf(ReorderingType*, int index);
+
 }
diff --git a/ThunkLibs/libfex_thunk_test/lib.cpp b/ThunkLibs/libfex_thunk_test/lib.cpp
index 2e6354b8e1..3e09d370cd 100644
--- a/ThunkLibs/libfex_thunk_test/lib.cpp
+++ b/ThunkLibs/libfex_thunk_test/lib.cpp
@@ -6,4 +6,21 @@ uint32_t GetDoubledValue(uint32_t input) {
   return 2 * input;
 }
 
+ReorderingType MakeReorderingType(uint32_t a, uint32_t b) {
+  return ReorderingType { .a = a, .b = b };
+}
+
+uint32_t GetReorderingTypeMember(ReorderingType* data, int index) {
+  if (index == 0) {
+    return data->a;
+  } else {
+    return data->b;
+  }
+}
+
+void ModifyReorderingTypeMembers(ReorderingType* data) {
+  data->a += 1;
+  data->b += 2;
+}
+
 } // extern "C"
diff --git a/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp b/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
index 7fedaa415d..c60eaf77e2 100644
--- a/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
+++ b/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
@@ -12,3 +12,10 @@ template<auto, int, typename>
 struct fex_gen_param {};
 
 template<> struct fex_gen_config<GetDoubledValue> {};
+
+template<> struct fex_gen_config<MakeReorderingType> {};
+template<> struct fex_gen_config<GetReorderingTypeMember> {};
+template<> struct fex_gen_config<ModifyReorderingTypeMembers> {};
+
+template<> struct fex_gen_config<QueryOffsetOf> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<QueryOffsetOf, 0, ReorderingType*> : fexgen::ptr_passthrough {};
diff --git a/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp b/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
index 4fc742db2f..bb54220c10 100644
--- a/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
+++ b/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
@@ -17,8 +17,34 @@ struct Fixture {
 
 #define GET_SYMBOL(name) decltype(&::name) name = (decltype(name))dlsym(lib, #name)
   GET_SYMBOL(GetDoubledValue);
+  GET_SYMBOL(MakeReorderingType);
+  GET_SYMBOL(GetReorderingTypeMember);
+  GET_SYMBOL(ModifyReorderingTypeMembers);
+  GET_SYMBOL(QueryOffsetOf);
 };
 
 TEST_CASE_METHOD(Fixture, "Trivial") {
   CHECK(GetDoubledValue(10) == 20);
 }
+
+TEST_CASE_METHOD(Fixture, "Automatic struct repacking") {
+  {
+    // Test repacking of return values
+    ReorderingType test_struct = MakeReorderingType(0x1234, 0x5678);
+    REQUIRE(test_struct.a == 0x1234);
+    REQUIRE(test_struct.b == 0x5678);
+
+    // Test offsets of the host-side guest_layout wrapper match the guest-side ones
+    CHECK(QueryOffsetOf(&test_struct, 0) == offsetof(ReorderingType, a));
+    CHECK(QueryOffsetOf(&test_struct, 1) == offsetof(ReorderingType, b));
+
+    // Test repacking of input pointers
+    CHECK(GetReorderingTypeMember(&test_struct, 0) == 0x1234);
+    CHECK(GetReorderingTypeMember(&test_struct, 1) == 0x5678);
+
+    // Test repacking of output pointers
+    ModifyReorderingTypeMembers(&test_struct);
+    CHECK(GetReorderingTypeMember(&test_struct, 0) == 0x1235);
+    CHECK(GetReorderingTypeMember(&test_struct, 1) == 0x567a);
+  };
+}

From f8778df15719497ab7f5c8a40c343079995546a4 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Wed, 23 Aug 2023 17:05:53 +0200
Subject: [PATCH 32/48] unittests/Thunks: Add tests for assisted struct
 repacking

---
 ThunkLibs/libfex_thunk_test/Host.cpp           | 18 ++++++++++++++++++
 ThunkLibs/libfex_thunk_test/api.h              | 13 +++++++++++++
 ThunkLibs/libfex_thunk_test/lib.cpp            |  4 ++++
 .../libfex_thunk_test_interface.cpp            |  3 +++
 .../tests/thunks/thunk_testlib.cpp             |  6 ++++++
 5 files changed, 44 insertions(+)

diff --git a/ThunkLibs/libfex_thunk_test/Host.cpp b/ThunkLibs/libfex_thunk_test/Host.cpp
index ab90519145..1b28b2c4bf 100644
--- a/ThunkLibs/libfex_thunk_test/Host.cpp
+++ b/ThunkLibs/libfex_thunk_test/Host.cpp
@@ -13,4 +13,22 @@ tags: thunklibs|fex_thunk_test
 
 #include "thunkgen_host_libfex_thunk_test.inl"
 
+static uint32_t fexfn_impl_libfex_thunk_test_QueryOffsetOf(guest_layout<ReorderingType*> data, int index) {
+    if (index == 0) {
+        return offsetof(guest_layout<ReorderingType>::type, a);
+    } else {
+        return offsetof(guest_layout<ReorderingType>::type, b);
+    }
+}
+
+template<>
+void fex_custom_repack<&CustomRepackedType::data>(host_layout<CustomRepackedType>& to, guest_layout<CustomRepackedType> const& from) {
+  to.data.custom_repack_invoked = 1;
+}
+
+template<>
+void fex_custom_repack_postcall<&CustomRepackedType::data>(ReorderingType* const&) {
+
+}
+
 EXPORTS(libfex_thunk_test)
diff --git a/ThunkLibs/libfex_thunk_test/api.h b/ThunkLibs/libfex_thunk_test/api.h
index e86d49fdcf..6fd8748e07 100644
--- a/ThunkLibs/libfex_thunk_test/api.h
+++ b/ThunkLibs/libfex_thunk_test/api.h
@@ -31,4 +31,17 @@ uint32_t GetReorderingTypeMember(ReorderingType*, int index);
 void ModifyReorderingTypeMembers(ReorderingType* data);
 uint32_t QueryOffsetOf(ReorderingType*, int index);
 
+
+/// Interfaces used to test assisted struct repacking
+
+// We enable custom repacking on the "data" member, with repacking code that
+// sets the first bit of "custom_repack_invoked" to 1 on entry.
+struct CustomRepackedType {
+    ReorderingType* data;
+    int custom_repack_invoked;
+};
+
+// Should return true if the custom repacker set "custom_repack_invoked" to true
+int RanCustomRepack(CustomRepackedType*);
+
 }
diff --git a/ThunkLibs/libfex_thunk_test/lib.cpp b/ThunkLibs/libfex_thunk_test/lib.cpp
index 3e09d370cd..f34857f0ab 100644
--- a/ThunkLibs/libfex_thunk_test/lib.cpp
+++ b/ThunkLibs/libfex_thunk_test/lib.cpp
@@ -23,4 +23,8 @@ void ModifyReorderingTypeMembers(ReorderingType* data) {
   data->b += 2;
 }
 
+int RanCustomRepack(CustomRepackedType* data) {
+  return data->custom_repack_invoked;
+}
+
 } // extern "C"
diff --git a/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp b/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
index c60eaf77e2..b96c3b0636 100644
--- a/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
+++ b/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
@@ -19,3 +19,6 @@ template<> struct fex_gen_config<ModifyReorderingTypeMembers> {};
 
 template<> struct fex_gen_config<QueryOffsetOf> : fexgen::custom_host_impl {};
 template<> struct fex_gen_param<QueryOffsetOf, 0, ReorderingType*> : fexgen::ptr_passthrough {};
+
+template<> struct fex_gen_config<&CustomRepackedType::data> : fexgen::custom_repack {};
+template<> struct fex_gen_config<RanCustomRepack> {};
diff --git a/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp b/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
index bb54220c10..c31437149d 100644
--- a/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
+++ b/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
@@ -21,6 +21,7 @@ struct Fixture {
   GET_SYMBOL(GetReorderingTypeMember);
   GET_SYMBOL(ModifyReorderingTypeMembers);
   GET_SYMBOL(QueryOffsetOf);
+  GET_SYMBOL(RanCustomRepack);
 };
 
 TEST_CASE_METHOD(Fixture, "Trivial") {
@@ -48,3 +49,8 @@ TEST_CASE_METHOD(Fixture, "Automatic struct repacking") {
     CHECK(GetReorderingTypeMember(&test_struct, 1) == 0x567a);
   };
 }
+
+TEST_CASE_METHOD(Fixture, "Assisted struct repacking") {
+  CustomRepackedType data {};
+  CHECK(RanCustomRepack(&data) == 1);
+}

From 239c01003e4e83cb9fed26f0b7b15c819fe21f39 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Wed, 6 Sep 2023 16:00:36 +0200
Subject: [PATCH 33/48] Add more assisted repacking tests

---
 unittests/ThunkLibs/generator.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index cd67d53212..4504a1acec 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -727,6 +727,11 @@ TEST_CASE_METHOD(Fixture, "StructRepacking") {
         SECTION("Parameter annotated as ptr_passthrough") {
             CHECK_NOTHROW(run_thunkgen_host(prelude, code + "template<> struct fex_gen_param<func, 0, A*> : fexgen::ptr_passthrough {};\n", guest_abi));
         }
+
+        SECTION("Struct member annotated as custom_repack") {
+            CHECK_NOTHROW(run_thunkgen_host("struct A { void* a; };\n",
+                  code + "template<> struct fex_gen_config<&A::a> : fexgen::custom_repack {};\n", guest_abi));
+        }
     }
 
     SECTION("Pointer to struct with pointer member of consistent data layout") {
@@ -797,4 +802,15 @@ TEST_CASE_METHOD(Fixture, "VoidPointerParameter") {
             CHECK_NOTHROW(run_thunkgen_host(prelude, code, guest_abi));
         }
     }
+
+    SECTION("Custom repack in struct") {
+        const char* prelude =
+            "struct A { void* a; };\n";
+        const char* code =
+            "#include <thunks_common.h>\n"
+            "void func(A*);\n"
+            "template<> struct fex_gen_config<&A::a> : fexgen::custom_repack {};\n"
+            "template<> struct fex_gen_config<func> {};\n";
+        CHECK_NOTHROW(run_thunkgen_host(prelude, code, guest_abi));
+    }
 }

From 23cc9bb4dc441670e71d41c31b2b21bd586b63b9 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Wed, 23 Aug 2023 17:24:25 +0200
Subject: [PATCH 34/48] unittests/thunks: Add tests for opaque types

---
 ThunkLibs/libfex_thunk_test/api.h                |  9 +++++++++
 ThunkLibs/libfex_thunk_test/lib.cpp              | 16 ++++++++++++++++
 .../libfex_thunk_test_interface.cpp              |  5 +++++
 .../FEXLinuxTests/tests/thunks/thunk_testlib.cpp | 12 ++++++++++++
 4 files changed, 42 insertions(+)

diff --git a/ThunkLibs/libfex_thunk_test/api.h b/ThunkLibs/libfex_thunk_test/api.h
index 6fd8748e07..dbda97a54a 100644
--- a/ThunkLibs/libfex_thunk_test/api.h
+++ b/ThunkLibs/libfex_thunk_test/api.h
@@ -11,6 +11,15 @@ extern "C" {
 uint32_t GetDoubledValue(uint32_t);
 
 
+/// Interfaces used to test opaque_type and assume_compatible_data_layout annotations
+
+struct OpaqueType;
+
+OpaqueType* MakeOpaqueType(uint32_t data);
+uint32_t ReadOpaqueTypeData(OpaqueType*);
+void DestroyOpaqueType(OpaqueType*);
+
+
 /// Interfaces used to test automatic struct repacking
 
 // A simple struct with data layout that differs between guest and host.
diff --git a/ThunkLibs/libfex_thunk_test/lib.cpp b/ThunkLibs/libfex_thunk_test/lib.cpp
index f34857f0ab..623e91e67a 100644
--- a/ThunkLibs/libfex_thunk_test/lib.cpp
+++ b/ThunkLibs/libfex_thunk_test/lib.cpp
@@ -6,6 +6,22 @@ uint32_t GetDoubledValue(uint32_t input) {
   return 2 * input;
 }
 
+struct OpaqueType {
+  uint32_t data;
+};
+
+OpaqueType* MakeOpaqueType(uint32_t data) {
+  return new OpaqueType { data };
+}
+
+uint32_t ReadOpaqueTypeData(OpaqueType* value) {
+  return value->data;
+}
+
+void DestroyOpaqueType(OpaqueType* value) {
+  delete value;
+}
+
 ReorderingType MakeReorderingType(uint32_t a, uint32_t b) {
   return ReorderingType { .a = a, .b = b };
 }
diff --git a/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp b/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
index b96c3b0636..f50ad2f6f5 100644
--- a/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
+++ b/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
@@ -13,6 +13,11 @@ struct fex_gen_param {};
 
 template<> struct fex_gen_config<GetDoubledValue> {};
 
+template<> struct fex_gen_type<OpaqueType> : fexgen::opaque_type {};
+template<> struct fex_gen_config<MakeOpaqueType> {};
+template<> struct fex_gen_config<ReadOpaqueTypeData> {};
+template<> struct fex_gen_config<DestroyOpaqueType> {};
+
 template<> struct fex_gen_config<MakeReorderingType> {};
 template<> struct fex_gen_config<GetReorderingTypeMember> {};
 template<> struct fex_gen_config<ModifyReorderingTypeMembers> {};
diff --git a/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp b/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
index c31437149d..be360741ee 100644
--- a/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
+++ b/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
@@ -17,10 +17,16 @@ struct Fixture {
 
 #define GET_SYMBOL(name) decltype(&::name) name = (decltype(name))dlsym(lib, #name)
   GET_SYMBOL(GetDoubledValue);
+
+  GET_SYMBOL(MakeOpaqueType);
+  GET_SYMBOL(ReadOpaqueTypeData);
+  GET_SYMBOL(DestroyOpaqueType);
+
   GET_SYMBOL(MakeReorderingType);
   GET_SYMBOL(GetReorderingTypeMember);
   GET_SYMBOL(ModifyReorderingTypeMembers);
   GET_SYMBOL(QueryOffsetOf);
+
   GET_SYMBOL(RanCustomRepack);
 };
 
@@ -28,6 +34,12 @@ TEST_CASE_METHOD(Fixture, "Trivial") {
   CHECK(GetDoubledValue(10) == 20);
 }
 
+TEST_CASE_METHOD(Fixture, "Opaque data types") {
+  auto data = MakeOpaqueType(0x1234);
+  CHECK(ReadOpaqueTypeData(data) == 0x1234);
+  DestroyOpaqueType(data);
+}
+
 TEST_CASE_METHOD(Fixture, "Automatic struct repacking") {
   {
     // Test repacking of return values

From fe624b8399747d8ef6f6b43a5388eb5248de94e5 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Wed, 23 Aug 2023 17:52:31 +0200
Subject: [PATCH 35/48] TODOSQUASH. For struct repacking, const must be
 stripped off from pointees

---
 ThunkLibs/Generator/gen.cpp | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index 395c9640d3..0713e41e3e 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -643,7 +643,15 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                 } else if (pointee_compat == TypeCompatibility::Repackable) {
                     // TODO: Require opt-in for this to be emitted since it's single-element only; otherwise, pointers-to-arrays arguments will cause stack trampling
                     // TODO: Rename to repacked_arg
-                    fmt::print(file, "  unpacked_arg_with_storage<{}> a_{} {{ args->a_{} }};\n", get_type_name(context, param_type.getTypePtr()), param_idx, param_idx);
+                    auto get_type_name_with_nonconst_pointee = [&](clang::QualType type) {
+                        type = type.getLocalUnqualifiedType();
+                        if (type->isPointerType()) {
+                            // Strip away "const" from pointee type
+                            type = context.getPointerType(type->getPointeeType().getLocalUnqualifiedType());
+                        }
+                        return get_type_name(context, type.getTypePtr());
+                    };
+                    fmt::print(file, "  unpacked_arg_with_storage<{}> a_{} {{ args->a_{} }};\n", get_type_name_with_nonconst_pointee(param_type), param_idx, param_idx);
                 } else {
                     throw report_error(thunk.decl->getLocation(), "Cannot generate unpacking function for function %0 with unannotated pointer parameter %1").AddString(function_name).AddTaggedVal(param_type);
                 }

From 6db1efd621b07498f1c03dce2f81d677df8e47e9 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Wed, 23 Aug 2023 17:53:41 +0200
Subject: [PATCH 36/48] unittests/Thunks: Add assume_compatible_data_layout
 test

---
 ThunkLibs/libfex_thunk_test/api.h                           | 4 +++-
 ThunkLibs/libfex_thunk_test/lib.cpp                         | 6 +++++-
 ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp | 2 ++
 unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp      | 5 +++++
 4 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/ThunkLibs/libfex_thunk_test/api.h b/ThunkLibs/libfex_thunk_test/api.h
index dbda97a54a..6800b183a4 100644
--- a/ThunkLibs/libfex_thunk_test/api.h
+++ b/ThunkLibs/libfex_thunk_test/api.h
@@ -36,10 +36,12 @@ struct ReorderingType {
 };
 
 ReorderingType MakeReorderingType(uint32_t a, uint32_t b);
-uint32_t GetReorderingTypeMember(ReorderingType*, int index);
+uint32_t GetReorderingTypeMember(const ReorderingType*, int index);
 void ModifyReorderingTypeMembers(ReorderingType* data);
 uint32_t QueryOffsetOf(ReorderingType*, int index);
 
+// Uses assume_compatible_data_layout to skip repacking
+uint32_t GetReorderingTypeMemberWithoutRepacking(const ReorderingType*, int index);
 
 /// Interfaces used to test assisted struct repacking
 
diff --git a/ThunkLibs/libfex_thunk_test/lib.cpp b/ThunkLibs/libfex_thunk_test/lib.cpp
index 623e91e67a..33490125ce 100644
--- a/ThunkLibs/libfex_thunk_test/lib.cpp
+++ b/ThunkLibs/libfex_thunk_test/lib.cpp
@@ -26,7 +26,7 @@ ReorderingType MakeReorderingType(uint32_t a, uint32_t b) {
   return ReorderingType { .a = a, .b = b };
 }
 
-uint32_t GetReorderingTypeMember(ReorderingType* data, int index) {
+uint32_t GetReorderingTypeMember(const ReorderingType* data, int index) {
   if (index == 0) {
     return data->a;
   } else {
@@ -34,6 +34,10 @@ uint32_t GetReorderingTypeMember(ReorderingType* data, int index) {
   }
 }
 
+uint32_t GetReorderingTypeMemberWithoutRepacking(const ReorderingType* data, int index) {
+  return GetReorderingTypeMember(data, index);
+}
+
 void ModifyReorderingTypeMembers(ReorderingType* data) {
   data->a += 1;
   data->b += 2;
diff --git a/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp b/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
index f50ad2f6f5..f40e4e718a 100644
--- a/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
+++ b/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
@@ -20,6 +20,8 @@ template<> struct fex_gen_config<DestroyOpaqueType> {};
 
 template<> struct fex_gen_config<MakeReorderingType> {};
 template<> struct fex_gen_config<GetReorderingTypeMember> {};
+template<> struct fex_gen_config<GetReorderingTypeMemberWithoutRepacking> {};
+template<> struct fex_gen_param<GetReorderingTypeMemberWithoutRepacking, 0, const ReorderingType*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<ModifyReorderingTypeMembers> {};
 
 template<> struct fex_gen_config<QueryOffsetOf> : fexgen::custom_host_impl {};
diff --git a/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp b/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
index be360741ee..0224744b98 100644
--- a/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
+++ b/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
@@ -24,6 +24,7 @@ struct Fixture {
 
   GET_SYMBOL(MakeReorderingType);
   GET_SYMBOL(GetReorderingTypeMember);
+  GET_SYMBOL(GetReorderingTypeMemberWithoutRepacking);
   GET_SYMBOL(ModifyReorderingTypeMembers);
   GET_SYMBOL(QueryOffsetOf);
 
@@ -55,6 +56,10 @@ TEST_CASE_METHOD(Fixture, "Automatic struct repacking") {
     CHECK(GetReorderingTypeMember(&test_struct, 0) == 0x1234);
     CHECK(GetReorderingTypeMember(&test_struct, 1) == 0x5678);
 
+    // Test that we can force reinterpreting the data in guest layout as host layout
+    CHECK(GetReorderingTypeMemberWithoutRepacking(&test_struct, 0) == 0x5678);
+    CHECK(GetReorderingTypeMemberWithoutRepacking(&test_struct, 1) == 0x1234);
+
     // Test repacking of output pointers
     ModifyReorderingTypeMembers(&test_struct);
     CHECK(GetReorderingTypeMember(&test_struct, 0) == 0x1235);

From a14b70ba9c47ff2fee5648d3896dcc5191da7af3 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Wed, 23 Aug 2023 17:59:52 +0200
Subject: [PATCH 37/48] unittests/thunks: Add assume_compatible_data_layout
 tests

---
 ThunkLibs/libfex_thunk_test/api.h                |  8 ++++++++
 ThunkLibs/libfex_thunk_test/lib.cpp              |  8 ++++++++
 .../libfex_thunk_test_interface.cpp              |  4 ++++
 .../FEXLinuxTests/tests/thunks/thunk_testlib.cpp | 16 +++++++++++++---
 4 files changed, 33 insertions(+), 3 deletions(-)

diff --git a/ThunkLibs/libfex_thunk_test/api.h b/ThunkLibs/libfex_thunk_test/api.h
index 6800b183a4..419057e30e 100644
--- a/ThunkLibs/libfex_thunk_test/api.h
+++ b/ThunkLibs/libfex_thunk_test/api.h
@@ -19,6 +19,14 @@ OpaqueType* MakeOpaqueType(uint32_t data);
 uint32_t ReadOpaqueTypeData(OpaqueType*);
 void DestroyOpaqueType(OpaqueType*);
 
+union UnionType {
+    uint32_t a;
+    int32_t b;
+    uint8_t c[4];
+};
+
+UnionType MakeUnionType(uint8_t a, uint8_t b, uint8_t c, uint8_t d);
+uint32_t GetUnionTypeA(UnionType*);
 
 /// Interfaces used to test automatic struct repacking
 
diff --git a/ThunkLibs/libfex_thunk_test/lib.cpp b/ThunkLibs/libfex_thunk_test/lib.cpp
index 33490125ce..dac27eae1b 100644
--- a/ThunkLibs/libfex_thunk_test/lib.cpp
+++ b/ThunkLibs/libfex_thunk_test/lib.cpp
@@ -22,6 +22,14 @@ void DestroyOpaqueType(OpaqueType* value) {
   delete value;
 }
 
+UnionType MakeUnionType(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {
+  return UnionType { .c = { a, b, c, d } };
+}
+
+uint32_t GetUnionTypeA(UnionType* value) {
+  return value->a;
+}
+
 ReorderingType MakeReorderingType(uint32_t a, uint32_t b) {
   return ReorderingType { .a = a, .b = b };
 }
diff --git a/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp b/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
index f40e4e718a..1e4293ca07 100644
--- a/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
+++ b/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
@@ -18,6 +18,10 @@ template<> struct fex_gen_config<MakeOpaqueType> {};
 template<> struct fex_gen_config<ReadOpaqueTypeData> {};
 template<> struct fex_gen_config<DestroyOpaqueType> {};
 
+template<> struct fex_gen_type<UnionType> : fexgen::assume_compatible_data_layout {};
+template<> struct fex_gen_config<MakeUnionType> {};
+template<> struct fex_gen_config<GetUnionTypeA> {};
+
 template<> struct fex_gen_config<MakeReorderingType> {};
 template<> struct fex_gen_config<GetReorderingTypeMember> {};
 template<> struct fex_gen_config<GetReorderingTypeMemberWithoutRepacking> {};
diff --git a/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp b/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
index 0224744b98..c1ae5c564e 100644
--- a/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
+++ b/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
@@ -22,6 +22,9 @@ struct Fixture {
   GET_SYMBOL(ReadOpaqueTypeData);
   GET_SYMBOL(DestroyOpaqueType);
 
+  GET_SYMBOL(MakeUnionType);
+  GET_SYMBOL(GetUnionTypeA);
+
   GET_SYMBOL(MakeReorderingType);
   GET_SYMBOL(GetReorderingTypeMember);
   GET_SYMBOL(GetReorderingTypeMemberWithoutRepacking);
@@ -36,9 +39,16 @@ TEST_CASE_METHOD(Fixture, "Trivial") {
 }
 
 TEST_CASE_METHOD(Fixture, "Opaque data types") {
-  auto data = MakeOpaqueType(0x1234);
-  CHECK(ReadOpaqueTypeData(data) == 0x1234);
-  DestroyOpaqueType(data);
+  {
+    auto data = MakeOpaqueType(0x1234);
+    CHECK(ReadOpaqueTypeData(data) == 0x1234);
+    DestroyOpaqueType(data);
+  }
+
+  {
+    auto data = MakeUnionType(0x1, 0x2, 0x3, 0x4);
+    CHECK(GetUnionTypeA(&data) == 0x04030201);
+  }
 }
 
 TEST_CASE_METHOD(Fixture, "Automatic struct repacking") {

From 657ca8f5fd9d1fe82a9625d13e622507a9618f1d Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Thu, 24 Aug 2023 10:48:30 +0200
Subject: [PATCH 38/48] unittests/Thunks: Add test for divergent function
 parameters

---
 ThunkLibs/Generator/gen.cpp                         |  2 +-
 ThunkLibs/libfex_thunk_test/api.h                   | 13 +++++++++++++
 ThunkLibs/libfex_thunk_test/lib.cpp                 |  4 ++++
 .../libfex_thunk_test_interface.cpp                 |  2 ++
 .../FEXLinuxTests/tests/thunks/thunk_testlib.cpp    |  6 ++++++
 5 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index 0713e41e3e..327bf665a5 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -363,7 +363,7 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
             }
 
             // These must be handled later since they are not canonicalized and hence must be de-duplicated first
-            if (type->isBuiltinType()) {
+            if (type->isBuiltinType() && !type->isEnumeralType()) {
                 continue;
             }
 
diff --git a/ThunkLibs/libfex_thunk_test/api.h b/ThunkLibs/libfex_thunk_test/api.h
index 419057e30e..6f1729c3a8 100644
--- a/ThunkLibs/libfex_thunk_test/api.h
+++ b/ThunkLibs/libfex_thunk_test/api.h
@@ -63,4 +63,17 @@ struct CustomRepackedType {
 // Should return true if the custom repacker set "custom_repack_invoked" to true
 int RanCustomRepack(CustomRepackedType*);
 
+/// Interface used to check that function arguments with different integer size
+/// get forwarded correctly
+/// TODO: Also test signatures that differ through the underlying type of a
+///       type alias. Currently, the thunk generator still requires a dedicated
+///       type to detect differences.
+
+#if defined(__aarch64__) || defined(_M_ARM64) // TODO: Use proper host check
+enum DivType : uint8_t {};
+#else
+enum DivType : uint32_t {};
+#endif
+int FunctionWithDivergentSignature(DivType, DivType, DivType, DivType);
+
 }
diff --git a/ThunkLibs/libfex_thunk_test/lib.cpp b/ThunkLibs/libfex_thunk_test/lib.cpp
index dac27eae1b..0fbe9a1c10 100644
--- a/ThunkLibs/libfex_thunk_test/lib.cpp
+++ b/ThunkLibs/libfex_thunk_test/lib.cpp
@@ -55,4 +55,8 @@ int RanCustomRepack(CustomRepackedType* data) {
   return data->custom_repack_invoked;
 }
 
+int FunctionWithDivergentSignature(DivType a, DivType b, DivType c, DivType d) {
+  return ((uint8_t)a << 24) | ((uint8_t)b << 16) | ((uint8_t)c << 8) | (uint8_t)d;
+}
+
 } // extern "C"
diff --git a/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp b/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
index 1e4293ca07..8923722f36 100644
--- a/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
+++ b/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
@@ -33,3 +33,5 @@ template<> struct fex_gen_param<QueryOffsetOf, 0, ReorderingType*> : fexgen::ptr
 
 template<> struct fex_gen_config<&CustomRepackedType::data> : fexgen::custom_repack {};
 template<> struct fex_gen_config<RanCustomRepack> {};
+
+template<> struct fex_gen_config<FunctionWithDivergentSignature> {};
diff --git a/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp b/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
index c1ae5c564e..dcac39b7e0 100644
--- a/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
+++ b/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
@@ -32,6 +32,8 @@ struct Fixture {
   GET_SYMBOL(QueryOffsetOf);
 
   GET_SYMBOL(RanCustomRepack);
+
+  GET_SYMBOL(FunctionWithDivergentSignature);
 };
 
 TEST_CASE_METHOD(Fixture, "Trivial") {
@@ -81,3 +83,7 @@ TEST_CASE_METHOD(Fixture, "Assisted struct repacking") {
   CustomRepackedType data {};
   CHECK(RanCustomRepack(&data) == 1);
 }
+
+TEST_CASE_METHOD(Fixture, "Function signature with differing parameter sizes") {
+  CHECK(FunctionWithDivergentSignature(DivType{1}, DivType{2}, DivType{3}, DivType{4}) == 0x01020304);
+}

From 08c8b38046f19353fff0b86088ef04f9ba331ec7 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Thu, 31 Aug 2023 15:21:36 +0200
Subject: [PATCH 39/48] TODO ENSURE THERE'S A REPLACEMENT. Deprecate
 callback_guest annotation

This is superseeded by ptr_passthrough.
---
 ThunkLibs/Generator/analysis.cpp              | 10 +------
 ThunkLibs/Generator/analysis.h                |  1 -
 ThunkLibs/Generator/gen.cpp                   | 14 ++-------
 ThunkLibs/include/common/GeneratorInterface.h |  1 -
 ThunkLibs/include/common/Host.h               | 21 --------------
 unittests/ThunkLibs/common.h                  |  1 -
 unittests/ThunkLibs/generator.cpp             | 29 -------------------
 7 files changed, 3 insertions(+), 74 deletions(-)

diff --git a/ThunkLibs/Generator/analysis.cpp b/ThunkLibs/Generator/analysis.cpp
index c25920810c..ecbbbaa86d 100644
--- a/ThunkLibs/Generator/analysis.cpp
+++ b/ThunkLibs/Generator/analysis.cpp
@@ -62,7 +62,6 @@ static NamespaceAnnotations GetNamespaceAnnotations(clang::ASTContext& context,
 enum class CallbackStrategy {
     Default,
     Stub,
-    Guest,
 };
 
 struct Annotations {
@@ -88,8 +87,6 @@ static Annotations GetAnnotations(clang::ASTContext& context, clang::CXXRecordDe
             ret.custom_host_impl = true;
         } else if (annotation == "fexgen::callback_stub") {
             ret.callback_strategy = CallbackStrategy::Stub;
-        } else if (annotation == "fexgen::callback_guest") {
-            ret.callback_strategy = CallbackStrategy::Guest;
         } else if (annotation == "fexgen::custom_guest_entrypoint") {
             ret.custom_guest_entrypoint = true;
         } else {
@@ -403,15 +400,10 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
                                 callback.param_types.push_back(cb_param);
                             }
                             callback.is_stub = annotations.callback_strategy == CallbackStrategy::Stub;
-                            callback.is_guest = annotations.callback_strategy == CallbackStrategy::Guest;
                             callback.is_variadic = funcptr->isVariadic();
 
-                            if (callback.is_guest && !data.custom_host_impl) {
-                                throw report_error(template_arg_loc, "callback_guest can only be used with custom_host_impl");
-                            }
-
                             data.callbacks.emplace(param_idx, callback);
-                            if (!callback.is_stub && !callback.is_guest && !data.custom_host_impl) {
+                            if (!callback.is_stub && !data.custom_host_impl) {
                                 funcptr_types[emitted_function->getNameAsString() + "_cb" + std::to_string(param_idx)] = std::pair { context.getCanonicalType(funcptr), no_param_annotations };
                             }
 
diff --git a/ThunkLibs/Generator/analysis.h b/ThunkLibs/Generator/analysis.h
index b2651104b2..9a7d50f7a4 100644
--- a/ThunkLibs/Generator/analysis.h
+++ b/ThunkLibs/Generator/analysis.h
@@ -17,7 +17,6 @@ struct ThunkedCallback : FunctionParams {
     clang::QualType return_type;
 
     bool is_stub = false;  // Callback will be replaced by a stub that calls std::abort
-    bool is_guest = false; // Callback will never be called on the host
     bool is_variadic = false;
 };
 
diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index 327bf665a5..3d6e51ef81 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -285,7 +285,7 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                 auto cb = data.callbacks.find(idx);
 
                 file << "  args.a_" << idx << " = ";
-                if (cb == data.callbacks.end() || cb->second.is_stub || cb->second.is_guest) {
+                if (cb == data.callbacks.end() || cb->second.is_stub) {
                     file << "a_" << idx << ";\n";
                 } else {
                     // Before passing guest function pointers to the host, wrap them in a host-callable trampoline
@@ -555,10 +555,7 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
 
                     file << (idx == 0 ? "" : ", ");
 
-                    auto cb = thunk.callbacks.find(idx);
-                    if (cb != thunk.callbacks.end() && cb->second.is_guest) {
-                        file << "fex_guest_function_ptr a_" << idx;
-                    } else if (thunk.param_annotations[idx].is_passthrough) {
+                    if (thunk.param_annotations[idx].is_passthrough) {
                         fmt::print(file, "guest_layout<{}> a_{}", type.getAsString(), idx);
                     } else {
                         file << format_decl(type, fmt::format("a_{}", idx));
@@ -677,13 +674,6 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                     auto cb = thunk.callbacks.find(idx);
                     if (cb != thunk.callbacks.end() && cb->second.is_stub) {
                         return "fexfn_unpack_" + get_callback_name(function_name, cb->first) + "_stub";
-                    } else if (cb != thunk.callbacks.end() && cb->second.is_guest) {
-                        auto arg_name = fmt::format("args->a_{}.data", idx); // Use parameter directly
-                        if (thunk.custom_host_impl) {
-                            return fmt::format("({})", arg_name);
-                        } else {
-                            return fmt::format("(({})(uint64_t {{ {}.data }}))", get_type_name(context, thunk.param_types[idx].getTypePtr()), arg_name);
-                        }
                     } else if (cb != thunk.callbacks.end()) {
                         auto arg_name = fmt::format("args->a_{}", idx); // Use parameter directly
                         // Use comma operator to inject a function call before returning the argument
diff --git a/ThunkLibs/include/common/GeneratorInterface.h b/ThunkLibs/include/common/GeneratorInterface.h
index 29c4f4eb4d..e367644827 100644
--- a/ThunkLibs/include/common/GeneratorInterface.h
+++ b/ThunkLibs/include/common/GeneratorInterface.h
@@ -11,7 +11,6 @@ struct callback_annotation_base {
     bool prevent_multiple;
 };
 struct callback_stub : callback_annotation_base {};
-struct callback_guest : callback_annotation_base {};
 
 // If used, fex_custom_repack must be specialized for the annotated struct member
 struct custom_repack {};
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index 042ebc259b..f6b48d2b61 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -53,27 +53,6 @@ struct ExportEntry { uint8_t* sha256; void(*fn)(void *); };
 
 typedef void fex_call_callback_t(uintptr_t callback, void *arg0, void* arg1);
 
-/**
- * Opaque wrapper around a guest function pointer.
- *
- * This prevents accidental calls to foreign function pointers while still
- * allowing us to label function pointers as such.
- */
-struct [[deprecated]] fex_guest_function_ptr {
-private:
-    void* value = nullptr;
-
-public:
-    fex_guest_function_ptr() = default;
-
-    template<typename Ret, typename... Args>
-    fex_guest_function_ptr(Ret (*ptr)(Args...)) : value(reinterpret_cast<void*>(ptr)) {}
-
-    inline operator bool() const {
-      return value != nullptr;
-    }
-};
-
 #define EXPORTS(name) \
   extern "C" { \
     ExportEntry* fexthunks_exports_##name() { \
diff --git a/unittests/ThunkLibs/common.h b/unittests/ThunkLibs/common.h
index b7ee25a410..b67a73fb59 100644
--- a/unittests/ThunkLibs/common.h
+++ b/unittests/ThunkLibs/common.h
@@ -82,7 +82,6 @@ struct returns_guest_pointer {}; // TODO: Deprecate in favor of pointer_passthro
 struct custom_host_impl {};
 struct callback_annotation_base { bool prevent_multiple; };
 struct callback_stub : callback_annotation_base {};
-struct callback_guest : callback_annotation_base {};
 
 // type annotations: fex_gen_config<MyStruct>
 //struct opaque_to_guest {};
diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index 4504a1acec..752a685bb2 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -575,35 +575,6 @@ TEST_CASE_METHOD(Fixture, "FunctionPointerParameter") {
             )));
 }
 
-// TODO: Decide what to do with this
-#if 0
-// Parameter is a guest function pointer
-TEST_CASE_METHOD(Fixture, "GuestFunctionPointerParameter") {
-    const std::string prelude =
-        "struct fex_guest_function_ptr { int (*x)(char,char); };\n"
-        "static void fexfn_impl_libtest_func(fex_guest_function_ptr) {}\n";
-    const auto output = run_thunkgen(prelude,
-        "#include <thunks_common.h>\n"
-        "void func(int (*funcptr)(char, char));\n"
-        "template<auto> struct fex_gen_config {};\n"
-        "template<> struct fex_gen_config<func> : fexgen::callback_guest, fexgen::custom_host_impl {};\n");
-
-    CHECK_THAT(output.guest,
-        matches(functionDecl(
-            hasName("fexfn_pack_func"),
-            returns(asString("void")),
-            parameterCountIs(1),
-            hasParameter(0, hasType(asString("int (*)(char, char)")))
-        )));
-
-    // Host-side implementation only sees an opaque type that it can't call
-    CHECK_THAT(output.host,
-        matches(callExpr(callee(functionDecl(hasName("fexfn_impl_libtest_func"))),
-                         hasArgument(0, hasType(asString("struct fex_guest_function_ptr")))
-            )));
-}
-#endif
-
 TEST_CASE_METHOD(Fixture, "MultipleParameters") {
     const std::string prelude =
         "struct TestStruct { int member; };\n";

From 715bd3a63089ffbce1edc4b3bb3e50227d76a068 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Thu, 31 Aug 2023 15:55:51 +0200
Subject: [PATCH 40/48] TODOFINISH. Thunks/gen: Map guest integer types to
 fixed-size equivalents

---
 ThunkLibs/Generator/data_layout.cpp | 19 +++++++++++++-
 ThunkLibs/Generator/gen.cpp         | 39 ++++++++++++++++++++++++++---
 unittests/ThunkLibs/generator.cpp   | 11 ++++----
 3 files changed, 59 insertions(+), 10 deletions(-)

diff --git a/ThunkLibs/Generator/data_layout.cpp b/ThunkLibs/Generator/data_layout.cpp
index fc45267a21..c3479a63e7 100644
--- a/ThunkLibs/Generator/data_layout.cpp
+++ b/ThunkLibs/Generator/data_layout.cpp
@@ -179,8 +179,25 @@ void AnalyzeDataLayoutAction::EmitOutput(clang::ASTContext& context) {
 
         info.result = func_type->getReturnType().getAsString();
         info.param_annotations = param_annotations;
+
+        // Heuristic approach to preserve data layout for arguments.
+        // We can re-use the string representation of most types without problems.
+        // Built-in types with differing size must be replaced with fixed-size integers.
+        // TODO: Instead of using these heuristics here, record the type name and its size.
+        //       Then, when emitting code, replace types with fixed-size integers only if the
+        //       sizes don't match
+        // TODO: Also apply these heuristics to the return type
+        // TODO: Respect param_annotations
         for (auto arg : func_type->getParamTypes()) {
-            info.args.push_back(arg.getAsString());
+            if (arg->isBuiltinType()) {
+                auto size = context.getTypeSize(arg);
+                info.args.push_back(fmt::format("uint{}_t", size));
+            } else if (arg->isPointerType() && arg->getPointeeType()->isBuiltinType() && context.getTypeSize(arg->getPointeeType()) >= 2 * 8) {
+                auto size = context.getTypeSize(arg->getPointeeType());
+                info.args.push_back(fmt::format("uint{}_t*", size));
+            } else {
+                info.args.push_back(arg.getAsString());
+            }
         }
         type_abi.funcptr_types[funcptr_id] = std::move(info);
     }
diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index 3d6e51ef81..73367ad58f 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -390,7 +390,14 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                 fmt::print(file, "  struct type {{\n");
                 // TODO: Insert any required padding bytes
                 for (auto& member : abi.at(struct_name).get_if_struct()->members) {
-                    fmt::print(file, "    guest_layout<{}> {};\n", member.type_name, member.member_name);
+                    // sizeof(size_t) is 4 on 32-bit but 8 on 64-bit. Turn it into a fixed-size type to resolve the difference.
+                    // TODO: Actually use 64 bits on 64 bit guests...
+                    // TODO: Auto-detect type size differences instead
+                    bool is_size_t = member.type_name == "size_t";
+                    fmt::print( file, "    guest_layout<{}{}> {};\n",
+                                is_size_t ? "uint32_t" : member.type_name,
+                                member.array_size ? fmt::format("[{}]", member.array_size.value()) : "",
+                                member.member_name);
                 }
                 fmt::print(file, "  }};\n");
             }
@@ -588,11 +595,20 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                 std::string struct_name = "fexfn_packed_args_" + libname + "_" + function_name;
                 file << "struct " << struct_name << " {\n";
 
+                auto get_type_name = [this](clang::QualType type) {
+                    if (type->isBuiltinType() && !type->isFloatingType()) {
+                        auto size = abi.at(type.getUnqualifiedType().getAsString()).get_if_simple_or_struct()->size_bits;
+                        return fmt::format("{}int{}_t", !type->isSignedIntegerType() ? "u" : "", size);
+                    } else {
+                        return type.getUnqualifiedType().getAsString();
+                    }
+                };
+
                 for (std::size_t idx = 0; idx < thunk.param_types.size(); ++idx) {
-                    fmt::print(file, "  guest_layout<{}> a_{};\n", get_type_name(context, thunk.param_types[idx].getTypePtr()), idx);
+                    fmt::print(file, "  guest_layout<{}> a_{};\n", get_type_name(thunk.param_types[idx]), idx);
                 }
                 if (!thunk.return_type->isVoidType()) {
-                    fmt::print(file, "  guest_layout<{}> rv;\n", get_type_name(context, thunk.return_type.getTypePtr()));
+                    fmt::print(file, "  guest_layout<{}> rv;\n", get_type_name(thunk.return_type));
                 } else if (thunk.param_types.size() == 0) {
                     // Avoid "empty struct has size 0 in C, size 1 in C++" warning
                     file << "    char force_nonempty;\n";
@@ -750,9 +766,24 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
             info.result = func_type->getReturnType().getAsString();
             info.param_annotations = param_annotations;
 
+            // Heuristic approach to preserve data layout for arguments.
+            // We can re-use the string representation of most types without problems.
+            // Built-in types with differing size must be replaced with fixed-size integers.
+            // TODO: Instead of using these heuristics here, record the type name and its size.
+            //       Then, when emitting code, replace types with fixed-size integers only if the
+            //       sizes don't match
+            // TODO: Also apply these heuristics to the return type
             // TODO: Respect param_annotations
             for (auto arg : func_type->getParamTypes()) {
-                info.args.push_back(arg.getAsString());
+                if (arg->isBuiltinType()) {
+                    auto size = context.getTypeSize(arg);
+                    info.args.push_back(fmt::format("uint{}_t", size));
+                } else if (arg->isPointerType() && arg->getPointeeType()->isBuiltinType() && context.getTypeSize(arg->getPointeeType()) >= 2 * 8) {
+                    auto size = context.getTypeSize(arg->getPointeeType());
+                    info.args.push_back(fmt::format("uint{}_t*", size));
+                } else {
+                    info.args.push_back(arg.getAsString());
+                }
             }
 
             std::string annotations;
diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index 752a685bb2..9e3f34722c 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -344,7 +344,8 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
         "struct host_layout {\n"
         "  T data;\n"
         "\n"
-        "  host_layout(const guest_layout<T>& from);\n"
+        "  template<typename U>\n"
+        "  host_layout(const guest_layout<U>& from) requires(!std::is_integral_v<T> || sizeof(T) == sizeof(U));\n"
         "};\n"
         "\n"
         "// Specialization for size_t, which is 64-bit on 64-bit but 32-bit on 32-bit\n"
@@ -536,7 +537,7 @@ TEST_CASE_METHOD(Fixture, "FunctionPointerViaType") {
             hasInitializer(hasDescendant(declRefExpr(to(cxxMethodDecl(hasName("Call"), ofClass(hasName("GuestWrapperForHostFunction"))).bind("funcptr")))))
             )).check_binding("funcptr", +[](const clang::CXXMethodDecl* decl) {
                 auto parent = llvm::cast<clang::ClassTemplateSpecializationDecl>(decl->getParent());
-                return parent->getTemplateArgs().get(0).getAsType().getAsString() == "int (char, char)";
+                return parent->getTemplateArgs().get(0).getAsType().getAsString() == "int (unsigned char, unsigned char)";
             }));
 }
 
@@ -615,9 +616,9 @@ TEST_CASE_METHOD(Fixture, "MultipleParameters") {
             parameterCountIs(1),
             hasParameter(0, hasType(pointerType(pointee(
                 recordType(hasDeclaration(decl(
-                    has(fieldDecl(hasType(asString("guest_layout<int>")))),
-                    has(fieldDecl(hasType(asString("guest_layout<char>")))),
-                    has(fieldDecl(hasType(asString("guest_layout<unsigned long>")))),
+                    has(fieldDecl(hasType(asString("guest_layout<int32_t>")))),
+                    has(fieldDecl(hasType(asString("guest_layout<uint8_t>")))),
+                    has(fieldDecl(hasType(asString("guest_layout<uint64_t>")))),
                     has(fieldDecl(hasType(asString("guest_layout<struct TestStruct>"))))
                     )))))))
             )));

From 43fe4a14e3cea4574f5c1b2bfa21d698b557c06e Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Thu, 31 Aug 2023 16:32:40 +0200
Subject: [PATCH 41/48] TODOFINISH. Disable struct padding for packed arguments

---
 Source/Tools/FEXLoader/VDSO_Emulation.cpp  | 44 ++++++------
 ThunkLibs/Generator/gen.cpp                | 11 +--
 ThunkLibs/include/common/Host.h            |  6 +-
 ThunkLibs/include/common/PackedArguments.h | 78 +++++++++++-----------
 4 files changed, 70 insertions(+), 69 deletions(-)

diff --git a/Source/Tools/FEXLoader/VDSO_Emulation.cpp b/Source/Tools/FEXLoader/VDSO_Emulation.cpp
index 0572ec1483..ad16a5492c 100644
--- a/Source/Tools/FEXLoader/VDSO_Emulation.cpp
+++ b/Source/Tools/FEXLoader/VDSO_Emulation.cpp
@@ -45,7 +45,7 @@ namespace FEX::VDSO {
     // glibc handlers
     namespace glibc {
       static void time(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           time_t *a_0;
           uint64_t rv;
         } *args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
@@ -55,7 +55,7 @@ namespace FEX::VDSO {
       }
 
       static void gettimeofday(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           struct timeval *tv;
           struct timezone *tz;
           uint64_t rv;
@@ -66,7 +66,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_gettime(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           struct timespec *tp;
           uint64_t rv;
@@ -77,7 +77,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_getres(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           struct timespec *tp;
           uint64_t rv;
@@ -88,7 +88,7 @@ namespace FEX::VDSO {
       }
 
       static void getcpu(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           uint32_t *cpu;
           uint32_t *node;
           uint64_t rv;
@@ -102,7 +102,7 @@ namespace FEX::VDSO {
     namespace VDSO {
       // VDSO handlers
       static void time(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           time_t *a_0;
           uint64_t rv;
         } *args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
@@ -111,7 +111,7 @@ namespace FEX::VDSO {
       }
 
       static void gettimeofday(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           struct timeval *tv;
           struct timezone *tz;
           uint64_t rv;
@@ -121,7 +121,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_gettime(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           struct timespec *tp;
           uint64_t rv;
@@ -131,7 +131,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_getres(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           struct timespec *tp;
           uint64_t rv;
@@ -141,7 +141,7 @@ namespace FEX::VDSO {
       }
 
       static void getcpu(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           uint32_t *cpu;
           uint32_t *node;
           uint64_t rv;
@@ -168,7 +168,7 @@ namespace FEX::VDSO {
 
       // glibc handlers
       static void time(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           HLE::x32::compat_ptr<FEX::HLE::x32::old_time32_t> a_0;
           int rv;
         } *args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
@@ -182,7 +182,7 @@ namespace FEX::VDSO {
       }
 
       static void gettimeofday(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           HLE::x32::compat_ptr<FEX::HLE::x32::timeval32> tv;
           HLE::x32::compat_ptr<struct timezone> tz;
           int rv;
@@ -203,7 +203,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_gettime(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           HLE::x32::compat_ptr<HLE::x32::timespec32> tp;
           int rv;
@@ -219,7 +219,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_gettime64(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           HLE::x32::compat_ptr<struct timespec> tp;
           int rv;
@@ -230,7 +230,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_getres(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           HLE::x32::compat_ptr<HLE::x32::timespec32> tp;
           int rv;
@@ -247,7 +247,7 @@ namespace FEX::VDSO {
       }
 
       static void getcpu(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           HLE::x32::compat_ptr<uint32_t> cpu;
           HLE::x32::compat_ptr<uint32_t> node;
           int rv;
@@ -265,7 +265,7 @@ namespace FEX::VDSO {
 
       // VDSO handlers
       static void time(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           HLE::x32::compat_ptr<FEX::HLE::x32::old_time32_t> a_0;
           int rv;
         } *args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
@@ -279,7 +279,7 @@ namespace FEX::VDSO {
       }
 
       static void gettimeofday(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           HLE::x32::compat_ptr<FEX::HLE::x32::timeval32> tv;
           HLE::x32::compat_ptr<struct timezone> tz;
           int rv;
@@ -300,7 +300,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_gettime(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           HLE::x32::compat_ptr<HLE::x32::timespec32> tp;
           int rv;
@@ -316,7 +316,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_gettime64(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           HLE::x32::compat_ptr<struct timespec> tp;
           int rv;
@@ -326,7 +326,7 @@ namespace FEX::VDSO {
       }
 
       static void clock_getres(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           clockid_t clk_id;
           HLE::x32::compat_ptr<HLE::x32::timespec32> tp;
           int rv;
@@ -343,7 +343,7 @@ namespace FEX::VDSO {
       }
 
       static void getcpu(void* ArgsRV) {
-        struct ArgsRV_t {
+        struct __attribute__((packed)) ArgsRV_t {
           HLE::x32::compat_ptr<uint32_t> cpu;
           HLE::x32::compat_ptr<uint32_t> node;
           int rv;
diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index 73367ad58f..0f94210575 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -268,7 +268,7 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
             }
             // Using trailing return type as it makes handling function pointer returns much easier
             file << ") -> " << data.return_type.getAsString() << " {\n";
-            file << "  struct {\n";
+            file << "  struct __attribute__((packed)) {\n";
             for (std::size_t idx = 0; idx < data.param_types.size(); ++idx) {
                 auto& type = data.param_types[idx];
                 file << "    " << format_decl(type.getUnqualifiedType(), fmt::format("a_{}", idx)) << ";\n";
@@ -373,7 +373,7 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
             }
 
             if (type->isEnumeralType()) {
-                fmt::print(file, "template<>\nstruct guest_layout<{}> {{\n", struct_name);
+                fmt::print(file, "template<>\nstruct __attribute__((packed)) guest_layout<{}> {{\n", struct_name);
                 fmt::print(file, "  using type = {}int{}_t;\n",
                            type->isUnsignedIntegerOrEnumerationType() ? "u" : "",
                            abi.at(struct_name).get_if_simple_or_struct()->size_bits);
@@ -383,12 +383,13 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
             }
 
             // Guest layout definition
-            fmt::print(file, "template<>\nstruct guest_layout<{}> {{\n", struct_name);
+            // NOTE: uint64_t has lower alignment requirements on 32-bit than on 64-bit, so we require tightly packed structs
+            // TODO: Now we must emit padding bytes explicitly, though!
+            fmt::print(file, "template<>\nstruct __attribute__((packed)) guest_layout<{}> {{\n", struct_name);
             if (type_compat.at(type) == TypeCompatibility::Full) {
                 fmt::print(file, "  using type = {};\n", struct_name);
             } else {
                 fmt::print(file, "  struct type {{\n");
-                // TODO: Insert any required padding bytes
                 for (auto& member : abi.at(struct_name).get_if_struct()->members) {
                     // sizeof(size_t) is 4 on 32-bit but 8 on 64-bit. Turn it into a fixed-size type to resolve the difference.
                     // TODO: Actually use 64 bits on 64 bit guests...
@@ -593,7 +594,7 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
             // Packed argument structs used in fexfn_unpack_*
             auto GeneratePackedArgs = [&](const auto &function_name, const ThunkedFunction &thunk) -> std::string {
                 std::string struct_name = "fexfn_packed_args_" + libname + "_" + function_name;
-                file << "struct " << struct_name << " {\n";
+                file << "struct __attribute__((packed)) " << struct_name << " {\n";
 
                 auto get_type_name = [this](clang::QualType type) {
                     if (type->isBuiltinType() && !type->isFloatingType()) {
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index f6b48d2b61..b55f46a0a4 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -125,7 +125,7 @@ template<> inline constexpr bool has_compatible_data_layout<const void**> = true
 
 // Placeholder type to indicate the given data is in guest-layout
 template<typename T>
-struct guest_layout {
+struct __attribute__((packed)) guest_layout {
   static_assert(!std::is_class_v<T>, "No guest layout defined for this non-opaque struct type. This may be a bug in the thunk generator.");
   static_assert(!std::is_union_v<T>, "No guest layout defined for this non-opaque union type. This may be a bug in the thunk generator.");
   static_assert(!std::is_enum_v<T>, "No guest layout defined for this enum type. This is a bug in the thunk generator.");
@@ -155,7 +155,7 @@ struct guest_layout {
 #if IS_32BIT_THUNK
 // Specialized for uint32_t so that members annotated as "size_t" can automatically be converted from 64-bit to 32-bit
 template<>
-struct guest_layout<uint32_t> {
+struct __attribute__((packed)) guest_layout<uint32_t> {
   using type = uint32_t;
   type data;
 
@@ -189,7 +189,7 @@ struct guest_layout<uint32_t> {
 #endif
 
 template<typename T, std::size_t N>
-struct guest_layout<T[N]> {
+struct __attribute__((packed)) guest_layout<T[N]> {
   // TODO: Check that the underlying type is ABI compatible
 //  static_assert(!std::is_class_v<T>, "No guest layout defined for this non-opaque struct type. This may be a bug in the thunk generator.");
 
diff --git a/ThunkLibs/include/common/PackedArguments.h b/ThunkLibs/include/common/PackedArguments.h
index 17af2f41c5..16f0f258ab 100644
--- a/ThunkLibs/include/common/PackedArguments.h
+++ b/ThunkLibs/include/common/PackedArguments.h
@@ -5,45 +5,45 @@
 #include <utility>
 
 template<typename Result, typename... Args>
-struct PackedArguments;
+struct __attribute__((packed)) PackedArguments;
 
 template<typename R>
-struct PackedArguments<R> { R rv; };
+struct __attribute__((packed)) PackedArguments<R> { R rv; };
 template<typename R, typename A0>
-struct PackedArguments<R, A0> { A0 a0; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0> { A0 a0; R rv; };
 template<typename R, typename A0, typename A1>
-struct PackedArguments<R, A0, A1> { A0 a0; A1 a1; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1> { A0 a0; A1 a1; R rv; };
 template<typename R, typename A0, typename A1, typename A2>
-struct PackedArguments<R, A0, A1, A2> { A0 a0; A1 a1; A2 a2; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2> { A0 a0; A1 a1; A2 a2; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3>
-struct PackedArguments<R, A0, A1, A2, A3> { A0 a0; A1 a1; A2 a2; A3 a3; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3> { A0 a0; A1 a1; A2 a2; A3 a3; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
-struct PackedArguments<R, A0, A1, A2, A3, A4> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; R rv; };
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; R rv; };
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; R rv; };
 
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9,
          typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19,
          typename A20, typename A21, typename A22>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9,
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9,
                        A10, A11, A12, A13, A14, A15, A16, A17, A18, A19,
                        A20, A21, A22> {
     A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9;
@@ -54,7 +54,7 @@ struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9,
 template<typename R, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9,
          typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19,
          typename A20, typename A21, typename A22, typename A23>
-struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9,
+struct __attribute__((packed)) PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9,
                        A10, A11, A12, A13, A14, A15, A16, A17, A18, A19,
                        A20, A21, A22, A23> {
     A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9;
@@ -63,45 +63,45 @@ struct PackedArguments<R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9,
 };
 
 template<>
-struct PackedArguments<void> { };
+struct __attribute__((packed)) PackedArguments<void> { };
 template<typename A0>
-struct PackedArguments<void, A0> { A0 a0; };
+struct __attribute__((packed)) PackedArguments<void, A0> { A0 a0; };
 template<typename A0, typename A1>
-struct PackedArguments<void, A0, A1> { A0 a0; A1 a1; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1> { A0 a0; A1 a1; };
 template<typename A0, typename A1, typename A2>
-struct PackedArguments<void, A0, A1, A2> { A0 a0; A1 a1; A2 a2; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2> { A0 a0; A1 a1; A2 a2; };
 template<typename A0, typename A1, typename A2, typename A3>
-struct PackedArguments<void, A0, A1, A2, A3> { A0 a0; A1 a1; A2 a2; A3 a3; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3> { A0 a0; A1 a1; A2 a2; A3 a3; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4>
-struct PackedArguments<void, A0, A1, A2, A3, A4> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; A15 a15; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; A15 a15; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; A15 a15; A16 a16; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; A15 a15; A16 a16; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; A15 a15; A16 a16; A17 a17; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; A15 a15; A16 a16; A17 a17; };
 template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18>
-struct PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; A15 a15; A16 a16; A17 a17; A18 a18; };
+struct __attribute__((packed)) PackedArguments<void, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> { A0 a0; A1 a1; A2 a2; A3 a3; A4 a4; A5 a5; A6 a6; A7 a7; A8 a8; A9 a9; A10 a10; A11 a11; A12 a12; A13 a13; A14 a14; A15 a15; A16 a16; A17 a17; A18 a18; };
 
 // Helper struct that allows assigning the result of a function to a variable, even if that result is a void type.
 //

From 44df42dd02b29ece97bb6643ed2d477c404cb1ca Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Thu, 31 Aug 2023 17:15:54 +0200
Subject: [PATCH 42/48] TODOSQUASH. Simplify this code. Not sure if correct

---
 ThunkLibs/include/common/Host.h | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index b55f46a0a4..90a7923410 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -428,11 +428,9 @@ inline guest_layout<T> to_guest(const host_layout<T>& from) requires(!std::is_po
   if constexpr (std::is_enum_v<T>) {
     // enums are represented by fixed-size integers in guest_layout, so explicitly cast them
     return guest_layout<T> { static_cast<std::underlying_type_t<T>>(from.data) };
-  } else if constexpr (!std::is_same_v<T, uint32_t>) {
+  } else {
     guest_layout<T> ret { .data = from.data };
     return ret;
-  } else {
-    return guest_layout<uint32_t> { from.data };
   }
 }
 

From 68266def32ee046eecb8e691e5cee1983d728576 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Mon, 4 Sep 2023 16:46:30 +0200
Subject: [PATCH 43/48] TODOFINISH. Fix 32-bit jemalloc symbols

---
 FEXCore/Source/Utils/Allocator.cpp        | 2 +-
 FEXCore/include/FEXCore/Utils/Allocator.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/FEXCore/Source/Utils/Allocator.cpp b/FEXCore/Source/Utils/Allocator.cpp
index 44415ec7ff..cd77066e4c 100644
--- a/FEXCore/Source/Utils/Allocator.cpp
+++ b/FEXCore/Source/Utils/Allocator.cpp
@@ -82,7 +82,7 @@ namespace FEXCore::Allocator {
   // so that when the sbrk syscall is used to allocate more memory, it fails with an ENOMEM since it runs in to the allocated guard page.
   //
   // glibc notices the sbrk failure and falls back to regular mmap based allocations when this occurs. Ensuring that memory can still be allocated.
-  void *DisableSBRKAllocations() {
+  extern "C" void *DisableSBRKAllocations() {
     void* INVALID_PTR = reinterpret_cast<void*>(~0ULL);
     // Get the starting sbrk pointer.
     void *StartingSBRK = sbrk(0);
diff --git a/FEXCore/include/FEXCore/Utils/Allocator.h b/FEXCore/include/FEXCore/Utils/Allocator.h
index 73d287c38d..dcd84a6c4b 100644
--- a/FEXCore/include/FEXCore/Utils/Allocator.h
+++ b/FEXCore/include/FEXCore/Utils/Allocator.h
@@ -62,7 +62,7 @@ namespace FEXCore::Allocator {
 
   // Disable allocations through glibc's sbrk allocation method.
   // Returns a pointer at the end of the sbrk region.
-  FEX_DEFAULT_VISIBILITY void *DisableSBRKAllocations();
+  extern "C" FEX_DEFAULT_VISIBILITY void *DisableSBRKAllocations();
 
   // Allow sbrk again. Pass in the pointer returned by `DisableSBRKAllocations`
   FEX_DEFAULT_VISIBILITY void ReenableSBRKAllocations(void* Ptr);

From 77d84ac660a3e6d8fdee0477054bd68963ca9996 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Mon, 4 Sep 2023 16:43:41 +0200
Subject: [PATCH 44/48] TODO SPLIT host.h changes. Thunks/libwayland: Add
 32-bit specific bits

---
 ThunkLibs/GuestLibs/CMakeLists.txt            |   6 +-
 ThunkLibs/HostLibs/CMakeLists.txt             |  13 +-
 ThunkLibs/include/common/Host.h               |   7 +-
 ThunkLibs/libwayland-client/Guest.cpp         | 163 ++++----
 ThunkLibs/libwayland-client/Host.cpp          | 382 +++++++++++++++++-
 .../libwayland-client_interface.cpp           |  43 +-
 6 files changed, 510 insertions(+), 104 deletions(-)

diff --git a/ThunkLibs/GuestLibs/CMakeLists.txt b/ThunkLibs/GuestLibs/CMakeLists.txt
index 579998bf82..d8380ea527 100644
--- a/ThunkLibs/GuestLibs/CMakeLists.txt
+++ b/ThunkLibs/GuestLibs/CMakeLists.txt
@@ -233,9 +233,6 @@ if (BITNESS EQUAL 64)
   target_compile_definitions(libxcb-guest-deps INTERFACE -DXCB_VERSION_MINOR=${XCB_VERSION_MINOR})
   target_compile_definitions(libxcb-guest-deps INTERFACE -DXCB_VERSION_PATCH=${XCB_VERSION_PATCH})
 
-  generate(libwayland-client ${CMAKE_CURRENT_SOURCE_DIR}/../libwayland-client/libwayland-client_interface.cpp)
-  add_guest_lib(wayland-client "libwayland-client.so.0.20.0")
-
   generate(libxcb-dri2 ${CMAKE_CURRENT_SOURCE_DIR}/../libxcb-dri2/libxcb-dri2_interface.cpp)
   add_guest_lib(xcb-dri2 "libxcb-dri2.so.0")
 
@@ -299,3 +296,6 @@ endif()
 
 generate(libfex_thunk_test ${CMAKE_CURRENT_SOURCE_DIR}/../libfex_thunk_test/libfex_thunk_test_interface.cpp)
 add_guest_lib(fex_thunk_test "libfex_thunk_test.so")
+
+generate(libwayland-client ${CMAKE_CURRENT_SOURCE_DIR}/../libwayland-client/libwayland-client_interface.cpp)
+add_guest_lib(wayland-client "libwayland-client.so.0.20.0")
diff --git a/ThunkLibs/HostLibs/CMakeLists.txt b/ThunkLibs/HostLibs/CMakeLists.txt
index f153ccd92b..18e78a014f 100644
--- a/ThunkLibs/HostLibs/CMakeLists.txt
+++ b/ThunkLibs/HostLibs/CMakeLists.txt
@@ -96,9 +96,9 @@ function(add_host_lib NAME GUEST_BITNESS)
   endif()
 endfunction()
 
-#set (BITNESS_LIST "32;64")
-set (BITNESS_LIST "64")
+set (BITNESS_LIST "32;64")
 foreach(GUEST_BITNESS IN LISTS BITNESS_LIST)
+if (GUEST_BITNESS EQUAL 64)
   #add_host_lib(fex_malloc_symbols ${GUEST_BITNESS})
 
   #generate(libfex_malloc)
@@ -149,7 +149,12 @@ foreach(GUEST_BITNESS IN LISTS BITNESS_LIST)
   generate(libvulkan ${CMAKE_CURRENT_SOURCE_DIR}/../libvulkan/libvulkan_interface.cpp ${GUEST_BITNESS})
   target_include_directories(libvulkan-${GUEST_BITNESS}-deps INTERFACE ${FEX_PROJECT_SOURCE_DIR}/External/Vulkan-Headers/include/)
   add_host_lib(vulkan ${GUEST_BITNESS})
+endif()
+
+  generate(libwayland-client ${CMAKE_CURRENT_SOURCE_DIR}/../libwayland-client/libwayland-client_interface.cpp ${GUEST_BITNESS})
+  add_host_lib(wayland-client ${GUEST_BITNESS})
 
+if (GUEST_BITNESS EQUAL 64)
   find_package(PkgConfig)
   pkg_search_module(XCB REQUIRED xcb)
   version_to_variables(${XCB_VERSION} XCB)
@@ -161,9 +166,6 @@ foreach(GUEST_BITNESS IN LISTS BITNESS_LIST)
   target_compile_definitions(libxcb-${GUEST_BITNESS}-deps INTERFACE -DXCB_VERSION_MINOR=${XCB_VERSION_MINOR})
   target_compile_definitions(libxcb-${GUEST_BITNESS}-deps INTERFACE -DXCB_VERSION_PATCH=${XCB_VERSION_PATCH})
 
-  generate(libwayland-client ${CMAKE_CURRENT_SOURCE_DIR}/../libwayland-client/libwayland-client_interface.cpp ${GUEST_BITNESS})
-  add_host_lib(wayland-client ${GUEST_BITNESS})
-
   generate(libxcb-dri2 ${CMAKE_CURRENT_SOURCE_DIR}/../libxcb-dri2/libxcb-dri2_interface.cpp ${GUEST_BITNESS})
   add_host_lib(xcb-dri2 ${GUEST_BITNESS})
 
@@ -195,6 +197,7 @@ foreach(GUEST_BITNESS IN LISTS BITNESS_LIST)
   target_include_directories(libdrm-${GUEST_BITNESS}-deps INTERFACE /usr/include/drm/)
   target_include_directories(libdrm-${GUEST_BITNESS}-deps INTERFACE /usr/include/libdrm/)
   add_host_lib(drm ${GUEST_BITNESS})
+endif()
 
   generate(libfex_thunk_test ${CMAKE_CURRENT_SOURCE_DIR}/../libfex_thunk_test/libfex_thunk_test_interface.cpp ${GUEST_BITNESS})
   add_host_lib(fex_thunk_test ${GUEST_BITNESS})
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index 90a7923410..aad83ad3f1 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -428,6 +428,9 @@ inline guest_layout<T> to_guest(const host_layout<T>& from) requires(!std::is_po
   if constexpr (std::is_enum_v<T>) {
     // enums are represented by fixed-size integers in guest_layout, so explicitly cast them
     return guest_layout<T> { static_cast<std::underlying_type_t<T>>(from.data) };
+  } else if constexpr (std::is_same_v<T, uint32_t>) {
+    // Handle guest_layout<uint32_t> separately, since it's specialized and uses custom constructors
+    return guest_layout<uint32_t> { from.data };
   } else {
     guest_layout<T> ret { .data = from.data };
     return ret;
@@ -528,8 +531,8 @@ struct CallbackUnpack<Result(Args...)> {
     GuestcallInfo *guestcall;
     LOAD_INTERNAL_GUESTPTR_VIA_CUSTOM_ABI(guestcall);
 
-    PackedArguments<Result, Args...> packed_args = {
-      args...
+    PackedArguments<Result, guest_layout<Args>...> packed_args = {
+      { to_guest(to_host_layout(args)) }...
     };
     guestcall->CallCallback(guestcall->GuestUnpacker, guestcall->GuestTarget, &packed_args);
     if constexpr (!std::is_void_v<Result>) {
diff --git a/ThunkLibs/libwayland-client/Guest.cpp b/ThunkLibs/libwayland-client/Guest.cpp
index 5f8fb7e996..067f586b5f 100644
--- a/ThunkLibs/libwayland-client/Guest.cpp
+++ b/ThunkLibs/libwayland-client/Guest.cpp
@@ -14,14 +14,14 @@ tags: thunklibs|wayland-client
 //       initializers. There is a workaround to enable late initialization anyway in OnInit.
 // NOTE: We only need to do this for interfaces exported by libwayland-client itself. Interfaces
 //       defined by external libraries work fine.
-extern "C" const wl_interface wl_output_interface {};
-extern "C" const wl_interface wl_shm_pool_interface {};
-extern "C" const wl_interface wl_pointer_interface {};
-extern "C" const wl_interface wl_compositor_interface {};
-extern "C" const wl_interface wl_shm_interface {};
-extern "C" const wl_interface wl_registry_interface {};
-extern "C" const wl_interface wl_buffer_interface {};
-extern "C" const wl_interface wl_seat_interface {};
+extern "C" const wl_interface wl_output_interface{};
+extern "C" const wl_interface wl_shm_pool_interface{};
+extern "C" const wl_interface wl_pointer_interface{};
+extern "C" const wl_interface wl_compositor_interface{};
+extern "C" const wl_interface wl_shm_interface{};
+extern "C" const wl_interface wl_registry_interface{};
+extern "C" const wl_interface wl_buffer_interface{};
+extern "C" const wl_interface wl_seat_interface{};
 extern "C" const wl_interface wl_surface_interface {};
 extern "C" const wl_interface wl_keyboard_interface {};
 extern "C" const wl_interface wl_callback_interface {};
@@ -37,12 +37,13 @@ extern "C" const wl_interface wl_callback_interface {};
 
 #include "common/Guest.h"
 
-#include "thunkgen_guest_libwayland-client.inl"
+#include <map>
 
-struct wl_proxy_private {
-  wl_interface* interface;
-  // Other data members omitted
-};
+#include <stdarg.h>
+
+#include <sys/mman.h>
+
+#include "thunkgen_guest_libwayland-client.inl"
 
 // See wayland-util.h for documentation on protocol message signatures
 template<char> struct ArgType;
@@ -56,37 +57,31 @@ template<> struct ArgType<'f'> { using type = wl_fixed_t; };
 template<> struct ArgType<'h'> { using type = int32_t; }; // fd?
 
 template<char... Signature>
-static void* WaylandAllocateHostTrampolineForGuestListener(void (*callback)()) {
+static uint64_t WaylandAllocateHostTrampolineForGuestListener(void (*callback)()) {
   using cb = void(void*, wl_proxy*, typename ArgType<Signature>::type...);
-  return (void*)AllocateHostTrampolineForGuestFunction((cb*)callback);
+  return (uint64_t)(uintptr_t)(void*)AllocateHostTrampolineForGuestFunction((cb*)callback);
 }
 
 #define WL_CLOSURE_MAX_ARGS 20
 
-// Per-proxy list of callbacks set up via wl_proxy_add_listener.
-// These tables store the host-callable trampolines to the actual listener
-// callbacks provided by the guest application.
-// NOTE: There can only be one listener per proxy. Wayland will return an error
-//       if wl_proxy_add_listener is called twice.
-// NOTE: Entries should be removed in wl_destroy_proxy. Since proxy wrappers do
-//       not use their own listeners, wl_proxy_wrapper_destroy does not need to
-//       be customized.
-static std::unordered_map<wl_proxy*, std::array<void*, WL_CLOSURE_MAX_ARGS>> proxy_listeners;
-
 extern "C" int wl_proxy_add_listener(wl_proxy *proxy,
       void (**callback)(void), void *data) {
-  auto interface = ((wl_proxy_private*)proxy)->interface;
 
-  // NOTE: This table must remain valid past the return of this function.
-  auto& host_callbacks = proxy_listeners[proxy];
+  // NOTE: This pointer must remain valid past the return of this function.
+  // TODO: What's a good way to manage the lifetime of this?
+  auto& host_callbacks = *new std::array<uint64_t, WL_CLOSURE_MAX_ARGS>;
+
 
-  for (int i = 0; i < ((wl_proxy_private*)proxy)->interface->event_count; ++i) {
-    auto signature_view = std::string_view { interface->events[i].signature };
+// TODO: Fixup for 32-bit...
+  for (int i = 0; i < fex_wl_get_interface_event_count(proxy); ++i) {
+    char event_signature[16];
+    fex_wl_get_interface_event_signature(proxy, i, event_signature);
+    auto signature2 = std::string_view { event_signature };
 
     // A leading number indicates the minimum protocol version
     uint32_t since_version = 0;
-    auto [ptr, res] = std::from_chars(signature_view.begin(), signature_view.end(), since_version, 10);
-    std::string signature { ptr, &*signature_view.end() };
+    auto [ptr, res] = std::from_chars(signature2.begin(), signature2.end(), since_version, 10);
+    auto signature = std::string { signature2.substr(ptr - signature2.begin()) };
 
     // ? just indicates that the argument may be null, so it doesn't change the signature
     signature.erase(std::remove(signature.begin(), signature.end(), '?'), signature.end());
@@ -185,7 +180,7 @@ extern "C" int wl_proxy_add_listener(wl_proxy *proxy,
       // E.g. zwp_text_input_v3::preedit_string
       host_callbacks[i] = WaylandAllocateHostTrampolineForGuestListener<'s', 'i', 'i'>(callback[i]);
     } else {
-      fprintf(stderr, "Unknown wayland signature descriptor \"%s\" for event \"%s\" in interface \"%s\"\n", signature.data(), interface->events[i].name, interface->name);
+      fprintf(stderr, "TODO: Unknown wayland event signature descriptor %s\n", signature.data());
       std::abort();
     }
   }
@@ -193,15 +188,15 @@ extern "C" int wl_proxy_add_listener(wl_proxy *proxy,
   return fexfn_pack_wl_proxy_add_listener(proxy, (void(**)())host_callbacks.data(), data);
 }
 
-extern "C" void wl_proxy_destroy(struct wl_proxy *proxy) {
-  proxy_listeners.erase(proxy);
-  return fexfn_pack_wl_proxy_destroy(proxy);
-}
+struct argument_details {
+  char type;
+  int nullable;
+};
 
-// Adapted from the Wayland sources
-static const char* get_next_argument_type(const char *signature, char &type)
+static const char* get_next_argument(const char *signature, argument_details *details)
 {
-  for (; *signature; ++signature) {
+  details->nullable = 0;
+  for(; *signature; ++signature) {
     switch(*signature) {
     case 'i':
     case 'u':
@@ -211,26 +206,27 @@ static const char* get_next_argument_type(const char *signature, char &type)
     case 'n':
     case 'a':
     case 'h':
-      type = *signature;
+      details->type = *signature;
       return signature + 1;
-
-    default:
-      continue;
+    case '?':
+      details->nullable = 1;
     }
   }
-  type = 0;
+  details->type = '\0';
   return signature;
 }
 
 static void wl_argument_from_va_list(const char *signature, wl_argument *args,
                                      int count, va_list ap) {
+  int i;
+  const char *sig_iter;
+  argument_details arg;
 
-  auto sig_iter = signature;
-  for (int i = 0; i < count; i++) {
-    char arg_type;
-    sig_iter = get_next_argument_type(sig_iter, arg_type);
+  sig_iter = signature;
+  for (i = 0; i < count; i++) {
+    sig_iter = get_next_argument(sig_iter, &arg);
 
-    switch (arg_type) {
+    switch (arg.type) {
     case 'i':
       args[i].i = va_arg(ap, int32_t);
       break;
@@ -266,18 +262,48 @@ extern "C" void wl_proxy_marshal(wl_proxy *proxy, uint32_t opcode, ...) {
   va_list ap;
 
   va_start(ap, opcode);
-#ifdef IS_32BIT_THUNK
-// Must extract signature from host due to different data layout on 32-bit
-#error Not implemented
-#else
-  wl_argument_from_va_list(((wl_proxy_private*)proxy)->interface->methods[opcode].signature,
-                           args, WL_CLOSURE_MAX_ARGS, ap);
-#endif
+  // This is equivalent to reading ((wl_proxy_private*)proxy)->interface->methods[opcode].signature on 64-bit.
+  // On 32-bit, the data layout differs between host and guest however, so we let the host extract the data.
+  char signature[64];
+  fex_wl_get_method_signature(proxy, opcode, signature);
+  wl_argument_from_va_list(signature, args, WL_CLOSURE_MAX_ARGS, ap);
   va_end(ap);
 
   wl_proxy_marshal_array(proxy, opcode, args);
 }
 
+extern "C" wl_proxy *wl_proxy_marshal_constructor(wl_proxy *proxy, uint32_t opcode,
+           const wl_interface *interface, ...) {
+  wl_argument args[WL_CLOSURE_MAX_ARGS];
+  va_list ap;
+
+  va_start(ap, interface);
+  // This is equivalent to reading ((wl_proxy_private*)proxy)->interface->methods[opcode].signature on 64-bit.
+  // On 32-bit, the data layout differs between host and guest however, so we let the host extract the data.
+  char signature[64];
+  fex_wl_get_method_signature(proxy, opcode, signature);
+  wl_argument_from_va_list(signature, args, WL_CLOSURE_MAX_ARGS, ap);
+  va_end(ap);
+
+  return wl_proxy_marshal_array_constructor(proxy, opcode, args, interface);
+}
+
+extern "C" wl_proxy *wl_proxy_marshal_constructor_versioned(wl_proxy *proxy, uint32_t opcode,
+           const wl_interface *interface, uint32_t version, ...) {
+  wl_argument args[WL_CLOSURE_MAX_ARGS];
+  va_list ap;
+
+  va_start(ap, version);
+  // This is equivalent to reading ((wl_proxy_private*)proxy)->interface->methods[opcode].signature on 64-bit.
+  // On 32-bit, the data layout differs between host and guest however, so we let the host extract the data.
+  char signature[64];
+  fex_wl_get_method_signature(proxy, opcode, signature);
+  wl_argument_from_va_list(signature, args, WL_CLOSURE_MAX_ARGS, ap);
+  va_end(ap);
+
+  return wl_proxy_marshal_array_constructor_versioned(proxy, opcode, args, interface, version);
+}
+
 extern "C" wl_proxy *wl_proxy_marshal_flags(wl_proxy *proxy, uint32_t opcode,
            const wl_interface *interface,
            uint32_t version,
@@ -286,24 +312,21 @@ extern "C" wl_proxy *wl_proxy_marshal_flags(wl_proxy *proxy, uint32_t opcode,
   va_list ap;
 
   va_start(ap, flags);
-#ifdef IS_32BIT_THUNK
-// Must extract signature from host due to different data layout on 32-bit
-#error Not implemented
-#else
-  wl_argument_from_va_list(((wl_proxy_private*)proxy)->interface->methods[opcode].signature,
-                           args, WL_CLOSURE_MAX_ARGS, ap);
-#endif
+  // This is equivalent to reading ((wl_proxy_private*)proxy)->interface->methods[opcode].signature on 64-bit.
+  // On 32-bit, the data layout differs between host and guest however, so we let the host extract the data.
+  char signature[64];
+  fex_wl_get_method_signature(proxy, opcode, signature);
+  wl_argument_from_va_list(signature, args, WL_CLOSURE_MAX_ARGS, ap);
   va_end(ap);
 
-  // wl_proxy_marshal_array_flags is only available starting from Wayland 1.19.91
-#if WAYLAND_VERSION_MAJOR * 10000 + WAYLAND_VERSION_MINOR * 100 + WAYLAND_VERSION_MICRO >= 11991
   return wl_proxy_marshal_array_flags(proxy, opcode, interface, version, flags, args);
-#else
-  fprintf(stderr, "Host Wayland version is too old to support FEX thunking\n");
-  __builtin_trap();
-#endif
 }
 
+extern "C" void wl_log_set_handler_client(wl_log_func_t handler) {
+  // Ignore
+}
+
+
 void OnInit() {
   fex_wl_exchange_interface_pointer(const_cast<wl_interface*>(&wl_output_interface), "wl_output");
   fex_wl_exchange_interface_pointer(const_cast<wl_interface*>(&wl_shm_pool_interface), "wl_shm_pool");
diff --git a/ThunkLibs/libwayland-client/Host.cpp b/ThunkLibs/libwayland-client/Host.cpp
index dd0b5b763c..8c471bb908 100644
--- a/ThunkLibs/libwayland-client/Host.cpp
+++ b/ThunkLibs/libwayland-client/Host.cpp
@@ -5,6 +5,7 @@ tags: thunklibs|wayland-client
 */
 
 #include <string_view>
+#include <unordered_map>
 #include <wayland-client.h>
 
 #include <stdio.h>
@@ -21,13 +22,286 @@ tags: thunklibs|wayland-client
 #include <map>
 #include <string>
 
+#include <ranges>
+
+template<>
+struct guest_layout<wl_argument> {
+#ifdef IS_32BIT_THUNK
+  using type = uint32_t;
+#else
+  using type = wl_argument;
+#endif
+  type data;
+
+  // TODO: Make this conversion explicit
+  guest_layout& operator=(const wl_argument from) {
+#ifdef IS_32BIT_THUNK
+    data = from.u;
+#else
+    data = from;
+#endif
+    return *this;
+  }
+};
+
+
 #include "thunkgen_host_libwayland-client.inl"
 
+// Maps guest interface to host_interfaces
+static std::map<void*, wl_interface*> guest_to_host_interface;
+
 struct wl_proxy_private {
   wl_interface* interface;
   // Other data members omitted
 };
 
+static wl_interface* lookup_wl_interface(const wl_interface* interface);
+
+#ifdef IS_32BIT_THUNK
+static void repack_guest_wl_interface_to_host(const wl_interface* guest_interface, wl_interface* host_interface) {
+  struct guest_wl_message {
+    guest_layout<char*> name;
+    guest_layout<char*> signature;
+    guest_layout<wl_interface**> types;
+  };
+
+  // Name pointer (offset 0) can safely be zero-extended
+  host_interface->name = (const char*)(uintptr_t)(uint32_t)reinterpret_cast<uintptr_t>(guest_interface->name);
+  memcpy(&host_interface->version, reinterpret_cast<const char*>(guest_interface) + 4, 4);
+  memcpy(&host_interface->method_count, reinterpret_cast<const char*>(guest_interface) + 8, 4);
+  // TODO: Manage lifetime of this memory?
+  host_interface->methods = new wl_message[host_interface->method_count];
+  memset((void*)host_interface->methods, 0, sizeof(wl_message) * host_interface->method_count);
+  for (int i = 0; i < host_interface->method_count; ++i) {
+    auto guest_method = &((*(guest_wl_message**)(reinterpret_cast<const char*>(guest_interface) + 12))[i]);
+    guest_method = (guest_wl_message*)((uintptr_t)guest_method & 0xffffffff);
+    // Sign-extend these pointers
+    auto name_ptr = guest_method->name.get_pointer();
+    memcpy((void*)&host_interface->methods[i].name, &name_ptr, sizeof(name_ptr));
+    auto sig_ptr = guest_method->signature.get_pointer();
+    memcpy((void*)&host_interface->methods[i].signature, &sig_ptr, sizeof(sig_ptr));
+
+    // TODO: Handle zero-argument case... can't use new with 0 elements!
+    auto num_types = std::ranges::count_if(std::string_view { host_interface->methods[i].signature }, [](char c) { return std::isalpha(c); });
+    auto types = new wl_interface*[num_types];
+    for (int type = 0; type < num_types; ++type) {
+      uintptr_t guest_interface_addr = ((uint32_t*)(uintptr_t)guest_method->types.data)[type];
+      types[type] = guest_interface_addr ? lookup_wl_interface(reinterpret_cast<const wl_interface*>(guest_interface_addr)) : nullptr;
+      fprintf(stderr, "  METHOD %d type %d: %p\n", i, type, types[type]);
+    }
+    memcpy((void*)&host_interface->methods[i].types, &types, sizeof(types));
+  }
+
+  memcpy(&host_interface->event_count, reinterpret_cast<const char*>(guest_interface) + 16, sizeof(host_interface->event_count));
+  // TODO: Manage lifetime of this memory?
+  host_interface->events = new wl_message[host_interface->event_count];
+  memset((void*)host_interface->events, 0, sizeof(wl_message) * host_interface->event_count);
+  for (int i = 0; i < host_interface->event_count; ++i) {
+    auto guest_event = &((*(guest_wl_message**)(reinterpret_cast<const char*>(guest_interface) + 20))[i]);
+    guest_event = (guest_wl_message*)((uintptr_t)guest_event & 0xffffffff);
+    // Sign-extend these pointers
+    auto name_ptr = guest_event->name.get_pointer();
+    memcpy((void*)&host_interface->events[i].name, &name_ptr, sizeof(name_ptr));
+    auto sig_ptr = guest_event->signature.get_pointer();
+    memcpy((void*)&host_interface->events[i].signature, &sig_ptr, sizeof(sig_ptr));
+
+    auto num_types = std::ranges::count_if(std::string_view { host_interface->events[i].signature }, [](char c) { return std::isalpha(c); });
+    auto types = new wl_interface*[num_types];
+    for (int type = 0; type < num_types; ++type) {
+      uintptr_t guest_interface_addr = ((uint32_t*)(uintptr_t)guest_event->types.data)[type];
+      types[type] = guest_interface_addr ? lookup_wl_interface(reinterpret_cast<const wl_interface*>(guest_interface_addr)) : nullptr;
+    }
+    memcpy((void*)&host_interface->events[i].types, &types, sizeof(types));
+  }
+}
+#endif
+
+// Maps guest interface pointers to host pointers
+wl_interface* lookup_wl_interface(const wl_interface* interface) {
+  // Used e.g. for wl_shm_pool_destroy
+  if (interface == nullptr) {
+    return nullptr;
+  }
+
+  if (!guest_to_host_interface.count((void*)interface)) {
+  bool is_host = (uint32_t)interface->method_count < 0x1000 && (uint32_t)interface->event_count < 0x1000;
+    fprintf(stderr, "Unknown wayland interface %p, adding to registry (as %s)\n", interface, is_host ? "host" : "guest");
+    auto [host_interface_it, inserted] = guest_to_host_interface.emplace((void*)interface, new wl_interface);
+#ifdef IS_32BIT_THUNK
+if ((uint32_t)interface->method_count < 0x1000 && (uint32_t)interface->event_count < 0x1000) {
+  // This is actually a host interface somehow reaching this function (otherwise the "method" pointer would bleed into method_count). This doesn't need repacking.
+  // TODO: Investigate if this can be avoided
+  memcpy(host_interface_it->second, interface, sizeof(wl_interface));
+} else {
+  wl_interface* host_interface = host_interface_it->second;
+  repack_guest_wl_interface_to_host(interface, host_interface);
+}
+#else
+    memcpy(host_interface_it->second, interface, sizeof(wl_interface));
+#endif
+  }
+
+  return guest_to_host_interface.at((void*)interface);
+}
+
+// TODO: Reduce code duplication between this and its _flags variant
+extern "C" void
+fexfn_impl_libwayland_client_wl_proxy_marshal_array(
+            wl_proxy *proxy, uint32_t opcode,
+            guest_layout<wl_argument*> args) {
+#define WL_CLOSURE_MAX_ARGS 20
+  std::array<wl_argument, WL_CLOSURE_MAX_ARGS> host_args;
+  for (int i = 0; i < host_args.size(); ++i) {
+    // NOTE: wl_argument can store a pointer argument, so for 32-bit guests
+    //       we need to make sure the upper 32-bits are explicitly zeroed
+    std::memset(&host_args[i], 0, sizeof(host_args[i]));
+    std::memcpy(&host_args[i], &args.get_pointer()[i], sizeof(args.get_pointer()[i]));
+  }
+
+  fexldr_ptr_libwayland_client_wl_proxy_marshal_array(proxy, opcode, host_args.data());
+}
+
+extern "C" wl_proxy*
+fexfn_impl_libwayland_client_wl_proxy_marshal_array_constructor_versioned(
+            wl_proxy *proxy, uint32_t opcode,
+            guest_layout<wl_argument*> args,
+            const wl_interface *interface,
+            uint32_t version) {
+  interface = lookup_wl_interface(interface);
+
+  // NOTE: "interface" and "name" are the first members of their respective parent structs, so this is safe to read even on 32-bit
+  if (((wl_proxy_private*)proxy)->interface->name == std::string_view { "wl_registry" }) {
+    auto& host_interface = guest_to_host_interface[(void*)interface];
+    if (!host_interface) {
+      host_interface = new wl_interface;
+#ifdef IS_32BIT_THUNK
+      if ((uint32_t)interface->method_count < 0x1000 && (uint32_t)interface->event_count < 0x1000) {
+        // This is actually a host interface somehow reaching this function (otherwise the "method" pointer would bleed into method_count). This doesn't need repacking.
+        // TODO: Investigate if this can be avoided
+        memcpy(host_interface, interface, sizeof(wl_interface));
+      } else {
+        repack_guest_wl_interface_to_host(interface, host_interface);
+      }
+#else
+      memcpy(host_interface, interface, sizeof(wl_interface));
+#endif
+    }
+  }
+
+#define WL_CLOSURE_MAX_ARGS 20
+  std::array<wl_argument, WL_CLOSURE_MAX_ARGS> host_args;
+  for (int i = 0; i < host_args.size(); ++i) {
+    // NOTE: wl_argument can store a pointer argument, so for 32-bit guests
+    //       we need to make sure the upper 32-bits are explicitly zeroed
+    std::memset(&host_args[i], 0, sizeof(host_args[i]));
+    std::memcpy(&host_args[i], &args.get_pointer()[i], sizeof(args.get_pointer()[i]));
+  }
+
+  return fexldr_ptr_libwayland_client_wl_proxy_marshal_array_constructor_versioned(proxy, opcode, host_args.data(), interface, version);
+}
+
+extern "C" wl_proxy*
+fexfn_impl_libwayland_client_wl_proxy_marshal_array_constructor(
+            wl_proxy *proxy, uint32_t opcode,
+            guest_layout<wl_argument*> args,
+            const wl_interface *interface) {
+  interface = lookup_wl_interface(interface);
+
+  // NOTE: "interface" and "name" are the first members of their respective parent structs, so this is safe to read even on 32-bit
+  if (((wl_proxy_private*)proxy)->interface->name == std::string_view { "wl_registry" }) {
+    auto& host_interface = guest_to_host_interface[(void*)interface];
+    if (!host_interface) {
+      host_interface = new wl_interface;
+#ifdef IS_32BIT_THUNK
+      if ((uint32_t)interface->method_count < 0x1000 && (uint32_t)interface->event_count < 0x1000) {
+        // This is actually a host interface somehow reaching this function (otherwise the "method" pointer would bleed into method_count). This doesn't need repacking.
+        // TODO: Investigate if this can be avoided
+        memcpy(host_interface, interface, sizeof(wl_interface));
+      } else {
+        repack_guest_wl_interface_to_host(interface, host_interface);
+      }
+#else
+      memcpy(host_interface, interface, sizeof(wl_interface));
+#endif
+    }
+  }
+
+#define WL_CLOSURE_MAX_ARGS 20
+  std::array<wl_argument, WL_CLOSURE_MAX_ARGS> host_args;
+  for (int i = 0; i < host_args.size(); ++i) {
+    // NOTE: wl_argument can store a pointer argument, so for 32-bit guests
+    //       we need to make sure the upper 32-bits are explicitly zeroed
+    std::memset(&host_args[i], 0, sizeof(host_args[i]));
+    std::memcpy(&host_args[i], &args.get_pointer()[i], sizeof(args.get_pointer()[i]));
+  }
+
+  return fexldr_ptr_libwayland_client_wl_proxy_marshal_array_constructor(proxy, opcode, host_args.data(), interface);
+}
+
+extern "C" wl_proxy*
+fexfn_impl_libwayland_client_wl_proxy_marshal_array_flags(
+            wl_proxy *proxy, uint32_t opcode,
+            const wl_interface *interface,
+            uint32_t version, uint32_t flags,
+            guest_layout<wl_argument*> args) {
+  interface = lookup_wl_interface(interface);
+
+  // NOTE: "interface" and "name" are the first members of their respective parent structs, so this is safe to read even on 32-bit
+  if (((wl_proxy_private*)proxy)->interface->name == std::string_view { "wl_registry" }) {
+    auto& host_interface = guest_to_host_interface[(void*)interface];
+    if (!host_interface) {
+      host_interface = new wl_interface;
+#ifdef IS_32BIT_THUNK
+      if ((uint32_t)interface->method_count < 0x1000 && (uint32_t)interface->event_count < 0x1000) {
+        // This is actually a host interface somehow reaching this function (otherwise the "method" pointer would bleed into method_count). This doesn't need repacking.
+        // TODO: Investigate if this can be avoided
+        memcpy(host_interface, interface, sizeof(wl_interface));
+      } else {
+        repack_guest_wl_interface_to_host(interface, host_interface);
+      }
+#else
+      memcpy(host_interface, interface, sizeof(wl_interface));
+#endif
+    }
+  }
+
+#define WL_CLOSURE_MAX_ARGS 20
+  std::array<wl_argument, WL_CLOSURE_MAX_ARGS> host_args;
+  for (int i = 0; i < host_args.size(); ++i) {
+    // NOTE: wl_argument can store a pointer argument, so for 32-bit guests
+    //       we need to make sure the upper 32-bits are explicitly zeroed
+    std::memset(&host_args[i], 0, sizeof(host_args[i]));
+    std::memcpy(&host_args[i], &args.get_pointer()[i], sizeof(args.get_pointer()[i]));
+  }
+
+  return fexldr_ptr_libwayland_client_wl_proxy_marshal_array_flags(proxy, opcode, interface, version, flags, host_args.data());
+}
+
+// Generalization of CallbackUnpack::CallGuestPtr that repacks an wl_array parameter
+// TODO: Provide a generic solution for this...
+template<typename Result, typename... Args>
+static auto CallGuestPtrWithWaylandArray(Args... args, struct wl_array *array) -> Result {
+  GuestcallInfo *guestcall;
+  LOAD_INTERNAL_GUESTPTR_VIA_CUSTOM_ABI(guestcall);
+
+  // TODO: What lifetime does this have? Can it be stack-allocated instead?
+  // TODO: Cleanup memory if heap allocation is indeed necessary
+  guest_layout<wl_array>* guest_array = new guest_layout<wl_array>;
+  guest_array->data.size = array->size;
+  guest_array->data.alloc = array->alloc;
+  guest_array->data.data = array->data;
+  guest_layout<wl_array*> guest_array_ptr = { .data = static_cast<guest_layout<wl_array*>::type>(reinterpret_cast<uintptr_t>(guest_array)) };
+
+  PackedArguments<Result, guest_layout<Args>..., guest_layout<wl_array*>> packed_args = {
+    to_guest(to_host_layout(args))..., guest_array_ptr
+  };
+  guestcall->CallCallback(guestcall->GuestUnpacker, guestcall->GuestTarget, &packed_args);
+
+  if constexpr (!std::is_void_v<Result>) {
+    return packed_args.rv;
+  }
+}
+
 // See wayland-util.h for documentation on protocol message signatures
 template<char> struct ArgType;
 template<> struct ArgType<'s'> { using type = const char*; };
@@ -46,8 +320,13 @@ static void WaylandFinalizeHostTrampolineForGuestListener(void (*callback)()) {
 }
 
 extern "C" int fexfn_impl_libwayland_client_wl_proxy_add_listener(struct wl_proxy *proxy,
-      guest_layout<void (**)(void)> callback_raw, guest_layout<void*> data) {
-  auto guest_interface = ((wl_proxy_private*)proxy)->interface;
+      guest_layout<void (**)(void)> callback, guest_layout<void *> data) {
+
+  auto guest_interface = lookup_wl_interface(((wl_proxy_private*)proxy)->interface);
+
+  // Drop upper 32-bits, since they are likely garbage... TODO: Let the repacker do this, or check if it's already done even
+//  auto callback2 = (uint32_t*)(uintptr_t)(uint32_t)(uintptr_t)callback;
+  auto callback2 = (void(**)(void))callback.get_pointer();
 
   for (int i = 0; i < guest_interface->event_count; ++i) {
     auto signature_view = std::string_view { guest_interface->events[i].signature };
@@ -55,19 +334,21 @@ extern "C" int fexfn_impl_libwayland_client_wl_proxy_add_listener(struct wl_prox
     // A leading number indicates the minimum protocol version
     uint32_t since_version = 0;
     auto [ptr, res] = std::from_chars(signature_view.begin(), signature_view.end(), since_version, 10);
-    std::string signature { ptr, &*signature_view.end() };
+    auto signature = std::string { signature_view.substr(ptr - signature_view.begin()) };
 
     // ? just indicates that the argument may be null, so it doesn't change the signature
     signature.erase(std::remove(signature.begin(), signature.end(), '?'), signature.end());
 
-    auto callback = reinterpret_cast<void(*)()>(uintptr_t { callback_raw.get_pointer()[i].data });
+    auto callback = callback2[i];
 
     if (signature == "") {
       // E.g. xdg_toplevel::close
       WaylandFinalizeHostTrampolineForGuestListener<>(callback);
     } else if (signature == "a") {
       // E.g. xdg_toplevel::wm_capabilities
-      WaylandFinalizeHostTrampolineForGuestListener<'a'>(callback);
+      FEXCore::FinalizeHostTrampolineForGuestFunction(
+          (FEXCore::HostToGuestTrampolinePtr*)callback,
+          (void*)CallGuestPtrWithWaylandArray<void, void*, wl_proxy*>);
     } else if (signature == "hu") {
       // E.g. zwp_linux_dmabuf_feedback_v1::format_table
       WaylandFinalizeHostTrampolineForGuestListener<'h', 'u'>(callback);
@@ -85,7 +366,9 @@ extern "C" int fexfn_impl_libwayland_client_wl_proxy_add_listener(struct wl_prox
       WaylandFinalizeHostTrampolineForGuestListener<'i', 'i'>(callback);
     } else if (signature == "iia") {
       // E.g. xdg_toplevel::configure
-      WaylandFinalizeHostTrampolineForGuestListener<'i', 'i', 'a'>(callback);
+      FEXCore::FinalizeHostTrampolineForGuestFunction(
+          (FEXCore::HostToGuestTrampolinePtr*)callback,
+          (void*)CallGuestPtrWithWaylandArray<void, void*, wl_proxy*, int32_t, int32_t>);
     } else if (signature == "iiiiissi") {
       // E.g. wl_output_listener::geometry
       WaylandFinalizeHostTrampolineForGuestListener<'i', 'i', 'i', 'i', 'i', 's', 's', 'i'>(callback);
@@ -118,7 +401,9 @@ extern "C" int fexfn_impl_libwayland_client_wl_proxy_add_listener(struct wl_prox
       WaylandFinalizeHostTrampolineForGuestListener<'u', 'o'>(callback);
     } else if (signature == "uoa") {
       // E.g. wl_keyboard_listener::enter
-      WaylandFinalizeHostTrampolineForGuestListener<'u', 'o', 'a'>(callback);
+      FEXCore::FinalizeHostTrampolineForGuestFunction(
+          (FEXCore::HostToGuestTrampolinePtr*)callback,
+          (void*)CallGuestPtrWithWaylandArray<void, void*, wl_proxy*, uint32_t, wl_surface*>);
     } else if (signature == "uoff") {
       // E.g. wl_pointer_listener::enter
       WaylandFinalizeHostTrampolineForGuestListener<'u', 'o', 'f', 'f'>(callback);
@@ -159,16 +444,30 @@ extern "C" int fexfn_impl_libwayland_client_wl_proxy_add_listener(struct wl_prox
       fprintf(stderr, "TODO: Unknown wayland event signature descriptor %s\n", signature.data());
       std::abort();
     }
+
+// TODO: Is this needed?
+//    MakeHostTrampolineForGuestFunctionAsyncCallable(registry_listener.global_remove, 1);
   }
 
   // Pass the original function pointer table to the host wayland library. This ensures the table is valid until the listener is unregistered.
-  return fexldr_ptr_libwayland_client_wl_proxy_add_listener(proxy,
-                                                            reinterpret_cast<void(**)(void)>(callback_raw.get_pointer()),
-                                                            reinterpret_cast<void*>(uintptr_t { data.data }));
+  return fexldr_ptr_libwayland_client_wl_proxy_add_listener(proxy, callback2, (void*)(uintptr_t)data.data);
 }
 
-wl_interface* fexfn_impl_libwayland_client_fex_wl_exchange_interface_pointer(wl_interface* guest_interface, char const* name) {
-  auto host_interface = reinterpret_cast<wl_interface*>(dlsym(fexldr_ptr_libwayland_client_so, (std::string { name } + "_interface").c_str()));
+void* fexfn_impl_libwayland_client_wl_proxy_create_wrapper(guest_layout<void*> void_proxy) {
+  guest_layout<wl_proxy*> proxy;
+  memcpy(&proxy, &void_proxy, sizeof(void_proxy));
+  return fexldr_ptr_libwayland_client_wl_proxy_create_wrapper(host_layout<wl_proxy*> { proxy }.data);
+}
+
+void fexfn_impl_libwayland_client_wl_proxy_wrapper_destroy(guest_layout<void*> void_proxy) {
+  guest_layout<wl_proxy*> proxy;
+  memcpy(&proxy, &void_proxy, sizeof(void_proxy));
+  return fexldr_ptr_libwayland_client_wl_proxy_wrapper_destroy(host_layout<wl_proxy*> { proxy }.data);
+}
+
+wl_interface* fexfn_impl_libwayland_client_fex_wl_exchange_interface_pointer(wl_interface* guest_interface, guest_layout<char const*> name) {
+  auto& host_interface = guest_to_host_interface[(void*)guest_interface];
+  host_interface = reinterpret_cast<wl_interface*>(dlsym(fexldr_ptr_libwayland_client_so, (std::string { (const char*)name.get_pointer() } + "_interface").c_str()));
   if (!host_interface) {
     fprintf(stderr, "Could not find host interface corresponding to %p (%s)\n", guest_interface, name);
     std::abort();
@@ -185,8 +484,36 @@ wl_interface* fexfn_impl_libwayland_client_fex_wl_exchange_interface_pointer(wl_
   }
 
 #ifdef IS_32BIT_THUNK
-// Requires struct repacking for wl_interface
-#error Not implemented
+  // TODO: Do wl_interface symbols from host get allocated in 32-bit memory space? At least add an assert for this!
+  memcpy(guest_interface, host_interface, 4); // name
+  memcpy(reinterpret_cast<char*>(guest_interface) + 4, &host_interface->version, 4);
+  memcpy(reinterpret_cast<char*>(guest_interface) + 8, &host_interface->method_count, 4);
+
+  struct guest_wl_message {
+    guest_layout<char*> name;
+    guest_layout<char*> signature;
+    guest_layout<wl_interface**> types;
+  };
+
+  // TODO: Manage lifetime of this memory?
+  auto guest_methods = new guest_wl_message[host_interface->method_count];
+  for (int i = 0; i < host_interface->method_count; ++i) {
+    guest_methods[i].name.data = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(host_interface->methods[i].name));
+    guest_methods[i].signature.data = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(host_interface->methods[i].signature));
+    // TODO: Ugh, this will require more sophisticated fixups...
+    guest_methods[i].types.data = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(host_interface->methods[i].types));
+  }
+  memcpy(reinterpret_cast<char*>(guest_interface) + 12, &guest_methods, 4);
+
+  auto guest_events = new guest_wl_message[host_interface->event_count];
+  for (int i = 0; i < host_interface->event_count; ++i) {
+    guest_events[i].name.data = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(host_interface->events[i].name));
+    guest_events[i].signature.data = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(host_interface->events[i].signature));
+    // TODO: Ugh, this will require more sophisticated fixups...
+    guest_events[i].types.data = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(host_interface->events[i].types));
+  }
+  memcpy(reinterpret_cast<char*>(guest_interface) + 16, &host_interface->event_count, sizeof(host_interface->event_count));
+  memcpy(reinterpret_cast<char*>(guest_interface) + 20, &guest_events, 4);
 #else
   memcpy(guest_interface, host_interface, sizeof(wl_interface));
 #endif
@@ -197,4 +524,31 @@ wl_interface* fexfn_impl_libwayland_client_fex_wl_exchange_interface_pointer(wl_
   return host_interface;
 }
 
+static wl_interface* get_proxy_interface(wl_proxy* proxy) {
+  // TODO: Use guest_layout/host_layout to do this dance instead
+  uintptr_t interface_addr = reinterpret_cast<uintptr_t>(((wl_proxy_private*)proxy)->interface);
+#ifdef IS_32BIT_THUNK
+  // The pointer has size 4 Zero out upper 4 bytes that might leak in
+  interface_addr &= 0xffffffff;
+#endif
+  return reinterpret_cast<wl_interface*>(interface_addr);
+}
+
+void fexfn_impl_libwayland_client_fex_wl_get_method_signature(wl_proxy* proxy, uint32_t opcode, char* out) {
+  // TODO: Assert proxy comes from the host library
+  strcpy(out, get_proxy_interface(proxy)->methods[opcode].signature);
+}
+
+int fexfn_impl_libwayland_client_fex_wl_get_interface_event_count(wl_proxy* proxy) {
+  return get_proxy_interface(proxy)->event_count;
+}
+
+void fexfn_impl_libwayland_client_fex_wl_get_interface_event_name(wl_proxy* proxy, int i, char* out) {
+  strcpy(out, get_proxy_interface(proxy)->events[i].name);
+}
+
+void fexfn_impl_libwayland_client_fex_wl_get_interface_event_signature(wl_proxy* proxy, int i, char* out) {
+  strcpy(out, ((wl_proxy_private*)proxy)->interface->events[i].signature);
+}
+
 EXPORTS(libwayland_client)
diff --git a/ThunkLibs/libwayland-client/libwayland-client_interface.cpp b/ThunkLibs/libwayland-client/libwayland-client_interface.cpp
index babccd4373..f64aaeaae5 100644
--- a/ThunkLibs/libwayland-client/libwayland-client_interface.cpp
+++ b/ThunkLibs/libwayland-client/libwayland-client_interface.cpp
@@ -24,22 +24,24 @@ template<> struct fex_gen_type<wl_event_queue> : fexgen::opaque_type {};
 template<> struct fex_gen_type<wl_array> {};
 
 
-template<> struct fex_gen_config<wl_proxy_destroy> : fexgen::custom_guest_entrypoint {};
+template<> struct fex_gen_config<wl_proxy_destroy> {};
 
-template<> struct fex_gen_config<wl_display_cancel_read> {};
 template<> struct fex_gen_config<wl_display_connect> {};
+template<> struct fex_gen_config<wl_display_flush> {};
+template<> struct fex_gen_config<wl_display_cancel_read> {};
 template<> struct fex_gen_config<wl_display_create_queue> {};
 template<> struct fex_gen_config<wl_display_disconnect> {};
 template<> struct fex_gen_config<wl_display_dispatch> {};
 template<> struct fex_gen_config<wl_display_dispatch_pending> {};
 template<> struct fex_gen_config<wl_display_dispatch_queue> {};
 template<> struct fex_gen_config<wl_display_dispatch_queue_pending> {};
-template<> struct fex_gen_config<wl_display_flush> {};
+template<> struct fex_gen_config<wl_display_get_error> {};
 template<> struct fex_gen_config<wl_display_prepare_read> {};
 template<> struct fex_gen_config<wl_display_prepare_read_queue> {};
 template<> struct fex_gen_config<wl_display_read_events> {};
 template<> struct fex_gen_config<wl_display_roundtrip> {};
 template<> struct fex_gen_config<wl_display_roundtrip_queue> {};
+template<> struct fex_gen_config<wl_display_connect_to_fd> {};
 template<> struct fex_gen_config<wl_display_get_fd> {};
 
 template<> struct fex_gen_config<wl_event_queue_destroy> {};
@@ -49,24 +51,45 @@ template<> struct fex_gen_param<wl_proxy_add_listener, 1, void(**)()> : fexgen::
 // TODO: Assume compatible
 template<> struct fex_gen_param<wl_proxy_add_listener, 2, void*> : fexgen::ptr_passthrough {};
 template<> struct fex_gen_config<wl_proxy_create> {};
-template<> struct fex_gen_config<wl_proxy_create_wrapper> {};
+template<> struct fex_gen_config<wl_proxy_create_wrapper> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<wl_proxy_create_wrapper, 0, void*> : fexgen::ptr_passthrough {}; // Actually a wl_proxy* => convert manually
+template<> struct fex_gen_config<wl_proxy_get_class> {};
+template<> struct fex_gen_config<wl_proxy_get_id> {};
 template<> struct fex_gen_config<wl_proxy_get_tag> {};
 template<> struct fex_gen_config<wl_proxy_get_user_data> {};
+template<> struct fex_gen_config<wl_proxy_set_tag> {};
 template<> struct fex_gen_config<wl_proxy_get_version> {};
 template<> struct fex_gen_config<wl_proxy_set_queue> {};
 //template<> struct fex_gen_param<wl_proxy_set_queue, 1, wl_event_queue *> : fexgen::ptr_passthrough {};
 template<> struct fex_gen_config<wl_proxy_set_tag> {};
 // TODO: This has a void* parameter. Why does 32-bit accept this without annotations?
 template<> struct fex_gen_config<wl_proxy_set_user_data> {};
-template<> struct fex_gen_config<wl_proxy_wrapper_destroy> {};
+template<> struct fex_gen_config<wl_proxy_wrapper_destroy> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<wl_proxy_wrapper_destroy, 0, void*> : fexgen::ptr_passthrough {}; // Actually a wl_proxy* => convert manually
 
-template<> struct fex_gen_config<wl_proxy_marshal_array> {};
-// wl_proxy_marshal_array_flags is only available starting from Wayland 1.19.91
-#if WAYLAND_VERSION_MAJOR * 10000 + WAYLAND_VERSION_MINOR * 100 + WAYLAND_VERSION_MICRO >= 11991
-template<> struct fex_gen_config<wl_proxy_marshal_array_flags> {};
-#endif
+template<> struct fex_gen_config<wl_proxy_marshal_array> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<wl_proxy_marshal_array, 2, wl_argument*> : fexgen::ptr_passthrough {};
+template<> struct fex_gen_config<wl_proxy_marshal_array_constructor> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<wl_proxy_marshal_array_constructor, 2, wl_argument*> : fexgen::ptr_passthrough {};
+template<> struct fex_gen_config<wl_proxy_marshal_array_constructor_versioned> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<wl_proxy_marshal_array_constructor_versioned, 2, wl_argument*> : fexgen::ptr_passthrough {};
+template<> struct fex_gen_config<wl_proxy_marshal_array_flags> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<wl_proxy_marshal_array_flags, 5, wl_argument*> : fexgen::ptr_passthrough {};
 
 // Guest notifies host about its interface. Host returns its corresponding interface pointer
 wl_interface* fex_wl_exchange_interface_pointer(wl_interface*, const char* name);
 template<> struct fex_gen_config<fex_wl_exchange_interface_pointer> : fexgen::custom_host_impl/*, fexgen::custom_guest_entrypoint*/ {};
 //template<> struct fex_gen_param<fex_wl_exchange_interface_pointer, 0, wl_interface*> : fexgen::ptr_passthrough {};
+template<> struct fex_gen_param<fex_wl_exchange_interface_pointer, 1, const char*> : fexgen::ptr_passthrough {};
+
+// This is equivalent to reading ((wl_proxy_private*)proxy)->interface->methods[opcode].signature on 64-bit.
+// On 32-bit, the data layout differs between host and guest however, so we let the host extract the data.
+void fex_wl_get_method_signature(wl_proxy*, uint32_t opcode, char*);
+template<> struct fex_gen_config<fex_wl_get_method_signature> : fexgen::custom_host_impl {};
+
+int fex_wl_get_interface_event_count(wl_proxy*);
+template<> struct fex_gen_config<fex_wl_get_interface_event_count> : fexgen::custom_host_impl {};
+void fex_wl_get_interface_event_name(wl_proxy*, int, char*);
+template<> struct fex_gen_config<fex_wl_get_interface_event_name> : fexgen::custom_host_impl {};
+void fex_wl_get_interface_event_signature(wl_proxy*, int, char*);
+template<> struct fex_gen_config<fex_wl_get_interface_event_signature> : fexgen::custom_host_impl {};

From dbdb8a6b6a6b36422afd2b32ac06117cf98aacdb Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Mon, 4 Sep 2023 17:42:11 +0200
Subject: [PATCH 45/48] TODOFINISH. Thunks/vulkan: Add 32-bit support

---
 ThunkLibs/Generator/data_layout.cpp         |   5 +-
 ThunkLibs/GuestLibs/CMakeLists.txt          |   8 +-
 ThunkLibs/HostLibs/CMakeLists.txt           |   2 +-
 ThunkLibs/include/common/Host.h             |  18 +
 ThunkLibs/libvulkan/Host.cpp                | 955 +++++++++++++++++++-
 ThunkLibs/libvulkan/libvulkan_interface.cpp | 100 +-
 6 files changed, 1071 insertions(+), 17 deletions(-)

diff --git a/ThunkLibs/Generator/data_layout.cpp b/ThunkLibs/Generator/data_layout.cpp
index c3479a63e7..1739457c19 100644
--- a/ThunkLibs/Generator/data_layout.cpp
+++ b/ThunkLibs/Generator/data_layout.cpp
@@ -284,9 +284,12 @@ TypeCompatibility DataLayoutCompareAction::GetTypeCompatibility(
                 // Automatic repacking of pointers to non-compatible types is only possible if:
                 // * Pointee is fully compatible, or
                 // * Pointer member is annotated
+                // TODO: Drop the Vulkan-specific workaround of ignoring "pNext" pointers
                 // TODO: Don't restrict this to structure types. it applies to pointers to builtin types too!
                 auto host_member_pointee_type = context.getCanonicalType(host_member_type->getPointeeType().getTypePtr());
-                if (type_repack_info.UsesCustomRepackFor(host_member_field)) {
+                if (type_repack_info.UsesCustomRepackFor(host_member_field)
+                    || (is_32bit && host_member_field->getNameAsString() == "pNext")
+                    ) {
                     member_compat.push_back(TypeCompatibility::Repackable);
                 } else if (types.contains(host_member_pointee_type) && types.at(host_member_pointee_type).is_opaque) {
                     // Pointee doesn't need repacking, but pointer needs extending on 32-bit
diff --git a/ThunkLibs/GuestLibs/CMakeLists.txt b/ThunkLibs/GuestLibs/CMakeLists.txt
index d8380ea527..fc84fd8742 100644
--- a/ThunkLibs/GuestLibs/CMakeLists.txt
+++ b/ThunkLibs/GuestLibs/CMakeLists.txt
@@ -218,10 +218,6 @@ if (BITNESS EQUAL 64)
   generate(libXfixes ${CMAKE_CURRENT_SOURCE_DIR}/../libXfixes/libXfixes_interface.cpp)
   add_guest_lib(Xfixes "libXfixes.so.3")
 
-  generate(libvulkan ${CMAKE_CURRENT_SOURCE_DIR}/../libvulkan/libvulkan_interface.cpp)
-  target_include_directories(libvulkan-guest-deps INTERFACE ${FEX_PROJECT_SOURCE_DIR}/External/Vulkan-Headers/include/)
-  add_guest_lib(vulkan "libvulkan.so.1")
-
   find_package(PkgConfig)
   pkg_search_module(XCB REQUIRED xcb)
   version_to_variables(${XCB_VERSION} XCB)
@@ -299,3 +295,7 @@ add_guest_lib(fex_thunk_test "libfex_thunk_test.so")
 
 generate(libwayland-client ${CMAKE_CURRENT_SOURCE_DIR}/../libwayland-client/libwayland-client_interface.cpp)
 add_guest_lib(wayland-client "libwayland-client.so.0.20.0")
+
+generate(libvulkan ${CMAKE_CURRENT_SOURCE_DIR}/../libvulkan/libvulkan_interface.cpp)
+target_include_directories(libvulkan-guest-deps INTERFACE ${FEX_PROJECT_SOURCE_DIR}/External/Vulkan-Headers/include/)
+add_guest_lib(vulkan "libvulkan.so.1")
diff --git a/ThunkLibs/HostLibs/CMakeLists.txt b/ThunkLibs/HostLibs/CMakeLists.txt
index 18e78a014f..f536d5cad3 100644
--- a/ThunkLibs/HostLibs/CMakeLists.txt
+++ b/ThunkLibs/HostLibs/CMakeLists.txt
@@ -145,11 +145,11 @@ if (GUEST_BITNESS EQUAL 64)
 
   generate(libXfixes ${CMAKE_CURRENT_SOURCE_DIR}/../libXfixes/libXfixes_interface.cpp ${GUEST_BITNESS})
   add_host_lib(Xfixes ${GUEST_BITNESS})
+endif()
 
   generate(libvulkan ${CMAKE_CURRENT_SOURCE_DIR}/../libvulkan/libvulkan_interface.cpp ${GUEST_BITNESS})
   target_include_directories(libvulkan-${GUEST_BITNESS}-deps INTERFACE ${FEX_PROJECT_SOURCE_DIR}/External/Vulkan-Headers/include/)
   add_host_lib(vulkan ${GUEST_BITNESS})
-endif()
 
   generate(libwayland-client ${CMAKE_CURRENT_SOURCE_DIR}/../libwayland-client/libwayland-client_interface.cpp ${GUEST_BITNESS})
   add_host_lib(wayland-client ${GUEST_BITNESS})
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index aad83ad3f1..2e7b2a3d89 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -247,6 +247,24 @@ struct guest_layout<T* const> {
   }
 };
 
+// Make guest_layout of "long long" and "long" interoperable, since they are
+// the same type as far as data layout is concerned.
+template<>
+struct guest_layout<unsigned long long> : guest_layout<unsigned long> {
+  using guest_layout<unsigned long>::guest_layout;
+
+  static_assert(sizeof(long long) == sizeof(long));
+};
+template<>
+struct guest_layout<unsigned long long*> : guest_layout<unsigned long*> {
+  using guest_layout<unsigned long*>::guest_layout;
+};
+template<>
+struct guest_layout<const unsigned long long*> : guest_layout<const unsigned long*> {
+  using guest_layout<const unsigned long*>::guest_layout;
+  guest_layout(guest_layout<const unsigned long*> oth) : guest_layout<const unsigned long*>(oth) { }
+};
+
 template<typename T>
 struct host_layout;
 
diff --git a/ThunkLibs/libvulkan/Host.cpp b/ThunkLibs/libvulkan/Host.cpp
index a5f924c323..fe087338db 100644
--- a/ThunkLibs/libvulkan/Host.cpp
+++ b/ThunkLibs/libvulkan/Host.cpp
@@ -17,6 +17,7 @@ tags: thunklibs|Vulkan
 #include <cstring>
 #include <mutex>
 #include <unordered_map>
+#include <vector>
 
 #include <dlfcn.h>
 
@@ -50,6 +51,7 @@ static void DoSetupWithInstance(VkInstance instance) {
 
 #define FEXFN_IMPL(fn) fexfn_impl_libvulkan_##fn
 
+#if 0
 // Functions with callbacks are overridden to ignore the guest-side callbacks
 
 static VkResult FEXFN_IMPL(vkCreateShaderModule)(VkDevice a_0, const VkShaderModuleCreateInfo* a_1, const VkAllocationCallbacks* a_2, VkShaderModule* a_3) {
@@ -61,6 +63,7 @@ static VkBool32 DummyVkDebugReportCallback(VkDebugReportFlagsEXT, VkDebugReportO
                                            int32_t, const char*, const char*, void*) {
   return VK_FALSE;
 }
+#endif
 
 static VkResult FEXFN_IMPL(vkCreateInstance)(const VkInstanceCreateInfo* a_0, const VkAllocationCallbacks* a_1, guest_layout<VkInstance*> a_2) {
   const VkInstanceCreateInfo* vk_struct_base = a_0;
@@ -78,18 +81,14 @@ static VkResult FEXFN_IMPL(vkCreateInstance)(const VkInstanceCreateInfo* a_0, co
 
   VkInstance out;
   auto ret = LDR_PTR(vkCreateInstance)(vk_struct_base, nullptr, &out);
-  if (ret == VK_SUCCESS) {
-    *a_2.get_pointer() = out;
-  }
+  *a_2.get_pointer() = out;
   return ret;
 }
 
-static VkResult FEXFN_IMPL(vkCreateDevice)(VkPhysicalDevice a_0, const VkDeviceCreateInfo* a_1, const VkAllocationCallbacks* a_2, guest_layout<VkDevice*> a_3){
+static VkResult FEXFN_IMPL(vkCreateDevice)(VkPhysicalDevice a_0, const VkDeviceCreateInfo* a_1, const VkAllocationCallbacks* a_2, guest_layout<VkDevice*> a_3) {
   VkDevice out;
   auto ret = LDR_PTR(vkCreateDevice)(a_0, a_1, nullptr, &out);
-  if (ret == VK_SUCCESS) {
-    *a_3.get_pointer() = out;
-  }
+  *a_3.get_pointer() = out;
   return ret;
 }
 
@@ -117,14 +116,143 @@ static void FEXFN_IMPL(vkDestroyDebugReportCallbackEXT)(VkInstance a_0, VkDebugR
 }
 #endif
 
+#ifdef IS_32BIT_THUNK
+VkResult fexfn_impl_libvulkan_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* count, guest_layout<VkPhysicalDevice*> devices) {
+  if (!devices.get_pointer()) {
+    return fexldr_ptr_libvulkan_vkEnumeratePhysicalDevices(instance, count, nullptr);
+  }
+
+  auto input_count = *count;
+  std::vector<VkPhysicalDevice> out(input_count);
+  auto ret = fexldr_ptr_libvulkan_vkEnumeratePhysicalDevices(instance, count, out.data());
+  for (size_t i = 0; i < std::min(input_count, *count); ++i) {
+    devices.get_pointer()[i] = out[i];
+  }
+  return ret;
+}
+
+void fexfn_impl_libvulkan_vkGetDeviceQueue(VkDevice device, uint32_t family_index, uint32_t queue_index, guest_layout<VkQueue*> queue) {
+  VkQueue out;
+  fexldr_ptr_libvulkan_vkGetDeviceQueue(device, family_index, queue_index, &out);
+  *queue.get_pointer() = out;
+}
+
+VkResult fexfn_impl_libvulkan_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* info, guest_layout<VkCommandBuffer*> buffers) {
+  std::vector<VkCommandBuffer> out(info->commandBufferCount);
+  auto ret = fexldr_ptr_libvulkan_vkAllocateCommandBuffers(device, info, out.data());
+  if (ret == VK_SUCCESS) {
+    for (size_t i = 0; i < info->commandBufferCount; ++i) {
+      buffers.get_pointer()[i] = out[i];
+    }
+  }
+  return ret;
+}
+
+VkResult fexfn_impl_libvulkan_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, guest_layout<void**> data) {
+  host_layout<void*> host_data {};
+  void* mapped;
+  auto ret = fexldr_ptr_libvulkan_vkMapMemory(device, memory, offset, size, flags, &mapped);
+  fprintf(stderr, "%s: Mapped %p\n", __FUNCTION__, mapped);
+  if (ret == VK_SUCCESS) {
+    host_data.data = mapped;
+    *data.get_pointer() = to_guest(host_data);
+  }
+  return ret;
+}
+
+void fexfn_impl_libvulkan_vkUpdateDescriptorSets(
+    VkDevice_T* device, unsigned int descriptorWriteCount,
+    guest_layout<const VkWriteDescriptorSet*> pDescriptorWrites,
+    unsigned int descriptorCopyCount, VkCopyDescriptorSet const* pDescriptorCopies) {
+
+  VkWriteDescriptorSet* HostDescriptorWrites;
+  if (!descriptorWriteCount || !descriptorWriteCount) {
+    HostDescriptorWrites = nullptr;
+  } else {
+    HostDescriptorWrites = new VkWriteDescriptorSet[descriptorWriteCount];
+    for (size_t i = 0; i < descriptorWriteCount; ++i) {
+      auto src = host_layout<VkWriteDescriptorSet> { pDescriptorWrites.get_pointer()[i] };
+      fex_apply_custom_repacking(src, pDescriptorWrites.get_pointer()[i]);
+      static_assert(sizeof(src.data) == sizeof(HostDescriptorWrites[i]));
+      memcpy((void*)&HostDescriptorWrites[i], &src.data, sizeof(src.data));
+    }
+  }
+
+// TODO: Is this needed?
+//  if (!from.data.pDescriptorCopies.get_pointer() || !from.data.descriptorCopyCount.data) {
+//    into.data.pDescriptorCopies = nullptr;
+//    return;
+//  }
+//  into.data.pDescriptorCopies = new VkCopyDescriptorSet[from.data.descriptorCopyCount.data];
+//  for (size_t i = 0; i < from.data.descriptorCopyCount.data; ++i) {
+//    auto src = host_layout<VkCopyDescriptorSet> { from.data.pDescriptorCopies.get_pointer()[i] }.data;
+//    static_assert(sizeof(src) == sizeof(into.data.pDescriptorCopies[i]));
+//    memcpy((void*)&into.data.pDescriptorCopies[i], &src, sizeof(src));
+//  }
+//  delete[] info;
+
+
+  fexldr_ptr_libvulkan_vkUpdateDescriptorSets(device, descriptorWriteCount, HostDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+
+  delete[] HostDescriptorWrites;
+}
+
+VkResult fexfn_impl_libvulkan_vkQueueSubmit(VkQueue queue, uint32_t submit_count,
+                                            guest_layout<const VkSubmitInfo*> submit_infos, VkFence fence) {
+
+  VkSubmitInfo* HostSubmitInfos = nullptr;
+  if (submit_count) {
+    HostSubmitInfos = new VkSubmitInfo[submit_count];
+    for (size_t i = 0; i < submit_count; ++i) {
+      auto src = host_layout<VkSubmitInfo> { submit_infos.get_pointer()[i] };
+      fex_apply_custom_repacking(src, submit_infos.get_pointer()[i]);
+      static_assert(sizeof(src.data) == sizeof(HostSubmitInfos[i]));
+      memcpy((void*)&HostSubmitInfos[i], &src.data, sizeof(src.data));
+    }
+  }
+
+  auto ret = fexldr_ptr_libvulkan_vkQueueSubmit(queue, submit_count, HostSubmitInfos, fence);
+
+  delete[] HostSubmitInfos;
+
+  return ret;
+}
+
+void fexfn_impl_libvulkan_vkFreeCommandBuffers(VkDevice device, VkCommandPool pool, uint32_t num_buffers,
+                                            guest_layout<const VkCommandBuffer*> buffers) {
+
+  VkCommandBuffer* HostBuffers = nullptr;
+  if (num_buffers) {
+    HostBuffers = new VkCommandBuffer[num_buffers];
+    for (size_t i = 0; i < num_buffers; ++i) {
+      auto src = host_layout<VkCommandBuffer_T*> { (const guest_layout<VkCommandBuffer_T *>&)buffers.get_pointer()[i] };
+      static_assert(sizeof(src.data) == sizeof(HostBuffers[i]));
+      memcpy((void*)&HostBuffers[i], &src.data, sizeof(src.data));
+    }
+  }
+
+  fexldr_ptr_libvulkan_vkFreeCommandBuffers(device, pool, num_buffers, HostBuffers);
+
+  delete[] HostBuffers;
+}
+
+VkResult fexfn_impl_libvulkan_vkGetPipelineCacheData(VkDevice device, VkPipelineCache cache, guest_layout<size_t*> guest_data_size, void* data) {
+  size_t data_size = guest_data_size.get_pointer()->data;
+  auto ret = fexldr_ptr_libvulkan_vkGetPipelineCacheData(device, cache, &data_size, data);
+  *guest_data_size.get_pointer() = data_size;
+  return ret;
+}
+
+#endif
+
 static PFN_vkVoidFunction FEXFN_IMPL(vkGetDeviceProcAddr)(VkDevice a_0, const char* a_1) {
   // Just return the host facing function pointer
   // The guest will handle mapping if this exists
 
-  // Check for functions with stubbed callbacks first
-  if (std::strcmp(a_1, "vkCreateShaderModule") == 0) {
+  // Check for functions with custom implementations first
+  /*if (std::strcmp(a_1, "vkCreateShaderModule") == 0) {
       return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkCreateShaderModule;
-  } else if (std::strcmp(a_1, "vkCreateInstance") == 0) {
+  } else */if (std::strcmp(a_1, "vkCreateInstance") == 0) {
       return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkCreateInstance;
   } else if (std::strcmp(a_1, "vkCreateDevice") == 0) {
       return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkCreateDevice;
@@ -132,6 +260,24 @@ static PFN_vkVoidFunction FEXFN_IMPL(vkGetDeviceProcAddr)(VkDevice a_0, const ch
       return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkAllocateMemory;
   } else if (std::strcmp(a_1, "vkFreeMemory") == 0) {
       return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkFreeMemory;
+#ifdef IS_32BIT_THUNK
+  } else if (std::strcmp(a_1, "vkEnumeratePhysicalDevices") == 0) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkEnumeratePhysicalDevices;
+  } else if (std::strcmp(a_1, "vkGetDeviceQueue") == 0) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkGetDeviceQueue;
+  } else if (std::strcmp(a_1, "vkAllocateCommandBuffers") == 0) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkAllocateCommandBuffers;
+  } else if (std::strcmp(a_1, "vkMapMemory") == 0) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkMapMemory;
+  } else if (std::strcmp(a_1, "vkUpdateDescriptorSets") == 0) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkUpdateDescriptorSets;
+  } else if (std::strcmp(a_1, "vkQueueSubmit") == 0) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkQueueSubmit;
+  } else if (std::strcmp(a_1, "vkFreeCommandBuffers") == 0) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkFreeCommandBuffers;
+  } else if (std::strcmp(a_1, "vkGetPipelineCacheData") == 0) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkGetPipelineCacheData;
+#endif
   }
 
   auto ret = LDR_PTR(vkGetDeviceProcAddr)(a_0, a_1);
@@ -149,4 +295,793 @@ static PFN_vkVoidFunction FEXFN_IMPL(vkGetInstanceProcAddr)(VkInstance a_0, cons
   return ret;
 }
 
+#ifdef IS_32BIT_THUNK
+template<VkStructureType TypeIndex, typename Type>
+static const VkBaseOutStructure* convert(const VkBaseOutStructure* source) {
+    // Using malloc here since no easily available type information is available at the time of destruction
+    auto child = (host_layout<Type>*)malloc(sizeof(host_layout<Type>));
+    new (child) host_layout<Type> { *reinterpret_cast<guest_layout<Type>*>((void*)(source)) }; // TODO: Use proper cast?
+
+    // TODO: Trigger *full* custom repack for children, not just the Next member
+    fex_custom_repack<&Type::pNext>(*child, *reinterpret_cast<guest_layout<Type>*>((void*)(source)));
+
+    return (const VkBaseOutStructure*)child; // TODO: Use proper cast?
+}
+
+template<VkStructureType TypeIndex, typename Type>
+inline constexpr std::pair<VkStructureType, const VkBaseOutStructure*(*)(const VkBaseOutStructure*)> converters =
+  { TypeIndex, convert<TypeIndex, Type> };
+
+
+static std::unordered_map<VkStructureType, const VkBaseOutStructure*(*)(const VkBaseOutStructure*)> next_handlers {
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, VkSemaphoreTypeCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, VkMemoryDedicatedRequirements>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, VkMemoryDedicatedAllocateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VkImageFormatListCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, VkRenderPassAttachmentBeginInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, VkTimelineSemaphoreSubmitInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO, VkPipelineRenderingCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, VkMemoryAllocateFlagsInfo>,
+};
+
+// Normally, we would implement fex_custom_repack individually for each customized struct.
+// In this case, they all need the same repacking, so we just implement it once and alias all fex_custom_repack instances
+extern "C" void default_fex_custom_repack(/*host_layout<*/VkBaseOutStructure/*>*/& into, /* guest_layout<VkBaseOutStructure>& */void* from) {
+  struct guest_vk_struct {
+    VkStructureType sType;
+    guest_layout<struct VkBaseOutStructure*> pNext;
+  };
+
+  auto* typed_source = reinterpret_cast<guest_vk_struct*>(from);
+  if (!typed_source->pNext.get_pointer()) {
+  fprintf(stderr, "  CUSTOM REPACK: no more pNext\n");
+      into.pNext = nullptr;
+      return;
+  }
+  typed_source = reinterpret_cast<guest_vk_struct*>(typed_source->pNext.get_pointer());
+
+  auto next_handler = next_handlers.find(typed_source->sType);
+  if (next_handler == next_handlers.end()) {
+    fprintf(stderr, "ERROR: Unrecognized VkStructureType %u referenced by pNext\n", typed_source->sType);
+    std::abort();
+  }
+  // TODO: Avoid redundant cast to VkBaseOutStructure...
+  const_cast<const VkBaseOutStructure*&>(into.pNext) = next_handler->second((const VkBaseOutStructure*)typed_source);
+}
+
+template<>
+void fex_custom_repack<&VkInstanceCreateInfo::pNext>(host_layout<VkInstanceCreateInfo>& into, const guest_layout<VkInstanceCreateInfo>& from) {
+  // TODO
+  default_fex_custom_repack((VkBaseOutStructure&)into.data, (void*)&from);
+}
+
+template<>
+void fex_custom_repack_postcall<&VkInstanceCreateInfo::pNext>(const void* const&) {
+  // TODO
+}
+
+#define CREATE_INFO_DEFAULT_CUSTOM_REPACK(name) \
+template<> \
+void fex_custom_repack<&name::pNext>(host_layout<name>& into, const guest_layout<name>& from) { \
+fprintf(stderr, "CUSTOM REPACK: %s\n", __PRETTY_FUNCTION__);\
+  default_fex_custom_repack((VkBaseOutStructure&)into.data, (void*)&from); \
+} \
+\
+template<> \
+void fex_custom_repack_postcall<&name::pNext>(decltype(std::declval<name>().pNext) const&) { \
+  /* TODO */ \
+}
+
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkAttachmentDescription2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkAttachmentReference2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkBaseOutStructure)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkBufferMemoryBarrier2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkDependencyInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkDescriptorUpdateTemplateCreateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkGraphicsPipelineCreateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkImageFormatListCreateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkImageMemoryBarrier2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkImageMemoryRequirementsInfo2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkMemoryAllocateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkMemoryAllocateFlagsInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkMemoryBarrier2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkMemoryDedicatedAllocateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkMemoryDedicatedRequirements)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkMemoryRequirements2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkPipelineRenderingCreateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkRenderPassAttachmentBeginInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkRenderPassBeginInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkRenderPassCreateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkRenderPassCreateInfo2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkSemaphoreCreateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkSemaphoreTypeCreateInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkSemaphoreWaitInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkSubmitInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkSubpassBeginInfo)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkSubpassDependency2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkSubpassDescription2)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkSwapchainCreateInfoKHR)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(VkTimelineSemaphoreSubmitInfo)
+
+template<>
+void fex_custom_repack<&VkInstanceCreateInfo::pApplicationInfo>(host_layout<VkInstanceCreateInfo>& into, const guest_layout<VkInstanceCreateInfo>& from) {
+  auto HostApplicationInfo = new host_layout<VkApplicationInfo> { *from.data.pApplicationInfo.get_pointer() };
+  fex_apply_custom_repacking(*HostApplicationInfo, *from.data.pApplicationInfo.get_pointer());
+  into.data.pApplicationInfo = &HostApplicationInfo->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkInstanceCreateInfo::pApplicationInfo>(const VkApplicationInfo* const& pApplicationInfo) {
+  delete pApplicationInfo;
+}
+
+template<>
+void fex_custom_repack<&VkInstanceCreateInfo::ppEnabledExtensionNames>(host_layout<VkInstanceCreateInfo>& into, const guest_layout<VkInstanceCreateInfo>& from) {
+  auto extension_count = from.data.enabledExtensionCount.data;
+  fprintf(stderr, "  Repacking %d ppEnabledExtensionNames\n", extension_count);
+  into.data.ppEnabledExtensionNames = new const char*[extension_count];
+
+  for (uint32_t i = 0; i < extension_count; ++i) {
+    const guest_layout<const char* const>& ExtensionName = from.data.ppEnabledExtensionNames.get_pointer()[i];
+    fprintf(stderr, "    EXT %p[%d]: %p %s\n", from.data.ppEnabledExtensionNames.get_pointer(), i, (void*)(uintptr_t)ExtensionName.data, (const char*)(uintptr_t)ExtensionName.data);
+    const_cast<const char*&>(into.data.ppEnabledExtensionNames[i]) = host_layout<const char* const> { ExtensionName }.data;
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkInstanceCreateInfo::ppEnabledExtensionNames>(const char* const* const& data) {
+  delete[] data;
+}
+
+template<>
+void fex_custom_repack<&VkInstanceCreateInfo::ppEnabledLayerNames>(host_layout<VkInstanceCreateInfo>& into, const guest_layout<VkInstanceCreateInfo>& from) {
+  auto layer_count = from.data.enabledLayerCount.data;
+  fprintf(stderr, "  Repacking %d ppEnabledLayerNames\n", layer_count);
+  into.data.ppEnabledLayerNames = new const char*[layer_count];
+
+  for (uint32_t i = 0; i < layer_count; ++i) {
+    const guest_layout<const char* const>& LayerName = from.data.ppEnabledLayerNames.get_pointer()[i];
+    fprintf(stderr, "    EXT %p[%d]: %p %s\n", from.data.ppEnabledLayerNames.get_pointer(), i, (void*)(uintptr_t)LayerName.data, (const char*)(uintptr_t)LayerName.data);
+    const_cast<const char*&>(into.data.ppEnabledLayerNames[i]) = host_layout<const char* const> { LayerName }.data;
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkInstanceCreateInfo::ppEnabledLayerNames>(const char* const* const& data) {
+  delete[] data;
+}
+
+template<>
+void fex_custom_repack<&VkApplicationInfo::pNext>(host_layout<VkApplicationInfo>& into, const guest_layout<VkApplicationInfo>& from) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack_postcall<&VkApplicationInfo::pNext>(const void* const&) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack<&VkDeviceQueueCreateInfo::pNext>(host_layout<VkDeviceQueueCreateInfo>& into, const guest_layout<VkDeviceQueueCreateInfo>& from) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDeviceQueueCreateInfo::pNext>(const void* const&) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack<&VkDeviceCreateInfo::pNext>(host_layout<VkDeviceCreateInfo>& into, const guest_layout<VkDeviceCreateInfo>& from) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDeviceCreateInfo::pNext>(const void* const&) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack<&VkDeviceCreateInfo::pQueueCreateInfos>(host_layout<VkDeviceCreateInfo>& into, const guest_layout<VkDeviceCreateInfo>& from) {
+  auto HostQueueCreateInfo = new host_layout<VkDeviceQueueCreateInfo> { *from.data.pQueueCreateInfos.get_pointer() };
+  fex_apply_custom_repacking(*HostQueueCreateInfo, *from.data.pQueueCreateInfos.get_pointer());
+  into.data.pQueueCreateInfos = &HostQueueCreateInfo->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDeviceCreateInfo::pQueueCreateInfos>(const VkDeviceQueueCreateInfo* const& pQueueCreateInfos) {
+  delete pQueueCreateInfos;
+}
+
+template<>
+void fex_custom_repack<&VkDeviceCreateInfo::ppEnabledExtensionNames>(host_layout<VkDeviceCreateInfo>& into, const guest_layout<VkDeviceCreateInfo>& from) {
+  auto extension_count = from.data.enabledExtensionCount.data;
+  fprintf(stderr, "  Repacking %d ppEnabledExtensionNames\n", extension_count);
+  into.data.ppEnabledExtensionNames = new const char*[extension_count];
+
+  for (uint32_t i = 0; i < extension_count; ++i) {
+    const guest_layout<const char* const>& ExtensionName = from.data.ppEnabledExtensionNames.get_pointer()[i];
+    fprintf(stderr, "    EXT %p[%d]: %p %s\n", from.data.ppEnabledExtensionNames.get_pointer(), i, (const char*)(uintptr_t)ExtensionName.data, (const char*)(uintptr_t)ExtensionName.data);
+    const_cast<const char*&>(into.data.ppEnabledExtensionNames[i]) = host_layout<const char* const> { ExtensionName }.data;
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDeviceCreateInfo::ppEnabledExtensionNames>(const char* const* const& data) {
+  delete[] data;
+}
+
+template<>
+void fex_custom_repack<&VkDeviceCreateInfo::ppEnabledLayerNames>(host_layout<VkDeviceCreateInfo>& into, const guest_layout<VkDeviceCreateInfo>& from) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDeviceCreateInfo::ppEnabledLayerNames>(const char* const* const& data) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack<&VkImageViewCreateInfo::pNext>(host_layout<VkImageViewCreateInfo>& into, const guest_layout<VkImageViewCreateInfo>& from) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack_postcall<&VkImageViewCreateInfo::pNext>(const void* const&) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack<&VkDescriptorSetLayoutCreateInfo::pNext>(host_layout<VkDescriptorSetLayoutCreateInfo>& into, const guest_layout<VkDescriptorSetLayoutCreateInfo>& from) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDescriptorSetLayoutCreateInfo::pNext>(const void* const&) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack<&VkDescriptorSetLayoutCreateInfo::pBindings>(host_layout<VkDescriptorSetLayoutCreateInfo>& into, const guest_layout<VkDescriptorSetLayoutCreateInfo>& from) {
+  if (!from.data.bindingCount.data) {
+    into.data.pBindings = nullptr;
+    return;
+  }
+
+  into.data.pBindings = new VkDescriptorSetLayoutBinding[from.data.bindingCount.data];
+  for (size_t i = 0; i < from.data.bindingCount.data; ++i) {
+    auto in_data = host_layout<VkDescriptorSetLayoutBinding> { from.data.pBindings.get_pointer()[i] }.data;
+    memcpy((void*)&into.data.pBindings[i], &in_data, sizeof(VkDescriptorSetLayoutBinding));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDescriptorSetLayoutCreateInfo::pBindings>(const VkDescriptorSetLayoutBinding* const& bindings) {
+  delete[] bindings;
+}
+
+template<>
+void fex_custom_repack<&VkRenderPassCreateInfo::pSubpasses>(host_layout<VkRenderPassCreateInfo>& into, const guest_layout<VkRenderPassCreateInfo>& from) {
+  if (from.data.subpassCount.data == 0) {
+    into.data.pSubpasses = nullptr;
+    return;
+  }
+
+  into.data.pSubpasses = new VkSubpassDescription[from.data.subpassCount.data];
+  for (size_t i = 0; i < from.data.subpassCount.data; ++i) {
+    auto in_data = host_layout<VkSubpassDescription> { from.data.pSubpasses.get_pointer()[i] }.data;
+    memcpy((void*)&into.data.pSubpasses[i], &in_data, sizeof(VkSubpassDescription));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkRenderPassCreateInfo::pSubpasses>(const VkSubpassDescription* const& subpasses) {
+  delete[] subpasses;
+}
+
+template<>
+void fex_custom_repack<&VkRenderPassCreateInfo2::pAttachments>(host_layout<VkRenderPassCreateInfo2>& into, const guest_layout<VkRenderPassCreateInfo2>& from) {
+  if (from.data.attachmentCount.data == 0) {
+    into.data.pAttachments = nullptr;
+    return;
+  }
+
+  into.data.pAttachments = new VkAttachmentDescription2[from.data.attachmentCount.data];
+  for (size_t i = 0; i < from.data.attachmentCount.data; ++i) {
+    auto in_data = host_layout<VkAttachmentDescription2> { from.data.pAttachments.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pAttachments.get_pointer()[i]);
+    memcpy((void*)&into.data.pAttachments[i], &in_data.data, sizeof(VkAttachmentDescription2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkRenderPassCreateInfo2::pAttachments>(const VkAttachmentDescription2* const& attachments) {
+  delete[] attachments;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkRenderPassCreateInfo2::pSubpasses>(host_layout<VkRenderPassCreateInfo2>& into, const guest_layout<VkRenderPassCreateInfo2>& from) {
+  if (from.data.subpassCount.data == 0) {
+    into.data.pSubpasses = nullptr;
+    return;
+  }
+
+  into.data.pSubpasses = new VkSubpassDescription2[from.data.subpassCount.data];
+  for (size_t i = 0; i < from.data.subpassCount.data; ++i) {
+    auto in_data = host_layout<VkSubpassDescription2> { from.data.pSubpasses.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pSubpasses.get_pointer()[i]);
+    memcpy((void*)&into.data.pSubpasses[i], &in_data.data, sizeof(VkSubpassDescription2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkRenderPassCreateInfo2::pSubpasses>(const VkSubpassDescription2* const& subpasses) {
+  delete[] subpasses;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkRenderPassCreateInfo2::pDependencies>(host_layout<VkRenderPassCreateInfo2>& into, const guest_layout<VkRenderPassCreateInfo2>& from) {
+  if (from.data.dependencyCount.data == 0) {
+    into.data.pDependencies = nullptr;
+    return;
+  }
+
+  into.data.pDependencies = new VkSubpassDependency2[from.data.dependencyCount.data];
+  for (size_t i = 0; i < from.data.dependencyCount.data; ++i) {
+    auto in_data = host_layout<VkSubpassDependency2> { from.data.pDependencies.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pDependencies.get_pointer()[i]);
+    memcpy((void*)&into.data.pDependencies[i], &in_data.data, sizeof(VkSubpassDependency2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkRenderPassCreateInfo2::pDependencies>(const VkSubpassDependency2* const& dependencies) {
+  delete[] dependencies;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkSubpassDescription2::pInputAttachments>(host_layout<VkSubpassDescription2>& into, const guest_layout<VkSubpassDescription2>& from) {
+  if (from.data.inputAttachmentCount.data == 0) {
+    into.data.pInputAttachments = nullptr;
+    return;
+  }
+
+  into.data.pInputAttachments = new VkAttachmentReference2[from.data.inputAttachmentCount.data];
+  for (size_t i = 0; i < from.data.inputAttachmentCount.data; ++i) {
+    auto in_data = host_layout<VkAttachmentReference2> { from.data.pInputAttachments.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pInputAttachments.get_pointer()[i]);
+    memcpy((void*)&into.data.pInputAttachments[i], &in_data.data, sizeof(VkAttachmentReference2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkSubpassDescription2::pInputAttachments>(const VkAttachmentReference2* const& references) {
+  delete[] references;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkSubpassDescription2::pColorAttachments>(host_layout<VkSubpassDescription2>& into, const guest_layout<VkSubpassDescription2>& from) {
+  if (from.data.colorAttachmentCount.data == 0) {
+    into.data.pColorAttachments = nullptr;
+    return;
+  }
+
+  into.data.pColorAttachments = new VkAttachmentReference2[from.data.colorAttachmentCount.data];
+  for (size_t i = 0; i < from.data.colorAttachmentCount.data; ++i) {
+    auto in_data = host_layout<VkAttachmentReference2> { from.data.pColorAttachments.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pColorAttachments.get_pointer()[i]);
+    memcpy((void*)&into.data.pColorAttachments[i], &in_data.data, sizeof(VkAttachmentReference2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkSubpassDescription2::pColorAttachments>(const VkAttachmentReference2* const& references) {
+  delete[] references;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkSubpassDescription2::pResolveAttachments>(host_layout<VkSubpassDescription2>& into, const guest_layout<VkSubpassDescription2>& from) {
+  if (from.data.colorAttachmentCount.data == 0 || from.data.pResolveAttachments.get_pointer() == nullptr) {
+    into.data.pResolveAttachments = nullptr;
+    return;
+  }
+
+  into.data.pResolveAttachments = new VkAttachmentReference2[from.data.colorAttachmentCount.data];
+  for (size_t i = 0; i < from.data.colorAttachmentCount.data; ++i) {
+    auto in_data = host_layout<VkAttachmentReference2> { from.data.pResolveAttachments.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pResolveAttachments.get_pointer()[i]);
+    memcpy((void*)&into.data.pResolveAttachments[i], &in_data.data, sizeof(VkAttachmentReference2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkSubpassDescription2::pResolveAttachments>(const VkAttachmentReference2* const& references) {
+  delete[] references;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkSubpassDescription2::pDepthStencilAttachment>(host_layout<VkSubpassDescription2>& into, const guest_layout<VkSubpassDescription2>& from) {
+  if (from.data.pDepthStencilAttachment.data == 0) {
+    into.data.pDepthStencilAttachment = nullptr;
+    return;
+  }
+
+  into.data.pDepthStencilAttachment = new VkAttachmentReference2;
+  auto in_data = host_layout<VkAttachmentReference2> { *from.data.pDepthStencilAttachment.get_pointer() };
+  fex_apply_custom_repacking(in_data, *from.data.pDepthStencilAttachment.get_pointer());
+  memcpy((void*)into.data.pDepthStencilAttachment, &in_data.data, sizeof(VkAttachmentReference2));
+}
+
+template<>
+void fex_custom_repack_postcall<&VkSubpassDescription2::pDepthStencilAttachment>(const VkAttachmentReference2* const& references) {
+  delete[] references;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkRenderingInfo::pColorAttachments>(host_layout<VkRenderingInfo>& into, const guest_layout<VkRenderingInfo>& from) {
+  if (from.data.colorAttachmentCount.data == 0) {
+    into.data.pColorAttachments = nullptr;
+    return;
+  }
+
+  into.data.pColorAttachments = new VkRenderingAttachmentInfo[from.data.colorAttachmentCount.data];
+  for (size_t i = 0; i < from.data.colorAttachmentCount.data; ++i) {
+    auto in_data = host_layout<VkRenderingAttachmentInfo> { from.data.pColorAttachments.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pColorAttachments.get_pointer()[i]);
+    memcpy((void*)&into.data.pColorAttachments[i], &in_data.data, sizeof(VkRenderingAttachmentInfo));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkRenderingInfo::pColorAttachments>(const VkRenderingAttachmentInfo* const& info) {
+  delete[] info;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkRenderingInfo::pDepthAttachment>(host_layout<VkRenderingInfo>& into, const guest_layout<VkRenderingInfo>& from) {
+  if (from.data.pDepthAttachment.get_pointer() == nullptr) {
+    into.data.pDepthAttachment = nullptr;
+    return;
+  }
+
+  into.data.pDepthAttachment = new VkRenderingAttachmentInfo;
+  auto in_data = host_layout<VkRenderingAttachmentInfo> { *from.data.pDepthAttachment.get_pointer() };
+  fex_apply_custom_repacking(in_data, *from.data.pDepthAttachment.get_pointer());
+  memcpy((void*)into.data.pDepthAttachment, &in_data.data, sizeof(VkRenderingAttachmentInfo));
+}
+
+template<>
+void fex_custom_repack_postcall<&VkRenderingInfo::pDepthAttachment>(const VkRenderingAttachmentInfo* const& info) {
+  delete info;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkRenderingInfo::pStencilAttachment>(host_layout<VkRenderingInfo>& into, const guest_layout<VkRenderingInfo>& from) {
+  if (from.data.pStencilAttachment.get_pointer() == nullptr) {
+    into.data.pStencilAttachment = nullptr;
+    return;
+  }
+
+  into.data.pStencilAttachment = new VkRenderingAttachmentInfo;
+  auto in_data = host_layout<VkRenderingAttachmentInfo> { *from.data.pStencilAttachment.get_pointer() };
+  fex_apply_custom_repacking(in_data, *from.data.pStencilAttachment.get_pointer());
+  memcpy((void*)into.data.pStencilAttachment, &in_data.data, sizeof(VkRenderingAttachmentInfo));
+}
+
+template<>
+void fex_custom_repack_postcall<&VkRenderingInfo::pStencilAttachment>(const VkRenderingAttachmentInfo* const& info) {
+  delete info;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkDependencyInfo::pMemoryBarriers>(host_layout<VkDependencyInfo>& into, const guest_layout<VkDependencyInfo>& from) {
+  if (from.data.memoryBarrierCount.data == 0) {
+    into.data.pMemoryBarriers = nullptr;
+    return;
+  }
+
+  into.data.pMemoryBarriers = new VkMemoryBarrier2[from.data.memoryBarrierCount.data];
+  for (size_t i = 0; i < from.data.memoryBarrierCount.data; ++i) {
+    auto in_data = host_layout<VkMemoryBarrier2> { from.data.pMemoryBarriers.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pMemoryBarriers.get_pointer()[i]);
+    memcpy((void*)&into.data.pMemoryBarriers[i], &in_data.data, sizeof(VkMemoryBarrier2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDependencyInfo::pMemoryBarriers>(const VkMemoryBarrier2* const& barriers) {
+  delete[] barriers;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkDependencyInfo::pBufferMemoryBarriers>(host_layout<VkDependencyInfo>& into, const guest_layout<VkDependencyInfo>& from) {
+  if (from.data.bufferMemoryBarrierCount.data == 0) {
+    into.data.pBufferMemoryBarriers = nullptr;
+    return;
+  }
+
+  into.data.pBufferMemoryBarriers = new VkBufferMemoryBarrier2[from.data.bufferMemoryBarrierCount.data];
+  for (size_t i = 0; i < from.data.bufferMemoryBarrierCount.data; ++i) {
+    auto in_data = host_layout<VkBufferMemoryBarrier2> { from.data.pBufferMemoryBarriers.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pBufferMemoryBarriers.get_pointer()[i]);
+    memcpy((void*)&into.data.pBufferMemoryBarriers[i], &in_data.data, sizeof(VkBufferMemoryBarrier2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDependencyInfo::pBufferMemoryBarriers>(const VkBufferMemoryBarrier2* const& barriers) {
+  delete[] barriers;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkDependencyInfo::pImageMemoryBarriers>(host_layout<VkDependencyInfo>& into, const guest_layout<VkDependencyInfo>& from) {
+  if (from.data.imageMemoryBarrierCount.data == 0) {
+    into.data.pImageMemoryBarriers = nullptr;
+    return;
+  }
+
+  into.data.pImageMemoryBarriers = new VkImageMemoryBarrier2[from.data.imageMemoryBarrierCount.data];
+  for (size_t i = 0; i < from.data.imageMemoryBarrierCount.data; ++i) {
+    auto in_data = host_layout<VkImageMemoryBarrier2> { from.data.pImageMemoryBarriers.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pImageMemoryBarriers.get_pointer()[i]);
+    memcpy((void*)&into.data.pImageMemoryBarriers[i], &in_data.data, sizeof(VkImageMemoryBarrier2));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDependencyInfo::pImageMemoryBarriers>(const VkImageMemoryBarrier2* const& barriers) {
+  delete[] barriers;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkDescriptorUpdateTemplateCreateInfo::pDescriptorUpdateEntries>(host_layout<VkDescriptorUpdateTemplateCreateInfo>& into, const guest_layout<VkDescriptorUpdateTemplateCreateInfo>& from) {
+  if (from.data.descriptorUpdateEntryCount.data == 0) {
+    into.data.pDescriptorUpdateEntries = nullptr;
+    return;
+  }
+
+  into.data.pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[from.data.descriptorUpdateEntryCount.data];
+  for (size_t i = 0; i < from.data.descriptorUpdateEntryCount.data; ++i) {
+    auto in_data = host_layout<VkDescriptorUpdateTemplateEntry> { from.data.pDescriptorUpdateEntries.get_pointer()[i] };
+    fex_apply_custom_repacking(in_data, from.data.pDescriptorUpdateEntries.get_pointer()[i]);
+    memcpy((void*)&into.data.pDescriptorUpdateEntries[i], &in_data.data, sizeof(VkDescriptorUpdateTemplateEntry));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkDescriptorUpdateTemplateCreateInfo::pDescriptorUpdateEntries>(const VkDescriptorUpdateTemplateEntry* const& entries) {
+  delete[] entries;
+  // TODO: Run custom exit-repacking
+}
+
+template<>
+void fex_custom_repack<&VkPipelineShaderStageCreateInfo::pSpecializationInfo>(host_layout<VkPipelineShaderStageCreateInfo>& into, const guest_layout<VkPipelineShaderStageCreateInfo>& from) {
+  if (from.data.pSpecializationInfo.get_pointer()) {
+    fprintf(stderr, "ERROR: Cannot repack non-null VkPipelineShaderStageCreateInfo::pSpecializationInfo yet");
+    std::abort();
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkPipelineShaderStageCreateInfo::pSpecializationInfo>(const VkSpecializationInfo* const&) {
+  // TODO
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pStages>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.stageCount.data) {
+    into.data.pStages = nullptr;
+    return;
+  }
+  auto host_stages = new VkPipelineShaderStageCreateInfo[from.data.stageCount.data];
+  for (size_t i = 0; i < from.data.stageCount.data; ++i) {
+     host_stages[i] = host_layout<VkPipelineShaderStageCreateInfo> { from.data.pStages.get_pointer()[i] }.data;
+  }
+  into.data.pStages = host_stages;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pStages>(const VkPipelineShaderStageCreateInfo* const& stages) {
+  delete[] stages;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pVertexInputState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pVertexInputState.get_pointer()) {
+    into.data.pVertexInputState = nullptr;
+    return;
+  }
+  into.data.pVertexInputState = &(new host_layout<VkPipelineVertexInputStateCreateInfo> { *from.data.pVertexInputState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pVertexInputState>(const VkPipelineVertexInputStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pInputAssemblyState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pInputAssemblyState.get_pointer()) {
+    into.data.pInputAssemblyState = nullptr;
+    return;
+  }
+  into.data.pInputAssemblyState = &(new host_layout<VkPipelineInputAssemblyStateCreateInfo> { *from.data.pInputAssemblyState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pInputAssemblyState>(const VkPipelineInputAssemblyStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pTessellationState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pTessellationState.get_pointer()) {
+    into.data.pTessellationState = nullptr;
+    return;
+  }
+  into.data.pTessellationState = &(new host_layout<VkPipelineTessellationStateCreateInfo> { *from.data.pTessellationState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pTessellationState>(const VkPipelineTessellationStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pViewportState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pViewportState.get_pointer()) {
+    into.data.pViewportState = nullptr;
+    return;
+  }
+  into.data.pViewportState = &(new host_layout<VkPipelineViewportStateCreateInfo> { *from.data.pViewportState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pViewportState>(const VkPipelineViewportStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pRasterizationState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pRasterizationState.get_pointer()) {
+    into.data.pRasterizationState = nullptr;
+    return;
+  }
+  into.data.pRasterizationState = &(new host_layout<VkPipelineRasterizationStateCreateInfo> { *from.data.pRasterizationState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pRasterizationState>(const VkPipelineRasterizationStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pMultisampleState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pMultisampleState.get_pointer()) {
+    into.data.pMultisampleState = nullptr;
+    return;
+  }
+  into.data.pMultisampleState = &(new host_layout<VkPipelineMultisampleStateCreateInfo> { *from.data.pMultisampleState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pMultisampleState>(const VkPipelineMultisampleStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pDepthStencilState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pDepthStencilState.get_pointer()) {
+    into.data.pDepthStencilState = nullptr;
+    return;
+  }
+  into.data.pDepthStencilState = &(new host_layout<VkPipelineDepthStencilStateCreateInfo> { *from.data.pDepthStencilState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pDepthStencilState>(const VkPipelineDepthStencilStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pColorBlendState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pColorBlendState.get_pointer()) {
+    into.data.pColorBlendState = nullptr;
+    return;
+  }
+  into.data.pColorBlendState = &(new host_layout<VkPipelineColorBlendStateCreateInfo> { *from.data.pColorBlendState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pColorBlendState>(const VkPipelineColorBlendStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkGraphicsPipelineCreateInfo::pDynamicState>(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  if (!from.data.pDynamicState.get_pointer()) {
+    into.data.pDynamicState = nullptr;
+    return;
+  }
+  into.data.pDynamicState = &(new host_layout<VkPipelineDynamicStateCreateInfo> { *from.data.pDynamicState.get_pointer() })->data;
+}
+
+template<>
+void fex_custom_repack_postcall<&VkGraphicsPipelineCreateInfo::pDynamicState>(const VkPipelineDynamicStateCreateInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkSubmitInfo::pCommandBuffers>(host_layout<VkSubmitInfo>& into, const guest_layout<VkSubmitInfo>& from) {
+  if (!from.data.pCommandBuffers.get_pointer() || !from.data.commandBufferCount.data) {
+    into.data.pCommandBuffers = nullptr;
+    return;
+  }
+  into.data.pCommandBuffers = new VkCommandBuffer[from.data.commandBufferCount.data];
+  for (size_t i = 0; i < from.data.commandBufferCount.data; ++i) {
+    auto src = host_layout<VkCommandBuffer_T*> { (const guest_layout<VkCommandBuffer_T *>&)from.data.pCommandBuffers.get_pointer()[i] }.data;
+    static_assert(sizeof(src) == sizeof(into.data.pCommandBuffers[i]));
+    memcpy((void*)&into.data.pCommandBuffers[i], &src, sizeof(src));
+  }
+}
+
+template<>
+void fex_custom_repack_postcall<&VkSubmitInfo::pCommandBuffers>(const VkCommandBuffer* const& buffers) {
+  delete[] buffers;
+}
+
+template<>
+void fex_custom_repack<&VkCommandBufferBeginInfo::pInheritanceInfo>(host_layout<VkCommandBufferBeginInfo>& into, const guest_layout<VkCommandBufferBeginInfo>& from) {
+  if (!from.data.pInheritanceInfo.get_pointer() || !from.data.pInheritanceInfo.data) {
+    into.data.pInheritanceInfo = nullptr;
+    return;
+  }
+  into.data.pInheritanceInfo = new VkCommandBufferInheritanceInfo;
+  auto src = host_layout<VkCommandBufferInheritanceInfo> { *from.data.pInheritanceInfo.get_pointer() }.data;
+  static_assert(sizeof(src) == sizeof(*into.data.pInheritanceInfo));
+  memcpy((void*)into.data.pInheritanceInfo, &src, sizeof(src));
+}
+
+template<>
+void fex_custom_repack_postcall<&VkCommandBufferBeginInfo::pInheritanceInfo>(const VkCommandBufferInheritanceInfo* const& info) {
+  delete info;
+}
+
+template<>
+void fex_custom_repack<&VkPipelineCacheCreateInfo::pInitialData>(host_layout<VkPipelineCacheCreateInfo>& into, const guest_layout<VkPipelineCacheCreateInfo>& from) {
+  // Same underlying layout, so there's nothing to do
+  into.data.pInitialData = from.data.pInitialData.get_pointer();
+}
+
+template<>
+void fex_custom_repack_postcall<&VkPipelineCacheCreateInfo::pInitialData>(const void* const&) {
+  // Nothing to do
+}
+
+template<>
+void fex_custom_repack<&VkRenderPassBeginInfo::pClearValues>(host_layout<VkRenderPassBeginInfo>& into, const guest_layout<VkRenderPassBeginInfo>& from) {
+  // Same underlying layout, so there's nothing to do
+  into.data.pClearValues = reinterpret_cast<const VkClearValue*>(from.data.pClearValues.get_pointer());
+}
+
+template<>
+void fex_custom_repack_postcall<&VkRenderPassBeginInfo::pClearValues>(const VkClearValue* const&) {
+  // Nothing to do
+}
+#endif
+
+
 EXPORTS(libvulkan)
diff --git a/ThunkLibs/libvulkan/libvulkan_interface.cpp b/ThunkLibs/libvulkan/libvulkan_interface.cpp
index 5c16b242ea..a4e0f04bd3 100644
--- a/ThunkLibs/libvulkan/libvulkan_interface.cpp
+++ b/ThunkLibs/libvulkan/libvulkan_interface.cpp
@@ -208,31 +208,54 @@ template<> struct fex_gen_config<vkEnumerateInstanceExtensionProperties> {};
 template<> struct fex_gen_config<vkEnumerateDeviceExtensionProperties> {};
 template<> struct fex_gen_config<vkEnumerateInstanceLayerProperties> {};
 template<> struct fex_gen_config<vkEnumerateDeviceLayerProperties> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetDeviceQueue> {};
+#else
+template<> struct fex_gen_config<vkGetDeviceQueue> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkGetDeviceQueue, 3, VkQueue*> : fexgen::ptr_passthrough {};
+#endif
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkQueueSubmit> {};
+#else
+// Needs array repacking for multiple submit infos
+template<> struct fex_gen_config<vkQueueSubmit> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkQueueSubmit, 2, const VkSubmitInfo*> : fexgen::ptr_passthrough {};
+#endif
 template<> struct fex_gen_config<vkQueueWaitIdle> {};
 template<> struct fex_gen_config<vkDeviceWaitIdle> {};
 template<> struct fex_gen_config<vkAllocateMemory> : fexgen::custom_host_impl {};
 template<> struct fex_gen_config<vkFreeMemory> : fexgen::custom_host_impl {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkMapMemory> {};
+#else
+template<> struct fex_gen_config<vkMapMemory> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkMapMemory, 5, void**> : fexgen::ptr_passthrough {};
+#endif
 template<> struct fex_gen_config<vkUnmapMemory> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkFlushMappedMemoryRanges> {};
 template<> struct fex_gen_config<vkInvalidateMappedMemoryRanges> {};
 template<> struct fex_gen_config<vkGetDeviceMemoryCommitment> {};
+#endif
 template<> struct fex_gen_config<vkBindBufferMemory> {};
 template<> struct fex_gen_config<vkBindImageMemory> {};
 template<> struct fex_gen_config<vkGetBufferMemoryRequirements> {};
 template<> struct fex_gen_config<vkGetImageMemoryRequirements> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetImageSparseMemoryRequirements> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceSparseImageFormatProperties> {};
 template<> struct fex_gen_config<vkQueueBindSparse> {};
+#endif
 template<> struct fex_gen_config<vkCreateFence> {};
 template<> struct fex_gen_config<vkDestroyFence> {};
 template<> struct fex_gen_config<vkResetFences> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetFenceStatus> {};
+#endif
 template<> struct fex_gen_config<vkWaitForFences> {};
 template<> struct fex_gen_config<vkCreateSemaphore> {};
 template<> struct fex_gen_config<vkDestroySemaphore> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCreateEvent> {};
 template<> struct fex_gen_config<vkDestroyEvent> {};
 template<> struct fex_gen_config<vkGetEventStatus> {};
@@ -242,6 +265,7 @@ template<> struct fex_gen_config<vkCreateQueryPool> {};
 template<> struct fex_gen_config<vkDestroyQueryPool> {};
 template<> struct fex_gen_config<vkGetQueryPoolResults> {};
 template<> struct fex_gen_param<vkGetQueryPoolResults, 5, void*> : fexgen::assume_compatible_data_layout {};
+#endif
 template<> struct fex_gen_config<vkCreateBuffer> {};
 template<> struct fex_gen_config<vkDestroyBuffer> {};
 template<> struct fex_gen_config<vkCreateBufferView> {};
@@ -255,10 +279,21 @@ template<> struct fex_gen_config<vkCreateShaderModule> /*: fexgen::custom_host_i
 template<> struct fex_gen_config<vkDestroyShaderModule> {};
 template<> struct fex_gen_config<vkCreatePipelineCache> {};
 template<> struct fex_gen_config<vkDestroyPipelineCache> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetPipelineCacheData> {};
+#else
+template<> struct fex_gen_config<vkGetPipelineCacheData> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkGetPipelineCacheData, 2, size_t*> : fexgen::ptr_passthrough {};
+#endif
+template<> struct fex_gen_param<vkGetPipelineCacheData, 3, void*> : fexgen::assume_compatible_data_layout {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkMergePipelineCaches> {};
+#endif
+// TODO: Should be custom_host_impl since there may be more than one VkGraphicsPipelineCreateInfo and more than one output pipeline
 template<> struct fex_gen_config<vkCreateGraphicsPipelines> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCreateComputePipelines> {};
+#endif
 template<> struct fex_gen_config<vkDestroyPipeline> {};
 template<> struct fex_gen_config<vkCreatePipelineLayout> {};
 template<> struct fex_gen_config<vkDestroyPipelineLayout> {};
@@ -271,7 +306,12 @@ template<> struct fex_gen_config<vkDestroyDescriptorPool> {};
 template<> struct fex_gen_config<vkResetDescriptorPool> {};
 template<> struct fex_gen_config<vkAllocateDescriptorSets> {};
 template<> struct fex_gen_config<vkFreeDescriptorSets> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkUpdateDescriptorSets> {};
+#else
+template<> struct fex_gen_config<vkUpdateDescriptorSets> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkUpdateDescriptorSets, 2, const VkWriteDescriptorSet*> : fexgen::ptr_passthrough {};
+#endif
 template<> struct fex_gen_config<vkCreateFramebuffer> {};
 template<> struct fex_gen_config<vkDestroyFramebuffer> {};
 template<> struct fex_gen_config<vkCreateRenderPass> {};
@@ -280,8 +320,19 @@ template<> struct fex_gen_config<vkGetRenderAreaGranularity> {};
 template<> struct fex_gen_config<vkCreateCommandPool> {};
 template<> struct fex_gen_config<vkDestroyCommandPool> {};
 template<> struct fex_gen_config<vkResetCommandPool> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkAllocateCommandBuffers> {};
+#else
+template<> struct fex_gen_config<vkAllocateCommandBuffers> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkAllocateCommandBuffers, 2, VkCommandBuffer*> : fexgen::ptr_passthrough {};
+#endif
+
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkFreeCommandBuffers> {};
+#else
+template<> struct fex_gen_config<vkFreeCommandBuffers> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkFreeCommandBuffers, 3, const VkCommandBuffer*> : fexgen::ptr_passthrough {};
+#endif
 template<> struct fex_gen_config<vkBeginCommandBuffer> {};
 template<> struct fex_gen_config<vkEndCommandBuffer> {};
 template<> struct fex_gen_config<vkResetCommandBuffer> {};
@@ -299,6 +350,7 @@ template<> struct fex_gen_config<vkCmdBindDescriptorSets> {};
 template<> struct fex_gen_config<vkCmdBindIndexBuffer> {};
 template<> struct fex_gen_config<vkCmdBindVertexBuffers> {};
 template<> struct fex_gen_config<vkCmdDraw> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdDrawIndexed> {};
 template<> struct fex_gen_config<vkCmdDrawIndirect> {};
 template<> struct fex_gen_config<vkCmdDrawIndexedIndirect> {};
@@ -307,42 +359,60 @@ template<> struct fex_gen_config<vkCmdDispatchIndirect> {};
 template<> struct fex_gen_config<vkCmdCopyBuffer> {};
 template<> struct fex_gen_config<vkCmdCopyImage> {};
 template<> struct fex_gen_config<vkCmdBlitImage> {};
+#endif
 template<> struct fex_gen_config<vkCmdCopyBufferToImage> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdCopyImageToBuffer> {};
 template<> struct fex_gen_config<vkCmdUpdateBuffer> {};
+template<> struct fex_gen_param<vkCmdUpdateBuffer, 4, const void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCmdFillBuffer> {};
 template<> struct fex_gen_config<vkCmdClearColorImage> {};
 template<> struct fex_gen_config<vkCmdClearDepthStencilImage> {};
+#endif
 template<> struct fex_gen_config<vkCmdClearAttachments> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdResolveImage> {};
 template<> struct fex_gen_config<vkCmdSetEvent> {};
 template<> struct fex_gen_config<vkCmdResetEvent> {};
 template<> struct fex_gen_config<vkCmdWaitEvents> {};
+#endif
 template<> struct fex_gen_config<vkCmdPipelineBarrier> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdBeginQuery> {};
 template<> struct fex_gen_config<vkCmdEndQuery> {};
 template<> struct fex_gen_config<vkCmdResetQueryPool> {};
 template<> struct fex_gen_config<vkCmdWriteTimestamp> {};
 template<> struct fex_gen_config<vkCmdCopyQueryPoolResults> {};
 template<> struct fex_gen_config<vkCmdPushConstants> {};
+template<> struct fex_gen_param<vkCmdPushConstants, 5, const void*> : fexgen::assume_compatible_data_layout {};
+#endif
 template<> struct fex_gen_config<vkCmdBeginRenderPass> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdNextSubpass> {};
+#endif
 template<> struct fex_gen_config<vkCmdEndRenderPass> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdExecuteCommands> {};
+#endif
 template<> struct fex_gen_config<vkEnumerateInstanceVersion> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkBindBufferMemory2> {};
 template<> struct fex_gen_config<vkBindImageMemory2> {};
 template<> struct fex_gen_config<vkGetDeviceGroupPeerMemoryFeatures> {};
 template<> struct fex_gen_config<vkCmdSetDeviceMask> {};
 template<> struct fex_gen_config<vkCmdDispatchBase> {};
 template<> struct fex_gen_config<vkEnumeratePhysicalDeviceGroups> {};
+#endif
 template<> struct fex_gen_config<vkGetImageMemoryRequirements2> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetBufferMemoryRequirements2> {};
 template<> struct fex_gen_config<vkGetImageSparseMemoryRequirements2> {};
+#endif
 template<> struct fex_gen_config<vkGetPhysicalDeviceFeatures2> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceProperties2> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceFormatProperties2> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceImageFormatProperties2> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetPhysicalDeviceQueueFamilyProperties2> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceMemoryProperties2> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceSparseImageFormatProperties2> {};
@@ -350,23 +420,31 @@ template<> struct fex_gen_config<vkTrimCommandPool> {};
 template<> struct fex_gen_config<vkGetDeviceQueue2> {};
 template<> struct fex_gen_config<vkCreateSamplerYcbcrConversion> {};
 template<> struct fex_gen_config<vkDestroySamplerYcbcrConversion> {};
+#endif
 template<> struct fex_gen_config<vkCreateDescriptorUpdateTemplate> {};
 template<> struct fex_gen_config<vkDestroyDescriptorUpdateTemplate> {};
 template<> struct fex_gen_config<vkUpdateDescriptorSetWithTemplate> {};
 template<> struct fex_gen_param<vkUpdateDescriptorSetWithTemplate, 3, const void*> : fexgen::assume_compatible_data_layout {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetPhysicalDeviceExternalBufferProperties> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceExternalFenceProperties> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceExternalSemaphoreProperties> {};
+#endif
 template<> struct fex_gen_config<vkGetDescriptorSetLayoutSupport> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdDrawIndirectCount> {};
 template<> struct fex_gen_config<vkCmdDrawIndexedIndirectCount> {};
+#endif
 template<> struct fex_gen_config<vkCreateRenderPass2> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdBeginRenderPass2> {};
 template<> struct fex_gen_config<vkCmdNextSubpass2> {};
 template<> struct fex_gen_config<vkCmdEndRenderPass2> {};
 template<> struct fex_gen_config<vkResetQueryPool> {};
 template<> struct fex_gen_config<vkGetSemaphoreCounterValue> {};
+#endif
 template<> struct fex_gen_config<vkWaitSemaphores> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkSignalSemaphore> {};
 template<> struct fex_gen_config<vkGetBufferDeviceAddress> {};
 template<> struct fex_gen_config<vkGetBufferOpaqueCaptureAddress> {};
@@ -379,7 +457,9 @@ template<> struct fex_gen_config<vkGetPrivateData> {};
 template<> struct fex_gen_config<vkCmdSetEvent2> {};
 template<> struct fex_gen_config<vkCmdResetEvent2> {};
 template<> struct fex_gen_config<vkCmdWaitEvents2> {};
+#endif
 template<> struct fex_gen_config<vkCmdPipelineBarrier2> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdWriteTimestamp2> {};
 template<> struct fex_gen_config<vkQueueSubmit2> {};
 template<> struct fex_gen_config<vkCmdCopyBuffer2> {};
@@ -388,8 +468,10 @@ template<> struct fex_gen_config<vkCmdCopyBufferToImage2> {};
 template<> struct fex_gen_config<vkCmdCopyImageToBuffer2> {};
 template<> struct fex_gen_config<vkCmdBlitImage2> {};
 template<> struct fex_gen_config<vkCmdResolveImage2> {};
+#endif
 template<> struct fex_gen_config<vkCmdBeginRendering> {};
 template<> struct fex_gen_config<vkCmdEndRendering> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdSetCullMode> {};
 template<> struct fex_gen_config<vkCmdSetFrontFace> {};
 template<> struct fex_gen_config<vkCmdSetPrimitiveTopology> {};
@@ -408,16 +490,18 @@ template<> struct fex_gen_config<vkCmdSetPrimitiveRestartEnable> {};
 template<> struct fex_gen_config<vkGetDeviceBufferMemoryRequirements> {};
 template<> struct fex_gen_config<vkGetDeviceImageMemoryRequirements> {};
 template<> struct fex_gen_config<vkGetDeviceImageSparseMemoryRequirements> {};
+#endif
 template<> struct fex_gen_config<vkDestroySurfaceKHR> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceSurfaceSupportKHR> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceSurfaceCapabilitiesKHR> {};
-template<> struct fex_gen_config<vkGetPhysicalDeviceSurfaceFormatsKHR> {};
+template<> struct fex_gen_config<vkGetPhysicalDeviceSurfaceFormatsKHR> {}; // TODO: Need to figure out how *not* to repack the last parameter on input...
 template<> struct fex_gen_config<vkGetPhysicalDeviceSurfacePresentModesKHR> {};
 template<> struct fex_gen_config<vkCreateSwapchainKHR> {};
 template<> struct fex_gen_config<vkDestroySwapchainKHR> {};
 template<> struct fex_gen_config<vkGetSwapchainImagesKHR> {};
 template<> struct fex_gen_config<vkAcquireNextImageKHR> {};
 template<> struct fex_gen_config<vkQueuePresentKHR> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetDeviceGroupPresentCapabilitiesKHR> {};
 template<> struct fex_gen_config<vkGetDeviceGroupSurfacePresentModesKHR> {};
 template<> struct fex_gen_config<vkGetPhysicalDevicePresentRectanglesKHR> {};
@@ -451,13 +535,17 @@ template<> struct fex_gen_config<vkGetPhysicalDeviceExternalSemaphorePropertiesK
 template<> struct fex_gen_config<vkImportSemaphoreFdKHR> {};
 template<> struct fex_gen_config<vkGetSemaphoreFdKHR> {};
 template<> struct fex_gen_config<vkCmdPushDescriptorSetKHR> {};
+#endif
 template<> struct fex_gen_config<vkCmdPushDescriptorSetWithTemplateKHR> {};
 template<> struct fex_gen_param<vkCmdPushDescriptorSetWithTemplateKHR, 4, const void*> : fexgen::assume_compatible_data_layout {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCreateDescriptorUpdateTemplateKHR> {};
 template<> struct fex_gen_config<vkDestroyDescriptorUpdateTemplateKHR> {};
+#endif
 template<> struct fex_gen_config<vkUpdateDescriptorSetWithTemplateKHR> {};
 template<> struct fex_gen_param<vkUpdateDescriptorSetWithTemplateKHR, 3, const void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCreateRenderPass2KHR> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdBeginRenderPass2KHR> {};
 template<> struct fex_gen_config<vkCmdNextSubpass2KHR> {};
 template<> struct fex_gen_config<vkCmdEndRenderPass2KHR> {};
@@ -606,7 +694,9 @@ template<> struct fex_gen_config<vkCompileDeferredNV> {};
 template<> struct fex_gen_config<vkGetMemoryHostPointerPropertiesEXT> {};
 template<> struct fex_gen_param<vkGetMemoryHostPointerPropertiesEXT, 2, const void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCmdWriteBufferMarkerAMD> {};
+#endif
 template<> struct fex_gen_config<vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetCalibratedTimestampsEXT> {};
 template<> struct fex_gen_config<vkCmdDrawMeshTasksNV> {};
 template<> struct fex_gen_config<vkCmdDrawMeshTasksIndirectNV> {};
@@ -667,14 +757,19 @@ template<> struct fex_gen_config<vkCmdSetVertexInputEXT> {};
 template<> struct fex_gen_config<vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI> {};
 template<> struct fex_gen_config<vkCmdSubpassShadingHUAWEI> {};
 template<> struct fex_gen_config<vkCmdBindInvocationMaskHUAWEI> {};
+#ifndef IS_32BIT_THUNK
+// VkRemoteAddressNV* expands to void**, so it needs custom repacking on on 32-bit
 template<> struct fex_gen_config<vkGetMemoryRemoteAddressNV> {};
+#endif
 template<> struct fex_gen_config<vkGetPipelinePropertiesEXT> {};
 template<> struct fex_gen_config<vkCmdSetPatchControlPointsEXT> {};
 template<> struct fex_gen_config<vkCmdSetRasterizerDiscardEnableEXT> {};
 template<> struct fex_gen_config<vkCmdSetDepthBiasEnableEXT> {};
 template<> struct fex_gen_config<vkCmdSetLogicOpEXT> {};
 template<> struct fex_gen_config<vkCmdSetPrimitiveRestartEnableEXT> {};
+#endif
 template<> struct fex_gen_config<vkCmdSetColorWriteEnableEXT> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdDrawMultiEXT> {};
 template<> struct fex_gen_config<vkCmdDrawMultiIndexedEXT> {};
 template<> struct fex_gen_config<vkCreateMicromapEXT> {};
@@ -784,7 +879,9 @@ template<> struct fex_gen_config<vkAcquireXlibDisplayEXT> {};
 template<> struct fex_gen_config<vkGetRandROutputDisplayEXT> {};
 
 // vulkan_wayland.h
+#endif
 template<> struct fex_gen_config<vkCreateWaylandSurfaceKHR> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetPhysicalDeviceWaylandPresentationSupportKHR> {};
 
 // vulkan_xcb.h
@@ -794,4 +891,5 @@ template<> struct fex_gen_config<vkGetPhysicalDeviceXcbPresentationSupportKHR> {
 // vulkan_xlib.h
 template<> struct fex_gen_config<vkCreateXlibSurfaceKHR> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceXlibPresentationSupportKHR> {};
+#endif
 } // namespace internal

From 17426aa7c2622ebc4e6b006de57492f9cfed9d49 Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Wed, 6 Sep 2023 16:00:47 +0200
Subject: [PATCH 46/48] Revert "TODOSPLIT test cases. unittests/ThunkLibs: Add
 struct repacking tests; Add tests for void pointer parameters"

This reverts commit ea59f314e469bc9be1c1c01c3913e131a70e1f9f.
---
 unittests/ThunkLibs/generator.cpp | 142 ++----------------------------
 1 file changed, 6 insertions(+), 136 deletions(-)

diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index 9e3f34722c..e315d56c61 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -73,7 +73,7 @@ struct Fixture {
      * It will be prepended to "code" before processing and also to the generator output.
      */
     SourceWithAST run_thunkgen_guest(std::string_view prelude, std::string_view code, bool silent = false);
-    SourceWithAST run_thunkgen_host(std::string_view prelude, std::string_view code, GuestABI = GuestABI::X86_64, bool silent = false);
+    SourceWithAST run_thunkgen_host(std::string_view prelude, std::string_view code, bool silent = false);
     GenOutput run_thunkgen(std::string_view prelude, std::string_view code, bool silent = false);
 
     const std::string libname = "libtest";
@@ -236,13 +236,13 @@ SourceWithAST Fixture::run_thunkgen_guest(std::string_view prelude, std::string_
 /**
  * Generates host thunk library code from the given input
  */
-SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_view code, GuestABI guest_abi, bool silent) {
+SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_view code, bool silent) {
     const std::string full_code = std::string { prelude } + std::string { code };
 
     // These tests don't deal with data layout differences, so just run data
     // layout analysis with host configuration
     auto data_layout_analysis_factory = std::make_unique<AnalyzeDataLayoutActionFactory>();
-    run_tool(*data_layout_analysis_factory, full_code, silent, guest_abi);
+    run_tool(*data_layout_analysis_factory, full_code, silent);
     auto& data_layout = data_layout_analysis_factory->GetDataLayout();
 
     run_tool(std::make_unique<GenerateThunkLibsActionFactory>(libname, output_filenames, data_layout), full_code, silent);
@@ -439,27 +439,17 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
     auto& filename = output_filenames.host;
     {
         std::ifstream file(filename);
-        const auto prelude_size = result.size();
+        const auto current_size = result.size();
         const auto new_data_size = std::filesystem::file_size(filename);
         result.resize(result.size() + new_data_size);
-        file.read(result.data() + prelude_size, result.size());
-
-        // Force all functions to be non-static, since having to define them
-        // would add a lot of noise to simple tests.
-        while (true) {
-            auto pos = result.find("static ", prelude_size);
-            if (pos == std::string::npos) {
-                break;
-            }
-            result.replace(pos, 6, "      "); // Replace "static" with 6 spaces (avoiding reallocation)
-        }
+        file.read(result.data() + current_size, result.size());
     }
     return SourceWithAST { std::string { prelude } + result };
 }
 
 Fixture::GenOutput Fixture::run_thunkgen(std::string_view prelude, std::string_view code, bool silent) {
     return { run_thunkgen_guest(prelude, code, silent),
-             run_thunkgen_host(prelude, code, GuestABI::X86_64, silent) };
+             run_thunkgen_host(prelude, code, silent) };
 }
 
 TEST_CASE_METHOD(Fixture, "Trivial") {
@@ -666,123 +656,3 @@ TEST_CASE_METHOD(Fixture, "VariadicFunctionsWithoutAnnotation") {
         "template<auto> struct fex_gen_config {};\n"
         "template<> struct fex_gen_config<func> {};\n", true));
 }
-
-TEST_CASE_METHOD(Fixture, "StructRepacking") {
-    auto guest_abi = GENERATE(GuestABI::X86_32, GuestABI::X86_64);
-    INFO(guest_abi);
-
-    // All tests use the same function, but the prelude defining its parameter type "A" varies
-    const std::string code =
-        "#include <thunks_common.h>\n"
-        "void func(A*);\n"
-        "template<auto> struct fex_gen_config {};\n"
-        "template<> struct fex_gen_config<func> : fexgen::custom_host_impl {};\n";
-
-    SECTION("Pointer to struct with consistent data layout") {
-        CHECK_NOTHROW(run_thunkgen_host("struct A { int a; };\n", code, guest_abi));
-    }
-
-    SECTION("Pointer to struct with unannotated pointer member with inconsistent data layout") {
-        const auto prelude =
-            "#ifdef HOST\n"
-            "struct B { int a; };\n"
-            "#else\n"
-            "struct B { int b; };\n"
-            "#endif\n"
-            "struct A { B* a; };\n";
-
-        SECTION("Parameter unannotated") {
-            // TODO
-            CHECK_THROWS(run_thunkgen_host(prelude, code, guest_abi, true));
-        }
-
-        SECTION("Parameter annotated as ptr_passthrough") {
-            CHECK_NOTHROW(run_thunkgen_host(prelude, code + "template<> struct fex_gen_param<func, 0, A*> : fexgen::ptr_passthrough {};\n", guest_abi));
-        }
-
-        SECTION("Struct member annotated as custom_repack") {
-            CHECK_NOTHROW(run_thunkgen_host("struct A { void* a; };\n",
-                  code + "template<> struct fex_gen_config<&A::a> : fexgen::custom_repack {};\n", guest_abi));
-        }
-    }
-
-    SECTION("Pointer to struct with pointer member of consistent data layout") {
-        std::string type = GENERATE("char", "short", "int", "float");
-        REQUIRE_NOTHROW(run_thunkgen_host("struct A { " + type + "* a; };\n", code, guest_abi));
-    }
-
-    SECTION("Pointer to struct with pointer member of opaque type") {
-        const auto prelude =
-            "struct B;\n"
-            "struct A { B* a; };\n";
-
-        // Unannotated
-        REQUIRE_THROWS_WITH(run_thunkgen_host(prelude, code, guest_abi), Catch::Contains("incomplete type"));
-
-        // Annotated as opaque_type
-        CHECK_NOTHROW(run_thunkgen_host(prelude,
-              code + "template<> struct fex_gen_type<B> : fexgen::opaque_type {};\n", guest_abi));
-    }
-}
-
-TEST_CASE_METHOD(Fixture, "VoidPointerParameter") {
-    auto guest_abi = GENERATE(GuestABI::X86_32, GuestABI::X86_64);
-    INFO(guest_abi);
-
-    SECTION("Unannotated") {
-        const char* code =
-            "#include <thunks_common.h>\n"
-            "void func(void*);\n"
-            "template<> struct fex_gen_config<func> {};\n";
-        if (guest_abi == GuestABI::X86_32) {
-//            CHECK_THROWS_WITH(run_thunkgen_host("", code, guest_abi, true), Catch::Contains("unsupported parameter type", Catch::CaseSensitive::No));
-        } else {
-            // Pointee data is assumed to be compatible on 64-bit
-            CHECK_NOTHROW(run_thunkgen_host("", code, guest_abi));
-        }
-    }
-
-    SECTION("Passthrough") {
-        const char* code =
-            "#include <thunks_common.h>\n"
-            "void func(void*);\n"
-            "template<> struct fex_gen_config<func> : fexgen::custom_host_impl {};\n"
-            "template<> struct fex_gen_param<func, 0, void*> : fexgen::ptr_passthrough {};\n";
-        CHECK_NOTHROW(run_thunkgen_host("", code, guest_abi));
-    }
-
-    SECTION("Assumed compatible") {
-        const char* code =
-            "#include <thunks_common.h>\n"
-            "void func(void*);\n"
-            "template<> struct fex_gen_config<func> {};\n"
-            "template<> struct fex_gen_param<func, 0, void*> : fexgen::assume_compatible_data_layout {};\n";
-        CHECK_NOTHROW(run_thunkgen_host("", code, guest_abi));
-    }
-
-    SECTION("Unannotated in struct") {
-        const char* prelude =
-            "struct A { void* a; };\n";
-        const char* code =
-            "#include <thunks_common.h>\n"
-            "void func(A*);\n"
-            "template<> struct fex_gen_config<func> {};\n";
-        if (guest_abi == GuestABI::X86_32) {
-            // TODO
-            CHECK_THROWS_WITH(run_thunkgen_host(prelude, code, guest_abi, true), Catch::Contains("unsupported parameter type", Catch::CaseSensitive::No));
-        } else {
-            CHECK_NOTHROW(run_thunkgen_host(prelude, code, guest_abi));
-        }
-    }
-
-    SECTION("Custom repack in struct") {
-        const char* prelude =
-            "struct A { void* a; };\n";
-        const char* code =
-            "#include <thunks_common.h>\n"
-            "void func(A*);\n"
-            "template<> struct fex_gen_config<&A::a> : fexgen::custom_repack {};\n"
-            "template<> struct fex_gen_config<func> {};\n";
-        CHECK_NOTHROW(run_thunkgen_host(prelude, code, guest_abi));
-    }
-}

From 02518f21c83b7c5e44f6290680027ed9b2ca7c5e Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Wed, 6 Sep 2023 14:10:45 +0200
Subject: [PATCH 47/48] TODOSQUASH. Thunks: Add more tests

---
 unittests/ThunkLibs/generator.cpp | 160 ++++++++++++++++++++++++++++--
 1 file changed, 153 insertions(+), 7 deletions(-)

diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index e315d56c61..2f6c9b636e 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -73,7 +73,7 @@ struct Fixture {
      * It will be prepended to "code" before processing and also to the generator output.
      */
     SourceWithAST run_thunkgen_guest(std::string_view prelude, std::string_view code, bool silent = false);
-    SourceWithAST run_thunkgen_host(std::string_view prelude, std::string_view code, bool silent = false);
+    SourceWithAST run_thunkgen_host(std::string_view prelude, std::string_view code, GuestABI = GuestABI::X86_64, bool silent = false);
     GenOutput run_thunkgen(std::string_view prelude, std::string_view code, bool silent = false);
 
     const std::string libname = "libtest";
@@ -236,13 +236,13 @@ SourceWithAST Fixture::run_thunkgen_guest(std::string_view prelude, std::string_
 /**
  * Generates host thunk library code from the given input
  */
-SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_view code, bool silent) {
+SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_view code, GuestABI guest_abi, bool silent) {
     const std::string full_code = std::string { prelude } + std::string { code };
 
     // These tests don't deal with data layout differences, so just run data
     // layout analysis with host configuration
     auto data_layout_analysis_factory = std::make_unique<AnalyzeDataLayoutActionFactory>();
-    run_tool(*data_layout_analysis_factory, full_code, silent);
+    run_tool(*data_layout_analysis_factory, full_code, silent, guest_abi);
     auto& data_layout = data_layout_analysis_factory->GetDataLayout();
 
     run_tool(std::make_unique<GenerateThunkLibsActionFactory>(libname, output_filenames, data_layout), full_code, silent);
@@ -434,22 +434,33 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
         "template<typename F> void FinalizeHostTrampolineForGuestFunction(F*);\n"
         "template<typename F> void FinalizeHostTrampolineForGuestFunction(const guest_layout<F*>&);\n"
         "template<typename T> T& unwrap_host(host_layout<T>&);\n"
-        "template<typename T> T* unwrap_host(unpacked_arg_base<T*>&);\n";
+        "template<typename T> T* unwrap_host(unpacked_arg_base<T*>&);\n"
+        "template<typename T> const host_layout<T>& to_host_layout(const T& t);\n";
 
     auto& filename = output_filenames.host;
     {
         std::ifstream file(filename);
-        const auto current_size = result.size();
+        const auto prelude_size = result.size();
         const auto new_data_size = std::filesystem::file_size(filename);
         result.resize(result.size() + new_data_size);
-        file.read(result.data() + current_size, result.size());
+        file.read(result.data() + prelude_size, result.size());
+
+        // Force all functions to be non-static, since having to define them
+        // would add a lot of noise to simple tests.
+        while (true) {
+            auto pos = result.find("static ", prelude_size);
+            if (pos == std::string::npos) {
+                break;
+            }
+            result.replace(pos, 6, "      "); // Replace "static" with 6 spaces (avoiding reallocation)
+        }
     }
     return SourceWithAST { std::string { prelude } + result };
 }
 
 Fixture::GenOutput Fixture::run_thunkgen(std::string_view prelude, std::string_view code, bool silent) {
     return { run_thunkgen_guest(prelude, code, silent),
-             run_thunkgen_host(prelude, code, silent) };
+             run_thunkgen_host(prelude, code, GuestABI::X86_64, silent) };
 }
 
 TEST_CASE_METHOD(Fixture, "Trivial") {
@@ -656,3 +667,138 @@ TEST_CASE_METHOD(Fixture, "VariadicFunctionsWithoutAnnotation") {
         "template<auto> struct fex_gen_config {};\n"
         "template<> struct fex_gen_config<func> {};\n", true));
 }
+
+TEST_CASE_METHOD(Fixture, "StructRepacking") {
+    auto guest_abi = GENERATE(GuestABI::X86_32, GuestABI::X86_64);
+    INFO(guest_abi);
+
+    // All tests use the same function, but the prelude defining its parameter type "A" varies
+    const std::string code =
+        "#include <thunks_common.h>\n"
+        "void func(A*);\n"
+        "template<auto> struct fex_gen_config {};\n"
+        "template<> struct fex_gen_config<func> : fexgen::custom_host_impl {};\n";
+
+    SECTION("Pointer to struct with consistent data layout") {
+        // TODO: NOTHROW
+        auto output = run_thunkgen_host("struct A { int a; };\n", code, guest_abi);
+    }
+
+    SECTION("Pointer to struct with unannotated pointer member with inconsistent data layout") {
+        // TODO: Should B have incompatible data layout?
+        const auto prelude =
+            "#ifdef HOST\n"
+            "struct B { int a; };\n"
+            "#else\n"
+            "struct B { int b; };\n"
+            "#endif\n"
+            "struct A { B* a; };\n";
+
+        SECTION("Parameter unannotated") {
+            CHECK_THROWS(run_thunkgen_host(prelude, code, guest_abi, true));
+        }
+
+
+//        SECTION("Parameter annotated as ptr_passthrough") {
+              // TODO: NOTHROW
+//            auto output = run_thunkgen_host(prelude, code + "template<> struct fex_gen_param<func, 0, A*> : fexgen::ptr_passthrough {};\n", guest_abi);
+//        }
+
+//        SECTION("Struct member annotated as custom_repack") {
+              // TODO: NOTHROW
+//            auto output = run_thunkgen_host("struct A { void* a; };\n",
+//                  code + "template<> struct fex_gen_config<&A::a> : fexgen::custom_repack {};\n", guest_abi);
+//        }
+    }
+
+    SECTION("Pointer to struct with pointer member of consistent data layout") {
+        std::string type = GENERATE("char", "short", "int", "float");
+        REQUIRE_NOTHROW(run_thunkgen_host("struct A { " + type + "* a; };\n", code, guest_abi));
+    }
+
+    SECTION("Pointer to struct with pointer member of opaque type") {
+        const auto prelude =
+            "struct B;\n"
+            "struct A { B* a; };\n";
+
+        // Unannotated
+        REQUIRE_THROWS_WITH(run_thunkgen_host(prelude, code, guest_abi), Catch::Contains("incomplete type"));
+
+        // Annotated as opaque_type
+        auto output = run_thunkgen_host(prelude,
+              code + "template<> struct fex_gen_type<B> : fexgen::opaque_type {};\n", guest_abi);
+    }
+
+    // TODO: Array arguments (ints, floats, enum, compatible structs)
+
+    // TODO: Check that the right repacking code gets emitted for each type of data layout compatibility:
+        // TODO: Check that fully compatible types use unpacked_arg, and that to_guest isn't called
+        // TODO: Check that repackable types use unpacked_arg_with_storage
+        // TODO: Check that custom_repack annotations cause fex_apply_custom_repacking(_postcall) to be called
+
+    // TODO: "assume compatible" annotations (and they should repack the pointer on 32-bit, without modifying the data!)
+        // TODO: assume_compatible annotations (void* arguments)
+
+    // TODO: Determine if we can do similar tests for calls through function pointers
+}
+
+TEST_CASE_METHOD(Fixture, "VoidPointerParameter") {
+    auto guest_abi = GENERATE(GuestABI::X86_32, GuestABI::X86_64);
+    INFO(guest_abi);
+
+    SECTION("Unannotated") {
+        const char* code =
+            "#include <thunks_common.h>\n"
+            "void func(void*);\n"
+            "template<> struct fex_gen_config<func> {};\n";
+        if (guest_abi == GuestABI::X86_32) {
+//            CHECK_THROWS_WITH(run_thunkgen_host("", code, guest_abi, true), Catch::Contains("unsupported parameter type", Catch::CaseSensitive::No));
+        } else {
+            // Pointee data is assumed to be compatible on 64-bit
+            CHECK_NOTHROW(run_thunkgen_host("", code, guest_abi));
+        }
+    }
+
+    SECTION("Passthrough") {
+        const char* code =
+            "#include <thunks_common.h>\n"
+            "void func(void*);\n"
+            "template<> struct fex_gen_config<func> : fexgen::custom_host_impl {};\n"
+            "template<> struct fex_gen_param<func, 0, void*> : fexgen::ptr_passthrough {};\n";
+        CHECK_NOTHROW(run_thunkgen_host("", code, guest_abi));
+    }
+
+    SECTION("Assumed compatible") {
+        const char* code =
+            "#include <thunks_common.h>\n"
+            "void func(void*);\n"
+            "template<> struct fex_gen_config<func> {};\n"
+            "template<> struct fex_gen_param<func, 0, void*> : fexgen::assume_compatible_data_layout {};\n";
+        CHECK_NOTHROW(run_thunkgen_host("", code, guest_abi));
+    }
+
+    SECTION("Unannotated in struct") {
+        const char* prelude =
+            "struct A { void* a; };\n";
+        const char* code =
+            "#include <thunks_common.h>\n"
+            "void func(A*);\n"
+            "template<> struct fex_gen_config<func> {};\n";
+        if (guest_abi == GuestABI::X86_32) {
+            CHECK_THROWS_WITH(run_thunkgen_host(prelude, code, guest_abi, true), Catch::Contains("unsupported parameter type", Catch::CaseSensitive::No));
+        } else {
+            CHECK_NOTHROW(run_thunkgen_host(prelude, code, guest_abi));
+        }
+    }
+
+    SECTION("Custom repack in struct") {
+        const char* prelude =
+            "struct A { void* a; };\n";
+        const char* code =
+            "#include <thunks_common.h>\n"
+            "void func(A*);\n"
+            "template<> struct fex_gen_config<&A::a> : fexgen::custom_repack {};\n"
+            "template<> struct fex_gen_config<func> {};\n";
+        CHECK_NOTHROW(run_thunkgen_host(prelude, code, guest_abi));
+    }
+}

From ca023e74aec35e654a49558df9b9708db73c40bf Mon Sep 17 00:00:00 2001
From: Tony Wasserka <neobrain@users.noreply.github.com>
Date: Wed, 6 Sep 2023 14:11:28 +0200
Subject: [PATCH 48/48] TODOFINISH. Thunks/gen: Avoid generating layout
 conversion code for non-repackable types. TODO: Needs an explicit mechanism
 to do this anyway if all members match vaguely!

---
 ThunkLibs/Generator/gen.cpp | 25 ++++++++++++++++++-------
 1 file changed, 18 insertions(+), 7 deletions(-)

diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index 0f94210575..cedc65e1e0 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -415,10 +415,13 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
             fmt::print(file, "  using type = {};\n", struct_name);
             fmt::print(file, "  type data;\n");
             fmt::print(file, "\n");
-            fmt::print(file, "  host_layout(const guest_layout<{}>& from) :\n", struct_name);
+            fmt::print(file, "  host_layout(const guest_layout<{}>& from) ", struct_name);
             if (type_compat.at(type) == TypeCompatibility::Full) {
+                fmt::print(file, ":\n");
                 fmt::print(file, "    data {{ from.data }} {{\n");
-            } else {
+                fmt::print(file, "  }}\n");
+            } else if (type_compat.at(type) == TypeCompatibility::Repackable) {
+                fmt::print(file, ":\n");
                 fmt::print(file, "    data {{\n");
                 fmt::print(file, "      // Constructor performs layout repacking.\n");
                 fmt::print(file, "      // Each initializer itself is wrapped in host_layout<> to enable recursive layout repacking\n");
@@ -451,18 +454,24 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                       // Leave field uninitialized
                     }
                 }
+                fmt::print(file, "  }}\n");
+            } else {
+                fmt::print(file, "= delete;\n");
             }
-            fmt::print(file, "  }}\n");
             fmt::print(file, "}};\n\n");
 
             fmt::print(file, "// Constructor performs layout repacking.\n");
             fmt::print(file, "// Each initializer itself is wrapped in host_layout<> to enable recursive layout repacking\n");
-            fmt::print(file, "inline guest_layout<{}> to_guest(const host_layout<{}>& from) {{\n", struct_name, struct_name);
+            fmt::print(file, "inline guest_layout<{}> to_guest(const host_layout<{}>& from) ", struct_name, struct_name);
             if (type_compat.at(type) == TypeCompatibility::Full) {
+                fmt::print(file, "{{\n");
                 fmt::print(file, "  guest_layout<{}> ret;\n", struct_name);
                 fmt::print(file, "  static_assert(sizeof(from) == sizeof(ret));\n");
                 fmt::print(file, "  memcpy(&ret, &from, sizeof(from));\n");
-            } else {
+                fmt::print(file, "  return ret;\n");
+                fmt::print(file, "}}\n\n");
+            } else if (type_compat.at(type) == TypeCompatibility::Repackable) {
+                fmt::print(file, "{{\n");
                 fmt::print(file, "  guest_layout<{}> ret {{ .data {{\n", struct_name);
                 auto map_field2 = [&file](const StructInfo::MemberInfo& member, bool skip_arrays) {
                     auto& decl_name = member.member_name;
@@ -493,9 +502,11 @@ void GenerateThunkLibsAction::EmitOutput(clang::ASTContext& context) {
                       // Leave field uninitialized
                     }
                 }
+                fmt::print(file, "  return ret;\n");
+                fmt::print(file, "}}\n\n");
+            } else {
+                fmt::print(file, "= delete;\n\n");
             }
-            fmt::print(file, "  return ret;\n");
-            fmt::print(file, "}}\n\n");
 
             // Forward-declare user-provided repacking functions
             for (const auto& member_name : type_repack_info.custom_repacked_members) {