hexagon_arch.c File Reference

#include <rz_asm.h>
#include <rz_analysis.h>
#include <rz_util.h>
#include "hexagon.h"
#include "hexagon_insn.h"
#include "hexagon_arch.h"

Go to the source code of this file.

Functions
static bool	is_last_instr (const ut8 parse_bits)
static bool	is_endloop0_pkt (const ut8 pb_hi_0, const ut8 pb_hi_1)
	Checks if packet ends hardware loop 0. More...
static bool	is_undoc_endloop0_pkt (const ut8 pb_hi_0, const ut8 pb_hi_1)
	Checks if packet ends hardware loop 0. But for an undocumented variant where the packet has only two instructions and the last one is a Duplex. More...
static bool	is_endloop1_pkt (const ut8 pb_hi_0, const ut8 pb_hi_1)
	Checks if packet ends hardware loop 1. More...
static bool	is_endloop01_pkt (const ut8 pb_hi_0, const ut8 pb_hi_1)
	Checks if packet ends hardware loop 0 and hw-loop 1. More...
static HexInsn *	hex_get_instr_at_addr (HexState *state, const ut32 addr)
	Gives the instruction at a given address from the state. More...
RZ_API ut8	hexagon_get_pkt_index_of_addr (const ut32 addr, const HexPkt *p)
	Returns the index of an addr in a given packet. More...
static void	hex_clear_pkt (RZ_NONNULL HexPkt *p)
	Clears a packet and sets its attributes to invalid values. More...
static HexPkt *	hex_get_stale_pkt (HexState *state)
	Gives the least used packet. More...
static HexPkt *	hex_get_pkt (HexState *state, const ut32 addr)
	Returns the packet which covers the given address. More...
RZ_API void	hex_insn_free (RZ_NULLABLE HexInsn *i)
	Frees an instruction. More...
RZ_API void	hex_const_ext_free (RZ_NULLABLE HexConstExt *ce)
	Frees an constant extender. More...
static ut8	get_state_pkt_index (HexState *state, const HexPkt *p)
	Get the index of a packet in the state. More...
RZ_API HexState *	hexagon_get_state ()
	Initializes each packet of the state once. More...
static bool	is_pkt_full (const HexPkt *p)
	Checks if the packet has 4 instructions set. More...
static char *	get_pkt_indicator (const bool utf8, const bool sdk, const bool prefix, HexPktSyntaxIndicator ind_type)
	Get the pkt indicator string. More...
static void	hex_set_pkt_info (const RzAsm *rz_asm, RZ_INOUT HexInsn *hi, const HexPkt *p, const ut8 k, const bool update_mnemonic)
	Sets the packet related information in an instruction. More...
RZ_API HexLoopAttr	hex_get_loop_flag (const HexPkt *p)
	Returns the loop type of a packet. Though only if this packet is the last packet in last packet in a hardware loop. Otherwise it returns HEX_NO_LOOP. More...
static void	make_next_packet_valid (HexState *state, const HexPkt *pkt)
	Sets the packet after pkt to valid and updates its mnemonic. More...
RZ_API HexInsn *	alloc_instr ()
	Allocates a new instruction on the heap. More...
static HexInsn *	hex_add_to_pkt (HexState *state, const HexInsn *new_ins, RZ_INOUT HexPkt *p, const ut8 k)
	Copies an instruction to the packet p at position k. More...
static HexInsn *	hex_to_new_pkt (HexState *state, const HexInsn *new_ins, const HexPkt *p, RZ_INOUT HexPkt *new_p)
	Cleans the packet new_p, copies the instruction new_ins and the attributes of p to it. More...
static HexInsn *	hex_add_to_stale_pkt (HexState *state, const HexInsn *new_ins)
	Cleans the least accessed packet and copies the given instruction into it. More...
static HexInsn *	hex_add_instr_to_state (HexState *state, const HexInsn *new_ins)
	Copies the given instruction to a state packet it belongs to. If the instruction does not fit to any packet, it will be written to a stale one. More...
static void	setup_new_instr (HexInsn *hi, const HexReversedOpcode *rz_reverse, const ut32 addr, const ut8 parse_bits)
	Set the up new instr. More...
static bool	imm_is_scaled (const HexOpAttr attr)
static HexConstExt *	get_const_ext_from_addr (const RzList *ce_list, const ut32 addr)
	Searched the constant extender in the ce_list, where addr is the key. More...
RZ_API void	hex_extend_op (HexState *state, RZ_INOUT HexOp *op, const bool set_new_extender, const ut32 addr)
	Applies the constant extender to the immediate value in op. More...
RZ_API void	hexagon_reverse_opcode (const RzAsm *rz_asm, HexReversedOpcode *rz_reverse, const ut8 *buf, const ut64 addr)
	Reverses a given opcode and copies the result into one of the rizin structs in rz_reverse. More...

Function Documentation

alloc_instr()

RZ_API HexInsn* alloc_instr

(

)

Allocates a new instruction on the heap.

Returns

HexInsn* The new instruction.

Definition at line 507 of file hexagon_arch.c.

                              {
    HexInsn *hi = calloc(1, sizeof(HexInsn));
    if (!hi) {
        RZ_LOG_FATAL("Could not allocate memory for new instruction.\n");
    }
 
    return hi;
}

References calloc(), hi(), and RZ_LOG_FATAL.

Referenced by hex_add_to_pkt(), hex_add_to_stale_pkt(), and hex_to_new_pkt().

get_const_ext_from_addr()

static HexConstExt* get_const_ext_from_addr ( const RzList *  ce_list, const ut32  addr  )

static

Searched the constant extender in the ce_list, where addr is the key.

