@patleeman/pi-boy 0.1.0

package/mgba-bridge/vendor/mgba/src/third-party/lzma/Bcj2.c

@@ -0,0 +1,257 @@
+/* Bcj2.c -- BCJ2 Decoder (Converter for x86 code)
+2018-04-28 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "Bcj2.h"
+#include "CpuArch.h"
+
+#define CProb UInt16
+
+#define kTopValue ((UInt32)1 << 24)
+#define kNumModelBits 11
+#define kBitModelTotal (1 << kNumModelBits)
+#define kNumMoveBits 5
+
+#define _IF_BIT_0 ttt = *prob; bound = (p->range >> kNumModelBits) * ttt; if (p->code < bound)
+#define _UPDATE_0 p->range = bound; *prob = (CProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
+#define _UPDATE_1 p->range -= bound; p->code -= bound; *prob = (CProb)(ttt - (ttt >> kNumMoveBits));
+
+void Bcj2Dec_Init(CBcj2Dec *p)
+{
+  unsigned i;
+
+  p->state = BCJ2_DEC_STATE_OK;
+  p->ip = 0;
+  p->temp[3] = 0;
+  p->range = 0;
+  p->code = 0;
+  for (i = 0; i < sizeof(p->probs) / sizeof(p->probs[0]); i++)
+    p->probs[i] = kBitModelTotal >> 1;
+}
+
+SRes Bcj2Dec_Decode(CBcj2Dec *p)
+{
+  if (p->range <= 5)
+  {
+    p->state = BCJ2_DEC_STATE_OK;
+    for (; p->range != 5; p->range++)
+    {
+      if (p->range == 1 && p->code != 0)
+        return SZ_ERROR_DATA;
+      
+      if (p->bufs[BCJ2_STREAM_RC] == p->lims[BCJ2_STREAM_RC])
+      {
+        p->state = BCJ2_STREAM_RC;
+        return SZ_OK;
+      }
+
+      p->code = (p->code << 8) | *(p->bufs[BCJ2_STREAM_RC])++;
+    }
+    
+    if (p->code == 0xFFFFFFFF)
+      return SZ_ERROR_DATA;
+    
+    p->range = 0xFFFFFFFF;
+  }
+  else if (p->state >= BCJ2_DEC_STATE_ORIG_0)
+  {
+    while (p->state <= BCJ2_DEC_STATE_ORIG_3)
+    {
+      Byte *dest = p->dest;
+      if (dest == p->destLim)
+        return SZ_OK;
+      *dest = p->temp[(size_t)p->state - BCJ2_DEC_STATE_ORIG_0];
+      p->state++;
+      p->dest = dest + 1;
+    }
+  }
+
+  /*
+  if (BCJ2_IS_32BIT_STREAM(p->state))
+  {
+    const Byte *cur = p->bufs[p->state];
+    if (cur == p->lims[p->state])
+      return SZ_OK;
+    p->bufs[p->state] = cur + 4;
+    
+    {
+      UInt32 val;
+      Byte *dest;
+      SizeT rem;
+      
+      p->ip += 4;
+      val = GetBe32(cur) - p->ip;
+      dest = p->dest;
+      rem = p->destLim - dest;
+      if (rem < 4)
+      {
+        SizeT i;
+        SetUi32(p->temp, val);
+        for (i = 0; i < rem; i++)
+          dest[i] = p->temp[i];
+        p->dest = dest + rem;
+        p->state = BCJ2_DEC_STATE_ORIG_0 + (unsigned)rem;
+        return SZ_OK;
+      }
+      SetUi32(dest, val);
+      p->temp[3] = (Byte)(val >> 24);
+      p->dest = dest + 4;
+      p->state = BCJ2_DEC_STATE_OK;
+    }
+  }
+  */
+
+  for (;;)
+  {
+    if (BCJ2_IS_32BIT_STREAM(p->state))
+      p->state = BCJ2_DEC_STATE_OK;
+    else
+    {
+      if (p->range < kTopValue)
+      {
+        if (p->bufs[BCJ2_STREAM_RC] == p->lims[BCJ2_STREAM_RC])
+        {
+          p->state = BCJ2_STREAM_RC;
+          return SZ_OK;
+        }
+        p->range <<= 8;
+        p->code = (p->code << 8) | *(p->bufs[BCJ2_STREAM_RC])++;
+      }
+
+      {
+        const Byte *src = p->bufs[BCJ2_STREAM_MAIN];
+        const Byte *srcLim;
+        Byte *dest;
+        SizeT num = p->lims[BCJ2_STREAM_MAIN] - src;
+        
+        if (num == 0)
+        {
+          p->state = BCJ2_STREAM_MAIN;
+          return SZ_OK;
+        }
+        
+        dest = p->dest;
+        if (num > (SizeT)(p->destLim - dest))
+        {
+          num = p->destLim - dest;
+          if (num == 0)
+          {
+            p->state = BCJ2_DEC_STATE_ORIG;
+            return SZ_OK;
+          }
+        }
+       
+        srcLim = src + num;
+
+        if (p->temp[3] == 0x0F && (src[0] & 0xF0) == 0x80)
+          *dest = src[0];
+        else for (;;)
+        {
+          Byte b = *src;
+          *dest = b;
+          if (b != 0x0F)
+          {
+            if ((b & 0xFE) == 0xE8)
+              break;
+            dest++;
+            if (++src != srcLim)
+              continue;
+            break;
+          }
+          dest++;
+          if (++src == srcLim)
+            break;
+          if ((*src & 0xF0) != 0x80)
+            continue;
+          *dest = *src;
+          break;
+        }
+        
+        num = src - p->bufs[BCJ2_STREAM_MAIN];
+        
+        if (src == srcLim)
+        {
+          p->temp[3] = src[-1];
+          p->bufs[BCJ2_STREAM_MAIN] = src;
+          p->ip += (UInt32)num;
+          p->dest += num;
+          p->state =
+            p->bufs[BCJ2_STREAM_MAIN] ==
+            p->lims[BCJ2_STREAM_MAIN] ?
+              (unsigned)BCJ2_STREAM_MAIN :
+              (unsigned)BCJ2_DEC_STATE_ORIG;
+          return SZ_OK;
+        }
+        
+        {
+          UInt32 bound, ttt;
+          CProb *prob;
+          Byte b = src[0];
+          Byte prev = (Byte)(num == 0 ? p->temp[3] : src[-1]);
+          
+          p->temp[3] = b;
+          p->bufs[BCJ2_STREAM_MAIN] = src + 1;
+          num++;
+          p->ip += (UInt32)num;
+          p->dest += num;
+          
+          prob = p->probs + (unsigned)(b == 0xE8 ? 2 + (unsigned)prev : (b == 0xE9 ? 1 : 0));
+          
+          _IF_BIT_0
+          {
+            _UPDATE_0
+            continue;
+          }
+          _UPDATE_1
+            
+        }
+      }
+    }
+
+    {
+      UInt32 val;
+      unsigned cj = (p->temp[3] == 0xE8) ? BCJ2_STREAM_CALL : BCJ2_STREAM_JUMP;
+      const Byte *cur = p->bufs[cj];
+      Byte *dest;
+      SizeT rem;
+      
+      if (cur == p->lims[cj])
+      {
+        p->state = cj;
+        break;
+      }
+      
+      val = GetBe32(cur);
+      p->bufs[cj] = cur + 4;
+
+      p->ip += 4;
+      val -= p->ip;
+      dest = p->dest;
+      rem = p->destLim - dest;
+      
+      if (rem < 4)
+      {
+        p->temp[0] = (Byte)val; if (rem > 0) dest[0] = (Byte)val; val >>= 8;
+        p->temp[1] = (Byte)val; if (rem > 1) dest[1] = (Byte)val; val >>= 8;
+        p->temp[2] = (Byte)val; if (rem > 2) dest[2] = (Byte)val; val >>= 8;
+        p->temp[3] = (Byte)val;
+        p->dest = dest + rem;
+        p->state = BCJ2_DEC_STATE_ORIG_0 + (unsigned)rem;
+        break;
+      }
+      
+      SetUi32(dest, val);
+      p->temp[3] = (Byte)(val >> 24);
+      p->dest = dest + 4;
+    }
+  }
+
+  if (p->range < kTopValue && p->bufs[BCJ2_STREAM_RC] != p->lims[BCJ2_STREAM_RC])
+  {
+    p->range <<= 8;
+    p->code = (p->code << 8) | *(p->bufs[BCJ2_STREAM_RC])++;
+  }
+
+  return SZ_OK;
+}

