Rizin
unix-like reverse engineering framework and cli tools
Macros | Functions | Variables
amd29k.c File Reference
#include "amd29k.h"
#include "amd29k_internal.h"
#include <stdio.h>
#include <string.h>
#include <rz_analysis.h>

Go to the source code of this file.

Macros

#define CPU_ANY   "*"
 
#define N_AMD29K_INSTRUCTIONS   207
 
#define AMD29K_GET_TYPE(x, i)   ((x)->type[(i)])
 
#define AMD29K_GET_VALUE(x, i)   ((x)->operands[(i)])
 
#define AMD29K_SET_VALUE(x, i, v, t)
 
#define AMD29K_SET_INVALID(x, i)   ((x)->type[(i)] = AMD29K_TYPE_UNK)
 
#define AMD29K_HAS_BIT(x)   (((x)[0] & 1))
 
#define AMD29K_IS_REG_GR(x)   ((x) >= 0 && (x) < 128)
 
#define AMD29K_IS_REG_LR(x)   ((x) >= 128 && (x) < 256)
 
#define AMD29K_REGNAME(x)   (AMD29K_IS_REG_GR(x) ? "gr" : "lr")
 
#define AMD29K_LR(x)   (AMD29K_IS_REG_GR(x) ? (x) : (x)-127)
 
#define AMD29K_IS_6(a, b, c, d, e, f)   (t0 == (a) && t1 == (b) && t2 == (c) && t3 == (d) && t4 == (e) && t5 == (f))
 
#define AMD29K_IS_1(a)   AMD29K_IS_6(a, (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK))
 
#define AMD29K_IS_2(a, b)   AMD29K_IS_6(a, b, (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK))
 
#define AMD29K_IS_3(a, b, c)   AMD29K_IS_6(a, b, c, (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK))
 
#define AMD29K_IS_4(a, b, c, d)   AMD29K_IS_6(a, b, c, d, (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK))
 
#define AMD29K_IS_5(a, b, c, d, e)   AMD29K_IS_6(a, b, c, d, e, (AMD29K_TYPE_UNK))
 

Functions