Parameters

ce_list	The list with constant extender values.
addr	The address of the instruction which gets the constant extender applied.

Returns

HexConstExt* A const. ext., if there is one which should be applied on the instruction at addr. Otherwise NULL.

Definition at line 719 of file hexagon_arch.c.

                                                                                    {
    HexConstExt *ce = NULL;
    RzListIter *iter = NULL;
    rz_list_foreach (ce_list, iter, ce) {
        if (addr == ce->addr) {
            return ce;
        }
    }
    return NULL;
}

References HexConstExt::addr, addr, and NULL.

Referenced by hex_extend_op().

get_pkt_indicator()

static char* get_pkt_indicator ( const bool  utf8, const bool  sdk, const bool  prefix, HexPktSyntaxIndicator  ind_type  )

static

Get the pkt indicator string.

Parameters

utf8	True: Return UTF8 string. False: Return ASCII.
sdk	True: Return SDK conforming string ('{', '}', ':endloop0' etc.). False: Returns a non SDK conforming string
prefix	True: Return the prefix indicator. False: Return the postfix. If there is no prefix/postfix for a given indicator type (e.g. for the utf8 version of 'endloop01') it returns an empty string.
ind_type	The
prefix

Returns

char* The indicator string according to the given flags.

Definition at line 262 of file hexagon_arch.c.

                                                                                                                   {
    switch (ind_type) {
    default:
        return "";
    case SINGLE_IN_PKT:
        if (prefix) {
            if (sdk) {
                return HEX_PKT_FIRST_SDK;
            } else {
                return utf8 ? HEX_PKT_SINGLE_UTF8 : HEX_PKT_SINGLE;
            }
        } else {
            if (sdk) {
                return HEX_PKT_LAST_SDK;
            }
        }
        break;
    case FIRST_IN_PKT:
        if (!prefix) {
            break;
        }
        if (sdk) {
            return HEX_PKT_FIRST_SDK;
        }
        if (utf8) {
            return HEX_PKT_FIRST_UTF8;
        } else {
            return HEX_PKT_FIRST;
        }
        break;
    case MID_IN_PKT:
        if (!prefix) {
            break;
        }
        if (sdk) {
            return HEX_PKT_SDK_PADDING;
        }
        if (utf8) {
            return HEX_PKT_MID_UTF8;
        } else {
            return HEX_PKT_MID;
        }
        break;
    case LAST_IN_PKT:
        if (prefix) {
            if (sdk) {
                return HEX_PKT_SDK_PADDING;
            }
            if (utf8) {
                return HEX_PKT_LAST_UTF8;
            } else {
                return HEX_PKT_LAST;
            }
        } else {
            if (sdk) {
                return HEX_PKT_LAST_SDK;
            }
        }
        break;
    case ELOOP_0_PKT:
        if (prefix) {
            break;
        }
        if (sdk) {
            return HEX_PKT_ELOOP_0_SDK;
        }
        if (utf8) {
            return HEX_PKT_ELOOP_0_UTF8;
        } else {
            return HEX_PKT_ELOOP_0;
        }
        break;
    case ELOOP_1_PKT:
        if (prefix) {
            break;
        }
        if (sdk) {
            return HEX_PKT_ELOOP_1_SDK;
        }
        if (utf8) {
            return HEX_PKT_ELOOP_1_UTF8;
        } else {
            return HEX_PKT_ELOOP_1;
        }
        break;
    case ELOOP_01_PKT:
        if (prefix) {
            break;
        }
        if (sdk) {
            return HEX_PKT_ELOOP_01_SDK;
        }
        if (utf8) {
            return HEX_PKT_ELOOP_01_UTF8;
        } else {
            return HEX_PKT_ELOOP_01;
        }
        break;
    }
    return "";
}

References ELOOP_01_PKT, ELOOP_0_PKT, ELOOP_1_PKT, FIRST_IN_PKT, HEX_PKT_ELOOP_0, HEX_PKT_ELOOP_01, HEX_PKT_ELOOP_01_SDK, HEX_PKT_ELOOP_01_UTF8, HEX_PKT_ELOOP_0_SDK, HEX_PKT_ELOOP_0_UTF8, HEX_PKT_ELOOP_1, HEX_PKT_ELOOP_1_SDK, HEX_PKT_ELOOP_1_UTF8, HEX_PKT_FIRST, HEX_PKT_FIRST_SDK, HEX_PKT_FIRST_UTF8, HEX_PKT_LAST, HEX_PKT_LAST_SDK, HEX_PKT_LAST_UTF8, HEX_PKT_MID, HEX_PKT_MID_UTF8, HEX_PKT_SDK_PADDING, HEX_PKT_SINGLE, HEX_PKT_SINGLE_UTF8, LAST_IN_PKT, MID_IN_PKT, prefix, and SINGLE_IN_PKT.

Referenced by hex_set_pkt_info().

get_state_pkt_index()

static ut8 get_state_pkt_index ( HexState *  state, const HexPkt *  p  )

static

Get the index of a packet in the state.

Parameters

state	The state to operade on.
p	The packet whichs index should be determined.

Returns

ut8 The index of the packet in the given state. UT8_MAX if it is not in the state.

Definition at line 201 of file hexagon_arch.c.

                                                                 {
    HexPkt *sp;
    for (ut8 i = 0; i < HEXAGON_STATE_PKTS; ++i) {
        sp = &state->pkts[i];
        if (sp->pkt_addr == p->pkt_addr) {
            return i;
        }
    }
    return UT8_MAX;
}

References HEXAGON_STATE_PKTS, i, p, sp, and UT8_MAX.

