blast.c File Reference

#include <stddef.h>
#include <setjmp.h>
#include "blast.h"

Go to the source code of this file.

Classes
struct	state
struct	huffman

Macros
#define	local   static /* for local function definitions */
#define	MAXBITS   13 /* maximum code length */
#define	MAXWIN   4096 /* maximum window size */

Functions
int	bits (struct state *s, int need)
int	decode (struct state *s, struct huffman *h)
int	construct (struct huffman *h, const unsigned char *rep, int n)
int	decomp (struct state *s)
int	blast (blast_in infun, void *inhow, blast_out outfun, void *outhow, unsigned *left, unsigned char **in)

Macro Definition Documentation

local

#define local   static /* for local function definitions */

Definition at line 36 of file blast.c.

MAXBITS

#define MAXBITS   13 /* maximum code length */

Definition at line 37 of file blast.c.

MAXWIN

#define MAXWIN   4096 /* maximum window size */

Definition at line 38 of file blast.c.

Function Documentation

bits()

int bits	(	struct state *	s,
		int	need
	)

Definition at line 72 of file blast.c.

{
    int val;            /* bit accumulator */
 
    /* load at least need bits into val */
    val = s->bitbuf;
    while (s->bitcnt < need) {
        if (s->left == 0) {
            s->left = s->infun(s->inhow, &(s->in));
            if (s->left == 0) longjmp(s->env, 1);       /* out of input */
        }
        val |= (int)(*(s->in)++) << s->bitcnt;          /* load eight bits */
        s->left--;
        s->bitcnt += 8;
    }
 
    /* drop need bits and update buffer, always zero to seven bits left */
    s->bitbuf = val >> need;
    s->bitcnt -= need;
 
    /* return need bits, zeroing the bits above that */
    return val & ((1 << need) - 1);
}

References int, s, and val.

