# backtrace

1. `loadEmulatedLib`

#0  loadEmulatedLib (
	libname=libname@entry=0xffffffffc7e0 "/opt/wine-devel/bin/../lib64/wine/x86_64-unix/ntdll.so",
	lib=lib@entry=0x36d1a220, context=context@entry=0x36d14fc0, verneeded=verneeded@entry=0x0)
	at /home/chiu/devarajabc_box64/box64/src/librarian/library.c:310
#1  0x0000000034896a80 in loadEmulatedLib (
	libname=0xffffffffc7e0 "/opt/wine-devel/bin/../lib64/wine/x86_64-unix/ntdll.so", lib=0x36d1a220,
	context=0x36d14fc0, verneeded=0x0) at /home/chiu/devarajabc_box64/box64/src/librarian/library.c:308
#2  initEmulatedLib (path=path@entry=0xffffffffd910 "/opt/wine-devel/bin/../lib64/wine/x86_64-unix/ntdll.so",
	lib=lib@entry=0x36d1a220, context=0x36d14fc0, verneeded=0x0)
	at /home/chiu/devarajabc_box64/box64/src/librarian/library.c:395
#3  0x0000000034899f9c in NewLibrary (
	path=path@entry=0xffffffffd910 "/opt/wine-devel/bin/../lib64/wine/x86_64-unix/ntdll.so",
	context=<optimized out>, verneeded=<optimized out>)
	at /home/chiu/devarajabc_box64/box64/src/librarian/library.c:532
#4  0x0000000034894950 in AddNeededLib_add (maplib=<synthetic pointer>, local=1, needed=0x36d255e0, n=0,
	verneeded=0x0, box64=0x36d14fc0, emu=0x36d174a0)
	at /home/chiu/devarajabc_box64/box64/src/librarian/librarian.c:226
#5  AddNeededLib (maplib=maplib@entry=0x0, local=local@entry=1, bindnow=<optimized out>,
	deepbind=deepbind@entry=0, needed=needed@entry=0x36d255e0, verneeded=verneeded@entry=0x0,
	box64=<optimized out>, emu=emu@entry=0x36d174a0)
	at /home/chiu/devarajabc_box64/box64/src/librarian/librarian.c:340
#6  0x0000000034e5f478 in my_dlopen (emu=<error reading variable: value has been optimized out>,
	filename=<error reading variable: value has been optimized out>, flag=2,
	flag@entry=<error reading variable: value has been optimized out>)
	at /home/chiu/devarajabc_box64/box64/src/wrapped/wrappedlibdl.c:234
#7  0x00000000348d4260 in pFEpi (emu=0x36d174a0, fcn=<optimized out>)
	at /home/chiu/devarajabc_box64/box64/src/wrapped/generated/wrapper.c:4293
#8  0x0000fffff70026e0 in ?? ()
#9  0x00000000360550a0 in my_alternates ()
Backtrace stopped: previous frame identical to this frame (corrupt stack?)

2. `initWrappedLib`

#0  initWrappedLib (lib=lib@entry=0x36d19ba0, context=context@entry=0x36d14fc0)
	at /home/chiu/devarajabc_box64/box64/src/librarian/library.c:262
#1  0x000000003489a128 in NewLibrary (path=path@entry=0x36d170a0 "libdl.so.2", context=<optimized out>,
	verneeded=<optimized out>) at /home/chiu/devarajabc_box64/box64/src/librarian/library.c:529
#2  0x0000000034894950 in AddNeededLib_add (maplib=<synthetic pointer>, local=0, needed=0x36d16200, n=0,
	verneeded=0x36d184b0, box64=0x36d14fc0, emu=0x36d174a0)
	at /home/chiu/devarajabc_box64/box64/src/librarian/librarian.c:226
#3  AddNeededLib (maplib=0x36d0ff30, local=local@entry=0, bindnow=bindnow@entry=0, deepbind=deepbind@entry=0,
	needed=needed@entry=0x36d16200, verneeded=<optimized out>, box64=<optimized out>, emu=emu@entry=0x36d174a0)
	at /home/chiu/devarajabc_box64/box64/src/librarian/librarian.c:340
#4  0x000000003486f7b8 in initialize (argc=<optimized out>, argv=<optimized out>, env=<optimized out>,
	emulator=emulator@entry=0xffffffffef10, elfheader=elfheader@entry=0xffffffffef18, exec=exec@entry=1)
	at /home/chiu/devarajabc_box64/box64/src/core.c:1498
#5  0x0000000034824f0c in main (argc=<optimized out>, argv=<optimized out>, env=<optimized out>)
	at /home/chiu/devarajabc_box64/box64/src/main.c:7

3. `initEmulatedLib`

#0  initEmulatedLib (path=path@entry=0xffffffffd910 "/opt/wine-devel/bin/../lib64/wine/x86_64-unix/ntdll.so",
	lib=lib@entry=0x36d1a220, context=0x36d14fc0, verneeded=0x0)
	at /home/chiu/devarajabc_box64/box64/src/librarian/library.c:392
#1  0x0000000034899f9c in NewLibrary (
	path=path@entry=0xffffffffd910 "/opt/wine-devel/bin/../lib64/wine/x86_64-unix/ntdll.so",
	context=<optimized out>, verneeded=<optimized out>)
	at /home/chiu/devarajabc_box64/box64/src/librarian/library.c:532
#2  0x0000000034894950 in AddNeededLib_add (maplib=<synthetic pointer>, local=1, needed=0x36d255e0, n=0,
	verneeded=0x0, box64=0x36d14fc0, emu=0x36d174a0)
	at /home/chiu/devarajabc_box64/box64/src/librarian/librarian.c:226
#3  AddNeededLib (maplib=maplib@entry=0x0, local=local@entry=1, bindnow=<optimized out>,
	deepbind=deepbind@entry=0, needed=needed@entry=0x36d255e0, verneeded=verneeded@entry=0x0,
	box64=<optimized out>, emu=emu@entry=0x36d174a0)
	at /home/chiu/devarajabc_box64/box64/src/librarian/librarian.c:340
#4  0x0000000034e5f478 in my_dlopen (emu=<error reading variable: value has been optimized out>,
	filename=<error reading variable: value has been optimized out>, flag=2,
	flag@entry=<error reading variable: value has been optimized out>)
	at /home/chiu/devarajabc_box64/box64/src/wrapped/wrappedlibdl.c:234