Referenced by hex_add_instr_to_state().

hex_add_instr_to_state()

static HexInsn* hex_add_instr_to_state ( HexState *  state, const HexInsn *  new_ins  )

static

Copies the given instruction to a state packet it belongs to. If the instruction does not fit to any packet, it will be written to a stale one.

The instruction must have its address and parse bits set!

Parameters

state	The state to operade on.
new_ins	The instruction to be copied.

Returns

The pointer to the added instruction. Null if the instruction could not be copied.

Definition at line 615 of file hexagon_arch.c.

                                                                                {
    if (!new_ins) {
        return NULL;
    }
    bool add_to_pkt = false;
    bool new_pkt = false;
    bool write_to_stale_pkt = false;
    bool insert_before_pkt_hi = false;
    ut8 k = 0; // New instruction position in packet.
 
    HexPkt *p;
    if (new_ins->addr == 0x0) {
        return hex_add_to_stale_pkt(state, new_ins);
    }
 
    for (ut8 i = 0; i < HEXAGON_STATE_PKTS; ++i, k = 0) {
        p = &(state->pkts[i]);
 
        HexInsn *pkt_instr = NULL; // Instructions already in the packet.
        RzListIter *iter = NULL;
        rz_list_foreach (p->insn, iter, pkt_instr) {
            if (new_ins->addr == (pkt_instr->addr - 4)) {
                // Instruction preceeds one in the packet.
                if (is_last_instr(new_ins->parse_bits) || is_pkt_full(p)) {
                    write_to_stale_pkt = true;
                    break;
                } else {
                    insert_before_pkt_hi = true;
                    add_to_pkt = true;
                    break;
                }
            } else if (new_ins->addr == (pkt_instr->addr + 4)) {
                if (is_last_instr(pkt_instr->parse_bits) || is_pkt_full(p)) {
                    new_pkt = true;
                    break;
                } else {
                    add_to_pkt = true;
                    break;
                }
            }
            ++k;
        }
        if (add_to_pkt || new_pkt || write_to_stale_pkt) {
            break;
        }
    }
 
    // Add the instruction to packet p
    if (add_to_pkt) {
        if (insert_before_pkt_hi) {
            return hex_add_to_pkt(state, new_ins, p, k);
        }
        return hex_add_to_pkt(state, new_ins, p, k + 1);
 
    } else if (new_pkt) {
        ut8 ni = (get_state_pkt_index(state, p) + 1) % HEXAGON_STATE_PKTS;
        return hex_to_new_pkt(state, new_ins, p, &state->pkts[ni]);
    } else {
        return hex_add_to_stale_pkt(state, new_ins);
    }
}

References HexInsn::addr, get_state_pkt_index(), hex_add_to_pkt(), hex_add_to_stale_pkt(), hex_to_new_pkt(), HEXAGON_STATE_PKTS, i, is_last_instr(), is_pkt_full(), k, NULL, p, and HexInsn::parse_bits.

Referenced by hexagon_reverse_opcode().

hex_add_to_pkt()

static HexInsn* hex_add_to_pkt ( HexState *  state, const HexInsn *  new_ins, RZ_INOUT HexPkt *  p, const ut8  k  )

static

Copies an instruction to the packet p at position k.

Parameters

state	The state to operade on.
new_ins	The instruction to copy.
p	The packet in which the instruction will hold the instruction.
k	The index of the instruction in the packet.

Returns

HexInsn* Pointer to the copied instruction on the heap.

Definition at line 525 of file hexagon_arch.c.

                                                                                                         {
    if (k > 3) {
        RZ_LOG_FATAL("Instruction could not be set! A packet can only hold four instructions but k=%d.", k);
    }
    HexInsn *hi = alloc_instr();
    memcpy(hi, new_ins, sizeof(HexInsn));
    rz_list_insert(p->insn, k, hi);
 
    if (k == 0) {
        p->pkt_addr = hi->addr;
    }
    p->last_instr_present |= is_last_instr(hi->parse_bits);
    ut32 p_l = rz_list_length(p->insn);
    hex_set_pkt_info(&state->rz_asm, hi, p, k, false);
    if (k == 0 && p_l > 1) {
        // Update the instruction which was previously the first one.
        hex_set_pkt_info(&state->rz_asm, rz_list_get_n(p->insn, 1), p, 1, true);
    }
    p->last_access = rz_time_now();
    if (p->last_instr_present) {
        make_next_packet_valid(state, p);
    }
    return hi;
}

References alloc_instr(), hex_set_pkt_info(), hi(), is_last_instr(), k, make_next_packet_valid(), memcpy(), p, rz_list_get_n(), rz_list_insert(), rz_list_length(), RZ_LOG_FATAL, and rz_time_now().

Referenced by hex_add_instr_to_state().

hex_add_to_stale_pkt()

static HexInsn* hex_add_to_stale_pkt ( HexState *  state, const HexInsn *  new_ins  )

static

Cleans the least accessed packet and copies the given instruction into it.

Parameters

state	The state to operade on.
new_ins	The instruction to copy.

Returns

HexInsn* Pointer to the copied instruction on the heap.

Definition at line 586 of file hexagon_arch.c.

                                                                              {
    HexPkt *p = hex_get_stale_pkt(state);
    hex_clear_pkt(p);
 
    HexInsn *hi = alloc_instr();
    memcpy(hi, new_ins, sizeof(HexInsn));
    rz_list_insert(p->insn, 0, hi);
 
    p->last_instr_present |= is_last_instr(hi->parse_bits);
    p->pkt_addr = new_ins->addr;
    // p->is_valid = true; // Setting it true also detects a lot of data as valid assembly.
    p->last_access = rz_time_now();
    hex_set_pkt_info(&state->rz_asm, hi, p, 0, false);
    if (p->last_instr_present) {
        make_next_packet_valid(state, p);
    }
    return hi;
}

