portugalfuturista/rizin
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

clang format files that previously were incorrectly excluded.

Browse source
This commit is contained in:
wargio 2024-03-06 14:00:27 +08:00 committed by Giovanni
parent d2f0c13fc1
commit d6fc5845aa
7 changed files with 111 additions and 189 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

143
librz/arch/isa/avr/assembler.c
View file

@ -4,8 +4,8 @@
#include "assembler.h"
#include "common.h"
#define MAX_TOKENS 6
#define IS_INDIRECT_ADDRESS_REGISTER(x) ((x)=='x'||(x)=='y'||(x)=='z')
#define MAX_TOKENS 6
#define IS_INDIRECT_ADDRESS_REGISTER(x) ((x) == 'x' || (x) == 'y' || (x) == 'z')
#define throw_error(msg, ...) \
do { \
@ -21,15 +21,15 @@
} \
} while (0)
#define expected_const_or_error(a,exp) \
#define expected_const_or_error(a, exp) \
do { \
if (RZ_STR_ISEMPTY((a)) || strcmp((a),(exp))) { \
if (RZ_STR_ISEMPTY((a)) || strcmp((a), (exp))) { \
RZ_LOG_ERROR("[!] avr_assembler: expected '%s' but got '%s'.\n", (exp), (a)); \
return AVR_INVALID_SIZE; \
} \
} while (0)
#define parse_register_or_error_limit(rn,rs,min,max) \
#define parse_register_or_error_limit(rn, rs, min, max) \
do { \
cchar *tmp = (rs); \
if (*tmp == 'r') { \
@ -46,7 +46,7 @@
} \
} while (0)
#define parse_register_or_error(rn,rs) \
#define parse_register_or_error(rn, rs) \
do { \
cchar *tmp = (rs); \
if (*tmp == 'r') { \
@ -64,7 +64,7 @@
} while (0)
/// Parse things like "r25:r24" or just "r24". Result would be 24 in both cases.
#define parse_register_pair_or_error(rn,rs) \
#define parse_register_pair_or_error(rn, rs) \
do { \
cchar *tmp = (rs); \
if (*tmp == 'r') { \
@ -92,13 +92,13 @@
} \
if (high != (rn) + 1) { \
RZ_LOG_ERROR("[!] avr_assembler: register pair r%u:r%u invalid: %u != %u + 1.\n", \
(unsigned int)high, (unsigned int)(rn), (unsigned int)high, (unsigned int)(rn)); \
(unsigned int)high, (unsigned int)(rn), (unsigned int)high, (unsigned int)(rn)); \
return AVR_INVALID_SIZE; \
} \
} \
} while (0)
#define parse_unsigned_or_error(rn,rs,limit) \
#define parse_unsigned_or_error(rn, rs, limit) \
do { \
cchar *tmp = (rs); \
ut32 base = 0; \
@ -117,7 +117,7 @@
} \
} while (0)
#define parse_address_or_error(rn,rs,pc,llow,lhigh) \
#define parse_address_or_error(rn, rs, pc, llow, lhigh) \
do { \
cchar *tmp = (rs); \
if (RZ_STR_ISEMPTY(tmp)) { \
@ -131,7 +131,7 @@
(rn) = abs - pc; \
} \
if ((rn) < 0) { \
(rn) = ~(-((rn) - 1)); \
(rn) = ~(-((rn)-1)); \
} else { \
(rn) -= 2; \
} \
@ -142,7 +142,7 @@
} \
} while (0)
#define parse_signed_or_error(rn,rs,min,max) \
#define parse_signed_or_error(rn, rs, min, max) \
do { \
cchar *tmp = (rs); \
if (RZ_STR_ISEMPTY(tmp)) { \
@ -160,7 +160,7 @@
} \
} while (0)
#define auto_write16(buf,val,be) \
#define auto_write16(buf, val, be) \
do { \
if (be) { \
rz_write_be16(buf, val); \
@ -169,30 +169,27 @@
} \
} while (0)
typedef ut32 (*Encode)(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be);
typedef ut32 (*Encode)(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be);
typedef struct avr_decoder_t {
cchar* opcode; /* instruction name */
cchar *opcode; /* instruction name */
ut16 cbits; /* constant bits */
ut32 mintoks; /* required min token number */
ut32 maxtoks; /* required max token number */
Encode encode;
} AvrInstruction;
static ut32 avr_unique(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_unique(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
auto_write16(data, cbins, be);
return 2;
}
static ut32 avr_rdddddrrrr(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_rdddddrrrr(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> Rd,Rr | 0 <= d <= 31 | 0 <= r <= 31 */
ut16 Rd, Rr;
parse_register_or_error(Rd, tokens[1]);
parse_register_or_error(Rr, tokens[2]);
cbins |= (Rr & 0x000F);
cbins |= ((Rr << 5) & 0x0200);
cbins |= ((Rd << 4) & 0x01F0);
@ -201,8 +198,7 @@ static ut32 avr_rdddddrrrr(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data,
return 2;
}
static ut32 avr_KKddKKKK(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_KKddKKKK(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> Rd, K | d = {24,26,28,30}, 0 <= K <= 63 */
ut16 Rd, K;
parse_register_pair_or_error(Rd, tokens[1]);
@ -223,8 +219,7 @@ static ut32 avr_KKddKKKK(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut
return 2;
}
static ut32 avr_KKKKddddKKKK(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_KKKKddddKKKK(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> Rd, K | 16 <= d <= 31, 0 <= K <= 255 */
ut16 Rd, K;
parse_register_or_error_limit(Rd, tokens[1], 16, 31);
@ -240,8 +235,7 @@ static ut32 avr_KKKKddddKKKK(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data
return 2;
}
static ut32 avr_cbr(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_cbr(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> Rd, K | 16 <= d <= 31, 0 <= K <= 255 */
ut16 Rd, K;
parse_register_or_error_limit(Rd, tokens[1], 16, 31);
@ -258,8 +252,7 @@ static ut32 avr_cbr(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc
return 2;
}
static ut32 avr_dddddcccc(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_dddddcccc(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> Rd | 0 <= d <= 31 */
ut16 Rd;
parse_register_or_error(Rd, tokens[1]);
@ -269,8 +262,7 @@ static ut32 avr_dddddcccc(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, u
return 2;
}
static ut32 avr_dddddcbbb(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_dddddcbbb(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> Rd, b | 0 <= d <= 31, 0 <= b <= 7 */
ut16 Rd, b;
@ -284,8 +276,7 @@ static ut32 avr_dddddcbbb(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, u
return 2;
}
static ut32 avr_kkkkkkkccc(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_kkkkkkkccc(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> k | -64 <= k <= 63 */
st16 k;
parse_address_or_error(k, tokens[1], pc, -64, 63);
@ -294,8 +285,7 @@ static ut32 avr_kkkkkkkccc(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data,
return 2;
}
static ut32 avr_kkkkkccck(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_kkkkkccck(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
// <opcode> k | 0 <= k < 0x7ffffe
ut32 k;
parse_unsigned_or_error(k, tokens[1], 0x7ffffe);
@ -313,14 +303,12 @@ static ut32 avr_kkkkkccck(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, u
return 4;
}
static ut32 avr_AAAAAbbb(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_AAAAAbbb(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
// CBI A,b | 0 <= A <= 31 | 0 <= b <= 7
ut16 A, b;
parse_unsigned_or_error(A, tokens[1], 31);
parse_unsigned_or_error(b, tokens[2], 7);
cbins |= (b & 0x0007);
cbins |= ((A << 3) & 0x00F8);
@ -328,8 +316,7 @@ static ut32 avr_AAAAAbbb(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut
return 2;
}
static ut32 avr_dddddddddd(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_dddddddddd(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> Rd | 0 <= d <= 31 */
ut16 Rd;
parse_register_or_error(Rd, tokens[1]);
@ -342,8 +329,7 @@ static ut32 avr_dddddddddd(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data,
return 2;
}
static ut32 avr_KKKKcccc(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_KKKKcccc(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> K | 0 <= K <= 0xF */
ut16 K;
parse_unsigned_or_error(K, tokens[1], 0xF);
@ -354,8 +340,7 @@ static ut32 avr_KKKKcccc(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut
return 2;
}
static ut32 avr_elpm(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_elpm(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
if (ntokens == 1) {
/* elpm */
/* 1001010111011000 */
@ -387,7 +372,7 @@ static ut32 avr_elpm(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 p
return 2;
}
static ut32 avr_dddcrrr(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_dddcrrr(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> Rd,Rr | 16 <= d <= 23 | 16 <= r <= 23 */
ut16 Rd, Rr;
parse_register_or_error_limit(Rd, tokens[1], 16, 23);
@ -403,8 +388,7 @@ static ut32 avr_dddcrrr(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut6
return 2;
}
static ut32 avr_AAdddddAAAA(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_AAdddddAAAA(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> Rd, A | 0 <= d <= 31, 0 <= A <= 63 */
ut16 Rd, A;
parse_register_or_error(Rd, tokens[1]);
@ -418,7 +402,7 @@ static ut32 avr_AAdddddAAAA(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data,
return 2;
}
static ut32 avr_rrrrrcccc(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_rrrrrcccc(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> Rd | 0 <= d <= 31 */
ut16 Rd;
expected_const_or_error(tokens[1], "z");
@ -429,9 +413,7 @@ static ut32 avr_rrrrrcccc(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, u
return 2;
}
static ut32 avr_ld(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_ld(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* ld Rd, M | 0 <= d <= 31 | M = {X,Y,Z,X+,Y+,Z+,-X,-Y,-Z} */
ut16 Rd;
parse_register_or_error(Rd, tokens[1]);
@ -489,8 +471,7 @@ static ut32 avr_ld(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc,
return 2;
}
static ut32 avr_ldd(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_ldd(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* ldd Rd, M + q | 0 <= d <= 31 | M = {Y,Z} | 0 <= q <= 63*/
ut16 Rd, q;
parse_register_or_error(Rd, tokens[1]);
@ -520,8 +501,7 @@ static ut32 avr_ldd(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc
return 2;
}
static ut32 avr_lds(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_lds(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
ut16 Rd;
ut32 k;
parse_register_or_error(Rd, tokens[1]);
@ -554,8 +534,7 @@ static ut32 avr_lds(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc
return 4;
}
static ut32 avr_lpm(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_lpm(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
if (ntokens == 1) {
/* lpm */
/* 1001010111001000 */
@ -587,8 +566,7 @@ static ut32 avr_lpm(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc
return 2;
}
static ut32 avr_kkkkkkkkkkkk(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_kkkkkkkkkkkk(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> k | -4096 <= k <= 4096 */
st16 k;
parse_address_or_error(k, tokens[1], pc, -4096, 4096);
@ -598,8 +576,7 @@ static ut32 avr_kkkkkkkkkkkk(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data
return 2;
}
static ut32 avr_ddddrrrr(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_ddddrrrr(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> Rd, Rr | d = {0,2,...,30} | r = {0,2,...,30} */
ut16 Rd, Rr;
parse_register_or_error(Rd, tokens[1]);
@ -620,8 +597,7 @@ static ut32 avr_ddddrrrr(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut
return 2;
}
static ut32 avr_ddddrrrr_2x(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_ddddrrrr_2x(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> Rd, Rr | 16 <= d <= 31 | 16 <= r <= 31 */
ut16 Rd, Rr;
parse_register_or_error_limit(Rd, tokens[1], 16, 31);
@ -636,8 +612,7 @@ static ut32 avr_ddddrrrr_2x(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data,
return 2;
}
static ut32 avr_AArrrrrAAAA(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_AArrrrrAAAA(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> Rd, A | 0 <= d <= 31, 0 <= A <= 63 */
ut16 Rd, A;
parse_unsigned_or_error(A, tokens[1], 63);
@ -651,8 +626,7 @@ static ut32 avr_AArrrrrAAAA(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data,
return 2;
}
static ut32 avr_rrrrrcbbb(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_rrrrrcbbb(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> Rr, b | 0 <= d <= 31, 0 <= b <= 7 */
ut16 Rr, b;
parse_register_or_error(Rr, tokens[1]);
@ -665,7 +639,7 @@ static ut32 avr_rrrrrcbbb(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, u
return 2;
}
static ut32 avr_ddddcccc(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_ddddcccc(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> Rd | 16 <= d <= 31 */
ut16 Rd;
parse_register_or_error_limit(Rd, tokens[1], 16, 31);
@ -677,8 +651,7 @@ static ut32 avr_ddddcccc(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut
return 2;
}
static ut32 avr_spm(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_spm(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
if (ntokens == 1) {
/* spm */
/* 1001010111101000 */
@ -698,8 +671,7 @@ static ut32 avr_spm(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc
return 2;
}
static ut32 avr_st(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_st(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* st M, Rr | 0 <= r <= 31 | M = {X,Y,Z,-X,-Y,-Z} */
ut16 Rr;
parse_register_or_error(Rr, tokens[2]);
@ -757,8 +729,7 @@ static ut32 avr_st(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc,
return 2;
}
static ut32 avr_std(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_std(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
if (ntokens == 4) {
/* std M, Rr | 0 <= r <= 31 | M = {X+,Y+,Z+} */
ut16 Rr;
@ -815,9 +786,7 @@ static ut32 avr_std(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc
throw_error("expected std Rr, M + q | 0 <= d <= 31 | M = {Y,Z} | 0 <= q <= 63\n");
}
static ut32 avr_sts(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_sts(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* sts k, Rr | 0 <= r <= 31, 0 <= k <= 0xFFFF */
ut16 Rr;
ut32 k;
@ -851,8 +820,7 @@ static ut32 avr_sts(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc
return 4;
}
static ut32 avr_ssscccc(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_ssscccc(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> b | 0 <= b <= 7 */
ut16 b;
parse_unsigned_or_error(b, tokens[1], 7);
@ -862,8 +830,7 @@ static ut32 avr_ssscccc(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut6
return 2;
}
static ut32 avr_kkkkkkksss(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
static ut32 avr_kkkkkkksss(ut16 cbins, cchar **tokens, ut32 ntokens, ut8 *data, ut64 pc, bool be) {
/* <opcode> b, k | -64 <= k <= 63 | 0 <= b <= 7 */
ut16 b;
st16 k;
@ -876,7 +843,7 @@ static ut32 avr_kkkkkkksss(ut16 cbins, cchar** tokens, ut32 ntokens, ut8 *data,
return 2;
}
// clang-format off
static const AvrInstruction instructions[] = {
{ "adc" /* 000111rdddddrrrr */ , 0x1C00, 3, 3, avr_rdddddrrrr },
{ "add" /* 000011rdddddrrrr */ , 0x0C00, 3, 3, avr_rdddddrrrr },
@ -998,13 +965,14 @@ static const AvrInstruction instructions[] = {
{ "wdr" /* 1001010110101000 */ , 0x95A8, 1, 1, avr_unique },
{ "xch" /* 1001001rrrrr0100 */ , 0x9204, 3, 3, avr_rrrrrcccc }
};
// clang-format on
static char *strdup_limit(cchar *begin, cchar *end) {
ssize_t size = end - begin;
if (size < 1) {
return NULL;
}
char* str = malloc(size + 1);
char *str = malloc(size + 1);
if (!str) {
return NULL;
}
@ -1023,7 +991,7 @@ static void sanitize_input(char *cinput, st32 input_size) {
static char **tokens_new(cchar *input, st32 input_size, ut32 *ntokens) {
char* cinput = strdup(input);
char *cinput = strdup(input);
if (!cinput) {
rz_warn_if_reached();
return NULL;
@ -1031,7 +999,7 @@ static char **tokens_new(cchar *input, st32 input_size, ut32 *ntokens) {
sanitize_input(cinput, input_size);
char **tokens = RZ_NEWS0(char*, MAX_TOKENS);
char **tokens = RZ_NEWS0(char *, MAX_TOKENS);
if (!tokens) {
free(cinput);
rz_warn_if_reached();
@ -1040,7 +1008,7 @@ static char **tokens_new(cchar *input, st32 input_size, ut32 *ntokens) {
ut32 count;
cchar *start, *end;
char* copy;
char *copy;
start = rz_str_trim_head_ro(cinput);
for (count = 0; *start && count < MAX_TOKENS; count++) {
@ -1086,13 +1054,12 @@ ut32 avr_assembler(const char *input, st32 input_size, ut8 *output, st32 output_
ut32 written = AVR_INVALID_SIZE;
ut32 ntokens = 0;
char** tokens = tokens_new(input, input_size, &ntokens);
char **tokens = tokens_new(input, input_size, &ntokens);
if (!tokens || ntokens < 1) {
RZ_LOG_ERROR("[!] avr_assembler: invalid assembly.\n");
goto avr_assembler_end;
}
for (ut32 i = 0; i < RZ_ARRAY_SIZE(instructions); ++i) {
if (!rz_str_casecmp(tokens[0], instructions[i].opcode)) {
ut16 mintoks = instructions[i].mintoks;
@ -1101,7 +1068,7 @@ ut32 avr_assembler(const char *input, st32 input_size, ut8 *output, st32 output_
RZ_LOG_ERROR("[!] avr_assembler: '%s' requires %u <= ntokens <= %u, but %u tokens was provided.\n", tokens[0], mintoks, maxtoks, ntokens);
goto avr_assembler_end;
}
written = instructions[i].encode(instructions[i].cbits, (cchar**)tokens, ntokens, output, pc, be);
written = instructions[i].encode(instructions[i].cbits, (cchar **)tokens, ntokens, output, pc, be);
break;
}
}

142
librz/arch/isa/avr/disassembler.c
View file

@ -20,10 +20,10 @@
* - q = displacement const
*/
typedef ut32 (*Decode)(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb);
typedef ut32 (*Decode)(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb);
typedef struct avr_decoder_t {
cchar* name; /* instruction name */
cchar *name; /* instruction name */
AVROpMnem id; /* instruction identifier */
ut32 cycles; /* number of execution cycles */
ut16 cbits; /* constant bits */
@ -32,13 +32,13 @@ typedef struct avr_decoder_t {
Decode decode;
} AvrInstruction;
static ut32 avr_unique(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_unique(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
aop->mnemonic = id;
rz_strbuf_set(sb, name);
return 2;
}
static ut32 avr_rdddddrrrr(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_rdddddrrrr(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rr = data[0] & 0x000F;
ut16 Rd = ((data[0] & 0x01F0) >> 4);
Rr |= ((data[0] & 0x0200) >> 5);
@ -71,8 +71,7 @@ static ut32 avr_rdddddrrrr(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVR
return 2;
}
static ut32 avr_KKddKKKK(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_KKddKKKK(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 K = data[0] & 0x000F;
ut16 Rd = 24 + ((data[0] & 0x0030) >> 3);
K |= ((data[0] & 0x00C0) >> 2);
@ -85,8 +84,7 @@ static ut32 avr_KKddKKKK(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp
return 2;
}
static ut32 avr_KKKKddddKKKK(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_KKKKddddKKKK(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 K = data[0] & 0x000F;
ut16 Rd = 16 + ((data[0] & 0x00F0) >> 4);
K |= ((data[0] & 0x0F00) >> 4);
@ -104,8 +102,7 @@ static ut32 avr_KKKKddddKKKK(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, A
return 2;
}
static ut32 avr_dddddcccc(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_dddddcccc(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rd = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -114,8 +111,7 @@ static ut32 avr_dddddcccc(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVRO
return 2;
}
static ut32 avr_dddddcbbb(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_dddddcbbb(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 b = data[0] & 0x0007;
ut16 Rd = ((data[0] & 0x01F0) >> 4);
@ -126,8 +122,7 @@ static ut32 avr_dddddcbbb(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVRO
return 2;
}
static ut32 avr_kkkkkkkccc(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_kkkkkkkccc(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
st16 k = (data[0] & 0x03F8) >> 3;
k *= 2;
if (k & 0x0080) {
@ -145,8 +140,7 @@ static ut32 avr_kkkkkkkccc(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVR
return 2;
}
static ut32 avr_kkkkkccck(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_kkkkkccck(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
st32 k = data[0] & 0x0001;
k |= ((data[0] & 0x01F0) >> 3);
k <<= 16;
@ -160,8 +154,7 @@ static ut32 avr_kkkkkccck(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVRO
return 4;
}
static ut32 avr_AAAAAbbb(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_AAAAAbbb(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 b = data[0] & 0x0007;
ut16 A = ((data[0] & 0x00F8) >> 3);
@ -172,8 +165,7 @@ static ut32 avr_AAAAAbbb(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp
return 2;
}
static ut32 avr_KKKKcccc(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_KKKKcccc(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 K = ((data[0] & 0x00F0) >> 4);
aop->mnemonic = id;
@ -182,8 +174,7 @@ static ut32 avr_KKKKcccc(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp
return 2;
}
static ut32 avr_dddddcccc_z(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_dddddcccc_z(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rd = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -193,8 +184,7 @@ static ut32 avr_dddddcccc_z(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AV
return 2;
}
static ut32 avr_dddddcccc_zp(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_dddddcccc_zp(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rd = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -206,8 +196,7 @@ static ut32 avr_dddddcccc_zp(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, A
return 2;
}
static ut32 avr_dddcrrr(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_dddcrrr(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rr = 16 + (data[0] & 0x0007);
ut16 Rd = 16 + ((data[0] & 0x0070) >> 4);
@ -218,8 +207,7 @@ static ut32 avr_dddcrrr(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp
return 2;
}
static ut32 avr_AAdddddAAAA(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_AAdddddAAAA(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 A = data[0] & 0x000F;
ut16 Rd = ((data[0] & 0x01F0) >> 4);
A |= ((data[0] & 0x0600) >> 5);
@ -231,8 +219,7 @@ static ut32 avr_AAdddddAAAA(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AV
return 2;
}
static ut32 avr_dddddcccc_x(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_dddddcccc_x(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rd = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -242,8 +229,7 @@ static ut32 avr_dddddcccc_x(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AV
return 2;
}
static ut32 avr_dddddcccc_xp(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_dddddcccc_xp(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rd = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -255,8 +241,7 @@ static ut32 avr_dddddcccc_xp(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, A
return 2;
}
static ut32 avr_dddddcccc_xm(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_dddddcccc_xm(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rd = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -268,8 +253,7 @@ static ut32 avr_dddddcccc_xm(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, A
return 2;
}
static ut32 avr_dddddcccc_y(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_dddddcccc_y(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rd = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -279,8 +263,7 @@ static ut32 avr_dddddcccc_y(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AV
return 2;
}
static ut32 avr_dddddcccc_yp(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_dddddcccc_yp(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rd = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -292,8 +275,7 @@ static ut32 avr_dddddcccc_yp(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, A
return 2;
}
static ut32 avr_dddddcccc_ym(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_dddddcccc_ym(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rd = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -305,8 +287,7 @@ static ut32 avr_dddddcccc_ym(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, A
return 2;
}
static ut32 avr_qcqqcdddddcqqq_y(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_qcqqcdddddcqqq_y(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 q = data[0] & 0x0007;
ut16 Rd = ((data[0] & 0x01F0) >> 4);
q |= ((data[0] & 0x0C00) >> 7);
@ -321,8 +302,7 @@ static ut32 avr_qcqqcdddddcqqq_y(cchar* name, AVROpMnem id, ut16 data[2], ut64 p
return 2;
}
static ut32 avr_dddddcccc_zm(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_dddddcccc_zm(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rd = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -334,8 +314,7 @@ static ut32 avr_dddddcccc_zm(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, A
return 2;
}
static ut32 avr_qcqqcdddddcqqq_z(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_qcqqcdddddcqqq_z(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 q = data[0] & 0x0007;
ut16 Rd = ((data[0] & 0x01F0) >> 4);
q |= ((data[0] & 0x0C00) >> 7);
@ -350,8 +329,7 @@ static ut32 avr_qcqqcdddddcqqq_z(cchar* name, AVROpMnem id, ut16 data[2], ut64 p
return 2;
}
static ut32 avr_dddddcccc_load32(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_dddddcccc_load32(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rd = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
aop->param[0] = Rd;
@ -360,8 +338,7 @@ static ut32 avr_dddddcccc_load32(cchar* name, AVROpMnem id, ut16 data[2], ut64 p
return 4;
}
static ut32 avr_kkkddddkkkk_load16(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_kkkddddkkkk_load16(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 k = data[0] & 0x000F;
ut16 Rd = 16 + ((data[0] & 0x00F0) >> 4);
k |= ((data[0] & 0x0700) >> 4);
@ -372,8 +349,7 @@ static ut32 avr_kkkddddkkkk_load16(cchar* name, AVROpMnem id, ut16 data[2], ut64
return 2;
}
static ut32 avr_ddddrrrr(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_ddddrrrr(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rr = data[0] & 0x000F;
ut16 Rd = ((data[0] & 0x00F0) >> 4);
@ -387,8 +363,7 @@ static ut32 avr_ddddrrrr(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp
return 2;
}
static ut32 avr_ddddrrrr_2x(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_ddddrrrr_2x(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rr = data[0] & 0x000F;
ut16 Rd = ((data[0] & 0x00F0) >> 4);
Rr += 16;
@ -401,8 +376,7 @@ static ut32 avr_ddddrrrr_2x(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AV
return 2;
}
static ut32 avr_AArrrrrAAAA(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_AArrrrrAAAA(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 A = data[0] & 0x000F;
ut16 Rr = ((data[0] & 0x01F0) >> 4);
A |= ((data[0] & 0x0600) >> 5);
@ -414,8 +388,7 @@ static ut32 avr_AArrrrrAAAA(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AV
return 2;
}
static ut32 avr_kkkkkkkkkkkk(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_kkkkkkkkkkkk(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
st16 k = data[0] & 0x0FFF;
k *= 2;
if (k & 0x1000) {
@ -434,8 +407,7 @@ static ut32 avr_kkkkkkkkkkkk(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, A
return 2;
}
static ut32 avr_rrrrrcbbb(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_rrrrrcbbb(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 b = data[0] & 0x0007;
ut16 Rr = ((data[0] & 0x01F0) >> 4);
@ -446,8 +418,7 @@ static ut32 avr_rrrrrcbbb(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVRO
return 2;
}
static ut32 avr_ddddcccc(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_ddddcccc(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rd = 16 + ((data[0] & 0x00F0) >> 4);
aop->mnemonic = id;
@ -456,8 +427,7 @@ static ut32 avr_ddddcccc(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp
return 2;
}
static ut32 avr_spmz(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_spmz(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
aop->mnemonic = id;
aop->param[0] = 'Z';
aop->param[1] = '+';
@ -465,8 +435,7 @@ static ut32 avr_spmz(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *ao
return 2;
}
static ut32 avr_rrrrrcccc_x(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_rrrrrcccc_x(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rr = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -476,8 +445,7 @@ static ut32 avr_rrrrrcccc_x(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AV
return 2;
}
static ut32 avr_rrrrrcccc_xp(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_rrrrrcccc_xp(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rr = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -489,8 +457,7 @@ static ut32 avr_rrrrrcccc_xp(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, A
return 2;
}
static ut32 avr_rrrrrcccc_xm(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_rrrrrcccc_xm(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rr = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -502,8 +469,7 @@ static ut32 avr_rrrrrcccc_xm(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, A
return 2;
}
static ut32 avr_rrrrrcccc_y(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_rrrrrcccc_y(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rr = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -513,8 +479,7 @@ static ut32 avr_rrrrrcccc_y(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AV
return 2;
}
static ut32 avr_rrrrrcccc_yp(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_rrrrrcccc_yp(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rr = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -526,8 +491,7 @@ static ut32 avr_rrrrrcccc_yp(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, A
return 2;
}
static ut32 avr_rrrrrcccc_ym(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_rrrrrcccc_ym(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rr = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -539,8 +503,7 @@ static ut32 avr_rrrrrcccc_ym(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, A
return 2;
}
static ut32 avr_qcqqcrrrrrcqqq_y(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_qcqqcrrrrrcqqq_y(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 q = data[0] & 0x0007;
ut16 Rr = ((data[0] & 0x01F0) >> 4);
q |= ((data[0] & 0x0C00) >> 7);
@ -555,8 +518,7 @@ static ut32 avr_qcqqcrrrrrcqqq_y(cchar* name, AVROpMnem id, ut16 data[2], ut64 p
return 2;
}
static ut32 avr_rrrrrcccc_z(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_rrrrrcccc_z(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rr = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -566,8 +528,7 @@ static ut32 avr_rrrrrcccc_z(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AV
return 2;
}
static ut32 avr_rrrrrcccc_zp(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_rrrrrcccc_zp(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rr = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -579,8 +540,7 @@ static ut32 avr_rrrrrcccc_zp(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, A
return 2;
}
static ut32 avr_rrrrrcccc_zm(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_rrrrrcccc_zm(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rr = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -592,8 +552,7 @@ static ut32 avr_rrrrrcccc_zm(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, A
return 2;
}
static ut32 avr_qcqqcrrrrrcqqq_z(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_qcqqcrrrrrcqqq_z(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 q = data[0] & 0x0007;
ut16 Rr = ((data[0] & 0x01F0) >> 4);
q |= ((data[0] & 0x0C00) >> 7);
@ -608,8 +567,7 @@ static ut32 avr_qcqqcrrrrrcqqq_z(cchar* name, AVROpMnem id, ut16 data[2], ut64 p
return 2;
}
static ut32 avr_dddddcccc_store32(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_dddddcccc_store32(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 Rd = ((data[0] & 0x01F0) >> 4);
aop->mnemonic = id;
@ -619,8 +577,7 @@ static ut32 avr_dddddcccc_store32(cchar* name, AVROpMnem id, ut16 data[2], ut64
return 4;
}
static ut32 avr_kkkddddkkkk_store16(cchar* name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
static ut32 avr_kkkddddkkkk_store16(cchar *name, AVROpMnem id, ut16 data[2], ut64 pc, AVROp *aop, RzStrBuf *sb) {
ut16 k = data[0] & 0x000F;
ut16 Rd = 16 + ((data[0] & 0x00F0) >> 4);
k |= ((data[0] & 0x0700) >> 4);
@ -632,7 +589,7 @@ static ut32 avr_kkkddddkkkk_store16(cchar* name, AVROpMnem id, ut16 data[2], ut6
return 2;
}
// clang-format off
static const AvrInstruction instructions[] = {
{ "adc", AVR_OP_ADC /* 000111rdddddrrrr */, 2, 0x1C00, 0xFC00, 2, avr_rdddddrrrr },
{ "add", AVR_OP_ADD /* 000011rdddddrrrr */, 2, 0x0C00, 0xFC00, 2, avr_rdddddrrrr },
@ -769,6 +726,7 @@ static const AvrInstruction instructions[] = {
{ "wdr", AVR_OP_WDR /* 1001010110101000 */, 2, 0x95A8, 0xFFFF, 2, avr_unique },
{ "xch", AVR_OP_XCH /* 1001001rrrrr0100 */, 2, 0x9204, 0xFE0F, 2, avr_rrrrrcccc_z }
};
// clang-format on
ut32 avr_disassembler(const ut8 *buffer, const ut32 size, ut64 pc, bool be, AVROp *aop, RzStrBuf *sb) {
rz_return_val_if_fail(buffer && size && aop && sb, false);
@ -777,7 +735,7 @@ ut32 avr_disassembler(const ut8 *buffer, const ut32 size, ut64 pc, bool be, AVRO
}
ut16 masked;
ut16 data[2] = {0};
ut16 data[2] = { 0 };
data[0] = rz_read_ble16(buffer, be);

2
librz/arch/isa/avr/disassembler.h
View file

@ -133,6 +133,6 @@ typedef struct avr_opcode_t {
ut16 size;
} AVROp;
ut32 avr_disassembler(const ut8 *buffer, const ut32 size, ut64 pc, bool be, AVROp* aop, RzStrBuf *sb);
ut32 avr_disassembler(const ut8 *buffer, const ut32 size, ut64 pc, bool be, AVROp *aop, RzStrBuf *sb);
#endif /* RZ_ASM_AVR_DISASSEMBLER_H */

5
librz/arch/isa/i8080/i8080dis.h
View file

@ -16,7 +16,7 @@
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
@ -31,7 +31,6 @@
#ifndef I8080DIS_H
#define I8080DIS_H
int i8080_disasm(unsigned char const* const code, char* text, int text_sz);
int i8080_disasm(unsigned char const *const code, char *text, int text_sz);
#endif

2
librz/arch/isa/mips/mips_assembler.c
View file

@ -2,7 +2,7 @@
// SPDX-License-Identifier: LGPL-3.0-only
#include <rz_types.h>
#include <rz_util.h>
#include <rz_util.h>
static const char *const regs[33] = {
"zero", "at", "v0", "v1", "a0", "a1", "a2", "a3",

2
librz/arch/isa/mips/mips_assembler.h
View file

@ -8,4 +8,4 @@
RZ_IPI int mips_assemble_opcode(const char *str, ut64 pc, ut8 *out);
#endif /* ASSEMBLE_MIPS_H */
#endif /* ASSEMBLE_MIPS_H */

4
sys/clang-format.py
View file

@ -26,13 +26,11 @@ dirlist = [
skiplist = [
"/gnu/",
"librz/arch/isa_gnu/",
"librz/asm/arch/i8080/",
"librz/asm/arch/arm/aarch64/",
"librz/hash/xxhash/",
"librz/bin/mangling/cxx/",
"librz/bin/d/jni.h",
"librz/util/bdiff.c",
"librz/asm/arch/tms320/c55x/table.h",
"librz/arch/isa/tms320/c55x/table.h",
"librz/include/sflib/",
]