denuvo-ref/rizin
1
0
Fork 0
mirror of https://github.com/rizinorg/rizin synced 2026-08-22 20:26:16 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Hexagon fix for abstract interpretation overestimation of jump targets (#6634)
Some checks failed
Manpage lint / mandoc (push) Has been cancelled
Details
Muon build / ubuntu-muon (push) Has been cancelled
Details
Mixed linter and checks / licenses (push) Has been cancelled
Details
Code scanning / build (CodeQL-cpp) (push) Has been cancelled
Details
Code scanning / build (CodeQL-javascript) (push) Has been cancelled
Details
Code scanning / build (CodeQL-python) (push) Has been cancelled
Details
Mixed linter and checks / changes (push) Has been cancelled
Details
TinyCC build / ubuntu-tcc-test (push) Has been cancelled
Details
Mixed linter and checks / cmd_descs_yaml_check (push) Has been cancelled
Details
Mixed linter and checks / bindgen-linter (push) Has been cancelled
Details
Mixed linter and checks / clang-format (push) Has been cancelled
Details
Mixed linter and checks / prettier (push) Has been cancelled
Details
Mixed linter and checks / python (push) Has been cancelled
Details

Browse source 
The jump addresses of call and jump instructions are now written to their own
and unique local variables. Before this, all jump instructions wrote to the
same local variable.

This was a problem for abstract interpretation: Because if multiple writes to
the same local var happen due to a previous TOP condition, the local variable
content is also TOP. If the jump target is TOP, the interpreter can't follow it
anymore.

Added tests for all the funny packet configurations with 0-2 jumps in it.
This commit is contained in:
Rot127 2026-07-27 20:50:13 +00:00 • committed by GitHub
parent d20f27aef3
commit dd618bb30a
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
12 changed files with 1950 additions and 212 deletions
Download patch file Download diff file Expand all files Collapse all files

16
librz/arch/isa/hexagon/hexagon.h
View file

