mem.c File Reference

#include <rz_util.h>

Go to the source code of this file.

Macros
#define	SET_BIT(p, n)   ((p) |= (1 << (n)))
#define	CLR_BIT(p, n)   ((p) &= (~(1) << (n)))

Functions
RZ_API int	rz_mem_count (const ut8 **addr)
RZ_API int	rz_mem_eq (const ut8 *a, const ut8 *b, int len)
	Compares memory a with b over len bytes. More...
RZ_API void	rz_mem_copyloop (ut8 *dest, const ut8 *orig, int dsize, int osize)
RZ_API void *	rz_mem_copy (void *dest, size_t dmax, const void *src, size_t smax)
RZ_API int	rz_mem_cmp_mask (const ut8 *dest, const ut8 *orig, const ut8 *mask, int len)
RZ_API void	rz_mem_copybits (ut8 *dst, const ut8 *src, int bits)
static char	readbit (const ut8 *src, int bitoffset)
static void	writebit (ut8 *dst, int i, bool c)
RZ_API void	rz_mem_copybits_delta (ut8 *dst, int doff, const ut8 *src, int soff, int bits)
RZ_API ut64	rz_mem_get_num (const ut8 *b, int size)
RZ_API int	rz_mem_set_num (ut8 *dest, int dest_size, ut64 num)
RZ_API void	rz_mem_swaporcopy (ut8 *dest, const ut8 *src, int len, bool big_endian)
RZ_API void	rz_mem_swapendian (ut8 *dest, const ut8 *orig, int size)
RZ_API const ut8 *	rz_mem_mem (const ut8 *haystack, int hlen, const ut8 *needle, int nlen)
RZ_API const ut8 *	rz_mem_mem_aligned (const ut8 *haystack, int hlen, const ut8 *needle, int nlen, int align)
RZ_API int	rz_mem_protect (void *ptr, int size, const char *prot)
RZ_API void *	rz_mem_dup (const void *s, int l)
RZ_API void	rz_mem_reverse (ut8 *b, int l)
RZ_API bool	rz_mem_is_printable (const ut8 *a, int la)
RZ_API bool	rz_mem_is_zero (const ut8 *b, int l)
RZ_API void *	rz_mem_alloc (int sz)
RZ_API void	rz_mem_free (void *p)
RZ_API void	rz_mem_memzero (void *dst, size_t l)

Macro Definition Documentation

CLR_BIT

#define CLR_BIT	(		p,
			n
	)		((p) &= (~(1) << (n)))

Definition at line 12 of file mem.c.

SET_BIT

#define SET_BIT	(		p,
			n
	)		((p) |= (1 << (n)))

Definition at line 11 of file mem.c.

Function Documentation

readbit()

static char readbit ( const ut8 *  src, int  bitoffset  )

inlinestatic

Definition at line 120 of file mem.c.

                                                          {
    const int wholeBytes = bitoffset / 8;
    const int remainingBits = bitoffset % 8;
    // return (src[wholeBytes] >> remainingBits) & 1;
    return (src[wholeBytes] & 1 << remainingBits);
}

References src.

Referenced by rz_mem_copybits_delta().

rz_mem_alloc()

RZ_API void* rz_mem_alloc

(

int

sz

)

Definition at line 357 of file mem.c.

                                  {
    return calloc(sz, 1);
}

References calloc().

Referenced by parse_type_string().

rz_mem_cmp_mask()

RZ_API int rz_mem_cmp_mask	(	const ut8 *	dest,
		const ut8 *	orig,
		const ut8 *	mask,
		int	len
	)

Definition at line 58 of file mem.c.

                                                                                       {
    ut8 *mdest = malloc(len);
    if (!mdest) {
        return -1;
    }
    ut8 *morig = malloc(len);
    if (!morig) {
        free(mdest);
        return -1;
    }
    int i;
    for (i = 0; i < len; i++) {
        mdest[i] = dest[i] & mask[i];
        morig[i] = orig[i] & mask[i];
    }
    int ret = memcmp(mdest, morig, len);
    free(mdest);
    free(morig);
    return ret;
}

References dest, free(), i, len, malloc(), and mask.

rz_mem_copy()

RZ_API void* rz_mem_copy	(	void *	dest,
		size_t	dmax,
		const void *	src,
		size_t	smax
	)

Definition at line 50 of file mem.c.

                                                                                {
    if (!smax || !dmax) {
        return NULL;
    }
    rz_return_val_if_fail(dest && src, NULL);
    return memcpy(dest, src, (smax < dmax) ? smax : dmax);
}