Referenced by __print_stack_cb(), add_sub(), addpoint(), address_bits(), adjust_unsigned(), anop_esil(), assemble(), autocmplt_bits_plugin(), bfd_get_bits(), bfm(), bic(), binary(), bitfield(), bits_hint_acc_cb(), DotZLib.Info::bitSize(), bitwise(), bl(), branch(), cb_asmarch(), cb_asmbits(), cbz(), cls(), clz(), cmd_analysis_trampoline(), cmp(), core_bin_file_print(), countLeadingZeros(), create(), cset(), csinc(), decode_add(), decode_arith(), decode_call(), decode_cmpeq(), decode_cmpgte(), decode_cmplte(), decode_cmpugte(), decode_cmpulte(), decode_div(), decode_divu(), decode_jmp(), decode_mul(), decode_mulu(), decode_not(), decode_sub(), decomp(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), deflatePending(), deflatePrime(), ds_print_data_type(), entries(), esil_mem_addeq_n(), esil_mem_andeq_n(), esil_mem_deceq_n(), esil_mem_diveq_n(), esil_mem_inceq_n(), esil_mem_lsleq_n(), esil_mem_lsreq_n(), esil_mem_modeq_n(), esil_mem_muleq_n(), esil_mem_oreq_n(), esil_mem_subeq_n(), esil_mem_xoreq_n(), esil_peek_n(), esil_poke_n(), examine(), expand_1st_key(), expand_2nd_key(), expand_subkey(), extr(), extract_binobj(), filter_reg_items(), fixedtables(), gdbr_get_reg_profile(), gdbr_set_architecture(), gen_bitlen(), gen_codes(), genmask(), get_bits(), get_category_t(), get_dwarf_reg_name(), get_symbols(), get_symbols_list(), getvalue(), gzip_normalize(), handle_arm_hint(), handleHints(), has_bits(), inflate(), inflate_fast(), inflate_table(), inflate_table9(), inflateBack(), inflateBack9(), inflatePrime(), info(), insert_offset(), is_arm_thumb_hack(), ldr(), libps_decode(), load_effect(), load_omf_symb(), lunpipe(), madd(), main(), mov(), movk(), movn(), mrs(), msr(), mul(), mvn(), newEntry(), number_of_bits(), omf_count_symb(), op_fillval(), opmov(), parse_struct_node(), parse_union_node(), parseDragons(), patch_capstone_bugs(), print_assembly_output(), print_bits_hint_cb(), process_constructors(), rasm_asm(), rasm_disasm(), rbit(), rc_direct_price(), reloc_target_size(), rotateAsmBits(), rz_analysis_data(), rz_analysis_function_setbits_handler(), rz_analysis_hint_set_bits(), rz_analysis_hint_set_bits_handler(), rz_analysis_hint_set_newbits(), rz_analysis_set_bits(), rz_analysis_set_triplet(), rz_arm_cs_analysis_op_64_esil(), rz_asm_set_arch(), rz_asm_set_bits(), rz_asm_setup(), rz_asn1_stringify_oid(), rz_bin_arch_options_init(), rz_bin_elf_fix_arm_thumb_object(), rz_bin_file_find_by_arch_bits(), rz_bin_object_find_by_arch_bits(), rz_bin_p9_get_arch(), rz_bin_pe_get_bits(), rz_bin_select(), rz_bin_select_object(), rz_bin_use_arch(), rz_bp_get_bytes(), rz_bp_size(), rz_bp_size_at(), rz_bp_traptrace_add(), rz_bv_hash(), rz_cmd_help(), rz_core_analysis_cc_init(), rz_core_analysis_hasrefs_to_depth(), rz_core_analysis_hint_print(), rz_core_analysis_sigdb_apply(), rz_core_analysis_sigdb_print(), rz_core_analysis_type_init(), rz_core_arch_bits_at(), rz_core_arg_get(), rz_core_asm_plugin_print(), rz_core_bin_apply_all_info(), rz_core_bin_info_print(), rz_core_bin_load(), rz_core_bin_set_arch_bits(), rz_core_bin_update_arch_bits(), rz_core_cmd_subst_i(), rz_core_egg_setup(), rz_core_file_reopen_debug(), rz_core_file_reopen_remote_debug(), rz_core_hack_arm(), rz_core_rtr_gdb_run(), rz_core_seek_arch_bits(), rz_core_set_asm_configs(), rz_coresym_cache_element_new(), rz_debug_bochs_reg_profile(), rz_debug_gdb_attach(), rz_debug_gdb_reg_profile(), rz_debug_gdb_reg_write(), rz_debug_qnx_attach(), rz_debug_qnx_reg_profile(), rz_debug_qnx_reg_write(), rz_debug_set_arch(), rz_egg_Cfile_parser(), rz_egg_Cfile_set_cEnv(), rz_egg_patch_num(), rz_egg_setup(), rz_main_rz_asm(), rz_main_rz_bin(), rz_main_rz_gg(), rz_mem_copybits(), rz_mem_copybits_delta(), rz_open_arch_bits_handler(), rz_project_migrate_v4_v5(), rz_read_be_double(), rz_read_be_float(), rz_read_le_double(), rz_read_le_float(), rz_read_me_double(), rz_read_me_float(), rz_str_utf16_to_utf8(), rz_syscall_setup(), rz_test_load_asm_test_file(), rz_test_run_asm_test(), rz_type_db_init(), rz_type_db_set_bits(), rz_write_be_double(), rz_write_be_float(), rz_write_le_double(), rz_write_le_float(), rz_write_me_double(), rz_write_me_float(), saturate(), saturate_signed(), saturate_signed_to_range(), saturate_unsigned(), sbfx(), sdiv(), set_default_type(), set_src_dst(), set_tmp_bits(), setab(), shift(), sign_ext(), sign_extend(), smaddl(), smulh(), smull(), str(), string_scan_range_cfstring(), sxt(), syscall_reload_needed(), sysregs_reload_needed(), tbz(), tr_static_init(), tst(), typeString(), udiv(), update_asmbits_options(), update_bits_range(), update_reg_list_regbits(), utf16be_to_utf8_impl(), winkd_get_profile(), and xtr_metadata_match().

blast()

int blast	(	blast_in	infun,
		void *	inhow,
		blast_out	outfun,
		void *	outhow,
		unsigned *	left,
		unsigned char **	in
	)

Definition at line 383 of file blast.c.

