react-native-update 10.34.2 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/test/unit_test.cpp

@@ -0,0 +1,417 @@
+//unit_test.cpp
+// for unitTest
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2017 HouSisong
+
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <time.h>
+#include <stdio.h>
+#include <string.h>
+#include <stddef.h>//for ptrdiff_t
+#include <stdlib.h>
+#include "math.h"
+#include "../libHDiffPatch/HDiff/diff.h"
+#include "../libHDiffPatch/HPatch/patch.h"
+typedef unsigned char   TByte;
+typedef ptrdiff_t       TInt;
+typedef size_t          TUInt;
+const long kRandTestCount=20000;
+//#define _AttackPacth_ON
+
+//===== select compress plugin =====
+#define _CompressPlugin_no
+//#define _CompressPlugin_zlib
+//#define _CompressPlugin_bz2
+//#define _CompressPlugin_lzma
+//#define _CompressPlugin_lzma2
+//#define _CompressPlugin_lz4
+//#define _CompressPlugin_lz4hc
+//#define _CompressPlugin_zstd
+//#define _CompressPlugin_brotli
+//#define _CompressPlugin_lzham
+
+#define IS_NOTICE_compress_canceled 0 //for test, close compress fail notice
+#define IS_REUSE_compress_handle    1 //for test, must in single thread
+#include "../compress_plugin_demo.h"
+#include "../decompress_plugin_demo.h"
+
+
+#ifdef  _CompressPlugin_no
+    const hdiff_TCompress* compressPlugin=0;
+    hpatch_TDecompress* decompressPlugin=0;
+#endif
+#ifdef  _CompressPlugin_zlib
+    const hdiff_TCompress* compressPlugin=&zlibCompressPlugin.base;
+    hpatch_TDecompress* decompressPlugin=&zlibDecompressPlugin;
+#endif
+#ifdef  _CompressPlugin_bz2
+    const hdiff_TCompress* compressPlugin=&bz2CompressPlugin.base;
+    hpatch_TDecompress* decompressPlugin=&bz2DecompressPlugin;
+#endif
+#ifdef  _CompressPlugin_lzma
+    const hdiff_TCompress* compressPlugin=&lzmaCompressPlugin.base;
+    hpatch_TDecompress* decompressPlugin=&lzmaDecompressPlugin;
+#endif
+#ifdef  _CompressPlugin_lzma2
+    const hdiff_TCompress* compressPlugin=&lzma2CompressPlugin.base;
+    hpatch_TDecompress* decompressPlugin=&lzma2DecompressPlugin;
+#endif
+#ifdef  _CompressPlugin_lz4
+    const hdiff_TCompress* compressPlugin=&lz4CompressPlugin.base;
+    hpatch_TDecompress* decompressPlugin=&lz4DecompressPlugin;
+#endif
+#ifdef  _CompressPlugin_lz4hc
+    const hdiff_TCompress* compressPlugin=&lz4hcCompressPlugin.base;
+    hpatch_TDecompress* decompressPlugin=&lz4DecompressPlugin;
+#endif
+#ifdef  _CompressPlugin_zstd
+    const hdiff_TCompress* compressPlugin=&zstdCompressPlugin.base;
+    hpatch_TDecompress* decompressPlugin=&zstdDecompressPlugin;
+#endif
+#ifdef  _CompressPlugin_brotli
+    const hdiff_TCompress* compressPlugin=&brotliCompressPlugin.base;
+    hpatch_TDecompress* decompressPlugin=&brotliDecompressPlugin;
+#endif
+#ifdef  _CompressPlugin_lzham
+    const hdiff_TCompress* compressPlugin=&lzhamCompressPlugin.base;
+    hpatch_TDecompress* decompressPlugin=&lzhamDecompressPlugin;
+#endif
+
+int testCompress(const char* str,const char* error_tag){
+    assert(  ((compressPlugin==0)&&(decompressPlugin==0))
+           ||((compressPlugin!=0)&&(decompressPlugin!=0)));
+    if (compressPlugin==0) return 0;
+    assert(decompressPlugin->is_can_open(compressPlugin->compressType()));
+    
+    const TByte* data=(const TByte*)str;
+    const size_t dataSize=strlen(str);
+    std::vector<TByte> code((size_t)compressPlugin->maxCompressedSize(dataSize));
+    size_t codeSize=hdiff_compress_mem(compressPlugin,code.data(),code.data()+code.size(),
+                                       data,data+dataSize);
+    if (codeSize>code.size()) {
+        printf("\n testCompress compress error!!! tag:%s\n",error_tag); return 1; }
+    code.resize(codeSize);
+    
+    std::vector<TByte> undata(dataSize);
+    if (!hpatch_deccompress_mem(decompressPlugin,code.data(),code.data()+code.size(),
+                                undata.data(),undata.data()+undata.size()))  {
+        printf("\n testCompress decompress error!!! tag:%s\n",error_tag); return 1; }
+    if (0!=memcmp(str,undata.data(),undata.size()))  {
+        printf("\n testCompress decompress data error!!! tag:%s\n",error_tag); return 1; }
+    return 0;
+}
+    
+
+static bool _patch_mem_stream(TByte* newData,TByte* newData_end,
+                              const TByte* oldData,const TByte* oldData_end,
+                              const TByte* diff,const TByte* diff_end){
+    struct hpatch_TStreamOutput out_newStream;
+    struct hpatch_TStreamInput  oldStream;
+    struct hpatch_TStreamInput  diffStream;
+    mem_as_hStreamOutput(&out_newStream,newData,newData_end);
+    mem_as_hStreamInput(&oldStream,oldData,oldData_end);
+    mem_as_hStreamInput(&diffStream,diff,diff_end);
+    
+    return 0!=patch_stream(&out_newStream,&oldStream,&diffStream);
+}
+
+static bool check_diff_stream(const TByte* newData,const TByte* newData_end,
+                              const TByte* oldData,const TByte* oldData_end,
+                              const TByte* diff,const TByte* diff_end){
+    std::vector<TByte> testNewData(newData_end-newData);
+    TByte* testNewData0=testNewData.data();
+
+    if (!_patch_mem_stream(testNewData0,testNewData0+testNewData.size(),
+                           oldData,oldData_end,diff,diff_end))
+        return false;
+    for (TUInt i=0; i<(TUInt)testNewData.size(); ++i) {
+        if (testNewData[i]!=newData[i])
+            return false;
+    }
+    return true;
+}
+
+
+#ifdef _AttackPacth_ON
+long attackPacth(TByte* out_newData,TByte* out_newData_end,
+                        const TByte* oldData,const TByte* oldData_end,
+                        const TByte* diffData,const TByte* diffData_end,
+                        const char* error_tag,bool isDiffz){
+    if (isDiffz){
+        patch_decompress_mem(out_newData,out_newData_end,oldData,oldData_end,
+                             diffData,diffData_end,decompressPlugin);
+    }else{
+        hpatch_BOOL rt0=patch(out_newData,out_newData_end,oldData,oldData_end,diffData,diffData_end);
+        hpatch_BOOL rt1=_patch_mem_stream(out_newData,out_newData_end,oldData,oldData_end,diffData,diffData_end);
+        if (rt0!=rt1){
+            printf("\n attackPacth error!!! tag:%s\n",error_tag);
+            return 1;
+        }
+    }
+    return 0;
+}
+
+long attackPacth(TInt newSize,const TByte* oldData,const TByte* oldData_end,
+                 const TByte* _diffData,const TByte* _diffData_end,int seed,bool isDiffz){
+    char tag[250]="\0";
+    srand(seed);
+    const long kLoopCount=1000;
+    long exceptionCount=0;
+    std::vector<TByte> _newData(newSize);
+    TByte* newData=_newData.data();
+    TByte* newData_end=newData+_newData.size();
+    const TInt diffSize=_diffData_end-_diffData;
+    std::vector<TByte> new_diffData(diffSize);
+    TByte* diffData=new_diffData.data();
+    TByte* diffData_end=diffData+diffSize;
+    try {
+        for (long i=0; i<kLoopCount; ++i) {
+            sprintf(tag, "attackPacth exceptionCount=%ld testSeed=%d i=%ld",exceptionCount,seed,i);
+            memcpy(diffData,_diffData,_diffData_end-_diffData);
+            const long randCount=(long)(1+rand()*(1.0/RAND_MAX)*rand()*(1.0/RAND_MAX)*diffSize/3);
+            for (long r=0; r<randCount; ++r){
+                diffData[rand()%diffSize]=rand();
+            }
+            exceptionCount+=attackPacth(newData,newData_end,oldData,oldData_end,diffData,diffData_end,tag,isDiffz);
+        }
+        return exceptionCount;
+    } catch (...) {
+        printf("exception!!! tag:%s\n",tag);
+        return exceptionCount+1;
+    }
+}
+#endif
+
+struct TVectorStreamOutput:public hpatch_TStreamOutput{
+    explicit TVectorStreamOutput(std::vector<TByte>& _dst):dst(_dst){
+        this->streamImport=this;
+        this->streamSize=~(hpatch_StreamPos_t)0;
+        this->read_writed=0;
+        this->write=_write;
+    }
+    static hpatch_BOOL _write(const hpatch_TStreamOutput* stream,
+                              const hpatch_StreamPos_t writeToPos,
+                              const unsigned char* data,const unsigned char* data_end){
+        TVectorStreamOutput* self=(TVectorStreamOutput*)stream->streamImport;
+        std::vector<TByte>& dst=self->dst;
+        size_t writeLen=(size_t)(data_end-data);
+        if (writeToPos>dst.size()) return false;
+        if  (dst.size()==writeToPos){
+            dst.insert(dst.end(),data,data_end);
+        }else{
+            if (writeToPos+writeLen!=(size_t)(writeToPos+writeLen)) return false;
+            if (dst.size()<writeToPos+writeLen)
+                dst.resize((size_t)(writeToPos+writeLen));
+            memcpy(&dst[(size_t)writeToPos],data,writeLen);
+        }
+        return true;
+    }
+    std::vector<TByte>& dst;
+};
+
+long test(const TByte* newData,const TByte* newData_end,
+          const TByte* oldData,const TByte* oldData_end,const char* tag,size_t* out_diffSize=0){
+    printf("%s newSize:%ld oldSize:%ld ",tag, (long)(newData_end-newData), (long)(oldData_end-oldData));
+    long result=0;
+    {//test diffz stream
+        std::vector<TByte> diffData;
+        struct hpatch_TStreamInput  newStream;
+        struct hpatch_TStreamInput  oldStream;
+        TVectorStreamOutput out_diffStream(diffData);
+        mem_as_hStreamInput(&newStream,newData,newData_end);
+        mem_as_hStreamInput(&oldStream,oldData,oldData_end);
+
+        create_compressed_diff_stream(&newStream,&oldStream,&out_diffStream,compressPlugin,1<<4);
+        
+        struct hpatch_TStreamInput in_diffStream;
+        mem_as_hStreamInput(&in_diffStream,diffData.data(),diffData.data()+diffData.size());
+        if (!check_compressed_diff(newData,newData_end,oldData,oldData_end,
+                                   diffData.data(),diffData.data()+diffData.size(),decompressPlugin)){
+            printf("\n diffz stream error!!! tag:%s\n",tag);
+            ++result;
+        }else{
+            printf(" diffzStream:%ld", (long)(diffData.size()));
+#ifdef _AttackPacth_ON
+            long exceptionCount=attackPacth(newData_end-newData,oldData,oldData_end,
+                                            diffData.data(),diffData.data()+diffData.size(),rand(),true);
+            if (exceptionCount>0) return exceptionCount;
+#endif
+        }
+    }
+    {//test diffz
+        std::vector<TByte> diffData;
+        create_compressed_diff(newData,newData_end,oldData,oldData_end,diffData,compressPlugin);
+        if (!check_compressed_diff(newData,newData_end,oldData,oldData_end,
+                                   diffData.data(),diffData.data()+diffData.size(),decompressPlugin)){
+            printf("\n diffz error!!! tag:%s\n",tag);
+            ++result;
+        }else{
+            printf(" diffz:%ld", (long)(diffData.size()));
+#ifdef _AttackPacth_ON
+            long exceptionCount=attackPacth(newData_end-newData,oldData,oldData_end,
+                                            diffData.data(),diffData.data()+diffData.size(),rand(),true);
+            if (exceptionCount>0) return exceptionCount;
+#endif
+        }
+    }
+    {//test diff
+        std::vector<TByte> diffData;
+        create_diff(newData,newData_end,oldData,oldData_end, diffData);
+        if (out_diffSize!=0)
+            *out_diffSize=diffData.size();
+        if ((!check_diff(newData,newData_end,oldData,oldData_end,diffData.data(),diffData.data()+diffData.size()))
+            ||(!check_diff_stream(newData,newData_end,oldData,oldData_end,
+                                  diffData.data(),diffData.data()+diffData.size())) ){
+            printf("\n  error!!! tag:%s\n",tag);
+            ++result;
+        }else{
+            printf(" diff:%ld\n", (long)(diffData.size()));
+#ifdef _AttackPacth_ON
+            long exceptionCount=attackPacth(newData_end-newData,oldData,oldData_end,
+                                            diffData.data(),diffData.data()+diffData.size(),rand(),false);
+            if (exceptionCount>0) return exceptionCount;
+#endif
+        }
+    }
+    return result;
+}
+
+
+
+static inline long test(const char* newStr,const char* oldStr,const char* error_tag){
+    const TByte* newData=(const TByte*)newStr;
+    const TByte* oldData=(const TByte*)oldStr;
+    return test(newData,newData+strlen(newStr),oldData,oldData+strlen(oldStr),error_tag);
+}
+
+
+void setRandDataSize(int kMaxDataSize,std::vector<TByte>& oldData,std::vector<TByte>& newData,
+                            double sunSizeMin,double subSizeMax){
+    const TInt oldSize=(TInt)(rand()*(1.0/RAND_MAX)*rand()*(1.0/RAND_MAX)*kMaxDataSize);
+    const TInt newSize=(TInt)(oldSize*(sunSizeMin+rand()*(1.0/RAND_MAX)*(subSizeMax-sunSizeMin)));
+    newData.resize(newSize);
+    oldData.resize(oldSize);
+}
+
+void setRandData(std::vector<TByte>& data){
+    for (TInt i=0; i<(TInt)data.size(); ++i)
+        data[i]=rand();
+}
+
+
+int main(int argc, const char * argv[]){
+    clock_t time1=clock();
+    long errorCount=0;
+    errorCount+=testCompress("","c1");
+    errorCount+=testCompress("1","c2");
+    errorCount+=testCompress("12","c3");
+    errorCount+=testCompress("123","c4");
+    errorCount+=testCompress("123456789876543212345677654321234567765432","c5");
+    
+    errorCount+=test("", "", "1");
+    errorCount+=test("", "1", "2");
+    errorCount+=test("1", "", "3");
+    errorCount+=test("1", "1", "4");
+    errorCount+=test("22", "11", "5");
+    errorCount+=test("22", "22", "6");
+    errorCount+=test("1234567890", "1234567890", "7");
+    errorCount+=test("123456789876543212345677654321234567765432", "asadsdasfefw45fg4gacasc234fervsvdfdsfef4g4gr", "8");
+    errorCount+=test("123456789876543212345677654321234567765432asadsdasfefw45fg4gacasc234fervsvdfdsfef4g4gr", "asadsdasfefw45fg4gacasc234fervsvdfdsfef4g4gr", "9");
+    errorCount+=test("asadsdasfefw45fg4gacasc234fervsvdfdsfef4g4gr123456789876543212345677654321234567765432", "asadsdasfefw45fg4gacasc234fervsvdfdsfef4g4gr", "10");
+    errorCount+=test("a123456789876543212345677654321234567765432asadsdasfefw45fg4gacasc234fervsvdfdsfef4g4gr", "asadsdasfefw45fg4gacasc234fervsvdfdsfef4g4gr", "11");
+    errorCount+=test("123456789876543212345677654321234567765432asadsdasfefw45fg4gacasc234fervsvdfdsfef4g4gr1", "asadsdasfefw45fg4gacasc234fervsvdfdsfef4g4gr", "12");
+    errorCount+=test("a123456789876543212345677654321234567765432asadsdasfefw45fg4gacasc234fervsvdfdsfef4g4gr1", "asadsdasfefw45fg4gacasc234fervsvdfdsfef4g4gr", "13");
+
+    {
+        const char* _strData14="a123456789876543212345677654321234567765432asadsdasfefw45fg4gacasc234fervsvdfdsfef4g4gr1";
+        const TByte* data14=(const TByte*)_strData14;
+        const size_t dataSize=strlen(_strData14);
+        size_t diffSize14=0;
+        errorCount+=test(data14, data14+dataSize,data14, data14+dataSize, "14",&diffSize14);
+        if (diffSize14>=dataSize){
+            ++errorCount;
+            printf("error!!! tag:%s\n","14 test diff size");
+        }
+    }
+
+    const int kMaxDataSize=1024*16;
+    
+    std::vector<int> seeds(kRandTestCount);
+    srand(0);
+    for (int i=0; i<kRandTestCount; ++i)
+        seeds[i]=rand();
+
+    double sumNewSize=0;
+    double sumOldSize=0;
+    double sumDiffSize=0;
+    std::vector<TByte> _newData;
+    std::vector<TByte> _oldData;
+    for (TInt i=0; i<kRandTestCount; ++i) {
+        char tag[256];
+    #if defined(_MSC_VER)&&(_MSC_VER>=1400) //VC2005
+        sprintf_s(tag,256, "error==%ld testSeed=%d",errorCount,seeds[i]);
+    #else
+        sprintf(tag, "error==%ld testSeed=%d",errorCount,seeds[i]);
+    #endif
+
+        srand(seeds[i]);
+
+        setRandDataSize(kMaxDataSize,_oldData,_newData,0.7,1.5);
+        setRandData(_oldData);
+        setRandData(_newData);
+        const TInt oldSize=(TInt)_oldData.size();
+        const TInt newSize=(TInt)_newData.size();
+        const TInt kMaxCopyCount=(TInt)sqrt((double)oldSize);
+        TByte* newData=_newData.data();
+        TByte* oldData=_oldData.data();
+        const TInt copyCount=0+(TInt)((1-rand()*(1.0/RAND_MAX)*rand()*(1.0/RAND_MAX))*kMaxCopyCount*4);
+        const TInt kMaxCopyLength=(TInt)(1+rand()*(1.0/RAND_MAX)*kMaxCopyCount*4);
+        for (TInt ci=0; ci<copyCount; ++ci) {
+            const TInt length=1+(TInt)(rand()*(1.0/RAND_MAX)*kMaxCopyLength);
+            if ((length>oldSize*4/5)||(length>newSize*4/5)) {
+                continue;
+            }
+            const TInt oldPos=(oldSize-length==0)?0:(TInt)(rand()*(1.0/RAND_MAX)*(oldSize-length));
+            const TInt newPos=(newSize-length==0)?0:(TInt)(rand()*(1.0/RAND_MAX)*(newSize-length));
+            memcpy(&newData[0]+newPos, &oldData[0]+oldPos, length);
+        }
+        size_t diffSize=0;
+        errorCount+=test(&newData[0],&newData[0]+newSize,&oldData[0],&oldData[0]+oldSize,tag,&diffSize);
+        sumNewSize+=newSize;
+        sumOldSize+=oldSize;
+        sumDiffSize+=diffSize;
+    }
+
+    printf("\nchecked:%ld  errorCount:%ld\n",kRandTestCount,errorCount);
+    printf("newSize:100%% oldSize:%2.2f%% diffSize:%2.2f%%\n",sumOldSize*100.0/sumNewSize,sumDiffSize*100.0/sumNewSize);
+    clock_t time2=clock();
+    printf("\nrun time:%.1f s\n",(time2-time1)*(1.0/CLOCKS_PER_SEC));
+
+    return (int)errorCount;
+}