package/mgba-bridge/vendor/mgba/src/third-party/lzma/Bcj2.h

@@ -0,0 +1,146 @@
+/* Bcj2.h -- BCJ2 Converter for x86 code
+2014-11-10 : Igor Pavlov : Public domain */
+
+#ifndef __BCJ2_H
+#define __BCJ2_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define BCJ2_NUM_STREAMS 4
+
+enum
+{
+  BCJ2_STREAM_MAIN,
+  BCJ2_STREAM_CALL,
+  BCJ2_STREAM_JUMP,
+  BCJ2_STREAM_RC
+};
+
+enum
+{
+  BCJ2_DEC_STATE_ORIG_0 = BCJ2_NUM_STREAMS,
+  BCJ2_DEC_STATE_ORIG_1,
+  BCJ2_DEC_STATE_ORIG_2,
+  BCJ2_DEC_STATE_ORIG_3,
+  
+  BCJ2_DEC_STATE_ORIG,
+  BCJ2_DEC_STATE_OK
+};
+
+enum
+{
+  BCJ2_ENC_STATE_ORIG = BCJ2_NUM_STREAMS,
+  BCJ2_ENC_STATE_OK
+};
+
+
+#define BCJ2_IS_32BIT_STREAM(s) ((s) == BCJ2_STREAM_CALL || (s) == BCJ2_STREAM_JUMP)
+
+/*
+CBcj2Dec / CBcj2Enc
+bufs sizes:
+  BUF_SIZE(n) = lims[n] - bufs[n]
+bufs sizes for BCJ2_STREAM_CALL and BCJ2_STREAM_JUMP must be mutliply of 4:
+    (BUF_SIZE(BCJ2_STREAM_CALL) & 3) == 0
+    (BUF_SIZE(BCJ2_STREAM_JUMP) & 3) == 0
+*/
+
+/*
+CBcj2Dec:
+dest is allowed to overlap with bufs[BCJ2_STREAM_MAIN], with the following conditions:
+  bufs[BCJ2_STREAM_MAIN] >= dest &&
+  bufs[BCJ2_STREAM_MAIN] - dest >= tempReserv +
+        BUF_SIZE(BCJ2_STREAM_CALL) +
+        BUF_SIZE(BCJ2_STREAM_JUMP)
+     tempReserv = 0 : for first call of Bcj2Dec_Decode
+     tempReserv = 4 : for any other calls of Bcj2Dec_Decode
+  overlap with offset = 1 is not allowed
+*/
+
+typedef struct
+{
+  const Byte *bufs[BCJ2_NUM_STREAMS];
+  const Byte *lims[BCJ2_NUM_STREAMS];
+  Byte *dest;
+  const Byte *destLim;
+
+  unsigned state; /* BCJ2_STREAM_MAIN has more priority than BCJ2_STATE_ORIG */
+
+  UInt32 ip;
+  Byte temp[4];
+  UInt32 range;
+  UInt32 code;
+  UInt16 probs[2 + 256];
+} CBcj2Dec;
+
+void Bcj2Dec_Init(CBcj2Dec *p);
+
+/* Returns: SZ_OK or SZ_ERROR_DATA */
+SRes Bcj2Dec_Decode(CBcj2Dec *p);
+
+#define Bcj2Dec_IsFinished(_p_) ((_p_)->code == 0)
+
+
+
+typedef enum
+{
+  BCJ2_ENC_FINISH_MODE_CONTINUE,
+  BCJ2_ENC_FINISH_MODE_END_BLOCK,
+  BCJ2_ENC_FINISH_MODE_END_STREAM
+} EBcj2Enc_FinishMode;
+
+typedef struct
+{
+  Byte *bufs[BCJ2_NUM_STREAMS];
+  const Byte *lims[BCJ2_NUM_STREAMS];
+  const Byte *src;
+  const Byte *srcLim;
+
+  unsigned state;
+  EBcj2Enc_FinishMode finishMode;
+
+  Byte prevByte;
+
+  Byte cache;
+  UInt32 range;
+  UInt64 low;
+  UInt64 cacheSize;
+
+  UInt32 ip;
+
+  /* 32-bit ralative offset in JUMP/CALL commands is
+       - (mod 4 GB)   in 32-bit mode
+       - signed Int32 in 64-bit mode
+     We use (mod 4 GB) check for fileSize.
+     Use fileSize up to 2 GB, if you want to support 32-bit and 64-bit code conversion. */
+  UInt32 fileIp;
+  UInt32 fileSize;    /* (fileSize <= ((UInt32)1 << 31)), 0 means no_limit */
+  UInt32 relatLimit;  /* (relatLimit <= ((UInt32)1 << 31)), 0 means desable_conversion */
+
+  UInt32 tempTarget;
+  unsigned tempPos;
+  Byte temp[4 * 2];
+
+  unsigned flushPos;
+  
+  UInt16 probs[2 + 256];
+} CBcj2Enc;
+
+void Bcj2Enc_Init(CBcj2Enc *p);
+void Bcj2Enc_Encode(CBcj2Enc *p);
+
+#define Bcj2Enc_Get_InputData_Size(p) ((SizeT)((p)->srcLim - (p)->src) + (p)->tempPos)
+#define Bcj2Enc_IsFinished(p) ((p)->flushPos == 5)
+
+
+#define BCJ2_RELAT_LIMIT_NUM_BITS 26
+#define BCJ2_RELAT_LIMIT ((UInt32)1 << BCJ2_RELAT_LIMIT_NUM_BITS)
+
+/* limit for CBcj2Enc::fileSize variable */
+#define BCJ2_FileSize_MAX ((UInt32)1 << 31)
+
+EXTERN_C_END
+
+#endif