@ -12,6 +12,7 @@
#ifndef HEXAGON_H
#define HEXAGON_H
#include "rz_il/rz_il_opcodes.h"
#include <rz_asm.h>
#include <rz_config.h>
#include <rz_list.h>
@ -243,6 +244,21 @@ typedef struct {
typedef struct {
const HexInsn *insn;
HexPkt *pkt;
/**
* \brief Every packet has a jump target.
* Either it is the next packet, or one or two jump/call instructions
* set a target.
*
* For our abstract interpretation it is required that every target address
* is written to a local variable before the rest of the packet is executed.
* The different elements for that procedure are below.
* Check out the code to see how they are used.
*/
const char *jmp_targets[2]; ///< The name of the local variables holding the jump/call targets.
const char *jmp_flags[2]; ///< The local flags a jump/call sets if it is taken.
RzILOpEffect *jmp_set_addr[2]; ///< Effects to set the respective target addresses.
size_t jmp_cnt; ///< Number of calls/jumps lifted.
} HexInsnPktBundle;
typedef struct {

81
librz/arch/isa/hexagon/hexagon_il.c
View file

@ -25,11 +25,21 @@ static HexILOp hex_jump_flag_init_op = {
.get_il_op = (HexILOpGetter)hex_il_op_jump_flag_init,
};
static HexILOp hex_next_jump_to_next_pkt = {
static HexILOp hex_jump_to_next_pkt = {
.attr = HEX_IL_INSN_ATTR_BRANCH | HEX_IL_INSN_ATTR_COND,
.get_il_op = (HexILOpGetter)hex_il_op_next_pkt_jmp,
};
static HexILOp hex_pkt_set_jmp_target_0 = {
.attr = HEX_IL_INSN_ATTR_NONE,
.get_il_op = (HexILOpGetter)hex_il_op_set_jmp_target_0,
};
static HexILOp hex_pkt_set_jmp_target_1 = {
.attr = HEX_IL_INSN_ATTR_NONE,
.get_il_op = (HexILOpGetter)hex_il_op_set_jmp_target_1,
};
static HexILOp hex_pkt_commit = {
.attr = HEX_IL_INSN_ATTR_NONE,
.get_il_op = (HexILOpGetter)hex_commit_packet,
@ -207,12 +217,23 @@ RZ_IPI bool hex_shuffle_insns(RZ_INOUT HexPkt *p) {
return true;
}
static RzILOpEffect *hex_il_op_to_effect(const HexILOp *il_op, HexPkt *pkt) {
rz_return_val_if_fail(il_op && il_op->get_il_op, NULL);
HexInsnPktBundle bundle = { 0 };
bundle.insn = (HexInsn *)il_op->hi;
bundle.pkt = pkt;
return il_op->get_il_op(&bundle);
static inline void bundle_init(HexInsnPktBundle *bundle) {
memset(bundle, 0, sizeof(HexInsnPktBundle));
bundle->jmp_targets[0] = "jump_target_0";
bundle->jmp_targets[1] = "jump_target_1";
bundle->jmp_flags[0] = "jump_flag_0";
bundle->jmp_flags[1] = "jump_flag_1";
}
static inline void bundle_update(HexInsnPktBundle *bundle, HexInsn *insn, HexPkt *pkt) {
bundle->insn = insn;
bundle->pkt = pkt;
}
static RzILOpEffect *hex_il_op_to_effect(const HexILOp *il_op, HexPkt *pkt, HexInsnPktBundle *bundle) {
rz_return_val_if_fail(bundle && il_op && il_op->get_il_op, NULL);
bundle_update(bundle, il_op->hi, pkt);
return il_op->get_il_op(bundle);
}
/**
@ -231,9 +252,11 @@ static RZ_OWN RzILOpEffect *hex_pkt_to_il_seq(HexPkt *pkt) {
RZ_LOG_WARN("Invalid il ops sequence! There should be at least two il ops per packet.\n");
return NULL;
}
HexInsnPktBundle bundle;
bundle_init(&bundle);
RzILOpEffect *complete_seq = EMPTY();
for (ut32 i = 0; i < rz_pvector_len(pkt->il_ops); ++i) {
complete_seq = SEQ2(complete_seq, hex_il_op_to_effect((HexILOp *)rz_pvector_at(pkt->il_ops, i), pkt));
complete_seq = SEQ2(complete_seq, hex_il_op_to_effect((HexILOp *)rz_pvector_at(pkt->il_ops, i), pkt, &bundle));
}
return complete_seq;
}
@ -336,6 +359,41 @@ static inline bool pkt_at_addr_is_emu_ready(const HexPkt *pkt, const ut32 addr)
return addr == pkt->pkt_addr && pkt->is_valid && pkt->last_instr_present;
}
/**
* \brief Inserts the `SETL(jmp_target_X, PURE)` effects after the respective
* jump effects.
*/
static bool insert_set_jmp_addr_effects(HexPkt *pkt) {
size_t idx[2] = { 0 };
size_t c = 0;
size_t i;
void **it;
rz_pvector_enumerate (pkt->il_ops, it, i) {
HexILOp *op = *it;
if (!(op->attr & HEX_IL_INSN_ATTR_BRANCH)) {
continue;
}
if (c >= 2) {
RZ_LOG_ERROR("Packet 0x%" PFMT32x " contains more than two branch instructions.\n", pkt->pkt_addr);
return false;
}
idx[c] = i + c + 1;
c++;
}
for (size_t k = 0; k < c; k++) {
rz_pvector_insert(pkt->il_ops, idx[k], k == 0 ? &hex_pkt_set_jmp_target_0 : &hex_pkt_set_jmp_target_1);
if (rz_pvector_at(pkt->il_ops, idx[k] - 1) == &hex_endloop01_op) {
// Edge case:
// The endloop01 effect has two jumps in it (one for each loop).
// but it is logged only once above.
// So we have to insert the second set_jmp_target_1 effect as well.
rz_pvector_insert(pkt->il_ops, idx[k] + 1, &hex_pkt_set_jmp_target_1);
break;
}
}
return true;
}
/**
* \brief Returns the IL operation of the instruction at \p addr. This will always be EMPTY().
* Except for last instructions in a packet. Those will always return the complete IL operation
@ -406,9 +464,14 @@ RZ_IPI RZ_OWN RzILOpEffect *hex_get_il_op(const ut32 addr, bool get_pkt_op, RZ_N
rz_pvector_push(p->il_ops, &hex_endloop01_op);
}
if (!insert_set_jmp_addr_effects(p)) {
rz_warn_if_reached();
return NULL;
}
rz_pvector_push(p->il_ops, &hex_pkt_commit);
// Add a jump to the next packet.
rz_pvector_push(p->il_ops, &hex_next_jump_to_next_pkt);
rz_pvector_push(p->il_ops, &hex_jump_to_next_pkt);
check_for_jumps(p, &state->might_have_jumped);

2
librz/arch/isa/hexagon/hexagon_il.h
View file

@ -62,6 +62,8 @@ RZ_IPI RZ_OWN RzILOpEffect *hex_get_npc(const HexPkt *pkt);
RZ_IPI RZ_OWN RzILOpEffect *hex_il_op_jump_flag_init(HexInsnPktBundle *bundle);
RZ_IPI RZ_OWN RzILOpEffect *hex_il_op_next_pkt_jmp(HexInsnPktBundle *bundle);
RZ_IPI RZ_OWN RzILOpEffect *hex_commit_packet(HexInsnPktBundle *bundle);
RZ_IPI RZ_OWN RzILOpEffect *hex_il_op_set_jmp_target_0(HexInsnPktBundle *bundle);
RZ_IPI RZ_OWN RzILOpEffect *hex_il_op_set_jmp_target_1(HexInsnPktBundle *bundle);
RZ_IPI RZ_OWN RzILOpEffect *hex_write_reg(RZ_BORROW HexInsnPktBundle *bundle, const HexOp *op, RzILOpPure *val);
RZ_IPI RZ_OWN RzILOpPure *hex_read_reg(RZ_BORROW HexPkt *pkt, const HexOp *op, bool tmp_reg);
RZ_IPI RZ_OWN RzILOpEffect *hex_cancel_slot(RZ_BORROW HexPkt *pkt, ut8 slot);

2
librz/arch/isa/hexagon/il_ops/hexagon_il_A2_ops.c
View file

@ -9161,4 +9161,4 @@ RzILOpEffect *hex_il_op_a2_zxth(HexInsnPktBundle *bundle) {
return instruction_sequence;
}
#include <rz_il/rz_il_opbuilder_end.h>
#include <rz_il/rz_il_opbuilder_end.h>

172
librz/arch/isa/hexagon/il_ops/hexagon_il_J2_ops.c
View file

@ -3,7 +3,7 @@
// LLVM commit: bc5ac5f3ebb0bc4fc65cef7160c817ca3174a68e
// LLVM commit date: 2026-03-15 10:22:07 -0700 (ISO 8601 format)
// Date of code generation: 2026-03-23 17:45:56+01:00
// Date of code generation: 2026-07-24 15:06:07+02:00
//========================================
// The following code is generated.
// Do not edit. Repository of code generator:
@ -48,7 +48,10 @@ RzILOpEffect *hex_il_op_j2_call(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_20 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_20_21 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_20));
RzILOpEffect *jump_op_ADD_20_21 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_20);
bundle->jmp_cnt++;
RzILOpEffect *instruction_sequence = SEQN(4, imm_assign_0, op_ASSIGN_7, seq_17, jump_op_ADD_20_21);
return instruction_sequence;
@ -90,7 +93,10 @@ RzILOpEffect *hex_il_op_j2_callf(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_26 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_26_27 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_26));
RzILOpEffect *jump_op_ADD_26_27 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_26);
bundle->jmp_cnt++;
// seq(seq(seq(HYB(call_pkt); h_tmp158 = HYB(call_pkt)); lr = (h_tm ...;
RzILOpEffect *seq_then_30 = SEQN(2, seq_23, jump_op_ADD_26_27);
@ -130,7 +136,10 @@ RzILOpEffect *hex_il_op_j2_callr(HexInsnPktBundle *bundle) {
RzILOpEffect *seq_9 = SEQN(2, seq_4, op_ASSIGN_8);
// jump(Rs);
RzILOpEffect *jump_Rs_11 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", Rs));
RzILOpEffect *jump_Rs_11 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], Rs);
bundle->jmp_cnt++;
RzILOpEffect *instruction_sequence = SEQN(2, seq_9, jump_Rs_11);
return instruction_sequence;
@ -164,7 +173,10 @@ RzILOpEffect *hex_il_op_j2_callrf(HexInsnPktBundle *bundle) {
RzILOpEffect *seq_15 = SEQN(2, seq_10, op_ASSIGN_14);
// jump(Rs);
RzILOpEffect *jump_Rs_17 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", Rs));
RzILOpEffect *jump_Rs_17 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], Rs);
bundle->jmp_cnt++;
// seq(seq(seq(HYB(call_pkt); h_tmp160 = HYB(call_pkt)); lr = (h_tm ...;
RzILOpEffect *seq_then_20 = SEQN(2, seq_15, jump_Rs_17);
@ -204,7 +216,10 @@ RzILOpEffect *hex_il_op_j2_callrh(HexInsnPktBundle *bundle) {
RzILOpEffect *seq_9 = SEQN(2, seq_4, op_ASSIGN_8);
// jump(Rs);
RzILOpEffect *jump_Rs_11 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", Rs));
RzILOpEffect *jump_Rs_11 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], Rs);
bundle->jmp_cnt++;
RzILOpEffect *instruction_sequence = SEQN(2, seq_9, jump_Rs_11);
return instruction_sequence;
@ -238,7 +253,10 @@ RzILOpEffect *hex_il_op_j2_callrt(HexInsnPktBundle *bundle) {
RzILOpEffect *seq_14 = SEQN(2, seq_9, op_ASSIGN_13);
// jump(Rs);
RzILOpEffect *jump_Rs_16 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", Rs));
RzILOpEffect *jump_Rs_16 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], Rs);
bundle->jmp_cnt++;
// seq(seq(seq(HYB(call_pkt); h_tmp162 = HYB(call_pkt)); lr = (h_tm ...;
RzILOpEffect *seq_then_19 = SEQN(2, seq_14, jump_Rs_16);
@ -287,7 +305,10 @@ RzILOpEffect *hex_il_op_j2_callt(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_25 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_25_26 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_25));
RzILOpEffect *jump_op_ADD_25_26 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_25);
bundle->jmp_cnt++;
// seq(seq(seq(HYB(call_pkt); h_tmp163 = HYB(call_pkt)); lr = (h_tm ...;
RzILOpEffect *seq_then_29 = SEQN(2, seq_22, jump_op_ADD_25_26);
@ -317,7 +338,10 @@ RzILOpEffect *hex_il_op_j2_jump(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_10 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_10_11 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_10));
RzILOpEffect *jump_op_ADD_10_11 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_10);
bundle->jmp_cnt++;
RzILOpEffect *instruction_sequence = SEQN(3, imm_assign_0, op_ASSIGN_7, jump_op_ADD_10_11);
return instruction_sequence;
@ -342,7 +366,10 @@ RzILOpEffect *hex_il_op_j2_jumpf(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_16 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_16_17 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_16));
RzILOpEffect *jump_op_ADD_16_17 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_16);
bundle->jmp_cnt++;
// seq(r; r = (r & -0x4); jump(pc + ((ut32) r)));
RzILOpEffect *seq_then_20 = SEQN(2, op_ASSIGN_13, jump_op_ADD_16_17);
@ -375,7 +402,10 @@ RzILOpEffect *hex_il_op_j2_jumpfnew(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_16 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_16_17 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_16));
RzILOpEffect *jump_op_ADD_16_17 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_16);
bundle->jmp_cnt++;
// seq(r; r = (r & -0x4); jump(pc + ((ut32) r)));
RzILOpEffect *seq_then_20 = SEQN(2, op_ASSIGN_13, jump_op_ADD_16_17);
@ -408,7 +438,10 @@ RzILOpEffect *hex_il_op_j2_jumpfnewpt(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_16 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_16_17 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_16));
RzILOpEffect *jump_op_ADD_16_17 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_16);
bundle->jmp_cnt++;
// seq(r; r = (r & -0x4); jump(pc + ((ut32) r)));
RzILOpEffect *seq_then_20 = SEQN(2, op_ASSIGN_13, jump_op_ADD_16_17);
@ -441,7 +474,10 @@ RzILOpEffect *hex_il_op_j2_jumpfpt(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_16 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_16_17 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_16));
RzILOpEffect *jump_op_ADD_16_17 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_16);
bundle->jmp_cnt++;
// seq(r; r = (r & -0x4); jump(pc + ((ut32) r)));
RzILOpEffect *seq_then_20 = SEQN(2, op_ASSIGN_13, jump_op_ADD_16_17);
@ -464,7 +500,10 @@ RzILOpEffect *hex_il_op_j2_jumpr(HexInsnPktBundle *bundle) {
RzILOpPure *Rs = READ_REG(pkt, Rs_op, false);
// jump(Rs);
RzILOpEffect *jump_Rs_1 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", Rs));
RzILOpEffect *jump_Rs_1 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], Rs);
bundle->jmp_cnt++;
RzILOpEffect *instruction_sequence = jump_Rs_1;
return instruction_sequence;
@ -481,7 +520,10 @@ RzILOpEffect *hex_il_op_j2_jumprf(HexInsnPktBundle *bundle) {
RzILOpPure *Rs = READ_REG(pkt, Rs_op, false);
// jump(Rs);
RzILOpEffect *jump_Rs_7 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", Rs));
RzILOpEffect *jump_Rs_7 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], Rs);
bundle->jmp_cnt++;
// seq(jump(Rs));
RzILOpEffect *seq_then_10 = jump_Rs_7;
@ -506,7 +548,10 @@ RzILOpEffect *hex_il_op_j2_jumprfnew(HexInsnPktBundle *bundle) {
RzILOpPure *Rs = READ_REG(pkt, Rs_op, false);
// jump(Rs);
RzILOpEffect *jump_Rs_7 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", Rs));
RzILOpEffect *jump_Rs_7 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], Rs);
bundle->jmp_cnt++;
// seq(jump(Rs));
RzILOpEffect *seq_then_10 = jump_Rs_7;
@ -531,7 +576,10 @@ RzILOpEffect *hex_il_op_j2_jumprfnewpt(HexInsnPktBundle *bundle) {
RzILOpPure *Rs = READ_REG(pkt, Rs_op, false);
// jump(Rs);
RzILOpEffect *jump_Rs_7 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", Rs));
RzILOpEffect *jump_Rs_7 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], Rs);
bundle->jmp_cnt++;
// seq(jump(Rs));
RzILOpEffect *seq_then_10 = jump_Rs_7;
@ -556,7 +604,10 @@ RzILOpEffect *hex_il_op_j2_jumprfpt(HexInsnPktBundle *bundle) {
RzILOpPure *Rs = READ_REG(pkt, Rs_op, false);
// jump(Rs);
RzILOpEffect *jump_Rs_7 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", Rs));
RzILOpEffect *jump_Rs_7 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], Rs);
bundle->jmp_cnt++;
// seq(jump(Rs));
RzILOpEffect *seq_then_10 = jump_Rs_7;
@ -585,7 +636,10 @@ RzILOpEffect *hex_il_op_j2_jumprgtez(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_7 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_7_8 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_7));
RzILOpEffect *jump_op_ADD_7_8 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_7);
bundle->jmp_cnt++;
// seq(jump(pc + ((ut32) r)));
RzILOpEffect *seq_then_10 = jump_op_ADD_7_8;
@ -613,7 +667,10 @@ RzILOpEffect *hex_il_op_j2_jumprgtezpt(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_7 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_7_8 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_7));
RzILOpEffect *jump_op_ADD_7_8 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_7);
bundle->jmp_cnt++;
// seq(jump(pc + ((ut32) r)));
RzILOpEffect *seq_then_10 = jump_op_ADD_7_8;
@ -635,7 +692,10 @@ RzILOpEffect *hex_il_op_j2_jumprh(HexInsnPktBundle *bundle) {
RzILOpPure *Rs = READ_REG(pkt, Rs_op, false);
// jump(Rs);
RzILOpEffect *jump_Rs_1 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", Rs));
RzILOpEffect *jump_Rs_1 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], Rs);
bundle->jmp_cnt++;
RzILOpEffect *instruction_sequence = jump_Rs_1;
return instruction_sequence;
@ -656,7 +716,10 @@ RzILOpEffect *hex_il_op_j2_jumprltez(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_7 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_7_8 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_7));
RzILOpEffect *jump_op_ADD_7_8 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_7);
bundle->jmp_cnt++;
// seq(jump(pc + ((ut32) r)));
RzILOpEffect *seq_then_10 = jump_op_ADD_7_8;
@ -684,7 +747,10 @@ RzILOpEffect *hex_il_op_j2_jumprltezpt(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_7 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_7_8 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_7));
RzILOpEffect *jump_op_ADD_7_8 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_7);
bundle->jmp_cnt++;
// seq(jump(pc + ((ut32) r)));
RzILOpEffect *seq_then_10 = jump_op_ADD_7_8;
@ -712,7 +778,10 @@ RzILOpEffect *hex_il_op_j2_jumprnz(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_7 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_7_8 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_7));
RzILOpEffect *jump_op_ADD_7_8 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_7);
bundle->jmp_cnt++;
// seq(jump(pc + ((ut32) r)));
RzILOpEffect *seq_then_10 = jump_op_ADD_7_8;
@ -740,7 +809,10 @@ RzILOpEffect *hex_il_op_j2_jumprnzpt(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_7 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_7_8 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_7));
RzILOpEffect *jump_op_ADD_7_8 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_7);
bundle->jmp_cnt++;
// seq(jump(pc + ((ut32) r)));
RzILOpEffect *seq_then_10 = jump_op_ADD_7_8;
@ -764,7 +836,10 @@ RzILOpEffect *hex_il_op_j2_jumprt(HexInsnPktBundle *bundle) {
RzILOpPure *Rs = READ_REG(pkt, Rs_op, false);
// jump(Rs);
RzILOpEffect *jump_Rs_6 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", Rs));
RzILOpEffect *jump_Rs_6 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], Rs);
bundle->jmp_cnt++;
// seq(jump(Rs));
RzILOpEffect *seq_then_9 = jump_Rs_6;
@ -788,7 +863,10 @@ RzILOpEffect *hex_il_op_j2_jumprtnew(HexInsnPktBundle *bundle) {
RzILOpPure *Rs = READ_REG(pkt, Rs_op, false);
// jump(Rs);
RzILOpEffect *jump_Rs_6 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", Rs));
RzILOpEffect *jump_Rs_6 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], Rs);
bundle->jmp_cnt++;
// seq(jump(Rs));
RzILOpEffect *seq_then_9 = jump_Rs_6;
@ -812,7 +890,10 @@ RzILOpEffect *hex_il_op_j2_jumprtnewpt(HexInsnPktBundle *bundle) {
RzILOpPure *Rs = READ_REG(pkt, Rs_op, false);
// jump(Rs);
RzILOpEffect *jump_Rs_6 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", Rs));
RzILOpEffect *jump_Rs_6 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], Rs);
bundle->jmp_cnt++;
// seq(jump(Rs));
RzILOpEffect *seq_then_9 = jump_Rs_6;
@ -836,7 +917,10 @@ RzILOpEffect *hex_il_op_j2_jumprtpt(HexInsnPktBundle *bundle) {
RzILOpPure *Rs = READ_REG(pkt, Rs_op, false);
// jump(Rs);
RzILOpEffect *jump_Rs_6 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", Rs));
RzILOpEffect *jump_Rs_6 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], Rs);
bundle->jmp_cnt++;
// seq(jump(Rs));
RzILOpEffect *seq_then_9 = jump_Rs_6;
@ -864,7 +948,10 @@ RzILOpEffect *hex_il_op_j2_jumprz(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_7 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_7_8 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_7));
RzILOpEffect *jump_op_ADD_7_8 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_7);
bundle->jmp_cnt++;
// seq(jump(pc + ((ut32) r)));
RzILOpEffect *seq_then_10 = jump_op_ADD_7_8;
@ -892,7 +979,10 @@ RzILOpEffect *hex_il_op_j2_jumprzpt(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_7 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_7_8 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_7));
RzILOpEffect *jump_op_ADD_7_8 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_7);
bundle->jmp_cnt++;
// seq(jump(pc + ((ut32) r)));
RzILOpEffect *seq_then_10 = jump_op_ADD_7_8;
@ -924,7 +1014,10 @@ RzILOpEffect *hex_il_op_j2_jumpt(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_15 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_15_16 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_15));
RzILOpEffect *jump_op_ADD_15_16 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_15);
bundle->jmp_cnt++;
// seq(r; r = (r & -0x4); jump(pc + ((ut32) r)));
RzILOpEffect *seq_then_19 = SEQN(2, op_ASSIGN_12, jump_op_ADD_15_16);
@ -956,7 +1049,10 @@ RzILOpEffect *hex_il_op_j2_jumptnew(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_15 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_15_16 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_15));
RzILOpEffect *jump_op_ADD_15_16 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_15);
bundle->jmp_cnt++;
// seq(r; r = (r & -0x4); jump(pc + ((ut32) r)));
RzILOpEffect *seq_then_19 = SEQN(2, op_ASSIGN_12, jump_op_ADD_15_16);
@ -988,7 +1084,10 @@ RzILOpEffect *hex_il_op_j2_jumptnewpt(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_15 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_15_16 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_15));
RzILOpEffect *jump_op_ADD_15_16 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_15);
bundle->jmp_cnt++;
// seq(r; r = (r & -0x4); jump(pc + ((ut32) r)));
RzILOpEffect *seq_then_19 = SEQN(2, op_ASSIGN_12, jump_op_ADD_15_16);
@ -1020,7 +1119,10 @@ RzILOpEffect *hex_il_op_j2_jumptpt(HexInsnPktBundle *bundle) {
// jump(pc + ((ut32) r));
RzILOpPure *op_ADD_15 = ADD(pc, CAST(32, IL_FALSE, VARL("r")));
RzILOpEffect *jump_op_ADD_15_16 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", op_ADD_15));
RzILOpEffect *jump_op_ADD_15_16 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], op_ADD_15);
bundle->jmp_cnt++;
// seq(r; r = (r & -0x4); jump(pc + ((ut32) r)));
RzILOpEffect *seq_then_19 = SEQN(2, op_ASSIGN_12, jump_op_ADD_15_16);

592
librz/arch/isa/hexagon/il_ops/hexagon_il_J4_ops.c
View file

File diff suppressed because it is too large Load diff

49
librz/arch/isa/hexagon/il_ops/hexagon_il_L4_ops.c
View file

@ -3,7 +3,7 @@
// LLVM commit: bc5ac5f3ebb0bc4fc65cef7160c817ca3174a68e
// LLVM commit date: 2026-03-15 10:22:07 -0700 (ISO 8601 format)
// Date of code generation: 2026-03-23 17:45:56+01:00
// Date of code generation: 2026-07-24 15:06:07+02:00
//========================================
// The following code is generated.
// Do not edit. Repository of code generator:
@ -1027,9 +1027,9 @@ RzILOpEffect *hex_il_op_l4_loadbsw4_ap(HexInsnPktBundle *bundle) {
RzILOpEffect *seq_47 = SEQN(2, op_ASSIGN_11, for_46);
// Re = ((st32) U);
RzILOpEffect *op_ASSIGN_50 = WRITE_REG(bundle, Re_op, CAST(32, IL_FALSE, VARL("U")));
RzILOpEffect *op_ASSIGN_51 = WRITE_REG(bundle, Re_op, CAST(32, IL_FALSE, VARL("U")));
RzILOpEffect *instruction_sequence = SEQN(5, imm_assign_0, op_ASSIGN_3, op_ASSIGN_9, seq_47, op_ASSIGN_50);
RzILOpEffect *instruction_sequence = SEQN(5, imm_assign_0, op_ASSIGN_3, op_ASSIGN_9, seq_47, op_ASSIGN_51);
return instruction_sequence;
}
@ -1167,9 +1167,9 @@ RzILOpEffect *hex_il_op_l4_loadbzw2_ap(HexInsnPktBundle *bundle) {
RzILOpEffect *seq_48 = SEQN(2, op_ASSIGN_11, for_47);
// Re = ((st32) U);
RzILOpEffect *op_ASSIGN_51 = WRITE_REG(bundle, Re_op, CAST(32, IL_FALSE, VARL("U")));
RzILOpEffect *op_ASSIGN_52 = WRITE_REG(bundle, Re_op, CAST(32, IL_FALSE, VARL("U")));
RzILOpEffect *instruction_sequence = SEQN(5, imm_assign_0, op_ASSIGN_3, op_ASSIGN_9, seq_48, op_ASSIGN_51);
RzILOpEffect *instruction_sequence = SEQN(5, imm_assign_0, op_ASSIGN_3, op_ASSIGN_9, seq_48, op_ASSIGN_52);
return instruction_sequence;
}
@ -1307,9 +1307,9 @@ RzILOpEffect *hex_il_op_l4_loadbzw4_ap(HexInsnPktBundle *bundle) {
RzILOpEffect *seq_47 = SEQN(2, op_ASSIGN_11, for_46);
// Re = ((st32) U);
RzILOpEffect *op_ASSIGN_50 = WRITE_REG(bundle, Re_op, CAST(32, IL_FALSE, VARL("U")));
RzILOpEffect *op_ASSIGN_51 = WRITE_REG(bundle, Re_op, CAST(32, IL_FALSE, VARL("U")));
RzILOpEffect *instruction_sequence = SEQN(5, imm_assign_0, op_ASSIGN_3, op_ASSIGN_9, seq_47, op_ASSIGN_50);
RzILOpEffect *instruction_sequence = SEQN(5, imm_assign_0, op_ASSIGN_3, op_ASSIGN_9, seq_47, op_ASSIGN_51);
return instruction_sequence;
}
@ -4062,7 +4062,10 @@ RzILOpEffect *hex_il_op_l4_return(HexInsnPktBundle *bundle) {
// jump(((ut32) ((st64) ((st32) ((Rdd >> 0x20) & 0xffffffff)))));
RzILOpPure *op_RSHIFT_25 = SHIFTRA(READ_REG(pkt, Rdd_op, true), SN(32, 0x20));
RzILOpPure *op_AND_27 = LOGAND(op_RSHIFT_25, SN(64, 0xffffffff));
RzILOpEffect *jump_cast_ut32_30_31 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, MSB(op_AND_27), DUP(op_AND_27))), CAST(32, MSB(DUP(op_AND_27)), DUP(op_AND_27))))));
RzILOpEffect *jump_cast_ut32_30_31 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, MSB(op_AND_27), DUP(op_AND_27))), CAST(32, MSB(DUP(op_AND_27)), DUP(op_AND_27)))));
bundle->jmp_cnt++;
RzILOpEffect *instruction_sequence = SEQN(5, op_ASSIGN_4, op_ASSIGN_8, op_ASSIGN_16, op_ASSIGN_21, jump_cast_ut32_30_31);
return instruction_sequence;
@ -4103,7 +4106,10 @@ RzILOpEffect *hex_il_op_l4_return_f(HexInsnPktBundle *bundle) {
// jump(((ut32) ((st64) ((st32) ((Rdd >> 0x20) & 0xffffffff)))));
RzILOpPure *op_RSHIFT_31 = SHIFTRA(READ_REG(pkt, Rdd_op, true), SN(32, 0x20));
RzILOpPure *op_AND_33 = LOGAND(op_RSHIFT_31, SN(64, 0xffffffff));
RzILOpEffect *jump_cast_ut32_36_37 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, MSB(op_AND_33), DUP(op_AND_33))), CAST(32, MSB(DUP(op_AND_33)), DUP(op_AND_33))))));
RzILOpEffect *jump_cast_ut32_36_37 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, MSB(op_AND_33), DUP(op_AND_33))), CAST(32, MSB(DUP(op_AND_33)), DUP(op_AND_33)))));
bundle->jmp_cnt++;
// nop;
RzILOpEffect *nop_39 = NOP();
@ -4158,7 +4164,10 @@ RzILOpEffect *hex_il_op_l4_return_fnew_pnt(HexInsnPktBundle *bundle) {
// jump(((ut32) ((st64) ((st32) ((Rdd >> 0x20) & 0xffffffff)))));
RzILOpPure *op_RSHIFT_31 = SHIFTRA(READ_REG(pkt, Rdd_op, true), SN(32, 0x20));
RzILOpPure *op_AND_33 = LOGAND(op_RSHIFT_31, SN(64, 0xffffffff));
RzILOpEffect *jump_cast_ut32_36_37 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, MSB(op_AND_33), DUP(op_AND_33))), CAST(32, MSB(DUP(op_AND_33)), DUP(op_AND_33))))));
RzILOpEffect *jump_cast_ut32_36_37 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, MSB(op_AND_33), DUP(op_AND_33))), CAST(32, MSB(DUP(op_AND_33)), DUP(op_AND_33)))));
bundle->jmp_cnt++;
// nop;
RzILOpEffect *nop_39 = NOP();
@ -4213,7 +4222,10 @@ RzILOpEffect *hex_il_op_l4_return_fnew_pt(HexInsnPktBundle *bundle) {
// jump(((ut32) ((st64) ((st32) ((Rdd >> 0x20) & 0xffffffff)))));
RzILOpPure *op_RSHIFT_31 = SHIFTRA(READ_REG(pkt, Rdd_op, true), SN(32, 0x20));
RzILOpPure *op_AND_33 = LOGAND(op_RSHIFT_31, SN(64, 0xffffffff));
RzILOpEffect *jump_cast_ut32_36_37 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, MSB(op_AND_33), DUP(op_AND_33))), CAST(32, MSB(DUP(op_AND_33)), DUP(op_AND_33))))));
RzILOpEffect *jump_cast_ut32_36_37 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, MSB(op_AND_33), DUP(op_AND_33))), CAST(32, MSB(DUP(op_AND_33)), DUP(op_AND_33)))));
bundle->jmp_cnt++;
// nop;
RzILOpEffect *nop_39 = NOP();
@ -4268,7 +4280,10 @@ RzILOpEffect *hex_il_op_l4_return_t(HexInsnPktBundle *bundle) {
// jump(((ut32) ((st64) ((st32) ((Rdd >> 0x20) & 0xffffffff)))));
RzILOpPure *op_RSHIFT_30 = SHIFTRA(READ_REG(pkt, Rdd_op, true), SN(32, 0x20));
RzILOpPure *op_AND_32 = LOGAND(op_RSHIFT_30, SN(64, 0xffffffff));
RzILOpEffect *jump_cast_ut32_35_36 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, MSB(op_AND_32), DUP(op_AND_32))), CAST(32, MSB(DUP(op_AND_32)), DUP(op_AND_32))))));
RzILOpEffect *jump_cast_ut32_35_36 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, MSB(op_AND_32), DUP(op_AND_32))), CAST(32, MSB(DUP(op_AND_32)), DUP(op_AND_32)))));
bundle->jmp_cnt++;
// nop;
RzILOpEffect *nop_38 = NOP();
@ -4322,7 +4337,10 @@ RzILOpEffect *hex_il_op_l4_return_tnew_pnt(HexInsnPktBundle *bundle) {
// jump(((ut32) ((st64) ((st32) ((Rdd >> 0x20) & 0xffffffff)))));
RzILOpPure *op_RSHIFT_30 = SHIFTRA(READ_REG(pkt, Rdd_op, true), SN(32, 0x20));
RzILOpPure *op_AND_32 = LOGAND(op_RSHIFT_30, SN(64, 0xffffffff));
RzILOpEffect *jump_cast_ut32_35_36 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, MSB(op_AND_32), DUP(op_AND_32))), CAST(32, MSB(DUP(op_AND_32)), DUP(op_AND_32))))));
RzILOpEffect *jump_cast_ut32_35_36 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, MSB(op_AND_32), DUP(op_AND_32))), CAST(32, MSB(DUP(op_AND_32)), DUP(op_AND_32)))));
bundle->jmp_cnt++;
// nop;
RzILOpEffect *nop_38 = NOP();
@ -4376,7 +4394,10 @@ RzILOpEffect *hex_il_op_l4_return_tnew_pt(HexInsnPktBundle *bundle) {
// jump(((ut32) ((st64) ((st32) ((Rdd >> 0x20) & 0xffffffff)))));
RzILOpPure *op_RSHIFT_30 = SHIFTRA(READ_REG(pkt, Rdd_op, true), SN(32, 0x20));
RzILOpPure *op_AND_32 = LOGAND(op_RSHIFT_30, SN(64, 0xffffffff));
RzILOpEffect *jump_cast_ut32_35_36 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, MSB(op_AND_32), DUP(op_AND_32))), CAST(32, MSB(DUP(op_AND_32)), DUP(op_AND_32))))));
RzILOpEffect *jump_cast_ut32_35_36 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, MSB(op_AND_32), DUP(op_AND_32))), CAST(32, MSB(DUP(op_AND_32)), DUP(op_AND_32)))));
bundle->jmp_cnt++;
// nop;
RzILOpEffect *nop_38 = NOP();

52
librz/arch/isa/hexagon/il_ops/hexagon_il_SL2_ops.c
View file

@ -3,7 +3,7 @@
// LLVM commit: bc5ac5f3ebb0bc4fc65cef7160c817ca3174a68e
// LLVM commit date: 2026-03-15 10:22:07 -0700 (ISO 8601 format)
// Date of code generation: 2026-03-23 17:45:56+01:00
// Date of code generation: 2026-07-24 15:06:07+02:00
//========================================
// The following code is generated.
// Do not edit. Repository of code generator:
@ -64,7 +64,10 @@ RzILOpEffect *hex_il_op_sl2_jumpr31(HexInsnPktBundle *bundle) {
RzILOpPure *lr = READ_REG(pkt, &lr_op, false);
// jump(lr);
RzILOpEffect *jump_lr_1 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", lr));
RzILOpEffect *jump_lr_1 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], lr);
bundle->jmp_cnt++;
RzILOpEffect *instruction_sequence = jump_lr_1;
return instruction_sequence;
@ -80,7 +83,10 @@ RzILOpEffect *hex_il_op_sl2_jumpr31_f(HexInsnPktBundle *bundle) {
RzILOpPure *lr = READ_REG(pkt, &lr_op, false);
// jump(lr);
RzILOpEffect *jump_lr_7 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", lr));
RzILOpEffect *jump_lr_7 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], lr);
bundle->jmp_cnt++;
// seq(jump(lr));
RzILOpEffect *seq_then_9 = jump_lr_7;
@ -104,7 +110,10 @@ RzILOpEffect *hex_il_op_sl2_jumpr31_fnew(HexInsnPktBundle *bundle) {
RzILOpPure *lr = READ_REG(pkt, &lr_op, false);
// jump(lr);
RzILOpEffect *jump_lr_7 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", lr));
RzILOpEffect *jump_lr_7 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], lr);
bundle->jmp_cnt++;
// seq(jump(lr));
RzILOpEffect *seq_then_9 = jump_lr_7;
@ -128,7 +137,10 @@ RzILOpEffect *hex_il_op_sl2_jumpr31_t(HexInsnPktBundle *bundle) {
RzILOpPure *lr = READ_REG(pkt, &lr_op, false);
// jump(lr);
RzILOpEffect *jump_lr_6 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", lr));
RzILOpEffect *jump_lr_6 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], lr);
bundle->jmp_cnt++;
// seq(jump(lr));
RzILOpEffect *seq_then_8 = jump_lr_6;
@ -151,7 +163,10 @@ RzILOpEffect *hex_il_op_sl2_jumpr31_tnew(HexInsnPktBundle *bundle) {
RzILOpPure *lr = READ_REG(pkt, &lr_op, false);
// jump(lr);
RzILOpEffect *jump_lr_6 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", lr));
RzILOpEffect *jump_lr_6 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], lr);
bundle->jmp_cnt++;
// seq(jump(lr));
RzILOpEffect *seq_then_8 = jump_lr_6;
@ -335,7 +350,10 @@ RzILOpEffect *hex_il_op_sl2_return(HexInsnPktBundle *bundle) {
// jump(((ut32) ((st64) ((st32) ((tmp >> 0x20) & ((ut64) 0xffffffff))))));
RzILOpPure *op_RSHIFT_45 = SHIFTR0(VARL("tmp"), SN(32, 0x20));
RzILOpPure *op_AND_48 = LOGAND(op_RSHIFT_45, CAST(64, IL_FALSE, SN(64, 0xffffffff)));
RzILOpEffect *jump_cast_ut32_51_52 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, IL_FALSE, op_AND_48)), CAST(32, IL_FALSE, DUP(op_AND_48))))));
RzILOpEffect *jump_cast_ut32_51_52 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, IL_FALSE, op_AND_48)), CAST(32, IL_FALSE, DUP(op_AND_48)))));
bundle->jmp_cnt++;
RzILOpEffect *instruction_sequence = SEQN(7, op_ASSIGN_3, op_ASSIGN_7, op_ASSIGN_13, op_ASSIGN_25, op_ASSIGN_36, op_ASSIGN_41, jump_cast_ut32_51_52);
return instruction_sequence;
@ -384,7 +402,10 @@ RzILOpEffect *hex_il_op_sl2_return_f(HexInsnPktBundle *bundle) {
// jump(((ut32) ((st64) ((st32) ((tmp >> 0x20) & ((ut64) 0xffffffff))))));
RzILOpPure *op_RSHIFT_52 = SHIFTR0(VARL("tmp"), SN(32, 0x20));
RzILOpPure *op_AND_55 = LOGAND(op_RSHIFT_52, CAST(64, IL_FALSE, SN(64, 0xffffffff)));
RzILOpEffect *jump_cast_ut32_58_59 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, IL_FALSE, op_AND_55)), CAST(32, IL_FALSE, DUP(op_AND_55))))));
RzILOpEffect *jump_cast_ut32_58_59 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, IL_FALSE, op_AND_55)), CAST(32, IL_FALSE, DUP(op_AND_55)))));
bundle->jmp_cnt++;
// nop;
RzILOpEffect *nop_61 = NOP();
@ -447,7 +468,10 @@ RzILOpEffect *hex_il_op_sl2_return_fnew(HexInsnPktBundle *bundle) {
// jump(((ut32) ((st64) ((st32) ((tmp >> 0x20) & ((ut64) 0xffffffff))))));
RzILOpPure *op_RSHIFT_51 = SHIFTR0(VARL("tmp"), SN(32, 0x20));
RzILOpPure *op_AND_54 = LOGAND(op_RSHIFT_51, CAST(64, IL_FALSE, SN(64, 0xffffffff)));
RzILOpEffect *jump_cast_ut32_57_58 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, IL_FALSE, op_AND_54)), CAST(32, IL_FALSE, DUP(op_AND_54))))));
RzILOpEffect *jump_cast_ut32_57_58 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, IL_FALSE, op_AND_54)), CAST(32, IL_FALSE, DUP(op_AND_54)))));
bundle->jmp_cnt++;
// nop;
RzILOpEffect *nop_60 = NOP();
@ -510,7 +534,10 @@ RzILOpEffect *hex_il_op_sl2_return_t(HexInsnPktBundle *bundle) {
// jump(((ut32) ((st64) ((st32) ((tmp >> 0x20) & ((ut64) 0xffffffff))))));
RzILOpPure *op_RSHIFT_51 = SHIFTR0(VARL("tmp"), SN(32, 0x20));
RzILOpPure *op_AND_54 = LOGAND(op_RSHIFT_51, CAST(64, IL_FALSE, SN(64, 0xffffffff)));
RzILOpEffect *jump_cast_ut32_57_58 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, IL_FALSE, op_AND_54)), CAST(32, IL_FALSE, DUP(op_AND_54))))));
RzILOpEffect *jump_cast_ut32_57_58 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, IL_FALSE, op_AND_54)), CAST(32, IL_FALSE, DUP(op_AND_54)))));
bundle->jmp_cnt++;
// nop;
RzILOpEffect *nop_60 = NOP();
@ -572,7 +599,10 @@ RzILOpEffect *hex_il_op_sl2_return_tnew(HexInsnPktBundle *bundle) {
// jump(((ut32) ((st64) ((st32) ((tmp >> 0x20) & ((ut64) 0xffffffff))))));
RzILOpPure *op_RSHIFT_50 = SHIFTR0(VARL("tmp"), SN(32, 0x20));
RzILOpPure *op_AND_53 = LOGAND(op_RSHIFT_50, CAST(64, IL_FALSE, SN(64, 0xffffffff)));
RzILOpEffect *jump_cast_ut32_56_57 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, IL_FALSE, op_AND_53)), CAST(32, IL_FALSE, DUP(op_AND_53))))));
RzILOpEffect *jump_cast_ut32_56_57 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], CAST(32, IL_FALSE, CAST(64, MSB(CAST(32, IL_FALSE, op_AND_53)), CAST(32, IL_FALSE, DUP(op_AND_53)))));
bundle->jmp_cnt++;
// nop;
RzILOpEffect *nop_59 = NOP();

66
librz/arch/isa/hexagon/il_ops/hexagon_il_non_insn_ops.c
View file

@ -3,7 +3,7 @@
// LLVM commit: bc5ac5f3ebb0bc4fc65cef7160c817ca3174a68e
// LLVM commit date: 2026-03-15 10:22:07 -0700 (ISO 8601 format)
// Date of code generation: 2026-03-23 17:45:56+01:00
// Date of code generation: 2026-07-24 15:06:07+02:00
//========================================
// The following code is generated.
// Do not edit. Repository of code generator:
@ -105,14 +105,20 @@ RzILOpEffect *hex_il_op_j2_endloop01(HexInsnPktBundle *bundle) {
RzILOpEffect *seq_42 = SEQN(2, seq_3, branch_41);
// jump(sa0);
RzILOpEffect *jump_sa0_48 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", sa0));
RzILOpEffect *jump_sa0_48 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], sa0);
bundle->jmp_cnt++;
// lc0 = lc0 - ((ut32) 0x1);
RzILOpPure *op_SUB_52 = SUB(READ_REG(pkt, &lc0_op, true), CAST(32, IL_FALSE, SN(32, 1)));
RzILOpEffect *op_ASSIGN_53 = WRITE_REG(bundle, &lc0_op, op_SUB_52);
// jump(sa1);
RzILOpEffect *jump_sa1_59 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", sa1));
RzILOpEffect *jump_sa1_59 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], sa1);
bundle->jmp_cnt++;
// lc1 = lc1 - ((ut32) 0x1);
RzILOpPure *op_SUB_63 = SUB(READ_REG(pkt, &lc1_op, true), CAST(32, IL_FALSE, SN(32, 1)));
@ -148,7 +154,10 @@ RzILOpEffect *hex_il_op_j2_endloop1(HexInsnPktBundle *bundle) {
RzILOpPure *sa1 = READ_REG(pkt, &sa1_op, false);
// jump(sa1);
RzILOpEffect *jump_sa1_5 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", sa1));
RzILOpEffect *jump_sa1_5 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], sa1);
bundle->jmp_cnt++;
// lc1 = lc1 - ((ut32) 0x1);
RzILOpPure *op_SUB_9 = SUB(READ_REG(pkt, &lc1_op, true), CAST(32, IL_FALSE, SN(32, 1)));
@ -253,7 +262,10 @@ RzILOpEffect *hex_il_op_j2_endloop0(HexInsnPktBundle *bundle) {
RzILOpEffect *seq_42 = SEQN(2, seq_3, branch_41);
// jump(sa0);
RzILOpEffect *jump_sa0_48 = SEQ2(SETL("jump_flag", IL_TRUE), SETL("jump_target", sa0));
RzILOpEffect *jump_sa0_48 = SETL(bundle->jmp_flags[bundle->jmp_cnt], IL_TRUE);
rz_return_val_if_fail(bundle->jmp_cnt < 2, NULL);
bundle->jmp_set_addr[bundle->jmp_cnt] = SETL(bundle->jmp_targets[bundle->jmp_cnt], sa0);
bundle->jmp_cnt++;
// lc0 = lc0 - ((ut32) 0x1);
RzILOpPure *op_SUB_52 = SUB(READ_REG(pkt, &lc0_op, true), CAST(32, IL_FALSE, SN(32, 1)));
@ -950,11 +962,49 @@ RZ_IPI RZ_OWN RzILOpEffect *hex_commit_packet(HexInsnPktBundle *bundle) {
}
RZ_IPI RZ_OWN RzILOpEffect *hex_il_op_jump_flag_init(HexInsnPktBundle *bundle) {
return SEQ2(SETL("jump_flag", IL_FALSE), SETL("jump_target", U32(0xffffffff)));
return SEQ2(SETL(bundle->jmp_flags[0], IL_FALSE),
SETL(bundle->jmp_flags[1], IL_FALSE));
}
RZ_IPI RZ_OWN RzILOpEffect *hex_il_op_set_jmp_target_0(HexInsnPktBundle *bundle) {
if (bundle->jmp_cnt < 1) {
rz_warn_if_reached();
return NULL;
}
return bundle->jmp_set_addr[0];
}
RZ_IPI RZ_OWN RzILOpEffect *hex_il_op_set_jmp_target_1(HexInsnPktBundle *bundle) {
if (bundle->jmp_cnt != 2) {
rz_warn_if_reached();
return NULL;
}
return bundle->jmp_set_addr[1];
}
RZ_IPI RZ_OWN RzILOpEffect *hex_il_op_next_pkt_jmp(HexInsnPktBundle *bundle) {
return BRANCH(VARL("jump_flag"), JMP(VARL("jump_target")), JMP(U32(bundle->pkt->pkt_addr + (HEX_INSN_SIZE * rz_list_length(bundle->pkt->bin)))));
RzILOpPure *next_pkt_addr = U32(bundle->pkt->pkt_addr + (HEX_INSN_SIZE * rz_list_length(bundle->pkt->bin)));
switch (bundle->jmp_cnt) {
case 0:
// No jump/call was lifted.
return JMP(next_pkt_addr);
case 1:
// One jump/call was lifted.
return BRANCH(VARL(bundle->jmp_flags[0]),
JMP(VARL(bundle->jmp_targets[0])),
JMP(next_pkt_addr));
case 2:
// Two jumps/calls were lifted.
return BRANCH(VARL(bundle->jmp_flags[0]),
JMP(VARL(bundle->jmp_targets[0])),
BRANCH(VARL(bundle->jmp_flags[1]),
JMP(VARL(bundle->jmp_targets[1])),
JMP(next_pkt_addr)));
default:
break;
}
rz_warn_if_reached();
return NULL;
}
#include <rz_il/rz_il_opbuilder_end.h>
#include <rz_il/rz_il_opbuilder_end.h>

4
librz/arch/p/analysis/analysis_alpha_cs.c
View file

@ -11,11 +11,7 @@
#include <alpha/alpha.inc>
#ifdef RZ_CAPSTONE_ALPHA_INSNS_UPPERCASE
#define RZ_ALPHA_INS(name) ALPHA_INS_##name
#else
#define RZ_ALPHA_INS(name) Alpha_INS_##name
#endif
static char *get_reg_profile(RzAnalysis *_) {
const char *p =

18
test/db/analysis/hexagon
View file

@ -1518,7 +1518,7 @@ EXPECT=<<EOF
| R4 = add(R4,##0x4)
| P0 = cmp.gtu(R5,##0x3f)
\ if (P0.new) R16 = ##0xb
0x53c8 (seq empty (set jump_flag false) (set jump_target (bv 32 0xffffffff)) (set s (bv 32 0x4)) (set R4_tmp (cast 32 false (cast 32 false (+ (var R4) (var s))))) (set u (bv 32 0x3f)) (set P0_tmp (cast 8 false (cast 8 (msb (ite (! (ule (cast 32 false (var R5)) (var u))) (bv 32 0xff) (bv 32 0x0))) (ite (! (ule (cast 32 false (var R5)) (var u))) (bv 32 0xff) (bv 32 0x0))))) (set s (bv 32 0xb)) (branch (! (is_zero (& (cast 32 (msb (var P0_tmp)) (var P0_tmp)) (bv 32 0x1)))) (set R16_tmp (cast 32 false (cast 32 false (var s)))) nop) (set r (bv 32 0xffffffec)) (branch (! (! (is_zero (& (cast 32 (msb (var P0_tmp)) (var P0_tmp)) (bv 32 0x1))))) (seq (set r (& (var r) (bv 32 0xfffffffc))) (set jump_flag true) (set jump_target (+ (bv 32 0x53c8) (cast 32 false (var r))))) empty) empty (set R4 (var R4_tmp)) (set R16 (var R16_tmp)) (set P0 (var P0_tmp)) (branch (var jump_flag) (jmp (var jump_target)) (jmp (bv 32 0x53d8))))
0x53c8 (seq empty (set jump_flag_0 false) (set jump_flag_1 false) (set s (bv 32 0x4)) (set R4_tmp (cast 32 false (cast 32 false (+ (var R4) (var s))))) (set u (bv 32 0x3f)) (set P0_tmp (cast 8 false (cast 8 (msb (ite (! (ule (cast 32 false (var R5)) (var u))) (bv 32 0xff) (bv 32 0x0))) (ite (! (ule (cast 32 false (var R5)) (var u))) (bv 32 0xff) (bv 32 0x0))))) (set s (bv 32 0xb)) (branch (! (is_zero (& (cast 32 (msb (var P0_tmp)) (var P0_tmp)) (bv 32 0x1)))) (set R16_tmp (cast 32 false (cast 32 false (var s)))) nop) (set r (bv 32 0xffffffec)) (branch (! (! (is_zero (& (cast 32 (msb (var P0_tmp)) (var P0_tmp)) (bv 32 0x1))))) (seq (set r (& (var r) (bv 32 0xfffffffc))) (set jump_flag_0 true)) empty) (set jump_target_0 (+ (bv 32 0x53c8) (cast 32 false (var r)))) empty (set R4 (var R4_tmp)) (set R16 (var R16_tmp)) (set P0 (var P0_tmp)) (branch (var jump_flag_0) (jmp (var jump_target_0)) (jmp (bv 32 0x53d8))))
EOF
RUN
@ -1540,7 +1540,7 @@ EXPECT=<<EOF
| R4 = add(R4,##0x4)
| P0 = cmp.gtu(R5,##0x3f)
\ if (P0.new) R16 = ##0xb
0x53c8 (seq empty (set jump_flag false) (set jump_target (bv 32 0xffffffff)) (set s (bv 32 0x4)) (set R4_tmp (cast 32 false (cast 32 false (+ (var R4) (var s))))) (set u (bv 32 0x3f)) (set P0_tmp (cast 8 false (cast 8 (msb (ite (! (ule (cast 32 false (var R5)) (var u))) (bv 32 0xff) (bv 32 0x0))) (ite (! (ule (cast 32 false (var R5)) (var u))) (bv 32 0xff) (bv 32 0x0))))) (set s (bv 32 0xb)) (branch (! (is_zero (& (cast 32 (msb (var P0_tmp)) (var P0_tmp)) (bv 32 0x1)))) (set R16_tmp (cast 32 false (cast 32 false (var s)))) nop) (set r (bv 32 0xffffffec)) (branch (! (! (is_zero (& (cast 32 (msb (var P0_tmp)) (var P0_tmp)) (bv 32 0x1))))) (seq (set r (& (var r) (bv 32 0xfffffffc))) (set jump_flag true) (set jump_target (+ (bv 32 0x53c8) (cast 32 false (var r))))) empty) empty (set R4 (var R4_tmp)) (set R16 (var R16_tmp)) (set P0 (var P0_tmp)) (branch (var jump_flag) (jmp (var jump_target)) (jmp (bv 32 0x53d8))))
0x53c8 (seq empty (set jump_flag_0 false) (set jump_flag_1 false) (set s (bv 32 0x4)) (set R4_tmp (cast 32 false (cast 32 false (+ (var R4) (var s))))) (set u (bv 32 0x3f)) (set P0_tmp (cast 8 false (cast 8 (msb (ite (! (ule (cast 32 false (var R5)) (var u))) (bv 32 0xff) (bv 32 0x0))) (ite (! (ule (cast 32 false (var R5)) (var u))) (bv 32 0xff) (bv 32 0x0))))) (set s (bv 32 0xb)) (branch (! (is_zero (& (cast 32 (msb (var P0_tmp)) (var P0_tmp)) (bv 32 0x1)))) (set R16_tmp (cast 32 false (cast 32 false (var s)))) nop) (set r (bv 32 0xffffffec)) (branch (! (! (is_zero (& (cast 32 (msb (var P0_tmp)) (var P0_tmp)) (bv 32 0x1))))) (seq (set r (& (var r) (bv 32 0xfffffffc))) (set jump_flag_0 true)) empty) (set jump_target_0 (+ (bv 32 0x53c8) (cast 32 false (var r)))) empty (set R4 (var R4_tmp)) (set R16 (var R16_tmp)) (set P0 (var P0_tmp)) (branch (var jump_flag_0) (jmp (var jump_target_0)) (jmp (bv 32 0x53d8))))
EOF
RUN
@ -1568,10 +1568,10 @@ EXPECT=<<EOF
0x8000040
(seq
empty
(set jump_flag
(set jump_flag_0
false)
(set jump_flag_1
false)
(set jump_target
(bv 32 0xffffffff))
(set u
(bv 32 0x8))
(set EA
@ -1622,12 +1622,8 @@ EXPECT=<<EOF
(var R29_tmp))
(set R30
(var R30_tmp))
(branch
(var jump_flag)
(jmp
(var jump_target))
(jmp
(bv 32 0x8000044))))
(jmp
(bv 32 0x8000044)))
[ allocframe(SP,#0x8):raw
EOF
EXPECT_ERR=

1108
test/db/rzil/hexagon
View file

File diff suppressed because it is too large Load diff