{
    struct state s;             /* input/output state */
    int err;                    /* return value */
 
    /* initialize input state */
    s.infun = infun;
    s.inhow = inhow;
    if (left != NULL && *left) {
        s.left = *left;
        s.in = *in;
    }
    else
        s.left = 0;
    s.bitbuf = 0;
    s.bitcnt = 0;
 
    /* initialize output state */
    s.outfun = outfun;
    s.outhow = outhow;
    s.next = 0;
    s.first = 1;
 
    /* return if bits() or decode() tries to read past available input */
    if (setjmp(s.env) != 0)             /* if came back here via longjmp(), */
        err = 2;                        /*  then skip decomp(), return error */
    else
        err = decomp(&s);               /* decompress */
 
    /* return unused input */
    if (left != NULL)
        *left = s.left;
    if (in != NULL)
        *in = s.left ? s.in : NULL;
 
    /* write any leftover output and update the error code if needed */
    if (err != 1 && s.next && s.outfun(s.outhow, s.out, s.next) && err == 0)
        err = 1;
    return err;
}

References decomp(), err, in, state::infun, state::inhow, state::left, NULL, state::outfun, state::outhow, and s.

construct()

int construct	(	struct huffman *	h,
		const unsigned char *	rep,
		int	n
	)

Definition at line 191 of file blast.c.

{
    int symbol;         /* current symbol when stepping through length[] */
    int len;            /* current length when stepping through h->count[] */
    int left;           /* number of possible codes left of current length */
    short offs[MAXBITS+1];      /* offsets in symbol table for each length */
    short length[256];  /* code lengths */
 
    /* convert compact repeat counts into symbol bit length list */
    symbol = 0;
    do {
        len = *rep++;
        left = (len >> 4) + 1;
        len &= 15;
        do {
            length[symbol++] = len;
        } while (--left);
    } while (--n);
    n = symbol;
 
    /* count number of codes of each length */
    for (len = 0; len <= MAXBITS; len++)
        h->count[len] = 0;
    for (symbol = 0; symbol < n; symbol++)
        (h->count[length[symbol]])++;   /* assumes lengths are within bounds */
    if (h->count[0] == n)               /* no codes! */
        return 0;                       /* complete, but decode() will fail */
 
    /* check for an over-subscribed or incomplete set of lengths */
    left = 1;                           /* one possible code of zero length */
    for (len = 1; len <= MAXBITS; len++) {
        left <<= 1;                     /* one more bit, double codes left */
        left -= h->count[len];          /* deduct count from possible codes */
        if (left < 0) return left;      /* over-subscribed--return negative */
    }                                   /* left > 0 means incomplete */
 
    /* generate offsets into symbol table for each length for sorting */
    offs[1] = 0;
    for (len = 1; len < MAXBITS; len++)
        offs[len + 1] = offs[len] + h->count[len];
 
    /*
     * put symbols in table sorted by length, by symbol order within each
     * length
     */
    for (symbol = 0; symbol < n; symbol++)
        if (length[symbol] != 0)
            h->symbol[offs[length[symbol]]++] = symbol;
 
    /* return zero for complete set, positive for incomplete set */
    return left;
}

References h, len, length, MAXBITS, and n.

Referenced by decomp().

decode()

int decode	(	struct state *	s,
		struct huffman *	h
	)

Definition at line 129 of file blast.c.

{
    int len;            /* current number of bits in code */
    int code;           /* len bits being decoded */
    int first;          /* first code of length len */
    int count;          /* number of codes of length len */
    int index;          /* index of first code of length len in symbol table */
    int bitbuf;         /* bits from stream */
    int left;           /* bits left in next or left to process */
    short *next;        /* next number of codes */
 
    bitbuf = s->bitbuf;
    left = s->bitcnt;
    code = first = index = 0;
    len = 1;
    next = h->count + 1;
    while (1) {
        while (left--) {
            code |= (bitbuf & 1) ^ 1;   /* invert code */
            bitbuf >>= 1;
            count = *next++;
            if (code < first + count) { /* if length len, return symbol */
                s->bitbuf = bitbuf;
                s->bitcnt = (s->bitcnt - len) & 7;
                return h->symbol[index + (code - first)];
            }
            index += count;             /* else update for next length */
            first += count;
            first <<= 1;
            code <<= 1;
            len++;
        }
        left = (MAXBITS+1) - len;
        if (left == 0) break;
        if (s->left == 0) {
            s->left = s->infun(s->inhow, &(s->in));
            if (s->left == 0) longjmp(s->env, 1);       /* out of input */
        }
        bitbuf = *(s->in)++;
        s->left--;
        if (left > 8) left = 8;
    }
    return -9;                          /* ran out of codes */
}

References code, count, h, len, MAXBITS, and s.

Referenced by decomp().

decomp()