References HexInsn::addr, alloc_instr(), hex_clear_pkt(), hex_get_stale_pkt(), hex_set_pkt_info(), hi(), is_last_instr(), make_next_packet_valid(), memcpy(), p, rz_list_insert(), and rz_time_now().

Referenced by hex_add_instr_to_state().

hex_clear_pkt()

static void hex_clear_pkt ( RZ_NONNULL HexPkt *  p )

static

Clears a packet and sets its attributes to invalid values.

Parameters

p	The packet to clear.

Definition at line 123 of file hexagon_arch.c.

                                                {
    p->last_instr_present = false;
    p->is_valid = false;
    p->last_access = 0;
    rz_list_purge(p->insn);
}

References p, and rz_list_purge().

Referenced by hex_add_to_stale_pkt(), hex_to_new_pkt(), and hexagon_get_state().

hex_const_ext_free()

RZ_API void hex_const_ext_free

(

RZ_NULLABLE HexConstExt *

ce

)

Frees an constant extender.

Parameters

ce	The constant extender to be freed.

Definition at line 187 of file hexagon_arch.c.

                                                            {
    if (!ce) {
        return;
    }
    free(ce);
}

References free().

Referenced by hexagon_get_state().

hex_extend_op()

RZ_API void hex_extend_op	(	HexState *	state,
		RZ_INOUT HexOp *	op,
		const bool	set_new_extender,
		const ut32	addr
	)

Applies the constant extender to the immediate value in op.

Parameters

state	The state to operade on.
op	The operand the extender is applied to or taken from.
set_new_extender	True if the immediate value of the op comes from immext() and sets the a new constant extender. False otherwise.
addr	The address of the currently disassembled instruction.

Definition at line 738 of file hexagon_arch.c.

                                                                                                             {
    if (rz_list_length(state->const_ext_l) > MAX_CONST_EXT) {
        rz_list_purge(state->const_ext_l);
    }
 
    if (op->type != HEX_OP_TYPE_IMM) {
        return;
    }
 
    HexConstExt *ce;
    if (set_new_extender) {
        ce = calloc(1, sizeof(HexConstExt));
        ce->addr = addr + 4;
        ce->const_ext = op->op.imm;
        rz_list_append(state->const_ext_l, ce);
        return;
    }
 
    ce = get_const_ext_from_addr(state->const_ext_l, addr);
    if (ce) {
        op->op.imm = imm_is_scaled(op->attr) ? (op->op.imm >> op->shift) : op->op.imm;
        op->op.imm = ((op->op.imm & 0x3F) | ce->const_ext);
        rz_list_delete_data(state->const_ext_l, ce);
        return;
    }
}

References HexConstExt::addr, addr, calloc(), HexConstExt::const_ext, get_const_ext_from_addr(), HEX_OP_TYPE_IMM, imm_is_scaled(), MAX_CONST_EXT, rz_list_append(), rz_list_delete_data(), rz_list_length(), and rz_list_purge().

Referenced by hex_disasm_with_templates().

hex_get_instr_at_addr()

static HexInsn* hex_get_instr_at_addr ( HexState *  state, const ut32  addr  )

static

Gives the instruction at a given address from the state.

Parameters

state	The state to operade on.
addr	The address of the instruction.

Returns

Pointer to instruction or NULL if none was found.

Definition at line 80 of file hexagon_arch.c.

                                                                        {
    HexPkt *p;
    for (ut8 i = 0; i < HEXAGON_STATE_PKTS; ++i) {
        p = &state->pkts[i];
        HexInsn *pi = NULL;
        RzListIter *iter = NULL;
        rz_list_foreach (p->insn, iter, pi) {
            if (addr == pi->addr) {
                p->last_access = rz_time_now();
                return pi;
            }
        }
    }
    return NULL;
}

References HexInsn::addr, addr, HEXAGON_STATE_PKTS, i, NULL, p, and rz_time_now().

Referenced by hexagon_reverse_opcode().

hex_get_loop_flag()

RZ_API HexLoopAttr hex_get_loop_flag

(

const HexPkt *

p

)

Returns the loop type of a packet. Though only if this packet is the last packet in last packet in a hardware loop. Otherwise it returns HEX_NO_LOOP.

Parameters

p	The instruction packet.

Returns

HexLoopAttr The loop type this packet belongs to.

Definition at line 446 of file hexagon_arch.c.

                                                      {
    if (!p || rz_list_length(p->insn) < 2) {
        return HEX_NO_LOOP;
    }
 
    ut8 pb_0 = ((HexInsn *)rz_list_get_n(p->insn, 0))->parse_bits;
    ut8 pb_1 = ((HexInsn *)rz_list_get_n(p->insn, 1))->parse_bits;
 
    if (is_endloop0_pkt(pb_0, pb_1)) {
        return HEX_LOOP_0;
    } else if (is_endloop1_pkt(pb_0, pb_1)) {
        return HEX_LOOP_1;
    } else if (is_endloop01_pkt(pb_0, pb_1)) {
        return HEX_LOOP_01;
    } else if (is_undoc_endloop0_pkt(pb_0, pb_1)) {
        RZ_LOG_VERBOSE("Undocumented hardware loop 0 endloop packet.");
        return HEX_LOOP_0;
    } else {
        return HEX_NO_LOOP;
    }
}

