代码拉取完成，页面将自动刷新
同步操作将从 src-openEuler/gcc 强制同步，此操作会覆盖自 Fork 仓库以来所做的任何修改，且无法恢复！！！
确定后同步将在后台操作，完成时将刷新页面，请耐心等待。
From 4c262af8e178ac7c81b32be5b159b4d09a5841c9 Mon Sep 17 00:00:00 2001
From: Diachkov Ilia <diachkov.ilia1@huawei-partners.com>
Date: Fri, 8 Mar 2024 07:07:50 +0800
Subject: [PATCH 1/2] Port fixes for IPA prefetch to GCC 12
---
gcc/ipa-devirt.cc | 9 +-
gcc/ipa-prefetch.cc | 174 +-
gcc/ipa-sra.cc | 7 +
gcc/params.opt | 4 +-
gcc/testsuite/gcc.dg/completion-1.c | 1 +
gcc/testsuite/gcc.dg/ipa/ipa-prefetch-xz.c | 1843 ++++++++++++++++++++
6 files changed, 1974 insertions(+), 64 deletions(-)
create mode 100644 gcc/testsuite/gcc.dg/ipa/ipa-prefetch-xz.c
diff --git a/gcc/ipa-devirt.cc b/gcc/ipa-devirt.cc
index dd3562d56..dd000b401 100644
--- a/gcc/ipa-devirt.cc
+++ b/gcc/ipa-devirt.cc
@@ -5029,9 +5029,12 @@ analyze_assign_stmt (gimple *stmt)
}
else
{
- fprintf (dump_file, "\nUnsupported rhs type %s in assign stmt: ",
- get_tree_code_name (TREE_CODE (rhs)));
- print_gimple_stmt (dump_file, stmt, 0);
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "\nUnsupported rhs type %s in assign stmt: ",
+ get_tree_code_name (TREE_CODE (rhs)));
+ print_gimple_stmt (dump_file, stmt, 0);
+ }
gcc_unreachable ();
}
}
diff --git a/gcc/ipa-prefetch.cc b/gcc/ipa-prefetch.cc
index aeea51105..9537e4835 100644
--- a/gcc/ipa-prefetch.cc
+++ b/gcc/ipa-prefetch.cc
@@ -167,6 +167,7 @@ analyse_cgraph ()
}
/* TODO: maybe remove loop info here. */
+ n->get_body ();
push_cfun (DECL_STRUCT_FUNCTION (n->decl));
calculate_dominance_info (CDI_DOMINATORS);
loop_optimizer_init (LOOPS_NORMAL);
@@ -942,6 +943,9 @@ compare_memrefs (memref_t* mr, memref_t* mr2)
(*mr_candidate_map)[mr] = mr2;
return;
}
+ /* Probably we shouldn't leave nulls in the map. */
+ if ((*mr_candidate_map)[mr] == NULL)
+ return;
/* TODO: support analysis with incrementation of different fields. */
if ((*mr_candidate_map)[mr]->offset != mr2->offset)
{
@@ -1090,6 +1094,15 @@ analyse_loops ()
memref_t *mr = it->first, *mr2 = it->second;
if (mr2 == NULL || !(*fmrs_map)[fn]->count (mr))
continue;
+ /* For now optimize only MRs that mem is MEM_REF.
+ TODO: support other MR types. */
+ if (TREE_CODE (mr->mem) != MEM_REF)
+ {
+ if (dump_file)
+ fprintf (dump_file, "Skip MR %d: unsupported tree code = %s\n",
+ mr->mr_id, get_tree_code_name (TREE_CODE (mr->mem)));
+ continue;
+ }
if (!optimize_mrs_map->count (fn))
(*optimize_mrs_map)[fn] = new memref_set;
(*optimize_mrs_map)[fn]->insert (mr);
@@ -1102,7 +1115,7 @@ analyse_loops ()
it != (*optimize_mrs_map)[fn]->end (); it++)
{
memref_t *mr = *it, *mr2 = (*mr_candidate_map)[mr];
- fprintf (dump_file, "MRs %d,%d with incremental offset ",
+ fprintf (dump_file, "MRs %d, %d with incremental offset ",
mr->mr_id, mr2->mr_id);
print_generic_expr (dump_file, mr2->offset);
fprintf (dump_file, "\n");
@@ -1435,6 +1448,52 @@ remap_gimple_op_r (tree *tp, int *walk_subtrees, void *data)
return NULL_TREE;
}
+/* Copy stmt and remap its operands. */
+
+static gimple *
+gimple_copy_and_remap (gimple *stmt)
+{
+ gimple *copy = gimple_copy (stmt);
+ gcc_checking_assert (!is_gimple_debug (copy));
+
+ /* Remap all the operands in COPY. */
+ struct walk_stmt_info wi;
+ memset (&wi, 0, sizeof (wi));
+ wi.info = copy;
+ walk_gimple_op (copy, remap_gimple_op_r, &wi);
+ if (dump_file)
+ {
+ fprintf (dump_file, "Stmt copy after remap:\n");
+ print_gimple_stmt (dump_file, copy, 0);
+ }
+ return copy;
+}
+
+/* Copy and remap stmts listed in MR in reverse order to last_idx, skipping
+ processed ones. Insert new stmts to the sequence. */
+
+static gimple *
+gimple_copy_and_remap_memref_stmts (memref_t *mr, gimple_seq &stmts,
+ int last_idx, stmt_set &processed)
+{
+ gimple *last_stmt = NULL;
+ for (int i = mr->stmts.length () - 1; i >= last_idx ; i--)
+ {
+ if (processed.count (mr->stmts[i]))
+ continue;
+ processed.insert (mr->stmts[i]);
+ if (dump_file)
+ {
+ fprintf (dump_file, "Copy stmt %d from used MR (%d):\n",
+ i, mr->mr_id);
+ print_gimple_stmt (dump_file, mr->stmts[i], 0);
+ }
+ last_stmt = gimple_copy_and_remap (mr->stmts[i]);
+ gimple_seq_add_stmt (&stmts, last_stmt);
+ }
+ return last_stmt;
+}
+
static void
create_cgraph_edge (cgraph_node *n, gimple *stmt)
{
@@ -1490,6 +1549,13 @@ optimize_function (cgraph_node *n, function *fn)
"Skip the case.\n");
return 0;
}
+ if (!tree_fits_shwi_p (inc_mr->step))
+ {
+ if (dump_file)
+ fprintf (dump_file, "Cannot represent incremental MR's step as "
+ "integer. Skip the case.\n");
+ return 0;
+ }
if (dump_file && !used_mrs.empty ())
print_mrs_ids (used_mrs, "Common list of used mrs:\n");
@@ -1539,16 +1605,44 @@ optimize_function (cgraph_node *n, function *fn)
return 0;
}
else if (dump_file)
- fprintf (dump_file, "Dominator bb %d for MRs\n", dom_bb->index);
+ {
+ fprintf (dump_file, "Dominator bb %d for MRs:\n", dom_bb->index);
+ gimple_dump_bb (dump_file, dom_bb, 0, dump_flags);
+ fprintf (dump_file, "\n");
+ }
- split_block (dom_bb, (gimple *) NULL);
+ /* Try to find comp_mr's stmt in the dominator bb. */
+ gimple *last_used = NULL;
+ for (gimple_stmt_iterator si = gsi_last_bb (dom_bb); !gsi_end_p (si);
+ gsi_prev (&si))
+ if (comp_mr->stmts[0] == gsi_stmt (si))
+ {
+ last_used = gsi_stmt (si);
+ if (dump_file)
+ {
+ fprintf (dump_file, "Last used stmt in dominator bb:\n");
+ print_gimple_stmt (dump_file, last_used, 0);
+ }
+ break;
+ }
+
+ split_block (dom_bb, last_used);
gimple_stmt_iterator gsi = gsi_last_bb (dom_bb);
/* Create new inc var. Insert new_var = old_var + step * factor. */
decl_map = new tree_map;
gcc_assert (comp_mr->stmts[0] && gimple_assign_single_p (comp_mr->stmts[0]));
tree inc_var = gimple_assign_lhs (comp_mr->stmts[0]);
+ /* If old_var definition dominates the current use, just use it, otherwise
+ evaluate it just before new inc var evaluation. */
gimple_seq stmts = NULL;
+ stmt_set processed_stmts;
+ if (!dominated_by_p (CDI_DOMINATORS, dom_bb, gimple_bb (comp_mr->stmts[0])))
+ {
+ gimple *tmp = gimple_copy_and_remap_memref_stmts (comp_mr, stmts, 0,
+ processed_stmts);
+ inc_var = gimple_assign_lhs (tmp);
+ }
tree var_type = TREE_TYPE (inc_var);
enum tree_code inc_code;
if (TREE_CODE (var_type) == POINTER_TYPE)
@@ -1556,52 +1650,28 @@ optimize_function (cgraph_node *n, function *fn)
else
inc_code = PLUS_EXPR;
tree step = inc_mr->step;
- unsigned dist_val = tree_to_uhwi (step) * param_ipa_prefetch_distance_factor;
+ HOST_WIDE_INT dist_val = tree_to_shwi (step)
+ * param_ipa_prefetch_distance_factor;
tree dist = build_int_cst (TREE_TYPE (step), dist_val);
tree new_inc_var = gimple_build (&stmts, inc_code, var_type, inc_var, dist);
(*decl_map)[inc_var] = new_inc_var;
+ if (dump_file)
+ {
+ fprintf (dump_file, "New distance value: %ld, new inc var: ", dist_val);
+ print_generic_expr (dump_file, new_inc_var);
+ fprintf (dump_file, "\n");
+ }
/* Create other new vars. Insert new stmts. */
- struct walk_stmt_info wi;
- stmt_set processed_stmts;
- memref_tree_map mr_new_trees;
for (memref_set::const_iterator it = used_mrs.begin ();
it != used_mrs.end (); it++)
{
memref_t *mr = *it;
- gimple *last_stmt = NULL;
if (mr == comp_mr)
continue;
- for (int i = mr->stmts.length () - 1; i >= 0 ; i--)
- {
- if (processed_stmts.count (mr->stmts[i]))
- continue;
- processed_stmts.insert (mr->stmts[i]);
- if (dump_file)
- {
- fprintf (dump_file, "Copy stmt %d from used MR (%d):\n",
- i, mr->mr_id);
- print_gimple_stmt (dump_file, mr->stmts[i], 0);
- }
- /* Create a new copy of STMT and duplicate STMT's virtual
- operands. */
- gimple *copy = gimple_copy (mr->stmts[i]);
- gcc_checking_assert (!is_gimple_debug (copy));
-
- /* Remap all the operands in COPY. */
- memset (&wi, 0, sizeof (wi));
- last_stmt = copy;
- wi.info = copy;
- walk_gimple_op (copy, remap_gimple_op_r, &wi);
- if (dump_file)
- {
- fprintf (dump_file, "Stmt %d after remap:\n",i);
- print_gimple_stmt (dump_file, copy, 0);
- }
- gimple_seq_add_stmt (&stmts, copy);
- }
+ gimple *last_stmt = gimple_copy_and_remap_memref_stmts (mr, stmts, 0,
+ processed_stmts);
gcc_assert (last_stmt);
- mr_new_trees[mr] = gimple_assign_lhs (last_stmt);
if (dump_file)
{
fprintf (dump_file, "MR (%d) new mem: ", mr->mr_id);
@@ -1637,29 +1707,9 @@ optimize_function (cgraph_node *n, function *fn)
memref_t *mr = vmrs[j];
/* Don't need to copy the last stmt, since we insert prefetch insn
instead of it. */
- for (int i = mr->stmts.length () - 1; i >= 1 ; i--)
- {
- if (processed_stmts.count (mr->stmts[i]))
- continue;
- processed_stmts.insert (mr->stmts[i]);
-
- gimple *copy = gimple_copy (mr->stmts[i]);
- gcc_checking_assert (!is_gimple_debug (copy));
-
- /* Remap all the operands in COPY. */
- memset (&wi, 0, sizeof (wi));
- wi.info = copy;
- walk_gimple_op (copy, remap_gimple_op_r, &wi);
- if (dump_file)
- {
- fprintf (dump_file, "Stmt %d after remap:\n",i);
- print_gimple_stmt (dump_file, copy, 0);
- }
- gimple_seq_add_stmt (&stmts, copy);
- }
+ gimple_copy_and_remap_memref_stmts (mr, stmts, 1, processed_stmts);
gimple *last_stmt = mr->stmts[0];
gcc_assert (last_stmt);
- mr_new_trees[mr] = gimple_assign_lhs (last_stmt);
tree write_p = mr->is_store ? integer_one_node : integer_zero_node;
tree addr = get_mem_ref_address_ssa_name (mr->mem, NULL_TREE);
if (decl_map->count (addr))
@@ -1668,6 +1718,11 @@ optimize_function (cgraph_node *n, function *fn)
3, addr, write_p, local);
pcalls.safe_push (last_stmt);
gimple_seq_add_stmt (&stmts, last_stmt);
+ if (dump_file)
+ {
+ fprintf (dump_file, "Insert %d prefetch stmt:\n", j);
+ print_gimple_stmt (dump_file, last_stmt, 0);
+ }
}
gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT);
@@ -1677,6 +1732,7 @@ optimize_function (cgraph_node *n, function *fn)
for (unsigned i = 0; i < pcalls.length (); i++)
create_cgraph_edge (n, pcalls[i]);
ipa_update_overall_fn_summary (n);
+ renumber_gimple_stmt_uids (DECL_STRUCT_FUNCTION (n->decl));
return 1;
}
@@ -1806,7 +1862,7 @@ pass_ipa_prefetch::gate (function *)
/* Don't bother doing anything if the program has errors. */
&& !seen_error ()
&& flag_lto_partition == LTO_PARTITION_ONE
- /* Only enable struct optimizations in lto or whole_program. */
+ /* Only enable prefetch optimizations in lto or whole_program. */
&& (in_lto_p || flag_whole_program));
}
diff --git a/gcc/ipa-sra.cc b/gcc/ipa-sra.cc
index 5355cf2f4..471b3927c 100644
--- a/gcc/ipa-sra.cc
+++ b/gcc/ipa-sra.cc
@@ -3393,6 +3393,13 @@ param_splitting_across_edge (cgraph_edge *cs)
gcc_checking_assert (from_ifs && from_ifs->m_parameters);
isra_call_summary *csum = call_sums->get (cs);
+ /* TODO: implement better support for call edges inserted after summary
+ collection but before sra wpa invocation. */
+ if (!csum)
+ {
+ csum = call_sums->get_create (cs);
+ csum->m_return_ignored = true;
+ }
gcc_checking_assert (csum);
unsigned args_count = csum->m_arg_flow.length ();
isra_func_summary *to_ifs = func_sums->get (callee);
diff --git a/gcc/params.opt b/gcc/params.opt
index 5c07e3986..50385dfd7 100644
--- a/gcc/params.opt
+++ b/gcc/params.opt
@@ -314,8 +314,8 @@ Common Joined UInteger Var(param_ipa_prefetch_distance_factor) Init(4) Param Opt
The factor represents the number of inductive variable incrementations to evaluate an indirect memory address for IPA prefetch.
-param=ipa-prefetch-locality=
-Common Joined UInteger Var(param_ipa_prefetch_locality) Init(3) Param Optimization
-The flag represents temporal locality values in the following way: 0:pstl1strm, 1:pstl3keep, 2:pstl2keep, 3:pstl1keep.
+Common Joined UInteger Var(param_ipa_prefetch_locality) Init(3) IntegerRange(0, 3) Param Optimization
+The flag represents temporal locality value between 0 and 3, the higher value means the higher temporal locality in the data.
-param=ira-loop-reserved-regs=
Common Joined UInteger Var(param_ira_loop_reserved_regs) Init(2) Param Optimization
diff --git a/gcc/testsuite/gcc.dg/completion-1.c b/gcc/testsuite/gcc.dg/completion-1.c
index 64da64f1c..df2319c76 100644
--- a/gcc/testsuite/gcc.dg/completion-1.c
+++ b/gcc/testsuite/gcc.dg/completion-1.c
@@ -2,6 +2,7 @@
/* { dg-options "--completion=-fipa-ic" } */
/* { dg-begin-multiline-output "" }
+-fipa-ic
-fipa-icf
-fipa-icf-functions
-fipa-icf-variables
diff --git a/gcc/testsuite/gcc.dg/ipa/ipa-prefetch-xz.c b/gcc/testsuite/gcc.dg/ipa/ipa-prefetch-xz.c
new file mode 100644
index 000000000..bd4fb2bdc
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/ipa/ipa-prefetch-xz.c
@@ -0,0 +1,1843 @@
+/* { dg-do link } */
+/* { dg-options "-O3 -fipa-ic -fipa-prefetch -flto -flto-partition=one -fdump-ipa-ipa_prefetch -fdump-ipa-icp" } */
+/* { dg-require-effective-target lto } */
+
+/* Based on opensource xz code. */
+
+#include <stdlib.h>
+#include <string.h>
+
+typedef long int ptrdiff_t;
+typedef long unsigned int size_t;
+typedef unsigned int wchar_t;
+
+typedef unsigned char __u_char;
+typedef unsigned short int __u_short;
+typedef unsigned int __u_int;
+typedef unsigned long int __u_long;
+
+typedef signed char __int8_t;
+typedef unsigned char __uint8_t;
+typedef signed short int __int16_t;
+typedef unsigned short int __uint16_t;
+typedef signed int __int32_t;
+typedef unsigned int __uint32_t;
+
+typedef signed long int __int64_t;
+typedef unsigned long int __uint64_t;
+
+typedef __int8_t __int_least8_t;
+typedef __uint8_t __uint_least8_t;
+typedef __int16_t __int_least16_t;
+typedef __uint16_t __uint_least16_t;
+typedef __int32_t __int_least32_t;
+typedef __uint32_t __uint_least32_t;
+typedef __int64_t __int_least64_t;
+typedef __uint64_t __uint_least64_t;
+
+typedef __int8_t int8_t;
+typedef __int16_t int16_t;
+typedef __int32_t int32_t;
+typedef __int64_t int64_t;
+
+typedef __uint8_t uint8_t;
+typedef __uint16_t uint16_t;
+typedef __uint32_t uint32_t;
+typedef __uint64_t uint64_t;
+
+typedef long int intptr_t;
+typedef unsigned long int uintptr_t;
+
+static inline uint16_t
+read16ne(const uint8_t *buf)
+{
+ uint16_t num;
+ memcpy(&num, buf, sizeof(num));
+ return num;
+}
+
+static inline uint32_t
+read32ne(const uint8_t *buf)
+{
+ uint32_t num;
+ memcpy(&num, buf, sizeof(num));
+ return num;
+}
+
+static inline uint16_t
+aligned_read16ne(const uint8_t *buf)
+{
+ uint16_t num;
+ memcpy(&num, __builtin_assume_aligned(buf, sizeof(num)), sizeof(num));
+ return num;
+}
+
+
+static inline uint32_t
+aligned_read32ne(const uint8_t *buf)
+{
+ uint32_t num;
+ memcpy(&num, __builtin_assume_aligned(buf, sizeof(num)), sizeof(num));
+ return num;
+}
+
+static inline uint64_t
+aligned_read64ne(const uint8_t *buf)
+{
+ uint64_t num;
+ memcpy(&num, __builtin_assume_aligned(buf, sizeof(num)), sizeof(num));
+ return num;
+}
+
+typedef unsigned char lzma_bool;
+
+typedef enum {
+ LZMA_RESERVED_ENUM = 0
+} lzma_reserved_enum;
+
+typedef enum {
+ LZMA_OK = 0,
+ LZMA_STREAM_END = 1,
+ LZMA_NO_CHECK = 2,
+ LZMA_UNSUPPORTED_CHECK = 3,
+ LZMA_GET_CHECK = 4,
+ LZMA_MEM_ERROR = 5,
+ LZMA_MEMLIMIT_ERROR = 6,
+ LZMA_FORMAT_ERROR = 7,
+ LZMA_OPTIONS_ERROR = 8,
+ LZMA_DATA_ERROR = 9,
+ LZMA_BUF_ERROR = 10,
+ LZMA_PROG_ERROR = 11,
+} lzma_ret;
+
+typedef enum {
+ LZMA_RUN = 0,
+ LZMA_SYNC_FLUSH = 1,
+ LZMA_FULL_FLUSH = 2,
+ LZMA_FULL_BARRIER = 4,
+ LZMA_FINISH = 3
+} lzma_action;
+
+typedef struct {
+ void *( *alloc)(void *opaque, size_t nmemb, size_t size);
+
+ void ( *free)(void *opaque, void *ptr);
+
+ void *opaque;
+} lzma_allocator;
+
+typedef uint64_t lzma_vli;
+
+typedef enum {
+ LZMA_CHECK_NONE = 0,
+ LZMA_CHECK_CRC32 = 1,
+ LZMA_CHECK_CRC64 = 4,
+ LZMA_CHECK_SHA256 = 10
+} lzma_check;
+
+typedef struct {
+ lzma_vli id;
+ void *options;
+} lzma_filter;
+
+typedef enum {
+ LZMA_MF_HC3 = 0x03,
+ LZMA_MF_HC4 = 0x04,
+ LZMA_MF_BT2 = 0x12,
+ LZMA_MF_BT3 = 0x13,
+ LZMA_MF_BT4 = 0x14
+} lzma_match_finder;
+
+typedef struct lzma_next_coder_s lzma_next_coder;
+
+typedef struct lzma_filter_info_s lzma_filter_info;
+
+typedef lzma_ret (*lzma_init_function)(
+ lzma_next_coder *next, const lzma_allocator *allocator,
+ const lzma_filter_info *filters);
+
+typedef lzma_ret (*lzma_code_function)(
+ void *coder, const lzma_allocator *allocator,
+ const uint8_t *restrict in, size_t *restrict in_pos,
+ size_t in_size, uint8_t *restrict out,
+ size_t *restrict out_pos, size_t out_size,
+ lzma_action action);
+
+typedef void (*lzma_end_function)(
+ void *coder, const lzma_allocator *allocator);
+
+struct lzma_filter_info_s {
+ lzma_vli id;
+ lzma_init_function init;
+ void *options;
+};
+
+struct lzma_next_coder_s {
+ void *coder;
+ lzma_vli id;
+ uintptr_t init;
+
+ lzma_code_function code;
+ lzma_end_function end;
+ void (*get_progress)(void *coder,
+ uint64_t *progress_in, uint64_t *progress_out);
+
+ lzma_check (*get_check)(const void *coder);
+ lzma_ret (*memconfig)(void *coder, uint64_t *memusage,
+ uint64_t *old_memlimit, uint64_t new_memlimit);
+ lzma_ret (*update)(void *coder, const lzma_allocator *allocator,
+ const lzma_filter *filters, const lzma_filter *reversed_filters);
+};
+
+typedef struct {
+ uint32_t len;
+ uint32_t dist;
+} lzma_match;
+
+typedef struct lzma_mf_s lzma_mf;
+struct lzma_mf_s {
+ uint8_t *buffer;
+ uint32_t size;
+ uint32_t keep_size_before;
+ uint32_t keep_size_after;
+ uint32_t offset;
+ uint32_t read_pos;
+ uint32_t read_ahead;
+ uint32_t read_limit;
+ uint32_t write_pos;
+ uint32_t pending;
+ uint32_t (*find)(lzma_mf *mf, lzma_match *matches);
+ void (*skip)(lzma_mf *mf, uint32_t num);
+ uint32_t *hash;
+ uint32_t *son;
+ uint32_t cyclic_pos;
+ uint32_t cyclic_size;
+ uint32_t hash_mask;
+ uint32_t depth;
+ uint32_t nice_len;
+ uint32_t match_len_max;
+ lzma_action action;
+ uint32_t hash_count;
+ uint32_t sons_count;
+};
+
+typedef struct {
+ size_t before_size;
+ size_t dict_size;
+ size_t after_size;
+ size_t match_len_max;
+ size_t nice_len;
+ lzma_match_finder match_finder;
+ uint32_t depth;
+ const uint8_t *preset_dict;
+ uint32_t preset_dict_size;
+} lzma_lz_options;
+
+typedef struct {
+ void *coder;
+ lzma_ret (*code)(void *coder,
+ lzma_mf *restrict mf, uint8_t *restrict out,
+ size_t *restrict out_pos, size_t out_size);
+ void (*end)(void *coder, const lzma_allocator *allocator);
+ lzma_ret (*options_update)(void *coder, const lzma_filter *filter);
+} lzma_lz_encoder;
+
+static inline const uint8_t *
+mf_ptr(const lzma_mf *mf)
+{
+ return mf->buffer + mf->read_pos;
+}
+
+static inline uint32_t
+mf_avail(const lzma_mf *mf)
+{
+ return mf->write_pos - mf->read_pos;
+}
+
+typedef struct {
+ uint32_t state[8];
+ uint64_t size;
+} lzma_sha256_state;
+
+typedef struct {
+ union {
+ uint8_t u8[64];
+ uint32_t u32[16];
+ uint64_t u64[8];
+ } buffer;
+ union {
+ uint32_t crc32;
+ uint64_t crc64;
+ lzma_sha256_state sha256;
+ } state;
+} lzma_check_state;
+
+// The table is constantly initialized in the original code.
+// Skip it in the test.
+const uint32_t lzma_crc32_table[8][256];
+
+static inline uint32_t __attribute__((__always_inline__))
+lzma_memcmplen(const uint8_t *buf1, const uint8_t *buf2,
+ uint32_t len, uint32_t limit)
+{
+ while (len < limit) {
+ uint32_t x = read32ne(buf1 + len) - read32ne(buf2 + len);
+ if (x != 0) {
+ if ((x & 0xFFFF) == 0) {
+ len += 2;
+ x >>= 16;
+ }
+
+ if ((x & 0xFF) == 0)
+ ++len;
+
+ return ((len) < (limit) ? (len) : (limit));
+ }
+
+ len += 4;
+ }
+
+ return limit;
+}
+
+extern uint32_t
+lzma_mf_find(lzma_mf *mf, uint32_t *count_ptr, lzma_match *matches)
+{
+ const uint32_t count = mf->find(mf, matches);
+ uint32_t len_best = 0;
+
+ if (count > 0) {
+ len_best = matches[count - 1].len;
+ if (len_best == mf->nice_len) {
+ uint32_t limit = mf_avail(mf) + 1;
+ if (limit > mf->match_len_max)
+ limit = mf->match_len_max;
+ const uint8_t *p1 = mf_ptr(mf) - 1;
+ const uint8_t *p2 = p1 - matches[count - 1].dist - 1;
+ len_best = lzma_memcmplen(p1, p2, len_best, limit);
+ }
+ }
+
+ *count_ptr = count;
+ ++mf->read_ahead;
+
+ return len_best;
+}
+
+static void
+normalize(lzma_mf *mf)
+{
+ const uint32_t subvalue = ((4294967295U) - mf->cyclic_size);
+
+ for (uint32_t i = 0; i < mf->hash_count; ++i) {
+ if (mf->hash[i] <= subvalue)
+ mf->hash[i] = 0;
+ else
+ mf->hash[i] -= subvalue;
+ }
+
+ for (uint32_t i = 0; i < mf->sons_count; ++i) {
+ if (mf->son[i] <= subvalue)
+ mf->son[i] = 0;
+ else
+ mf->son[i] -= subvalue;
+ }
+
+ mf->offset -= subvalue;
+ return;
+}
+
+static void
+move_pos(lzma_mf *mf)
+{
+ if (++mf->cyclic_pos == mf->cyclic_size)
+ mf->cyclic_pos = 0;
+ ++mf->read_pos;
+ if (__builtin_expect(mf->read_pos + mf->offset == (4294967295U), 0 ))
+ normalize(mf);
+}
+
+static void
+move_pending(lzma_mf *mf)
+{
+ ++mf->read_pos;
+ ++mf->pending;
+}
+
+static lzma_match *
+hc_find_func(
+ const uint32_t len_limit,
+ const uint32_t pos,
+ const uint8_t *const cur,
+ uint32_t cur_match,
+ uint32_t depth,
+ uint32_t *const son,
+ const uint32_t cyclic_pos,
+ const uint32_t cyclic_size,
+ lzma_match *matches,
+ uint32_t len_best)
+{
+ son[cyclic_pos] = cur_match;
+
+ while (1) {
+ const uint32_t delta = pos - cur_match;
+ if (depth-- == 0 || delta >= cyclic_size)
+ return matches;
+
+ const uint8_t *const pb = cur - delta;
+ cur_match = son[cyclic_pos - delta
+ + (delta > cyclic_pos ? cyclic_size : 0)];
+
+ if (pb[len_best] == cur[len_best] && pb[0] == cur[0]) {
+ uint32_t len = lzma_memcmplen(pb, cur, 1, len_limit);
+
+ if (len_best < len) {
+ len_best = len;
+ matches->len = len;
+ matches->dist = delta - 1;
+ ++matches;
+
+ if (len == len_limit)
+ return matches;
+ }
+ }
+ }
+}
+
+extern uint32_t
+lzma_mf_hc3_find(lzma_mf *mf, lzma_match *matches)
+{
+ uint32_t len_limit = mf_avail(mf);
+ if (mf->nice_len <= len_limit) {
+ len_limit = mf->nice_len;
+ } else if (len_limit < (3)) {
+ move_pending(mf);
+ return 0;
+ }
+ const uint8_t *cur = mf_ptr(mf);
+ const uint32_t pos = mf->read_pos + mf->offset;
+ uint32_t matches_count = 0;
+
+ const uint32_t temp = lzma_crc32_table[0][cur[0]] ^ cur[1];
+ const uint32_t hash_2_value = temp & ((1U << 10) - 1);
+ const uint32_t hash_value = (temp ^ ((uint32_t)(cur[2]) << 8)) & mf->hash_mask;
+
+ const uint32_t delta2 = pos - mf->hash[hash_2_value];
+ const uint32_t cur_match = mf->hash[((1U << 10)) + hash_value];
+
+ mf->hash[hash_2_value] = pos;
+ mf->hash[((1U << 10)) + hash_value] = pos;
+
+ uint32_t len_best = 2;
+
+ if (delta2 < mf->cyclic_size && *(cur - delta2) == *cur) {
+ len_best = lzma_memcmplen(cur - delta2, cur, len_best, len_limit);
+
+ matches[0].len = len_best;
+ matches[0].dist = delta2 - 1;
+ matches_count = 1;
+
+ if (len_best == len_limit) {
+ mf->son[mf->cyclic_pos] = cur_match;
+ move_pos(mf);
+ return 1;
+ }
+ }
+
+ matches_count = hc_find_func(len_limit, pos, cur, cur_match, mf->depth,
+ mf->son, mf->cyclic_pos, mf->cyclic_size,
+ matches + matches_count, len_best) - matches;
+ move_pos(mf);
+ return matches_count;
+}
+
+extern void
+lzma_mf_hc3_skip(lzma_mf *mf, uint32_t amount)
+{
+ do {
+ if (mf_avail(mf) < 3) {
+ move_pending(mf);
+ continue;
+ }
+
+ const uint8_t *cur = mf_ptr(mf);
+ const uint32_t pos = mf->read_pos + mf->offset;
+
+ const uint32_t temp = lzma_crc32_table[0][cur[0]] ^ cur[1];
+ const uint32_t hash_2_value = temp & ((1U << 10) - 1);
+ const uint32_t hash_value = (temp ^ ((uint32_t)(cur[2]) << 8)) & mf->hash_mask;
+
+ const uint32_t cur_match
+ = mf->hash[((1U << 10)) + hash_value];
+
+ mf->hash[hash_2_value] = pos;
+ mf->hash[((1U << 10)) + hash_value] = pos;
+
+ do { mf->son[mf->cyclic_pos] = cur_match; move_pos(mf); } while (0);
+
+ } while (--amount != 0);
+}
+
+extern uint32_t
+lzma_mf_hc4_find(lzma_mf *mf, lzma_match *matches)
+{
+ uint32_t len_limit = mf_avail(mf);
+ if (mf->nice_len <= len_limit) {
+ len_limit = mf->nice_len;
+ } else if (len_limit < (4)) {
+ move_pending(mf);
+ return 0;
+ }
+ const uint8_t *cur = mf_ptr(mf);
+ const uint32_t pos = mf->read_pos + mf->offset;
+ uint32_t matches_count = 0;
+
+ const uint32_t temp = lzma_crc32_table[0][cur[0]] ^ cur[1];
+ const uint32_t hash_2_value = temp & ((1U << 10) - 1);
+ const uint32_t hash_3_value = (temp ^ ((uint32_t)(cur[2]) << 8))
+ & ((1U << 16) - 1);
+ const uint32_t hash_value = (temp ^ ((uint32_t)(cur[2]) << 8)
+ ^ (lzma_crc32_table[0][cur[3]] << 5))
+ & mf->hash_mask;
+ uint32_t delta2 = pos - mf->hash[hash_2_value];
+ const uint32_t delta3
+ = pos - mf->hash[((1U << 10)) + hash_3_value];
+ const uint32_t cur_match = mf->hash[((1U << 10) + (1U << 16)) + hash_value];
+
+ mf->hash[hash_2_value ] = pos;
+ mf->hash[((1U << 10)) + hash_3_value] = pos;
+ mf->hash[((1U << 10) + (1U << 16)) + hash_value] = pos;
+
+ uint32_t len_best = 1;
+
+ if (delta2 < mf->cyclic_size && *(cur - delta2) == *cur) {
+ len_best = 2;
+ matches[0].len = 2;
+ matches[0].dist = delta2 - 1;
+ matches_count = 1;
+ }
+
+ if (delta2 != delta3 && delta3 < mf->cyclic_size
+ && *(cur - delta3) == *cur) {
+ len_best = 3;
+ matches[matches_count++].dist = delta3 - 1;
+ delta2 = delta3;
+ }
+
+ if (matches_count != 0) {
+ len_best = lzma_memcmplen(cur - delta2, cur,
+ len_best, len_limit);
+
+ matches[matches_count - 1].len = len_best;
+
+ if (len_best == len_limit) {
+ mf->son[mf->cyclic_pos] = cur_match; move_pos(mf);
+ return matches_count;
+ }
+ }
+
+ if (len_best < 3)
+ len_best = 3;
+
+ matches_count = hc_find_func(len_limit, pos, cur, cur_match, mf->depth,
+ mf->son, mf->cyclic_pos, mf->cyclic_size,
+ matches + matches_count, len_best) - matches;
+ move_pos(mf);
+ return matches_count;
+}
+
+extern void
+lzma_mf_hc4_skip(lzma_mf *mf, uint32_t amount)
+{
+ do {
+ if (mf_avail(mf) < 4) {
+ move_pending(mf);
+ continue;
+ }
+
+ const uint8_t *cur = mf_ptr(mf);
+ const uint32_t pos = mf->read_pos + mf->offset;
+
+ const uint32_t temp = lzma_crc32_table[0][cur[0]] ^ cur[1];
+ const uint32_t hash_2_value = temp & ((1U << 10) - 1);
+ const uint32_t hash_3_value = (temp ^ ((uint32_t)(cur[2]) << 8)) & ((1U << 16) - 1);
+ const uint32_t hash_value = (temp ^ ((uint32_t)(cur[2]) << 8)
+ ^ (lzma_crc32_table[0][cur[3]] << 5))
+ & mf->hash_mask;
+
+ const uint32_t cur_match
+ = mf->hash[((1U << 10) + (1U << 16)) + hash_value];
+
+ mf->hash[hash_2_value] = pos;
+ mf->hash[((1U << 10)) + hash_3_value] = pos;
+ mf->hash[((1U << 10) + (1U << 16)) + hash_value] = pos;
+
+ mf->son[mf->cyclic_pos] = cur_match;
+ move_pos(mf);
+ } while (--amount != 0);
+}
+
+static lzma_match *
+bt_find_func(
+ const uint32_t len_limit,
+ const uint32_t pos,
+ const uint8_t *const cur,
+ uint32_t cur_match,
+ uint32_t depth,
+ uint32_t *const son,
+ const uint32_t cyclic_pos,
+ const uint32_t cyclic_size,
+ lzma_match *matches,
+ uint32_t len_best)
+{
+ uint32_t *ptr0 = son + (cyclic_pos << 1) + 1;
+ uint32_t *ptr1 = son + (cyclic_pos << 1);
+
+ uint32_t len0 = 0;
+ uint32_t len1 = 0;
+
+ while (1) {
+ const uint32_t delta = pos - cur_match;
+ if (depth-- == 0 || delta >= cyclic_size) {
+ *ptr0 = 0;
+ *ptr1 = 0;
+ return matches;
+ }
+
+ uint32_t *const pair = son + ((cyclic_pos - delta
+ + (delta > cyclic_pos ? cyclic_size : 0))
+ << 1);
+
+ const uint8_t *const pb = cur - delta;
+ uint32_t len = ((len0) < (len1) ? (len0) : (len1));
+
+ if (pb[len] == cur[len]) {
+ len = lzma_memcmplen(pb, cur, len + 1, len_limit);
+
+ if (len_best < len) {
+ len_best = len;
+ matches->len = len;
+ matches->dist = delta - 1;
+ ++matches;
+
+ if (len == len_limit) {
+ *ptr1 = pair[0];
+ *ptr0 = pair[1];
+ return matches;
+ }
+ }
+ }
+
+ if (pb[len] < cur[len]) {
+ *ptr1 = cur_match;
+ ptr1 = pair + 1;
+ cur_match = *ptr1;
+ len1 = len;
+ } else {
+ *ptr0 = cur_match;
+ ptr0 = pair;
+ cur_match = *ptr0;
+ len0 = len;
+ }
+ }
+}
+
+
+static void
+bt_skip_func(
+ const uint32_t len_limit,
+ const uint32_t pos,
+ const uint8_t *const cur,
+ uint32_t cur_match,
+ uint32_t depth,
+ uint32_t *const son,
+ const uint32_t cyclic_pos,
+ const uint32_t cyclic_size)
+{
+ uint32_t *ptr0 = son + (cyclic_pos << 1) + 1;
+ uint32_t *ptr1 = son + (cyclic_pos << 1);
+
+ uint32_t len0 = 0;
+ uint32_t len1 = 0;
+
+ while (1) {
+ const uint32_t delta = pos - cur_match;
+ if (depth-- == 0 || delta >= cyclic_size) {
+ *ptr0 = 0;
+ *ptr1 = 0;
+ return;
+ }
+
+ uint32_t *pair = son + ((cyclic_pos - delta
+ + (delta > cyclic_pos ? cyclic_size : 0))
+ << 1);
+ const uint8_t *pb = cur - delta;
+ uint32_t len = ((len0) < (len1) ? (len0) : (len1));
+
+ if (pb[len] == cur[len]) {
+ len = lzma_memcmplen(pb, cur, len + 1, len_limit);
+
+ if (len == len_limit) {
+ *ptr1 = pair[0];
+ *ptr0 = pair[1];
+ return;
+ }
+ }
+
+ if (pb[len] < cur[len]) {
+ *ptr1 = cur_match;
+ ptr1 = pair + 1;
+ cur_match = *ptr1;
+ len1 = len;
+ } else {
+ *ptr0 = cur_match;
+ ptr0 = pair;
+ cur_match = *ptr0;
+ len0 = len;
+ }
+ }
+}
+
+extern uint32_t
+lzma_mf_bt2_find(lzma_mf *mf, lzma_match *matches)
+{
+ uint32_t len_limit = mf_avail(mf);
+ if (mf->nice_len <= len_limit) {
+ len_limit = mf->nice_len;
+ } else if (len_limit < (2) || (mf->action == LZMA_SYNC_FLUSH)) {
+ move_pending(mf);
+ return 0;
+ }
+ const uint8_t *cur = mf_ptr(mf);
+ const uint32_t pos = mf->read_pos + mf->offset;
+ uint32_t matches_count = 0;
+ const uint32_t hash_value = read16ne(cur);
+ const uint32_t cur_match = mf->hash[hash_value];
+ mf->hash[hash_value] = pos;
+
+ matches_count = bt_find_func(len_limit, pos, cur, cur_match, mf->depth,
+ mf->son, mf->cyclic_pos, mf->cyclic_size,
+ matches + matches_count, 1) - matches;
+ move_pos(mf);
+ return matches_count;
+}
+
+extern void
+lzma_mf_bt2_skip(lzma_mf *mf, uint32_t amount)
+{
+ do {
+ uint32_t len_limit = mf_avail(mf);
+ if (mf->nice_len <= len_limit) {
+ len_limit = mf->nice_len;
+ } else if (len_limit < (2) || (mf->action == LZMA_SYNC_FLUSH)) {
+ move_pending(mf);
+ continue;
+ }
+ const uint8_t *cur = mf_ptr(mf);
+ const uint32_t pos = mf->read_pos + mf->offset;
+
+ const uint32_t hash_value = read16ne(cur);
+ const uint32_t cur_match = mf->hash[hash_value];
+ mf->hash[hash_value] = pos;
+
+ bt_skip_func(len_limit, pos, cur, cur_match, mf->depth, mf->son,
+ mf->cyclic_pos, mf->cyclic_size);
+ move_pos(mf);
+ } while (--amount != 0);
+}
+
+extern uint32_t
+lzma_mf_bt3_find(lzma_mf *mf, lzma_match *matches)
+{
+ uint32_t len_limit = mf_avail(mf);
+ if (mf->nice_len <= len_limit) {
+ len_limit = mf->nice_len;
+ } else if (len_limit < (3) || (1 && mf->action == LZMA_SYNC_FLUSH)) {
+ move_pending(mf);
+ return 0;
+ }
+ const uint8_t *cur = mf_ptr(mf);
+ const uint32_t pos = mf->read_pos + mf->offset;
+ uint32_t matches_count = 0;
+
+ const uint32_t temp = lzma_crc32_table[0][cur[0]] ^ cur[1];
+ const uint32_t hash_2_value = temp & ((1U << 10) - 1);
+ const uint32_t hash_value = (temp ^ ((uint32_t)(cur[2]) << 8)) & mf->hash_mask;
+
+ const uint32_t delta2 = pos - mf->hash[hash_2_value];
+ const uint32_t cur_match = mf->hash[((1U << 10)) + hash_value];
+
+ mf->hash[hash_2_value] = pos;
+ mf->hash[((1U << 10)) + hash_value] = pos;
+
+ uint32_t len_best = 2;
+
+ if (delta2 < mf->cyclic_size && *(cur - delta2) == *cur) {
+ len_best = lzma_memcmplen(
+ cur, cur - delta2, len_best, len_limit);
+
+ matches[0].len = len_best;
+ matches[0].dist = delta2 - 1;
+ matches_count = 1;
+
+ if (len_best == len_limit) {
+ bt_skip_func(len_limit, pos, cur, cur_match, mf->depth, mf->son,
+ mf->cyclic_pos, mf->cyclic_size);
+ move_pos(mf);
+ return 1;
+ }
+ }
+
+ matches_count = bt_find_func(len_limit, pos, cur, cur_match, mf->depth,
+ mf->son, mf->cyclic_pos, mf->cyclic_size,
+ matches + matches_count, len_best) - matches;
+ move_pos(mf);
+ return matches_count;
+}
+
+
+extern void
+lzma_mf_bt3_skip(lzma_mf *mf, uint32_t amount)
+{
+ do {
+ uint32_t len_limit = mf_avail(mf);
+ if (mf->nice_len <= len_limit) {
+ len_limit = mf->nice_len; }
+ else if (len_limit < (3) || (1 && mf->action == LZMA_SYNC_FLUSH)) {
+ move_pending(mf);
+ continue;
+ }
+ const uint8_t *cur = mf_ptr(mf);
+ const uint32_t pos = mf->read_pos + mf->offset;
+
+ const uint32_t temp = lzma_crc32_table[0][cur[0]] ^ cur[1];
+ const uint32_t hash_2_value = temp & ((1U << 10) - 1);
+ const uint32_t hash_value = (temp ^ ((uint32_t)(cur[2]) << 8)) & mf->hash_mask;
+
+ const uint32_t cur_match = mf->hash[((1U << 10)) + hash_value];
+
+ mf->hash[hash_2_value] = pos;
+ mf->hash[((1U << 10)) + hash_value] = pos;
+
+ bt_skip_func(len_limit, pos, cur, cur_match, mf->depth, mf->son,
+ mf->cyclic_pos, mf->cyclic_size);
+ move_pos(mf);
+ } while (--amount != 0);
+}
+
+extern uint32_t
+lzma_mf_bt4_find(lzma_mf *mf, lzma_match *matches)
+{
+ uint32_t len_limit = mf->write_pos - mf->read_pos;
+ if (mf->nice_len <= len_limit) {
+ len_limit = mf->nice_len;
+ } else if (len_limit < (4) || (mf->action == LZMA_SYNC_FLUSH)) {
+ ++mf->read_pos;
+ ++mf->pending;
+ return 0;
+ }
+
+ const uint8_t *cur = mf->buffer + mf->read_pos;
+ const uint32_t pos = mf->read_pos + mf->offset;
+ uint32_t matches_count = 0;
+
+ const uint32_t temp = lzma_crc32_table[0][cur[0]] ^ cur[1];
+ const uint32_t hash_2_value = temp & ((1U << 10) - 1);
+ const uint32_t hash_3_value = (temp ^ ((uint32_t)(cur[2]) << 8)) & ((1U << 16) - 1);
+ const uint32_t hash_value = (temp ^ ((uint32_t)(cur[2]) << 8)
+ ^ (lzma_crc32_table[0][cur[3]] << 5))
+ & mf->hash_mask;
+
+ uint32_t delta2 = pos - mf->hash[hash_2_value];
+ const uint32_t delta3 = pos - mf->hash[((1U << 10)) + hash_3_value];
+ const uint32_t cur_match = mf->hash[((1U << 10) + (1U << 16)) + hash_value];
+
+ mf->hash[hash_2_value] = pos;
+ mf->hash[((1U << 10)) + hash_3_value] = pos;
+ mf->hash[((1U << 10) + (1U << 16)) + hash_value] = pos;
+
+ uint32_t len_best = 1;
+
+ if (delta2 < mf->cyclic_size && *(cur - delta2) == *cur) {
+ len_best = 2;
+ matches[0].len = 2;
+ matches[0].dist = delta2 - 1;
+ matches_count = 1;
+ }
+
+ if (delta2 != delta3 && delta3 < mf->cyclic_size && *(cur - delta3) == *cur) {
+ len_best = 3;
+ matches[matches_count++].dist = delta3 - 1;
+ delta2 = delta3;
+ }
+
+ if (matches_count != 0) {
+ len_best = lzma_memcmplen(cur, cur - delta2, len_best, len_limit);
+
+ matches[matches_count - 1].len = len_best;
+
+ if (len_best == len_limit) {
+ bt_skip_func(len_limit, pos, cur, cur_match, mf->depth, mf->son,
+ mf->cyclic_pos, mf->cyclic_size);
+ move_pos(mf);
+ return matches_count;
+ }
+ }
+
+ if (len_best < 3)
+ len_best = 3;
+
+ matches_count = bt_find_func(len_limit, pos, cur, cur_match, mf->depth, mf->son,
+ mf->cyclic_pos, mf->cyclic_size,
+ matches + matches_count, len_best) - matches;
+ move_pos(mf);
+ return matches_count;
+}
+
+extern void
+lzma_mf_bt4_skip(lzma_mf *mf, uint32_t amount)
+{
+ do {
+ uint32_t len_limit = mf_avail(mf);
+ if (mf->nice_len <= len_limit) {
+ len_limit = mf->nice_len;
+ } else if (len_limit < (4) || (mf->action == LZMA_SYNC_FLUSH)) {
+ move_pending(mf);
+ continue;
+ }
+
+ const uint8_t *cur = mf->buffer + mf->read_pos;
+ const uint32_t pos = mf->read_pos + mf->offset;
+
+ const uint32_t temp = lzma_crc32_table[0][cur[0]] ^ cur[1];
+ const uint32_t hash_2_value = temp & ((1U << 10) - 1);
+ const uint32_t hash_3_value = (temp ^ ((uint32_t)(cur[2]) << 8))
+ & ((1U << 16) - 1);
+ const uint32_t hash_value = (temp ^ ((uint32_t)(cur[2]) << 8)
+ ^ (lzma_crc32_table[0][cur[3]] << 5))
+ & mf->hash_mask;
+
+ const uint32_t cur_match = mf->hash[((1U << 10) + (1U << 16)) + hash_value];
+
+ mf->hash[hash_2_value] = pos;
+ mf->hash[((1U << 10)) + hash_3_value] = pos;
+ mf->hash[((1U << 10) + (1U << 16)) + hash_value] = pos;
+
+ bt_skip_func(len_limit, pos, cur, cur_match, mf->depth, mf->son,
+ mf->cyclic_pos, mf->cyclic_size);
+ move_pos(mf);
+ } while (--amount != 0);
+}
+
+static inline void
+mf_skip(lzma_mf *mf, uint32_t amount)
+{
+ if (amount != 0) {
+ mf->skip(mf, amount);
+ mf->read_ahead += amount;
+ }
+}
+
+typedef struct lzma_lzma1_encoder_s lzma_lzma1_encoder;
+typedef uint16_t probability;
+
+typedef struct {
+ probability choice;
+ probability choice2;
+ probability low[(1 << 4)][(1 << 3)];
+ probability mid[(1 << 4)][(1 << 3)];
+ probability high[(1 << 8)];
+ uint32_t prices[(1 << 4)][((1 << 3) + (1 << 3) + (1 << 8))];
+ uint32_t table_size;
+ uint32_t counters[(1 << 4)];
+} lzma_length_encoder;
+
+typedef struct {
+ uint64_t low;
+ uint64_t cache_size;
+ uint32_t range;
+ uint8_t cache;
+ size_t count;
+ size_t pos;
+
+ enum {
+ RC_BIT_0,
+ RC_BIT_1,
+ RC_DIRECT_0,
+ RC_DIRECT_1,
+ RC_FLUSH,
+ } symbols[58];
+
+ probability *probs[58];
+} lzma_range_encoder;
+
+
+typedef enum {
+ STATE_LIT_LIT,
+ STATE_MATCH_LIT_LIT,
+ STATE_REP_LIT_LIT,
+ STATE_SHORTREP_LIT_LIT,
+ STATE_MATCH_LIT,
+ STATE_REP_LIT,
+ STATE_SHORTREP_LIT,
+ STATE_LIT_MATCH,
+ STATE_LIT_LONGREP,
+ STATE_LIT_SHORTREP,
+ STATE_NONLIT_MATCH,
+ STATE_NONLIT_REP,
+} lzma_lzma_state;
+
+typedef struct {
+ lzma_lzma_state state;
+ _Bool prev_1_is_literal;
+ _Bool prev_2;
+
+ uint32_t pos_prev_2;
+ uint32_t back_prev_2;
+
+ uint32_t price;
+ uint32_t pos_prev;
+ uint32_t back_prev;
+
+ uint32_t backs[4];
+} lzma_optimal;
+
+struct lzma_lzma1_encoder_s {
+ lzma_range_encoder rc;
+ lzma_lzma_state state;
+ uint32_t reps[4];
+ lzma_match matches[(2 + ((1 << 3) + (1 << 3) + (1 << 8)) - 1) + 1];
+ uint32_t matches_count;
+ uint32_t longest_match_length;
+ _Bool fast_mode;
+ _Bool is_initialized;
+ _Bool is_flushed;
+ uint32_t pos_mask;
+ uint32_t literal_context_bits;
+ uint32_t literal_pos_mask;
+
+ probability literal[(1 << 4)][0x300];
+ probability is_match[12][(1 << 4)];
+ probability is_rep[12];
+ probability is_rep0[12];
+ probability is_rep1[12];
+ probability is_rep2[12];
+ probability is_rep0_long[12][(1 << 4)];
+ probability dist_slot[4][(1 << 6)];
+ probability dist_special[(1 << (14 / 2)) - 14];
+ probability dist_align[(1 << 4)];
+
+ lzma_length_encoder match_len_encoder;
+ lzma_length_encoder rep_len_encoder;
+
+ uint32_t dist_slot_prices[4][(1 << 6)];
+ uint32_t dist_prices[4][(1 << (14 / 2))];
+ uint32_t dist_table_size;
+ uint32_t match_price_count;
+
+ uint32_t align_prices[(1 << 4)];
+ uint32_t align_price_count;
+ uint32_t opts_end_index;
+ uint32_t opts_current_index;
+ lzma_optimal opts[(1 << 12)];
+};
+
+extern void
+lzma_lzma_optimum_fast(lzma_lzma1_encoder *restrict coder,
+ lzma_mf *restrict mf,
+ uint32_t *restrict back_res, uint32_t *restrict len_res)
+{
+ const uint32_t nice_len = mf->nice_len;
+
+ uint32_t len_main;
+ uint32_t matches_count;
+ if (mf->read_ahead == 0) {
+ len_main = lzma_mf_find(mf, &matches_count, coder->matches);
+ } else {
+ len_main = coder->longest_match_length;
+ matches_count = coder->matches_count;
+ }
+
+ const uint8_t *buf = mf_ptr(mf) - 1;
+ const uint32_t buf_avail
+ = ((mf_avail(mf) + 1) < ((2 + ((1 << 3) + (1 << 3) + (1 << 8)) - 1))
+ ? (mf_avail(mf) + 1) : ((2 + ((1 << 3) + (1 << 3) + (1 << 8)) - 1)));
+
+ if (buf_avail < 2) {
+ *back_res = (4294967295U);
+ *len_res = 1;
+ return;
+ }
+
+ uint32_t rep_len = 0;
+ uint32_t rep_index = 0;
+
+ for (uint32_t i = 0; i < 4; ++i) {
+ const uint8_t *const buf_back = buf - coder->reps[i] - 1;
+ if ((read16ne(buf) != read16ne(buf_back)))
+ continue;
+ const uint32_t len = lzma_memcmplen(buf, buf_back, 2, buf_avail);
+ if (len >= nice_len) {
+ *back_res = i;
+ *len_res = len;
+ mf_skip(mf, len - 1);
+ return;
+ }
+ if (len > rep_len) {
+ rep_index = i;
+ rep_len = len;
+ }
+ }
+ if (len_main >= nice_len) {
+ *back_res = coder->matches[matches_count - 1].dist + 4;
+ *len_res = len_main;
+ mf_skip(mf, len_main - 1);
+ return;
+ }
+
+ uint32_t back_main = 0;
+ if (len_main >= 2) {
+ back_main = coder->matches[matches_count - 1].dist;
+ while (matches_count > 1 && len_main ==
+ coder->matches[matches_count - 2].len + 1) {
+ if (!(((back_main) >> 7) > (coder->matches[ matches_count - 2].dist)))
+ break;
+ --matches_count;
+ len_main = coder->matches[matches_count - 1].len;
+ back_main = coder->matches[matches_count - 1].dist;
+ }
+ if (len_main == 2 && back_main >= 0x80)
+ len_main = 1;
+ }
+
+ if (rep_len >= 2) {
+ if (rep_len + 1 >= len_main
+ || (rep_len + 2 >= len_main
+ && back_main > (1U << 9))
+ || (rep_len + 3 >= len_main
+ && back_main > (1U << 15))) {
+ *back_res = rep_index;
+ *len_res = rep_len;
+ mf_skip(mf, rep_len - 1);
+ return;
+ }
+ }
+
+ if (len_main < 2 || buf_avail <= 2) {
+ *back_res = (4294967295U);
+ *len_res = 1;
+ return;
+ }
+
+ coder->longest_match_length = lzma_mf_find(mf,
+ &coder->matches_count, coder->matches);
+
+ if (coder->longest_match_length >= 2) {
+ const uint32_t new_dist = coder->matches[
+ coder->matches_count - 1].dist;
+
+ if ((coder->longest_match_length >= len_main
+ && new_dist < back_main)
+ || (coder->longest_match_length == len_main + 1
+ && !(((new_dist) >> 7) > (back_main)))
+ || (coder->longest_match_length > len_main + 1)
+ || (coder->longest_match_length + 1 >= len_main
+ && len_main >= 3
+ && (((back_main) >> 7) > (new_dist)))) {
+ *back_res = (4294967295U);
+ *len_res = 1;
+ return;
+ }
+ }
+ ++buf;
+ const uint32_t limit = ((2) > (len_main - 1) ? (2) : (len_main - 1));
+ for (uint32_t i = 0; i < 4; ++i) {
+ if (memcmp(buf, buf - coder->reps[i] - 1, limit) == 0) {
+ *back_res = (4294967295U);
+ *len_res = 1;
+ return;
+ }
+ }
+
+ *back_res = back_main + 4;
+ *len_res = len_main;
+ mf_skip(mf, len_main - 2);
+ return;
+}
+
+static inline void
+rc_bit(lzma_range_encoder *rc, probability *prob, uint32_t bit)
+{
+ rc->symbols[rc->count] = bit;
+ rc->probs[rc->count] = prob;
+ ++rc->count;
+}
+
+static inline void
+rc_bittree(lzma_range_encoder *rc, probability *probs,
+ uint32_t bit_count, uint32_t symbol)
+{
+ uint32_t model_index = 1;
+
+ do {
+ const uint32_t bit = (symbol >> --bit_count) & 1;
+ rc_bit(rc, &probs[model_index], bit);
+ model_index = (model_index << 1) + bit;
+ } while (bit_count != 0);
+}
+
+static _Bool
+encode_init(lzma_lzma1_encoder *coder, lzma_mf *mf)
+{
+ if (mf->read_pos == mf->read_limit) {
+ if (mf->action == LZMA_RUN)
+ return 0;
+ } else {
+ mf_skip(mf, 1);
+ mf->read_ahead = 0;
+ rc_bit(&coder->rc, &coder->is_match[0][0], 0);
+ rc_bittree(&coder->rc, coder->literal[0], 8, mf->buffer[0]);
+ }
+
+ coder->is_initialized = 1;
+
+ return 1;
+}
+
+static inline uint32_t
+mf_position(const lzma_mf *mf)
+{
+ return mf->read_pos - mf->read_ahead;
+}
+
+static inline _Bool
+rc_shift_low(lzma_range_encoder *rc,
+ uint8_t *out, size_t *out_pos, size_t out_size)
+{
+ if ((uint32_t)(rc->low) < (uint32_t)(0xFF000000)
+ || (uint32_t)(rc->low >> 32) != 0) {
+ do {
+ if (*out_pos == out_size)
+ return 1;
+
+ out[*out_pos] = rc->cache + (uint8_t)(rc->low >> 32);
+ ++*out_pos;
+ rc->cache = 0xFF;
+ } while (--rc->cache_size != 0);
+ rc->cache = (rc->low >> 24) & 0xFF;
+ }
+
+ ++rc->cache_size;
+ rc->low = (rc->low & 0x00FFFFFF) << 8;
+ return 0;
+}
+
+static inline void
+rc_reset(lzma_range_encoder *rc)
+{
+ rc->low = 0;
+ rc->cache_size = 1;
+ rc->range = (4294967295U);
+ rc->cache = 0;
+ rc->count = 0;
+ rc->pos = 0;
+}
+
+static inline _Bool
+rc_encode(lzma_range_encoder *rc,
+ uint8_t *out, size_t *out_pos, size_t out_size)
+{
+ while (rc->pos < rc->count) {
+ if (rc->range < (1U << 24)) {
+ if (rc_shift_low(rc, out, out_pos, out_size))
+ return 1;
+ rc->range <<= 8;
+ }
+
+ switch (rc->symbols[rc->pos]) {
+ case RC_BIT_0: {
+ probability prob = *rc->probs[rc->pos];
+ rc->range = (rc->range >> 11)
+ * prob;
+ prob += ((1U << 11) - prob) >> 5;
+ *rc->probs[rc->pos] = prob;
+ break;
+ }
+
+ case RC_BIT_1: {
+ probability prob = *rc->probs[rc->pos];
+ const uint32_t bound = prob * (rc->range
+ >> 11);
+ rc->low += bound;
+ rc->range -= bound;
+ prob -= prob >> 5;
+ *rc->probs[rc->pos] = prob;
+ break;
+ }
+
+ case RC_DIRECT_0:
+ rc->range >>= 1;
+ break;
+
+ case RC_DIRECT_1:
+ rc->range >>= 1;
+ rc->low += rc->range;
+ break;
+
+ case RC_FLUSH:
+ rc->range = (4294967295U);
+ do {
+ if (rc_shift_low(rc, out, out_pos, out_size))
+ return 1;
+ } while (++rc->pos < rc->count);
+
+ rc_reset(rc);
+ return 0;
+
+ default:
+ break;
+ }
+ ++rc->pos;
+ }
+
+ rc->count = 0;
+ rc->pos = 0;
+ return 0;
+}
+
+static inline uint64_t
+rc_pending(const lzma_range_encoder *rc)
+{
+ return rc->cache_size + 5 - 1;
+}
+
+static inline void
+literal_matched(lzma_range_encoder *rc, probability *subcoder,
+ uint32_t match_byte, uint32_t symbol)
+{
+ uint32_t offset = 0x100;
+ symbol += 1U << 8;
+
+ do {
+ match_byte <<= 1;
+ const uint32_t match_bit = match_byte & offset;
+ const uint32_t subcoder_index
+ = offset + match_bit + (symbol >> 8);
+ const uint32_t bit = (symbol >> 7) & 1;
+ rc_bit(rc, &subcoder[subcoder_index], bit);
+
+ symbol <<= 1;
+ offset &= ~(match_byte ^ symbol);
+
+ } while (symbol < (1U << 16));
+}
+
+static inline void
+literal(lzma_lzma1_encoder *coder, lzma_mf *mf, uint32_t position)
+{
+ const uint8_t cur_byte = mf->buffer[mf->read_pos - mf->read_ahead];
+ probability *subcoder = ((coder->literal)[
+ (((position) & (coder->literal_pos_mask))
+ << (coder->literal_context_bits))
+ + ((uint32_t)(mf->buffer[mf->read_pos - mf->read_ahead - 1])
+ >> (8U - (coder->literal_context_bits)))]);
+
+ if (((coder->state) < 7)) {
+ rc_bittree(&coder->rc, subcoder, 8, cur_byte);
+ } else {
+ const uint8_t match_byte
+ = mf->buffer[mf->read_pos - coder->reps[0] - 1 - mf->read_ahead];
+ literal_matched(&coder->rc, subcoder, match_byte, cur_byte);
+ }
+ coder->state
+ = ((coder->state) <= STATE_SHORTREP_LIT_LIT
+ ? STATE_LIT_LIT : ((coder->state) <= STATE_LIT_SHORTREP
+ ? (coder->state) - 3 : (coder->state) - 6));
+}
+
+const uint8_t lzma_rc_prices[] = {
+ 128, 103, 91, 84, 78, 73, 69, 66,
+ 63, 61, 58, 56, 54, 52, 51, 49,
+ 48, 46, 45, 44, 43, 42, 41, 40,
+ 39, 38, 37, 36, 35, 34, 34, 33,
+ 32, 31, 31, 30, 29, 29, 28, 28,
+ 27, 26, 26, 25, 25, 24, 24, 23,
+ 23, 22, 22, 22, 21, 21, 20, 20,
+ 19, 19, 19, 18, 18, 17, 17, 17,
+ 16, 16, 16, 15, 15, 15, 14, 14,
+ 14, 13, 13, 13, 12, 12, 12, 11,
+ 11, 11, 11, 10, 10, 10, 10, 9,
+ 9, 9, 9, 8, 8, 8, 8, 7,
+ 7, 7, 7, 6, 6, 6, 6, 5,
+ 5, 5, 5, 5, 4, 4, 4, 4,
+ 3, 3, 3, 3, 3, 2, 2, 2,
+ 2, 2, 2, 1, 1, 1, 1, 1
+};
+
+static inline uint32_t
+rc_bit_price(const probability prob, const uint32_t bit)
+{
+ return lzma_rc_prices[(prob ^ ((0U - bit)
+ & ((1U << 11) - 1))) >> 4];
+}
+
+static inline uint32_t
+rc_bit_0_price(const probability prob)
+{
+ return lzma_rc_prices[prob >> 4];
+}
+
+static inline uint32_t
+rc_bit_1_price(const probability prob)
+{
+ return lzma_rc_prices[(prob ^ ((1U << 11) - 1))
+ >> 4];
+}
+
+static inline uint32_t
+rc_bittree_price(const probability *const probs,
+ const uint32_t bit_levels, uint32_t symbol)
+{
+ uint32_t price = 0;
+ symbol += 1U << bit_levels;
+
+ do {
+ const uint32_t bit = symbol & 1;
+ symbol >>= 1;
+ price += rc_bit_price(probs[symbol], bit);
+ } while (symbol != 1);
+
+ return price;
+}
+
+static void
+length_update_prices(lzma_length_encoder *lc, const uint32_t pos_state)
+{
+ const uint32_t table_size = lc->table_size;
+ lc->counters[pos_state] = table_size;
+
+ const uint32_t a0 = rc_bit_0_price(lc->choice);
+ const uint32_t a1 = rc_bit_1_price(lc->choice);
+ const uint32_t b0 = a1 + rc_bit_0_price(lc->choice2);
+ const uint32_t b1 = a1 + rc_bit_1_price(lc->choice2);
+ uint32_t *const prices = lc->prices[pos_state];
+
+ uint32_t i;
+ for (i = 0; i < table_size && i < (1 << 3); ++i)
+ prices[i] = a0 + rc_bittree_price(lc->low[pos_state],
+ 3, i);
+
+ for (; i < table_size && i < (1 << 3) + (1 << 3); ++i)
+ prices[i] = b0 + rc_bittree_price(lc->mid[pos_state],
+ 3, i - (1 << 3));
+
+ for (; i < table_size; ++i)
+ prices[i] = b1 + rc_bittree_price(lc->high, 8,
+ i - (1 << 3) - (1 << 3));
+
+ return;
+}
+
+static inline void
+length(lzma_range_encoder *rc, lzma_length_encoder *lc,
+ const uint32_t pos_state, uint32_t len, const _Bool fast_mode)
+{
+ len -= 2;
+
+ if (len < (1 << 3)) {
+ rc_bit(rc, &lc->choice, 0);
+ rc_bittree(rc, lc->low[pos_state], 3, len);
+ } else {
+ rc_bit(rc, &lc->choice, 1);
+ len -= (1 << 3);
+
+ if (len < (1 << 3)) {
+ rc_bit(rc, &lc->choice2, 0);
+ rc_bittree(rc, lc->mid[pos_state], 3, len);
+ } else {
+ rc_bit(rc, &lc->choice2, 1);
+ len -= (1 << 3);
+ rc_bittree(rc, lc->high, 8, len);
+ }
+ }
+
+ if (!fast_mode)
+ if (--lc->counters[pos_state] == 0)
+ length_update_prices(lc, pos_state);
+}
+
+static inline void
+rep_match(lzma_lzma1_encoder *coder, const uint32_t pos_state,
+ const uint32_t rep, const uint32_t len)
+{
+ if (rep == 0) {
+ rc_bit(&coder->rc, &coder->is_rep0[coder->state], 0);
+ rc_bit(&coder->rc,
+ &coder->is_rep0_long[coder->state][pos_state],
+ len != 1);
+ } else {
+ const uint32_t distance = coder->reps[rep];
+ rc_bit(&coder->rc, &coder->is_rep0[coder->state], 1);
+
+ if (rep == 1) {
+ rc_bit(&coder->rc, &coder->is_rep1[coder->state], 0);
+ } else {
+ rc_bit(&coder->rc, &coder->is_rep1[coder->state], 1);
+ rc_bit(&coder->rc, &coder->is_rep2[coder->state],
+ rep - 2);
+
+ if (rep == 3)
+ coder->reps[3] = coder->reps[2];
+
+ coder->reps[2] = coder->reps[1];
+ }
+
+ coder->reps[1] = coder->reps[0];
+ coder->reps[0] = distance;
+ }
+
+ if (len == 1) {
+ coder->state = ((coder->state) < 7 ? STATE_LIT_SHORTREP : STATE_NONLIT_REP);
+ } else {
+ length(&coder->rc, &coder->rep_len_encoder, pos_state, len,
+ coder->fast_mode);
+ coder->state = ((coder->state) < 7 ? STATE_LIT_LONGREP : STATE_NONLIT_REP);
+ }
+}
+
+// This array is constantly initialized in the original code. It's quite big
+// so we skip it.
+const uint8_t lzma_fastpos[1 << 13];
+
+static inline uint32_t
+get_dist_slot(uint32_t dist)
+{
+ if (dist < (1U << (13 + ((0) + (0) * (13 - 1)))))
+ return lzma_fastpos[dist];
+
+ if (dist < (1U << (13 + ((0) + (1) * (13 - 1)))))
+ return (uint32_t)(lzma_fastpos[(dist) >> ((0) + (1) * (13 - 1))]) + 2 * ((0) + (1) * (13 - 1));
+
+ return (uint32_t)(lzma_fastpos[(dist) >> ((0) + (2) * (13 - 1))]) + 2 * ((0) + (2) * (13 - 1));
+}
+
+static inline void
+rc_bittree_reverse(lzma_range_encoder *rc, probability *probs,
+ uint32_t bit_count, uint32_t symbol)
+{
+ uint32_t model_index = 1;
+ do {
+ const uint32_t bit = symbol & 1;
+ symbol >>= 1;
+ rc_bit(rc, &probs[model_index], bit);
+ model_index = (model_index << 1) + bit;
+ } while (--bit_count != 0);
+}
+
+static inline void
+rc_direct(lzma_range_encoder *rc, uint32_t value, uint32_t bit_count)
+{
+ do {
+ rc->symbols[rc->count++]
+ = RC_DIRECT_0 + ((value >> --bit_count) & 1);
+ } while (bit_count != 0);
+}
+
+static inline void
+match(lzma_lzma1_encoder *coder, const uint32_t pos_state,
+ const uint32_t distance, const uint32_t len)
+{
+ coder->state = ((coder->state) < 7 ? STATE_LIT_MATCH : STATE_NONLIT_MATCH);
+
+ length(&coder->rc, &coder->match_len_encoder, pos_state, len,
+ coder->fast_mode);
+
+ const uint32_t dist_slot = get_dist_slot(distance);
+ const uint32_t dist_state = ((len) < 4 + 2 ? (len) - 2 : 4 - 1);
+ rc_bittree(&coder->rc, coder->dist_slot[dist_state], 6, dist_slot);
+
+ if (dist_slot >= 4) {
+ const uint32_t footer_bits = (dist_slot >> 1) - 1;
+ const uint32_t base = (2 | (dist_slot & 1)) << footer_bits;
+ const uint32_t dist_reduced = distance - base;
+
+ if (dist_slot < 14) {
+ rc_bittree_reverse(&coder->rc, coder->dist_special + base - dist_slot - 1,
+ footer_bits, dist_reduced);
+ } else {
+ rc_direct(&coder->rc, dist_reduced >> 4,
+ footer_bits - 4);
+ rc_bittree_reverse(
+ &coder->rc, coder->dist_align,
+ 4, dist_reduced & ((1 << 4) - 1));
+ ++coder->align_price_count;
+ }
+ }
+
+ coder->reps[3] = coder->reps[2];
+ coder->reps[2] = coder->reps[1];
+ coder->reps[1] = coder->reps[0];
+ coder->reps[0] = distance;
+ ++coder->match_price_count;
+}
+
+static void
+encode_symbol(lzma_lzma1_encoder *coder, lzma_mf *mf,
+ uint32_t back, uint32_t len, uint32_t position)
+{
+ const uint32_t pos_state = position & coder->pos_mask;
+
+ if (back == (4294967295U)) {
+ rc_bit(&coder->rc,
+ &coder->is_match[coder->state][pos_state], 0);
+ literal(coder, mf, position);
+ } else {
+ rc_bit(&coder->rc,
+ &coder->is_match[coder->state][pos_state], 1);
+
+ if (back < 4) {
+ rc_bit(&coder->rc, &coder->is_rep[coder->state], 1);
+ rep_match(coder, pos_state, back, len);
+ } else {
+ rc_bit(&coder->rc, &coder->is_rep[coder->state], 0);
+ match(coder, pos_state, back - 4, len);
+ }
+ }
+ mf->read_ahead -= len;
+}
+
+static void
+encode_eopm(lzma_lzma1_encoder *coder, uint32_t position)
+{
+ const uint32_t pos_state = position & coder->pos_mask;
+ rc_bit(&coder->rc, &coder->is_match[coder->state][pos_state], 1);
+ rc_bit(&coder->rc, &coder->is_rep[coder->state], 0);
+ match(coder, pos_state, (4294967295U), 2);
+}
+
+static inline void
+rc_flush(lzma_range_encoder *rc)
+{
+ for (size_t i = 0; i < 5; ++i)
+ rc->symbols[rc->count++] = RC_FLUSH;
+}
+
+extern void exit (int __status)
+ __attribute__ ((__nothrow__ , __leaf__ , __noreturn__));
+
+extern lzma_ret
+lzma_lzma_encode(lzma_lzma1_encoder *restrict coder, lzma_mf *restrict mf,
+ uint8_t *restrict out, size_t *restrict out_pos,
+ size_t out_size, uint32_t limit)
+{
+
+ if (!coder->is_initialized && !encode_init(coder, mf))
+ return LZMA_OK;
+
+ uint32_t position = mf_position(mf);
+
+ while (1) {
+ if (rc_encode(&coder->rc, out, out_pos, out_size)) {
+ return LZMA_OK;
+ }
+
+ if (limit != (4294967295U)
+ && (mf->read_pos - mf->read_ahead >= limit
+ || *out_pos + rc_pending(&coder->rc)
+ >= (1U << 16) - ((1 << 12) + 1)))
+ break;
+
+ if (mf->read_pos >= mf->read_limit) {
+ if (mf->action == LZMA_RUN)
+ return LZMA_OK;
+
+
+ if (mf->read_ahead == 0)
+ break;
+ }
+ uint32_t len;
+ uint32_t back;
+
+ if (coder->fast_mode)
+ lzma_lzma_optimum_fast(coder, mf, &back, &len);
+ else
+ // The original code contains the call to
+ // lzma_lzma_optimum_normal(coder, mf, &back, &len, position);
+ exit (-1);
+
+ encode_symbol(coder, mf, back, len, position);
+
+ position += len;
+ }
+
+ if (!coder->is_flushed) {
+ coder->is_flushed = 1;
+ if (limit == (4294967295U))
+ encode_eopm(coder, position);
+
+ rc_flush(&coder->rc);
+
+ if (rc_encode(&coder->rc, out, out_pos, out_size)) {
+ return LZMA_OK;
+ }
+ }
+
+ coder->is_flushed = 0;
+ return LZMA_STREAM_END;
+}
+
+extern void
+lzma_free(void *ptr, const lzma_allocator *allocator)
+{
+ if (allocator != ((void *)0) && allocator->free != ((void *)0))
+ allocator->free(allocator->opaque, ptr);
+ else
+ free(ptr);
+ return;
+}
+
+static _Bool
+lz_encoder_prepare(lzma_mf *mf, const lzma_allocator *allocator,
+ const lzma_lz_options *lz_options)
+{
+ if (lz_options->dict_size < 4096U
+ || lz_options->dict_size
+ > (1U << 30) + (1U << 29)
+ || lz_options->nice_len > lz_options->match_len_max)
+ return 1;
+
+ mf->keep_size_before = lz_options->before_size + lz_options->dict_size;
+ mf->keep_size_after = lz_options->after_size
+ + lz_options->match_len_max;
+ uint32_t reserve = lz_options->dict_size / 2;
+ if (reserve > (1U << 30))
+ reserve /= 2;
+
+ reserve += (lz_options->before_size + lz_options->match_len_max
+ + lz_options->after_size) / 2 + (1U << 19);
+
+ const uint32_t old_size = mf->size;
+ mf->size = mf->keep_size_before + reserve + mf->keep_size_after;
+
+ if ((mf->buffer != ((void *)0)) && old_size != mf->size) {
+ lzma_free(mf->buffer, allocator);
+ mf->buffer = ((void *)0);
+ }
+
+ mf->match_len_max = lz_options->match_len_max;
+ mf->nice_len = lz_options->nice_len;
+ mf->cyclic_size = lz_options->dict_size + 1;
+
+ switch (lz_options->match_finder) {
+ case LZMA_MF_HC3:
+ mf->find = &lzma_mf_hc3_find;
+ mf->skip = &lzma_mf_hc3_skip;
+ break;
+
+ case LZMA_MF_HC4:
+ mf->find = &lzma_mf_hc4_find;
+ mf->skip = &lzma_mf_hc4_skip;
+ break;
+
+ case LZMA_MF_BT2:
+ mf->find = &lzma_mf_bt2_find;
+ mf->skip = &lzma_mf_bt2_skip;
+ break;
+
+ case LZMA_MF_BT3:
+ mf->find = &lzma_mf_bt3_find;
+ mf->skip = &lzma_mf_bt3_skip;
+ break;
+
+ case LZMA_MF_BT4:
+ mf->find = &lzma_mf_bt4_find;
+ mf->skip = &lzma_mf_bt4_skip;
+ break;
+
+ default:
+ return 1;
+ }
+
+ const uint32_t hash_bytes = lz_options->match_finder & 0x0F;
+ if (hash_bytes > mf->nice_len)
+ return 1;
+
+ const _Bool is_bt = (lz_options->match_finder & 0x10) != 0;
+ uint32_t hs;
+
+ if (hash_bytes == 2) {
+ hs = 0xFFFF;
+ } else {
+ hs = lz_options->dict_size - 1;
+ hs |= hs >> 1;
+ hs |= hs >> 2;
+ hs |= hs >> 4;
+ hs |= hs >> 8;
+ hs >>= 1;
+ hs |= 0xFFFF;
+
+ if (hs > (1U << 24)) {
+ if (hash_bytes == 3)
+ hs = (1U << 24) - 1;
+ else
+ hs >>= 1;
+ }
+ }
+
+ mf->hash_mask = hs;
+
+ ++hs;
+ if (hash_bytes > 2)
+ hs += (1U << 10);
+ if (hash_bytes > 3)
+ hs += (1U << 16);
+
+ const uint32_t old_hash_count = mf->hash_count;
+ const uint32_t old_sons_count = mf->sons_count;
+ mf->hash_count = hs;
+ mf->sons_count = mf->cyclic_size;
+ if (is_bt)
+ mf->sons_count *= 2;
+
+ if (old_hash_count != mf->hash_count
+ || old_sons_count != mf->sons_count) {
+ lzma_free(mf->hash, allocator);
+ mf->hash = ((void *)0);
+
+ lzma_free(mf->son, allocator);
+ mf->son = ((void *)0);
+ }
+
+ mf->depth = lz_options->depth;
+ if (mf->depth == 0) {
+ if (is_bt)
+ mf->depth = 16 + mf->nice_len / 2;
+ else
+ mf->depth = 4 + mf->nice_len / 4;
+ }
+
+ return 0;
+}
+
+int
+main ()
+{
+ lzma_mf mf;
+ lzma_allocator allocator;
+ lzma_lz_options lz_options;
+
+ void *coder;
+ uint8_t *restrict out;
+ size_t *restrict out_pos;
+ size_t out_size;
+
+ lz_encoder_prepare(&mf, &allocator, &lz_options);
+ return (int) lzma_lzma_encode(coder, &mf, out, out_pos, out_size, (4294967295U));
+}
+
+
+/* { dg-final { scan-wpa-ipa-dump "Save results of indirect call analysis." "icp"} } */
+/* { dg-final { scan-wpa-ipa-dump-times "For call" 2 "icp"} } */
+/* { dg-final { scan-wpa-ipa-dump-times "Insert 0 prefetch stmt:" 5 "ipa_prefetch"} } */
+/* { dg-final { scan-wpa-ipa-dump-times "Insert 1 prefetch stmt:" 4 "ipa_prefetch"} } */
+/* { dg-final { scan-wpa-ipa-dump-times "Insert 2 prefetch stmt:" 2 "ipa_prefetch"} } */
--
2.33.0
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。