References dest, memcpy(), NULL, rz_return_val_if_fail, and src.

Referenced by rz_debug_add_checkpoint(), trace_hook_mem_read(), and trace_hook_mem_write().

rz_mem_copybits()

RZ_API void rz_mem_copybits	(	ut8 *	dst,
		const ut8 *	src,
		int	bits
	)

Definition at line 79 of file mem.c.

                                                                {
    ut8 srcmask, dstmask;
    int bytes = (int)(bits / 8);
    bits = bits % 8;
    memcpy(dst, src, bytes);
    if (bits) {
        srcmask = dstmask = 0;
        switch (bits) {
        case 1:
            srcmask = 0x80;
            dstmask = 0x7f;
            break;
        case 2:
            srcmask = 0xc0;
            dstmask = 0x3f;
            break;
        case 3:
            srcmask = 0xe0;
            dstmask = 0x1f;
            break;
        case 4:
            srcmask = 0xf0;
            dstmask = 0x0f;
            break;
        case 5:
            srcmask = 0xf8;
            dstmask = 0x07;
            break;
        case 6:
            srcmask = 0xfc;
            dstmask = 0x03;
            break;
        case 7:
            srcmask = 0xfe;
            dstmask = 0x01;
            break;
        }
        dst[bytes] = ((dst[bytes] & dstmask) | (src[bytes] & srcmask));
    }
}

References bits(), bytes, dst, int, memcpy(), and src.

Referenced by rz_reg_set_double(), rz_reg_set_longdouble(), and rz_reg_set_value().

rz_mem_copybits_delta()

RZ_API void rz_mem_copybits_delta	(	ut8 *	dst,
		int	doff,
		const ut8 *	src,
		int	soff,
		int	bits
	)

Definition at line 141 of file mem.c.

                                                                                          {
    int i;
    if (doff < 0 || soff < 0 || !dst || !src) {
        return;
    }
    for (i = 0; i < bits; i++) {
        bool c = readbit(src, i + soff);
        writebit(dst, i + doff, c);
    }
}

References bits(), c, dst, i, readbit(), src, and writebit().

Referenced by rz_asm_disassemble(), and rz_read_me27().

rz_mem_copyloop()

RZ_API void rz_mem_copyloop	(	ut8 *	dest,
		const ut8 *	orig,
		int	dsize,
		int	osize
	)

Definition at line 41 of file mem.c.

                                                                              {
    int i = 0, j;
    while (i < dsize) {
        for (j = 0; j < osize && i < dsize; j++) {
            dest[i++] = orig[j];
        }
    }
}

References dest, and i.

Referenced by rz_core_write_block().

rz_mem_count()

RZ_API int rz_mem_count

(

const ut8 **

addr

)

Definition at line 15 of file mem.c.

                                          {
    int i = 0;
    while (*addr++) {
        i++;
    }
    return i;
}

References addr, and i.

rz_mem_dup()

RZ_API void* rz_mem_dup	(	const void *	s,
		int	l
	)

Definition at line 319 of file mem.c.

                                              {
    void *d = malloc(l);
    if (d) {
        memcpy(d, s, l);
    }
    return d;
}

References d, malloc(), memcpy(), and s.

Referenced by copy_into_flagitem_list(), debug_qnx_read_at(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), drain(), rz_bin_import_clone(), rz_core_cmd_foreach3(), rz_core_cmp_mem_data(), and rz_io_write_at().

rz_mem_eq()

RZ_API int rz_mem_eq	(	const ut8 *	a,
		const ut8 *	b,
		int	len
	)

Compares memory a with b over len bytes.

Parameters

a	Pointer to memory a.
b	Pointer to memory b.
len	Number of bytes to compare.

Returns

bool True if memory bytes in memory a and b match over len bytes. False otherwise.

Definition at line 31 of file mem.c.

                                                          {
    register int i;
    for (i = 0; i < len; i++) {
        if (a[i] != b[i]) {
            return false;
        }
    }
    return true;
}

References a, b, i, and len.

Referenced by rz_core_cmp_mem_data(), rz_core_cmp_mem_mem(), and rz_str_strchr().

rz_mem_free()

RZ_API void rz_mem_free

(

void *

p

)

Definition at line 361 of file mem.c.

                                 {
    free(p);
}

References free(), and p.

Referenced by rz_il_vm_add_mem().

rz_mem_get_num()

RZ_API ut64 rz_mem_get_num	(	const ut8 *	b,
		int	size
	)