References HEX_LOOP_0, HEX_LOOP_01, HEX_LOOP_1, HEX_NO_LOOP, is_endloop01_pkt(), is_endloop0_pkt(), is_endloop1_pkt(), is_undoc_endloop0_pkt(), p, rz_list_get_n(), rz_list_length(), and RZ_LOG_VERBOSE.

Referenced by hex_set_pkt_info(), and hexagon_disasm_instruction().

hex_get_pkt()

static HexPkt* hex_get_pkt ( HexState *  state, const ut32  addr  )

static

Returns the packet which covers the given address.

Parameters

state	The state to operade on.
addr	The address of an instruction.

Returns

HexPkt* The packet to which this address belongs to or NULL if no packet was found.

Definition at line 155 of file hexagon_arch.c.

                                                             {
    HexPkt *p = NULL;
    HexInsn *pi = NULL;
    RzListIter *iter = NULL;
    for (ut8 i = 0; i < HEXAGON_STATE_PKTS; ++i) {
        p = &state->pkts[i];
        rz_list_foreach (p->insn, iter, pi) {
            if (addr == pi->addr) {
                return p;
            }
        }
    }
    return NULL;
}

References HexInsn::addr, addr, HEXAGON_STATE_PKTS, i, NULL, and p.

Referenced by hexagon_reverse_opcode().

hex_get_stale_pkt()

static HexPkt* hex_get_stale_pkt ( HexState *  state )

static

Gives the least used packet.

Parameters

state

The state to operade on.

Returns

HexPkt* Pointer to the least used packet.

Definition at line 136 of file hexagon_arch.c.

                                                  {
    HexPkt *stale_state_pkt = &state->pkts[0];
    ut64 oldest = UT64_MAX;
 
    for (ut8 i = 0; i < HEXAGON_STATE_PKTS; ++i) {
        if (state->pkts[i].last_access < oldest) {
            stale_state_pkt = &state->pkts[i];
        }
    }
    return stale_state_pkt;
}

References HEXAGON_STATE_PKTS, i, ut64(), and UT64_MAX.

Referenced by hex_add_to_stale_pkt().

hex_insn_free()

RZ_API void hex_insn_free

(

RZ_NULLABLE HexInsn *

i

)

Frees an instruction.

Parameters

i	The instruction to be freed.

Definition at line 175 of file hexagon_arch.c.

                                                  {
    if (!i) {
        return;
    }
    free(i);
}

References free(), and i.

Referenced by hexagon_get_state().

hex_set_pkt_info()

static void hex_set_pkt_info ( const RzAsm *  rz_asm, RZ_INOUT HexInsn *  hi, const HexPkt *  p, const ut8  k, const bool  update_mnemonic  )

static

Sets the packet related information in an instruction.

Parameters

hi	The instruction.
p	The packet the instruction belongs to.
k	The index of the instruction within the packet.

Definition at line 371 of file hexagon_arch.c.

                                                                                                                                  {
    rz_return_if_fail(hi && p);
    bool is_first = (k == 0);
    HexPktInfo *hi_pi = &hi->pkt_info;
    HexState *state = hexagon_get_state();
    bool sdk_form = rz_config_get_b(state->cfg, "plugins.hexagon.sdk");
 
    strncpy(hi_pi->mnem_postfix, "", 16);
    // Parse instr. position in pkt
    if (is_first && is_last_instr(hi->parse_bits)) { // Single instruction packet.
        hi_pi->first_insn = true;
        hi_pi->last_insn = true;
        if (p->is_valid) {
            strncpy(hi_pi->mnem_prefix, get_pkt_indicator(rz_asm->utf8, sdk_form, true, SINGLE_IN_PKT), 8);
            if (sdk_form) {
                strncpy(hi_pi->mnem_postfix, get_pkt_indicator(rz_asm->utf8, sdk_form, false, SINGLE_IN_PKT), 8);
            }
        } else {
            strncpy(hi_pi->mnem_prefix, HEX_PKT_UNK, 8);
        }
    } else if (is_first) {
        hi_pi->first_insn = true;
        hi_pi->last_insn = false;
        if (p->is_valid) {
            strncpy(hi_pi->mnem_prefix, get_pkt_indicator(rz_asm->utf8, sdk_form, true, FIRST_IN_PKT), 8);
        } else {
            strncpy(hi_pi->mnem_prefix, HEX_PKT_UNK, 8);
        }
    } else if (is_last_instr(hi->parse_bits)) {
        hi_pi->first_insn = false;
        hi_pi->last_insn = true;
        if (p->is_valid) {
            strncpy(hi_pi->mnem_prefix, get_pkt_indicator(rz_asm->utf8, sdk_form, true, LAST_IN_PKT), 8);
            if (sdk_form) {
                strncpy(hi_pi->mnem_postfix, get_pkt_indicator(rz_asm->utf8, sdk_form, false, LAST_IN_PKT), 8);
            }
 
            switch (hex_get_loop_flag(p)) {
            default:
                break;
            case HEX_LOOP_01:
                strncat(hi_pi->mnem_postfix, get_pkt_indicator(rz_asm->utf8, sdk_form, false, ELOOP_01_PKT), 23 - strlen(hi_pi->mnem_postfix));
                break;
            case HEX_LOOP_0:
                strncat(hi_pi->mnem_postfix, get_pkt_indicator(rz_asm->utf8, sdk_form, false, ELOOP_0_PKT), 23 - strlen(hi_pi->mnem_postfix));
                break;
            case HEX_LOOP_1:
                strncat(hi_pi->mnem_postfix, get_pkt_indicator(rz_asm->utf8, sdk_form, false, ELOOP_1_PKT), 23 - strlen(hi_pi->mnem_postfix));
                break;
            }
        } else {
            strncpy(hi_pi->mnem_prefix, HEX_PKT_UNK, 8);
        }
    } else {
        hi_pi->first_insn = false;
        hi_pi->last_insn = false;
        if (p->is_valid) {
            strncpy(hi_pi->mnem_prefix, get_pkt_indicator(rz_asm->utf8, sdk_form, true, MID_IN_PKT), 8);
        } else {
            strncpy(hi_pi->mnem_prefix, HEX_PKT_UNK, 8);
        }
    }
    if (update_mnemonic) {
        sprintf(hi->mnem, "%s%s%s", hi_pi->mnem_prefix, hi->mnem_infix, hi_pi->mnem_postfix);
    }
}

