IOS IL2CPP

[nzcv]

metadata/GenericMethod.cpp

    std::string get_klsname(Il2CppClass *klass) {
        char name[512]{0};
        strcat(name, klass->name);
        if (klass->generic_class) {
            const Il2CppGenericInst* inst = klass->generic_class->context.class_inst;
            for (int i = 0; i < inst->type_argc; ++i) {
                Il2CppClass *inst_kls = Class::FromIl2CppType(inst->type_argv[i]);
                if (i == 0) strcat(name, "<");
                if (i != 0) strcat(name, ", ");
                strcat(name, inst_kls->name);
                if (i == inst->type_argc - 1) strcat(name, ">");
            }
        }
        return name;
    }

    const MethodInfo* GenericMethod::CreateMethodLocked(const Il2CppGenericMethod* gmethod, bool copyMethodPtr)
    {
        // We need to inflate a new generic method, take the metadata mutex
        // All code below this point can and does assume mutual exclusion
        FastAutoLock lock(&il2cpp::vm::g_MetadataLock);

        // Recheck the s_GenericMethodMap in case there was a race to add this generic method
        MethodInfo* existingMethod;
        if (s_GenericMethodMap.TryGet(gmethod, &existingMethod))
            return existingMethod;

        // GetMethodLocked may be called recursively, we keep tracking of pending inflations
        if (s_PendingGenericMethodMap.TryGet(gmethod, &existingMethod))
            return existingMethod;

        if (copyMethodPtr)
            gmethod = MetadataCache::GetGenericMethod(gmethod->methodDefinition, gmethod->context.class_inst, gmethod->context.method_inst);

        const MethodInfo* methodDefinition = gmethod->methodDefinition;
        Il2CppClass* declaringClass = methodDefinition->klass;
        if (gmethod->context.class_inst)
        {
            Il2CppGenericClass* genericClassDeclaringType = GenericMetadata::GetGenericClass(methodDefinition->klass, gmethod->context.class_inst);
            declaringClass = GenericClass::GetClass(genericClassDeclaringType);

            // we may fail if we cannot construct generic type
            if (!declaringClass)
                return NULL;
        }

        //add by tp
        auto loger = FLog::Get("generic_method");
        loger->write("%s\t%s\n", get_klsname(declaringClass).c_str(), methodDefinition->name);
        loger->flush();
        //end add

[nzcv]

vm/FLog.cpp

#include "FLog.h"
#include <map>
// #include <Runtime/File/ApplicationSpecificPersistentDataPath.h>
// #import <Foundation/Foundation.h>

static std::string sDocDir;
extern "C" EXPORTC void SetDocumentDir(const char* docDir) {
    // set doc dir
    sDocDir = docDir;
}

FLog::FLoger::FLoger(const std::string& name) : m_file(nullptr) {
    //std::string log_dir = fmt::format("{}/" VKLOG_DIR "/{}_{}", get_files_dir(), ts_buf, getpid());    
    //std::string log_file = fmt::format("{}/{}", log_dir, name);
    
    // Get the paths to the user's Document directory
    // NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    
    // Get the first path (the Documents directory)
    // NSString *docDir = [paths objectAtIndex:0];

    // std::string docDirCStr = [docDir UTF8String];
    

    // docdir cstr
    // auto docDirCStr = GetPersistentDataPathApplicationSpecific(); //[docDir UTF8String];

    char log_file[256];
    time_t now = time(nullptr);
    snprintf(log_file, sizeof(log_file), "%s/%s_%ld.txt", sDocDir.c_str(), name.c_str(), now);
    printf("[TP]%s\n", log_file);
    m_file = fopen(log_file, "w");
    if (!m_file) {
        assert(false && "Failed to open log file");
    }
}

extern "C" EXPORTC void FLogCallBack(const char* a1, const char* a2, uint64_t a3) {
    auto f = FLog::Get("FLog");
    f->write("%016lx %s %s %ld\n", FLog::now_us(), a1, a2, a3);            
}

[nzcv]

vm/FLog.h

#pragma once
#include <string>
#include <stdio.h>
#include <string_view>
#include <cstdarg>
#include <chrono>

#define EXPORTC  __attribute__((visibility("default")))

extern "C" EXPORTC void FLogCallBack(const char* a1, const char* a2, uint64_t a3);

extern "C" EXPORTC void SetDocumentDir(const char* docDir);

namespace FLog{
    class FLoger {
    public:
        explicit FLoger(const std::string& name);
        ~FLoger() {
            if (m_file) {
                fclose(m_file);
            }
        }
        FLoger(const FLoger&) = delete;
        FLoger& operator=(const FLoger&) = delete;
        FLoger(FLoger&&) = delete;
        FLoger& operator=(FLoger&&) = delete;
        
        FLoger& write(const char* fmt, ...) {            
            va_list args;
            va_start(args, fmt);
            vfprintf(m_file, fmt, args);
            va_end(args);
            return *this;
        }

        FILE* fd() { return m_file; }
        void flush() { fflush(m_file); }
        void close() { fclose(m_file); m_file = NULL; }
    private:
        FILE* m_file;
    public:
        std::string pre_msg = "x";
    };

    using SFLoger = std::shared_ptr<FLoger>;

    SFLoger Get(const char* name) {
        static std::map<std::string, FLog::SFLoger> s_FLogers;
        auto it = s_FLogers.find(name);
        if (it == s_FLogers.end()) {
            it = s_FLogers.emplace(name, std::make_shared<FLoger>(name)).first;
        }
        return it->second;
    }

    //
    uint64_t now_us() {
        auto now = std::chrono::high_resolution_clock::now();
        auto ns = std::chrono::time_point_cast<std::chrono::nanoseconds>(now);
        return ns.time_since_epoch().count();
    }
}  // namespace FLog

[nzcv]

用于调试 il2cpp 初始化内存占用

[nzcv]

extern "C" void SetDocumentDir(const char* docDir);

- (void)frameworkWarmup:(int)argc argv:(char*[])argv
{
#if UNITY_USES_DYNAMIC_PLAYER_LIB
    SetAllUnityFunctionsForDynamicPlayerLib();
#endif
    // Get the paths to the user's Document directory
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
       
    // Get the first path (the Documents directory)
    NSString *docDir = [paths objectAtIndex:0];

    const char* docDirCStr = [docDir UTF8String];
    
    SetDocumentDir(docDirCStr);

[nzcv]

    static int CreateMethodLocked_counter = 0;
    struct GenericMethodRecord
    {
        const Il2CppClass *klass;
        std::string method_name;
    };
    static std::vector<GenericMethodRecord*> s_created_generic_methods;

    IL2CPP_EXPORT void il2cpp_get_created_generic_method_count()
    {
        auto f = FLog::Get("generic_method");
        for (auto& rec : s_created_generic_methods) {
            f->write("%s\t%s\n", get_klsname((Il2CppClass*)rec->klass).c_str(), rec->method_name.c_str());
        }
        f->write("total generic method count: %zu\n", s_created_generic_methods.size());
        f->flush();
    }

[nzcv]

非直接文件映射会产生vm_allocation开销

[nzcv]

[nzcv]

https://support.unity.com/hc/zh-cn/articles/208412186-IL2CPP-%E6%9E%84%E5%BB%BA%E5%A4%A7%E5%B0%8F%E4%BC%98%E5%8C%96