Definition at line 152 of file mem.c.

                                                   {
    // LITTLE ENDIAN is the default for streams
    switch (size) {
    case 1:
        return rz_read_le8(b);
    case 2:
        return rz_read_le16(b);
    case 4:
        return rz_read_le32(b);
    case 8:
        return rz_read_le64(b);
    }
    return 0LL;
}

References b, rz_read_le16(), rz_read_le32(), rz_read_le64(), and rz_read_le8().

Referenced by is_number(), is_pointer(), and rz_core_analysis_data().

rz_mem_is_printable()

RZ_API bool rz_mem_is_printable	(	const ut8 *	a,
		int	la
	)

Definition at line 337 of file mem.c.

                                                      {
    int i;
    for (i = 0; i < la; i++) {
        if (a[i] != '\n' && a[i] != '\t' && !IS_PRINTABLE(a[i])) {
            return false;
        }
    }
    return true;
}

References a, i, and IS_PRINTABLE.

rz_mem_is_zero()

RZ_API bool rz_mem_is_zero	(	const ut8 *	b,
		int	l
	)

Definition at line 347 of file mem.c.

                                                {
    int i;
    for (i = 0; i < l; i++) {
        if (b[i]) {
            return false;
        }
    }
    return true;
}

References b, and i.

rz_mem_mem()

RZ_API const ut8* rz_mem_mem	(	const ut8 *	haystack,
		int	hlen,
		const ut8 *	needle,
		int	nlen
	)

Definition at line 246 of file mem.c.

                                                                                         {
    int i, until = hlen - nlen + 1;
    if (hlen < 1 || nlen < 1) {
        return NULL;
    }
    for (i = 0; i < until; i++) {
        if (!memcmp(haystack + i, needle, nlen)) {
            return haystack + i;
        }
    }
    return NULL;
}

References i, and NULL.

Referenced by binutils_assemble(), findPair(), rz_cmd_analysis(), rz_cons_memcat(), rz_cons_visual_write(), rz_str_replace_thunked(), rz_str_stripLine(), and visual_search().

rz_mem_mem_aligned()

RZ_API const ut8* rz_mem_mem_aligned	(	const ut8 *	haystack,
		int	hlen,
		const ut8 *	needle,
		int	nlen,
		int	align
	)

Definition at line 260 of file mem.c.

                                                                                                            {
    int i, until = hlen - nlen + 1;
    if (align < 1) {
        align = 1;
    }
    if (hlen < 1 || nlen < 1) {
        return NULL;
    }
    if (align > 1) {
        until -= (until % align);
    }
    for (i = 0; i < until; i += align) {
        if (!memcmp(haystack + i, needle, nlen)) {
            return haystack + i;
        }
    }
    return NULL;
}

References i, and NULL.

Referenced by ds_esc_str(), get_import_addr_mips(), and rz_str_escape_utf().

rz_mem_memzero()

RZ_API void rz_mem_memzero	(	void *	dst,
		size_t	l
	)

Definition at line 365 of file mem.c.

                                                {
#ifdef _MSC_VER
    RtlSecureZeroMemory(dst, l);
#else
#if HAVE_EXPLICIT_BZERO
    explicit_bzero(dst, l);
#elif HAVE_EXPLICIT_MEMSET
    (void)explicit_memset(dst, 0, l);
#else
    memset(dst, 0, l);
    __asm__ volatile("" ::"r"(dst)
             : "memory");
#endif
#endif
}

References dst, and memset().

Referenced by rz_MD5Final(), SHA256_End(), SHA256_Init(), SHA512_End(), SHA512_Final(), and SHA512_Init().

rz_mem_protect()

RZ_API int rz_mem_protect	(	void *	ptr,
		int	size,
		const char *	prot
	)

Definition at line 279 of file mem.c.

                                                                 {
#if __UNIX__
    int p = 0;
    if (strchr(prot, 'x')) {
        p |= PROT_EXEC;
    }
    if (strchr(prot, 'r')) {
        p |= PROT_READ;
    }
    if (strchr(prot, 'w')) {
        p |= PROT_WRITE;
    }
    if (mprotect(ptr, size, p) == -1) {
        return false;
    }
#elif __WINDOWS__
    int r, w, x;
    DWORD p = PAGE_NOACCESS;
    r = strchr(prot, 'r') ? 1 : 0;
    w = strchr(prot, 'w') ? 1 : 0;
    x = strchr(prot, 'x') ? 1 : 0;
    if (w && x) {
        return false;
    }
    if (x) {
        p = PAGE_EXECUTE_READ;
    } else if (w) {
        p = PAGE_READWRITE;
    } else if (r) {
        p = PAGE_READONLY;
    }
    if (!VirtualProtect(ptr, size, p, NULL)) {
        return false;
    }
#else
#warning Unknown platform
#endif
    return true;
}

