From 3f43e85e38ccd93079b08e8212c521e982981cee Mon Sep 17 00:00:00 2001 From: eching Date: Fri, 28 Oct 2022 08:35:22 -0700 Subject: [PATCH 1/5] Maple Engine for Lmbc --- BUILD.gn | 6 + Makefile | 5 + build/config/BUILDCONFIG.gn | 1 + src/MapleEng/BUILD.gn | 19 + src/MapleEng/cscope.in.out | Bin 0 -> 90112 bytes src/MapleEng/cscope.out | 19956 ++++++++++++++++++++++ src/MapleEng/cscope.po.out | Bin 0 -> 178872 bytes src/MapleEng/lmbc/BUILD.gn | 54 + src/MapleEng/lmbc/include/eng_shim.h | 27 + src/MapleEng/lmbc/include/lmbc_eng.h | 151 + src/MapleEng/lmbc/include/massert.h | 30 + src/MapleEng/lmbc/include/mexpression.h | 233 + src/MapleEng/lmbc/include/mfunction.h | 114 + src/MapleEng/lmbc/include/mprimtype.h | 136 + src/MapleEng/lmbc/include/mvalue.h | 44 + src/MapleEng/lmbc/src/eng_shim.cpp | 75 + src/MapleEng/lmbc/src/init.cpp | 611 + src/MapleEng/lmbc/src/invoke_method.cpp | 1326 ++ src/MapleEng/lmbc/src/load_store.cpp | 127 + src/MapleEng/lmbc/src/mfunction.cpp | 342 + src/MapleEng/lmbc/src/mplsh.cpp | 129 + src/MapleEng/tags | 315 + 22 files changed, 23701 insertions(+) create mode 100644 src/MapleEng/BUILD.gn create mode 100644 src/MapleEng/cscope.in.out create mode 100644 src/MapleEng/cscope.out create mode 100644 src/MapleEng/cscope.po.out create mode 100755 src/MapleEng/lmbc/BUILD.gn create mode 100644 src/MapleEng/lmbc/include/eng_shim.h create mode 100644 src/MapleEng/lmbc/include/lmbc_eng.h create mode 100644 src/MapleEng/lmbc/include/massert.h create mode 100644 src/MapleEng/lmbc/include/mexpression.h create mode 100644 src/MapleEng/lmbc/include/mfunction.h create mode 100644 src/MapleEng/lmbc/include/mprimtype.h create mode 100644 src/MapleEng/lmbc/include/mvalue.h create mode 100644 src/MapleEng/lmbc/src/eng_shim.cpp create mode 100644 src/MapleEng/lmbc/src/init.cpp create mode 100644 src/MapleEng/lmbc/src/invoke_method.cpp create mode 100644 src/MapleEng/lmbc/src/load_store.cpp create mode 100644 src/MapleEng/lmbc/src/mfunction.cpp create mode 100644 src/MapleEng/lmbc/src/mplsh.cpp create mode 100644 src/MapleEng/tags diff --git a/BUILD.gn b/BUILD.gn index 40e691379f..07bdc8aeac 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -66,3 +66,9 @@ group("maplegendef") { ]) } } + +group("mplsh-lmbc") { + deps = [ "${MAPLEENG_ROOT}/lmbc:mplsh-lmbc" ] +} + + diff --git a/Makefile b/Makefile index e3a7e3bc88..11deae88aa 100644 --- a/Makefile +++ b/Makefile @@ -173,6 +173,11 @@ ctorture: ctorture2: (cd third_party/ctorture; git checkout .; git pull; ./run.sh work.list hir2mpl) +.PHONY: mplsh-lmbc +mplsh-lmbc: + $(call build_gn, $(GN_OPTIONS), mplsh-lmbc) + + THREADS := 50 ifneq ($(findstring test,$(MAKECMDGOALS)),) TESTTARGET := $(MAKECMDGOALS) diff --git a/build/config/BUILDCONFIG.gn b/build/config/BUILDCONFIG.gn index 675724a3a7..9de64def59 100755 --- a/build/config/BUILDCONFIG.gn +++ b/build/config/BUILDCONFIG.gn @@ -67,6 +67,7 @@ MAPLEALL_ROOT = "${MAPLE_ROOT}/src/mapleall" HIR2MPL_ROOT = "${MAPLE_ROOT}/src/hir2mpl" MAPLE_MRT_ROOT = "${MAPLE_ROOT}/src/mrt" THIRD_PARTY_ROOT = "${MAPLE_ROOT}/third_party" +MAPLEENG_ROOT = "${MAPLE_ROOT}/src/MapleEng" # Put all built library files under lib GN_ARCHIVE_OUTPUT_DIRECTORY = "${MAPLE_BUILD_OUTPUT}/ar/host-x86_64-${OPT}" diff --git a/src/MapleEng/BUILD.gn b/src/MapleEng/BUILD.gn new file mode 100644 index 0000000000..aca0f4de0b --- /dev/null +++ b/src/MapleEng/BUILD.gn @@ -0,0 +1,19 @@ +# +# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. +# +# OpenArkCompiler is licensed under Mulan PSL v2. +# You can use this software according to the terms and conditions of the Mulan PSL v2. +# You may obtain a copy of Mulan PSL v2 at: +# +# http://license.coscl.org.cn/MulanPSL2 +# +# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR +# FIT FOR A PARTICULAR PURPOSE. +# See the Mulan PSL v2 for more details. +# +configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ] + +group("mplsh-lmbc") { + deps = [ "${MAPLEENG_ROOT}/lmbc:lmbc_mplsh" ] +} diff --git a/src/MapleEng/cscope.in.out b/src/MapleEng/cscope.in.out new file mode 100644 index 0000000000000000000000000000000000000000..b71595a05141c28a87fbce64be2ccee03b066bc5 GIT binary patch literal 90112 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 z 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 + +19  + ~"lmbc_g.h +" + +21 +mea + + gm + { + +23 "C" +t64_t + +__geShim +( +LmbcFunc +*, ...); + + @lmbc/include/lmbc_eng.h + +1 #ide +LMBC_ENG_H_ + + +2  + #LMBC_ENG_H_ + + + ) + +4  + ~ + +5  + ~ + +6  + ~ + +7  + ~ + +8  + ~"m_rr.h +" + +9  + ~"b_mt.h +" + +10  + ~"code_fo.h +" + +11  + ~"m_funi.h +" + +12  + ~"cڡtfd.h +" + +13  + ~"m_ty.h +" + +14  + ~"mvue.h +" + +15  + ~"glob_bs.h +" + +16  + ~"mfuni.h +" + +18 +mea + + gm + { + +19 +ass + + gMFuni +; + +20 +usg + + gLabM + = +d +:: +unded_m +< +LabIdx +, + gStmtNode +*>; + +23 +usg + + gVInf + =  +PmInf +; + +24  + sPmInf + { + +25 +PrimTy + + gyp +; + +26 +size_t + + gsize +; + +27 +bo + + gisPg +; + +28 +bo + + gisVg +; + +29 +t32 + + geIdx +; + +34 +MIRSymb + * + gsym +; + +35 +PUIdx + + gpuIdx +; + +36 +PmInf +( +PrimTy + +ty +, +size_t + +sz +, +bo + +ig +, +t32_t + +ageIdx +) + +37 : +yp +( +ty +), +size +( +sz +), +isPg +( +ig +), +eIdx +( +ageIdx +) {} + +38 +PmInf +( +PrimTy + +ty +, +size_t + +sz +, +bo + +ig +, +t32_t + +ageIdx +, +MIRSymb + * +psym +) + +39 : +yp +( +ty +), +size +( +sz +), +isPg +( +ig +), +eIdx +( +ageIdx +), +sym +( +psym +) {} + +40 +PmInf +( +PrimTy + +ty +, +size_t + +sz +, +bo + +ig +, +t32_t + +ageIdx +, +MIRSymb + * +psym +, +PUIdx + +puidx +) + +41 : +yp +( +ty +), +size +( +sz +), +isPg +( +ig +), +eIdx +( +ageIdx +), +sym +( +psym +), +puIdx +( +puidx +) {} + +44 +ass + + gLmbcMod +; + +45 as + cLmbcFunc + { + +46 + gpublic +: + +47 +LmbcMod + * +lmbcMod +; + +48 +MIRFuni + * + gmFunc +; + +49 +ut32 + + gtSize +; + +50 +ut32 + + gameSize +; + +51 +ut16 + + gfmsNum +; + +52 +ut32 + + gfmsNumVs +; + +53 +ut32 + + gfmsAggSize +; + +54 +ut32 + + gfmsSize +; + +55 +LabM + + gbM +; + +56 +size_t + + gnumPgs +; + +57 +bo + + gisVArgs +; + +58 + gd +:: +ve +< +PmInf +*> +pos2Pm +; + +59 + gd +:: +unded_m +< +t32 +, + gPmInf +*> + gidx2Pm +; + +60  +SnFuncFms +(); + +61  +SnLabs +( +StmtNode +* +mt +); + +62  +SnPUStic +(); + +65 +usg + + gFuncM + = +d +:: +unded_m +< +PUIdx +, + gLmbcFunc +*>; + +67 as + cFuncAddr + { + +68 + gpublic +: + +70 +LmbcFunc + * +lmbcFunc +; + +71 * + gtiveFunc +; + +72 } + gfuncP +; + +73 +bo + + gisLmbcFunc +; + +74 +ut32 + + gfmsAggSize +; + +75 + gd +:: +rg + +funcName +; + +76 +FuncAddr +( +bo + +lmbcFunc +, * +func +, +d +:: +rg + +funcName +, +ut32 + +fmsAggSz + = 0); + +79 as + cLmbcMod + { + +80 + gpublic +: + +81 +d +:: +rg + +lmbcPh +; + +82 +MIRModu +* + gmMod +; + +83 +FuncM + + gfuncM +; + +84 +LmbcFunc +* + gmaFn +; + +86 + gd +:: +unded_m +< +ut64 +, + gVInf +*> + gglobAndSticVs +; + +87 + gd +:: +unded_m +< +ut32 +, std:: +rg +> +globSTbl +; + +88  + gglobSticMemSize +; + +89 +ut8 +* + gglobSticMem +; + +90  + gglobsSize +; + +91 +ut8 +* + gglobs +; + +92 +ut32 + + gaggrInOfft +; + +93 + gpublic +: + +94  +InGlobVs +(); + +95  +InGlobVb +( +VInf + * +pInf +); + +96  +InICڡ +( +VInf + * +pInf +, +MIRICڡ + & +tCڡ +, +ut8 + * +d +); + +97  +InSCڡ +( +VInf +* +pInf +, +MIRSCڡ + & +mSCڡ +, +ut8 + * +d +); + +98  +InAddrofCڡ +( +VInf + * +pInf +, +MIRAddrofCڡ + & +addrofCڡ +, +ut8 + * +d +); + +99  +InFltCڡ +( +VInf + * +pInf +, +MIRFltCڡ + & +f32Cڡ +, +ut8 + * +d +); + +100  +InDoubCڡ +( +VInf + * +Inf +, +MIRDoubCڡ + & +f64Cڡ +, +ut8 + * +d +); + +101  +InLblCڡ +( +VInf + * +pInf +, +MIRLblCڡ + & +bCڡ +, +ut8 + * +d +); + +102  +InBFldCڡ +( +VInf + * +pInf +, +MIRCڡ + & +mCڡ +, +t32_t + & +locdBs +, +bo + & +fAlign +); + +103 +ut8_t +* +GGlobVInAddr +( +VInf +* +pInf +, +ut32 + +ign +); + +104  +UpdeGlobVInAddr +( +VInf +* +pInf +, +ut32 + +size +); + +105  +CheckUmedBFld +( +MIRSuTy + & +Ty +, +ut32 + & +evInFd +, ut32 +curFd +, +t32 + & +locdBs +); + +107 +LmbcMod +(* +th +); + +108 +MIRModu +* +Impt +( +d +:: +rg + +th +); + +109  +SnModu +(); + +110  +CcGlobVsSize +(); + +111 +LmbcFunc +* +LkupLmbcFunc +( +PUIdx + +puIdx +); + +113 + gd +:: +ve +<*> +libHds +; + +114 + gd +:: +unded_m +< +PUIdx +, *> + gextFuncM +; + +115 + gd +:: +unded_m +< +ut32 +, *> + gextSymM +; + +116  +LdDefLibs +(); + +117 * +FdExtFunc +( +PUIdx + +puidx +); + +118 * +FdExtSym +( +StIdx + +idx +); + +119  +AddGlobV +( +MIRSymb + & +sym +, +VInf + * +pInf +); + +120  +AddPUSticV +( +PUIdx + +puIdx +, +MIRSymb + & +sym +, +VInf + * +pInf +); + +121 +ut8 + * +GVAddr +( +StIdx + +idx +); + +122 +ut8 + * +GVAddr +( +PUIdx + +puidx +, +StIdx + +idx +); + +124  +InAggCڡ +( +VInf + * +pInf +, +MIRCڡ + & +mCڡ +); + +125  +InAayCڡ +( +VInf + * +pInf +, +MIRCڡ + & +mCڡ +); + +126  +InSrCڡ +( +VInf + * +pInf +, +MIRCڡ + & +mCڡ +); + +127  +InPorCڡ +( +VInf + * +pInf +, +MIRCڡ + & +mCڡ +); + +128 + gd +:: +unded_m +< +PUIdx +, + gFuncAddr +*> + gPUIdx2FuncAddr +; + +129 +FuncAddr +* +GFuncAddr +( +PUIdx + +puIdx +); + + @lmbc/include/massert.h + +16 #ide +MAPLERE_MASSERT_H_ + + +17  + #MAPLERE_MASSERT_H_ + + + ) + +19  + ~ + +20  + ~ + +22  + #MASSERT +( +cd +, +fmt +, ...) \ + +24 i(!( +cd +)) { \ + +25 + `rtf +( +dr +, +__FILE__ + ":%d: As faed: " +fmt + "\n", +__LINE__ +, ## +__VA_ARGS__ +); \ + +26 + `abt +(); \ + +28 } 0) + + ) + + @lmbc/include/mexpression.h + +16 #ide +MAPLERE_MEXPRESSION_H_ + + +17  + #MAPLERE_MEXPRESSION_H_ + + + ) + +19  + ~ + +20  + ~"mas.h +" + +22  + #EXPRBINOP +( +ex +, +s +, +0 +, +1 +, +exPtyp +) \ + +24  +exPtyp +) { \ + +25  +PTY_i8 +: +s +. +x +. +i8 + = +0 +.x.i8 +ex + +1 +.x.i8; ; \ + +26  +PTY_i16 +: +s +. +x +. +i16 + = +0 +.x.i16 +ex + +1 +.x.i16; ; \ + +27  +PTY_i32 +: +s +. +x +. +i32 + = ( +t64 +) +0 +.x.i32 + `ex + (t64) +1 +.x.i32; ; \ + +28  +PTY_i64 +: +s +. +x +. +i64 + = +0 +.x.i64 +ex + +1 +.x.i64; ; \ + +29  +PTY_u8 +: +s +. +x +. +u8 + = +0 +.x.u8 +ex + +1 +.x.u8; ; \ + +30  +PTY_u16 +: +s +. +x +. +u16 + = +0 +.x.u16 +ex + +1 +.x.u16; ; \ + +31  +PTY_u32 +: +s +. +x +. +u32 + = +0 +.x.u32 +ex + +1 +.x.u32; ; \ + +32  +PTY_u64 +: +s +. +x +. +u64 + = +0 +.x.u64 +ex + +1 +.x.u64; ; \ + +33  +PTY_a64 +: +s +. +x +. +u64 + = +0 +.x.u64 +ex + +1 +.x.u64; ; \ + +34  +PTY_f32 +: +s +. +x +. +f32 + = +0 +.x.f32 +ex + +1 +.x.f32; ; \ + +35  +PTY_f64 +: +s +. +x +. +f64 + = +0 +.x.f64 +ex + +1 +.x.f64; ; \ + +36 : + `MIR_FATAL +("Unsu܋d PrimTy %d f by ot %s", +exPtyp +, #exprop); \ + +38 +s +. +yp + = +ex +->ptyp; \ + +39 } 0) + + ) + +41  + #EXPRCOMPOP +( +ex +, +s +, +0 +, +1 +, +typ +, +exyp +) \ + +44  +typ +) { \ + +45  +PTY_i8 +: +s +. +x +. +i64 + = +0 +.x. +i8 + +ex + +1 +.x.i8; ; \ + +46  +PTY_i16 +: +s +. +x +. +i64 + = +0 +.x. +i16 + +ex + +1 +.x.i16; ; \ + +47  +PTY_i32 +: +s +. +x +. +i64 + = +0 +.x. +i32 + +ex + +1 +.x.i32; ; \ + +48  +PTY_i64 +: +s +. +x +. +i64 + = +0 +.x.i64 +ex + +1 +.x.i64; ; \ + +49  +PTY_u8 +: +s +. +x +. +i64 + = +0 +.x. +u8 + +ex + +1 +.x.u8; ; \ + +50  +PTY_u16 +: +s +. +x +. +i64 + = +0 +.x. +u16 + +ex + +1 +.x.u16; ; \ + +51  +PTY_u32 +: +s +. +x +. +i64 + = +0 +.x. +u32 + +ex + +1 +.x.u32; ; \ + +52  +PTY_u64 +: +s +. +x +. +i64 + = +0 +.x. +u64 + +ex + +1 +.x.u64; ; \ + +53  +PTY_a64 +: +s +. +x +. +i64 + = +0 +.x. +a64 + +ex + +1 +.x.a64; ; \ + +54  +PTY_f32 +: +s +. +x +. +i64 + = +0 +.x. +f32 + +ex + +1 +.x.f32; ; \ + +55  +PTY_f64 +: +s +. +x +. +i64 + = +0 +.x. +f64 + +ex + +1 +.x.f64; ; \ + +56 : + `MIR_FATAL +("Unsu܋d ond PrimTy %d f comris ot %s", +0 +. +yp +, #exprop); \ + +58 +s +. +yp + = +exyp +; \ + +59 } 0) + + ) + +64  + #EXPRCOMPOPNOFLOAT +( +ex +, +s +, +0 +, +1 +, +typ +, +exyp +) \ + +67  +typ +) { \ + +68  +PTY_i8 +: +s +. +x +. +i64 + = +0 +.x. +i8 + +ex + +1 +.x.i8; ; \ + +69  +PTY_i16 +: +s +. +x +. +i64 + = +0 +.x. +i16 + +ex + +1 +.x.i16; ; \ + +70  +PTY_i32 +: +s +. +x +. +i64 + = +0 +.x. +i32 + +ex + +1 +.x.i32; ; \ + +71  +PTY_i64 +: +s +. +x +. +i64 + = +0 +.x.i64 +ex + +1 +.x.i64; ; \ + +72  +PTY_u8 +: +s +. +x +. +i64 + = +0 +.x. +u8 + +ex + +1 +.x.u8; ; \ + +73  +PTY_u16 +: +s +. +x +. +i64 + = +0 +.x. +u16 + +ex + +1 +.x.u16; ; \ + +74  +PTY_u32 +: +s +. +x +. +i64 + = +0 +.x. +u32 + +ex + +1 +.x.u32; ; \ + +75  +PTY_u64 +: +s +. +x +. +i64 + = +0 +.x. +u64 + +ex + +1 +.x.u64; ; \ + +76  +PTY_a64 +: +s +. +x +. +i64 + = +0 +.x. +a64 + +ex + +1 +.x.a64; ; \ + +77 : + `MIR_FATAL +("Unsu܋d ond PrimTy %d f comris ot %s", +0 +. +yp +, #exprop); \ + +79 +s +. +yp + = +exyp +; \ + +80 } 0) + + ) + +82  + #EXPRSELECTOP +( +s +, +0 +, +l1 +, +l2 +, +exyp +) \ + +84 +MVue + +1 +, +2 +; \ + +85 +1 + = + `CvtTy +( +l1 +, +exyp +, s1. +yp +); \ + +86 +2 + = + `CvtTy +( +l2 +, +exyp +, s2. +yp +); \ + +87  +exyp +) { \ + +88  +PTY_i8 +: +s +. +x +. +i8 + = +0 +.x. +i64 +? +1 +.x.i8 : +2 +.x.i8; ; \ + +89  +PTY_i16 +: +s +. +x +. +i16 + = +0 +.x. +i64 +? +1 +.x.i16 : +2 +.x.i16; ; \ + +90  +PTY_i32 +: +s +. +x +. +i32 + = +0 +.x. +i64 +? +1 +.x.i32 : +2 +.x.i32; ; \ + +91  +PTY_i64 +: +s +. +x +. +i64 + = +0 +.x.i64? +1 +.x.i64 : +2 +.x.i64; ; \ + +92  +PTY_u8 +: +s +. +x +. +u8 + = +0 +.x. +i64 +? +1 +.x.u8 : +2 +.x.u8; ; \ + +93  +PTY_u16 +: +s +. +x +. +u16 + = +0 +.x. +i64 +? +1 +.x.u16 : +2 +.x.u16; ; \ + +94  +PTY_u32 +: +s +. +x +. +u32 + = +0 +.x. +i64 +? +1 +.x.u32 : +2 +.x.u32; ; \ + +95  +PTY_u64 +: +s +. +x +. +u64 + = +0 +.x. +i64 +? +1 +.x.u64 : +2 +.x.u64; ; \ + +96  +PTY_a64 +: +s +. +x +. +a64 + = +0 +.x. +i64 +? +1 +.x.a64 : +2 +.x.a64; ; \ + +97  +PTY_f32 +: +s +. +x +. +f32 + = +0 +.x. +i64 +? +1 +.x.f32 : +2 +.x.f32; ; \ + +98  +PTY_f64 +: +s +. +x +. +f64 + = +0 +.x. +i64 +? +1 +.x.f64 : +2 +.x.f64; ; \ + +99 : + `MIR_FATAL +("Unsu܋d PrimTy %d f se ot", +exyp +); \ + +101 +s +. +yp + = +exyp +; \ + +102 } 0) + + ) + +104  + #EXPRBININTOP +( +ex +, +s +, + +, +1 +, +exyp +) \ + +106 +MVue + +0 + = + `CvtTy +( + +, +exyp +, op. +yp +); \ + +107  +exyp +) { \ + +108  +PTY_i8 +: +s +. +x +. +i8 + = +0 +.x.i8 +ex + +1 +.x.i8; ; \ + +109  +PTY_i16 +: +s +. +x +. +i16 + = +0 +.x.i16 +ex + +1 +.x.i16; ; \ + +110  +PTY_i32 +: +s +. +x +. +i32 + = +0 +.x.i32 +ex + +1 +.x.i32; ; \ + +111  +PTY_i64 +: +s +. +x +. +i64 + = +0 +.x.i64 +ex + +1 +.x.i64; ; \ + +112  +PTY_u8 +: +s +. +x +. +u8 + = +0 +.x.u8 +ex + +1 +.x.u8; ; \ + +113  +PTY_u16 +: +s +. +x +. +u16 + = +0 +.x.u16 +ex + +1 +.x.u16; ; \ + +114  +PTY_u32 +: +s +. +x +. +u32 + = +0 +.x.u32 +ex + +1 +.x.u32; ; \ + +115  +PTY_u64 +: +s +. +x +. +u64 + = +0 +.x.u64 +ex + +1 +.x.u64; ; \ + +116  +PTY_a64 +: +s +. +x +. +u64 + = +0 +.x.u64 +ex + +1 +.x.u64; ; \ + +117 : + `MIR_FATAL +("Unsu܋d PrimTy %d f ieg by ot %s", +exyp +, #exprop); \ + +119 +s +. +yp + = +exyp +; \ + +120 } 0) + + ) + +123  + #EXPRBININTOPUNSIGNED +( +ex +, +s +, +0 +, +1 +, +exyp +) \ + +125 + `MASSERT +(( +0 +. +yp + = +exyp +) || \ + +126 ( +0 +. +yp + = +PTY_u32 + && +exyp + = +PTY_i32 +) || \ + +127 ( +0 +. +yp + = +PTY_i32 + && +exyp + = +PTY_u32 +), \ + +128 "BINUINTOP Ty mismch: 0x%02xnd 0x%02x", +0 +. +yp +, +exyp +); \ + +129  +1 +. +yp +) { \ + +130  +PTY_i8 +: \ + +131  +PTY_u8 +: \ + +132 + `MASSERT +( +1 +. +x +. +u8 + <= 64, "OP_lshr shifting morehan 64 bites"); \ + +134  +PTY_i16 +: \ + +135  +PTY_u16 +: \ + +136 + `MASSERT +( +1 +. +x +. +u16 + <= 64, "OP_lshr shifting morehan 64 bites"); \ + +138  +PTY_i32 +: \ + +139  +PTY_u32 +: \ + +140 + `MASSERT +( +1 +. +x +. +u32 + <= 64, "OP_lshr shifting morehan 64 bites"); \ + +142  +PTY_i64 +: \ + +143  +PTY_u64 +: \ + +144  +PTY_a64 +: \ + +145 + `MASSERT +( +1 +. +x +. +u64 + <= 64, "OP_lshr shifting morehan 64 bites"); \ + +148 + `MIR_FATAL +("Unsu܋d PrimTy %d f unsigd ieg by ot %s", +exyp +, #exprop); \ + +151  +exyp +) { \ + +152  +PTY_i8 +: +s +. +x +. +u8 + = +0 +.x.u8 +ex + +1 +.x.u8; ; \ + +153  +PTY_i16 +: +s +. +x +. +u16 + = +0 +.x.u16 +ex + +1 +.x.u16; ; \ + +154  +PTY_i32 +: +s +. +x +. +u32 + = +0 +.x.u32 +ex + +1 +.x.u32; ; \ + +155  +PTY_i64 +: +s +. +x +. +u64 + = +0 +.x.u64 +ex + +1 +.x.u64; ; \ + +156  +PTY_a64 +: +s +. +x +. +u64 + = +0 +.x.u64 +ex + +1 +.x.u64; ; \ + +157  +PTY_u8 +: +s +. +x +. +u8 + = +0 +.x.u8 +ex + +1 +.x.u8; ; \ + +158  +PTY_u16 +: +s +. +x +. +u16 + = +0 +.x.u16 +ex + +1 +.x.u16; ; \ + +159  +PTY_u32 +: +s +. +x +. +u32 + = +0 +.x.u32 +ex + +1 +.x.u32; ; \ + +160  +PTY_u64 +: +s +. +x +. +u64 + = +0 +.x.u64 +ex + +1 +.x.u64; ; \ + +161 : + `MIR_FATAL +("Unsu܋d PrimTy %d f unsigd ieg by ot %s", +exyp +, #exprop); \ + +163 +s +. +yp + = +exyp +; \ + +164 } 0) + + ) + +166  + #EXPRMAXMINOP +( +ex +, +s +, +0 +, +1 +, +exyp +) \ + +168 + `MASSERT +( +0 +. +yp + = +1 +.ptyp, "MAXMINOP Type mismatch: 0x%02xnd 0x%02x", op0.ptyp, op1.ptyp); \ + +169 + `MASSERT +( +0 +. +yp + = +exyp +, "MAXMINOP Type mismatch: 0x%02xnd 0x%02x", op0.ptyp,xprptyp); \ + +170  +exyp +) { \ + +171  +PTY_i8 +: +s +. +x +. +i8 + = +0 +.x.i8 +ex + +1 +.x.i8? op0.x.i8 : op1.x.i8; ; \ + +172  +PTY_i16 +: +s +. +x +. +i16 + = +0 +.x.i16 +ex + +1 +.x.i16? op0.x.i16 : op1.x.i16; ; \ + +173  +PTY_i32 +: +s +. +x +. +i32 + = +0 +.x.i32 +ex + +1 +.x.i32? op0.x.i32 : op1.x.i32; ; \ + +174  +PTY_i64 +: +s +. +x +. +i64 + = +0 +.x.i64 +ex + +1 +.x.i64? op0.x.i64 : op1.x.i64; ; \ + +175  +PTY_u8 +: +s +. +x +. +u8 + = +0 +.x.u8 +ex + +1 +.x.u8 ? op0.x.u8 : op1.x.u8; ; \ + +176  +PTY_u16 +: +s +. +x +. +u16 + = +0 +.x.u16 +ex + +1 +.x.u16? op0.x.u16 : op1.x.u16; ; \ + +177  +PTY_u32 +: +s +. +x +. +u32 + = +0 +.x.u32 +ex + +1 +.x.u32? op0.x.u32 : op1.x.u32; ; \ + +178  +PTY_u64 +: +s +. +x +. +u64 + = +0 +.x.u64 +ex + +1 +.x.u64? op0.x.u64 : op1.x.u64; ; \ + +179  +PTY_a64 +: +s +. +x +. +a64 + = +0 +.x.a64 +ex + +1 +.x.a64? op0.x.a64 : op1.x.a64; ; \ + +180  +PTY_f32 +: +s +. +x +. +f32 + = +0 +.x.f32 +ex + +1 +.x.f32? op0.x.f32 : op1.x.f32; ; \ + +181  +PTY_f64 +: +s +. +x +. +f64 + = +0 +.x.f64 +ex + +1 +.x.f64? op0.x.f64 : op1.x.f64; ; \ + +182 : + `MIR_FATAL +("Unsu܋d PrimTy %d f by max/m ot %s", +exyp +, #exprop); \ + +184 +s +. +yp + = +exyp +; \ + +185 } 0) + + ) + +187  + #EXPRREMOP +( +ex +, +s +, +0 +, +1 +, +exyp +) \ + +189  +exyp +) { \ + +190  +PTY_i8 +: if( +1 +. +x +. +i8 + =0 +s +.x.i8 = 0; \ + +191 if( +1 +. +x +. +i8 + =-1 && +0 +.x.i8 = +INT8_MIN +) op0.x.i8 = 0; \ + +192 +s +. +x +. +i8 + = +0 +.x.i8 +ex + +1 +.x.i8; ; \ + +193  +PTY_i16 +: if( +1 +. +x +. +i16 + =0 +s +.x.i16 = 0; \ + +194 if( +1 +. +x +. +i16 + =-1 && +0 +.x.i16 = +INT16_MIN +) op0.x.i16 = 0; \ + +195 +s +. +x +. +i16 + = +0 +.x.i16 +ex + +1 +.x.i16; ; \ + +196  +PTY_i32 +: if( +1 +. +x +. +i32 + =0 +s +.x.i32 = 0; \ + +197 if( +1 +. +x +. +i32 + =-1 && +0 +.x.i32 = +INT32_MIN +) op0.x.i32 = 0; \ + +198 +s +. +x +. +i32 + = +0 +.x.i32 +ex + +1 +.x.i32; ; \ + +199  +PTY_i64 +: if( +1 +. +x +. +i64 + =0 +s +.x.i64 = 0; \ + +200 if( +1 +. +x +. +i64 + =-1 && +0 +.x.i64 = +INT64_MIN +) op0.x.i64 = 0; \ + +201 +s +. +x +. +i64 + = +0 +.x.i64 +ex + +1 +.x.i64; ; \ + +202  +PTY_u8 +: if( +1 +. +x +. +u8 + =0 +s +.x.u8 = 0; \ + +203 +s +. +x +. +u8 + = +0 +.x.u8 +ex + +1 +.x.u8; ; \ + +204  +PTY_u16 +: if( +1 +. +x +. +u16 + =0 +s +.x.u16 = 0; \ + +205 +s +. +x +. +u16 + = +0 +.x.u16 +ex + +1 +.x.u16; ; \ + +206  +PTY_u32 +: if( +1 +. +x +. +u32 + =0 +s +.x.u32 = 0; \ + +207 +s +. +x +. +u32 + = +0 +.x.u32 +ex + +1 +.x.u32; ; \ + +208  +PTY_u64 +: if( +1 +. +x +. +u64 + =0 +s +.x.u64 = 0; \ + +209 +s +. +x +. +u64 + = +0 +.x.u64 +ex + +1 +.x.u64; ; \ + +210 : + `MIR_FATAL +("Unsu܋d PrimTy %d f܄em ot %s", +exyp +, #exprop); \ + +212 +s +. +yp + = +exyp +; \ + +213 } 0) + + ) + +215  + #EXPRUNROP +( +ex +, +s +, +0 +, +exyp +) \ + +217 + `MASSERT +( +0 +. +yp + = +exyp + || \ + +218 (( +0 +. +yp + = +PTY_i32 + || op0.y= +PTY_u32 +) && \ + +219 ( +exyp + = +PTY_i32 + ||xy= +PTY_u32 +), "UNROP Ty mismch: 0x%02xnd 0x%02x", +0 +. +yp +,xprptyp); \ + +220  +exyp +) { \ + +221  +PTY_i8 +: +s +. +x +. +i8 + = +ex + +0 +.x.i8; ; \ + +222  +PTY_i16 +: +s +. +x +. +i16 + = +ex + +0 +.x.i16; ; \ + +223  +PTY_i32 +: +s +. +x +. +i32 + = +ex + +0 +.x.i32; ; \ + +224  +PTY_i64 +: +s +. +x +. +i64 + = +ex + +0 +.x.i64; ; \ + +225  +PTY_u8 +: +s +. +x +. +u8 + = +ex + +0 +.x.u8; ; \ + +226  +PTY_u16 +: +s +. +x +. +u16 + = +ex + +0 +.x.u16; ; \ + +227  +PTY_u32 +: +s +. +x +. +u32 + = +ex + +0 +.x.u32; ; \ + +228  +PTY_u64 +: +s +. +x +. +u64 + = +ex + +0 +.x.u64; ; \ + +229 : + `MIR_FATAL +("Unsu܋d PrimTy %d f ury ot %s", +exyp +, #exprop); \ + +231 +s +. +yp + = +exyp +; \ + +232 } 0) + + ) + + @lmbc/include/mfunction.h + +16 #ide +MAPLERE_MFUNCTION_H_ + + +17  + #MAPLERE_MFUNCTION_H_ + + + ) + +19  + ~ + +20  + ~ + +22  + ~ + +23  + ~ + +24  + #gtid +( + `sys +( +SYS_gtid +) + + ) + +26  + ~"m_nodes.h +" + +27  + ~"mvue.h +" + +28  + ~"lmbc_g.h +" + +30  + #VARNAMELENGTH + 16 + + ) + +31  + #ALLOCA_MEMMAX + 0x4000 + + ) + +33 +mea + + gm + { + +35 +ass + + gLmbcMod +; + +36 +ass + + gLmbcFunc +; + +37  + gPmInf +; + +40 +usg + + gffi__t + = (*)(); + +51 +ut + + ggp_offt +; + +52 +ut + + g_offt +; + +53 * + govow_g_ +; + +54 * + gg_ve_ +; + +55 } + tVaLiX86_64 +[1]; + +58 * + gack +; + +59 * + ggr_t +; + +60 * + gvr_t +; + +61  + ggr_offs +; + +62  + gvr_offs +; + +63 } + tVaLiAch64 +; + +65 +usg + + gVaLi + = +VaLiAch64 +; + +68 as + cMFuni + { + +69 + gpublic +: + +71 +LmbcFunc +* +fo +; + +72 +MFuni +* + gΔ +; + +73 +StmtNode +* + gxtStmt +; + +74 +ut8 +* + game +; + +75 +ut8 +* + g +; + +76 +ut8 +* + gloMem +; + +77 +ut32 + + gloOfft +; + +78 +MVue +* + gpRegs +; + +79 +MVue +* + gfmVs +; + +82 +ut16 + + gnumClArgs +; + +83 +MVue +* + gArgs +; + +84 +ut8 +* + gaggrArgsBuf +; + +85 +ut8 +* + gvArgsBuf +; + +86 +MVue + + gtV0 +; + +87 +MVue + + gtV1 +; + +88 +ut8 +* + gvaArgs +; + +89 +ut32 + + gvaArgsSize +; + +91 +exic + +MFuni +( +LmbcFunc + * +funcInfo +, + +92 +MFuni + * +funcCr +, + +93 +ut8 + * +autoVs +, + +94 +MVue + * +pRegs +, + +95 +MVue + * +fmVs +); + +96 ~ +MFuni +(); + +97 +ut8 + * +Ao +( +ut32 + +size +); + +98 +ut8 + * +GFmVAddr +( +StIdx + +idx +); + +99  +ClMFuncDe +( +ClNode + * + +); + +100  +ClMFuncInde +( +INode + * +i +, +LmbcFunc + * +Info +); + +101  +ClExtFuncDe +( +ClNode +* + +); + +102  +ClExtFuncInde +( +INode + * +iδo +, * + +); + +103  +ClVaArgFunc +( +numArgs +, +LmbcFunc + * +Info +); + +104  +ClWhFFI +( +PrimTy + +t_yp +, +ffi__t + + +); + +105  +ClIrsic +( +IrsicNode + & +n +); + +108 +bo + +IsExtFunc +( +PUIdx + +puIdx +, +LmbcMod + & +modu +); + +109 +MVue + +InvokeFunc +( +LmbcFunc +* + +, +MFuni + * +Δ +); + +110 +MVue + +EvEx +( +MFuni + & +func +, +BaNode +* +ex +, +PmInf + * +rm + = +nuαr +); + +111  +me +( +ut8 +* +addr +, +PrimTy + +yp +, +MVue +& +v +, +bo + +toVArgSck +); + + @lmbc/include/mprimtype.h + +16 #ide +MAPLERE_MPRIMTYPE_H_ + + +17  + #MAPLERE_MPRIMTYPE_H_ + + + ) + +26  + #PTYSIZE_Invid + 0 + + ) + +27  + #PTYSIZE_void + 0 + + ) + +28  + #PTYSIZE_i8 + 1 + + ) + +29  + #PTYSIZE_i16 + 2 + + ) + +30  + #PTYSIZE_i32 + 3 + + ) + +31  + #PTYSIZE_i64 + 4 + + ) + +32  + #PTYSIZE_u8 + 1 + + ) + +33  + #PTYSIZE_u16 + 2 + + ) + +34  + #PTYSIZE_u32 + 3 + + ) + +35  + #PTYSIZE_u64 + 4 + + ) + +36  + #PTYSIZE_u1 + 1 + + ) + +37  + #PTYSIZE_r + 3 + + ) + +38  + #PTYSIZE_f + 3 + + ) + +39  + #PTYSIZE_a32 + 3 + + ) + +40  + #PTYSIZE_a64 + 4 + + ) + +41  + #PTYSIZE_f32 + 3 + + ) + +42  + #PTYSIZE_f64 + 4 + + ) + +43  + #PTYSIZE_f128 + 5 + + ) + +44  + #PTYSIZE_c64 + 5 + + ) + +45  + #PTYSIZE_c128 + 6 + + ) + +46  + #PTYSIZE_simer + 3 + + ) + +47  + #PTYSIZE_simeobj + 3 + + ) + +48  + #PTYSIZE_dyny + 4 + + ) + +49  + #PTYSIZE_dynundef + 4 + + ) + +50  + #PTYSIZE_dyu + 4 + + ) + +51  + #PTYSIZE_dynbo + 4 + + ) + +52  + #PTYSIZE_dyni32 + 4 + + ) + +53  + #PTYSIZE_dynr + 4 + + ) + +54  + #PTYSIZE_dynobj + 4 + + ) + +55  + #PTYSIZE_dynf64 + 4 + + ) + +56  + #PTYSIZE_dynf32 + 4 + + ) + +57  + #PTYSIZE_dye + 4 + + ) + +58  + #PTYSIZE_cڡS + 0 + + ) + +59  + #PTYSIZE_g + 0 + + ) + +60  + #PTYSIZE_agg + 0 + + ) + +61  + #PTYSIZE_v2i64 + 0 + + ) + +62  + #PTYSIZE_v4i32 + 0 + + ) + +63  + #PTYSIZE_v8i16 + 0 + + ) + +64  + #PTYSIZE_v16i8 + 0 + + ) + +65  + #PTYSIZE_v2f64 + 0 + + ) + +66  + #PTYSIZE_v4f32 + 0 + + ) + +67  + #PTYSIZE_unknown + 0 + + ) + +68  + #PTYSIZE_Dived + 0 + + ) + +71  + #FFITYPE_Invid + +ffi_ty_void + + + ) + +72  + #FFITYPE_void + +ffi_ty_void + + + ) + +73  + #FFITYPE_i8 + +ffi_ty_st8 + + + ) + +74  + #FFITYPE_i16 + +ffi_ty_st16 + + + ) + +75  + #FFITYPE_i32 + +ffi_ty_st32 + + + ) + +76  + #FFITYPE_i64 + +ffi_ty_st64 + + + ) + +77  + #FFITYPE_u8 + +ffi_ty_ut8 + + + ) + +78  + #FFITYPE_u16 + +ffi_ty_ut16 + + + ) + +79  + #FFITYPE_u32 + +ffi_ty_ut32 + + + ) + +80  + #FFITYPE_u64 + +ffi_ty_ut64 + + + ) + +81  + #FFITYPE_u1 + +ffi_ty_ut8 + + + ) + +82  + #FFITYPE_r + +ffi_ty_por + + + ) + +83  + #FFITYPE_f + +ffi_ty_por + + + ) + +84  + #FFITYPE_a32 + +ffi_ty_por + + + ) + +85  + #FFITYPE_a64 + +ffi_ty_por + + + ) + +86  + #FFITYPE_f32 + +ffi_ty_t + + + ) + +87  + #FFITYPE_f64 + +ffi_ty_doub + + + ) + +88  + #FFITYPE_f128 + +ffi_ty_void + + + ) + +89  + #FFITYPE_c64 + +ffi_ty_void + + + ) + +90  + #FFITYPE_c128 + +ffi_ty_void + + + ) + +91  + #FFITYPE_simer + +ffi_ty_void + + + ) + +92  + #FFITYPE_simeobj + +ffi_ty_void + + + ) + +93  + #FFITYPE_dyny + +ffi_ty_void + + + ) + +94  + #FFITYPE_dynundef + +ffi_ty_void + + + ) + +95  + #FFITYPE_dyu + +ffi_ty_void + + + ) + +96  + #FFITYPE_dynbo + +ffi_ty_void + + + ) + +97  + #FFITYPE_dyni32 + +ffi_ty_void + + + ) + +98  + #FFITYPE_dynr + +ffi_ty_void + + + ) + +99  + #FFITYPE_dynobj + +ffi_ty_void + + + ) + +100  + #FFITYPE_dynf64 + +ffi_ty_void + + + ) + +101  + #FFITYPE_dynf32 + +ffi_ty_void + + + ) + +102  + #FFITYPE_dye + +ffi_ty_void + + + ) + +103  + #FFITYPE_cڡS + +ffi_ty_void + + + ) + +104  + #FFITYPE_g + +ffi_ty_void + + + ) + +105  + #FFITYPE_agg + +ffi_ty_void + + + ) + +106  + #FFITYPE_v2i64 + +ffi_ty_void + + + ) + +107  + #FFITYPE_v4i32 + +ffi_ty_void + + + ) + +108  + #FFITYPE_v8i16 + +ffi_ty_void + + + ) + +109  + #FFITYPE_v16i8 + +ffi_ty_void + + + ) + +110  + #FFITYPE_v2f64 + +ffi_ty_void + + + ) + +111  + #FFITYPE_v4f32 + +ffi_ty_void + + + ) + +112  + #FFITYPE_unknown + +ffi_ty_void + + + ) + +113  + #FFITYPE_Dived + +ffi_ty_void + + + ) + +114  + #FFITYPE_i128 + +ffi_ty_void + + + ) + +115  + #FFITYPE_u128 + +ffi_ty_void + + + ) + +116  + #FFITYPE_v2u64 + +ffi_ty_void + + + ) + +117  + #FFITYPE_v4u32 + +ffi_ty_void + + + ) + +118  + #FFITYPE_v8u16 + +ffi_ty_void + + + ) + +119  + #FFITYPE_v16u8 + +ffi_ty_void + + + ) + +120  + #FFITYPE_v2i32 + +ffi_ty_void + + + ) + +121  + #FFITYPE_v4i16 + +ffi_ty_void + + + ) + +122  + #FFITYPE_v8i8 + +ffi_ty_void + + + ) + +123  + #FFITYPE_v2u32 + +ffi_ty_void + + + ) + +124  + #FFITYPE_v4u16 + +ffi_ty_void + + + ) + +125  + #FFITYPE_v8u8 + +ffi_ty_void + + + ) + +126  + #FFITYPE_v2f32 + +ffi_ty_void + + + ) + +127  + #FFITYPE_rvedy1 + +ffi_ty_void + + + ) + +128  + #FFITYPE_rvedy2 + +ffi_ty_void + + + ) + +129  + #FFITYPE_rvedy3 + +ffi_ty_void + + + ) + +130  + #FFITYPE_rvedy4 + +ffi_ty_void + + + ) + +131  + #FFITYPE_rvedy5 + +ffi_ty_void + + + ) + +132  + #FFITYPE_rvedy6 + +ffi_ty_void + + + ) + +133  + #FFITYPE_rvedy7 + +ffi_ty_void + + + ) + +134  + #FFITYPE_rvedy8 + +ffi_ty_void + + + ) + +135  + #FFITYPE_rvedy9 + +ffi_ty_void + + + ) + +136  + #FFITYPE_rvedy10 + +ffi_ty_void + + + ) + + @lmbc/include/mvalue.h + +16 #ide +MAPLERE_MVALUE_H_ + + +17  + #MAPLERE_MVALUE_H_ + + + ) + +19  + ~ + +20  + ~"im_tys.h +" + +22 +mea + + gm + { + +23  + sMVue + { + +25 +t8 + + gi8 +; + +26 +t16 + + gi16 +; + +27 +t32 + + gi32 +; + +28 +t64 + + gi64 +; + +29 +ut8 + + gu8 +; + +30 +ut16 + + gu16 +; + +31 +ut32 + + gu32 +; + +32 +ut64 + + gu64 +; + +33  + gf32 +; + +34  + gf64 +; + +35 +ut8 + * + ga64 +; + +36 * + gr +; + +37 * + gr +; + +38 } + gx +; + +39 +PrimTy + + gyp +:8; + +40 +size_t + + gaggSize +; + + @lmbc/src/eng_shim.cpp + +15  + ~"mfuni.h +" + +16  + ~"mas.h +" + +17  + ~"lmbc_g.h +" + +19 +mea + + gm + { + +21 "C" +t64 + + +22 +__geShim +( +LmbcFunc +* + +, ...) { + +23 +ut8 + +ame +[ + +-> +ameSize +]; + +24 +MVue + +egs +[ + +-> +numPgs +]; + +25 +MVue + +fmVs +[ + +-> +fmsNumVs ++1]; + +26 +MFuni + +shim_Δ +( + +, +nuαr +, +ame +, +egs +, +fmVs +); + +28 +MVue + +v +; + +29 i( + +-> +fmsNum + > 0) { + +30 +MVue + +Args +[ + +-> +fmsNum +]; + +31 +va_li + +gs +; + +32 +va_t + ( +gs +, + +); + +34  +gIdx + = 0; + +35  +gIdx + < + +-> +fmsNum +) { + +37 +v +. +yp + = + +-> +pos2Pm +[ +gIdx +]->ptyp; + +38  +v +. +yp +) { + +39  +PTY_i8 +: + +40 +v +. +x +. +i8 + = +va_g +( +gs +, ); + +42  +PTY_i16 +: + +43 +v +. +x +. +i16 + = +va_g +( +gs +, ); + +45  +PTY_i32 +: + +46 +v +. +x +. +i32 + = +va_g +( +gs +, ); + +48  +PTY_i64 +: + +49 +v +. +x +. +i64 + = +va_g +( +gs +, ); + +51  +PTY_u16 +: + +52 +v +. +x +. +u16 + = +va_g +( +gs +, ); + +54  +PTY_a64 +: + +55 +v +. +x +. +a64 + = +va_g +( +gs +, +ut8 +*); + +57  +PTY_f32 +: + +59  +PTY_f64 +: + +60 +v +. +x +. +f64 + = +va_g +( +gs +, ); + +63 +MIR_FATAL +("Unsu܋d PrimTy %d", +v +. +yp +); + +65 +Args +[ +gIdx +] = +v +; + +66 ++ +gIdx +; + +68 +shim_Δ +. +numClArgs + = + +-> +fmsNum +; + +69 +shim_Δ +. +Args + = callArgs; + +71 +v + = +InvokeFunc +( + +, & +shim_Δ +); + + @lmbc/src/init.cpp + +15  + ~"mas.h +" + +16  + ~"lmbc_g.h +" + +17  + ~"g_shim.h +" + +19 +mea + + gm + { + +22  + #ROUNDUP8 +( +v +(((v+7)>>3)<<3) + + ) + +25 +le +  +AlignOfft +( +ut32 + & +offt +, ut32 +ign +) { + +26 + gofft + = ( +offt + + +ign +-1) & ~(align-1); + +29 + gLmbcFunc +:: +LmbcFunc +( +LmbcMod + * +mod +, +MIRFuni + * +func +: +lmbcMod +(mod), +mFunc +(func) { + +30 + gameSize + = +ROUNDUP8 +( +func +-> +GFmeSize +()); + +31 + gisVArgs + = +func +-> +GMIRFuncTy +()-> +IsVgs +(); + +32 + gnumPgs + = +func +-> +GPgTab +()-> +Size +(); + +35  + gLmbcMod +:: +InModu +() { + +36 +CcGlobAndSticVSize +(); + +37  +MIRFuni + * + gmFunc + : +mMod +-> +GFuniLi +()) { + +38 iut +node + = +mFunc +-> +GBody +()) { + +39 +LmbcFunc +* + + = +w + LmbcFunc( +this +, +mFunc +); + +40 +ASSERT +( + +, "Create Lmbc function failed"); + +41 + g +-> +SnFms +(); + +42 + g +-> +SnLabs +( +node +); + +43 + gfuncM +[ +mFunc +-> +GPuidx +()] = + +; + +44 i( + gmFunc +-> +GName +(). +com +("main") == 0) { + +45 +maFn + = + +; + +50 +InGlobVs +(); + +53  + gLmbcFunc +:: +SnFms +() { + +54 +MVe +< +FmDef +> +fmDefVec + = +mFunc +-> +GFmDefVec +(); + +55 + gfmsNum + = +fmDefVec +. +size +(); + +56 + gfmsSize + = 0; + +57 + gfmsNumVs + = 0; + +58 + gfmsAggSize + = 0; + +59 +MASSERT +( +mFunc +-> +GRuTy +(! +nuαr +, "mirFunceturnype isull"); + +60 + gtSize + = +mFunc +-> +GRuTy +()-> +GSize +(); + +61  +ut32 + + gi + = 0; i < + gfmDefVec +. +size +(); i++) { + +62 +MIRSymb +* + gsymb + = +fmDefVec +[ +i +]. +fmSym +; + +63 +MIRTy +* + gty + = +GlobTabs +:: +GTyTab +(). +GTyFromTyIdx +( +fmDefVec +[ +i +]. +fmTyIdx +); + +64 +bo + + gisPg + = ( +symb +-> +GSKd +(= +kStPg +); + +65 +t32 + + gageIdx +; + +66 i( + gty +-> +GPrimTy +(= +PTY_agg +) { + +67 +ageIdx + = +fmsAggSize +; + +68 + gfmsAggSize + + +ty +-> +GSize +(); + +70 + gageIdx + = +isPg +? +symb +-> +GPg +()-> +GPgNo +(): ++ +fmsNumVs +; + +73 +PmInf +* + gpInf + = +w + PmInf( +ty +-> +GPrimTy +(),y-> +GSize +(), +isPg +, +ageIdx +); + +74 + gidx2Pm +[ +symb +-> +GStIdx +(). +FuIdx +()] = +pInf +; + +75 + gpos2Pm +. +push_back +( +pInf +); + +76 + gfmsSize + + +ty +-> +GSize +(); + +80  + gLmbcFunc +:: +SnLabs +( +StmtNode +* +mt +) { + +81  +mt + ! +nuαr +) { + +82  +mt +-> + +) { + +83  +OP_block +: + +84 +mt + = +ic_ +< +BlockNode +*>(mt)-> +GF +(); + +85 +SnLabs +( +mt +); + +87  + gOP_b +: + +88 +bM +[ +ic_ +< +LabNode +*>( +mt +)-> +GLabIdx +()] = stmt; + +93 + gmt + +mt +-> +GNext +(); + +108 +ut32 + +CheckFxAayMemb +( +MIRSymb + & +sym +, +MIRTy + & +ty +) { + +109 aut& + gTy + = +ic_ +< +MIRSuTy +&>( +ty +); + +110 aut& + gCڡ + = +ic_ +< +MIRAggCڡ +&>(* +sym +. +GKڡ +()); + +111 +TyIdxFldArPa + + gtp + = +Ty +. +GTyidxFldArPa +(Ty. +GFldsSize +()-1); + +112 +MIRTy + * + gϡFdTy + = +GlobTabs +:: +GTyTab +(). +GTyFromTyIdx +( +tp +. +f +); + +113 i( + gϡFdTy +-> +GKd +(= +kTyAay + && + +114 +ic_ +< +MIRAayTy +*>( +ϡFdTy +)-> +GSizeAayIm +(0) == 1 && + +115 +Cڡ +. +GCڡVec +(). +size +(= +Ty +. +GFldsSize +()) { + +116 +MIRCڡ + & +emCڡ + = * +Cڡ +. +GCڡVecIm +(Cڡ. +GCڡVec +(). +size +()-1); + +117 +MASSERT +( +emCڡ +. +GTy +(). +GKd +(= +kTyAay +, "array initializerxpected"); + +118 aut& + grCt + = +ic_ +< +MIRAggCڡ +&>( +emCڡ +); + +119 i( + grCt +. +GCڡVec +(). +size +() > 1) { + +120  ( + grCt +. +GCڡVec +(). +size +()-1* + gemCڡ +. +GTy +(). +GSize +(); + +127  + gLmbcMod +:: +CcGlobAndSticVSize +() { + +128 +ut32 + +offt + = 0; + +130  +size_t + + gi + = 0; i < + gGlobTabs +:: +GGsymTab +(). +GSymbTabSize +(); ++i) { + +131 +MIRSymb + * + gsym + = +GlobTabs +:: +GGsymTab +(). +GSymbFromStidx +( +i +); + +132 i(! + gsym + || + +133 !( + gsym +-> +GSKd +(= +kStV +) || + +134 !( +sym +-> +GStageCss +(= +kScGlob + || sym->GStageCss(= +kScFic +)) { + +137 i( +MIRTy + * + gty + = +sym +-> +GTy +()) { + +138 +AlignOfft +( +offt +, +ty +-> +GAlign +()); + +139 +VInf +* + gpInf + = +w + VInf( +ty +-> +GPrimTy +(),y-> +GSize +(), +l +, +offt +, +sym +); + +140 +AddGlobV +(* +sym +, +pInf +); + +141 + gofft + + +ty +-> +GSize +(); + +142 i( + gty +-> +GKd +(= +kTySu +) { + +143 +offt + + +CheckFxAayMemb +(* +sym +, * +ty +); + +147 + gglobsSize + = +offt +; + +149  +MIRFuni + * + gfunc + : +mMod +-> +GFuniLi +()) { + +150 iut +node + = +func +-> +GBody +()) { + +151 +SnPUStic +( +func +); + +156  + gLmbcMod +:: +SnPUStic +( +MIRFuni + * +func +) { + +157 +size_t + +size + = +func +-> +GSymbTabSize +(); + +158  +size_t + + gi + = 0; i < + gsize +; ++i) { + +159 +MIRSymb + * + gsym + = +func +-> +GSymbTabIm +( +i +); + +160 i(! + gsym + || !sym-> +IsPUStic +(|| !sym-> +IsCڡ +()) { + +163 i( +MIRTy + * + gty + = +sym +-> +GTy +()) { + +164 +VInf +* +pInf + = +w + VInf( +ty +-> +GPrimTy +(),y-> +GSize +(), +l +, +globsSize +, +sym +, +func +-> +GPuidx +()); + +165 +AddPUSticV +( +func +-> +GPuidx +(), * +sym +, +pInf +); + +166 + gglobsSize + + +ty +-> +GSize +(); + +176 +ut8 + * + gLmbcMod +:: +GGlobVInAddr +( +VInf +* +pInf +, +ut32 + +ign +) { + +177 i( + gpInf +-> + gyp + ! +PTY_agg +) { + +178  +globs + + +pInf +-> +eIdx +; + +180 +AlignOfft +( +aggrInOfft +, +ign +); + +181  + gglobs + + + gpInf +-> + geIdx + + + gaggrInOfft +; + +184 +le +  + gLmbcMod +:: +UpdeGlobVInAddr +( +VInf +* +pInf +, +ut32 + +size +) { + +185 i( + gpInf +-> + gyp + = +PTY_agg +) { + +186 +aggrInOfft + + +size +; + +194  + gLmbcMod +:: +CheckUmedBFld +( +MIRSuTy + & +Ty +, +ut32 + & +evInFd +, ut32 +curFd +, +t32 + & +locdBs +) { + +196 i( + gcurFd + - 1 = +evInFd +) { + +197 +evInFd + = +curFd +; + +201 aut + gi + = +evInFd +; i < + gcurFd + -1; ++i) { + +202 +TyIdxFldArPa + + gtp + = +Ty +. +GTyidxFldArPa +( +i +); + +203 +MIRTy + * + gty + = +GlobTabs +:: +GTyTab +(). +GTyFromTyIdx +( +tp +. +f +); + +206 i( + gty +-> +GKd +(! +kTyBFld +) { + +209 +MASSERT +( +ty +-> +GKd +()== +kTyBFld +, "Un-named bitfieldxpected"); + +210 +ut8 + + gbFdWidth + = +ic_ +< +MIRBFldTy +*>( +ty +)-> +GFldSize +(); + +211 +ut32 + + gbaFdSz + = +GPrimTySize +( +ty +-> +GPrimTy +()); + +213 +ut32 + + gign + = +locdBs + ? 1 : +baFdSz +; + +214 +AlignOfft +( +aggrInOfft +, +ign +); + +216 i( + glocdBs + + + gbFdWidth + > ( + gbaFdSz + * 8)) { + +217 + gaggrInOfft ++ +baFdSz +; + +218 + glocdBs + = +bFdWidth +; + +220 + glocdBs + + +bFdWidth +; + +223 + gevInFd + = +curFd +; + +226  + gLmbcMod +:: +InSCڡ +( +VInf +* +pInf +, +MIRSCڡ + & +mSCڡ +, +ut8 +* +d +) { + +227 +USIdx + + gurIdx + = +mSCڡ +. +GVue +(); + +228 aut + g + = +globSTbl +. + +( + +229 +d +:: + +< +ut32 +, std:: +rg +>( +urIdx +, +GlobTabs +:: +GUSTab +(). +GSgFromSIdx +(ustrIdx))); + +230 *(cڡ **) + gd + = + +. +f +-> +cd +. +c_r +(); + +233 +le +  + gLmbcMod +:: +InFltCڡ +( +VInf + * +pInf +, +MIRFltCڡ + & +f32Cڡ +, +ut8 +* +d +) { + +234 *(*) + gd + = +f32Cڡ +. +GVue +(); + +237 +le +  + gLmbcMod +:: +InDoubCڡ +( +VInf + * +pInf +, +MIRDoubCڡ + & +f64Cڡ +, +ut8 +* +d +) { + +238 *(*) + gd + = +f64Cڡ +. +GVue +(); + +241  + gLmbcMod +:: +InLblCڡ +( +VInf + * +pInf +, +MIRLblCڡ + & +bCڡ +, +ut8 + * +d +) { + +242 +LabIdx + + gbIdx + = +bCڡ +. +GVue +(); + +243 +LmbcFunc + * + g + = +LkupLmbcFunc +( +bCڡ +. +GPUIdx +()); + +244 +StmtNode +* + gb + = + +-> +bM +[ +bIdx +]; + +245 +MASSERT +( +b +, "InitLblConstabelot foound"); + +246 *( + gStmtNode + **) + gd + = +b +; + +249  + gLmbcMod +:: +InICڡ +( +VInf +* +pInf +, +MIRICڡ + & +tCڡ +, +ut8 +* +d +) { + +250 +t64 + + gv + = +tCڡ +. +GExtVue +(); + +251  + gtCڡ +. +GTy +(). +GPrimTy +()) { + +252  + gPTY_i64 +: + +253 *( +t64 +*) +d + = (t64) +v +; + +255  + gPTY_i32 +: + +256 *( +t32 +*) +d + = (t32) +v +; + +258  + gPTY_i16 +: + +259 *( +t16 +*) +d + = (t16) +v +; + +261  + gPTY_i8 +: + +262 *( +t8 +*) +d + = (t8) +v +; + +264  + gPTY_u64 +: + +265 *( +ut64 +*) +d + = (ut64) +v +; + +267  + gPTY_u32 +: + +268 *( +ut32 +*) +d + = (ut32) +v +; + +270  + gPTY_u16 +: + +271 *( +ut16 +*) +d + = (ut16) +v +; + +273  + gPTY_u8 +: + +274 *( +ut8 +*) +d + = (ut8) +v +; + +281  + gLmbcMod +:: +InPorCڡ +( +VInf + * +pInf +, +MIRCڡ + & +mCڡ +) { + +282 +ut8 + * + gd + = +GGlobVInAddr +( +pInf +, +mCڡ +. +GTy +(). +GAlign +()); + +283  + gmCڡ +. +GKd +()) { + +284  + gkCڡAddrof +: + +285 +InAddrofCڡ +( +pInf +, +ic_ +< +MIRAddrofCڡ +&>( +mCڡ +), +d +); + +287  + gkCڡSCڡ +: + +288 +InSCڡ +( +pInf +, +ic_ +< +MIRSCڡ +&>( +mCڡ +), +d +); + +290  + gkCڡI +: { + +291 +InICڡ +( +pInf +, +ic_ +< +MIRICڡ +&>( +mCڡ +), +d +); + +294  + gkCڡAddrofFunc +: + +296 +MASSERT +( +l +, "InPorCڡ %d kd NYI", +mCڡ +. +GKd +()); + +299 +UpdeGlobVInAddr +( +pInf +, +mCڡ +. +GTy +(). +GSize +()); + +302  +SBFldCڡ +( +ut8 +* +baFdAddr +, +ut32 + +baFdSz +, ut32 +bsOfft +, ut8 +bsSize +, +MIRCڡ + & +emCڡ +) { + +303 + gMIRICڡ + & + gtCڡ + = +ic_ +< +MIRICڡ +&>( +emCڡ +); ()intConst; + +304 +t64 + + gv + = +tCڡ +. +GExtVue +(); + +305 +ut64 + + gmask + = ~(0xfffffffffffffff<< +bsSize +); + +306 +ut64 + + gom + = ( +v + & +mask +<< +bsOfft +; + +307 + gmask + = +mask + << +bsOfft +; + +308  + gemCڡ +. +GTy +(). +GPrimTy +()) { + +309  + gPTY_i64 +: + +310 *( +t64 +*) +baFdAddr + = ((*(t64*)baFdAddr& ~( +mask +)| +om +; + +312  + gPTY_i32 +: + +313 *( +t32 +*) +baFdAddr + = ((*(t32*)baFdAddr& ~( +mask +)| +om +; + +315  + gPTY_i16 +: + +316 *( +t16 +*) +baFdAddr + = ((*(t16*)baFdAddr& ~( +mask +)| +om +; + +318  + gPTY_i8 +: + +319 *( +t8 +*) +baFdAddr + = ((*(t8*)baFdAddr& ~( +mask +)| +om +; + +321  + gPTY_u64 +: + +322 *( +ut64 +*) +baFdAddr + = ((*(ut64*)baFdAddr& ~( +mask +)| +om +; + +324  + gPTY_u32 +: + +325 *( +ut32 +*) +baFdAddr + = ((*(ut32*)baFdAddr& ~( +mask +)| +om +; + +327  + gPTY_u16 +: + +328 *( +ut16 +*) +baFdAddr + = ((*(ut16*)baFdAddr& ~( +mask +)| +om +; + +330  + gPTY_u8 +: + +331 *( +ut8 +*) +baFdAddr + = ((*(ut8*)baFdAddr& ~( +mask +)| +om +; + +334 +MASSERT +( +l +, "Unexpectedrimaryype"); + +339  + gLmbcMod +:: +InBFldCڡ +( +VInf + * +pInf +, +MIRCڡ + & +emCڡ +, +t32 + & +locdBs +, +bo + & +fAlign +) { + +340 +ut8 + + gbFdWidth + = +ic_ +< +MIRBFldTy +&>( +emCڡ +. +GTy +()). +GFldSize +(); + +341 i(! + gbFdWidth +) { + +342 + gfAlign + = +ue +; + +345 i( + gfAlign +) { + +346 + gaggrInOfft + +( +locdBs + + 7) >> 3; + +347 + gfAlign + = +l +; + +349 +ut32 + + gbaFdSz + = +GPrimTySize +( +emCڡ +. +GTy +(). +GPrimTy +()); + +350 +ut32 + + gign + = +locdBs + ? 1 : +baFdSz +; + +351 +ut8 +* + gbaFdAddr + = +GGlobVInAddr +( +pInf +, +ign +); + +353 i( + glocdBs + + + gbFdWidth + > ( + gbaFdSz + * 8)) { + +354 + gbaFdAddr + = +baFdAddr + + +baFdSz +; + +355 +SBFldCڡ +( +baFdAddr +, +baFdSz +, 0, +bFdWidth +, +emCڡ +); + +356 + gaggrInOfft ++ +baFdSz +; + +357 + glocdBs + = +bFdWidth +; + +359 +SBFldCڡ +( +baFdAddr +, +baFdSz +, +locdBs +, +bFdWidth +, +emCڡ +); + +360 + glocdBs + + +bFdWidth +; + +364  + gLmbcMod +:: +InAggCڡ +( +VInf + * +pInf +, +MIRCڡ + & +mCڡ +) { + +365 aut& + gTy + = +ic_ +< +MIRSuTy +&>( +mCڡ +. +GTy +()); + +366 aut& + gaggCڡ + = +ic_ +< +MIRAggCڡ +&>( +mCڡ +); + +367 +bo + + gfAlign + = +l +; + +368 +t32 + + glocdBs + = 0; + +370 +AlignOfft +( +aggrInOfft +, +aggCڡ +. +GTy +(). +GAlign +()); + +371 +MIRTyKd + + gevEmKd + = +kTyUnknown +; + +372  +ut32 + + gi + = 0, + gevInFd + = 0; i < + gaggCڡ +. +GCڡVec +(). +size +(); ++i) { + +373 + gMIRCڡ + & + gemCڡ + = * +aggCڡ +. +GCڡVecIm +( +i +); + +374 + gMIRTy + & + gemTy + = +emCڡ +. +GTy +(); + +378 i( + gevEmKd + = +kTyBFld + && +emTy +. +GKd +() != kTypeBitField) { + +379 +fAlign + = +l +; + +380 i( + glocdBs +) { + +381 + gaggrInOfft + +( +locdBs + + 7) >> 3; + +382 + glocdBs + = 0; + +387 i( + gTy +. +GKd +(! +kTyAay +) { + +388 +CheckUmedBFld +( +Ty +, +evInFd +, +aggCڡ +. +GFldIdIm +( +i +), +locdBs +); + +390  + gemTy +. +GKd +()) { + +391  + gkTySr +: + +392 +InSrCڡ +( +pInf +, +emCڡ +); + +394  + gkTySu +: + +395  +kTyUni +: + +396 +InAggCڡ +( +pInf +, +emCڡ +); + +398  + gkTyAay +: + +399 +InAayCڡ +( +pInf +, +emCڡ +); + +401  + gkTyPor +: + +402 +InPorCڡ +( +pInf +, +emCڡ +); + +404  + gkTyBFld +: { + +405 +InBFldCڡ +( +pInf +, +emCڡ +, +locdBs +, +fAlign +); + +409 +MASSERT +( +l +, " suy %d NYI", +emTy +. +GKd +()); + +413 + gevEmKd + = +emTy +. +GKd +(); + +417  + gLmbcMod +:: +InSrCڡ +( +VInf + * +pInf +, +MIRCڡ + & +mCڡ +) { + +418 +ut8 + * + gd + = +GGlobVInAddr +( +pInf +, +mCڡ +. +GTy +(). +GAlign +()); + +419  + gmCڡ +. +GKd +()) { + +420  + gkCڡI +: + +421 +InICڡ +( +pInf +, +ic_ +< +MIRICڡ +&>( +mCڡ +), +d +); + +423  + gkCڡFltCڡ +: + +424 +InFltCڡ +( +pInf +, +ic_ +< +MIRFltCڡ +&>( +mCڡ +), +d +); + +426  + gkCڡDoubCڡ +: + +427 +InDoubCڡ +( +pInf +, +ic_ +< +MIRDoubCڡ +&>( +mCڡ +), +d +); + +429  + gkCڡSCڡ +: + +430 +InSCڡ +( +pInf +, +ic_ +< +MIRSCڡ +&>( +mCڡ +), +d +); + +432  + gkCڡLblCڡ +: + +433 +InLblCڡ +( +pInf +, +ic_ +< +MIRLblCڡ +&>( +mCڡ +), +d +); + +435  + gkCڡS16Cڡ +: + +436  +kCڡAddrof +: + +437  +kCڡAddrofFunc +: + +439 +MASSERT +( +l +, "SϸCڡ Ty %d NYI", +mCڡ +. +GKd +()); + +442 +UpdeGlobVInAddr +( +pInf +, +mCڡ +. +GTy +(). +GSize +()); + +445  + gLmbcMod +:: +InAayCڡ +( +VInf + * +pInf +, +MIRCڡ + & +mCڡ +) { + +446 + gMIRAayTy + & + gyTy + = +ic_ +< +MIRAayTy +&>( +mCڡ +. +GTy +()); + +447 + gMIRAggCڡ + & + gyCt + = +ic_ +< +MIRAggCڡ +&>( +mCڡ +); + +448 +AlignOfft +( +aggrInOfft +, +yTy +. +GAlign +()); + +450 +size_t + + guNum + = +yCt +. +GCڡVec +(). +size +(); + +451 +ut32 + + gdim + = +yTy +. +GSizeAayIm +(0); + +452 +TyIdx + + gsrIdx + = +yTy +. +GEmTyIdx +(); + +453 +MIRTy + * + gsubTy + = +GlobTabs +:: +GTyTab +(). +GTyFromTyIdx +( +srIdx +); + +454 i( + guNum + =0 && +dim + != 0) { + +455  +subTy +-> +GKd +(= +kTyAay +) { + +456 +MIRAayTy + * +aSubTy + = +ic_ +( +subTy +); + +457 i( + gaSubTy +-> +GSizeAayIm +(0) > 0) { + +458 + gdim + *( +aSubTy +-> +GSizeAayIm +(0)); + +460 + gsrIdx + = +aSubTy +-> +GEmTyIdx +(); + +461 + gsubTy + = +GlobTabs +:: +GTyTab +(). +GTyFromTyIdx +( +srIdx +); + +464  +size_t + + gi + = 0; i < + guNum +; ++i) { + +465 +MIRCڡ + * + gemCڡ + = +yCt +. +GCڡVecIm +( +i +); + +466 i( +IsPrimiveVe +( +subTy +-> +GPrimTy +())) { + +467 +MASSERT +( +l +, "Unexpectedrimitive vector"); + +468 } i( +IsPrimiveSr +( +emCڡ +-> +GTy +(). +GPrimTy +())) { + +469 +bo + + grL + = +l +; + +470 i( + gyTy +. +GDim +() == 1) { + +471 +MIRTy + * +y + = +yTy +. +GEmTy +(); + +472 i( + gy +-> +GPrimTy +(= +PTY_i8 + || +y +->GPrimTy(= +PTY_u8 +) { + +473 +rL + = +ue +; + +476 +InSrCڡ +( +pInf +, * +emCڡ +); + +477 } i( + gemCڡ +-> +GTy +(). +GKd +(= +kTyAay +) { + +478 +InAayCڡ +( +pInf +, * +emCڡ +); + +479 } i( + gemCڡ +-> +GTy +(). +GKd +(= +kTySu + || + +480 +emCڡ +-> +GTy +(). +GKd +(= +kTyCss + || + +481 +emCڡ +-> +GTy +(). +GKd +(= +kTyUni +) { + +482 +InAggCڡ +( +pInf +, * +emCڡ +); + +486 +ASSERT +( +l +, "shouldotun here"); + +491  + gLmbcMod +:: +InAddrofCڡ +( +VInf + * +pInf +, +MIRAddrofCڡ + & +addrofCڡ +, +ut8 +* +d +) { + +492 +StIdx + + gIdx + = +addrofCڡ +. +GSymbIndex +(); + +493 +t32 + + gofft + = +addrofCڡ +. +GOfft +(); + +494 +ut8 + * + gaddr + = +pInf +-> +sym +-> +IsPUStic +(? +GVAddr +Inf-> +puIdx +, +Idx +) : GetVarAddr(stIdx); + +495 *( + gut8 +**) + gd + = +addr + + +offt +; + +498  + gLmbcMod +:: +InGlobVb +( +VInf + * +pInf +) { + +499 +MIRCڡ + * +mCڡ + = +pInf +-> +sym +-> +GKڡ +(); + +500 +ut8 + * + gd + = +GGlobVInAddr +( +pInf +, +mCڡ +-> +GTy +(). +GAlign +()); + +502  + gmCڡ +-> +GKd +()) { + +503  + gkCڡAggCڡ +: + +504 +aggrInOfft + = 0; + +505 +InAggCڡ +( +pInf +, * +mCڡ +); + +507  + gkCڡI +: + +508 +InICڡ +( +pInf +, * +ic_ +< +MIRICڡ +*>( +mCڡ +), +d +); + +510  + gkCڡFltCڡ +: + +511 +InFltCڡ +( +pInf +, * +ic_ +< +MIRFltCڡ +*>( +mCڡ +), +d +); + +513  + gkCڡDoubCڡ +: + +514 +InDoubCڡ +( +pInf +, * +ic_ +< +MIRDoubCڡ +*>( +mCڡ +), +d +); + +516  + gkCڡAddrof +: + +517 +InAddrofCڡ +( +pInf +, * +ic_ +< +MIRAddrofCڡ +*>( +mCڡ +), +d +); + +519  + gkCڡSCڡ +: + +520 +InSCڡ +( +pInf +, * +ic_ +< +MIRSCڡ +*>( +mCڡ +), +d +); + +523 +MASSERT +( +l +, "In MIRCڡy %d NYI", +mCڡ +-> +GKd +()); + +526 +UpdeGlobVInAddr +( +pInf +, +mCڡ +-> +GTy +(). +GSize +()); + +529  + gLmbcMod +:: +InGlobVs +() { + +531 +this +-> +globs + = ( +ut8 +*) +mloc +his-> +globsSize +); + +532 + gthis +-> + gglobSticMem + = ( +ut8 +*) +mloc +( +this +-> +globSticMemSize +); + +533 +memt +( +this +-> +globs +, 0,his-> +globsSize +); + +534 +memt +( +this +-> +globSticMem +, 0,his-> +globSticMemSize +); + +537 cڡut + g + : +globAndSticVs +) { + +538 +VInf + * +pInf + = + +. +cd +; + +539 i( + gpInf +-> + gsym +-> +IsCڡ +()) { + +540 +InGlobVb +( +pInf +); + +545 +le +  + gLmbcMod +:: +AddGlobV +( +MIRSymb + & +sym +, +VInf + * +pInf +) { + +546 + gglobAndSticVs +[ +sym +. +GStIdx +(). +FuIdx +()] = +pInf +; + +549 +le +  + gLmbcMod +:: +AddPUSticV +( +PUIdx + +puIdx +, +MIRSymb + & +sym +, +VInf + * +pInf +) { + +550 + gglobAndSticVs +[( +ut64 +) +puIdx + << 32 | +sym +. +GStIdx +(). +FuIdx +()] = +pInf +; + +554 +ut8 + * + gLmbcMod +:: +GVAddr +( +StIdx + +Idx +) { + +555 aut + + = +globAndSticVs +. +fd +( +Idx +. +FuIdx +()); + +556 +MASSERT +( + + ! +globAndSticVs +. +d +(), "global varot found"); + +557  + gglobs + + + g +-> + gcd +-> + geIdx +; + +561 +ut8 + * + gLmbcMod +:: +GVAddr +( +PUIdx + +puIdx +, +StIdx + +Idx +) { + +562 aut + g + = +globAndSticVs +. +fd +(() +puIdx + << 32 | +Idx +. +FuIdx +()); + +563 +MASSERT +( + + ! +globAndSticVs +. +d +(), "PUStatic varot found"); + +564  + gglobs + + + g +-> + gcd +-> + geIdx +; + +567 +LmbcFunc +* + +568 + gLmbcMod +:: +LkupLmbcFunc +( +PUIdx + +puIdx +) { + +569 aut + + = +funcM +. +fd +( +puIdx +); + +570  + g + = +funcM +. +d +()? +nuαr +: + +-> +cd +; + +573 + gFuncAddr +:: +FuncAddr +( +bo + +lmbcFunc +, * +func +, +d +:: +rg + +me +, +ut32 + +fmsAggSz +) { + +574 + gfuncName + = +me +; + +575 + gisLmbcFunc + = +lmbcFunc +; + +576 + gfmsAggSize + = +fmsAggSz +; + +577 i( + gisLmbcFunc +) { + +578 + gfuncP +. + glmbcFunc + = ( +LmbcFunc +*) +func +; + +580 + gfuncP +. + gtiveFunc + = +func +; + +585 +ut32 + +GAggFmsSize +( +MIRFuni + * +func +) { + +586 +ut32 + + gtٮSize + = 0; + +587 + gMVe +< + gFmDef +> & + gfmDefVec + = +func +-> +GFmDefVec +(); + +588  + gi + = 0; i < + gfmDefVec +. +size +(); i++) { + +589 +MIRTy +* + gty + = +GlobTabs +:: +GTyTab +(). +GTyFromTyIdx +( +fmDefVec +[ +i +]. +fmTyIdx +); + +590 i( + gty +-> +GPrimTy +(= +PTY_agg +) { + +591 +tٮSize + + +ty +-> +GSize +(); + +594  + gtٮSize +; + +597 +FuncAddr +* + gLmbcMod +:: +GFuncAddr +( +PUIdx + +idx +) { + +598 +FuncAddr + * +ddr +; + +599 i( + gPUIdx2FuncAddr +[ +idx +]) { + +600  + gPUIdx2FuncAddr +[ +idx +]; + +602 +MIRFuni + * + gfunc + = +GlobTabs +:: +GFuniTab +(). +GFuniFromPuidx +( +idx +); + +603 +MASSERT +( +func +, "Functionot found in globalable"); + +604 i( +IsExtFunc +( +idx +, * +this +)) { + +605 + gddr + = +w + +FuncAddr +( +l +, +FdExtFunc +( +idx +), +func +-> +GName +(), +GAggFmsSize +(func)); + +607 + gddr + = +w + +FuncAddr +( +ue +, +LkupLmbcFunc +( +idx +), +func +-> +GName +()); + +609 + gPUIdx2FuncAddr +[ +idx +] = +ddr +; + +610  + gddr +; + + @lmbc/src/invoke_method.cpp + +15  + ~ + +16  + ~ + +17  + ~ + +18  + ~ + +19  + ~ + +21  + ~"mvue.h +" + +22  + ~"mimty.h +" + +23  + ~"mfuni.h +" + +24  + ~"mexessi.h +" + +26  + ~"codes.h +" + +27  + ~"mas.h +" + +29 +mea + + gm + { + +31 +thad_lol + +ut32 + + g__code_t + = 0; + +32 "C" +ut32 + +__c_code_t +() { + +33  ++ +__code_t +; + +36 cڡ * +tyr +( +PrimTy + +t + +__ibu +(( +unud +)); + +37 cڡ * +tyr +( +PrimTy + +t +) { + +38  + gt +) { + +39  + gPTY_i8 +:  " i8"; + +40  + gPTY_i16 +:  "i16"; + +41  + gPTY_i32 +:  "i32"; + +42  + gPTY_i64 +:  "i64"; + +43  + gPTY_u8 +:  " u8"; + +44  + gPTY_u16 +:  "u16"; + +45  + gPTY_u32 +:  "u32"; + +46  + gPTY_u64 +:  "u64"; + +47  + gPTY_a64 +:  "a64"; + +48  + gPTY_f32 +:  "f32"; + +49  + gPTY_f64 +:  "f64"; + +50  + gPTY_void +:  "---"; + +51  + gkPtyInvid +:  "INV"; + +56 +t64 + +MV2I64 +( +MVue + & +v +) { + +57  + gv +. + gyp +) { + +58  + gPTY_i64 +: + +59  +v +. +x +. +i64 +; + +60  + gPTY_i32 +: + +61  ( +t64 +) +v +. +x +. +i32 +; + +62  + gPTY_i16 +: + +63  ( +t64 +) +v +. +x +. +i16 +; + +64  + gPTY_i8 +: + +65  ( +t64 +) +v +. +x +. +i8 +; + +66  + gPTY_u32 +: + +67  ( +t64 +) +v +. +x +. +u32 +; + +69 +MASSERT +( +l +, "MVuty %d f i64 cvsi NYI", +v +. +yp +); + +73  + #MMASK1 + 0xffu + + ) + +74  + #MMASK2 + 0xffffu + + ) + +75  + #MMASK3 + 0xffffffffu + + ) + +77  +mld +( +ut8 +* +addr +, +PrimTy + +yp +, +MVue +& +s +, +size_t + +aggSize +=0) { + +78 +s +. +yp + =typ; + +79  + gyp +) { + +80  + gPTY_i8 +: + +81 +s +. +x +. +i64 + = *( +t8 + *) +addr +; + +83  + gPTY_i16 +: + +84 +s +. +x +. +i64 + = *( +t16 + *) +addr +; + +86  + gPTY_i32 +: + +87 +s +. +x +. +i64 + = *( +t32 + *) +addr +; + +89  + gPTY_i64 +: + +90 +s +. +x +. +i64 + = *( +t64 + *) +addr +; + +92  + gPTY_u8 +: + +93 +s +. +x +. +u64 + = *( +ut8 + *) +addr +; + +95  + gPTY_u16 +: + +96 +s +. +x +. +u64 + = *( +ut16 + *) +addr +; + +98  + gPTY_u32 +: + +99 +s +. +x +. +u64 + = *( +ut32 + *) +addr +; + +101  + gPTY_u64 +: + +102 +s +. +x +. +u64 + = *( +ut64 + *) +addr +; + +104  + gPTY_f32 +: + +105 +s +. +x +. +f32 + = *(*) +addr +; + +107  + gPTY_f64 +: + +108 +s +. +x +. +f64 + = *(*) +addr +; + +110  + gPTY_a64 +: + +111 +s +. +x +. +a64 + = *( +ut8 + **) +addr +; + +113  + gPTY_agg +: + +115 +s +. +x +. +a64 + = +addr +; + +116 + gs +. + gaggSize + = +aggSize +; + +119 +MASSERT +( +l +, "mldty%d NYI", +yp +); + +124  +me +( +ut8 +* +addr +, +PrimTy + +yp +, +MVue +& +v +, +bo + +toVArgSck + = +l +) { + +125 i(! +IsPrimiveIeg +( +yp +|| !IsPrimiveIeg( +v +.ptyp)) { + +126 +MASSERT +( +yp + = +v +.ptyp || + +127 +yp + = +PTY_a64 + && +v +.y= +PTY_u64 + || + +128 +yp + = +PTY_u64 + && +v +.y= +PTY_a64 +, + +129 "mܐty mismch: %dnd %d", +yp +, +v +.ptyp); + +131  + gyp +) { + +132  + gPTY_i8 +: + +133 *( +t8 + *) +addr + = +v +. +x +. +i8 +; + +135  + gPTY_i16 +: + +136 *( +t16 + *) +addr + = +v +. +x +. +i16 +; + +138  + gPTY_i32 +: + +139 *( +t32 + *) +addr + = +v +. +x +. +i32 +; + +141  + gPTY_i64 +: + +142 *( +t64 + *) +addr + = +v +. +x +. +i64 +; + +144  + gPTY_u8 +: + +145 *( +ut8 + *) +addr + = +v +. +x +. +u8 +; + +147  + gPTY_u16 +: + +148 *( +ut16 + *) +addr + = +v +. +x +. +u16 +; + +150  + gPTY_u32 +: + +151 *( +ut32 + *) +addr + = +v +. +x +. +u32 +; + +153  + gPTY_u64 +: + +154 *( +ut64 + *) +addr + = +v +. +x +. +u64 +; + +156  + gPTY_f32 +: + +157 *(*) +addr + = +v +. +x +. +f32 +; + +159  + gPTY_f64 +: + +160 *(*) +addr + = +v +. +x +. +f64 +; + +162  + gPTY_a64 +: + +163 *( +ut8 + **) +addr + = +v +. +x +. +a64 +; + +165  + gPTY_agg +: + +166 i( +toVArgSck +) { + +167 i( +v +. +aggSize + > 16) { + +168 *( +ut8 + **) +addr + = +v +. +x +. +a64 +; + +170 +memy +( +addr +, +v +. +x +. +a64 +, v. +aggSize +); + +174 +MASSERT +( +v +. +aggSize + <= 16, "mstoregg > 16"); + +175 +memy +( +addr +, &( +v +. +x +. +u64 +), v. +aggSize +); + +179 +MASSERT +( +l +, "mܐy%d NYI", +yp +); + +184 +bo + +IsZo +( +MVue +& +cd +) { + +185  + gcd +. + gyp +) { + +186  + gPTY_u8 +:  +cd +. +x +. +u8 + == 0; + +187  + gPTY_u16 +:  +cd +. +x +. +u16 + == 0; + +188  + gPTY_u32 +:  +cd +. +x +. +u32 + == 0; + +189  + gPTY_u64 +:  +cd +. +x +. +u64 + == 0; + +190  + gPTY_i8 +:  +cd +. +x +. +i8 + == 0; + +191  + gPTY_i16 +:  +cd +. +x +. +i16 + == 0; + +192  + gPTY_i32 +:  +cd +. +x +. +i32 + == 0; + +193  + gPTY_i64 +:  +cd +. +x +. +i64 + == 0; + +194 : +MASSERT +( +l +, "IsZty %d NYI", +cd +. +yp +); + +198 +bo + + +199 +RegAssignZextOrSext +( +MVue +& +om +, +PrimTy + +toTyp +, MVue& +to +) { + +200  + gtoTyp +) { + +201  + gPTY_u8 +: + +202  +om +. +yp +) { + +203  +PTY_u32 +: +to +. +x +. +u8 + = +om +.x. +u32 +; ; + +204 :  +l +; + +207  + gPTY_u32 +: + +208  +om +. +yp +) { + +209  +PTY_u8 +: +to +. +x +. +u64 + = +om +.x. +u8 +; ; + +210  + gPTY_u16 +: +to +. +x +. +u64 + = +om +.x. +u16 +; ; + +211  + gPTY_i32 +: +to +. +x +. +u64 + = +om +.x. +i32 +; ; + +212 :  +l +; + +215  + gPTY_i32 +: + +216  +om +. +yp +) { + +217  +PTY_i8 +: +to +. +x +. +i64 + = +om +.x. +i8 +; ; + +218  + gPTY_i16 +: +to +. +x +. +i64 + = +om +.x. +i16 +; ; + +219  + gPTY_u32 +: +to +. +x +. +i64 + = +om +.x. +u32 +; ; + +220 :  +l +; + +223  + gPTY_u64 +: + +224  +om +. +yp +) { + +225  +PTY_u8 +: +to +. +x +. +u64 + = +om +.x. +u8 +; ; + +226  + gPTY_u16 +: +to +. +x +. +u64 + = +om +.x. +u16 +; ; + +227  + gPTY_u32 +: +to +. +x +. +u64 + = +om +.x. +u32 +; ; + +228  + gPTY_i64 +: +to +. +x +. +u64 + = +om +.x. +i64 +; ; + +229 :  +l +; + +232  + gPTY_i64 +: + +233  +om +. +yp +) { + +234  +PTY_i8 +: +to +. +x +. +i64 + = +om +.x. +i8 +; ; + +235  + gPTY_i16 +: +to +. +x +. +i64 + = +om +.x. +i16 +; ; + +236  + gPTY_i32 +: +to +. +x +. +i64 + = +om +.x. +i32 +; ; + +237 :  +l +; + +240  + gPTY_i16 +: + +241  +om +. +yp +) { + +242  +PTY_i32 +: +to +. +x +. +i16 + = +om +.x. +i32 +; ; + +243  + gPTY_u16 +: +to +. +x +. +i16 + = +om +.x. +u16 +; ; + +244 :  +l +; + +247  + gPTY_u16 +: + +248  +om +. +yp +) { + +249  +PTY_u32 +: +to +. +x +. +u16 + = +om +.x. +i32 +; ; + +250 :  +l +; + +254  +l +; + +257 + gto +. + gyp + = +toTyp +; + +258  + gue +; + +261  + #CASE_TOPTYP +( +toPtyp +, +toCtyp +) \ + +262  +PTY_ +## +toPtyp +: \ + +263 i( +cvtI + +s +. +x +. +toPtyp + = ( +toCtyp +) +omI +; \ + +264 i( +cvtUt + +s +. +x +. +toPtyp + = ( +toCtyp +) +omUt +; \ + +265 i( +cvtf32 + +s +. +x +. +toPtyp + = ( +toCtyp +) +omFlt +; \ + +266 i( +cvtf64 + +s +. +x +. +toPtyp + = ( +toCtyp +) +omDoub +; \ + +267 ; + + ) + +269 +MVue + +CvtTy +(MVu& +nd +, +PrimTy + +toPtyp +, PrimTy +omPtyp +) { + +270 +MVue + + gs +; + +271 +t64 + + gomI +; + +272 +ut64 + + gomUt +; + +273  + gomFlt +; + +274  + gomDoub +; + +275 +bo + + gcvtI + = +l +; + +276 +bo + + gcvtUt + = +l +; + +277 +bo + + gcvtf32 + = +l +; + +278 +bo + + gcvtf64 + = +l +; + +280 i( + gnd +. + gyp + = +toPtyp +) { + +281  +nd +; + +283  + gomPtyp +) { + +284  + gPTY_i8 +: +omI + = +nd +. +x +. +i8 +; + gcvtI + = +ue +; ; + +285  + gPTY_i16 +: +omI + = +nd +. +x +. +i16 +; + gcvtI + = +ue +; ; + +286  + gPTY_i32 +: +omI + = +nd +. +x +. +i32 +; + gcvtI + = +ue +; ; + +287  + gPTY_i64 +: +omI + = +nd +. +x +. +i64 +; + gcvtI + = +ue +; ; + +288  + gPTY_u8 +: +omUt + = +nd +. +x +. +u8 +; + gcvtUt + +ue +; ; + +289  + gPTY_u16 +: +omUt + = +nd +. +x +. +u16 +; + gcvtUt + +ue +; ; + +290  + gPTY_u32 +: +omUt + = +nd +. +x +. +u32 +; + gcvtUt + +ue +; ; + +291  + gPTY_u64 +: +omUt + = +nd +. +x +. +u64 +; + gcvtUt + +ue +; ; + +292  + gPTY_a64 +: +omUt + = +nd +. +x +. +u64 +; + gcvtUt + +ue +; ; + +293  + gPTY_r +: +omUt + = +nd +. +x +. +u64 +; + gcvtUt + +ue +; ; + +294  + gPTY_f32 +: +omFlt + = +nd +. +x +. +f32 +; + gcvtf32 + = +ue +; ; + +295  + gPTY_f64 +: +omDoub + +nd +. +x +. +f64 +; + gcvtf64 + = +ue +; ; + +296 : +MASSERT +( +l +, "OP_cvomty%d NYI", +omPtyp +); ; + +298  + gtoPtyp +) { + +299 +CASE_TOPTYP +( +i8 +, +t8 +) + +300 +CASE_TOPTYP +( +i16 +, +t16 +) + +301 +CASE_TOPTYP +( +i32 +, +t32 +) + +302 +CASE_TOPTYP +( +i64 +, +t64 +) + +303 +CASE_TOPTYP +( +u8 +, +ut8 +) + +304 +CASE_TOPTYP +( +u16 +, +ut16 +) + +305 +CASE_TOPTYP +( +u32 +, +ut32 +) + +306 +CASE_TOPTYP +( +u64 +, +ut64 +) + +307 +CASE_TOPTYP +( +f32 +, ) + +308 +CASE_TOPTYP +( +f64 +, ) + +309  + gPTY_a64 +: + +310 i( +cvtI +) + +311 +s +. +x +. +a64 + = ( +ut8 +*) +omI +; + +312 i( + gcvtUt +) + +313 + gs +. + gx +. + ga64 + = ( +ut8 +*) +omUt +; + +315 +MASSERT +( +l +, "OP_cvt:y %d%d su܋d", +omPtyp +, +toPtyp +); + +317 : +MASSERT +( +l +, "OP_cvt:y %d%d NYI", +omPtyp +, +toPtyp +); + +319 + gs +. + gyp + = +toPtyp +; + +320  + gs +; + +324 +LdArgs +( +MFuni +& +func +) { + +325  + gi +=0; i < + gfunc +. + gfo +-> + gfmsNum +; ++i) { + +326 i( + gfunc +. + gfo +-> + gpos2Pm +[ +i +]-> + gisPg +) { + +327 + gfunc +. + gpRegs +[ +func +. +fo +-> +pos2Pm +[ +i +]-> + geIdx +] = func. +Δ +-> +Args +[i]; + +329 + gfunc +. + gfmVs +[ +func +. +fo +-> +pos2Pm +[ +i +]-> + geIdx +] = func. +Δ +-> +Args +[i]; + +334 +bo + +ComFlt +( +x +,  +y +,  +s + = 0.00000001f) { + +335 i( +isf +( +x +&& isf( +y +)) { + +336  +ue +; + +338  ( +bs +( +x + - +y +< + gs +? + gue + : +l +; + +341 +le + +bo + +ComDoub +( +x +,  +y +,  +s + = 0.0000000000000001f) { + +342 i( +isf +( +x +&& isf( +y +)) { + +343  +ue +; + +345  ( +bs +( +x + - +y +< + gs +? + gue + : +l +; + +348  +HdFltEq +( +Opcode + + +, +PrimTy + +ndTy +, +MVue + & +s +, MVu& +1 +, MVu& +2 +) { + +349 +MASSERT +( +ndTy + = +1 +. +yp + && op1.y= +2 +.ptyp, "Operandype mismatch %d %d", op1.ptyp, op2.ptyp); + +350  + g +) { + +351  + gOP_ +: + +352 i( +ndTy + = +PTY_f32 +) { + +353 +s +. +x +. +i64 + = ! +ComFlt +( +1 +.x. +f32 +, +2 +.x.f32); + +354 } i( + gndTy + = +PTY_f64 +) { + +355 +s +. +x +. +i64 + = ! +ComDoub +( +1 +.x. +f64 +, +2 +.x.f64); + +357 +MASSERT +( +l +, "Unexpectedype"); + +360  + gOP_eq +: + +361 i( +ndTy + = +PTY_f32 +) { + +362 +s +. +x +. +i64 + = +ComFlt +( +1 +.x. +f32 +, +2 +.x.f32); + +363 } i( + gndTy + = +PTY_f64 +) { + +364 +s +. +x +. +i64 + = +ComDoub +( +1 +.x. +f64 +, +2 +.x.f64); + +366 +MASSERT +( +l +, "Unexpectedype"); + +374 +ut32 + +GVaArgSize +( +MFuni + & +Δ +,  +numArgs +, +LmbcFunc + * +Info +) { + +375 +ut32 + + gvaArgSize + = 0; + +376  + gi + = +Info +-> +fmsNum +; i < + gnumArgs +; ++i) { + +377 i( + gΔ +. + gArgs +[ +i +]. + gyp + ! +PTY_agg + || +Δ +. +Args +[i]. +aggSize + > 16 ) { + +378 +vaArgSize + += 8; + +380 + gvaArgSize + + +Δ +. +Args +[ +i +]. +aggSize +; + +383  + gvaArgSize +; + +386  +SupVaArg +( +MFuni + & +Δ +,  +numArgs +, +LmbcFunc + * +Info +) { + +387  + gi + = +Info +-> +fmsNum +, + gofft + = 0; i < + gnumArgs +; ++i) { + +388 +me +( +Δ +. +vaArgs + + +offt +, cr. +Args +[ +i +]. +yp +, cr.Args[i], +ue +); + +389 i( + gΔ +. + gArgs +[ +i +]. + gyp + ! +PTY_agg + || +Δ +. +Args +[i]. +aggSize + > 16 ) { + +390 +offt + += 8; + +392 + gofft + + +Δ +. +Args +[ +i +]. +aggSize +; + +398 +MVue + +InvokeFunc +( +LmbcFunc +* + +, +MFuni + * +Δ +) { + +399 +MVue + + gtV +; + +400 +MVue + + gegs +[ + +-> +numPgs +]; + +401 +MVue + + gfmVs +[ + +-> +fmsNumVs ++1]; + +402 +igs +(8 +ut8 + + game +[ + +-> +ameSize +]; + +403 +MFuni + +mfunc +( + +, +Δ +, +ame +, +egs +, +fmVs +); + +405 * cڡ + gbs +[] = { + +406 && +b_OP_Undef +, + +407  + #OPCODE +( +ba_node +, +dummy1 +, +dummy2 +, +dummy3 +&& +b_OP_ +##ba_node, + + ) + +408  + ~"codes.def +" + +409 #unde +OPCODE + + +410 && +b_OP_Undef + + +413 +LdArgs +( +mfunc +); + +414 + gmfunc +. + gloMem + = +ic_ +< +ut8 +*>( +lo +( +ALLOCA_MEMMAX +)); + +416 +StmtNode + * + gmt + = +mfunc +. +xtStmt +; + +417 *( + gbs +[ +mt +-> + +]); + +419 + gb_OP_Undef +: + +421 +MASSERT +( +l +, "Hit OP_undef"); + +423 + gb_OP_block +: + +425 +mt + = +ic_ +< +BlockNode +*>(mt)-> +GF +(); + +426 + gmfunc +. + gxtStmt + = +mt +; + +427 *( + gbs +[ +mt +-> + +]); + +429 + gb_OP_ssignoff +: + +431 +IassignFPoffNode +* +node + = +ic_ +( +mt +); + +432 +t32 + + gofft + +node +-> +GOfft +(); + +433 +BaNode +* + grhs + = +node +-> +GRHS +(); + +434 +MVue + + gv + = +EvEx +( +mfunc +, +rhs +); + +435 +PrimTy + + gyp + = +node +-> +yp +; + +436 +me +( +mfunc +. + ++ +offt +, +yp +, +v +); + +438 + gmt + = +mt +-> +GNext +(); + +439 + gmfunc +. + gxtStmt + = +mt +; + +440 *( + gbs +[ +mt +-> + +]); + +441 + gb_OP_ +: + +443 +ClNode + * + + = +ic_ +( +mt +); + +444 +MVue + + gArgs +[ + +-> +NumOds +()]; + +445 + gmfunc +. + gArgs + = +Args +; + +446 + gmfunc +. + gnumClArgs + = + +-> +NumOds +(); + +447 i( +IsExtFunc +( + +-> +GPUIdx +(), * +mfunc +. +fo +-> +lmbcMod +)) { + +448 + gmfunc +. +ClExtFuncDe +( + +); + +450 + gmfunc +. +ClMFuncDe +( + +); + +453 + gmt + = +mt +-> +GNext +(); + +454 + gmfunc +. + gxtStmt + = +mt +; + +455 *( + gbs +[ +mt +-> + +]); + +456 + gb_OP_gassign +: + +458 +RegassignNode +* +node + = +ic_ +( +mt +); + +459 +PgIdx + + ggIdx + = +node +-> +GRegIdx +(); + +460 +MVue + + grhs + = +EvEx +( +mfunc +, +node +-> +GRHS +()); + +461 i( + gnode +-> + gyp + = +rhs +. +yp +) { + +462 +MASSERT +( +gIdx + !- +kSgRv1 +, "regassigno %%%%retval1"); + +463 i( + ggIdx + =- +kSgRv0 +) { + +464 i( +node +-> +yp + ! +PTY_agg +) { + +465 +Δ +-> +tV0 + = +rhs +; + +469 +MASSERT +( +rhs +. +aggSize + <= 16, "regassign ofgg >16 byteso %%retval0"); + +470 +ut64 + + gtv +[2] = {0, 0}; + +471 +memy +( +tv +, +rhs +. +x +. +a64 +,hs. +aggSize +); + +472 + gΔ +-> + gtV0 +. + gx +. + gu64 + = +tv +[0]; + +473 + gΔ +-> + gtV0 +. + gyp + = +PTY_agg +; + +474 + gΔ +-> + gtV0 +. + gaggSize + = +rhs +. +aggSize +; + +475 i( + grhs +. + gaggSize + > 8) { + +476 + gΔ +-> + gtV1 +. + gx +. + gu64 + = +tv +[1]; + +477 + gΔ +-> + gtV1 +. + gyp + = +PTY_agg +; + +478 + gΔ +-> + gtV1 +. + gaggSize + +rhs +. +aggSize +; + +482 +MASSERT +( +gIdx + < + +-> +numPgs +, "regassignegIdx %d out of bound",egIdx); + +483 + gmfunc +. + gpRegs +[ +gIdx +] = +rhs +; + +486 +bo + + gexnded + = +l +; + +487 i( + ggIdx + =- +kSgRv0 +) { + +488 +exnded + = +RegAssignZextOrSext +( +rhs +, +node +-> +yp +, +Δ +-> +tV0 +); + +489 } i( + ggIdx + =- +kSgRv1 +) { + +490 +exnded + = +RegAssignZextOrSext +( +rhs +, +node +-> +yp +, +Δ +-> +tV1 +); + +492 +MASSERT +( +gIdx + < + +-> +numPgs +, "regassignegIdx %d out of bound",egIdx); + +493 + gexnded + = +RegAssignZextOrSext +( +rhs +, +node +-> +yp +, +mfunc +. +pRegs +[ +gIdx +]); + +495 i(! + gexnded +) { + +496 i(( + gnode +-> + gyp + = +PTY_a64 + || +node +-> +yp + = +PTY_u64 +) && + +497 ( +rhs +. +yp + = +PTY_a64 + ||hs.y= +PTY_u64 +)) { + +498 +mfunc +. +pRegs +[ +gIdx +] = +rhs +; + +499 + gmfunc +. + gpRegs +[ +gIdx +]. + gyp + = +node +-> +yp +; + +502 + gmfunc +. + gpRegs +[ +gIdx +] = +CvtTy +( +rhs +, +node +-> +yp +,hs.ptyp); + +507 + gmt + = +mt +-> +GNext +(); + +508 + gmfunc +. + gxtStmt + = +mt +; + +509 *( + gbs +[ +mt +-> + +]); + +510 + gb_OP_brl +: + +511 +b_OP_brue +: + +513 +CdGoNode +* +node + = +ic_ +( +mt +); + +514 +ut32 + + gbIdx + = +node +-> +GOfft +(); ()labelIdx; + +515 +MVue + + gcd + = +EvEx +( +mfunc +, +node +-> +GRHS +()); + +516 +StmtNode +* + gb + = + +-> +bM +[ +bIdx +]; + +517 i( + gmt +-> + g + = +OP_brl + && +IsZo +( +cd +) +mt + = +b +; + +518 i( + gmt +-> + g + = +OP_brue + && ! +IsZo +( +cd +) +mt + = +b +; + +520 + gmt + = +mt +-> +GNext +(); + +521 + gmfunc +. + gxtStmt + = +mt +; + +522 *( + gbs +[ +mt +-> + +]); + +523 + gb_OP_b +: + +525 +mt + = stmt-> +GNext +(); + +526 + gmfunc +. + gxtStmt + = +mt +; + +527 *( + gbs +[ +mt +-> + +]); + +528 + gb_OP_go +: + +530 +ut32 + +bIdx + = +ic_ +< +GoNode +*>( +mt +)-> +GOfft +(); + +531 +StmtNode +* + gb + = + +-> +bM +[ +bIdx +]; + +532 + gmt + = +b +; + +534 + gmt + = +mt +-> +GNext +(); + +535 + gmfunc +. + gxtStmt + = +mt +; + +536 *( + gbs +[ +mt +-> + +]); + +537 + gb_OP_tu +: + +538  +Δ +-> +tV0 +; + +539 + gb_OP_ssignoff +: + +541 +IassignoffNode +* +node + = +ic_ +( +mt +); + +542 +t32 + + gofft + = +node +-> +GOfft +(); + +543 +MVue + + gaddr + = +EvEx +( +mfunc +, +node +-> +Od +(0)); + +544 +MVue + + grhs + = +EvEx +( +mfunc +, +node +-> +Od +(1)); + +545 +me +( +addr +. +x +. +a64 + + +offt +, +mt +-> +yp +, +rhs +); + +547 + gmt + = +mt +-> +GNext +(); + +548 + gmfunc +. + gxtStmt + = +mt +; + +549 *( + gbs +[ +mt +-> + +]); + +550 + gb_OP_blkassignoff +: + +552 +BlkassignoffNode +* +node + = +ic_ +( +mt +); + +554 +t32 + + gdOfft + = +node +-> +offt +; + +555 +t32 + + gblkSize + = +node +-> +blockSize +; + +556 +MVue + + gdAddr + = +EvEx +( +mfunc +, +node +-> +Od +(0)); + +557 +MVue + + gcAddr + = +EvEx +( +mfunc +, +node +-> +Od +(1)); + +558 +memy +( +dAddr +. +x +. +a64 + + +dOfft +, +cAddr +.x.a64, +blkSize +); + +560 + gmt + = +mt +-> +GNext +(); + +561 + gmfunc +. + gxtStmt + = +mt +; + +562 *( + gbs +[ +mt +-> + +]); + +563 + gb_OP_iδo +: + +565 +INode + * +iδo + = +ic_ +( +mt +); + +566 +MASSERT +( +iδo +-> +NumOds +() > 0, "icallprotoum operands is %ld", icallproto->NumOpnds()); + +568 +MVue + + gArgs +[ +iδo +-> +NumOds +()-1]; + +569 + gmfunc +. + gArgs + = +Args +; + +570 + gmfunc +. + gnumClArgs + = +iδo +-> +NumOds +()-1; + +572 +MVue + + gAddr + = +EvEx +( +mfunc +, +iδo +-> +Od +(0)); + +573 +FuncAddr + * + gddr + = +t_ +( +Addr +. +x +. +a64 +); + +574 i( + gddr +-> + gisLmbcFunc +) { + +575 + gmfunc +. +ClMFuncInde +( +iδo +, +ddr +-> +funcP +. +lmbcFunc +); + +577 + gmfunc +. +ClExtFuncInde +( +iδo +, +ddr +-> +funcP +. +tiveFunc +); + +580 + gmt + = +mt +-> +GNext +(); + +581 + gmfunc +. + gxtStmt + = +mt +; + +582 *( + gbs +[ +mt +-> + +]); + +583 + gb_OP_ngego +: + +585 +RgeGoNode + * +rgo + = +ic_ +( +mt +); + +586 +t32 + + ggOfft + = +rgo +-> +GTagOfft +(); + +587 +MVue + + gnd + = +EvEx +( +mfunc +, +rgo +-> +Od +(0)); + +588 +t64 + + gg + = +MV2I64 +( +nd +); + +589 +ut32 + + gbIdx + = +rgo +-> +GRgeGoTabIm +( +g + - +gOfft +). +cd +; + +590 +StmtNode + * + gb + = + +-> +bM +[ +bIdx +]; + +591 + gmt + = +b +; + +593 + gmt + = +mt +-> +GNext +(); + +594 + gmfunc +. + gxtStmt + = +mt +; + +595 *( + gbs +[ +mt +-> + +]); + +596 + gb_OP_igo +: + +598 +MVue + +nd + = +EvEx +( +mfunc +, +mt +-> +Od +(0)); + +599 +StmtNode + * + gb + = (StmtNode*) +nd +. +x +. +a64 +; + +600 + gmt + = +b +; + +602 + gmt + = +mt +-> +GNext +(); + +603 + gmfunc +. + gxtStmt + = +mt +; + +604 *( + gbs +[ +mt +-> + +]); + +605 + gb_OP_sic +: + +607 +mfunc +. +ClIrsic +(* +ic_ +< +IrsicNode +*>( +mt +)); + +609 + gmt + = +mt +-> +GNext +(); + +610 + gmfunc +. + gxtStmt + = +mt +; + +611 *( + gbs +[ +mt +-> + +]); + +613 + gb_OP_dassign +: + +614 +b_OP_pssign +: + +615 +b_OP_maydassign +: + +616 +b_OP_ssign +: + +617 +b_OP_do +: + +618 +b_OP_dowhe +: + +619 +b_OP_if +: + +620 +b_OP_whe +: + +621 +b_OP_swch +: + +622 +b_OP_muiway +: + +623 +b_OP_fܗchem +: + +624 +b_OP_commt +: + +625 +b_OP_ev +: + +626 +b_OP_ +: + +627 +b_OP_lsge +: + +628 +b_OP_ls +: + +629 +b_OP_asge +: + +630 +b_OP_as +: + +631 +b_OP_as +: + +632 +b_OP_tuas +: + +633 +b_OP_assigs +: + +634 +b_OP_abt +: + +635 +b_OP_asnnu +: + +636 +b_OP_assigsnnu +: + +637 +b_OP_asnnu +: + +638 +b_OP_tuasnnu +: + +639 +b_OP_dad +: + +640 +b_OP_d +: + +641 +b_OP_addrof +: + +642 +b_OP_ddrof +: + +643 +b_OP_sizeoy +: + +644 +b_OP_fldsdi +: + +645 +b_OP_y +: + +646 +b_OP_vtu +: + +647 +b_OP_surass +: + +648 +b_OP_r +: + +649 +b_OP_cuom +: + +650 +b_OP_pymphic +: + +651 +b_OP_i +: + +652 +b_OP_ri +: + +653 +b_OP_vtui +: + +654 +b_OP_sicwhty +: + +655 +b_OP_xsic +: + +656 +b_OP_assigd +: + +657 +b_OP_vtuassigd +: + +658 +b_OP_surassassigd +: + +659 +b_OP_rassigd +: + +660 +b_OP_cuomassigd +: + +661 +b_OP_pymphicassigd +: + +662 +b_OP_iassigd +: + +663 +b_OP_riassigd +: + +664 +b_OP_vtuiassigd +: + +665 +b_OP_sicassigd +: + +666 +b_OP_sicwhtyassigd +: + +667 +b_OP_xsicassigd +: + +668 +b_OP_Κt +: + +669 +b_OP_Κssigd +: + +670 +b_OP_vtuΚt +: + +671 +b_OP_vtuΚssigd +: + +672 +b_OP_surassΚt +: + +673 +b_OP_surassΚssigd +: + +674 +b_OP_rΚt +: + +675 +b_OP_rΚssigd +: + +676 +b_OP_jry +: + +677 +b_OP_y +: + +678 +b_OP_ry +: + +679 +b_OP_throw +: + +680 +b_OP_jstch +: + +681 +b_OP_tch +: + +682 +b_OP_ptch +: + +683 +b_OP_fly +: + +684 +b_OP_nury +: + +685 +b_OP_dy +: + +686 +b_OP_ +: + +687 +b_OP_d +: + +688 +b_OP_un +: + +689 +b_OP_dun +: + +690 +b_OP_gosub +: + +691 +b_OP_tsub +: + +692 +b_OP_syn +: + +693 +b_OP_synx +: + +694 +b_OP_deef +: + +695 +b_OP_ef +: + +696 +b_OP_deeet +: + +697 +b_OP_membacque +: + +698 +b_OP_memba +: + +699 +b_OP_membܖd +: + +700 +b_OP_membee +: + +701 +b_OP_doff +: + +702 +b_OP_doff +: + +703 +b_OP_gad +: + +704 +b_OP_addroffunc +: + +705 +b_OP_addroab +: + +706 +b_OP_cڡv +: + +707 +b_OP_cڡr +: + +708 +b_OP_cڡr16 +: + +709 +b_OP_ +: + +710 +b_OP_cvt +: + +711 +b_OP_o +: + +712 +b_OP_ty +: + +713 +b_OP_round +: + +714 +b_OP_unc +: + +715 +b_OP_abs +: + +716 +b_OP_bn +: + +717 +b_OP_ +: + +718 +b_OP_g +: + +719 +b_OP_c +: + +720 +b_OP_sq +: + +721 +b_OP_xt +: + +722 +b_OP_zext +: + +723 +b_OP_lo +: + +724 +b_OP_mloc +: + +725 +b_OP_gcmloc +: + +726 +b_OP_gmloc +: + +727 +b_OP_ackmloc +: + +728 +b_OP_gcmlocjy +: + +729 +b_OP_gmlocjy +: + +730 +b_OP_ackmlocjy +: + +731 +b_OP_sverfunc +: + +732 +b_OP_svevtufunc +: + +733 +b_OP_add +: + +734 +b_OP_sub +: + +735 +b_OP_mul +: + +736 +b_OP_div +: + +737 +b_OP_m +: + +738 +b_OP_ashr +: + +739 +b_OP_lshr +: + +740 +b_OP_shl +: + +741 +b_OP_r +: + +742 +b_OP_max +: + +743 +b_OP_m +: + +744 +b_OP_bd +: + +745 +b_OP_bi +: + +746 +b_OP_bx +: + +747 +b_OP_CG_y_em_add +: + +748 +b_OP_eq +: + +749 +b_OP_ge +: + +750 +b_OP_gt +: + +751 +b_OP_ +: + +752 +b_OP_ +: + +753 +b_OP_ +: + +754 +b_OP_cmp +: + +755 +b_OP_cm +: + +756 +b_OP_cmpg +: + +757 +b_OP_nd +: + +758 +b_OP_li +: + +759 +b_OP_nd +: + +760 +b_OP_ci +: + +761 +b_OP_ +: + +762 +b_OP_sic +: + +763 +b_OP_sicwhty +: + +764 +b_OP_exabs +: + +765 +b_OP_dosbs +: + +766 +b_OP_ssigcoff +: + +767 +b_OP_dpcoff +: + +768 +b_OP_checkpot +: + +769 +b_OP_addrofc +: + +770 +b_OP_asm +: + +771 +b_OP_dadoff +: + +772 +b_OP_addrofoff +: + +773 +b_OP_dassignoff +: + +774 +b_OP_ssignoff +: + +775 +b_OP_iδssigd +: + +777 +MASSERT +( +l +, "NIY"); + +780  + gtV +; + +783 +MVue + +EvEx +( +MFuni +& +func +, +BaNode +* +ex +, +PmInf + * +rm +) { + +784 +MVue + + gs +; + +786 * cڡ + gbs +[] = { + +787 && +b_OP_Undef +, + +788  + #OPCODE +( +ba_node +, +dummy1 +, +dummy2 +, +dummy3 +&& +b_OP_ +##ba_node, + + ) + +789  + ~"codes.def +" + +790 #unde +OPCODE + + +791 && +b_OP_Undef + + +794 *( + gbs +[ +ex +-> + +]); + +795 + gb_OP_Undef +: + +797 +MASSERT +( +l +, "Hit OP_undef"); + +799 + gb_OP_cڡv +: + +801 +MIRCڡ +* +cڡv + = +ic_ +< +CڡvNode +*>( +ex +)-> +GCڡV +(); + +802 +t64 + + gcڡI + = 0; + +803  + gcڡFlt + = 0; + +804  + gcڡDoub + = 0; + +805  + gcڡv +-> +GKd +()) { + +806  + gkCڡI +: + +807 +cڡI + = +ic_ +< +MIRICڡ + *>( +cڡv +)-> +GExtVue +(); + +809  + gkCڡDoubCڡ +: + +810 +cڡDoub + = +ic_ +< +MIRDoubCڡ + *>( +cڡv +)-> +GVue +(); + +812  + gkCڡFltCڡ +: + +813 +cڡFlt + = +ic_ +< +MIRFltCڡ + *>( +cڡv +)-> +GVue +(); + +816 +MASSERT +( +l +, "cڡv kd %d NYI", +cڡv +-> +GKd +()); + +819 +PrimTy + + gyp + = +ex +-> +yp +; + +820  + gyp +) { + +821  + gPTY_i8 +: + +822  +PTY_i16 +: + +823  +PTY_i32 +: + +824  +PTY_i64 +: + +825 +MASSERT +( +cڡv +-> +GKd +(= +kCڡI +, "ptypnd constval kind mismatch"); + +826 + gs +. + gx +. + gi64 + = +cڡI +; + +827 + gs +. + gyp + = +yp +; + +829  + gPTY_u8 +: + +830  +PTY_u16 +: + +831  +PTY_u32 +: + +832  +PTY_u64 +: + +833  +PTY_a64 +: + +834 +MASSERT +( +cڡv +-> +GKd +(= +kCڡI +, "ptypnd constval kind mismatch"); + +835 + gs +. + gx +. + gu64 + = +cڡI +; + +836 + gs +. + gyp + = +yp +; + +838  + gPTY_f32 +: + +839 +MASSERT +( +cڡv +-> +GKd +(= +kCڡFltCڡ +, "ptypnd constval kind mismatch"); + +840 + gs +. + gx +. + gf32 + = +cڡFlt +; + +841 + gs +. + gyp + = +yp +; + +843  + gPTY_f64 +: + +844 +MASSERT +( +cڡv +-> +GKd +(= +kCڡDoubCڡ +, "constvaltypnd kind mismatch"); + +845 + gs +. + gx +. + gf64 + = +cڡDoub +; + +846 + gs +. + gyp + = +yp +; + +849 +MASSERT +( +l +, "y %d f cڡv NYI", +yp +); + +853  + g_ex +; + +855 + gb_OP_add +: + +857 +MVue + +0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +858 +MVue + + g1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +859  + gex +-> + gyp +) { + +860  + gPTY_i8 +: +s +. +x +. +i8 + = +0 +.x.i8 + +1 +.x.i8; ; + +861  + gPTY_i16 +: +s +. +x +. +i16 + = +0 +.x.i16 + +1 +.x.i16; ; + +862  + gPTY_i32 +: +s +. +x +. +i32 + = ( +t64 +) +0 +.x.i32 + (t64) +1 +.x.i32; ; + +863  + gPTY_i64 +: +s +. +x +. +i64 + = ( +ut64 +) +0 +.x.i64 + (ut64) +1 +.x.i64; ; + +864  + gPTY_u8 +: +s +. +x +. +u8 + = +0 +.x.u8 + +1 +.x.u8; ; + +865  + gPTY_u16 +: +s +. +x +. +u16 + = +0 +.x.u16 + +1 +.x.u16; ; + +866  + gPTY_u32 +: +s +. +x +. +u32 + = +0 +.x.u32 + +1 +.x.u32; ; + +867  + gPTY_u64 +: +s +. +x +. +u64 + = +0 +.x.u64 + +1 +.x.u64; ; + +868  + gPTY_a64 +: +s +. +x +. +u64 + = +0 +.x.u64 + +1 +.x.u64; ; + +869  + gPTY_f32 +: +s +. +x +. +f32 + = +0 +.x.f32 + +1 +.x.f32; ; + +870  + gPTY_f64 +: +s +. +x +. +f64 + = +0 +.x.f64 + +1 +.x.f64; ; + +871 : +MIR_FATAL +("Unsu܋d PrimTy %d f by ot %s", +ex +-> +yp +, "+"); + +873 + gs +. + gyp + = +ex +-> +yp +; + +875  + g_ex +; + +877 + gb_OP_sub +: + +879 +MVue + +nd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +880 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +881 +EXPRBINOP +(-, +s +, +nd0 +, +nd1 +, +ex +-> +yp +); + +882  + g_ex +; + +884 + gb_OP_mul +: + +886 +MVue + +nd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +887 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +888 +EXPRBINOP +(*, +s +, +nd0 +, +nd1 +, +ex +-> +yp +); + +889  + g_ex +; + +891 + gb_OP_div +: + +893 +MVue + +nd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +894 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +895 +EXPRBINOP +(/, +s +, +nd0 +, +nd1 +, +ex +-> +yp +); + +896  + g_ex +; + +898 + gb_OP_gad +: + +900 +PgIdx + +gIdx + = +ic_ +< +RegadNode +*>( +ex +)-> +GRegIdx +(); + +901  + ggIdx +) { + +902 -( + gkSgFp +): + +903 +MASSERT +( +ex +-> +yp + = +PTY_a64 +, "regread %%FP with wrongtyp %d",xpr->ptyp); + +904 + gs +. + gx +. + ga64 + = +func +. + +; + +906 -( + gkSgRv0 +): + +907 i( +ex +-> +yp + = +func +. +tV0 +.ptyp) { + +908 +s + = +func +. +tV0 +; + +909 } i( + gex +-> + gyp + = +PTY_agg + || +ex +-> +yp + = +PTY_u64 +) { + +910 +s + = +func +. +tV0 +; + +912 + gs + = +CvtTy +( +func +. +tV0 +, +ex +-> +yp +, func.retVal0.ptyp); + +915 -( + gkSgRv1 +): + +916 +MASSERT +( +ex +-> +yp + = +func +. +tV1 +.ptyp || + +917 ( +ex +-> +yp + = +PTY_agg + ||x->y= +PTY_u64 +), + +918 "gad %%tV0y mismch: %d %d", +ex +-> +yp +, +func +. +tV1 +.ptyp); + +919 + gs + = +func +. +tV1 +; + +921 -( + gkSgGp +): + +922 +MASSERT +( +ex +-> +yp + = +PTY_a64 +, "regread %%GP with wrongtyp %d",xpr->ptyp); + +923 + gs +. + gx +. + ga64 + = +func +. +fo +-> +lmbcMod +-> +globSticMem +; + +926 +MASSERT +( +gIdx + < +func +. +fo +-> +numPgs +, "regreadegIdx %d out of bound",egIdx); + +928 + gs + = +func +. +pRegs +[ +gIdx +]; + +931 + gs +. + gyp + = +ex +-> +yp +; + +932  + g_ex +; + +934 + gb_OP_cڡr +: + +936 +USIdx + +urIdx + = +ic_ +< +CڡrNode +*>( +ex +)-> +GSIdx +(); + +937 aut + g + = +func +. +fo +-> +lmbcMod +-> +globSTbl +. + +( + +938 +d +:: + +< +ut32 +, std:: +rg +>( +urIdx +, +GlobTabs +:: +GUSTab +(). +GSgFromSIdx +(ustrIdx))); + +939 + gs +. + gx +. + gr + = +cڡ_ +<*>( + +. +f +-> +cd +. +c_r +()); + +940 + gs +. + gyp + = +PTY_a64 +; + +941  + g_ex +; + +943 + gb_OP_doff +: + +945 +IadFPoffNode +* +node + = +ic_ +( +ex +); + +946 +t32 + + gofft + = +node +-> +GOfft +(); + +947 i( + gnode +-> + gyp + ! +PTY_agg +) { + +948 +mld +( +func +. + ++ +offt +, +ex +-> +yp +, +s +); + +949  + g_ex +; + +958 i( + gfunc +. + gxtStmt +-> + g + = +OP_ +) { + +960 +MASSERT +( +func +. +aggrArgsBuf + ! +nuαr +, "aggrArgsBuf isull"); + +961 +memy +( +func +. +aggrArgsBuf ++ +rm +-> +eIdx +, func. + ++ +offt +,m-> +size +); + +962 +mld +( +func +. +aggrArgsBuf ++ +rm +-> +eIdx +, +ex +-> +yp +, +s +,m-> +size +); + +964 +mld +( +func +. + ++ +offt +, +ex +-> +yp +, +s +, func. +fo +-> +tSize +); + +966  + g_ex +; + +968 + gb_OP_doff +: + +970 +t32 + +offt + = +ic_ +< +IadoffNode + *>( +ex +)-> +GOfft +(); + +971 +MVue + + grhs + = +EvEx +( +func +, +ic_ +< +IadoffNode + *>( +ex +)-> +Od +(0)); + +972 i( + gex +-> + gyp + = +PTY_agg +) { + +976 +MASSERT +( +rhs +. +yp + = +PTY_a64 +, "ireadoffgg RHSot PTY_agg"); + +977 i( + gfunc +. + gxtStmt +-> + g + = +OP_ +) { + +978 +MASSERT +( +func +. +aggrArgsBuf + ! +nuαr +, "aggrArgsBuf isull"); + +979 +memy +( +func +. +aggrArgsBuf ++ +rm +-> +eIdx +, +rhs +. +x +. +a64 + + +offt +,m-> +size +); + +980 +mld +( +func +. +aggrArgsBuf ++ +rm +-> +eIdx +, +ex +-> +yp +, +s +,m-> +size +); + +982 +MASSERT +( +func +. +xtStmt +-> + + = +OP_gassign +, "ireadoffggot usedsegassigngg opnd"); + +983 +mld +( +rhs +. +x +. +a64 + + +offt +, +ex +-> +yp +, +s +, +func +. +fo +-> +tSize +); + +985  + g_ex +; + +987 +MASSERT +( +rhs +. +yp + = +PTY_a64 + ||hs.y= +PTY_u64 + ||hs.y= +PTY_i64 +, + +988 "dofrhy%d PTY_a64 oPTY_u64", +rhs +. +yp +); + +989 +mld +( +rhs +. +x +. +a64 ++ +offt +, +ex +-> +yp +, +s +); + +990  + g_ex +; + +992 + gb_OP_d +: + +994 +MASSERT +( +func +. +xtStmt +-> + + = +OP_ + && +ex +-> +yp + = +PTY_agg +, "iread unexpected outside call"); + +995 +MVue + + gaddr + = +EvEx +( +func +, +ex +-> +Od +(0)); + +996 +MASSERT +( +func +. +aggrArgsBuf + ! +nuαr +, "aggrArgsBuf isull"); + +997 +memy +( +func +. +aggrArgsBuf ++ +rm +-> +eIdx +, +addr +. +x +. +a64 +,m-> +size +); + +998 +mld +( +func +. +aggrArgsBuf ++ +rm +-> +eIdx +, +ex +-> +yp +, +s +,m-> +size +); + +999  + g_ex +; + +1001 + gb_OP_eq +: + +1003 +PrimTy + +ndTy + = +ic_ +< +ComNode +*>( +ex +)-> +GOdTy +(); + +1004 +MVue + + gnd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1005 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1006 i( + gndTy + = +PTY_f32 + || +ndTy + = +PTY_f64 +) { + +1007 +s +. +yp + = +ex +->ptyp; + +1008 +HdFltEq +( +ex +-> + +, +ndTy +, +s +, +nd0 +, +nd1 +); + +1010 +EXPRCOMPOPNOFLOAT +(==, +s +, +nd0 +, +nd1 +, +ndTy +, +ex +-> +yp +); + +1012  + g_ex +; + +1014 + gb_OP_ +: + +1016 +PrimTy + +ndTy + = +ic_ +< +ComNode +*>( +ex +)-> +GOdTy +(); + +1017 +MVue + + gnd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1018 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1019 i( + gndTy + = +PTY_f32 + || +ndTy + = +PTY_f64 +) { + +1020 +s +. +yp + = +ex +->ptyp; + +1021 +HdFltEq +( +ex +-> + +, +ndTy +, +s +, +nd0 +, +nd1 +); + +1023 +EXPRCOMPOPNOFLOAT +(!=, +s +, +nd0 +, +nd1 +, +ndTy +, +ex +-> +yp +); + +1025  + g_ex +; + +1027 + gb_OP_gt +: + +1029 +PrimTy + +ndTyp + +ic_ +< +ComNode +*>( +ex +)-> +GOdTy +(); + +1030 +MVue + + gnd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1031 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1032 +EXPRCOMPOP +(>, +s +, +nd0 +, +nd1 +, +ndTyp +, +ex +-> +yp +); + +1033  + g_ex +; + +1035 + gb_OP_ge +: + +1037 +PrimTy + +ndTyp + +ic_ +< +ComNode +*>( +ex +)-> +GOdTy +(); + +1038 +MVue + + gnd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1039 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1040 +EXPRCOMPOP +(>=, +s +, +nd0 +, +nd1 +, +ndTyp +, +ex +-> +yp +); + +1041  + g_ex +; + +1043 + gb_OP_ +: + +1045 +PrimTy + +ndTyp + +ic_ +< +ComNode +*>( +ex +)-> +GOdTy +(); + +1046 +MVue + + gnd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1047 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1048 +EXPRCOMPOP +(<, +s +, +nd0 +, +nd1 +, +ndTyp +, +ex +-> +yp +); + +1049  + g_ex +; + +1051 + gb_OP_ +: + +1053 +PrimTy + +ndTyp + +ic_ +< +ComNode +*>( +ex +)-> +GOdTy +(); + +1054 +MVue + + gnd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1055 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1056 +EXPRCOMPOP +(<=, +s +, +nd0 +, +nd1 +, +ndTyp +, +ex +-> +yp +); + +1057  + g_ex +; + +1059 + gb_OP_ +: + +1061 +MVue + +nd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1062 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1063 +MVue + + gnd2 + = +EvEx +( +func +, +ex +-> +Od +(2)); + +1064 +EXPRSELECTOP +( +s +, +nd0 +, +nd1 +, +nd2 +, +ex +-> +yp +); + +1065  + g_ex +; + +1067 + gb_OP_bd +: + +1069 +MVue + +nd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1070 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1071 +EXPRBININTOP +(&, +s +, +nd0 +, +nd1 +, +ex +-> +yp +); + +1072  + g_ex +; + +1074 + gb_OP_bi +: + +1076 +MVue + +nd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1077 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1078 +EXPRBININTOP +(|, +s +, +nd0 +, +nd1 +, +ex +-> +yp +); + +1079  + g_ex +; + +1081 + gb_OP_bx +: + +1083 +MVue + +nd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1084 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1085 +EXPRBININTOP +(^, +s +, +nd0 +, +nd1 +, +ex +-> +yp +); + +1086  + g_ex +; + +1088 + gb_OP_lshr +: + +1090 +MVue + +nd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1091 +MVue + + gnumBs + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1092 +EXPRBININTOPUNSIGNED +(>>, +s +, +nd0 +, +numBs +, +ex +-> +yp +); + +1093  + g_ex +; + +1095 + gb_OP_ashr +: + +1097 +MVue + +nd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1098 +MVue + + gnumBs + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1099 +EXPRBININTOP +(>>, +s +, +nd0 +, +numBs +, +ex +-> +yp +); + +1100  + g_ex +; + +1102 + gb_OP_shl +: + +1104 +MVue + +nd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1105 +MVue + + gnumBs + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1106 +EXPRBININTOP +(<<, +s +, +nd0 +, +numBs +, +ex +-> +yp +); + +1107  + g_ex +; + +1109 + gb_OP_bn +: + +1111 +MVue + +nd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1112 +EXPRUNROP +(~, +s +, +nd0 +, +ex +-> +yp +); + +1113  + g_ex +; + +1115 + gb_OP_ +: + +1117 +MVue + +nd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1118 +EXPRUNROP +(!, +s +, +nd0 +, +ex +-> +yp +); + +1119  + g_ex +; + +1121 + gb_OP_g +: + +1123 +MVue + +nd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1124  + gex +-> + gyp +) { + +1125  + gPTY_i8 +: +s +. +x +. +i8 + = - +nd0 +.x.i8; ; + +1126  + gPTY_i16 +: +s +. +x +. +i16 + = - +nd0 +.x.i16; ; + +1128  + gPTY_i32 +: +s +. +x +. +i32 + = ~( +ut32 +) +nd0 +.x.i32+1; ; + +1129  + gPTY_i64 +: +s +. +x +. +i64 + = - +nd0 +.x.i64; ; + +1130  + gPTY_u8 +: +s +. +x +. +u8 + = - +nd0 +.x.u8; ; + +1131  + gPTY_u16 +: +s +. +x +. +u16 + = - +nd0 +.x.u16; ; + +1132  + gPTY_u32 +: +s +. +x +. +u32 + = - +nd0 +.x.u32; ; + +1133  + gPTY_u64 +: +s +. +x +. +u64 + = - +nd0 +.x.u64; ; + +1134  + gPTY_f32 +: +s +. +x +. +f32 + = - +nd0 +.x.f32; ; + +1135  + gPTY_f64 +: +s +. +x +. +f64 + = - +nd0 +.x.f64; ; + +1136 : +MIR_FATAL +("Unsu܋d PrimTy %d f ury ot %s", +ex +-> +yp +, "OP_neg"); + +1138 + gs +. + gyp + = +ex +-> +yp +; + +1140 +EXPRUNROP +(-, +s +, +nd0 +, +ex +-> +yp +); + +1142  + g_ex +; + +1144 + gb_OP_abs +: + +1146 +MVue + +0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1147  + gex +-> + gyp +) { + +1149  + gPTY_i8 +: +s +. +x +. +i8 + = +abs +( +0 +.x.i8); ; + +1150  + gPTY_i16 +: +s +. +x +. +i16 + = +abs +( +0 +.x.i16); ; + +1151  + gPTY_i32 +: +s +. +x +. +i32 + = +abs +( +0 +.x.i32); ; + +1152  + gPTY_i64 +: +s +. +x +. +i64 + = +abs +( +0 +.x.i64); ; + +1153  + gPTY_f32 +: +s +. +x +. +f32 + = +bsf +( +0 +.x.f32); ; + +1154  + gPTY_f64 +: +s +. +x +. +f64 + = +bs +( +0 +.x.f64); ; + +1155 : +MASSERT +( +l +, "_abunsu܋dy %d", +ex +-> +yp +); + +1157 + gs +. + gyp + = +ex +-> +yp +; + +1158  + g_ex +; + +1160 + gb_OP_m +: + +1162 +MVue + +nd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1163 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1164 +EXPRMAXMINOP +(<, +s +, +nd0 +, +nd1 +, +ex +-> +yp +); + +1165  + g_ex +; + +1167 + gb_OP_max +: + +1169 +MVue + +nd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1170 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1171 +EXPRMAXMINOP +(>, +s +, +nd0 +, +nd1 +, +ex +-> +yp +); + +1172  + g_ex +; + +1174 + gb_OP_m +: + +1176 +MVue + +nd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1177 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1178 +EXPRREMOP +(%, +s +, +nd0 +, +nd1 +, +ex +-> +yp +); + +1179  + g_ex +; + +1181 + gb_OP_cvt +: + +1183 +PrimTy + +toPtyp + = +ex +-> +yp +; + +1184 +PrimTy + + gomPtyp + = +ic_ +< +TyCvtNode +*>( +ex +)-> +FromTy +(); + +1185 +MVue + + gnd + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1186 + gs + = +CvtTy +( +nd +, +toPtyp +, +omPtyp +); + +1187  + g_ex +; + +1189 + gb_OP_addrofoff +: + +1192 +t32 + +offt + = +ic_ +< +AddrofoffNode +*>( +ex +)->offset; + +1193 +StIdx + + gidx + = +ic_ +< +AddrofoffNode +*>( +ex +)-> +Idx +; + +1194 +ut8 + * + gaddr +; + +1196 i( + gidx +. +Iol +()) { + +1197 + gaddr + = +func +. +GFmVAddr +( +idx +); + +1198 i(! + gaddr +) { + +1199 + gaddr + = +func +. +fo +-> +lmbcMod +-> +GVAddr +(func.fo-> +mFunc +-> +GPuidx +(), +idx +); + +1201 +MASSERT +( +addr +, "addrofoff canot findocal var"); + +1203 +MASSERT +( +idx +. +IsGlob +(), "addrofoff: symboleitherocalor global"); + +1204 +MIRSymb +* + gv + = +GlobTabs +:: +GGsymTab +(). +GSymbFromStidx +( +idx +. +Idx +()); + +1205  + gv +-> +GStageCss +()) { + +1206  + gkScEx +: + +1207 +addr + = ( +ut8 + *)( +func +. +fo +-> +lmbcMod +-> +FdExtSym +( +idx +)); + +1209  + gkScGlob +: + +1210  +kScFic +: + +1211 +addr + = +func +. +fo +-> +lmbcMod +-> +GVAddr +( +v +-> +GStIdx +()); + +1214 +MASSERT +( +l +, "addrofoff: stagas%d NYI", +v +-> +GStageCss +()); + +1218 + gs +. + gx +. + ga64 + = +addr + + +offt +; + +1219 + gs +. + gyp + = +PTY_a64 +; + +1220  + g_ex +; + +1222 + gb_OP_lo +: + +1224 +MVue + +nd + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1225 + gs +. + gyp + = +PTY_a64 +; + +1226 + gs +. + gx +. + ga64 + = +func +. +Ao +( +nd +. +x +. +u64 +); + +1227  + g_ex +; + +1229 + gb_OP_addroffunc +: + +1231 +FuncAddr + * +ddr + = +func +. +fo +-> +lmbcMod +-> +GFuncAddr +( +ic_ +< +AddroffuncNode +*>( +ex +)-> +GPUIdx +()); + +1232 + gs +. + gx +. + ga64 + = ( +ut8 +*) +ddr +; + +1233 + gs +. + gyp + = +PTY_a64 +; + +1234  + g_ex +; + +1236 + gb_OP_addroab +: + +1238 +AddroabNode + * +node + = +ic_ +( +ex +); + +1239 +LabIdx + + gbIdx + = +node +-> +GOfft +(); + +1240 +StmtNode + * + gb + = +func +. +fo +-> +bM +[ +bIdx +]; + +1241 + gs +. + gx +. + ga64 + = +t_ +< +ut8 +*>( +b +); + +1242 + gs +. + gyp + = +ex +-> +yp +; + +1243  + g_ex +; + +1245 + gb_OP_ty +: + +1247 +s + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1248 + gs +. + gyp + = +ex +-> +yp +; + +1249  + g_ex +; + +1251 + gb_OP_xt +: + +1253 +ExabsNode + * +ext + = +ic_ +( +ex +); + +1254 +ut8 + + gbOfft + = +ext +-> +GBsOfft +(); + +1255 +ut8 + + gbSize + = +ext +-> +GBsSize +(); + +1256 +MASSERT +( +bOfft + == 0, "sext unexpected offset"); + +1257 +ut64 + + gmask + = +bSize + < 64 ? (1ull << bSize) - 1 : ~0ull; + +1258 + gs + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1259 + gs +. + gx +. + gi64 + = (( +ut64 +) +s +. +x +. +i64 + >> ( +bSize + - 1& 1u?es.x.i64 | ~ +mask + :es.x.i64 & mask; + +1260 + gs +. + gyp + = +ex +-> +yp +; + +1261  + g_ex +; + +1263 + gb_OP_zext +: + +1265 +ExabsNode + * +ext + = +ic_ +( +ex +); + +1266 +ut8 + + gbOfft + = +ext +-> +GBsOfft +(); + +1267 +ut8 + + gbSize + = +ext +-> +GBsSize +(); + +1268 +MASSERT +( +bOfft + == 0, "zext unexpected offset"); + +1269 +ut64 + + gmask + = +bSize + < 64 ? (1ull << bSize) - 1 : ~0ull; + +1270 + gs + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1271 + gs +. + gx +. + gi64 + & +mask +; + +1272 + gs +. + gyp + = +ex +-> +yp +; + +1273  + g_ex +; + +1275 + gb_OP_exabs +: + +1277 +ExabsNode + * +ebs + = +ic_ +( +ex +); + +1278 +ut8 + + gbOfft + = +ebs +-> +GBsOfft +(); + +1279 +ut8 + + gbSize + = +ebs +-> +GBsSize +(); + +1280 +ut64 + + gmask + = ((1u << +bSize +- 1<< +bOfft +; + +1281 + gs + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1282 + gs +. + gx +. + gi64 + = ( +ut64 +)( +s +. +x +. +i64 + & +mask +>> +bOfft +; + +1283 i( +IsSigdIeg +( +ex +-> +yp +)) { + +1284 + gmask + = (1u << +bSize +) - 1; + +1285 + gs +. + gx +. + gi64 + = (( +ut64 +) +s +. +x +. +i64 + >> ( +bSize + - 1& 1u?es.x.i64 | ~ +mask + :es.x.i64 & mask; + +1287 + gs +. + gyp + = +ex +-> +yp +; + +1288  + g_ex +; + +1290 + gb_OP_dosbs +: + +1292 +DosbsNode + * +dbs + = +ic_ +( +ex +); + +1293 +MVue + + gnd0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1294 +MVue + + gnd1 + = +EvEx +( +func +, +ex +-> +Od +(1)); + +1295 +ut64 + + gmask + = ~(0xfffffffffffffff<< +dbs +-> +GBsSize +()); + +1296 +ut64 + + gom + = ( +nd1 +. +x +. +u64 + & +mask +<< +dbs +-> +GBsOfft +(); + +1297 + gmask + = +mask + << +dbs +-> +GBsOfft +(); + +1298 + gs +. + gx +. + gu64 + = ( +nd0 +. +x +. +u64 + & ~( +mask +)| +om +; + +1299 + gs +. + gyp + = +ex +-> +yp +; + +1300  + g_ex +; + +1302 + gb_OP_sic +: + +1304 aut* +n + = +ic_ +< +IrsicNode +*>( +ex +); + +1305 +MVue + + g0 + = +EvEx +( +func +, +ex +-> +Od +(0)); + +1306 + gs +. + gyp + = +ex +-> +yp +; + +1308  + gn +-> +GIrsic +()) { + +1309  + gINTRN_C_s +: + +1310 i( +ex +-> +yp + = +PTY_f32 +) { + +1311 +s +. +x +. +f32 + = +s +( +0 +.x.f32); + +1312 } i( + gex +-> + gyp + = +PTY_f64 +) { + +1313 +s +. +x +. +f64 + = +s +( +0 +.x.f64); + +1316  + gINTRN_C_z32 +: + +1317 i( +ex +-> +yp + = +PTY_u32 + ||x->y= +PTY_i32 +) { + +1318 +s +. +x +. +u32 + = +__but_z +( +0 +.x.u32); + +1321  + gINTRN_C_z32 +: + +1322 i( +ex +-> +yp + = +PTY_u32 + ||x->y= +PTY_i32 +) { + +1323 +s +. +x +. +u32 + = +__but_z +( +0 +.x.u32); + +1326  + gINTRN_C_ffs +: + +1327 i( +ex +-> +yp + = +PTY_u32 + ||x->y= +PTY_i32 +) { + +1328 +s +. +x +. +u32 + = +__but_ffs +( +0 +.x.u32); + +1331  + gINTRN_C_v_4 +: + +1332 i( +ex +-> +yp + = +PTY_u32 + ||x->y= +PTY_i32 +) { + +1333 +s +. +x +. +u32 + = +__but_bv32 +( +0 +.x.u32); + +1339  + g_ex +; + +1343 + gb_OP_dassign +: + +1344 +b_OP_pssign +: + +1345 +b_OP_maydassign +: + +1346 +b_OP_ssign +: + +1347 +b_OP_block +: + +1348 +b_OP_do +: + +1349 +b_OP_dowhe +: + +1350 +b_OP_if +: + +1351 +b_OP_whe +: + +1352 +b_OP_swch +: + +1353 +b_OP_muiway +: + +1354 +b_OP_fܗchem +: + +1355 +b_OP_commt +: + +1356 +b_OP_ev +: + +1357 +b_OP_ +: + +1358 +b_OP_lsge +: + +1359 +b_OP_ls +: + +1360 +b_OP_asge +: + +1361 +b_OP_as +: + +1362 +b_OP_as +: + +1363 +b_OP_tuas +: + +1364 +b_OP_assigs +: + +1365 +b_OP_abt +: + +1366 +b_OP_asnnu +: + +1367 +b_OP_assigsnnu +: + +1368 +b_OP_asnnu +: + +1369 +b_OP_tuasnnu +: + +1370 +b_OP_dad +: + +1371 +b_OP_addrof +: + +1372 +b_OP_ddrof +: + +1373 +b_OP_sizeoy +: + +1374 +b_OP_fldsdi +: + +1375 +b_OP_y +: + +1376 +b_OP_ssignoff +: + +1377 +b_OP_ssignoff +: + +1378 +b_OP_gassign +: + +1379 +b_OP_go +: + +1380 +b_OP_brl +: + +1381 +b_OP_brue +: + +1382 +b_OP_tu +: + +1383 +b_OP_ngego +: + +1384 +b_OP_ +: + +1385 +b_OP_vtu +: + +1386 +b_OP_surass +: + +1387 +b_OP_r +: + +1388 +b_OP_cuom +: + +1389 +b_OP_pymphic +: + +1390 +b_OP_i +: + +1391 +b_OP_ri +: + +1392 +b_OP_vtui +: + +1393 +b_OP_sic +: + +1394 +b_OP_sicwhty +: + +1395 +b_OP_xsic +: + +1396 +b_OP_assigd +: + +1397 +b_OP_vtuassigd +: + +1398 +b_OP_surassassigd +: + +1399 +b_OP_rassigd +: + +1400 +b_OP_cuomassigd +: + +1401 +b_OP_pymphicassigd +: + +1402 +b_OP_iassigd +: + +1403 +b_OP_riassigd +: + +1404 +b_OP_vtuiassigd +: + +1405 +b_OP_sicassigd +: + +1406 +b_OP_sicwhtyassigd +: + +1407 +b_OP_xsicassigd +: + +1408 +b_OP_Κt +: + +1409 +b_OP_Κssigd +: + +1410 +b_OP_vtuΚt +: + +1411 +b_OP_vtuΚssigd +: + +1412 +b_OP_surassΚt +: + +1413 +b_OP_surassΚssigd +: + +1414 +b_OP_rΚt +: + +1415 +b_OP_rΚssigd +: + +1416 +b_OP_jry +: + +1417 +b_OP_y +: + +1418 +b_OP_ry +: + +1419 +b_OP_throw +: + +1420 +b_OP_jstch +: + +1421 +b_OP_tch +: + +1422 +b_OP_ptch +: + +1423 +b_OP_fly +: + +1424 +b_OP_nury +: + +1425 +b_OP_dy +: + +1426 +b_OP_ +: + +1427 +b_OP_d +: + +1428 +b_OP_un +: + +1429 +b_OP_dun +: + +1430 +b_OP_gosub +: + +1431 +b_OP_tsub +: + +1432 +b_OP_syn +: + +1433 +b_OP_synx +: + +1434 +b_OP_deef +: + +1435 +b_OP_ef +: + +1436 +b_OP_deeet +: + +1437 +b_OP_membacque +: + +1438 +b_OP_memba +: + +1439 +b_OP_membܖd +: + +1440 +b_OP_membee +: + +1441 +b_OP_b +: + +1442 +b_OP_cڡr16 +: + +1443 +b_OP_ +: + +1444 +b_OP_o +: + +1445 +b_OP_round +: + +1446 +b_OP_unc +: + +1447 +b_OP_c +: + +1448 +b_OP_sq +: + +1449 +b_OP_mloc +: + +1450 +b_OP_gcmloc +: + +1451 +b_OP_gmloc +: + +1452 +b_OP_ackmloc +: + +1453 +b_OP_gcmlocjy +: + +1454 +b_OP_gmlocjy +: + +1455 +b_OP_ackmlocjy +: + +1456 +b_OP_sverfunc +: + +1457 +b_OP_svevtufunc +: + +1458 +b_OP_r +: + +1459 +b_OP_CG_y_em_add +: + +1460 +b_OP_cmp +: + +1461 +b_OP_cm +: + +1462 +b_OP_cmpg +: + +1463 +b_OP_nd +: + +1464 +b_OP_li +: + +1465 +b_OP_nd +: + +1466 +b_OP_ci +: + +1467 +b_OP_sicwhty +: + +1468 +b_OP_ssigcoff +: + +1469 +b_OP_dpcoff +: + +1470 +b_OP_checkpot +: + +1471 +b_OP_addrofc +: + +1472 +b_OP_igo +: + +1473 +b_OP_asm +: + +1474 +b_OP_dadoff +: + +1475 +b_OP_dassignoff +: + +1476 +b_OP_ssignoff +: + +1477 +b_OP_blkassignoff +: + +1478 +b_OP_iδo +: + +1479 +b_OP_iδssigd +: + +1481 +MASSERT +( +l +, "NIY"); + +1484 + g_ex +: + +1485  +s +; + + @lmbc/src/load_store.cpp + +15  + ~"mvue.h +" + +16  + ~"mfuni.h +" + +17  + ~"mas.h +" + +19 +mea + + gm + { + +21  +mld +( +ut8 +* +addr +, +PrimTy + +yp +, +MVue +& +s +, +size_t + +aggSize +) { + +22 + gs +. + gyp + = +yp +; + +23  + gyp +) { + +24  + gPTY_i8 +: + +25 +s +. +x +. +i64 + = *( +t8 + *) +addr +; + +27  + gPTY_i16 +: + +28 +s +. +x +. +i64 + = *( +t16 + *) +addr +; + +30  + gPTY_i32 +: + +31 +s +. +x +. +i64 + = *( +t32 + *) +addr +; + +33  + gPTY_i64 +: + +34 +s +. +x +. +i64 + = *( +t64 + *) +addr +; + +36  + gPTY_u8 +: + +37 +s +. +x +. +u64 + = *( +ut8 + *) +addr +; + +39  + gPTY_u16 +: + +40 +s +. +x +. +u64 + = *( +ut16 + *) +addr +; + +42  + gPTY_u32 +: + +43 +s +. +x +. +u64 + = *( +ut32 + *) +addr +; + +45  + gPTY_u64 +: + +46 +s +. +x +. +u64 + = *( +ut64 + *) +addr +; + +48  + gPTY_f32 +: + +49 +s +. +x +. +f32 + = *(*) +addr +; + +51  + gPTY_f64 +: + +52 +s +. +x +. +f64 + = *(*) +addr +; + +54  + gPTY_a64 +: + +55 +s +. +x +. +a64 + = *( +ut8 + **) +addr +; + +57  + gPTY_agg +: + +58 +s +. +x +. +a64 + = +addr +; + +59 + gs +. + gaggSize + = +aggSize +; + +62 +MASSERT +( +l +, "mldty%d NYI", +yp +); + +67  +me +( +ut8 +* +addr +, +PrimTy + +yp +, +MVue +& +v +, +bo + +toVArgSck +) { + +68 i(! +IsPrimiveIeg +( +yp +|| !IsPrimiveIeg( +v +.ptyp)) { + +69 +MASSERT +( +yp + = +v +.ptyp || + +70 +yp + = +PTY_a64 + && +v +.y= +PTY_u64 + || + +71 +yp + = +PTY_u64 + && +v +.y= +PTY_a64 +, + +72 "mܐty mismch: %dnd %d", +yp +, +v +.ptyp); + +74  + gyp +) { + +75  + gPTY_i8 +: + +76 *( +t8 + *) +addr + = +v +. +x +. +i8 +; + +78  + gPTY_i16 +: + +79 *( +t16 + *) +addr + = +v +. +x +. +i16 +; + +81  + gPTY_i32 +: + +82 *( +t32 + *) +addr + = +v +. +x +. +i32 +; + +84  + gPTY_i64 +: + +85 *( +t64 + *) +addr + = +v +. +x +. +i64 +; + +87  + gPTY_u8 +: + +88 *( +ut8 + *) +addr + = +v +. +x +. +u8 +; + +90  + gPTY_u16 +: + +91 *( +ut16 + *) +addr + = +v +. +x +. +u16 +; + +93  + gPTY_u32 +: + +94 *( +ut32 + *) +addr + = +v +. +x +. +u32 +; + +96  + gPTY_u64 +: + +97 *( +ut64 + *) +addr + = +v +. +x +. +u64 +; + +99  + gPTY_f32 +: + +100 *(*) +addr + = +v +. +x +. +f32 +; + +102  + gPTY_f64 +: + +103 *(*) +addr + = +v +. +x +. +f64 +; + +105  + gPTY_a64 +: + +106 *( +ut8 + **) +addr + = +v +. +x +. +a64 +; + +108  + gPTY_agg +: + +109 i( +toVArgSck +) { + +110 i( +v +. +aggSize + > 16) { + +111 *( +ut8 + **) +addr + = +v +. +x +. +a64 +; + +113 +memy +( +addr +, +v +. +x +. +a64 +, v. +aggSize +); + +117 +MASSERT +( +v +. +aggSize + <= 16, "mstoregg > 16"); + +118 +memy +( +addr +, &( +v +. +x +. +u64 +), v. +aggSize +); + +122 +MASSERT +( +l +, "mܐy%d NYI", +yp +); + + @lmbc/src/mfunction.cpp + +16  + ~ + +17  + ~ + +19  + ~ + +20  + ~ + +21  + #gtid +( + `sys +( +SYS_gtid +) + + ) + +22  + ~ + +23  + ~ + +25  + ~"mfuni.h +" + +26  + ~"mimty.h +" + +27  + ~"mas.h +" + +29 +mea + + gm + { + +31 + gMFuni +:: +MFuni +( +LmbcFunc + * +funcInfo +, + +32 +MFuni + * +funcCr +, + +33 +ut8 + * +autoVs +, + +34 +MVue + * +egs +, + +35 +MVue + * +fmvs +) : + +36 +fo +( +funcInfo +), + +37 +Δ +( +funcCr +), + +38 +ame +( +autoVs +), + +39 +pRegs +( +egs +), + +40 +fmVs +( +fmvs +), + +41 +Args +( +nuαr +), + +42 +aggrArgsBuf +( +nuαr +) + +44 + gnumClArgs + = 0; + +45 + gxtStmt + = +fo +-> +mFunc +-> +GBody +(); + +46 + g + = ( +ut8 +*) +ame + + +fo +-> +ameSize +; + +47 + gloOfft + = 0; + +48 + gloMem + = +nuαr +; + +51 + gMFuni +::~ +MFuni +() { } + +53 +ut8 + * +MFuni +:: +Ao +( +ut32 + +sz +) { + +54 i( +loOfft + + +sz + > +ALLOCA_MEMMAX +) { + +55  +nuαr +; + +57 +ut8 + * + gr + = +loMem + + +loOfft +; + +58 + gloOfft + + +sz +; + +59  + gr +; + +62 +ut8 + * + gMFuni +:: +GFmVAddr +( +StIdx + +idx +) { + +63 aut + + = +fo +-> +idx2Pm +. +fd +( +idx +. +FuIdx +()); + +64 i( + g + = +fo +-> +idx2Pm +. +d +()) { + +65  +nuαr +; + +67 i( + g +-> + gcd +-> + gyp + = +PTY_agg +) { + +68 +MASSERT +( +Δ +-> +aggrArgsBuf +, "aggrArgsBufot init"); + +69  + gΔ +-> + gaggrArgsBuf + + + g +-> + gcd +-> + geIdx +; + +71 (( + gut8 +*)& + gfmVs +[ + +-> +cd +-> +eIdx +]. + gx +); + +74 +bo + +IsExtFunc +( +PUIdx + +puIdx +, +LmbcMod +& +modu +) { + +75 +MIRFuni + * + gfunc + = +GlobTabs +:: +GFuniTab +(). +GFuniFromPuidx +( +puIdx +); + +76 i( + gfunc +-> +IsEx +() || + +77 + gfunc +-> +GAr +( +FUNCATTR_imic +) || + +78 ! + gfunc +-> +GBody +() || + +79 ( + gfunc +-> +IsWk +(&& + gmodu +. +FdExtFunc +( +puIdx +))) { + +80  + gue +; + +82  + gl +; + +86 +size_t + +GIRdAggrSize +( +BaNode +* +ex +) { + +87 +MASSERT +( +ex +-> + + = +OP_d + &&x-> +yp + = +PTY_agg +, "iread onon PTY_aggype"); + +88 +IadNode + * + gd + = +ic_ +( +ex +); + +89 +TyIdx + + grTyIdx + = +d +-> +GTyIdx +(); + +90 +MIRPTy + * + grTy + = + +91 +ic_ +< +MIRPTy +*>( +GlobTabs +:: +GTyTab +(). +GTyFromTyIdx +( +rTyIdx +)); + +92 +MIRTy + * + gaggTy + = +GlobTabs +:: +GTyTab +(). +GTyFromTyIdx +( +rTy +-> +GPodTyIdx +()); + +93 +FldID + + gfd + = +d +-> +GFldID +(); + +94 +size_t + + gsz + = +aggTy +-> +GSize +(); + +95 i( + gfd + != 0) { + +96 +MIRSuTy + * +ruTy + = +ic_ +( +aggTy +); + +97 +MIRTy + * + gfdTy + = +ruTy +-> +GFldTy +( +fd +); + +98 +ut32 + + gfdOfft + = +ruTy +-> +GBOfftFromBaAddr +( +fd +); + +99 + gsz + = +fdTy +-> +GSize +(); + +100 () + gfdOfft +; + +102  (( + gsz + + 7) >> 3) << 3; + +107 +size_t + +GAggClArgsSize +( +LmbcFunc + * +Γ +, +ClNode + * + +) { + +108 +size_t + + gtٮAggClArgsSize + = +Γ +-> +fmsAggSize +; + +109 i( + gΓ +-> + gisVArgs +) { + +110  + gi + = +Γ +-> +fmsNum +; i < + g +-> +NumOds +(); i++) { + +111 i( + g +-> +Od +( +i +)-> + gyp + = +PTY_agg +) { + +112 +MASSERT +( + +-> +Od +( +i +)-> + + = +OP_d +, "agg varrg unexpected op"); + +113 + gtٮAggClArgsSize + + +GIRdAggrSize +( + +-> +Od +( +i +)); + +117  + gtٮAggClArgsSize +; + +135  + gMFuni +:: +ClMFuncDe +( +ClNode + * + +) { + +136 +LmbcFunc + * +Γ + = +fo +-> +lmbcMod +-> +LkupLmbcFunc +( + +-> +GPUIdx +()); + +137 i(! + gΓ +-> + gfmsNum +) { + +138 +InvokeFunc +( +Γ +, +this +); + +142 +size_t + + gtٮAggClArgsSize + = +GAggClArgsSize +( +Γ +, + +); + +143 + gaggrArgsBuf + = +ic_ +< +ut8 +*>( +lo +( +tٮAggClArgsSize +)); + +144  + gi + = 0, + gsz + = 0, + gofft + = +Γ +-> +fmsAggSize +; i < + g +-> +NumOds +(); i++) { + +146 i( + g +-> +Od +( +i +)-> + gyp + ! +PTY_agg +) { + +147 +Args +[ +i +] = +EvEx +(* +this +, + +-> +Od +(i)); + +151 i( + gi + < + gΓ +-> + gfmsNum +) { + +152 + gArgs +[ +i +] = +EvEx +(* +this +, + +-> +Od +(i), +Γ +-> +pos2Pm +[i]); + +156 + gsz + = +GIRdAggrSize +( + +-> +Od +( +i +)); + +157 +PmInf + +rmInf +( +PTY_agg +, +sz +, +l +, +offt +); + +158 + gofft + + +sz +; + +159 + gArgs +[ +i +] = +EvEx +(* +this +, + +-> +Od +(i), & +rmInf +); + +161 i( + gΓ +-> + gisVArgs +) { + +162 +ClVaArgFunc +( + +-> +NumOds +(), +Γ +); + +164 +InvokeFunc +( +Γ +, +this +); + +168  + gMFuni +:: +ClMFuncInde +( +INode + * +i +, +LmbcFunc + * +Info +) { + +169 i(! + gInfo +-> + gfmsNum +) { + +170 +InvokeFunc +( +Info +, +this +); + +175 + gaggrArgsBuf + = +ic_ +< +ut8 +*>( +lo +( +Info +-> +fmsAggSize +)); + +176  + gi +=0; i < + gi +-> +NumOds +()-1; i++) { + +177 + gArgs +[ +i +] = ( +i +-> +Od +(i+1)-> +yp + = +PTY_agg +) ? + +178 +EvEx +(* +this +, +i +-> +Od +( +i ++1), +Info +-> +pos2Pm +[i]) : + +179 +EvEx +(* +this +, +i +-> +Od +( +i ++1)); + +181 i( + gInfo +-> + gisVArgs +) { + +182 +ClVaArgFunc +( +i +-> +NumOds +()-1, +Info +); + +184 +InvokeFunc +( +Info +, +this +); + +199  + gMFuni +:: +ClVaArgFunc +( +numArgs +, +LmbcFunc + * +Info +) { + +200 +ut32 + + gvArgsSz + = 0; + +201  + gi + = +Info +-> +fmsNum +; i < + gnumArgs +; ++i) { + +202 i( + gArgs +[ +i +]. + gyp + ! +PTY_agg + || +Args +[i]. +aggSize + > 16 ) { + +203 +vArgsSz + += 8; + +205 + gvArgsSz + + +Args +[ +i +]. +aggSize +; + +208 + gvaArgsSize + = +vArgsSz +; + +209 + gvaArgs + = +ic_ +< +ut8 +*>( +lo +( +vaArgsSize +)); + +210  + gi + = +Info +-> +fmsNum +, + gofft + = 0; i < + gnumArgs +; ++i) { + +211 +me +( +vaArgs + + +offt +, +Args +[ +i +]. +yp +, clArgs[i], +ue +); + +212 i( + gArgs +[ +i +]. + gyp + ! +PTY_agg + || +Args +[i]. +aggSize + > 16 ) { + +213 +offt + += 8; + +215 + gofft + + +Args +[ +i +]. +aggSize +; + +218 +InvokeFunc +( +Info +, +this +); + +221  + gMFuni +:: +ClExtFuncDe +( +ClNode +* + +) { + +222 +MIRFuni + * +func + = +GlobTabs +:: +GFuniTab +(). +GFuniFromPuidx +( + +-> +GPUIdx +()); + +223 + gMVe +< + gFmDef +> & + gfmDefVec + = +func +-> +GFmDefVec +(); + +224 + gFuncAddr +& + gddr + = * +fo +-> +lmbcMod +-> +GFuncAddr +( + +-> +GPUIdx +()); + +225 +ffi__t + + g + = (ffi__t)( +ddr +. +funcP +. +tiveFunc +); + +226 +MASSERT +( + +, "External functionot found"); + +228  + gi + = +fmDefVec +. +size +(); i < + g +-> +NumOds +(); i++) { + +229 i( + g +-> +Od +( +i +)-> + gyp + = +PTY_agg +) { + +231 +MASSERT +( +l +, "extern func: va-arg ofggype NYI"); + +235 + gaggrArgsBuf + = +ic_ +< +ut8 +*>( +lo +( +ddr +. +fmsAggSize +)); + +236  + gi + = 0, + gofft + = 0; i < + g +-> +NumOds +(); i++) { + +238 i( + g +-> +Od +( +i +)-> + gyp + ! +PTY_agg +) { + +239 +Args +[ +i +] = +EvEx +(* +this +, + +-> +Od +(i)); + +243 i( + gi + < + gfmDefVec +. +size +()) { + +244 +MIRTy +* + gty + = +GlobTabs +:: +GTyTab +(). +GTyFromTyIdx +( +fmDefVec +[ +i +]. +fmTyIdx +); + +245 +MASSERT +( +ty +-> +GPrimTy +(= +PTY_agg +, "expects formalrg ofggype"); + +246 +PmInf + +rmInf +( +PTY_agg +, +ty +-> +GSize +(), +l +, +offt +); + +247 + gofft + + +ty +-> +GSize +(); + +248 + gArgs +[ +i +] = +EvEx +(* +this +, + +-> +Od +(i), & +rmInf +); + +253 +ClWhFFI +( +func +-> +GRuTy +()-> +GPrimTy +(), + +); + +256  + gMFuni +:: +ClExtFuncInde +( +INode + * +iδo +, * + +) { + +258  + gi +=0; i < + giδo +-> +NumOds +()-1; i++) { + +259 + gArgs +[ +i +] +EvEx +(* +this +, +iδo +-> +Od +(i+1)); + +261 +MIRTy + * + gty + = +GlobTabs +:: +GTyTab +(). +GTyFromTyIdx +( +iδo +-> +GRTyIdx +()); + +262 +MIRFuncTy + * + gfPro + = +ic_ +( +ty +); + +263 +MIRTy + * + gfRTy + = +GlobTabs +:: +GTyTab +(). +GTyFromTyIdx +( +fPro +-> +GRTyIdx +()); + +264 +ClWhFFI +( +fRTy +-> +GPrimTy +(), ( +ffi__t +) + +); + +267  + gMFuni +:: +ClIrsic +( +IrsicNode + & +n +) { + +268 +MIRIrsicID + +Id + = +n +. +GIrsic +(); + +269  + gId +) { + +270  + gINTRN_C_va_t +: { + +271 +MVue + +addrofAP + = +EvEx +(* +this +, +n +. +Od +(0)); + +273 +VaLi + * + gvaLi + = ( +m +::VaLi*) +addrofAP +. +x +. +a64 +; + +274 + gvaLi +-> + ggr_offs + = 0; + +275 + gvaLi +-> + gack + = +Δ +-> +vaArgs +; + +279 +MASSERT +( +l +, "ClIrsi%d\NYI", +Id +); + +285  +ffi_ty + + gffi_ty_b +[] = { + +286 +ffi_ty_void +, + +287  + #EXPANDFFI1 +( +x +x, + + ) + +288  + #EXPANDFFI2 +( +x + + `EXPANDFFI1 +(x) + + ) + +289  + #PRIMTYPE +( +P + + `EXPANDFFI2 +( +FFITYPE_ +##P) + + ) + +290  + #LOAD_ALGO_PRIMARY_TYPE + + + ) + +291  + ~"im_tys.def +" + +292 #unde +PRIMTYPE + + +293 +ffi_ty_void + + +297 +ffi_ty + * + gvaLiObjAch64 + [] = { + +298 +ffi_ty_b + + +PTY_r +, + +299 +ffi_ty_b + + +PTY_r +, + +300 +ffi_ty_b + + +PTY_r +, + +301 +ffi_ty_b + + +PTY_i32 +, + +302 +ffi_ty_b + + +PTY_i32 +, + +303 +nuαr + + +307 +ffi_ty + * + gvaLiObjX86_64 + [] = { + +308 +ffi_ty_b + + +PTY_u32 +, + +309 +ffi_ty_b + + +PTY_u32 +, + +310 +ffi_ty_b + + +PTY_r +, + +311 +ffi_ty_b + + +PTY_r +, + +312 +nuαr + + +316 +ffi_ty + + gvaLi_ffi_ty + = { 0, 0, +FFI_TYPE_STRUCT +, +vaLiObjAch64 + }; + +326  + gMFuni +:: +ClWhFFI +( +PrimTy + +t_yp +, +ffi__t + + +) { + +327 +ffi_cif + + gcif +; + +328 +ffi_ty + + gffi_t_ty + = +ffi_ty_b +[ +t_yp +]; + +329 +ffi_ty +* + gg_tys +[ +numClArgs +]; + +330 * + ggs +[ +numClArgs +]; + +333  + gi +=0; i < + gnumClArgs +; ++i) { + +334 + ggs +[ +i +] = & +Args +[i]. +x +; + +335 i( + gArgs +[ +i +]. + gyp + = +PTY_agg +) { + +336 +g_tys +[ +i +] = & +vaLi_ffi_ty +; + +338 + gg_tys +[ +i +] = +ffi_ty_b + + +Args +[i]. +yp +; + +342 +ffi_us + + gus + = +ffi__cif +(& +cif +, +FFI_DEFAULT_ABI +, +numClArgs +, & +ffi_t_ty +, +g_tys +); + +343 if( + gus + = +FFI_OK +) { + +344 +ffi_ +(& +cif +, + +, & +tV0 +. +x +, +gs +); + +345 + gtV0 +. + gyp + = +t_yp +; + +347 +MIR_FATAL +("Faed mhod%p", (*) + +); + + @lmbc/src/mplsh.cpp + +15  + ~ + +16  + ~"mas.h +" + +17  + ~"lmbc_g.h +" + +18  + ~"g_shim.h +" + +20 +mea + + gm + { + +22 * + gLmbcMod +:: +FdExtFunc +( +PUIdx + +puidx +) { + +23 * + + = +extFuncM +[ +puidx +]; + +24 i( + g +) { + +25  + g +; + +27 + gd +:: +rg + +ame + = +GlobTabs +:: +GFuniTab +(). +GFuniFromPuidx +( +puidx +)-> +GName +(); + +28 aut + g + : +libHds +) { + +29 + + = +dlsym +( + +, +ame +. +c_r +()); + +30 i( + g +) { + +34 +MASSERT +( + +, "dlsym symbނ found: %s", +ame +. +c_r +()); + +35 + gextFuncM +[ +puidx +] = + +; + +36 ( + g +); + +39 * + gLmbcMod +:: +FdExtSym +( +StIdx + +idx +) { + +40 * +v + = +extSymM +[ +idx +. +FuIdx +()]; + +41 i( + gv +) { + +42  + gv +; + +44 +MIRSymb +* + gsym + = +GlobTabs +:: +GGsymTab +(). +GSymbFromStidx +( +idx +. +Idx +()); + +45 i( + gsym +) { + +46 aut + g + : +libHds +) { + +47 +v + = +dlsym +( + +, +sym +-> +GName +(). +c_r +()); + +48 i( + gv +) { + +52 +MASSERT +( +v +, "dlsym ExtSym found: %s", +sym +-> +GName +(). +c_r +()); + +53 + gextSymM +[ +idx +. +FuIdx +()] = +v +; + +55 +MASSERT +( +sym +, "Unableo find symbol"); + +56 ( + gv +); + +59 + gm +:: +MIRModu +* + +60 +LmbcMod +:: +Impt +( +d +:: +rg + +th +) { + +61 +m +:: +MIRModu +* +mod + = +w + m::MIRModu( +th +. +c_r +()); + +62 + gmod +-> +SSrcLg +( +kSrcLgC +); + +63 + gd +:: +rg +:: +size_ty + +ϡd + = +mod +-> +GFeName +(). +fd_ϡ_of +("."); + +64 +bo + + gimbc + = +ϡd + ! +d +:: +rg +:: +os + && +mod +-> +GFeName +(). +com +(lastdot, 5, ".lmbc\0") == 0; + +65 i(! + gimbc +) { + +66 +ERR +( +kLncE +, "Iumu b.lmbfe: %s", +th +. +c_r +()); + +67 +de + + gmod +; + +68  + gnuαr +; + +71 +ByMImpt + +bMt +(* +mod +); + +72 + gbMt +. +SImp܋d +( +l +); + +73 + gd +:: +rg + +modid + = +mod +-> +GFeName +(); + +74 i(! + gbMt +. +Impt +( +modid +, +ue +)) { + +75 +ERR +( +kLncE +, "msh-lmbc: cn o.lmbfe: %s", +modid +. +c_r +()); + +76 +de + + gmod +; + +77  + gnuαr +; + +79  + gmod +; + +84 + gd +:: +ve +< +d +:: +rg +> +eLdLibs + = { + +85 +LIBC_SO +, + +86 +LIBM_SO + + +89  + gLmbcMod +:: +LdDefLibs +() { + +90 aut + + : +eLdLibs +) { + +91 * +hd + = +dlݒ +( + +. +c_r +(), +RTLD_NOW + | +RTLD_GLOBAL + | +RTLD_NODELETE +); + +92 +MASSERT +( +hd +, "dlݒ %ed", + +. +c_r +()); + +93 + glibHds +. +push_back +( +hd +); + +97 + gLmbcMod +:: +LmbcMod +(* +th +: +lmbcPh +(path) { + +98 +LdDefLibs +(); + +99 + gmMod + = +Impt +( +th +); + +100 + gglobSticMemSize + = +mMod +-> +GGlobMemSize +(); + +104 +RunLmbc +( +gc +, ** +gv +) { + +105  + grc + = 1; + +106 cڡ  + gskArgsNum + = 1; + +107 +LmbcMod +* + gmod + = +w + LmbcMod( +gv +[ +skArgsNum +]); + +108 +ASSERT +( +mod +, "Create Lmbc module failed"); + +109 +ASSERT +( +mod +-> +mMod +, "Import Lmbc module failed"); + +110 + gmod +-> +InModu +(); + +111 i( + gmod +-> + gmaFn +) { + +112 + grc + = +__geShim +( +mod +-> +maFn +, +gc +- +skArgsNum +, +gv ++skipArgsNum); + +114  + grc +; + +120 + $ma +( +gc +, ** +gv +) { + +121 i( +gc + == 1) { + +122 +d +:: +rg + + `th +( +gv +[0]); + +123 () + `MIR_PRINTF +("uge: %.lmbc\n", +th +. + `subr +թh. + `fd_ϡ_of +("/\\"+ 1). + `c_r +()); + +124 + `ex +(1); + +126  +m +:: + `RunLmbc +( +gc +, +gv +); + +127 + } +} + + @ +1 +. +0 +13 +303 +lmbc/include/eng_shim.h +lmbc/include/lmbc_eng.h +lmbc/include/massert.h +lmbc/include/mexpression.h +lmbc/include/mfunction.h +lmbc/include/mprimtype.h +lmbc/include/mvalue.h +lmbc/src/eng_shim.cpp +lmbc/src/init.cpp +lmbc/src/invoke_method.cpp +lmbc/src/load_store.cpp +lmbc/src/mfunction.cpp +lmbc/src/mplsh.cpp diff --git a/src/MapleEng/cscope.po.out b/src/MapleEng/cscope.po.out new file mode 100644 index 0000000000000000000000000000000000000000..d88bffc2496bdb37760124bacf48fcd3b39fd39d GIT binary patch literal 178872 zcmeI5dE8Y~`|yuSca$_rrP>;3(x{|~G88I}n#7$*r9q`Z^FX1bD2k9!$e2vgK!!>Z zB4tWs%tKT{!@JkD_p;AE>-xT*XTNWK9?$RB{^Oi|zV~%sYwfkKHLrE85{*)^D_1I2 z&Vc@FV>oq8D&-lnqy15_KjaPhx^6L?$`kTpx9fbyn7E#Nq5SK>w;vzZ1_-8A0f+5jE8H};jZF3A6P=?bx+cH(Na3!aEgsd@NMJMs-!Nzt*|ct$ALJv@qhcE z&hJg>`WF<7%iH)gg?!N$^2MD+b^R+KzlMfR7v{HAR>r*`|)KXv(4z;A^7wH$ay$am9$SAzU_1@M{2 z=V=xnUfNJa&qph&>AZ6do%gAw^Pg+${55E&9RR-m3|&vJ%j4Ykf7bxN zJ6o4ubcN1$0>7!ZE}sScsa$<^`C|Qb-k^G%+j_7?O`R8lbXMA*o~dz;Z5^+7jt<+O zRWHzagNt;2CGf?qbopv6be8 z5AwG_x-EuqyMvzGApa%EKL_E~1U*wh&sNZr57M(Eho|T}#b>+DHF`<0HVR3Hte0`Z7 zpU(F=TxJBau8!;R(^L3%XutKj!qMXyaw^QntpVQkZe35Odvw0EgA-5BNH&FZcw%^5 z-lk6j{{^LAzEltMd!Nfa!xt4apV8&ZOZx0|xo4!_nj6WQJ8KUL7d;Q$ugiZ1ob0Xp z1G=8UU&Oh!ADSm^1NQKHR$PxwhZlW?>6gzv^PA=)&b!Q)NV{zQ&F$K!XT<1vX}>PwKu9aX})a5wQ)T*J--{P z^KDQsZ@yBOCwqAP`nbK>dZF+Lou55Y=SkNmB&e4?^F&I$EWAS#^VjIg6_&TR!g`f) zP;Xv%X{5v4+4QG+jq0fc^@wM}X*AD#Mwbn@4dnNSVO_!3(2lAO<Zu3!#O1C1T>iVx zo9)&44&bx@(B1&;Te0!YR z_g;5hoZECO2J_Kp!SlYnMb}e4OD|Vj!My64({%ZN+Pb4wL*mbC)AM|=H)_v33-uJW zPn3SNXJYbR=Xko=`fgcwJ)Xp0hH{`e=*bJ?HvN0+;kM|j^Wz5U{9fosv>m0(ZyBfa zHqZ}R3cMfGJB?xdq;(%X{gbXgq;#O?ste^ar8BL2{{Y(gv`#zeI+oYJjK3FK&dhmN z=le~|HSMzUO<|sKEAY9Orz!DoZ9e@TIK8jE*}9%Pd+D6?&rFz)-iG`|;|Y}Sb|%b^ z2OytLg?46BXxD9oc2pn8N7>LH?*`*t_d~w>8u$`ux38P3zsD0`+~Zu}hiV-ART!UN z4)#_YN+d4;TLP+i8j5-`aE-4&y?PHi^sI`6k-ene};G-s-3QkF?*D?40c6%KY(g z{Z#Y}seXMtJ@bWpFwE;MfcctU{y(N)R{uMB(`hu1(+I}@n?n2f*I98rwj6jH%Hb5W z>;8gyfnQ-<{jr&PxH$^OxqaT+ljGdR^9E?|RfBN%LwXJ$tLt9`;nI6)2=(T=n|1xO zApJ{2JeNTK>sruX5A>G+`?^bN_~!&YkHffAvAc9VO+Zg67~lIB*m-eChpk|5 zOCX)!g!ef57Crty!MJE@tX>Wb0y`fxT-VtQ@|61- z-pi?wZmnVb=TPmtzw3;6`rCS;>^bptu=UIHUE(||EVl=(j&rN09IPv=4*S;M1U?M* ztzQ7^5WdQ-Ki6NK;@p3Io{2flr_lbjt=Gh#*Os?4p&Z!WG%jz`^Sya-ZuQVSND)|% z@fh%aupWToPyL8BkHzC@-|r7C;^}#8n4UDAK=TOwPLJ!c`e|O3*6}{{lpfDjn{=M% zW1aVh@%)QN#pCH0kDk$R8St`k@s$5lc)8eLWo^*3oA zP|(Yhyhq}$wC{WRab3fgrvuUBVoT)(w*n(wB0y$|DR%rDP;>^a(eMwcJ|9_AOV zkG;Z=K>B5$_dVb6(l5*Dd9P`dE}csG`C8I*dt--thTL|x`HU`G4p4iZ{C-gRJo%DH zx4EGazb?X+c9d|XoiAMJUkF#)tHPD`vv8%IDO~9X30L}k z!j<-pBGEOL5DbIx~>rsVMyG7Y|Bl5~V z8sRi<(ATYhMZOD+8z@}l+mDHt54L_kYGvGRZ8_6nt-|cdd&($z4Z|kE9E*JSz&W+3a#hS#Ynaf4KP5ZdKU)+iO z0GEsWz3^N`PYv{Zd`j@0GxV!dzoO2c0$!n#F8?I(`KJZ){lae>ZvJXIUtBNXlfrK+ zPwOaX-jmj^t{f8Rx1Y8ir}eANVcdq+qvn`mH3#2T|BbiloYr~X1@jJ%!o0(*dAk1g z3*y}7yGGC-$+t+C&kg;8A;9ZCqw6WWOy_5>(D^OEk6ES5cYa;x?O@*Oq_=hXnj3V! z1^9dK>+&5p>bx;n zo7PL0r}dCq!5_#2L*sgEyM@+) zZ-({ZDQJfba>pN}y|lvZ=k_qqwa?|A;ne?Kezy5*blG-DnI;i4ca~HCm;8xU=or_N z6~0Gm*Bz?|rxHA7JT=5?(T=6?9{BX|$(*BW8d&b|pZAVR>sPp1e|7|YMMe8tWeV4*T&qufF z;U?V&O7n&^PfGKcG+#sWLA0M&>A!pCN!O3ipI7PEi@egW7q09Vmh@Em`y#LO_l48` zV%mR1`>YT5d@HSAI^6THv_5J+tXDt7?_j21eyu3!OygZi_oXW1U80}-Bs7|r9-C->R^^vkCIS$=~p{jz*Na5}ew z&Y|dkMg~yfTjJnGlt6RN+b2N74F8ia)J$PP!hR)>SI&%%vQlb(Q45 zg4RpZx@htvaj4ceHod{Twdk_;U%pttz7NMoeKXEB!W* z2EQ}?pI;D;S9UKKmp@P`_?$+|dD8u-hue?(d>BtY-2T-c zfbr@he%FI??1ARUhQT@TXXh~M=f9sW~(*AJCn^zs)R6{{HR{K#D}pHiw_T;BG7 zYXK*}are1I&*W9Qewv@9_Tk}fUmdD;)RA^kQ2rlj7X|5Xq+JxG!;yAT zkPiQ;cF}*!c{FpO{XpwR$PZ^7IKL+8c{k+Glg`1p2HGu2&&TNs?U@eHo;lp->Cibi zmfKq1Z}&?3r|7juStQ@KJ)Hl77*6@?V@1CAxjKLAJe_X?eoAv)zR&qOzZm$>&2;%U zK)wvfF9Cih@J7Jj2c84?aNu2mZ-eKm4SYYO|A`=<58lf%c<&zr{|)$q!0&)~J^}n; zi2o$u*Mpvlz|R4G8SwnTe}?p&4g5LaO@O}-{4(Gpflr3_(&mLAf1MV7+wtK}Cj>lg zzR5GhbLX3c?=NNkno6b3H+kmwfs@UrKkgpRN97FX9dex#@U;0R&yag61w3uON%;6G zI`3XH;A!(sB0s8g!0l&N81BOlSrUBPe%51;>b%AxhkJ%}2kt%T$X{*9!IyRZ^m3h- z%Gf|?-^*3N>+W^*c!pGU=gTBMw0;=Z3Bx{RS`SR?dnZ+i*GKlbj;X5idZ+1p%SCbS zj|<6jT@34K#{#e1TG!LOdpte!g!VJEpU%g)`^7vXNq$7X1$*lT_EY)Ic(^v*K6p## zvtj-GbMNW$17KZ!%N+6avEiN%>&e@|c*qaO=z3^8q^LW-C-3)acwf~Lu79TXEwxuK z%#O$3wxg(>+2~4Le)&~8Puk9;b=Tx4^TNS;xO1VL?+NAnMeh0m&sfwlD2JCqIlL0e z;l_|JmOSCut=Pk)S9E@tJKp6P$va+m$TQ7rftViv-V=*-mS4V!+eZ1{&Af@_q5K3J*)Gs&*}VQ z;1!nY@>PF#xMxV)zZ@>lTd7RE+_32|Hp3x^Z%;0M8;e+PSRTs_dAY0t|}4|t|Me_k)(nf81l*m?f?y8H)V z|NDmq^7hl(|E5uv1mBkDg7W!Ju>a2&#`RcxxCrcjE7<=>i*-GvAYaS?`%gXZ=hyEfzd~W;^G@k^#?b=gfn4&e!Dv`OJ3C2~aN#gnD5r zv~wS+e{IUm|NJKb?43HO{=qBxp6tG_pt zw>JS_2z>Owc>L}7!(8A~p*(L@JcwszeyLI_;F2% z1+eaIJWp}trJ?V@c@1@X6^HXnTg{oMX;ec_q^J;|*XgztoY z?#|!Me?^xKw+7hxX6Vn}1m*Kb&~M!X>2|9>z>rv2uMe_)X(f4{|#H`=1h z>YoFg_N~)7K8p%Qy3L){Pv^grUvb)>uK4rxOgM@^PvMF`PvHstd5XO9T+$BNbH5*W z+Lb4qFDN-L4f?m1FL^-c8*;?CO}AfNKG;Y;1a^|tU%}Z~dbqt^9<;j}#pQE_&r5!* z=zLi6A4T)&G=H7+{LoyGZigy8CpLA`$1{ZXBX8;um(LyM_a5#zjOdvQJn25-r2BT{iyPfhXN}rug;pOmG)=O$*e&^~;BH!Y_5W zXUG$-f8hTozH_V57G3sv$sT5Y5XqW5D}T&Joi763>0Mo(&iPG&ALD`Jg7=l_pW%*% zf&RP0Z@*mf3@H-&mn#{5+wrjj-2!?0>8HPE?iK&=!XI|aL*dJS7rV@8i!Q5Q@iXrk zsaZWDS#xLQZ_gj+{?mJgdVEJ?M1Jq-{PC60 zK1q7cV2390=dyM}=g%sB#XX~e+93ri`fn)hviU{vL+BYX#ZS0!I_HAytqAz#AbY!Y zhzUKqtexy}xzzhFu8m~Poqew9n{+;5v(5`|(|Lifbp98t^Gw|um$&ghROk6p`A_F; z(s{}c9T$(M&A-Yy0-lkib9?DLTsmiVUsw*>(0x0X`ejaIOM-9Perw-9Znw6aoZ!k| zXZ};s;~8EEsRICi(p%KZNAxjr>Mt!+R%tNa{E2 zaQmgCbL3m}O@CWaJ*AwN;TcJ?bLCtNkyp;e5U!kyAzV2ZL%4D-hH&z$nbdz~yPHz6 z%a%XnCsR2WL*k>Hiy?gA?3nt$+XG4cxqVzH(DP9Eog-{NB<0i}*#YZPw!!+AZoqqj zo)6>6V19Y#gU$)6KQ>;DYJQ#HRzT<73h8`uVVy57 zqVrFR>ipZ0`Jccy7T4vUETQu|OX_^+NjmRPO6T7J9|7wV-f{if$$QLKUe~`J z_=*a;{4BTsEBYTeRhNIHiq3nv`*%c77q?v}{H|)co+8zCUcRQzzp173OX}#n?-@ET z*FfiUn(O>f?SrHJYjfQ3B1yNYo#W+9R#@&Wdo<2%x%VgV+U`Ch&uDlA`1`;&F4w~? zxWeHQ|CaAL+%u&6CpvHPna&4)p>yhAta8uGkodIArN7?|$2#0IA%2lp=j+{aRpd`{ z%TM7QAsqaE~y8^!x_6bwdb*LH zL#nT7JPpS;Zuc`m+Lb44S9}ayIbTNd`@xB6O8i@^XV47}7kTA;6VFIioaD$0{{`CB zRR5m%SX_@S9~3U}xf$BY)PAP({-_)#KLGb8^bgQ_l zKG)^)z7#InlXhGr(#7g3`Gaqz|QM#qm!3C4DY+xx}-~ znz+2pNB!68T(LLNqu879pP-yk>`>&pKslhqN1kiEdw!qr${id#7yW}le;?4Z!{wrf z^mlT@mH5#79i2l&=M5?LAn|zu>?H4?RP6HGGZLSwz-fL;$&V7QVsFClb?r^U9RT^4 z)_Z&b@?W~`G|@i~^1D(FNIbsKNx)Vf!=HN#|vO*X^Rqw+H^z zAji%n9j*s|I}f;A4gP zOTzeed*C!4z6IpB!22riroX(GtFLq3@Bj6^v_C}e>w|>vOF73=;$K8Q#ggR1mOo8_ zE9ZNPiq>0C%U$CK*)b)cWt|CF2_J(Ib!&xPlFogJ6A>%nrj)8Fq1;??8wetj+J zL+34zX$lQz*~+np+uJr_YvSZ#zwN{&dMw8LrJ&I z<8^t3i+s}coX0`CC22cH=|^}b=JdX{j5B|YE}MUowr7-d@QhYU2c`ca^3?vZ=TNK- z+v&D_ZqJ+8`I`wXnwQx(BA&nUg?6Z{o0a!9*j-O6{OP!wl>bvKN;&UXzSK6PR(MsvBv_D0j?CSTCMq6~*{8bgo0n+md=$ZLx zq}$xt@}K6Z6?xD6U#*zQB8fFG)TD;2Y%FwLC}_hCPw(l5*R0jK^H?en5} z(!JT~p+@B)^@CQr{SMD)*ms+*=dHOqr+Gsdq0pKNu>+;#a=^W(Q5dV2@ zdFz?z(Y~A1Xgxl3e(3lnX%Fk)+IHrTz^ACp{-(R5v}`XMvyRj=Op$1(frxBtD8?U*U)Q911#Dt3QnA)4A$xuGZ5> zId4mzOYtWxTsenJxN@F_@TBKiDCfqC9y%|T##?TO@s>F&&0CHxn_u>e15{BJ8<^wYdsf_x!*a`ko6Q@AqjN>#vKNM$FtI}#BgUA~>mbCo?OhX1zzr1cTy z7o|Ru=Tf-Dhw3THUx&N?qI1JruZgFdEgzO`(D{V-94^nRoLeEB)|oVP*OQ36a?XWt zT4$1UU;O!7ocMc&^nm&_>3V}DP;Ora^BOd-MDrSha>V2B=PHT+=SS zUoYW`-#p=pA28vHKULw1pLyYm|83!lKVji@VSJ;VyYE|`H|aUKy>_Q!m;c^HPag0e z^3xwN@xR;iZ9vZzpr;AwsSA3ZcDba_Q@`u+xofY^X*^_S+?>t$o7nR&yL3I{-1tbk zQ9LO95-crQuL5t-xK@|Q^G zvXMXMeeQEfJimnJQpS5lp3W^Q{bG=AneR~<9~M1yKF$Pp|D&XT{kriCVB2F8fNuc4 z3C34{fbmsjeqZ8$)2+et+D~iG%Kk5r@7T~v2H$>rL-Hey-_rOqjWhq#{7#Vn1Z5mv z(ue#i6uB;*Znpd(e+&14Jo#ZDe=_8s;gg|Gd^|%64Ac2}z^@1XIPkB4ml&>x+Zy;w zE|>IgbiJlq|ITgEwhgwwhOTA!foKa%+5cGtCv{--DD;r<1@ z_GDeYA8=Y9tE|(LcrLw7*T3FfUnlY3<#N$eZHBI=y~{;@n#)E1O5nc&SJGMZ*MsyQ zG(!$zQa>CEV%Khk0Dte%Dkbbcf7<-q>{-tnNW ze>(8Dfmbpk7ipJ`{}sUR1x|iJ>3r&(IrMPJFTKJg{htOs1#{~9>Ad67AW!FLmvsF* zc_tajui#g(u4aVm_eu27{<}|LUtTNMPn77H30yhHS<;jC>m~Jye$2$4djg*i{Bz*VPSoQ+9{4igC%b;q zB%WP?-v#_H;B`vq@f-;JBj5!}>UvrMUk-dP@Vc&_H%W(kfo}p{w3HstQNW)Ep1-uN zr#bL>z_++u%5(2zUH?$v_W<7oyegc#x3HWZ?zg~emDlC_0)GT}KG#2U^^6mrTMPR85y(0sLp+4cvW9qQ7$u zUH?JgEo$oWeQN3aRp2zP@^funPe0hlRI`pQPviElf&2mB&CbyE-vxX<@I3W&Jw1Ud z=h{noa=6b;8_+2pPrGjU0pNcD-xkh4X7)EvDw2{blb477De0keY_A3V%K7QpCL(lR zGo5cm=Yi7sjC4+1rxPR@oO7b*0^bUJL6~lt=aABQz70+c!p)SYbL8pVYC7kO&PAnj zD(SpD@(bFtgdYFLfsZN~$Y-8AM&}xzc#AX=o_b}HfdOSCTJo7v_I#+serS{O`c&{Pgiv zbUkzq9i7`t=c3Yij#r%)gqwNJFP)dYt(q?1xVp~iTzEQ1kIo&Yb6tgfC+@Bwvo`7eOCJwum&1NfMFfqdqdAoG3DAiwW!g4#ao}%)6e(B)3GRygQLY{fPWVtedd?xP%{8r%G z%j$ZnhUIXkekz}5LAkvF_ytfNJ_wx3$)cwQ@y{#|lb-wh0_ZtVN!Q;E%G-~s>hkr% zaxXKUR37Gsa&I{BAyA%d08Zu18Bop~gnZp5%-5Oa66N>BP!603`Tb_#S2qaKIkP-@ z894PHM?k+)@tfh95UKyD`1cTb#czgi&%Um6Wqq=wPhXfHTA=nM9+73_ihIg`I)IzKDHdO}IJ`LHi?tII`R;gUX0-F=QCudII%uB>wqPU%MZ z>$Ce)vCFPs-8(Oa|MpMS{Q;dXak*zCKXbV}uX6r{@TFhG_1p6HbC-+$id!9d;WXZ> zoI@e<%KmhT&x5dUo%~NGJ&&yUh@!7hdKoOS|lQIeSGK^lvS{1$ff(tuxd|?Vvt7 z>1{neO1sfBlI4HXYZz%xYvlqbpbVzUbU`s;8)3LFawbe%qmgoOG7- zA$j6O1~_^=^OR>@tMkGGb-o(75>L^u__-Cn7|8z` zep~s%pQ}E&N?4gLe#nUzWiqhQDvg z;7^CYU&!EF!rxzJ@T`_WeDa6iHa<1O-}N&1rQz=$8GLg1ds+s6Cj9+k2LCkt{dES< z(<+Ehf$-bL=k)M*!wi0T`1|S%eoOfK_6)u_{Jk`Te-i%wDud^~I82}L+s3D6`1{NZ zerfpo$_zd^{C!&nUmX5kn!!H{e{av=$F>gQQz-nl@u?gBZk)lh!{5C!_$}e@+cWrc z;qPS`d~5joy9}PUO%R{L;rHM134b@v;N8RDy)*dK@b}CN{(Sg*c?SP7{QZ3f&(}7H zPm%EZ@A!nj8)xwD;qTrVe0unMb_QP&{(dWi|112xCxe%27sRJR_-*6UBK+MxgO3b< zPt4$tg})bP@Xg`xFEe!fzXHeW>57K>6SG?m&s_gE5qTizS?p)Bp7 zw-a8!KF;%n^*i}LtagyfiyoinfzRp|m$&w_4)_6=OS`DpWsV-T=OT{)kquj_Wxle7`>fr}J6JuhDz&>-sxx)cN#HI-jsv=Y_ZFytX^OC+Vz=6M9C& z*D&8i`{l`BEBOJY{g~axnb4!lw=0R~@Np3{ca|&Tbt12f*9oWbI@%ZcHP~Cl%boam zhLp)RpV4LG*)=<2=FaDy`JS0=KBLR>&i6&k+*v&j0^jU%&-`DOJH9IEp!fw9`IWun z<$2yP{eN`1$R~X+iYMt`aF%(B=(7Fv+)W~8?tJc<@1*7Jo|WdmqRY?kl0Hg)7f$(l zK|3eiJfn5fB@P!o%lrw)^vjnLzQTXe>6hgbTzeDw!QIoP)9lLSBH!m;M_xGj162Iw zdPW2JOQdmo@)J(}x0QHGxRW5=lGdA4KT;P{z>DsFJGsJOY2_Va@!~JT$_MXyJZHfpP}}Qvff70C#SovM&h%+kxA9)vh|nJ zAIUaSHNg(4-$DHdrCloVq56x?Gg9ozGx6*T`IO>$;icxkqRZw}C7zyCA$8TfVTpE1MsE5 zi@P5-I!=0nQ=ImQT5 zzk~e4eBCvs{_lReQh#|ya=crw34a;*ZGFstMVGAy*SOp>QojMue@&#r-1&Mu^L-xh zg}__%HUAY|R?q9eslWD^+pqMD*3W_GhVcqz+(Yy^CD*MZ2b2ESJu~g z=KqdbX+ERN+7USuqzo4Xkfs*?F zq5cv1^Qj5`d1eAn>d%M#_N>VnFKDctw9BRQIly-TfBa}&5A_pQWI6I;C%?E{?27u8 zN&Nzm|DVps>hZb7fN%?h7{)LkI5lZUkC#fHv zq<(dh`pHS^_vTRfw@K>9CaJ%gq<(3V`kzVaXC|pX8S)!L{$a=u4EbqE>R%KFY6 zM*8K)Lh5&Aeq1=M-yr{@pZN{u^vl=pncviJI?Zj*OSpHqdW0+e0^v%(AmCr5$0iyF ztGHF?%J{ZtB=2Y#m-pYJ>^LssroZqVkk04Nj_a}gi&N(~T;jh5IIY7WKe4nvhy2Ih zd~7^E)=oy;73Y5ZC7wCpxu_l6@88$&nGi|;o1^`hrCt7dA&E~7SHEY(b`DAt_HS+a zQ#-j@j<~!Znv4T1bM;HO_xFp-TmAoXxyUzi)6+8=)&c**U4JEdeskAf34a9Qd2Jsj zo+3~E_XBSK{r@TcZQ`%%?{Srj=f~sYXCF!DobLRK@aG%Fo-1@)QZ#c)V(EH@yW=yWfyQm< z{Fi589o?WCoNz_I;-B0zk`*U8^1^?Z=5W!Y_zxHPr0Z1@jJJq>Wn4wLGJYalnU|ON zE9dBmJe{Mb%;Srmr03|-d9TWP0MW0Ur!4VIdY-bfu0!-I=OBxII@gufA<#LDCuTeO zTJ$UDzzVN-g(ENVRL+MLc{;Cir>jTgm30xKUpY@!3Xm%SSPUFw zIQb_ezkGG&zx;FTOB=1JRL)R8`L!c|Xv@HU_5dfpVdQr!XNMqu_S4$cS729+)9ue+Kvg;N-`N{QQvLPV)CSvQ7~H%=&Z*aPo^teg%s`xmU7t z5U%~S_31b$_eL+YlEJsFcb*6S3-HR1=z8vka+S{iJyh$vX#LfpT4zP;cGg1qO#ZmY zFBAFcB7aTFxxiPOH?kG#h51k~?1p+_N{yppFWB0N!X@0fwH$fjCxahyg^T<$kXN|K zKYKwuT-z?%0sNE;b@^=IPeT1j{6~#YA1GhbI=!BdPfvjSvfDkM!ZR^%2Kgli*vX?!;?Ha6ecE)7 z+o3-WDf$ohxJ1()dbqS7A?x#a{B1eV82EhPe*#zb4@x>D^&3X}2$GHuGzI@}58NM5 z2Rlx?2YAVOx_l$x?*ZQnoYtEyc|Z?$d*e8_c9>vXRLa{qE8}{sJaZNY4CJm#_Av&dbC4NjeXa&QYRvERE+p z1om^5UlF8V)_(RA&zCM8*&B^RD*aZ^Xc%@$T#s+Y!UqnGb8ClmZu|6+x;*XMssa6C z8YiT2X=>lrg?4Y!{<5+UMbd}*n{&b5>h6xGkF|3gKTOyU`Y^8E{PN6)(q9mM{V?;_ z=(6wk9w={Vyn^}>)Xt}VBDLF__zm*(%jSzxV4q~S_qy`Zj#ADU7f$y466_Zq4gQB; z0A8%W|0HRb?RU`mT&KByn)gK`0Lg9UYI4A5W3rn;qx=-|K2Ahd^*uIr=qV9I(w376LU z(fYBZ>pzusp%Sjrj}uOQw-WSsL{ByFi!uke;zz|Z7JC8g->3cle+|>^xx{dXi~ie2 z={)Irvs14(v5hWU&U|!B#LS(oXFr|g@F3kr===xJGjgUbzvO0}kA`r6aoZ;npV@!J z_1N;HGw44V^k1~c(IfhI>~*+j$QDS?EC_c!q{DsiT$lf@huaL|bG4iP68{yzZ-n?4 z0{I4a#^Yn{XSQ1odq#3zM#b-!+rkUE?P`f|=vfK!O>Z!vM3;SEioZdL=gJ|GthuxDdw?r`|3uHKO>sTe z&hvb%bHz`f=y`6lF0c3x6#4VF>GB1>a=6GhbGc_EmHka3U$2^zk3@b6jAOicozWIu zHa$y0dMf@QJ@em+yu?R&k0M{pO@EPB-j~Rq1?jB37m!QGv&`(Yf12J^&I`S!zJC`5949~YUO+GvLvqO9+!)r_TT98wHoR1 zKjvS${O2b-@}mENpLO|Re>z;`4?uk0h4@_mtE0y=WKJ_DKEl19%wMC+rrY)Ieo2W> zeUQHf?Ehtm&*D>^_=x^_ke)A9(dD~*8^zt++4xs)?8tlO?*}3M7nXG7B|bAC{%=8g zezDzz5?wYvFE(`adq!$E$iEBny}%xtfj!g*`C=eH9^|`&{6NU>HBWS&SJLwakk4CO zm(S(S7l@upa9+$gP(I9V;OLk1KMCxuXDLTs!hQN9^VXuvf4{;X277zUmG{hlzYOws zLHcZm^m!WWXENB&YLK4?@+01fp4Hsh=RE-NKNjp~JLtb3>6ZFr6_CQCFUk&o-g8UMY9|HD&0oZ3RNdJpn|1eSxj0X8{;C;0N z`OVNisR!v_9MXUL54yd*)>OBj=f2hDFFi|_-vs$_KIF#*@VpC7ar8@ij{n+;kMPso z@?7{vu>aq{o=@N5==Tgc8QxbnkZ%FAfU!1KNY`LW=6&hv`>bc5%u0nd9M$X^HYYoI+g4dPP}^2=tB-wOH{ zfP7WZzZ>MYfc?xa?4+lZSD(ZCdJEoHWp^Ay^vnQz*a7kBUr3Kn5wN#!Aiuv2<;i#` zPd<3tFI>|uzr7^!?*{Sj=B_Ui`Ex+N8k9d5LHYA9kk1eOi*F%)rbGQ$4BC@lL;d*k zXK9J!-`ey!AL5e-#yz@$d|t?pTi|`Y>W()``Y(p`ya4LQGoXIF57P5oNY9s`y)hBe zb0V~VE`|2beIP#^4=Sz@34eaelXrG*ToUVTt*yq~Zy8P!LU-uYYzB!a9Jt6-2q5S^|>}>_u z=iMOxtUDhe_VYgE$7>+{KZE|%0jOVg6xGvb4Cvnp`l~~I{RfQC6o&Y$D51yac!z>?yD7e+KH)o=`py0sFiP-tTmf9}n`6g8V%ozY64^2l>k(eM*(r z)8{Q{k2O6A^(NGJCqnzv1ACZPK#xxou!kw7b@{vD{kDSlyAJA?>!5tz4dwZ(P``Y< zRZq8XpncU2p0_pFf8%#`{lh_jUg(c}lhV`kC$NVN6?FNlK)wc)KNCUzVvzq0%Ja{l zJzoRbx9>svoDB8dez51IAU_w{^Xnk}A93e}r5>pd`L{o$&sNZ10qkcQq~~Br&le#7 zo={A;hwH(fD^%CzPle~5e3C9-8S?LbNdKM?pDQ7K_JaHhkZ%t5TnOIR5|F?4fS#{! zfak3Q<<)E`uew8d)dboqF*u&8f|1HoT@j!kL$QOe6EQ9#BhW=3* z&|eDd?I&mtG>7=)hxBqX6@J9hFRP#Y zB-1%5%Dxy07yTrEksfL^&s!>YoZI-&`87%RcPs1vC7y?SUv|=c(BqHM)1k{~KSk26 ze4#x&n#RIg*$?$?!}uR^h5Mu~x+KoCLVirwIQPv%^wa?Vw{yoj@hNXKyywPW?2XR3 zKFQT1^7UQr8U5t1Sn&%j^2^OX#V^s{HAfu!Pb0ixqd51|P55)|n_;n{9_3a{;^ zr|_@m$MyKhCHy$oZ;bE<+Q!p4Zz$g$_S1E7-DCWZsY1>rszz6Wb> zuZ)bx-?tOdqnu+XdaA;{Y=w&++CNMCyJ^2X?d$w?v=e`cXG^j6=x?^%egt@qv5~B~ zv+_k;|3&g#ivJ?d{9gr_uT=aRiTsk|MiL*zuaU^tudC}<&fOFF z4X!+K375|4d$({ZcI6DqpL%Zok~gxaOHACPzwr0m{3ZO)jCq`6L-}cL{u238ZaxzJ z{*&=={q*+?Y5bJVTfV3BCT{!3Gm>PX6A>@BIQu zXF89ygWHak`1E(V*vX477y0SX?wz*IPrS6tz85;b_zY+#{{+17`ZVSKt<87T4w(Y- zi-G?Ie2v>~_e@MGd|*DK%f@HX#)z3an+|h7)cGoxOZp!G-Vgc#^;Dmw+F8y(2I0rIE`$BY8LQ ze*tek!qG2!rUFk*)aB0uJ{fqsn{+*MfdAlfNr&P$>w2yQz7F`Qx9ECC1J5xbX*(2l6YwhO;my4d`M>+Ds+q-rse1^*< zT(aAgJH8}(l8#5wa}9Q%OX5R*47N8-#V&u`N#u)kjHiR2-GtM*fuo=ubv?9~UN|Qf zY|4h)@3A9L9GSvo&%?>t?;`vW?s@>3~)Jfoq=S#dpf+&Jkt28~P5 z_yG0C4^_XL`q9)crv54QL#e+>{Yp9?oX+W{^R?+5ZKd5Mc24cdV$cp;(znC)`UNX~S}ql6!`(fl>K?DNt%RVjDe z$us}0aEXsHekJnC_?7TaKQh{)%f?6XgW(w|8rK>Q<5A?tHRJK*Qc-L3C z^ryq)OE3hQ6$f0geM$(lQx9~FOb zp85MP?sEyhm{CLW9wQ{+n z=U$hKd|h|FqR4M@xyTnS<%BEpE1~_+qf0z}vO+tj`3M?+{?)ZNiO*Am;_6Fx z&ViM1m3EGB>OU&=smN2mlIlmL{t`Vj{zLPybnXNBQKxy^q~k*5kG-So&qv-norim2 zww_NXx?IwS%1`R2=j*BKSI&VI{dBJD{e5&jU%OoNbS`JCJ(cPne&-C!$yvY~_6X$d zr_GOxUb7_lw&l$5RSuVMmGzmPkyO@a3Rl)=3Rl)=3Rl)=3RnE*NqiK)dBTTpP0kl$0XryC>Xa} z`@9cyigR1f(mB`L3a8}yKK!=!Oy_^mIlpv10-dwjqNpD3RNxzc7db)K(+T)o;9G$& zC>H2{BK)@LL+7B;dB=2K?OP}6`tugoc`M*Efo}osmC*I~1pYYiUxAM*8R(xFe%o}T zbK>YcXgbgLp_6p|-vO^uN|zr9`~~3qfuB=a*Z)q)GtUX7bMgMSokL3XCY=vR=YZ2W z&UDV{uJXbA%B;uhRM7bd;46UVIz`vBA><#2-!@+qJvETe`AvGxX1&t`{h4|u0#AB=deU=;2h`Q$^9As>XXx^8 z03TB?ke?KOTRU6~{Bz(Zo~i4hb4xdZJe@C3=PysFuZQ~*@ZW%+)2k@%4_<@=+Bk3e{?4FgQ(xM0OYAZRUG|ccv-6{Zc-l|@=NNNeWUVE^x1W!MH`t}~Ww4I=>K7e(&yc%ca=7HLl`a?guYgxr z>gW;q-oT##z7u%umv#NafWHj2i^8c7iUy!sQ}g)%6D` z{Bz*V-1Ce?ei`tSi#zcV`MZGs1$h!>#hS7d0GcJ3f2cc z4?KTq{kfV0p9g$5@JeNL{n^0h1K$k%I8WDqF7T1S7X$wu_&qSLTg&yAEAQ(O;Q1=( z@t**EJMgZj=z3nO<8aBpTds;cmABK~a#iH1yuBi&$A`+>YYtI)d#1atM&g;Y zyv+^eCzZD~+;UaI?dx)}lP+$#D)Lm`PISvvk*D&ur(3RyJe9ZO-Evjrsl4s#mY*U| zE@RT=XPu?=5lL zd!m1cTP_ioaFdo-w9f6@Vkx;Y*T2#H$m=Bo`OI}++ZzSke&!0>|0Vndis_eM>U-vQ z6X4_r;2n@JoiAN`wR_kQ~K$AsLLhX`(5rC4gYev$XDsF>mTFtAbkeu@=FHmyy0~^ z$8)!b>hgnz>zw@j94dc4$s+LLwpe!v$2PwFq|KjjxF zssEq#)AjVJHbdvX0&jY|E`Q7&I-d_bsehq=njazZ7c_9To(?lzF6G86F87RvEx=Em zqwDVtd=2nvXT|l{diIyI9qt)2XQla!E;}ywpYr>+E0@#n^Gxh!w2O1Ux)*)|l*2z9 z9hdi?OXO*vZ@b@2DA8r*X@3^^?V){G5 zVD5Y=&wO7Ay!!QVJ$`db=C*=`JGn$M~VIq#s+%Q{03+H(M;`ixyYZLW&Rpn z{(pPsSJ_SxGk3n2XTFv8kL2s@mFBO}W%G-Yk31u_XQla!E^Ak7E)U{w|6 z+VxZ9ng6{FIPH6-{p`xVS9xCYvsw!BBjwYkH`pf)zWsKl=&yI9&MV)f^KHk)xu05| zA#b?tH{lHin7>AsZQphWJ_>kCw;d?)9|X@;5!y5R1~~6m=Ed%BAH~t!$XPY43QGL`F>Zu%Ef^h9;R#+ZVf0_EZ9UrzDf^S=|wO`Y3N z{!*7qK5g`vE>C{p)_{DzMY^6Ez`FyV4*U(5OZv#9^?HLjvkSxby=0))aA)9#0PKb^5nNl;SwM63!(U@ z@=S;d7d_;+>bdvycn)}9=l>}`S66-L#K$v){9h?t(t-S9kw1-Xd-QM>F8Yu8-H{i* z(dC|zRJh2$ve(fg@(LIEUVrHF3K#jJf9moI7x`Kszt80&zXSFYHFW1^<+&6tdT8F3 z=4WXhw(n8#_MYwUpC1#{~9&j&sl_&(qzVLUb z8hUyvT;yM^rOPW^6=QUA~SxekcH8Jmhl@Ph`VH^&%ktm+jGTU1{$b;E znlk?RMSs%qfD`7w?j zNeAVeP~o?R^G!ylx%~JGSNvcLuel+Rv!Awqbe+pZp8Sp~^Ru4OdF=;QbMS4)@wNdc z|E1(NJHh#Go{0gC1ME-5)7hrOxo-b4NKcp-rupLiu-Mw%k zPsu;t5q}Xu{-XKfq<$n;*A7|~ne)r!FM|Bwkza@=b#(pY|KT9W|F`>jpm}`qzxUtn zH;>j8B%OaBy)dvJ`)S*~&jbGjc;!c|hTz-k=>hy+;2#4o@~E!A4e-gpmjVA1_=)bi z0_k^L^Fk1x)57m#!v5^Tz`q1u`bAyOvmv)n?dz9tH!im%__pB|g!y!uXa5!CX}{Is z_KWhsZ_abc^FH;v&S~EEE_dEm^w7L*6L;QLcxlkR6c zGM^jd$E5SQ|J(dCDD%;he`((NpXQHOnb(&1AFBCl#XpbeSIz?xo^)PY@#iCYjy>(D zScAZ}i)bEP8NU@hG!MQ4#(QZVyt6wGF8Zgq+%pkZxX9DIc^`M)T;%5hr}^}sYwPKD zGR(6pT*6%j@(LGunwMAnhlqTFd3lllr}>wDG~;|{+dfY)FE7vatULcM_Ok={DHq1y zubr3A20jP)2f*`Rr0c%`_zl2c1il0Ksjzz6qUSd!@ANlJ{gbxL- zq>so~hWFmmoGUH)ciK8#zj98r z$SdpZC0xp1TOi+2x+(cf^cM%aQtVCSX+@$G z6Srqu9@4sE+6PVL?V(y%oVqpsT(5gRQpNEUr@~^@#pgEK}r9LZhJ;}ne4c{Z|B1QxJu`Bd+NN1SY7lttEVaO^R9_x z&7GAW?sCyU{&p6^er;txwP(VaIn{hdmksy9`yyuUEdQtZZ7Axl+w@F)SN4vVtG1n> z*rCWjFJr> zMd#0T)%iZ)=Ut}DzkYq3+jWd}VLf4cmrMF6>kNhG_{@I^X_u{ko4DLFVsoxc6ZUWY zd?9ZzY56e!c3lsxzb)_9cb?JE6?oG1w*@Q4)7iFH$uGo}kPe$&F7c%FA^#H34lqv_ zUAFu=Z(_vEolXA(;O~O`MO1}#xl8)T)4?w{|Fv;$^J$m2b^bH(Y47Oro!-^?ryuG3tj#(fzD4I{ zKh=5G=Q^i;^rv6x^1tlT`O~{~o@bBFuK-T#t9!ye*00?Cs-6k4mD}$VuJi|mliyVG zYf64=$v-Xmp(TH_+hPCRdN_B0>X$pK#>-o4&y(GG3Q30s)phw6HFaLd9k&-f6JQ_Q zU9jKnFKGXezn%HeE}9DMoFBW#De!{B;_~)AHU&Nn_!Gl*J(RB% z|HhJT6wh4{|7BUhd$ON?EIf0+6Z|BXhxT?u;M8uP1@hFMKM3*)mvng1ZKnzU#^v(7 z)P9=|?YAYssl8Ve+ItF@c%A|BU4c`3a`SrgHlxet3x!L#e}Q}%XqQrZ^&)7mDqO*C|u(6D#&jKPW_-;VBAUJ67J(5zX3S)vj%T9 zsU2O`ZWS)!&e|Hunma5167ZeC&);VLJGy*5qW@Btdqzs(B0mP?=L4s6)|!14#l_s& z_;ho*Xa25miO*P&e-JqJXHWXtgc4mgofR(OHU{}CfYZ1)&CAeuIQjpiadPr+P`!Kf ztme+|4#;y2cDZN%zRcw!ubj&u^4)Tp|B9}oLjCl-^jsAGq~|6ioyVNBGK#yov-Y_M z_&;sFCh0usD;?s`>(86W``ve2oLf72VY{5Z9b#R*YBBM%K0_I z>HL~TeawGFm({cInuwV@pUeB&3cOTbN8U3e>G?P`??&ft%$)6nEAc$+=TNx)cM11< z;3c46pACF7@UGeV^X_%IXC#$+S-3K8ApESheodTq7vWFZ|4Gk)#VcI+%F>?=FYZ@Xnj|;g!0O~wuD;^=53Yv zYmwhQARbR!?#=3^^G0{+e8j)cCERr&pTjN3JQL!3^UP;-*?5+7?ZGoryFM~;(0+&o!``3=XB0XE|`BQ=B_J{aQ~X`CtliR?SJGm zY0$s5JjY_4_Xj=?_(#Ccdsf#!4EPhkPgrbXNS^dq%SDGDlv@v9nh=+%x1B;L84ekthGL z%Dz02r~J6u&8HGi#U4Ztom)ZYGF+U3;rMkuC z{dSS?%YZBE^hBQKwHvtWNJYNS{b>*7-`e`+R+o!>w{f~W_4m6!pvxBx?ce^@wiCX3 z$&%pPrgMd*I`0kq3E(?{*M3>oKMeTGzz+gH=M`Q5B;fA=U-GK1=QWqh`?~ryU4Dqm zMV`)~XwylzPx9|Ncw}7O&WFy-j>pILE1P%M`AnC4Mv}%A-@d}pBl6ULr}cqK|60=L ztlqkQ>UZx1`66z=Tl7+K!03m_lln8?m9-{gIzA^N$Vbu8>pwxW+;Ce zLpej`(vNOCP~zFTPu$-8@>AkT=L3EX^8d7cXj8WxE6+>oi<0)^rWOs}SLXR&t%?Uc z^PI0Lr2?LLo>#Gx1D<(4SDgw0&pe0gsfq#5JP&JeWu0eL)p^Sr0na=SYeC(BXZkDq z0{Bby1NqGJtr~X-xc#)_-t9YE5`1Tc_EzADIJfmz-lug={Q_#ACv6W?y>{GkJwAQ+ z>HIh^p1; zU9|=N8`xDlu&cTY^z?5Dc2yVbiu$M2Po#bywSQ`W{X7o#b1v9VH#jd~8}Od>r;pUiUdNwDXJRRZ};J0A~x2H5%0 zH3L1F<>yqe=Qn_#)*#T6S$_5cJ3rk1^lpLt()g($p7zt)Pj|>ihiW|MaF4?rs{Tkj z$k)ogdufL#`|gF4|GFJeK2+Ur-$?Ln-^)lSHx$1*p83xSb@lQ=@zWym3YYjFZoeXT zLb=pDV?M>!r!Am9%?stycPE+DNTo8{Y3n_~smylTuJQrTEPv`lJB|DdzX|2fp6Y@A z%yK5Fzt#y*pH_i#=EKK>aP6nHt8GvYP`ydz0Oe~MXV|gK#w7T*@u>m%VsjbYp1*As z=hjY?{ikBjH@Wlm!j*lg!k=#xkEcI>=NYmd_$0q!oPPPS^UUv+XQfk_Hx#b4tA&>s z9+$V{QICw#Ir(3ub~v?r$zKq)Zx#PM692xC4)cI71O5r{6@G%GUpAd-{S2*>`Or6* z^vmkWJ}#X`=V;Tue%hC+?91?s=D}bOgU>d9jV^0%G4@VLgy_ZA8i?@%U2w)bMj-b zZmKR%`)hLFr^_qj)t-^0dAf@3e6+}uA7<)LQNL!?8z%JVvgP(Wz>95)WX+wGr}fx0 zKTi9PvY}oe|7O$=qIC|m9&8)T+ba9NJoDU2`(OCuV7IS~H2)P{Hh=vN{MXTuthuxD zYv$;j{BKi#;R~2Aqjs|5&&o3~+4@&JKGq(J{QLeDMNfrVeo38nSv^Z&f2HF8Q1mE% z4u#i;_A|As$!{LDZ*PWrXBqG&{y=W}W$UR)z~2F0I$ye$s9x&@d%UDKly*S6zc0aH|cts-mY_6 zhdJa9M_yV=d1pG@GbHJ{De|vEepJYR4vjC-xd}AyPyNT*upZzM;MDI+a1Mf`XPGr7 zRin$6|KyM264)n8`(72l#GVOF@jonl1o#111bhnk2Y3Z|Td3D=08W0BXgr7fwbHr{ z>UTGS^&X3X=WZ9T$Ng$c((_DMUrOz?%CPQ~_Ae`b@Ff4zx{*WW4}toXy&D?qiY~wY zk{-$r8RKAn`Uod~2+ICw&uAsT2h?7r{<7kKK=e~TSMfg}@-#n7&$S_kd5Y-rt;RFI z=(%RW_{^Nfkq&cb+X*Y(`cdqG`kUlmh59K3vTrTqKT<)3YQ2JjYKj}^L z*XXk4KGK!xo&%|084-q{|ItW+76+P|U^{yg+2XG}m zB7fGkPI)DK^+1P9xP@I#^1`nltn0b1lSz%}$_nj&5%8~omxT5t&Er%1a|`HM(J_jn zxwG;7064Xudx3mec&@g<|69^6M;ATa>H;S}s26q(^t1`TZ99LU+ddb2`^4p*(NF-! zCC&qWJ#ZS|pz%5y_ojZt^pU~y+E4#^<+*5_q{hQmGWfRTVMmvXo^dYs%zr)t{A1u* z3xe?Mrwy0ZIkX3PYM-xp%xVt4t^RzAbY25^ci_{3e+Rtm<9fK40lynK^*d-@gT^yy zTIweu}&PpoG8baqKF3tBfz>mHM? zH=BEc{#N)cB$^`b1xo+os;B`G+ej;#M7ewp2XiBbFG}mRXuUnHmrlCw zl-7gMdVX4uJ)>&yelyp*9y#YdDEBU^9i&g@y7ckDlb+{Z?{r;%(sSPTfS#o1zb~ny z$LD|Qx$yt(=e)0V=YOSL_un#3^`9CKIdZOjP`=T*_D9BHg7ir`-a_Llv@V+VuhIS^ z+D|bR_E|g!d@Jz0&jjVa{j~k=r0ch7|J@P49D!XOD!&|u+t0=kzX8GfBEJC%)|p7X z+~HN5vx0A%zh(ee{115MKlg(CxvvF!?WfhR_$Ba+%nPfmWbkd}OT4c0XMq=eLzky> zGn4LnB0t7-j@95V^!OC`O6O1g?r?cuwBM@9AG-Wcz)$$gk@pN~3;cHAwBD8WxzN62 z+E1EvA6ei1`g1)FeAQ7$#s0y!H%aGqxpc0aQz`OE&k0?h&(ZIhh@6yP=etYmyb`Pr zr*-4=L7w&>(SC5+=S%ze7JGX9zX#r|tS&zm_)_4zf!8Rf>+cJ^qdWdD@16E1DqQ51 zb$7y*b$7z2)X?LpaFL(ut{WFl>%$c;^0aPT;UZ7##+7}SV&@7MJxR|wJ>2`skDP0t zlJ`aD+8>$U4ALj*JSNRo(z;D$eV4qKiw6YdL&xwtZ#b_#ApAWngO`W(S9IR}KdpWE Fe*kVUhF1Up literal 0 HcmV?d00001 diff --git a/src/MapleEng/lmbc/BUILD.gn b/src/MapleEng/lmbc/BUILD.gn new file mode 100755 index 0000000000..08ae04b2a4 --- /dev/null +++ b/src/MapleEng/lmbc/BUILD.gn @@ -0,0 +1,54 @@ +# +# Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved. +# +# OpenArkCompiler is licensed under Mulan PSL v2. +# You can use this software according to the terms and conditions of the Mulan PSL v2. +# You may obtain a copy of Mulan PSL v2 at: +# +# http://license.coscl.org.cn/MulanPSL2 +# +# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR +# FIT FOR A PARTICULAR PURPOSE. +# See the Mulan PSL v2 for more details. +# +configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ] + +include_directories = [ + "${MAPLEALL_ROOT}/maple_ir/include", + "${MAPLEALL_ROOT}/mpl2mpl/include", + "${MAPLEALL_ROOT}/maple_util/include", + "${MAPLEALL_ROOT}/maple_driver/include", + "${MAPLEALL_ROOT}/mempool/include", + "${THIRD_PARTY_ROOT}/bounds_checking_function/include", + "${MAPLEALL_ROOT}/maple_ipa/include", + "${MAPLEALL_ROOT}/maple_ipa/include/old", + "${MAPLEALL_ROOT}/maple_me/include", + "${MAPLEALL_ROOT}/maple_phase/include", + "${MAPLEENG_ROOT}/lmbc/include" +] + +src_mplsh_lmbc = [ + "src/mplsh.cpp", + "src/init.cpp", + "src/mfunction.cpp", + "src/eng_shim.cpp", + "src/load_store.cpp", + "src/invoke_method.cpp", +] + +executable("mplsh-lmbc") { + sources = src_mplsh_lmbc + include_dirs = include_directories + deps = [ + "${MAPLEALL_ROOT}/maple_ir:libmplir", + "${MAPLEALL_ROOT}/mempool:libmempool", + "${MAPLEALL_ROOT}/mpl2mpl:libmpl2mpl", + "${THIRD_PARTY_ROOT}/bounds_checking_function:libHWSecureC", + ] + + libs = [ + "ffi", + "dl", + ] +} diff --git a/src/MapleEng/lmbc/include/eng_shim.h b/src/MapleEng/lmbc/include/eng_shim.h new file mode 100644 index 0000000000..2c29f723b0 --- /dev/null +++ b/src/MapleEng/lmbc/include/eng_shim.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved. + * + * OpenArkCompiler is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +#ifndef MPLENG_SHIM_H_ +#define MPLENG_SHIM_H_ + +#include +#include "lmbc_eng.h" + +namespace maple { + +extern "C" int64_t __engineShim(LmbcFunc*, ...); + +} + +#endif // MPLENG_SHIM_H_ diff --git a/src/MapleEng/lmbc/include/lmbc_eng.h b/src/MapleEng/lmbc/include/lmbc_eng.h new file mode 100644 index 0000000000..3ac873b23a --- /dev/null +++ b/src/MapleEng/lmbc/include/lmbc_eng.h @@ -0,0 +1,151 @@ +/* + * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved. + * + * OpenArkCompiler is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +#ifndef MPLENG_LMBC_H_ +#define MPLENG_LMBC_H_ + +#include +#include +#include +#include +#include "mir_parser.h" +#include "bin_mplt.h" +#include "opcode_info.h" +#include "mir_function.h" +#include "constantfold.h" +#include "mir_type.h" +#include "mvalue.h" +#include "global_tables.h" +#include "mfunction.h" + +namespace maple { +class MFunction; +class LmbcMod; +class LmbcFunc; + +using LabelMap = std::unordered_map; +using FuncMap = std::unordered_map; +using VarInf = struct ParmInf; + +// Parameter and variable info +struct ParmInf { + PrimType ptyp; + size_t size; + bool isPreg; + bool isVararg; + // use scenarios for storeIdx field: + // ParmInf - idx into pReg array if isPreg (formal is preg) + // ParmInf - idx into formalvar array if formal is var symbol + // ParmInf - offset into func formalagg mem block if PTY_agg formal arg + // ParmInf - offset into func varagg mem blk if PTY_agg var-arg + // VarInf - offset into module globals mem blk if global or PUStatic var + int32 storeIdx; + MIRSymbol *sym; // VarInf only - for global and PUStatic var + PUIdx puIdx; // VarInf only - for PUStatic var + ParmInf(PrimType type, size_t sz, bool ispreg, int32_t storageIdx) + : ptyp(type), size(sz), isPreg(ispreg), storeIdx(storageIdx) {} + ParmInf(PrimType type, size_t sz, bool ispreg, int32_t storageIdx, MIRSymbol *psym) + : ptyp(type), size(sz), isPreg(ispreg), storeIdx(storageIdx), sym(psym) {} + ParmInf(PrimType type, size_t sz, bool ispreg, int32_t storageIdx, MIRSymbol *psym, PUIdx puidx) + : ptyp(type), size(sz), isPreg(ispreg), storeIdx(storageIdx), sym(psym), puIdx(puidx) {} +}; + +class LmbcFunc { + public: + LmbcMod *lmbcMod; + MIRFunction *mirFunc; + uint32 retSize; + uint32 frameSize; // auto var size in bytes + uint16 formalsNum; // num formals: vars+pregs + uint32 formalsNumVars; // num formals: vars only + uint32 formalsAggSize; // total struct size of all formal args of type agg + uint32 formalsSize; // total size of all formal args + LabelMap labelMap; // map labelIdx to Stmt address + size_t numPregs; + bool isVarArgs; + std::vector pos2Parm; // formals info lkup by pos order + std::unordered_map stidx2Parm; // formals info lkup by formals stidx + LmbcFunc(LmbcMod *mod, MIRFunction *func); + void ScanFormals(void); + void ScanLabels(StmtNode* stmt); +}; + +class FuncAddr { + public: + union { + LmbcFunc *lmbcFunc; + void *nativeFunc; + } funcPtr; + bool isLmbcFunc; + uint32 formalsAggSize; // native func only + std::string funcName; + FuncAddr(bool lmbcFunc, void *func, std::string funcName, uint32 formalsAggSz = 0); +}; + +class LmbcMod { +public: + std::string lmbcPath; + MIRModule* mirMod {nullptr}; + FuncMap funcMap; + LmbcFunc* mainFn {nullptr}; + std::unordered_map globalAndStaticVars; + std::unordered_map globalStrTbl; + int unInitPUStaticsSize {0}; // uninitalized PUStatic vars + uint8* unInitPUStatics{nullptr}; + int globalsSize {0}; // global vars and initialized PUStatic + uint8* globals {nullptr}; + uint32 aggrInitOffset {0}; +public: + void InitGlobalVars(void); + void InitGlobalVariable(VarInf *pInf); + void InitIntConst(VarInf *pInf, MIRIntConst &intConst, uint8 *dst); + void InitStrConst(VarInf* pInf, MIRStrConst &mirStrConst, uint8 *dst); + void InitAddrofConst(VarInf *pInf, MIRAddrofConst &addrofConst, uint8 *dst); + void InitFloatConst(VarInf *pInf, MIRFloatConst &f32Const, uint8 *dst); + void InitDoubleConst(VarInf *Inf, MIRDoubleConst &f64Const, uint8 *dst); + void InitLblConst(VarInf *pInf, MIRLblConst &labelConst, uint8 *dst); + void InitBitFieldConst(VarInf *pInf, MIRConst &mirConst, int32_t &allocdBits, bool &forceAlign); + uint8_t* GetGlobalVarInitAddr(VarInf* pInf, uint32 align); + void UpdateGlobalVarInitAddr(VarInf* pInf, uint32 size); + void CheckUnamedBitField(MIRStructType &stType, uint32 &prevInitFd, uint32 curFd, int32 &allocdBits); + + LmbcMod(char* path); + MIRModule* Import(std::string path); + void InitModule(void); + void CalcGlobalAndStaticVarSize(void); + void ScanPUStatic(MIRFunction *func); + LmbcFunc* LkupLmbcFunc(PUIdx puIdx); + + std::vector libHandles; + std::unordered_mapextFuncMap; // PUIdx to ext func addr map + std::unordered_mapextSymMap; // StIdx.FullIdx() to ext sym addr map + void LoadDefLibs(void); + void* FindExtFunc(PUIdx puidx); + void* FindExtSym(StIdx stidx); + void AddGlobalVar(MIRSymbol &sym, VarInf *pInf); + void AddPUStaticVar(PUIdx puIdx, MIRSymbol &sym, VarInf *pInf); + uint8 *GetVarAddr(StIdx stidx); // globa var + uint8 *GetVarAddr(PUIdx puidx, StIdx stidx); // PUStatic var + + void InitAggConst(VarInf *pInf, MIRConst &mirConst); + void InitArrayConst(VarInf *pInf, MIRConst &mirConst); + void InitScalarConst(VarInf *pInf, MIRConst &mirConst); + void InitPointerConst(VarInf *pInf, MIRConst &mirConst); + std::unordered_map PUIdx2FuncAddr; + FuncAddr* GetFuncAddr(PUIdx puIdx); +}; + +} // namespace maple + +#endif // MPLENG_LMBC_H_ diff --git a/src/MapleEng/lmbc/include/massert.h b/src/MapleEng/lmbc/include/massert.h new file mode 100644 index 0000000000..2030082a9a --- /dev/null +++ b/src/MapleEng/lmbc/include/massert.h @@ -0,0 +1,30 @@ +/* + * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved. + * + * OpenArkCompiler is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +#ifndef MPLENG_MASSERT_H_ +#define MPLENG_MASSERT_H_ + +#include +#include + +#define MASSERT(cond, fmt, ...) \ + do { \ + if (!(cond)) { \ + fprintf(stderr, __FILE__ ":%d: Assert failed: " fmt "\n", __LINE__, ##__VA_ARGS__); \ + abort(); \ + } \ + } while (0) + +#endif // MPLENG_MASSERT_H_ + diff --git a/src/MapleEng/lmbc/include/mexpression.h b/src/MapleEng/lmbc/include/mexpression.h new file mode 100644 index 0000000000..e3de8becdf --- /dev/null +++ b/src/MapleEng/lmbc/include/mexpression.h @@ -0,0 +1,233 @@ +/* + * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved. + * + * OpenArkCompiler is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +#ifndef MPLENG_MEXPRESSION_H_ +#define MPLENG_MEXPRESSION_H_ + +#include +#include "massert.h" // for MASSERT + +#define EXPRBINOP(exprop, res, op0, op1, exprPtyp) \ + do { \ + switch(exprPtyp) { \ + case PTY_i8: res.x.i8 = op0.x.i8 exprop op1.x.i8; break; \ + case PTY_i16: res.x.i16 = op0.x.i16 exprop op1.x.i16; break; \ + case PTY_i32: res.x.i32 = (int64)op0.x.i32 exprop (int64)op1.x.i32; break; \ + case PTY_i64: res.x.i64 = op0.x.i64 exprop op1.x.i64; break; \ + case PTY_u8: res.x.u8 = op0.x.u8 exprop op1.x.u8; break; \ + case PTY_u16: res.x.u16 = op0.x.u16 exprop op1.x.u16; break; \ + case PTY_u32: res.x.u32 = op0.x.u32 exprop op1.x.u32; break; \ + case PTY_u64: res.x.u64 = op0.x.u64 exprop op1.x.u64; break; \ + case PTY_a64: res.x.u64 = op0.x.u64 exprop op1.x.u64; break; \ + case PTY_f32: res.x.f32 = op0.x.f32 exprop op1.x.f32; break; \ + case PTY_f64: res.x.f64 = op0.x.f64 exprop op1.x.f64; break; \ + default: MIR_FATAL("Unsupported PrimType %d for binary operator %s", exprPtyp, #exprop); \ + } \ + res.ptyp = expr->ptyp; \ + } while(0) + +#define EXPRCOMPOP(exprop,res, op0, op1, optyp, exprptyp) \ + do { \ + /*MASSERT(op0.ptyp == op1.ptyp, "COMOP Type mismatch: 0x%02x and 0x%02x", op0.ptyp, op1.ptyp);*/ \ + switch(optyp) { \ + case PTY_i8: res.x.i64 = op0.x.i8 exprop op1.x.i8; break; \ + case PTY_i16: res.x.i64 = op0.x.i16 exprop op1.x.i16; break; \ + case PTY_i32: res.x.i64 = op0.x.i32 exprop op1.x.i32; break; \ + case PTY_i64: res.x.i64 = op0.x.i64 exprop op1.x.i64; break; \ + case PTY_u8: res.x.i64 = op0.x.u8 exprop op1.x.u8; break; \ + case PTY_u16: res.x.i64 = op0.x.u16 exprop op1.x.u16; break; \ + case PTY_u32: res.x.i64 = op0.x.u32 exprop op1.x.u32; break; \ + case PTY_u64: res.x.i64 = op0.x.u64 exprop op1.x.u64; break; \ + case PTY_a64: res.x.i64 = op0.x.a64 exprop op1.x.a64; break; \ + case PTY_f32: res.x.i64 = op0.x.f32 exprop op1.x.f32; break; \ + case PTY_f64: res.x.i64 = op0.x.f64 exprop op1.x.f64; break; \ + default: MIR_FATAL("Unsupported operand PrimType %d for comparison operator %s", op0.ptyp, #exprop); \ + } \ + res.ptyp = exprptyp; \ + } while(0) + +// EXPRCOMPOP with f32 amd f64 comparison cases taken out because of +// -Wfloat-equal compile flag warnings with != and == on float types. +// The float cases for != and == are special case handled in op handlers. +#define EXPRCOMPOPNOFLOAT(exprop,res, op0, op1, optyp, exprptyp) \ + do { \ + /*MASSERT(op0.ptyp == op1.ptyp, "COMPOP Type mismatch: 0x%02x and 0x%02x", op0.ptyp, op1.ptyp);*/ \ + switch(optyp) { \ + case PTY_i8: res.x.i64 = op0.x.i8 exprop op1.x.i8; break; \ + case PTY_i16: res.x.i64 = op0.x.i16 exprop op1.x.i16; break; \ + case PTY_i32: res.x.i64 = op0.x.i32 exprop op1.x.i32; break; \ + case PTY_i64: res.x.i64 = op0.x.i64 exprop op1.x.i64; break; \ + case PTY_u8: res.x.i64 = op0.x.u8 exprop op1.x.u8; break; \ + case PTY_u16: res.x.i64 = op0.x.u16 exprop op1.x.u16; break; \ + case PTY_u32: res.x.i64 = op0.x.u32 exprop op1.x.u32; break; \ + case PTY_u64: res.x.i64 = op0.x.u64 exprop op1.x.u64; break; \ + case PTY_a64: res.x.i64 = op0.x.a64 exprop op1.x.a64; break; \ + default: MIR_FATAL("Unsupported operand PrimType %d for comparison operator %s", op0.ptyp, #exprop); \ + } \ + res.ptyp = exprptyp; \ + } while(0) + +#define EXPRSELECTOP(res, op0, sel1, sel2, exprptyp) \ + do { \ + MValue op1, op2; \ + op1 = CvtType(sel1, exprptyp, sel1.ptyp); \ + op2 = CvtType(sel2, exprptyp, sel2.ptyp); \ + switch(exprptyp) { \ + case PTY_i8: res.x.i8 = op0.x.i64? op1.x.i8 : op2.x.i8; break; \ + case PTY_i16: res.x.i16 = op0.x.i64? op1.x.i16 : op2.x.i16; break; \ + case PTY_i32: res.x.i32 = op0.x.i64? op1.x.i32 : op2.x.i32; break; \ + case PTY_i64: res.x.i64 = op0.x.i64? op1.x.i64 : op2.x.i64; break; \ + case PTY_u8: res.x.u8 = op0.x.i64? op1.x.u8 : op2.x.u8; break; \ + case PTY_u16: res.x.u16 = op0.x.i64? op1.x.u16 : op2.x.u16; break; \ + case PTY_u32: res.x.u32 = op0.x.i64? op1.x.u32 : op2.x.u32; break; \ + case PTY_u64: res.x.u64 = op0.x.i64? op1.x.u64 : op2.x.u64; break; \ + case PTY_a64: res.x.a64 = op0.x.i64? op1.x.a64 : op2.x.a64; break; \ + case PTY_f32: res.x.f32 = op0.x.i64? op1.x.f32 : op2.x.f32; break; \ + case PTY_f64: res.x.f64 = op0.x.i64? op1.x.f64 : op2.x.f64; break; \ + default: MIR_FATAL("Unsupported PrimType %d for select operator", exprptyp); \ + } \ + res.ptyp = exprptyp; \ + } while(0) + +#define EXPRBININTOP(exprop, res, op, op1, exprptyp) \ + do { \ + MValue op0 = CvtType(op, exprptyp, op.ptyp); \ + switch(exprptyp) { \ + case PTY_i8: res.x.i8 = op0.x.i8 exprop op1.x.i8; break; \ + case PTY_i16: res.x.i16 = op0.x.i16 exprop op1.x.i16; break; \ + case PTY_i32: res.x.i32 = op0.x.i32 exprop op1.x.i32; break; \ + case PTY_i64: res.x.i64 = op0.x.i64 exprop op1.x.i64; break; \ + case PTY_u8: res.x.u8 = op0.x.u8 exprop op1.x.u8; break; \ + case PTY_u16: res.x.u16 = op0.x.u16 exprop op1.x.u16; break; \ + case PTY_u32: res.x.u32 = op0.x.u32 exprop op1.x.u32; break; \ + case PTY_u64: res.x.u64 = op0.x.u64 exprop op1.x.u64; break; \ + case PTY_a64: res.x.u64 = op0.x.u64 exprop op1.x.u64; break; \ + default: MIR_FATAL("Unsupported PrimType %d for integer binary operator %s", exprptyp, #exprop); \ + } \ + res.ptyp = exprptyp; \ + } while(0) + +// Used by OP_lshr only +#define EXPRBININTOPUNSIGNED(exprop, res, op0, op1, exprptyp) \ + do { \ + MASSERT((op0.ptyp == exprptyp) || \ + (op0.ptyp == PTY_u32 && exprptyp == PTY_i32) || \ + (op0.ptyp == PTY_i32 && exprptyp == PTY_u32), \ + "BINUINTOP Type mismatch: 0x%02x and 0x%02x", op0.ptyp, exprptyp); \ + switch(op1.ptyp) { \ + case PTY_i8: \ + case PTY_u8: \ + MASSERT(op1.x.u8 <= 64, "OP_lshr shifting more than 64 bites"); \ + break; \ + case PTY_i16: \ + case PTY_u16: \ + MASSERT(op1.x.u16 <= 64, "OP_lshr shifting more than 64 bites"); \ + break; \ + case PTY_i32: \ + case PTY_u32: \ + MASSERT(op1.x.u32 <= 64, "OP_lshr shifting more than 64 bites"); \ + break; \ + case PTY_i64: \ + case PTY_u64: \ + case PTY_a64: \ + MASSERT(op1.x.u64 <= 64, "OP_lshr shifting more than 64 bites"); \ + break; \ + default: \ + MIR_FATAL("Unsupported PrimType %d for unsigned integer binary operator %s", exprptyp, #exprop); \ + break; \ + } \ + switch(exprptyp) { \ + case PTY_i8: res.x.u8 = op0.x.u8 exprop op1.x.u8; break; \ + case PTY_i16: res.x.u16 = op0.x.u16 exprop op1.x.u16; break; \ + case PTY_i32: res.x.u32 = op0.x.u32 exprop op1.x.u32; break; \ + case PTY_i64: res.x.u64 = op0.x.u64 exprop op1.x.u64; break; \ + case PTY_a64: res.x.u64 = op0.x.u64 exprop op1.x.u64; break; \ + case PTY_u8: res.x.u8 = op0.x.u8 exprop op1.x.u8; break; \ + case PTY_u16: res.x.u16 = op0.x.u16 exprop op1.x.u16; break; \ + case PTY_u32: res.x.u32 = op0.x.u32 exprop op1.x.u32; break; \ + case PTY_u64: res.x.u64 = op0.x.u64 exprop op1.x.u64; break; \ + default: MIR_FATAL("Unsupported PrimType %d for unsigned integer binary operator %s", exprptyp, #exprop); \ + } \ + res.ptyp = exprptyp; \ + } while(0) + +#define EXPRMAXMINOP(exprop, res, op0, op1, exprptyp) \ + do { \ + MASSERT(op0.ptyp == op1.ptyp, "MAXMINOP Type mismatch: 0x%02x and 0x%02x", op0.ptyp, op1.ptyp); \ + MASSERT(op0.ptyp == exprptyp, "MAXMINOP Type mismatch: 0x%02x and 0x%02x", op0.ptyp, exprptyp); \ + switch(exprptyp) { \ + case PTY_i8: res.x.i8 = op0.x.i8 exprop op1.x.i8? op0.x.i8 : op1.x.i8; break; \ + case PTY_i16: res.x.i16 = op0.x.i16 exprop op1.x.i16? op0.x.i16 : op1.x.i16; break; \ + case PTY_i32: res.x.i32 = op0.x.i32 exprop op1.x.i32? op0.x.i32 : op1.x.i32; break; \ + case PTY_i64: res.x.i64 = op0.x.i64 exprop op1.x.i64? op0.x.i64 : op1.x.i64; break; \ + case PTY_u8: res.x.u8 = op0.x.u8 exprop op1.x.u8 ? op0.x.u8 : op1.x.u8; break; \ + case PTY_u16: res.x.u16 = op0.x.u16 exprop op1.x.u16? op0.x.u16 : op1.x.u16; break; \ + case PTY_u32: res.x.u32 = op0.x.u32 exprop op1.x.u32? op0.x.u32 : op1.x.u32; break; \ + case PTY_u64: res.x.u64 = op0.x.u64 exprop op1.x.u64? op0.x.u64 : op1.x.u64; break; \ + case PTY_a64: res.x.a64 = op0.x.a64 exprop op1.x.a64? op0.x.a64 : op1.x.a64; break; \ + case PTY_f32: res.x.f32 = op0.x.f32 exprop op1.x.f32? op0.x.f32 : op1.x.f32; break; \ + case PTY_f64: res.x.f64 = op0.x.f64 exprop op1.x.f64? op0.x.f64 : op1.x.f64; break; \ + default: MIR_FATAL("Unsupported PrimType %d for binary max/min operator %s", exprptyp, #exprop); \ + } \ + res.ptyp = exprptyp; \ + } while(0) + +#define EXPRREMOP(exprop, res, op0, op1, exprptyp) \ + do { \ + switch(exprptyp) { \ + case PTY_i8: if(op1.x.i8 == 0) res.x.i8 = 0; \ + else if(op1.x.i8 == -1 && op0.x.i8 == INT8_MIN) op0.x.i8 = 0; \ + else res.x.i8 = op0.x.i8 exprop op1.x.i8; break; \ + case PTY_i16: if(op1.x.i16 == 0) res.x.i16 = 0; \ + else if(op1.x.i16 == -1 && op0.x.i16 == INT16_MIN) op0.x.i16 = 0; \ + else res.x.i16 = op0.x.i16 exprop op1.x.i16; break; \ + case PTY_i32: if(op1.x.i32 == 0) res.x.i32 = 0; \ + else if(op1.x.i32 == -1 && op0.x.i32 == INT32_MIN) op0.x.i32 = 0; \ + else res.x.i32 = op0.x.i32 exprop op1.x.i32; break; \ + case PTY_i64: if(op1.x.i64 == 0) res.x.i64 = 0; \ + else if(op1.x.i64 == -1 && op0.x.i64 == INT64_MIN) op0.x.i64 = 0; \ + else res.x.i64 = op0.x.i64 exprop op1.x.i64; break; \ + case PTY_u8: if(op1.x.u8 == 0) res.x.u8 = 0; \ + else res.x.u8 = op0.x.u8 exprop op1.x.u8; break; \ + case PTY_u16: if(op1.x.u16 == 0) res.x.u16 = 0; \ + else res.x.u16 = op0.x.u16 exprop op1.x.u16; break; \ + case PTY_u32: if(op1.x.u32 == 0) res.x.u32 = 0; \ + else res.x.u32 = op0.x.u32 exprop op1.x.u32; break; \ + case PTY_u64: if(op1.x.u64 == 0) res.x.u64 = 0; \ + else res.x.u64 = op0.x.u64 exprop op1.x.u64; break; \ + default: MIR_FATAL("Unsupported PrimType %d for rem operator %s", exprptyp, #exprop); \ + } \ + res.ptyp = exprptyp; \ + } while(0) + +#define EXPRUNROP(exprop, res, op0, exprptyp) \ + do { \ + MASSERT(op0.ptyp == exprptyp || \ + ((op0.ptyp == PTY_i32 || op0.ptyp == PTY_u32) && \ + (exprptyp == PTY_i32 || exprptyp == PTY_u32)) , "UNROP Type mismatch: 0x%02x and 0x%02x", op0.ptyp, exprptyp); \ + switch(exprptyp) { \ + case PTY_i8: res.x.i8 = exprop op0.x.i8; break; \ + case PTY_i16: res.x.i16 = exprop op0.x.i16; break; \ + case PTY_i32: res.x.i32 = exprop op0.x.i32; break; \ + case PTY_i64: res.x.i64 = exprop op0.x.i64; break; \ + case PTY_u8: res.x.u8 = exprop op0.x.u8; break; \ + case PTY_u16: res.x.u16 = exprop op0.x.u16; break; \ + case PTY_u32: res.x.u32 = exprop op0.x.u32; break; \ + case PTY_u64: res.x.u64 = exprop op0.x.u64; break; \ + default: MIR_FATAL("Unsupported PrimType %d for unary operator %s", exprptyp, #exprop); \ + } \ + res.ptyp = exprptyp; \ + } while(0) + +#endif // MPLENG_MEXPRESSION_H_ diff --git a/src/MapleEng/lmbc/include/mfunction.h b/src/MapleEng/lmbc/include/mfunction.h new file mode 100644 index 0000000000..fb5dc72546 --- /dev/null +++ b/src/MapleEng/lmbc/include/mfunction.h @@ -0,0 +1,114 @@ +/* + * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved. + * + * OpenArkCompiler is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +#ifndef MPLENG_MFUNCTION_H_ +#define MPLENG_MFUNCTION_H_ + +#include +#include + +#include +#include +#define gettid() syscall(SYS_gettid) + +#include "mir_nodes.h" +#include "mvalue.h" +#include "lmbc_eng.h" + +#define VARNAMELENGTH 16 +#define ALLOCA_MEMMAX 0x4000 + +namespace maple { + +class LmbcMod; +class LmbcFunc; +struct ParmInf; + +//using ffi_fp_t = void(*const)(); +using ffi_fp_t = void(*)(); + +// For x86 valist setup, gp_offset and fp_offset are set to values +// to force va arg access from stack pointed to by overflow_arg_area +// instead of reg_save_area (ref. x86_64 ABI), e.g. +// VaListX86_64 *vaList = (maple::VaListX86_64*)addrofAP.x.a64; +// vaList->gp_offset = 48; +// vaList->fp_offset = 304; +// vaList->overflow_arg_area = caller.caller->vaArgs; +// vaList->reg_save_area = nullptr; +typedef struct { + uint gp_offset; + uint fp_offset; + void *overflow_arg_area; + void *reg_save_area; +} VaListX86_64[1]; + +typedef struct { + void *stack; + void *gr_top; + void *vr_top; + int gr_offs; + int vr_offs; +} VaListAarch64; + +using VaList = VaListAarch64; + +// State of executing Maple function +class MFunction { + public: + // state of an executing function + LmbcFunc* info; // current func + MFunction* caller; // caller of current func + StmtNode* nextStmt; // next maple IR statement to execute + uint8* frame; // stack frame (auto var only) + uint8* fp; // point to bottom of frame + uint8* allocaMem; // point to reserved stack memory for Maple IR OP_alloca + uint32 allocaOffset; // next avail offset in allocaMem + MValue* pRegs; // array of pseudo regs used in function + MValue* formalVars; // array of var/non-preg args passed in + + // for function calls made from this function + uint16 numCallArgs; // number of call args to pass to callee + MValue* callArgs; // array of call args to pass to callee + uint8* aggrArgsBuf; // buffer for PTY_agg call formal args, which offsets into it + uint8* varArgsBuf; // buffer for PTY_agg call var-args, which offsets into it + MValue retVal0; // %retVal0 return from callee + MValue retVal1; // %retval1 return from callee + uint8* vaArgs; // AARCH64 ABI vararg stack for calling va-arg funcs + uint32 vaArgsSize; + + explicit MFunction(LmbcFunc *funcInfo, + MFunction *funcCaller, + uint8 *autoVars, + MValue *pRegs, + MValue *formalVars); + ~MFunction(); + uint8 *Alloca(uint32 size); + uint8 *GetFormalVarAddr(StIdx stidx); + void CallMapleFuncDirect(CallNode *call); + void CallMapleFuncIndirect(IcallNode *icall, LmbcFunc *callInfo); + void CallExtFuncDirect(CallNode* call); + void CallExtFuncIndirect(IcallNode *icallproto, void* fp); + void CallVaArgFunc(int numArgs, LmbcFunc *callInfo); + void CallWithFFI(PrimType ret_ptyp, ffi_fp_t fp); + void CallIntrinsic(IntrinsiccallNode &intrn); +}; + +bool IsExtFunc(PUIdx puIdx, LmbcMod &module); +MValue InvokeFunc(LmbcFunc* fn, MFunction *caller); +MValue EvalExpr(MFunction &func, BaseNode* expr, ParmInf *parm = nullptr); +void mload(uint8* addr, PrimType ptyp, MValue& res, size_t aggSizea = 0); +void mstore(uint8* addr, PrimType ptyp, MValue& val, bool toVarArgStack = false); + +} +#endif // MPLENG_MFUNCTION_H_ diff --git a/src/MapleEng/lmbc/include/mprimtype.h b/src/MapleEng/lmbc/include/mprimtype.h new file mode 100644 index 0000000000..68b42041c4 --- /dev/null +++ b/src/MapleEng/lmbc/include/mprimtype.h @@ -0,0 +1,136 @@ +/* + * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved. + * + * OpenArkCompiler is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +#ifndef MPLENG_MPRIMTYPE_H_ +#define MPLENG_MPRIMTYPE_H_ + +// Define size info of primtypes, some of them are undefined for now(set to 0) +// 1 - 1 byte +// 2 - 2 bytes +// 3 - 4 bytes +// 4 - 8 bytes +// 5 - 16 bytes +// 6 - 32 bytes +#define PTYSIZE_Invalid 0 +#define PTYSIZE_void 0 +#define PTYSIZE_i8 1 +#define PTYSIZE_i16 2 +#define PTYSIZE_i32 3 +#define PTYSIZE_i64 4 +#define PTYSIZE_u8 1 +#define PTYSIZE_u16 2 +#define PTYSIZE_u32 3 +#define PTYSIZE_u64 4 +#define PTYSIZE_u1 1 +#define PTYSIZE_ptr 3 +#define PTYSIZE_ref 3 +#define PTYSIZE_a32 3 +#define PTYSIZE_a64 4 +#define PTYSIZE_f32 3 +#define PTYSIZE_f64 4 +#define PTYSIZE_f128 5 +#define PTYSIZE_c64 5 +#define PTYSIZE_c128 6 +#define PTYSIZE_simplestr 3 +#define PTYSIZE_simpleobj 3 +#define PTYSIZE_dynany 4 +#define PTYSIZE_dynundef 4 +#define PTYSIZE_dynnull 4 +#define PTYSIZE_dynbool 4 +#define PTYSIZE_dyni32 4 +#define PTYSIZE_dynstr 4 +#define PTYSIZE_dynobj 4 +#define PTYSIZE_dynf64 4 +#define PTYSIZE_dynf32 4 +#define PTYSIZE_dynnone 4 +#define PTYSIZE_constStr 0 +#define PTYSIZE_gen 0 +#define PTYSIZE_agg 0 +#define PTYSIZE_v2i64 0 +#define PTYSIZE_v4i32 0 +#define PTYSIZE_v8i16 0 +#define PTYSIZE_v16i8 0 +#define PTYSIZE_v2f64 0 +#define PTYSIZE_v4f32 0 +#define PTYSIZE_unknown 0 +#define PTYSIZE_Derived 0 + +// Define ffi types for each primtype, some of them are unsupported(set to ffi_type_void) +#define FFITYPE_Invalid ffi_type_void +#define FFITYPE_void ffi_type_void +#define FFITYPE_i8 ffi_type_sint8 +#define FFITYPE_i16 ffi_type_sint16 +#define FFITYPE_i32 ffi_type_sint32 +#define FFITYPE_i64 ffi_type_sint64 +#define FFITYPE_u8 ffi_type_uint8 +#define FFITYPE_u16 ffi_type_uint16 +#define FFITYPE_u32 ffi_type_uint32 +#define FFITYPE_u64 ffi_type_uint64 +#define FFITYPE_u1 ffi_type_uint8 +#define FFITYPE_ptr ffi_type_pointer +#define FFITYPE_ref ffi_type_pointer +#define FFITYPE_a32 ffi_type_pointer +#define FFITYPE_a64 ffi_type_pointer +#define FFITYPE_f32 ffi_type_float +#define FFITYPE_f64 ffi_type_double +#define FFITYPE_f128 ffi_type_void +#define FFITYPE_c64 ffi_type_void +#define FFITYPE_c128 ffi_type_void +#define FFITYPE_simplestr ffi_type_void +#define FFITYPE_simpleobj ffi_type_void +#define FFITYPE_dynany ffi_type_void +#define FFITYPE_dynundef ffi_type_void +#define FFITYPE_dynnull ffi_type_void +#define FFITYPE_dynbool ffi_type_void +#define FFITYPE_dyni32 ffi_type_void +#define FFITYPE_dynstr ffi_type_void +#define FFITYPE_dynobj ffi_type_void +#define FFITYPE_dynf64 ffi_type_void +#define FFITYPE_dynf32 ffi_type_void +#define FFITYPE_dynnone ffi_type_void +#define FFITYPE_constStr ffi_type_void +#define FFITYPE_gen ffi_type_void +#define FFITYPE_agg ffi_type_void +#define FFITYPE_v2i64 ffi_type_void +#define FFITYPE_v4i32 ffi_type_void +#define FFITYPE_v8i16 ffi_type_void +#define FFITYPE_v16i8 ffi_type_void +#define FFITYPE_v2f64 ffi_type_void +#define FFITYPE_v4f32 ffi_type_void +#define FFITYPE_unknown ffi_type_void +#define FFITYPE_Derived ffi_type_void +#define FFITYPE_i128 ffi_type_void +#define FFITYPE_u128 ffi_type_void +#define FFITYPE_v2u64 ffi_type_void +#define FFITYPE_v4u32 ffi_type_void +#define FFITYPE_v8u16 ffi_type_void +#define FFITYPE_v16u8 ffi_type_void +#define FFITYPE_v2i32 ffi_type_void +#define FFITYPE_v4i16 ffi_type_void +#define FFITYPE_v8i8 ffi_type_void +#define FFITYPE_v2u32 ffi_type_void +#define FFITYPE_v4u16 ffi_type_void +#define FFITYPE_v8u8 ffi_type_void +#define FFITYPE_v2f32 ffi_type_void +#define FFITYPE_reservedpty1 ffi_type_void +#define FFITYPE_reservedpty2 ffi_type_void +#define FFITYPE_reservedpty3 ffi_type_void +#define FFITYPE_reservedpty4 ffi_type_void +#define FFITYPE_reservedpty5 ffi_type_void +#define FFITYPE_reservedpty6 ffi_type_void +#define FFITYPE_reservedpty7 ffi_type_void +#define FFITYPE_reservedpty8 ffi_type_void +#define FFITYPE_reservedpty9 ffi_type_void +#define FFITYPE_reservedpty10 ffi_type_void +#endif // MPLENG_MPRIMTYPE_H_ diff --git a/src/MapleEng/lmbc/include/mvalue.h b/src/MapleEng/lmbc/include/mvalue.h new file mode 100644 index 0000000000..f7bb933d8a --- /dev/null +++ b/src/MapleEng/lmbc/include/mvalue.h @@ -0,0 +1,44 @@ +/* + * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved. + * + * OpenArkCompiler is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +#ifndef MPLENG_MVALUE_H_ +#define MPLENG_MVALUE_H_ + +#include +#include "prim_types.h" + +namespace maple { + struct MValue { + union { + int8 i8; + int16 i16; + int32 i32; + int64 i64; + uint8 u8; + uint16 u16; + uint32 u32; + uint64 u64; + float f32; + double f64; + uint8 *a64; // object ref (use uint8_t* instead of void* for reference) + void *ptr; + void *str; + } x; + PrimType ptyp:8; + size_t aggSize; // for PTY_agg only + }; +} + +#endif // MPLENG_MVALUE_H_ + diff --git a/src/MapleEng/lmbc/src/eng_shim.cpp b/src/MapleEng/lmbc/src/eng_shim.cpp new file mode 100644 index 0000000000..7a0cae2e68 --- /dev/null +++ b/src/MapleEng/lmbc/src/eng_shim.cpp @@ -0,0 +1,75 @@ +/* + * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved. + * + * OpenArkCompiler is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +#include "mfunction.h" +#include "massert.h" +#include "lmbc_eng.h" + +namespace maple { + +extern "C" int64 +__engineShim(LmbcFunc* fn, ...) { + uint8 frame[fn->frameSize]; + MValue pregs[fn->numPregs]; + MValue formalVars[fn->formalsNumVars+1]; + MFunction shim_caller(fn, nullptr, frame, pregs, formalVars); // create local Mfunction obj for shim + + MValue val; + if (fn->formalsNum > 0) { + MValue callArgs[fn->formalsNum]; + va_list args; + va_start (args, fn); + + int argIdx = 0; + while (argIdx < fn->formalsNum) { + // convert argv args to interpreter types and push on operand stack + val.ptyp = fn->pos2Parm[argIdx]->ptyp; + switch(val.ptyp) { + case PTY_i8: + val.x.i8 = va_arg(args, int); + break; + case PTY_i16: + val.x.i16 = va_arg(args, int); + break; + case PTY_i32: + val.x.i32 = va_arg(args, int); + break; + case PTY_i64: + val.x.i64 = va_arg(args, long long); + break; + case PTY_u16: + val.x.u16 = va_arg(args, int); + break; + case PTY_a64: + val.x.a64 = va_arg(args, uint8*); + break; + case PTY_f32: + // Variadic function expects that float arg is promoted to double + case PTY_f64: + val.x.f64 = va_arg(args, double); + break; + default: + MIR_FATAL("Unsupported PrimType %d", val.ptyp); + } + callArgs[argIdx] = val; + ++argIdx; + } + shim_caller.numCallArgs = fn->formalsNum; + shim_caller.callArgs = callArgs; + } + val = InvokeFunc(fn, &shim_caller); + return 0; +} + +} diff --git a/src/MapleEng/lmbc/src/init.cpp b/src/MapleEng/lmbc/src/init.cpp new file mode 100644 index 0000000000..285e93949f --- /dev/null +++ b/src/MapleEng/lmbc/src/init.cpp @@ -0,0 +1,611 @@ +/* + * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved. + * + * OpenArkCompiler is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +#include "massert.h" +#include "lmbc_eng.h" +#include "eng_shim.h" + +namespace maple { + +// Align offset to required alignment +inline void AlignOffset(uint32 &offset, uint32 align) { + offset = (offset + align-1) & ~(align-1); +} + +LmbcFunc::LmbcFunc(LmbcMod *mod, MIRFunction *func) : lmbcMod(mod), mirFunc(func) { + frameSize = ((func->GetFrameSize()+7)>>3)<<3; // round up to nearest 8 + isVarArgs = func->GetMIRFuncType()->IsVarargs(); + numPregs = func->GetPregTab()->Size(); +} + +void LmbcMod::InitModule(void) { + CalcGlobalAndStaticVarSize(); + for (MIRFunction *mirFunc : mirMod->GetFunctionList()) { + if (auto node = mirFunc->GetBody()) { + LmbcFunc* fn = new LmbcFunc(this, mirFunc); + ASSERT(fn, "Create Lmbc function failed"); + fn->ScanFormals(); + fn->ScanLabels(node); + funcMap[mirFunc->GetPuidx()] = fn; + if (mirFunc->GetName().compare("main") == 0) { + mainFn = fn; + } + } + } + InitGlobalVars(); +} + +void LmbcFunc::ScanFormals(void) { + MapleVector formalDefVec = mirFunc->GetFormalDefVec(); + formalsNum = formalDefVec.size(); + formalsSize = 0; + formalsNumVars = 0; + formalsAggSize = 0; + MASSERT(mirFunc->GetReturnType() != nullptr, "mirFunc return type is null"); + retSize = mirFunc->GetReturnType()->GetSize(); + for (uint32 i = 0; i < formalDefVec.size(); i++) { + MIRSymbol* symbol = formalDefVec[i].formalSym; + MIRType* ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(formalDefVec[i].formalTyIdx); + bool isPreg = (symbol->GetSKind() == kStPreg); + int32 storageIdx; + if (ty->GetPrimType() == PTY_agg) { + storageIdx = formalsAggSize; + formalsAggSize += ty->GetSize(); + } else { + storageIdx = isPreg? symbol->GetPreg()->GetPregNo(): ++formalsNumVars; + } + // collect formal params info + ParmInf* pInf = new ParmInf(ty->GetPrimType(), ty->GetSize(), isPreg, storageIdx); + stidx2Parm[symbol->GetStIdx().FullIdx()] = pInf; // formals info map keyed on formals stidx + pos2Parm.push_back(pInf); // vector of formals info in formalDefVec order + formalsSize += ty->GetSize(); + } +} + +void LmbcFunc::ScanLabels(StmtNode* stmt) { + while (stmt != nullptr) { + switch (stmt->op) { + case OP_block: + stmt = static_cast(stmt)->GetFirst(); + ScanLabels(stmt); + break; + case OP_label: + labelMap[static_cast(stmt)->GetLabelIdx()] = stmt; + break; + default: + break; + } + stmt= stmt->GetNext(); + } +} + +// Check for initialized flex array struct member and return size. The number +// of elements is not specified in the array type declaration but determined +// by array initializer. +// Note:: +// - Flex array must be last field of a top level struct +// - Only 1st dim of multi-dim array can be unspecified. Other dims must have bounds. +// - In Maple AST, array with unspecified num elements is defined with 1 element in +// 1st array dim, and is the storage for 1st initialiazed array element. +// The interpreter identifies such arrays by a dim of 1 in the array's 1st dim +// together with an array const initializer with > 1 element (should identify using +// kTypeFArray return from GetKind() but it's returning kTypeArray now ). +uint32 CheckFlexArrayMember(MIRSymbol &sym, MIRType &ty) { + auto &stType = static_cast(ty); + auto &stConst = static_cast(*sym.GetKonst()); + TyIdxFieldAttrPair tfap = stType.GetTyidxFieldAttrPair(stType.GetFieldsSize()-1); // last struct fd + MIRType *lastFdType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tfap.first); + if (lastFdType->GetKind() == kTypeArray && // last struct field is array + static_cast(lastFdType)->GetSizeArrayItem(0) == 1 && // 1st dim of array is 1 + stConst.GetConstVec().size() == stType.GetFieldsSize()) { // there is an initializer for the array + MIRConst &elemConst = *stConst.GetConstVecItem(stConst.GetConstVec().size()-1); // get array initializer + MASSERT(elemConst.GetType().GetKind() == kTypeArray, "array initializer expected"); + auto &arrCt = static_cast(elemConst); + if (arrCt.GetConstVec().size() > 1) { + return (arrCt.GetConstVec().size()-1) * elemConst.GetType().GetSize(); // 1st elem already in arr type def + } + } + return 0; +} + +// Calcluate total memory needed for global vars, Fstatic vars and initialized PUstatic vars. +// Walks global sym table and local sym table of all funcs to gather size info and adds +// var to table for looking up its size, type and offset within the storage segment. +void LmbcMod::CalcGlobalAndStaticVarSize() { + uint32 offset = 0; + for (size_t i = 0; i < GlobalTables::GetGsymTable().GetSymbolTableSize(); ++i) { + MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(i); + if (!sym || + !(sym->GetSKind() == kStVar) || + !(sym->GetStorageClass() == kScGlobal || sym->GetStorageClass() == kScFstatic)) { + continue; + } + if (MIRType *ty = sym->GetType()) { + AlignOffset(offset, ty->GetAlign()); // check and align var + VarInf* pInf = new VarInf(ty->GetPrimType(), ty->GetSize(), false, offset, sym); + AddGlobalVar(*sym, pInf); // add var to lookup table + offset += ty->GetSize(); + if (ty->GetKind() == kTypeStruct) { // check and account for flex array member + offset += CheckFlexArrayMember(*sym, *ty); + } + } + } + globalsSize = offset; + // get total size of nitialized function static vars + for (MIRFunction *func : mirMod->GetFunctionList()) { + if (auto node = func->GetBody()) { + ScanPUStatic(func); + } + } +} + +void LmbcMod::ScanPUStatic(MIRFunction *func) { + size_t size = func->GetSymbolTabSize(); + for (size_t i = 0; i < size; ++i) { + MIRSymbol *sym = func->GetSymbolTabItem(i); + if (!sym || !sym->IsPUStatic() || !sym->IsConst()) { // exclude un-init PUStatic + continue; + } + if (MIRType *ty = sym->GetType()) { + VarInf* pInf = new VarInf(ty->GetPrimType(), ty->GetSize(), false, globalsSize, sym, func->GetPuidx()); + AddPUStaticVar(func->GetPuidx(), *sym, pInf); // add var to lookup table + globalsSize += ty->GetSize(); + } + } +} + +// Get the address of a non-agg global var or next field within a global var to init. +// If a PTY_agg var, align offset to next init addr (aggrInitOffset) for ptyp. +// Otherwise, storeIdx should be aligned properly already in CalcGlobalVarsSize. +// - storeIdx: offset of the global var in global var segment +// - aggrInitOffset: offset of the field to init within global var of type PTY_agg +uint8 *LmbcMod::GetGlobalVarInitAddr(VarInf* pInf, uint32 align) { + if (pInf->ptyp != PTY_agg) { // init non-aggr global var + return globals + pInf->storeIdx; + } + AlignOffset(aggrInitOffset, align); + return globals + pInf->storeIdx + aggrInitOffset; +} + +inline void LmbcMod::UpdateGlobalVarInitAddr(VarInf* pInf, uint32 size) { + if (pInf->ptyp == PTY_agg) { + aggrInitOffset += size; + } +} + +// Check for un-named bitfields in initialized global struct vars and +// include in global var memory sizing and field offset calcuations. Un-named +// bit fields appears as gaps in field id between initialized struct fields +// of a global var. +void LmbcMod::CheckUnamedBitField(MIRStructType &stType, uint32 &prevInitFd, uint32 curFd, int32 &allocdBits) { + + if (curFd - 1 == prevInitFd) { + prevInitFd = curFd; + return; + } + + for (auto i = prevInitFd; i < curFd -1; ++i) { // struct fd idx 0 based; agg const fd 1 based + TyIdxFieldAttrPair tfap = stType.GetTyidxFieldAttrPair(i); + MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tfap.first); // type of struct fd + // Gaps in struct fields with initializer are either un-named bit fields or empty struct fields + // Account for bits in un-named bit fields. Skip over emtpy struct fields. + if (ty->GetKind() != kTypeBitField) { + continue; + } + MASSERT(ty->GetKind()==kTypeBitField, "Un-named bitfield expected"); + uint8 bitFdWidth = static_cast(ty)->GetFieldSize(); + uint32 baseFdSz = GetPrimTypeSize(ty->GetPrimType()); + + uint32 align = allocdBits ? 1 : baseFdSz; // align with base fd if no bits have been allocated + AlignOffset(aggrInitOffset, align); + + if (allocdBits + bitFdWidth > (baseFdSz * 8)) { // alloc bits will cross align boundary of base type + aggrInitOffset+= baseFdSz; + allocdBits = bitFdWidth; // alloc bits at new boundary + } else { + allocdBits += bitFdWidth; + } + } + prevInitFd = curFd; +} + +void LmbcMod::InitStrConst(VarInf* pInf, MIRStrConst &mirStrConst, uint8* dst) { + UStrIdx ustrIdx = mirStrConst.GetValue(); + auto it = globalStrTbl.insert( + std::pair(ustrIdx, GlobalTables::GetUStrTable().GetStringFromStrIdx(ustrIdx))); + *(const char **)dst = it.first->second.c_str(); +} + +inline void LmbcMod::InitFloatConst(VarInf *pInf, MIRFloatConst &f32Const, uint8* dst) { + *(float*)dst = f32Const.GetValue(); +} + +inline void LmbcMod::InitDoubleConst(VarInf *pInf, MIRDoubleConst &f64Const, uint8* dst) { + *(double*)dst = f64Const.GetValue(); +} + +void LmbcMod::InitLblConst(VarInf *pInf, MIRLblConst &labelConst, uint8 *dst) { + LabelIdx labelIdx = labelConst.GetValue(); + LmbcFunc *fn = LkupLmbcFunc(labelConst.GetPUIdx()); + StmtNode* label = fn->labelMap[labelIdx]; + MASSERT(label, "InitLblConst label not foound"); + *(StmtNode **)dst = label; +} + +void LmbcMod::InitIntConst(VarInf* pInf, MIRIntConst &intConst, uint8* dst) { + int64 val = intConst.GetExtValue(); + switch(intConst.GetType().GetPrimType()) { + case PTY_i64: + *(int64*)dst = (int64)val; + break; + case PTY_i32: + *(int32*)dst = (int32)val; + break; + case PTY_i16: + *(int16*)dst = (int16)val; + break; + case PTY_i8: + *(int8*)dst = (int8)val; + break; + case PTY_u64: + *(uint64*)dst = (uint64)val; + break; + case PTY_u32: + *(uint32*)dst = (uint32)val; + break; + case PTY_u16: + *(uint16*)dst = (uint16)val; + break; + case PTY_u8: + *(uint8*)dst = (uint8)val; + break; + default: + break; + } +} + +void LmbcMod::InitPointerConst(VarInf *pInf, MIRConst &mirConst) { + uint8 *dst = GetGlobalVarInitAddr(pInf, mirConst.GetType().GetAlign()); + switch(mirConst.GetKind()) { + case kConstAddrof: + InitAddrofConst(pInf, static_cast(mirConst), dst); + break; + case kConstStrConst: + InitStrConst(pInf, static_cast(mirConst), dst); + break; + case kConstInt: { + InitIntConst(pInf, static_cast(mirConst), dst); + break; + } + case kConstAddrofFunc: + default: + MASSERT(false, "InitPointerConst %d kind NYI", mirConst.GetKind()); + break; + } + UpdateGlobalVarInitAddr(pInf, mirConst.GetType().GetSize()); +} + +void SetBitFieldConst(uint8* baseFdAddr, uint32 baseFdSz, uint32 bitsOffset, uint8 bitsSize, MIRConst &elemConst) { + MIRIntConst &intConst = static_cast(elemConst); (void)intConst; + int64 val = intConst.GetExtValue(); + uint64 mask = ~(0xffffffffffffffff << bitsSize); + uint64 from = (val & mask) << bitsOffset; + mask = mask << bitsOffset; + switch(elemConst.GetType().GetPrimType()) { + case PTY_i64: + *(int64*)baseFdAddr = ((*(int64*)baseFdAddr) & ~(mask)) | from; + break; + case PTY_i32: + *(int32*)baseFdAddr = ((*(int32*)baseFdAddr) & ~(mask)) | from; + break; + case PTY_i16: + *(int16*)baseFdAddr = ((*(int16*)baseFdAddr) & ~(mask)) | from; + break; + case PTY_i8: + *(int8*)baseFdAddr = ((*(int8*)baseFdAddr) & ~(mask)) | from; + break; + case PTY_u64: + *(uint64*)baseFdAddr = ((*(uint64*)baseFdAddr) & ~(mask)) | from; + break; + case PTY_u32: + *(uint32*)baseFdAddr = ((*(uint32*)baseFdAddr) & ~(mask)) | from; + break; + case PTY_u16: + *(uint16*)baseFdAddr = ((*(uint16*)baseFdAddr) & ~(mask)) | from; + break; + case PTY_u8: + *(uint8*)baseFdAddr = ((*(uint8*)baseFdAddr) & ~(mask)) | from; + break; + default: + MASSERT(false, "Unexpected primary type"); + break; + } +} + +void LmbcMod::InitBitFieldConst(VarInf *pInf, MIRConst &elemConst, int32 &allocdBits, bool &forceAlign) { + uint8 bitFdWidth = static_cast(elemConst.GetType()).GetFieldSize(); + if (!bitFdWidth) { // flag to force align immediate following bit field + forceAlign = true; + return; + } + if (forceAlign) { // align to next boundary + aggrInitOffset += (allocdBits + 7) >> 3; + forceAlign = false; + } + uint32 baseFdSz = GetPrimTypeSize(elemConst.GetType().GetPrimType()); + uint32 align = allocdBits ? 1 : baseFdSz; // align with base fd if no bits have been allocated + uint8* baseFdAddr = GetGlobalVarInitAddr(pInf, align); + + if (allocdBits + bitFdWidth > (baseFdSz * 8)) { // alloc bits will cross align boundary of base type + baseFdAddr = baseFdAddr + baseFdSz; // inc addr & offset by size of base type + SetBitFieldConst(baseFdAddr, baseFdSz, 0, bitFdWidth, elemConst); + aggrInitOffset+= baseFdSz; + allocdBits = bitFdWidth; // alloc bits at new boundary + } else { + SetBitFieldConst(baseFdAddr, baseFdSz, allocdBits, bitFdWidth, elemConst); + allocdBits += bitFdWidth; + } +} + +void LmbcMod::InitAggConst(VarInf *pInf, MIRConst &mirConst) { + auto &stType = static_cast(mirConst.GetType()); + auto &aggConst = static_cast(mirConst); + bool forceAlign = false; + int32 allocdBits = 0; + + AlignOffset(aggrInitOffset, aggConst.GetType().GetAlign()); // next init offset in global var mem + MIRTypeKind prevElemKind = kTypeUnknown; + for (uint32 i = 0, prevInitFd = 0; i < aggConst.GetConstVec().size(); ++i) { + MIRConst &elemConst = *aggConst.GetConstVecItem(i); + MIRType &elemType = elemConst.GetType(); + + // if non bit fd preceded by bit fd, round bit fd to byte boundary + // so next bit fd will start on new boundary + if (prevElemKind == kTypeBitField && elemType.GetKind() != kTypeBitField) { + forceAlign = false; + if (allocdBits) { + aggrInitOffset += (allocdBits + 7) >> 3; // pad preceding bit fd to byte boundary + allocdBits = 0; + } + } + + // No need to check for un-named bit fd if aggr is an array + if (stType.GetKind() != kTypeArray) { + CheckUnamedBitField(stType, prevInitFd, aggConst.GetFieldIdItem(i), allocdBits); + } + switch(elemType.GetKind()) { + case kTypeScalar: + InitScalarConst(pInf, elemConst); + break; + case kTypeStruct: + case kTypeUnion: + InitAggConst(pInf, elemConst); + break; + case kTypeArray: + InitArrayConst(pInf, elemConst); + break; + case kTypePointer: + InitPointerConst(pInf, elemConst); + break; + case kTypeBitField: { + InitBitFieldConst(pInf, elemConst, allocdBits, forceAlign); + break; + } + default: { + MASSERT(false, "init struct type %d NYI", elemType.GetKind()); + break; + } + } + prevElemKind = elemType.GetKind(); + } +} + +void LmbcMod::InitScalarConst(VarInf *pInf, MIRConst &mirConst) { + uint8 *dst = GetGlobalVarInitAddr(pInf, mirConst.GetType().GetAlign()); + switch (mirConst.GetKind()) { + case kConstInt: + InitIntConst(pInf, static_cast(mirConst), dst); + break; + case kConstFloatConst: + InitFloatConst(pInf, static_cast(mirConst), dst); + break; + case kConstDoubleConst: + InitDoubleConst(pInf, static_cast(mirConst), dst); + break; + case kConstStrConst: + InitStrConst(pInf, static_cast(mirConst), dst); + break; + case kConstLblConst: + InitLblConst(pInf, static_cast(mirConst), dst); + break; + case kConstStr16Const: + case kConstAddrof: + case kConstAddrofFunc: + default: + MASSERT(false, "Scalar Const Type %d NYI", mirConst.GetKind()); + break; + } + UpdateGlobalVarInitAddr(pInf, mirConst.GetType().GetSize()); +} + +void LmbcMod::InitArrayConst(VarInf *pInf, MIRConst &mirConst) { + MIRArrayType &arrayType = static_cast(mirConst.GetType()); + MIRAggConst &arrayCt = static_cast(mirConst); + AlignOffset(aggrInitOffset, arrayType.GetAlign()); + + size_t uNum = arrayCt.GetConstVec().size(); + uint32 dim = arrayType.GetSizeArrayItem(0); + TyIdx scalarIdx = arrayType.GetElemTyIdx(); + MIRType *subTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(scalarIdx); + if (uNum == 0 && dim != 0) { + while (subTy->GetKind() == kTypeArray) { + MIRArrayType *aSubTy = static_cast(subTy); + if (aSubTy->GetSizeArrayItem(0) > 0) { + dim *= (aSubTy->GetSizeArrayItem(0)); + } + scalarIdx = aSubTy->GetElemTyIdx(); + subTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(scalarIdx); + } + } + for (size_t i = 0; i < uNum; ++i) { + MIRConst *elemConst = arrayCt.GetConstVecItem(i); + if (IsPrimitiveVector(subTy->GetPrimType())) { + MASSERT(false, "Unexpected primitive vector"); + } else if (IsPrimitiveScalar(elemConst->GetType().GetPrimType())) { + bool strLiteral = false; + if (arrayType.GetDim() == 1) { + MIRType *ety = arrayType.GetElemType(); + if (ety->GetPrimType() == PTY_i8 || ety->GetPrimType() == PTY_u8) { + strLiteral = true; + } + } + InitScalarConst(pInf, *elemConst); + } else if (elemConst->GetType().GetKind() == kTypeArray) { + InitArrayConst(pInf, *elemConst); + } else if (elemConst->GetType().GetKind() == kTypeStruct || + elemConst->GetType().GetKind() == kTypeClass || + elemConst->GetType().GetKind() == kTypeUnion) { + InitAggConst(pInf, *elemConst); +// } else if (elemConst->GetKind() == kConstAddrofFunc) { +// InitScalarConstant(pInf, *elemConst); + } else { + ASSERT(false, "should not run here"); + } + } +} + +void LmbcMod::InitAddrofConst(VarInf *pInf, MIRAddrofConst &addrofConst, uint8* dst) { + StIdx stIdx = addrofConst.GetSymbolIndex(); + int32 offset = addrofConst.GetOffset(); + uint8 *addr = pInf->sym->IsPUStatic() ? GetVarAddr(pInf->puIdx, stIdx) : GetVarAddr(stIdx); + *(uint8**)dst = addr + offset; +} + +void LmbcMod::InitGlobalVariable(VarInf *pInf) { + MIRConst *mirConst = pInf->sym->GetKonst(); + uint8 *dst = GetGlobalVarInitAddr(pInf, mirConst->GetType().GetAlign()); + + switch(mirConst->GetKind()) { + case kConstAggConst: + aggrInitOffset = 0; + InitAggConst(pInf, *mirConst); + return; + case kConstInt: + InitIntConst(pInf, *static_cast(mirConst), dst); + break; + case kConstFloatConst: + InitFloatConst(pInf, *static_cast(mirConst), dst); + break; + case kConstDoubleConst: + InitDoubleConst(pInf, *static_cast(mirConst), dst); + break; + case kConstAddrof: + InitAddrofConst(pInf, *static_cast(mirConst), dst); + break; + case kConstStrConst: + InitStrConst(pInf, *static_cast(mirConst), dst); + break; + default: + MASSERT(false, "Init MIRConst type %d NYI", mirConst->GetKind()); + break; + } + UpdateGlobalVarInitAddr(pInf, mirConst->GetType().GetSize()); +} + +void LmbcMod::InitGlobalVars(void) { + // alloc mem for global vars + this->globals = (uint8*)malloc(this->globalsSize); + this->unInitPUStatics = (uint8*)malloc(this->unInitPUStaticsSize); + memset(this->globals, 0, this->globalsSize); + memset(this->unInitPUStatics, 0, this->unInitPUStaticsSize); + + // init global vars and static vars + for (const auto it : globalAndStaticVars) { + VarInf *pInf = it.second; + if (pInf->sym->IsConst()) { + InitGlobalVariable(pInf); + } + } +} + +inline void LmbcMod::AddGlobalVar(MIRSymbol &sym, VarInf *pInf) { + globalAndStaticVars[sym.GetStIdx().FullIdx()] = pInf; +} + +inline void LmbcMod::AddPUStaticVar(PUIdx puIdx, MIRSymbol &sym, VarInf *pInf) { + globalAndStaticVars[(uint64)puIdx << 32 | sym.GetStIdx().FullIdx()] = pInf; +} + +// global var +uint8 *LmbcMod::GetVarAddr(StIdx stIdx) { + auto it = globalAndStaticVars.find(stIdx.FullIdx()); + MASSERT(it != globalAndStaticVars.end(), "global var not found"); + return globals + it->second->storeIdx; +} + +// PUStatic var +uint8 *LmbcMod::GetVarAddr(PUIdx puIdx, StIdx stIdx) { + auto it = globalAndStaticVars.find((long)puIdx << 32 | stIdx.FullIdx()); + MASSERT(it != globalAndStaticVars.end(), "PUStatic var not found"); + return globals + it->second->storeIdx; +} + +LmbcFunc* +LmbcMod::LkupLmbcFunc(PUIdx puIdx) { + auto it = funcMap.find(puIdx); + return it == funcMap.end()? nullptr: it->second; +} + +FuncAddr::FuncAddr(bool lmbcFunc, void *func, std::string name, uint32 formalsAggSz) { + funcName = name; + isLmbcFunc = lmbcFunc; + formalsAggSize = formalsAggSz; + if (isLmbcFunc) { + funcPtr.lmbcFunc = (LmbcFunc*)func; + } else { + funcPtr.nativeFunc = func; + } +} + +// Get size total of all func parameters of type TY_agg. +uint32 GetAggFormalsSize(MIRFunction *func) { + uint32 totalSize = 0; + MapleVector &formalDefVec = func->GetFormalDefVec(); + for (int i = 0; i < formalDefVec.size(); i++) { + MIRType* ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(formalDefVec[i].formalTyIdx); + if (ty->GetPrimType() == PTY_agg) { + totalSize += ty->GetSize(); + } + } + return totalSize; +} + +FuncAddr* LmbcMod::GetFuncAddr(PUIdx idx) { + FuncAddr *faddr; + if (PUIdx2FuncAddr[idx]) { + return PUIdx2FuncAddr[idx]; + } + MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(idx); + MASSERT(func, "Function not found in global table"); + if (IsExtFunc(idx, *this)) { + faddr = new FuncAddr(false, FindExtFunc(idx), func->GetName(), GetAggFormalsSize(func)); + } else { + faddr = new FuncAddr(true, LkupLmbcFunc(idx), func->GetName()); + } + PUIdx2FuncAddr[idx] = faddr; + return faddr; +} + + +} // namespace maple diff --git a/src/MapleEng/lmbc/src/invoke_method.cpp b/src/MapleEng/lmbc/src/invoke_method.cpp new file mode 100644 index 0000000000..c26ad606d7 --- /dev/null +++ b/src/MapleEng/lmbc/src/invoke_method.cpp @@ -0,0 +1,1326 @@ +/* + * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved. + * + * OpenArkCompiler is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +#include +#include +#include +#include +#include +#include "mvalue.h" +#include "mprimtype.h" +#include "mfunction.h" +#include "mexpression.h" +#include "opcodes.h" +#include "massert.h" + +namespace maple { + +int64 MVal2Int64(MValue &val) { + switch(val.ptyp) { + case PTY_i64: + return val.x.i64; + case PTY_i32: + return (int64)val.x.i32; + case PTY_i16: + return (int64)val.x.i16; + case PTY_i8: + return (int64)val.x.i8; + case PTY_u32: + return (int64)val.x.u32; + default: + MASSERT(false, "MValue type %d for int64 conversion NYI", val.ptyp); + } +} + +bool IsZero(MValue& cond) { + switch (cond.ptyp) { + case PTY_u8: return cond.x.u8 == 0; + case PTY_u16: return cond.x.u16 == 0; + case PTY_u32: return cond.x.u32 == 0; + case PTY_u64: return cond.x.u64 == 0; + case PTY_i8: return cond.x.i8 == 0; + case PTY_i16: return cond.x.i16 == 0; + case PTY_i32: return cond.x.i32 == 0; + case PTY_i64: return cond.x.i64 == 0; + default: MASSERT(false, "IsZero type %d NYI", cond.ptyp); + } +} + +bool RegAssignZextOrSext(MValue& from, PrimType toTyp, MValue& to) { + switch(toTyp) { + case PTY_u8: + switch(from.ptyp) { + case PTY_u32: to.x.u8 = from.x.u32; break; // special case as needed + default: return false; + } + break; + case PTY_u32: + switch (from.ptyp) { + case PTY_u8: to.x.u64 = from.x.u8; break; + case PTY_u16: to.x.u64 = from.x.u16; break; + case PTY_i32: to.x.u64 = from.x.i32; break; + default: return false; + } + break; + case PTY_i32: + switch (from.ptyp) { + case PTY_i8: to.x.i64 = from.x.i8; break; + case PTY_i16: to.x.i64 = from.x.i16; break; + case PTY_u32: to.x.i64 = from.x.u32; break; + default: return false; + } + break; + case PTY_u64: + switch (from.ptyp) { + case PTY_u8: to.x.u64 = from.x.u8; break; + case PTY_u16: to.x.u64 = from.x.u16; break; + case PTY_u32: to.x.u64 = from.x.u32; break; + case PTY_i64: to.x.u64 = from.x.i64; break; // for large_stack.c + default: return false; + } + break; + case PTY_i64: + switch (from.ptyp) { + case PTY_i8: to.x.i64 = from.x.i8; break; + case PTY_i16: to.x.i64 = from.x.i16; break; + case PTY_i32: to.x.i64 = from.x.i32; break; + default: return false; + } + break; + case PTY_i16: + switch (from.ptyp) { + case PTY_i32: to.x.i16 = from.x.i32; break; + case PTY_u16: to.x.i16 = from.x.u16; break; + default: return false; + } + break; + case PTY_u16: + switch (from.ptyp) { + case PTY_u32: to.x.u16 = from.x.i32; break; + default: return false; + } + break; + default: + return false; + break; + } + to.ptyp = toTyp; + return true; +} + +#define CASE_TOPTYP(toPtyp, toCtyp) \ + case PTY_##toPtyp: \ + if (cvtInt) res.x.toPtyp = (toCtyp)fromInt; else \ + if (cvtUint) res.x.toPtyp = (toCtyp)fromUint; else \ + if (cvtf32) res.x.toPtyp = (toCtyp)fromFloat; else \ + if (cvtf64) res.x.toPtyp = (toCtyp)fromDouble; \ + break; + +MValue CvtType(MValue &opnd, PrimType toPtyp, PrimType fromPtyp) { + MValue res; + int64 fromInt; + uint64 fromUint; + float fromFloat; + double fromDouble; + bool cvtInt = false; + bool cvtUint = false; + bool cvtf32 = false; + bool cvtf64 = false; + + if (opnd.ptyp == toPtyp) { + return opnd; + } + switch(fromPtyp) { + case PTY_i8: fromInt = opnd.x.i8; cvtInt = true; break; + case PTY_i16: fromInt = opnd.x.i16; cvtInt = true; break; + case PTY_i32: fromInt = opnd.x.i32; cvtInt = true; break; + case PTY_i64: fromInt = opnd.x.i64; cvtInt = true; break; + case PTY_u8: fromUint = opnd.x.u8; cvtUint= true; break; + case PTY_u16: fromUint = opnd.x.u16; cvtUint= true; break; + case PTY_u32: fromUint = opnd.x.u32; cvtUint= true; break; + case PTY_u64: fromUint = opnd.x.u64; cvtUint= true; break; + case PTY_a64: fromUint = opnd.x.u64; cvtUint= true; break; + case PTY_ptr: fromUint = opnd.x.u64; cvtUint= true; break; + case PTY_f32: fromFloat = opnd.x.f32; cvtf32 = true; break; + case PTY_f64: fromDouble= opnd.x.f64; cvtf64 = true; break; + default: MASSERT(false, "OP_cvt from ptyp %d NYI", fromPtyp); break; + } + switch(toPtyp) { + CASE_TOPTYP(i8, int8) + CASE_TOPTYP(i16, int16) + CASE_TOPTYP(i32, int32) + CASE_TOPTYP(i64, int64) + CASE_TOPTYP(u8, uint8) + CASE_TOPTYP(u16, uint16) + CASE_TOPTYP(u32, uint32) + CASE_TOPTYP(u64, uint64) + CASE_TOPTYP(f32, float) + CASE_TOPTYP(f64, double) + case PTY_a64: + if (cvtInt) + res.x.a64 = (uint8*)fromInt; + else if (cvtUint) + res.x.a64 = (uint8*)fromUint; + else + MASSERT(false, "OP_cvt: type %d to %d not supported", fromPtyp, toPtyp); + break; + default: MASSERT(false, "OP_cvt: type %d to %d NYI", fromPtyp, toPtyp); + } + res.ptyp = toPtyp; + return res; +} + + +inline bool CompareFloat(float x, float y, float epsilon = 0.00000001f) { + if (isinf(x) && isinf(y)) { + return true; + } + return (fabs(x - y) < epsilon) ? true : false; +} + +inline bool CompareDouble(double x, double y, double epsilon = 0.0000000000000001f) { + if (isinf(x) && isinf(y)) { + return true; + } + return (fabs(x - y) < epsilon) ? true : false; +} + +void HandleFloatEq(Opcode op, PrimType opndType, MValue &res, MValue &op1, MValue &op2) { + MASSERT(opndType == op1.ptyp && op1.ptyp == op2.ptyp, "Operand type mismatch %d %d", op1.ptyp, op2.ptyp); + switch(op) { + case OP_ne: + if (opndType == PTY_f32) { + res.x.i64 = !CompareFloat(op1.x.f32, op2.x.f32); + } else if (opndType == PTY_f64) { + res.x.i64 = !CompareDouble(op1.x.f64, op2.x.f64); + } else { + MASSERT(false, "Unexpected type"); + } + break; + case OP_eq: + if (opndType == PTY_f32) { + res.x.i64 = CompareFloat(op1.x.f32, op2.x.f32); + } else if (opndType == PTY_f64) { + res.x.i64 = CompareDouble(op1.x.f64, op2.x.f64); + } else { + MASSERT(false, "Unexpected type"); + } + break; + default: + break; + } +} + +void LoadArgs(MFunction& func) { + for (int i=0; i < func.info->formalsNum; ++i) { + if (func.info->pos2Parm[i]->isPreg) { + func.pRegs[func.info->pos2Parm[i]->storeIdx] = func.caller->callArgs[i]; + } else { + func.formalVars[func.info->pos2Parm[i]->storeIdx] = func.caller->callArgs[i]; + } + } +} + +// Walk the Maple LMBC IR tree of a function and execute its statements. +MValue InvokeFunc(LmbcFunc* fn, MFunction *caller) { + MValue retVal; + MValue pregs[fn->numPregs]; // func pregs (incl. func formals that are pregs) + MValue formalVars[fn->formalsNumVars+1]; // func formals that are named vars + alignas(8) uint8 frame[fn->frameSize]; // func autovars + MFunction mfunc(fn, caller, frame, pregs, formalVars); // init func execution state + + static void* const labels[] = { + &&label_OP_Undef, +#define OPCODE(base_node,dummy1,dummy2,dummy3) &&label_OP_##base_node, +#include "opcodes.def" +#undef OPCODE + &&label_OP_Undef + }; + + LoadArgs(mfunc); + mfunc.allocaMem = static_cast(alloca(ALLOCA_MEMMAX)); + //memset(mfunc.allocaMem, 0, ALLOCA_MEMMAX); // for debug only + StmtNode *stmt = mfunc.nextStmt; + goto *(labels[stmt->op]); + +label_OP_Undef: + { + MASSERT(false, "Hit OP_undef"); + } +label_OP_block: + { + stmt = static_cast(stmt)->GetFirst(); + mfunc.nextStmt = stmt; + goto *(labels[stmt->op]); + } +label_OP_iassignfpoff: + { + IassignFPoffNode* node = static_cast(stmt); + int32 offset= node->GetOffset(); + BaseNode* rhs = node->GetRHS(); + MValue val = EvalExpr(mfunc, rhs); + PrimType ptyp = node->ptyp; + mstore(mfunc.fp+offset, ptyp, val); + } + stmt = stmt->GetNext(); + mfunc.nextStmt = stmt; + goto *(labels[stmt->op]); +label_OP_call: + { + CallNode *call = static_cast(stmt); + MValue callArgs[call->NumOpnds()]; // stack for callArgs + mfunc.callArgs = callArgs; + mfunc.numCallArgs = call->NumOpnds(); + if (IsExtFunc(call->GetPUIdx(), *mfunc.info->lmbcMod)) { + mfunc.CallExtFuncDirect(call); + } else { + mfunc.CallMapleFuncDirect(call); + } + } + stmt = stmt->GetNext(); + mfunc.nextStmt = stmt; + goto *(labels[stmt->op]); +label_OP_regassign: + { + RegassignNode* node = static_cast(stmt); + PregIdx regIdx = node->GetRegIdx(); + MValue rhs = EvalExpr(mfunc, node->GetRHS()); + if (node->ptyp == rhs.ptyp) { + MASSERT(regIdx != -kSregRetval1, "regassign to %%%%retval1"); + if (regIdx == -kSregRetval0) { + if (node->ptyp != PTY_agg) { + caller->retVal0 = rhs; + } else { + // handle regassign agg %%retval0 + // - return agg <= 16 bytes in %retval0 and %retval1 as type PTY_u64 + MASSERT(rhs.aggSize <= 16, "regassign of agg >16 bytes to %%retval0"); + uint64 retval[2] = {0, 0}; + memcpy(retval, rhs.x.a64, rhs.aggSize); + caller->retVal0.x.u64 = retval[0]; + caller->retVal0.ptyp = PTY_agg; // treat as PTY_u64 if aggSize <= 16 + caller->retVal0.aggSize = rhs.aggSize; + if (rhs.aggSize > 8) { + caller->retVal1.x.u64 = retval[1]; + caller->retVal1.ptyp = PTY_agg; + caller->retVal1.aggSize= rhs.aggSize; + } + } + } else { + MASSERT(regIdx < fn->numPregs, "regassign regIdx %d out of bound", regIdx); + mfunc.pRegs[regIdx] = rhs; + } + } else { + bool extended = false; + if (regIdx == -kSregRetval0) { + extended = RegAssignZextOrSext(rhs, node->ptyp, caller->retVal0); + } else if (regIdx == -kSregRetval1) { + extended = RegAssignZextOrSext(rhs, node->ptyp, caller->retVal1); + } else { + MASSERT(regIdx < fn->numPregs, "regassign regIdx %d out of bound", regIdx); + extended = RegAssignZextOrSext(rhs, node->ptyp, mfunc.pRegs[regIdx]); + } + if (!extended) { + if ((node->ptyp == PTY_a64 || node->ptyp == PTY_u64) && + (rhs.ptyp == PTY_a64 || rhs.ptyp == PTY_u64)) { + mfunc.pRegs[regIdx] = rhs; + mfunc.pRegs[regIdx].ptyp = node->ptyp; + } else { + // MASSERT(false, "regassign type mismatch: %d and %d", node->ptyp, rhs.ptyp); + mfunc.pRegs[regIdx] = CvtType(rhs, node->ptyp, rhs.ptyp); + } + } + } + } + stmt = stmt->GetNext(); + mfunc.nextStmt = stmt; + goto *(labels[stmt->op]); +label_OP_brfalse: +label_OP_brtrue: + { + CondGotoNode* node = static_cast(stmt); + uint32 labelIdx = node->GetOffset(); (void)labelIdx; + MValue cond = EvalExpr(mfunc, node->GetRHS()); + StmtNode* label = fn->labelMap[labelIdx]; + if (stmt->op == OP_brfalse && IsZero(cond)) stmt = label; + if (stmt->op == OP_brtrue && !IsZero(cond)) stmt = label; + } + stmt = stmt->GetNext(); + mfunc.nextStmt = stmt; + goto *(labels[stmt->op]); +label_OP_label: + // no-op + stmt = stmt->GetNext(); + mfunc.nextStmt = stmt; + goto *(labels[stmt->op]); +label_OP_goto: + { + uint32 labelIdx = static_cast(stmt)->GetOffset(); + StmtNode* label = fn->labelMap[labelIdx]; + stmt = label; + } + stmt = stmt->GetNext(); + mfunc.nextStmt = stmt; + goto *(labels[stmt->op]); +label_OP_return: + return caller->retVal0; +label_OP_iassignoff: + { + IassignoffNode* node = static_cast(stmt); + int32 offset = node->GetOffset(); + MValue addr = EvalExpr(mfunc, node->Opnd(0)); + MValue rhs = EvalExpr(mfunc, node->Opnd(1)); + mstore(addr.x.a64 + offset, stmt->ptyp, rhs); + } + stmt = stmt->GetNext(); + mfunc.nextStmt = stmt; + goto *(labels[stmt->op]); +label_OP_blkassignoff: + { + BlkassignoffNode* node = static_cast(stmt); + //uint32 align = node->GetAlign(); + int32 dstOffset = node->offset; + int32 blkSize = node->blockSize; + MValue dstAddr = EvalExpr(mfunc, node->Opnd(0)); + MValue srcAddr = EvalExpr(mfunc, node->Opnd(1)); + memcpy(dstAddr.x.a64 + dstOffset, srcAddr.x.a64, blkSize); + } + stmt = stmt->GetNext(); + mfunc.nextStmt = stmt; + goto *(labels[stmt->op]); +label_OP_icallproto: + { + IcallNode *icallproto = static_cast(stmt); + MASSERT(icallproto->NumOpnds() > 0, "icallproto num operands is %ld", icallproto->NumOpnds()); + // alloc stack space for call args + MValue callArgs[icallproto->NumOpnds()-1]; + mfunc.callArgs = callArgs; + mfunc.numCallArgs = icallproto->NumOpnds()-1; + // assume func addr in opnd 0 is from addroffunc + MValue fnAddr = EvalExpr(mfunc, icallproto->Opnd(0)); + FuncAddr *faddr = reinterpret_cast(fnAddr.x.a64); + if (faddr->isLmbcFunc) { + mfunc.CallMapleFuncIndirect(icallproto, faddr->funcPtr.lmbcFunc); + } else { + mfunc.CallExtFuncIndirect(icallproto, faddr->funcPtr.nativeFunc); + } + } + stmt = stmt->GetNext(); + mfunc.nextStmt = stmt; + goto *(labels[stmt->op]); +label_OP_rangegoto: + { + RangeGotoNode *rgoto = static_cast(stmt); + int32 tagOffset = rgoto->GetTagOffset(); + MValue opnd = EvalExpr(mfunc, rgoto->Opnd(0)); + int64 tag = MVal2Int64(opnd); + uint32 labelIdx = rgoto->GetRangeGotoTableItem(tag - tagOffset).second; + StmtNode *label = fn->labelMap[labelIdx]; + stmt = label; + } + stmt = stmt->GetNext(); + mfunc.nextStmt = stmt; + goto *(labels[stmt->op]); +label_OP_igoto: + { + MValue opnd = EvalExpr(mfunc, stmt->Opnd(0)); + StmtNode *label = (StmtNode*)opnd.x.a64; + stmt = label; + } + stmt = stmt->GetNext(); + mfunc.nextStmt = stmt; + goto *(labels[stmt->op]); +label_OP_intrinsiccall: + { + mfunc.CallIntrinsic(*static_cast(stmt)); + } + stmt = stmt->GetNext(); + mfunc.nextStmt = stmt; + goto *(labels[stmt->op]); + +label_OP_dassign: +label_OP_piassign: +label_OP_maydassign: +label_OP_iassign: +label_OP_doloop: +label_OP_dowhile: +label_OP_if: +label_OP_while: +label_OP_switch: +label_OP_multiway: +label_OP_foreachelem: +label_OP_comment: +label_OP_eval: +label_OP_free: +label_OP_calcassertge: +label_OP_calcassertlt: +label_OP_assertge: +label_OP_assertlt: +label_OP_callassertle: +label_OP_returnassertle: +label_OP_assignassertle: +label_OP_abort: +label_OP_assertnonnull: +label_OP_assignassertnonnull: +label_OP_callassertnonnull: +label_OP_returnassertnonnull: +label_OP_dread: +label_OP_iread: +label_OP_addrof: +label_OP_iaddrof: +label_OP_sizeoftype: +label_OP_fieldsdist: +label_OP_array: +label_OP_virtualcall: +label_OP_superclasscall: +label_OP_interfacecall: +label_OP_customcall: +label_OP_polymorphiccall: +label_OP_icall: +label_OP_interfaceicall: +label_OP_virtualicall: +label_OP_intrinsiccallwithtype: +label_OP_xintrinsiccall: +label_OP_callassigned: +label_OP_virtualcallassigned: +label_OP_superclasscallassigned: +label_OP_interfacecallassigned: +label_OP_customcallassigned: +label_OP_polymorphiccallassigned: +label_OP_icallassigned: +label_OP_interfaceicallassigned: +label_OP_virtualicallassigned: +label_OP_intrinsiccallassigned: +label_OP_intrinsiccallwithtypeassigned: +label_OP_xintrinsiccallassigned: +label_OP_callinstant: +label_OP_callinstantassigned: +label_OP_virtualcallinstant: +label_OP_virtualcallinstantassigned: +label_OP_superclasscallinstant: +label_OP_superclasscallinstantassigned: +label_OP_interfacecallinstant: +label_OP_interfacecallinstantassigned: +label_OP_jstry: +label_OP_try: +label_OP_cpptry: +label_OP_throw: +label_OP_jscatch: +label_OP_catch: +label_OP_cppcatch: +label_OP_finally: +label_OP_cleanuptry: +label_OP_endtry: +label_OP_safe: +label_OP_endsafe: +label_OP_unsafe: +label_OP_endunsafe: +label_OP_gosub: +label_OP_retsub: +label_OP_syncenter: +label_OP_syncexit: +label_OP_decref: +label_OP_incref: +label_OP_decrefreset: +label_OP_membaracquire: +label_OP_membarrelease: +label_OP_membarstoreload: +label_OP_membarstorestore: +label_OP_ireadoff: +label_OP_ireadfpoff: +label_OP_regread: +label_OP_addroffunc: +label_OP_addroflabel: +label_OP_constval: +label_OP_conststr: +label_OP_conststr16: +label_OP_ceil: +label_OP_cvt: +label_OP_floor: +label_OP_retype: +label_OP_round: +label_OP_trunc: +label_OP_abs: +label_OP_bnot: +label_OP_lnot: +label_OP_neg: +label_OP_recip: +label_OP_sqrt: +label_OP_sext: +label_OP_zext: +label_OP_alloca: +label_OP_malloc: +label_OP_gcmalloc: +label_OP_gcpermalloc: +label_OP_stackmalloc: +label_OP_gcmallocjarray: +label_OP_gcpermallocjarray: +label_OP_stackmallocjarray: +label_OP_resolveinterfacefunc: +label_OP_resolvevirtualfunc: +label_OP_add: +label_OP_sub: +label_OP_mul: +label_OP_div: +label_OP_rem: +label_OP_ashr: +label_OP_lshr: +label_OP_shl: +label_OP_ror: +label_OP_max: +label_OP_min: +label_OP_band: +label_OP_bior: +label_OP_bxor: +label_OP_CG_array_elem_add: +label_OP_eq: +label_OP_ge: +label_OP_gt: +label_OP_le: +label_OP_lt: +label_OP_ne: +label_OP_cmp: +label_OP_cmpl: +label_OP_cmpg: +label_OP_land: +label_OP_lior: +label_OP_cand: +label_OP_cior: +label_OP_select: +label_OP_intrinsicop: +label_OP_intrinsicopwithtype: +label_OP_extractbits: +label_OP_depositbits: +label_OP_iassignpcoff: +label_OP_ireadpcoff: +label_OP_checkpoint: +label_OP_addroffpc: +label_OP_asm: +label_OP_dreadoff: +label_OP_addrofoff: +label_OP_dassignoff: +label_OP_iassignspoff: +label_OP_icallprotoassigned: + { + MASSERT(false, "NIY"); + for(;;); + } + return retVal; +} + +MValue EvalExpr(MFunction& func, BaseNode* expr, ParmInf *parm) { + MValue res; + + static void* const labels[] = { + &&label_OP_Undef, +#define OPCODE(base_node,dummy1,dummy2,dummy3) &&label_OP_##base_node, +#include "opcodes.def" +#undef OPCODE + &&label_OP_Undef + }; + + goto *(labels[expr->op]); +label_OP_Undef: + { + MASSERT(false, "Hit OP_undef"); + } +label_OP_constval: + { + MIRConst* constval = static_cast(expr)->GetConstVal(); + int64 constInt = 0; + float constFloat = 0; + double constDouble = 0; + switch(constval->GetKind()) { + case kConstInt: + constInt = static_cast(constval)->GetExtValue(); + break; + case kConstDoubleConst: + constDouble = static_cast(constval)->GetValue(); + break; + case kConstFloatConst: + constFloat = static_cast(constval)->GetValue(); + break; + default: + MASSERT(false, "constval kind %d NYI", constval->GetKind()); + break; + } + PrimType ptyp = expr->ptyp; + switch(ptyp) { + case PTY_i8: + case PTY_i16: + case PTY_i32: + case PTY_i64: + MASSERT(constval->GetKind() == kConstInt, "ptyp and constval kind mismatch"); + res.x.i64 = constInt; + res.ptyp = ptyp; + break; + case PTY_u8: + case PTY_u16: + case PTY_u32: + case PTY_u64: + case PTY_a64: + MASSERT(constval->GetKind() == kConstInt, "ptyp and constval kind mismatch"); + res.x.u64 = constInt; + res.ptyp = ptyp; + break; + case PTY_f32: + MASSERT(constval->GetKind() == kConstFloatConst, "ptyp and constval kind mismatch"); + res.x.f32 = constFloat; + res.ptyp = ptyp; + break; + case PTY_f64: + MASSERT(constval->GetKind() == kConstDoubleConst, "constval ptyp and kind mismatch"); + res.x.f64 = constDouble; + res.ptyp = ptyp; + break; + default: + MASSERT(false, "ptype %d for constval NYI", ptyp); + break; + } + } + goto _exit; + +label_OP_add: + { + MValue op0 = EvalExpr(func, expr->Opnd(0)); + MValue op1 = EvalExpr(func, expr->Opnd(1)); + switch(expr->ptyp) { + case PTY_i8: res.x.i8 = op0.x.i8 + op1.x.i8; break; + case PTY_i16: res.x.i16 = op0.x.i16 + op1.x.i16; break; + case PTY_i32: res.x.i32 = (int64)op0.x.i32 + (int64)op1.x.i32; break; + case PTY_i64: res.x.i64 = (uint64)op0.x.i64 + (uint64)op1.x.i64; break; + case PTY_u8: res.x.u8 = op0.x.u8 + op1.x.u8; break; + case PTY_u16: res.x.u16 = op0.x.u16 + op1.x.u16; break; + case PTY_u32: res.x.u32 = op0.x.u32 + op1.x.u32; break; + case PTY_u64: res.x.u64 = op0.x.u64 + op1.x.u64; break; + case PTY_a64: res.x.u64 = op0.x.u64 + op1.x.u64; break; + case PTY_f32: res.x.f32 = op0.x.f32 + op1.x.f32; break; + case PTY_f64: res.x.f64 = op0.x.f64 + op1.x.f64; break; + default: MIR_FATAL("Unsupported PrimType %d for binary operator %s", expr->ptyp, "+"); + } + res.ptyp = expr->ptyp; +// EXPRBINOP(+, res, opnd0, opnd1, expr->ptyp); + goto _exit; + } +label_OP_sub: + { + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + EXPRBINOP(-, res, opnd0, opnd1, expr->ptyp); + goto _exit; + } +label_OP_mul: + { + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + EXPRBINOP(*, res, opnd0, opnd1, expr->ptyp); + goto _exit; + } +label_OP_div: + { + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + EXPRBINOP(/, res, opnd0, opnd1, expr->ptyp); + goto _exit; + } +label_OP_regread: + { + PregIdx regIdx = static_cast(expr)->GetRegIdx(); + switch(regIdx) { + case -(kSregFp): + MASSERT(expr->ptyp == PTY_a64, "regread %%FP with wrong ptyp %d", expr->ptyp); + res.x.a64 = func.fp; + break; + case -(kSregRetval0): + if (expr->ptyp == func.retVal0.ptyp) { + res = func.retVal0; + } else if (expr->ptyp == PTY_agg || expr->ptyp == PTY_u64) { + res = func.retVal0; + } else { + res = CvtType(func.retVal0, expr->ptyp, func.retVal0.ptyp); + } + break; + case -(kSregRetval1): + MASSERT(expr->ptyp == func.retVal1.ptyp || + (expr->ptyp == PTY_agg || expr->ptyp == PTY_u64), + "regread %%retVal0 type mismatch: %d %d", expr->ptyp, func.retVal1.ptyp); + res = func.retVal1; + break; + case -(kSregGp): + MASSERT(expr->ptyp == PTY_a64, "regread %%GP with wrong ptyp %d", expr->ptyp); + res.x.a64 = func.info->lmbcMod->unInitPUStatics; + break; + default: + MASSERT(regIdx < func.info->numPregs, "regread regIdx %d out of bound", regIdx); + // MASSERT(expr->ptyp == func.pRegs[regIdx].ptyp, "regread primtype mismatch: %d and %d", expr->ptyp, func.pRegs[regIdx].ptyp); + res = func.pRegs[regIdx]; + break; + } + res.ptyp = expr->ptyp; + goto _exit; + } +label_OP_conststr: + { + UStrIdx ustrIdx = static_cast(expr)->GetStrIdx(); + auto it = func.info->lmbcMod->globalStrTbl.insert( + std::pair(ustrIdx, GlobalTables::GetUStrTable().GetStringFromStrIdx(ustrIdx))); + res.x.ptr = const_cast(it.first->second.c_str()); + res.ptyp = PTY_a64; + goto _exit; + } +label_OP_ireadfpoff: + { + IreadFPoffNode* node = static_cast(expr); + int32 offset = node->GetOffset(); + if (node->ptyp != PTY_agg) { + mload(func.fp+offset, expr->ptyp, res); + goto _exit; + } + // handle PTY_agg + // ireadfpoff agg should be opnd from either call or return, i.e. either + // - caller: call &foo (ireadfpoff agg -16, ireadfpoff agg -28) + // - callee: regassign agg %%retval0 (ireadfpoff agg -12) + // so set agg size in mvalue result with agg size from corresponding func formal or func return, and + // - if from caller, read agg into caller allocated buffer for agg and return the pointer in an mvalue to be passed to callee + // - if from callee, just pass fp offset ptr in an mvalue and regassign will copy it to caller's retval0/1 area + if (func.nextStmt->op == OP_call) { // caller + // check if calling external func: + MASSERT(func.aggrArgsBuf != nullptr, "aggrArgsBuf is null"); + memcpy(func.aggrArgsBuf+parm->storeIdx, func.fp+offset, parm->size); + mload(func.aggrArgsBuf+parm->storeIdx, expr->ptyp, res, parm->size); + } else { // callee + mload(func.fp+offset, expr->ptyp, res, func.info->retSize); + } + goto _exit; + } +label_OP_ireadoff: + { + int32 offset = static_cast(expr)->GetOffset(); + MValue rhs = EvalExpr(func, static_cast(expr)->Opnd(0)); + if (expr->ptyp == PTY_agg) { + // ireadoff agg should be operand for either call or return (like ireadfpoff) + // - caller: call &f (ireadoff agg 0 (regread a64 %1)) + // - callee: regassign agg %%retval0 (ireadoff agg 0 (addrofoff a64 $x 0)) + MASSERT(rhs.ptyp == PTY_a64, "ireadoff agg RHS not PTY_agg"); + if (func.nextStmt->op == OP_call) { + MASSERT(func.aggrArgsBuf != nullptr, "aggrArgsBuf is null"); + memcpy(func.aggrArgsBuf+parm->storeIdx, rhs.x.a64 + offset, parm->size); + mload(func.aggrArgsBuf+parm->storeIdx, expr->ptyp, res, parm->size); + } else { + MASSERT(func.nextStmt->op == OP_regassign, "ireadoff agg not used as regassign agg opnd"); + mload(rhs.x.a64 + offset, expr->ptyp, res, func.info->retSize); + } + goto _exit; + } + MASSERT(rhs.ptyp == PTY_a64 || rhs.ptyp == PTY_u64 || rhs.ptyp == PTY_i64, + "ireadoff rhs ptyp %d not PTY_a64 or PTY_u64", rhs.ptyp); + mload(rhs.x.a64+offset, expr->ptyp, res); + goto _exit; + } +label_OP_iread: + { + MASSERT(func.nextStmt->op == OP_call && expr->ptyp == PTY_agg, "iread unexpected outside call"); + MValue addr = EvalExpr(func, expr->Opnd(0)); + MASSERT(func.aggrArgsBuf != nullptr, "aggrArgsBuf is null"); + memcpy(func.aggrArgsBuf+parm->storeIdx, addr.x.a64, parm->size); + mload(func.aggrArgsBuf+parm->storeIdx, expr->ptyp, res, parm->size); + goto _exit; + } +label_OP_eq: + { + PrimType opndType = static_cast(expr)->GetOpndType(); + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + if (opndType == PTY_f32 || opndType == PTY_f64) { + res.ptyp = expr->ptyp; + HandleFloatEq(expr->op, opndType, res, opnd0, opnd1); + } else { + EXPRCOMPOPNOFLOAT(==, res, opnd0, opnd1, opndType, expr->ptyp); + } + goto _exit; + } +label_OP_ne: + { + PrimType opndType = static_cast(expr)->GetOpndType(); + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + if (opndType == PTY_f32 || opndType == PTY_f64) { + res.ptyp = expr->ptyp; + HandleFloatEq(expr->op, opndType, res, opnd0, opnd1); + } else { + EXPRCOMPOPNOFLOAT(!=, res, opnd0, opnd1, opndType, expr->ptyp); + } + goto _exit; + } +label_OP_gt: + { + PrimType opndTyp= static_cast(expr)->GetOpndType(); + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + EXPRCOMPOP(>, res, opnd0, opnd1, opndTyp, expr->ptyp); + goto _exit; + } +label_OP_ge: + { + PrimType opndTyp= static_cast(expr)->GetOpndType(); + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + EXPRCOMPOP(>=, res, opnd0, opnd1, opndTyp, expr->ptyp); + goto _exit; + } +label_OP_lt: + { + PrimType opndTyp= static_cast(expr)->GetOpndType(); + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + EXPRCOMPOP(<, res, opnd0, opnd1, opndTyp, expr->ptyp); + goto _exit; + } +label_OP_le: + { + PrimType opndTyp= static_cast(expr)->GetOpndType(); + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + EXPRCOMPOP(<=, res, opnd0, opnd1, opndTyp, expr->ptyp); + goto _exit; + } +label_OP_select: + { + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + MValue opnd2 = EvalExpr(func, expr->Opnd(2)); + EXPRSELECTOP(res, opnd0, opnd1, opnd2, expr->ptyp); + goto _exit; + } +label_OP_band: + { + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + EXPRBININTOP(&, res, opnd0, opnd1, expr->ptyp); + goto _exit; + } +label_OP_bior: + { + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + EXPRBININTOP(|, res, opnd0, opnd1, expr->ptyp); + goto _exit; + } +label_OP_bxor: + { + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + EXPRBININTOP(^, res, opnd0, opnd1, expr->ptyp); + goto _exit; + } +label_OP_lshr: + { + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue numBits = EvalExpr(func, expr->Opnd(1)); + EXPRBININTOPUNSIGNED(>>, res, opnd0, numBits, expr->ptyp); + goto _exit; + } +label_OP_ashr: + { + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue numBits = EvalExpr(func, expr->Opnd(1)); + EXPRBININTOP(>>, res, opnd0, numBits, expr->ptyp); + goto _exit; + } +label_OP_shl: + { + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue numBits = EvalExpr(func, expr->Opnd(1)); + EXPRBININTOP(<<, res, opnd0, numBits, expr->ptyp); + goto _exit; + } +label_OP_bnot: + { + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + EXPRUNROP(~, res, opnd0, expr->ptyp); + goto _exit; + } +label_OP_lnot: + { + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + EXPRUNROP(!, res, opnd0, expr->ptyp); + goto _exit; + } +label_OP_neg: + { + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + switch(expr->ptyp) { + case PTY_i8: res.x.i8 = -opnd0.x.i8; break; + case PTY_i16: res.x.i16 = -opnd0.x.i16; break; + //case PTY_i32: res.x.i32 = -opnd0.x.i32; break; + case PTY_i32: res.x.i32 = ~(uint32)opnd0.x.i32+1; break; + case PTY_i64: res.x.i64 = -opnd0.x.i64; break; + case PTY_u8: res.x.u8 = -opnd0.x.u8; break; + case PTY_u16: res.x.u16 = -opnd0.x.u16; break; + case PTY_u32: res.x.u32 = -opnd0.x.u32; break; + case PTY_u64: res.x.u64 = -opnd0.x.u64; break; + case PTY_f32: res.x.f32 = -opnd0.x.f32; break; + case PTY_f64: res.x.f64 = -opnd0.x.f64; break; + default: MIR_FATAL("Unsupported PrimType %d for unary operator %s", expr->ptyp, "OP_neg"); + } + res.ptyp = expr->ptyp; +#if 0 + EXPRUNROP(-, res, opnd0, expr->ptyp); +#endif + goto _exit; + } +label_OP_abs: + { + MValue op0 = EvalExpr(func, expr->Opnd(0)); + switch(expr->ptyp) { + // abs operand must be signed + case PTY_i8: res.x.i8 = abs(op0.x.i8); break; + case PTY_i16: res.x.i16 = abs(op0.x.i16); break; + case PTY_i32: res.x.i32 = abs(op0.x.i32); break; + case PTY_i64: res.x.i64 = abs(op0.x.i64); break; + case PTY_f32: res.x.f32 = fabsf(op0.x.f32); break; + case PTY_f64: res.x.f64 = fabs(op0.x.f64); break; + default: MASSERT(false, "op_abs unsupported type %d", expr->ptyp); + } + res.ptyp = expr->ptyp; + goto _exit; + } +label_OP_min: + { + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + EXPRMAXMINOP(<, res, opnd0, opnd1, expr->ptyp); + goto _exit; + } +label_OP_max: + { + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + EXPRMAXMINOP(>, res, opnd0, opnd1, expr->ptyp); + goto _exit; + } +label_OP_rem: + { + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + EXPRREMOP(%, res, opnd0, opnd1, expr->ptyp); + goto _exit; + } +label_OP_cvt: + { + PrimType toPtyp = expr->ptyp; + PrimType fromPtyp = static_cast(expr)->FromType(); + MValue opnd = EvalExpr(func, expr->Opnd(0)); + res = CvtType(opnd, toPtyp, fromPtyp); + goto _exit; + } +label_OP_addrofoff: + { + // get addr of var symbol which can be formal/global/extern/PUStatic + int32 offset = static_cast(expr)->offset; + StIdx stidx = static_cast(expr)->stIdx; + uint8 *addr; + + if (stidx.Islocal()) { // local sym can only be formals or PUstatic + addr = func.GetFormalVarAddr(stidx); + if (!addr) { + addr = func.info->lmbcMod->GetVarAddr(func.info->mirFunc->GetPuidx(), stidx); + } + MASSERT(addr, "addrofoff can not find local var"); + } else { + MASSERT(stidx.IsGlobal(), "addrofoff: symbol neither local nor global"); + MIRSymbol* var = GlobalTables::GetGsymTable().GetSymbolFromStidx(stidx.Idx()); + switch(var->GetStorageClass()) { + case kScExtern: + addr = (uint8 *)(func.info->lmbcMod->FindExtSym(stidx)); + break; + case kScGlobal: + case kScFstatic: + addr = func.info->lmbcMod->GetVarAddr(var->GetStIdx()); + break; + default: + MASSERT(false, "addrofoff: storage class %d NYI", var->GetStorageClass()); + break; + } + } + res.x.a64 = addr + offset; + res.ptyp = PTY_a64; + goto _exit; + } +label_OP_alloca: + { + MValue opnd = EvalExpr(func, expr->Opnd(0)); + res.ptyp = PTY_a64; + res.x.a64 = func.Alloca(opnd.x.u64); + goto _exit; + } +label_OP_addroffunc: + { + FuncAddr *faddr = func.info->lmbcMod->GetFuncAddr(static_cast(expr)->GetPUIdx()); + res.x.a64 = (uint8*)faddr; + res.ptyp = PTY_a64; + goto _exit; + } +label_OP_addroflabel: + { + AddroflabelNode *node = static_cast(expr); + LabelIdx labelIdx = node->GetOffset(); + StmtNode *label = func.info->labelMap[labelIdx]; + res.x.a64 = reinterpret_cast(label); + res.ptyp = expr->ptyp; + goto _exit; + } +label_OP_retype: + { + res = EvalExpr(func, expr->Opnd(0)); + res.ptyp = expr->ptyp; + goto _exit; + } +label_OP_sext: + { + ExtractbitsNode *ext = static_cast(expr); + uint8 bOffset = ext->GetBitsOffset(); + uint8 bSize = ext->GetBitsSize(); + MASSERT(bOffset == 0, "sext unexpected offset"); + uint64 mask = bSize < 64 ? (1ull << bSize) - 1 : ~0ull; + res = EvalExpr(func, expr->Opnd(0)); + res.x.i64 = ((uint64)res.x.i64 >> (bSize - 1) & 1ull) ? res.x.i64 | ~mask : res.x.i64 & mask; + res.ptyp = expr->ptyp; + goto _exit; + } +label_OP_zext: + { + ExtractbitsNode *ext = static_cast(expr); + uint8 bOffset = ext->GetBitsOffset(); + uint8 bSize = ext->GetBitsSize(); + MASSERT(bOffset == 0, "zext unexpected offset"); + uint64 mask = bSize < 64 ? (1ull << bSize) - 1 : ~0ull; + res = EvalExpr(func, expr->Opnd(0)); + res.x.i64 &= mask; + res.ptyp = expr->ptyp; + goto _exit; + } +label_OP_extractbits: + { + ExtractbitsNode *ebits = static_cast(expr); + uint8 bOffset = ebits->GetBitsOffset(); + uint8 bSize = ebits->GetBitsSize(); + uint64 mask = ((1ull << bSize) - 1) << bOffset; + res = EvalExpr(func, expr->Opnd(0)); + res.x.i64 = (uint64)(res.x.i64 & mask) >> bOffset; + if (IsSignedInteger(expr->ptyp)) { + mask = (1ull << bSize) - 1; + res.x.i64 = ((uint64)res.x.i64 >> (bSize - 1) & 1ull) ? res.x.i64 | ~mask : res.x.i64 & mask; + } + res.ptyp = expr->ptyp; + goto _exit; + } +label_OP_depositbits: + { + DepositbitsNode *dbits = static_cast(expr); + MValue opnd0 = EvalExpr(func, expr->Opnd(0)); + MValue opnd1 = EvalExpr(func, expr->Opnd(1)); + uint64 mask = ~(0xffffffffffffffff << dbits->GetBitsSize()); + uint64 from = (opnd1.x.u64 & mask) << dbits->GetBitsOffset(); + mask = mask << dbits->GetBitsOffset(); + res.x.u64 = (opnd0.x.u64 & ~(mask)) | from; + res.ptyp = expr->ptyp; + goto _exit; + } +label_OP_intrinsicop: + { + auto *intrnop = static_cast(expr); + MValue op0 = EvalExpr(func, expr->Opnd(0)); + res.ptyp = expr->ptyp; + // MASSERT(expr->ptyp == op0.ptyp, "intrinsicop type mismatch %d and %d", expr->ptyp, op0.ptyp); + switch(intrnop->GetIntrinsic()) { + case INTRN_C_sin: + if (expr->ptyp == PTY_f32) { + res.x.f32 = sin(op0.x.f32); + } else if (expr->ptyp == PTY_f64) { + res.x.f64 = sin(op0.x.f64); + } + break; + case INTRN_C_ctz32: + if (expr->ptyp == PTY_u32 || expr->ptyp == PTY_i32) { + res.x.u32 = __builtin_ctz(op0.x.u32); + } + break; + case INTRN_C_clz32: + if (expr->ptyp == PTY_u32 || expr->ptyp == PTY_i32) { + res.x.u32 = __builtin_clz(op0.x.u32); + } + break; + case INTRN_C_ffs: + if (expr->ptyp == PTY_u32 || expr->ptyp == PTY_i32) { + res.x.u32 = __builtin_ffs(op0.x.u32); + } + break; + case INTRN_C_rev_4: + if (expr->ptyp == PTY_u32 || expr->ptyp == PTY_i32) { + res.x.u32 = __builtin_bitreverse32(op0.x.u32); + } + break; + default: + break; + } + goto _exit; + } + + // unsupported opcodes +label_OP_dassign: +label_OP_piassign: +label_OP_maydassign: +label_OP_iassign: +label_OP_block: +label_OP_doloop: +label_OP_dowhile: +label_OP_if: +label_OP_while: +label_OP_switch: +label_OP_multiway: +label_OP_foreachelem: +label_OP_comment: +label_OP_eval: +label_OP_free: +label_OP_calcassertge: +label_OP_calcassertlt: +label_OP_assertge: +label_OP_assertlt: +label_OP_callassertle: +label_OP_returnassertle: +label_OP_assignassertle: +label_OP_abort: +label_OP_assertnonnull: +label_OP_assignassertnonnull: +label_OP_callassertnonnull: +label_OP_returnassertnonnull: +label_OP_dread: +label_OP_addrof: +label_OP_iaddrof: +label_OP_sizeoftype: +label_OP_fieldsdist: +label_OP_array: +label_OP_iassignoff: +label_OP_iassignfpoff: +label_OP_regassign: +label_OP_goto: +label_OP_brfalse: +label_OP_brtrue: +label_OP_return: +label_OP_rangegoto: +label_OP_call: +label_OP_virtualcall: +label_OP_superclasscall: +label_OP_interfacecall: +label_OP_customcall: +label_OP_polymorphiccall: +label_OP_icall: +label_OP_interfaceicall: +label_OP_virtualicall: +label_OP_intrinsiccall: +label_OP_intrinsiccallwithtype: +label_OP_xintrinsiccall: +label_OP_callassigned: +label_OP_virtualcallassigned: +label_OP_superclasscallassigned: +label_OP_interfacecallassigned: +label_OP_customcallassigned: +label_OP_polymorphiccallassigned: +label_OP_icallassigned: +label_OP_interfaceicallassigned: +label_OP_virtualicallassigned: +label_OP_intrinsiccallassigned: +label_OP_intrinsiccallwithtypeassigned: +label_OP_xintrinsiccallassigned: +label_OP_callinstant: +label_OP_callinstantassigned: +label_OP_virtualcallinstant: +label_OP_virtualcallinstantassigned: +label_OP_superclasscallinstant: +label_OP_superclasscallinstantassigned: +label_OP_interfacecallinstant: +label_OP_interfacecallinstantassigned: +label_OP_jstry: +label_OP_try: +label_OP_cpptry: +label_OP_throw: +label_OP_jscatch: +label_OP_catch: +label_OP_cppcatch: +label_OP_finally: +label_OP_cleanuptry: +label_OP_endtry: +label_OP_safe: +label_OP_endsafe: +label_OP_unsafe: +label_OP_endunsafe: +label_OP_gosub: +label_OP_retsub: +label_OP_syncenter: +label_OP_syncexit: +label_OP_decref: +label_OP_incref: +label_OP_decrefreset: +label_OP_membaracquire: +label_OP_membarrelease: +label_OP_membarstoreload: +label_OP_membarstorestore: +label_OP_label: +label_OP_conststr16: +label_OP_ceil: +label_OP_floor: +label_OP_round: +label_OP_trunc: +label_OP_recip: +label_OP_sqrt: +label_OP_malloc: +label_OP_gcmalloc: +label_OP_gcpermalloc: +label_OP_stackmalloc: +label_OP_gcmallocjarray: +label_OP_gcpermallocjarray: +label_OP_stackmallocjarray: +label_OP_resolveinterfacefunc: +label_OP_resolvevirtualfunc: +label_OP_ror: +label_OP_CG_array_elem_add: +label_OP_cmp: +label_OP_cmpl: +label_OP_cmpg: +label_OP_land: +label_OP_lior: +label_OP_cand: +label_OP_cior: +label_OP_intrinsicopwithtype: +label_OP_iassignpcoff: +label_OP_ireadpcoff: +label_OP_checkpoint: +label_OP_addroffpc: +label_OP_igoto: +label_OP_asm: +label_OP_dreadoff: +label_OP_dassignoff: +label_OP_iassignspoff: +label_OP_blkassignoff: +label_OP_icallproto: +label_OP_icallprotoassigned: + { + MASSERT(false, "NIY"); + } + +_exit: + return res; +} + +} // namespace maple diff --git a/src/MapleEng/lmbc/src/load_store.cpp b/src/MapleEng/lmbc/src/load_store.cpp new file mode 100644 index 0000000000..83a7ed6faf --- /dev/null +++ b/src/MapleEng/lmbc/src/load_store.cpp @@ -0,0 +1,127 @@ +/* + * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved. + * + * OpenArkCompiler is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +#include "mvalue.h" +#include "mfunction.h" +#include "massert.h" + +namespace maple { + +void mload(uint8* addr, PrimType ptyp, MValue& res, size_t aggSize) { + res.ptyp = ptyp; + switch(ptyp) { + case PTY_i8: + res.x.i64 = *(int8 *)addr; + return; + case PTY_i16: + res.x.i64 = *(int16 *)addr; + return; + case PTY_i32: + res.x.i64 = *(int32 *)addr; + return; + case PTY_i64: + res.x.i64 = *(int64 *)addr; + return; + case PTY_u8: + res.x.u64 = *(uint8 *)addr; + return; + case PTY_u16: + res.x.u64 = *(uint16 *)addr; + return; + case PTY_u32: + res.x.u64 = *(uint32 *)addr; + return; + case PTY_u64: + res.x.u64 = *(uint64 *)addr; + return; + case PTY_f32: + res.x.f32 = *(float *)addr; + return; + case PTY_f64: + res.x.f64 = *(double *)addr; + return; + case PTY_a64: + res.x.a64 = *(uint8 **)addr; + return; + case PTY_agg: + res.x.a64 = addr; + res.aggSize = aggSize; // agg size + return; + default: + MASSERT(false, "mload ptyp %d NYI", ptyp); + break; + } +} + +void mstore(uint8* addr, PrimType ptyp, MValue& val, bool toVarArgStack) { + if (!IsPrimitiveInteger(ptyp) || !IsPrimitiveInteger(val.ptyp)) { + MASSERT(ptyp == val.ptyp || + ptyp == PTY_a64 && val.ptyp == PTY_u64 || + ptyp == PTY_u64 && val.ptyp == PTY_a64, + "mstore type mismatch: %d and %d", ptyp, val.ptyp); + } + switch(ptyp) { + case PTY_i8: + *(int8 *)addr = val.x.i8; + return; + case PTY_i16: + *(int16 *)addr = val.x.i16; + return; + case PTY_i32: + *(int32 *)addr = val.x.i32; + return; + case PTY_i64: + *(int64 *)addr = val.x.i64; + return; + case PTY_u8: + *(uint8 *)addr = val.x.u8; + return; + case PTY_u16: + *(uint16 *)addr = val.x.u16; + return; + case PTY_u32: + *(uint32 *)addr = val.x.u32; + return; + case PTY_u64: + *(uint64 *)addr = val.x.u64; + return; + case PTY_f32: + *(float *)addr = val.x.f32; + return; + case PTY_f64: + *(double *)addr = val.x.f64; + return; + case PTY_a64: + *(uint8 **)addr = val.x.a64; + return; + case PTY_agg: + if (toVarArgStack) { + if (val.aggSize > 16) { + *(uint8 **)addr = val.x.a64; + } else { + memcpy(addr, val.x.a64, val.aggSize); + } + } else { + // val holds aggr data (regassign agg of <= 16 bytes to %%retval0) instead of ptr to aggr data + MASSERT(val.aggSize <= 16, "mstore agg > 16"); + memcpy(addr, &(val.x.u64), val.aggSize); + } + return; + default: + MASSERT(false, "mstore ptyp %d NYI", ptyp); + break; + } +} + +} // namespace maple diff --git a/src/MapleEng/lmbc/src/mfunction.cpp b/src/MapleEng/lmbc/src/mfunction.cpp new file mode 100644 index 0000000000..333b7a7bd3 --- /dev/null +++ b/src/MapleEng/lmbc/src/mfunction.cpp @@ -0,0 +1,342 @@ +/* + * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved. + * + * OpenArkCompiler is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +#include +#include "mfunction.h" +#include "mprimtype.h" +#include "massert.h" + +namespace maple { + +MFunction::MFunction(LmbcFunc *funcInfo, + MFunction *funcCaller, + uint8 *autoVars, + MValue *pregs, + MValue *formalvars) : + info(funcInfo), + caller(funcCaller), + frame(autoVars), + pRegs(pregs), + formalVars(formalvars), + callArgs(nullptr), + aggrArgsBuf(nullptr) +{ + numCallArgs = 0; + nextStmt = info->mirFunc->GetBody(); + fp = (uint8*)frame + info->frameSize; + allocaOffset = 0; + allocaMem = nullptr; +} + +MFunction::~MFunction() { } + +uint8 *MFunction::Alloca(uint32 sz) { + if (allocaOffset + sz > ALLOCA_MEMMAX) { + return nullptr; + } + uint8 *ptr = allocaMem + allocaOffset; + allocaOffset += sz; + return ptr; +} + +uint8 *MFunction::GetFormalVarAddr(StIdx stidx) { + auto it = info->stidx2Parm.find(stidx.FullIdx()); + if (it == info->stidx2Parm.end()) { + return nullptr; + } + if (it->second->ptyp == PTY_agg) { + MASSERT(caller->aggrArgsBuf, "aggrArgsBuf not init"); + return caller->aggrArgsBuf + it->second->storeIdx; + } + return((uint8*)&formalVars[it->second->storeIdx].x); +} + +bool IsExtFunc(PUIdx puIdx, LmbcMod& module) { + MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx); + if (func->IsExtern() || // ext func with proto + func->GetAttr(FUNCATTR_implicit) || // ext func with no proto + !func->GetBody() || // func with no body + (func->IsWeak() && module.FindExtFunc(puIdx))) { + return true; + } + return false; +} + +// Return size (roundup to 8 byte multiples) of aggregate returned by an iread. +size_t GetIReadAggrSize(BaseNode* expr) { + MASSERT(expr->op == OP_iread && expr->ptyp == PTY_agg, "iread on non PTY_agg type"); + IreadNode *iread = static_cast(expr); + TyIdx ptrTyIdx = iread->GetTyIdx(); + MIRPtrType *ptrType = + static_cast(GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrTyIdx)); + MIRType *aggType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrType->GetPointedTyIdx()); + FieldID fd = iread->GetFieldID(); + size_t sz = aggType->GetSize(); + if (fd != 0) { + MIRStructType *structType = static_cast(aggType); + MIRType *fdType = structType->GetFieldType(fd); + uint32 fdOffset = structType->GetBitOffsetFromBaseAddr(fd); + sz = fdType->GetSize(); + (void)fdOffset; + } + return ((sz + 7) >> 3) << 3; +} + +// Get total buffer size needed for all arguments of type PTY_agg in a call. +// This includes all type PTY_agg formal args and va-args (if any). +size_t GetAggCallArgsSize(LmbcFunc *callee, CallNode *call) { + size_t totalAggCallArgsSize = callee->formalsAggSize; + if (callee->isVarArgs) { + for (int i = callee->formalsNum; i < call->NumOpnds(); i++) { // PTY_agg va-args + if (call->Opnd(i)->ptyp == PTY_agg) { + MASSERT(call->Opnd(i)->op == OP_iread, "agg var arg unexpected op"); + totalAggCallArgsSize += GetIReadAggrSize(call->Opnd(i)); + } + } + } + return totalAggCallArgsSize; +} + +// Caller passes arguments to callees using MValues which is a union of Maple +// prim types. For PTY_agg, MValue holds ptr to the aggregate data. +// +// Memory allocation scenarios for call arguments: +// 1. Non-varidiac callee: +// - Caller alloca array of MValue to pass call operands to callee +// - If any call arg is PTY_agg +// - Caller alloca agg buffer to hold data for all args of type PTY_agg +// - MValues for all args of type PTY_agg points to offsets in agg buffer +// 2. Varidiac callee: +// - Caller alloca array of MValue to pass call operands including va-arg ones to callee +// - If any call arg is PTY_agg +// - Caller alloca agg buffer to hold data for all args (formals+va_args) of type PTY_agg +// - MValues of all args of type PTY_agg points to offsets in agg buffer +// - Caller alloca arg stack per AARCH64 ABI for va-args and copy va-args to this arg stack +void MFunction::CallMapleFuncDirect(CallNode *call) { + LmbcFunc *callee = info->lmbcMod->LkupLmbcFunc(call->GetPUIdx()); + if (!callee->formalsNum) { // ignore args if callee takes no params + InvokeFunc(callee, this); + return; + } + // alloca stack space for aggr args before evaluating operands + size_t totalAggCallArgsSize = GetAggCallArgsSize(callee, call); + aggrArgsBuf = static_cast(alloca(totalAggCallArgsSize)); // stack alloc for aggr args + for (int i = 0, sz = 0, offset = callee->formalsAggSize; i < call->NumOpnds(); i++) { + // a non-aggregate arg + if (call->Opnd(i)->ptyp != PTY_agg) { + callArgs[i] = EvalExpr(*this, call->Opnd(i)); + continue; + } + // an aggregate formal arg + if (i < callee->formalsNum) { + callArgs[i] = EvalExpr(*this, call->Opnd(i), callee->pos2Parm[i]); + continue; + } + // an aggregate var-arg + sz = GetIReadAggrSize(call->Opnd(i)); + ParmInf parmInf(PTY_agg, sz, false, offset); + offset += sz; + callArgs[i] = EvalExpr(*this, call->Opnd(i), &parmInf); + } + if (callee->isVarArgs) { + CallVaArgFunc(call->NumOpnds(), callee); + } else { + InvokeFunc(callee, this); + } +} + +void MFunction::CallMapleFuncIndirect(IcallNode *icall, LmbcFunc *callInfo) { + if (!callInfo->formalsNum) { // ignore caller args if callee has no formals + InvokeFunc(callInfo, this); + return; + } + + // Set up call args - skip over 1st arg, which is addr of func to call + aggrArgsBuf = static_cast(alloca(callInfo->formalsAggSize)); // stack alloc for aggr args + for (int i=0; i < icall->NumOpnds()-1; i++) { + callArgs[i] = (icall->Opnd(i+1)->ptyp == PTY_agg) ? + EvalExpr(*this, icall->Opnd(i+1), callInfo->pos2Parm[i]) : + EvalExpr(*this, icall->Opnd(i+1)); + } + if (callInfo->isVarArgs) { + CallVaArgFunc(icall->NumOpnds()-1, callInfo); + } else { + InvokeFunc(callInfo, this); + } +} + +// Maple front end generates Maple IR in varidiac functions to +// use target ABI va_list to access va-args. For the caller, this +// function sets up va-args in a stack buffer which is passed to +// the variadic callee in va_list fields (stack field in aarch64 +// valist, or overflow_arg_area field in x86_64 valist): +// - Calc size of stack to emulate va-args stack in ABI +// - Alloca va-args stack and copy args to the stack +// - For vaArg up to 16 bytes, copy data directly to vaArg stack +// - For vaArg larger than 16 bytes, put pointer to data in vaArg stack +// - On a va_start intrinsic, the va-args stack addr in caller.vaArgs +// is saved in corresponding vaList field for va-arg access by callee. +void MFunction::CallVaArgFunc(int numArgs, LmbcFunc *callInfo) { + uint32 vArgsSz = 0; + for (int i = callInfo->formalsNum; i < numArgs; ++i) { + if (callArgs[i].ptyp != PTY_agg || callArgs[i].aggSize > 16 ) { + vArgsSz += 8; + } else { + vArgsSz += callArgs[i].aggSize; + } + } + vaArgsSize = vArgsSz; + vaArgs = static_cast(alloca(vaArgsSize)); + for (int i = callInfo->formalsNum, offset = 0; i < numArgs; ++i) { + mstore(vaArgs + offset, callArgs[i].ptyp, callArgs[i], true); + if (callArgs[i].ptyp != PTY_agg || callArgs[i].aggSize > 16 ) { + offset += 8; + } else { + offset += callArgs[i].aggSize; + } + } + InvokeFunc(callInfo, this); +} + +void MFunction::CallExtFuncDirect(CallNode* call) { + MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(call->GetPUIdx()); + MapleVector &formalDefVec = func->GetFormalDefVec(); + FuncAddr& faddr = *info->lmbcMod->GetFuncAddr(call->GetPUIdx()); + ffi_fp_t fp = (ffi_fp_t)(faddr.funcPtr.nativeFunc); + MASSERT(fp, "External function not found"); + + for (int i = formalDefVec.size(); i < call->NumOpnds(); i++) { + if (call->Opnd(i)->ptyp == PTY_agg) { + // TODO: Handle type PTY_agg va-args for external calls + MASSERT(false, "extern func: va-arg of agg type NYI"); + } + } + // alloca stack space for aggr args before evaluating operands + aggrArgsBuf = static_cast(alloca(faddr.formalsAggSize)); + for (int i = 0, offset = 0; i < call->NumOpnds(); i++) { + // a non-aggregate arg + if (call->Opnd(i)->ptyp != PTY_agg) { + callArgs[i] = EvalExpr(*this, call->Opnd(i)); + continue; + } + // an aggregate formal arg + if (i < formalDefVec.size()) { + MIRType* ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(formalDefVec[i].formalTyIdx); + MASSERT(ty->GetPrimType() == PTY_agg, "expects formal arg of agg type"); + ParmInf parmInf(PTY_agg, ty->GetSize(), false, offset); + offset += ty->GetSize(); + callArgs[i] = EvalExpr(*this, call->Opnd(i), &parmInf); + continue; + } + // TODO: Handle aggregate var-arg here. See CallMapleFuncDirect + } + CallWithFFI(func->GetReturnType()->GetPrimType(), fp); +} + +void MFunction::CallExtFuncIndirect(IcallNode *icallproto, void* fp) { + // TODO: handle aggregate args for ext funcs + for (int i=0; i < icallproto->NumOpnds()-1; i++) { + callArgs[i]= EvalExpr(*this, icallproto->Opnd(i+1)); + } + MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(icallproto->GetRetTyIdx()); + MIRFuncType *fProto = static_cast(type); + MIRType *fRetType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fProto->GetRetTyIdx()); + CallWithFFI(fRetType->GetPrimType(), (ffi_fp_t)fp); +} + +void MFunction::CallIntrinsic(IntrinsiccallNode &intrn) { + MIRIntrinsicID callId = intrn.GetIntrinsic(); + switch(callId) { + case INTRN_C_va_start: { + MValue addrofAP = EvalExpr(*this, intrn.Opnd(0)); + // setup VaList for Aarch64 + VaList *vaList = (maple::VaList*)addrofAP.x.a64; + vaList->gr_offs = 0; // indicate args are on vaList stack + vaList->stack = caller->vaArgs; + break; + } + default: + MASSERT(false, "CallIntrinsic %d\n NYI", callId); + break; + } +} + +// Maple PrimType to libffi type conversion table +static ffi_type ffi_type_table[] = { + ffi_type_void, // kPtyInvalid +#define EXPANDFFI1(x) x, +#define EXPANDFFI2(x) EXPANDFFI1(x) +#define PRIMTYPE(P) EXPANDFFI2(FFITYPE_##P) +#define LOAD_ALGO_PRIMARY_TYPE +#include "prim_types.def" +#undef PRIMTYPE + ffi_type_void // kPtyDerived + }; + +// FFI type def for Arm64 VaList struct fields +ffi_type *vaListObjAarch64 [] = { + ffi_type_table + PTY_ptr, + ffi_type_table + PTY_ptr, + ffi_type_table + PTY_ptr, + ffi_type_table + PTY_i32, + ffi_type_table + PTY_i32, + nullptr +}; + +// FFI type def for X86_64 VaList struct fields +ffi_type *vaListObjX86_64 [] = { + ffi_type_table + PTY_u32, + ffi_type_table + PTY_u32, + ffi_type_table + PTY_ptr, + ffi_type_table + PTY_ptr, + nullptr +}; + +// currently only support ARM64 va_list +ffi_type vaList_ffi_type = { 0, 0, FFI_TYPE_STRUCT, vaListObjAarch64 }; + +// Setup array of call args and their types then call libffi interface +// to invoked external function. Note that for varidiac external funcs, +// PTY_agg type is used to detect a pass by value va_list arg, and used +// to setup its type for ffi call - this works for now because pass by +// value struct args (except va_list) is not supported yet when calling +// external varidiac functions - a different way to detect pass by value +// va_list arg will be needed when pass by value struct for external +// varidiac funcs is supported. +void MFunction::CallWithFFI(PrimType ret_ptyp, ffi_fp_t fp) { + ffi_cif cif; + ffi_type ffi_ret_type = ffi_type_table[ret_ptyp]; + ffi_type* arg_types[numCallArgs]; + void* args[numCallArgs]; + + // gather args and arg types + for (int i=0; i < numCallArgs; ++i) { + args[i] = &callArgs[i].x; + if (callArgs[i].ptyp == PTY_agg) { + arg_types[i] = &vaList_ffi_type; + } else { + arg_types[i] = ffi_type_table + callArgs[i].ptyp; + } + } + + ffi_status status = ffi_prep_cif(&cif, FFI_DEFAULT_ABI, numCallArgs, &ffi_ret_type, arg_types); + if(status == FFI_OK) { + ffi_call(&cif, fp, &retVal0.x, args); + retVal0.ptyp = ret_ptyp; + } else { + MIR_FATAL("Failed to call method at %p", (void *)fp); + } +} + +} // namespace maple diff --git a/src/MapleEng/lmbc/src/mplsh.cpp b/src/MapleEng/lmbc/src/mplsh.cpp new file mode 100644 index 0000000000..62fccac37b --- /dev/null +++ b/src/MapleEng/lmbc/src/mplsh.cpp @@ -0,0 +1,129 @@ +/* + * Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved. + * + * OpenArkCompiler is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +#include +#include "massert.h" +#include "lmbc_eng.h" +#include "eng_shim.h" + +namespace maple { + +void *LmbcMod::FindExtFunc(PUIdx puidx) { + void* fp = extFuncMap[puidx]; + if (fp) { + return fp; + } + std::string fname = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puidx)->GetName(); + for (auto it : libHandles) { + fp = dlsym(it, fname.c_str()); + if (fp) { + break; + } + } + MASSERT(fp, "dlsym symbol not found: %s", fname.c_str()); + extFuncMap[puidx] = fp; + return(fp); +} + +void *LmbcMod::FindExtSym(StIdx stidx) { + void* var = extSymMap[stidx.FullIdx()]; + if (var) { + return var; + } + MIRSymbol* sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(stidx.Idx()); + if (sym) { + for (auto it : libHandles) { + var = dlsym(it, sym->GetName().c_str()); + if (var) { + break; + } + } + MASSERT(var, "dlsym ExtSym not found: %s", sym->GetName().c_str()); + extSymMap[stidx.FullIdx()] = var; + } + MASSERT(sym, "Unable to find symbol"); + return(var); +} + +maple::MIRModule* +LmbcMod::Import(std::string path) { + maple::MIRModule* mod = new maple::MIRModule(path.c_str()); + mod->SetSrcLang(kSrcLangC); + std::string::size_type lastdot = mod->GetFileName().find_last_of("."); + bool islmbc = lastdot != std::string::npos && mod->GetFileName().compare(lastdot, 5, ".lmbc\0") == 0; + if (!islmbc) { + ERR(kLncErr, "Input must be .lmbc file: %s", path.c_str()); + delete mod; + return nullptr; + } + + BinaryMplImport binMplt(*mod); + binMplt.SetImported(false); + std::string modid = mod->GetFileName(); + if (!binMplt.Import(modid, true)) { + ERR(kLncErr, "mplsh-lmbc: cannot open .lmbc file: %s", modid.c_str()); + delete mod; + return nullptr; + } + return mod; +} + +// C runtime libs to preload +// - add to list as needed or change to read list dynamically at runtime +std::vector preLoadLibs = { + LIBC_SO, + LIBM_SO +}; + +void LmbcMod::LoadDefLibs() { + for (auto it : preLoadLibs) { + void *handle = dlopen(it.c_str(), RTLD_NOW | RTLD_GLOBAL | RTLD_NODELETE); + MASSERT(handle, "dlopen %s failed", it.c_str()); + libHandles.push_back(handle); + } +} + +LmbcMod::LmbcMod(char* path) : lmbcPath(path) { + LoadDefLibs(); + mirMod = Import(path); + // In Lmbc GlobalMemSize is the mem segment size for un-init + // PU static variables, and is referenced through %%GP register. + unInitPUStaticsSize = mirMod->GetGlobalMemSize(); +} + +int +RunLmbc(int argc, char** argv) { + int rc = 1; + const int skipArgsNum = 1; + LmbcMod* mod = new LmbcMod(argv[skipArgsNum]); + ASSERT(mod, "Create Lmbc module failed"); + ASSERT(mod->mirMod, "Import Lmbc module failed"); + mod->InitModule(); + if (mod->mainFn) { + rc = __engineShim(mod->mainFn, argc-skipArgsNum, argv+skipArgsNum); + } + return rc; +} + +} // namespace maple + +int +main(int argc, char **argv) { + if (argc == 1) { + std::string path(argv[0]); + (void)MIR_PRINTF("usage: %s .lmbc\n", path.substr(path.find_last_of("/\\") + 1).c_str()); + exit(1); + } + return maple::RunLmbc(argc, argv); +} diff --git a/src/MapleEng/tags b/src/MapleEng/tags new file mode 100644 index 0000000000..c15d1cbf76 --- /dev/null +++ b/src/MapleEng/tags @@ -0,0 +1,315 @@ +!_TAG_FILE_FORMAT 2 /extended format; --format=1 will not append ;" to lines/ +!_TAG_FILE_SORTED 1 /0=unsorted, 1=sorted, 2=foldcase/ +!_TAG_PROGRAM_AUTHOR Darren Hiebert /dhiebert@users.sourceforge.net/ +!_TAG_PROGRAM_NAME Exuberant Ctags // +!_TAG_PROGRAM_URL http://ctags.sourceforge.net /official site/ +!_TAG_PROGRAM_VERSION 5.9~svn20110310 // +ALLOCA_MEMMAX lmbc/include/mfunction.h 30;" d +AddGlobalVar lmbc/src/init.cpp /^inline void LmbcMod::AddGlobalVar(MIRSymbol &sym, VarInf *pInf) {$/;" f class:maple::LmbcMod +AddPUStaticVar lmbc/src/init.cpp /^inline void LmbcMod::AddPUStaticVar(PUIdx puIdx, MIRSymbol &sym, VarInf *pInf) {$/;" f class:maple::LmbcMod +AlignOffset lmbc/src/init.cpp /^inline void AlignOffset(uint32 &offset, uint32 align) {$/;" f namespace:maple +Alloca lmbc/src/mfunction.cpp /^uint8 *MFunction::Alloca(uint32 sz) {$/;" f class:maple::MFunction +CASE_TOPTYP lmbc/src/invoke_method.cpp 122;" d file: +CalcGlobalAndStaticVarSize lmbc/src/init.cpp /^void LmbcMod::CalcGlobalAndStaticVarSize() {$/;" f class:maple::LmbcMod +CallExtFuncDirect lmbc/src/mfunction.cpp /^void MFunction::CallExtFuncDirect(CallNode* call) {$/;" f class:maple::MFunction +CallExtFuncIndirect lmbc/src/mfunction.cpp /^void MFunction::CallExtFuncIndirect(IcallNode *icallproto, void* fp) {$/;" f class:maple::MFunction +CallIntrinsic lmbc/src/mfunction.cpp /^void MFunction::CallIntrinsic(IntrinsiccallNode &intrn) {$/;" f class:maple::MFunction +CallMapleFuncDirect lmbc/src/mfunction.cpp /^void MFunction::CallMapleFuncDirect(CallNode *call) {$/;" f class:maple::MFunction +CallMapleFuncIndirect lmbc/src/mfunction.cpp /^void MFunction::CallMapleFuncIndirect(IcallNode *icall, LmbcFunc *callInfo) {$/;" f class:maple::MFunction +CallVaArgFunc lmbc/src/mfunction.cpp /^void MFunction::CallVaArgFunc(int numArgs, LmbcFunc *callInfo) {$/;" f class:maple::MFunction +CallWithFFI lmbc/src/mfunction.cpp /^void MFunction::CallWithFFI(PrimType ret_ptyp, ffi_fp_t fp) {$/;" f class:maple::MFunction +CheckFlexArrayMember lmbc/src/init.cpp /^uint32 CheckFlexArrayMember(MIRSymbol &sym, MIRType &ty) {$/;" f namespace:maple +CheckUnamedBitField lmbc/src/init.cpp /^void LmbcMod::CheckUnamedBitField(MIRStructType &stType, uint32 &prevInitFd, uint32 curFd, int32 &allocdBits) {$/;" f class:maple::LmbcMod +CompareDouble lmbc/src/invoke_method.cpp /^inline bool CompareDouble(double x, double y, double epsilon = 0.0000000000000001f) {$/;" f namespace:maple +CompareFloat lmbc/src/invoke_method.cpp /^inline bool CompareFloat(float x, float y, float epsilon = 0.00000001f) {$/;" f namespace:maple +CvtType lmbc/src/invoke_method.cpp /^MValue CvtType(MValue &opnd, PrimType toPtyp, PrimType fromPtyp) {$/;" f namespace:maple +EXPANDFFI1 lmbc/src/mfunction.cpp 278;" d file: +EXPANDFFI2 lmbc/src/mfunction.cpp 279;" d file: +EXPRBININTOP lmbc/include/mexpression.h 103;" d +EXPRBININTOPUNSIGNED lmbc/include/mexpression.h 122;" d +EXPRBINOP lmbc/include/mexpression.h 21;" d +EXPRCOMPOP lmbc/include/mexpression.h 40;" d +EXPRCOMPOPNOFLOAT lmbc/include/mexpression.h 63;" d +EXPRMAXMINOP lmbc/include/mexpression.h 165;" d +EXPRREMOP lmbc/include/mexpression.h 186;" d +EXPRSELECTOP lmbc/include/mexpression.h 81;" d +EXPRUNROP lmbc/include/mexpression.h 214;" d +EvalExpr lmbc/src/invoke_method.cpp /^MValue EvalExpr(MFunction& func, BaseNode* expr, ParmInf *parm) {$/;" f namespace:maple +FFITYPE_Derived lmbc/include/mprimtype.h 112;" d +FFITYPE_Invalid lmbc/include/mprimtype.h 70;" d +FFITYPE_a32 lmbc/include/mprimtype.h 83;" d +FFITYPE_a64 lmbc/include/mprimtype.h 84;" d +FFITYPE_agg lmbc/include/mprimtype.h 104;" d +FFITYPE_c128 lmbc/include/mprimtype.h 89;" d +FFITYPE_c64 lmbc/include/mprimtype.h 88;" d +FFITYPE_constStr lmbc/include/mprimtype.h 102;" d +FFITYPE_dynany lmbc/include/mprimtype.h 92;" d +FFITYPE_dynbool lmbc/include/mprimtype.h 95;" d +FFITYPE_dynf32 lmbc/include/mprimtype.h 100;" d +FFITYPE_dynf64 lmbc/include/mprimtype.h 99;" d +FFITYPE_dyni32 lmbc/include/mprimtype.h 96;" d +FFITYPE_dynnone lmbc/include/mprimtype.h 101;" d +FFITYPE_dynnull lmbc/include/mprimtype.h 94;" d +FFITYPE_dynobj lmbc/include/mprimtype.h 98;" d +FFITYPE_dynstr lmbc/include/mprimtype.h 97;" d +FFITYPE_dynundef lmbc/include/mprimtype.h 93;" d +FFITYPE_f128 lmbc/include/mprimtype.h 87;" d +FFITYPE_f32 lmbc/include/mprimtype.h 85;" d +FFITYPE_f64 lmbc/include/mprimtype.h 86;" d +FFITYPE_gen lmbc/include/mprimtype.h 103;" d +FFITYPE_i128 lmbc/include/mprimtype.h 113;" d +FFITYPE_i16 lmbc/include/mprimtype.h 73;" d +FFITYPE_i32 lmbc/include/mprimtype.h 74;" d +FFITYPE_i64 lmbc/include/mprimtype.h 75;" d +FFITYPE_i8 lmbc/include/mprimtype.h 72;" d +FFITYPE_ptr lmbc/include/mprimtype.h 81;" d +FFITYPE_ref lmbc/include/mprimtype.h 82;" d +FFITYPE_reservedpty1 lmbc/include/mprimtype.h 126;" d +FFITYPE_reservedpty10 lmbc/include/mprimtype.h 135;" d +FFITYPE_reservedpty2 lmbc/include/mprimtype.h 127;" d +FFITYPE_reservedpty3 lmbc/include/mprimtype.h 128;" d +FFITYPE_reservedpty4 lmbc/include/mprimtype.h 129;" d +FFITYPE_reservedpty5 lmbc/include/mprimtype.h 130;" d +FFITYPE_reservedpty6 lmbc/include/mprimtype.h 131;" d +FFITYPE_reservedpty7 lmbc/include/mprimtype.h 132;" d +FFITYPE_reservedpty8 lmbc/include/mprimtype.h 133;" d +FFITYPE_reservedpty9 lmbc/include/mprimtype.h 134;" d +FFITYPE_simpleobj lmbc/include/mprimtype.h 91;" d +FFITYPE_simplestr lmbc/include/mprimtype.h 90;" d +FFITYPE_u1 lmbc/include/mprimtype.h 80;" d +FFITYPE_u128 lmbc/include/mprimtype.h 114;" d +FFITYPE_u16 lmbc/include/mprimtype.h 77;" d +FFITYPE_u32 lmbc/include/mprimtype.h 78;" d +FFITYPE_u64 lmbc/include/mprimtype.h 79;" d +FFITYPE_u8 lmbc/include/mprimtype.h 76;" d +FFITYPE_unknown lmbc/include/mprimtype.h 111;" d +FFITYPE_v16i8 lmbc/include/mprimtype.h 108;" d +FFITYPE_v16u8 lmbc/include/mprimtype.h 118;" d +FFITYPE_v2f32 lmbc/include/mprimtype.h 125;" d +FFITYPE_v2f64 lmbc/include/mprimtype.h 109;" d +FFITYPE_v2i32 lmbc/include/mprimtype.h 119;" d +FFITYPE_v2i64 lmbc/include/mprimtype.h 105;" d +FFITYPE_v2u32 lmbc/include/mprimtype.h 122;" d +FFITYPE_v2u64 lmbc/include/mprimtype.h 115;" d +FFITYPE_v4f32 lmbc/include/mprimtype.h 110;" d +FFITYPE_v4i16 lmbc/include/mprimtype.h 120;" d +FFITYPE_v4i32 lmbc/include/mprimtype.h 106;" d +FFITYPE_v4u16 lmbc/include/mprimtype.h 123;" d +FFITYPE_v4u32 lmbc/include/mprimtype.h 116;" d +FFITYPE_v8i16 lmbc/include/mprimtype.h 107;" d +FFITYPE_v8i8 lmbc/include/mprimtype.h 121;" d +FFITYPE_v8u16 lmbc/include/mprimtype.h 117;" d +FFITYPE_v8u8 lmbc/include/mprimtype.h 124;" d +FFITYPE_void lmbc/include/mprimtype.h 71;" d +FindExtFunc lmbc/src/mplsh.cpp /^void *LmbcMod::FindExtFunc(PUIdx puidx) {$/;" f class:maple::LmbcMod +FindExtSym lmbc/src/mplsh.cpp /^void *LmbcMod::FindExtSym(StIdx stidx) {$/;" f class:maple::LmbcMod +FuncAddr lmbc/include/lmbc_eng.h /^class FuncAddr {$/;" c namespace:maple +FuncAddr lmbc/src/init.cpp /^FuncAddr::FuncAddr(bool lmbcFunc, void *func, std::string name, uint32 formalsAggSz) {$/;" f class:maple::FuncAddr +GetAggCallArgsSize lmbc/src/mfunction.cpp /^size_t GetAggCallArgsSize(LmbcFunc *callee, CallNode *call) {$/;" f namespace:maple +GetAggFormalsSize lmbc/src/init.cpp /^uint32 GetAggFormalsSize(MIRFunction *func) {$/;" f namespace:maple +GetFormalVarAddr lmbc/src/mfunction.cpp /^uint8 *MFunction::GetFormalVarAddr(StIdx stidx) {$/;" f class:maple::MFunction +GetFuncAddr lmbc/src/init.cpp /^FuncAddr* LmbcMod::GetFuncAddr(PUIdx idx) {$/;" f class:maple::LmbcMod +GetGlobalVarInitAddr lmbc/src/init.cpp /^uint8 *LmbcMod::GetGlobalVarInitAddr(VarInf* pInf, uint32 align) {$/;" f class:maple::LmbcMod +GetIReadAggrSize lmbc/src/mfunction.cpp /^size_t GetIReadAggrSize(BaseNode* expr) {$/;" f namespace:maple +GetVarAddr lmbc/src/init.cpp /^uint8 *LmbcMod::GetVarAddr(PUIdx puIdx, StIdx stIdx) {$/;" f class:maple::LmbcMod +GetVarAddr lmbc/src/init.cpp /^uint8 *LmbcMod::GetVarAddr(StIdx stIdx) {$/;" f class:maple::LmbcMod +HandleFloatEq lmbc/src/invoke_method.cpp /^void HandleFloatEq(Opcode op, PrimType opndType, MValue &res, MValue &op1, MValue &op2) {$/;" f namespace:maple +Import lmbc/src/mplsh.cpp /^LmbcMod::Import(std::string path) {$/;" f class:maple::LmbcMod +InitAddrofConst lmbc/src/init.cpp /^void LmbcMod::InitAddrofConst(VarInf *pInf, MIRAddrofConst &addrofConst, uint8* dst) {$/;" f class:maple::LmbcMod +InitAggConst lmbc/src/init.cpp /^void LmbcMod::InitAggConst(VarInf *pInf, MIRConst &mirConst) {$/;" f class:maple::LmbcMod +InitArrayConst lmbc/src/init.cpp /^void LmbcMod::InitArrayConst(VarInf *pInf, MIRConst &mirConst) {$/;" f class:maple::LmbcMod +InitBitFieldConst lmbc/src/init.cpp /^void LmbcMod::InitBitFieldConst(VarInf *pInf, MIRConst &elemConst, int32 &allocdBits, bool &forceAlign) {$/;" f class:maple::LmbcMod +InitDoubleConst lmbc/src/init.cpp /^inline void LmbcMod::InitDoubleConst(VarInf *pInf, MIRDoubleConst &f64Const, uint8* dst) {$/;" f class:maple::LmbcMod +InitFloatConst lmbc/src/init.cpp /^inline void LmbcMod::InitFloatConst(VarInf *pInf, MIRFloatConst &f32Const, uint8* dst) {$/;" f class:maple::LmbcMod +InitGlobalVariable lmbc/src/init.cpp /^void LmbcMod::InitGlobalVariable(VarInf *pInf) {$/;" f class:maple::LmbcMod +InitGlobalVars lmbc/src/init.cpp /^void LmbcMod::InitGlobalVars(void) {$/;" f class:maple::LmbcMod +InitIntConst lmbc/src/init.cpp /^void LmbcMod::InitIntConst(VarInf* pInf, MIRIntConst &intConst, uint8* dst) {$/;" f class:maple::LmbcMod +InitLblConst lmbc/src/init.cpp /^void LmbcMod::InitLblConst(VarInf *pInf, MIRLblConst &labelConst, uint8 *dst) {$/;" f class:maple::LmbcMod +InitModule lmbc/src/init.cpp /^void LmbcMod::InitModule(void) {$/;" f class:maple::LmbcMod +InitPointerConst lmbc/src/init.cpp /^void LmbcMod::InitPointerConst(VarInf *pInf, MIRConst &mirConst) {$/;" f class:maple::LmbcMod +InitScalarConst lmbc/src/init.cpp /^void LmbcMod::InitScalarConst(VarInf *pInf, MIRConst &mirConst) {$/;" f class:maple::LmbcMod +InitStrConst lmbc/src/init.cpp /^void LmbcMod::InitStrConst(VarInf* pInf, MIRStrConst &mirStrConst, uint8* dst) {$/;" f class:maple::LmbcMod +InvokeFunc lmbc/src/invoke_method.cpp /^MValue InvokeFunc(LmbcFunc* fn, MFunction *caller) {$/;" f namespace:maple +IsExtFunc lmbc/src/mfunction.cpp /^bool IsExtFunc(PUIdx puIdx, LmbcMod& module) {$/;" f namespace:maple +IsZero lmbc/src/invoke_method.cpp /^bool IsZero(MValue& cond) {$/;" f namespace:maple +LOAD_ALGO_PRIMARY_TYPE lmbc/src/mfunction.cpp 281;" d file: +LkupLmbcFunc lmbc/src/init.cpp /^LmbcMod::LkupLmbcFunc(PUIdx puIdx) {$/;" f class:maple::LmbcMod +LmbcFunc lmbc/include/lmbc_eng.h /^class LmbcFunc {$/;" c namespace:maple +LmbcFunc lmbc/src/init.cpp /^LmbcFunc::LmbcFunc(LmbcMod *mod, MIRFunction *func) : lmbcMod(mod), mirFunc(func) {$/;" f class:maple::LmbcFunc +LmbcMod lmbc/include/lmbc_eng.h /^class LmbcMod {$/;" c namespace:maple +LmbcMod lmbc/src/mplsh.cpp /^LmbcMod::LmbcMod(char* path) : lmbcPath(path) {$/;" f class:maple::LmbcMod +LoadArgs lmbc/src/invoke_method.cpp /^void LoadArgs(MFunction& func) {$/;" f namespace:maple +LoadDefLibs lmbc/src/mplsh.cpp /^void LmbcMod::LoadDefLibs() {$/;" f class:maple::LmbcMod +MASSERT lmbc/include/massert.h 21;" d +MFunction lmbc/include/mfunction.h /^class MFunction {$/;" c namespace:maple +MFunction lmbc/src/mfunction.cpp /^MFunction::MFunction(LmbcFunc *funcInfo,$/;" f class:maple::MFunction +MPLENG_LMBC_H_ lmbc/include/lmbc_eng.h 16;" d +MPLENG_MASSERT_H_ lmbc/include/massert.h 16;" d +MPLENG_MEXPRESSION_H_ lmbc/include/mexpression.h 16;" d +MPLENG_MFUNCTION_H_ lmbc/include/mfunction.h 16;" d +MPLENG_MPRIMTYPE_H_ lmbc/include/mprimtype.h 16;" d +MPLENG_MVALUE_H_ lmbc/include/mvalue.h 16;" d +MPLENG_SHIM_H_ lmbc/include/eng_shim.h 16;" d +MVal2Int64 lmbc/src/invoke_method.cpp /^int64 MVal2Int64(MValue &val) {$/;" f namespace:maple +MValue lmbc/include/mvalue.h /^ struct MValue {$/;" s namespace:maple +OPCODE lmbc/src/invoke_method.cpp 245;" d file: +OPCODE lmbc/src/invoke_method.cpp 247;" d file: +OPCODE lmbc/src/invoke_method.cpp 626;" d file: +OPCODE lmbc/src/invoke_method.cpp 628;" d file: +PRIMTYPE lmbc/src/mfunction.cpp 280;" d file: +PRIMTYPE lmbc/src/mfunction.cpp 283;" d file: +PTYSIZE_Derived lmbc/include/mprimtype.h 67;" d +PTYSIZE_Invalid lmbc/include/mprimtype.h 25;" d +PTYSIZE_a32 lmbc/include/mprimtype.h 38;" d +PTYSIZE_a64 lmbc/include/mprimtype.h 39;" d +PTYSIZE_agg lmbc/include/mprimtype.h 59;" d +PTYSIZE_c128 lmbc/include/mprimtype.h 44;" d +PTYSIZE_c64 lmbc/include/mprimtype.h 43;" d +PTYSIZE_constStr lmbc/include/mprimtype.h 57;" d +PTYSIZE_dynany lmbc/include/mprimtype.h 47;" d +PTYSIZE_dynbool lmbc/include/mprimtype.h 50;" d +PTYSIZE_dynf32 lmbc/include/mprimtype.h 55;" d +PTYSIZE_dynf64 lmbc/include/mprimtype.h 54;" d +PTYSIZE_dyni32 lmbc/include/mprimtype.h 51;" d +PTYSIZE_dynnone lmbc/include/mprimtype.h 56;" d +PTYSIZE_dynnull lmbc/include/mprimtype.h 49;" d +PTYSIZE_dynobj lmbc/include/mprimtype.h 53;" d +PTYSIZE_dynstr lmbc/include/mprimtype.h 52;" d +PTYSIZE_dynundef lmbc/include/mprimtype.h 48;" d +PTYSIZE_f128 lmbc/include/mprimtype.h 42;" d +PTYSIZE_f32 lmbc/include/mprimtype.h 40;" d +PTYSIZE_f64 lmbc/include/mprimtype.h 41;" d +PTYSIZE_gen lmbc/include/mprimtype.h 58;" d +PTYSIZE_i16 lmbc/include/mprimtype.h 28;" d +PTYSIZE_i32 lmbc/include/mprimtype.h 29;" d +PTYSIZE_i64 lmbc/include/mprimtype.h 30;" d +PTYSIZE_i8 lmbc/include/mprimtype.h 27;" d +PTYSIZE_ptr lmbc/include/mprimtype.h 36;" d +PTYSIZE_ref lmbc/include/mprimtype.h 37;" d +PTYSIZE_simpleobj lmbc/include/mprimtype.h 46;" d +PTYSIZE_simplestr lmbc/include/mprimtype.h 45;" d +PTYSIZE_u1 lmbc/include/mprimtype.h 35;" d +PTYSIZE_u16 lmbc/include/mprimtype.h 32;" d +PTYSIZE_u32 lmbc/include/mprimtype.h 33;" d +PTYSIZE_u64 lmbc/include/mprimtype.h 34;" d +PTYSIZE_u8 lmbc/include/mprimtype.h 31;" d +PTYSIZE_unknown lmbc/include/mprimtype.h 66;" d +PTYSIZE_v16i8 lmbc/include/mprimtype.h 63;" d +PTYSIZE_v2f64 lmbc/include/mprimtype.h 64;" d +PTYSIZE_v2i64 lmbc/include/mprimtype.h 60;" d +PTYSIZE_v4f32 lmbc/include/mprimtype.h 65;" d +PTYSIZE_v4i32 lmbc/include/mprimtype.h 61;" d +PTYSIZE_v8i16 lmbc/include/mprimtype.h 62;" d +PTYSIZE_void lmbc/include/mprimtype.h 26;" d +PUIdx2FuncAddr lmbc/include/lmbc_eng.h /^ std::unordered_map PUIdx2FuncAddr;$/;" m class:maple::LmbcMod +ParmInf lmbc/include/lmbc_eng.h /^ ParmInf(PrimType type, size_t sz, bool ispreg, int32_t storageIdx)$/;" f struct:maple::ParmInf +ParmInf lmbc/include/lmbc_eng.h /^ ParmInf(PrimType type, size_t sz, bool ispreg, int32_t storageIdx, MIRSymbol *psym)$/;" f struct:maple::ParmInf +ParmInf lmbc/include/lmbc_eng.h /^ ParmInf(PrimType type, size_t sz, bool ispreg, int32_t storageIdx, MIRSymbol *psym, PUIdx puidx)$/;" f struct:maple::ParmInf +ParmInf lmbc/include/lmbc_eng.h /^struct ParmInf {$/;" s namespace:maple +ROUNDUP8 lmbc/src/init.cpp 22;" d file: +RegAssignZextOrSext lmbc/src/invoke_method.cpp /^bool RegAssignZextOrSext(MValue& from, PrimType toTyp, MValue& to) {$/;" f namespace:maple +RunLmbc lmbc/src/mplsh.cpp /^RunLmbc(int argc, char** argv) {$/;" f namespace:maple +ScanFormals lmbc/src/init.cpp /^void LmbcFunc::ScanFormals(void) {$/;" f class:maple::LmbcFunc +ScanLabels lmbc/src/init.cpp /^void LmbcFunc::ScanLabels(StmtNode* stmt) {$/;" f class:maple::LmbcFunc +ScanPUStatic lmbc/src/init.cpp /^void LmbcMod::ScanPUStatic(MIRFunction *func) {$/;" f class:maple::LmbcMod +SetBitFieldConst lmbc/src/init.cpp /^void SetBitFieldConst(uint8* baseFdAddr, uint32 baseFdSz, uint32 bitsOffset, uint8 bitsSize, MIRConst &elemConst) {$/;" f namespace:maple +UpdateGlobalVarInitAddr lmbc/src/init.cpp /^inline void LmbcMod::UpdateGlobalVarInitAddr(VarInf* pInf, uint32 size) {$/;" f class:maple::LmbcMod +VARNAMELENGTH lmbc/include/mfunction.h 29;" d +VaListAarch64 lmbc/include/mfunction.h /^} VaListAarch64;$/;" t namespace:maple typeref:struct:maple::__anon2 +VaListX86_64 lmbc/include/mfunction.h /^} VaListX86_64[1];$/;" t namespace:maple typeref:struct:maple::__anon1 +__engineShim lmbc/src/eng_shim.cpp /^__engineShim(LmbcFunc* fn, ...) {$/;" f namespace:maple +a64 lmbc/include/mvalue.h /^ uint8 *a64; \/\/ object ref (use uint8_t* instead of void* for reference)$/;" m union:maple::MValue::__anon4 +aggSize lmbc/include/mvalue.h /^ size_t aggSize; \/\/ for PTY_agg only$/;" m struct:maple::MValue +aggrArgsBuf lmbc/include/mfunction.h /^ uint8* aggrArgsBuf; \/\/ buffer for PTY_agg call formal args, which offsets into it$/;" m class:maple::MFunction +allocaMem lmbc/include/mfunction.h /^ uint8* allocaMem; \/\/ point to reserved stack memory for Maple IR OP_alloca$/;" m class:maple::MFunction +allocaOffset lmbc/include/mfunction.h /^ uint32 allocaOffset; \/\/ next avail offset in allocaMem$/;" m class:maple::MFunction +callArgs lmbc/include/mfunction.h /^ MValue* callArgs; \/\/ array of call args to pass to callee$/;" m class:maple::MFunction +caller lmbc/include/mfunction.h /^ MFunction* caller; \/\/ caller of current func$/;" m class:maple::MFunction +extFuncMap lmbc/include/lmbc_eng.h /^ std::unordered_mapextFuncMap; \/\/ PUIdx to ext func addr map$/;" m class:maple::LmbcMod +extSymMap lmbc/include/lmbc_eng.h /^ std::unordered_mapextSymMap; \/\/ StIdx.FullIdx() to ext sym addr map$/;" m class:maple::LmbcMod +f32 lmbc/include/mvalue.h /^ float f32;$/;" m union:maple::MValue::__anon4 +f64 lmbc/include/mvalue.h /^ double f64;$/;" m union:maple::MValue::__anon4 +ffi_type_table lmbc/src/mfunction.cpp /^static ffi_type ffi_type_table[] = {$/;" m namespace:maple file: +formalVars lmbc/include/mfunction.h /^ MValue* formalVars; \/\/ array of var\/non-preg args passed in$/;" m class:maple::MFunction +formalsAggSize lmbc/include/lmbc_eng.h /^ uint32 formalsAggSize; \/\/ total struct size of all formal args of type agg$/;" m class:maple::LmbcFunc +formalsAggSize lmbc/include/lmbc_eng.h /^ uint32 formalsAggSize; \/\/ native func only$/;" m class:maple::FuncAddr +formalsNum lmbc/include/lmbc_eng.h /^ uint16 formalsNum; \/\/ num formals: vars+pregs$/;" m class:maple::LmbcFunc +formalsNumVars lmbc/include/lmbc_eng.h /^ uint32 formalsNumVars; \/\/ num formals: vars only$/;" m class:maple::LmbcFunc +formalsSize lmbc/include/lmbc_eng.h /^ uint32 formalsSize; \/\/ total size of all formal args$/;" m class:maple::LmbcFunc +fp lmbc/include/mfunction.h /^ uint8* fp; \/\/ point to bottom of frame$/;" m class:maple::MFunction +fp_offset lmbc/include/mfunction.h /^ uint fp_offset;$/;" m struct:maple::__anon1 +frame lmbc/include/mfunction.h /^ uint8* frame; \/\/ stack frame (auto var only)$/;" m class:maple::MFunction +frameSize lmbc/include/lmbc_eng.h /^ uint32 frameSize; \/\/ auto var size in bytes$/;" m class:maple::LmbcFunc +funcMap lmbc/include/lmbc_eng.h /^ FuncMap funcMap;$/;" m class:maple::LmbcMod +funcName lmbc/include/lmbc_eng.h /^ std::string funcName;$/;" m class:maple::FuncAddr +funcPtr lmbc/include/lmbc_eng.h /^ } funcPtr;$/;" m class:maple::FuncAddr typeref:union:maple::FuncAddr::__anon3 +gettid lmbc/include/mfunction.h 23;" d +globalAndStaticVars lmbc/include/lmbc_eng.h /^ std::unordered_map globalAndStaticVars;$/;" m class:maple::LmbcMod +globalStrTbl lmbc/include/lmbc_eng.h /^ std::unordered_map globalStrTbl;$/;" m class:maple::LmbcMod +gp_offset lmbc/include/mfunction.h /^ uint gp_offset;$/;" m struct:maple::__anon1 +gr_offs lmbc/include/mfunction.h /^ int gr_offs;$/;" m struct:maple::__anon2 +gr_top lmbc/include/mfunction.h /^ void *gr_top;$/;" m struct:maple::__anon2 +i16 lmbc/include/mvalue.h /^ int16 i16;$/;" m union:maple::MValue::__anon4 +i32 lmbc/include/mvalue.h /^ int32 i32;$/;" m union:maple::MValue::__anon4 +i64 lmbc/include/mvalue.h /^ int64 i64;$/;" m union:maple::MValue::__anon4 +i8 lmbc/include/mvalue.h /^ int8 i8;$/;" m union:maple::MValue::__anon4 +info lmbc/include/mfunction.h /^ LmbcFunc* info; \/\/ current func$/;" m class:maple::MFunction +isLmbcFunc lmbc/include/lmbc_eng.h /^ bool isLmbcFunc;$/;" m class:maple::FuncAddr +isPreg lmbc/include/lmbc_eng.h /^ bool isPreg;$/;" m struct:maple::ParmInf +isVarArgs lmbc/include/lmbc_eng.h /^ bool isVarArgs;$/;" m class:maple::LmbcFunc +isVararg lmbc/include/lmbc_eng.h /^ bool isVararg;$/;" m struct:maple::ParmInf +labelMap lmbc/include/lmbc_eng.h /^ LabelMap labelMap; \/\/ map labelIdx to Stmt address$/;" m class:maple::LmbcFunc +libHandles lmbc/include/lmbc_eng.h /^ std::vector libHandles;$/;" m class:maple::LmbcMod +lmbcFunc lmbc/include/lmbc_eng.h /^ LmbcFunc *lmbcFunc;$/;" m union:maple::FuncAddr::__anon3 +lmbcMod lmbc/include/lmbc_eng.h /^ LmbcMod *lmbcMod;$/;" m class:maple::LmbcFunc +lmbcPath lmbc/include/lmbc_eng.h /^ std::string lmbcPath;$/;" m class:maple::LmbcMod +main lmbc/src/mplsh.cpp /^main(int argc, char **argv) {$/;" f +maple lmbc/include/eng_shim.h /^namespace maple {$/;" n +maple lmbc/include/lmbc_eng.h /^namespace maple {$/;" n +maple lmbc/include/mfunction.h /^namespace maple {$/;" n +maple lmbc/include/mvalue.h /^namespace maple {$/;" n +maple lmbc/src/eng_shim.cpp /^namespace maple {$/;" n file: +maple lmbc/src/init.cpp /^namespace maple {$/;" n file: +maple lmbc/src/invoke_method.cpp /^namespace maple {$/;" n file: +maple lmbc/src/load_store.cpp /^namespace maple {$/;" n file: +maple lmbc/src/mfunction.cpp /^namespace maple {$/;" n file: +maple lmbc/src/mplsh.cpp /^namespace maple {$/;" n file: +mirFunc lmbc/include/lmbc_eng.h /^ MIRFunction *mirFunc;$/;" m class:maple::LmbcFunc +mload lmbc/src/load_store.cpp /^void mload(uint8* addr, PrimType ptyp, MValue& res, size_t aggSize) {$/;" f namespace:maple +mstore lmbc/src/load_store.cpp /^void mstore(uint8* addr, PrimType ptyp, MValue& val, bool toVarArgStack) {$/;" f namespace:maple +nativeFunc lmbc/include/lmbc_eng.h /^ void *nativeFunc;$/;" m union:maple::FuncAddr::__anon3 +nextStmt lmbc/include/mfunction.h /^ StmtNode* nextStmt; \/\/ next maple IR statement to execute$/;" m class:maple::MFunction +numCallArgs lmbc/include/mfunction.h /^ uint16 numCallArgs; \/\/ number of call args to pass to callee$/;" m class:maple::MFunction +numPregs lmbc/include/lmbc_eng.h /^ size_t numPregs;$/;" m class:maple::LmbcFunc +overflow_arg_area lmbc/include/mfunction.h /^ void *overflow_arg_area;$/;" m struct:maple::__anon1 +pRegs lmbc/include/mfunction.h /^ MValue* pRegs; \/\/ array of pseudo regs used in function$/;" m class:maple::MFunction +pos2Parm lmbc/include/lmbc_eng.h /^ std::vector pos2Parm; \/\/ formals info lkup by pos order$/;" m class:maple::LmbcFunc +preLoadLibs lmbc/src/mplsh.cpp /^std::vector preLoadLibs = {$/;" m namespace:maple file: +ptr lmbc/include/mvalue.h /^ void *ptr;$/;" m union:maple::MValue::__anon4 +ptyp lmbc/include/lmbc_eng.h /^ PrimType ptyp;$/;" m struct:maple::ParmInf +ptyp lmbc/include/mvalue.h /^ PrimType ptyp:8;$/;" m struct:maple::MValue +puIdx lmbc/include/lmbc_eng.h /^ PUIdx puIdx; \/\/ VarInf only - for PUStatic var$/;" m struct:maple::ParmInf +reg_save_area lmbc/include/mfunction.h /^ void *reg_save_area;$/;" m struct:maple::__anon1 +retSize lmbc/include/lmbc_eng.h /^ uint32 retSize;$/;" m class:maple::LmbcFunc +retVal0 lmbc/include/mfunction.h /^ MValue retVal0; \/\/ %retVal0 return from callee$/;" m class:maple::MFunction +retVal1 lmbc/include/mfunction.h /^ MValue retVal1; \/\/ %retval1 return from callee$/;" m class:maple::MFunction +size lmbc/include/lmbc_eng.h /^ size_t size;$/;" m struct:maple::ParmInf +stack lmbc/include/mfunction.h /^ void *stack;$/;" m struct:maple::__anon2 +stidx2Parm lmbc/include/lmbc_eng.h /^ std::unordered_map stidx2Parm; \/\/ formals info lkup by formals stidx$/;" m class:maple::LmbcFunc +storeIdx lmbc/include/lmbc_eng.h /^ int32 storeIdx;$/;" m struct:maple::ParmInf +str lmbc/include/mvalue.h /^ void *str;$/;" m union:maple::MValue::__anon4 +sym lmbc/include/lmbc_eng.h /^ MIRSymbol *sym; \/\/ VarInf only - for global and PUStatic var$/;" m struct:maple::ParmInf +u16 lmbc/include/mvalue.h /^ uint16 u16;$/;" m union:maple::MValue::__anon4 +u32 lmbc/include/mvalue.h /^ uint32 u32;$/;" m union:maple::MValue::__anon4 +u64 lmbc/include/mvalue.h /^ uint64 u64;$/;" m union:maple::MValue::__anon4 +u8 lmbc/include/mvalue.h /^ uint8 u8;$/;" m union:maple::MValue::__anon4 +vaArgs lmbc/include/mfunction.h /^ uint8* vaArgs; \/\/ AARCH64 ABI vararg stack for calling va-arg funcs$/;" m class:maple::MFunction +vaArgsSize lmbc/include/mfunction.h /^ uint32 vaArgsSize;$/;" m class:maple::MFunction +vaListObjAarch64 lmbc/src/mfunction.cpp /^ffi_type *vaListObjAarch64 [] = {$/;" m namespace:maple file: +vaListObjX86_64 lmbc/src/mfunction.cpp /^ffi_type *vaListObjX86_64 [] = {$/;" m namespace:maple file: +vaList_ffi_type lmbc/src/mfunction.cpp /^ffi_type vaList_ffi_type = { 0, 0, FFI_TYPE_STRUCT, vaListObjAarch64 };$/;" m namespace:maple file: +varArgsBuf lmbc/include/mfunction.h /^ uint8* varArgsBuf; \/\/ buffer for PTY_agg call var-args, which offsets into it$/;" m class:maple::MFunction +vr_offs lmbc/include/mfunction.h /^ int vr_offs;$/;" m struct:maple::__anon2 +vr_top lmbc/include/mfunction.h /^ void *vr_top;$/;" m struct:maple::__anon2 +x lmbc/include/mvalue.h /^ } x;$/;" m struct:maple::MValue typeref:union:maple::MValue::__anon4 +~MFunction lmbc/src/mfunction.cpp /^MFunction::~MFunction() { }$/;" f class:maple::MFunction -- Gitee From a28627d6e40835dd3a253b5af7e503fca96049ee Mon Sep 17 00:00:00 2001 From: eching Date: Fri, 11 Nov 2022 12:07:10 -0800 Subject: [PATCH 2/5] Fix copyright header --- src/MapleEng/BUILD.gn | 2 +- src/MapleEng/lmbc/BUILD.gn | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/MapleEng/BUILD.gn b/src/MapleEng/BUILD.gn index aca0f4de0b..9ec5543293 100644 --- a/src/MapleEng/BUILD.gn +++ b/src/MapleEng/BUILD.gn @@ -1,5 +1,5 @@ # -# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. +# Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved. # # OpenArkCompiler is licensed under Mulan PSL v2. # You can use this software according to the terms and conditions of the Mulan PSL v2. diff --git a/src/MapleEng/lmbc/BUILD.gn b/src/MapleEng/lmbc/BUILD.gn index 08ae04b2a4..e23e84064c 100755 --- a/src/MapleEng/lmbc/BUILD.gn +++ b/src/MapleEng/lmbc/BUILD.gn @@ -1,5 +1,5 @@ # -# Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved. +# Copyright (c) [2022] Futurewei Technologies, Inc. All rights reserved. # # OpenArkCompiler is licensed under Mulan PSL v2. # You can use this software according to the terms and conditions of the Mulan PSL v2. -- Gitee From 6a818507e346b57e42debdd3aa484ff80caef14b Mon Sep 17 00:00:00 2001 From: eching Date: Sat, 3 Dec 2022 08:30:26 -0800 Subject: [PATCH 3/5] Resolve code compliance review issues --- src/MapleEng/lmbc/BUILD.gn | 1 + src/MapleEng/lmbc/include/eng_shim.h | 2 +- src/MapleEng/lmbc/include/lmbc_eng.h | 32 +++---- src/MapleEng/lmbc/include/mexpression.h | 71 +++++++------- src/MapleEng/lmbc/include/mfunction.h | 17 +--- src/MapleEng/lmbc/src/eng_shim.cpp | 5 +- src/MapleEng/lmbc/src/init.cpp | 117 +++++++++++------------- src/MapleEng/lmbc/src/invoke_method.cpp | 94 +++++++++---------- src/MapleEng/lmbc/src/load_store.cpp | 14 +-- src/MapleEng/lmbc/src/mfunction.cpp | 114 ++++++++++++----------- src/MapleEng/lmbc/src/mplsh.cpp | 29 +++--- 11 files changed, 233 insertions(+), 263 deletions(-) diff --git a/src/MapleEng/lmbc/BUILD.gn b/src/MapleEng/lmbc/BUILD.gn index e23e84064c..4f1012ff5e 100755 --- a/src/MapleEng/lmbc/BUILD.gn +++ b/src/MapleEng/lmbc/BUILD.gn @@ -25,6 +25,7 @@ include_directories = [ "${MAPLEALL_ROOT}/maple_ipa/include/old", "${MAPLEALL_ROOT}/maple_me/include", "${MAPLEALL_ROOT}/maple_phase/include", + "${MAPLEALL_ROOT}/maple_be/include/be", "${MAPLEENG_ROOT}/lmbc/include" ] diff --git a/src/MapleEng/lmbc/include/eng_shim.h b/src/MapleEng/lmbc/include/eng_shim.h index 2c29f723b0..8e67057c16 100644 --- a/src/MapleEng/lmbc/include/eng_shim.h +++ b/src/MapleEng/lmbc/include/eng_shim.h @@ -20,7 +20,7 @@ namespace maple { -extern "C" int64_t __engineShim(LmbcFunc*, ...); +extern "C" int64_t MplEngShim(LmbcFunc*, ...); } diff --git a/src/MapleEng/lmbc/include/lmbc_eng.h b/src/MapleEng/lmbc/include/lmbc_eng.h index 3ac873b23a..2fb0a21eae 100644 --- a/src/MapleEng/lmbc/include/lmbc_eng.h +++ b/src/MapleEng/lmbc/include/lmbc_eng.h @@ -28,15 +28,10 @@ #include "mvalue.h" #include "global_tables.h" #include "mfunction.h" +#include "common_utils.h" namespace maple { -class MFunction; class LmbcMod; -class LmbcFunc; - -using LabelMap = std::unordered_map; -using FuncMap = std::unordered_map; -using VarInf = struct ParmInf; // Parameter and variable info struct ParmInf { @@ -53,14 +48,16 @@ struct ParmInf { int32 storeIdx; MIRSymbol *sym; // VarInf only - for global and PUStatic var PUIdx puIdx; // VarInf only - for PUStatic var - ParmInf(PrimType type, size_t sz, bool ispreg, int32_t storageIdx) - : ptyp(type), size(sz), isPreg(ispreg), storeIdx(storageIdx) {} - ParmInf(PrimType type, size_t sz, bool ispreg, int32_t storageIdx, MIRSymbol *psym) - : ptyp(type), size(sz), isPreg(ispreg), storeIdx(storageIdx), sym(psym) {} - ParmInf(PrimType type, size_t sz, bool ispreg, int32_t storageIdx, MIRSymbol *psym, PUIdx puidx) - : ptyp(type), size(sz), isPreg(ispreg), storeIdx(storageIdx), sym(psym), puIdx(puidx) {} + ParmInf(PrimType type, size_t sz, bool ispreg, int32_t storageIdx) : ptyp(type), + size(sz), isPreg(ispreg), storeIdx(storageIdx) {} + ParmInf(PrimType type, size_t sz, bool ispreg, int32_t storageIdx, MIRSymbol *psym) : ptyp(type), + size(sz), isPreg(ispreg), storeIdx(storageIdx), sym(psym) {} + ParmInf(PrimType type, size_t sz, bool ispreg, int32_t storageIdx, MIRSymbol *psym, PUIdx puidx) : ptyp(type), + size(sz), isPreg(ispreg), storeIdx(storageIdx), sym(psym), puIdx(puidx) {} }; +using LabelMap = std::unordered_map; + class LmbcFunc { public: LmbcMod *lmbcMod; @@ -93,8 +90,11 @@ class FuncAddr { FuncAddr(bool lmbcFunc, void *func, std::string funcName, uint32 formalsAggSz = 0); }; +using VarInf = struct ParmInf; +using FuncMap = std::unordered_map; + class LmbcMod { -public: + public: std::string lmbcPath; MIRModule* mirMod {nullptr}; FuncMap funcMap; @@ -103,10 +103,10 @@ public: std::unordered_map globalStrTbl; int unInitPUStaticsSize {0}; // uninitalized PUStatic vars uint8* unInitPUStatics{nullptr}; - int globalsSize {0}; // global vars and initialized PUStatic + int globalsSize {0}; // global vars and initialized PUStatic uint8* globals {nullptr}; uint32 aggrInitOffset {0}; -public: + void InitGlobalVars(void); void InitGlobalVariable(VarInf *pInf); void InitIntConst(VarInf *pInf, MIRIntConst &intConst, uint8 *dst); @@ -120,7 +120,7 @@ public: void UpdateGlobalVarInitAddr(VarInf* pInf, uint32 size); void CheckUnamedBitField(MIRStructType &stType, uint32 &prevInitFd, uint32 curFd, int32 &allocdBits); - LmbcMod(char* path); + LmbcMod(std::string path); MIRModule* Import(std::string path); void InitModule(void); void CalcGlobalAndStaticVarSize(void); diff --git a/src/MapleEng/lmbc/include/mexpression.h b/src/MapleEng/lmbc/include/mexpression.h index e3de8becdf..306ac1bf8e 100644 --- a/src/MapleEng/lmbc/include/mexpression.h +++ b/src/MapleEng/lmbc/include/mexpression.h @@ -20,7 +20,7 @@ #define EXPRBINOP(exprop, res, op0, op1, exprPtyp) \ do { \ - switch(exprPtyp) { \ + switch (exprPtyp) { \ case PTY_i8: res.x.i8 = op0.x.i8 exprop op1.x.i8; break; \ case PTY_i16: res.x.i16 = op0.x.i16 exprop op1.x.i16; break; \ case PTY_i32: res.x.i32 = (int64)op0.x.i32 exprop (int64)op1.x.i32; break; \ @@ -35,12 +35,11 @@ default: MIR_FATAL("Unsupported PrimType %d for binary operator %s", exprPtyp, #exprop); \ } \ res.ptyp = expr->ptyp; \ - } while(0) + } while (0) -#define EXPRCOMPOP(exprop,res, op0, op1, optyp, exprptyp) \ +#define EXPRCOMPOP(exprop, res, op0, op1, optyp, exprptyp) \ do { \ - /*MASSERT(op0.ptyp == op1.ptyp, "COMOP Type mismatch: 0x%02x and 0x%02x", op0.ptyp, op1.ptyp);*/ \ - switch(optyp) { \ + switch (optyp) { \ case PTY_i8: res.x.i64 = op0.x.i8 exprop op1.x.i8; break; \ case PTY_i16: res.x.i64 = op0.x.i16 exprop op1.x.i16; break; \ case PTY_i32: res.x.i64 = op0.x.i32 exprop op1.x.i32; break; \ @@ -55,15 +54,14 @@ default: MIR_FATAL("Unsupported operand PrimType %d for comparison operator %s", op0.ptyp, #exprop); \ } \ res.ptyp = exprptyp; \ - } while(0) + } while (0) -// EXPRCOMPOP with f32 amd f64 comparison cases taken out because of +// EXPRCOMPOP with f32 amd f64 comparison cases taken out because of // -Wfloat-equal compile flag warnings with != and == on float types. // The float cases for != and == are special case handled in op handlers. #define EXPRCOMPOPNOFLOAT(exprop,res, op0, op1, optyp, exprptyp) \ do { \ - /*MASSERT(op0.ptyp == op1.ptyp, "COMPOP Type mismatch: 0x%02x and 0x%02x", op0.ptyp, op1.ptyp);*/ \ - switch(optyp) { \ + switch (optyp) { \ case PTY_i8: res.x.i64 = op0.x.i8 exprop op1.x.i8; break; \ case PTY_i16: res.x.i64 = op0.x.i16 exprop op1.x.i16; break; \ case PTY_i32: res.x.i64 = op0.x.i32 exprop op1.x.i32; break; \ @@ -76,14 +74,14 @@ default: MIR_FATAL("Unsupported operand PrimType %d for comparison operator %s", op0.ptyp, #exprop); \ } \ res.ptyp = exprptyp; \ - } while(0) + } while (0) #define EXPRSELECTOP(res, op0, sel1, sel2, exprptyp) \ do { \ MValue op1, op2; \ op1 = CvtType(sel1, exprptyp, sel1.ptyp); \ op2 = CvtType(sel2, exprptyp, sel2.ptyp); \ - switch(exprptyp) { \ + switch (exprptyp) { \ case PTY_i8: res.x.i8 = op0.x.i64? op1.x.i8 : op2.x.i8; break; \ case PTY_i16: res.x.i16 = op0.x.i64? op1.x.i16 : op2.x.i16; break; \ case PTY_i32: res.x.i32 = op0.x.i64? op1.x.i32 : op2.x.i32; break; \ @@ -98,12 +96,12 @@ default: MIR_FATAL("Unsupported PrimType %d for select operator", exprptyp); \ } \ res.ptyp = exprptyp; \ - } while(0) + } while (0) #define EXPRBININTOP(exprop, res, op, op1, exprptyp) \ do { \ MValue op0 = CvtType(op, exprptyp, op.ptyp); \ - switch(exprptyp) { \ + switch (exprptyp) { \ case PTY_i8: res.x.i8 = op0.x.i8 exprop op1.x.i8; break; \ case PTY_i16: res.x.i16 = op0.x.i16 exprop op1.x.i16; break; \ case PTY_i32: res.x.i32 = op0.x.i32 exprop op1.x.i32; break; \ @@ -116,7 +114,7 @@ default: MIR_FATAL("Unsupported PrimType %d for integer binary operator %s", exprptyp, #exprop); \ } \ res.ptyp = exprptyp; \ - } while(0) + } while (0) // Used by OP_lshr only #define EXPRBININTOPUNSIGNED(exprop, res, op0, op1, exprptyp) \ @@ -125,7 +123,7 @@ (op0.ptyp == PTY_u32 && exprptyp == PTY_i32) || \ (op0.ptyp == PTY_i32 && exprptyp == PTY_u32), \ "BINUINTOP Type mismatch: 0x%02x and 0x%02x", op0.ptyp, exprptyp); \ - switch(op1.ptyp) { \ + switch (op1.ptyp) { \ case PTY_i8: \ case PTY_u8: \ MASSERT(op1.x.u8 <= 64, "OP_lshr shifting more than 64 bites"); \ @@ -147,7 +145,7 @@ MIR_FATAL("Unsupported PrimType %d for unsigned integer binary operator %s", exprptyp, #exprop); \ break; \ } \ - switch(exprptyp) { \ + switch (exprptyp) { \ case PTY_i8: res.x.u8 = op0.x.u8 exprop op1.x.u8; break; \ case PTY_i16: res.x.u16 = op0.x.u16 exprop op1.x.u16; break; \ case PTY_i32: res.x.u32 = op0.x.u32 exprop op1.x.u32; break; \ @@ -160,13 +158,13 @@ default: MIR_FATAL("Unsupported PrimType %d for unsigned integer binary operator %s", exprptyp, #exprop); \ } \ res.ptyp = exprptyp; \ - } while(0) + } while (0) #define EXPRMAXMINOP(exprop, res, op0, op1, exprptyp) \ do { \ MASSERT(op0.ptyp == op1.ptyp, "MAXMINOP Type mismatch: 0x%02x and 0x%02x", op0.ptyp, op1.ptyp); \ MASSERT(op0.ptyp == exprptyp, "MAXMINOP Type mismatch: 0x%02x and 0x%02x", op0.ptyp, exprptyp); \ - switch(exprptyp) { \ + switch (exprptyp) { \ case PTY_i8: res.x.i8 = op0.x.i8 exprop op1.x.i8? op0.x.i8 : op1.x.i8; break; \ case PTY_i16: res.x.i16 = op0.x.i16 exprop op1.x.i16? op0.x.i16 : op1.x.i16; break; \ case PTY_i32: res.x.i32 = op0.x.i32 exprop op1.x.i32? op0.x.i32 : op1.x.i32; break; \ @@ -181,42 +179,43 @@ default: MIR_FATAL("Unsupported PrimType %d for binary max/min operator %s", exprptyp, #exprop); \ } \ res.ptyp = exprptyp; \ - } while(0) + } while (0) #define EXPRREMOP(exprop, res, op0, op1, exprptyp) \ do { \ - switch(exprptyp) { \ - case PTY_i8: if(op1.x.i8 == 0) res.x.i8 = 0; \ - else if(op1.x.i8 == -1 && op0.x.i8 == INT8_MIN) op0.x.i8 = 0; \ + switch (exprptyp) { \ + case PTY_i8: if (op1.x.i8 == 0) res.x.i8 = 0; \ + else if (op1.x.i8 == -1 && op0.x.i8 == INT8_MIN) op0.x.i8 = 0; \ else res.x.i8 = op0.x.i8 exprop op1.x.i8; break; \ - case PTY_i16: if(op1.x.i16 == 0) res.x.i16 = 0; \ - else if(op1.x.i16 == -1 && op0.x.i16 == INT16_MIN) op0.x.i16 = 0; \ + case PTY_i16: if (op1.x.i16 == 0) res.x.i16 = 0; \ + else if (op1.x.i16 == -1 && op0.x.i16 == INT16_MIN) op0.x.i16 = 0; \ else res.x.i16 = op0.x.i16 exprop op1.x.i16; break; \ - case PTY_i32: if(op1.x.i32 == 0) res.x.i32 = 0; \ - else if(op1.x.i32 == -1 && op0.x.i32 == INT32_MIN) op0.x.i32 = 0; \ + case PTY_i32: if (op1.x.i32 == 0) res.x.i32 = 0; \ + else if (op1.x.i32 == -1 && op0.x.i32 == INT32_MIN) op0.x.i32 = 0; \ else res.x.i32 = op0.x.i32 exprop op1.x.i32; break; \ - case PTY_i64: if(op1.x.i64 == 0) res.x.i64 = 0; \ - else if(op1.x.i64 == -1 && op0.x.i64 == INT64_MIN) op0.x.i64 = 0; \ + case PTY_i64: if (op1.x.i64 == 0) res.x.i64 = 0; \ + else if (op1.x.i64 == -1 && op0.x.i64 == INT64_MIN) op0.x.i64 = 0; \ else res.x.i64 = op0.x.i64 exprop op1.x.i64; break; \ - case PTY_u8: if(op1.x.u8 == 0) res.x.u8 = 0; \ + case PTY_u8: if (op1.x.u8 == 0) res.x.u8 = 0; \ else res.x.u8 = op0.x.u8 exprop op1.x.u8; break; \ - case PTY_u16: if(op1.x.u16 == 0) res.x.u16 = 0; \ + case PTY_u16: if (op1.x.u16 == 0) res.x.u16 = 0; \ else res.x.u16 = op0.x.u16 exprop op1.x.u16; break; \ - case PTY_u32: if(op1.x.u32 == 0) res.x.u32 = 0; \ + case PTY_u32: if (op1.x.u32 == 0) res.x.u32 = 0; \ else res.x.u32 = op0.x.u32 exprop op1.x.u32; break; \ - case PTY_u64: if(op1.x.u64 == 0) res.x.u64 = 0; \ + case PTY_u64: if (op1.x.u64 == 0) res.x.u64 = 0; \ else res.x.u64 = op0.x.u64 exprop op1.x.u64; break; \ default: MIR_FATAL("Unsupported PrimType %d for rem operator %s", exprptyp, #exprop); \ } \ res.ptyp = exprptyp; \ - } while(0) + } while (0) #define EXPRUNROP(exprop, res, op0, exprptyp) \ do { \ MASSERT(op0.ptyp == exprptyp || \ ((op0.ptyp == PTY_i32 || op0.ptyp == PTY_u32) && \ - (exprptyp == PTY_i32 || exprptyp == PTY_u32)) , "UNROP Type mismatch: 0x%02x and 0x%02x", op0.ptyp, exprptyp); \ - switch(exprptyp) { \ + (exprptyp == PTY_i32 || exprptyp == PTY_u32)), \ + "UNROP Type mismatch: 0x%02x and 0x%02x", op0.ptyp, exprptyp); \ + switch (exprptyp) { \ case PTY_i8: res.x.i8 = exprop op0.x.i8; break; \ case PTY_i16: res.x.i16 = exprop op0.x.i16; break; \ case PTY_i32: res.x.i32 = exprop op0.x.i32; break; \ @@ -228,6 +227,6 @@ default: MIR_FATAL("Unsupported PrimType %d for unary operator %s", exprptyp, #exprop); \ } \ res.ptyp = exprptyp; \ - } while(0) + } while (0) #endif // MPLENG_MEXPRESSION_H_ diff --git a/src/MapleEng/lmbc/include/mfunction.h b/src/MapleEng/lmbc/include/mfunction.h index fb5dc72546..b56e9fc34b 100644 --- a/src/MapleEng/lmbc/include/mfunction.h +++ b/src/MapleEng/lmbc/include/mfunction.h @@ -20,7 +20,6 @@ #include #include -#define gettid() syscall(SYS_gettid) #include "mir_nodes.h" #include "mvalue.h" @@ -35,17 +34,11 @@ class LmbcMod; class LmbcFunc; struct ParmInf; -//using ffi_fp_t = void(*const)(); using ffi_fp_t = void(*)(); -// For x86 valist setup, gp_offset and fp_offset are set to values -// to force va arg access from stack pointed to by overflow_arg_area -// instead of reg_save_area (ref. x86_64 ABI), e.g. -// VaListX86_64 *vaList = (maple::VaListX86_64*)addrofAP.x.a64; -// vaList->gp_offset = 48; -// vaList->fp_offset = 304; -// vaList->overflow_arg_area = caller.caller->vaArgs; -// vaList->reg_save_area = nullptr; +// For x86 valist setup, to force va arg acess from stack pointed to +// by overflow_arg_area, set gp_offset to 48, fp_offset to 304, +// reg_save_rea to null, and overflow_arg_arg to location for vaArgs. typedef struct { uint gp_offset; uint fp_offset; @@ -63,9 +56,9 @@ typedef struct { using VaList = VaListAarch64; -// State of executing Maple function +// State of executing Maple function class MFunction { - public: + public: // state of an executing function LmbcFunc* info; // current func MFunction* caller; // caller of current func diff --git a/src/MapleEng/lmbc/src/eng_shim.cpp b/src/MapleEng/lmbc/src/eng_shim.cpp index 7a0cae2e68..3323aaf9f4 100644 --- a/src/MapleEng/lmbc/src/eng_shim.cpp +++ b/src/MapleEng/lmbc/src/eng_shim.cpp @@ -18,8 +18,7 @@ namespace maple { -extern "C" int64 -__engineShim(LmbcFunc* fn, ...) { +extern "C" int64 MplEngShim(LmbcFunc* fn, ...) { uint8 frame[fn->frameSize]; MValue pregs[fn->numPregs]; MValue formalVars[fn->formalsNumVars+1]; @@ -35,7 +34,7 @@ __engineShim(LmbcFunc* fn, ...) { while (argIdx < fn->formalsNum) { // convert argv args to interpreter types and push on operand stack val.ptyp = fn->pos2Parm[argIdx]->ptyp; - switch(val.ptyp) { + switch (val.ptyp) { case PTY_i8: val.x.i8 = va_arg(args, int); break; diff --git a/src/MapleEng/lmbc/src/init.cpp b/src/MapleEng/lmbc/src/init.cpp index 285e93949f..eccab17f79 100644 --- a/src/MapleEng/lmbc/src/init.cpp +++ b/src/MapleEng/lmbc/src/init.cpp @@ -24,7 +24,7 @@ inline void AlignOffset(uint32 &offset, uint32 align) { } LmbcFunc::LmbcFunc(LmbcMod *mod, MIRFunction *func) : lmbcMod(mod), mirFunc(func) { - frameSize = ((func->GetFrameSize()+7)>>3)<<3; // round up to nearest 8 + frameSize = ((func->GetFrameSize()+maplebe::k8ByteSize-1) >> maplebe::k8BitShift) << maplebe::k8BitShift; // round up to nearest 8 isVarArgs = func->GetMIRFuncType()->IsVarargs(); numPregs = func->GetPregTab()->Size(); } @@ -34,7 +34,7 @@ void LmbcMod::InitModule(void) { for (MIRFunction *mirFunc : mirMod->GetFunctionList()) { if (auto node = mirFunc->GetBody()) { LmbcFunc* fn = new LmbcFunc(this, mirFunc); - ASSERT(fn, "Create Lmbc function failed"); + MASSERT(fn, "Create Lmbc function failed"); fn->ScanFormals(); fn->ScanLabels(node); funcMap[mirFunc->GetPuidx()] = fn; @@ -93,7 +93,6 @@ void LmbcFunc::ScanLabels(StmtNode* stmt) { // Check for initialized flex array struct member and return size. The number // of elements is not specified in the array type declaration but determined // by array initializer. -// Note:: // - Flex array must be last field of a top level struct // - Only 1st dim of multi-dim array can be unspecified. Other dims must have bounds. // - In Maple AST, array with unspecified num elements is defined with 1 element in @@ -128,7 +127,7 @@ void LmbcMod::CalcGlobalAndStaticVarSize() { MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(i); if (!sym || !(sym->GetSKind() == kStVar) || - !(sym->GetStorageClass() == kScGlobal || sym->GetStorageClass() == kScFstatic)) { + !(sym->GetStorageClass() == kScGlobal || sym->GetStorageClass() == kScFstatic)) { continue; } if (MIRType *ty = sym->GetType()) { @@ -161,7 +160,7 @@ void LmbcMod::ScanPUStatic(MIRFunction *func) { VarInf* pInf = new VarInf(ty->GetPrimType(), ty->GetSize(), false, globalsSize, sym, func->GetPuidx()); AddPUStaticVar(func->GetPuidx(), *sym, pInf); // add var to lookup table globalsSize += ty->GetSize(); - } + } } } @@ -189,12 +188,10 @@ inline void LmbcMod::UpdateGlobalVarInitAddr(VarInf* pInf, uint32 size) { // bit fields appears as gaps in field id between initialized struct fields // of a global var. void LmbcMod::CheckUnamedBitField(MIRStructType &stType, uint32 &prevInitFd, uint32 curFd, int32 &allocdBits) { - if (curFd - 1 == prevInitFd) { prevInitFd = curFd; return; } - for (auto i = prevInitFd; i < curFd -1; ++i) { // struct fd idx 0 based; agg const fd 1 based TyIdxFieldAttrPair tfap = stType.GetTyidxFieldAttrPair(i); MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tfap.first); // type of struct fd @@ -210,7 +207,7 @@ void LmbcMod::CheckUnamedBitField(MIRStructType &stType, uint32 &prevInitFd, uin uint32 align = allocdBits ? 1 : baseFdSz; // align with base fd if no bits have been allocated AlignOffset(aggrInitOffset, align); - if (allocdBits + bitFdWidth > (baseFdSz * 8)) { // alloc bits will cross align boundary of base type + if (allocdBits + bitFdWidth > (baseFdSz * maplebe::k8BitSize)) { // alloc bits will cross align boundary of base type aggrInitOffset+= baseFdSz; allocdBits = bitFdWidth; // alloc bits at new boundary } else { @@ -245,7 +242,7 @@ void LmbcMod::InitLblConst(VarInf *pInf, MIRLblConst &labelConst, uint8 *dst) { void LmbcMod::InitIntConst(VarInf* pInf, MIRIntConst &intConst, uint8* dst) { int64 val = intConst.GetExtValue(); - switch(intConst.GetType().GetPrimType()) { + switch (intConst.GetType().GetPrimType()) { case PTY_i64: *(int64*)dst = (int64)val; break; @@ -277,7 +274,7 @@ void LmbcMod::InitIntConst(VarInf* pInf, MIRIntConst &intConst, uint8* dst) { void LmbcMod::InitPointerConst(VarInf *pInf, MIRConst &mirConst) { uint8 *dst = GetGlobalVarInitAddr(pInf, mirConst.GetType().GetAlign()); - switch(mirConst.GetKind()) { + switch (mirConst.GetKind()) { case kConstAddrof: InitAddrofConst(pInf, static_cast(mirConst), dst); break; @@ -297,39 +294,39 @@ void LmbcMod::InitPointerConst(VarInf *pInf, MIRConst &mirConst) { } void SetBitFieldConst(uint8* baseFdAddr, uint32 baseFdSz, uint32 bitsOffset, uint8 bitsSize, MIRConst &elemConst) { - MIRIntConst &intConst = static_cast(elemConst); (void)intConst; + MIRIntConst &intConst = static_cast(elemConst); int64 val = intConst.GetExtValue(); uint64 mask = ~(0xffffffffffffffff << bitsSize); uint64 from = (val & mask) << bitsOffset; mask = mask << bitsOffset; - switch(elemConst.GetType().GetPrimType()) { - case PTY_i64: - *(int64*)baseFdAddr = ((*(int64*)baseFdAddr) & ~(mask)) | from; - break; - case PTY_i32: - *(int32*)baseFdAddr = ((*(int32*)baseFdAddr) & ~(mask)) | from; - break; - case PTY_i16: - *(int16*)baseFdAddr = ((*(int16*)baseFdAddr) & ~(mask)) | from; - break; - case PTY_i8: - *(int8*)baseFdAddr = ((*(int8*)baseFdAddr) & ~(mask)) | from; - break; - case PTY_u64: - *(uint64*)baseFdAddr = ((*(uint64*)baseFdAddr) & ~(mask)) | from; - break; - case PTY_u32: - *(uint32*)baseFdAddr = ((*(uint32*)baseFdAddr) & ~(mask)) | from; - break; - case PTY_u16: - *(uint16*)baseFdAddr = ((*(uint16*)baseFdAddr) & ~(mask)) | from; - break; - case PTY_u8: - *(uint8*)baseFdAddr = ((*(uint8*)baseFdAddr) & ~(mask)) | from; - break; - default: - MASSERT(false, "Unexpected primary type"); - break; + switch (elemConst.GetType().GetPrimType()) { + case PTY_i64: + *(int64*)baseFdAddr = ((*(int64*)baseFdAddr) & ~(mask)) | from; + break; + case PTY_i32: + *(int32*)baseFdAddr = ((*(int32*)baseFdAddr) & ~(mask)) | from; + break; + case PTY_i16: + *(int16*)baseFdAddr = ((*(int16*)baseFdAddr) & ~(mask)) | from; + break; + case PTY_i8: + *(int8*)baseFdAddr = ((*(int8*)baseFdAddr) & ~(mask)) | from; + break; + case PTY_u64: + *(uint64*)baseFdAddr = ((*(uint64*)baseFdAddr) & ~(mask)) | from; + break; + case PTY_u32: + *(uint32*)baseFdAddr = ((*(uint32*)baseFdAddr) & ~(mask)) | from; + break; + case PTY_u16: + *(uint16*)baseFdAddr = ((*(uint16*)baseFdAddr) & ~(mask)) | from; + break; + case PTY_u8: + *(uint8*)baseFdAddr = ((*(uint8*)baseFdAddr) & ~(mask)) | from; + break; + default: + MASSERT(false, "Unexpected primary type"); + break; } } @@ -340,14 +337,14 @@ void LmbcMod::InitBitFieldConst(VarInf *pInf, MIRConst &elemConst, int32 &allocd return; } if (forceAlign) { // align to next boundary - aggrInitOffset += (allocdBits + 7) >> 3; + aggrInitOffset += (allocdBits + maplebe::k8ByteSize-1) >> maplebe::k8BitShift; forceAlign = false; } uint32 baseFdSz = GetPrimTypeSize(elemConst.GetType().GetPrimType()); uint32 align = allocdBits ? 1 : baseFdSz; // align with base fd if no bits have been allocated uint8* baseFdAddr = GetGlobalVarInitAddr(pInf, align); - if (allocdBits + bitFdWidth > (baseFdSz * 8)) { // alloc bits will cross align boundary of base type + if (allocdBits + bitFdWidth > (baseFdSz * maplebe::k8BitSize)) { // alloc bits will cross align boundary of base type baseFdAddr = baseFdAddr + baseFdSz; // inc addr & offset by size of base type SetBitFieldConst(baseFdAddr, baseFdSz, 0, bitFdWidth, elemConst); aggrInitOffset+= baseFdSz; @@ -375,7 +372,7 @@ void LmbcMod::InitAggConst(VarInf *pInf, MIRConst &mirConst) { if (prevElemKind == kTypeBitField && elemType.GetKind() != kTypeBitField) { forceAlign = false; if (allocdBits) { - aggrInitOffset += (allocdBits + 7) >> 3; // pad preceding bit fd to byte boundary + aggrInitOffset += (allocdBits + maplebe::k8ByteSize-1) >> maplebe::k8BitShift; // pad preceding bit fd to byte boundary allocdBits = 0; } } @@ -384,7 +381,7 @@ void LmbcMod::InitAggConst(VarInf *pInf, MIRConst &mirConst) { if (stType.GetKind() != kTypeArray) { CheckUnamedBitField(stType, prevInitFd, aggConst.GetFieldIdItem(i), allocdBits); } - switch(elemType.GetKind()) { + switch (elemType.GetKind()) { case kTypeScalar: InitScalarConst(pInf, elemConst); break; @@ -405,7 +402,7 @@ void LmbcMod::InitAggConst(VarInf *pInf, MIRConst &mirConst) { default: { MASSERT(false, "init struct type %d NYI", elemType.GetKind()); break; - } + } } prevElemKind = elemType.GetKind(); } @@ -463,24 +460,15 @@ void LmbcMod::InitArrayConst(VarInf *pInf, MIRConst &mirConst) { if (IsPrimitiveVector(subTy->GetPrimType())) { MASSERT(false, "Unexpected primitive vector"); } else if (IsPrimitiveScalar(elemConst->GetType().GetPrimType())) { - bool strLiteral = false; - if (arrayType.GetDim() == 1) { - MIRType *ety = arrayType.GetElemType(); - if (ety->GetPrimType() == PTY_i8 || ety->GetPrimType() == PTY_u8) { - strLiteral = true; - } - } InitScalarConst(pInf, *elemConst); } else if (elemConst->GetType().GetKind() == kTypeArray) { InitArrayConst(pInf, *elemConst); - } else if (elemConst->GetType().GetKind() == kTypeStruct || + } else if (elemConst->GetType().GetKind() == kTypeStruct || elemConst->GetType().GetKind() == kTypeClass || elemConst->GetType().GetKind() == kTypeUnion) { InitAggConst(pInf, *elemConst); -// } else if (elemConst->GetKind() == kConstAddrofFunc) { -// InitScalarConstant(pInf, *elemConst); } else { - ASSERT(false, "should not run here"); + MASSERT(false, "InitArrayConst unexpected error"); } } } @@ -496,7 +484,7 @@ void LmbcMod::InitGlobalVariable(VarInf *pInf) { MIRConst *mirConst = pInf->sym->GetKonst(); uint8 *dst = GetGlobalVarInitAddr(pInf, mirConst->GetType().GetAlign()); - switch(mirConst->GetKind()) { + switch (mirConst->GetKind()) { case kConstAggConst: aggrInitOffset = 0; InitAggConst(pInf, *mirConst); @@ -524,11 +512,11 @@ void LmbcMod::InitGlobalVariable(VarInf *pInf) { } void LmbcMod::InitGlobalVars(void) { - // alloc mem for global vars + // alloc mem for global vars this->globals = (uint8*)malloc(this->globalsSize); this->unInitPUStatics = (uint8*)malloc(this->unInitPUStaticsSize); - memset(this->globals, 0, this->globalsSize); - memset(this->unInitPUStatics, 0, this->unInitPUStaticsSize); + memset_s(this->globals, this->globalsSize, 0, this->globalsSize); + memset_s(this->unInitPUStatics, this->unInitPUStaticsSize, 0, this->unInitPUStaticsSize); // init global vars and static vars for (const auto it : globalAndStaticVars) { @@ -544,25 +532,24 @@ inline void LmbcMod::AddGlobalVar(MIRSymbol &sym, VarInf *pInf) { } inline void LmbcMod::AddPUStaticVar(PUIdx puIdx, MIRSymbol &sym, VarInf *pInf) { - globalAndStaticVars[(uint64)puIdx << 32 | sym.GetStIdx().FullIdx()] = pInf; + globalAndStaticVars[((uint64)puIdx << maplebe::k32BitSize) | sym.GetStIdx().FullIdx()] = pInf; } // global var uint8 *LmbcMod::GetVarAddr(StIdx stIdx) { auto it = globalAndStaticVars.find(stIdx.FullIdx()); MASSERT(it != globalAndStaticVars.end(), "global var not found"); - return globals + it->second->storeIdx; + return globals + it->second->storeIdx; } // PUStatic var uint8 *LmbcMod::GetVarAddr(PUIdx puIdx, StIdx stIdx) { - auto it = globalAndStaticVars.find((long)puIdx << 32 | stIdx.FullIdx()); + auto it = globalAndStaticVars.find(((long)puIdx << maplebe::k32BitSize) | stIdx.FullIdx()); MASSERT(it != globalAndStaticVars.end(), "PUStatic var not found"); - return globals + it->second->storeIdx; + return globals + it->second->storeIdx; } -LmbcFunc* -LmbcMod::LkupLmbcFunc(PUIdx puIdx) { +LmbcFunc *LmbcMod::LkupLmbcFunc(PUIdx puIdx) { auto it = funcMap.find(puIdx); return it == funcMap.end()? nullptr: it->second; } diff --git a/src/MapleEng/lmbc/src/invoke_method.cpp b/src/MapleEng/lmbc/src/invoke_method.cpp index c26ad606d7..162fda67b0 100644 --- a/src/MapleEng/lmbc/src/invoke_method.cpp +++ b/src/MapleEng/lmbc/src/invoke_method.cpp @@ -27,7 +27,7 @@ namespace maple { int64 MVal2Int64(MValue &val) { - switch(val.ptyp) { + switch (val.ptyp) { case PTY_i64: return val.x.i64; case PTY_i32: @@ -58,9 +58,9 @@ bool IsZero(MValue& cond) { } bool RegAssignZextOrSext(MValue& from, PrimType toTyp, MValue& to) { - switch(toTyp) { + switch (toTyp) { case PTY_u8: - switch(from.ptyp) { + switch (from.ptyp) { case PTY_u32: to.x.u8 = from.x.u32; break; // special case as needed default: return false; } @@ -129,8 +129,8 @@ bool RegAssignZextOrSext(MValue& from, PrimType toTyp, MValue& to) { MValue CvtType(MValue &opnd, PrimType toPtyp, PrimType fromPtyp) { MValue res; - int64 fromInt; - uint64 fromUint; + intptr_t fromInt; + uintptr_t fromUint; float fromFloat; double fromDouble; bool cvtInt = false; @@ -141,7 +141,7 @@ MValue CvtType(MValue &opnd, PrimType toPtyp, PrimType fromPtyp) { if (opnd.ptyp == toPtyp) { return opnd; } - switch(fromPtyp) { + switch (fromPtyp) { case PTY_i8: fromInt = opnd.x.i8; cvtInt = true; break; case PTY_i16: fromInt = opnd.x.i16; cvtInt = true; break; case PTY_i32: fromInt = opnd.x.i32; cvtInt = true; break; @@ -156,7 +156,7 @@ MValue CvtType(MValue &opnd, PrimType toPtyp, PrimType fromPtyp) { case PTY_f64: fromDouble= opnd.x.f64; cvtf64 = true; break; default: MASSERT(false, "OP_cvt from ptyp %d NYI", fromPtyp); break; } - switch(toPtyp) { + switch (toPtyp) { CASE_TOPTYP(i8, int8) CASE_TOPTYP(i16, int16) CASE_TOPTYP(i32, int32) @@ -198,7 +198,7 @@ inline bool CompareDouble(double x, double y, double epsilon = 0.000000000000000 void HandleFloatEq(Opcode op, PrimType opndType, MValue &res, MValue &op1, MValue &op2) { MASSERT(opndType == op1.ptyp && op1.ptyp == op2.ptyp, "Operand type mismatch %d %d", op1.ptyp, op2.ptyp); - switch(op) { + switch (op) { case OP_ne: if (opndType == PTY_f32) { res.x.i64 = !CompareFloat(op1.x.f32, op2.x.f32); @@ -232,12 +232,28 @@ void LoadArgs(MFunction& func) { } } +// Handle regassign agg %%retval0 +// Return agg <= 16 bytes in %%retval0 and %%retval1 +void HandleAggrRetval(MValue &rhs, MFunction *caller) { + MASSERT(rhs.aggSize <= 16, "regassign of agg >16 bytes to %%retval0"); + uint64 retval[2] = {0, 0}; + memcpy_s(retval, sizeof(retval), rhs.x.a64, rhs.aggSize); + caller->retVal0.x.u64 = retval[0]; + caller->retVal0.ptyp = PTY_agg; // treat as PTY_u64 if aggSize <= 16 + caller->retVal0.aggSize = rhs.aggSize; + if (rhs.aggSize > maplebe::k8ByteSize) { + caller->retVal1.x.u64 = retval[1]; + caller->retVal1.ptyp = PTY_agg; + caller->retVal1.aggSize= rhs.aggSize; + } +} + // Walk the Maple LMBC IR tree of a function and execute its statements. MValue InvokeFunc(LmbcFunc* fn, MFunction *caller) { MValue retVal; MValue pregs[fn->numPregs]; // func pregs (incl. func formals that are pregs) MValue formalVars[fn->formalsNumVars+1]; // func formals that are named vars - alignas(8) uint8 frame[fn->frameSize]; // func autovars + alignas(maplebe::k8ByteSize) uint8 frame[fn->frameSize]; // func autovars MFunction mfunc(fn, caller, frame, pregs, formalVars); // init func execution state static void* const labels[] = { @@ -249,8 +265,9 @@ MValue InvokeFunc(LmbcFunc* fn, MFunction *caller) { }; LoadArgs(mfunc); - mfunc.allocaMem = static_cast(alloca(ALLOCA_MEMMAX)); - //memset(mfunc.allocaMem, 0, ALLOCA_MEMMAX); // for debug only + uint8 buf[ALLOCA_MEMMAX]; + mfunc.allocaMem = buf; +// mfunc.allocaMem = static_cast(alloca(ALLOCA_MEMMAX)); StmtNode *stmt = mfunc.nextStmt; goto *(labels[stmt->op]); @@ -302,19 +319,7 @@ label_OP_regassign: if (node->ptyp != PTY_agg) { caller->retVal0 = rhs; } else { - // handle regassign agg %%retval0 - // - return agg <= 16 bytes in %retval0 and %retval1 as type PTY_u64 - MASSERT(rhs.aggSize <= 16, "regassign of agg >16 bytes to %%retval0"); - uint64 retval[2] = {0, 0}; - memcpy(retval, rhs.x.a64, rhs.aggSize); - caller->retVal0.x.u64 = retval[0]; - caller->retVal0.ptyp = PTY_agg; // treat as PTY_u64 if aggSize <= 16 - caller->retVal0.aggSize = rhs.aggSize; - if (rhs.aggSize > 8) { - caller->retVal1.x.u64 = retval[1]; - caller->retVal1.ptyp = PTY_agg; - caller->retVal1.aggSize= rhs.aggSize; - } + HandleAggrRetval(rhs, caller); } } else { MASSERT(regIdx < fn->numPregs, "regassign regIdx %d out of bound", regIdx); @@ -336,7 +341,6 @@ label_OP_regassign: mfunc.pRegs[regIdx] = rhs; mfunc.pRegs[regIdx].ptyp = node->ptyp; } else { - // MASSERT(false, "regassign type mismatch: %d and %d", node->ptyp, rhs.ptyp); mfunc.pRegs[regIdx] = CvtType(rhs, node->ptyp, rhs.ptyp); } } @@ -388,12 +392,11 @@ label_OP_iassignoff: label_OP_blkassignoff: { BlkassignoffNode* node = static_cast(stmt); - //uint32 align = node->GetAlign(); int32 dstOffset = node->offset; int32 blkSize = node->blockSize; MValue dstAddr = EvalExpr(mfunc, node->Opnd(0)); MValue srcAddr = EvalExpr(mfunc, node->Opnd(1)); - memcpy(dstAddr.x.a64 + dstOffset, srcAddr.x.a64, blkSize); + memcpy_s(dstAddr.x.a64 + dstOffset, blkSize, srcAddr.x.a64, blkSize); } stmt = stmt->GetNext(); mfunc.nextStmt = stmt; @@ -640,7 +643,7 @@ label_OP_constval: int64 constInt = 0; float constFloat = 0; double constDouble = 0; - switch(constval->GetKind()) { + switch (constval->GetKind()) { case kConstInt: constInt = static_cast(constval)->GetExtValue(); break; @@ -655,7 +658,7 @@ label_OP_constval: break; } PrimType ptyp = expr->ptyp; - switch(ptyp) { + switch (ptyp) { case PTY_i8: case PTY_i16: case PTY_i32: @@ -694,7 +697,7 @@ label_OP_add: { MValue op0 = EvalExpr(func, expr->Opnd(0)); MValue op1 = EvalExpr(func, expr->Opnd(1)); - switch(expr->ptyp) { + switch (expr->ptyp) { case PTY_i8: res.x.i8 = op0.x.i8 + op1.x.i8; break; case PTY_i16: res.x.i16 = op0.x.i16 + op1.x.i16; break; case PTY_i32: res.x.i32 = (int64)op0.x.i32 + (int64)op1.x.i32; break; @@ -709,7 +712,6 @@ label_OP_add: default: MIR_FATAL("Unsupported PrimType %d for binary operator %s", expr->ptyp, "+"); } res.ptyp = expr->ptyp; -// EXPRBINOP(+, res, opnd0, opnd1, expr->ptyp); goto _exit; } label_OP_sub: @@ -736,7 +738,7 @@ label_OP_div: label_OP_regread: { PregIdx regIdx = static_cast(expr)->GetRegIdx(); - switch(regIdx) { + switch (regIdx) { case -(kSregFp): MASSERT(expr->ptyp == PTY_a64, "regread %%FP with wrong ptyp %d", expr->ptyp); res.x.a64 = func.fp; @@ -762,7 +764,6 @@ label_OP_regread: break; default: MASSERT(regIdx < func.info->numPregs, "regread regIdx %d out of bound", regIdx); - // MASSERT(expr->ptyp == func.pRegs[regIdx].ptyp, "regread primtype mismatch: %d and %d", expr->ptyp, func.pRegs[regIdx].ptyp); res = func.pRegs[regIdx]; break; } @@ -796,7 +797,7 @@ label_OP_ireadfpoff: if (func.nextStmt->op == OP_call) { // caller // check if calling external func: MASSERT(func.aggrArgsBuf != nullptr, "aggrArgsBuf is null"); - memcpy(func.aggrArgsBuf+parm->storeIdx, func.fp+offset, parm->size); + memcpy_s(func.aggrArgsBuf+parm->storeIdx, parm->size, func.fp+offset, parm->size); mload(func.aggrArgsBuf+parm->storeIdx, expr->ptyp, res, parm->size); } else { // callee mload(func.fp+offset, expr->ptyp, res, func.info->retSize); @@ -814,7 +815,7 @@ label_OP_ireadoff: MASSERT(rhs.ptyp == PTY_a64, "ireadoff agg RHS not PTY_agg"); if (func.nextStmt->op == OP_call) { MASSERT(func.aggrArgsBuf != nullptr, "aggrArgsBuf is null"); - memcpy(func.aggrArgsBuf+parm->storeIdx, rhs.x.a64 + offset, parm->size); + memcpy_s(func.aggrArgsBuf+parm->storeIdx, parm->size, rhs.x.a64 + offset, parm->size); mload(func.aggrArgsBuf+parm->storeIdx, expr->ptyp, res, parm->size); } else { MASSERT(func.nextStmt->op == OP_regassign, "ireadoff agg not used as regassign agg opnd"); @@ -832,7 +833,7 @@ label_OP_iread: MASSERT(func.nextStmt->op == OP_call && expr->ptyp == PTY_agg, "iread unexpected outside call"); MValue addr = EvalExpr(func, expr->Opnd(0)); MASSERT(func.aggrArgsBuf != nullptr, "aggrArgsBuf is null"); - memcpy(func.aggrArgsBuf+parm->storeIdx, addr.x.a64, parm->size); + memcpy_s(func.aggrArgsBuf+parm->storeIdx, parm->size, addr.x.a64, parm->size); mload(func.aggrArgsBuf+parm->storeIdx, expr->ptyp, res, parm->size); goto _exit; } @@ -959,10 +960,9 @@ label_OP_lnot: label_OP_neg: { MValue opnd0 = EvalExpr(func, expr->Opnd(0)); - switch(expr->ptyp) { + switch (expr->ptyp) { case PTY_i8: res.x.i8 = -opnd0.x.i8; break; case PTY_i16: res.x.i16 = -opnd0.x.i16; break; - //case PTY_i32: res.x.i32 = -opnd0.x.i32; break; case PTY_i32: res.x.i32 = ~(uint32)opnd0.x.i32+1; break; case PTY_i64: res.x.i64 = -opnd0.x.i64; break; case PTY_u8: res.x.u8 = -opnd0.x.u8; break; @@ -974,15 +974,12 @@ label_OP_neg: default: MIR_FATAL("Unsupported PrimType %d for unary operator %s", expr->ptyp, "OP_neg"); } res.ptyp = expr->ptyp; -#if 0 - EXPRUNROP(-, res, opnd0, expr->ptyp); -#endif goto _exit; } label_OP_abs: { MValue op0 = EvalExpr(func, expr->Opnd(0)); - switch(expr->ptyp) { + switch (expr->ptyp) { // abs operand must be signed case PTY_i8: res.x.i8 = abs(op0.x.i8); break; case PTY_i16: res.x.i16 = abs(op0.x.i16); break; @@ -1040,7 +1037,7 @@ label_OP_addrofoff: } else { MASSERT(stidx.IsGlobal(), "addrofoff: symbol neither local nor global"); MIRSymbol* var = GlobalTables::GetGsymTable().GetSymbolFromStidx(stidx.Idx()); - switch(var->GetStorageClass()) { + switch (var->GetStorageClass()) { case kScExtern: addr = (uint8 *)(func.info->lmbcMod->FindExtSym(stidx)); break; @@ -1092,9 +1089,9 @@ label_OP_sext: uint8 bOffset = ext->GetBitsOffset(); uint8 bSize = ext->GetBitsSize(); MASSERT(bOffset == 0, "sext unexpected offset"); - uint64 mask = bSize < 64 ? (1ull << bSize) - 1 : ~0ull; + uint64 mask = bSize < k64BitSize ? (1ull << bSize) - 1 : ~0ull; res = EvalExpr(func, expr->Opnd(0)); - res.x.i64 = ((uint64)res.x.i64 >> (bSize - 1) & 1ull) ? res.x.i64 | ~mask : res.x.i64 & mask; + res.x.i64 = (((uint64)res.x.i64 >> (bSize - 1)) & 1ull) ? res.x.i64 | ~mask : res.x.i64 & mask; res.ptyp = expr->ptyp; goto _exit; } @@ -1104,7 +1101,7 @@ label_OP_zext: uint8 bOffset = ext->GetBitsOffset(); uint8 bSize = ext->GetBitsSize(); MASSERT(bOffset == 0, "zext unexpected offset"); - uint64 mask = bSize < 64 ? (1ull << bSize) - 1 : ~0ull; + uint64 mask = bSize < k64BitSize ? (1ull << bSize) - 1 : ~0ull; res = EvalExpr(func, expr->Opnd(0)); res.x.i64 &= mask; res.ptyp = expr->ptyp; @@ -1120,7 +1117,7 @@ label_OP_extractbits: res.x.i64 = (uint64)(res.x.i64 & mask) >> bOffset; if (IsSignedInteger(expr->ptyp)) { mask = (1ull << bSize) - 1; - res.x.i64 = ((uint64)res.x.i64 >> (bSize - 1) & 1ull) ? res.x.i64 | ~mask : res.x.i64 & mask; + res.x.i64 = (((uint64)res.x.i64 >> (bSize - 1)) & 1ull) ? res.x.i64 | ~mask : res.x.i64 & mask; } res.ptyp = expr->ptyp; goto _exit; @@ -1142,8 +1139,7 @@ label_OP_intrinsicop: auto *intrnop = static_cast(expr); MValue op0 = EvalExpr(func, expr->Opnd(0)); res.ptyp = expr->ptyp; - // MASSERT(expr->ptyp == op0.ptyp, "intrinsicop type mismatch %d and %d", expr->ptyp, op0.ptyp); - switch(intrnop->GetIntrinsic()) { + switch (intrnop->GetIntrinsic()) { case INTRN_C_sin: if (expr->ptyp == PTY_f32) { res.x.f32 = sin(op0.x.f32); diff --git a/src/MapleEng/lmbc/src/load_store.cpp b/src/MapleEng/lmbc/src/load_store.cpp index 83a7ed6faf..d5ccd611e2 100644 --- a/src/MapleEng/lmbc/src/load_store.cpp +++ b/src/MapleEng/lmbc/src/load_store.cpp @@ -20,7 +20,7 @@ namespace maple { void mload(uint8* addr, PrimType ptyp, MValue& res, size_t aggSize) { res.ptyp = ptyp; - switch(ptyp) { + switch (ptyp) { case PTY_i8: res.x.i64 = *(int8 *)addr; return; @@ -68,10 +68,10 @@ void mstore(uint8* addr, PrimType ptyp, MValue& val, bool toVarArgStack) { if (!IsPrimitiveInteger(ptyp) || !IsPrimitiveInteger(val.ptyp)) { MASSERT(ptyp == val.ptyp || ptyp == PTY_a64 && val.ptyp == PTY_u64 || - ptyp == PTY_u64 && val.ptyp == PTY_a64, - "mstore type mismatch: %d and %d", ptyp, val.ptyp); + ptyp == PTY_u64 && val.ptyp == PTY_a64, + "mstore type mismatch: %d and %d", ptyp, val.ptyp); } - switch(ptyp) { + switch (ptyp) { case PTY_i8: *(int8 *)addr = val.x.i8; return; @@ -107,15 +107,15 @@ void mstore(uint8* addr, PrimType ptyp, MValue& val, bool toVarArgStack) { return; case PTY_agg: if (toVarArgStack) { - if (val.aggSize > 16) { + if (val.aggSize > maplebe::k16ByteSize) { *(uint8 **)addr = val.x.a64; } else { - memcpy(addr, val.x.a64, val.aggSize); + memcpy_s(addr, val.aggSize, val.x.a64, val.aggSize); } } else { // val holds aggr data (regassign agg of <= 16 bytes to %%retval0) instead of ptr to aggr data MASSERT(val.aggSize <= 16, "mstore agg > 16"); - memcpy(addr, &(val.x.u64), val.aggSize); + memcpy_s(addr, val.aggSize, &(val.x.u64), val.aggSize); } return; default: diff --git a/src/MapleEng/lmbc/src/mfunction.cpp b/src/MapleEng/lmbc/src/mfunction.cpp index 333b7a7bd3..9d274c2b3d 100644 --- a/src/MapleEng/lmbc/src/mfunction.cpp +++ b/src/MapleEng/lmbc/src/mfunction.cpp @@ -19,19 +19,17 @@ namespace maple { -MFunction::MFunction(LmbcFunc *funcInfo, - MFunction *funcCaller, - uint8 *autoVars, - MValue *pregs, - MValue *formalvars) : - info(funcInfo), - caller(funcCaller), - frame(autoVars), - pRegs(pregs), - formalVars(formalvars), - callArgs(nullptr), - aggrArgsBuf(nullptr) -{ +MFunction::MFunction(LmbcFunc *funcInfo, + MFunction *funcCaller, + uint8 *autoVars, + MValue *pregs, + MValue *formalvars) : info(funcInfo), + caller(funcCaller), + frame(autoVars), + pRegs(pregs), + formalVars(formalvars), + callArgs(nullptr), + aggrArgsBuf(nullptr) { numCallArgs = 0; nextStmt = info->mirFunc->GetBody(); fp = (uint8*)frame + info->frameSize; @@ -90,7 +88,7 @@ size_t GetIReadAggrSize(BaseNode* expr) { sz = fdType->GetSize(); (void)fdOffset; } - return ((sz + 7) >> 3) << 3; + return ((sz + maplebe::k8ByteSize-1) >> maplebe::k8BitShift) << maplebe::k8BitShift; } // Get total buffer size needed for all arguments of type PTY_agg in a call. @@ -110,19 +108,18 @@ size_t GetAggCallArgsSize(LmbcFunc *callee, CallNode *call) { // Caller passes arguments to callees using MValues which is a union of Maple // prim types. For PTY_agg, MValue holds ptr to the aggregate data. -// // Memory allocation scenarios for call arguments: -// 1. Non-varidiac callee: -// - Caller alloca array of MValue to pass call operands to callee -// - If any call arg is PTY_agg -// - Caller alloca agg buffer to hold data for all args of type PTY_agg -// - MValues for all args of type PTY_agg points to offsets in agg buffer -// 2. Varidiac callee: -// - Caller alloca array of MValue to pass call operands including va-arg ones to callee -// - If any call arg is PTY_agg -// - Caller alloca agg buffer to hold data for all args (formals+va_args) of type PTY_agg -// - MValues of all args of type PTY_agg points to offsets in agg buffer -// - Caller alloca arg stack per AARCH64 ABI for va-args and copy va-args to this arg stack +// 1. Non-varidiac callee +// - Caller alloca array of MValue to pass call operands to callee +// - If any call arg is PTY_agg +// - Caller alloca agg buffer to hold data for all args of type PTY_agg +// - MValues for all args of type PTY_agg points to offsets in agg buffer +// 2. Varidiac callee +// - Caller alloca array of MValue to pass call operands including va-arg ones to callee +// - If any call arg is PTY_agg +// - Caller alloca agg buffer to hold data for all args (formals+va_args) of type PTY_agg +// - MValues of all args of type PTY_agg points to offsets in agg buffer +// - Caller alloca arg stack per AARCH64 ABI for va-args and copy va-args to this arg stack void MFunction::CallMapleFuncDirect(CallNode *call) { LmbcFunc *callee = info->lmbcMod->LkupLmbcFunc(call->GetPUIdx()); if (!callee->formalsNum) { // ignore args if callee takes no params @@ -131,7 +128,8 @@ void MFunction::CallMapleFuncDirect(CallNode *call) { } // alloca stack space for aggr args before evaluating operands size_t totalAggCallArgsSize = GetAggCallArgsSize(callee, call); - aggrArgsBuf = static_cast(alloca(totalAggCallArgsSize)); // stack alloc for aggr args + uint8 buf[totalAggCallArgsSize]; + aggrArgsBuf = buf; // stack alloc for aggr args for (int i = 0, sz = 0, offset = callee->formalsAggSize; i < call->NumOpnds(); i++) { // a non-aggregate arg if (call->Opnd(i)->ptyp != PTY_agg) { @@ -163,8 +161,9 @@ void MFunction::CallMapleFuncIndirect(IcallNode *icall, LmbcFunc *callInfo) { } // Set up call args - skip over 1st arg, which is addr of func to call - aggrArgsBuf = static_cast(alloca(callInfo->formalsAggSize)); // stack alloc for aggr args - for (int i=0; i < icall->NumOpnds()-1; i++) { + uint8 buf[callInfo->formalsAggSize]; + aggrArgsBuf = buf; + for (int i = 0; i < icall->NumOpnds() - 1; i++) { callArgs[i] = (icall->Opnd(i+1)->ptyp == PTY_agg) ? EvalExpr(*this, icall->Opnd(i+1), callInfo->pos2Parm[i]) : EvalExpr(*this, icall->Opnd(i+1)); @@ -190,21 +189,22 @@ void MFunction::CallMapleFuncIndirect(IcallNode *icall, LmbcFunc *callInfo) { void MFunction::CallVaArgFunc(int numArgs, LmbcFunc *callInfo) { uint32 vArgsSz = 0; for (int i = callInfo->formalsNum; i < numArgs; ++i) { - if (callArgs[i].ptyp != PTY_agg || callArgs[i].aggSize > 16 ) { - vArgsSz += 8; + if (callArgs[i].ptyp != PTY_agg || callArgs[i].aggSize > maplebe::k16ByteSize) { + vArgsSz += maplebe::k8ByteSize; } else { vArgsSz += callArgs[i].aggSize; - } + } } vaArgsSize = vArgsSz; - vaArgs = static_cast(alloca(vaArgsSize)); + uint8 buf[vaArgsSize]; + vaArgs = buf; for (int i = callInfo->formalsNum, offset = 0; i < numArgs; ++i) { mstore(vaArgs + offset, callArgs[i].ptyp, callArgs[i], true); - if (callArgs[i].ptyp != PTY_agg || callArgs[i].aggSize > 16 ) { - offset += 8; + if (callArgs[i].ptyp != PTY_agg || callArgs[i].aggSize > maplebe::k16ByteSize) { + offset += maplebe::k8ByteSize; } else { offset += callArgs[i].aggSize; - } + } } InvokeFunc(callInfo, this); } @@ -218,12 +218,12 @@ void MFunction::CallExtFuncDirect(CallNode* call) { for (int i = formalDefVec.size(); i < call->NumOpnds(); i++) { if (call->Opnd(i)->ptyp == PTY_agg) { - // TODO: Handle type PTY_agg va-args for external calls MASSERT(false, "extern func: va-arg of agg type NYI"); } } // alloca stack space for aggr args before evaluating operands - aggrArgsBuf = static_cast(alloca(faddr.formalsAggSize)); + uint8 buf[faddr.formalsAggSize]; + aggrArgsBuf = buf; for (int i = 0, offset = 0; i < call->NumOpnds(); i++) { // a non-aggregate arg if (call->Opnd(i)->ptyp != PTY_agg) { @@ -239,14 +239,12 @@ void MFunction::CallExtFuncDirect(CallNode* call) { callArgs[i] = EvalExpr(*this, call->Opnd(i), &parmInf); continue; } - // TODO: Handle aggregate var-arg here. See CallMapleFuncDirect } CallWithFFI(func->GetReturnType()->GetPrimType(), fp); } void MFunction::CallExtFuncIndirect(IcallNode *icallproto, void* fp) { - // TODO: handle aggregate args for ext funcs - for (int i=0; i < icallproto->NumOpnds()-1; i++) { + for (int i = 0; i < icallproto->NumOpnds() - 1; i++) { callArgs[i]= EvalExpr(*this, icallproto->Opnd(i+1)); } MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(icallproto->GetRetTyIdx()); @@ -257,7 +255,7 @@ void MFunction::CallExtFuncIndirect(IcallNode *icallproto, void* fp) { void MFunction::CallIntrinsic(IntrinsiccallNode &intrn) { MIRIntrinsicID callId = intrn.GetIntrinsic(); - switch(callId) { + switch (callId) { case INTRN_C_va_start: { MValue addrofAP = EvalExpr(*this, intrn.Opnd(0)); // setup VaList for Aarch64 @@ -274,33 +272,33 @@ void MFunction::CallIntrinsic(IntrinsiccallNode &intrn) { // Maple PrimType to libffi type conversion table static ffi_type ffi_type_table[] = { - ffi_type_void, // kPtyInvalid + ffi_type_void, // kPtyInvalid #define EXPANDFFI1(x) x, #define EXPANDFFI2(x) EXPANDFFI1(x) #define PRIMTYPE(P) EXPANDFFI2(FFITYPE_##P) #define LOAD_ALGO_PRIMARY_TYPE #include "prim_types.def" #undef PRIMTYPE - ffi_type_void // kPtyDerived - }; + ffi_type_void // kPtyDerived +}; // FFI type def for Arm64 VaList struct fields ffi_type *vaListObjAarch64 [] = { - ffi_type_table + PTY_ptr, - ffi_type_table + PTY_ptr, - ffi_type_table + PTY_ptr, - ffi_type_table + PTY_i32, - ffi_type_table + PTY_i32, - nullptr + ffi_type_table + PTY_ptr, + ffi_type_table + PTY_ptr, + ffi_type_table + PTY_ptr, + ffi_type_table + PTY_i32, + ffi_type_table + PTY_i32, + nullptr }; // FFI type def for X86_64 VaList struct fields ffi_type *vaListObjX86_64 [] = { - ffi_type_table + PTY_u32, - ffi_type_table + PTY_u32, - ffi_type_table + PTY_ptr, - ffi_type_table + PTY_ptr, - nullptr + ffi_type_table + PTY_u32, + ffi_type_table + PTY_u32, + ffi_type_table + PTY_ptr, + ffi_type_table + PTY_ptr, + nullptr }; // currently only support ARM64 va_list @@ -321,7 +319,7 @@ void MFunction::CallWithFFI(PrimType ret_ptyp, ffi_fp_t fp) { void* args[numCallArgs]; // gather args and arg types - for (int i=0; i < numCallArgs; ++i) { + for (int i = 0; i < numCallArgs; ++i) { args[i] = &callArgs[i].x; if (callArgs[i].ptyp == PTY_agg) { arg_types[i] = &vaList_ffi_type; @@ -331,7 +329,7 @@ void MFunction::CallWithFFI(PrimType ret_ptyp, ffi_fp_t fp) { } ffi_status status = ffi_prep_cif(&cif, FFI_DEFAULT_ABI, numCallArgs, &ffi_ret_type, arg_types); - if(status == FFI_OK) { + if (status == FFI_OK) { ffi_call(&cif, fp, &retVal0.x, args); retVal0.ptyp = ret_ptyp; } else { diff --git a/src/MapleEng/lmbc/src/mplsh.cpp b/src/MapleEng/lmbc/src/mplsh.cpp index 62fccac37b..9cbf9812dc 100644 --- a/src/MapleEng/lmbc/src/mplsh.cpp +++ b/src/MapleEng/lmbc/src/mplsh.cpp @@ -56,8 +56,7 @@ void *LmbcMod::FindExtSym(StIdx stidx) { return(var); } -maple::MIRModule* -LmbcMod::Import(std::string path) { +maple::MIRModule *LmbcMod::Import(std::string path) { maple::MIRModule* mod = new maple::MIRModule(path.c_str()); mod->SetSrcLang(kSrcLangC); std::string::size_type lastdot = mod->GetFileName().find_last_of("."); @@ -79,47 +78,45 @@ LmbcMod::Import(std::string path) { return mod; } -// C runtime libs to preload -// - add to list as needed or change to read list dynamically at runtime +// C runtime libs to preload. +// Add to list as needed or change to read list dynamically at runtime. std::vector preLoadLibs = { - LIBC_SO, - LIBM_SO + LIBC_SO, + LIBM_SO }; void LmbcMod::LoadDefLibs() { - for (auto it : preLoadLibs) { + for (auto it : preLoadLibs) { void *handle = dlopen(it.c_str(), RTLD_NOW | RTLD_GLOBAL | RTLD_NODELETE); MASSERT(handle, "dlopen %s failed", it.c_str()); libHandles.push_back(handle); } } -LmbcMod::LmbcMod(char* path) : lmbcPath(path) { +LmbcMod::LmbcMod(std::string path) : lmbcPath(path) { LoadDefLibs(); mirMod = Import(path); // In Lmbc GlobalMemSize is the mem segment size for un-init - // PU static variables, and is referenced through %%GP register. + // PU static variables, and is referenced through %%GP register. unInitPUStaticsSize = mirMod->GetGlobalMemSize(); } -int -RunLmbc(int argc, char** argv) { +int RunLmbc(int argc, char** argv) { int rc = 1; const int skipArgsNum = 1; LmbcMod* mod = new LmbcMod(argv[skipArgsNum]); - ASSERT(mod, "Create Lmbc module failed"); - ASSERT(mod->mirMod, "Import Lmbc module failed"); + MASSERT(mod, "Create Lmbc module failed"); + MASSERT(mod->mirMod, "Import Lmbc module failed"); mod->InitModule(); if (mod->mainFn) { - rc = __engineShim(mod->mainFn, argc-skipArgsNum, argv+skipArgsNum); + rc = MplEngShim(mod->mainFn, argc-skipArgsNum, argv+skipArgsNum); } return rc; } } // namespace maple -int -main(int argc, char **argv) { +int main(int argc, char **argv) { if (argc == 1) { std::string path(argv[0]); (void)MIR_PRINTF("usage: %s .lmbc\n", path.substr(path.find_last_of("/\\") + 1).c_str()); -- Gitee From 02e3b6c150e7fccaa40fbae11ff008e076279648 Mon Sep 17 00:00:00 2001 From: eching Date: Sun, 4 Dec 2022 17:46:33 -0800 Subject: [PATCH 4/5] Added Maple Engine for Lmbc readme and script for compiling C app to Lmbc. --- src/MapleEng/Readme.md | 45 +++++++++++++++++++++++++ src/MapleEng/lmbc/test/c2lmbc.sh | 58 ++++++++++++++++++++++++++++++++ 2 files changed, 103 insertions(+) create mode 100644 src/MapleEng/Readme.md create mode 100755 src/MapleEng/lmbc/test/c2lmbc.sh diff --git a/src/MapleEng/Readme.md b/src/MapleEng/Readme.md new file mode 100644 index 0000000000..5604ff83b7 --- /dev/null +++ b/src/MapleEng/Readme.md @@ -0,0 +1,45 @@ +``` +# +# Copyright (C) [2022] Futurewei Technologies, Inc. All rights reserved. +# +# OpenArkCompiler is licensed underthe Mulan Permissive Software License v2. +# You can use this software according to the terms and conditions of the MulanPSL - 2.0. +# You may obtain a copy of MulanPSL - 2.0 at: +# +# https://opensource.org/licenses/MulanPSL-2.0 +# +# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR +# FIT FOR A PARTICULAR PURPOSE. +# See the MulanPSL - 2.0 for more details. +# +``` +## Maple Engine for Lmbc + Maple Engine for Lmbc is an interpreter that executes Lmbc files (.lmbc) that the + OpenArkCompiler generates. C source code is first parsed by C to Maple frontends, which + can be either hir2mpl or clang2mpl, and the output is then compiled by OpernArkCompiler + into .lmbc (lowered Maple bytecode format) format to be executed by Maple Engine for Lmbc. + +## Build OpernArkCompiler and engine + The following build example assumes OpenArkCompiler root directory at ~/OpenArkCompiler: +``` + cd ~/OpenArkCompiler + source build/envsetup.sh arm release + make + make clang2mpl + make mplsh_lmbc +``` +## Build and run a C app + The following example compiles a C demo program at ~/OpenArkCompiler/test/c_demo/ to lmbc + and runs it with Maple Engine for Lmbc. +``` + cd $MAPLE_ROOT/test/c_demo + $MAPLE_ROOT/src/MapleEng/lmbc/test/c2lmbc.sh printHuawei.c + $MAPLE_EXECUTE_BIN/mplsh-lmbc printHuawei.lmbc +``` +## Running ctorture with Maple Engine for Lmbc +``` + git clone https://gitee.com/hu-_-wen/ctorture + cd ctorture + ./mpleng.sh mpleng.list +``` diff --git a/src/MapleEng/lmbc/test/c2lmbc.sh b/src/MapleEng/lmbc/test/c2lmbc.sh new file mode 100755 index 0000000000..5c0e8d9ffe --- /dev/null +++ b/src/MapleEng/lmbc/test/c2lmbc.sh @@ -0,0 +1,58 @@ +#!/bin/bash +# Copyright (C) [2022] Futurewei Technologies, Inc. All rights reverved. +# +# Licensed under the Mulan Permissive Software License v2 +# You can use this software according to the terms and conditions of the MulanPSL - 2.0. +# You may obtain a copy of MulanPSL - 2.0 at: +# +# https://opensource.org/licenses/MulanPSL-2.0 +# +# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR +# FIT FOR A PARTICULAR PURPOSE. +# See the MulanPSL - 2.0 for more details. +# +set -x +[[ -z "${MAPLE_ROOT}" ]] && { echo "Please source OpenArkCompiler environment"; exit 1; } + +if [ ! $# -le 2 ] || [ $# -eq 0 ]; then + echo "usage: ./c2lmbc.sh .c [clang2mpl|hir2mpl]" + exit +fi + +if [ $# -le 1 ]; then + FE=clang2mpl +else + FE=$2 +fi + +# hir2mpl flags +CLANGBIN=$MAPLE_ROOT/output/tools/bin +LINARO=$MAPLE_ROOT/output/tools/gcc-linaro-7.5.0 +ISYSTEM_FLAGS="-isystem $MAPLE_ROOT/output/aarch64-clang-release/lib/include -isystem $LINARO/aarch64-linux-gnu/libc/usr/include -isystem $LINARO/lib/gcc/aarch64-linux-gnu/7.5.0/include" +CLANGFE_FLAGS="-emit-ast --target=aarch64 -U __SIZEOF_INT128__ $ISYSTEM_FLAGS" +CLANGFE_FLAGS="$CLANGFE_FLAGS -o ${file%.c}.ast" +# clang2mpl flags +FE_FLAG="--ascii --simple-short-circuit --improved-issimple" +CLANG_FLAGS="--target=aarch64-linux-elf -Wno-return-type -U__SIZEOF_INT128__ -O3 -Wno-implicit -save-temps -fno-builtin-printf -fno-common -falign-functions=4" +# executables +CLANG=$CLANGBIN/clang +HIR2MPL=$MAPLE_EXECUTE_BIN/hir2mpl +CLANG2MPL=$MAPLE_EXECUTE_BIN/clang2mpl +MAPLE=$MAPLE_EXECUTE_BIN/maple +IRBUILD=$MAPLE_EXECUTE_BIN/irbuild +MPLSH=$MAPLE_EXECUTE_BIN/mplsh-lmbc + +file=$(basename -- "$1") +file="${file%.*}" + +if [[ $FE == "hir2mpl" ]]; then + $CLANG $CLANGFE_FLAGS -o ${file%.c}.ast $file.c || exit 1 + $HIR2MPL ${file%.c}.ast -enable-variable-array -o ${file%.c}.mpl || exit 1 +else + $CLANG2MPL $FE_FLAG $file.c -- $CLANG_FLAGS || exit 1 +fi + +$MAPLE --run=me --option="-O2 --no-lfo --no-mergestmts --skip-phases=slp" --genmempl --genlmbc $file.mpl +$IRBUILD $file.lmbc +mv comb.me.mpl $file.me.mpl -- Gitee From 98bd81e14474e245aee397cd1a395adcd466dcd7 Mon Sep 17 00:00:00 2001 From: eching Date: Fri, 16 Dec 2022 08:04:57 -0800 Subject: [PATCH 5/5] Removed files used by vim editor only. --- src/MapleEng/cscope.in.out | Bin 90112 -> 0 bytes src/MapleEng/cscope.out | 19956 ----------------------------------- src/MapleEng/cscope.po.out | Bin 178872 -> 0 bytes src/MapleEng/tags | 315 - 4 files changed, 20271 deletions(-) delete mode 100644 src/MapleEng/cscope.in.out delete mode 100644 src/MapleEng/cscope.out delete mode 100644 src/MapleEng/cscope.po.out delete mode 100644 src/MapleEng/tags diff --git a/src/MapleEng/cscope.in.out b/src/MapleEng/cscope.in.out deleted file mode 100644 index b71595a05141c28a87fbce64be2ccee03b066bc5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 90112 zcmeHw3v{E~Ro=^9G=PxL`Z{p8)!g0*207qR9JvXTM(2|w_UJAySflis8}r^Xlc67*?a&0 ze~#=)Sc|Zr{k85L`}_7e`<%1S^FR9c_RECvi4qRJO#O0`#XTCYnA+!q(4mMarwcUJ|*Y!eTKfl4Zo&;_r|LgX8oNTsQLila_z!##0J&`H>r6qT%2T-9EyQ_pZN1OW(bY_2>3&U&s91p4N4&ALIJ>C8 z&cJcf&-Dpk)7uxghW*9u7nJ`MRDSQO-XA+x_4c-}>iyj$Ioq#Ja@KEM#s0WQ`j@U^ z``Df_lCyonBxf8ju(*o-$MXIa9d`}9eMPr_%aCtg(Z{oO1?Ly*U%I0AN7Rsq4D2`X z@Uou2XW*U7dUv3<4-dBea~ z1jiqzk4JF6G7cMZzkvsr^!!}|w+-Aduw~%5fy0+@ymNj01|Cl8?d?tK_TQP*?bSAL z)4+8@Uv5$#AMr_Cued%D0|yQ4Gw|R!J^!wOI|kk|aKpeg11Aj}GjQ0z0RxNYbo=!u z^!j!ubosV{TNApy8WXr*vb}1Cd}%`O-`E7Mx12saf&ItpRbT@9o7X2Xf$JUP!9`rp zIDhXV>hsb1)+PDt33o`&>tpL8?thHy7qNbfEy~a9carjRdC`jjwf-{>T}1ow`t84{ zw?|NZZeM>~AFo})T;BFL+LznAHLlyYF^>Ji^{pBDl7u;bY+Ro|;cL)Rv3(*JaJ;d70vGiC zLQr{}zkeR<&$xRY#|!80oY(EwK9BW(it5umkNwBxZ&G^3)_HwAEuGif8##~XMJ_*Z z9_KfgFV5@z(?6$=m#%@^=k)V&^PE0jH_u^v*xtEwXdfF4u!i1ab` z6XyKGvwC^`v-)`Gp2hy<^XfLGe+!kjMd`VIjk9`x)XwVmOBy(4;E16wNcvd6&%lE- z`ux~EgXMGjjv?PVqxVO{z_l}a|0U00{dv8OpV80f(KGttLJYT>1)sG<1a~a9*?nS_42}mSsr*6`0N8T%jL^ynYz^LR23v&v#0S96xPE~X`gjzSp3Cna*Xz?gj`?{%?;J;a@&3AX z+^8?5e*@R|IF`rt%N^Ip>ym+E1`Z!bd$BzOq>r(W(r2i=!7;24x4(A`?a%e^9@E#$ z4#~NGTgUYJHjZKYSzbSe?PvYgu~%sGBT4$WesM#8)JPvXhU16z2dI9GeaD_u`s38T z;WIDO%IiOa?c?&g&*4^6V9UTu&*=4w8uHLH`hMnrMqgitNA>#jj_UFq z1Gf#_H1gLCoHNqL4IDYD*DrWfZ;$V&ZjV7w$GZmZ7y+!zG!VSW2CR{hLMfecOlY~zZjvMmm5nK;AeVF9@JQ5_#&qsd3CrO_m93(tA zjQS1`?j6SY$?fYN#`S`q2euF6eBkwY>oB&T*Q+LBp5L3KkLyz-%<|-6eLTbt>-LWr z^$8ksaTuR3xIXQ#+VuaaV;X^oHc)blA z($9y&s89c(K0mq!?i@76+d=G)*HC}84q|`3j&OtITz~7Je*RcGsM{lUP`5|u;M>%C z&HJnWpl(lb5XTGa?;k)pQIAyu9&t_V^4F~)cEmFiMtGBG(JnWV-~rON4?5`;A#5;C5;KR0!6 z`tJ1H^NTT{`=6Ftgm_?OQq}D9h0=1Wpvufwr!twcuvorOEzf3ZB1(91!^+-%RGlkj zu$>{Bhg389Y#}oRc8I6)Wz;|XXZUk*LuwIXhwwsmO)1&>QIs!KQNH~ng!3<{0$Pl- z)phHI)KqyD<(m$_P)^@X6^XYTes;|&m8)4i2`xGNt$bBg^meIOsrs2ur;70h3)NIL zpOz);{4mu6_bm*o@6O+vx~mdyGe7@e?#_dFWRq~b zoL`e;M*INkiPdHUxlLNi^eS{x?bX;0c4MP!e^N^(VJ(Ou>39L;Dy;QomOp@yx-&_dD$8<{D73gy0rLi zOh1vA%arJi@GFYnG5PU4)Ix~%2rpYBMAPKQCZ(A~-Qd@Y4~wPu6-CbEWn%cmO^XAY4CDR%TL|pNl(t?sbAs-KU;j1D!`@?G59;# za{dwQX+h@i&)!>ncYJ#AmDEoBA$AGRTSc|AEaCDm=B>2ax}%Ka30RSF3z1nv4iCKp zc6D$;Zg)f4@8;u)yxfp>9Gra-(zhL)PC>ut9K2kvme*+;6>&Ge0y`xMA}+pAN1{yyKz}IX8y!7I)(@ShpC@-cQ8u&(1B*V7-Daer9Tsc1ze- zsJ-`Q@5}A+9eL~~v90qWPUiwhx3ICc3?mvp0d-1&b^{M)O;^<>3;W|T%8^$`97Tj2 zK3*+TVvr0|c6#?QM>HM&?sCD=6L)y9VmV)|c2KUFTLHn_k|7r(m7 zrNOv&@o*k4t&phw9@3+=2JE;*{M5q2^!-JVd?#ZVSofzB_gau_sf zB6AW`KJ#Gi_TudP9Lc+M0d{YS^iMCv?@uo*aEg{G$9l1LVUhf9DV4dCUAdcI#)%ek z@o?C#4Ck>O@-PYmL`3koCnT08sLzu8;kw0~WPHraMT5_nzz<@SUh*($J8ld|zZ&ED zsXK|OyU)+d*>rE}{<{-$m4oLVmfyQ|J0WMRoUHH(Ge3LlUSeTh1RQ)@VnKMe0;@`@ zAo|Z^J!UIknk|=L-q`qE+0;WJHf;<~MJX@@CKr~?FTkNYn}JD?UCoxolFiE#Z@vnP zv}-jIB04HxfO@28ITN8#IjdGB4{1G_t+=03;5o(S@fogdqF!2A;V#<+o6FCv_VfYku$!NW+c~zFFFqk+}sH0CUXe6w=dDnvGbMvkRZR;lM zSy8_<7^{b8XcuGk^bScFoBecy^x#p#9uJnz+aqO(`MJgWbBWuDN2x@mnkrYL24BhJ zei1TwxPnPcK#_ifUs=JKI=oKxA^qvWy9g+R%r8^^n3>8Nq(kWg2#7Qm+O~o{c7u6dd`LO zqgOv6w;b~OT{yKm58aeiC(EJiMEF2?c)n3J;o8GE-$O2?JA3f6)$Cf^%^|$LHot<Xxkv|>LD)_QJm0Rty6ooFO$(-LxOl$$QKnXvfag?~ zJhlMy-of#8uu}JeT^?WQs7`8)@+x8EyeoZn6^cR})cHBsdez6L^I~ugd9WWY;~8w@ zu8WsfMKK4<=K->g5Zh<%{LWwlYIw%x=j5GO=UE4**0Lh(VC`rcaCmj?XO94fe}{a8 z?4GvusWW}-l#O8?nyiS^OcP?dtO>De&n(ivh+?k`IP)# zc1_I_hvyTk(wQ6Od(SJ$7kiUmv_ z4xw;h65V5t{(QMoZMktFJ16@{ewN%k+&WjNz>vZ7fbbhU*RS`Ct31#%o52aOWAb+} zUEAT|fJG0NAj-M;LKd$)WsbPX)4&Nj{GI$7tRoIqJ2}`wRitwi%Y}KsyduIT4`*8W z2{`<%Qf5PJ2Nf;XS2#wnmB4;FZ_kn5)9&<0%K>mJRmsZE-f`seqF=OKxBw^OpbM|A z(k(a}8&nUD*!p3}--g4Ue9CYVbVx1-7d#$_h6~H`mkwk88MsuErfeP}tTrkuTW72W z8w@HGiwN_urb5TTUW0~@OU%Y9_3Z~rpb>@Dnr*td1cU?!Sj80+~ien!TpHI(*;z} zs}p5xf4TfRLxlI2s}p5le>tAa_Lr-ZSD#+g<#FX|AKdc6J>CBDF?mGVevDk^ zZ;i-tMcOoY{vN?Hc$~ekUYk6PpQy>x_z9UjjUWFAkN5w>x60ZI!FJ&97kUQI-!JT# zJeAuvdA=t%c>aE&KFU|*S1P$tUJc6lD6hU>i0r}3?-zojyjrk)qr7U`;4Qixpq^^M z+8yQ9_Y0j-UVXo?W$fjC%YvLp1)s+nLOzUn>_VPz~K4&1!3^~{X+lE zx*fWNVec%b($!@+OQ>6#P3Gb2is_nFj=vuB$?M1mbNA=t2*u!a4!;0jCf{B}QOCvK zpT1|OZ@Bn-Q%mpwj-r^0zde61J|CZ(pSe3fwMgZN5jhGrU+a{AiqS)O#mul`471o*m-h z9Se1I4KSAD2W)I#jk$T4G0gXUs22{48NOSPOxNbutW-J6$wgG>)dhu2KYW$^SBTps zl^(CA0JoXXWz!EI6yZ3Y;p-`tKIfLt6tXq-qzext%Wz2wp9st0 z^+~5(lDo9R_eG98?c57G=i1zee5#ni*G=Gw$VnIBbW;n{2^foTxKjm(UykM9l3$A1 zy$77lKh$pC`cF{$d@)ttxMvmcZ5YvI9?tVpjYW8>An(OtKG+xz^Y&8#+@HJ*^~p1M zX{BUe5a%>reMP8h7uWa|=p?Lk#NqiO8`=-&8dNVpzimEAZ848utME0xn7Vs+{`OSj z-t;|K9Vm_aM~lj#=GdbCOXK#{~O3&AjS*JtY*){pfyDP95NI>i%UebzO! z7d(9^;=i5KNu$|o&lE^BRQ8BzN)`(AEflOJqtgT&-%nw z{e9HI75#nI9%0tsy@KuK@zuG4`FT9GDLs#;7RkB1hJov(kK1FBob8jmqT4%e)F(>m zxqe~N$N7Vl|1|fn(Z1njoR6Hoe_6N3u7P(9ynR`pk1f(i*D>%tguY(YFJpVSy}8TS zzg+&(WwbxbW0aol7rBh%h1(k<{fq-7{{*$yM{>?Tj9~ltJlT(6{Z3K(-3Zpt?q7<> z!1=c#XfMW1%FpZ9Cgtb(R3ka3&yoB~sJtaZ9;5oPJt8D$9D)Oc+|O8FAcFSi_WKC) z{2g9G`6Vi^f9VO8pY6MQNnd|7FD~ixyFZEhHMgg0#CzB_aLd4(le#{OFt4XeM*66MLk9L!es158 z;xjzQ_J0oh&#o`UYvA;q=diz6-hK|pBgD1 zxP6i5bbqhlbNK!|=l4;5Ue5*-XfIw*cPV}Zr|(dFhc{AtwlYn~FM;;r^*2E2xjf$l+WR=wXK+#9Pj)Zr^LdBjIk3KMiWk9ni!j@x zN$Gj~ZeGOlzLv_fjPjC{pW7d&{M_GBLmnnM&xhbey}!jp^k3or?NfXS*0(dR`?s_y z{sWiar1W;-D|DJ)n zgzr-N&KQmty7m(7F?~EV$FRS7yl+x|wpVQo`-}7E#?Zdp{w2cPo*3!p{1L)*4Jkrn z`u-IlIbFjDAIaI?!!VZ5`uY@)g8O?ntgi<<6mNp-vrXw)-xj53`!>SZejX3?Ft(4& z%Tc@vo-a#=z8LA_@*-xv>R-V1n)7!r=<9F$0{R1TeVde? zah>8*aCtc+f1J{@Jt8D$dxR*y2AA)r_!*pjXvClBok#m|`W=!pZX4-a6#s(tH4I!k zuiGPO;JA@KdLH|W^@XTD+t_+uAjy80?U(U zb^o>KSv{Ue@T~4XFO2kkiYLMPx)iU1@ixW3VBDg36O8L;a6B_k8aR4J_va6uLH{{U zKYaF(IF=hLpWZzzP*rMekY{&_m&~wG~`wY=O^o1GSWv4917{{ znUCUGaQ^-&z5Jb1`gqtfaO0Fdek~(^?9@SRJcKFU1eX^$rPpV8QZK(}#B1mn@giCV z-lTXBtlu*7FP+rOi&FduP9HSlPxy@VgA;mtyC?Mdx=ryKSYM0cM=-9R(8o*igx=oR z3B7({iXXxG{YL&F#e-n^?s2`pwvX%cvw2)E-#V_3?`e20)xp5I76Jf_#b zXW-5;eg3tM>Fuu@@}z-d$MpFVI;O8jK0{yc8GZciP<#Y#Uz_3~Fm6&j2FA5#bp7#X zj%edK^vq!m509SE@a|FF{_UerYx2fXU4QPVu0LvE|Iw3L{y|Xh&z+#Y{)c9KrJnrwJ*QF^(PH^?6BTn;lsLpe24Y%+B;;-5Ay$K{cQs`4(a1LcSs*^aU*?%;sdb0 z;30iH`Y3(@%LfPb^>vs0@mbzEsJEweQ191H&sm)tN4|jbWu-!LFtzw;m4mT9arPtC*71XMCs(asU z+B;W}kMiviKC3+1>!W-@eiIxY;ZrMF&=WNIatZug;rqu=8ReGIk+3tuXJuVQV-FtQ z&IbEu%hh73C|^pE{{P9xr32@X@ZNGE_TVe)%X8g-YSuGbDHR@NALYx{^;AKA(JIX) zTKl9^9x*GabXKN>7X+-)bZgT8KRU{*00jO$cpP-9Ske3BNd3}z%gVM#c=;CkDg+=v z|Npuvw@QVLwNly2<r= zT6@dO*+Le+*%!jvTb@e4xDGEvOedlv^3+BKEv4Qh@{h`E6Hu?-cbfH5OM_^ed;w+w z`2W{O_)1Q`2ofLRizT@}1V{M1nur5>0l{9c$g!$3!h@p?=xL1dGFV47Y4Y!dmuEJn z6X8)lostW=$%FM$8E~RrSyAy7y5C{gL&-r3V@G~kd&*ZVNTKA`o^tRP9O2n}pk%=g zlT(WjXz)KKoh+dD?PmR0kDOJkiDwtAvtLkpc;Dr*=~&-%BL3KP@P6JN@@!cyPDnllxGSKhQ{nIJ`fB&9xM@8?WX1!!N*+P4S$2=7p(e-`gYQ})0dVC)_ z&xhbXay4V7VW0kpSuZTVGs>$sl^Q0$T2=o4$q^nb2>$=!Q69EkFz5&`PZO|Cf7qzc zY8uXY?(>pLCR&e42j_`*Sfg@HNpwFs`TzS(`ARt}U0-_*qkb!}$E4CZ*e8?+M0-SD zD9Hu4KElI`WQD>;e3X~oHyPd`7P4F#2ZiOMjG7_gjtnDS5fn8sSUt%jFAM zYm^5AS|U2a=O0P`fBy*YyZ|cw|9jtJmYm0 zntb|^>d3)28}&%9!|`Ozy(TOF|IYsD)Ocu&$Sru)eM2Po;MIm3Q`tm#L{2Zjl3eU5 zhrN7kQu+UPzsan>%nx$%|8I@T*VeMdsx`ucpAY!|NB7{R|G$3^Ui$y{zR@fn4rax5 z*>)8lpgkhTb54DPmoM5{(vw{oCO#t1=H&xYaDwdC{QDyE)Phh%N)?t3CKMln?p~Rj``1zkF4$;89b) zTvO*w{|JxKYkJ>c)MFVAD-gY=J;K9z7X1I~BfNZpx0H&H^3Dsqu&@P3Z%FO%*;~E}PbD%+-AwnN81+w8 z)};S`Yn0EGfwx9@c?WSj5gp;x3(N`s2+uDplmGwMo8>FHdaRJuZ|^O)pR4Qp$Sr*A z7V*91BDe=H%Nu;1S)b)fs<4>qjPel7a4OR<`3Eve7eqKR`PzzKY6Sknt9(<(h+K=t7aSF`)Zd>5`#5JOZP9SZeIPpY=id=Pj}A#xvGh%fTv& z8-g;Q#MuK3?4*pP&2k=4JSm zRIj_m^mMr_b{MO^g^r*;uABVWq>|(`o+GEMEygt-JS@O}A6mZHd5OwXxt$0oNsV_! zKskr~AvC!t8v4M9J&SH?)zyjhNY?JaJ(Y=p&wVbGeS;e-4 z;iz26Y%;bI5@%ujs$j7e^TqWGh5Yh4>G@PSpG$?9S3wt)Bm1=U|8KsN%0XTX;%=O% zssJzNb7EKHVcsn+7vxE`VeoRMQ%DD8xbWU`(VcgfGv)Fzswn?|Kg%iRY;O+J%MA_! z!-=>H%U}yW7lv)2ymik>4{=*dNf*8?ZwTb&9()2WURtFerF=NNMVB%7?LUCS?eHea zWv~gj+={y}tRiCTh9g(22l@XeUA*n2Cd+s6vOe2aI6pK>x?8EIUpW7{dGPycUZ!*w z#OkQ7h`NnwJdpo?&gP|dxQDw$`BdD2M{uKy{{Ov6H}3>GXzDzKGlX@e0_XS<9`$ce zXnJ5FTzE-JtWh2s2hZ;p-RV)cOusem=AF1PNsWiCmi+Kz8c#twKu>7Q)|1Xo$;b~< zJFE*~;^hPZ9JH}qqo)&t3oKX3h3_2UH4MqPdzP@A{16ABX5(Te0p9{tp&Mj;gqVw$ zn)+ub-%36q??yR*!r-LAuS2)O-E3zs9&Wz3_Tpi!Y3#*=Pj$`Y)y#(V^Mp|@1hSIl zM)%^O+|XV;l)`V_$lqd2A$=?x z&#PrQYGb8F^p27~`7j3gw+}IfVFyWa2N^F{RzMziVX48#Se>S0niXW`NRP99QzVgO$AXR+PhaSQbv~nUI5FvcbwqafEwsvD3-p3LitmIRi5AK2?PyN*nmg{N6g{8)wzec^;8ip}x+c;m9^Q+0Y3YX>Zi8Hn; zdDx)D;IAluaWzrN<=4*V#ud@A`HZS(k}(Cv=?^I%U}Y%s!;k$1@zS$gb{OHz`r6vY z#py)%&rz;06xDL$F^DhBxKhOdvQdPm-mHi^yj*}1eg`Xskv}87h04a-1dIb4m#l0N z)~f-_SJFkfUo+0bLj*))Z7_z%tSWr3mSim3A+r*OYc+^3P%Ur&cho2G#qsHczN1Gx!t2>*bjY^h=U4?4uB+OvD_VfpdunxNsi6N9g}I%3rBwr2ZCTx=w5V zG07!{HxgD#h0OU}Ml{_#%uu@C6?HccH4M73+L%$_?jO1Ix;Ey9!^^Mfg#QmYo$@oE z@AV0P)*4KW|!4NlKw)US0L%2dYOqc#6Vl^1x*Vex$EU$UwIfI|)Y+kWqi7_-v zCJVVR4q){E@BI$xgFjl3c~?GD&EX$j*!_3R7ZY$pS%p56+pXw0JUD$l=tO=HS~f%*Eh0Sibs5`u`^#tfo=)*KN7FY1#QVHdcF4h5Y|>4iC2uR$=h3 zDV@9?lA#J{KlA@97oWn$NT&H&HxDOn6;%M@7HE8Rrt@o@4vs#lir8{vIP-URNDgt` zW{Y`Rlwdsns>93ib!&YE%(jpZ|BB5o%J)n9zieY=`M@vPSS_2aUnC4YMZt;H4O>*> zr{aD$h6lIY&r!Z*^#AwS7_OI6&<~#>`NI10;>OBKgE7SyN&XDV6ZDQ$^rr|XN-DB= zB3-P?FBttcpD(6evf)p1`fPC(o*Wlo?~wlgZJX!6vjW>ZByEoH5Xlqx`Y2zJe2#cB zGZqH_;%*4@|0a4SJVBB!VCgT(c-!#jZ{5`2FRS0w-)~#GslSgGzNx?8CvG0o^!IM) z@8fRY(BBVik^eo{r+!0!|8MDr{(fBahWCj6ZeZZ<0Sg+k5jm`lqn|8ez_#Bma8r6F&m zML10P*}pDm=<{7idvN(f@_#==`Fq#!eNnD&m;Bp9B=3-a{p$#~$-kZL(WLxr&-yhS zKU`jpNgujGv{fa(ba#TLsCw@iuUyNSS z{Q=pZ{tD>}l7Bth!*BT83-Yh$_7BMaocp^+{_<@9&gG}n`oZ>WlmGf0mDi&5+XVqR)?=h&~^-$zPq@ zyG8!*jM;yl+p`G)gxu?Ojq=lRLFCB4o$a|q{_;HEVz3p13`J%Fp_S zm-O+{yQIJW-MxhKmmbGNhy35UJ#E8(zD4raQ-3xHbN%Y%@6P!x%Fj4S{`ZXIRQ>_d z7rBJvm*pYK&*LR<3CA#B=$e&?@eO+IDK~#^Rqu^XA;-@H&OXplluH=kUq9= zeNyjFi!jTRle)idob>Z}jgp+}6C(XFDnCH!S?;6y^Zqg<|9GBXee#dz^{Pw$?cDwj z`RB*EeI#dlHlM@wirc?Q{`sumqV!y!B$fY0(ibB+w?9Jl;qeKh>aLCWtVIoEeU z{_|Y^?u33`*dc#;uFp34*YkMag8M~xJc;In-v4#-r|0|@`O|axNy2a8_E9_lu1|!@ z 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 - -19  - ~"lmbc_g.h -" - -21 -mea - - gm - { - -23 "C" -t64_t - -__geShim -( -LmbcFunc -*, ...); - - @lmbc/include/lmbc_eng.h - -1 #ide -LMBC_ENG_H_ - - -2  - #LMBC_ENG_H_ - - - ) - -4  - ~ - -5  - ~ - -6  - ~ - -7  - ~ - -8  - ~"m_rr.h -" - -9  - ~"b_mt.h -" - -10  - ~"code_fo.h -" - -11  - ~"m_funi.h -" - -12  - ~"cڡtfd.h -" - -13  - ~"m_ty.h -" - -14  - ~"mvue.h -" - -15  - ~"glob_bs.h -" - -16  - ~"mfuni.h -" - -18 -mea - - gm - { - -19 -ass - - gMFuni -; - -20 -usg - - gLabM - = -d -:: -unded_m -< -LabIdx -, - gStmtNode -*>; - -23 -usg - - gVInf - =  -PmInf -; - -24  - sPmInf - { - -25 -PrimTy - - gyp -; - -26 -size_t - - gsize -; - -27 -bo - - gisPg -; - -28 -bo - - gisVg -; - -29 -t32 - - geIdx -; - -34 -MIRSymb - * - gsym -; - -35 -PUIdx - - gpuIdx -; - -36 -PmInf -( -PrimTy - -ty -, -size_t - -sz -, -bo - -ig -, -t32_t - -ageIdx -) - -37 : -yp -( -ty -), -size -( -sz -), -isPg -( -ig -), -eIdx -( -ageIdx -) {} - -38 -PmInf -( -PrimTy - -ty -, -size_t - -sz -, -bo - -ig -, -t32_t - -ageIdx -, -MIRSymb - * -psym -) - -39 : -yp -( -ty -), -size -( -sz -), -isPg -( -ig -), -eIdx -( -ageIdx -), -sym -( -psym -) {} - -40 -PmInf -( -PrimTy - -ty -, -size_t - -sz -, -bo - -ig -, -t32_t - -ageIdx -, -MIRSymb - * -psym -, -PUIdx - -puidx -) - -41 : -yp -( -ty -), -size -( -sz -), -isPg -( -ig -), -eIdx -( -ageIdx -), -sym -( -psym -), -puIdx -( -puidx -) {} - -44 -ass - - gLmbcMod -; - -45 as - cLmbcFunc - { - -46 - gpublic -: - -47 -LmbcMod - * -lmbcMod -; - -48 -MIRFuni - * - gmFunc -; - -49 -ut32 - - gtSize -; - -50 -ut32 - - gameSize -; - -51 -ut16 - - gfmsNum -; - -52 -ut32 - - gfmsNumVs -; - -53 -ut32 - - gfmsAggSize -; - -54 -ut32 - - gfmsSize -; - -55 -LabM - - gbM -; - -56 -size_t - - gnumPgs -; - -57 -bo - - gisVArgs -; - -58 - gd -:: -ve -< -PmInf -*> -pos2Pm -; - -59 - gd -:: -unded_m -< -t32 -, - gPmInf -*> - gidx2Pm -; - -60  -SnFuncFms -(); - -61  -SnLabs -( -StmtNode -* -mt -); - -62  -SnPUStic -(); - -65 -usg - - gFuncM - = -d -:: -unded_m -< -PUIdx -, - gLmbcFunc -*>; - -67 as - cFuncAddr - { - -68 - gpublic -: - -70 -LmbcFunc - * -lmbcFunc -; - -71 * - gtiveFunc -; - -72 } - gfuncP -; - -73 -bo - - gisLmbcFunc -; - -74 -ut32 - - gfmsAggSize -; - -75 - gd -:: -rg - -funcName -; - -76 -FuncAddr -( -bo - -lmbcFunc -, * -func -, -d -:: -rg - -funcName -, -ut32 - -fmsAggSz - = 0); - -79 as - cLmbcMod - { - -80 - gpublic -: - -81 -d -:: -rg - -lmbcPh -; - -82 -MIRModu -* - gmMod -; - -83 -FuncM - - gfuncM -; - -84 -LmbcFunc -* - gmaFn -; - -86 - gd -:: -unded_m -< -ut64 -, - gVInf -*> - gglobAndSticVs -; - -87 - gd -:: -unded_m -< -ut32 -, std:: -rg -> -globSTbl -; - -88  - gglobSticMemSize -; - -89 -ut8 -* - gglobSticMem -; - -90  - gglobsSize -; - -91 -ut8 -* - gglobs -; - -92 -ut32 - - gaggrInOfft -; - -93 - gpublic -: - -94  -InGlobVs -(); - -95  -InGlobVb -( -VInf - * -pInf -); - -96  -InICڡ -( -VInf - * -pInf -, -MIRICڡ - & -tCڡ -, -ut8 - * -d -); - -97  -InSCڡ -( -VInf -* -pInf -, -MIRSCڡ - & -mSCڡ -, -ut8 - * -d -); - -98  -InAddrofCڡ -( -VInf - * -pInf -, -MIRAddrofCڡ - & -addrofCڡ -, -ut8 - * -d -); - -99  -InFltCڡ -( -VInf - * -pInf -, -MIRFltCڡ - & -f32Cڡ -, -ut8 - * -d -); - -100  -InDoubCڡ -( -VInf - * -Inf -, -MIRDoubCڡ - & -f64Cڡ -, -ut8 - * -d -); - -101  -InLblCڡ -( -VInf - * -pInf -, -MIRLblCڡ - & -bCڡ -, -ut8 - * -d -); - -102  -InBFldCڡ -( -VInf - * -pInf -, -MIRCڡ - & -mCڡ -, -t32_t - & -locdBs -, -bo - & -fAlign -); - -103 -ut8_t -* -GGlobVInAddr -( -VInf -* -pInf -, -ut32 - -ign -); - -104  -UpdeGlobVInAddr -( -VInf -* -pInf -, -ut32 - -size -); - -105  -CheckUmedBFld -( -MIRSuTy - & -Ty -, -ut32 - & -evInFd -, ut32 -curFd -, -t32 - & -locdBs -); - -107 -LmbcMod -(* -th -); - -108 -MIRModu -* -Impt -( -d -:: -rg - -th -); - -109  -SnModu -(); - -110  -CcGlobVsSize -(); - -111 -LmbcFunc -* -LkupLmbcFunc -( -PUIdx - -puIdx -); - -113 - gd -:: -ve -<*> -libHds -; - -114 - gd -:: -unded_m -< -PUIdx -, *> - gextFuncM -; - -115 - gd -:: -unded_m -< -ut32 -, *> - gextSymM -; - -116  -LdDefLibs -(); - -117 * -FdExtFunc -( -PUIdx - -puidx -); - -118 * -FdExtSym -( -StIdx - -idx -); - -119  -AddGlobV -( -MIRSymb - & -sym -, -VInf - * -pInf -); - -120  -AddPUSticV -( -PUIdx - -puIdx -, -MIRSymb - & -sym -, -VInf - * -pInf -); - -121 -ut8 - * -GVAddr -( -StIdx - -idx -); - -122 -ut8 - * -GVAddr -( -PUIdx - -puidx -, -StIdx - -idx -); - -124  -InAggCڡ -( -VInf - * -pInf -, -MIRCڡ - & -mCڡ -); - -125  -InAayCڡ -( -VInf - * -pInf -, -MIRCڡ - & -mCڡ -); - -126  -InSrCڡ -( -VInf - * -pInf -, -MIRCڡ - & -mCڡ -); - -127  -InPorCڡ -( -VInf - * -pInf -, -MIRCڡ - & -mCڡ -); - -128 - gd -:: -unded_m -< -PUIdx -, - gFuncAddr -*> - gPUIdx2FuncAddr -; - -129 -FuncAddr -* -GFuncAddr -( -PUIdx - -puIdx -); - - @lmbc/include/massert.h - -16 #ide -MAPLERE_MASSERT_H_ - - -17  - #MAPLERE_MASSERT_H_ - - - ) - -19  - ~ - -20  - ~ - -22  - #MASSERT -( -cd -, -fmt -, ...) \ - -24 i(!( -cd -)) { \ - -25 - `rtf -( -dr -, -__FILE__ - ":%d: As faed: " -fmt - "\n", -__LINE__ -, ## -__VA_ARGS__ -); \ - -26 - `abt -(); \ - -28 } 0) - - ) - - @lmbc/include/mexpression.h - -16 #ide -MAPLERE_MEXPRESSION_H_ - - -17  - #MAPLERE_MEXPRESSION_H_ - - - ) - -19  - ~ - -20  - ~"mas.h -" - -22  - #EXPRBINOP -( -ex -, -s -, -0 -, -1 -, -exPtyp -) \ - -24  -exPtyp -) { \ - -25  -PTY_i8 -: -s -. -x -. -i8 - = -0 -.x.i8 -ex - -1 -.x.i8; ; \ - -26  -PTY_i16 -: -s -. -x -. -i16 - = -0 -.x.i16 -ex - -1 -.x.i16; ; \ - -27  -PTY_i32 -: -s -. -x -. -i32 - = ( -t64 -) -0 -.x.i32 - `ex - (t64) -1 -.x.i32; ; \ - -28  -PTY_i64 -: -s -. -x -. -i64 - = -0 -.x.i64 -ex - -1 -.x.i64; ; \ - -29  -PTY_u8 -: -s -. -x -. -u8 - = -0 -.x.u8 -ex - -1 -.x.u8; ; \ - -30  -PTY_u16 -: -s -. -x -. -u16 - = -0 -.x.u16 -ex - -1 -.x.u16; ; \ - -31  -PTY_u32 -: -s -. -x -. -u32 - = -0 -.x.u32 -ex - -1 -.x.u32; ; \ - -32  -PTY_u64 -: -s -. -x -. -u64 - = -0 -.x.u64 -ex - -1 -.x.u64; ; \ - -33  -PTY_a64 -: -s -. -x -. -u64 - = -0 -.x.u64 -ex - -1 -.x.u64; ; \ - -34  -PTY_f32 -: -s -. -x -. -f32 - = -0 -.x.f32 -ex - -1 -.x.f32; ; \ - -35  -PTY_f64 -: -s -. -x -. -f64 - = -0 -.x.f64 -ex - -1 -.x.f64; ; \ - -36 : - `MIR_FATAL -("Unsu܋d PrimTy %d f by ot %s", -exPtyp -, #exprop); \ - -38 -s -. -yp - = -ex -->ptyp; \ - -39 } 0) - - ) - -41  - #EXPRCOMPOP -( -ex -, -s -, -0 -, -1 -, -typ -, -exyp -) \ - -44  -typ -) { \ - -45  -PTY_i8 -: -s -. -x -. -i64 - = -0 -.x. -i8 - -ex - -1 -.x.i8; ; \ - -46  -PTY_i16 -: -s -. -x -. -i64 - = -0 -.x. -i16 - -ex - -1 -.x.i16; ; \ - -47  -PTY_i32 -: -s -. -x -. -i64 - = -0 -.x. -i32 - -ex - -1 -.x.i32; ; \ - -48  -PTY_i64 -: -s -. -x -. -i64 - = -0 -.x.i64 -ex - -1 -.x.i64; ; \ - -49  -PTY_u8 -: -s -. -x -. -i64 - = -0 -.x. -u8 - -ex - -1 -.x.u8; ; \ - -50  -PTY_u16 -: -s -. -x -. -i64 - = -0 -.x. -u16 - -ex - -1 -.x.u16; ; \ - -51  -PTY_u32 -: -s -. -x -. -i64 - = -0 -.x. -u32 - -ex - -1 -.x.u32; ; \ - -52  -PTY_u64 -: -s -. -x -. -i64 - = -0 -.x. -u64 - -ex - -1 -.x.u64; ; \ - -53  -PTY_a64 -: -s -. -x -. -i64 - = -0 -.x. -a64 - -ex - -1 -.x.a64; ; \ - -54  -PTY_f32 -: -s -. -x -. -i64 - = -0 -.x. -f32 - -ex - -1 -.x.f32; ; \ - -55  -PTY_f64 -: -s -. -x -. -i64 - = -0 -.x. -f64 - -ex - -1 -.x.f64; ; \ - -56 : - `MIR_FATAL -("Unsu܋d ond PrimTy %d f comris ot %s", -0 -. -yp -, #exprop); \ - -58 -s -. -yp - = -exyp -; \ - -59 } 0) - - ) - -64  - #EXPRCOMPOPNOFLOAT -( -ex -, -s -, -0 -, -1 -, -typ -, -exyp -) \ - -67  -typ -) { \ - -68  -PTY_i8 -: -s -. -x -. -i64 - = -0 -.x. -i8 - -ex - -1 -.x.i8; ; \ - -69  -PTY_i16 -: -s -. -x -. -i64 - = -0 -.x. -i16 - -ex - -1 -.x.i16; ; \ - -70  -PTY_i32 -: -s -. -x -. -i64 - = -0 -.x. -i32 - -ex - -1 -.x.i32; ; \ - -71  -PTY_i64 -: -s -. -x -. -i64 - = -0 -.x.i64 -ex - -1 -.x.i64; ; \ - -72  -PTY_u8 -: -s -. -x -. -i64 - = -0 -.x. -u8 - -ex - -1 -.x.u8; ; \ - -73  -PTY_u16 -: -s -. -x -. -i64 - = -0 -.x. -u16 - -ex - -1 -.x.u16; ; \ - -74  -PTY_u32 -: -s -. -x -. -i64 - = -0 -.x. -u32 - -ex - -1 -.x.u32; ; \ - -75  -PTY_u64 -: -s -. -x -. -i64 - = -0 -.x. -u64 - -ex - -1 -.x.u64; ; \ - -76  -PTY_a64 -: -s -. -x -. -i64 - = -0 -.x. -a64 - -ex - -1 -.x.a64; ; \ - -77 : - `MIR_FATAL -("Unsu܋d ond PrimTy %d f comris ot %s", -0 -. -yp -, #exprop); \ - -79 -s -. -yp - = -exyp -; \ - -80 } 0) - - ) - -82  - #EXPRSELECTOP -( -s -, -0 -, -l1 -, -l2 -, -exyp -) \ - -84 -MVue - -1 -, -2 -; \ - -85 -1 - = - `CvtTy -( -l1 -, -exyp -, s1. -yp -); \ - -86 -2 - = - `CvtTy -( -l2 -, -exyp -, s2. -yp -); \ - -87  -exyp -) { \ - -88  -PTY_i8 -: -s -. -x -. -i8 - = -0 -.x. -i64 -? -1 -.x.i8 : -2 -.x.i8; ; \ - -89  -PTY_i16 -: -s -. -x -. -i16 - = -0 -.x. -i64 -? -1 -.x.i16 : -2 -.x.i16; ; \ - -90  -PTY_i32 -: -s -. -x -. -i32 - = -0 -.x. -i64 -? -1 -.x.i32 : -2 -.x.i32; ; \ - -91  -PTY_i64 -: -s -. -x -. -i64 - = -0 -.x.i64? -1 -.x.i64 : -2 -.x.i64; ; \ - -92  -PTY_u8 -: -s -. -x -. -u8 - = -0 -.x. -i64 -? -1 -.x.u8 : -2 -.x.u8; ; \ - -93  -PTY_u16 -: -s -. -x -. -u16 - = -0 -.x. -i64 -? -1 -.x.u16 : -2 -.x.u16; ; \ - -94  -PTY_u32 -: -s -. -x -. -u32 - = -0 -.x. -i64 -? -1 -.x.u32 : -2 -.x.u32; ; \ - -95  -PTY_u64 -: -s -. -x -. -u64 - = -0 -.x. -i64 -? -1 -.x.u64 : -2 -.x.u64; ; \ - -96  -PTY_a64 -: -s -. -x -. -a64 - = -0 -.x. -i64 -? -1 -.x.a64 : -2 -.x.a64; ; \ - -97  -PTY_f32 -: -s -. -x -. -f32 - = -0 -.x. -i64 -? -1 -.x.f32 : -2 -.x.f32; ; \ - -98  -PTY_f64 -: -s -. -x -. -f64 - = -0 -.x. -i64 -? -1 -.x.f64 : -2 -.x.f64; ; \ - -99 : - `MIR_FATAL -("Unsu܋d PrimTy %d f se ot", -exyp -); \ - -101 -s -. -yp - = -exyp -; \ - -102 } 0) - - ) - -104  - #EXPRBININTOP -( -ex -, -s -, - -, -1 -, -exyp -) \ - -106 -MVue - -0 - = - `CvtTy -( - -, -exyp -, op. -yp -); \ - -107  -exyp -) { \ - -108  -PTY_i8 -: -s -. -x -. -i8 - = -0 -.x.i8 -ex - -1 -.x.i8; ; \ - -109  -PTY_i16 -: -s -. -x -. -i16 - = -0 -.x.i16 -ex - -1 -.x.i16; ; \ - -110  -PTY_i32 -: -s -. -x -. -i32 - = -0 -.x.i32 -ex - -1 -.x.i32; ; \ - -111  -PTY_i64 -: -s -. -x -. -i64 - = -0 -.x.i64 -ex - -1 -.x.i64; ; \ - -112  -PTY_u8 -: -s -. -x -. -u8 - = -0 -.x.u8 -ex - -1 -.x.u8; ; \ - -113  -PTY_u16 -: -s -. -x -. -u16 - = -0 -.x.u16 -ex - -1 -.x.u16; ; \ - -114  -PTY_u32 -: -s -. -x -. -u32 - = -0 -.x.u32 -ex - -1 -.x.u32; ; \ - -115  -PTY_u64 -: -s -. -x -. -u64 - = -0 -.x.u64 -ex - -1 -.x.u64; ; \ - -116  -PTY_a64 -: -s -. -x -. -u64 - = -0 -.x.u64 -ex - -1 -.x.u64; ; \ - -117 : - `MIR_FATAL -("Unsu܋d PrimTy %d f ieg by ot %s", -exyp -, #exprop); \ - -119 -s -. -yp - = -exyp -; \ - -120 } 0) - - ) - -123  - #EXPRBININTOPUNSIGNED -( -ex -, -s -, -0 -, -1 -, -exyp -) \ - -125 - `MASSERT -(( -0 -. -yp - = -exyp -) || \ - -126 ( -0 -. -yp - = -PTY_u32 - && -exyp - = -PTY_i32 -) || \ - -127 ( -0 -. -yp - = -PTY_i32 - && -exyp - = -PTY_u32 -), \ - -128 "BINUINTOP Ty mismch: 0x%02xnd 0x%02x", -0 -. -yp -, -exyp -); \ - -129  -1 -. -yp -) { \ - -130  -PTY_i8 -: \ - -131  -PTY_u8 -: \ - -132 - `MASSERT -( -1 -. -x -. -u8 - <= 64, "OP_lshr shifting morehan 64 bites"); \ - -134  -PTY_i16 -: \ - -135  -PTY_u16 -: \ - -136 - `MASSERT -( -1 -. -x -. -u16 - <= 64, "OP_lshr shifting morehan 64 bites"); \ - -138  -PTY_i32 -: \ - -139  -PTY_u32 -: \ - -140 - `MASSERT -( -1 -. -x -. -u32 - <= 64, "OP_lshr shifting morehan 64 bites"); \ - -142  -PTY_i64 -: \ - -143  -PTY_u64 -: \ - -144  -PTY_a64 -: \ - -145 - `MASSERT -( -1 -. -x -. -u64 - <= 64, "OP_lshr shifting morehan 64 bites"); \ - -148 - `MIR_FATAL -("Unsu܋d PrimTy %d f unsigd ieg by ot %s", -exyp -, #exprop); \ - -151  -exyp -) { \ - -152  -PTY_i8 -: -s -. -x -. -u8 - = -0 -.x.u8 -ex - -1 -.x.u8; ; \ - -153  -PTY_i16 -: -s -. -x -. -u16 - = -0 -.x.u16 -ex - -1 -.x.u16; ; \ - -154  -PTY_i32 -: -s -. -x -. -u32 - = -0 -.x.u32 -ex - -1 -.x.u32; ; \ - -155  -PTY_i64 -: -s -. -x -. -u64 - = -0 -.x.u64 -ex - -1 -.x.u64; ; \ - -156  -PTY_a64 -: -s -. -x -. -u64 - = -0 -.x.u64 -ex - -1 -.x.u64; ; \ - -157  -PTY_u8 -: -s -. -x -. -u8 - = -0 -.x.u8 -ex - -1 -.x.u8; ; \ - -158  -PTY_u16 -: -s -. -x -. -u16 - = -0 -.x.u16 -ex - -1 -.x.u16; ; \ - -159  -PTY_u32 -: -s -. -x -. -u32 - = -0 -.x.u32 -ex - -1 -.x.u32; ; \ - -160  -PTY_u64 -: -s -. -x -. -u64 - = -0 -.x.u64 -ex - -1 -.x.u64; ; \ - -161 : - `MIR_FATAL -("Unsu܋d PrimTy %d f unsigd ieg by ot %s", -exyp -, #exprop); \ - -163 -s -. -yp - = -exyp -; \ - -164 } 0) - - ) - -166  - #EXPRMAXMINOP -( -ex -, -s -, -0 -, -1 -, -exyp -) \ - -168 - `MASSERT -( -0 -. -yp - = -1 -.ptyp, "MAXMINOP Type mismatch: 0x%02xnd 0x%02x", op0.ptyp, op1.ptyp); \ - -169 - `MASSERT -( -0 -. -yp - = -exyp -, "MAXMINOP Type mismatch: 0x%02xnd 0x%02x", op0.ptyp,xprptyp); \ - -170  -exyp -) { \ - -171  -PTY_i8 -: -s -. -x -. -i8 - = -0 -.x.i8 -ex - -1 -.x.i8? op0.x.i8 : op1.x.i8; ; \ - -172  -PTY_i16 -: -s -. -x -. -i16 - = -0 -.x.i16 -ex - -1 -.x.i16? op0.x.i16 : op1.x.i16; ; \ - -173  -PTY_i32 -: -s -. -x -. -i32 - = -0 -.x.i32 -ex - -1 -.x.i32? op0.x.i32 : op1.x.i32; ; \ - -174  -PTY_i64 -: -s -. -x -. -i64 - = -0 -.x.i64 -ex - -1 -.x.i64? op0.x.i64 : op1.x.i64; ; \ - -175  -PTY_u8 -: -s -. -x -. -u8 - = -0 -.x.u8 -ex - -1 -.x.u8 ? op0.x.u8 : op1.x.u8; ; \ - -176  -PTY_u16 -: -s -. -x -. -u16 - = -0 -.x.u16 -ex - -1 -.x.u16? op0.x.u16 : op1.x.u16; ; \ - -177  -PTY_u32 -: -s -. -x -. -u32 - = -0 -.x.u32 -ex - -1 -.x.u32? op0.x.u32 : op1.x.u32; ; \ - -178  -PTY_u64 -: -s -. -x -. -u64 - = -0 -.x.u64 -ex - -1 -.x.u64? op0.x.u64 : op1.x.u64; ; \ - -179  -PTY_a64 -: -s -. -x -. -a64 - = -0 -.x.a64 -ex - -1 -.x.a64? op0.x.a64 : op1.x.a64; ; \ - -180  -PTY_f32 -: -s -. -x -. -f32 - = -0 -.x.f32 -ex - -1 -.x.f32? op0.x.f32 : op1.x.f32; ; \ - -181  -PTY_f64 -: -s -. -x -. -f64 - = -0 -.x.f64 -ex - -1 -.x.f64? op0.x.f64 : op1.x.f64; ; \ - -182 : - `MIR_FATAL -("Unsu܋d PrimTy %d f by max/m ot %s", -exyp -, #exprop); \ - -184 -s -. -yp - = -exyp -; \ - -185 } 0) - - ) - -187  - #EXPRREMOP -( -ex -, -s -, -0 -, -1 -, -exyp -) \ - -189  -exyp -) { \ - -190  -PTY_i8 -: if( -1 -. -x -. -i8 - =0 -s -.x.i8 = 0; \ - -191 if( -1 -. -x -. -i8 - =-1 && -0 -.x.i8 = -INT8_MIN -) op0.x.i8 = 0; \ - -192 -s -. -x -. -i8 - = -0 -.x.i8 -ex - -1 -.x.i8; ; \ - -193  -PTY_i16 -: if( -1 -. -x -. -i16 - =0 -s -.x.i16 = 0; \ - -194 if( -1 -. -x -. -i16 - =-1 && -0 -.x.i16 = -INT16_MIN -) op0.x.i16 = 0; \ - -195 -s -. -x -. -i16 - = -0 -.x.i16 -ex - -1 -.x.i16; ; \ - -196  -PTY_i32 -: if( -1 -. -x -. -i32 - =0 -s -.x.i32 = 0; \ - -197 if( -1 -. -x -. -i32 - =-1 && -0 -.x.i32 = -INT32_MIN -) op0.x.i32 = 0; \ - -198 -s -. -x -. -i32 - = -0 -.x.i32 -ex - -1 -.x.i32; ; \ - -199  -PTY_i64 -: if( -1 -. -x -. -i64 - =0 -s -.x.i64 = 0; \ - -200 if( -1 -. -x -. -i64 - =-1 && -0 -.x.i64 = -INT64_MIN -) op0.x.i64 = 0; \ - -201 -s -. -x -. -i64 - = -0 -.x.i64 -ex - -1 -.x.i64; ; \ - -202  -PTY_u8 -: if( -1 -. -x -. -u8 - =0 -s -.x.u8 = 0; \ - -203 -s -. -x -. -u8 - = -0 -.x.u8 -ex - -1 -.x.u8; ; \ - -204  -PTY_u16 -: if( -1 -. -x -. -u16 - =0 -s -.x.u16 = 0; \ - -205 -s -. -x -. -u16 - = -0 -.x.u16 -ex - -1 -.x.u16; ; \ - -206  -PTY_u32 -: if( -1 -. -x -. -u32 - =0 -s -.x.u32 = 0; \ - -207 -s -. -x -. -u32 - = -0 -.x.u32 -ex - -1 -.x.u32; ; \ - -208  -PTY_u64 -: if( -1 -. -x -. -u64 - =0 -s -.x.u64 = 0; \ - -209 -s -. -x -. -u64 - = -0 -.x.u64 -ex - -1 -.x.u64; ; \ - -210 : - `MIR_FATAL -("Unsu܋d PrimTy %d f܄em ot %s", -exyp -, #exprop); \ - -212 -s -. -yp - = -exyp -; \ - -213 } 0) - - ) - -215  - #EXPRUNROP -( -ex -, -s -, -0 -, -exyp -) \ - -217 - `MASSERT -( -0 -. -yp - = -exyp - || \ - -218 (( -0 -. -yp - = -PTY_i32 - || op0.y= -PTY_u32 -) && \ - -219 ( -exyp - = -PTY_i32 - ||xy= -PTY_u32 -), "UNROP Ty mismch: 0x%02xnd 0x%02x", -0 -. -yp -,xprptyp); \ - -220  -exyp -) { \ - -221  -PTY_i8 -: -s -. -x -. -i8 - = -ex - -0 -.x.i8; ; \ - -222  -PTY_i16 -: -s -. -x -. -i16 - = -ex - -0 -.x.i16; ; \ - -223  -PTY_i32 -: -s -. -x -. -i32 - = -ex - -0 -.x.i32; ; \ - -224  -PTY_i64 -: -s -. -x -. -i64 - = -ex - -0 -.x.i64; ; \ - -225  -PTY_u8 -: -s -. -x -. -u8 - = -ex - -0 -.x.u8; ; \ - -226  -PTY_u16 -: -s -. -x -. -u16 - = -ex - -0 -.x.u16; ; \ - -227  -PTY_u32 -: -s -. -x -. -u32 - = -ex - -0 -.x.u32; ; \ - -228  -PTY_u64 -: -s -. -x -. -u64 - = -ex - -0 -.x.u64; ; \ - -229 : - `MIR_FATAL -("Unsu܋d PrimTy %d f ury ot %s", -exyp -, #exprop); \ - -231 -s -. -yp - = -exyp -; \ - -232 } 0) - - ) - - @lmbc/include/mfunction.h - -16 #ide -MAPLERE_MFUNCTION_H_ - - -17  - #MAPLERE_MFUNCTION_H_ - - - ) - -19  - ~ - -20  - ~ - -22  - ~ - -23  - ~ - -24  - #gtid -( - `sys -( -SYS_gtid -) - - ) - -26  - ~"m_nodes.h -" - -27  - ~"mvue.h -" - -28  - ~"lmbc_g.h -" - -30  - #VARNAMELENGTH - 16 - - ) - -31  - #ALLOCA_MEMMAX - 0x4000 - - ) - -33 -mea - - gm - { - -35 -ass - - gLmbcMod -; - -36 -ass - - gLmbcFunc -; - -37  - gPmInf -; - -40 -usg - - gffi__t - = (*)(); - -51 -ut - - ggp_offt -; - -52 -ut - - g_offt -; - -53 * - govow_g_ -; - -54 * - gg_ve_ -; - -55 } - tVaLiX86_64 -[1]; - -58 * - gack -; - -59 * - ggr_t -; - -60 * - gvr_t -; - -61  - ggr_offs -; - -62  - gvr_offs -; - -63 } - tVaLiAch64 -; - -65 -usg - - gVaLi - = -VaLiAch64 -; - -68 as - cMFuni - { - -69 - gpublic -: - -71 -LmbcFunc -* -fo -; - -72 -MFuni -* - gΔ -; - -73 -StmtNode -* - gxtStmt -; - -74 -ut8 -* - game -; - -75 -ut8 -* - g -; - -76 -ut8 -* - gloMem -; - -77 -ut32 - - gloOfft -; - -78 -MVue -* - gpRegs -; - -79 -MVue -* - gfmVs -; - -82 -ut16 - - gnumClArgs -; - -83 -MVue -* - gArgs -; - -84 -ut8 -* - gaggrArgsBuf -; - -85 -ut8 -* - gvArgsBuf -; - -86 -MVue - - gtV0 -; - -87 -MVue - - gtV1 -; - -88 -ut8 -* - gvaArgs -; - -89 -ut32 - - gvaArgsSize -; - -91 -exic - -MFuni -( -LmbcFunc - * -funcInfo -, - -92 -MFuni - * -funcCr -, - -93 -ut8 - * -autoVs -, - -94 -MVue - * -pRegs -, - -95 -MVue - * -fmVs -); - -96 ~ -MFuni -(); - -97 -ut8 - * -Ao -( -ut32 - -size -); - -98 -ut8 - * -GFmVAddr -( -StIdx - -idx -); - -99  -ClMFuncDe -( -ClNode - * - -); - -100  -ClMFuncInde -( -INode - * -i -, -LmbcFunc - * -Info -); - -101  -ClExtFuncDe -( -ClNode -* - -); - -102  -ClExtFuncInde -( -INode - * -iδo -, * - -); - -103  -ClVaArgFunc -( -numArgs -, -LmbcFunc - * -Info -); - -104  -ClWhFFI -( -PrimTy - -t_yp -, -ffi__t - - -); - -105  -ClIrsic -( -IrsicNode - & -n -); - -108 -bo - -IsExtFunc -( -PUIdx - -puIdx -, -LmbcMod - & -modu -); - -109 -MVue - -InvokeFunc -( -LmbcFunc -* - -, -MFuni - * -Δ -); - -110 -MVue - -EvEx -( -MFuni - & -func -, -BaNode -* -ex -, -PmInf - * -rm - = -nuαr -); - -111  -me -( -ut8 -* -addr -, -PrimTy - -yp -, -MVue -& -v -, -bo - -toVArgSck -); - - @lmbc/include/mprimtype.h - -16 #ide -MAPLERE_MPRIMTYPE_H_ - - -17  - #MAPLERE_MPRIMTYPE_H_ - - - ) - -26  - #PTYSIZE_Invid - 0 - - ) - -27  - #PTYSIZE_void - 0 - - ) - -28  - #PTYSIZE_i8 - 1 - - ) - -29  - #PTYSIZE_i16 - 2 - - ) - -30  - #PTYSIZE_i32 - 3 - - ) - -31  - #PTYSIZE_i64 - 4 - - ) - -32  - #PTYSIZE_u8 - 1 - - ) - -33  - #PTYSIZE_u16 - 2 - - ) - -34  - #PTYSIZE_u32 - 3 - - ) - -35  - #PTYSIZE_u64 - 4 - - ) - -36  - #PTYSIZE_u1 - 1 - - ) - -37  - #PTYSIZE_r - 3 - - ) - -38  - #PTYSIZE_f - 3 - - ) - -39  - #PTYSIZE_a32 - 3 - - ) - -40  - #PTYSIZE_a64 - 4 - - ) - -41  - #PTYSIZE_f32 - 3 - - ) - -42  - #PTYSIZE_f64 - 4 - - ) - -43  - #PTYSIZE_f128 - 5 - - ) - -44  - #PTYSIZE_c64 - 5 - - ) - -45  - #PTYSIZE_c128 - 6 - - ) - -46  - #PTYSIZE_simer - 3 - - ) - -47  - #PTYSIZE_simeobj - 3 - - ) - -48  - #PTYSIZE_dyny - 4 - - ) - -49  - #PTYSIZE_dynundef - 4 - - ) - -50  - #PTYSIZE_dyu - 4 - - ) - -51  - #PTYSIZE_dynbo - 4 - - ) - -52  - #PTYSIZE_dyni32 - 4 - - ) - -53  - #PTYSIZE_dynr - 4 - - ) - -54  - #PTYSIZE_dynobj - 4 - - ) - -55  - #PTYSIZE_dynf64 - 4 - - ) - -56  - #PTYSIZE_dynf32 - 4 - - ) - -57  - #PTYSIZE_dye - 4 - - ) - -58  - #PTYSIZE_cڡS - 0 - - ) - -59  - #PTYSIZE_g - 0 - - ) - -60  - #PTYSIZE_agg - 0 - - ) - -61  - #PTYSIZE_v2i64 - 0 - - ) - -62  - #PTYSIZE_v4i32 - 0 - - ) - -63  - #PTYSIZE_v8i16 - 0 - - ) - -64  - #PTYSIZE_v16i8 - 0 - - ) - -65  - #PTYSIZE_v2f64 - 0 - - ) - -66  - #PTYSIZE_v4f32 - 0 - - ) - -67  - #PTYSIZE_unknown - 0 - - ) - -68  - #PTYSIZE_Dived - 0 - - ) - -71  - #FFITYPE_Invid - -ffi_ty_void - - - ) - -72  - #FFITYPE_void - -ffi_ty_void - - - ) - -73  - #FFITYPE_i8 - -ffi_ty_st8 - - - ) - -74  - #FFITYPE_i16 - -ffi_ty_st16 - - - ) - -75  - #FFITYPE_i32 - -ffi_ty_st32 - - - ) - -76  - #FFITYPE_i64 - -ffi_ty_st64 - - - ) - -77  - #FFITYPE_u8 - -ffi_ty_ut8 - - - ) - -78  - #FFITYPE_u16 - -ffi_ty_ut16 - - - ) - -79  - #FFITYPE_u32 - -ffi_ty_ut32 - - - ) - -80  - #FFITYPE_u64 - -ffi_ty_ut64 - - - ) - -81  - #FFITYPE_u1 - -ffi_ty_ut8 - - - ) - -82  - #FFITYPE_r - -ffi_ty_por - - - ) - -83  - #FFITYPE_f - -ffi_ty_por - - - ) - -84  - #FFITYPE_a32 - -ffi_ty_por - - - ) - -85  - #FFITYPE_a64 - -ffi_ty_por - - - ) - -86  - #FFITYPE_f32 - -ffi_ty_t - - - ) - -87  - #FFITYPE_f64 - -ffi_ty_doub - - - ) - -88  - #FFITYPE_f128 - -ffi_ty_void - - - ) - -89  - #FFITYPE_c64 - -ffi_ty_void - - - ) - -90  - #FFITYPE_c128 - -ffi_ty_void - - - ) - -91  - #FFITYPE_simer - -ffi_ty_void - - - ) - -92  - #FFITYPE_simeobj - -ffi_ty_void - - - ) - -93  - #FFITYPE_dyny - -ffi_ty_void - - - ) - -94  - #FFITYPE_dynundef - -ffi_ty_void - - - ) - -95  - #FFITYPE_dyu - -ffi_ty_void - - - ) - -96  - #FFITYPE_dynbo - -ffi_ty_void - - - ) - -97  - #FFITYPE_dyni32 - -ffi_ty_void - - - ) - -98  - #FFITYPE_dynr - -ffi_ty_void - - - ) - -99  - #FFITYPE_dynobj - -ffi_ty_void - - - ) - -100  - #FFITYPE_dynf64 - -ffi_ty_void - - - ) - -101  - #FFITYPE_dynf32 - -ffi_ty_void - - - ) - -102  - #FFITYPE_dye - -ffi_ty_void - - - ) - -103  - #FFITYPE_cڡS - -ffi_ty_void - - - ) - -104  - #FFITYPE_g - -ffi_ty_void - - - ) - -105  - #FFITYPE_agg - -ffi_ty_void - - - ) - -106  - #FFITYPE_v2i64 - -ffi_ty_void - - - ) - -107  - #FFITYPE_v4i32 - -ffi_ty_void - - - ) - -108  - #FFITYPE_v8i16 - -ffi_ty_void - - - ) - -109  - #FFITYPE_v16i8 - -ffi_ty_void - - - ) - -110  - #FFITYPE_v2f64 - -ffi_ty_void - - - ) - -111  - #FFITYPE_v4f32 - -ffi_ty_void - - - ) - -112  - #FFITYPE_unknown - -ffi_ty_void - - - ) - -113  - #FFITYPE_Dived - -ffi_ty_void - - - ) - -114  - #FFITYPE_i128 - -ffi_ty_void - - - ) - -115  - #FFITYPE_u128 - -ffi_ty_void - - - ) - -116  - #FFITYPE_v2u64 - -ffi_ty_void - - - ) - -117  - #FFITYPE_v4u32 - -ffi_ty_void - - - ) - -118  - #FFITYPE_v8u16 - -ffi_ty_void - - - ) - -119  - #FFITYPE_v16u8 - -ffi_ty_void - - - ) - -120  - #FFITYPE_v2i32 - -ffi_ty_void - - - ) - -121  - #FFITYPE_v4i16 - -ffi_ty_void - - - ) - -122  - #FFITYPE_v8i8 - -ffi_ty_void - - - ) - -123  - #FFITYPE_v2u32 - -ffi_ty_void - - - ) - -124  - #FFITYPE_v4u16 - -ffi_ty_void - - - ) - -125  - #FFITYPE_v8u8 - -ffi_ty_void - - - ) - -126  - #FFITYPE_v2f32 - -ffi_ty_void - - - ) - -127  - #FFITYPE_rvedy1 - -ffi_ty_void - - - ) - -128  - #FFITYPE_rvedy2 - -ffi_ty_void - - - ) - -129  - #FFITYPE_rvedy3 - -ffi_ty_void - - - ) - -130  - #FFITYPE_rvedy4 - -ffi_ty_void - - - ) - -131  - #FFITYPE_rvedy5 - -ffi_ty_void - - - ) - -132  - #FFITYPE_rvedy6 - -ffi_ty_void - - - ) - -133  - #FFITYPE_rvedy7 - -ffi_ty_void - - - ) - -134  - #FFITYPE_rvedy8 - -ffi_ty_void - - - ) - -135  - #FFITYPE_rvedy9 - -ffi_ty_void - - - ) - -136  - #FFITYPE_rvedy10 - -ffi_ty_void - - - ) - - @lmbc/include/mvalue.h - -16 #ide -MAPLERE_MVALUE_H_ - - -17  - #MAPLERE_MVALUE_H_ - - - ) - -19  - ~ - -20  - ~"im_tys.h -" - -22 -mea - - gm - { - -23  - sMVue - { - -25 -t8 - - gi8 -; - -26 -t16 - - gi16 -; - -27 -t32 - - gi32 -; - -28 -t64 - - gi64 -; - -29 -ut8 - - gu8 -; - -30 -ut16 - - gu16 -; - -31 -ut32 - - gu32 -; - -32 -ut64 - - gu64 -; - -33  - gf32 -; - -34  - gf64 -; - -35 -ut8 - * - ga64 -; - -36 * - gr -; - -37 * - gr -; - -38 } - gx -; - -39 -PrimTy - - gyp -:8; - -40 -size_t - - gaggSize -; - - @lmbc/src/eng_shim.cpp - -15  - ~"mfuni.h -" - -16  - ~"mas.h -" - -17  - ~"lmbc_g.h -" - -19 -mea - - gm - { - -21 "C" -t64 - - -22 -__geShim -( -LmbcFunc -* - -, ...) { - -23 -ut8 - -ame -[ - --> -ameSize -]; - -24 -MVue - -egs -[ - --> -numPgs -]; - -25 -MVue - -fmVs -[ - --> -fmsNumVs -+1]; - -26 -MFuni - -shim_Δ -( - -, -nuαr -, -ame -, -egs -, -fmVs -); - -28 -MVue - -v -; - -29 i( - --> -fmsNum - > 0) { - -30 -MVue - -Args -[ - --> -fmsNum -]; - -31 -va_li - -gs -; - -32 -va_t - ( -gs -, - -); - -34  -gIdx - = 0; - -35  -gIdx - < - --> -fmsNum -) { - -37 -v -. -yp - = - --> -pos2Pm -[ -gIdx -]->ptyp; - -38  -v -. -yp -) { - -39  -PTY_i8 -: - -40 -v -. -x -. -i8 - = -va_g -( -gs -, ); - -42  -PTY_i16 -: - -43 -v -. -x -. -i16 - = -va_g -( -gs -, ); - -45  -PTY_i32 -: - -46 -v -. -x -. -i32 - = -va_g -( -gs -, ); - -48  -PTY_i64 -: - -49 -v -. -x -. -i64 - = -va_g -( -gs -, ); - -51  -PTY_u16 -: - -52 -v -. -x -. -u16 - = -va_g -( -gs -, ); - -54  -PTY_a64 -: - -55 -v -. -x -. -a64 - = -va_g -( -gs -, -ut8 -*); - -57  -PTY_f32 -: - -59  -PTY_f64 -: - -60 -v -. -x -. -f64 - = -va_g -( -gs -, ); - -63 -MIR_FATAL -("Unsu܋d PrimTy %d", -v -. -yp -); - -65 -Args -[ -gIdx -] = -v -; - -66 ++ -gIdx -; - -68 -shim_Δ -. -numClArgs - = - --> -fmsNum -; - -69 -shim_Δ -. -Args - = callArgs; - -71 -v - = -InvokeFunc -( - -, & -shim_Δ -); - - @lmbc/src/init.cpp - -15  - ~"mas.h -" - -16  - ~"lmbc_g.h -" - -17  - ~"g_shim.h -" - -19 -mea - - gm - { - -22  - #ROUNDUP8 -( -v -(((v+7)>>3)<<3) - - ) - -25 -le -  -AlignOfft -( -ut32 - & -offt -, ut32 -ign -) { - -26 - gofft - = ( -offt - + -ign --1) & ~(align-1); - -29 - gLmbcFunc -:: -LmbcFunc -( -LmbcMod - * -mod -, -MIRFuni - * -func -: -lmbcMod -(mod), -mFunc -(func) { - -30 - gameSize - = -ROUNDUP8 -( -func --> -GFmeSize -()); - -31 - gisVArgs - = -func --> -GMIRFuncTy -()-> -IsVgs -(); - -32 - gnumPgs - = -func --> -GPgTab -()-> -Size -(); - -35  - gLmbcMod -:: -InModu -() { - -36 -CcGlobAndSticVSize -(); - -37  -MIRFuni - * - gmFunc - : -mMod --> -GFuniLi -()) { - -38 iut -node - = -mFunc --> -GBody -()) { - -39 -LmbcFunc -* - - = -w - LmbcFunc( -this -, -mFunc -); - -40 -ASSERT -( - -, "Create Lmbc function failed"); - -41 - g --> -SnFms -(); - -42 - g --> -SnLabs -( -node -); - -43 - gfuncM -[ -mFunc --> -GPuidx -()] = - -; - -44 i( - gmFunc --> -GName -(). -com -("main") == 0) { - -45 -maFn - = - -; - -50 -InGlobVs -(); - -53  - gLmbcFunc -:: -SnFms -() { - -54 -MVe -< -FmDef -> -fmDefVec - = -mFunc --> -GFmDefVec -(); - -55 - gfmsNum - = -fmDefVec -. -size -(); - -56 - gfmsSize - = 0; - -57 - gfmsNumVs - = 0; - -58 - gfmsAggSize - = 0; - -59 -MASSERT -( -mFunc --> -GRuTy -(! -nuαr -, "mirFunceturnype isull"); - -60 - gtSize - = -mFunc --> -GRuTy -()-> -GSize -(); - -61  -ut32 - - gi - = 0; i < - gfmDefVec -. -size -(); i++) { - -62 -MIRSymb -* - gsymb - = -fmDefVec -[ -i -]. -fmSym -; - -63 -MIRTy -* - gty - = -GlobTabs -:: -GTyTab -(). -GTyFromTyIdx -( -fmDefVec -[ -i -]. -fmTyIdx -); - -64 -bo - - gisPg - = ( -symb --> -GSKd -(= -kStPg -); - -65 -t32 - - gageIdx -; - -66 i( - gty --> -GPrimTy -(= -PTY_agg -) { - -67 -ageIdx - = -fmsAggSize -; - -68 - gfmsAggSize - + -ty --> -GSize -(); - -70 - gageIdx - = -isPg -? -symb --> -GPg -()-> -GPgNo -(): ++ -fmsNumVs -; - -73 -PmInf -* - gpInf - = -w - PmInf( -ty --> -GPrimTy -(),y-> -GSize -(), -isPg -, -ageIdx -); - -74 - gidx2Pm -[ -symb --> -GStIdx -(). -FuIdx -()] = -pInf -; - -75 - gpos2Pm -. -push_back -( -pInf -); - -76 - gfmsSize - + -ty --> -GSize -(); - -80  - gLmbcFunc -:: -SnLabs -( -StmtNode -* -mt -) { - -81  -mt - ! -nuαr -) { - -82  -mt --> - -) { - -83  -OP_block -: - -84 -mt - = -ic_ -< -BlockNode -*>(mt)-> -GF -(); - -85 -SnLabs -( -mt -); - -87  - gOP_b -: - -88 -bM -[ -ic_ -< -LabNode -*>( -mt -)-> -GLabIdx -()] = stmt; - -93 - gmt - -mt --> -GNext -(); - -108 -ut32 - -CheckFxAayMemb -( -MIRSymb - & -sym -, -MIRTy - & -ty -) { - -109 aut& - gTy - = -ic_ -< -MIRSuTy -&>( -ty -); - -110 aut& - gCڡ - = -ic_ -< -MIRAggCڡ -&>(* -sym -. -GKڡ -()); - -111 -TyIdxFldArPa - - gtp - = -Ty -. -GTyidxFldArPa -(Ty. -GFldsSize -()-1); - -112 -MIRTy - * - gϡFdTy - = -GlobTabs -:: -GTyTab -(). -GTyFromTyIdx -( -tp -. -f -); - -113 i( - gϡFdTy --> -GKd -(= -kTyAay - && - -114 -ic_ -< -MIRAayTy -*>( -ϡFdTy -)-> -GSizeAayIm -(0) == 1 && - -115 -Cڡ -. -GCڡVec -(). -size -(= -Ty -. -GFldsSize -()) { - -116 -MIRCڡ - & -emCڡ - = * -Cڡ -. -GCڡVecIm -(Cڡ. -GCڡVec -(). -size -()-1); - -117 -MASSERT -( -emCڡ -. -GTy -(). -GKd -(= -kTyAay -, "array initializerxpected"); - -118 aut& - grCt - = -ic_ -< -MIRAggCڡ -&>( -emCڡ -); - -119 i( - grCt -. -GCڡVec -(). -size -() > 1) { - -120  ( - grCt -. -GCڡVec -(). -size -()-1* - gemCڡ -. -GTy -(). -GSize -(); - -127  - gLmbcMod -:: -CcGlobAndSticVSize -() { - -128 -ut32 - -offt - = 0; - -130  -size_t - - gi - = 0; i < - gGlobTabs -:: -GGsymTab -(). -GSymbTabSize -(); ++i) { - -131 -MIRSymb - * - gsym - = -GlobTabs -:: -GGsymTab -(). -GSymbFromStidx -( -i -); - -132 i(! - gsym - || - -133 !( - gsym --> -GSKd -(= -kStV -) || - -134 !( -sym --> -GStageCss -(= -kScGlob - || sym->GStageCss(= -kScFic -)) { - -137 i( -MIRTy - * - gty - = -sym --> -GTy -()) { - -138 -AlignOfft -( -offt -, -ty --> -GAlign -()); - -139 -VInf -* - gpInf - = -w - VInf( -ty --> -GPrimTy -(),y-> -GSize -(), -l -, -offt -, -sym -); - -140 -AddGlobV -(* -sym -, -pInf -); - -141 - gofft - + -ty --> -GSize -(); - -142 i( - gty --> -GKd -(= -kTySu -) { - -143 -offt - + -CheckFxAayMemb -(* -sym -, * -ty -); - -147 - gglobsSize - = -offt -; - -149  -MIRFuni - * - gfunc - : -mMod --> -GFuniLi -()) { - -150 iut -node - = -func --> -GBody -()) { - -151 -SnPUStic -( -func -); - -156  - gLmbcMod -:: -SnPUStic -( -MIRFuni - * -func -) { - -157 -size_t - -size - = -func --> -GSymbTabSize -(); - -158  -size_t - - gi - = 0; i < - gsize -; ++i) { - -159 -MIRSymb - * - gsym - = -func --> -GSymbTabIm -( -i -); - -160 i(! - gsym - || !sym-> -IsPUStic -(|| !sym-> -IsCڡ -()) { - -163 i( -MIRTy - * - gty - = -sym --> -GTy -()) { - -164 -VInf -* -pInf - = -w - VInf( -ty --> -GPrimTy -(),y-> -GSize -(), -l -, -globsSize -, -sym -, -func --> -GPuidx -()); - -165 -AddPUSticV -( -func --> -GPuidx -(), * -sym -, -pInf -); - -166 - gglobsSize - + -ty --> -GSize -(); - -176 -ut8 - * - gLmbcMod -:: -GGlobVInAddr -( -VInf -* -pInf -, -ut32 - -ign -) { - -177 i( - gpInf --> - gyp - ! -PTY_agg -) { - -178  -globs - + -pInf --> -eIdx -; - -180 -AlignOfft -( -aggrInOfft -, -ign -); - -181  - gglobs - + - gpInf --> - geIdx - + - gaggrInOfft -; - -184 -le -  - gLmbcMod -:: -UpdeGlobVInAddr -( -VInf -* -pInf -, -ut32 - -size -) { - -185 i( - gpInf --> - gyp - = -PTY_agg -) { - -186 -aggrInOfft - + -size -; - -194  - gLmbcMod -:: -CheckUmedBFld -( -MIRSuTy - & -Ty -, -ut32 - & -evInFd -, ut32 -curFd -, -t32 - & -locdBs -) { - -196 i( - gcurFd - - 1 = -evInFd -) { - -197 -evInFd - = -curFd -; - -201 aut - gi - = -evInFd -; i < - gcurFd - -1; ++i) { - -202 -TyIdxFldArPa - - gtp - = -Ty -. -GTyidxFldArPa -( -i -); - -203 -MIRTy - * - gty - = -GlobTabs -:: -GTyTab -(). -GTyFromTyIdx -( -tp -. -f -); - -206 i( - gty --> -GKd -(! -kTyBFld -) { - -209 -MASSERT -( -ty --> -GKd -()== -kTyBFld -, "Un-named bitfieldxpected"); - -210 -ut8 - - gbFdWidth - = -ic_ -< -MIRBFldTy -*>( -ty -)-> -GFldSize -(); - -211 -ut32 - - gbaFdSz - = -GPrimTySize -( -ty --> -GPrimTy -()); - -213 -ut32 - - gign - = -locdBs - ? 1 : -baFdSz -; - -214 -AlignOfft -( -aggrInOfft -, -ign -); - -216 i( - glocdBs - + - gbFdWidth - > ( - gbaFdSz - * 8)) { - -217 - gaggrInOfft -+ -baFdSz -; - -218 - glocdBs - = -bFdWidth -; - -220 - glocdBs - + -bFdWidth -; - -223 - gevInFd - = -curFd -; - -226  - gLmbcMod -:: -InSCڡ -( -VInf -* -pInf -, -MIRSCڡ - & -mSCڡ -, -ut8 -* -d -) { - -227 -USIdx - - gurIdx - = -mSCڡ -. -GVue -(); - -228 aut - g - = -globSTbl -. - -( - -229 -d -:: - -< -ut32 -, std:: -rg ->( -urIdx -, -GlobTabs -:: -GUSTab -(). -GSgFromSIdx -(ustrIdx))); - -230 *(cڡ **) - gd - = - -. -f --> -cd -. -c_r -(); - -233 -le -  - gLmbcMod -:: -InFltCڡ -( -VInf - * -pInf -, -MIRFltCڡ - & -f32Cڡ -, -ut8 -* -d -) { - -234 *(*) - gd - = -f32Cڡ -. -GVue -(); - -237 -le -  - gLmbcMod -:: -InDoubCڡ -( -VInf - * -pInf -, -MIRDoubCڡ - & -f64Cڡ -, -ut8 -* -d -) { - -238 *(*) - gd - = -f64Cڡ -. -GVue -(); - -241  - gLmbcMod -:: -InLblCڡ -( -VInf - * -pInf -, -MIRLblCڡ - & -bCڡ -, -ut8 - * -d -) { - -242 -LabIdx - - gbIdx - = -bCڡ -. -GVue -(); - -243 -LmbcFunc - * - g - = -LkupLmbcFunc -( -bCڡ -. -GPUIdx -()); - -244 -StmtNode -* - gb - = - --> -bM -[ -bIdx -]; - -245 -MASSERT -( -b -, "InitLblConstabelot foound"); - -246 *( - gStmtNode - **) - gd - = -b -; - -249  - gLmbcMod -:: -InICڡ -( -VInf -* -pInf -, -MIRICڡ - & -tCڡ -, -ut8 -* -d -) { - -250 -t64 - - gv - = -tCڡ -. -GExtVue -(); - -251  - gtCڡ -. -GTy -(). -GPrimTy -()) { - -252  - gPTY_i64 -: - -253 *( -t64 -*) -d - = (t64) -v -; - -255  - gPTY_i32 -: - -256 *( -t32 -*) -d - = (t32) -v -; - -258  - gPTY_i16 -: - -259 *( -t16 -*) -d - = (t16) -v -; - -261  - gPTY_i8 -: - -262 *( -t8 -*) -d - = (t8) -v -; - -264  - gPTY_u64 -: - -265 *( -ut64 -*) -d - = (ut64) -v -; - -267  - gPTY_u32 -: - -268 *( -ut32 -*) -d - = (ut32) -v -; - -270  - gPTY_u16 -: - -271 *( -ut16 -*) -d - = (ut16) -v -; - -273  - gPTY_u8 -: - -274 *( -ut8 -*) -d - = (ut8) -v -; - -281  - gLmbcMod -:: -InPorCڡ -( -VInf - * -pInf -, -MIRCڡ - & -mCڡ -) { - -282 -ut8 - * - gd - = -GGlobVInAddr -( -pInf -, -mCڡ -. -GTy -(). -GAlign -()); - -283  - gmCڡ -. -GKd -()) { - -284  - gkCڡAddrof -: - -285 -InAddrofCڡ -( -pInf -, -ic_ -< -MIRAddrofCڡ -&>( -mCڡ -), -d -); - -287  - gkCڡSCڡ -: - -288 -InSCڡ -( -pInf -, -ic_ -< -MIRSCڡ -&>( -mCڡ -), -d -); - -290  - gkCڡI -: { - -291 -InICڡ -( -pInf -, -ic_ -< -MIRICڡ -&>( -mCڡ -), -d -); - -294  - gkCڡAddrofFunc -: - -296 -MASSERT -( -l -, "InPorCڡ %d kd NYI", -mCڡ -. -GKd -()); - -299 -UpdeGlobVInAddr -( -pInf -, -mCڡ -. -GTy -(). -GSize -()); - -302  -SBFldCڡ -( -ut8 -* -baFdAddr -, -ut32 - -baFdSz -, ut32 -bsOfft -, ut8 -bsSize -, -MIRCڡ - & -emCڡ -) { - -303 - gMIRICڡ - & - gtCڡ - = -ic_ -< -MIRICڡ -&>( -emCڡ -); ()intConst; - -304 -t64 - - gv - = -tCڡ -. -GExtVue -(); - -305 -ut64 - - gmask - = ~(0xfffffffffffffff<< -bsSize -); - -306 -ut64 - - gom - = ( -v - & -mask -<< -bsOfft -; - -307 - gmask - = -mask - << -bsOfft -; - -308  - gemCڡ -. -GTy -(). -GPrimTy -()) { - -309  - gPTY_i64 -: - -310 *( -t64 -*) -baFdAddr - = ((*(t64*)baFdAddr& ~( -mask -)| -om -; - -312  - gPTY_i32 -: - -313 *( -t32 -*) -baFdAddr - = ((*(t32*)baFdAddr& ~( -mask -)| -om -; - -315  - gPTY_i16 -: - -316 *( -t16 -*) -baFdAddr - = ((*(t16*)baFdAddr& ~( -mask -)| -om -; - -318  - gPTY_i8 -: - -319 *( -t8 -*) -baFdAddr - = ((*(t8*)baFdAddr& ~( -mask -)| -om -; - -321  - gPTY_u64 -: - -322 *( -ut64 -*) -baFdAddr - = ((*(ut64*)baFdAddr& ~( -mask -)| -om -; - -324  - gPTY_u32 -: - -325 *( -ut32 -*) -baFdAddr - = ((*(ut32*)baFdAddr& ~( -mask -)| -om -; - -327  - gPTY_u16 -: - -328 *( -ut16 -*) -baFdAddr - = ((*(ut16*)baFdAddr& ~( -mask -)| -om -; - -330  - gPTY_u8 -: - -331 *( -ut8 -*) -baFdAddr - = ((*(ut8*)baFdAddr& ~( -mask -)| -om -; - -334 -MASSERT -( -l -, "Unexpectedrimaryype"); - -339  - gLmbcMod -:: -InBFldCڡ -( -VInf - * -pInf -, -MIRCڡ - & -emCڡ -, -t32 - & -locdBs -, -bo - & -fAlign -) { - -340 -ut8 - - gbFdWidth - = -ic_ -< -MIRBFldTy -&>( -emCڡ -. -GTy -()). -GFldSize -(); - -341 i(! - gbFdWidth -) { - -342 - gfAlign - = -ue -; - -345 i( - gfAlign -) { - -346 - gaggrInOfft - +( -locdBs - + 7) >> 3; - -347 - gfAlign - = -l -; - -349 -ut32 - - gbaFdSz - = -GPrimTySize -( -emCڡ -. -GTy -(). -GPrimTy -()); - -350 -ut32 - - gign - = -locdBs - ? 1 : -baFdSz -; - -351 -ut8 -* - gbaFdAddr - = -GGlobVInAddr -( -pInf -, -ign -); - -353 i( - glocdBs - + - gbFdWidth - > ( - gbaFdSz - * 8)) { - -354 - gbaFdAddr - = -baFdAddr - + -baFdSz -; - -355 -SBFldCڡ -( -baFdAddr -, -baFdSz -, 0, -bFdWidth -, -emCڡ -); - -356 - gaggrInOfft -+ -baFdSz -; - -357 - glocdBs - = -bFdWidth -; - -359 -SBFldCڡ -( -baFdAddr -, -baFdSz -, -locdBs -, -bFdWidth -, -emCڡ -); - -360 - glocdBs - + -bFdWidth -; - -364  - gLmbcMod -:: -InAggCڡ -( -VInf - * -pInf -, -MIRCڡ - & -mCڡ -) { - -365 aut& - gTy - = -ic_ -< -MIRSuTy -&>( -mCڡ -. -GTy -()); - -366 aut& - gaggCڡ - = -ic_ -< -MIRAggCڡ -&>( -mCڡ -); - -367 -bo - - gfAlign - = -l -; - -368 -t32 - - glocdBs - = 0; - -370 -AlignOfft -( -aggrInOfft -, -aggCڡ -. -GTy -(). -GAlign -()); - -371 -MIRTyKd - - gevEmKd - = -kTyUnknown -; - -372  -ut32 - - gi - = 0, - gevInFd - = 0; i < - gaggCڡ -. -GCڡVec -(). -size -(); ++i) { - -373 - gMIRCڡ - & - gemCڡ - = * -aggCڡ -. -GCڡVecIm -( -i -); - -374 - gMIRTy - & - gemTy - = -emCڡ -. -GTy -(); - -378 i( - gevEmKd - = -kTyBFld - && -emTy -. -GKd -() != kTypeBitField) { - -379 -fAlign - = -l -; - -380 i( - glocdBs -) { - -381 - gaggrInOfft - +( -locdBs - + 7) >> 3; - -382 - glocdBs - = 0; - -387 i( - gTy -. -GKd -(! -kTyAay -) { - -388 -CheckUmedBFld -( -Ty -, -evInFd -, -aggCڡ -. -GFldIdIm -( -i -), -locdBs -); - -390  - gemTy -. -GKd -()) { - -391  - gkTySr -: - -392 -InSrCڡ -( -pInf -, -emCڡ -); - -394  - gkTySu -: - -395  -kTyUni -: - -396 -InAggCڡ -( -pInf -, -emCڡ -); - -398  - gkTyAay -: - -399 -InAayCڡ -( -pInf -, -emCڡ -); - -401  - gkTyPor -: - -402 -InPorCڡ -( -pInf -, -emCڡ -); - -404  - gkTyBFld -: { - -405 -InBFldCڡ -( -pInf -, -emCڡ -, -locdBs -, -fAlign -); - -409 -MASSERT -( -l -, " suy %d NYI", -emTy -. -GKd -()); - -413 - gevEmKd - = -emTy -. -GKd -(); - -417  - gLmbcMod -:: -InSrCڡ -( -VInf - * -pInf -, -MIRCڡ - & -mCڡ -) { - -418 -ut8 - * - gd - = -GGlobVInAddr -( -pInf -, -mCڡ -. -GTy -(). -GAlign -()); - -419  - gmCڡ -. -GKd -()) { - -420  - gkCڡI -: - -421 -InICڡ -( -pInf -, -ic_ -< -MIRICڡ -&>( -mCڡ -), -d -); - -423  - gkCڡFltCڡ -: - -424 -InFltCڡ -( -pInf -, -ic_ -< -MIRFltCڡ -&>( -mCڡ -), -d -); - -426  - gkCڡDoubCڡ -: - -427 -InDoubCڡ -( -pInf -, -ic_ -< -MIRDoubCڡ -&>( -mCڡ -), -d -); - -429  - gkCڡSCڡ -: - -430 -InSCڡ -( -pInf -, -ic_ -< -MIRSCڡ -&>( -mCڡ -), -d -); - -432  - gkCڡLblCڡ -: - -433 -InLblCڡ -( -pInf -, -ic_ -< -MIRLblCڡ -&>( -mCڡ -), -d -); - -435  - gkCڡS16Cڡ -: - -436  -kCڡAddrof -: - -437  -kCڡAddrofFunc -: - -439 -MASSERT -( -l -, "SϸCڡ Ty %d NYI", -mCڡ -. -GKd -()); - -442 -UpdeGlobVInAddr -( -pInf -, -mCڡ -. -GTy -(). -GSize -()); - -445  - gLmbcMod -:: -InAayCڡ -( -VInf - * -pInf -, -MIRCڡ - & -mCڡ -) { - -446 - gMIRAayTy - & - gyTy - = -ic_ -< -MIRAayTy -&>( -mCڡ -. -GTy -()); - -447 - gMIRAggCڡ - & - gyCt - = -ic_ -< -MIRAggCڡ -&>( -mCڡ -); - -448 -AlignOfft -( -aggrInOfft -, -yTy -. -GAlign -()); - -450 -size_t - - guNum - = -yCt -. -GCڡVec -(). -size -(); - -451 -ut32 - - gdim - = -yTy -. -GSizeAayIm -(0); - -452 -TyIdx - - gsrIdx - = -yTy -. -GEmTyIdx -(); - -453 -MIRTy - * - gsubTy - = -GlobTabs -:: -GTyTab -(). -GTyFromTyIdx -( -srIdx -); - -454 i( - guNum - =0 && -dim - != 0) { - -455  -subTy --> -GKd -(= -kTyAay -) { - -456 -MIRAayTy - * -aSubTy - = -ic_ -( -subTy -); - -457 i( - gaSubTy --> -GSizeAayIm -(0) > 0) { - -458 - gdim - *( -aSubTy --> -GSizeAayIm -(0)); - -460 - gsrIdx - = -aSubTy --> -GEmTyIdx -(); - -461 - gsubTy - = -GlobTabs -:: -GTyTab -(). -GTyFromTyIdx -( -srIdx -); - -464  -size_t - - gi - = 0; i < - guNum -; ++i) { - -465 -MIRCڡ - * - gemCڡ - = -yCt -. -GCڡVecIm -( -i -); - -466 i( -IsPrimiveVe -( -subTy --> -GPrimTy -())) { - -467 -MASSERT -( -l -, "Unexpectedrimitive vector"); - -468 } i( -IsPrimiveSr -( -emCڡ --> -GTy -(). -GPrimTy -())) { - -469 -bo - - grL - = -l -; - -470 i( - gyTy -. -GDim -() == 1) { - -471 -MIRTy - * -y - = -yTy -. -GEmTy -(); - -472 i( - gy --> -GPrimTy -(= -PTY_i8 - || -y -->GPrimTy(= -PTY_u8 -) { - -473 -rL - = -ue -; - -476 -InSrCڡ -( -pInf -, * -emCڡ -); - -477 } i( - gemCڡ --> -GTy -(). -GKd -(= -kTyAay -) { - -478 -InAayCڡ -( -pInf -, * -emCڡ -); - -479 } i( - gemCڡ --> -GTy -(). -GKd -(= -kTySu - || - -480 -emCڡ --> -GTy -(). -GKd -(= -kTyCss - || - -481 -emCڡ --> -GTy -(). -GKd -(= -kTyUni -) { - -482 -InAggCڡ -( -pInf -, * -emCڡ -); - -486 -ASSERT -( -l -, "shouldotun here"); - -491  - gLmbcMod -:: -InAddrofCڡ -( -VInf - * -pInf -, -MIRAddrofCڡ - & -addrofCڡ -, -ut8 -* -d -) { - -492 -StIdx - - gIdx - = -addrofCڡ -. -GSymbIndex -(); - -493 -t32 - - gofft - = -addrofCڡ -. -GOfft -(); - -494 -ut8 - * - gaddr - = -pInf --> -sym --> -IsPUStic -(? -GVAddr -Inf-> -puIdx -, -Idx -) : GetVarAddr(stIdx); - -495 *( - gut8 -**) - gd - = -addr - + -offt -; - -498  - gLmbcMod -:: -InGlobVb -( -VInf - * -pInf -) { - -499 -MIRCڡ - * -mCڡ - = -pInf --> -sym --> -GKڡ -(); - -500 -ut8 - * - gd - = -GGlobVInAddr -( -pInf -, -mCڡ --> -GTy -(). -GAlign -()); - -502  - gmCڡ --> -GKd -()) { - -503  - gkCڡAggCڡ -: - -504 -aggrInOfft - = 0; - -505 -InAggCڡ -( -pInf -, * -mCڡ -); - -507  - gkCڡI -: - -508 -InICڡ -( -pInf -, * -ic_ -< -MIRICڡ -*>( -mCڡ -), -d -); - -510  - gkCڡFltCڡ -: - -511 -InFltCڡ -( -pInf -, * -ic_ -< -MIRFltCڡ -*>( -mCڡ -), -d -); - -513  - gkCڡDoubCڡ -: - -514 -InDoubCڡ -( -pInf -, * -ic_ -< -MIRDoubCڡ -*>( -mCڡ -), -d -); - -516  - gkCڡAddrof -: - -517 -InAddrofCڡ -( -pInf -, * -ic_ -< -MIRAddrofCڡ -*>( -mCڡ -), -d -); - -519  - gkCڡSCڡ -: - -520 -InSCڡ -( -pInf -, * -ic_ -< -MIRSCڡ -*>( -mCڡ -), -d -); - -523 -MASSERT -( -l -, "In MIRCڡy %d NYI", -mCڡ --> -GKd -()); - -526 -UpdeGlobVInAddr -( -pInf -, -mCڡ --> -GTy -(). -GSize -()); - -529  - gLmbcMod -:: -InGlobVs -() { - -531 -this --> -globs - = ( -ut8 -*) -mloc -his-> -globsSize -); - -532 - gthis --> - gglobSticMem - = ( -ut8 -*) -mloc -( -this --> -globSticMemSize -); - -533 -memt -( -this --> -globs -, 0,his-> -globsSize -); - -534 -memt -( -this --> -globSticMem -, 0,his-> -globSticMemSize -); - -537 cڡut - g - : -globAndSticVs -) { - -538 -VInf - * -pInf - = - -. -cd -; - -539 i( - gpInf --> - gsym --> -IsCڡ -()) { - -540 -InGlobVb -( -pInf -); - -545 -le -  - gLmbcMod -:: -AddGlobV -( -MIRSymb - & -sym -, -VInf - * -pInf -) { - -546 - gglobAndSticVs -[ -sym -. -GStIdx -(). -FuIdx -()] = -pInf -; - -549 -le -  - gLmbcMod -:: -AddPUSticV -( -PUIdx - -puIdx -, -MIRSymb - & -sym -, -VInf - * -pInf -) { - -550 - gglobAndSticVs -[( -ut64 -) -puIdx - << 32 | -sym -. -GStIdx -(). -FuIdx -()] = -pInf -; - -554 -ut8 - * - gLmbcMod -:: -GVAddr -( -StIdx - -Idx -) { - -555 aut - - = -globAndSticVs -. -fd -( -Idx -. -FuIdx -()); - -556 -MASSERT -( - - ! -globAndSticVs -. -d -(), "global varot found"); - -557  - gglobs - + - g --> - gcd --> - geIdx -; - -561 -ut8 - * - gLmbcMod -:: -GVAddr -( -PUIdx - -puIdx -, -StIdx - -Idx -) { - -562 aut - g - = -globAndSticVs -. -fd -(() -puIdx - << 32 | -Idx -. -FuIdx -()); - -563 -MASSERT -( - - ! -globAndSticVs -. -d -(), "PUStatic varot found"); - -564  - gglobs - + - g --> - gcd --> - geIdx -; - -567 -LmbcFunc -* - -568 - gLmbcMod -:: -LkupLmbcFunc -( -PUIdx - -puIdx -) { - -569 aut - - = -funcM -. -fd -( -puIdx -); - -570  - g - = -funcM -. -d -()? -nuαr -: - --> -cd -; - -573 - gFuncAddr -:: -FuncAddr -( -bo - -lmbcFunc -, * -func -, -d -:: -rg - -me -, -ut32 - -fmsAggSz -) { - -574 - gfuncName - = -me -; - -575 - gisLmbcFunc - = -lmbcFunc -; - -576 - gfmsAggSize - = -fmsAggSz -; - -577 i( - gisLmbcFunc -) { - -578 - gfuncP -. - glmbcFunc - = ( -LmbcFunc -*) -func -; - -580 - gfuncP -. - gtiveFunc - = -func -; - -585 -ut32 - -GAggFmsSize -( -MIRFuni - * -func -) { - -586 -ut32 - - gtٮSize - = 0; - -587 - gMVe -< - gFmDef -> & - gfmDefVec - = -func --> -GFmDefVec -(); - -588  - gi - = 0; i < - gfmDefVec -. -size -(); i++) { - -589 -MIRTy -* - gty - = -GlobTabs -:: -GTyTab -(). -GTyFromTyIdx -( -fmDefVec -[ -i -]. -fmTyIdx -); - -590 i( - gty --> -GPrimTy -(= -PTY_agg -) { - -591 -tٮSize - + -ty --> -GSize -(); - -594  - gtٮSize -; - -597 -FuncAddr -* - gLmbcMod -:: -GFuncAddr -( -PUIdx - -idx -) { - -598 -FuncAddr - * -ddr -; - -599 i( - gPUIdx2FuncAddr -[ -idx -]) { - -600  - gPUIdx2FuncAddr -[ -idx -]; - -602 -MIRFuni - * - gfunc - = -GlobTabs -:: -GFuniTab -(). -GFuniFromPuidx -( -idx -); - -603 -MASSERT -( -func -, "Functionot found in globalable"); - -604 i( -IsExtFunc -( -idx -, * -this -)) { - -605 - gddr - = -w - -FuncAddr -( -l -, -FdExtFunc -( -idx -), -func --> -GName -(), -GAggFmsSize -(func)); - -607 - gddr - = -w - -FuncAddr -( -ue -, -LkupLmbcFunc -( -idx -), -func --> -GName -()); - -609 - gPUIdx2FuncAddr -[ -idx -] = -ddr -; - -610  - gddr -; - - @lmbc/src/invoke_method.cpp - -15  - ~ - -16  - ~ - -17  - ~ - -18  - ~ - -19  - ~ - -21  - ~"mvue.h -" - -22  - ~"mimty.h -" - -23  - ~"mfuni.h -" - -24  - ~"mexessi.h -" - -26  - ~"codes.h -" - -27  - ~"mas.h -" - -29 -mea - - gm - { - -31 -thad_lol - -ut32 - - g__code_t - = 0; - -32 "C" -ut32 - -__c_code_t -() { - -33  ++ -__code_t -; - -36 cڡ * -tyr -( -PrimTy - -t - -__ibu -(( -unud -)); - -37 cڡ * -tyr -( -PrimTy - -t -) { - -38  - gt -) { - -39  - gPTY_i8 -:  " i8"; - -40  - gPTY_i16 -:  "i16"; - -41  - gPTY_i32 -:  "i32"; - -42  - gPTY_i64 -:  "i64"; - -43  - gPTY_u8 -:  " u8"; - -44  - gPTY_u16 -:  "u16"; - -45  - gPTY_u32 -:  "u32"; - -46  - gPTY_u64 -:  "u64"; - -47  - gPTY_a64 -:  "a64"; - -48  - gPTY_f32 -:  "f32"; - -49  - gPTY_f64 -:  "f64"; - -50  - gPTY_void -:  "---"; - -51  - gkPtyInvid -:  "INV"; - -56 -t64 - -MV2I64 -( -MVue - & -v -) { - -57  - gv -. - gyp -) { - -58  - gPTY_i64 -: - -59  -v -. -x -. -i64 -; - -60  - gPTY_i32 -: - -61  ( -t64 -) -v -. -x -. -i32 -; - -62  - gPTY_i16 -: - -63  ( -t64 -) -v -. -x -. -i16 -; - -64  - gPTY_i8 -: - -65  ( -t64 -) -v -. -x -. -i8 -; - -66  - gPTY_u32 -: - -67  ( -t64 -) -v -. -x -. -u32 -; - -69 -MASSERT -( -l -, "MVuty %d f i64 cvsi NYI", -v -. -yp -); - -73  - #MMASK1 - 0xffu - - ) - -74  - #MMASK2 - 0xffffu - - ) - -75  - #MMASK3 - 0xffffffffu - - ) - -77  -mld -( -ut8 -* -addr -, -PrimTy - -yp -, -MVue -& -s -, -size_t - -aggSize -=0) { - -78 -s -. -yp - =typ; - -79  - gyp -) { - -80  - gPTY_i8 -: - -81 -s -. -x -. -i64 - = *( -t8 - *) -addr -; - -83  - gPTY_i16 -: - -84 -s -. -x -. -i64 - = *( -t16 - *) -addr -; - -86  - gPTY_i32 -: - -87 -s -. -x -. -i64 - = *( -t32 - *) -addr -; - -89  - gPTY_i64 -: - -90 -s -. -x -. -i64 - = *( -t64 - *) -addr -; - -92  - gPTY_u8 -: - -93 -s -. -x -. -u64 - = *( -ut8 - *) -addr -; - -95  - gPTY_u16 -: - -96 -s -. -x -. -u64 - = *( -ut16 - *) -addr -; - -98  - gPTY_u32 -: - -99 -s -. -x -. -u64 - = *( -ut32 - *) -addr -; - -101  - gPTY_u64 -: - -102 -s -. -x -. -u64 - = *( -ut64 - *) -addr -; - -104  - gPTY_f32 -: - -105 -s -. -x -. -f32 - = *(*) -addr -; - -107  - gPTY_f64 -: - -108 -s -. -x -. -f64 - = *(*) -addr -; - -110  - gPTY_a64 -: - -111 -s -. -x -. -a64 - = *( -ut8 - **) -addr -; - -113  - gPTY_agg -: - -115 -s -. -x -. -a64 - = -addr -; - -116 - gs -. - gaggSize - = -aggSize -; - -119 -MASSERT -( -l -, "mldty%d NYI", -yp -); - -124  -me -( -ut8 -* -addr -, -PrimTy - -yp -, -MVue -& -v -, -bo - -toVArgSck - = -l -) { - -125 i(! -IsPrimiveIeg -( -yp -|| !IsPrimiveIeg( -v -.ptyp)) { - -126 -MASSERT -( -yp - = -v -.ptyp || - -127 -yp - = -PTY_a64 - && -v -.y= -PTY_u64 - || - -128 -yp - = -PTY_u64 - && -v -.y= -PTY_a64 -, - -129 "mܐty mismch: %dnd %d", -yp -, -v -.ptyp); - -131  - gyp -) { - -132  - gPTY_i8 -: - -133 *( -t8 - *) -addr - = -v -. -x -. -i8 -; - -135  - gPTY_i16 -: - -136 *( -t16 - *) -addr - = -v -. -x -. -i16 -; - -138  - gPTY_i32 -: - -139 *( -t32 - *) -addr - = -v -. -x -. -i32 -; - -141  - gPTY_i64 -: - -142 *( -t64 - *) -addr - = -v -. -x -. -i64 -; - -144  - gPTY_u8 -: - -145 *( -ut8 - *) -addr - = -v -. -x -. -u8 -; - -147  - gPTY_u16 -: - -148 *( -ut16 - *) -addr - = -v -. -x -. -u16 -; - -150  - gPTY_u32 -: - -151 *( -ut32 - *) -addr - = -v -. -x -. -u32 -; - -153  - gPTY_u64 -: - -154 *( -ut64 - *) -addr - = -v -. -x -. -u64 -; - -156  - gPTY_f32 -: - -157 *(*) -addr - = -v -. -x -. -f32 -; - -159  - gPTY_f64 -: - -160 *(*) -addr - = -v -. -x -. -f64 -; - -162  - gPTY_a64 -: - -163 *( -ut8 - **) -addr - = -v -. -x -. -a64 -; - -165  - gPTY_agg -: - -166 i( -toVArgSck -) { - -167 i( -v -. -aggSize - > 16) { - -168 *( -ut8 - **) -addr - = -v -. -x -. -a64 -; - -170 -memy -( -addr -, -v -. -x -. -a64 -, v. -aggSize -); - -174 -MASSERT -( -v -. -aggSize - <= 16, "mstoregg > 16"); - -175 -memy -( -addr -, &( -v -. -x -. -u64 -), v. -aggSize -); - -179 -MASSERT -( -l -, "mܐy%d NYI", -yp -); - -184 -bo - -IsZo -( -MVue -& -cd -) { - -185  - gcd -. - gyp -) { - -186  - gPTY_u8 -:  -cd -. -x -. -u8 - == 0; - -187  - gPTY_u16 -:  -cd -. -x -. -u16 - == 0; - -188  - gPTY_u32 -:  -cd -. -x -. -u32 - == 0; - -189  - gPTY_u64 -:  -cd -. -x -. -u64 - == 0; - -190  - gPTY_i8 -:  -cd -. -x -. -i8 - == 0; - -191  - gPTY_i16 -:  -cd -. -x -. -i16 - == 0; - -192  - gPTY_i32 -:  -cd -. -x -. -i32 - == 0; - -193  - gPTY_i64 -:  -cd -. -x -. -i64 - == 0; - -194 : -MASSERT -( -l -, "IsZty %d NYI", -cd -. -yp -); - -198 -bo - - -199 -RegAssignZextOrSext -( -MVue -& -om -, -PrimTy - -toTyp -, MVue& -to -) { - -200  - gtoTyp -) { - -201  - gPTY_u8 -: - -202  -om -. -yp -) { - -203  -PTY_u32 -: -to -. -x -. -u8 - = -om -.x. -u32 -; ; - -204 :  -l -; - -207  - gPTY_u32 -: - -208  -om -. -yp -) { - -209  -PTY_u8 -: -to -. -x -. -u64 - = -om -.x. -u8 -; ; - -210  - gPTY_u16 -: -to -. -x -. -u64 - = -om -.x. -u16 -; ; - -211  - gPTY_i32 -: -to -. -x -. -u64 - = -om -.x. -i32 -; ; - -212 :  -l -; - -215  - gPTY_i32 -: - -216  -om -. -yp -) { - -217  -PTY_i8 -: -to -. -x -. -i64 - = -om -.x. -i8 -; ; - -218  - gPTY_i16 -: -to -. -x -. -i64 - = -om -.x. -i16 -; ; - -219  - gPTY_u32 -: -to -. -x -. -i64 - = -om -.x. -u32 -; ; - -220 :  -l -; - -223  - gPTY_u64 -: - -224  -om -. -yp -) { - -225  -PTY_u8 -: -to -. -x -. -u64 - = -om -.x. -u8 -; ; - -226  - gPTY_u16 -: -to -. -x -. -u64 - = -om -.x. -u16 -; ; - -227  - gPTY_u32 -: -to -. -x -. -u64 - = -om -.x. -u32 -; ; - -228  - gPTY_i64 -: -to -. -x -. -u64 - = -om -.x. -i64 -; ; - -229 :  -l -; - -232  - gPTY_i64 -: - -233  -om -. -yp -) { - -234  -PTY_i8 -: -to -. -x -. -i64 - = -om -.x. -i8 -; ; - -235  - gPTY_i16 -: -to -. -x -. -i64 - = -om -.x. -i16 -; ; - -236  - gPTY_i32 -: -to -. -x -. -i64 - = -om -.x. -i32 -; ; - -237 :  -l -; - -240  - gPTY_i16 -: - -241  -om -. -yp -) { - -242  -PTY_i32 -: -to -. -x -. -i16 - = -om -.x. -i32 -; ; - -243  - gPTY_u16 -: -to -. -x -. -i16 - = -om -.x. -u16 -; ; - -244 :  -l -; - -247  - gPTY_u16 -: - -248  -om -. -yp -) { - -249  -PTY_u32 -: -to -. -x -. -u16 - = -om -.x. -i32 -; ; - -250 :  -l -; - -254  -l -; - -257 - gto -. - gyp - = -toTyp -; - -258  - gue -; - -261  - #CASE_TOPTYP -( -toPtyp -, -toCtyp -) \ - -262  -PTY_ -## -toPtyp -: \ - -263 i( -cvtI - -s -. -x -. -toPtyp - = ( -toCtyp -) -omI -; \ - -264 i( -cvtUt - -s -. -x -. -toPtyp - = ( -toCtyp -) -omUt -; \ - -265 i( -cvtf32 - -s -. -x -. -toPtyp - = ( -toCtyp -) -omFlt -; \ - -266 i( -cvtf64 - -s -. -x -. -toPtyp - = ( -toCtyp -) -omDoub -; \ - -267 ; - - ) - -269 -MVue - -CvtTy -(MVu& -nd -, -PrimTy - -toPtyp -, PrimTy -omPtyp -) { - -270 -MVue - - gs -; - -271 -t64 - - gomI -; - -272 -ut64 - - gomUt -; - -273  - gomFlt -; - -274  - gomDoub -; - -275 -bo - - gcvtI - = -l -; - -276 -bo - - gcvtUt - = -l -; - -277 -bo - - gcvtf32 - = -l -; - -278 -bo - - gcvtf64 - = -l -; - -280 i( - gnd -. - gyp - = -toPtyp -) { - -281  -nd -; - -283  - gomPtyp -) { - -284  - gPTY_i8 -: -omI - = -nd -. -x -. -i8 -; - gcvtI - = -ue -; ; - -285  - gPTY_i16 -: -omI - = -nd -. -x -. -i16 -; - gcvtI - = -ue -; ; - -286  - gPTY_i32 -: -omI - = -nd -. -x -. -i32 -; - gcvtI - = -ue -; ; - -287  - gPTY_i64 -: -omI - = -nd -. -x -. -i64 -; - gcvtI - = -ue -; ; - -288  - gPTY_u8 -: -omUt - = -nd -. -x -. -u8 -; - gcvtUt - -ue -; ; - -289  - gPTY_u16 -: -omUt - = -nd -. -x -. -u16 -; - gcvtUt - -ue -; ; - -290  - gPTY_u32 -: -omUt - = -nd -. -x -. -u32 -; - gcvtUt - -ue -; ; - -291  - gPTY_u64 -: -omUt - = -nd -. -x -. -u64 -; - gcvtUt - -ue -; ; - -292  - gPTY_a64 -: -omUt - = -nd -. -x -. -u64 -; - gcvtUt - -ue -; ; - -293  - gPTY_r -: -omUt - = -nd -. -x -. -u64 -; - gcvtUt - -ue -; ; - -294  - gPTY_f32 -: -omFlt - = -nd -. -x -. -f32 -; - gcvtf32 - = -ue -; ; - -295  - gPTY_f64 -: -omDoub - -nd -. -x -. -f64 -; - gcvtf64 - = -ue -; ; - -296 : -MASSERT -( -l -, "OP_cvomty%d NYI", -omPtyp -); ; - -298  - gtoPtyp -) { - -299 -CASE_TOPTYP -( -i8 -, -t8 -) - -300 -CASE_TOPTYP -( -i16 -, -t16 -) - -301 -CASE_TOPTYP -( -i32 -, -t32 -) - -302 -CASE_TOPTYP -( -i64 -, -t64 -) - -303 -CASE_TOPTYP -( -u8 -, -ut8 -) - -304 -CASE_TOPTYP -( -u16 -, -ut16 -) - -305 -CASE_TOPTYP -( -u32 -, -ut32 -) - -306 -CASE_TOPTYP -( -u64 -, -ut64 -) - -307 -CASE_TOPTYP -( -f32 -, ) - -308 -CASE_TOPTYP -( -f64 -, ) - -309  - gPTY_a64 -: - -310 i( -cvtI -) - -311 -s -. -x -. -a64 - = ( -ut8 -*) -omI -; - -312 i( - gcvtUt -) - -313 - gs -. - gx -. - ga64 - = ( -ut8 -*) -omUt -; - -315 -MASSERT -( -l -, "OP_cvt:y %d%d su܋d", -omPtyp -, -toPtyp -); - -317 : -MASSERT -( -l -, "OP_cvt:y %d%d NYI", -omPtyp -, -toPtyp -); - -319 - gs -. - gyp - = -toPtyp -; - -320  - gs -; - -324 -LdArgs -( -MFuni -& -func -) { - -325  - gi -=0; i < - gfunc -. - gfo --> - gfmsNum -; ++i) { - -326 i( - gfunc -. - gfo --> - gpos2Pm -[ -i -]-> - gisPg -) { - -327 - gfunc -. - gpRegs -[ -func -. -fo --> -pos2Pm -[ -i -]-> - geIdx -] = func. -Δ --> -Args -[i]; - -329 - gfunc -. - gfmVs -[ -func -. -fo --> -pos2Pm -[ -i -]-> - geIdx -] = func. -Δ --> -Args -[i]; - -334 -bo - -ComFlt -( -x -,  -y -,  -s - = 0.00000001f) { - -335 i( -isf -( -x -&& isf( -y -)) { - -336  -ue -; - -338  ( -bs -( -x - - -y -< - gs -? - gue - : -l -; - -341 -le - -bo - -ComDoub -( -x -,  -y -,  -s - = 0.0000000000000001f) { - -342 i( -isf -( -x -&& isf( -y -)) { - -343  -ue -; - -345  ( -bs -( -x - - -y -< - gs -? - gue - : -l -; - -348  -HdFltEq -( -Opcode - - -, -PrimTy - -ndTy -, -MVue - & -s -, MVu& -1 -, MVu& -2 -) { - -349 -MASSERT -( -ndTy - = -1 -. -yp - && op1.y= -2 -.ptyp, "Operandype mismatch %d %d", op1.ptyp, op2.ptyp); - -350  - g -) { - -351  - gOP_ -: - -352 i( -ndTy - = -PTY_f32 -) { - -353 -s -. -x -. -i64 - = ! -ComFlt -( -1 -.x. -f32 -, -2 -.x.f32); - -354 } i( - gndTy - = -PTY_f64 -) { - -355 -s -. -x -. -i64 - = ! -ComDoub -( -1 -.x. -f64 -, -2 -.x.f64); - -357 -MASSERT -( -l -, "Unexpectedype"); - -360  - gOP_eq -: - -361 i( -ndTy - = -PTY_f32 -) { - -362 -s -. -x -. -i64 - = -ComFlt -( -1 -.x. -f32 -, -2 -.x.f32); - -363 } i( - gndTy - = -PTY_f64 -) { - -364 -s -. -x -. -i64 - = -ComDoub -( -1 -.x. -f64 -, -2 -.x.f64); - -366 -MASSERT -( -l -, "Unexpectedype"); - -374 -ut32 - -GVaArgSize -( -MFuni - & -Δ -,  -numArgs -, -LmbcFunc - * -Info -) { - -375 -ut32 - - gvaArgSize - = 0; - -376  - gi - = -Info --> -fmsNum -; i < - gnumArgs -; ++i) { - -377 i( - gΔ -. - gArgs -[ -i -]. - gyp - ! -PTY_agg - || -Δ -. -Args -[i]. -aggSize - > 16 ) { - -378 -vaArgSize - += 8; - -380 - gvaArgSize - + -Δ -. -Args -[ -i -]. -aggSize -; - -383  - gvaArgSize -; - -386  -SupVaArg -( -MFuni - & -Δ -,  -numArgs -, -LmbcFunc - * -Info -) { - -387  - gi - = -Info --> -fmsNum -, - gofft - = 0; i < - gnumArgs -; ++i) { - -388 -me -( -Δ -. -vaArgs - + -offt -, cr. -Args -[ -i -]. -yp -, cr.Args[i], -ue -); - -389 i( - gΔ -. - gArgs -[ -i -]. - gyp - ! -PTY_agg - || -Δ -. -Args -[i]. -aggSize - > 16 ) { - -390 -offt - += 8; - -392 - gofft - + -Δ -. -Args -[ -i -]. -aggSize -; - -398 -MVue - -InvokeFunc -( -LmbcFunc -* - -, -MFuni - * -Δ -) { - -399 -MVue - - gtV -; - -400 -MVue - - gegs -[ - --> -numPgs -]; - -401 -MVue - - gfmVs -[ - --> -fmsNumVs -+1]; - -402 -igs -(8 -ut8 - - game -[ - --> -ameSize -]; - -403 -MFuni - -mfunc -( - -, -Δ -, -ame -, -egs -, -fmVs -); - -405 * cڡ - gbs -[] = { - -406 && -b_OP_Undef -, - -407  - #OPCODE -( -ba_node -, -dummy1 -, -dummy2 -, -dummy3 -&& -b_OP_ -##ba_node, - - ) - -408  - ~"codes.def -" - -409 #unde -OPCODE - - -410 && -b_OP_Undef - - -413 -LdArgs -( -mfunc -); - -414 - gmfunc -. - gloMem - = -ic_ -< -ut8 -*>( -lo -( -ALLOCA_MEMMAX -)); - -416 -StmtNode - * - gmt - = -mfunc -. -xtStmt -; - -417 *( - gbs -[ -mt --> - -]); - -419 - gb_OP_Undef -: - -421 -MASSERT -( -l -, "Hit OP_undef"); - -423 - gb_OP_block -: - -425 -mt - = -ic_ -< -BlockNode -*>(mt)-> -GF -(); - -426 - gmfunc -. - gxtStmt - = -mt -; - -427 *( - gbs -[ -mt --> - -]); - -429 - gb_OP_ssignoff -: - -431 -IassignFPoffNode -* -node - = -ic_ -( -mt -); - -432 -t32 - - gofft - -node --> -GOfft -(); - -433 -BaNode -* - grhs - = -node --> -GRHS -(); - -434 -MVue - - gv - = -EvEx -( -mfunc -, -rhs -); - -435 -PrimTy - - gyp - = -node --> -yp -; - -436 -me -( -mfunc -. - -+ -offt -, -yp -, -v -); - -438 - gmt - = -mt --> -GNext -(); - -439 - gmfunc -. - gxtStmt - = -mt -; - -440 *( - gbs -[ -mt --> - -]); - -441 - gb_OP_ -: - -443 -ClNode - * - - = -ic_ -( -mt -); - -444 -MVue - - gArgs -[ - --> -NumOds -()]; - -445 - gmfunc -. - gArgs - = -Args -; - -446 - gmfunc -. - gnumClArgs - = - --> -NumOds -(); - -447 i( -IsExtFunc -( - --> -GPUIdx -(), * -mfunc -. -fo --> -lmbcMod -)) { - -448 - gmfunc -. -ClExtFuncDe -( - -); - -450 - gmfunc -. -ClMFuncDe -( - -); - -453 - gmt - = -mt --> -GNext -(); - -454 - gmfunc -. - gxtStmt - = -mt -; - -455 *( - gbs -[ -mt --> - -]); - -456 - gb_OP_gassign -: - -458 -RegassignNode -* -node - = -ic_ -( -mt -); - -459 -PgIdx - - ggIdx - = -node --> -GRegIdx -(); - -460 -MVue - - grhs - = -EvEx -( -mfunc -, -node --> -GRHS -()); - -461 i( - gnode --> - gyp - = -rhs -. -yp -) { - -462 -MASSERT -( -gIdx - !- -kSgRv1 -, "regassigno %%%%retval1"); - -463 i( - ggIdx - =- -kSgRv0 -) { - -464 i( -node --> -yp - ! -PTY_agg -) { - -465 -Δ --> -tV0 - = -rhs -; - -469 -MASSERT -( -rhs -. -aggSize - <= 16, "regassign ofgg >16 byteso %%retval0"); - -470 -ut64 - - gtv -[2] = {0, 0}; - -471 -memy -( -tv -, -rhs -. -x -. -a64 -,hs. -aggSize -); - -472 - gΔ --> - gtV0 -. - gx -. - gu64 - = -tv -[0]; - -473 - gΔ --> - gtV0 -. - gyp - = -PTY_agg -; - -474 - gΔ --> - gtV0 -. - gaggSize - = -rhs -. -aggSize -; - -475 i( - grhs -. - gaggSize - > 8) { - -476 - gΔ --> - gtV1 -. - gx -. - gu64 - = -tv -[1]; - -477 - gΔ --> - gtV1 -. - gyp - = -PTY_agg -; - -478 - gΔ --> - gtV1 -. - gaggSize - -rhs -. -aggSize -; - -482 -MASSERT -( -gIdx - < - --> -numPgs -, "regassignegIdx %d out of bound",egIdx); - -483 - gmfunc -. - gpRegs -[ -gIdx -] = -rhs -; - -486 -bo - - gexnded - = -l -; - -487 i( - ggIdx - =- -kSgRv0 -) { - -488 -exnded - = -RegAssignZextOrSext -( -rhs -, -node --> -yp -, -Δ --> -tV0 -); - -489 } i( - ggIdx - =- -kSgRv1 -) { - -490 -exnded - = -RegAssignZextOrSext -( -rhs -, -node --> -yp -, -Δ --> -tV1 -); - -492 -MASSERT -( -gIdx - < - --> -numPgs -, "regassignegIdx %d out of bound",egIdx); - -493 - gexnded - = -RegAssignZextOrSext -( -rhs -, -node --> -yp -, -mfunc -. -pRegs -[ -gIdx -]); - -495 i(! - gexnded -) { - -496 i(( - gnode --> - gyp - = -PTY_a64 - || -node --> -yp - = -PTY_u64 -) && - -497 ( -rhs -. -yp - = -PTY_a64 - ||hs.y= -PTY_u64 -)) { - -498 -mfunc -. -pRegs -[ -gIdx -] = -rhs -; - -499 - gmfunc -. - gpRegs -[ -gIdx -]. - gyp - = -node --> -yp -; - -502 - gmfunc -. - gpRegs -[ -gIdx -] = -CvtTy -( -rhs -, -node --> -yp -,hs.ptyp); - -507 - gmt - = -mt --> -GNext -(); - -508 - gmfunc -. - gxtStmt - = -mt -; - -509 *( - gbs -[ -mt --> - -]); - -510 - gb_OP_brl -: - -511 -b_OP_brue -: - -513 -CdGoNode -* -node - = -ic_ -( -mt -); - -514 -ut32 - - gbIdx - = -node --> -GOfft -(); ()labelIdx; - -515 -MVue - - gcd - = -EvEx -( -mfunc -, -node --> -GRHS -()); - -516 -StmtNode -* - gb - = - --> -bM -[ -bIdx -]; - -517 i( - gmt --> - g - = -OP_brl - && -IsZo -( -cd -) -mt - = -b -; - -518 i( - gmt --> - g - = -OP_brue - && ! -IsZo -( -cd -) -mt - = -b -; - -520 - gmt - = -mt --> -GNext -(); - -521 - gmfunc -. - gxtStmt - = -mt -; - -522 *( - gbs -[ -mt --> - -]); - -523 - gb_OP_b -: - -525 -mt - = stmt-> -GNext -(); - -526 - gmfunc -. - gxtStmt - = -mt -; - -527 *( - gbs -[ -mt --> - -]); - -528 - gb_OP_go -: - -530 -ut32 - -bIdx - = -ic_ -< -GoNode -*>( -mt -)-> -GOfft -(); - -531 -StmtNode -* - gb - = - --> -bM -[ -bIdx -]; - -532 - gmt - = -b -; - -534 - gmt - = -mt --> -GNext -(); - -535 - gmfunc -. - gxtStmt - = -mt -; - -536 *( - gbs -[ -mt --> - -]); - -537 - gb_OP_tu -: - -538  -Δ --> -tV0 -; - -539 - gb_OP_ssignoff -: - -541 -IassignoffNode -* -node - = -ic_ -( -mt -); - -542 -t32 - - gofft - = -node --> -GOfft -(); - -543 -MVue - - gaddr - = -EvEx -( -mfunc -, -node --> -Od -(0)); - -544 -MVue - - grhs - = -EvEx -( -mfunc -, -node --> -Od -(1)); - -545 -me -( -addr -. -x -. -a64 - + -offt -, -mt --> -yp -, -rhs -); - -547 - gmt - = -mt --> -GNext -(); - -548 - gmfunc -. - gxtStmt - = -mt -; - -549 *( - gbs -[ -mt --> - -]); - -550 - gb_OP_blkassignoff -: - -552 -BlkassignoffNode -* -node - = -ic_ -( -mt -); - -554 -t32 - - gdOfft - = -node --> -offt -; - -555 -t32 - - gblkSize - = -node --> -blockSize -; - -556 -MVue - - gdAddr - = -EvEx -( -mfunc -, -node --> -Od -(0)); - -557 -MVue - - gcAddr - = -EvEx -( -mfunc -, -node --> -Od -(1)); - -558 -memy -( -dAddr -. -x -. -a64 - + -dOfft -, -cAddr -.x.a64, -blkSize -); - -560 - gmt - = -mt --> -GNext -(); - -561 - gmfunc -. - gxtStmt - = -mt -; - -562 *( - gbs -[ -mt --> - -]); - -563 - gb_OP_iδo -: - -565 -INode - * -iδo - = -ic_ -( -mt -); - -566 -MASSERT -( -iδo --> -NumOds -() > 0, "icallprotoum operands is %ld", icallproto->NumOpnds()); - -568 -MVue - - gArgs -[ -iδo --> -NumOds -()-1]; - -569 - gmfunc -. - gArgs - = -Args -; - -570 - gmfunc -. - gnumClArgs - = -iδo --> -NumOds -()-1; - -572 -MVue - - gAddr - = -EvEx -( -mfunc -, -iδo --> -Od -(0)); - -573 -FuncAddr - * - gddr - = -t_ -( -Addr -. -x -. -a64 -); - -574 i( - gddr --> - gisLmbcFunc -) { - -575 - gmfunc -. -ClMFuncInde -( -iδo -, -ddr --> -funcP -. -lmbcFunc -); - -577 - gmfunc -. -ClExtFuncInde -( -iδo -, -ddr --> -funcP -. -tiveFunc -); - -580 - gmt - = -mt --> -GNext -(); - -581 - gmfunc -. - gxtStmt - = -mt -; - -582 *( - gbs -[ -mt --> - -]); - -583 - gb_OP_ngego -: - -585 -RgeGoNode - * -rgo - = -ic_ -( -mt -); - -586 -t32 - - ggOfft - = -rgo --> -GTagOfft -(); - -587 -MVue - - gnd - = -EvEx -( -mfunc -, -rgo --> -Od -(0)); - -588 -t64 - - gg - = -MV2I64 -( -nd -); - -589 -ut32 - - gbIdx - = -rgo --> -GRgeGoTabIm -( -g - - -gOfft -). -cd -; - -590 -StmtNode - * - gb - = - --> -bM -[ -bIdx -]; - -591 - gmt - = -b -; - -593 - gmt - = -mt --> -GNext -(); - -594 - gmfunc -. - gxtStmt - = -mt -; - -595 *( - gbs -[ -mt --> - -]); - -596 - gb_OP_igo -: - -598 -MVue - -nd - = -EvEx -( -mfunc -, -mt --> -Od -(0)); - -599 -StmtNode - * - gb - = (StmtNode*) -nd -. -x -. -a64 -; - -600 - gmt - = -b -; - -602 - gmt - = -mt --> -GNext -(); - -603 - gmfunc -. - gxtStmt - = -mt -; - -604 *( - gbs -[ -mt --> - -]); - -605 - gb_OP_sic -: - -607 -mfunc -. -ClIrsic -(* -ic_ -< -IrsicNode -*>( -mt -)); - -609 - gmt - = -mt --> -GNext -(); - -610 - gmfunc -. - gxtStmt - = -mt -; - -611 *( - gbs -[ -mt --> - -]); - -613 - gb_OP_dassign -: - -614 -b_OP_pssign -: - -615 -b_OP_maydassign -: - -616 -b_OP_ssign -: - -617 -b_OP_do -: - -618 -b_OP_dowhe -: - -619 -b_OP_if -: - -620 -b_OP_whe -: - -621 -b_OP_swch -: - -622 -b_OP_muiway -: - -623 -b_OP_fܗchem -: - -624 -b_OP_commt -: - -625 -b_OP_ev -: - -626 -b_OP_ -: - -627 -b_OP_lsge -: - -628 -b_OP_ls -: - -629 -b_OP_asge -: - -630 -b_OP_as -: - -631 -b_OP_as -: - -632 -b_OP_tuas -: - -633 -b_OP_assigs -: - -634 -b_OP_abt -: - -635 -b_OP_asnnu -: - -636 -b_OP_assigsnnu -: - -637 -b_OP_asnnu -: - -638 -b_OP_tuasnnu -: - -639 -b_OP_dad -: - -640 -b_OP_d -: - -641 -b_OP_addrof -: - -642 -b_OP_ddrof -: - -643 -b_OP_sizeoy -: - -644 -b_OP_fldsdi -: - -645 -b_OP_y -: - -646 -b_OP_vtu -: - -647 -b_OP_surass -: - -648 -b_OP_r -: - -649 -b_OP_cuom -: - -650 -b_OP_pymphic -: - -651 -b_OP_i -: - -652 -b_OP_ri -: - -653 -b_OP_vtui -: - -654 -b_OP_sicwhty -: - -655 -b_OP_xsic -: - -656 -b_OP_assigd -: - -657 -b_OP_vtuassigd -: - -658 -b_OP_surassassigd -: - -659 -b_OP_rassigd -: - -660 -b_OP_cuomassigd -: - -661 -b_OP_pymphicassigd -: - -662 -b_OP_iassigd -: - -663 -b_OP_riassigd -: - -664 -b_OP_vtuiassigd -: - -665 -b_OP_sicassigd -: - -666 -b_OP_sicwhtyassigd -: - -667 -b_OP_xsicassigd -: - -668 -b_OP_Κt -: - -669 -b_OP_Κssigd -: - -670 -b_OP_vtuΚt -: - -671 -b_OP_vtuΚssigd -: - -672 -b_OP_surassΚt -: - -673 -b_OP_surassΚssigd -: - -674 -b_OP_rΚt -: - -675 -b_OP_rΚssigd -: - -676 -b_OP_jry -: - -677 -b_OP_y -: - -678 -b_OP_ry -: - -679 -b_OP_throw -: - -680 -b_OP_jstch -: - -681 -b_OP_tch -: - -682 -b_OP_ptch -: - -683 -b_OP_fly -: - -684 -b_OP_nury -: - -685 -b_OP_dy -: - -686 -b_OP_ -: - -687 -b_OP_d -: - -688 -b_OP_un -: - -689 -b_OP_dun -: - -690 -b_OP_gosub -: - -691 -b_OP_tsub -: - -692 -b_OP_syn -: - -693 -b_OP_synx -: - -694 -b_OP_deef -: - -695 -b_OP_ef -: - -696 -b_OP_deeet -: - -697 -b_OP_membacque -: - -698 -b_OP_memba -: - -699 -b_OP_membܖd -: - -700 -b_OP_membee -: - -701 -b_OP_doff -: - -702 -b_OP_doff -: - -703 -b_OP_gad -: - -704 -b_OP_addroffunc -: - -705 -b_OP_addroab -: - -706 -b_OP_cڡv -: - -707 -b_OP_cڡr -: - -708 -b_OP_cڡr16 -: - -709 -b_OP_ -: - -710 -b_OP_cvt -: - -711 -b_OP_o -: - -712 -b_OP_ty -: - -713 -b_OP_round -: - -714 -b_OP_unc -: - -715 -b_OP_abs -: - -716 -b_OP_bn -: - -717 -b_OP_ -: - -718 -b_OP_g -: - -719 -b_OP_c -: - -720 -b_OP_sq -: - -721 -b_OP_xt -: - -722 -b_OP_zext -: - -723 -b_OP_lo -: - -724 -b_OP_mloc -: - -725 -b_OP_gcmloc -: - -726 -b_OP_gmloc -: - -727 -b_OP_ackmloc -: - -728 -b_OP_gcmlocjy -: - -729 -b_OP_gmlocjy -: - -730 -b_OP_ackmlocjy -: - -731 -b_OP_sverfunc -: - -732 -b_OP_svevtufunc -: - -733 -b_OP_add -: - -734 -b_OP_sub -: - -735 -b_OP_mul -: - -736 -b_OP_div -: - -737 -b_OP_m -: - -738 -b_OP_ashr -: - -739 -b_OP_lshr -: - -740 -b_OP_shl -: - -741 -b_OP_r -: - -742 -b_OP_max -: - -743 -b_OP_m -: - -744 -b_OP_bd -: - -745 -b_OP_bi -: - -746 -b_OP_bx -: - -747 -b_OP_CG_y_em_add -: - -748 -b_OP_eq -: - -749 -b_OP_ge -: - -750 -b_OP_gt -: - -751 -b_OP_ -: - -752 -b_OP_ -: - -753 -b_OP_ -: - -754 -b_OP_cmp -: - -755 -b_OP_cm -: - -756 -b_OP_cmpg -: - -757 -b_OP_nd -: - -758 -b_OP_li -: - -759 -b_OP_nd -: - -760 -b_OP_ci -: - -761 -b_OP_ -: - -762 -b_OP_sic -: - -763 -b_OP_sicwhty -: - -764 -b_OP_exabs -: - -765 -b_OP_dosbs -: - -766 -b_OP_ssigcoff -: - -767 -b_OP_dpcoff -: - -768 -b_OP_checkpot -: - -769 -b_OP_addrofc -: - -770 -b_OP_asm -: - -771 -b_OP_dadoff -: - -772 -b_OP_addrofoff -: - -773 -b_OP_dassignoff -: - -774 -b_OP_ssignoff -: - -775 -b_OP_iδssigd -: - -777 -MASSERT -( -l -, "NIY"); - -780  - gtV -; - -783 -MVue - -EvEx -( -MFuni -& -func -, -BaNode -* -ex -, -PmInf - * -rm -) { - -784 -MVue - - gs -; - -786 * cڡ - gbs -[] = { - -787 && -b_OP_Undef -, - -788  - #OPCODE -( -ba_node -, -dummy1 -, -dummy2 -, -dummy3 -&& -b_OP_ -##ba_node, - - ) - -789  - ~"codes.def -" - -790 #unde -OPCODE - - -791 && -b_OP_Undef - - -794 *( - gbs -[ -ex --> - -]); - -795 - gb_OP_Undef -: - -797 -MASSERT -( -l -, "Hit OP_undef"); - -799 - gb_OP_cڡv -: - -801 -MIRCڡ -* -cڡv - = -ic_ -< -CڡvNode -*>( -ex -)-> -GCڡV -(); - -802 -t64 - - gcڡI - = 0; - -803  - gcڡFlt - = 0; - -804  - gcڡDoub - = 0; - -805  - gcڡv --> -GKd -()) { - -806  - gkCڡI -: - -807 -cڡI - = -ic_ -< -MIRICڡ - *>( -cڡv -)-> -GExtVue -(); - -809  - gkCڡDoubCڡ -: - -810 -cڡDoub - = -ic_ -< -MIRDoubCڡ - *>( -cڡv -)-> -GVue -(); - -812  - gkCڡFltCڡ -: - -813 -cڡFlt - = -ic_ -< -MIRFltCڡ - *>( -cڡv -)-> -GVue -(); - -816 -MASSERT -( -l -, "cڡv kd %d NYI", -cڡv --> -GKd -()); - -819 -PrimTy - - gyp - = -ex --> -yp -; - -820  - gyp -) { - -821  - gPTY_i8 -: - -822  -PTY_i16 -: - -823  -PTY_i32 -: - -824  -PTY_i64 -: - -825 -MASSERT -( -cڡv --> -GKd -(= -kCڡI -, "ptypnd constval kind mismatch"); - -826 - gs -. - gx -. - gi64 - = -cڡI -; - -827 - gs -. - gyp - = -yp -; - -829  - gPTY_u8 -: - -830  -PTY_u16 -: - -831  -PTY_u32 -: - -832  -PTY_u64 -: - -833  -PTY_a64 -: - -834 -MASSERT -( -cڡv --> -GKd -(= -kCڡI -, "ptypnd constval kind mismatch"); - -835 - gs -. - gx -. - gu64 - = -cڡI -; - -836 - gs -. - gyp - = -yp -; - -838  - gPTY_f32 -: - -839 -MASSERT -( -cڡv --> -GKd -(= -kCڡFltCڡ -, "ptypnd constval kind mismatch"); - -840 - gs -. - gx -. - gf32 - = -cڡFlt -; - -841 - gs -. - gyp - = -yp -; - -843  - gPTY_f64 -: - -844 -MASSERT -( -cڡv --> -GKd -(= -kCڡDoubCڡ -, "constvaltypnd kind mismatch"); - -845 - gs -. - gx -. - gf64 - = -cڡDoub -; - -846 - gs -. - gyp - = -yp -; - -849 -MASSERT -( -l -, "y %d f cڡv NYI", -yp -); - -853  - g_ex -; - -855 - gb_OP_add -: - -857 -MVue - -0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -858 -MVue - - g1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -859  - gex --> - gyp -) { - -860  - gPTY_i8 -: -s -. -x -. -i8 - = -0 -.x.i8 + -1 -.x.i8; ; - -861  - gPTY_i16 -: -s -. -x -. -i16 - = -0 -.x.i16 + -1 -.x.i16; ; - -862  - gPTY_i32 -: -s -. -x -. -i32 - = ( -t64 -) -0 -.x.i32 + (t64) -1 -.x.i32; ; - -863  - gPTY_i64 -: -s -. -x -. -i64 - = ( -ut64 -) -0 -.x.i64 + (ut64) -1 -.x.i64; ; - -864  - gPTY_u8 -: -s -. -x -. -u8 - = -0 -.x.u8 + -1 -.x.u8; ; - -865  - gPTY_u16 -: -s -. -x -. -u16 - = -0 -.x.u16 + -1 -.x.u16; ; - -866  - gPTY_u32 -: -s -. -x -. -u32 - = -0 -.x.u32 + -1 -.x.u32; ; - -867  - gPTY_u64 -: -s -. -x -. -u64 - = -0 -.x.u64 + -1 -.x.u64; ; - -868  - gPTY_a64 -: -s -. -x -. -u64 - = -0 -.x.u64 + -1 -.x.u64; ; - -869  - gPTY_f32 -: -s -. -x -. -f32 - = -0 -.x.f32 + -1 -.x.f32; ; - -870  - gPTY_f64 -: -s -. -x -. -f64 - = -0 -.x.f64 + -1 -.x.f64; ; - -871 : -MIR_FATAL -("Unsu܋d PrimTy %d f by ot %s", -ex --> -yp -, "+"); - -873 - gs -. - gyp - = -ex --> -yp -; - -875  - g_ex -; - -877 - gb_OP_sub -: - -879 -MVue - -nd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -880 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -881 -EXPRBINOP -(-, -s -, -nd0 -, -nd1 -, -ex --> -yp -); - -882  - g_ex -; - -884 - gb_OP_mul -: - -886 -MVue - -nd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -887 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -888 -EXPRBINOP -(*, -s -, -nd0 -, -nd1 -, -ex --> -yp -); - -889  - g_ex -; - -891 - gb_OP_div -: - -893 -MVue - -nd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -894 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -895 -EXPRBINOP -(/, -s -, -nd0 -, -nd1 -, -ex --> -yp -); - -896  - g_ex -; - -898 - gb_OP_gad -: - -900 -PgIdx - -gIdx - = -ic_ -< -RegadNode -*>( -ex -)-> -GRegIdx -(); - -901  - ggIdx -) { - -902 -( - gkSgFp -): - -903 -MASSERT -( -ex --> -yp - = -PTY_a64 -, "regread %%FP with wrongtyp %d",xpr->ptyp); - -904 - gs -. - gx -. - ga64 - = -func -. - -; - -906 -( - gkSgRv0 -): - -907 i( -ex --> -yp - = -func -. -tV0 -.ptyp) { - -908 -s - = -func -. -tV0 -; - -909 } i( - gex --> - gyp - = -PTY_agg - || -ex --> -yp - = -PTY_u64 -) { - -910 -s - = -func -. -tV0 -; - -912 - gs - = -CvtTy -( -func -. -tV0 -, -ex --> -yp -, func.retVal0.ptyp); - -915 -( - gkSgRv1 -): - -916 -MASSERT -( -ex --> -yp - = -func -. -tV1 -.ptyp || - -917 ( -ex --> -yp - = -PTY_agg - ||x->y= -PTY_u64 -), - -918 "gad %%tV0y mismch: %d %d", -ex --> -yp -, -func -. -tV1 -.ptyp); - -919 - gs - = -func -. -tV1 -; - -921 -( - gkSgGp -): - -922 -MASSERT -( -ex --> -yp - = -PTY_a64 -, "regread %%GP with wrongtyp %d",xpr->ptyp); - -923 - gs -. - gx -. - ga64 - = -func -. -fo --> -lmbcMod --> -globSticMem -; - -926 -MASSERT -( -gIdx - < -func -. -fo --> -numPgs -, "regreadegIdx %d out of bound",egIdx); - -928 - gs - = -func -. -pRegs -[ -gIdx -]; - -931 - gs -. - gyp - = -ex --> -yp -; - -932  - g_ex -; - -934 - gb_OP_cڡr -: - -936 -USIdx - -urIdx - = -ic_ -< -CڡrNode -*>( -ex -)-> -GSIdx -(); - -937 aut - g - = -func -. -fo --> -lmbcMod --> -globSTbl -. - -( - -938 -d -:: - -< -ut32 -, std:: -rg ->( -urIdx -, -GlobTabs -:: -GUSTab -(). -GSgFromSIdx -(ustrIdx))); - -939 - gs -. - gx -. - gr - = -cڡ_ -<*>( - -. -f --> -cd -. -c_r -()); - -940 - gs -. - gyp - = -PTY_a64 -; - -941  - g_ex -; - -943 - gb_OP_doff -: - -945 -IadFPoffNode -* -node - = -ic_ -( -ex -); - -946 -t32 - - gofft - = -node --> -GOfft -(); - -947 i( - gnode --> - gyp - ! -PTY_agg -) { - -948 -mld -( -func -. - -+ -offt -, -ex --> -yp -, -s -); - -949  - g_ex -; - -958 i( - gfunc -. - gxtStmt --> - g - = -OP_ -) { - -960 -MASSERT -( -func -. -aggrArgsBuf - ! -nuαr -, "aggrArgsBuf isull"); - -961 -memy -( -func -. -aggrArgsBuf -+ -rm --> -eIdx -, func. - -+ -offt -,m-> -size -); - -962 -mld -( -func -. -aggrArgsBuf -+ -rm --> -eIdx -, -ex --> -yp -, -s -,m-> -size -); - -964 -mld -( -func -. - -+ -offt -, -ex --> -yp -, -s -, func. -fo --> -tSize -); - -966  - g_ex -; - -968 - gb_OP_doff -: - -970 -t32 - -offt - = -ic_ -< -IadoffNode - *>( -ex -)-> -GOfft -(); - -971 -MVue - - grhs - = -EvEx -( -func -, -ic_ -< -IadoffNode - *>( -ex -)-> -Od -(0)); - -972 i( - gex --> - gyp - = -PTY_agg -) { - -976 -MASSERT -( -rhs -. -yp - = -PTY_a64 -, "ireadoffgg RHSot PTY_agg"); - -977 i( - gfunc -. - gxtStmt --> - g - = -OP_ -) { - -978 -MASSERT -( -func -. -aggrArgsBuf - ! -nuαr -, "aggrArgsBuf isull"); - -979 -memy -( -func -. -aggrArgsBuf -+ -rm --> -eIdx -, -rhs -. -x -. -a64 - + -offt -,m-> -size -); - -980 -mld -( -func -. -aggrArgsBuf -+ -rm --> -eIdx -, -ex --> -yp -, -s -,m-> -size -); - -982 -MASSERT -( -func -. -xtStmt --> - - = -OP_gassign -, "ireadoffggot usedsegassigngg opnd"); - -983 -mld -( -rhs -. -x -. -a64 - + -offt -, -ex --> -yp -, -s -, -func -. -fo --> -tSize -); - -985  - g_ex -; - -987 -MASSERT -( -rhs -. -yp - = -PTY_a64 - ||hs.y= -PTY_u64 - ||hs.y= -PTY_i64 -, - -988 "dofrhy%d PTY_a64 oPTY_u64", -rhs -. -yp -); - -989 -mld -( -rhs -. -x -. -a64 -+ -offt -, -ex --> -yp -, -s -); - -990  - g_ex -; - -992 - gb_OP_d -: - -994 -MASSERT -( -func -. -xtStmt --> - - = -OP_ - && -ex --> -yp - = -PTY_agg -, "iread unexpected outside call"); - -995 -MVue - - gaddr - = -EvEx -( -func -, -ex --> -Od -(0)); - -996 -MASSERT -( -func -. -aggrArgsBuf - ! -nuαr -, "aggrArgsBuf isull"); - -997 -memy -( -func -. -aggrArgsBuf -+ -rm --> -eIdx -, -addr -. -x -. -a64 -,m-> -size -); - -998 -mld -( -func -. -aggrArgsBuf -+ -rm --> -eIdx -, -ex --> -yp -, -s -,m-> -size -); - -999  - g_ex -; - -1001 - gb_OP_eq -: - -1003 -PrimTy - -ndTy - = -ic_ -< -ComNode -*>( -ex -)-> -GOdTy -(); - -1004 -MVue - - gnd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1005 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -1006 i( - gndTy - = -PTY_f32 - || -ndTy - = -PTY_f64 -) { - -1007 -s -. -yp - = -ex -->ptyp; - -1008 -HdFltEq -( -ex --> - -, -ndTy -, -s -, -nd0 -, -nd1 -); - -1010 -EXPRCOMPOPNOFLOAT -(==, -s -, -nd0 -, -nd1 -, -ndTy -, -ex --> -yp -); - -1012  - g_ex -; - -1014 - gb_OP_ -: - -1016 -PrimTy - -ndTy - = -ic_ -< -ComNode -*>( -ex -)-> -GOdTy -(); - -1017 -MVue - - gnd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1018 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -1019 i( - gndTy - = -PTY_f32 - || -ndTy - = -PTY_f64 -) { - -1020 -s -. -yp - = -ex -->ptyp; - -1021 -HdFltEq -( -ex --> - -, -ndTy -, -s -, -nd0 -, -nd1 -); - -1023 -EXPRCOMPOPNOFLOAT -(!=, -s -, -nd0 -, -nd1 -, -ndTy -, -ex --> -yp -); - -1025  - g_ex -; - -1027 - gb_OP_gt -: - -1029 -PrimTy - -ndTyp - -ic_ -< -ComNode -*>( -ex -)-> -GOdTy -(); - -1030 -MVue - - gnd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1031 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -1032 -EXPRCOMPOP -(>, -s -, -nd0 -, -nd1 -, -ndTyp -, -ex --> -yp -); - -1033  - g_ex -; - -1035 - gb_OP_ge -: - -1037 -PrimTy - -ndTyp - -ic_ -< -ComNode -*>( -ex -)-> -GOdTy -(); - -1038 -MVue - - gnd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1039 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -1040 -EXPRCOMPOP -(>=, -s -, -nd0 -, -nd1 -, -ndTyp -, -ex --> -yp -); - -1041  - g_ex -; - -1043 - gb_OP_ -: - -1045 -PrimTy - -ndTyp - -ic_ -< -ComNode -*>( -ex -)-> -GOdTy -(); - -1046 -MVue - - gnd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1047 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -1048 -EXPRCOMPOP -(<, -s -, -nd0 -, -nd1 -, -ndTyp -, -ex --> -yp -); - -1049  - g_ex -; - -1051 - gb_OP_ -: - -1053 -PrimTy - -ndTyp - -ic_ -< -ComNode -*>( -ex -)-> -GOdTy -(); - -1054 -MVue - - gnd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1055 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -1056 -EXPRCOMPOP -(<=, -s -, -nd0 -, -nd1 -, -ndTyp -, -ex --> -yp -); - -1057  - g_ex -; - -1059 - gb_OP_ -: - -1061 -MVue - -nd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1062 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -1063 -MVue - - gnd2 - = -EvEx -( -func -, -ex --> -Od -(2)); - -1064 -EXPRSELECTOP -( -s -, -nd0 -, -nd1 -, -nd2 -, -ex --> -yp -); - -1065  - g_ex -; - -1067 - gb_OP_bd -: - -1069 -MVue - -nd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1070 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -1071 -EXPRBININTOP -(&, -s -, -nd0 -, -nd1 -, -ex --> -yp -); - -1072  - g_ex -; - -1074 - gb_OP_bi -: - -1076 -MVue - -nd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1077 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -1078 -EXPRBININTOP -(|, -s -, -nd0 -, -nd1 -, -ex --> -yp -); - -1079  - g_ex -; - -1081 - gb_OP_bx -: - -1083 -MVue - -nd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1084 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -1085 -EXPRBININTOP -(^, -s -, -nd0 -, -nd1 -, -ex --> -yp -); - -1086  - g_ex -; - -1088 - gb_OP_lshr -: - -1090 -MVue - -nd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1091 -MVue - - gnumBs - = -EvEx -( -func -, -ex --> -Od -(1)); - -1092 -EXPRBININTOPUNSIGNED -(>>, -s -, -nd0 -, -numBs -, -ex --> -yp -); - -1093  - g_ex -; - -1095 - gb_OP_ashr -: - -1097 -MVue - -nd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1098 -MVue - - gnumBs - = -EvEx -( -func -, -ex --> -Od -(1)); - -1099 -EXPRBININTOP -(>>, -s -, -nd0 -, -numBs -, -ex --> -yp -); - -1100  - g_ex -; - -1102 - gb_OP_shl -: - -1104 -MVue - -nd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1105 -MVue - - gnumBs - = -EvEx -( -func -, -ex --> -Od -(1)); - -1106 -EXPRBININTOP -(<<, -s -, -nd0 -, -numBs -, -ex --> -yp -); - -1107  - g_ex -; - -1109 - gb_OP_bn -: - -1111 -MVue - -nd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1112 -EXPRUNROP -(~, -s -, -nd0 -, -ex --> -yp -); - -1113  - g_ex -; - -1115 - gb_OP_ -: - -1117 -MVue - -nd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1118 -EXPRUNROP -(!, -s -, -nd0 -, -ex --> -yp -); - -1119  - g_ex -; - -1121 - gb_OP_g -: - -1123 -MVue - -nd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1124  - gex --> - gyp -) { - -1125  - gPTY_i8 -: -s -. -x -. -i8 - = - -nd0 -.x.i8; ; - -1126  - gPTY_i16 -: -s -. -x -. -i16 - = - -nd0 -.x.i16; ; - -1128  - gPTY_i32 -: -s -. -x -. -i32 - = ~( -ut32 -) -nd0 -.x.i32+1; ; - -1129  - gPTY_i64 -: -s -. -x -. -i64 - = - -nd0 -.x.i64; ; - -1130  - gPTY_u8 -: -s -. -x -. -u8 - = - -nd0 -.x.u8; ; - -1131  - gPTY_u16 -: -s -. -x -. -u16 - = - -nd0 -.x.u16; ; - -1132  - gPTY_u32 -: -s -. -x -. -u32 - = - -nd0 -.x.u32; ; - -1133  - gPTY_u64 -: -s -. -x -. -u64 - = - -nd0 -.x.u64; ; - -1134  - gPTY_f32 -: -s -. -x -. -f32 - = - -nd0 -.x.f32; ; - -1135  - gPTY_f64 -: -s -. -x -. -f64 - = - -nd0 -.x.f64; ; - -1136 : -MIR_FATAL -("Unsu܋d PrimTy %d f ury ot %s", -ex --> -yp -, "OP_neg"); - -1138 - gs -. - gyp - = -ex --> -yp -; - -1140 -EXPRUNROP -(-, -s -, -nd0 -, -ex --> -yp -); - -1142  - g_ex -; - -1144 - gb_OP_abs -: - -1146 -MVue - -0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1147  - gex --> - gyp -) { - -1149  - gPTY_i8 -: -s -. -x -. -i8 - = -abs -( -0 -.x.i8); ; - -1150  - gPTY_i16 -: -s -. -x -. -i16 - = -abs -( -0 -.x.i16); ; - -1151  - gPTY_i32 -: -s -. -x -. -i32 - = -abs -( -0 -.x.i32); ; - -1152  - gPTY_i64 -: -s -. -x -. -i64 - = -abs -( -0 -.x.i64); ; - -1153  - gPTY_f32 -: -s -. -x -. -f32 - = -bsf -( -0 -.x.f32); ; - -1154  - gPTY_f64 -: -s -. -x -. -f64 - = -bs -( -0 -.x.f64); ; - -1155 : -MASSERT -( -l -, "_abunsu܋dy %d", -ex --> -yp -); - -1157 - gs -. - gyp - = -ex --> -yp -; - -1158  - g_ex -; - -1160 - gb_OP_m -: - -1162 -MVue - -nd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1163 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -1164 -EXPRMAXMINOP -(<, -s -, -nd0 -, -nd1 -, -ex --> -yp -); - -1165  - g_ex -; - -1167 - gb_OP_max -: - -1169 -MVue - -nd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1170 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -1171 -EXPRMAXMINOP -(>, -s -, -nd0 -, -nd1 -, -ex --> -yp -); - -1172  - g_ex -; - -1174 - gb_OP_m -: - -1176 -MVue - -nd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1177 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -1178 -EXPRREMOP -(%, -s -, -nd0 -, -nd1 -, -ex --> -yp -); - -1179  - g_ex -; - -1181 - gb_OP_cvt -: - -1183 -PrimTy - -toPtyp - = -ex --> -yp -; - -1184 -PrimTy - - gomPtyp - = -ic_ -< -TyCvtNode -*>( -ex -)-> -FromTy -(); - -1185 -MVue - - gnd - = -EvEx -( -func -, -ex --> -Od -(0)); - -1186 - gs - = -CvtTy -( -nd -, -toPtyp -, -omPtyp -); - -1187  - g_ex -; - -1189 - gb_OP_addrofoff -: - -1192 -t32 - -offt - = -ic_ -< -AddrofoffNode -*>( -ex -)->offset; - -1193 -StIdx - - gidx - = -ic_ -< -AddrofoffNode -*>( -ex -)-> -Idx -; - -1194 -ut8 - * - gaddr -; - -1196 i( - gidx -. -Iol -()) { - -1197 - gaddr - = -func -. -GFmVAddr -( -idx -); - -1198 i(! - gaddr -) { - -1199 - gaddr - = -func -. -fo --> -lmbcMod --> -GVAddr -(func.fo-> -mFunc --> -GPuidx -(), -idx -); - -1201 -MASSERT -( -addr -, "addrofoff canot findocal var"); - -1203 -MASSERT -( -idx -. -IsGlob -(), "addrofoff: symboleitherocalor global"); - -1204 -MIRSymb -* - gv - = -GlobTabs -:: -GGsymTab -(). -GSymbFromStidx -( -idx -. -Idx -()); - -1205  - gv --> -GStageCss -()) { - -1206  - gkScEx -: - -1207 -addr - = ( -ut8 - *)( -func -. -fo --> -lmbcMod --> -FdExtSym -( -idx -)); - -1209  - gkScGlob -: - -1210  -kScFic -: - -1211 -addr - = -func -. -fo --> -lmbcMod --> -GVAddr -( -v --> -GStIdx -()); - -1214 -MASSERT -( -l -, "addrofoff: stagas%d NYI", -v --> -GStageCss -()); - -1218 - gs -. - gx -. - ga64 - = -addr - + -offt -; - -1219 - gs -. - gyp - = -PTY_a64 -; - -1220  - g_ex -; - -1222 - gb_OP_lo -: - -1224 -MVue - -nd - = -EvEx -( -func -, -ex --> -Od -(0)); - -1225 - gs -. - gyp - = -PTY_a64 -; - -1226 - gs -. - gx -. - ga64 - = -func -. -Ao -( -nd -. -x -. -u64 -); - -1227  - g_ex -; - -1229 - gb_OP_addroffunc -: - -1231 -FuncAddr - * -ddr - = -func -. -fo --> -lmbcMod --> -GFuncAddr -( -ic_ -< -AddroffuncNode -*>( -ex -)-> -GPUIdx -()); - -1232 - gs -. - gx -. - ga64 - = ( -ut8 -*) -ddr -; - -1233 - gs -. - gyp - = -PTY_a64 -; - -1234  - g_ex -; - -1236 - gb_OP_addroab -: - -1238 -AddroabNode - * -node - = -ic_ -( -ex -); - -1239 -LabIdx - - gbIdx - = -node --> -GOfft -(); - -1240 -StmtNode - * - gb - = -func -. -fo --> -bM -[ -bIdx -]; - -1241 - gs -. - gx -. - ga64 - = -t_ -< -ut8 -*>( -b -); - -1242 - gs -. - gyp - = -ex --> -yp -; - -1243  - g_ex -; - -1245 - gb_OP_ty -: - -1247 -s - = -EvEx -( -func -, -ex --> -Od -(0)); - -1248 - gs -. - gyp - = -ex --> -yp -; - -1249  - g_ex -; - -1251 - gb_OP_xt -: - -1253 -ExabsNode - * -ext - = -ic_ -( -ex -); - -1254 -ut8 - - gbOfft - = -ext --> -GBsOfft -(); - -1255 -ut8 - - gbSize - = -ext --> -GBsSize -(); - -1256 -MASSERT -( -bOfft - == 0, "sext unexpected offset"); - -1257 -ut64 - - gmask - = -bSize - < 64 ? (1ull << bSize) - 1 : ~0ull; - -1258 - gs - = -EvEx -( -func -, -ex --> -Od -(0)); - -1259 - gs -. - gx -. - gi64 - = (( -ut64 -) -s -. -x -. -i64 - >> ( -bSize - - 1& 1u?es.x.i64 | ~ -mask - :es.x.i64 & mask; - -1260 - gs -. - gyp - = -ex --> -yp -; - -1261  - g_ex -; - -1263 - gb_OP_zext -: - -1265 -ExabsNode - * -ext - = -ic_ -( -ex -); - -1266 -ut8 - - gbOfft - = -ext --> -GBsOfft -(); - -1267 -ut8 - - gbSize - = -ext --> -GBsSize -(); - -1268 -MASSERT -( -bOfft - == 0, "zext unexpected offset"); - -1269 -ut64 - - gmask - = -bSize - < 64 ? (1ull << bSize) - 1 : ~0ull; - -1270 - gs - = -EvEx -( -func -, -ex --> -Od -(0)); - -1271 - gs -. - gx -. - gi64 - & -mask -; - -1272 - gs -. - gyp - = -ex --> -yp -; - -1273  - g_ex -; - -1275 - gb_OP_exabs -: - -1277 -ExabsNode - * -ebs - = -ic_ -( -ex -); - -1278 -ut8 - - gbOfft - = -ebs --> -GBsOfft -(); - -1279 -ut8 - - gbSize - = -ebs --> -GBsSize -(); - -1280 -ut64 - - gmask - = ((1u << -bSize -- 1<< -bOfft -; - -1281 - gs - = -EvEx -( -func -, -ex --> -Od -(0)); - -1282 - gs -. - gx -. - gi64 - = ( -ut64 -)( -s -. -x -. -i64 - & -mask ->> -bOfft -; - -1283 i( -IsSigdIeg -( -ex --> -yp -)) { - -1284 - gmask - = (1u << -bSize -) - 1; - -1285 - gs -. - gx -. - gi64 - = (( -ut64 -) -s -. -x -. -i64 - >> ( -bSize - - 1& 1u?es.x.i64 | ~ -mask - :es.x.i64 & mask; - -1287 - gs -. - gyp - = -ex --> -yp -; - -1288  - g_ex -; - -1290 - gb_OP_dosbs -: - -1292 -DosbsNode - * -dbs - = -ic_ -( -ex -); - -1293 -MVue - - gnd0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1294 -MVue - - gnd1 - = -EvEx -( -func -, -ex --> -Od -(1)); - -1295 -ut64 - - gmask - = ~(0xfffffffffffffff<< -dbs --> -GBsSize -()); - -1296 -ut64 - - gom - = ( -nd1 -. -x -. -u64 - & -mask -<< -dbs --> -GBsOfft -(); - -1297 - gmask - = -mask - << -dbs --> -GBsOfft -(); - -1298 - gs -. - gx -. - gu64 - = ( -nd0 -. -x -. -u64 - & ~( -mask -)| -om -; - -1299 - gs -. - gyp - = -ex --> -yp -; - -1300  - g_ex -; - -1302 - gb_OP_sic -: - -1304 aut* -n - = -ic_ -< -IrsicNode -*>( -ex -); - -1305 -MVue - - g0 - = -EvEx -( -func -, -ex --> -Od -(0)); - -1306 - gs -. - gyp - = -ex --> -yp -; - -1308  - gn --> -GIrsic -()) { - -1309  - gINTRN_C_s -: - -1310 i( -ex --> -yp - = -PTY_f32 -) { - -1311 -s -. -x -. -f32 - = -s -( -0 -.x.f32); - -1312 } i( - gex --> - gyp - = -PTY_f64 -) { - -1313 -s -. -x -. -f64 - = -s -( -0 -.x.f64); - -1316  - gINTRN_C_z32 -: - -1317 i( -ex --> -yp - = -PTY_u32 - ||x->y= -PTY_i32 -) { - -1318 -s -. -x -. -u32 - = -__but_z -( -0 -.x.u32); - -1321  - gINTRN_C_z32 -: - -1322 i( -ex --> -yp - = -PTY_u32 - ||x->y= -PTY_i32 -) { - -1323 -s -. -x -. -u32 - = -__but_z -( -0 -.x.u32); - -1326  - gINTRN_C_ffs -: - -1327 i( -ex --> -yp - = -PTY_u32 - ||x->y= -PTY_i32 -) { - -1328 -s -. -x -. -u32 - = -__but_ffs -( -0 -.x.u32); - -1331  - gINTRN_C_v_4 -: - -1332 i( -ex --> -yp - = -PTY_u32 - ||x->y= -PTY_i32 -) { - -1333 -s -. -x -. -u32 - = -__but_bv32 -( -0 -.x.u32); - -1339  - g_ex -; - -1343 - gb_OP_dassign -: - -1344 -b_OP_pssign -: - -1345 -b_OP_maydassign -: - -1346 -b_OP_ssign -: - -1347 -b_OP_block -: - -1348 -b_OP_do -: - -1349 -b_OP_dowhe -: - -1350 -b_OP_if -: - -1351 -b_OP_whe -: - -1352 -b_OP_swch -: - -1353 -b_OP_muiway -: - -1354 -b_OP_fܗchem -: - -1355 -b_OP_commt -: - -1356 -b_OP_ev -: - -1357 -b_OP_ -: - -1358 -b_OP_lsge -: - -1359 -b_OP_ls -: - -1360 -b_OP_asge -: - -1361 -b_OP_as -: - -1362 -b_OP_as -: - -1363 -b_OP_tuas -: - -1364 -b_OP_assigs -: - -1365 -b_OP_abt -: - -1366 -b_OP_asnnu -: - -1367 -b_OP_assigsnnu -: - -1368 -b_OP_asnnu -: - -1369 -b_OP_tuasnnu -: - -1370 -b_OP_dad -: - -1371 -b_OP_addrof -: - -1372 -b_OP_ddrof -: - -1373 -b_OP_sizeoy -: - -1374 -b_OP_fldsdi -: - -1375 -b_OP_y -: - -1376 -b_OP_ssignoff -: - -1377 -b_OP_ssignoff -: - -1378 -b_OP_gassign -: - -1379 -b_OP_go -: - -1380 -b_OP_brl -: - -1381 -b_OP_brue -: - -1382 -b_OP_tu -: - -1383 -b_OP_ngego -: - -1384 -b_OP_ -: - -1385 -b_OP_vtu -: - -1386 -b_OP_surass -: - -1387 -b_OP_r -: - -1388 -b_OP_cuom -: - -1389 -b_OP_pymphic -: - -1390 -b_OP_i -: - -1391 -b_OP_ri -: - -1392 -b_OP_vtui -: - -1393 -b_OP_sic -: - -1394 -b_OP_sicwhty -: - -1395 -b_OP_xsic -: - -1396 -b_OP_assigd -: - -1397 -b_OP_vtuassigd -: - -1398 -b_OP_surassassigd -: - -1399 -b_OP_rassigd -: - -1400 -b_OP_cuomassigd -: - -1401 -b_OP_pymphicassigd -: - -1402 -b_OP_iassigd -: - -1403 -b_OP_riassigd -: - -1404 -b_OP_vtuiassigd -: - -1405 -b_OP_sicassigd -: - -1406 -b_OP_sicwhtyassigd -: - -1407 -b_OP_xsicassigd -: - -1408 -b_OP_Κt -: - -1409 -b_OP_Κssigd -: - -1410 -b_OP_vtuΚt -: - -1411 -b_OP_vtuΚssigd -: - -1412 -b_OP_surassΚt -: - -1413 -b_OP_surassΚssigd -: - -1414 -b_OP_rΚt -: - -1415 -b_OP_rΚssigd -: - -1416 -b_OP_jry -: - -1417 -b_OP_y -: - -1418 -b_OP_ry -: - -1419 -b_OP_throw -: - -1420 -b_OP_jstch -: - -1421 -b_OP_tch -: - -1422 -b_OP_ptch -: - -1423 -b_OP_fly -: - -1424 -b_OP_nury -: - -1425 -b_OP_dy -: - -1426 -b_OP_ -: - -1427 -b_OP_d -: - -1428 -b_OP_un -: - -1429 -b_OP_dun -: - -1430 -b_OP_gosub -: - -1431 -b_OP_tsub -: - -1432 -b_OP_syn -: - -1433 -b_OP_synx -: - -1434 -b_OP_deef -: - -1435 -b_OP_ef -: - -1436 -b_OP_deeet -: - -1437 -b_OP_membacque -: - -1438 -b_OP_memba -: - -1439 -b_OP_membܖd -: - -1440 -b_OP_membee -: - -1441 -b_OP_b -: - -1442 -b_OP_cڡr16 -: - -1443 -b_OP_ -: - -1444 -b_OP_o -: - -1445 -b_OP_round -: - -1446 -b_OP_unc -: - -1447 -b_OP_c -: - -1448 -b_OP_sq -: - -1449 -b_OP_mloc -: - -1450 -b_OP_gcmloc -: - -1451 -b_OP_gmloc -: - -1452 -b_OP_ackmloc -: - -1453 -b_OP_gcmlocjy -: - -1454 -b_OP_gmlocjy -: - -1455 -b_OP_ackmlocjy -: - -1456 -b_OP_sverfunc -: - -1457 -b_OP_svevtufunc -: - -1458 -b_OP_r -: - -1459 -b_OP_CG_y_em_add -: - -1460 -b_OP_cmp -: - -1461 -b_OP_cm -: - -1462 -b_OP_cmpg -: - -1463 -b_OP_nd -: - -1464 -b_OP_li -: - -1465 -b_OP_nd -: - -1466 -b_OP_ci -: - -1467 -b_OP_sicwhty -: - -1468 -b_OP_ssigcoff -: - -1469 -b_OP_dpcoff -: - -1470 -b_OP_checkpot -: - -1471 -b_OP_addrofc -: - -1472 -b_OP_igo -: - -1473 -b_OP_asm -: - -1474 -b_OP_dadoff -: - -1475 -b_OP_dassignoff -: - -1476 -b_OP_ssignoff -: - -1477 -b_OP_blkassignoff -: - -1478 -b_OP_iδo -: - -1479 -b_OP_iδssigd -: - -1481 -MASSERT -( -l -, "NIY"); - -1484 - g_ex -: - -1485  -s -; - - @lmbc/src/load_store.cpp - -15  - ~"mvue.h -" - -16  - ~"mfuni.h -" - -17  - ~"mas.h -" - -19 -mea - - gm - { - -21  -mld -( -ut8 -* -addr -, -PrimTy - -yp -, -MVue -& -s -, -size_t - -aggSize -) { - -22 - gs -. - gyp - = -yp -; - -23  - gyp -) { - -24  - gPTY_i8 -: - -25 -s -. -x -. -i64 - = *( -t8 - *) -addr -; - -27  - gPTY_i16 -: - -28 -s -. -x -. -i64 - = *( -t16 - *) -addr -; - -30  - gPTY_i32 -: - -31 -s -. -x -. -i64 - = *( -t32 - *) -addr -; - -33  - gPTY_i64 -: - -34 -s -. -x -. -i64 - = *( -t64 - *) -addr -; - -36  - gPTY_u8 -: - -37 -s -. -x -. -u64 - = *( -ut8 - *) -addr -; - -39  - gPTY_u16 -: - -40 -s -. -x -. -u64 - = *( -ut16 - *) -addr -; - -42  - gPTY_u32 -: - -43 -s -. -x -. -u64 - = *( -ut32 - *) -addr -; - -45  - gPTY_u64 -: - -46 -s -. -x -. -u64 - = *( -ut64 - *) -addr -; - -48  - gPTY_f32 -: - -49 -s -. -x -. -f32 - = *(*) -addr -; - -51  - gPTY_f64 -: - -52 -s -. -x -. -f64 - = *(*) -addr -; - -54  - gPTY_a64 -: - -55 -s -. -x -. -a64 - = *( -ut8 - **) -addr -; - -57  - gPTY_agg -: - -58 -s -. -x -. -a64 - = -addr -; - -59 - gs -. - gaggSize - = -aggSize -; - -62 -MASSERT -( -l -, "mldty%d NYI", -yp -); - -67  -me -( -ut8 -* -addr -, -PrimTy - -yp -, -MVue -& -v -, -bo - -toVArgSck -) { - -68 i(! -IsPrimiveIeg -( -yp -|| !IsPrimiveIeg( -v -.ptyp)) { - -69 -MASSERT -( -yp - = -v -.ptyp || - -70 -yp - = -PTY_a64 - && -v -.y= -PTY_u64 - || - -71 -yp - = -PTY_u64 - && -v -.y= -PTY_a64 -, - -72 "mܐty mismch: %dnd %d", -yp -, -v -.ptyp); - -74  - gyp -) { - -75  - gPTY_i8 -: - -76 *( -t8 - *) -addr - = -v -. -x -. -i8 -; - -78  - gPTY_i16 -: - -79 *( -t16 - *) -addr - = -v -. -x -. -i16 -; - -81  - gPTY_i32 -: - -82 *( -t32 - *) -addr - = -v -. -x -. -i32 -; - -84  - gPTY_i64 -: - -85 *( -t64 - *) -addr - = -v -. -x -. -i64 -; - -87  - gPTY_u8 -: - -88 *( -ut8 - *) -addr - = -v -. -x -. -u8 -; - -90  - gPTY_u16 -: - -91 *( -ut16 - *) -addr - = -v -. -x -. -u16 -; - -93  - gPTY_u32 -: - -94 *( -ut32 - *) -addr - = -v -. -x -. -u32 -; - -96  - gPTY_u64 -: - -97 *( -ut64 - *) -addr - = -v -. -x -. -u64 -; - -99  - gPTY_f32 -: - -100 *(*) -addr - = -v -. -x -. -f32 -; - -102  - gPTY_f64 -: - -103 *(*) -addr - = -v -. -x -. -f64 -; - -105  - gPTY_a64 -: - -106 *( -ut8 - **) -addr - = -v -. -x -. -a64 -; - -108  - gPTY_agg -: - -109 i( -toVArgSck -) { - -110 i( -v -. -aggSize - > 16) { - -111 *( -ut8 - **) -addr - = -v -. -x -. -a64 -; - -113 -memy -( -addr -, -v -. -x -. -a64 -, v. -aggSize -); - -117 -MASSERT -( -v -. -aggSize - <= 16, "mstoregg > 16"); - -118 -memy -( -addr -, &( -v -. -x -. -u64 -), v. -aggSize -); - -122 -MASSERT -( -l -, "mܐy%d NYI", -yp -); - - @lmbc/src/mfunction.cpp - -16  - ~ - -17  - ~ - -19  - ~ - -20  - ~ - -21  - #gtid -( - `sys -( -SYS_gtid -) - - ) - -22  - ~ - -23  - ~ - -25  - ~"mfuni.h -" - -26  - ~"mimty.h -" - -27  - ~"mas.h -" - -29 -mea - - gm - { - -31 - gMFuni -:: -MFuni -( -LmbcFunc - * -funcInfo -, - -32 -MFuni - * -funcCr -, - -33 -ut8 - * -autoVs -, - -34 -MVue - * -egs -, - -35 -MVue - * -fmvs -) : - -36 -fo -( -funcInfo -), - -37 -Δ -( -funcCr -), - -38 -ame -( -autoVs -), - -39 -pRegs -( -egs -), - -40 -fmVs -( -fmvs -), - -41 -Args -( -nuαr -), - -42 -aggrArgsBuf -( -nuαr -) - -44 - gnumClArgs - = 0; - -45 - gxtStmt - = -fo --> -mFunc --> -GBody -(); - -46 - g - = ( -ut8 -*) -ame - + -fo --> -ameSize -; - -47 - gloOfft - = 0; - -48 - gloMem - = -nuαr -; - -51 - gMFuni -::~ -MFuni -() { } - -53 -ut8 - * -MFuni -:: -Ao -( -ut32 - -sz -) { - -54 i( -loOfft - + -sz - > -ALLOCA_MEMMAX -) { - -55  -nuαr -; - -57 -ut8 - * - gr - = -loMem - + -loOfft -; - -58 - gloOfft - + -sz -; - -59  - gr -; - -62 -ut8 - * - gMFuni -:: -GFmVAddr -( -StIdx - -idx -) { - -63 aut - - = -fo --> -idx2Pm -. -fd -( -idx -. -FuIdx -()); - -64 i( - g - = -fo --> -idx2Pm -. -d -()) { - -65  -nuαr -; - -67 i( - g --> - gcd --> - gyp - = -PTY_agg -) { - -68 -MASSERT -( -Δ --> -aggrArgsBuf -, "aggrArgsBufot init"); - -69  - gΔ --> - gaggrArgsBuf - + - g --> - gcd --> - geIdx -; - -71 (( - gut8 -*)& - gfmVs -[ - --> -cd --> -eIdx -]. - gx -); - -74 -bo - -IsExtFunc -( -PUIdx - -puIdx -, -LmbcMod -& -modu -) { - -75 -MIRFuni - * - gfunc - = -GlobTabs -:: -GFuniTab -(). -GFuniFromPuidx -( -puIdx -); - -76 i( - gfunc --> -IsEx -() || - -77 - gfunc --> -GAr -( -FUNCATTR_imic -) || - -78 ! - gfunc --> -GBody -() || - -79 ( - gfunc --> -IsWk -(&& - gmodu -. -FdExtFunc -( -puIdx -))) { - -80  - gue -; - -82  - gl -; - -86 -size_t - -GIRdAggrSize -( -BaNode -* -ex -) { - -87 -MASSERT -( -ex --> - - = -OP_d - &&x-> -yp - = -PTY_agg -, "iread onon PTY_aggype"); - -88 -IadNode - * - gd - = -ic_ -( -ex -); - -89 -TyIdx - - grTyIdx - = -d --> -GTyIdx -(); - -90 -MIRPTy - * - grTy - = - -91 -ic_ -< -MIRPTy -*>( -GlobTabs -:: -GTyTab -(). -GTyFromTyIdx -( -rTyIdx -)); - -92 -MIRTy - * - gaggTy - = -GlobTabs -:: -GTyTab -(). -GTyFromTyIdx -( -rTy --> -GPodTyIdx -()); - -93 -FldID - - gfd - = -d --> -GFldID -(); - -94 -size_t - - gsz - = -aggTy --> -GSize -(); - -95 i( - gfd - != 0) { - -96 -MIRSuTy - * -ruTy - = -ic_ -( -aggTy -); - -97 -MIRTy - * - gfdTy - = -ruTy --> -GFldTy -( -fd -); - -98 -ut32 - - gfdOfft - = -ruTy --> -GBOfftFromBaAddr -( -fd -); - -99 - gsz - = -fdTy --> -GSize -(); - -100 () - gfdOfft -; - -102  (( - gsz - + 7) >> 3) << 3; - -107 -size_t - -GAggClArgsSize -( -LmbcFunc - * -Γ -, -ClNode - * - -) { - -108 -size_t - - gtٮAggClArgsSize - = -Γ --> -fmsAggSize -; - -109 i( - gΓ --> - gisVArgs -) { - -110  - gi - = -Γ --> -fmsNum -; i < - g --> -NumOds -(); i++) { - -111 i( - g --> -Od -( -i -)-> - gyp - = -PTY_agg -) { - -112 -MASSERT -( - --> -Od -( -i -)-> - - = -OP_d -, "agg varrg unexpected op"); - -113 - gtٮAggClArgsSize - + -GIRdAggrSize -( - --> -Od -( -i -)); - -117  - gtٮAggClArgsSize -; - -135  - gMFuni -:: -ClMFuncDe -( -ClNode - * - -) { - -136 -LmbcFunc - * -Γ - = -fo --> -lmbcMod --> -LkupLmbcFunc -( - --> -GPUIdx -()); - -137 i(! - gΓ --> - gfmsNum -) { - -138 -InvokeFunc -( -Γ -, -this -); - -142 -size_t - - gtٮAggClArgsSize - = -GAggClArgsSize -( -Γ -, - -); - -143 - gaggrArgsBuf - = -ic_ -< -ut8 -*>( -lo -( -tٮAggClArgsSize -)); - -144  - gi - = 0, - gsz - = 0, - gofft - = -Γ --> -fmsAggSize -; i < - g --> -NumOds -(); i++) { - -146 i( - g --> -Od -( -i -)-> - gyp - ! -PTY_agg -) { - -147 -Args -[ -i -] = -EvEx -(* -this -, - --> -Od -(i)); - -151 i( - gi - < - gΓ --> - gfmsNum -) { - -152 - gArgs -[ -i -] = -EvEx -(* -this -, - --> -Od -(i), -Γ --> -pos2Pm -[i]); - -156 - gsz - = -GIRdAggrSize -( - --> -Od -( -i -)); - -157 -PmInf - -rmInf -( -PTY_agg -, -sz -, -l -, -offt -); - -158 - gofft - + -sz -; - -159 - gArgs -[ -i -] = -EvEx -(* -this -, - --> -Od -(i), & -rmInf -); - -161 i( - gΓ --> - gisVArgs -) { - -162 -ClVaArgFunc -( - --> -NumOds -(), -Γ -); - -164 -InvokeFunc -( -Γ -, -this -); - -168  - gMFuni -:: -ClMFuncInde -( -INode - * -i -, -LmbcFunc - * -Info -) { - -169 i(! - gInfo --> - gfmsNum -) { - -170 -InvokeFunc -( -Info -, -this -); - -175 - gaggrArgsBuf - = -ic_ -< -ut8 -*>( -lo -( -Info --> -fmsAggSize -)); - -176  - gi -=0; i < - gi --> -NumOds -()-1; i++) { - -177 - gArgs -[ -i -] = ( -i --> -Od -(i+1)-> -yp - = -PTY_agg -) ? - -178 -EvEx -(* -this -, -i --> -Od -( -i -+1), -Info --> -pos2Pm -[i]) : - -179 -EvEx -(* -this -, -i --> -Od -( -i -+1)); - -181 i( - gInfo --> - gisVArgs -) { - -182 -ClVaArgFunc -( -i --> -NumOds -()-1, -Info -); - -184 -InvokeFunc -( -Info -, -this -); - -199  - gMFuni -:: -ClVaArgFunc -( -numArgs -, -LmbcFunc - * -Info -) { - -200 -ut32 - - gvArgsSz - = 0; - -201  - gi - = -Info --> -fmsNum -; i < - gnumArgs -; ++i) { - -202 i( - gArgs -[ -i -]. - gyp - ! -PTY_agg - || -Args -[i]. -aggSize - > 16 ) { - -203 -vArgsSz - += 8; - -205 - gvArgsSz - + -Args -[ -i -]. -aggSize -; - -208 - gvaArgsSize - = -vArgsSz -; - -209 - gvaArgs - = -ic_ -< -ut8 -*>( -lo -( -vaArgsSize -)); - -210  - gi - = -Info --> -fmsNum -, - gofft - = 0; i < - gnumArgs -; ++i) { - -211 -me -( -vaArgs - + -offt -, -Args -[ -i -]. -yp -, clArgs[i], -ue -); - -212 i( - gArgs -[ -i -]. - gyp - ! -PTY_agg - || -Args -[i]. -aggSize - > 16 ) { - -213 -offt - += 8; - -215 - gofft - + -Args -[ -i -]. -aggSize -; - -218 -InvokeFunc -( -Info -, -this -); - -221  - gMFuni -:: -ClExtFuncDe -( -ClNode -* - -) { - -222 -MIRFuni - * -func - = -GlobTabs -:: -GFuniTab -(). -GFuniFromPuidx -( - --> -GPUIdx -()); - -223 - gMVe -< - gFmDef -> & - gfmDefVec - = -func --> -GFmDefVec -(); - -224 - gFuncAddr -& - gddr - = * -fo --> -lmbcMod --> -GFuncAddr -( - --> -GPUIdx -()); - -225 -ffi__t - - g - = (ffi__t)( -ddr -. -funcP -. -tiveFunc -); - -226 -MASSERT -( - -, "External functionot found"); - -228  - gi - = -fmDefVec -. -size -(); i < - g --> -NumOds -(); i++) { - -229 i( - g --> -Od -( -i -)-> - gyp - = -PTY_agg -) { - -231 -MASSERT -( -l -, "extern func: va-arg ofggype NYI"); - -235 - gaggrArgsBuf - = -ic_ -< -ut8 -*>( -lo -( -ddr -. -fmsAggSize -)); - -236  - gi - = 0, - gofft - = 0; i < - g --> -NumOds -(); i++) { - -238 i( - g --> -Od -( -i -)-> - gyp - ! -PTY_agg -) { - -239 -Args -[ -i -] = -EvEx -(* -this -, - --> -Od -(i)); - -243 i( - gi - < - gfmDefVec -. -size -()) { - -244 -MIRTy -* - gty - = -GlobTabs -:: -GTyTab -(). -GTyFromTyIdx -( -fmDefVec -[ -i -]. -fmTyIdx -); - -245 -MASSERT -( -ty --> -GPrimTy -(= -PTY_agg -, "expects formalrg ofggype"); - -246 -PmInf - -rmInf -( -PTY_agg -, -ty --> -GSize -(), -l -, -offt -); - -247 - gofft - + -ty --> -GSize -(); - -248 - gArgs -[ -i -] = -EvEx -(* -this -, - --> -Od -(i), & -rmInf -); - -253 -ClWhFFI -( -func --> -GRuTy -()-> -GPrimTy -(), - -); - -256  - gMFuni -:: -ClExtFuncInde -( -INode - * -iδo -, * - -) { - -258  - gi -=0; i < - giδo --> -NumOds -()-1; i++) { - -259 - gArgs -[ -i -] -EvEx -(* -this -, -iδo --> -Od -(i+1)); - -261 -MIRTy - * - gty - = -GlobTabs -:: -GTyTab -(). -GTyFromTyIdx -( -iδo --> -GRTyIdx -()); - -262 -MIRFuncTy - * - gfPro - = -ic_ -( -ty -); - -263 -MIRTy - * - gfRTy - = -GlobTabs -:: -GTyTab -(). -GTyFromTyIdx -( -fPro --> -GRTyIdx -()); - -264 -ClWhFFI -( -fRTy --> -GPrimTy -(), ( -ffi__t -) - -); - -267  - gMFuni -:: -ClIrsic -( -IrsicNode - & -n -) { - -268 -MIRIrsicID - -Id - = -n -. -GIrsic -(); - -269  - gId -) { - -270  - gINTRN_C_va_t -: { - -271 -MVue - -addrofAP - = -EvEx -(* -this -, -n -. -Od -(0)); - -273 -VaLi - * - gvaLi - = ( -m -::VaLi*) -addrofAP -. -x -. -a64 -; - -274 - gvaLi --> - ggr_offs - = 0; - -275 - gvaLi --> - gack - = -Δ --> -vaArgs -; - -279 -MASSERT -( -l -, "ClIrsi%d\NYI", -Id -); - -285  -ffi_ty - - gffi_ty_b -[] = { - -286 -ffi_ty_void -, - -287  - #EXPANDFFI1 -( -x -x, - - ) - -288  - #EXPANDFFI2 -( -x - - `EXPANDFFI1 -(x) - - ) - -289  - #PRIMTYPE -( -P - - `EXPANDFFI2 -( -FFITYPE_ -##P) - - ) - -290  - #LOAD_ALGO_PRIMARY_TYPE - - - ) - -291  - ~"im_tys.def -" - -292 #unde -PRIMTYPE - - -293 -ffi_ty_void - - -297 -ffi_ty - * - gvaLiObjAch64 - [] = { - -298 -ffi_ty_b - + -PTY_r -, - -299 -ffi_ty_b - + -PTY_r -, - -300 -ffi_ty_b - + -PTY_r -, - -301 -ffi_ty_b - + -PTY_i32 -, - -302 -ffi_ty_b - + -PTY_i32 -, - -303 -nuαr - - -307 -ffi_ty - * - gvaLiObjX86_64 - [] = { - -308 -ffi_ty_b - + -PTY_u32 -, - -309 -ffi_ty_b - + -PTY_u32 -, - -310 -ffi_ty_b - + -PTY_r -, - -311 -ffi_ty_b - + -PTY_r -, - -312 -nuαr - - -316 -ffi_ty - - gvaLi_ffi_ty - = { 0, 0, -FFI_TYPE_STRUCT -, -vaLiObjAch64 - }; - -326  - gMFuni -:: -ClWhFFI -( -PrimTy - -t_yp -, -ffi__t - - -) { - -327 -ffi_cif - - gcif -; - -328 -ffi_ty - - gffi_t_ty - = -ffi_ty_b -[ -t_yp -]; - -329 -ffi_ty -* - gg_tys -[ -numClArgs -]; - -330 * - ggs -[ -numClArgs -]; - -333  - gi -=0; i < - gnumClArgs -; ++i) { - -334 - ggs -[ -i -] = & -Args -[i]. -x -; - -335 i( - gArgs -[ -i -]. - gyp - = -PTY_agg -) { - -336 -g_tys -[ -i -] = & -vaLi_ffi_ty -; - -338 - gg_tys -[ -i -] = -ffi_ty_b - + -Args -[i]. -yp -; - -342 -ffi_us - - gus - = -ffi__cif -(& -cif -, -FFI_DEFAULT_ABI -, -numClArgs -, & -ffi_t_ty -, -g_tys -); - -343 if( - gus - = -FFI_OK -) { - -344 -ffi_ -(& -cif -, - -, & -tV0 -. -x -, -gs -); - -345 - gtV0 -. - gyp - = -t_yp -; - -347 -MIR_FATAL -("Faed mhod%p", (*) - -); - - @lmbc/src/mplsh.cpp - -15  - ~ - -16  - ~"mas.h -" - -17  - ~"lmbc_g.h -" - -18  - ~"g_shim.h -" - -20 -mea - - gm - { - -22 * - gLmbcMod -:: -FdExtFunc -( -PUIdx - -puidx -) { - -23 * - - = -extFuncM -[ -puidx -]; - -24 i( - g -) { - -25  - g -; - -27 - gd -:: -rg - -ame - = -GlobTabs -:: -GFuniTab -(). -GFuniFromPuidx -( -puidx -)-> -GName -(); - -28 aut - g - : -libHds -) { - -29 - - = -dlsym -( - -, -ame -. -c_r -()); - -30 i( - g -) { - -34 -MASSERT -( - -, "dlsym symbނ found: %s", -ame -. -c_r -()); - -35 - gextFuncM -[ -puidx -] = - -; - -36 ( - g -); - -39 * - gLmbcMod -:: -FdExtSym -( -StIdx - -idx -) { - -40 * -v - = -extSymM -[ -idx -. -FuIdx -()]; - -41 i( - gv -) { - -42  - gv -; - -44 -MIRSymb -* - gsym - = -GlobTabs -:: -GGsymTab -(). -GSymbFromStidx -( -idx -. -Idx -()); - -45 i( - gsym -) { - -46 aut - g - : -libHds -) { - -47 -v - = -dlsym -( - -, -sym --> -GName -(). -c_r -()); - -48 i( - gv -) { - -52 -MASSERT -( -v -, "dlsym ExtSym found: %s", -sym --> -GName -(). -c_r -()); - -53 - gextSymM -[ -idx -. -FuIdx -()] = -v -; - -55 -MASSERT -( -sym -, "Unableo find symbol"); - -56 ( - gv -); - -59 - gm -:: -MIRModu -* - -60 -LmbcMod -:: -Impt -( -d -:: -rg - -th -) { - -61 -m -:: -MIRModu -* -mod - = -w - m::MIRModu( -th -. -c_r -()); - -62 - gmod --> -SSrcLg -( -kSrcLgC -); - -63 - gd -:: -rg -:: -size_ty - -ϡd - = -mod --> -GFeName -(). -fd_ϡ_of -("."); - -64 -bo - - gimbc - = -ϡd - ! -d -:: -rg -:: -os - && -mod --> -GFeName -(). -com -(lastdot, 5, ".lmbc\0") == 0; - -65 i(! - gimbc -) { - -66 -ERR -( -kLncE -, "Iumu b.lmbfe: %s", -th -. -c_r -()); - -67 -de - - gmod -; - -68  - gnuαr -; - -71 -ByMImpt - -bMt -(* -mod -); - -72 - gbMt -. -SImp܋d -( -l -); - -73 - gd -:: -rg - -modid - = -mod --> -GFeName -(); - -74 i(! - gbMt -. -Impt -( -modid -, -ue -)) { - -75 -ERR -( -kLncE -, "msh-lmbc: cn o.lmbfe: %s", -modid -. -c_r -()); - -76 -de - - gmod -; - -77  - gnuαr -; - -79  - gmod -; - -84 - gd -:: -ve -< -d -:: -rg -> -eLdLibs - = { - -85 -LIBC_SO -, - -86 -LIBM_SO - - -89  - gLmbcMod -:: -LdDefLibs -() { - -90 aut - - : -eLdLibs -) { - -91 * -hd - = -dlݒ -( - -. -c_r -(), -RTLD_NOW - | -RTLD_GLOBAL - | -RTLD_NODELETE -); - -92 -MASSERT -( -hd -, "dlݒ %ed", - -. -c_r -()); - -93 - glibHds -. -push_back -( -hd -); - -97 - gLmbcMod -:: -LmbcMod -(* -th -: -lmbcPh -(path) { - -98 -LdDefLibs -(); - -99 - gmMod - = -Impt -( -th -); - -100 - gglobSticMemSize - = -mMod --> -GGlobMemSize -(); - -104 -RunLmbc -( -gc -, ** -gv -) { - -105  - grc - = 1; - -106 cڡ  - gskArgsNum - = 1; - -107 -LmbcMod -* - gmod - = -w - LmbcMod( -gv -[ -skArgsNum -]); - -108 -ASSERT -( -mod -, "Create Lmbc module failed"); - -109 -ASSERT -( -mod --> -mMod -, "Import Lmbc module failed"); - -110 - gmod --> -InModu -(); - -111 i( - gmod --> - gmaFn -) { - -112 - grc - = -__geShim -( -mod --> -maFn -, -gc -- -skArgsNum -, -gv -+skipArgsNum); - -114  - grc -; - -120 - $ma -( -gc -, ** -gv -) { - -121 i( -gc - == 1) { - -122 -d -:: -rg - - `th -( -gv -[0]); - -123 () - `MIR_PRINTF -("uge: %.lmbc\n", -th -. - `subr -թh. - `fd_ϡ_of -("/\\"+ 1). - `c_r -()); - -124 - `ex -(1); - -126  -m -:: - `RunLmbc -( -gc -, -gv -); - -127 - } -} - - @ -1 -. -0 -13 -303 -lmbc/include/eng_shim.h -lmbc/include/lmbc_eng.h -lmbc/include/massert.h -lmbc/include/mexpression.h -lmbc/include/mfunction.h -lmbc/include/mprimtype.h -lmbc/include/mvalue.h -lmbc/src/eng_shim.cpp -lmbc/src/init.cpp -lmbc/src/invoke_method.cpp -lmbc/src/load_store.cpp -lmbc/src/mfunction.cpp -lmbc/src/mplsh.cpp diff --git a/src/MapleEng/cscope.po.out b/src/MapleEng/cscope.po.out deleted file mode 100644 index d88bffc2496bdb37760124bacf48fcd3b39fd39d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 178872 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 Fe*kVUhF1Up diff --git a/src/MapleEng/tags b/src/MapleEng/tags deleted file mode 100644 index c15d1cbf76..0000000000 --- a/src/MapleEng/tags +++ /dev/null @@ -1,315 +0,0 @@ -!_TAG_FILE_FORMAT 2 /extended format; --format=1 will not append ;" to lines/ -!_TAG_FILE_SORTED 1 /0=unsorted, 1=sorted, 2=foldcase/ -!_TAG_PROGRAM_AUTHOR Darren Hiebert /dhiebert@users.sourceforge.net/ -!_TAG_PROGRAM_NAME Exuberant Ctags // -!_TAG_PROGRAM_URL http://ctags.sourceforge.net /official site/ -!_TAG_PROGRAM_VERSION 5.9~svn20110310 // -ALLOCA_MEMMAX lmbc/include/mfunction.h 30;" d -AddGlobalVar lmbc/src/init.cpp /^inline void LmbcMod::AddGlobalVar(MIRSymbol &sym, VarInf *pInf) {$/;" f class:maple::LmbcMod -AddPUStaticVar lmbc/src/init.cpp /^inline void LmbcMod::AddPUStaticVar(PUIdx puIdx, MIRSymbol &sym, VarInf *pInf) {$/;" f class:maple::LmbcMod -AlignOffset lmbc/src/init.cpp /^inline void AlignOffset(uint32 &offset, uint32 align) {$/;" f namespace:maple -Alloca lmbc/src/mfunction.cpp /^uint8 *MFunction::Alloca(uint32 sz) {$/;" f class:maple::MFunction -CASE_TOPTYP lmbc/src/invoke_method.cpp 122;" d file: -CalcGlobalAndStaticVarSize lmbc/src/init.cpp /^void LmbcMod::CalcGlobalAndStaticVarSize() {$/;" f class:maple::LmbcMod -CallExtFuncDirect lmbc/src/mfunction.cpp /^void MFunction::CallExtFuncDirect(CallNode* call) {$/;" f class:maple::MFunction -CallExtFuncIndirect lmbc/src/mfunction.cpp /^void MFunction::CallExtFuncIndirect(IcallNode *icallproto, void* fp) {$/;" f class:maple::MFunction -CallIntrinsic lmbc/src/mfunction.cpp /^void MFunction::CallIntrinsic(IntrinsiccallNode &intrn) {$/;" f class:maple::MFunction -CallMapleFuncDirect lmbc/src/mfunction.cpp /^void MFunction::CallMapleFuncDirect(CallNode *call) {$/;" f class:maple::MFunction -CallMapleFuncIndirect lmbc/src/mfunction.cpp /^void MFunction::CallMapleFuncIndirect(IcallNode *icall, LmbcFunc *callInfo) {$/;" f class:maple::MFunction -CallVaArgFunc lmbc/src/mfunction.cpp /^void MFunction::CallVaArgFunc(int numArgs, LmbcFunc *callInfo) {$/;" f class:maple::MFunction -CallWithFFI lmbc/src/mfunction.cpp /^void MFunction::CallWithFFI(PrimType ret_ptyp, ffi_fp_t fp) {$/;" f class:maple::MFunction -CheckFlexArrayMember lmbc/src/init.cpp /^uint32 CheckFlexArrayMember(MIRSymbol &sym, MIRType &ty) {$/;" f namespace:maple -CheckUnamedBitField lmbc/src/init.cpp /^void LmbcMod::CheckUnamedBitField(MIRStructType &stType, uint32 &prevInitFd, uint32 curFd, int32 &allocdBits) {$/;" f class:maple::LmbcMod -CompareDouble lmbc/src/invoke_method.cpp /^inline bool CompareDouble(double x, double y, double epsilon = 0.0000000000000001f) {$/;" f namespace:maple -CompareFloat lmbc/src/invoke_method.cpp /^inline bool CompareFloat(float x, float y, float epsilon = 0.00000001f) {$/;" f namespace:maple -CvtType lmbc/src/invoke_method.cpp /^MValue CvtType(MValue &opnd, PrimType toPtyp, PrimType fromPtyp) {$/;" f namespace:maple -EXPANDFFI1 lmbc/src/mfunction.cpp 278;" d file: -EXPANDFFI2 lmbc/src/mfunction.cpp 279;" d file: -EXPRBININTOP lmbc/include/mexpression.h 103;" d -EXPRBININTOPUNSIGNED lmbc/include/mexpression.h 122;" d -EXPRBINOP lmbc/include/mexpression.h 21;" d -EXPRCOMPOP lmbc/include/mexpression.h 40;" d -EXPRCOMPOPNOFLOAT lmbc/include/mexpression.h 63;" d -EXPRMAXMINOP lmbc/include/mexpression.h 165;" d -EXPRREMOP lmbc/include/mexpression.h 186;" d -EXPRSELECTOP lmbc/include/mexpression.h 81;" d -EXPRUNROP lmbc/include/mexpression.h 214;" d -EvalExpr lmbc/src/invoke_method.cpp /^MValue EvalExpr(MFunction& func, BaseNode* expr, ParmInf *parm) {$/;" f namespace:maple -FFITYPE_Derived lmbc/include/mprimtype.h 112;" d -FFITYPE_Invalid lmbc/include/mprimtype.h 70;" d -FFITYPE_a32 lmbc/include/mprimtype.h 83;" d -FFITYPE_a64 lmbc/include/mprimtype.h 84;" d -FFITYPE_agg lmbc/include/mprimtype.h 104;" d -FFITYPE_c128 lmbc/include/mprimtype.h 89;" d -FFITYPE_c64 lmbc/include/mprimtype.h 88;" d -FFITYPE_constStr lmbc/include/mprimtype.h 102;" d -FFITYPE_dynany lmbc/include/mprimtype.h 92;" d -FFITYPE_dynbool lmbc/include/mprimtype.h 95;" d -FFITYPE_dynf32 lmbc/include/mprimtype.h 100;" d -FFITYPE_dynf64 lmbc/include/mprimtype.h 99;" d -FFITYPE_dyni32 lmbc/include/mprimtype.h 96;" d -FFITYPE_dynnone lmbc/include/mprimtype.h 101;" d -FFITYPE_dynnull lmbc/include/mprimtype.h 94;" d -FFITYPE_dynobj lmbc/include/mprimtype.h 98;" d -FFITYPE_dynstr lmbc/include/mprimtype.h 97;" d -FFITYPE_dynundef lmbc/include/mprimtype.h 93;" d -FFITYPE_f128 lmbc/include/mprimtype.h 87;" d -FFITYPE_f32 lmbc/include/mprimtype.h 85;" d -FFITYPE_f64 lmbc/include/mprimtype.h 86;" d -FFITYPE_gen lmbc/include/mprimtype.h 103;" d -FFITYPE_i128 lmbc/include/mprimtype.h 113;" d -FFITYPE_i16 lmbc/include/mprimtype.h 73;" d -FFITYPE_i32 lmbc/include/mprimtype.h 74;" d -FFITYPE_i64 lmbc/include/mprimtype.h 75;" d -FFITYPE_i8 lmbc/include/mprimtype.h 72;" d -FFITYPE_ptr lmbc/include/mprimtype.h 81;" d -FFITYPE_ref lmbc/include/mprimtype.h 82;" d -FFITYPE_reservedpty1 lmbc/include/mprimtype.h 126;" d -FFITYPE_reservedpty10 lmbc/include/mprimtype.h 135;" d -FFITYPE_reservedpty2 lmbc/include/mprimtype.h 127;" d -FFITYPE_reservedpty3 lmbc/include/mprimtype.h 128;" d -FFITYPE_reservedpty4 lmbc/include/mprimtype.h 129;" d -FFITYPE_reservedpty5 lmbc/include/mprimtype.h 130;" d -FFITYPE_reservedpty6 lmbc/include/mprimtype.h 131;" d -FFITYPE_reservedpty7 lmbc/include/mprimtype.h 132;" d -FFITYPE_reservedpty8 lmbc/include/mprimtype.h 133;" d -FFITYPE_reservedpty9 lmbc/include/mprimtype.h 134;" d -FFITYPE_simpleobj lmbc/include/mprimtype.h 91;" d -FFITYPE_simplestr lmbc/include/mprimtype.h 90;" d -FFITYPE_u1 lmbc/include/mprimtype.h 80;" d -FFITYPE_u128 lmbc/include/mprimtype.h 114;" d -FFITYPE_u16 lmbc/include/mprimtype.h 77;" d -FFITYPE_u32 lmbc/include/mprimtype.h 78;" d -FFITYPE_u64 lmbc/include/mprimtype.h 79;" d -FFITYPE_u8 lmbc/include/mprimtype.h 76;" d -FFITYPE_unknown lmbc/include/mprimtype.h 111;" d -FFITYPE_v16i8 lmbc/include/mprimtype.h 108;" d -FFITYPE_v16u8 lmbc/include/mprimtype.h 118;" d -FFITYPE_v2f32 lmbc/include/mprimtype.h 125;" d -FFITYPE_v2f64 lmbc/include/mprimtype.h 109;" d -FFITYPE_v2i32 lmbc/include/mprimtype.h 119;" d -FFITYPE_v2i64 lmbc/include/mprimtype.h 105;" d -FFITYPE_v2u32 lmbc/include/mprimtype.h 122;" d -FFITYPE_v2u64 lmbc/include/mprimtype.h 115;" d -FFITYPE_v4f32 lmbc/include/mprimtype.h 110;" d -FFITYPE_v4i16 lmbc/include/mprimtype.h 120;" d -FFITYPE_v4i32 lmbc/include/mprimtype.h 106;" d -FFITYPE_v4u16 lmbc/include/mprimtype.h 123;" d -FFITYPE_v4u32 lmbc/include/mprimtype.h 116;" d -FFITYPE_v8i16 lmbc/include/mprimtype.h 107;" d -FFITYPE_v8i8 lmbc/include/mprimtype.h 121;" d -FFITYPE_v8u16 lmbc/include/mprimtype.h 117;" d -FFITYPE_v8u8 lmbc/include/mprimtype.h 124;" d -FFITYPE_void lmbc/include/mprimtype.h 71;" d -FindExtFunc lmbc/src/mplsh.cpp /^void *LmbcMod::FindExtFunc(PUIdx puidx) {$/;" f class:maple::LmbcMod -FindExtSym lmbc/src/mplsh.cpp /^void *LmbcMod::FindExtSym(StIdx stidx) {$/;" f class:maple::LmbcMod -FuncAddr lmbc/include/lmbc_eng.h /^class FuncAddr {$/;" c namespace:maple -FuncAddr lmbc/src/init.cpp /^FuncAddr::FuncAddr(bool lmbcFunc, void *func, std::string name, uint32 formalsAggSz) {$/;" f class:maple::FuncAddr -GetAggCallArgsSize lmbc/src/mfunction.cpp /^size_t GetAggCallArgsSize(LmbcFunc *callee, CallNode *call) {$/;" f namespace:maple -GetAggFormalsSize lmbc/src/init.cpp /^uint32 GetAggFormalsSize(MIRFunction *func) {$/;" f namespace:maple -GetFormalVarAddr lmbc/src/mfunction.cpp /^uint8 *MFunction::GetFormalVarAddr(StIdx stidx) {$/;" f class:maple::MFunction -GetFuncAddr lmbc/src/init.cpp /^FuncAddr* LmbcMod::GetFuncAddr(PUIdx idx) {$/;" f class:maple::LmbcMod -GetGlobalVarInitAddr lmbc/src/init.cpp /^uint8 *LmbcMod::GetGlobalVarInitAddr(VarInf* pInf, uint32 align) {$/;" f class:maple::LmbcMod -GetIReadAggrSize lmbc/src/mfunction.cpp /^size_t GetIReadAggrSize(BaseNode* expr) {$/;" f namespace:maple -GetVarAddr lmbc/src/init.cpp /^uint8 *LmbcMod::GetVarAddr(PUIdx puIdx, StIdx stIdx) {$/;" f class:maple::LmbcMod -GetVarAddr lmbc/src/init.cpp /^uint8 *LmbcMod::GetVarAddr(StIdx stIdx) {$/;" f class:maple::LmbcMod -HandleFloatEq lmbc/src/invoke_method.cpp /^void HandleFloatEq(Opcode op, PrimType opndType, MValue &res, MValue &op1, MValue &op2) {$/;" f namespace:maple -Import lmbc/src/mplsh.cpp /^LmbcMod::Import(std::string path) {$/;" f class:maple::LmbcMod -InitAddrofConst lmbc/src/init.cpp /^void LmbcMod::InitAddrofConst(VarInf *pInf, MIRAddrofConst &addrofConst, uint8* dst) {$/;" f class:maple::LmbcMod -InitAggConst lmbc/src/init.cpp /^void LmbcMod::InitAggConst(VarInf *pInf, MIRConst &mirConst) {$/;" f class:maple::LmbcMod -InitArrayConst lmbc/src/init.cpp /^void LmbcMod::InitArrayConst(VarInf *pInf, MIRConst &mirConst) {$/;" f class:maple::LmbcMod -InitBitFieldConst lmbc/src/init.cpp /^void LmbcMod::InitBitFieldConst(VarInf *pInf, MIRConst &elemConst, int32 &allocdBits, bool &forceAlign) {$/;" f class:maple::LmbcMod -InitDoubleConst lmbc/src/init.cpp /^inline void LmbcMod::InitDoubleConst(VarInf *pInf, MIRDoubleConst &f64Const, uint8* dst) {$/;" f class:maple::LmbcMod -InitFloatConst lmbc/src/init.cpp /^inline void LmbcMod::InitFloatConst(VarInf *pInf, MIRFloatConst &f32Const, uint8* dst) {$/;" f class:maple::LmbcMod -InitGlobalVariable lmbc/src/init.cpp /^void LmbcMod::InitGlobalVariable(VarInf *pInf) {$/;" f class:maple::LmbcMod -InitGlobalVars lmbc/src/init.cpp /^void LmbcMod::InitGlobalVars(void) {$/;" f class:maple::LmbcMod -InitIntConst lmbc/src/init.cpp /^void LmbcMod::InitIntConst(VarInf* pInf, MIRIntConst &intConst, uint8* dst) {$/;" f class:maple::LmbcMod -InitLblConst lmbc/src/init.cpp /^void LmbcMod::InitLblConst(VarInf *pInf, MIRLblConst &labelConst, uint8 *dst) {$/;" f class:maple::LmbcMod -InitModule lmbc/src/init.cpp /^void LmbcMod::InitModule(void) {$/;" f class:maple::LmbcMod -InitPointerConst lmbc/src/init.cpp /^void LmbcMod::InitPointerConst(VarInf *pInf, MIRConst &mirConst) {$/;" f class:maple::LmbcMod -InitScalarConst lmbc/src/init.cpp /^void LmbcMod::InitScalarConst(VarInf *pInf, MIRConst &mirConst) {$/;" f class:maple::LmbcMod -InitStrConst lmbc/src/init.cpp /^void LmbcMod::InitStrConst(VarInf* pInf, MIRStrConst &mirStrConst, uint8* dst) {$/;" f class:maple::LmbcMod -InvokeFunc lmbc/src/invoke_method.cpp /^MValue InvokeFunc(LmbcFunc* fn, MFunction *caller) {$/;" f namespace:maple -IsExtFunc lmbc/src/mfunction.cpp /^bool IsExtFunc(PUIdx puIdx, LmbcMod& module) {$/;" f namespace:maple -IsZero lmbc/src/invoke_method.cpp /^bool IsZero(MValue& cond) {$/;" f namespace:maple -LOAD_ALGO_PRIMARY_TYPE lmbc/src/mfunction.cpp 281;" d file: -LkupLmbcFunc lmbc/src/init.cpp /^LmbcMod::LkupLmbcFunc(PUIdx puIdx) {$/;" f class:maple::LmbcMod -LmbcFunc lmbc/include/lmbc_eng.h /^class LmbcFunc {$/;" c namespace:maple -LmbcFunc lmbc/src/init.cpp /^LmbcFunc::LmbcFunc(LmbcMod *mod, MIRFunction *func) : lmbcMod(mod), mirFunc(func) {$/;" f class:maple::LmbcFunc -LmbcMod lmbc/include/lmbc_eng.h /^class LmbcMod {$/;" c namespace:maple -LmbcMod lmbc/src/mplsh.cpp /^LmbcMod::LmbcMod(char* path) : lmbcPath(path) {$/;" f class:maple::LmbcMod -LoadArgs lmbc/src/invoke_method.cpp /^void LoadArgs(MFunction& func) {$/;" f namespace:maple -LoadDefLibs lmbc/src/mplsh.cpp /^void LmbcMod::LoadDefLibs() {$/;" f class:maple::LmbcMod -MASSERT lmbc/include/massert.h 21;" d -MFunction lmbc/include/mfunction.h /^class MFunction {$/;" c namespace:maple -MFunction lmbc/src/mfunction.cpp /^MFunction::MFunction(LmbcFunc *funcInfo,$/;" f class:maple::MFunction -MPLENG_LMBC_H_ lmbc/include/lmbc_eng.h 16;" d -MPLENG_MASSERT_H_ lmbc/include/massert.h 16;" d -MPLENG_MEXPRESSION_H_ lmbc/include/mexpression.h 16;" d -MPLENG_MFUNCTION_H_ lmbc/include/mfunction.h 16;" d -MPLENG_MPRIMTYPE_H_ lmbc/include/mprimtype.h 16;" d -MPLENG_MVALUE_H_ lmbc/include/mvalue.h 16;" d -MPLENG_SHIM_H_ lmbc/include/eng_shim.h 16;" d -MVal2Int64 lmbc/src/invoke_method.cpp /^int64 MVal2Int64(MValue &val) {$/;" f namespace:maple -MValue lmbc/include/mvalue.h /^ struct MValue {$/;" s namespace:maple -OPCODE lmbc/src/invoke_method.cpp 245;" d file: -OPCODE lmbc/src/invoke_method.cpp 247;" d file: -OPCODE lmbc/src/invoke_method.cpp 626;" d file: -OPCODE lmbc/src/invoke_method.cpp 628;" d file: -PRIMTYPE lmbc/src/mfunction.cpp 280;" d file: -PRIMTYPE lmbc/src/mfunction.cpp 283;" d file: -PTYSIZE_Derived lmbc/include/mprimtype.h 67;" d -PTYSIZE_Invalid lmbc/include/mprimtype.h 25;" d -PTYSIZE_a32 lmbc/include/mprimtype.h 38;" d -PTYSIZE_a64 lmbc/include/mprimtype.h 39;" d -PTYSIZE_agg lmbc/include/mprimtype.h 59;" d -PTYSIZE_c128 lmbc/include/mprimtype.h 44;" d -PTYSIZE_c64 lmbc/include/mprimtype.h 43;" d -PTYSIZE_constStr lmbc/include/mprimtype.h 57;" d -PTYSIZE_dynany lmbc/include/mprimtype.h 47;" d -PTYSIZE_dynbool lmbc/include/mprimtype.h 50;" d -PTYSIZE_dynf32 lmbc/include/mprimtype.h 55;" d -PTYSIZE_dynf64 lmbc/include/mprimtype.h 54;" d -PTYSIZE_dyni32 lmbc/include/mprimtype.h 51;" d -PTYSIZE_dynnone lmbc/include/mprimtype.h 56;" d -PTYSIZE_dynnull lmbc/include/mprimtype.h 49;" d -PTYSIZE_dynobj lmbc/include/mprimtype.h 53;" d -PTYSIZE_dynstr lmbc/include/mprimtype.h 52;" d -PTYSIZE_dynundef lmbc/include/mprimtype.h 48;" d -PTYSIZE_f128 lmbc/include/mprimtype.h 42;" d -PTYSIZE_f32 lmbc/include/mprimtype.h 40;" d -PTYSIZE_f64 lmbc/include/mprimtype.h 41;" d -PTYSIZE_gen lmbc/include/mprimtype.h 58;" d -PTYSIZE_i16 lmbc/include/mprimtype.h 28;" d -PTYSIZE_i32 lmbc/include/mprimtype.h 29;" d -PTYSIZE_i64 lmbc/include/mprimtype.h 30;" d -PTYSIZE_i8 lmbc/include/mprimtype.h 27;" d -PTYSIZE_ptr lmbc/include/mprimtype.h 36;" d -PTYSIZE_ref lmbc/include/mprimtype.h 37;" d -PTYSIZE_simpleobj lmbc/include/mprimtype.h 46;" d -PTYSIZE_simplestr lmbc/include/mprimtype.h 45;" d -PTYSIZE_u1 lmbc/include/mprimtype.h 35;" d -PTYSIZE_u16 lmbc/include/mprimtype.h 32;" d -PTYSIZE_u32 lmbc/include/mprimtype.h 33;" d -PTYSIZE_u64 lmbc/include/mprimtype.h 34;" d -PTYSIZE_u8 lmbc/include/mprimtype.h 31;" d -PTYSIZE_unknown lmbc/include/mprimtype.h 66;" d -PTYSIZE_v16i8 lmbc/include/mprimtype.h 63;" d -PTYSIZE_v2f64 lmbc/include/mprimtype.h 64;" d -PTYSIZE_v2i64 lmbc/include/mprimtype.h 60;" d -PTYSIZE_v4f32 lmbc/include/mprimtype.h 65;" d -PTYSIZE_v4i32 lmbc/include/mprimtype.h 61;" d -PTYSIZE_v8i16 lmbc/include/mprimtype.h 62;" d -PTYSIZE_void lmbc/include/mprimtype.h 26;" d -PUIdx2FuncAddr lmbc/include/lmbc_eng.h /^ std::unordered_map PUIdx2FuncAddr;$/;" m class:maple::LmbcMod -ParmInf lmbc/include/lmbc_eng.h /^ ParmInf(PrimType type, size_t sz, bool ispreg, int32_t storageIdx)$/;" f struct:maple::ParmInf -ParmInf lmbc/include/lmbc_eng.h /^ ParmInf(PrimType type, size_t sz, bool ispreg, int32_t storageIdx, MIRSymbol *psym)$/;" f struct:maple::ParmInf -ParmInf lmbc/include/lmbc_eng.h /^ ParmInf(PrimType type, size_t sz, bool ispreg, int32_t storageIdx, MIRSymbol *psym, PUIdx puidx)$/;" f struct:maple::ParmInf -ParmInf lmbc/include/lmbc_eng.h /^struct ParmInf {$/;" s namespace:maple -ROUNDUP8 lmbc/src/init.cpp 22;" d file: -RegAssignZextOrSext lmbc/src/invoke_method.cpp /^bool RegAssignZextOrSext(MValue& from, PrimType toTyp, MValue& to) {$/;" f namespace:maple -RunLmbc lmbc/src/mplsh.cpp /^RunLmbc(int argc, char** argv) {$/;" f namespace:maple -ScanFormals lmbc/src/init.cpp /^void LmbcFunc::ScanFormals(void) {$/;" f class:maple::LmbcFunc -ScanLabels lmbc/src/init.cpp /^void LmbcFunc::ScanLabels(StmtNode* stmt) {$/;" f class:maple::LmbcFunc -ScanPUStatic lmbc/src/init.cpp /^void LmbcMod::ScanPUStatic(MIRFunction *func) {$/;" f class:maple::LmbcMod -SetBitFieldConst lmbc/src/init.cpp /^void SetBitFieldConst(uint8* baseFdAddr, uint32 baseFdSz, uint32 bitsOffset, uint8 bitsSize, MIRConst &elemConst) {$/;" f namespace:maple -UpdateGlobalVarInitAddr lmbc/src/init.cpp /^inline void LmbcMod::UpdateGlobalVarInitAddr(VarInf* pInf, uint32 size) {$/;" f class:maple::LmbcMod -VARNAMELENGTH lmbc/include/mfunction.h 29;" d -VaListAarch64 lmbc/include/mfunction.h /^} VaListAarch64;$/;" t namespace:maple typeref:struct:maple::__anon2 -VaListX86_64 lmbc/include/mfunction.h /^} VaListX86_64[1];$/;" t namespace:maple typeref:struct:maple::__anon1 -__engineShim lmbc/src/eng_shim.cpp /^__engineShim(LmbcFunc* fn, ...) {$/;" f namespace:maple -a64 lmbc/include/mvalue.h /^ uint8 *a64; \/\/ object ref (use uint8_t* instead of void* for reference)$/;" m union:maple::MValue::__anon4 -aggSize lmbc/include/mvalue.h /^ size_t aggSize; \/\/ for PTY_agg only$/;" m struct:maple::MValue -aggrArgsBuf lmbc/include/mfunction.h /^ uint8* aggrArgsBuf; \/\/ buffer for PTY_agg call formal args, which offsets into it$/;" m class:maple::MFunction -allocaMem lmbc/include/mfunction.h /^ uint8* allocaMem; \/\/ point to reserved stack memory for Maple IR OP_alloca$/;" m class:maple::MFunction -allocaOffset lmbc/include/mfunction.h /^ uint32 allocaOffset; \/\/ next avail offset in allocaMem$/;" m class:maple::MFunction -callArgs lmbc/include/mfunction.h /^ MValue* callArgs; \/\/ array of call args to pass to callee$/;" m class:maple::MFunction -caller lmbc/include/mfunction.h /^ MFunction* caller; \/\/ caller of current func$/;" m class:maple::MFunction -extFuncMap lmbc/include/lmbc_eng.h /^ std::unordered_mapextFuncMap; \/\/ PUIdx to ext func addr map$/;" m class:maple::LmbcMod -extSymMap lmbc/include/lmbc_eng.h /^ std::unordered_mapextSymMap; \/\/ StIdx.FullIdx() to ext sym addr map$/;" m class:maple::LmbcMod -f32 lmbc/include/mvalue.h /^ float f32;$/;" m union:maple::MValue::__anon4 -f64 lmbc/include/mvalue.h /^ double f64;$/;" m union:maple::MValue::__anon4 -ffi_type_table lmbc/src/mfunction.cpp /^static ffi_type ffi_type_table[] = {$/;" m namespace:maple file: -formalVars lmbc/include/mfunction.h /^ MValue* formalVars; \/\/ array of var\/non-preg args passed in$/;" m class:maple::MFunction -formalsAggSize lmbc/include/lmbc_eng.h /^ uint32 formalsAggSize; \/\/ total struct size of all formal args of type agg$/;" m class:maple::LmbcFunc -formalsAggSize lmbc/include/lmbc_eng.h /^ uint32 formalsAggSize; \/\/ native func only$/;" m class:maple::FuncAddr -formalsNum lmbc/include/lmbc_eng.h /^ uint16 formalsNum; \/\/ num formals: vars+pregs$/;" m class:maple::LmbcFunc -formalsNumVars lmbc/include/lmbc_eng.h /^ uint32 formalsNumVars; \/\/ num formals: vars only$/;" m class:maple::LmbcFunc -formalsSize lmbc/include/lmbc_eng.h /^ uint32 formalsSize; \/\/ total size of all formal args$/;" m class:maple::LmbcFunc -fp lmbc/include/mfunction.h /^ uint8* fp; \/\/ point to bottom of frame$/;" m class:maple::MFunction -fp_offset lmbc/include/mfunction.h /^ uint fp_offset;$/;" m struct:maple::__anon1 -frame lmbc/include/mfunction.h /^ uint8* frame; \/\/ stack frame (auto var only)$/;" m class:maple::MFunction -frameSize lmbc/include/lmbc_eng.h /^ uint32 frameSize; \/\/ auto var size in bytes$/;" m class:maple::LmbcFunc -funcMap lmbc/include/lmbc_eng.h /^ FuncMap funcMap;$/;" m class:maple::LmbcMod -funcName lmbc/include/lmbc_eng.h /^ std::string funcName;$/;" m class:maple::FuncAddr -funcPtr lmbc/include/lmbc_eng.h /^ } funcPtr;$/;" m class:maple::FuncAddr typeref:union:maple::FuncAddr::__anon3 -gettid lmbc/include/mfunction.h 23;" d -globalAndStaticVars lmbc/include/lmbc_eng.h /^ std::unordered_map globalAndStaticVars;$/;" m class:maple::LmbcMod -globalStrTbl lmbc/include/lmbc_eng.h /^ std::unordered_map globalStrTbl;$/;" m class:maple::LmbcMod -gp_offset lmbc/include/mfunction.h /^ uint gp_offset;$/;" m struct:maple::__anon1 -gr_offs lmbc/include/mfunction.h /^ int gr_offs;$/;" m struct:maple::__anon2 -gr_top lmbc/include/mfunction.h /^ void *gr_top;$/;" m struct:maple::__anon2 -i16 lmbc/include/mvalue.h /^ int16 i16;$/;" m union:maple::MValue::__anon4 -i32 lmbc/include/mvalue.h /^ int32 i32;$/;" m union:maple::MValue::__anon4 -i64 lmbc/include/mvalue.h /^ int64 i64;$/;" m union:maple::MValue::__anon4 -i8 lmbc/include/mvalue.h /^ int8 i8;$/;" m union:maple::MValue::__anon4 -info lmbc/include/mfunction.h /^ LmbcFunc* info; \/\/ current func$/;" m class:maple::MFunction -isLmbcFunc lmbc/include/lmbc_eng.h /^ bool isLmbcFunc;$/;" m class:maple::FuncAddr -isPreg lmbc/include/lmbc_eng.h /^ bool isPreg;$/;" m struct:maple::ParmInf -isVarArgs lmbc/include/lmbc_eng.h /^ bool isVarArgs;$/;" m class:maple::LmbcFunc -isVararg lmbc/include/lmbc_eng.h /^ bool isVararg;$/;" m struct:maple::ParmInf -labelMap lmbc/include/lmbc_eng.h /^ LabelMap labelMap; \/\/ map labelIdx to Stmt address$/;" m class:maple::LmbcFunc -libHandles lmbc/include/lmbc_eng.h /^ std::vector libHandles;$/;" m class:maple::LmbcMod -lmbcFunc lmbc/include/lmbc_eng.h /^ LmbcFunc *lmbcFunc;$/;" m union:maple::FuncAddr::__anon3 -lmbcMod lmbc/include/lmbc_eng.h /^ LmbcMod *lmbcMod;$/;" m class:maple::LmbcFunc -lmbcPath lmbc/include/lmbc_eng.h /^ std::string lmbcPath;$/;" m class:maple::LmbcMod -main lmbc/src/mplsh.cpp /^main(int argc, char **argv) {$/;" f -maple lmbc/include/eng_shim.h /^namespace maple {$/;" n -maple lmbc/include/lmbc_eng.h /^namespace maple {$/;" n -maple lmbc/include/mfunction.h /^namespace maple {$/;" n -maple lmbc/include/mvalue.h /^namespace maple {$/;" n -maple lmbc/src/eng_shim.cpp /^namespace maple {$/;" n file: -maple lmbc/src/init.cpp /^namespace maple {$/;" n file: -maple lmbc/src/invoke_method.cpp /^namespace maple {$/;" n file: -maple lmbc/src/load_store.cpp /^namespace maple {$/;" n file: -maple lmbc/src/mfunction.cpp /^namespace maple {$/;" n file: -maple lmbc/src/mplsh.cpp /^namespace maple {$/;" n file: -mirFunc lmbc/include/lmbc_eng.h /^ MIRFunction *mirFunc;$/;" m class:maple::LmbcFunc -mload lmbc/src/load_store.cpp /^void mload(uint8* addr, PrimType ptyp, MValue& res, size_t aggSize) {$/;" f namespace:maple -mstore lmbc/src/load_store.cpp /^void mstore(uint8* addr, PrimType ptyp, MValue& val, bool toVarArgStack) {$/;" f namespace:maple -nativeFunc lmbc/include/lmbc_eng.h /^ void *nativeFunc;$/;" m union:maple::FuncAddr::__anon3 -nextStmt lmbc/include/mfunction.h /^ StmtNode* nextStmt; \/\/ next maple IR statement to execute$/;" m class:maple::MFunction -numCallArgs lmbc/include/mfunction.h /^ uint16 numCallArgs; \/\/ number of call args to pass to callee$/;" m class:maple::MFunction -numPregs lmbc/include/lmbc_eng.h /^ size_t numPregs;$/;" m class:maple::LmbcFunc -overflow_arg_area lmbc/include/mfunction.h /^ void *overflow_arg_area;$/;" m struct:maple::__anon1 -pRegs lmbc/include/mfunction.h /^ MValue* pRegs; \/\/ array of pseudo regs used in function$/;" m class:maple::MFunction -pos2Parm lmbc/include/lmbc_eng.h /^ std::vector pos2Parm; \/\/ formals info lkup by pos order$/;" m class:maple::LmbcFunc -preLoadLibs lmbc/src/mplsh.cpp /^std::vector preLoadLibs = {$/;" m namespace:maple file: -ptr lmbc/include/mvalue.h /^ void *ptr;$/;" m union:maple::MValue::__anon4 -ptyp lmbc/include/lmbc_eng.h /^ PrimType ptyp;$/;" m struct:maple::ParmInf -ptyp lmbc/include/mvalue.h /^ PrimType ptyp:8;$/;" m struct:maple::MValue -puIdx lmbc/include/lmbc_eng.h /^ PUIdx puIdx; \/\/ VarInf only - for PUStatic var$/;" m struct:maple::ParmInf -reg_save_area lmbc/include/mfunction.h /^ void *reg_save_area;$/;" m struct:maple::__anon1 -retSize lmbc/include/lmbc_eng.h /^ uint32 retSize;$/;" m class:maple::LmbcFunc -retVal0 lmbc/include/mfunction.h /^ MValue retVal0; \/\/ %retVal0 return from callee$/;" m class:maple::MFunction -retVal1 lmbc/include/mfunction.h /^ MValue retVal1; \/\/ %retval1 return from callee$/;" m class:maple::MFunction -size lmbc/include/lmbc_eng.h /^ size_t size;$/;" m struct:maple::ParmInf -stack lmbc/include/mfunction.h /^ void *stack;$/;" m struct:maple::__anon2 -stidx2Parm lmbc/include/lmbc_eng.h /^ std::unordered_map stidx2Parm; \/\/ formals info lkup by formals stidx$/;" m class:maple::LmbcFunc -storeIdx lmbc/include/lmbc_eng.h /^ int32 storeIdx;$/;" m struct:maple::ParmInf -str lmbc/include/mvalue.h /^ void *str;$/;" m union:maple::MValue::__anon4 -sym lmbc/include/lmbc_eng.h /^ MIRSymbol *sym; \/\/ VarInf only - for global and PUStatic var$/;" m struct:maple::ParmInf -u16 lmbc/include/mvalue.h /^ uint16 u16;$/;" m union:maple::MValue::__anon4 -u32 lmbc/include/mvalue.h /^ uint32 u32;$/;" m union:maple::MValue::__anon4 -u64 lmbc/include/mvalue.h /^ uint64 u64;$/;" m union:maple::MValue::__anon4 -u8 lmbc/include/mvalue.h /^ uint8 u8;$/;" m union:maple::MValue::__anon4 -vaArgs lmbc/include/mfunction.h /^ uint8* vaArgs; \/\/ AARCH64 ABI vararg stack for calling va-arg funcs$/;" m class:maple::MFunction -vaArgsSize lmbc/include/mfunction.h /^ uint32 vaArgsSize;$/;" m class:maple::MFunction -vaListObjAarch64 lmbc/src/mfunction.cpp /^ffi_type *vaListObjAarch64 [] = {$/;" m namespace:maple file: -vaListObjX86_64 lmbc/src/mfunction.cpp /^ffi_type *vaListObjX86_64 [] = {$/;" m namespace:maple file: -vaList_ffi_type lmbc/src/mfunction.cpp /^ffi_type vaList_ffi_type = { 0, 0, FFI_TYPE_STRUCT, vaListObjAarch64 };$/;" m namespace:maple file: -varArgsBuf lmbc/include/mfunction.h /^ uint8* varArgsBuf; \/\/ buffer for PTY_agg call var-args, which offsets into it$/;" m class:maple::MFunction -vr_offs lmbc/include/mfunction.h /^ int vr_offs;$/;" m struct:maple::__anon2 -vr_top lmbc/include/mfunction.h /^ void *vr_top;$/;" m struct:maple::__anon2 -x lmbc/include/mvalue.h /^ } x;$/;" m struct:maple::MValue typeref:union:maple::MValue::__anon4 -~MFunction lmbc/src/mfunction.cpp /^MFunction::~MFunction() { }$/;" f class:maple::MFunction -- Gitee