static void Sha256_WriteByteBlock(CSha256 *p) { UInt32 W[16]; unsigned j; UInt32 *state; #ifdef _SHA256_UNROLL2 UInt32 a,b,c,d,e,f,g,h; #else UInt32 T[8]; #endif for (j = 0; j < 16; j += 4) { const Byte *ccc = p->buffer + j * 4; W[j ] = GetBe32(ccc); W[j + 1] = GetBe32(ccc + 4); W[j + 2] = GetBe32(ccc + 8); W[j + 3] = GetBe32(ccc + 12); } state = p->state; #ifdef _SHA256_UNROLL2 a = state[0]; b = state[1]; c = state[2]; d = state[3]; e = state[4]; f = state[5]; g = state[6]; h = state[7]; #else for (j = 0; j < 8; j++) T[j] = state[j]; #endif for (j = 0; j < 64; j += 16) { RX_16 } #ifdef _SHA256_UNROLL2 state[0] += a; state[1] += b; state[2] += c; state[3] += d; state[4] += e; state[5] += f; state[6] += g; state[7] += h; #else for (j = 0; j < 8; j++) state[j] += T[j]; #endif /* Wipe variables */ /* memset(W, 0, sizeof(W)); */ /* memset(T, 0, sizeof(T)); */ }
SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding) { Byte *p; const Byte *lim; size &= ~(size_t)3; ip -= 4; p = data; lim = data + size; for (;;) { for (;;) { if (p >= lim) return p - data; p += 4; /* if ((v & 0xFC000003) == 0x48000001) */ if ((p[-4] & 0xFC) == 0x48 && (p[-1] & 3) == 1) break; } { UInt32 v = GetBe32(p - 4); if (encoding) v += ip + (UInt32)(p - data); else v -= ip + (UInt32)(p - data); v &= 0x03FFFFFF; v |= 0x48000000; SetBe32(p - 4, v); } } }
static bool ParseSize(const char *p, UInt64 &val) { if (GetBe32(p) == (UInt32)1 << 31) { // GNU extension val = GetBe64(p + 4); return ((val >> 63) & 1) == 0; }
static bool ParseInt64(const char *p, Int64 &val) { UInt32 h = GetBe32(p); val = GetBe64(p + 4); if (h == (UInt32)1 << 31) return ((val >> 63) & 1) == 0; if (h == (UInt32)(Int32)-1) return ((val >> 63) & 1) != 0; UInt64 uv; bool res = OctalToNumber(p, 12, uv); val = uv; return res; }
SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding) { Byte *p; const Byte *lim; size &= ~(size_t)3; ip -= 4; p = data; lim = data + size; for (;;) { for (;;) { if (p >= lim) return p - data; /* v = GetBe32(p); p += 4; m = v + ((UInt32)5 << 29); m ^= (UInt32)7 << 29; m += (UInt32)1 << 22; if ((m & ((UInt32)0x1FF << 23)) == 0) break; */ p += 4; if ((p[-4] == 0x40 && (p[-3] & 0xC0) == 0) || (p[-4] == 0x7F && (p[-3] >= 0xC0))) break; } { UInt32 v = GetBe32(p - 4); v <<= 2; if (encoding) v += ip + (UInt32)(p - data); else v -= ip + (UInt32)(p - data); v &= 0x01FFFFFF; v -= (UInt32)1 << 24; v ^= 0xFF000000; v >>= 2; v |= 0x40000000; SetBe32(p - 4, v); } } }
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[p->state++ - BCJ2_DEC_STATE_ORIG_0]; 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) { 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; 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; }