{"header":{"message":"Add zstd_seekable + many headers","description":null,"timestamp":"2022-08-17T12:39:19.166257156Z","authors":[{}]},"hash":"3NA345CN3HKNUQOWTUMUTINQMFLYATWPO4H74J4AFGEUQKGQYBWQC","authors":[{"login":"laumann","key":"26ibH2ZceFecUuiipNxtdzeLok5RbhVCUacPbXeugrNC"}],"deps":{"hashes":[["3NA345CN3HKNUQOWTUMUTINQMFLYATWPO4H74J4AFGEUQKGQYBWQC","Add zstd_seekable + many headers"],["AA",null],["Q7TKZCJP2Z75EICZYKCEZDHKGERSOKZGMTSU3UXETBHTF663T66AC","Add initial support for reading the offsets from a (fixed) change"],["HERYCRORG4CHKEPCFLBI6OYK4H52ZBGIFVQWSHMZ2PAL3USQKICAC","make: define _POSIX_C_SOURCE=200809L, -std=c99"],["B3XLVPNC4COLLC3FUE34Y7HIKTMF6CJZUASZOU3YM2YGPZKJZP7QC","Add ani.c and initial Makefile"],["FB67XX5EGNF45JNAQISW7CBLSLS36F6JEUOBTTPUMVBMOVLGA3VQC","add argument parsing setup"],["PEUS54XQ5KJQYAVUYBG5MWLEHIOVPMZ3ANVC7HPQP6JUWWPRDW5AC",""]],"deps":["Q7TKZCJP2Z75EICZYKCEZDHKGERSOKZGMTSU3UXETBHTF663T66AC","HERYCRORG4CHKEPCFLBI6OYK4H52ZBGIFVQWSHMZ2PAL3USQKICAC"],"known":["B3XLVPNC4COLLC3FUE34Y7HIKTMF6CJZUASZOU3YM2YGPZKJZP7QC","FB67XX5EGNF45JNAQISW7CBLSLS36F6JEUOBTTPUMVBMOVLGA3VQC"]},"hunks":[{"FileAdd":{"meta":{"basename":"zstdseek_decompress.c","metadata":0},"context":[{"change":7,"pos":1}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) 2017-present, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":"/* *********************************************************"},{"Add":"* Turn on Large Files support (>4GB) for 32-bit Linux/Unix"},{"Add":"***********************************************************/"},{"Add":"#if !defined(__64BIT__) || defined(__MINGW32__) /* No point defining Large file for 64 bit but MinGW-w64 requires it */"},{"Add":"# if !defined(_FILE_OFFSET_BITS)"},{"Add":"# define _FILE_OFFSET_BITS 64 /* turn off_t into a 64-bit type for ftello, fseeko */"},{"Add":"# endif"},{"Add":"# if !defined(_LARGEFILE_SOURCE) /* obsolete macro, replaced with _FILE_OFFSET_BITS */"},{"Add":"# define _LARGEFILE_SOURCE 1 /* Large File Support extension (LFS) - fseeko, ftello */"},{"Add":"# endif"},{"Add":"# if defined(_AIX) || defined(__hpux)"},{"Add":"# define _LARGE_FILES /* Large file support on 32-bits AIX and HP-UX */"},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":"/* ************************************************************"},{"Add":"* Avoid fseek()'s 2GiB barrier with MSVC, macOS, *BSD, MinGW"},{"Add":"***************************************************************/"},{"Add":"#if defined(_MSC_VER) && _MSC_VER >= 1400"},{"Add":"# define LONG_SEEK _fseeki64"},{"Add":"#elif !defined(__64BIT__) && (PLATFORM_POSIX_VERSION >= 200112L) /* No point defining Large file for 64 bit */"},{"Add":"# define LONG_SEEK fseeko"},{"Add":"#elif defined(__MINGW32__) && !defined(__STRICT_ANSI__) && !defined(__NO_MINGW_LFS) && defined(__MSVCRT__)"},{"Add":"# define LONG_SEEK fseeko64"},{"Add":"#elif defined(_WIN32) && !defined(__DJGPP__)"},{"Add":"# include "},{"Add":" static int LONG_SEEK(FILE* file, __int64 offset, int origin) {"},{"Add":" LARGE_INTEGER off;"},{"Add":" DWORD method;"},{"Add":" off.QuadPart = offset;"},{"Add":" if (origin == SEEK_END)"},{"Add":" method = FILE_END;"},{"Add":" else if (origin == SEEK_CUR)"},{"Add":" method = FILE_CURRENT;"},{"Add":" else"},{"Add":" method = FILE_BEGIN;"},{"Add":""},{"Add":" if (SetFilePointerEx((HANDLE) _get_osfhandle(_fileno(file)), off, NULL, method))"},{"Add":" return 0;"},{"Add":" else"},{"Add":" return -1;"},{"Add":" }"},{"Add":"#else"},{"Add":"# define LONG_SEEK fseek"},{"Add":"#endif"},{"Add":""},{"Add":"#include /* malloc, free */"},{"Add":"#include /* FILE* */"},{"Add":"#include /* UNIT_MAX */"},{"Add":"#include "},{"Add":""},{"Add":"#include "},{"Add":""},{"Add":"#include "},{"Add":"#include "},{"Add":"#include \"mem.h\""},{"Add":"#include \"zstd_seekable.h\""},{"Add":""},{"Add":"#undef ERROR"},{"Add":"#define ERROR(name) ((size_t)-ZSTD_error_##name)"},{"Add":""},{"Add":"#define CHECK_IO(f) { int const errcod = (f); if (errcod < 0) return ERROR(seekableIO); }"},{"Add":""},{"Add":"#undef MIN"},{"Add":"#undef MAX"},{"Add":"#define MIN(a, b) ((a) < (b) ? (a) : (b))"},{"Add":"#define MAX(a, b) ((a) > (b) ? (a) : (b))"},{"Add":""},{"Add":"#define ZSTD_SEEKABLE_NO_OUTPUT_PROGRESS_MAX 16"},{"Add":""},{"Add":"/* Special-case callbacks for FILE* and in-memory modes, so that we can treat"},{"Add":" * them the same way as the advanced API */"},{"Add":"static int ZSTD_seekable_read_FILE(void* opaque, void* buffer, size_t n)"},{"Add":"{"},{"Add":" size_t const result = fread(buffer, 1, n, (FILE*)opaque);"},{"Add":" if (result != n) {"},{"Add":" return -1;"},{"Add":" }"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"static int ZSTD_seekable_seek_FILE(void* opaque, long long offset, int origin)"},{"Add":"{"},{"Add":" int const ret = LONG_SEEK((FILE*)opaque, offset, origin);"},{"Add":" if (ret) return ret;"},{"Add":" return fflush((FILE*)opaque);"},{"Add":"}"},{"Add":""},{"Add":"typedef struct {"},{"Add":" const void *ptr;"},{"Add":" size_t size;"},{"Add":" size_t pos;"},{"Add":"} buffWrapper_t;"},{"Add":""},{"Add":"static int ZSTD_seekable_read_buff(void* opaque, void* buffer, size_t n)"},{"Add":"{"},{"Add":" buffWrapper_t* const buff = (buffWrapper_t*)opaque;"},{"Add":" assert(buff != NULL);"},{"Add":" if (buff->pos + n > buff->size) return -1;"},{"Add":" memcpy(buffer, (const BYTE*)buff->ptr + buff->pos, n);"},{"Add":" buff->pos += n;"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"static int ZSTD_seekable_seek_buff(void* opaque, long long offset, int origin)"},{"Add":"{"},{"Add":" buffWrapper_t* const buff = (buffWrapper_t*) opaque;"},{"Add":" unsigned long long newOffset;"},{"Add":" assert(buff != NULL);"},{"Add":" switch (origin) {"},{"Add":" case SEEK_SET:"},{"Add":" assert(offset >= 0);"},{"Add":" newOffset = (unsigned long long)offset;"},{"Add":" break;"},{"Add":" case SEEK_CUR:"},{"Add":" newOffset = (unsigned long long)((long long)buff->pos + offset);"},{"Add":" break;"},{"Add":" case SEEK_END:"},{"Add":" newOffset = (unsigned long long)((long long)buff->size + offset);"},{"Add":" break;"},{"Add":" default:"},{"Add":" assert(0); /* not possible */"},{"Add":" }"},{"Add":" if (newOffset > buff->size) {"},{"Add":" return -1;"},{"Add":" }"},{"Add":" buff->pos = newOffset;"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"typedef struct {"},{"Add":" U64 cOffset;"},{"Add":" U64 dOffset;"},{"Add":" U32 checksum;"},{"Add":"} seekEntry_t;"},{"Add":""},{"Add":"struct ZSTD_seekTable_s {"},{"Add":" seekEntry_t* entries;"},{"Add":" size_t tableLen;"},{"Add":""},{"Add":" int checksumFlag;"},{"Add":"};"},{"Add":""},{"Add":"#define SEEKABLE_BUFF_SIZE ZSTD_BLOCKSIZE_MAX"},{"Add":""},{"Add":"struct ZSTD_seekable_s {"},{"Add":" ZSTD_DStream* dstream;"},{"Add":" ZSTD_seekTable seekTable;"},{"Add":" ZSTD_seekable_customFile src;"},{"Add":""},{"Add":" U64 decompressedOffset;"},{"Add":" U32 curFrame;"},{"Add":""},{"Add":" BYTE inBuff[SEEKABLE_BUFF_SIZE]; /* need to do our own input buffering */"},{"Add":" BYTE outBuff[SEEKABLE_BUFF_SIZE]; /* so we can efficiently decompress the"},{"Add":" starts of chunks before we get to the"},{"Add":" desired section */"},{"Add":" ZSTD_inBuffer in; /* maintain continuity across ZSTD_seekable_decompress operations */"},{"Add":" buffWrapper_t buffWrapper; /* for `src.opaque` in in-memory mode */"},{"Add":""},{"Add":" XXH64_state_t *xxhState;"},{"Add":"};"},{"Add":""},{"Add":"ZSTD_seekable* ZSTD_seekable_create(void)"},{"Add":"{"},{"Add":" ZSTD_seekable* const zs = (ZSTD_seekable*)malloc(sizeof(ZSTD_seekable));"},{"Add":" if (zs == NULL) return NULL;"},{"Add":""},{"Add":" /* also initializes stage to zsds_init */"},{"Add":" memset(zs, 0, sizeof(*zs));"},{"Add":""},{"Add":" zs->dstream = ZSTD_createDStream();"},{"Add":" if (zs->dstream == NULL) {"},{"Add":" free(zs);"},{"Add":" return NULL;"},{"Add":" }"},{"Add":""},{"Add":" return zs;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekable_free(ZSTD_seekable* zs)"},{"Add":"{"},{"Add":" if (zs == NULL) return 0; /* support free on null */"},{"Add":" ZSTD_freeDStream(zs->dstream);"},{"Add":" free(zs->seekTable.entries);"},{"Add":" free(zs);"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"ZSTD_seekTable* ZSTD_seekTable_create_fromSeekable(const ZSTD_seekable* zs)"},{"Add":"{"},{"Add":" ZSTD_seekTable* const st = (ZSTD_seekTable*)malloc(sizeof(ZSTD_seekTable));"},{"Add":" if (st==NULL) return NULL;"},{"Add":""},{"Add":" st->checksumFlag = zs->seekTable.checksumFlag;"},{"Add":" st->tableLen = zs->seekTable.tableLen;"},{"Add":""},{"Add":" /* Allocate an extra entry at the end to match logic of initial allocation */"},{"Add":" size_t const entriesSize = sizeof(seekEntry_t) * (zs->seekTable.tableLen + 1);"},{"Add":" seekEntry_t* const entries = (seekEntry_t*)malloc(entriesSize);"},{"Add":" if (entries==NULL) {"},{"Add":" free(st);"},{"Add":" return NULL;"},{"Add":" }"},{"Add":""},{"Add":" memcpy(entries, zs->seekTable.entries, entriesSize);"},{"Add":" st->entries = entries;"},{"Add":" return st;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekTable_free(ZSTD_seekTable* st)"},{"Add":"{"},{"Add":" if (st == NULL) return 0; /* support free on null */"},{"Add":" free(st->entries);"},{"Add":" free(st);"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"/** ZSTD_seekable_offsetToFrameIndex() :"},{"Add":" * Performs a binary search to find the last frame with a decompressed offset"},{"Add":" * <= pos"},{"Add":" * @return : the frame's index */"},{"Add":"unsigned ZSTD_seekable_offsetToFrameIndex(const ZSTD_seekable* zs, unsigned long long pos)"},{"Add":"{"},{"Add":" return ZSTD_seekTable_offsetToFrameIndex(&zs->seekTable, pos);"},{"Add":"}"},{"Add":""},{"Add":"unsigned ZSTD_seekTable_offsetToFrameIndex(const ZSTD_seekTable* st, unsigned long long pos)"},{"Add":"{"},{"Add":" U32 lo = 0;"},{"Add":" U32 hi = (U32)st->tableLen;"},{"Add":" assert(st->tableLen <= UINT_MAX);"},{"Add":""},{"Add":" if (pos >= st->entries[st->tableLen].dOffset) {"},{"Add":" return (unsigned)st->tableLen;"},{"Add":" }"},{"Add":""},{"Add":" while (lo + 1 < hi) {"},{"Add":" U32 const mid = lo + ((hi - lo) >> 1);"},{"Add":" if (st->entries[mid].dOffset <= pos) {"},{"Add":" lo = mid;"},{"Add":" } else {"},{"Add":" hi = mid;"},{"Add":" }"},{"Add":" }"},{"Add":" return lo;"},{"Add":"}"},{"Add":""},{"Add":"unsigned ZSTD_seekable_getNumFrames(const ZSTD_seekable* zs)"},{"Add":"{"},{"Add":" return ZSTD_seekTable_getNumFrames(&zs->seekTable);"},{"Add":"}"},{"Add":""},{"Add":"unsigned ZSTD_seekTable_getNumFrames(const ZSTD_seekTable* st)"},{"Add":"{"},{"Add":" assert(st->tableLen <= UINT_MAX);"},{"Add":" return (unsigned)st->tableLen;"},{"Add":"}"},{"Add":""},{"Add":"unsigned long long ZSTD_seekable_getFrameCompressedOffset(const ZSTD_seekable* zs, unsigned frameIndex)"},{"Add":"{"},{"Add":" return ZSTD_seekTable_getFrameCompressedOffset(&zs->seekTable, frameIndex);"},{"Add":"}"},{"Add":""},{"Add":"unsigned long long ZSTD_seekTable_getFrameCompressedOffset(const ZSTD_seekTable* st, unsigned frameIndex)"},{"Add":"{"},{"Add":" if (frameIndex >= st->tableLen) return ZSTD_SEEKABLE_FRAMEINDEX_TOOLARGE;"},{"Add":" return st->entries[frameIndex].cOffset;"},{"Add":"}"},{"Add":""},{"Add":"unsigned long long ZSTD_seekable_getFrameDecompressedOffset(const ZSTD_seekable* zs, unsigned frameIndex)"},{"Add":"{"},{"Add":" return ZSTD_seekTable_getFrameDecompressedOffset(&zs->seekTable, frameIndex);"},{"Add":"}"},{"Add":""},{"Add":"unsigned long long ZSTD_seekTable_getFrameDecompressedOffset(const ZSTD_seekTable* st, unsigned frameIndex)"},{"Add":"{"},{"Add":" if (frameIndex >= st->tableLen) return ZSTD_SEEKABLE_FRAMEINDEX_TOOLARGE;"},{"Add":" return st->entries[frameIndex].dOffset;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekable_getFrameCompressedSize(const ZSTD_seekable* zs, unsigned frameIndex)"},{"Add":"{"},{"Add":" return ZSTD_seekTable_getFrameCompressedSize(&zs->seekTable, frameIndex);"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekTable_getFrameCompressedSize(const ZSTD_seekTable* st, unsigned frameIndex)"},{"Add":"{"},{"Add":" if (frameIndex >= st->tableLen) return ERROR(frameIndex_tooLarge);"},{"Add":" return st->entries[frameIndex + 1].cOffset -"},{"Add":" st->entries[frameIndex].cOffset;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekable_getFrameDecompressedSize(const ZSTD_seekable* zs, unsigned frameIndex)"},{"Add":"{"},{"Add":" return ZSTD_seekTable_getFrameDecompressedSize(&zs->seekTable, frameIndex);"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekTable_getFrameDecompressedSize(const ZSTD_seekTable* st, unsigned frameIndex)"},{"Add":"{"},{"Add":" if (frameIndex > st->tableLen) return ERROR(frameIndex_tooLarge);"},{"Add":" return st->entries[frameIndex + 1].dOffset -"},{"Add":" st->entries[frameIndex].dOffset;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTD_seekable_loadSeekTable(ZSTD_seekable* zs)"},{"Add":"{"},{"Add":" int checksumFlag;"},{"Add":" ZSTD_seekable_customFile src = zs->src;"},{"Add":" /* read the footer, fixed size */"},{"Add":" CHECK_IO(src.seek(src.opaque, -(int)ZSTD_seekTableFooterSize, SEEK_END));"},{"Add":" CHECK_IO(src.read(src.opaque, zs->inBuff, ZSTD_seekTableFooterSize));"},{"Add":""},{"Add":" if (MEM_readLE32(zs->inBuff + 5) != ZSTD_SEEKABLE_MAGICNUMBER) {"},{"Add":" return ERROR(prefix_unknown);"},{"Add":" }"},{"Add":""},{"Add":" { BYTE const sfd = zs->inBuff[4];"},{"Add":" checksumFlag = sfd >> 7;"},{"Add":""},{"Add":" /* check reserved bits */"},{"Add":" if ((sfd >> 2) & 0x1f) {"},{"Add":" return ERROR(corruption_detected);"},{"Add":" } }"},{"Add":""},{"Add":" { U32 const numFrames = MEM_readLE32(zs->inBuff);"},{"Add":" U32 const sizePerEntry = 8 + (checksumFlag?4:0);"},{"Add":" U32 const tableSize = sizePerEntry * numFrames;"},{"Add":" U32 const frameSize = tableSize + ZSTD_seekTableFooterSize + ZSTD_SKIPPABLEHEADERSIZE;"},{"Add":""},{"Add":" U32 remaining = frameSize - ZSTD_seekTableFooterSize; /* don't need to re-read footer */"},{"Add":" { U32 const toRead = MIN(remaining, SEEKABLE_BUFF_SIZE);"},{"Add":" CHECK_IO(src.seek(src.opaque, -(S64)frameSize, SEEK_END));"},{"Add":" CHECK_IO(src.read(src.opaque, zs->inBuff, toRead));"},{"Add":" remaining -= toRead;"},{"Add":" }"},{"Add":""},{"Add":" if (MEM_readLE32(zs->inBuff) != (ZSTD_MAGIC_SKIPPABLE_START | 0xE)) {"},{"Add":" return ERROR(prefix_unknown);"},{"Add":" }"},{"Add":" if (MEM_readLE32(zs->inBuff+4) + ZSTD_SKIPPABLEHEADERSIZE != frameSize) {"},{"Add":" return ERROR(prefix_unknown);"},{"Add":" }"},{"Add":""},{"Add":" { /* Allocate an extra entry at the end so that we can do size"},{"Add":" * computations on the last element without special case */"},{"Add":" seekEntry_t* const entries = (seekEntry_t*)malloc(sizeof(seekEntry_t) * (numFrames + 1));"},{"Add":""},{"Add":" U32 idx = 0;"},{"Add":" U32 pos = 8;"},{"Add":""},{"Add":" U64 cOffset = 0;"},{"Add":" U64 dOffset = 0;"},{"Add":""},{"Add":" if (entries == NULL) return ERROR(memory_allocation);"},{"Add":""},{"Add":" /* compute cumulative positions */"},{"Add":" for (; idx < numFrames; idx++) {"},{"Add":" if (pos + sizePerEntry > SEEKABLE_BUFF_SIZE) {"},{"Add":" U32 const offset = SEEKABLE_BUFF_SIZE - pos;"},{"Add":" U32 const toRead = MIN(remaining, SEEKABLE_BUFF_SIZE - offset);"},{"Add":" memmove(zs->inBuff, zs->inBuff + pos, offset); /* move any data we haven't read yet */"},{"Add":" CHECK_IO(src.read(src.opaque, zs->inBuff+offset, toRead));"},{"Add":" remaining -= toRead;"},{"Add":" pos = 0;"},{"Add":" }"},{"Add":" entries[idx].cOffset = cOffset;"},{"Add":" entries[idx].dOffset = dOffset;"},{"Add":""},{"Add":" cOffset += MEM_readLE32(zs->inBuff + pos);"},{"Add":" pos += 4;"},{"Add":" dOffset += MEM_readLE32(zs->inBuff + pos);"},{"Add":" pos += 4;"},{"Add":" if (checksumFlag) {"},{"Add":" entries[idx].checksum = MEM_readLE32(zs->inBuff + pos);"},{"Add":" pos += 4;"},{"Add":" }"},{"Add":" }"},{"Add":" entries[numFrames].cOffset = cOffset;"},{"Add":" entries[numFrames].dOffset = dOffset;"},{"Add":""},{"Add":" zs->seekTable.entries = entries;"},{"Add":" zs->seekTable.tableLen = numFrames;"},{"Add":" zs->seekTable.checksumFlag = checksumFlag;"},{"Add":" return 0;"},{"Add":" }"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekable_initBuff(ZSTD_seekable* zs, const void* src, size_t srcSize)"},{"Add":"{"},{"Add":" zs->buffWrapper = (buffWrapper_t){src, srcSize, 0};"},{"Add":" { ZSTD_seekable_customFile srcFile = {&zs->buffWrapper,"},{"Add":" &ZSTD_seekable_read_buff,"},{"Add":" &ZSTD_seekable_seek_buff};"},{"Add":" return ZSTD_seekable_initAdvanced(zs, srcFile); }"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekable_initFile(ZSTD_seekable* zs, FILE* src)"},{"Add":"{"},{"Add":" ZSTD_seekable_customFile srcFile = {src, &ZSTD_seekable_read_FILE,"},{"Add":" &ZSTD_seekable_seek_FILE};"},{"Add":" return ZSTD_seekable_initAdvanced(zs, srcFile);"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekable_initAdvanced(ZSTD_seekable* zs, ZSTD_seekable_customFile src)"},{"Add":"{"},{"Add":" zs->src = src;"},{"Add":""},{"Add":" { const size_t seekTableInit = ZSTD_seekable_loadSeekTable(zs);"},{"Add":" if (ZSTD_isError(seekTableInit)) return seekTableInit; }"},{"Add":""},{"Add":" zs->decompressedOffset = (U64)-1;"},{"Add":" zs->curFrame = (U32)-1;"},{"Add":""},{"Add":" { const size_t dstreamInit = ZSTD_initDStream(zs->dstream);"},{"Add":" if (ZSTD_isError(dstreamInit)) return dstreamInit; }"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekable_decompress(ZSTD_seekable* zs, void* dst, size_t len, unsigned long long offset)"},{"Add":"{"},{"Add":" unsigned long long const eos = zs->seekTable.entries[zs->seekTable.tableLen].dOffset;"},{"Add":" if (offset + len > eos) {"},{"Add":" len = eos - offset;"},{"Add":" }"},{"Add":""},{"Add":" U32 targetFrame = ZSTD_seekable_offsetToFrameIndex(zs, offset);"},{"Add":" U32 noOutputProgressCount = 0;"},{"Add":" size_t srcBytesRead = 0;"},{"Add":" do {"},{"Add":" /* check if we can continue from a previous decompress job */"},{"Add":" if (targetFrame != zs->curFrame || offset != zs->decompressedOffset) {"},{"Add":" zs->decompressedOffset = zs->seekTable.entries[targetFrame].dOffset;"},{"Add":" zs->curFrame = targetFrame;"},{"Add":""},{"Add":" assert(zs->seekTable.entries[targetFrame].cOffset < LLONG_MAX);"},{"Add":" CHECK_IO(zs->src.seek(zs->src.opaque,"},{"Add":" (long long)zs->seekTable.entries[targetFrame].cOffset,"},{"Add":" SEEK_SET));"},{"Add":" zs->in = (ZSTD_inBuffer){zs->inBuff, 0, 0};"},{"Add":" XXH64_reset(zs->xxhState, 0);"},{"Add":" ZSTD_DCtx_reset(zs->dstream, ZSTD_reset_session_only);"},{"Add":" if (zs->buffWrapper.size && srcBytesRead > zs->buffWrapper.size) {"},{"Add":" return ERROR(seekableIO);"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" while (zs->decompressedOffset < offset + len) {"},{"Add":" size_t toRead;"},{"Add":" ZSTD_outBuffer outTmp;"},{"Add":" size_t prevOutPos;"},{"Add":" size_t prevInPos;"},{"Add":" size_t forwardProgress;"},{"Add":" if (zs->decompressedOffset < offset) {"},{"Add":" /* dummy decompressions until we get to the target offset */"},{"Add":" outTmp = (ZSTD_outBuffer){zs->outBuff, MIN(SEEKABLE_BUFF_SIZE, offset - zs->decompressedOffset), 0};"},{"Add":" } else {"},{"Add":" outTmp = (ZSTD_outBuffer){dst, len, zs->decompressedOffset - offset};"},{"Add":" }"},{"Add":""},{"Add":" prevOutPos = outTmp.pos;"},{"Add":" prevInPos = zs->in.pos;"},{"Add":" toRead = ZSTD_decompressStream(zs->dstream, &outTmp, &zs->in);"},{"Add":" if (ZSTD_isError(toRead)) {"},{"Add":" return toRead;"},{"Add":" }"},{"Add":""},{"Add":" if (zs->seekTable.checksumFlag) {"},{"Add":" XXH64_update(zs->xxhState, (BYTE*)outTmp.dst + prevOutPos,"},{"Add":" outTmp.pos - prevOutPos);"},{"Add":" }"},{"Add":" forwardProgress = outTmp.pos - prevOutPos;"},{"Add":" if (forwardProgress == 0) {"},{"Add":" if (noOutputProgressCount++ > ZSTD_SEEKABLE_NO_OUTPUT_PROGRESS_MAX) {"},{"Add":" return ERROR(seekableIO);"},{"Add":" }"},{"Add":" } else {"},{"Add":" noOutputProgressCount = 0;"},{"Add":" }"},{"Add":" zs->decompressedOffset += forwardProgress;"},{"Add":" srcBytesRead += zs->in.pos - prevInPos;"},{"Add":""},{"Add":" if (toRead == 0) {"},{"Add":" /* frame complete */"},{"Add":""},{"Add":" /* verify checksum */"},{"Add":" if (zs->seekTable.checksumFlag &&"},{"Add":" (XXH64_digest(zs->xxhState) & 0xFFFFFFFFU) !="},{"Add":" zs->seekTable.entries[targetFrame].checksum) {"},{"Add":" return ERROR(corruption_detected);"},{"Add":" }"},{"Add":""},{"Add":" if (zs->decompressedOffset < offset + len) {"},{"Add":" /* go back to the start and force a reset of the stream */"},{"Add":" targetFrame = ZSTD_seekable_offsetToFrameIndex(zs, zs->decompressedOffset);"},{"Add":" /* in this case it will fail later with corruption_detected, since last block does not have checksum */"},{"Add":" assert(targetFrame != zs->seekTable.tableLen);"},{"Add":" }"},{"Add":" break;"},{"Add":" }"},{"Add":""},{"Add":" /* read in more data if we're done with this buffer */"},{"Add":" if (zs->in.pos == zs->in.size) {"},{"Add":" toRead = MIN(toRead, SEEKABLE_BUFF_SIZE);"},{"Add":" CHECK_IO(zs->src.read(zs->src.opaque, zs->inBuff, toRead));"},{"Add":" zs->in.size = toRead;"},{"Add":" zs->in.pos = 0;"},{"Add":" }"},{"Add":" } /* while (zs->decompressedOffset < offset + len) */"},{"Add":" } while (zs->decompressedOffset != offset + len);"},{"Add":""},{"Add":" return len;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekable_decompressFrame(ZSTD_seekable* zs, void* dst, size_t dstSize, unsigned frameIndex)"},{"Add":"{"},{"Add":" if (frameIndex >= zs->seekTable.tableLen) {"},{"Add":" return ERROR(frameIndex_tooLarge);"},{"Add":" }"},{"Add":""},{"Add":" { size_t const decompressedSize ="},{"Add":" zs->seekTable.entries[frameIndex + 1].dOffset -"},{"Add":" zs->seekTable.entries[frameIndex].dOffset;"},{"Add":" if (dstSize < decompressedSize) {"},{"Add":" return ERROR(dstSize_tooSmall);"},{"Add":" }"},{"Add":" return ZSTD_seekable_decompress("},{"Add":" zs, dst, decompressedSize,"},{"Add":" zs->seekTable.entries[frameIndex].dOffset);"},{"Add":" }"},{"Add":"}"}]}},{"FileAdd":{"meta":{"basename":"zstdseek_compress.c","metadata":0},"context":[{"change":7,"pos":1}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) 2017-present, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" */"},{"Add":""},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":"#include /* malloc, free */"},{"Add":"#include /* UINT_MAX */"},{"Add":"#include "},{"Add":""},{"Add":"#include "},{"Add":""},{"Add":"#include \"mem.h\" /* what is this? linux-kernel/mem.h => typedefs */"},{"Add":""},{"Add":"#include \"zstd_seekable.h\""},{"Add":""},{"Add":"#define CHECK_Z(f) { size_t const ret = (f); if (ret != 0) return ret; }"},{"Add":""},{"Add":"#undef ERROR"},{"Add":"#define ERROR(name) ((size_t)-ZSTD_error_##name)"},{"Add":""},{"Add":"#undef MIN"},{"Add":"#undef MAX"},{"Add":"#define MIN(a, b) ((a) < (b) ? (a) : (b))"},{"Add":"#define MAX(a, b) ((a) > (b) ? (a) : (b))"},{"Add":""},{"Add":"typedef struct {"},{"Add":" U32 cSize;"},{"Add":" U32 dSize;"},{"Add":" U32 checksum;"},{"Add":"} framelogEntry_t;"},{"Add":""},{"Add":"struct ZSTD_frameLog_s {"},{"Add":" framelogEntry_t* entries;"},{"Add":" U32 size;"},{"Add":" U32 capacity;"},{"Add":""},{"Add":" int checksumFlag;"},{"Add":""},{"Add":" /* for use when streaming out the seek table */"},{"Add":" U32 seekTablePos;"},{"Add":" U32 seekTableIndex;"},{"Add":"} framelog_t;"},{"Add":""},{"Add":"struct ZSTD_seekable_CStream_s {"},{"Add":" ZSTD_CStream* cstream;"},{"Add":" ZSTD_frameLog framelog;"},{"Add":""},{"Add":" U32 frameCSize;"},{"Add":" U32 frameDSize;"},{"Add":""},{"Add":" XXH64_state_t *xxhState;"},{"Add":""},{"Add":" U32 maxFrameSize;"},{"Add":""},{"Add":" int writingSeekTable;"},{"Add":"};"},{"Add":""},{"Add":"static size_t ZSTD_seekable_frameLog_allocVec(ZSTD_frameLog* fl)"},{"Add":"{"},{"Add":" /* allocate some initial space */"},{"Add":" size_t const FRAMELOG_STARTING_CAPACITY = 16;"},{"Add":" fl->entries = (framelogEntry_t*)malloc("},{"Add":" sizeof(framelogEntry_t) * FRAMELOG_STARTING_CAPACITY);"},{"Add":" if (fl->entries == NULL) return ERROR(memory_allocation);"},{"Add":" fl->capacity = (U32)FRAMELOG_STARTING_CAPACITY;"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"static size_t ZSTD_seekable_frameLog_freeVec(ZSTD_frameLog* fl)"},{"Add":"{"},{"Add":" if (fl != NULL) free(fl->entries);"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"ZSTD_frameLog* ZSTD_seekable_createFrameLog(int checksumFlag)"},{"Add":"{"},{"Add":" ZSTD_frameLog* const fl = (ZSTD_frameLog*)malloc(sizeof(ZSTD_frameLog));"},{"Add":" if (fl == NULL) return NULL;"},{"Add":""},{"Add":" if (ZSTD_isError(ZSTD_seekable_frameLog_allocVec(fl))) {"},{"Add":" free(fl);"},{"Add":" return NULL;"},{"Add":" }"},{"Add":""},{"Add":" fl->checksumFlag = checksumFlag;"},{"Add":" fl->seekTablePos = 0;"},{"Add":" fl->seekTableIndex = 0;"},{"Add":" fl->size = 0;"},{"Add":""},{"Add":" return fl;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekable_freeFrameLog(ZSTD_frameLog* fl)"},{"Add":"{"},{"Add":" ZSTD_seekable_frameLog_freeVec(fl);"},{"Add":" free(fl);"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"ZSTD_seekable_CStream* ZSTD_seekable_createCStream(void)"},{"Add":"{"},{"Add":" ZSTD_seekable_CStream* const zcs = (ZSTD_seekable_CStream*)malloc(sizeof(ZSTD_seekable_CStream));"},{"Add":" if (zcs == NULL) return NULL;"},{"Add":""},{"Add":" memset(zcs, 0, sizeof(*zcs));"},{"Add":""},{"Add":" zcs->cstream = ZSTD_createCStream();"},{"Add":" if (zcs->cstream == NULL) goto failed1;"},{"Add":""},{"Add":" if (ZSTD_isError(ZSTD_seekable_frameLog_allocVec(&zcs->framelog))) goto failed2;"},{"Add":""},{"Add":" return zcs;"},{"Add":""},{"Add":"failed2:"},{"Add":" ZSTD_freeCStream(zcs->cstream);"},{"Add":"failed1:"},{"Add":" free(zcs);"},{"Add":" return NULL;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekable_freeCStream(ZSTD_seekable_CStream* zcs)"},{"Add":"{"},{"Add":" if (zcs == NULL) return 0; /* support free on null */"},{"Add":" ZSTD_freeCStream(zcs->cstream);"},{"Add":" ZSTD_seekable_frameLog_freeVec(&zcs->framelog);"},{"Add":" free(zcs);"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekable_initCStream(ZSTD_seekable_CStream* zcs,"},{"Add":" int compressionLevel,"},{"Add":" int checksumFlag,"},{"Add":" unsigned maxFrameSize)"},{"Add":"{"},{"Add":" zcs->framelog.size = 0;"},{"Add":" zcs->frameCSize = 0;"},{"Add":" zcs->frameDSize = 0;"},{"Add":""},{"Add":" /* make sure maxFrameSize has a reasonable value */"},{"Add":" if (maxFrameSize > ZSTD_SEEKABLE_MAX_FRAME_DECOMPRESSED_SIZE) {"},{"Add":" return ERROR(frameParameter_unsupported);"},{"Add":" }"},{"Add":""},{"Add":" zcs->maxFrameSize = maxFrameSize ?"},{"Add":" maxFrameSize : ZSTD_SEEKABLE_MAX_FRAME_DECOMPRESSED_SIZE;"},{"Add":""},{"Add":" zcs->framelog.checksumFlag = checksumFlag;"},{"Add":" if (zcs->framelog.checksumFlag) {"},{"Add":"\tzcs->xxhState = XXH64_createState();"},{"Add":" XXH64_reset(zcs->xxhState, 0);"},{"Add":" }"},{"Add":""},{"Add":" zcs->framelog.seekTablePos = 0;"},{"Add":" zcs->framelog.seekTableIndex = 0;"},{"Add":" zcs->writingSeekTable = 0;"},{"Add":""},{"Add":" return ZSTD_initCStream(zcs->cstream, compressionLevel);"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekable_logFrame(ZSTD_frameLog* fl,"},{"Add":" unsigned compressedSize,"},{"Add":" unsigned decompressedSize,"},{"Add":" unsigned checksum)"},{"Add":"{"},{"Add":" if (fl->size == ZSTD_SEEKABLE_MAXFRAMES)"},{"Add":" return ERROR(frameIndex_tooLarge);"},{"Add":""},{"Add":" /* grow the buffer if required */"},{"Add":" if (fl->size == fl->capacity) {"},{"Add":" /* exponential size increase for constant amortized runtime */"},{"Add":" size_t const newCapacity = fl->capacity * 2;"},{"Add":" framelogEntry_t* const newEntries = (framelogEntry_t*)realloc(fl->entries,"},{"Add":" sizeof(framelogEntry_t) * newCapacity);"},{"Add":""},{"Add":" if (newEntries == NULL) return ERROR(memory_allocation);"},{"Add":""},{"Add":" fl->entries = newEntries;"},{"Add":" assert(newCapacity <= UINT_MAX);"},{"Add":" fl->capacity = (U32)newCapacity;"},{"Add":" }"},{"Add":""},{"Add":" fl->entries[fl->size] = (framelogEntry_t){"},{"Add":" compressedSize, decompressedSize, checksum"},{"Add":" };"},{"Add":" fl->size++;"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekable_endFrame(ZSTD_seekable_CStream* zcs, ZSTD_outBuffer* output)"},{"Add":"{"},{"Add":" size_t const prevOutPos = output->pos;"},{"Add":" /* end the frame */"},{"Add":" size_t ret = ZSTD_endStream(zcs->cstream, output);"},{"Add":""},{"Add":" zcs->frameCSize += (U32)(output->pos - prevOutPos);"},{"Add":""},{"Add":" /* need to flush before doing the rest */"},{"Add":" if (ret) return ret;"},{"Add":""},{"Add":" /* frame done */"},{"Add":""},{"Add":" /* store the frame data for later */"},{"Add":" ret = ZSTD_seekable_logFrame("},{"Add":" &zcs->framelog, zcs->frameCSize, zcs->frameDSize,"},{"Add":" zcs->framelog.checksumFlag"},{"Add":" ? XXH64_digest(zcs->xxhState) & 0xFFFFFFFFU"},{"Add":" : 0);"},{"Add":" if (ret) return ret;"},{"Add":""},{"Add":" /* reset for the next frame */"},{"Add":" zcs->frameCSize = 0;"},{"Add":" zcs->frameDSize = 0;"},{"Add":""},{"Add":" ZSTD_CCtx_reset(zcs->cstream, ZSTD_reset_session_only);"},{"Add":" if (zcs->framelog.checksumFlag) XXH64_reset(zcs->xxhState, 0);"},{"Add":""},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekable_compressStream(ZSTD_seekable_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input)"},{"Add":"{"},{"Add":" const BYTE* const inBase = (const BYTE*) input->src + input->pos;"},{"Add":" size_t inLen = input->size - input->pos;"},{"Add":""},{"Add":" inLen = MIN(inLen, (size_t)(zcs->maxFrameSize - zcs->frameDSize));"},{"Add":""},{"Add":" /* if we haven't finished flushing the last frame, don't start writing a new one */"},{"Add":" if (inLen > 0) {"},{"Add":" ZSTD_inBuffer inTmp = { inBase, inLen, 0 };"},{"Add":" size_t const prevOutPos = output->pos;"},{"Add":""},{"Add":" size_t const ret = ZSTD_compressStream(zcs->cstream, output, &inTmp);"},{"Add":""},{"Add":" if (zcs->framelog.checksumFlag) {"},{"Add":" XXH64_update(zcs->xxhState, inBase, inTmp.pos);"},{"Add":" }"},{"Add":""},{"Add":" zcs->frameCSize += (U32)(output->pos - prevOutPos);"},{"Add":" zcs->frameDSize += (U32)inTmp.pos;"},{"Add":""},{"Add":" input->pos += inTmp.pos;"},{"Add":""},{"Add":" if (ZSTD_isError(ret)) return ret;"},{"Add":" }"},{"Add":""},{"Add":" if (zcs->maxFrameSize == zcs->frameDSize) {"},{"Add":" /* log the frame and start over */"},{"Add":" size_t const ret = ZSTD_seekable_endFrame(zcs, output);"},{"Add":" if (ZSTD_isError(ret)) return ret;"},{"Add":""},{"Add":" /* get the client ready for the next frame */"},{"Add":" return (size_t)zcs->maxFrameSize;"},{"Add":" }"},{"Add":""},{"Add":" return (size_t)(zcs->maxFrameSize - zcs->frameDSize);"},{"Add":"}"},{"Add":""},{"Add":"static inline size_t ZSTD_seekable_seekTableSize(const ZSTD_frameLog* fl)"},{"Add":"{"},{"Add":" size_t const sizePerFrame = 8 + (fl->checksumFlag?4:0);"},{"Add":" size_t const seekTableLen = ZSTD_SKIPPABLEHEADERSIZE +"},{"Add":" sizePerFrame * fl->size +"},{"Add":" ZSTD_seekTableFooterSize;"},{"Add":""},{"Add":" return seekTableLen;"},{"Add":"}"},{"Add":""},{"Add":"static inline size_t ZSTD_stwrite32(ZSTD_frameLog* fl,"},{"Add":" ZSTD_outBuffer* output, U32 const value,"},{"Add":" U32 const offset)"},{"Add":"{"},{"Add":" if (fl->seekTablePos < offset + 4) {"},{"Add":" BYTE tmp[4]; /* so that we can work with buffers too small to write a whole word to */"},{"Add":" size_t const lenWrite ="},{"Add":" MIN(output->size - output->pos, offset + 4 - fl->seekTablePos);"},{"Add":" MEM_writeLE32(tmp, value);"},{"Add":" memcpy((BYTE*)output->dst + output->pos,"},{"Add":" tmp + (fl->seekTablePos - offset), lenWrite);"},{"Add":" output->pos += lenWrite;"},{"Add":" fl->seekTablePos += (U32)lenWrite;"},{"Add":""},{"Add":" if (lenWrite < 4) return ZSTD_seekable_seekTableSize(fl) - fl->seekTablePos;"},{"Add":" }"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekable_writeSeekTable(ZSTD_frameLog* fl, ZSTD_outBuffer* output)"},{"Add":"{"},{"Add":" /* seekTableIndex: the current index in the table and"},{"Add":" * seekTableSize: the amount of the table written so far"},{"Add":" *"},{"Add":" * This function is written this way so that if it has to return early"},{"Add":" * because of a small buffer, it can keep going where it left off."},{"Add":" */"},{"Add":""},{"Add":" size_t const sizePerFrame = 8 + (fl->checksumFlag?4:0);"},{"Add":" size_t const seekTableLen = ZSTD_seekable_seekTableSize(fl);"},{"Add":""},{"Add":" CHECK_Z(ZSTD_stwrite32(fl, output, ZSTD_MAGIC_SKIPPABLE_START | 0xE, 0));"},{"Add":" assert(seekTableLen <= (size_t)UINT_MAX);"},{"Add":" CHECK_Z(ZSTD_stwrite32(fl, output, (U32)seekTableLen - ZSTD_SKIPPABLEHEADERSIZE, 4));"},{"Add":""},{"Add":" while (fl->seekTableIndex < fl->size) {"},{"Add":" unsigned long long const start = ZSTD_SKIPPABLEHEADERSIZE + sizePerFrame * fl->seekTableIndex;"},{"Add":" assert(start + 8 <= UINT_MAX);"},{"Add":" CHECK_Z(ZSTD_stwrite32(fl, output,"},{"Add":" fl->entries[fl->seekTableIndex].cSize,"},{"Add":" (U32)start + 0));"},{"Add":""},{"Add":" CHECK_Z(ZSTD_stwrite32(fl, output,"},{"Add":" fl->entries[fl->seekTableIndex].dSize,"},{"Add":" (U32)start + 4));"},{"Add":""},{"Add":" if (fl->checksumFlag) {"},{"Add":" CHECK_Z(ZSTD_stwrite32("},{"Add":" fl, output, fl->entries[fl->seekTableIndex].checksum,"},{"Add":" (U32)start + 8));"},{"Add":" }"},{"Add":""},{"Add":" fl->seekTableIndex++;"},{"Add":" }"},{"Add":""},{"Add":" assert(seekTableLen <= UINT_MAX);"},{"Add":" CHECK_Z(ZSTD_stwrite32(fl, output, fl->size,"},{"Add":" (U32)seekTableLen - ZSTD_seekTableFooterSize));"},{"Add":""},{"Add":" if (output->size - output->pos < 1) return seekTableLen - fl->seekTablePos;"},{"Add":" if (fl->seekTablePos < seekTableLen - 4) {"},{"Add":" BYTE const sfd = (BYTE)((fl->checksumFlag) << 7);"},{"Add":""},{"Add":" ((BYTE*)output->dst)[output->pos] = sfd;"},{"Add":" output->pos++;"},{"Add":" fl->seekTablePos++;"},{"Add":" }"},{"Add":""},{"Add":" CHECK_Z(ZSTD_stwrite32(fl, output, ZSTD_SEEKABLE_MAGICNUMBER,"},{"Add":" (U32)seekTableLen - 4));"},{"Add":""},{"Add":" if (fl->seekTablePos != seekTableLen) return ERROR(GENERIC);"},{"Add":" return 0;"},{"Add":"}"},{"Add":""},{"Add":"size_t ZSTD_seekable_endStream(ZSTD_seekable_CStream* zcs, ZSTD_outBuffer* output)"},{"Add":"{"},{"Add":" if (!zcs->writingSeekTable && zcs->frameDSize) {"},{"Add":" const size_t endFrame = ZSTD_seekable_endFrame(zcs, output);"},{"Add":" if (ZSTD_isError(endFrame)) return endFrame;"},{"Add":" /* return an accurate size hint */"},{"Add":" if (endFrame) return endFrame + ZSTD_seekable_seekTableSize(&zcs->framelog);"},{"Add":" }"},{"Add":""},{"Add":" zcs->writingSeekTable = 1;"},{"Add":""},{"Add":" return ZSTD_seekable_writeSeekTable(&zcs->framelog, output);"},{"Add":"}"}]}},{"FileAdd":{"meta":{"basename":"zstd_seekable.h","metadata":0},"context":[{"change":7,"pos":1}],"contents":[{"Add":"#ifndef ZSTDSEEKABLE_H"},{"Add":"#define ZSTDSEEKABLE_H"},{"Add":""},{"Add":"/** "},{"Add":" * Required includes:"},{"Add":" * - stdio.h"},{"Add":" * - zstd.h"},{"Add":" */ "},{"Add":""},{"Add":"/** zstd.h: the ZSTD_SKIPPABLEHEADERSIZE is part of the \"experimental\" API and"},{"Add":" * currently confined to static-only. But that's not how we roll, is it?"},{"Add":" */"},{"Add":"#define ZSTD_SKIPPABLEHEADERSIZE\t8"},{"Add":""},{"Add":"#define ZSTD_seekTableFooterSize 9"},{"Add":""},{"Add":"#define ZSTD_SEEKABLE_MAGICNUMBER 0x8F92EAB1"},{"Add":""},{"Add":"#define ZSTD_SEEKABLE_MAXFRAMES 0x8000000U"},{"Add":""},{"Add":"/* Limit the maximum size to avoid any potential issues storing the compressed size */"},{"Add":"#define ZSTD_SEEKABLE_MAX_FRAME_DECOMPRESSED_SIZE 0x80000000U"},{"Add":""},{"Add":"/*-****************************************************************************"},{"Add":"* Seekable Format"},{"Add":"*"},{"Add":"* The seekable format splits the compressed data into a series of \"frames\","},{"Add":"* each compressed individually so that decompression of a section in the"},{"Add":"* middle of an archive only requires zstd to decompress at most a frame's"},{"Add":"* worth of extra data, instead of the entire archive."},{"Add":"******************************************************************************/"},{"Add":""},{"Add":"typedef struct ZSTD_seekable_CStream_s ZSTD_seekable_CStream;"},{"Add":"typedef struct ZSTD_seekable_s ZSTD_seekable;"},{"Add":"typedef struct ZSTD_seekTable_s ZSTD_seekTable;"},{"Add":""},{"Add":"/*-****************************************************************************"},{"Add":"* Seekable compression - HowTo"},{"Add":"* A ZSTD_seekable_CStream object is required to tracking streaming operation."},{"Add":"* Use ZSTD_seekable_createCStream() and ZSTD_seekable_freeCStream() to create/"},{"Add":"* release resources."},{"Add":"*"},{"Add":"* Streaming objects are reusable to avoid allocation and deallocation,"},{"Add":"* to start a new compression operation call ZSTD_seekable_initCStream() on the"},{"Add":"* compressor."},{"Add":"*"},{"Add":"* Data streamed to the seekable compressor will automatically be split into"},{"Add":"* frames of size `maxFrameSize` (provided in ZSTD_seekable_initCStream()),"},{"Add":"* or if none is provided, will be cut off whenever ZSTD_seekable_endFrame() is"},{"Add":"* called or when the default maximum frame size (2GB) is reached."},{"Add":"*"},{"Add":"* Use ZSTD_seekable_initCStream() to initialize a ZSTD_seekable_CStream object"},{"Add":"* for a new compression operation."},{"Add":"* `maxFrameSize` indicates the size at which to automatically start a new"},{"Add":"* seekable frame. `maxFrameSize == 0` implies the default maximum size."},{"Add":"* `checksumFlag` indicates whether or not the seek table should include frame"},{"Add":"* checksums on the uncompressed data for verification."},{"Add":"* @return : a size hint for input to provide for compression, or an error code"},{"Add":"* checkable with ZSTD_isError()"},{"Add":"*"},{"Add":"* Use ZSTD_seekable_compressStream() repetitively to consume input stream."},{"Add":"* The function will automatically update both `pos` fields."},{"Add":"* Note that it may not consume the entire input, in which case `pos < size`,"},{"Add":"* and it's up to the caller to present again remaining data."},{"Add":"* @return : a size hint, preferred nb of bytes to use as input for next"},{"Add":"* function call or an error code, which can be tested using"},{"Add":"* ZSTD_isError()."},{"Add":"* Note 1 : it's just a hint, to help latency a little, any other"},{"Add":"* value will work fine."},{"Add":"*"},{"Add":"* At any time, call ZSTD_seekable_endFrame() to end the current frame and"},{"Add":"* start a new one."},{"Add":"*"},{"Add":"* ZSTD_seekable_endStream() will end the current frame, and then write the seek"},{"Add":"* table so that decompressors can efficiently find compressed frames."},{"Add":"* ZSTD_seekable_endStream() may return a number > 0 if it was unable to flush"},{"Add":"* all the necessary data to `output`. In this case, it should be called again"},{"Add":"* until all remaining data is flushed out and 0 is returned."},{"Add":"******************************************************************************/"},{"Add":""},{"Add":"/*===== Seekable compressor management =====*/"},{"Add":"ZSTDLIB_API ZSTD_seekable_CStream* ZSTD_seekable_createCStream(void);"},{"Add":"ZSTDLIB_API size_t ZSTD_seekable_freeCStream(ZSTD_seekable_CStream* zcs);"},{"Add":""},{"Add":"/*===== Seekable compression functions =====*/"},{"Add":"ZSTDLIB_API size_t ZSTD_seekable_initCStream(ZSTD_seekable_CStream* zcs, int compressionLevel, int checksumFlag, unsigned maxFrameSize);"},{"Add":"ZSTDLIB_API size_t ZSTD_seekable_compressStream(ZSTD_seekable_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input);"},{"Add":"ZSTDLIB_API size_t ZSTD_seekable_endFrame(ZSTD_seekable_CStream* zcs, ZSTD_outBuffer* output);"},{"Add":"ZSTDLIB_API size_t ZSTD_seekable_endStream(ZSTD_seekable_CStream* zcs, ZSTD_outBuffer* output);"},{"Add":""},{"Add":"/*= Raw seek table API"},{"Add":" * These functions allow for the seek table to be constructed directly."},{"Add":" * This table can then be appended to a file of concatenated frames."},{"Add":" * This allows the frames to be compressed independently, even in parallel,"},{"Add":" * and compiled together afterward into a seekable archive."},{"Add":" *"},{"Add":" * Use ZSTD_seekable_createFrameLog() to allocate and initialize a tracking"},{"Add":" * structure."},{"Add":" *"},{"Add":" * Call ZSTD_seekable_logFrame() once for each frame in the archive."},{"Add":" * checksum is optional, and will not be used if checksumFlag was 0 when the"},{"Add":" * frame log was created. If present, it should be the least significant 32"},{"Add":" * bits of the XXH64 hash of the uncompressed data."},{"Add":" *"},{"Add":" * Call ZSTD_seekable_writeSeekTable to serialize the data into a seek table."},{"Add":" * If the entire table was written, the return value will be 0. Otherwise,"},{"Add":" * it will be equal to the number of bytes left to write. */"},{"Add":"typedef struct ZSTD_frameLog_s ZSTD_frameLog;"},{"Add":"ZSTDLIB_API ZSTD_frameLog* ZSTD_seekable_createFrameLog(int checksumFlag);"},{"Add":"ZSTDLIB_API size_t ZSTD_seekable_freeFrameLog(ZSTD_frameLog* fl);"},{"Add":"ZSTDLIB_API size_t ZSTD_seekable_logFrame(ZSTD_frameLog* fl, unsigned compressedSize, unsigned decompressedSize, unsigned checksum);"},{"Add":"ZSTDLIB_API size_t ZSTD_seekable_writeSeekTable(ZSTD_frameLog* fl, ZSTD_outBuffer* output);"},{"Add":""},{"Add":""},{"Add":"/*-****************************************************************************"},{"Add":"* Seekable decompression - HowTo"},{"Add":"* A ZSTD_seekable object is required to tracking the seekTable."},{"Add":"*"},{"Add":"* Call ZSTD_seekable_init* to initialize a ZSTD_seekable object with the"},{"Add":"* the seek table provided in the input."},{"Add":"* There are three modes for ZSTD_seekable_init:"},{"Add":"* - ZSTD_seekable_initBuff() : An in-memory API. The data contained in"},{"Add":"* `src` should be the entire seekable file, including the seek table."},{"Add":"* `src` should be kept alive and unmodified until the ZSTD_seekable object"},{"Add":"* is freed or reset."},{"Add":"* - ZSTD_seekable_initFile() : A simplified file API using stdio. fread and"},{"Add":"* fseek will be used to access the required data for building the seek"},{"Add":"* table and doing decompression operations. `src` should not be closed"},{"Add":"* or modified until the ZSTD_seekable object is freed or reset."},{"Add":"* - ZSTD_seekable_initAdvanced() : A general API allowing the client to"},{"Add":"* provide its own read and seek callbacks."},{"Add":"* + ZSTD_seekable_read() : read exactly `n` bytes into `buffer`."},{"Add":"* Premature EOF should be treated as an error."},{"Add":"* + ZSTD_seekable_seek() : seek the read head to `offset` from `origin`,"},{"Add":"* where origin is either SEEK_SET (beginning of"},{"Add":"* file), or SEEK_END (end of file)."},{"Add":"* Both functions should return a non-negative value in case of success, and a"},{"Add":"* negative value in case of failure. If implementing using this API and"},{"Add":"* stdio, be careful with files larger than 4GB and fseek. All of these"},{"Add":"* functions return an error code checkable with ZSTD_isError()."},{"Add":"*"},{"Add":"* Call ZSTD_seekable_decompress to decompress `dstSize` bytes at decompressed"},{"Add":"* offset `offset`. ZSTD_seekable_decompress may have to decompress the entire"},{"Add":"* prefix of the frame before the desired data if it has not already processed"},{"Add":"* this section. If ZSTD_seekable_decompress is called multiple times for a"},{"Add":"* consecutive range of data, it will efficiently retain the decompressor object"},{"Add":"* and avoid redecompressing frame prefixes. The return value is the number of"},{"Add":"* bytes decompressed, or an error code checkable with ZSTD_isError()."},{"Add":"*"},{"Add":"* The seek table access functions can be used to obtain the data contained"},{"Add":"* in the seek table. If frameIndex is larger than the value returned by"},{"Add":"* ZSTD_seekable_getNumFrames(), they will return error codes checkable with"},{"Add":"* ZSTD_isError(). Note that since the offset access functions return"},{"Add":"* unsigned long long instead of size_t, in this case they will instead return"},{"Add":"* the value ZSTD_SEEKABLE_FRAMEINDEX_TOOLARGE."},{"Add":"******************************************************************************/"},{"Add":""},{"Add":"/*===== Seekable decompressor management =====*/"},{"Add":"ZSTDLIB_API ZSTD_seekable* ZSTD_seekable_create(void);"},{"Add":"ZSTDLIB_API size_t ZSTD_seekable_free(ZSTD_seekable* zs);"},{"Add":""},{"Add":"/*===== Seekable decompression functions =====*/"},{"Add":"ZSTDLIB_API size_t ZSTD_seekable_initBuff(ZSTD_seekable* zs, const void* src, size_t srcSize);"},{"Add":"ZSTDLIB_API size_t ZSTD_seekable_initFile(ZSTD_seekable* zs, FILE* src);"},{"Add":"ZSTDLIB_API size_t ZSTD_seekable_decompress(ZSTD_seekable* zs, void* dst, size_t dstSize, unsigned long long offset);"},{"Add":"ZSTDLIB_API size_t ZSTD_seekable_decompressFrame(ZSTD_seekable* zs, void* dst, size_t dstSize, unsigned frameIndex);"},{"Add":""},{"Add":"#define ZSTD_SEEKABLE_FRAMEINDEX_TOOLARGE (0ULL-2)"},{"Add":"/*===== Seekable seek table access functions =====*/"},{"Add":"ZSTDLIB_API unsigned ZSTD_seekable_getNumFrames(const ZSTD_seekable* zs);"},{"Add":"ZSTDLIB_API unsigned long long ZSTD_seekable_getFrameCompressedOffset(const ZSTD_seekable* zs, unsigned frameIndex);"},{"Add":"ZSTDLIB_API unsigned long long ZSTD_seekable_getFrameDecompressedOffset(const ZSTD_seekable* zs, unsigned frameIndex);"},{"Add":"ZSTDLIB_API size_t ZSTD_seekable_getFrameCompressedSize(const ZSTD_seekable* zs, unsigned frameIndex);"},{"Add":"ZSTDLIB_API size_t ZSTD_seekable_getFrameDecompressedSize(const ZSTD_seekable* zs, unsigned frameIndex);"},{"Add":"ZSTDLIB_API unsigned ZSTD_seekable_offsetToFrameIndex(const ZSTD_seekable* zs, unsigned long long offset);"},{"Add":""},{"Add":""},{"Add":"/*-****************************************************************************"},{"Add":"* Direct exploitation of the seekTable"},{"Add":"*"},{"Add":"* Memory constrained use cases that manage multiple archives"},{"Add":"* benefit from retaining multiple archive seek tables"},{"Add":"* without retaining a ZSTD_seekable instance for each."},{"Add":"*"},{"Add":"* Below API allow the above-mentioned use cases"},{"Add":"* to initialize a ZSTD_seekable, extract its (smaller) ZSTD_seekTable,"},{"Add":"* then throw the ZSTD_seekable away to save memory."},{"Add":"*"},{"Add":"* Standard ZSTD operations can then be used"},{"Add":"* to decompress frames based on seek table offsets."},{"Add":"******************************************************************************/"},{"Add":""},{"Add":"/*===== Independent seek table management =====*/"},{"Add":"ZSTDLIB_API ZSTD_seekTable* ZSTD_seekTable_create_fromSeekable(const ZSTD_seekable* zs);"},{"Add":"ZSTDLIB_API size_t ZSTD_seekTable_free(ZSTD_seekTable* st);"},{"Add":""},{"Add":"/*===== Direct seek table access functions =====*/"},{"Add":"ZSTDLIB_API unsigned ZSTD_seekTable_getNumFrames(const ZSTD_seekTable* st);"},{"Add":"ZSTDLIB_API unsigned long long ZSTD_seekTable_getFrameCompressedOffset(const ZSTD_seekTable* st, unsigned frameIndex);"},{"Add":"ZSTDLIB_API unsigned long long ZSTD_seekTable_getFrameDecompressedOffset(const ZSTD_seekTable* st, unsigned frameIndex);"},{"Add":"ZSTDLIB_API size_t ZSTD_seekTable_getFrameCompressedSize(const ZSTD_seekTable* st, unsigned frameIndex);"},{"Add":"ZSTDLIB_API size_t ZSTD_seekTable_getFrameDecompressedSize(const ZSTD_seekTable* st, unsigned frameIndex);"},{"Add":"ZSTDLIB_API unsigned ZSTD_seekTable_offsetToFrameIndex(const ZSTD_seekTable* st, unsigned long long offset);"},{"Add":""},{"Add":""},{"Add":"/*===== Seekable advanced I/O API =====*/"},{"Add":"typedef int(ZSTD_seekable_read)(void* opaque, void* buffer, size_t n);"},{"Add":"typedef int(ZSTD_seekable_seek)(void* opaque, long long offset, int origin);"},{"Add":"typedef struct {"},{"Add":" void* opaque;"},{"Add":" ZSTD_seekable_read* read;"},{"Add":" ZSTD_seekable_seek* seek;"},{"Add":"} ZSTD_seekable_customFile;"},{"Add":"ZSTDLIB_API size_t ZSTD_seekable_initAdvanced(ZSTD_seekable* zs, ZSTD_seekable_customFile src);"},{"Add":""},{"Add":"#endif"}]}},{"FileAdd":{"meta":{"basename":"zstd_deps.h","metadata":0},"context":[{"change":7,"pos":1}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":"/* This file provides common libc dependencies that zstd requires."},{"Add":" * The purpose is to allow replacing this file with a custom implementation"},{"Add":" * to compile zstd without libc support."},{"Add":" */"},{"Add":""},{"Add":"/* Need:"},{"Add":" * NULL"},{"Add":" * INT_MAX"},{"Add":" * UINT_MAX"},{"Add":" * ZSTD_memcpy()"},{"Add":" * ZSTD_memset()"},{"Add":" * ZSTD_memmove()"},{"Add":" */"},{"Add":"#ifndef ZSTD_DEPS_COMMON"},{"Add":"#define ZSTD_DEPS_COMMON"},{"Add":""},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":""},{"Add":"#if defined(__GNUC__) && __GNUC__ >= 4"},{"Add":"# define ZSTD_memcpy(d,s,l) __builtin_memcpy((d),(s),(l))"},{"Add":"# define ZSTD_memmove(d,s,l) __builtin_memmove((d),(s),(l))"},{"Add":"# define ZSTD_memset(p,v,l) __builtin_memset((p),(v),(l))"},{"Add":"#else"},{"Add":"# define ZSTD_memcpy(d,s,l) memcpy((d),(s),(l))"},{"Add":"# define ZSTD_memmove(d,s,l) memmove((d),(s),(l))"},{"Add":"# define ZSTD_memset(p,v,l) memset((p),(v),(l))"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* ZSTD_DEPS_COMMON */"},{"Add":""},{"Add":"/* Need:"},{"Add":" * ZSTD_malloc()"},{"Add":" * ZSTD_free()"},{"Add":" * ZSTD_calloc()"},{"Add":" */"},{"Add":"#ifdef ZSTD_DEPS_NEED_MALLOC"},{"Add":"#ifndef ZSTD_DEPS_MALLOC"},{"Add":"#define ZSTD_DEPS_MALLOC"},{"Add":""},{"Add":"#include "},{"Add":""},{"Add":"#define ZSTD_malloc(s) malloc(s)"},{"Add":"#define ZSTD_calloc(n,s) calloc((n), (s))"},{"Add":"#define ZSTD_free(p) free((p))"},{"Add":""},{"Add":"#endif /* ZSTD_DEPS_MALLOC */"},{"Add":"#endif /* ZSTD_DEPS_NEED_MALLOC */"},{"Add":""},{"Add":"/*"},{"Add":" * Provides 64-bit math support."},{"Add":" * Need:"},{"Add":" * U64 ZSTD_div64(U64 dividend, U32 divisor)"},{"Add":" */"},{"Add":"#ifdef ZSTD_DEPS_NEED_MATH64"},{"Add":"#ifndef ZSTD_DEPS_MATH64"},{"Add":"#define ZSTD_DEPS_MATH64"},{"Add":""},{"Add":"#define ZSTD_div64(dividend, divisor) ((dividend) / (divisor))"},{"Add":""},{"Add":"#endif /* ZSTD_DEPS_MATH64 */"},{"Add":"#endif /* ZSTD_DEPS_NEED_MATH64 */"},{"Add":""},{"Add":"/* Need:"},{"Add":" * assert()"},{"Add":" */"},{"Add":"#ifdef ZSTD_DEPS_NEED_ASSERT"},{"Add":"#ifndef ZSTD_DEPS_ASSERT"},{"Add":"#define ZSTD_DEPS_ASSERT"},{"Add":""},{"Add":"#include "},{"Add":""},{"Add":"#endif /* ZSTD_DEPS_ASSERT */"},{"Add":"#endif /* ZSTD_DEPS_NEED_ASSERT */"},{"Add":""},{"Add":"/* Need:"},{"Add":" * ZSTD_DEBUG_PRINT()"},{"Add":" */"},{"Add":"#ifdef ZSTD_DEPS_NEED_IO"},{"Add":"#ifndef ZSTD_DEPS_IO"},{"Add":"#define ZSTD_DEPS_IO"},{"Add":""},{"Add":"#include "},{"Add":"#define ZSTD_DEBUG_PRINT(...) fprintf(stderr, __VA_ARGS__)"},{"Add":""},{"Add":"#endif /* ZSTD_DEPS_IO */"},{"Add":"#endif /* ZSTD_DEPS_NEED_IO */"},{"Add":""},{"Add":"/* Only requested when is known to be present."},{"Add":" * Need:"},{"Add":" * intptr_t"},{"Add":" */"},{"Add":"#ifdef ZSTD_DEPS_NEED_STDINT"},{"Add":"#ifndef ZSTD_DEPS_STDINT"},{"Add":"#define ZSTD_DEPS_STDINT"},{"Add":""},{"Add":"#include "},{"Add":""},{"Add":"#endif /* ZSTD_DEPS_STDINT */"},{"Add":"#endif /* ZSTD_DEPS_NEED_STDINT */"}]}},{"FileAdd":{"meta":{"basename":"portability_macros.h","metadata":0},"context":[{"change":7,"pos":1}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":"#ifndef ZSTD_PORTABILITY_MACROS_H"},{"Add":"#define ZSTD_PORTABILITY_MACROS_H"},{"Add":""},{"Add":"/**"},{"Add":" * This header file contains macro definitions to support portability."},{"Add":" * This header is shared between C and ASM code, so it MUST only"},{"Add":" * contain macro definitions. It MUST not contain any C code."},{"Add":" *"},{"Add":" * This header ONLY defines macros to detect platforms/feature support."},{"Add":" *"},{"Add":" */"},{"Add":""},{"Add":""},{"Add":"/* compat. with non-clang compilers */"},{"Add":"#ifndef __has_attribute"},{"Add":" #define __has_attribute(x) 0"},{"Add":"#endif"},{"Add":""},{"Add":"/* compat. with non-clang compilers */"},{"Add":"#ifndef __has_builtin"},{"Add":"# define __has_builtin(x) 0"},{"Add":"#endif"},{"Add":""},{"Add":"/* compat. with non-clang compilers */"},{"Add":"#ifndef __has_feature"},{"Add":"# define __has_feature(x) 0"},{"Add":"#endif"},{"Add":""},{"Add":"/* detects whether we are being compiled under msan */"},{"Add":"#ifndef ZSTD_MEMORY_SANITIZER"},{"Add":"# if __has_feature(memory_sanitizer)"},{"Add":"# define ZSTD_MEMORY_SANITIZER 1"},{"Add":"# else"},{"Add":"# define ZSTD_MEMORY_SANITIZER 0"},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":"/* detects whether we are being compiled under asan */"},{"Add":"#ifndef ZSTD_ADDRESS_SANITIZER"},{"Add":"# if __has_feature(address_sanitizer)"},{"Add":"# define ZSTD_ADDRESS_SANITIZER 1"},{"Add":"# elif defined(__SANITIZE_ADDRESS__)"},{"Add":"# define ZSTD_ADDRESS_SANITIZER 1"},{"Add":"# else"},{"Add":"# define ZSTD_ADDRESS_SANITIZER 0"},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":"/* detects whether we are being compiled under dfsan */"},{"Add":"#ifndef ZSTD_DATAFLOW_SANITIZER"},{"Add":"# if __has_feature(dataflow_sanitizer)"},{"Add":"# define ZSTD_DATAFLOW_SANITIZER 1"},{"Add":"# else"},{"Add":"# define ZSTD_DATAFLOW_SANITIZER 0"},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":"/* Mark the internal assembly functions as hidden */"},{"Add":"#ifdef __ELF__"},{"Add":"# define ZSTD_HIDE_ASM_FUNCTION(func) .hidden func"},{"Add":"#else"},{"Add":"# define ZSTD_HIDE_ASM_FUNCTION(func)"},{"Add":"#endif"},{"Add":""},{"Add":"/* Enable runtime BMI2 dispatch based on the CPU."},{"Add":" * Enabled for clang & gcc >=4.8 on x86 when BMI2 isn't enabled by default."},{"Add":" */"},{"Add":"#ifndef DYNAMIC_BMI2"},{"Add":" #if ((defined(__clang__) && __has_attribute(__target__)) \\"},{"Add":" || (defined(__GNUC__) \\"},{"Add":" && (__GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))) \\"},{"Add":" && (defined(__x86_64__) || defined(_M_X64)) \\"},{"Add":" && !defined(__BMI2__)"},{"Add":" # define DYNAMIC_BMI2 1"},{"Add":" #else"},{"Add":" # define DYNAMIC_BMI2 0"},{"Add":" #endif"},{"Add":"#endif"},{"Add":""},{"Add":"/**"},{"Add":" * Only enable assembly for GNUC compatible compilers,"},{"Add":" * because other platforms may not support GAS assembly syntax."},{"Add":" *"},{"Add":" * Only enable assembly for Linux / MacOS, other platforms may"},{"Add":" * work, but they haven't been tested. This could likely be"},{"Add":" * extended to BSD systems."},{"Add":" *"},{"Add":" * Disable assembly when MSAN is enabled, because MSAN requires"},{"Add":" * 100% of code to be instrumented to work."},{"Add":" */"},{"Add":"#if defined(__GNUC__)"},{"Add":"# if defined(__linux__) || defined(__linux) || defined(__APPLE__)"},{"Add":"# if ZSTD_MEMORY_SANITIZER"},{"Add":"# define ZSTD_ASM_SUPPORTED 0"},{"Add":"# elif ZSTD_DATAFLOW_SANITIZER"},{"Add":"# define ZSTD_ASM_SUPPORTED 0"},{"Add":"# else"},{"Add":"# define ZSTD_ASM_SUPPORTED 1"},{"Add":"# endif"},{"Add":"# else"},{"Add":"# define ZSTD_ASM_SUPPORTED 0"},{"Add":"# endif"},{"Add":"#else"},{"Add":"# define ZSTD_ASM_SUPPORTED 0"},{"Add":"#endif"},{"Add":""},{"Add":"/**"},{"Add":" * Determines whether we should enable assembly for x86-64"},{"Add":" * with BMI2."},{"Add":" *"},{"Add":" * Enable if all of the following conditions hold:"},{"Add":" * - ASM hasn't been explicitly disabled by defining ZSTD_DISABLE_ASM"},{"Add":" * - Assembly is supported"},{"Add":" * - We are compiling for x86-64 and either:"},{"Add":" * - DYNAMIC_BMI2 is enabled"},{"Add":" * - BMI2 is supported at compile time"},{"Add":" */"},{"Add":"#if !defined(ZSTD_DISABLE_ASM) && \\"},{"Add":" ZSTD_ASM_SUPPORTED && \\"},{"Add":" defined(__x86_64__) && \\"},{"Add":" (DYNAMIC_BMI2 || defined(__BMI2__))"},{"Add":"# define ZSTD_ENABLE_ASM_X86_64_BMI2 1"},{"Add":"#else"},{"Add":"# define ZSTD_ENABLE_ASM_X86_64_BMI2 0"},{"Add":"#endif"},{"Add":""},{"Add":"/*"},{"Add":" * For x86 ELF targets, add .note.gnu.property section for Intel CET in"},{"Add":" * assembly sources when CET is enabled."},{"Add":" */"},{"Add":"#if defined(__ELF__) && (defined(__x86_64__) || defined(__i386__)) \\"},{"Add":" && defined(__has_include)"},{"Add":"# if __has_include()"},{"Add":"# include "},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* ZSTD_PORTABILITY_MACROS_H */"}]}},{"FileAdd":{"meta":{"basename":"mem.h","metadata":0},"context":[{"change":7,"pos":1}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) Yann Collet, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":"#ifndef MEM_H_MODULE"},{"Add":"#define MEM_H_MODULE"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"/*-****************************************"},{"Add":"* Dependencies"},{"Add":"******************************************/"},{"Add":"#include /* size_t, ptrdiff_t */"},{"Add":"#include \"compiler.h\" /* __has_builtin */"},{"Add":"#include \"debug.h\" /* DEBUG_STATIC_ASSERT */"},{"Add":"#include \"zstd_deps.h\" /* ZSTD_memcpy */"},{"Add":""},{"Add":""},{"Add":"/*-****************************************"},{"Add":"* Compiler specifics"},{"Add":"******************************************/"},{"Add":"#if defined(_MSC_VER) /* Visual Studio */"},{"Add":"# include /* _byteswap_ulong */"},{"Add":"# include /* _byteswap_* */"},{"Add":"#endif"},{"Add":"#if defined(__GNUC__)"},{"Add":"# define MEM_STATIC static __inline __attribute__((unused))"},{"Add":"#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)"},{"Add":"# define MEM_STATIC static inline"},{"Add":"#elif defined(_MSC_VER)"},{"Add":"# define MEM_STATIC static __inline"},{"Add":"#else"},{"Add":"# define MEM_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */"},{"Add":"#endif"},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* Basic Types"},{"Add":"*****************************************************************/"},{"Add":"#if !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )"},{"Add":"# if defined(_AIX)"},{"Add":"# include "},{"Add":"# else"},{"Add":"# include /* intptr_t */"},{"Add":"# endif"},{"Add":" typedef uint8_t BYTE;"},{"Add":" typedef uint8_t U8;"},{"Add":" typedef int8_t S8;"},{"Add":" typedef uint16_t U16;"},{"Add":" typedef int16_t S16;"},{"Add":" typedef uint32_t U32;"},{"Add":" typedef int32_t S32;"},{"Add":" typedef uint64_t U64;"},{"Add":" typedef int64_t S64;"},{"Add":"#else"},{"Add":"# include "},{"Add":"#if CHAR_BIT != 8"},{"Add":"# error \"this implementation requires char to be exactly 8-bit type\""},{"Add":"#endif"},{"Add":" typedef unsigned char BYTE;"},{"Add":" typedef unsigned char U8;"},{"Add":" typedef signed char S8;"},{"Add":"#if USHRT_MAX != 65535"},{"Add":"# error \"this implementation requires short to be exactly 16-bit type\""},{"Add":"#endif"},{"Add":" typedef unsigned short U16;"},{"Add":" typedef signed short S16;"},{"Add":"#if UINT_MAX != 4294967295"},{"Add":"# error \"this implementation requires int to be exactly 32-bit type\""},{"Add":"#endif"},{"Add":" typedef unsigned int U32;"},{"Add":" typedef signed int S32;"},{"Add":"/* note : there are no limits defined for long long type in C90."},{"Add":" * limits exist in C99, however, in such case, is preferred */"},{"Add":" typedef unsigned long long U64;"},{"Add":" typedef signed long long S64;"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* Memory I/O API"},{"Add":"*****************************************************************/"},{"Add":"/*=== Static platform detection ===*/"},{"Add":"MEM_STATIC unsigned MEM_32bits(void);"},{"Add":"MEM_STATIC unsigned MEM_64bits(void);"},{"Add":"MEM_STATIC unsigned MEM_isLittleEndian(void);"},{"Add":""},{"Add":"/*=== Native unaligned read/write ===*/"},{"Add":"MEM_STATIC U16 MEM_read16(const void* memPtr);"},{"Add":"MEM_STATIC U32 MEM_read32(const void* memPtr);"},{"Add":"MEM_STATIC U64 MEM_read64(const void* memPtr);"},{"Add":"MEM_STATIC size_t MEM_readST(const void* memPtr);"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value);"},{"Add":"MEM_STATIC void MEM_write32(void* memPtr, U32 value);"},{"Add":"MEM_STATIC void MEM_write64(void* memPtr, U64 value);"},{"Add":""},{"Add":"/*=== Little endian unaligned read/write ===*/"},{"Add":"MEM_STATIC U16 MEM_readLE16(const void* memPtr);"},{"Add":"MEM_STATIC U32 MEM_readLE24(const void* memPtr);"},{"Add":"MEM_STATIC U32 MEM_readLE32(const void* memPtr);"},{"Add":"MEM_STATIC U64 MEM_readLE64(const void* memPtr);"},{"Add":"MEM_STATIC size_t MEM_readLEST(const void* memPtr);"},{"Add":""},{"Add":"MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val);"},{"Add":"MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val);"},{"Add":"MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32);"},{"Add":"MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64);"},{"Add":"MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val);"},{"Add":""},{"Add":"/*=== Big endian unaligned read/write ===*/"},{"Add":"MEM_STATIC U32 MEM_readBE32(const void* memPtr);"},{"Add":"MEM_STATIC U64 MEM_readBE64(const void* memPtr);"},{"Add":"MEM_STATIC size_t MEM_readBEST(const void* memPtr);"},{"Add":""},{"Add":"MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32);"},{"Add":"MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64);"},{"Add":"MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val);"},{"Add":""},{"Add":"/*=== Byteswap ===*/"},{"Add":"MEM_STATIC U32 MEM_swap32(U32 in);"},{"Add":"MEM_STATIC U64 MEM_swap64(U64 in);"},{"Add":"MEM_STATIC size_t MEM_swapST(size_t in);"},{"Add":""},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* Memory I/O Implementation"},{"Add":"*****************************************************************/"},{"Add":"/* MEM_FORCE_MEMORY_ACCESS :"},{"Add":" * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable."},{"Add":" * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal."},{"Add":" * The below switch allow to select different access method for improved performance."},{"Add":" * Method 0 (default) : use `memcpy()`. Safe and portable."},{"Add":" * Method 1 : `__packed` statement. It depends on compiler extension (i.e., not portable)."},{"Add":" * This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`."},{"Add":" * Method 2 : direct access. This method is portable but violate C standard."},{"Add":" * It can generate buggy code on targets depending on alignment."},{"Add":" * In some circumstances, it's the only known way to get the most performance (i.e. GCC + ARMv6)"},{"Add":" * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details."},{"Add":" * Prefer these methods in priority order (0 > 1 > 2)"},{"Add":" */"},{"Add":"#ifndef MEM_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */"},{"Add":"# if defined(__INTEL_COMPILER) || defined(__GNUC__) || defined(__ICCARM__)"},{"Add":"# define MEM_FORCE_MEMORY_ACCESS 1"},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":"MEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; }"},{"Add":"MEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; }"},{"Add":""},{"Add":"MEM_STATIC unsigned MEM_isLittleEndian(void)"},{"Add":"{"},{"Add":"#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)"},{"Add":" return 1;"},{"Add":"#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)"},{"Add":" return 0;"},{"Add":"#elif defined(__clang__) && __LITTLE_ENDIAN__"},{"Add":" return 1;"},{"Add":"#elif defined(__clang__) && __BIG_ENDIAN__"},{"Add":" return 0;"},{"Add":"#elif defined(_MSC_VER) && (_M_AMD64 || _M_IX86)"},{"Add":" return 1;"},{"Add":"#elif defined(__DMC__) && defined(_M_IX86)"},{"Add":" return 1;"},{"Add":"#else"},{"Add":" const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */"},{"Add":" return one.c[0];"},{"Add":"#endif"},{"Add":"}"},{"Add":""},{"Add":"#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)"},{"Add":""},{"Add":"/* violates C standard, by lying on structure alignment."},{"Add":"Only use if no other choice to achieve best performance on target platform */"},{"Add":"MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }"},{"Add":"MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }"},{"Add":"MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }"},{"Add":"MEM_STATIC size_t MEM_readST(const void* memPtr) { return *(const size_t*) memPtr; }"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }"},{"Add":"MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }"},{"Add":"MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }"},{"Add":""},{"Add":"#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)"},{"Add":""},{"Add":"/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */"},{"Add":"/* currently only defined for gcc and icc */"},{"Add":"#if defined(_MSC_VER) || (defined(__INTEL_COMPILER) && defined(WIN32))"},{"Add":" __pragma( pack(push, 1) )"},{"Add":" typedef struct { U16 v; } unalign16;"},{"Add":" typedef struct { U32 v; } unalign32;"},{"Add":" typedef struct { U64 v; } unalign64;"},{"Add":" typedef struct { size_t v; } unalignArch;"},{"Add":" __pragma( pack(pop) )"},{"Add":"#else"},{"Add":" typedef struct { U16 v; } __attribute__((packed)) unalign16;"},{"Add":" typedef struct { U32 v; } __attribute__((packed)) unalign32;"},{"Add":" typedef struct { U64 v; } __attribute__((packed)) unalign64;"},{"Add":" typedef struct { size_t v; } __attribute__((packed)) unalignArch;"},{"Add":"#endif"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign16*)ptr)->v; }"},{"Add":"MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign32*)ptr)->v; }"},{"Add":"MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign64*)ptr)->v; }"},{"Add":"MEM_STATIC size_t MEM_readST(const void* ptr) { return ((const unalignArch*)ptr)->v; }"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign16*)memPtr)->v = value; }"},{"Add":"MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign32*)memPtr)->v = value; }"},{"Add":"MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign64*)memPtr)->v = value; }"},{"Add":""},{"Add":"#else"},{"Add":""},{"Add":"/* default method, safe and standard."},{"Add":" can sometimes prove slower */"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_read16(const void* memPtr)"},{"Add":"{"},{"Add":" U16 val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_read32(const void* memPtr)"},{"Add":"{"},{"Add":" U32 val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U64 MEM_read64(const void* memPtr)"},{"Add":"{"},{"Add":" U64 val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC size_t MEM_readST(const void* memPtr)"},{"Add":"{"},{"Add":" size_t val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_write16(void* memPtr, U16 value)"},{"Add":"{"},{"Add":" ZSTD_memcpy(memPtr, &value, sizeof(value));"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_write32(void* memPtr, U32 value)"},{"Add":"{"},{"Add":" ZSTD_memcpy(memPtr, &value, sizeof(value));"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_write64(void* memPtr, U64 value)"},{"Add":"{"},{"Add":" ZSTD_memcpy(memPtr, &value, sizeof(value));"},{"Add":"}"},{"Add":""},{"Add":"#endif /* MEM_FORCE_MEMORY_ACCESS */"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_swap32_fallback(U32 in)"},{"Add":"{"},{"Add":" return ((in << 24) & 0xff000000 ) |"},{"Add":" ((in << 8) & 0x00ff0000 ) |"},{"Add":" ((in >> 8) & 0x0000ff00 ) |"},{"Add":" ((in >> 24) & 0x000000ff );"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_swap32(U32 in)"},{"Add":"{"},{"Add":"#if defined(_MSC_VER) /* Visual Studio */"},{"Add":" return _byteswap_ulong(in);"},{"Add":"#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \\"},{"Add":" || (defined(__clang__) && __has_builtin(__builtin_bswap32))"},{"Add":" return __builtin_bswap32(in);"},{"Add":"#else"},{"Add":" return MEM_swap32_fallback(in);"},{"Add":"#endif"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U64 MEM_swap64_fallback(U64 in)"},{"Add":"{"},{"Add":" return ((in << 56) & 0xff00000000000000ULL) |"},{"Add":" ((in << 40) & 0x00ff000000000000ULL) |"},{"Add":" ((in << 24) & 0x0000ff0000000000ULL) |"},{"Add":" ((in << 8) & 0x000000ff00000000ULL) |"},{"Add":" ((in >> 8) & 0x00000000ff000000ULL) |"},{"Add":" ((in >> 24) & 0x0000000000ff0000ULL) |"},{"Add":" ((in >> 40) & 0x000000000000ff00ULL) |"},{"Add":" ((in >> 56) & 0x00000000000000ffULL);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U64 MEM_swap64(U64 in)"},{"Add":"{"},{"Add":"#if defined(_MSC_VER) /* Visual Studio */"},{"Add":" return _byteswap_uint64(in);"},{"Add":"#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \\"},{"Add":" || (defined(__clang__) && __has_builtin(__builtin_bswap64))"},{"Add":" return __builtin_bswap64(in);"},{"Add":"#else"},{"Add":" return MEM_swap64_fallback(in);"},{"Add":"#endif"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC size_t MEM_swapST(size_t in)"},{"Add":"{"},{"Add":" if (MEM_32bits())"},{"Add":" return (size_t)MEM_swap32((U32)in);"},{"Add":" else"},{"Add":" return (size_t)MEM_swap64((U64)in);"},{"Add":"}"},{"Add":""},{"Add":"/*=== Little endian r/w ===*/"},{"Add":""},{"Add":"MEM_STATIC U16 MEM_readLE16(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read16(memPtr);"},{"Add":" else {"},{"Add":" const BYTE* p = (const BYTE*)memPtr;"},{"Add":" return (U16)(p[0] + (p[1]<<8));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian()) {"},{"Add":" MEM_write16(memPtr, val);"},{"Add":" } else {"},{"Add":" BYTE* p = (BYTE*)memPtr;"},{"Add":" p[0] = (BYTE)val;"},{"Add":" p[1] = (BYTE)(val>>8);"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_readLE24(const void* memPtr)"},{"Add":"{"},{"Add":" return (U32)MEM_readLE16(memPtr) + ((U32)(((const BYTE*)memPtr)[2]) << 16);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val)"},{"Add":"{"},{"Add":" MEM_writeLE16(memPtr, (U16)val);"},{"Add":" ((BYTE*)memPtr)[2] = (BYTE)(val>>16);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_readLE32(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read32(memPtr);"},{"Add":" else"},{"Add":" return MEM_swap32(MEM_read32(memPtr));"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" MEM_write32(memPtr, val32);"},{"Add":" else"},{"Add":" MEM_write32(memPtr, MEM_swap32(val32));"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U64 MEM_readLE64(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_read64(memPtr);"},{"Add":" else"},{"Add":" return MEM_swap64(MEM_read64(memPtr));"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" MEM_write64(memPtr, val64);"},{"Add":" else"},{"Add":" MEM_write64(memPtr, MEM_swap64(val64));"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC size_t MEM_readLEST(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_32bits())"},{"Add":" return (size_t)MEM_readLE32(memPtr);"},{"Add":" else"},{"Add":" return (size_t)MEM_readLE64(memPtr);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val)"},{"Add":"{"},{"Add":" if (MEM_32bits())"},{"Add":" MEM_writeLE32(memPtr, (U32)val);"},{"Add":" else"},{"Add":" MEM_writeLE64(memPtr, (U64)val);"},{"Add":"}"},{"Add":""},{"Add":"/*=== Big endian r/w ===*/"},{"Add":""},{"Add":"MEM_STATIC U32 MEM_readBE32(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_swap32(MEM_read32(memPtr));"},{"Add":" else"},{"Add":" return MEM_read32(memPtr);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" MEM_write32(memPtr, MEM_swap32(val32));"},{"Add":" else"},{"Add":" MEM_write32(memPtr, val32);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC U64 MEM_readBE64(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" return MEM_swap64(MEM_read64(memPtr));"},{"Add":" else"},{"Add":" return MEM_read64(memPtr);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64)"},{"Add":"{"},{"Add":" if (MEM_isLittleEndian())"},{"Add":" MEM_write64(memPtr, MEM_swap64(val64));"},{"Add":" else"},{"Add":" MEM_write64(memPtr, val64);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC size_t MEM_readBEST(const void* memPtr)"},{"Add":"{"},{"Add":" if (MEM_32bits())"},{"Add":" return (size_t)MEM_readBE32(memPtr);"},{"Add":" else"},{"Add":" return (size_t)MEM_readBE64(memPtr);"},{"Add":"}"},{"Add":""},{"Add":"MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val)"},{"Add":"{"},{"Add":" if (MEM_32bits())"},{"Add":" MEM_writeBE32(memPtr, (U32)val);"},{"Add":" else"},{"Add":" MEM_writeBE64(memPtr, (U64)val);"},{"Add":"}"},{"Add":""},{"Add":"/* code only tested on 32 and 64 bits systems */"},{"Add":"MEM_STATIC void MEM_check(void) { DEBUG_STATIC_ASSERT((sizeof(size_t)==4) || (sizeof(size_t)==8)); }"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* MEM_H_MODULE */"}]}},{"FileAdd":{"meta":{"basename":"debug.h","metadata":0},"context":[{"change":7,"pos":1}],"contents":[{"Add":"/* ******************************************************************"},{"Add":" * debug"},{"Add":" * Part of FSE library"},{"Add":" * Copyright (c) Yann Collet, Facebook, Inc."},{"Add":" *"},{"Add":" * You can contact the author at :"},{"Add":" * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy"},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":"****************************************************************** */"},{"Add":""},{"Add":""},{"Add":"/*"},{"Add":" * The purpose of this header is to enable debug functions."},{"Add":" * They regroup assert(), DEBUGLOG() and RAWLOG() for run-time,"},{"Add":" * and DEBUG_STATIC_ASSERT() for compile-time."},{"Add":" *"},{"Add":" * By default, DEBUGLEVEL==0, which means run-time debug is disabled."},{"Add":" *"},{"Add":" * Level 1 enables assert() only."},{"Add":" * Starting level 2, traces can be generated and pushed to stderr."},{"Add":" * The higher the level, the more verbose the traces."},{"Add":" *"},{"Add":" * It's possible to dynamically adjust level using variable g_debug_level,"},{"Add":" * which is only declared if DEBUGLEVEL>=2,"},{"Add":" * and is a global variable, not multi-thread protected (use with care)"},{"Add":" */"},{"Add":""},{"Add":"#ifndef DEBUG_H_12987983217"},{"Add":"#define DEBUG_H_12987983217"},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* static assert is triggered at compile time, leaving no runtime artefact."},{"Add":" * static assert only works with compile-time constants."},{"Add":" * Also, this variant can only be used inside a function. */"},{"Add":"#define DEBUG_STATIC_ASSERT(c) (void)sizeof(char[(c) ? 1 : -1])"},{"Add":""},{"Add":""},{"Add":"/* DEBUGLEVEL is expected to be defined externally,"},{"Add":" * typically through compiler command line."},{"Add":" * Value must be a number. */"},{"Add":"#ifndef DEBUGLEVEL"},{"Add":"# define DEBUGLEVEL 0"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* recommended values for DEBUGLEVEL :"},{"Add":" * 0 : release mode, no debug, all run-time checks disabled"},{"Add":" * 1 : enables assert() only, no display"},{"Add":" * 2 : reserved, for currently active debug path"},{"Add":" * 3 : events once per object lifetime (CCtx, CDict, etc.)"},{"Add":" * 4 : events once per frame"},{"Add":" * 5 : events once per block"},{"Add":" * 6 : events once per sequence (verbose)"},{"Add":" * 7+: events at every position (*very* verbose)"},{"Add":" *"},{"Add":" * It's generally inconvenient to output traces > 5."},{"Add":" * In which case, it's possible to selectively trigger high verbosity levels"},{"Add":" * by modifying g_debug_level."},{"Add":" */"},{"Add":""},{"Add":"#if (DEBUGLEVEL>=1)"},{"Add":"# define ZSTD_DEPS_NEED_ASSERT"},{"Add":"# include \"zstd_deps.h\""},{"Add":"#else"},{"Add":"# ifndef assert /* assert may be already defined, due to prior #include */"},{"Add":"# define assert(condition) ((void)0) /* disable assert (default) */"},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":"#if (DEBUGLEVEL>=2)"},{"Add":"# define ZSTD_DEPS_NEED_IO"},{"Add":"# include \"zstd_deps.h\""},{"Add":"extern int g_debuglevel; /* the variable is only declared,"},{"Add":" it actually lives in debug.c,"},{"Add":" and is shared by the whole process."},{"Add":" It's not thread-safe."},{"Add":" It's useful when enabling very verbose levels"},{"Add":" on selective conditions (such as position in src) */"},{"Add":""},{"Add":"# define RAWLOG(l, ...) { \\"},{"Add":" if (l<=g_debuglevel) { \\"},{"Add":" ZSTD_DEBUG_PRINT(__VA_ARGS__); \\"},{"Add":" } }"},{"Add":"# define DEBUGLOG(l, ...) { \\"},{"Add":" if (l<=g_debuglevel) { \\"},{"Add":" ZSTD_DEBUG_PRINT(__FILE__ \": \" __VA_ARGS__); \\"},{"Add":" ZSTD_DEBUG_PRINT(\" \\n\"); \\"},{"Add":" } }"},{"Add":"#else"},{"Add":"# define RAWLOG(l, ...) {} /* disabled */"},{"Add":"# define DEBUGLOG(l, ...) {} /* disabled */"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"#if defined (__cplusplus)"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* DEBUG_H_12987983217 */"}]}},{"FileAdd":{"meta":{"basename":"compiler.h","metadata":0},"context":[{"change":7,"pos":1}],"contents":[{"Add":"/*"},{"Add":" * Copyright (c) Yann Collet, Facebook, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This source code is licensed under both the BSD-style license (found in the"},{"Add":" * LICENSE file in the root directory of this source tree) and the GPLv2 (found"},{"Add":" * in the COPYING file in the root directory of this source tree)."},{"Add":" * You may select, at your option, one of the above-listed licenses."},{"Add":" */"},{"Add":""},{"Add":"#ifndef ZSTD_COMPILER_H"},{"Add":"#define ZSTD_COMPILER_H"},{"Add":""},{"Add":"#include \"portability_macros.h\""},{"Add":""},{"Add":"/*-*******************************************************"},{"Add":"* Compiler specifics"},{"Add":"*********************************************************/"},{"Add":"/* force inlining */"},{"Add":""},{"Add":"#if !defined(ZSTD_NO_INLINE)"},{"Add":"#if (defined(__GNUC__) && !defined(__STRICT_ANSI__)) || defined(__cplusplus) || defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */"},{"Add":"# define INLINE_KEYWORD inline"},{"Add":"#else"},{"Add":"# define INLINE_KEYWORD"},{"Add":"#endif"},{"Add":""},{"Add":"#if defined(__GNUC__) || defined(__ICCARM__)"},{"Add":"# define FORCE_INLINE_ATTR __attribute__((always_inline))"},{"Add":"#elif defined(_MSC_VER)"},{"Add":"# define FORCE_INLINE_ATTR __forceinline"},{"Add":"#else"},{"Add":"# define FORCE_INLINE_ATTR"},{"Add":"#endif"},{"Add":""},{"Add":"#else"},{"Add":""},{"Add":"#define INLINE_KEYWORD"},{"Add":"#define FORCE_INLINE_ATTR"},{"Add":""},{"Add":"#endif"},{"Add":""},{"Add":"/**"},{"Add":" On MSVC qsort requires that functions passed into it use the __cdecl calling conversion(CC)."},{"Add":" This explicitly marks such functions as __cdecl so that the code will still compile"},{"Add":" if a CC other than __cdecl has been made the default."},{"Add":"*/"},{"Add":"#if defined(_MSC_VER)"},{"Add":"# define WIN_CDECL __cdecl"},{"Add":"#else"},{"Add":"# define WIN_CDECL"},{"Add":"#endif"},{"Add":""},{"Add":"/**"},{"Add":" * FORCE_INLINE_TEMPLATE is used to define C \"templates\", which take constant"},{"Add":" * parameters. They must be inlined for the compiler to eliminate the constant"},{"Add":" * branches."},{"Add":" */"},{"Add":"#define FORCE_INLINE_TEMPLATE static INLINE_KEYWORD FORCE_INLINE_ATTR"},{"Add":"/**"},{"Add":" * HINT_INLINE is used to help the compiler generate better code. It is *not*"},{"Add":" * used for \"templates\", so it can be tweaked based on the compilers"},{"Add":" * performance."},{"Add":" *"},{"Add":" * gcc-4.8 and gcc-4.9 have been shown to benefit from leaving off the"},{"Add":" * always_inline attribute."},{"Add":" *"},{"Add":" * clang up to 5.0.0 (trunk) benefit tremendously from the always_inline"},{"Add":" * attribute."},{"Add":" */"},{"Add":"#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 8 && __GNUC__ < 5"},{"Add":"# define HINT_INLINE static INLINE_KEYWORD"},{"Add":"#else"},{"Add":"# define HINT_INLINE static INLINE_KEYWORD FORCE_INLINE_ATTR"},{"Add":"#endif"},{"Add":""},{"Add":"/* UNUSED_ATTR tells the compiler it is okay if the function is unused. */"},{"Add":"#if defined(__GNUC__)"},{"Add":"# define UNUSED_ATTR __attribute__((unused))"},{"Add":"#else"},{"Add":"# define UNUSED_ATTR"},{"Add":"#endif"},{"Add":""},{"Add":"/* force no inlining */"},{"Add":"#ifdef _MSC_VER"},{"Add":"# define FORCE_NOINLINE static __declspec(noinline)"},{"Add":"#else"},{"Add":"# if defined(__GNUC__) || defined(__ICCARM__)"},{"Add":"# define FORCE_NOINLINE static __attribute__((__noinline__))"},{"Add":"# else"},{"Add":"# define FORCE_NOINLINE static"},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"/* target attribute */"},{"Add":"#if defined(__GNUC__) || defined(__ICCARM__)"},{"Add":"# define TARGET_ATTRIBUTE(target) __attribute__((__target__(target)))"},{"Add":"#else"},{"Add":"# define TARGET_ATTRIBUTE(target)"},{"Add":"#endif"},{"Add":""},{"Add":"/* Target attribute for BMI2 dynamic dispatch."},{"Add":" * Enable lzcnt, bmi, and bmi2."},{"Add":" * We test for bmi1 & bmi2. lzcnt is included in bmi1."},{"Add":" */"},{"Add":"#define BMI2_TARGET_ATTRIBUTE TARGET_ATTRIBUTE(\"lzcnt,bmi,bmi2\")"},{"Add":""},{"Add":"/* prefetch"},{"Add":" * can be disabled, by declaring NO_PREFETCH build macro */"},{"Add":"#if defined(NO_PREFETCH)"},{"Add":"# define PREFETCH_L1(ptr) (void)(ptr) /* disabled */"},{"Add":"# define PREFETCH_L2(ptr) (void)(ptr) /* disabled */"},{"Add":"#else"},{"Add":"# if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_I86)) /* _mm_prefetch() is not defined outside of x86/x64 */"},{"Add":"# include /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */"},{"Add":"# define PREFETCH_L1(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T0)"},{"Add":"# define PREFETCH_L2(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T1)"},{"Add":"# elif defined(__GNUC__) && ( (__GNUC__ >= 4) || ( (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1) ) )"},{"Add":"# define PREFETCH_L1(ptr) __builtin_prefetch((ptr), 0 /* rw==read */, 3 /* locality */)"},{"Add":"# define PREFETCH_L2(ptr) __builtin_prefetch((ptr), 0 /* rw==read */, 2 /* locality */)"},{"Add":"# elif defined(__aarch64__)"},{"Add":"# define PREFETCH_L1(ptr) __asm__ __volatile__(\"prfm pldl1keep, %0\" ::\"Q\"(*(ptr)))"},{"Add":"# define PREFETCH_L2(ptr) __asm__ __volatile__(\"prfm pldl2keep, %0\" ::\"Q\"(*(ptr)))"},{"Add":"# else"},{"Add":"# define PREFETCH_L1(ptr) (void)(ptr) /* disabled */"},{"Add":"# define PREFETCH_L2(ptr) (void)(ptr) /* disabled */"},{"Add":"# endif"},{"Add":"#endif /* NO_PREFETCH */"},{"Add":""},{"Add":"#define CACHELINE_SIZE 64"},{"Add":""},{"Add":"#define PREFETCH_AREA(p, s) { \\"},{"Add":" const char* const _ptr = (const char*)(p); \\"},{"Add":" size_t const _size = (size_t)(s); \\"},{"Add":" size_t _pos; \\"},{"Add":" for (_pos=0; _pos<_size; _pos+=CACHELINE_SIZE) { \\"},{"Add":" PREFETCH_L2(_ptr + _pos); \\"},{"Add":" } \\"},{"Add":"}"},{"Add":""},{"Add":"/* vectorization"},{"Add":" * older GCC (pre gcc-4.3 picked as the cutoff) uses a different syntax,"},{"Add":" * and some compilers, like Intel ICC and MCST LCC, do not support it at all. */"},{"Add":"#if !defined(__INTEL_COMPILER) && !defined(__clang__) && defined(__GNUC__) && !defined(__LCC__)"},{"Add":"# if (__GNUC__ == 4 && __GNUC_MINOR__ > 3) || (__GNUC__ >= 5)"},{"Add":"# define DONT_VECTORIZE __attribute__((optimize(\"no-tree-vectorize\")))"},{"Add":"# else"},{"Add":"# define DONT_VECTORIZE _Pragma(\"GCC optimize(\\\"no-tree-vectorize\\\")\")"},{"Add":"# endif"},{"Add":"#else"},{"Add":"# define DONT_VECTORIZE"},{"Add":"#endif"},{"Add":""},{"Add":"/* Tell the compiler that a branch is likely or unlikely."},{"Add":" * Only use these macros if it causes the compiler to generate better code."},{"Add":" * If you can remove a LIKELY/UNLIKELY annotation without speed changes in gcc"},{"Add":" * and clang, please do."},{"Add":" */"},{"Add":"#if defined(__GNUC__)"},{"Add":"#define LIKELY(x) (__builtin_expect((x), 1))"},{"Add":"#define UNLIKELY(x) (__builtin_expect((x), 0))"},{"Add":"#else"},{"Add":"#define LIKELY(x) (x)"},{"Add":"#define UNLIKELY(x) (x)"},{"Add":"#endif"},{"Add":""},{"Add":"/* disable warnings */"},{"Add":"#ifdef _MSC_VER /* Visual Studio */"},{"Add":"# include /* For Visual 2005 */"},{"Add":"# pragma warning(disable : 4100) /* disable: C4100: unreferenced formal parameter */"},{"Add":"# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */"},{"Add":"# pragma warning(disable : 4204) /* disable: C4204: non-constant aggregate initializer */"},{"Add":"# pragma warning(disable : 4214) /* disable: C4214: non-int bitfields */"},{"Add":"# pragma warning(disable : 4324) /* disable: C4324: padded structure */"},{"Add":"#endif"},{"Add":""},{"Add":"/*Like DYNAMIC_BMI2 but for compile time determination of BMI2 support*/"},{"Add":"#ifndef STATIC_BMI2"},{"Add":"# if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_I86))"},{"Add":"# ifdef __AVX2__ //MSVC does not have a BMI2 specific flag, but every CPU that supports AVX2 also supports BMI2"},{"Add":"# define STATIC_BMI2 1"},{"Add":"# endif"},{"Add":"# elif defined(__BMI2__) && defined(__x86_64__) && defined(__GNUC__)"},{"Add":"# define STATIC_BMI2 1"},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":"#ifndef STATIC_BMI2"},{"Add":" #define STATIC_BMI2 0"},{"Add":"#endif"},{"Add":""},{"Add":"/* compile time determination of SIMD support */"},{"Add":"#if !defined(ZSTD_NO_INTRINSICS)"},{"Add":"# if defined(__SSE2__) || defined(_M_AMD64) || (defined (_M_IX86) && defined(_M_IX86_FP) && (_M_IX86_FP >= 2))"},{"Add":"# define ZSTD_ARCH_X86_SSE2"},{"Add":"# endif"},{"Add":"# if defined(__ARM_NEON) || defined(_M_ARM64)"},{"Add":"# define ZSTD_ARCH_ARM_NEON"},{"Add":"# endif"},{"Add":"#"},{"Add":"# if defined(ZSTD_ARCH_X86_SSE2)"},{"Add":"# include "},{"Add":"# elif defined(ZSTD_ARCH_ARM_NEON)"},{"Add":"# include "},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":"/* C-language Attributes are added in C23. */"},{"Add":"#if defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201710L) && defined(__has_c_attribute)"},{"Add":"# define ZSTD_HAS_C_ATTRIBUTE(x) __has_c_attribute(x)"},{"Add":"#else"},{"Add":"# define ZSTD_HAS_C_ATTRIBUTE(x) 0"},{"Add":"#endif"},{"Add":""},{"Add":"/* Only use C++ attributes in C++. Some compilers report support for C++"},{"Add":" * attributes when compiling with C."},{"Add":" */"},{"Add":"#if defined(__cplusplus) && defined(__has_cpp_attribute)"},{"Add":"# define ZSTD_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)"},{"Add":"#else"},{"Add":"# define ZSTD_HAS_CPP_ATTRIBUTE(x) 0"},{"Add":"#endif"},{"Add":""},{"Add":"/* Define ZSTD_FALLTHROUGH macro for annotating switch case with the 'fallthrough' attribute."},{"Add":" * - C23: https://en.cppreference.com/w/c/language/attributes/fallthrough"},{"Add":" * - CPP17: https://en.cppreference.com/w/cpp/language/attributes/fallthrough"},{"Add":" * - Else: __attribute__((__fallthrough__))"},{"Add":" */"},{"Add":"#ifndef ZSTD_FALLTHROUGH"},{"Add":"# if ZSTD_HAS_C_ATTRIBUTE(fallthrough)"},{"Add":"# define ZSTD_FALLTHROUGH [[fallthrough]]"},{"Add":"# elif ZSTD_HAS_CPP_ATTRIBUTE(fallthrough)"},{"Add":"# define ZSTD_FALLTHROUGH [[fallthrough]]"},{"Add":"# elif __has_attribute(__fallthrough__)"},{"Add":"/* Leading semicolon is to satisfy gcc-11 with -pedantic. Without the semicolon"},{"Add":" * gcc complains about: a label can only be part of a statement and a declaration is not a statement."},{"Add":" */"},{"Add":"# define ZSTD_FALLTHROUGH ; __attribute__((__fallthrough__))"},{"Add":"# else"},{"Add":"# define ZSTD_FALLTHROUGH"},{"Add":"# endif"},{"Add":"#endif"},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* Alignment check"},{"Add":"*****************************************************************/"},{"Add":""},{"Add":"/* this test was initially positioned in mem.h,"},{"Add":" * but this file is removed (or replaced) for linux kernel"},{"Add":" * so it's now hosted in compiler.h,"},{"Add":" * which remains valid for both user & kernel spaces."},{"Add":" */"},{"Add":""},{"Add":"#ifndef ZSTD_ALIGNOF"},{"Add":"# if defined(__GNUC__) || defined(_MSC_VER)"},{"Add":"/* covers gcc, clang & MSVC */"},{"Add":"/* note : this section must come first, before C11,"},{"Add":" * due to a limitation in the kernel source generator */"},{"Add":"# define ZSTD_ALIGNOF(T) __alignof(T)"},{"Add":""},{"Add":"# elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)"},{"Add":"/* C11 support */"},{"Add":"# include "},{"Add":"# define ZSTD_ALIGNOF(T) alignof(T)"},{"Add":""},{"Add":"# else"},{"Add":"/* No known support for alignof() - imperfect backup */"},{"Add":"# define ZSTD_ALIGNOF(T) (sizeof(void*) < sizeof(T) ? sizeof(void*) : sizeof(T))"},{"Add":""},{"Add":"# endif"},{"Add":"#endif /* ZSTD_ALIGNOF */"},{"Add":""},{"Add":"/*-**************************************************************"},{"Add":"* Sanitizer"},{"Add":"*****************************************************************/"},{"Add":""},{"Add":"#if ZSTD_MEMORY_SANITIZER"},{"Add":"/* Not all platforms that support msan provide sanitizers/msan_interface.h."},{"Add":" * We therefore declare the functions we need ourselves, rather than trying to"},{"Add":" * include the header file... */"},{"Add":"#include /* size_t */"},{"Add":"#define ZSTD_DEPS_NEED_STDINT"},{"Add":"#include \"zstd_deps.h\" /* intptr_t */"},{"Add":""},{"Add":"/* Make memory region fully initialized (without changing its contents). */"},{"Add":"void __msan_unpoison(const volatile void *a, size_t size);"},{"Add":""},{"Add":"/* Make memory region fully uninitialized (without changing its contents)."},{"Add":" This is a legacy interface that does not update origin information. Use"},{"Add":" __msan_allocated_memory() instead. */"},{"Add":"void __msan_poison(const volatile void *a, size_t size);"},{"Add":""},{"Add":"/* Returns the offset of the first (at least partially) poisoned byte in the"},{"Add":" memory range, or -1 if the whole range is good. */"},{"Add":"intptr_t __msan_test_shadow(const volatile void *x, size_t size);"},{"Add":"#endif"},{"Add":""},{"Add":"#if ZSTD_ADDRESS_SANITIZER"},{"Add":"/* Not all platforms that support asan provide sanitizers/asan_interface.h."},{"Add":" * We therefore declare the functions we need ourselves, rather than trying to"},{"Add":" * include the header file... */"},{"Add":"#include /* size_t */"},{"Add":""},{"Add":"/**"},{"Add":" * Marks a memory region ([addr, addr+size)) as unaddressable."},{"Add":" *"},{"Add":" * This memory must be previously allocated by your program. Instrumented"},{"Add":" * code is forbidden from accessing addresses in this region until it is"},{"Add":" * unpoisoned. This function is not guaranteed to poison the entire region -"},{"Add":" * it could poison only a subregion of [addr, addr+size) due to ASan"},{"Add":" * alignment restrictions."},{"Add":" *"},{"Add":" * \\note This function is not thread-safe because no two threads can poison or"},{"Add":" * unpoison memory in the same memory region simultaneously."},{"Add":" *"},{"Add":" * \\param addr Start of memory region."},{"Add":" * \\param size Size of memory region. */"},{"Add":"void __asan_poison_memory_region(void const volatile *addr, size_t size);"},{"Add":""},{"Add":"/**"},{"Add":" * Marks a memory region ([addr, addr+size)) as addressable."},{"Add":" *"},{"Add":" * This memory must be previously allocated by your program. Accessing"},{"Add":" * addresses in this region is allowed until this region is poisoned again."},{"Add":" * This function could unpoison a super-region of [addr, addr+size) due"},{"Add":" * to ASan alignment restrictions."},{"Add":" *"},{"Add":" * \\note This function is not thread-safe because no two threads can"},{"Add":" * poison or unpoison memory in the same memory region simultaneously."},{"Add":" *"},{"Add":" * \\param addr Start of memory region."},{"Add":" * \\param size Size of memory region. */"},{"Add":"void __asan_unpoison_memory_region(void const volatile *addr, size_t size);"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* ZSTD_COMPILER_H */"}]}},{"Replacement":{"inode":{"change":4,"pos":458},"path":"Makefile","line":7,"ins":{"up_context":[{"change":4,"pos":571}],"down_context":[{"change":4,"pos":606}],"flag":"BLOCK","start":78578,"end":78779,"inode":{"change":4,"pos":458}},"del":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":4,"pos":571},"to":{"change":4,"start":571,"end":579},"introduced_by":4},{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":4,"pos":579},"to":{"change":3,"start":0,"end":50},"introduced_by":3},{"previous":"","flag":"DELETED","from":{"change":3,"pos":50},"to":{"change":4,"start":594,"end":606},"introduced_by":3},{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":4,"pos":594},"to":{"change":4,"start":594,"end":606},"introduced_by":4}],"inode":{"change":4,"pos":458}},"ins_contents":[{"Add":"CC ?= cc"},{"Add":"CFLAGS ?= -Wall -D_POSIX_C_SOURCE=200809L -std=c99"},{"Add":"PKG_CONFIG ?= pkg-config"},{"Add":"RM ?= rm -rf"},{"Add":""},{"Add":"ZSTD_LIB = $(shell ${PKG_CONFIG} --libs libzstd)"},{"Add":"XXHASH_LIB = $(shell ${PKG_CONFIG} --libs libxxhash)"}],"del_contents":[{"Del":"CC = cc\n"},{"Del":"CFLAGS = -Wall -D_POSIX_C_SOURCE=200809L -std=c99\n"},{"Del":"RM = rm -rf\n"}]}},{"Edit":{"inode":{"change":4,"pos":458},"path":"Makefile","line":18,"atom":{"NewVertex":{"up_context":[{"change":2,"pos":3272}],"down_context":[{"change":4,"pos":620}],"flag":"BLOCK","start":78780,"end":78838,"inode":{"change":4,"pos":458}}},"contents":[{"Add":"OBJS += zstdseek_compress.o"},{"Add":"OBJS += zstdseek_decompress.o"}]}},{"Replacement":{"inode":{"change":4,"pos":458},"path":"Makefile","line":22,"ins":{"up_context":[{"change":4,"pos":634}],"down_context":[{"change":4,"pos":676}],"flag":"BLOCK","start":78839,"end":78907,"inode":{"change":4,"pos":458}},"del":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":4,"pos":634},"to":{"change":4,"start":634,"end":676},"introduced_by":4}],"inode":{"change":4,"pos":458}},"ins_contents":[{"Add":"\t$(CC) $(CFLAGS) -o $@ $(LDFLAGS) $(OBJS) $(ZSTD_LIB) $(XXHASH_LIB)"}],"del_contents":[{"Del":"\t$(CC) $(CFLAGS) -o $@ $(LDFLAGS) $(OBJS)\n"}]}}],"owner":"laumann","repo":"ani","token":"+obAjz1WfiLO/OjSt7JlLRVFdpVfJf4OT/xL6tqk7as=","login":null}

…

Dependencies

Change contents