References ELOOP_01_PKT, ELOOP_0_PKT, ELOOP_1_PKT, FIRST_IN_PKT, HexPktInfo::first_insn, get_pkt_indicator(), hex_get_loop_flag(), HEX_LOOP_0, HEX_LOOP_01, HEX_LOOP_1, HEX_PKT_UNK, hexagon_get_state(), hi(), is_last_instr(), k, LAST_IN_PKT, HexPktInfo::last_insn, MID_IN_PKT, HexPktInfo::mnem_postfix, HexPktInfo::mnem_prefix, p, rz_config_get_b(), rz_return_if_fail, SINGLE_IN_PKT, sprintf, and rz_asm_t::utf8.

Referenced by hex_add_to_pkt(), hex_add_to_stale_pkt(), hex_to_new_pkt(), and make_next_packet_valid().

hex_to_new_pkt()

static HexInsn* hex_to_new_pkt ( HexState *  state, const HexInsn *  new_ins, const HexPkt *  p, RZ_INOUT HexPkt *  new_p  )

static

Cleans the packet new_p, copies the instruction new_ins and the attributes of p to it.

Parameters

state	The state to operade on.
new_ins	The instruction to copy.
p	The old packet which attributes are copied to the new one.
new_p	The new packet will hold the instruction.

Returns

HexInsn* Pointer to the copied instruction on the heap.

Definition at line 559 of file hexagon_arch.c.

                                                                                                                 {
    hex_clear_pkt(new_p);
 
    HexInsn *hi = alloc_instr();
    memcpy(hi, new_ins, sizeof(HexInsn));
    rz_list_insert(new_p->insn, 0, hi);
 
    new_p->last_instr_present |= is_last_instr(hi->parse_bits);
    new_p->hw_loop0_addr = p->hw_loop0_addr;
    new_p->hw_loop1_addr = p->hw_loop1_addr;
    new_p->is_valid = (p->is_valid || p->last_instr_present);
    new_p->pkt_addr = hi->addr;
    new_p->last_access = rz_time_now();
    hex_set_pkt_info(&state->rz_asm, hi, new_p, 0, false);
    if (new_p->last_instr_present) {
        make_next_packet_valid(state, new_p);
    }
    return hi;
}

References alloc_instr(), hex_clear_pkt(), hex_set_pkt_info(), hi(), is_last_instr(), make_next_packet_valid(), memcpy(), p, rz_list_insert(), and rz_time_now().

Referenced by hex_add_instr_to_state().

hexagon_get_pkt_index_of_addr()

RZ_API ut8 hexagon_get_pkt_index_of_addr	(	const ut32	addr,
		const HexPkt *	p
	)

Returns the index of an addr in a given packet.

Parameters

addr	Address of an instruction.
p	The packet. to search in.

Returns

ut8 The index of the addr if it is in the packet. UT8_MAX otherwise.

Definition at line 103 of file hexagon_arch.c.

                                                                           {
    rz_return_val_if_fail(p, UT8_MAX);
 
    HexInsn *hi = NULL;
    RzListIter *it = NULL;
    ut8 i = 0;
    rz_list_foreach (p->insn, it, hi) {
        if (hi->addr == addr) {
            return i;
        }
        ++i;
    }
    return UT8_MAX;
}

References addr, hi(), i, NULL, p, rz_return_val_if_fail, and UT8_MAX.

Referenced by resolve_n_register().

hexagon_get_state()

RZ_API HexState* hexagon_get_state

(

)

Initializes each packet of the state once.

Returns

The initialized state of the plugins.

Definition at line 217 of file hexagon_arch.c.

                                     {
    static HexState *state = NULL;
    if (state) {
        return state;
    }
 
    state = calloc(1, sizeof(HexState));
    if (!state) {
        RZ_LOG_FATAL("Could not allocate memory for HexState!");
    }
    for (int i = 0; i < HEXAGON_STATE_PKTS; ++i) {
        state->pkts[i].insn = rz_list_newf((RzListFree)hex_insn_free);
        if (!state->pkts[i].insn) {
            RZ_LOG_FATAL("Could not initialize instruction list!");
        }
        hex_clear_pkt(&(state->pkts[i]));
    }
    state->const_ext_l = rz_list_newf((RzListFree)hex_const_ext_free);
    return state;
}

References calloc(), hex_clear_pkt(), hex_const_ext_free(), hex_insn_free(), HEXAGON_STATE_PKTS, i, NULL, rz_list_newf(), and RZ_LOG_FATAL.

Referenced by hex_set_pkt_info(), and hexagon_reverse_opcode().

hexagon_reverse_opcode()

RZ_API void hexagon_reverse_opcode	(	const RzAsm *	rz_asm,
		HexReversedOpcode *	rz_reverse,
		const ut8 *	buf,
		const ut64	addr
	)

Reverses a given opcode and copies the result into one of the rizin structs in rz_reverse.

Parameters

rz_reverse	Rizin core structs which store asm and analysis information.
buf	The buffer which stores the current opcode.
addr	The address of the current opcode.