package/harmony/pushy/src/main/cpp/lzma/Asm/arm/7zCrcOpt.asm

@@ -0,0 +1,100 @@
+	CODE32
+
+	EXPORT	|CrcUpdateT4@16|
+
+	AREA	|.text|, CODE, ARM
+
+	MACRO
+	CRC32_STEP_1
+
+	ldrb    r4, [r1], #1
+	subs    r2, r2, #1
+	eor     r4, r4, r0
+	and     r4, r4, #0xFF
+	ldr     r4, [r3, +r4, lsl #2]
+	eor     r0, r4, r0, lsr #8
+
+	MEND
+
+
+	MACRO
+	CRC32_STEP_4 $STREAM_WORD
+	
+	eor     r7, r7, r8
+	eor     r7, r7, r9
+	eor     r0, r0, r7
+	eor     r0, r0, $STREAM_WORD
+	ldr     $STREAM_WORD, [r1], #4
+	
+	and     r7, r0, #0xFF
+	and     r8, r0, #0xFF00
+	and     r9, r0, #0xFF0000
+	and     r0, r0, #0xFF000000
+
+	ldr     r7, [r6, +r7, lsl #2]
+	ldr     r8, [r5, +r8, lsr #6]
+	ldr     r9, [r4, +r9, lsr #14]
+	ldr     r0, [r3, +r0, lsr #22]
+	
+	MEND
+
+
+|CrcUpdateT4@16| PROC
+
+	stmdb   sp!, {r4-r11, lr}
+	cmp     r2, #0
+	beq     |$fin|
+
+|$v1|
+	tst     r1, #7
+	beq     |$v2|
+	CRC32_STEP_1
+	bne     |$v1|
+
+|$v2|
+	cmp     r2, #16
+	blo     |$v3|
+
+	ldr     r10, [r1], #4
+	ldr     r11, [r1], #4
+
+	add     r4, r3, #0x400 
+	add     r5, r3, #0x800
+	add     r6, r3, #0xC00
+
+	mov     r7, #0
+	mov     r8, #0
+	mov     r9, #0
+
+	sub     r2, r2, #16
+
+|$loop|
+	; pld     [r1, #0x40]
+
+	CRC32_STEP_4 r10
+	CRC32_STEP_4 r11
+
+	subs    r2, r2, #8
+	bhs     |$loop|
+
+	sub     r1, r1, #8
+	add     r2, r2, #16
+
+	eor     r7, r7, r8
+	eor     r7, r7, r9
+	eor     r0, r0, r7
+
+|$v3|
+	cmp     r2, #0
+	beq     |$fin|
+
+|$v4|
+	CRC32_STEP_1
+	bne     |$v4|
+
+|$fin|
+	ldmia   sp!, {r4-r11, pc}
+
+|CrcUpdateT4@16| ENDP
+
+	END

package/harmony/pushy/src/main/cpp/lzma/Asm/x86/7zAsm.asm

@@ -0,0 +1,147 @@
+; 7zAsm.asm -- ASM macros
+; 2018-02-03 : Igor Pavlov : Public domain
+
+MY_ASM_START macro
+  ifdef x64
+    .code
+  else
+    .386
+    .model flat
+    _TEXT$00 SEGMENT PARA PUBLIC 'CODE'
+  endif
+endm
+
+MY_PROC macro name:req, numParams:req
+  align 16
+  proc_numParams = numParams
+  ifdef x64
+    proc_name equ name
+  else
+    proc_name equ @CatStr(@,name,@, %numParams * 4)
+  endif
+  proc_name PROC
+endm
+
+MY_ENDP macro
+  ifdef x64
+    ret
+  else
+    if proc_numParams LT 3
+      ret
+    else
+      ret (proc_numParams - 2) * 4
+    endif
+  endif
+  proc_name ENDP
+endm
+
+ifdef x64
+  REG_SIZE equ 8
+  REG_LOGAR_SIZE equ 3
+else
+  REG_SIZE equ 4
+  REG_LOGAR_SIZE equ 2
+endif
+
+  x0 equ EAX
+  x1 equ ECX
+  x2 equ EDX
+  x3 equ EBX
+  x4 equ ESP
+  x5 equ EBP
+  x6 equ ESI
+  x7 equ EDI
+
+  x0_W equ AX
+  x1_W equ CX
+  x2_W equ DX
+  x3_W equ BX
+
+  x5_W equ BP
+  x6_W equ SI
+  x7_W equ DI
+
+  x0_L equ AL
+  x1_L equ CL
+  x2_L equ DL
+  x3_L equ BL
+
+  x0_H equ AH
+  x1_H equ CH
+  x2_H equ DH
+  x3_H equ BH
+
+ifdef x64
+  x5_L equ BPL
+  x6_L equ SIL
+  x7_L equ DIL
+
+  r0 equ RAX
+  r1 equ RCX
+  r2 equ RDX
+  r3 equ RBX
+  r4 equ RSP
+  r5 equ RBP
+  r6 equ RSI
+  r7 equ RDI
+  x8 equ r8d
+  x9 equ r9d
+  x10 equ r10d
+  x11 equ r11d
+  x12 equ r12d
+  x13 equ r13d
+  x14 equ r14d
+  x15 equ r15d
+else
+  r0 equ x0
+  r1 equ x1
+  r2 equ x2
+  r3 equ x3
+  r4 equ x4
+  r5 equ x5
+  r6 equ x6
+  r7 equ x7
+endif
+
+MY_PUSH_4_REGS macro
+    push    r3
+    push    r5
+    push    r6
+    push    r7
+endm
+
+MY_POP_4_REGS macro
+    pop     r7
+    pop     r6
+    pop     r5
+    pop     r3
+endm
+
+
+ifdef x64
+
+; for WIN64-x64 ABI:
+
+REG_PARAM_0 equ r1
+REG_PARAM_1 equ r2
+REG_PARAM_2 equ r8
+REG_PARAM_3 equ r9
+
+MY_PUSH_PRESERVED_REGS macro
+    MY_PUSH_4_REGS
+    push    r12
+    push    r13
+    push    r14
+    push    r15
+endm
+
+
+MY_POP_PRESERVED_REGS macro
+    pop     r15
+    pop     r14
+    pop     r13
+    pop     r12
+    MY_POP_4_REGS
+endm
+
+endif