package/mgba-bridge/vendor/mgba/src/third-party/lzma/Bcj2Enc.c

@@ -0,0 +1,311 @@
+/* Bcj2Enc.c -- BCJ2 Encoder (Converter for x86 code)
+2019-02-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+/* #define SHOW_STAT */
+
+#ifdef SHOW_STAT
+#include <stdio.h>
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+
+#include <string.h>
+
+#include "Bcj2.h"
+#include "CpuArch.h"
+
+#define CProb UInt16
+
+#define kTopValue ((UInt32)1 << 24)
+#define kNumModelBits 11
+#define kBitModelTotal (1 << kNumModelBits)
+#define kNumMoveBits 5
+
+void Bcj2Enc_Init(CBcj2Enc *p)
+{
+  unsigned i;
+
+  p->state = BCJ2_ENC_STATE_OK;
+  p->finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
+
+  p->prevByte = 0;
+
+  p->cache = 0;
+  p->range = 0xFFFFFFFF;
+  p->low = 0;
+  p->cacheSize = 1;
+
+  p->ip = 0;
+
+  p->fileIp = 0;
+  p->fileSize = 0;
+  p->relatLimit = BCJ2_RELAT_LIMIT;
+
+  p->tempPos = 0;
+
+  p->flushPos = 0;
+
+  for (i = 0; i < sizeof(p->probs) / sizeof(p->probs[0]); i++)
+    p->probs[i] = kBitModelTotal >> 1;
+}
+
+static BoolInt MY_FAST_CALL RangeEnc_ShiftLow(CBcj2Enc *p)
+{
+  if ((UInt32)p->low < (UInt32)0xFF000000 || (UInt32)(p->low >> 32) != 0)
+  {
+    Byte *buf = p->bufs[BCJ2_STREAM_RC];
+    do
+    {
+      if (buf == p->lims[BCJ2_STREAM_RC])
+      {
+        p->state = BCJ2_STREAM_RC;
+        p->bufs[BCJ2_STREAM_RC] = buf;
+        return True;
+      }
+      *buf++ = (Byte)(p->cache + (Byte)(p->low >> 32));
+      p->cache = 0xFF;
+    }
+    while (--p->cacheSize);
+    p->bufs[BCJ2_STREAM_RC] = buf;
+    p->cache = (Byte)((UInt32)p->low >> 24);
+  }
+  p->cacheSize++;
+  p->low = (UInt32)p->low << 8;
+  return False;
+}
+
+static void Bcj2Enc_Encode_2(CBcj2Enc *p)
+{
+  if (BCJ2_IS_32BIT_STREAM(p->state))
+  {
+    Byte *cur = p->bufs[p->state];
+    if (cur == p->lims[p->state])
+      return;
+    SetBe32(cur, p->tempTarget);
+    p->bufs[p->state] = cur + 4;
+  }
+
+  p->state = BCJ2_ENC_STATE_ORIG;
+
+  for (;;)
+  {
+    if (p->range < kTopValue)
+    {
+      if (RangeEnc_ShiftLow(p))
+        return;
+      p->range <<= 8;
+    }
+
+    {
+      {
+        const Byte *src = p->src;
+        const Byte *srcLim;
+        Byte *dest;
+        SizeT num = p->srcLim - src;
+
+        if (p->finishMode == BCJ2_ENC_FINISH_MODE_CONTINUE)
+        {
+          if (num <= 4)
+            return;
+          num -= 4;
+        }
+        else if (num == 0)
+          break;
+
+        dest = p->bufs[BCJ2_STREAM_MAIN];
+        if (num > (SizeT)(p->lims[BCJ2_STREAM_MAIN] - dest))
+        {
+          num = p->lims[BCJ2_STREAM_MAIN] - dest;
+          if (num == 0)
+          {
+            p->state = BCJ2_STREAM_MAIN;
+            return;
+          }
+        }
+       
+        srcLim = src + num;
+
+        if (p->prevByte == 0x0F && (src[0] & 0xF0) == 0x80)
+          *dest = src[0];
+        else for (;;)
+        {
+          Byte b = *src;
+          *dest = b;
+          if (b != 0x0F)
+          {
+            if ((b & 0xFE) == 0xE8)
+              break;
+            dest++;
+            if (++src != srcLim)
+              continue;
+            break;
+          }
+          dest++;
+          if (++src == srcLim)
+            break;
+          if ((*src & 0xF0) != 0x80)
+            continue;
+          *dest = *src;
+          break;
+        }
+        
+        num = src - p->src;
+        
+        if (src == srcLim)
+        {
+          p->prevByte = src[-1];
+          p->bufs[BCJ2_STREAM_MAIN] = dest;
+          p->src = src;
+          p->ip += (UInt32)num;
+          continue;
+        }
+ 
+        {
+          Byte context = (Byte)(num == 0 ? p->prevByte : src[-1]);
+          BoolInt needConvert;
+
+          p->bufs[BCJ2_STREAM_MAIN] = dest + 1;
+          p->ip += (UInt32)num + 1;
+          src++;
+          
+          needConvert = False;
+
+          if ((SizeT)(p->srcLim - src) >= 4)
+          {
+            UInt32 relatVal = GetUi32(src);
+            if ((p->fileSize == 0 || (UInt32)(p->ip + 4 + relatVal - p->fileIp) < p->fileSize)
+                && ((relatVal + p->relatLimit) >> 1) < p->relatLimit)
+              needConvert = True;
+          }
+
+          {
+            UInt32 bound;
+            unsigned ttt;
+            Byte b = src[-1];
+            CProb *prob = p->probs + (unsigned)(b == 0xE8 ? 2 + (unsigned)context : (b == 0xE9 ? 1 : 0));
+
+            ttt = *prob;
+            bound = (p->range >> kNumModelBits) * ttt;
+            
+            if (!needConvert)
+            {
+              p->range = bound;
+              *prob = (CProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
+              p->src = src;
+              p->prevByte = b;
+              continue;
+            }
+            
+            p->low += bound;
+            p->range -= bound;
+            *prob = (CProb)(ttt - (ttt >> kNumMoveBits));
+
+            {
+              UInt32 relatVal = GetUi32(src);
+              UInt32 absVal;
+              p->ip += 4;
+              absVal = p->ip + relatVal;
+              p->prevByte = src[3];
+              src += 4;
+              p->src = src;
+              {
+                unsigned cj = (b == 0xE8) ? BCJ2_STREAM_CALL : BCJ2_STREAM_JUMP;
+                Byte *cur = p->bufs[cj];
+                if (cur == p->lims[cj])
+                {
+                  p->state = cj;
+                  p->tempTarget = absVal;
+                  return;
+                }
+                SetBe32(cur, absVal);
+                p->bufs[cj] = cur + 4;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if (p->finishMode != BCJ2_ENC_FINISH_MODE_END_STREAM)
+    return;
+
+  for (; p->flushPos < 5; p->flushPos++)
+    if (RangeEnc_ShiftLow(p))
+      return;
+  p->state = BCJ2_ENC_STATE_OK;
+}
+
+
+void Bcj2Enc_Encode(CBcj2Enc *p)
+{
+  PRF(printf("\n"));
+  PRF(printf("---- ip = %8d   tempPos = %8d   src = %8d\n", p->ip, p->tempPos, p->srcLim - p->src));
+
+  if (p->tempPos != 0)
+  {
+    unsigned extra = 0;
+   
+    for (;;)
+    {
+      const Byte *src = p->src;
+      const Byte *srcLim = p->srcLim;
+      EBcj2Enc_FinishMode finishMode = p->finishMode;
+      
+      p->src = p->temp;
+      p->srcLim = p->temp + p->tempPos;
+      if (src != srcLim)
+        p->finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
+      
+      PRF(printf("     ip = %8d   tempPos = %8d   src = %8d\n", p->ip, p->tempPos, p->srcLim - p->src));
+
+      Bcj2Enc_Encode_2(p);
+      
+      {
+        unsigned num = (unsigned)(p->src - p->temp);
+        unsigned tempPos = p->tempPos - num;
+        unsigned i;
+        p->tempPos = tempPos;
+        for (i = 0; i < tempPos; i++)
+          p->temp[i] = p->temp[(size_t)i + num];
+      
+        p->src = src;
+        p->srcLim = srcLim;
+        p->finishMode = finishMode;
+        
+        if (p->state != BCJ2_ENC_STATE_ORIG || src == srcLim)
+          return;
+        
+        if (extra >= tempPos)
+        {
+          p->src = src - tempPos;
+          p->tempPos = 0;
+          break;
+        }
+        
+        p->temp[tempPos] = src[0];
+        p->tempPos = tempPos + 1;
+        p->src = src + 1;
+        extra++;
+      }
+    }
+  }
+
+  PRF(printf("++++ ip = %8d   tempPos = %8d   src = %8d\n", p->ip, p->tempPos, p->srcLim - p->src));
+
+  Bcj2Enc_Encode_2(p);
+  
+  if (p->state == BCJ2_ENC_STATE_ORIG)
+  {
+    const Byte *src = p->src;
+    unsigned rem = (unsigned)(p->srcLim - src);
+    unsigned i;
+    for (i = 0; i < rem; i++)
+      p->temp[i] = src[i];
+    p->tempPos = rem;
+    p->src = src + rem;
+  }
+}