#5  0x00000000348d4260 in pFEpi (emu=0x36d174a0, fcn=<optimized out>)
	at /home/chiu/devarajabc_box64/box64/src/wrapped/generated/wrapper.c:4293
#6  0x0000fffff70026e0 in ?? ()
#7  0x00000000360550a0 in my_alternates ()
Backtrace stopped: previous frame identical to this frame (corrupt stack?)

## `library_t`

typedef struct library_s {
    char*               name;   // <> path
    char*               path;   // original path
    int8_t              nbdot;  // number of "." after .so
    int8_t              type;   // 0: native(wrapped) 1: emulated(elf) -1: undetermined
    uint8_t             deepbind;
    wrappedlib_fini_t   fini;
    wrappedlib_get_t    getglobal;  // get global (non-weak)
    wrappedlib_get_t    getweak;    // get weak symbol
    wrappedlib_get_t    getlocal;   // get local symbol
    union {
        wlib_t  w;     
        elib_t  e;
    };                              // private lib data
    lib_t               *maplib;        // local maplib, for dlopen'd library with LOCAL binding (most of the dlopen)
    int                 maplib_ref;     // ref to maplib (not owned)
    size_t              dlopen;   // idx to the dlopen idx (or 0 if not dlopen)
} library_t;

#define LIB_WRAPPED     0
#define LIB_EMULATED    1
#define LIB_UNNKNOW     -1

