From f69664f8c0e58702c54ea3c8d1857c66407696e6 Mon Sep 17 00:00:00 2001 From: rajdakin Date: Thu, 5 Sep 2024 19:08:34 +0200 Subject: [PATCH] [WRAPPED] Removed GOS, renamed GODW into GOWD --- rebuild_wrappers.py | 2 +- src/wrapped/wrappedandroidsupport_private.h | 2 +- src/wrapped/wrappediconv_private.h | 2 +- src/wrapped/wrappedlib_init.h | 33 +------ src/wrapped/wrappedlibc_private.h | 26 ++--- src/wrapped/wrappedlibm_private.h | 104 ++++++++++---------- src/wrapped/wrappedsdl2.c | 2 - src/wrapped/wrappedtermuxexec_private.h | 2 +- 8 files changed, 72 insertions(+), 101 deletions(-) diff --git a/rebuild_wrappers.py b/rebuild_wrappers.py index ab35401359..c91332d286 100755 --- a/rebuild_wrappers.py +++ b/rebuild_wrappers.py @@ -536,7 +536,7 @@ def add_symbol_name(funname: Union[str, None], funsname: Dict[ClausesStr, List[s gbl[str(dependants)].append(FunctionType(ln)) if any(c in origLine for c in depends_on_ld): - if (gotype != "GOM") and (gotype != "GOWM") and (gotype != "GOD") and (gotype != "GODW"): + if (gotype != "GOM") and (gotype != "GOWM") and (gotype != "GOD") and (gotype != "GOWD"): print("\033[91mError:\033[m type depends on HAVE_LD80BITS but the GO type doesn't support that ({0}:{1})" .format(filename, line[:-1])) halt_required = True diff --git a/src/wrapped/wrappedandroidsupport_private.h b/src/wrapped/wrappedandroidsupport_private.h index a0ed8e1f1f..4c8e334bfb 100644 --- a/src/wrapped/wrappedandroidsupport_private.h +++ b/src/wrapped/wrappedandroidsupport_private.h @@ -1,4 +1,4 @@ -#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA) && defined(GOS)) +#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA)) #error Meh... #endif diff --git a/src/wrapped/wrappediconv_private.h b/src/wrapped/wrappediconv_private.h index a0ed8e1f1f..4c8e334bfb 100644 --- a/src/wrapped/wrappediconv_private.h +++ b/src/wrapped/wrappediconv_private.h @@ -1,4 +1,4 @@ -#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA) && defined(GOS)) +#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA)) #error Meh... #endif diff --git a/src/wrapped/wrappedlib_init.h b/src/wrapped/wrappedlib_init.h index 18d5b9f074..c861228779 100644 --- a/src/wrapped/wrappedlib_init.h +++ b/src/wrapped/wrappedlib_init.h @@ -28,9 +28,9 @@ #endif // regular symbol mapped to itself or another one (depending on HAVE_LD80BITS), but weak #ifdef HAVE_LD80BITS -#define GODW(N, W, O) GOW(N, W) +#define GOWD(N, W, O) GOW(N, W) #else -#define GODW(N, W, O) GOW2(N, W, O) +#define GOWD(N, W, O) GOW2(N, W, O) #endif // regular symbol mapped to itself @@ -41,8 +41,6 @@ #define GOM(N, W) // symbol mapped to my_symbol, but weak #define GOWM(N, W) -// regular symbol mapped to itself, that returns a structure -#define GOS(N, W) // symbol mapped to another one #define GO2(N, W, O) // symbol mapped to another one, but weak @@ -87,21 +85,10 @@ static const map_onesymbol_t MAPNAME(mysymbolmap)[] = { }; #undef GOM #undef GOWM -#undef GOS #define GOM(N, W) #define GOWM(N, W) -#ifdef STATICBUILD -#define GOS(N, W) {#N, W, 0, &my_##N}, -#else -#define GOS(N, W) {#N, W, 0}, -#endif -static const map_onesymbol_t MAPNAME(stsymbolmap)[] = { - #include PRIVATE(LIBNAME) -}; -#undef GOS #undef GO2 #undef GOW2 -#define GOS(N, W) #ifdef STATICBUILD #define GO2(N, W, O) {#N, W, 0, #O, &O}, #define GOW2(N, W, O) {#N, W, 1, #O, &O}, @@ -150,12 +137,11 @@ static const map_onedata_t MAPNAME(mydatamap)[] = { #undef GO #undef GOW #undef GOD -#undef GODW +#undef GOWD #undef GOM #undef GOWM #undef GO2 #undef GOW2 -#undef GOS #undef DATA #undef DATAV #undef DATAB @@ -255,19 +241,6 @@ int FUNC(_init)(library_t* lib, box64context_t* box64) DOIT(symbolmap) DOIT(mysymbolmap) #undef DOIT - cnt = sizeof(MAPNAME(stsymbolmap))/sizeof(map_onesymbol_t); - for (int i=0; iw.stsymbolmap, MAPNAME(stsymbolmap)[i].name, &ret); - kh_value(lib->w.stsymbolmap, k).w = MAPNAME(stsymbolmap)[i].w; - #ifdef STATICBUILD - kh_value(lib->w.stsymbolmap, k).resolved = 1; - kh_value(lib->w.stsymbolmap, k).addr = (uintptr_t)MAPNAME(stsymbolmap)[i].addr; - #else - kh_value(lib->w.stsymbolmap, k).resolved = 0; - #endif - if(strchr(MAPNAME(stsymbolmap)[i].name, '@')) - AddDictionnary(box64->versym, MAPNAME(stsymbolmap)[i].name); - } cnt = sizeof(MAPNAME(symbol2map))/sizeof(map_onesymbol2_t); for (int i=0; iw.symbol2map, MAPNAME(symbol2map)[i].name, &ret); diff --git a/src/wrapped/wrappedlibc_private.h b/src/wrapped/wrappedlibc_private.h index 77ac3c48f1..ceaef297d4 100644 --- a/src/wrapped/wrappedlibc_private.h +++ b/src/wrapped/wrappedlibc_private.h @@ -1,4 +1,4 @@ -#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA) && defined(GOS)) +#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA)) #error Meh... #endif @@ -182,7 +182,7 @@ GO(copy_file_range, lFipipLu) //GO(__copy_grp, GOW(copysign, dFdd) GOW(copysignf, fFff) -GODW(copysignl, DFDD, copysign) +GOWD(copysignl, DFDD, copysign) GOW(creat, iFpu) GOW(creat64, iFpu) //GO(create_module, @@ -394,7 +394,7 @@ GOW(finite, iFd) GO(__finitef, iFf) GOW(finitef, iFf) GOD(__finitel, iFD, __finite) -GODW(finitel, iFD, finite) +GOWD(finitel, iFD, finite) GO(__flbf, iFp) GO(flistxattr, lFipL) GOW(flock, iFii) @@ -439,7 +439,7 @@ GO(freopen, pFppp) GO(freopen64, pFppp) GOW(frexp, dFdp) GOW(frexpf, fFfp) -GODW(frexpl, DFDp, frexp) +GOWD(frexpl, DFDp, frexp) GOM(fscanf, iFEppV) GO(fseek, iFpli) GO(fseeko, iFpIi) @@ -964,7 +964,7 @@ GOW(isinf, iFd) GO(__isinff, iFf) GOW(isinff, iFf) GOD(__isinfl, iFD, __isinf) -GODW(isinfl, iFD, isinf) +GOWD(isinfl, iFD, isinf) GO(islower, iFi) //GO(__islower_l, //GOW(islower_l, iFi!) @@ -973,7 +973,7 @@ GOW(isnan, iFd) GO(__isnanf, iFf) GOW(isnanf, iFf) GOD(__isnanl, iFD, __isnan) -GODW(isnanl, iFD, isnan) +GOWD(isnanl, iFD, isnan) GO2(__isoc23_fscanf, iFEppV, my___isoc99_fscanf) GO2(__isoc23_sscanf, iFEppV, my___isoc99_sscanf) GO2(__isoc23_strtol, lFppi, strtol) @@ -1081,7 +1081,7 @@ GO(lcong48, vFp) GOW(lcong48_r, iFpp) GOW(ldexp, dFdi) GOW(ldexpf, fFfi) -GODW(ldexpl, DFDi, ldexp) +GOWD(ldexpl, DFDi, ldexp) GO(ldiv, HFll) GOM(lfind, pFEpppLp) GO(lgetxattr, lFpppL) @@ -1257,7 +1257,7 @@ GOWM(mmap, pFEpLiiil) GOWM(mmap64, pFEpLiiil) GOW(modf, dFdp) GOW(modff, fFfp) -GODW(modfl, DFDp, modf) +GOWD(modfl, DFDp, modf) //GOW(modify_ldt, // Deprecated //GOW(moncontrol, //GO(__monstartup, @@ -1501,7 +1501,7 @@ GO(pwritev2, lFipili) GO(pwritev64, lFipil) GO(pwritev64v2, lFipili) GOD(qecvt, pFDipp, ecvt) -GODW(qecvt_r, iFDipppL, ecvt_r) +GOWD(qecvt_r, iFDipppL, ecvt_r) GOD(qfcvt, pFDipp, fcvt) GOD(qfcvt_r, iFDipppL, fcvt_r) GOD(qgcvt, pFDip, gcvt) @@ -1623,7 +1623,7 @@ GO(__sbrk, pFl) GO(sbrk, pFl) GOW(scalbn, dFdi) GOW(scalbnf, fFfi) -GODW(scalbnl, DFDi, scalbn) +GOWD(scalbnl, DFDi, scalbn) GOWM(scandir, iFEpppp) GOWM(scandir64, iFEpppp) GOWM(scandirat, iFipppp) @@ -1909,7 +1909,7 @@ GOW(strtof32x, dFpp) //GOW(strtof32x_l, dFpp!) GOW(strtof64, dFpp) //GOW(strtof64_l, dFpp!) -GODW(strtof64x, DFpp, strtof64) +GOWD(strtof64x, DFpp, strtof64) //GOW(strtof64x_l, DFpp!) GO(__strtof_internal, fFppi) GO(__strtof_l, fFppL) @@ -1925,7 +1925,7 @@ GO(strtol, lFppi) GOD(strtold, DFpp, strtod) GOD(__strtold_internal, DFppi, __strtod_internal) GOD(__strtold_l, DFppp, __strtod_l) -GODW(strtold_l, DFppp, strtod_l) +GOWD(strtold_l, DFppp, strtod_l) //GO(__strtold_nan, GO(__strtol_internal, lFppii) GO(__strtol_l, lFppi) @@ -2262,7 +2262,7 @@ GOW(wcstof32x, dFpp) //GOW(wcstof32x_l, dFpp!) GOW(wcstof64, dFpp) //GOW(wcstof64_l, dFpp!) -GODW(wcstof64x, DFpp, wcstof64) +GOWD(wcstof64x, DFpp, wcstof64) //GOW(wcstof64x_l, DFpp!) //GO(__wcstof_internal, //GO(__wcstof_l, diff --git a/src/wrapped/wrappedlibm_private.h b/src/wrapped/wrappedlibm_private.h index 6f12f62cce..2c4c2d41cc 100644 --- a/src/wrapped/wrappedlibm_private.h +++ b/src/wrapped/wrappedlibm_private.h @@ -10,32 +10,32 @@ GOW(acosh, dFd) GOW(acoshf, fFf) GOM(__acoshf_finite, fFf) GOM(__acosh_finite, dFd) -GODW(acoshl, DFD, acosh) -GODW(acosl, DFD, acos) +GOWD(acoshl, DFD, acosh) +GOWD(acosl, DFD, acos) GOW(asin, dFd) GOW(asinf, fFf) GOM(__asinf_finite, fFf) GOM(__asin_finite, dFd) GOW(asinh, dFd) GOW(asinhf, fFf) -GODW(asinhl, DFD, asinh) -GODW(asinl, DFD, asin) +GOWD(asinhl, DFD, asinh) +GOWD(asinl, DFD, asin) GO(atan, dFd) GOW(atan2, dFdd) GOW(atan2f, fFff) GOM(__atan2f_finite, fFff) GOM(__atan2_finite, dFdd) -GODW(atan2l, lFDD, atan2) +GOWD(atan2l, lFDD, atan2) GOW(atanf, fFf) GOW(atanh, dFd) GOW(atanhf, fFf) // __atanhf_finite // __atanh_finite -GODW(atanhl, DFD, atanh) -GODW(atanl, DFD, atan) +GOWD(atanhl, DFD, atanh) +GOWD(atanl, DFD, atan) GOW(cabs, XFX) GOW(cabsf, xFx) -GODW(cabsl, DFY, cabs) +GOWD(cabsl, DFY, cabs) GOW(cacos, XFX) GOW(cacosf, xFx) GOW(cacosh, XFX) @@ -59,19 +59,19 @@ GOW(catanhf, xFx) // catanl // Weak GOW(cbrt, dFd) GOW(cbrtf, fFf) -GODW(cbrtl, DFD, cbrt) +GOWD(cbrtl, DFD, cbrt) GOW(ccos, XFX) GOW(ccosf, xFx) GOW(ccosh, XFX) GOW(ccoshf, xFx) -GODW(ccoshl, YFY, ccosh) -GODW(ccosl, YFY, ccos) +GOWD(ccoshl, YFY, ccosh) +GOWD(ccosl, YFY, ccos) GOW(ceil, dFd) GOW(ceilf, fFf) -GODW(ceill, DFD, ceil) +GOWD(ceill, DFD, ceil) GOW(cexp, XFX) GOW(cexpf, xFx) -GODW(cexpl, YFY, cexp) +GOWD(cexpl, YFY, cexp) // cimag // Weak // cimagf // Weak // cimagl // Weak @@ -83,7 +83,7 @@ GOW(clog, XFX) // clog10l // Weak // __clog10l GOW(clogf, xFx) -GODW(clogl, YFY, clog) +GOWD(clogl, YFY, clog) // conj // Weak // conjf // Weak // conjl // Weak @@ -96,11 +96,11 @@ GOW(cosh, dFd) GOW(coshf, fFf) GOM(__coshf_finite, fFf) GOM(__cosh_finite, dFd) -GODW(coshl, DFD, cosh) -GODW(cosl, DFD, cos) +GOWD(coshl, DFD, cosh) +GOWD(cosl, DFD, cos) GOW(cpow, XFXX) GOW(cpowf, xFxx) -GODW(cpowl, YFYY, cpow) +GOWD(cpowl, YFYY, cpow) GOW(cproj, XFX) GOW(cprojf, xFx) // cprojl // Weak @@ -111,17 +111,17 @@ GOW(csin, XFX) GOW(csinf, xFx) GOW(csinh, XFX) GOW(csinhf, xFx) -GODW(csinhl, YFY, csinh) -GODW(csinl, YFY, csin) +GOWD(csinhl, YFY, csinh) +GOWD(csinl, YFY, csin) GOW(csqrt, XFX) GOW(csqrtf, xFx) -GODW(csqrtl, YFY, csqrt) +GOWD(csqrtl, YFY, csqrt) GOW(ctan, XFX) GOW(ctanf, xFx) GOW(ctanh, XFX) GOW(ctanhf, xFx) -GODW(ctanhl, YFY, ctanh) -GODW(ctanl, YFY, ctan) +GOWD(ctanhl, YFY, ctanh) +GOWD(ctanl, YFY, ctan) // __cxa_finalize // Weak // drem // Weak // dremf // Weak @@ -129,9 +129,9 @@ GODW(ctanl, YFY, ctan) GOW(erf, dFd) GOW(erfc, dFd) GOW(erfcf, fFf) -GODW(erfcl, DFD, erfc) +GOWD(erfcl, DFD, erfc) GOW(erff, fFf) -GODW(erfl, DFD, erf) +GOWD(erfl, DFD, erf) GOW(exp, dFd) GOW(exp10, dFd) GOW(exp10f, fFf) @@ -142,14 +142,14 @@ GOW(exp2, dFd) GOW(exp2f, fFf) GOM(__exp2f_finite, fFf) GOM(__exp2_finite, dFd) -GODW(exp2l, DFD, exp2) +GOWD(exp2l, DFD, exp2) GOW(expf, fFf) GOM(__expf_finite, fFf) GOM(__exp_finite, dFd) -GODW(expl, DFD, exp) +GOWD(expl, DFD, exp) GOW(expm1, dFd) GOW(expm1f, fFf) -GODW(expm1l, DFD, expm1) +GOWD(expm1l, DFD, expm1) GOW(fabs, dFd) GOW(fabsf, fFf) // fabsl // Weak @@ -178,10 +178,10 @@ GO(__finitef, iFf) // __finitel GOW(floor, dFd) GOW(floorf, fFf) -GODW(floorl, DFD, floor) +GOWD(floorl, DFD, floor) GOW(fma, dFddd) GOW(fmaf, fFfff) -GODW(fmal, DFDDD, fma) +GOWD(fmal, DFDDD, fma) GOW(fmax, dFdd) GOW(fmaxf, fFff) // fmaxl // Weak @@ -192,12 +192,12 @@ GOW(fmod, dFdd) GOW(fmodf, fFff) GOM(__fmodf_finite, fFff) GOM(__fmod_finite, dFdd) -GODW(fmodl, DFDD, fmod) +GOWD(fmodl, DFDD, fmod) GO(__fpclassify, iFd) GO(__fpclassifyf, iFf) GOW(frexp, dFdp) GOW(frexpf, fFfp) -GODW(frexpl, DFDp, frexp) +GOWD(frexpl, DFDp, frexp) // gamma // Weak // gammaf // Weak // __gammaf_r_finite @@ -208,7 +208,7 @@ GOW(hypot, dFdd) GOW(hypotf, fFff) GOM(__hypotf_finite, fFff) GOM(__hypot_finite, dFdd) -GODW(hypotl, DFDD, hypot) +GOWD(hypotl, DFDD, hypot) GOW(ilogb, iFd) GOW(ilogbf, iFf) // ilogbl // Weak @@ -233,13 +233,13 @@ GO(jnf, fFif) GOD(jnl, DFiD, jn) GOW(ldexp, dFdi) GOW(ldexpf, fFfi) -GODW(ldexpl, DFD, ldexp) +GOWD(ldexpl, DFD, ldexp) GOW(lgamma, dFd) GOW(lgammaf, fFf) GOW(lgammaf_r, fFfp) // __lgammaf_r_finite -GODW(lgammal, DFD, lgamma) -GODW(lgammal_r, DFDp, lgamma_r) +GOWD(lgammal, DFD, lgamma) +GOWD(lgammal_r, DFDp, lgamma_r) GOW(lgamma_r, dFdp) // __lgamma_r_finite #ifdef STATICBUILD @@ -258,28 +258,28 @@ GOW(log10, dFd) GOW(log10f, fFf) GOM(__log10f_finite, fFf) GOM(__log10_finite, dFd) -GODW(log10l, DFD, log10) //Weak +GOWD(log10l, DFD, log10) //Weak GOW(log1p, dFd) GOW(log1pf, fFf) -GODW(log1pl, DFD, log1p) +GOWD(log1pl, DFD, log1p) GOW(log2, dFd) GOW(log2f, fFf) GOM(__log2f_finite, fFf) GOM(__log2_finite, dFd) -GODW(log2l, DFD, log2) +GOWD(log2l, DFD, log2) GOW(logb, dFd) GOW(logbf, fFf) // logbl // Weak GOW(logf, fFf) GOM(__logf_finite, fFf) GOM(__log_finite, dFd) -GODW(logl, DFD, log) +GOWD(logl, DFD, log) GOWM(lrint, iFEd) GOWM(lrintf, iFEf) // lrintl // Weak GOW(lround, iFd) GOW(lroundf, iFf) -GODW(lroundl, lFD, lround) +GOWD(lroundl, lFD, lround) // matherr // Weak GOW(modf, dFdp) GOW(modff, fFfp) @@ -292,9 +292,9 @@ GOWM(nearbyintf, fFEf) // nearbyintl // Weak GOW(nextafter, dFdd) GOW(nextafterf, fFff) -GODW(nextafterl, DFDD, nextafter) -GODW(nexttoward, dFdD, my_nexttoward) // This loses precision -GODW(nexttowardf, fFfD, my_nexttowardf) // This loses precision +GOWD(nextafterl, DFDD, nextafter) +GOWD(nexttoward, dFdD, my_nexttoward) // This loses precision +GOWD(nexttowardf, fFfD, my_nexttowardf) // This loses precision // nexttowardl // Weak GOW(pow, dFdd) GOWM(pow10, dFd) @@ -303,7 +303,7 @@ GOWM(pow10l, DFD) GOW(powf, fFff) GOM(__powf_finite, fFff) GOM(__pow_finite, dFdd) -GODW(powl, DFDD, pow) +GOWD(powl, DFDD, pow) GOW(remainder, dFdd) GOW(remainderf, fFff) // __remainderf_finite @@ -320,7 +320,7 @@ GOW(roundf, fFf) GO(roundeven, dFd) //since C23 GO(roundevenf, fFf) //GO(roundevenl, DFD) -GODW(roundl, DFD, round) +GOWD(roundl, DFD, round) // scalb // Weak // scalbf // Weak // __scalbf_finite @@ -341,28 +341,28 @@ DATAB(signgam, 8) GOW(sin, dFd) GOW(sincos, vFdpp) GOW(sincosf, vFfpp) -GODW(sincosl, vFDpp, sincos) +GOWD(sincosl, vFDpp, sincos) GOW(sinf, fFf) GOW(sinh, dFd) GOW(sinhf, fFf) GOM(__sinhf_finite, fFf) GOM(__sinh_finite, dFd) -GODW(sinhl, DFD, sinh) -GODW(sinl, DFD, sin) +GOWD(sinhl, DFD, sinh) +GOWD(sinl, DFD, sin) GOW(sqrt, dFd) GOW(sqrtf, fFf) GOM(__sqrtf_finite, fFf) GOM(__sqrt_finite, dFd) -GODW(sqrtl, DFD, sqrt) +GOWD(sqrtl, DFD, sqrt) GO(tan, dFd) GOW(tanf, fFf) GOW(tanh, dFd) GOW(tanhf, fFf) -GODW(tanhl, DFD, tanh) -GODW(tanl, DFD, tan) +GOWD(tanhl, DFD, tanh) +GOWD(tanl, DFD, tan) GOW(tgamma, dFd) GOW(tgammaf, fFf) -GODW(tgammal, DFD, tgamma) +GOWD(tgammal, DFD, tgamma) GOW(trunc, dFd) GOW(truncf, fFf) // truncl // Weak diff --git a/src/wrapped/wrappedsdl2.c b/src/wrapped/wrappedsdl2.c index 33cbfab6f0..d0a933d74f 100644 --- a/src/wrapped/wrappedsdl2.c +++ b/src/wrapped/wrappedsdl2.c @@ -550,7 +550,6 @@ static int get_sdl_priv(x64emu_t* emu, const char *sym_str, void **w, void **f) *f = dlsym(emu->context->box64lib, "my2_"#sym); \ return *f != NULL; \ } - #define GOS(sym, _w) GOM(sym, _w) #define DATA if(0); @@ -559,7 +558,6 @@ static int get_sdl_priv(x64emu_t* emu, const char *sym_str, void **w, void **f) #undef GO #undef GOM #undef GO2 - #undef GOS #undef DATA return 0; } diff --git a/src/wrapped/wrappedtermuxexec_private.h b/src/wrapped/wrappedtermuxexec_private.h index a0ed8e1f1f..4c8e334bfb 100644 --- a/src/wrapped/wrappedtermuxexec_private.h +++ b/src/wrapped/wrappedtermuxexec_private.h @@ -1,4 +1,4 @@ -#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA) && defined(GOS)) +#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA)) #error Meh... #endif