References DWORD, mprotect, NULL, p, prot, PROT_EXEC, PROT_READ, PROT_WRITE, r, w, and x.

Referenced by rz_sys_run().

rz_mem_reverse()

RZ_API void rz_mem_reverse	(	ut8 *	b,
		int	l
	)

Definition at line 327 of file mem.c.

                                          {
    ut8 tmp;
    int i, end = l / 2;
    for (i = 0; i < end; i++) {
        tmp = b[i];
        b[i] = b[l - i - 1];
        b[l - i - 1] = tmp;
    }
}

References b, test_evm::end, i, and autogen_x86imm::tmp.

Referenced by rz_cmd_analysis().

rz_mem_set_num()

RZ_API int rz_mem_set_num	(	ut8 *	dest,
		int	dest_size,
		ut64	num
	)

Definition at line 168 of file mem.c.

                                                              {
    // LITTLE ENDIAN is the default for streams
    switch (dest_size) {
    case 1:
        rz_write_le8(dest, (ut8)(num & UT8_MAX));
        break;
    case 2:
        rz_write_le16(dest, (ut16)(num & UT16_MAX));
        break;
    case 4:
        rz_write_le32(dest, (ut32)(num & UT32_MAX));
        break;
    case 8:
        rz_write_le64(dest, num);
        break;
    default:
        return false;
    }
    return true;
}

References dest, num, rz_write_le16(), rz_write_le32(), rz_write_le64(), rz_write_le8(), UT16_MAX, UT32_MAX, and UT8_MAX.

Referenced by rz_analysis_value_set_ut64().

rz_mem_swapendian()

RZ_API void rz_mem_swapendian	(	ut8 *	dest,
		const ut8 *	orig,
		int	size
	)

Definition at line 202 of file mem.c.

                                                                    {
    ut8 buffer[8];
    switch (size) {
    case 1:
        *dest = *orig;
        break;
    case 2:
        *buffer = *orig;
        dest[0] = orig[1];
        dest[1] = buffer[0];
        break;
    case 3:
        *buffer = *orig;
        dest[0] = orig[2];
        dest[1] = orig[1];
        dest[2] = buffer[0];
        break;
    case 4:
        memcpy(buffer, orig, 4);
        dest[0] = buffer[3];
        dest[1] = buffer[2];
        dest[2] = buffer[1];
        dest[3] = buffer[0];
        break;
    case 8:
        memcpy(buffer, orig, 8);
        dest[0] = buffer[7];
        dest[1] = buffer[6];
        dest[2] = buffer[5];
        dest[3] = buffer[4];
        dest[4] = buffer[3];
        dest[5] = buffer[2];
        dest[6] = buffer[1];
        dest[7] = buffer[0];
        break;
    default:
        if (dest != orig) {
            memmove(dest, orig, size);
        }
    }
}

References dest, and memcpy().

Referenced by arm_assemble(), disassemble(), esil_peek_n(), filter(), format_output(), h8300_analysis_jmp(), h8300_analysis_jsr(), and rz_mem_swaporcopy().

rz_mem_swaporcopy()

RZ_API void rz_mem_swaporcopy	(	ut8 *	dest,
		const ut8 *	src,
		int	len,
		bool	big_endian
	)

Definition at line 192 of file mem.c.

                                                                                   {
    if (big_endian) {
        rz_mem_swapendian(dest, src, len);
    } else {
        memcpy(dest, src, len);
    }
}

References dest, len, memcpy(), rz_mem_swapendian(), and src.

Referenced by rz_print_hexdump_str(), rz_type_format_double(), and updateAddr().

writebit()

static void writebit ( ut8 *  dst, int  i, bool  c  )

inlinestatic

Definition at line 127 of file mem.c.

                                                     {
    const int byte = i / 8;
    const int bit = (i % 8);
    // eprintf ("Write %d %d = %d\n", byte, bit, c);
    dst += byte;
    if (c) {
        // dst[byte] |= (1 << bit);
        RZ_BIT_SET(dst, bit);
    } else {
        // dst[byte] &= (1 << bit);
        RZ_BIT_UNSET(dst, bit);
    }
}

References bit, c, dst, i, RZ_BIT_SET, and RZ_BIT_UNSET.

Referenced by rz_mem_copybits_delta().