int initialize(int argc, const char **argv, char** env, x64emu_t** emulator, elfheader_t** elfheader, int exec)
{
    #ifndef STATICBUILD
    init_malloc_hook();
    #endif
    init_auxval(argc, argv, environ?environ:env);
    // analogue to QEMU_VERSION in qemu-user-mode emulation
    if(getenv("BOX64_VERSION")) {
        PrintBox64Version(0);
        exit(0);
    }
    // trying to open and load 1st arg
    if(argc==1) {
        /*PrintBox64Version(1);
        PrintHelp();
        return 1;*/
        printf("[BOX64] Missing operand after 'box64'\n");
        printf("See 'box64 --help' for more information.\n");
        exit(0);
    }
    if(argc>1 && !strcmp(argv[1], "/usr/bin/gdb") && BOX64ENV(trace_file))
        exit(0);
    // uname -m is redirected to box64 -m
    if(argc==2 && (!strcmp(argv[1], "-m") || !strcmp(argv[1], "-p") || !strcmp(argv[1], "-i")))
    {
        printf("x86_64\n");
        exit(0);
    }

    ftrace = stdout;

    LoadEnvVariables();
    InitializeEnvFiles();

    const char* prog = argv[1];
    int nextarg = 1;
    // check if some options are passed
    while(prog && prog[0]=='-') {
        if(!strcmp(prog, "-v") || !strcmp(prog, "--version")) {
            PrintBox64Version(0);
            exit(0);
        }
        if(!strcmp(prog, "-h") || !strcmp(prog, "--help")) {
            PrintHelp();
            exit(0);
        }
        // other options?
        if(!strcmp(prog, "--")) {
            prog = argv[++nextarg];
            break;
        }
        printf("Warning, Unrecognized option '%s'\n", prog);
        prog = argv[++nextarg];
    }
    if(!prog || nextarg==argc) {
        printf("[BOX64] Nothing to run\n");
        exit(0);
    }

    if (!BOX64ENV(nobanner)) PrintBox64Version(1);

    displayMiscInfo();

    hookMangoHud();

    char* bashpath = NULL;
    {
        char* p = BOX64ENV(bash);
        if(p) {
            if(FileIsX64ELF(p)) {
                bashpath = p;
                printf_log(LOG_INFO, "Using bash \"%s\"\n", bashpath);
            } else {
                printf_log(LOG_INFO, "The x86_64 bash \"%s\" is not an x86_64 binary.\n", p);
            }
        }
    }

    // precheck, for win-preload
    const char* prog_ = strrchr(prog, '/');
    if(!prog_) prog_ = prog; else ++prog_;
    if(!strcmp(prog_, "wine-preloader") || !strcmp(prog_, "wine64-preloader")) {
        // wine-preloader detecter, skipping it if next arg exist and is an x86 binary
        int x64 = (nextarg<argc)?FileIsX64ELF(argv[nextarg]):0;
        #ifdef BOX32
        int x86 = (nextarg<argc)?FileIsX86ELF(argv[nextarg]):0;
        #else
        int x86 = 0;
        #endif
        if(x64 || x86) {
            prog = argv[++nextarg];
            printf_log(LOG_INFO, "Wine preloader detected, loading \"%s\" directly\n", prog);
            wine_preloaded = 1;
            prog_ = strrchr(prog, '/');
            if(!prog_) prog_ = prog; else ++prog_;
        }
    }
    #ifndef STATICBUILD
    // pre-check for pressure-vessel-wrap
    if(!strcmp(prog_, "pressure-vessel-wrap")) {
        printf_log(LOG_INFO, "pressure-vessel-wrap detected\n");
        pressure_vessel(argc, argv, nextarg+1, prog);
    }
    #endif
    int ld_libs_args = -1;
    int is_custom_gstreamer = 0;
    // check if this is wine
    if(!strcmp(prog_, "wine64")
     || !strcmp(prog_, "wine64-development")
     || !strcmp(prog_, "wine")) {
        const char* prereserve = getenv("WINEPRELOADRESERVE");
        printf_log(LOG_INFO, "Wine64 detected, WINEPRELOADRESERVE=\"%s\"\n", prereserve?prereserve:"");
        if(wine_preloaded || 1) {
            wine_prereserve(prereserve);
        }
        // special case for winedbg, doesn't work anyway
        if(argv[nextarg+1] && strstr(argv[nextarg+1], "winedbg")==argv[nextarg+1]) {
            if(getenv("BOX64_WINEDBG")) {
                SET_BOX64ENV(nobanner, 1);
                BOX64ENV(log) = 0;
            } else {
                printf_log(LOG_NONE, "winedbg detected, not launching it!\n");
                exit(0);    // exiting, it doesn't work anyway
            }
        }
        box64_wine = 1;
        // check if it's proton, with it's custom gstreamer build, to disable gtk3 loading
        char tmp[strlen(prog)+100];
        strcpy(tmp, prog);
        char* pp = strrchr(tmp, '/');
        if(pp) {
            *pp = '\0'; // remove the wine binary call
            strcat(tmp, "/../lib64/gstreamer-1.0");
            // check if it exist
            if(FileExist(tmp, 0)) {
                box64_custom_gstreamer = box_strdup(tmp);
            }
        }
        // Try to get the name of the exe being run, to ApplyEnvFileEntry laters
        if(argv[nextarg+1] && argv[nextarg+1][0]!='-' && strlen(argv[nextarg+1])>4 /*&& !strcasecmp(argv[nextarg+1]+strlen(argv[nextarg+1])-4, ".exe")*/) {
            const char* pp = strrchr(argv[nextarg+1], '/');
            if(pp)
                box64_wine_guest_name = pp + 1;
            else {
                pp = strrchr(argv[nextarg+1], '\\');
                if(pp)
                    box64_wine_guest_name = pp + 1;
                else
                    box64_wine_guest_name = argv[nextarg + 1];
            }
        }
        if (box64_wine_guest_name) printf_log(LOG_INFO, "Detected running wine with \"%s\"\n", box64_wine_guest_name);
    } else if(strstr(prog, "ld-musl-x86_64.so.1")) {
    // check if ld-musl-x86_64.so.1 is used
        printf_log(LOG_INFO, "ld-musl detected. Trying to workaround and use system ld-linux\n");
        box64_musl = 1;
        // skip ld-musl and go through args unti "--" is found, handling "--library-path" to add some libs to BOX64_LD_LIBRARY
        ++nextarg;
        while(strcmp(argv[nextarg], "--")) {
            if(!strcmp(argv[nextarg], "--library-path")) {
                ++nextarg;
                ld_libs_args = nextarg;
            }
            ++nextarg;
        }
        ++nextarg;
        prog = argv[nextarg];
    } else if(!strcmp(prog_, "steam") ) {
        printf_log(LOG_INFO, "steam detected\n");
        box64_steam = 1;
    } else if(!strcmp(prog_, "steamcmd")) {
        printf_log(LOG_INFO, "steamcmd detected\n");
        box64_steamcmd = 1;
    } else  if(!strcmp(prog_, "wineserver")) {
        // check if this is wineserver
        box64_wine = 1;
    }
    // Create a new context
    my_context = NewBox64Context(argc - nextarg);

    addLibPaths(my_context);

    // Append ld_list if it exist
    if(ld_libs_args!=-1)
        PrependList(&my_context->box64_ld_lib, argv[ld_libs_args], 1);
    if(is_custom_gstreamer) //TODO: is this still needed?
        AddPath("libwayland-client.so.0", &my_context->box64_emulated_libs, 0);

    my_context->box64path = ResolveFile(argv[0], &my_context->box64_path);
    // prepare all other env. var
    my_context->envc = CountEnv(environ?environ:env);
    printf_log(LOG_INFO, "Counted %d Env var\n", my_context->envc);
    // allocate extra space for new environment variables such as BOX64_PATH
    my_context->envv = (char**)box_calloc(my_context->envc+1, sizeof(char*));

    path_collection_t ld_preload = {0};
    if(getenv("BOX64_LD_PRELOAD")) {
        char* p = getenv("BOX64_LD_PRELOAD");
        ParseList(p, &ld_preload, 0);
        if (ld_preload.size && BOX64ENV(log)) {
            printf_log(LOG_INFO, "BOX64 trying to Preload ");
            for (int i=0; i<ld_preload.size; ++i)
                printf_log_prefix(0, LOG_INFO, "%s ", ld_preload.paths[i]);
            printf_log_prefix(0, LOG_INFO, "\n");
        }
    }
    if(getenv("LD_PRELOAD")) {
        char* p = getenv("LD_PRELOAD");
        if(strstr(p, "libtcmalloc_minimal.so.0"))
            box64_tcmalloc_minimal = 1;
        if(strstr(p, "libtcmalloc_minimal.so.4"))
            box64_tcmalloc_minimal = 1;
        if(strstr(p, "libtcmalloc_minimal_debug.so.4"))
            box64_tcmalloc_minimal = 1;
        if(strstr(p, "libasan.so"))
            box64_tcmalloc_minimal = 1; // it seems Address Sanitizer doesn't handle dlsym'd malloc very well
        AppendList(&ld_preload, p, 0);
        if (ld_preload.size && BOX64ENV(log)) {
            printf_log(LOG_INFO, "BOX64 trying to Preload ");
            for (int i=0; i<ld_preload.size; ++i)
                printf_log_prefix(0, LOG_INFO, "%s ", ld_preload.paths[i]);
            printf_log_prefix(0, LOG_INFO, "\n");
        }
    }
    // print PATH and LD_LIB used
    PrintCollection(&my_context->box64_ld_lib, "Library search path");
    PrintCollection(&my_context->box64_path, "Binary search path");
    // lets build argc/argv stuff
    printf_log(LOG_INFO, "Looking for %s\n", prog);
    if(strchr(prog, '/'))
        my_context->argv[0] = box_strdup(prog);
    else
        my_context->argv[0] = ResolveFileSoft(prog, &my_context->box64_path);
    //
    GatherEnv(&my_context->envv, environ?environ:env, my_context->argv[0]);
    if (BOX64ENV(dump) || BOX64ENV(log)<=LOG_DEBUG) {
        for (int i=0; i<my_context->envc; ++i)
            printf_dump(LOG_DEBUG, " Env[%02d]: %s\n", i, my_context->envv[i]);
    }
    // check if box86 is present
    {
        my_context->box86path = box_strdup(my_context->box64path);
        #ifndef BOX32
        if(strstr(my_context->box86path, "box64")) {
            char* p = strrchr(my_context->box86path, '6');  // get the 6 of box64
            p[0] = '8'; p[1] = '6'; // change 64 to 86
        } else {
            box_free(my_context->box86path);
            my_context->box86path = ResolveFileSoft("box86", &my_context->box64_path);
        }
        if(my_context->box86path && !FileExist(my_context->box86path, IS_FILE)) {
            box_free(my_context->box86path);
            my_context->box86path = NULL;
        }
        #endif
    }
    box64_guest_name = strrchr(prog, '/');
    if (!box64_guest_name)
        box64_guest_name = prog;
    else
        ++box64_guest_name;
    if(box64_wine) {
        #ifdef ANDROID
            AddPath("libdl.so", &ld_preload, 0);
        #else
            AddPath("libdl.so.2", &ld_preload, 0);
        #endif
    }
    // special case for zoom
    if (strstr(box64_guest_name, "zoom") == box64_guest_name) {
        printf_log(LOG_INFO, "Zoom detected, Trying to use system libturbojpeg if possible\n");
        box64_zoom = 1;
    }
    // special case for bash
    if (!strcmp(box64_guest_name, "bash") || !strcmp(box64_guest_name, "box64-bash")) {
        printf_log(LOG_INFO, "Bash detected, disabling banner\n");
        if (!BOX64ENV(nobanner)) {
            setenv("BOX86_NOBANNER", "1", 0);
            setenv("BOX64_NOBANNER", "1", 0);
        }
        if (!bashpath) {
            bashpath = (char*)prog;
            setenv("BOX64_BASH", prog, 1);
        }
    }
    if(!bashpath)
        bashpath = ResolveFile("box64-bash", &my_context->box64_path);
    if(bashpath)
        my_context->bashpath = box_strdup(bashpath);

    ApplyEnvFileEntry(box64_guest_name);
    if (box64_wine && box64_wine_guest_name) {
        ApplyEnvFileEntry(box64_wine_guest_name);
        box64_wine_guest_name = NULL;
    }
    openFTrace(0);
    setupZydis(my_context);
    PrintEnvVariables(&box64env, LOG_INFO);

    for(int i=1; i<my_context->argc; ++i) {
        my_context->argv[i] = box_strdup(argv[i+nextarg]);
        printf_log(LOG_INFO, "argv[%i]=\"%s\"\n", i, my_context->argv[i]);
    }
    if(BOX64ENV(nosandbox))
    {
        add_argv("--no-sandbox");
    }
    if(BOX64ENV(inprocessgpu))
    {
        add_argv("--in-process-gpu");
    }
    if(BOX64ENV(cefdisablegpu))
    {
        add_argv("-cef-disable-gpu");
    }
    if(BOX64ENV(cefdisablegpucompositor))
    {
        add_argv("-cef-disable-gpu-compositor");
    }
    // add new args only if there is no args already
    if(BOX64ENV(args)) {
        char tmp[256];
        char* p = BOX64ENV(args);
        int state = 0;
        char* p2 = p;
        if(my_context->argc==1 || (my_context->argc==2 && box64_wine))
            while(state>=0) {
                switch(*p2) {
                    case 0: // end of flux
                        if(state && (p2!=p)) add_argv(p);
                        state = -1;
                        break;
                    case '"': // start/end of quotes
                        if(state<2) {if(!state) p=p2; state=2;} else state=1;
                        break;
                    case ' ':
                        if(state==1) {strncpy(tmp, p, p2-p); tmp[p2-p]='\0'; add_argv(tmp); state=0;}
                        break;
                    default:
                        if(state==0) {state=1; p=p2;}
                        break;
                }
                ++p2;
            }
    }
    if(BOX64ENV(insert_args)) {
        char tmp[256];
        char* p = BOX64ENV(insert_args);
        int state = 0;
        char* p2 = p;
        while(state>=0) {
            switch(*p2) {
                case 0: // end of flux
                    if(state && (p2!=p)) add_argv(p);
                    state = -1;
                    break;
                case '"': // start/end of quotes
                    if(state<2) {if(!state) p=p2; state=2;} else state=1;
                    break;
                case ' ':
                    if(state==1) {strncpy(tmp, p, p2-p); tmp[p2-p]='\0'; add_argv(tmp); state=0;}
                    break;
                default:
                    if(state==0) {state=1; p=p2;}
                    break;
            }
            ++p2;
        }
    }
    // check if file exist
    if(!my_context->argv[0] || !FileExist(my_context->argv[0], IS_FILE)) {
        printf_log(LOG_NONE, "Error: File is not found. (%s)\n", my_context->argv[0]);
        free_contextargv();
        FreeBox64Context(&my_context);
        FreeCollection(&ld_preload);
        return -1;
    }
    if(!FileExist(my_context->argv[0], IS_FILE|IS_EXECUTABLE)) {
        printf_log(LOG_NONE, "Error: %s is not an executable file.\n", my_context->argv[0]);
        free_contextargv();
        FreeBox64Context(&my_context);
        FreeCollection(&ld_preload);
        return -1;
    }
    if(!(my_context->fullpath = box_realpath(my_context->argv[0], NULL)))
        my_context->fullpath = box_strdup(my_context->argv[0]);
    if(getenv("BOX64_ARG0"))
        my_context->argv[0] = box_strdup(getenv("BOX64_ARG0"));
    FILE *f = fopen(my_context->fullpath, "rb");
    if(!f) {
        printf_log(LOG_NONE, "Error: Cannot open %s\n", my_context->fullpath);
        free_contextargv();
        FreeBox64Context(&my_context);
        FreeCollection(&ld_preload);
        return -1;
    }
    #ifdef BOX32
    box64_is32bits = FileIsX86ELF(my_context->fullpath);
    if(box64_is32bits) {
        printf_log(LOG_INFO, "Using Box32 to load 32bits elf\n");
        loadProtectionFromMap();
        reserveHighMem();
        init_pthread_helper_32();
    }
    #endif
    LoadLDPath(my_context);
    elfheader_t *elf_header = LoadAndCheckElfHeader(f, my_context->fullpath, 1);
    if(!elf_header) {
        int x86 = my_context->box86path?FileIsX86ELF(my_context->fullpath):0;
        int script = my_context->bashpath?FileIsShell(my_context->fullpath):0;
        printf_log(LOG_NONE, "Error: Reading elf header of %s, Try to launch %s instead\n", my_context->fullpath, x86?"using box86":(script?"using bash":"natively"));
        fclose(f);
        FreeCollection(&ld_preload);
        int ret;
        if(x86) {
            // duplicate the array and insert 1st arg as box86
            const char** newargv = (const char**)box_calloc(my_context->argc+2, sizeof(char*));
            newargv[0] = my_context->box86path;
            for(int i=0; i<my_context->argc; ++i)
                newargv[i+1] = my_context->argv[i];
            ret = execvp(newargv[0], (char * const*)newargv);
        } else if (script) {
            // duplicate the array and insert 1st arg as box64, 2nd is bash
            const char** newargv = (const char**)box_calloc(my_context->argc+3, sizeof(char*));
            newargv[0] = my_context->box64path;
            newargv[1] = my_context->bashpath;
            for(int i=0; i<my_context->argc; ++i)
                newargv[i+2] = my_context->argv[i];
            ret = execvp(newargv[0], (char * const*)newargv);
        } else {
            const char** newargv = (const char**)box_calloc(my_context->argc+1, sizeof(char*));
            for(int i=0; i<my_context->argc; ++i)
                newargv[i] = my_context->argv[i];
            ret = execvp(newargv[0], (char * const*)newargv);
        }
        free_contextargv();
        FreeBox64Context(&my_context);
        return ret;
    }
    AddElfHeader(my_context, elf_header);
    *elfheader = elf_header;

    if(CalcLoadAddr(elf_header)) {
        printf_log(LOG_NONE, "Error: Reading elf header of %s\n", my_context->fullpath);
        FreeElfHeader(&elf_header);
        free_contextargv();
        FreeBox64Context(&my_context);
        FreeCollection(&ld_preload);
        return -1;
    }
    // allocate memory and load elf
    if(AllocLoadElfMemory(my_context, elf_header, 1)) {
        printf_log(LOG_NONE, "Error: Loading elf %s\n", my_context->fullpath);
        FreeElfHeader(&elf_header);
        free_contextargv();
        FreeBox64Context(&my_context);
        FreeCollection(&ld_preload);
        return -1;
    }
    if (!strcmp(box64_guest_name, "heroic")) {
        // check if heroic needs patching (for the 2.15.1 version)
        uint8_t* address = GetBaseAddress(elf_header);
        if(address[0x422f6e1]==0x72 && address[0x422f6e2]==0x44 && address[0x422f6e0]==0xF8 && address[0x422f727]==0xcc) {
            printf_log(LOG_INFO, "Patched heroic!\n");
            uintptr_t page = ((uintptr_t)&address[0x422f6e1])&~(box64_pagesize-1);
            int prot = getProtection(page);
            mprotect((void*)page, box64_pagesize, PROT_READ|PROT_WRITE|PROT_EXEC);
            address[0x422f6e1]=0x90; address[0x422f6e2]=0x90;
            mprotect((void*)page, box64_pagesize, prot);
        }
    }
    if(ElfCheckIfUseTCMallocMinimal(elf_header)) {
        if(!box64_tcmalloc_minimal) {
            // need to reload with tcmalloc_minimal as a LD_PRELOAD!
            printf_log(LOG_INFO, "tcmalloc_minimal.so.4 used. Reloading box64 with the lib preladed\n");
            // need to get a new envv variable. so first count it and check if LD_PRELOAD is there
            int preload=(getenv("LD_PRELOAD"))?1:0;
            int nenv = 0;
            while(env[nenv]) nenv++;
            // alloc + "LD_PRELOAD" if needd + last NULL ending
            char** newenv = (char**)box_calloc(nenv+1+((preload)?0:1), sizeof(char*));
            // copy strings
            for (int i=0; i<nenv; ++i)
                newenv[i] = box_strdup(env[i]);
            // add ld_preload
            if(preload) {
                // find the line
                int l = 0;
                while(l<nenv) {
                    if(strstr(newenv[l], "LD_PRELOAD=")==newenv[l]) {
                        // found it!
                        char *old = newenv[l];
                        newenv[l] = (char*)box_calloc(strlen(old)+strlen("libtcmalloc_minimal.so.4:")+1, sizeof(char));
                        strcpy(newenv[l], "LD_PRELOAD=libtcmalloc_minimal.so.4:");
                        strcat(newenv[l], old + strlen("LD_PRELOAD="));
                        box_free(old);
                        // done, end loop
                        l = nenv;
                    } else ++l;
                }
            } else {
                //move last one
                newenv[nenv] = box_strdup(newenv[nenv-1]);
                box_free(newenv[nenv-1]);
                newenv[nenv-1] = box_strdup("LD_PRELOAD=libtcmalloc_minimal.so.4");
            }
            // duplicate argv too
            char** newargv = box_calloc(argc+1, sizeof(char*));
            int narg = 0;
            while(argv[narg]) {newargv[narg] = box_strdup(argv[narg]); narg++;}
            // launch with new env...
            if(execve(newargv[0], newargv, newenv)<0)
                printf_log(LOG_NONE, "Failed to relaunch. Error is %d/%s\n", errno, strerror(errno));
        } else {
            printf_log(LOG_INFO, "Using tcmalloc_minimal.so.4, and it's in the LD_PRELOAD command\n");
        }
    }
#if defined(RPI) || defined(RK3399) || defined(RK3326)
    // before launching emulation, let's check if this is a mojosetup from GOG
    if (((strstr(prog, "bin/linux/x86_64/mojosetup") && getenv("MOJOSETUP_BASE")) || strstr(prog, ".mojosetup/mojosetup"))
       && getenv("GTK2_RC_FILES")) {
        sanitize_mojosetup_gtk_background();
    }
#endif
    // change process name
    {
        char* p = strrchr(my_context->fullpath, '/');
        if(p)
            ++p;
        else
            p = my_context->fullpath;
        if(prctl(PR_SET_NAME, p)==-1)
            printf_log(LOG_NONE, "Error setting process name (%s)\n", strerror(errno));
        else
            printf_log(LOG_INFO, "Rename process to \"%s\"\n", p);
        if (strcmp(box64_guest_name, p)) {
            ApplyEnvFileEntry(p);
        }
        // and now all change the argv (so libs libs mesa find the correct program names)
        char* endp = (char*)argv[argc-1];
        while(*endp)
            ++endp;    // find last argv[] address
        uintptr_t diff = prog - argv[0]; // this is the difference we need to compensate
        for(p=(char*)prog; p<=endp; ++p)
            *(p - diff) = *p;  // copy all element at argv[nextarg] to argv[0]
        memset(endp - diff, 0, diff); // fill reminder with NULL
        for(int i=nextarg; i<argc; ++i)
            argv[i] -= diff;    // adjust strings
        my_context->orig_argc = argc;
        my_context->orig_argv = (char**)argv;
    }
    box64_isglibc234 = GetNeededVersionForLib(elf_header, "libc.so.6", "GLIBC_2.34");
    if(box64_isglibc234)
        printf_log(LOG_DEBUG, "Program linked with GLIBC 2.34+\n");
    // get and alloc stack size and align
    if(CalcStackSize(my_context)) {
        printf_log(LOG_NONE, "Error: Allocating stack\n");
        free_contextargv();
        FreeBox64Context(&my_context);
        FreeCollection(&ld_preload);
        return -1;
    }
    // init x86_64 emu
    x64emu_t *emu = NewX64Emu(my_context, my_context->ep, (uintptr_t)my_context->stack, my_context->stacksz, 0);
    // stack setup is much more complicated then just that!
    SetupInitialStack(emu); // starting here, the argv[] don't need free anymore
    SetupX64Emu(emu, NULL);
    if(box64_is32bits) {
        SetEAX(emu, my_context->argc);
        SetEBX(emu, my_context->argv32);
    } else {
        SetRSI(emu, my_context->argc);
        SetRDX(emu, (uint64_t)my_context->argv);
        SetRCX(emu, (uint64_t)my_context->envv);
        SetRBP(emu, 0); // Frame pointer so to "No more frame pointer"
    }

    // child fork to handle traces
    //pthread_atfork(my_prepare_fork, my_parent_fork, my_child_fork);

    thread_set_emu(emu);

    // export symbols
    AddSymbols(my_context->maplib, elf_header);
    if(wine_preloaded) {
        uintptr_t wineinfo = 0;
        int ver = -1, veropt = 0;
        const char* vername = NULL;
        if(!ElfGetGlobalSymbolStartEnd(elf_header, &wineinfo, NULL, "wine_main_preload_info", &ver, &vername, 1, &veropt))
            if(!ElfGetWeakSymbolStartEnd(elf_header, &wineinfo, NULL, "wine_main_preload_info", &ver, &vername, 1, &veropt))
                ElfGetLocalSymbolStartEnd(elf_header, &wineinfo, NULL, "wine_main_preload_info", &ver, &vername, 1, &veropt);
        if(!wineinfo) {printf_log(LOG_DEBUG, "Warning, Symbol wine_main_preload_info not found\n");}
        else {
            *(void**)wineinfo = get_wine_prereserve();
            printf_log(LOG_DEBUG, "WINE wine_main_preload_info found and updated %p -> %p\n", get_wine_prereserve(), *(void**)wineinfo);
        }
        #ifdef DYNAREC
        dynarec_wine_prereserve();
        #endif
    }
    AddMainElfToLinkmap(elf_header);    //TODO: LinkMap seems incorect
    // pre-load lib if needed
    if(ld_preload.size) {
        my_context->preload = new_neededlib(0);
        for(int i=0; i<ld_preload.size; ++i) {
            needed_libs_t* tmp = new_neededlib(1);
            tmp->names[0] = ld_preload.paths[i];
            if(AddNeededLib(my_context->maplib, 0, 0, 0, tmp, elf_header, my_context, emu)) {
                printf_log(LOG_INFO, "Warning, cannot pre-load %s\n", tmp->names[0]);
                RemoveNeededLib(my_context->maplib, 0, tmp, my_context, emu);
            } else {
                for(int j=0; j<tmp->size; ++j)
                    add1lib_neededlib(my_context->preload, tmp->libs[j], tmp->names[j]);
            }
            free_neededlib(tmp);
        }
    }
    FreeCollection(&ld_preload);
    // Call librarian to load all dependant elf
    if(LoadNeededLibs(elf_header, my_context->maplib, 0, 0, 0, my_context, emu)) {
        printf_log(LOG_NONE, "Error: Loading needed libs in elf %s\n", my_context->argv[0]);
        FreeBox64Context(&my_context);
        return -1;
    }
    // reloc...
    printf_log(LOG_DEBUG, "And now export symbols / relocation for %s...\n", ElfName(elf_header));
    if(RelocateElf(my_context->maplib, NULL, 0, 0, elf_header)) {
        printf_log(LOG_NONE, "Error: Relocating symbols in elf %s\n", my_context->argv[0]);
        FreeBox64Context(&my_context);
        return -1;
    }
    // and handle PLT
    RelocateElfPlt(my_context->maplib, NULL, 0, 0, elf_header);
    // deferred init
    setupTraceInit();
    RunDeferredElfInit(emu);
    // update TLS of main elf
    RefreshElfTLS(elf_header);
    // do some special case check, _IO_2_1_stderr_ and friends, that are setup by libc, but it's already done here, so need to do a copy
    ResetSpecialCaseMainElf(elf_header);
    // init...
    setupTrace();

    *emulator = emu;
    return 0;
}