Definition at line 772 of file hexagon_arch.c.

                                                                                                                        {
    HexState *state = hexagon_get_state();
    if (!state) {
        RZ_LOG_FATAL("HexState was NULL.");
    }
    if (rz_asm) {
        memcpy(&state->rz_asm, rz_asm, sizeof(RzAsm));
    }
    HexInsn *hi = hex_get_instr_at_addr(state, addr);
    if (hi) {
        // Opcode was already reversed and is still in the state. Copy the result and return.
        switch (rz_reverse->action) {
        default:
            memcpy(rz_reverse->asm_op, &(hi->asm_op), sizeof(RzAsmOp));
            memcpy(rz_reverse->ana_op, &(hi->ana_op), sizeof(RzAnalysisOp));
            rz_strbuf_set(&rz_reverse->asm_op->buf_asm, hi->mnem);
            rz_reverse->asm_op->asm_toks = rz_asm_tokenize_asm_regex(&rz_reverse->asm_op->buf_asm, state->token_patterns);
            rz_reverse->asm_op->asm_toks->op_type = hi->ana_op.type;
            return;
        case HEXAGON_DISAS:
            memcpy(rz_reverse->asm_op, &(hi->asm_op), sizeof(RzAsmOp));
            rz_strbuf_set(&rz_reverse->asm_op->buf_asm, hi->mnem);
            rz_reverse->asm_op->asm_toks = rz_asm_tokenize_asm_regex(&rz_reverse->asm_op->buf_asm, state->token_patterns);
            rz_reverse->asm_op->asm_toks->op_type = hi->ana_op.type;
            return;
        case HEXAGON_ANALYSIS:
            memcpy(rz_reverse->ana_op, &(hi->ana_op), sizeof(RzAnalysisOp));
            return;
        }
    }
 
    ut32 data = rz_read_le32(buf);
    ut8 parse_bits = (data & 0x0000c000) >> 14;
    HexInsn instr = { 0 };
    setup_new_instr(&instr, rz_reverse, addr, parse_bits);
    // Add to state
    hi = hex_add_instr_to_state(state, &instr);
    if (!hi) {
        return;
    }
    HexPkt *p = hex_get_pkt(state, hi->addr);
 
    // Do disasassembly and analysis
    hexagon_disasm_instruction(state, data, hi, p);
 
    switch (rz_reverse->action) {
    default:
        memcpy(rz_reverse->asm_op, &hi->asm_op, sizeof(RzAsmOp));
        memcpy(rz_reverse->ana_op, &hi->ana_op, sizeof(RzAnalysisOp));
        rz_strbuf_set(&rz_reverse->asm_op->buf_asm, hi->mnem);
        rz_reverse->asm_op->asm_toks = rz_asm_tokenize_asm_regex(&rz_reverse->asm_op->buf_asm, state->token_patterns);
        rz_reverse->asm_op->asm_toks->op_type = hi->ana_op.type;
        break;
    case HEXAGON_DISAS:
        memcpy(rz_reverse->asm_op, &hi->asm_op, sizeof(RzAsmOp));
        rz_strbuf_set(&rz_reverse->asm_op->buf_asm, hi->mnem);
        rz_reverse->asm_op->asm_toks = rz_asm_tokenize_asm_regex(&rz_reverse->asm_op->buf_asm, state->token_patterns);
        rz_reverse->asm_op->asm_toks->op_type = hi->ana_op.type;
        break;
    case HEXAGON_ANALYSIS:
        memcpy(rz_reverse->ana_op, &hi->ana_op, sizeof(RzAnalysisOp));
        break;
    }
}

References HexReversedOpcode::action, addr, HexReversedOpcode::ana_op, HexReversedOpcode::asm_op, rz_asm_op_t::asm_toks, rz_asm_op_t::buf_asm, hex_add_instr_to_state(), hex_get_instr_at_addr(), hex_get_pkt(), HEXAGON_ANALYSIS, HEXAGON_DISAS, hexagon_disasm_instruction(), hexagon_get_state(), hi(), memcpy(), RzAsmTokenString::op_type, p, rz_asm_tokenize_asm_regex(), RZ_LOG_FATAL, rz_read_le32(), rz_strbuf_set(), and setup_new_instr().

Referenced by hexagon_v6_op().

imm_is_scaled()

static bool imm_is_scaled ( const HexOpAttr  attr )

inlinestatic

Definition at line 708 of file hexagon_arch.c.

                                                       {
    return (attr & HEX_OP_IMM_SCALED);
}

References HEX_OP_IMM_SCALED.

Referenced by hex_extend_op().

is_endloop01_pkt()

static bool is_endloop01_pkt ( const ut8  pb_hi_0, const ut8  pb_hi_1  )

inlinestatic

Checks if packet ends hardware loop 0 and hw-loop 1.

Parameters

pb_hi_0	Parse bits instruction 0.
pb_hi_1	Parse bits instruction 1.

Returns

true Packet ends hardware loop 0 and hw-loop 1.

false Packet does not end hardware loop 0 and hw-loop 1.

Definition at line 69 of file hexagon_arch.c.

                                                                          {
    return ((pb_hi_0 == 0x2) && (pb_hi_1 == 0x2));
}

Referenced by hex_get_loop_flag().

is_endloop0_pkt()

static bool is_endloop0_pkt ( const ut8  pb_hi_0, const ut8  pb_hi_1  )

inlinestatic

Checks if packet ends hardware loop 0.

Parameters

pb_hi_0	Parse bits instruction 0.
pb_hi_1	Parse bits instruction 1.

Returns