int decomp

(

struct state *

s

)

Definition at line 282 of file blast.c.

{
    int lit;            /* true if literals are coded */
    int dict;           /* log2(dictionary size) - 6 */
    int symbol;         /* decoded symbol, extra bits for distance */
    int len;            /* length for copy */
    unsigned dist;      /* distance for copy */
    int copy;           /* copy counter */
    unsigned char *from, *to;   /* copy pointers */
    static int virgin = 1;                              /* build tables once */
    static short litcnt[MAXBITS+1], litsym[256];        /* litcode memory */
    static short lencnt[MAXBITS+1], lensym[16];         /* lencode memory */
    static short distcnt[MAXBITS+1], distsym[64];       /* distcode memory */
    static struct huffman litcode = {litcnt, litsym};   /* length code */
    static struct huffman lencode = {lencnt, lensym};   /* length code */
    static struct huffman distcode = {distcnt, distsym};/* distance code */
        /* bit lengths of literal codes */
    static const unsigned char litlen[] = {
        11, 124, 8, 7, 28, 7, 188, 13, 76, 4, 10, 8, 12, 10, 12, 10, 8, 23, 8,
        9, 7, 6, 7, 8, 7, 6, 55, 8, 23, 24, 12, 11, 7, 9, 11, 12, 6, 7, 22, 5,
        7, 24, 6, 11, 9, 6, 7, 22, 7, 11, 38, 7, 9, 8, 25, 11, 8, 11, 9, 12,
        8, 12, 5, 38, 5, 38, 5, 11, 7, 5, 6, 21, 6, 10, 53, 8, 7, 24, 10, 27,
        44, 253, 253, 253, 252, 252, 252, 13, 12, 45, 12, 45, 12, 61, 12, 45,
        44, 173};
        /* bit lengths of length codes 0..15 */
    static const unsigned char lenlen[] = {2, 35, 36, 53, 38, 23};
        /* bit lengths of distance codes 0..63 */
    static const unsigned char distlen[] = {2, 20, 53, 230, 247, 151, 248};
    static const short base[16] = {     /* base for length codes */
        3, 2, 4, 5, 6, 7, 8, 9, 10, 12, 16, 24, 40, 72, 136, 264};
    static const char extra[16] = {     /* extra bits for length codes */
        0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8};
 
    /* set up decoding tables (once--might not be thread-safe) */
    if (virgin) {
        construct(&litcode, litlen, sizeof(litlen));
        construct(&lencode, lenlen, sizeof(lenlen));
        construct(&distcode, distlen, sizeof(distlen));
        virgin = 0;
    }
 
    /* read header */
    lit = bits(s, 8);
    if (lit > 1) return -1;
    dict = bits(s, 8);
    if (dict < 4 || dict > 6) return -2;
 
    /* decode literals and length/distance pairs */
    do {
        if (bits(s, 1)) {
            /* get length */
            symbol = decode(s, &lencode);
            len = base[symbol] + bits(s, extra[symbol]);
            if (len == 519) break;              /* end code */
 
            /* get distance */
            symbol = len == 2 ? 2 : dict;
            dist = decode(s, &distcode) << symbol;
            dist += bits(s, symbol);
            dist++;
            if (s->first && dist > s->next)
                return -3;              /* distance too far back */
 
            /* copy length bytes from distance bytes back */
            do {
                to = s->out + s->next;
                from = to - dist;
                copy = MAXWIN;
                if (s->next < dist) {
                    from += copy;
                    copy = dist;
                }
                copy -= s->next;
                if (copy > len) copy = len;
                len -= copy;
                s->next += copy;
                do {
                    *to++ = *from++;
                } while (--copy);
                if (s->next == MAXWIN) {
                    if (s->outfun(s->outhow, s->out, s->next)) return 1;
                    s->next = 0;
                    s->first = 0;
                }
            } while (len != 0);
        }
        else {
            /* get literal and write it */
            symbol = lit ? decode(s, &litcode) : bits(s, 8);
            s->out[s->next++] = symbol;
            if (s->next == MAXWIN) {
                if (s->outfun(s->outhow, s->out, s->next)) return 1;
                s->next = 0;
                s->first = 0;
            }
        }
    } while (1);
    return 0;
}

References bits(), construct(), decode(), from, len, MAXBITS, MAXWIN, s, huffman::symbol, and to.

Referenced by blast().