RelocateElfRELA (maplib=maplib@entry=0x36f68fa0, local_maplib=local_maplib@entry=0x0, bindnow=bindnow@entry=1, deepbind=deepbind@entry=0, head=head@entry=0x36f71800, cnt=cnt@entry=9,
rela=<optimized out>, need_resolv=need_resolv@entry=0x0) at /root/box64/src/elfs/elfloader.c:634
634 if(!offs && !end && local_maplib && !deepbind)
(gdb) n
638 sym_elf = FindElfSymbol(my_context, elfsym);
(gdb) n
639 if(elfsym && (ELF64_ST_TYPE(elfsym->st_info)==STT_TLS))
(gdb) n
645 switch(t) {
(gdb) n
687 if(GetSymbolStartEnd(my_context->globdata, symname, &globoffs, &globend, version, vername, 1, veropt)) {
(gdb) n
695 if (!offs) {
(gdb) n
699 printf_dump(LOG_NEVER, "Apply %s R_X86_64_GLOB_DAT @%p (%p -> %p) on sym=%s (%sver=%d/%s, elf=%s)\n", BindSym(bind), p, (void*)(p?(*p):0), (void*)(offs + rela[i].r_addend), symname, veropt?"opt":"", version, vername?vername:"(none)", sym_elf?sym_elf->name:"(native)");
(gdb) n
700 *p = offs + rela[i].r_addend;
(gdb) n
701 if(sym_elf && sym_elf!=last_elf && sym_elf!=head) last_elf = checkElfLib(head, sym_elf->lib);
(gdb) n
581 for (int i=0; i<cnt; ++i) {
(gdb) n
582 int t = ELF64_R_TYPE(rela[i].r_info);
(gdb) n
584 int bind = ELF64_ST_BIND(sym->st_info);
(gdb) n
586 const char* symname = SymName64(head, sym);
(gdb) n
593 int version = head->VerSym?((Elf64_Half*)((uintptr_t)head->VerSym+head->delta))[ELF64_R_SYM(rela[i].r_info)]:-1;
(gdb) n
594 if(version!=-1) version &=0x7fff;
(gdb) n
595 const char* vername = GetSymbolVersion(head, version);
(gdb) n
596 Elf64_Half flags = GetSymbolVersionFlag(head, version);
(gdb) n
600 if(vis==STV_PROTECTED) {
(gdb) n
608 if(bind==STB_GNU_UNIQUE) {
(gdb) n
612 } else if(bind==STB_LOCAL) {
(gdb)
630 if(!offs && !end && local_maplib && deepbind)
(gdb) n
633 GetGlobalSymbolStartEnd(maplib, symname, &offs, &end, head, version, vername, veropt, (void**)&elfsym);
(gdb) n
634 if(!offs && !end && local_maplib && !deepbind)
(gdb) n
638 sym_elf = FindElfSymbol(my_context, elfsym);
(gdb) n
639 if(elfsym && (ELF64_ST_TYPE(elfsym->st_info)==STT_TLS))
(gdb) n
645 switch(t) {
(gdb) n
687 if(GetSymbolStartEnd(my_context->globdata, symname, &globoffs, &globend, version, vername, 1, veropt)) {
(gdb) n
695 if (!offs) {
(gdb) n
699 printf_dump(LOG_NEVER, "Apply %s R_X86_64_GLOB_DAT @%p (%p -> %p) on sym=%s (%sver=%d/%s, elf=%s)\n", BindSym(bind), p, (void*)(p?(*p):0), (void*)(offs + rela[i].r_addend), symname, veropt?"opt":"", version, vername?vername:"(none)", sym_elf?sym_elf->name:"(native)");
(gdb) n
700 *p = offs + rela[i].r_addend;
(gdb) n
701 if(sym_elf && sym_elf!=last_elf && sym_elf!=head) last_elf = checkElfLib(head, sym_elf->lib);
(gdb) n
581 for (int i=0; i<cnt; ++i) {
(gdb) n
582 int t = ELF64_R_TYPE(rela[i].r_info);
(gdb)
584 int bind = ELF64_ST_BIND(sym->st_info);
(gdb) n
586 const char* symname = SymName64(head, sym);
(gdb) n
593 int version = head->VerSym?((Elf64_Half*)((uintptr_t)head->VerSym+head->delta))[ELF64_R_SYM(rela[i].r_info)]:-1;
(gdb) n
594 if(version!=-1) version &=0x7fff;
(gdb) n
595 const char* vername = GetSymbolVersion(head, version);
(gdb) n
596 Elf64_Half flags = GetSymbolVersionFlag(head, version);
(gdb) n
600 if(vis==STV_PROTECTED) {
(gdb) n
608 if(bind==STB_GNU_UNIQUE) {
(gdb)
612 } else if(bind==STB_LOCAL) {
(gdb) n
630 if(!offs && !end && local_maplib && deepbind)
(gdb) n
633 GetGlobalSymbolStartEnd(maplib, symname, &offs, &end, head, version, vername, veropt, (void**)&elfsym);
(gdb) n
634 if(!offs && !end && local_maplib && !deepbind)
(gdb) n
638 sym_elf = FindElfSymbol(my_context, elfsym);
(gdb) n
639 if(elfsym && (ELF64_ST_TYPE(elfsym->st_info)==STT_TLS))
(gdb) n
645 switch(t) {
(gdb) n
687 if(GetSymbolStartEnd(my_context->globdata, symname, &globoffs, &globend, version, vername, 1, veropt)) {
(gdb)
695 if (!offs) {
(gdb) n
696 if(strcmp(symname, "__gmon_start__") && strcmp(symname, "data_start") && strcmp(symname, "__data_start") && strcmp(symname, "collector_func_load"))
(gdb) n
581 for (int i=0; i<cnt; ++i) {
(gdb) n
582 int t = ELF64_R_TYPE(rela[i].r_info);
(gdb) n
584 int bind = ELF64_ST_BIND(sym->st_info);
(gdb)
586 const char* symname = SymName64(head, sym);
(gdb) n
593 int version = head->VerSym?((Elf64_Half*)((uintptr_t)head->VerSym+head->delta))[ELF64_R_SYM(rela[i].r_info)]:-1;
(gdb) n
594 if(version!=-1) version &=0x7fff;
(gdb) n
595 const char* vername = GetSymbolVersion(head, version);
(gdb) n
596 Elf64_Half flags = GetSymbolVersionFlag(head, version);
(gdb)
600 if(vis==STV_PROTECTED) {
(gdb) n
608 if(bind==STB_GNU_UNIQUE) {
(gdb) n
612 } else if(bind==STB_LOCAL) {
(gdb) n
630 if(!offs && !end && local_maplib && deepbind)
(gdb) n
633 GetGlobalSymbolStartEnd(maplib, symname, &offs, &end, head, version, vername, veropt, (void**)&elfsym);
(gdb)
634 if(!offs && !end && local_maplib && !deepbind)
(gdb) n
638 sym_elf = FindElfSymbol(my_context, elfsym);
(gdb) n
639 if(elfsym && (ELF64_ST_TYPE(elfsym->st_info)==STT_TLS))
(gdb) n
645 switch(t) {
(gdb)
687 if(GetSymbolStartEnd(my_context->globdata, symname, &globoffs, &globend, version, vername, 1, veropt)) {
(gdb) n
695 if (!offs) {
(gdb) n
699 printf_dump(LOG_NEVER, "Apply %s R_X86_64_GLOB_DAT @%p (%p -> %p) on sym=%s (%sver=%d/%s, elf=%s)\n", BindSym(bind), p, (void*)(p?(*p):0), (void*)(offs + rela[i].r_addend), symname, veropt?"opt":"", version, vername?vername:"(none)", sym_elf?sym_elf->name:"(native)");
(gdb)
700 *p = offs + rela[i].r_addend;
(gdb) n
701 if(sym_elf && sym_elf!=last_elf && sym_elf!=head) last_elf = checkElfLib(head, sym_elf->lib);
(gdb) n
581 for (int i=0; i<cnt; ++i) {
(gdb) n
582 int t = ELF64_R_TYPE(rela[i].r_info);
(gdb)
584 int bind = ELF64_ST_BIND(sym->st_info);
(gdb) n
586 const char* symname = SymName64(head, sym);
(gdb) n
593 int version = head->VerSym?((Elf64_Half*)((uintptr_t)head->VerSym+head->delta))[ELF64_R_SYM(rela[i].r_info)]:-1;
(gdb) n
594 if(version!=-1) version &=0x7fff;
(gdb) n
595 const char* vername = GetSymbolVersion(head, version);
(gdb)
596 Elf64_Half flags = GetSymbolVersionFlag(head, version);
(gdb) n
600 if(vis==STV_PROTECTED) {
(gdb) n
608 if(bind==STB_GNU_UNIQUE) {
(gdb)
612 } else if(bind==STB_LOCAL) {
(gdb) n
630 if(!offs && !end && local_maplib && deepbind)
(gdb) n
633 GetGlobalSymbolStartEnd(maplib, symname, &offs, &end, head, version, vername, veropt, (void**)&elfsym);
(gdb)
634 if(!offs && !end && local_maplib && !deepbind)
(gdb) n
638 sym_elf = FindElfSymbol(my_context, elfsym);
(gdb) n
639 if(elfsym && (ELF64_ST_TYPE(elfsym->st_info)==STT_TLS))
(gdb) n
645 switch(t) {
(gdb)
687 if(GetSymbolStartEnd(my_context->globdata, symname, &globoffs, &globend, version, vername, 1, veropt)) {
(gdb) nn
Undefined command: "nn". Try "help".
(gdb) n
695 if (!offs) {
(gdb) n
699 printf_dump(LOG_NEVER, "Apply %s R_X86_64_GLOB_DAT @%p (%p -> %p) on sym=%s (%sver=%d/%s, elf=%s)\n", BindSym(bind), p, (void*)(p?(*p):0), (void*)(offs + rela[i].r_addend), symname, veropt?"opt":"", version, vername?vername:"(none)", sym_elf?sym_elf->name:"(native)");
(gdb) n
700 *p = offs + rela[i].r_addend;
(gdb) n
701 if(sym_elf && sym_elf!=last_elf && sym_elf!=head) last_elf = checkElfLib(head, sym_elf->lib);
(gdb) n
581 for (int i=0; i<cnt; ++i) {
(gdb) n
582 int t = ELF64_R_TYPE(rela[i].r_info);
(gdb) n
584 int bind = ELF64_ST_BIND(sym->st_info);
(gdb) n
586 const char* symname = SymName64(head, sym);
(gdb) n
593 int version = head->VerSym?((Elf64_Half*)((uintptr_t)head->VerSym+head->delta))[ELF64_R_SYM(rela[i].r_info)]:-1;
(gdb) n
594 if(version!=-1) version &=0x7fff;
(gdb) n
595 const char* vername = GetSymbolVersion(head, version);
(gdb) n
596 Elf64_Half flags = GetSymbolVersionFlag(head, version);
(gdb) n
600 if(vis==STV_PROTECTED) {
(gdb) n
608 if(bind==STB_GNU_UNIQUE) {
(gdb) n
612 } else if(bind==STB_LOCAL) {
(gdb) n
630 if(!offs && !end && local_maplib && deepbind)
(gdb) n
633 GetGlobalSymbolStartEnd(maplib, symname, &offs, &end, head, version, vername, veropt, (void**)&elfsym);
(gdb) n
634 if(!offs && !end && local_maplib && !deepbind)
(gdb) n
638 sym_elf = FindElfSymbol(my_context, elfsym);
(gdb) n
639 if(elfsym && (ELF64_ST_TYPE(elfsym->st_info)==STT_TLS))
(gdb) n
645 switch(t) {
(gdb) n
665 globoffs = offs;
(gdb) n
668 if(!offs && local_maplib && deepbind)
(gdb) n
671 GetNoSelfSymbolStartEnd(maplib, symname, &offs, &end, head, size, version, vername, veropt, NULL);
(gdb) n
672 if(!offs && local_maplib && !deepbind)
(gdb) nn
Undefined command: "nn". Try "help".
(gdb) n
677 printf_dump(LOG_NEVER, "Apply R_X86_64_COPY @%p with sym=%s (%sver=%d/%s), @%p+0x%lx size=%ld\n", p, symname, veropt?"opt":"", version, vername?vername:"(none)", (void*)offs, rela[i].r_addend, sym->st_size);
(gdb) n
678 if(p!=(void*)(offs+rela[i].r_addend))
(gdb) n
679 memmove(p, (void*)(offs+rela[i].r_addend), sym->st_size);
(gdb) n
680 sym_elf = FindElfAddress(my_context, offs);
(gdb) n
681 if(sym_elf && sym_elf!=last_elf && sym_elf!=head) last_elf = checkElfLib(head, sym_elf->lib);
(gdb) n
581 for (int i=0; i<cnt; ++i) {
(gdb) n
ninitialize (argc=<optimized out>, argv=<optimized out>, env=<optimized out>, emulator=emulator@entry=0x3ffffff360, elfheader=elfheader@entry=0x3ffffff368, exec=exec@entry=1)
at /root/box64/src/core.c:1528
1528 RelocateElfPlt(my_context->maplib, NULL, 0, 0, elf_header);
(gdb) n
1531 RunDeferredElfInit(emu);
(gdb) n
1533 RefreshElfTLS(elf_header);
(gdb) n
1535 ResetSpecialCaseMainElf(elf_header);
(gdb)
1539 *emulator = emu;
(gdb) n
1540 return 0;
(gdb) n
main (argc=<optimized out>, argv=<optimized out>, env=<optimized out>) at /root/box64/src/main.c:11
11 return emulate(emu, elf_header);
(gdb) n

Program received signal SIGSEGV, Segmentation fault.
0x0000003ff7236060 in ?? ()

AddBridge



### src/dynarec/dynarec_native_pass.c

Below is a structured walkthrough of native_pass, the core “one‐pass” routine in Box64’s dynarec that scans x86(-64) instructions, emits RISC-V code, and decides where to stop or extend the translated block.