true Packet ends hardware loop 0.

false Packet does not end hardware loop 0.

Definition at line 32 of file hexagon_arch.c.

                                                                         {
    return ((pb_hi_0 == 0x2) && ((pb_hi_1 == 0x1) || (pb_hi_1 == 0x3)));
}

Referenced by hex_get_loop_flag().

is_endloop1_pkt()

static bool is_endloop1_pkt ( const ut8  pb_hi_0, const ut8  pb_hi_1  )

inlinestatic

Checks if packet ends hardware loop 1.

Parameters

pb_hi_0	Parse bits instruction 0.
pb_hi_1	Parse bits instruction 1.

Returns

true Packet ends hardware loop 1.

false Packet does not end hardware loop 1.

Definition at line 57 of file hexagon_arch.c.

                                                                         {
    return ((pb_hi_0 == 0x1) && (pb_hi_1 == 0x2));
}

Referenced by hex_get_loop_flag().

is_last_instr()

static bool is_last_instr ( const ut8  parse_bits )

inlinestatic

Definition at line 19 of file hexagon_arch.c.

                                                       {
    // Duplex instr. (parse bits = 0) are always the last.
    return ((parse_bits == 0x3) || (parse_bits == 0x0));
}

Referenced by hex_add_instr_to_state(), hex_add_to_pkt(), hex_add_to_stale_pkt(), hex_set_pkt_info(), and hex_to_new_pkt().

is_pkt_full()

static bool is_pkt_full ( const HexPkt *  p )

inlinestatic

Checks if the packet has 4 instructions set.

Parameters

p	The packet to check.

Returns

true The packet stores already 4 instructions.

false The packet stores less than 4 instructions.

Definition at line 245 of file hexagon_arch.c.

                                                {
    return rz_list_length(p->insn) >= 4;
}

References p, and rz_list_length().

Referenced by hex_add_instr_to_state().

is_undoc_endloop0_pkt()

static bool is_undoc_endloop0_pkt ( const ut8  pb_hi_0, const ut8  pb_hi_1  )

inlinestatic

Checks if packet ends hardware loop 0. But for an undocumented variant where the packet has only two instructions and the last one is a Duplex.

Parameters

pb_hi_0	Parse bits instruction 0.
pb_hi_1	Parse bits instruction 1 (duplex and end of packet).

Returns

true Packet ends hardware loop 0.

false Packet does not end hardware loop 0.

Definition at line 45 of file hexagon_arch.c.

                                                                               {
    return ((pb_hi_0 == 0x2) && (pb_hi_1 == 0x0));
}

Referenced by hex_get_loop_flag().

make_next_packet_valid()

static void make_next_packet_valid ( HexState *  state, const HexPkt *  pkt  )

static

Sets the packet after pkt to valid and updates its mnemonic.

Parameters

state	The state to operade on.
pkt	The packet which predecessor will be updated.

Definition at line 474 of file hexagon_arch.c.

                                                                       {
    HexInsn *tmp = rz_list_get_top(pkt->insn);
    if (!tmp) {
        return;
    }
    ut32 pkt_addr = tmp->addr + 4;
 
    HexPkt *p;
    for (int i = 0; i < HEXAGON_STATE_PKTS; ++i) {
        p = &state->pkts[i];
        if (p->pkt_addr == pkt_addr) {
            if (p->is_valid) {
                break;
            }
            p->is_valid = true;
            HexInsn *hi = NULL;
            RzListIter *it = NULL;
            ut8 k = 0;
            rz_list_foreach (p->insn, it, hi) {
                hex_set_pkt_info(&state->rz_asm, hi, p, k, true);
                ++k;
            }
            p->last_access = rz_time_now();
            break;
        }
    }
}

References hex_set_pkt_info(), HEXAGON_STATE_PKTS, hi(), i, HexPkt::insn, k, NULL, p, rz_list_get_top(), rz_time_now(), and autogen_x86imm::tmp.

Referenced by hex_add_to_pkt(), hex_add_to_stale_pkt(), and hex_to_new_pkt().

setup_new_instr()

static void setup_new_instr ( HexInsn *  hi, const HexReversedOpcode *  rz_reverse, const ut32  addr, const ut8  parse_bits  )

static

Set the up new instr.

Parameters

hi	The instruction to set up.
rz_reverse	RzAsmOp and RzAnalysisOp which could have some data, which needs to be copied.
addr	The address of the instruction.
parse_bits	The parse bits of the instruction

Definition at line 685 of file hexagon_arch.c.

                                                                                                                     {
    hi->instruction = HEX_INS_INVALID_DECODE;
    hi->addr = addr;
    hi->parse_bits = parse_bits;
    if (rz_reverse->asm_op) {
        memcpy(&(hi->asm_op), rz_reverse->asm_op, sizeof(RzAsmOp));
    }
    if (rz_reverse->ana_op) {
        memcpy(&(hi->ana_op), rz_reverse->ana_op, sizeof(RzAnalysisOp));
    }
 
    hi->ana_op.val = UT64_MAX;
    for (ut8 i = 0; i < 6; ++i) {
        hi->ana_op.analysis_vals[i].imm = ST64_MAX;
    }
    hi->ana_op.jump = UT64_MAX;
    hi->ana_op.fail = UT64_MAX;
    hi->ana_op.ptr = UT64_MAX;
 
    hi->asm_op.size = 4;
    hi->ana_op.size = 4;
}

References addr, HexReversedOpcode::ana_op, HexReversedOpcode::asm_op, HEX_INS_INVALID_DECODE, hi(), i, memcpy(), ST64_MAX, and UT64_MAX.

Referenced by hexagon_reverse_opcode().