static void decode_ra_rb_rci (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_ra_rb_rc (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_ra_imm16 (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_ra_i16_sh2 (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_imm16_sh2 (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_load_store (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_calli (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_rc_ra_imm (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_clz (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_convert (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_rc_ra (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_dmac_fmac (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_ra_rb (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_rb (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_rc_imm (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_ra_imm (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_mfsr (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_mtsr (amd29k_instr_t *instruction, const ut8 *buffer)
 
static void decode_none (amd29k_instr_t *instruction, const ut8 *buffer)
 
static bool is_cpu (const char *cpu, const amd29k_instruction_t *in)
 
bool amd29k_instr_decode (const ut8 *buffer, const ut32 buffer_size, amd29k_instr_t *instruction, const char *cpu)
 
bool amd29k_instr_is_ret (amd29k_instr_t *instruction)
 
ut64 amd29k_instr_jump (ut64 address, amd29k_instr_t *instruction)
 
void amd29k_instr_print (char *string, int string_size, ut64 address, amd29k_instr_t *instruction)
 

Variables

const amd29k_instruction_t amd29k_instructions [N_AMD29K_INSTRUCTIONS]
 

Macro Definition Documentation

◆ AMD29K_GET_TYPE

#define AMD29K_GET_TYPE (   x,
  i 
)    ((x)->type[(i)])

Definition at line 13 of file amd29k.c.

◆ AMD29K_GET_VALUE

#define AMD29K_GET_VALUE (   x,
  i 
)    ((x)->operands[(i)])

Definition at line 14 of file amd29k.c.

◆ AMD29K_HAS_BIT

#define AMD29K_HAS_BIT (   x)    (((x)[0] & 1))

Definition at line 19 of file amd29k.c.

◆ AMD29K_IS_1

#define AMD29K_IS_1 (   a)    AMD29K_IS_6(a, (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK))

Definition at line 467 of file amd29k.c.

◆ AMD29K_IS_2

#define AMD29K_IS_2 (   a,
  b 
)    AMD29K_IS_6(a, b, (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK))

Definition at line 468 of file amd29k.c.

◆ AMD29K_IS_3

#define AMD29K_IS_3 (   a,
  b,
  c 
)    AMD29K_IS_6(a, b, c, (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK))

Definition at line 469 of file amd29k.c.

◆ AMD29K_IS_4

#define AMD29K_IS_4 (   a,
  b,
  c,
  d 
)    AMD29K_IS_6(a, b, c, d, (AMD29K_TYPE_UNK), (AMD29K_TYPE_UNK))

Definition at line 470 of file amd29k.c.

◆ AMD29K_IS_5

#define AMD29K_IS_5 (   a,
  b,
  c,
  d,
  e 
)    AMD29K_IS_6(a, b, c, d, e, (AMD29K_TYPE_UNK))

Definition at line 471 of file amd29k.c.

◆ AMD29K_IS_6

#define AMD29K_IS_6 (   a,
  b,
  c,
  d,
  e,
  f 
)    (t0 == (a) && t1 == (b) && t2 == (c) && t3 == (d) && t4 == (e) && t5 == (f))

Definition at line 466 of file amd29k.c.

◆ AMD29K_IS_REG_GR

#define AMD29K_IS_REG_GR (   x)    ((x) >= 0 && (x) < 128)

Definition at line 21 of file amd29k.c.

◆ AMD29K_IS_REG_LR

#define AMD29K_IS_REG_LR (   x)    ((x) >= 128 && (x) < 256)

Definition at line 23 of file amd29k.c.

◆ AMD29K_LR

#define AMD29K_LR (   x)    (AMD29K_IS_REG_GR(x) ? (x) : (x)-127)

Definition at line 25 of file amd29k.c.

◆ AMD29K_REGNAME

#define AMD29K_REGNAME (   x)    (AMD29K_IS_REG_GR(x) ? "gr" : "lr")

Definition at line 24 of file amd29k.c.

◆ AMD29K_SET_INVALID

#define AMD29K_SET_INVALID (   x,
  i 
)    ((x)->type[(i)] = AMD29K_TYPE_UNK)

Definition at line 18 of file amd29k.c.

◆ AMD29K_SET_VALUE

#define AMD29K_SET_VALUE (   x,
  i,
  v,
  t 
)
Value:
((x)->operands[(i)] = (v)); \
((x)->type[(i)] = (t))
i
lzma_index ** i
Definition: index.h:629
v
const char * v
Definition: dsignal.c:12
x
int x
Definition: mipsasm.c:20
type
int type
Definition: mipsasm.c:17

Definition at line 15 of file amd29k.c.

◆ CPU_ANY

#define CPU_ANY   "*"

Definition at line 9 of file amd29k.c.

◆ N_AMD29K_INSTRUCTIONS

#define N_AMD29K_INSTRUCTIONS   207

Definition at line 11 of file amd29k.c.

Function Documentation

◆ amd29k_instr_decode()

bool amd29k_instr_decode ( const ut8 *  buffer,
const ut32  buffer_size,
amd29k_instr_t *  instruction,
const char *  cpu 
)

Definition at line 435 of file amd29k.c.

435  {
436  if (!buffer || buffer_size < 4 || !instruction || (cpu && strlen(cpu) < 5)) {
437  return false;
438  }
439  if (!cpu) {
440  cpu = CPU_29000;
441  }
442  if (buffer[0] == 0x70 && buffer[1] == 0x40 && buffer[2] == 0x01 && buffer[3] == 0x01) {
443  decode_none(instruction, buffer);
444  instruction->mnemonic = "nop";
445  instruction->op_type = RZ_ANALYSIS_OP_TYPE_NOP;
446  return true;
447  }
448  int i;
449  for (i = 0; i < N_AMD29K_INSTRUCTIONS; i++) {
450  const amd29k_instruction_t *in = &amd29k_instructions[i];
451  if (in->cpu[0] == '*' && in->mask == buffer[0]) {
452  in->decode(instruction, buffer);
453  instruction->mnemonic = in->mnemonic;
454  instruction->op_type = in->op_type;
455  return true;
456  } else if (in->cpu[0] != '*' && in->mask == buffer[0] && is_cpu(cpu, in)) {
457  in->decode(instruction, buffer);
458  instruction->mnemonic = in->mnemonic;
459  instruction->op_type = in->op_type;
460  return true;
461  }
462  }
463  return false;
464 }
decode_none
static void decode_none(amd29k_instr_t *instruction, const ut8 *buffer)
Definition: amd29k.c:207
amd29k_instructions
const amd29k_instruction_t amd29k_instructions[N_AMD29K_INSTRUCTIONS]
Definition: amd29k.c:217
N_AMD29K_INSTRUCTIONS
#define N_AMD29K_INSTRUCTIONS
Definition: amd29k.c:11
is_cpu
static bool is_cpu(const char *cpu, const amd29k_instruction_t *in)
Definition: amd29k.c:427
CPU_29000
#define CPU_29000
Definition: amd29k.h:13
cpu
static ut32 cpu[32]
Definition: analysis_or1k.c:21
in
const lzma_allocator const uint8_t * in
Definition: block.h:527
RZ_ANALYSIS_OP_TYPE_NOP
@ RZ_ANALYSIS_OP_TYPE_NOP
Definition: rz_analysis.h:389
amd29k_instruction_s
Definition: amd29k_internal.h:9
buffer
Definition: buffer.h:15
buffer_size
#define buffer_size(buffer)
Definition: zip_source_buffer.c:70

References amd29k_instructions, buffer_size, cpu, CPU_29000, decode_none(), i, in, is_cpu(), N_AMD29K_INSTRUCTIONS, and RZ_ANALYSIS_OP_TYPE_NOP.

Referenced by analop(), and disassemble().

◆ amd29k_instr_is_ret()

bool amd29k_instr_is_ret ( amd29k_instr_t *  instruction)

Definition at line 473 of file amd29k.c.

473  {
474  if (instruction && !strcmp(instruction->mnemonic, "calli") && instruction->operands[0] == 128 && instruction->operands[1] == 128) {
475  return true;
476  }
477  return false;
478 }

Referenced by analop().

◆ amd29k_instr_jump()

ut64 amd29k_instr_jump ( ut64  address,
amd29k_instr_t *  instruction 
)

Definition at line 480 of file amd29k.c.

480  {
481  if (!instruction) {
482  return UT64_MAX;
483  }
484  int t0 = AMD29K_GET_TYPE(instruction, 0);
485  int t1 = AMD29K_GET_TYPE(instruction, 1);
486  int t2 = AMD29K_GET_TYPE(instruction, 2);
487  int t3 = AMD29K_GET_TYPE(instruction, 3);
488  int t4 = AMD29K_GET_TYPE(instruction, 4);
489  int t5 = AMD29K_GET_TYPE(instruction, 5);
490 
491  int v0 = AMD29K_GET_VALUE(instruction, 0);
492  int v1 = AMD29K_GET_VALUE(instruction, 1);
493  if (AMD29K_IS_1(AMD29K_TYPE_JMP)) {
494  return address + ((int)v0);
495  } else if (AMD29K_IS_2(AMD29K_TYPE_REG, AMD29K_TYPE_JMP)) {
496  return address + ((int)v1);
497  }
498  return UT64_MAX;
499 }
AMD29K_IS_2
#define AMD29K_IS_2(a, b)
Definition: amd29k.c:468
AMD29K_GET_VALUE
#define AMD29K_GET_VALUE(x, i)
Definition: amd29k.c:14
AMD29K_IS_1
#define AMD29K_IS_1(a)
Definition: amd29k.c:467
AMD29K_GET_TYPE
#define AMD29K_GET_TYPE(x, i)
Definition: amd29k.c:13
AMD29K_TYPE_JMP
@ AMD29K_TYPE_JMP
Definition: amd29k_internal.h:22
AMD29K_TYPE_REG
@ AMD29K_TYPE_REG
Definition: amd29k_internal.h:20
v0
@ v0
Definition: lanai.h:84
v1
@ v1
Definition: lanai.h:85
UT64_MAX
#define UT64_MAX
Definition: rz_types_base.h:86
int
static int
Definition: sfsocketcall.h:114

References AMD29K_GET_TYPE, AMD29K_GET_VALUE, AMD29K_IS_1, AMD29K_IS_2, AMD29K_TYPE_JMP, AMD29K_TYPE_REG, int, benchmark::t1, UT64_MAX, v0, and v1.

Referenced by analop().

◆ amd29k_instr_print()

void amd29k_instr_print ( char *  string,
int  string_size,
ut64  address,
amd29k_instr_t *  instruction 
)

Definition at line 501 of file amd29k.c.

501  {
502  if (!string || string_size < 0 || !instruction) {
503  return;
504  }
505  int t0 = AMD29K_GET_TYPE(instruction, 0);
506  int t1 = AMD29K_GET_TYPE(instruction, 1);
507  int t2 = AMD29K_GET_TYPE(instruction, 2);
508  int t3 = AMD29K_GET_TYPE(instruction, 3);
509  int t4 = AMD29K_GET_TYPE(instruction, 4);
510  int t5 = AMD29K_GET_TYPE(instruction, 5);
511 
512  int v0 = AMD29K_GET_VALUE(instruction, 0);
513  int v1 = AMD29K_GET_VALUE(instruction, 1);
514  int v2 = AMD29K_GET_VALUE(instruction, 2);
515  int v3 = AMD29K_GET_VALUE(instruction, 3);
516  int v4 = AMD29K_GET_VALUE(instruction, 4);
517  int v5 = AMD29K_GET_VALUE(instruction, 5);
518 
519  if (AMD29K_IS_1(AMD29K_TYPE_REG)) {
520  const char *p0 = AMD29K_REGNAME(v0);
521  snprintf(string, string_size, "%s %s%d", instruction->mnemonic, p0, AMD29K_LR(v0));
522 
523  } else if (AMD29K_IS_1(AMD29K_TYPE_IMM)) {
524  if (v0 >= 0) {
525  snprintf(string, string_size, "%s 0x%x", instruction->mnemonic, v0);
526  } else {
527  v0 = 0 - v0;
528  snprintf(string, string_size, "%s -0x%x", instruction->mnemonic, v0);
529  }
530 
531  } else if (AMD29K_IS_1(AMD29K_TYPE_JMP)) {
532  ut64 ptr = address + ((int)v0);
533  snprintf(string, string_size, "%s 0x%" PFMT64x, instruction->mnemonic, ptr);
534 
535  } else if (AMD29K_IS_2(AMD29K_TYPE_REG, AMD29K_TYPE_REG)) {
536  const char *p0 = AMD29K_REGNAME(v0);
537  const char *p1 = AMD29K_REGNAME(v1);
538  snprintf(string, string_size, "%s %s%d %s%d", instruction->mnemonic, p0, AMD29K_LR(v0), p1, AMD29K_LR(v1));
539 
540  } else if (AMD29K_IS_2(AMD29K_TYPE_REG, AMD29K_TYPE_IMM)) {
541  const char *p0 = AMD29K_REGNAME(v0);
542  if (v1 >= 0) {
543  snprintf(string, string_size, "%s %s%d 0x%x", instruction->mnemonic, p0, AMD29K_LR(v0), v1);
544  } else {
545  v1 = 0 - v1;
546  snprintf(string, string_size, "%s %s%d -0x%x", instruction->mnemonic, p0, AMD29K_LR(v0), v1);
547  }
548 
549  } else if (AMD29K_IS_2(AMD29K_TYPE_REG, AMD29K_TYPE_JMP)) {
550  const char *p0 = AMD29K_REGNAME(v0);
551  ut64 ptr = address + ((int)v1);
552  snprintf(string, string_size, "%s %s%d 0x%" PFMT64x, instruction->mnemonic, p0, AMD29K_LR(v0), ptr);
553 
554  } else if (AMD29K_IS_3(AMD29K_TYPE_REG, AMD29K_TYPE_REG, AMD29K_TYPE_REG)) {
555  const char *p0 = AMD29K_REGNAME(v0);
556  const char *p1 = AMD29K_REGNAME(v1);
557  const char *p2 = AMD29K_REGNAME(v2);
558  snprintf(string, string_size, "%s %s%d %s%d %s%d", instruction->mnemonic, p0, AMD29K_LR(v0), p1, AMD29K_LR(v1), p2, AMD29K_LR(v2));
559 
560  } else if (AMD29K_IS_3(AMD29K_TYPE_REG, AMD29K_TYPE_REG, AMD29K_TYPE_IMM)) {
561  const char *p0 = AMD29K_REGNAME(v0);
562  const char *p1 = AMD29K_REGNAME(v1);
563  if (v2 >= 0) {
564  snprintf(string, string_size, "%s %s%d %s%d 0x%x", instruction->mnemonic, p0, AMD29K_LR(v0), p1, AMD29K_LR(v1), v2);
565  } else {
566  v2 = 0 - v2;
567  snprintf(string, string_size, "%s %s%d %s%d -0x%x", instruction->mnemonic, p0, AMD29K_LR(v0), p1, AMD29K_LR(v1), v2);
568  }
569 
570  } else if (AMD29K_IS_4(AMD29K_TYPE_IMM, AMD29K_TYPE_IMM, AMD29K_TYPE_REG, AMD29K_TYPE_REG)) {
571  const char *p2 = AMD29K_REGNAME(v2);
572  const char *p3 = AMD29K_REGNAME(v3);
573  snprintf(string, string_size, "%s %d %d %s%d %s%d", instruction->mnemonic, v0, v1, p2, AMD29K_LR(v2), p3, AMD29K_LR(v3));
574 
575  } else if (AMD29K_IS_6(AMD29K_TYPE_REG, AMD29K_TYPE_REG, AMD29K_TYPE_IMM, AMD29K_TYPE_IMM, AMD29K_TYPE_IMM, AMD29K_TYPE_IMM)) {
576  const char *p0 = AMD29K_REGNAME(v0);
577  const char *p1 = AMD29K_REGNAME(v1);
578  snprintf(string, string_size, "%s %s%d %s%d %d %d %d %d", instruction->mnemonic, p0, AMD29K_LR(v0), p1, AMD29K_LR(v1), v2, v3, v4, v5);
579 
580  } else {
581  snprintf(string, string_size, "%s", instruction->mnemonic);
582  }
583  return;
584 }
AMD29K_IS_4
#define AMD29K_IS_4(a, b, c, d)
Definition: amd29k.c:470
AMD29K_LR
#define AMD29K_LR(x)
Definition: amd29k.c:25
AMD29K_IS_3
#define AMD29K_IS_3(a, b, c)
Definition: amd29k.c:469
AMD29K_REGNAME
#define AMD29K_REGNAME(x)
Definition: amd29k.c:24
AMD29K_IS_6
#define AMD29K_IS_6(a, b, c, d, e, f)
Definition: amd29k.c:466
AMD29K_TYPE_IMM
@ AMD29K_TYPE_IMM
Definition: amd29k_internal.h:21
snprintf
snprintf
Definition: kernel.h:364
PFMT64x
#define PFMT64x
Definition: rz_types.h:393
ut64
ut64(WINAPI *w32_GetEnabledXStateFeatures)()

References AMD29K_GET_TYPE, AMD29K_GET_VALUE, AMD29K_IS_1, AMD29K_IS_2, AMD29K_IS_3, AMD29K_IS_4, AMD29K_IS_6, AMD29K_LR, AMD29K_REGNAME, AMD29K_TYPE_IMM, AMD29K_TYPE_JMP, AMD29K_TYPE_REG, int, PFMT64x, snprintf, benchmark::t1, ut64(), v0, and v1.

Referenced by disassemble().

◆ decode_calli()

static void decode_calli ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 98 of file amd29k.c.

98  {
99  AMD29K_SET_VALUE(instruction, 0, buffer[2], AMD29K_TYPE_REG);
100  AMD29K_SET_VALUE(instruction, 1, buffer[3], AMD29K_TYPE_REG);
101  AMD29K_SET_INVALID(instruction, 2);
102  AMD29K_SET_INVALID(instruction, 3);
103  AMD29K_SET_INVALID(instruction, 4);
104  AMD29K_SET_INVALID(instruction, 5);
105 }
AMD29K_SET_VALUE
#define AMD29K_SET_VALUE(x, i, v, t)
Definition: amd29k.c:15
AMD29K_SET_INVALID
#define AMD29K_SET_INVALID(x, i)
Definition: amd29k.c:18

References AMD29K_SET_INVALID, AMD29K_SET_VALUE, and AMD29K_TYPE_REG.

◆ decode_clz()

static void decode_clz ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 116 of file amd29k.c.

116  {
117  AMD29K_SET_VALUE(instruction, 0, buffer[1], AMD29K_TYPE_REG);
118  AMD29K_SET_VALUE(instruction, 1, buffer[3], AMD29K_HAS_BIT(buffer) ? AMD29K_TYPE_IMM : AMD29K_TYPE_REG);
119  AMD29K_SET_INVALID(instruction, 2);
120  AMD29K_SET_INVALID(instruction, 3);
121  AMD29K_SET_INVALID(instruction, 4);
122  AMD29K_SET_INVALID(instruction, 5);
123 }
AMD29K_HAS_BIT
#define AMD29K_HAS_BIT(x)
Definition: amd29k.c:19

References AMD29K_HAS_BIT, AMD29K_SET_INVALID, AMD29K_SET_VALUE, AMD29K_TYPE_IMM, and AMD29K_TYPE_REG.

◆ decode_convert()

static void decode_convert ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 125 of file amd29k.c.

125  {
126  // lambda w,ea: (w >> 24,[decode_byte1(w), decode_byte2(w), ('imm',False,(w&0x80)>>7), ('imm',False,(w&0x70)>>4), ('imm',False,(w&0xC)>>2), ('imm',False, w&3)])
127  AMD29K_SET_VALUE(instruction, 0, buffer[1], AMD29K_TYPE_REG);
128  AMD29K_SET_VALUE(instruction, 1, buffer[2], AMD29K_TYPE_REG);
129  AMD29K_SET_VALUE(instruction, 2, ((buffer[3] & 0x80) >> 7), AMD29K_TYPE_IMM);
130  AMD29K_SET_VALUE(instruction, 3, ((buffer[3] & 0x70) >> 4), AMD29K_TYPE_IMM);
131  AMD29K_SET_VALUE(instruction, 4, ((buffer[3] & 0x0c) >> 2), AMD29K_TYPE_IMM);
132  AMD29K_SET_VALUE(instruction, 5, (buffer[3] & 0x03), AMD29K_TYPE_IMM);
133 }

References AMD29K_SET_VALUE, AMD29K_TYPE_IMM, and AMD29K_TYPE_REG.

◆ decode_dmac_fmac()

static void decode_dmac_fmac ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 144 of file amd29k.c.

144  {
145  AMD29K_SET_VALUE(instruction, 0, ((buffer[1] & 0x3c) >> 2), AMD29K_TYPE_IMM);
146  AMD29K_SET_VALUE(instruction, 1, (buffer[1] & 0x03), AMD29K_TYPE_IMM);
147  AMD29K_SET_VALUE(instruction, 2, buffer[1], AMD29K_TYPE_REG);
148  AMD29K_SET_VALUE(instruction, 3, buffer[2], AMD29K_TYPE_REG);
149  AMD29K_SET_INVALID(instruction, 4);
150  AMD29K_SET_INVALID(instruction, 5);
151 }

References AMD29K_SET_INVALID, AMD29K_SET_VALUE, AMD29K_TYPE_IMM, and AMD29K_TYPE_REG.

◆ decode_imm16_sh2()

static void decode_imm16_sh2 ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 76 of file amd29k.c.

76  {
77  int word = (buffer[1] << 10) + (buffer[3] << 2);
78  if (word & 0x20000) {
79  word = (int)(0xfffc0000 | word);
80  }
81  AMD29K_SET_VALUE(instruction, 0, word, AMD29K_HAS_BIT(buffer) ? AMD29K_TYPE_JMP : AMD29K_TYPE_IMM);
82  AMD29K_SET_INVALID(instruction, 1);
83  AMD29K_SET_INVALID(instruction, 2);
84  AMD29K_SET_INVALID(instruction, 3);
85  AMD29K_SET_INVALID(instruction, 4);
86  AMD29K_SET_INVALID(instruction, 5);
87 }

References AMD29K_HAS_BIT, AMD29K_SET_INVALID, AMD29K_SET_VALUE, AMD29K_TYPE_IMM, AMD29K_TYPE_JMP, and int.

◆ decode_load_store()

static void decode_load_store ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 89 of file amd29k.c.

89  {
90  AMD29K_SET_VALUE(instruction, 0, ((buffer[1] & 0x80) >> 7), AMD29K_TYPE_IMM);
91  AMD29K_SET_VALUE(instruction, 1, (buffer[1] & 0x7F), AMD29K_TYPE_IMM);
92  AMD29K_SET_VALUE(instruction, 2, buffer[2], AMD29K_TYPE_REG);
93  AMD29K_SET_VALUE(instruction, 3, buffer[3], AMD29K_HAS_BIT(buffer) ? AMD29K_TYPE_IMM : AMD29K_TYPE_REG);
94  AMD29K_SET_INVALID(instruction, 4);
95  AMD29K_SET_INVALID(instruction, 5);
96 }

References AMD29K_HAS_BIT, AMD29K_SET_INVALID, AMD29K_SET_VALUE, AMD29K_TYPE_IMM, and AMD29K_TYPE_REG.

◆ decode_mfsr()

static void decode_mfsr ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 189 of file amd29k.c.

189  {
190  AMD29K_SET_VALUE(instruction, 0, buffer[1], AMD29K_TYPE_REG);
191  AMD29K_SET_VALUE(instruction, 1, buffer[2], AMD29K_TYPE_REG);
192  AMD29K_SET_INVALID(instruction, 2);
193  AMD29K_SET_INVALID(instruction, 3);
194  AMD29K_SET_INVALID(instruction, 4);
195  AMD29K_SET_INVALID(instruction, 5);
196 }

References AMD29K_SET_INVALID, AMD29K_SET_VALUE, and AMD29K_TYPE_REG.

◆ decode_mtsr()

static void decode_mtsr ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 198 of file amd29k.c.

198  {
199  AMD29K_SET_VALUE(instruction, 0, buffer[2], AMD29K_TYPE_REG);
200  AMD29K_SET_VALUE(instruction, 1, buffer[3], AMD29K_TYPE_REG);
201  AMD29K_SET_INVALID(instruction, 2);
202  AMD29K_SET_INVALID(instruction, 3);
203  AMD29K_SET_INVALID(instruction, 4);
204  AMD29K_SET_INVALID(instruction, 5);
205 }

References AMD29K_SET_INVALID, AMD29K_SET_VALUE, and AMD29K_TYPE_REG.

◆ decode_none()

static void decode_none ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 207 of file amd29k.c.

207  {
208  // lambda w,ea: (w >> 24, None)
209  AMD29K_SET_INVALID(instruction, 0);
210  AMD29K_SET_INVALID(instruction, 1);
211  AMD29K_SET_INVALID(instruction, 2);
212  AMD29K_SET_INVALID(instruction, 3);
213  AMD29K_SET_INVALID(instruction, 4);
214  AMD29K_SET_INVALID(instruction, 5);
215 }

References AMD29K_SET_INVALID.

Referenced by amd29k_instr_decode().

◆ decode_ra_i16_sh2()

static void decode_ra_i16_sh2 ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 59 of file amd29k.c.

59  {
60  int word = (buffer[1] << 10) + (buffer[3] << 2);
61  if (word & 0x20000) {
62  word = (int)(0xfffc0000 | word);
63  }
64  AMD29K_SET_VALUE(instruction, 0, buffer[2], AMD29K_TYPE_REG);
65  if (AMD29K_HAS_BIT(buffer)) {
66  AMD29K_SET_VALUE(instruction, 1, word, AMD29K_TYPE_IMM);
67  } else {
68  AMD29K_SET_VALUE(instruction, 1, (ut32)word, AMD29K_TYPE_JMP);
69  }
70  AMD29K_SET_INVALID(instruction, 2);
71  AMD29K_SET_INVALID(instruction, 3);
72  AMD29K_SET_INVALID(instruction, 4);
73  AMD29K_SET_INVALID(instruction, 5);
74 }
ut32
uint32_t ut32
Definition: demangler_util.h:31

References AMD29K_HAS_BIT, AMD29K_SET_INVALID, AMD29K_SET_VALUE, AMD29K_TYPE_IMM, AMD29K_TYPE_JMP, AMD29K_TYPE_REG, and int.

◆ decode_ra_imm()

static void decode_ra_imm ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 180 of file amd29k.c.

180  {
181  AMD29K_SET_VALUE(instruction, 0, buffer[2], AMD29K_TYPE_REG);
182  AMD29K_SET_VALUE(instruction, 1, ((buffer[3] & 0x0c) >> 2), AMD29K_TYPE_IMM);
183  AMD29K_SET_VALUE(instruction, 2, (buffer[3] & 0x03), AMD29K_TYPE_IMM);
184  AMD29K_SET_INVALID(instruction, 3);
185  AMD29K_SET_INVALID(instruction, 4);
186  AMD29K_SET_INVALID(instruction, 5);
187 }

References AMD29K_SET_INVALID, AMD29K_SET_VALUE, AMD29K_TYPE_IMM, and AMD29K_TYPE_REG.

◆ decode_ra_imm16()

static void decode_ra_imm16 ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 49 of file amd29k.c.

49  {
50  int word = (buffer[1] << 8) + buffer[3];
51  AMD29K_SET_VALUE(instruction, 0, buffer[2], AMD29K_TYPE_REG);
52  AMD29K_SET_VALUE(instruction, 1, word, AMD29K_TYPE_IMM);
53  AMD29K_SET_INVALID(instruction, 2);
54  AMD29K_SET_INVALID(instruction, 3);
55  AMD29K_SET_INVALID(instruction, 4);
56  AMD29K_SET_INVALID(instruction, 5);
57 }

References AMD29K_SET_INVALID, AMD29K_SET_VALUE, AMD29K_TYPE_IMM, and AMD29K_TYPE_REG.

◆ decode_ra_rb()

static void decode_ra_rb ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 153 of file amd29k.c.

153  {
154  AMD29K_SET_VALUE(instruction, 0, buffer[1], AMD29K_TYPE_REG);
155  AMD29K_SET_VALUE(instruction, 1, buffer[3], AMD29K_TYPE_REG);
156  AMD29K_SET_INVALID(instruction, 2);
157  AMD29K_SET_INVALID(instruction, 3);
158  AMD29K_SET_INVALID(instruction, 4);
159  AMD29K_SET_INVALID(instruction, 5);
160 }

References AMD29K_SET_INVALID, AMD29K_SET_VALUE, and AMD29K_TYPE_REG.

◆ decode_ra_rb_rc()

static void decode_ra_rb_rc ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 40 of file amd29k.c.

40  {
41  AMD29K_SET_VALUE(instruction, 0, buffer[1], AMD29K_TYPE_REG);
42  AMD29K_SET_VALUE(instruction, 1, buffer[2], AMD29K_TYPE_REG);
43  AMD29K_SET_VALUE(instruction, 2, buffer[3], AMD29K_TYPE_REG);
44  AMD29K_SET_INVALID(instruction, 3);
45  AMD29K_SET_INVALID(instruction, 4);
46  AMD29K_SET_INVALID(instruction, 5);
47 }

References AMD29K_SET_INVALID, AMD29K_SET_VALUE, and AMD29K_TYPE_REG.

◆ decode_ra_rb_rci()

static void decode_ra_rb_rci ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 27 of file amd29k.c.

27  {
28  AMD29K_SET_VALUE(instruction, 0, buffer[1], AMD29K_TYPE_REG);
29  AMD29K_SET_VALUE(instruction, 1, buffer[2], AMD29K_TYPE_REG);
30  if (AMD29K_HAS_BIT(buffer)) {
31  AMD29K_SET_VALUE(instruction, 2, buffer[3], AMD29K_TYPE_IMM);
32  } else {
33  AMD29K_SET_VALUE(instruction, 2, buffer[3], AMD29K_TYPE_REG);
34  }
35  AMD29K_SET_INVALID(instruction, 3);
36  AMD29K_SET_INVALID(instruction, 4);
37  AMD29K_SET_INVALID(instruction, 5);
38 }

References AMD29K_HAS_BIT, AMD29K_SET_INVALID, AMD29K_SET_VALUE, AMD29K_TYPE_IMM, and AMD29K_TYPE_REG.

◆ decode_rb()

static void decode_rb ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 162 of file amd29k.c.

162  {
163  AMD29K_SET_VALUE(instruction, 0, buffer[3], AMD29K_TYPE_REG);
164  AMD29K_SET_INVALID(instruction, 1);
165  AMD29K_SET_INVALID(instruction, 2);
166  AMD29K_SET_INVALID(instruction, 3);
167  AMD29K_SET_INVALID(instruction, 4);
168  AMD29K_SET_INVALID(instruction, 5);
169 }

References AMD29K_SET_INVALID, AMD29K_SET_VALUE, and AMD29K_TYPE_REG.

◆ decode_rc_imm()

static void decode_rc_imm ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 171 of file amd29k.c.

171  {
172  AMD29K_SET_VALUE(instruction, 0, buffer[1], AMD29K_TYPE_REG);
173  AMD29K_SET_VALUE(instruction, 1, ((buffer[3] & 0x0c) >> 2), AMD29K_TYPE_IMM);
174  AMD29K_SET_VALUE(instruction, 2, (buffer[3] & 0x03), AMD29K_TYPE_IMM);
175  AMD29K_SET_INVALID(instruction, 3);
176  AMD29K_SET_INVALID(instruction, 4);
177  AMD29K_SET_INVALID(instruction, 5);
178 }

References AMD29K_SET_INVALID, AMD29K_SET_VALUE, AMD29K_TYPE_IMM, and AMD29K_TYPE_REG.

◆ decode_rc_ra()

static void decode_rc_ra ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 135 of file amd29k.c.

135  {
136  AMD29K_SET_VALUE(instruction, 0, buffer[1], AMD29K_TYPE_REG);
137  AMD29K_SET_VALUE(instruction, 1, buffer[2], AMD29K_TYPE_REG);
138  AMD29K_SET_INVALID(instruction, 2);
139  AMD29K_SET_INVALID(instruction, 3);
140  AMD29K_SET_INVALID(instruction, 4);
141  AMD29K_SET_INVALID(instruction, 5);
142 }

References AMD29K_SET_INVALID, AMD29K_SET_VALUE, and AMD29K_TYPE_REG.

◆ decode_rc_ra_imm()

static void decode_rc_ra_imm ( amd29k_instr_t *  instruction,
const ut8 *  buffer 
)
static

Definition at line 107 of file amd29k.c.

107  {
108  AMD29K_SET_VALUE(instruction, 0, buffer[1], AMD29K_TYPE_REG);
109  AMD29K_SET_VALUE(instruction, 1, buffer[2], AMD29K_TYPE_REG);
110  AMD29K_SET_VALUE(instruction, 2, (buffer[3] & 3), AMD29K_TYPE_IMM);
111  AMD29K_SET_INVALID(instruction, 3);
112  AMD29K_SET_INVALID(instruction, 4);
113  AMD29K_SET_INVALID(instruction, 5);
114 }

References AMD29K_SET_INVALID, AMD29K_SET_VALUE, AMD29K_TYPE_IMM, and AMD29K_TYPE_REG.

◆ is_cpu()

static bool is_cpu ( const char *  cpu,
const amd29k_instruction_t *  in 
)
static

Definition at line 427 of file amd29k.c.

427  {
428  return cpu[0] == in->cpu[0] &&
429  cpu[1] == in->cpu[1] &&
430  cpu[2] == in->cpu[2] &&
431  cpu[3] == in->cpu[3] &&
432  cpu[4] == in->cpu[4];
433 }

References cpu, and in.

Referenced by amd29k_instr_decode().

Variable Documentation

◆ amd29k_instructions

const amd29k_instruction_t amd29k_instructions[N_AMD29K_INSTRUCTIONS]

Definition at line 217 of file amd29k.c.

Referenced by amd29k_instr_decode().