Coverage Report

Created: 2023-09-25 06:24

/src/capstonenext/arch/M680X/M680XDisassembler.c
Line
Count
Source (jump to first uncovered line)
1
/* Capstone Disassembly Engine */
2
/* M680X Backend by Wolfgang Schwotzer <wolfgang.schwotzer@gmx.net> 2017 */
3
4
/* ======================================================================== */
5
/* ================================ INCLUDES ============================== */
6
/* ======================================================================== */
7
8
#include <stdlib.h>
9
#include <stdio.h>
10
#include <string.h>
11
12
#include "../../cs_priv.h"
13
#include "../../utils.h"
14
15
#include "../../MCInst.h"
16
#include "../../MCInstrDesc.h"
17
#include "../../MCRegisterInfo.h"
18
#include "M680XInstPrinter.h"
19
#include "M680XDisassembler.h"
20
#include "M680XDisassemblerInternals.h"
21
22
#ifdef CAPSTONE_HAS_M680X
23
24
#ifndef DECL_SPEC
25
#ifdef _MSC_VER
26
#define DECL_SPEC __cdecl
27
#else
28
#define DECL_SPEC
29
#endif  // _MSC_VER
30
#endif  // DECL_SPEC
31
32
/* ======================================================================== */
33
/* ============================ GENERAL DEFINES =========================== */
34
/* ======================================================================== */
35
36
/* ======================================================================== */
37
/* =============================== PROTOTYPES ============================= */
38
/* ======================================================================== */
39
40
typedef enum insn_hdlr_id {
41
  illgl_hid,
42
  rel8_hid,
43
  rel16_hid,
44
  imm8_hid,
45
  imm16_hid,
46
  imm32_hid,
47
  dir_hid,
48
  ext_hid,
49
  idxX_hid,
50
  idxY_hid,
51
  idx09_hid,
52
  inh_hid,
53
  rr09_hid,
54
  rbits_hid,
55
  bitmv_hid,
56
  tfm_hid,
57
  opidx_hid,
58
  opidxdr_hid,
59
  idxX0_hid,
60
  idxX16_hid,
61
  imm8rel_hid,
62
  idxS_hid,
63
  idxS16_hid,
64
  idxXp_hid,
65
  idxX0p_hid,
66
  idx12_hid,
67
  idx12s_hid,
68
  rr12_hid,
69
  loop_hid,
70
  index_hid,
71
  imm8i12x_hid,
72
  imm16i12x_hid,
73
  exti12x_hid,
74
  HANDLER_ID_ENDING,
75
} insn_hdlr_id;
76
77
// Access modes for the first 4 operands. If there are more than
78
// four operands they use the same access mode as the 4th operand.
79
//
80
// u: unchanged
81
// r: (r)read access
82
// w: (w)write access
83
// m: (m)odify access (= read + write)
84
//
85
typedef enum e_access_mode {
86
87
  uuuu,
88
  rrrr,
89
  wwww,
90
  rwww,
91
  rrrm,
92
  rmmm,
93
  wrrr,
94
  mrrr,
95
  mwww,
96
  mmmm,
97
  mwrr,
98
  mmrr,
99
  wmmm,
100
  rruu,
101
  muuu,
102
  ACCESS_MODE_ENDING,
103
} e_access_mode;
104
105
// Access type values are compatible with enum cs_ac_type:
106
typedef enum e_access {
107
  UNCHANGED = CS_AC_INVALID,
108
  READ = CS_AC_READ,
109
  WRITE = CS_AC_WRITE,
110
  MODIFY = (CS_AC_READ | CS_AC_WRITE),
111
} e_access;
112
113
/* Properties of one instruction in PAGE1 (without prefix) */
114
typedef struct inst_page1 {
115
  unsigned insn : 9;        // A value of type m680x_insn
116
  unsigned handler_id1 : 6; // Type insn_hdlr_id, first instr. handler id
117
  unsigned handler_id2 : 6; // Type insn_hdlr_id, second instr. handler id
118
} inst_page1;
119
120
/* Properties of one instruction in any other PAGE X */
121
typedef struct inst_pageX {
122
  unsigned opcode : 8;      // The opcode byte
123
  unsigned insn : 9;        // A value of type m680x_insn
124
  unsigned handler_id1 : 6; // Type insn_hdlr_id, first instr. handler id
125
  unsigned handler_id2 : 6; // Type insn_hdlr_id, second instr. handler id
126
} inst_pageX;
127
128
typedef struct insn_props {
129
  unsigned group : 4;
130
  unsigned access_mode : 5; // A value of type e_access_mode
131
  unsigned reg0 : 5;        // A value of type m680x_reg
132
  unsigned reg1 : 5;        // A value of type m680x_reg
133
  bool cc_modified : 1;
134
  bool update_reg_access : 1;
135
} insn_props;
136
137
#include "m6800.inc"
138
#include "m6801.inc"
139
#include "hd6301.inc"
140
#include "m6811.inc"
141
#include "cpu12.inc"
142
#include "m6805.inc"
143
#include "m6808.inc"
144
#include "hcs08.inc"
145
#include "m6809.inc"
146
#include "hd6309.inc"
147
148
#include "insn_props.inc"
149
150
//////////////////////////////////////////////////////////////////////////////
151
152
// M680X instuctions have 1 up to 8 bytes (CPU12: MOVW IDX2,IDX2).
153
// A reader is needed to read a byte or word from a given memory address.
154
// See also X86 reader(...)
155
static bool read_byte(const m680x_info *info, uint8_t *byte, uint16_t address)
156
766k
{
157
766k
  if (address < info->offset ||
158
766k
    (uint32_t)(address - info->offset) >= info->size)
159
    // out of code buffer range
160
1.52k
    return false;
161
162
765k
  *byte = info->code[address - info->offset];
163
164
765k
  return true;
165
766k
}
166
167
static bool read_byte_sign_extended(const m680x_info *info, int16_t *word,
168
  uint16_t address)
169
47.9k
{
170
47.9k
  if (address < info->offset ||
171
47.9k
    (uint32_t)(address - info->offset) >= info->size)
172
    // out of code buffer range
173
0
    return false;
174
175
47.9k
  *word = (int16_t) info->code[address - info->offset];
176
177
47.9k
  if (*word & 0x80)
178
18.7k
    *word |= 0xFF00;
179
180
47.9k
  return true;
181
47.9k
}
182
183
static bool read_word(const m680x_info *info, uint16_t *word, uint16_t address)
184
55.8k
{
185
55.8k
  if (address < info->offset ||
186
55.8k
    (uint32_t)(address + 1 - info->offset) >= info->size)
187
    // out of code buffer range
188
13
    return false;
189
190
55.8k
  *word = (uint16_t)info->code[address - info->offset] << 8;
191
55.8k
  *word |= (uint16_t)info->code[address + 1 - info->offset];
192
193
55.8k
  return true;
194
55.8k
}
195
196
static bool read_sdword(const m680x_info *info, int32_t *sdword,
197
  uint16_t address)
198
496
{
199
496
  if (address < info->offset ||
200
496
    (uint32_t)(address + 3 - info->offset) >= info->size)
201
    // out of code buffer range
202
0
    return false;
203
204
496
  *sdword = (uint32_t)info->code[address - info->offset] << 24;
205
496
  *sdword |= (uint32_t)info->code[address + 1 - info->offset] << 16;
206
496
  *sdword |= (uint32_t)info->code[address + 2 - info->offset] << 8;
207
496
  *sdword |= (uint32_t)info->code[address + 3 - info->offset];
208
209
496
  return true;
210
496
}
211
212
// For PAGE2 and PAGE3 opcodes when using an an array of inst_page1 most
213
// entries have M680X_INS_ILLGL. To avoid wasting memory an inst_pageX is
214
// used which contains the opcode. Using a binary search for the right opcode
215
// is much faster (= O(log n) ) in comparison to a linear search ( = O(n) ).
216
static int binary_search(const inst_pageX *const inst_pageX_table,
217
  size_t table_size, unsigned int opcode)
218
125k
{
219
  // As part of the algorithm last may get negative.
220
  // => signed integer has to be used.
221
125k
  int first = 0;
222
125k
  int last = (int)table_size - 1;
223
125k
  int middle = (first + last) / 2;
224
225
621k
  while (first <= last) {
226
569k
    if (inst_pageX_table[middle].opcode < opcode) {
227
190k
      first = middle + 1;
228
190k
    }
229
379k
    else if (inst_pageX_table[middle].opcode == opcode) {
230
73.3k
      return middle;  /* item found */
231
73.3k
    }
232
305k
    else
233
305k
      last = middle - 1;
234
235
495k
    middle = (first + last) / 2;
236
495k
  }
237
238
51.9k
  if (first > last)
239
51.9k
    return -1;  /* item not found */
240
241
0
  return -2;
242
51.9k
}
243
244
void M680X_get_insn_id(cs_struct *handle, cs_insn *insn, unsigned int id)
245
323k
{
246
323k
  const m680x_info *const info = (const m680x_info *)handle->printer_info;
247
323k
  const cpu_tables *cpu = info->cpu;
248
323k
  uint8_t insn_prefix = (id >> 8) & 0xff;
249
  // opcode is the first instruction byte without the prefix.
250
323k
  uint8_t opcode = id & 0xff;
251
323k
  int index;
252
323k
  int i;
253
254
323k
  insn->id = M680X_INS_ILLGL;
255
256
757k
  for (i = 0; i < ARR_SIZE(cpu->pageX_prefix); ++i) {
257
738k
    if (cpu->pageX_table_size[i] == 0 ||
258
738k
      (cpu->inst_pageX_table[i] == NULL))
259
278k
      break;
260
261
460k
    if (cpu->pageX_prefix[i] == insn_prefix) {
262
26.7k
      index = binary_search(cpu->inst_pageX_table[i],
263
26.7k
          cpu->pageX_table_size[i], opcode);
264
26.7k
      insn->id = (index >= 0) ?
265
18.8k
        cpu->inst_pageX_table[i][index].insn :
266
26.7k
        M680X_INS_ILLGL;
267
26.7k
      return;
268
26.7k
    }
269
460k
  }
270
271
296k
  if (insn_prefix != 0)
272
0
    return;
273
274
296k
  insn->id = cpu->inst_page1_table[id].insn;
275
276
296k
  if (insn->id != M680X_INS_ILLGL)
277
261k
    return;
278
279
  // Check if opcode byte is present in an overlay table
280
53.0k
  for (i = 0; i < ARR_SIZE(cpu->overlay_table_size); ++i) {
281
51.2k
    if (cpu->overlay_table_size[i] == 0 ||
282
51.2k
      (cpu->inst_overlay_table[i] == NULL))
283
15.3k
      break;
284
285
35.9k
    if ((index = binary_search(cpu->inst_overlay_table[i],
286
35.9k
            cpu->overlay_table_size[i],
287
35.9k
            opcode)) >= 0) {
288
17.7k
      insn->id = cpu->inst_overlay_table[i][index].insn;
289
17.7k
      return;
290
17.7k
    }
291
35.9k
  }
292
34.9k
}
293
294
static void add_insn_group(cs_detail *detail, m680x_group_type group)
295
311k
{
296
311k
  if (detail != NULL &&
297
311k
    (group != M680X_GRP_INVALID) && (group != M680X_GRP_ENDING))
298
71.8k
    detail->groups[detail->groups_count++] = (uint8_t)group;
299
311k
}
300
301
static bool exists_reg_list(uint16_t *regs, uint8_t count, m680x_reg reg)
302
888k
{
303
888k
  uint8_t i;
304
305
1.48M
  for (i = 0; i < count; ++i) {
306
627k
    if (regs[i] == (uint16_t)reg)
307
29.9k
      return true;
308
627k
  }
309
310
858k
  return false;
311
888k
}
312
313
static void add_reg_to_rw_list(MCInst *MI, m680x_reg reg, e_access access)
314
587k
{
315
587k
  cs_detail *detail = MI->flat_insn->detail;
316
317
587k
  if (detail == NULL || (reg == M680X_REG_INVALID))
318
0
    return;
319
320
587k
  switch (access) {
321
301k
  case MODIFY:
322
301k
    if (!exists_reg_list(detail->regs_read,
323
301k
        detail->regs_read_count, reg))
324
293k
      detail->regs_read[detail->regs_read_count++] =
325
293k
        (uint16_t)reg;
326
327
  // intentionally fall through
328
329
388k
  case WRITE:
330
388k
    if (!exists_reg_list(detail->regs_write,
331
388k
        detail->regs_write_count, reg))
332
380k
      detail->regs_write[detail->regs_write_count++] =
333
380k
        (uint16_t)reg;
334
335
388k
    break;
336
337
199k
  case READ:
338
199k
    if (!exists_reg_list(detail->regs_read,
339
199k
        detail->regs_read_count, reg))
340
184k
      detail->regs_read[detail->regs_read_count++] =
341
184k
        (uint16_t)reg;
342
343
199k
    break;
344
345
0
  case UNCHANGED:
346
0
  default:
347
0
    break;
348
587k
  }
349
587k
}
350
351
static void update_am_reg_list(MCInst *MI, m680x_info *info, cs_m680x_op *op,
352
  e_access access)
353
409k
{
354
409k
  if (MI->flat_insn->detail == NULL)
355
0
    return;
356
357
409k
  switch (op->type) {
358
173k
  case M680X_OP_REGISTER:
359
173k
    add_reg_to_rw_list(MI, op->reg, access);
360
173k
    break;
361
362
83.7k
  case M680X_OP_INDEXED:
363
83.7k
    add_reg_to_rw_list(MI, op->idx.base_reg, READ);
364
365
83.7k
    if (op->idx.base_reg == M680X_REG_X &&
366
83.7k
      info->cpu->reg_byte_size[M680X_REG_H])
367
11.0k
      add_reg_to_rw_list(MI, M680X_REG_H, READ);
368
369
370
83.7k
    if (op->idx.offset_reg != M680X_REG_INVALID)
371
6.51k
      add_reg_to_rw_list(MI, op->idx.offset_reg, READ);
372
373
83.7k
    if (op->idx.inc_dec) {
374
17.7k
      add_reg_to_rw_list(MI, op->idx.base_reg, WRITE);
375
376
17.7k
      if (op->idx.base_reg == M680X_REG_X &&
377
17.7k
        info->cpu->reg_byte_size[M680X_REG_H])
378
1.35k
        add_reg_to_rw_list(MI, M680X_REG_H, WRITE);
379
17.7k
    }
380
381
83.7k
    break;
382
383
151k
  default:
384
151k
    break;
385
409k
  }
386
409k
}
387
388
static const e_access g_access_mode_to_access[4][15] = {
389
  {
390
    UNCHANGED, READ, WRITE, READ,  READ, READ,   WRITE, MODIFY,
391
    MODIFY, MODIFY, MODIFY, MODIFY, WRITE, READ, MODIFY,
392
  },
393
  {
394
    UNCHANGED, READ, WRITE, WRITE, READ, MODIFY, READ,  READ,
395
    WRITE, MODIFY, WRITE, MODIFY, MODIFY, READ, UNCHANGED,
396
  },
397
  {
398
    UNCHANGED, READ, WRITE, WRITE, READ, MODIFY, READ,  READ,
399
    WRITE, MODIFY, READ, READ, MODIFY, UNCHANGED, UNCHANGED,
400
  },
401
  {
402
    UNCHANGED, READ, WRITE, WRITE, MODIFY, MODIFY, READ, READ,
403
    WRITE, MODIFY, READ, READ, MODIFY, UNCHANGED, UNCHANGED,
404
  },
405
};
406
407
static e_access get_access(int operator_index, e_access_mode access_mode)
408
881k
{
409
881k
  int idx = (operator_index > 3) ? 3 : operator_index;
410
411
881k
  return g_access_mode_to_access[idx][access_mode];
412
881k
}
413
414
static void build_regs_read_write_counts(MCInst *MI, m680x_info *info,
415
  e_access_mode access_mode)
416
285k
{
417
285k
  cs_m680x *m680x = &info->m680x;
418
285k
  int i;
419
420
285k
  if (MI->flat_insn->detail == NULL || (!m680x->op_count))
421
44.3k
    return;
422
423
650k
  for (i = 0; i < m680x->op_count; ++i) {
424
425
409k
    e_access access = get_access(i, access_mode);
426
409k
    update_am_reg_list(MI, info, &m680x->operands[i], access);
427
409k
  }
428
240k
}
429
430
static void add_operators_access(MCInst *MI, m680x_info *info,
431
  e_access_mode access_mode)
432
285k
{
433
285k
  cs_m680x *m680x = &info->m680x;
434
285k
  int offset = 0;
435
285k
  int i;
436
437
285k
  if (MI->flat_insn->detail == NULL || (!m680x->op_count) ||
438
285k
    (access_mode == uuuu))
439
71.4k
    return;
440
441
594k
  for (i = 0; i < m680x->op_count; ++i) {
442
381k
    e_access access;
443
444
    // Ugly fix: MULD has a register operand, an immediate operand
445
    // AND an implicitly changed register W
446
381k
    if (info->insn == M680X_INS_MULD && (i == 1))
447
278
      offset = 1;
448
449
381k
    access = get_access(i + offset, access_mode);
450
381k
    m680x->operands[i].access = access;
451
381k
  }
452
213k
}
453
454
typedef struct insn_to_changed_regs {
455
  m680x_insn insn;
456
  e_access_mode access_mode;
457
  m680x_reg regs[10];
458
} insn_to_changed_regs;
459
460
static void set_changed_regs_read_write_counts(MCInst *MI, m680x_info *info)
461
33.1k
{
462
  //TABLE
463
1.82M
#define EOL M680X_REG_INVALID
464
33.1k
  static const insn_to_changed_regs changed_regs[] = {
465
33.1k
    { M680X_INS_BSR, mmmm, { M680X_REG_S, EOL } },
466
33.1k
    { M680X_INS_CALL, mmmm, { M680X_REG_S, EOL } },
467
33.1k
    {
468
33.1k
      M680X_INS_CWAI, mrrr, {
469
33.1k
        M680X_REG_S, M680X_REG_PC, M680X_REG_U,
470
33.1k
        M680X_REG_Y, M680X_REG_X, M680X_REG_DP,
471
33.1k
        M680X_REG_D, M680X_REG_CC, EOL
472
33.1k
      },
473
33.1k
    },
474
33.1k
    { M680X_INS_DAA, mrrr, { M680X_REG_A, EOL } },
475
33.1k
    {
476
33.1k
      M680X_INS_DIV, mmrr, {
477
33.1k
        M680X_REG_A, M680X_REG_H, M680X_REG_X, EOL
478
33.1k
      }
479
33.1k
    },
480
33.1k
    {
481
33.1k
      M680X_INS_EDIV, mmrr, {
482
33.1k
        M680X_REG_D, M680X_REG_Y, M680X_REG_X, EOL
483
33.1k
      }
484
33.1k
    },
485
33.1k
    {
486
33.1k
      M680X_INS_EDIVS, mmrr, {
487
33.1k
        M680X_REG_D, M680X_REG_Y, M680X_REG_X, EOL
488
33.1k
      }
489
33.1k
    },
490
33.1k
    { M680X_INS_EMACS, mrrr, { M680X_REG_X, M680X_REG_Y, EOL } },
491
33.1k
    { M680X_INS_EMAXM, rrrr, { M680X_REG_D, EOL } },
492
33.1k
    { M680X_INS_EMINM, rrrr, { M680X_REG_D, EOL } },
493
33.1k
    { M680X_INS_EMUL, mmrr, { M680X_REG_D, M680X_REG_Y, EOL } },
494
33.1k
    { M680X_INS_EMULS, mmrr, { M680X_REG_D, M680X_REG_Y, EOL } },
495
33.1k
    { M680X_INS_ETBL, wmmm, { M680X_REG_A, M680X_REG_B, EOL } },
496
33.1k
    { M680X_INS_FDIV, mmmm, { M680X_REG_D, M680X_REG_X, EOL } },
497
33.1k
    { M680X_INS_IDIV, mmmm, { M680X_REG_D, M680X_REG_X, EOL } },
498
33.1k
    { M680X_INS_IDIVS, mmmm, { M680X_REG_D, M680X_REG_X, EOL } },
499
33.1k
    { M680X_INS_JSR, mmmm, { M680X_REG_S, EOL } },
500
33.1k
    { M680X_INS_LBSR, mmmm, { M680X_REG_S, EOL } },
501
33.1k
    { M680X_INS_MAXM, rrrr, { M680X_REG_A, EOL } },
502
33.1k
    { M680X_INS_MINM, rrrr, { M680X_REG_A, EOL } },
503
33.1k
    {
504
33.1k
      M680X_INS_MEM, mmrr, {
505
33.1k
        M680X_REG_X, M680X_REG_Y, M680X_REG_A, EOL
506
33.1k
      }
507
33.1k
    },
508
33.1k
    { M680X_INS_MUL, mmmm, { M680X_REG_A, M680X_REG_B, EOL } },
509
33.1k
    { M680X_INS_MULD, mwrr, { M680X_REG_D, M680X_REG_W, EOL } },
510
33.1k
    { M680X_INS_PSHA, rmmm, { M680X_REG_A, M680X_REG_S, EOL } },
511
33.1k
    { M680X_INS_PSHB, rmmm, { M680X_REG_B, M680X_REG_S, EOL } },
512
33.1k
    { M680X_INS_PSHC, rmmm, { M680X_REG_CC, M680X_REG_S, EOL } },
513
33.1k
    { M680X_INS_PSHD, rmmm, { M680X_REG_D, M680X_REG_S, EOL } },
514
33.1k
    { M680X_INS_PSHH, rmmm, { M680X_REG_H, M680X_REG_S, EOL } },
515
33.1k
    { M680X_INS_PSHX, rmmm, { M680X_REG_X, M680X_REG_S, EOL } },
516
33.1k
    { M680X_INS_PSHY, rmmm, { M680X_REG_Y, M680X_REG_S, EOL } },
517
33.1k
    { M680X_INS_PULA, wmmm, { M680X_REG_A, M680X_REG_S, EOL } },
518
33.1k
    { M680X_INS_PULB, wmmm, { M680X_REG_B, M680X_REG_S, EOL } },
519
33.1k
    { M680X_INS_PULC, wmmm, { M680X_REG_CC, M680X_REG_S, EOL } },
520
33.1k
    { M680X_INS_PULD, wmmm, { M680X_REG_D, M680X_REG_S, EOL } },
521
33.1k
    { M680X_INS_PULH, wmmm, { M680X_REG_H, M680X_REG_S, EOL } },
522
33.1k
    { M680X_INS_PULX, wmmm, { M680X_REG_X, M680X_REG_S, EOL } },
523
33.1k
    { M680X_INS_PULY, wmmm, { M680X_REG_Y, M680X_REG_S, EOL } },
524
33.1k
    {
525
33.1k
      M680X_INS_REV, mmrr, {
526
33.1k
        M680X_REG_A, M680X_REG_X, M680X_REG_Y, EOL
527
33.1k
      }
528
33.1k
    },
529
33.1k
    {
530
33.1k
      M680X_INS_REVW, mmmm, {
531
33.1k
        M680X_REG_A, M680X_REG_X, M680X_REG_Y, EOL
532
33.1k
      }
533
33.1k
    },
534
33.1k
    { M680X_INS_RTC, mwww, { M680X_REG_S, M680X_REG_PC, EOL } },
535
33.1k
    {
536
33.1k
      M680X_INS_RTI, mwww, {
537
33.1k
        M680X_REG_S, M680X_REG_CC, M680X_REG_B,
538
33.1k
        M680X_REG_A, M680X_REG_DP, M680X_REG_X,
539
33.1k
        M680X_REG_Y, M680X_REG_U, M680X_REG_PC,
540
33.1k
        EOL
541
33.1k
      },
542
33.1k
    },
543
33.1k
    { M680X_INS_RTS, mwww, { M680X_REG_S, M680X_REG_PC, EOL } },
544
33.1k
    { M680X_INS_SEX, wrrr, { M680X_REG_A, M680X_REG_B, EOL } },
545
33.1k
    { M680X_INS_SEXW, rwww, { M680X_REG_W, M680X_REG_D, EOL } },
546
33.1k
    {
547
33.1k
      M680X_INS_SWI, mmrr, {
548
33.1k
        M680X_REG_S, M680X_REG_PC, M680X_REG_U,
549
33.1k
        M680X_REG_Y, M680X_REG_X, M680X_REG_DP,
550
33.1k
        M680X_REG_A, M680X_REG_B, M680X_REG_CC,
551
33.1k
        EOL
552
33.1k
      }
553
33.1k
    },
554
33.1k
    {
555
33.1k
      M680X_INS_SWI2, mmrr, {
556
33.1k
        M680X_REG_S, M680X_REG_PC, M680X_REG_U,
557
33.1k
        M680X_REG_Y, M680X_REG_X, M680X_REG_DP,
558
33.1k
        M680X_REG_A, M680X_REG_B, M680X_REG_CC,
559
33.1k
        EOL
560
33.1k
      },
561
33.1k
    },
562
33.1k
    {
563
33.1k
      M680X_INS_SWI3, mmrr, {
564
33.1k
        M680X_REG_S, M680X_REG_PC, M680X_REG_U,
565
33.1k
        M680X_REG_Y, M680X_REG_X, M680X_REG_DP,
566
33.1k
        M680X_REG_A, M680X_REG_B, M680X_REG_CC,
567
33.1k
        EOL
568
33.1k
      },
569
33.1k
    },
570
33.1k
    { M680X_INS_TBL, wrrr, { M680X_REG_A, M680X_REG_B, EOL } },
571
33.1k
    {
572
33.1k
      M680X_INS_WAI, mrrr, {
573
33.1k
        M680X_REG_S, M680X_REG_PC, M680X_REG_X,
574
33.1k
        M680X_REG_A, M680X_REG_B, M680X_REG_CC,
575
33.1k
        EOL
576
33.1k
      }
577
33.1k
    },
578
33.1k
    {
579
33.1k
      M680X_INS_WAV, rmmm, {
580
33.1k
        M680X_REG_A, M680X_REG_B, M680X_REG_X,
581
33.1k
        M680X_REG_Y, EOL
582
33.1k
      }
583
33.1k
    },
584
33.1k
    {
585
33.1k
      M680X_INS_WAVR, rmmm, {
586
33.1k
        M680X_REG_A, M680X_REG_B, M680X_REG_X,
587
33.1k
        M680X_REG_Y, EOL
588
33.1k
      }
589
33.1k
    },
590
33.1k
  };
591
592
33.1k
  int i, j;
593
594
33.1k
  if (MI->flat_insn->detail == NULL)
595
0
    return;
596
597
1.72M
  for (i = 0; i < ARR_SIZE(changed_regs); ++i) {
598
1.69M
    if (info->insn == changed_regs[i].insn) {
599
33.1k
      e_access_mode access_mode = changed_regs[i].access_mode;
600
601
129k
      for (j = 0; changed_regs[i].regs[j] != EOL; ++j) {
602
96.2k
        e_access access;
603
604
96.2k
        m680x_reg reg = changed_regs[i].regs[j];
605
606
96.2k
        if (!info->cpu->reg_byte_size[reg]) {
607
6.67k
          if (info->insn != M680X_INS_MUL)
608
5.88k
            continue;
609
610
          // Hack for M68HC05: MUL uses reg. A,X
611
792
          reg = M680X_REG_X;
612
792
        }
613
614
90.3k
        access = get_access(j, access_mode);
615
90.3k
        add_reg_to_rw_list(MI, reg, access);
616
90.3k
      }
617
33.1k
    }
618
1.69M
  }
619
620
33.1k
#undef EOL
621
33.1k
}
622
623
typedef struct insn_desc {
624
  uint32_t opcode;
625
  m680x_insn insn;
626
  insn_hdlr_id hid[2];
627
  uint16_t insn_size;
628
} insn_desc;
629
630
// If successfull return the additional byte size needed for M6809
631
// indexed addressing mode (including the indexed addressing post_byte).
632
// On error return -1.
633
static int get_indexed09_post_byte_size(const m680x_info *info,
634
          uint16_t address)
635
34.9k
{
636
34.9k
  uint8_t ir = 0;
637
34.9k
  uint8_t post_byte;
638
639
  // Read the indexed addressing post byte.
640
34.9k
  if (!read_byte(info, &post_byte, address))
641
159
    return -1;
642
643
  // Depending on the indexed addressing mode more bytes have to be read.
644
34.8k
  switch (post_byte & 0x9F) {
645
584
  case 0x87:
646
1.97k
  case 0x8A:
647
2.69k
  case 0x8E:
648
4.50k
  case 0x8F:
649
4.90k
  case 0x90:
650
5.57k
  case 0x92:
651
5.93k
  case 0x97:
652
6.42k
  case 0x9A:
653
6.83k
  case 0x9E:
654
6.83k
    return -1; // illegal indexed post bytes
655
656
879
  case 0x88: // n8,R
657
1.86k
  case 0x8C: // n8,PCR
658
2.32k
  case 0x98: // [n8,R]
659
3.02k
  case 0x9C: // [n8,PCR]
660
3.02k
    if (!read_byte(info, &ir, address + 1))
661
22
      return -1;
662
3.00k
    return 2;
663
664
586
  case 0x89: // n16,R
665
1.96k
  case 0x8D: // n16,PCR
666
2.90k
  case 0x99: // [n16,R]
667
3.22k
  case 0x9D: // [n16,PCR]
668
3.22k
    if (!read_byte(info, &ir, address + 2))
669
56
      return -1;
670
3.17k
    return 3;
671
672
1.26k
  case 0x9F: // [n]
673
1.26k
    if ((post_byte & 0x60) != 0 ||
674
1.26k
      !read_byte(info, &ir, address + 2))
675
982
      return -1;
676
284
    return  3;
677
34.8k
  }
678
679
  // Any other indexed post byte is valid and
680
  // no additional bytes have to be read.
681
20.4k
  return 1;
682
34.8k
}
683
684
// If successfull return the additional byte size needed for CPU12
685
// indexed addressing mode (including the indexed addressing post_byte).
686
// On error return -1.
687
static int get_indexed12_post_byte_size(const m680x_info *info,
688
          uint16_t address, bool is_subset)
689
35.7k
{
690
35.7k
  uint8_t ir;
691
35.7k
  uint8_t post_byte;
692
693
  // Read the indexed addressing post byte.
694
35.7k
  if (!read_byte(info, &post_byte, address))
695
128
    return -1;
696
697
  // Depending on the indexed addressing mode more bytes have to be read.
698
35.5k
  if (!(post_byte & 0x20)) // n5,R
699
12.5k
    return 1;
700
701
23.0k
  switch (post_byte & 0xe7) {
702
1.39k
  case 0xe0:
703
3.85k
  case 0xe1: // n9,R
704
3.85k
    if (is_subset)
705
512
      return -1;
706
707
3.34k
    if (!read_byte(info, &ir, address))
708
0
      return -1;
709
3.34k
    return 2;
710
711
2.07k
  case 0xe2: // n16,R
712
3.84k
  case 0xe3: // [n16,R]
713
3.84k
    if (is_subset)
714
299
      return -1;
715
716
3.54k
    if (!read_byte(info, &ir, address + 1))
717
20
      return -1;
718
3.52k
    return 3;
719
720
938
  case 0xe4: // A,R
721
1.61k
  case 0xe5: // B,R
722
2.70k
  case 0xe6: // D,R
723
3.61k
  case 0xe7: // [D,R]
724
15.3k
  default: // n,-r n,+r n,r- n,r+
725
15.3k
    break;
726
23.0k
  }
727
728
15.3k
  return 1;
729
23.0k
}
730
731
// Check for M6809/HD6309 TFR/EXG instruction for valid register
732
static bool is_tfr09_reg_valid(const m680x_info *info, uint8_t reg_nibble)
733
3.84k
{
734
3.84k
  if (info->cpu->tfr_reg_valid != NULL)
735
1.75k
    return info->cpu->tfr_reg_valid[reg_nibble];
736
737
2.08k
  return true; // e.g. for the M6309 all registers are valid
738
3.84k
}
739
740
// Check for CPU12 TFR/EXG instruction for valid register
741
static bool is_exg_tfr12_post_byte_valid(const m680x_info *info,
742
  uint8_t post_byte)
743
1.63k
{
744
1.63k
  return !(post_byte & 0x08);
745
1.63k
}
746
747
static bool is_tfm_reg_valid(const m680x_info *info, uint8_t reg_nibble)
748
1.44k
{
749
  // HD6809 TFM instruction: Only register X,Y,U,S,D is allowed
750
1.44k
  return reg_nibble <= 4;
751
1.44k
}
752
753
// If successfull return the additional byte size needed for CPU12
754
// loop instructions DBEQ/DBNE/IBEQ/IBNE/TBEQ/TBNE (including the post byte).
755
// On error return -1.
756
static int get_loop_post_byte_size(const m680x_info *info, uint16_t address)
757
2.43k
{
758
2.43k
  uint8_t post_byte;
759
2.43k
  uint8_t rr;
760
761
2.43k
  if (!read_byte(info, &post_byte, address))
762
9
    return -1;
763
764
  // According to documentation bit 3 is don't care and not checked here.
765
2.42k
  if ((post_byte >= 0xc0) ||
766
2.42k
    ((post_byte & 0x07) == 2) || ((post_byte & 0x07) == 3))
767
1.06k
    return -1;
768
769
1.35k
  if (!read_byte(info, &rr, address + 1))
770
8
    return -1;
771
772
1.35k
  return 2;
773
1.35k
}
774
775
// If successfull return the additional byte size needed for HD6309
776
// bit move instructions BAND/BEOR/BIAND/BIEOR/BIOR/BOR/LDBT/STBT
777
// (including the post byte).
778
// On error return -1.
779
static int get_bitmv_post_byte_size(const m680x_info *info, uint16_t address)
780
1.48k
{
781
1.48k
  uint8_t post_byte;
782
1.48k
  uint8_t rr;
783
784
1.48k
  if (!read_byte(info, &post_byte, address))
785
10
    return -1;
786
787
1.47k
  if ((post_byte & 0xc0) == 0xc0)
788
538
    return -1; // Invalid register specified
789
934
  else {
790
934
    if (!read_byte(info, &rr, address + 1))
791
6
      return -1;
792
934
  }
793
794
928
  return 2;
795
1.47k
}
796
797
static bool is_sufficient_code_size(const m680x_info *info, uint16_t address,
798
  insn_desc *insn_description)
799
298k
{
800
298k
  int i;
801
298k
  bool retval = true;
802
298k
  uint16_t size = 0;
803
298k
  int sz;
804
805
868k
  for (i = 0; i < 2; i++) {
806
583k
    uint8_t ir = 0;
807
583k
    bool is_subset = false;
808
809
583k
    switch (insn_description->hid[i]) {
810
811
520
    case imm32_hid:
812
520
      if ((retval = read_byte(info, &ir, address + size + 3)))
813
496
        size += 4;
814
520
      break;
815
816
37.8k
    case ext_hid:
817
40.9k
    case imm16_hid:
818
42.6k
    case rel16_hid:
819
45.4k
    case imm8rel_hid:
820
50.4k
    case opidxdr_hid:
821
52.5k
    case idxX16_hid:
822
52.7k
    case idxS16_hid:
823
52.7k
      if ((retval = read_byte(info, &ir, address + size + 1)))
824
52.2k
        size += 2;
825
52.7k
      break;
826
827
15.4k
    case rel8_hid:
828
54.7k
    case dir_hid:
829
58.5k
    case rbits_hid:
830
78.0k
    case imm8_hid:
831
86.0k
    case idxX_hid:
832
86.6k
    case idxXp_hid:
833
87.7k
    case idxY_hid:
834
88.3k
    case idxS_hid:
835
89.4k
    case index_hid:
836
89.4k
      if ((retval = read_byte(info, &ir, address + size)))
837
89.0k
        size++;
838
89.4k
      break;
839
840
0
    case illgl_hid:
841
349k
    case inh_hid:
842
357k
    case idxX0_hid:
843
358k
    case idxX0p_hid:
844
361k
    case opidx_hid:
845
361k
      retval = true;
846
361k
      break;
847
848
34.9k
    case idx09_hid:
849
34.9k
      sz = get_indexed09_post_byte_size(info, address + size);
850
34.9k
      if (sz >= 0)
851
26.9k
        size += sz;
852
8.05k
      else
853
8.05k
        retval = false;
854
34.9k
      break;
855
856
1.37k
    case idx12s_hid:
857
1.37k
      is_subset = true;
858
859
    // intentionally fall through
860
861
28.9k
    case idx12_hid:
862
28.9k
      sz = get_indexed12_post_byte_size(info,
863
28.9k
          address + size, is_subset);
864
28.9k
      if (sz >= 0)
865
28.0k
        size += sz;
866
933
      else
867
933
        retval = false;
868
28.9k
      break;
869
870
2.78k
    case exti12x_hid:
871
4.37k
    case imm16i12x_hid:
872
4.37k
      sz = get_indexed12_post_byte_size(info,
873
4.37k
          address + size, false);
874
4.37k
      if (sz >= 0) {
875
4.35k
        size += sz;
876
4.35k
        if ((retval = read_byte(info, &ir,
877
4.35k
            address + size + 1)))
878
4.31k
          size += 2;
879
4.35k
      } else
880
21
        retval = false;
881
4.37k
      break;
882
883
2.38k
    case imm8i12x_hid:
884
2.38k
      sz = get_indexed12_post_byte_size(info,
885
2.38k
          address + size, false);
886
2.38k
      if (sz >= 0) {
887
2.38k
        size += sz;
888
2.38k
        if ((retval = read_byte(info, &ir,
889
2.38k
            address + size)))
890
2.34k
          size++;
891
2.38k
      } else
892
5
        retval = false;
893
2.38k
      break;
894
895
962
    case tfm_hid:
896
962
      if ((retval = read_byte(info, &ir, address + size))) {
897
954
        size++;
898
954
        retval = is_tfm_reg_valid(info, (ir >> 4) & 0x0F) &&
899
954
          is_tfm_reg_valid(info, ir & 0x0F);
900
954
      }
901
962
      break;
902
903
2.08k
    case rr09_hid:
904
2.08k
      if ((retval = read_byte(info, &ir, address + size))) {
905
2.06k
        size++;
906
2.06k
        retval = is_tfr09_reg_valid(info, (ir >> 4) & 0x0F) &&
907
2.06k
          is_tfr09_reg_valid(info, ir & 0x0F);
908
2.06k
      }
909
2.08k
      break;
910
911
1.63k
    case rr12_hid:
912
1.63k
      if ((retval = read_byte(info, &ir, address + size))) {
913
1.63k
        size++;
914
1.63k
        retval = is_exg_tfr12_post_byte_valid(info, ir);
915
1.63k
      }
916
1.63k
      break;
917
918
1.48k
    case bitmv_hid:
919
1.48k
      sz = get_bitmv_post_byte_size(info, address + size);
920
1.48k
      if (sz >= 0)
921
928
        size += sz;
922
554
      else
923
554
        retval = false;
924
1.48k
      break;
925
926
2.43k
    case loop_hid:
927
2.43k
      sz = get_loop_post_byte_size(info, address + size);
928
2.43k
      if (sz >= 0)
929
1.35k
        size += sz;
930
1.08k
      else
931
1.08k
        retval = false;
932
2.43k
      break;
933
934
0
    default:
935
0
      CS_ASSERT(0 && "Unexpected instruction handler id");
936
0
      retval = false;
937
0
      break;
938
583k
    }
939
940
583k
    if (!retval)
941
13.1k
      return false;
942
583k
  }
943
944
285k
  insn_description->insn_size += size;
945
946
285k
  return retval;
947
298k
}
948
949
// Check for a valid M680X instruction AND for enough bytes in the code buffer
950
// Return an instruction description in insn_desc.
951
static bool decode_insn(const m680x_info *info, uint16_t address,
952
  insn_desc *insn_description)
953
323k
{
954
323k
  const inst_pageX *inst_table = NULL;
955
323k
  const cpu_tables *cpu = info->cpu;
956
323k
  size_t table_size = 0;
957
323k
  uint16_t base_address = address;
958
323k
  uint8_t ir; // instruction register
959
323k
  int i;
960
323k
  int index;
961
962
323k
  if (!read_byte(info, &ir, address++))
963
0
    return false;
964
965
323k
  insn_description->insn = M680X_INS_ILLGL;
966
323k
  insn_description->opcode = ir;
967
968
  // Check if a page prefix byte is present
969
757k
  for (i = 0; i < ARR_SIZE(cpu->pageX_table_size); ++i) {
970
738k
    if (cpu->pageX_table_size[i] == 0 ||
971
738k
      (cpu->inst_pageX_table[i] == NULL))
972
278k
      break;
973
974
460k
    if ((cpu->pageX_prefix[i] == ir)) {
975
      // Get pageX instruction and handler id.
976
      // Abort for illegal instr.
977
26.7k
      inst_table = cpu->inst_pageX_table[i];
978
26.7k
      table_size = cpu->pageX_table_size[i];
979
980
26.7k
      if (!read_byte(info, &ir, address++))
981
51
        return false;
982
983
26.7k
      insn_description->opcode =
984
26.7k
        (insn_description->opcode << 8) | ir;
985
986
26.7k
      if ((index = binary_search(inst_table, table_size,
987
26.7k
        ir)) < 0)
988
7.85k
        return false;
989
990
18.8k
      insn_description->hid[0] =
991
18.8k
        inst_table[index].handler_id1;
992
18.8k
      insn_description->hid[1] =
993
18.8k
        inst_table[index].handler_id2;
994
18.8k
      insn_description->insn = inst_table[index].insn;
995
18.8k
      break;
996
26.7k
    }
997
460k
  }
998
999
315k
  if (insn_description->insn == M680X_INS_ILLGL) {
1000
    // Get page1 insn description
1001
296k
    insn_description->insn = cpu->inst_page1_table[ir].insn;
1002
296k
    insn_description->hid[0] =
1003
296k
      cpu->inst_page1_table[ir].handler_id1;
1004
296k
    insn_description->hid[1] =
1005
296k
      cpu->inst_page1_table[ir].handler_id2;
1006
296k
  }
1007
1008
315k
  if (insn_description->insn == M680X_INS_ILLGL) {
1009
    // Check if opcode byte is present in an overlay table
1010
52.9k
    for (i = 0; i < ARR_SIZE(cpu->overlay_table_size); ++i) {
1011
51.1k
      if (cpu->overlay_table_size[i] == 0 ||
1012
51.1k
        (cpu->inst_overlay_table[i] == NULL))
1013
15.2k
        break;
1014
1015
35.8k
      inst_table = cpu->inst_overlay_table[i];
1016
35.8k
      table_size = cpu->overlay_table_size[i];
1017
1018
35.8k
      if ((index = binary_search(inst_table, table_size,
1019
35.8k
              ir)) >= 0) {
1020
17.7k
        insn_description->hid[0] =
1021
17.7k
          inst_table[index].handler_id1;
1022
17.7k
        insn_description->hid[1] =
1023
17.7k
          inst_table[index].handler_id2;
1024
17.7k
        insn_description->insn = inst_table[index].insn;
1025
17.7k
        break;
1026
17.7k
      }
1027
35.8k
    }
1028
34.8k
  }
1029
1030
315k
  insn_description->insn_size = address - base_address;
1031
1032
315k
  return (insn_description->insn != M680X_INS_ILLGL) &&
1033
315k
    (insn_description->insn != M680X_INS_INVLD) &&
1034
315k
    is_sufficient_code_size(info, address, insn_description);
1035
323k
}
1036
1037
static void illegal_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1038
38.1k
{
1039
38.1k
  cs_m680x_op *op0 = &info->m680x.operands[info->m680x.op_count++];
1040
38.1k
  uint8_t temp8 = 0;
1041
1042
38.1k
  info->insn = M680X_INS_ILLGL;
1043
38.1k
  read_byte(info, &temp8, (*address)++);
1044
38.1k
  op0->imm = (int32_t)temp8 & 0xff;
1045
38.1k
  op0->type = M680X_OP_IMMEDIATE;
1046
38.1k
  op0->size = 1;
1047
38.1k
}
1048
1049
static void inherent_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1050
349k
{
1051
  // There is nothing to do here :-)
1052
349k
}
1053
1054
static void add_reg_operand(m680x_info *info, m680x_reg reg)
1055
173k
{
1056
173k
  cs_m680x *m680x = &info->m680x;
1057
173k
  cs_m680x_op *op = &m680x->operands[m680x->op_count++];
1058
1059
173k
  op->type = M680X_OP_REGISTER;
1060
173k
  op->reg = reg;
1061
173k
  op->size = info->cpu->reg_byte_size[reg];
1062
173k
}
1063
1064
static void set_operand_size(m680x_info *info, cs_m680x_op *op,
1065
  uint8_t default_size)
1066
198k
{
1067
198k
  cs_m680x *m680x = &info->m680x;
1068
1069
198k
  if (info->insn == M680X_INS_JMP || info->insn == M680X_INS_JSR)
1070
10.2k
    op->size = 0;
1071
188k
  else if (info->insn == M680X_INS_DIVD ||
1072
188k
    ((info->insn == M680X_INS_AIS || info->insn == M680X_INS_AIX) &&
1073
186k
      op->type != M680X_OP_REGISTER))
1074
2.30k
    op->size = 1;
1075
186k
  else if (info->insn == M680X_INS_DIVQ ||
1076
186k
    info->insn == M680X_INS_MOVW)
1077
7.83k
    op->size = 2;
1078
178k
  else if (info->insn == M680X_INS_EMACS)
1079
440
    op->size = 4;
1080
177k
  else if ((m680x->op_count > 0) &&
1081
177k
    (m680x->operands[0].type == M680X_OP_REGISTER))
1082
105k
    op->size = m680x->operands[0].size;
1083
72.4k
  else
1084
72.4k
    op->size = default_size;
1085
198k
}
1086
1087
static const m680x_reg reg_s_reg_ids[] = {
1088
  M680X_REG_CC, M680X_REG_A, M680X_REG_B, M680X_REG_DP,
1089
  M680X_REG_X,  M680X_REG_Y, M680X_REG_U, M680X_REG_PC,
1090
};
1091
1092
static const m680x_reg reg_u_reg_ids[] = {
1093
  M680X_REG_CC, M680X_REG_A, M680X_REG_B, M680X_REG_DP,
1094
  M680X_REG_X,  M680X_REG_Y, M680X_REG_S, M680X_REG_PC,
1095
};
1096
1097
static void reg_bits_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1098
3.80k
{
1099
3.80k
  cs_m680x_op *op0 = &info->m680x.operands[0];
1100
3.80k
  uint8_t reg_bits = 0;
1101
3.80k
  uint16_t bit_index;
1102
3.80k
  const m680x_reg *reg_to_reg_ids = NULL;
1103
1104
3.80k
  read_byte(info, &reg_bits, (*address)++);
1105
1106
3.80k
  switch (op0->reg) {
1107
1.90k
  case M680X_REG_U:
1108
1.90k
    reg_to_reg_ids = &reg_u_reg_ids[0];
1109
1.90k
    break;
1110
1111
1.90k
  case M680X_REG_S:
1112
1.90k
    reg_to_reg_ids = &reg_s_reg_ids[0];
1113
1.90k
    break;
1114
1115
0
  default:
1116
0
    CS_ASSERT(0 && "Unexpected operand0 register");
1117
0
    break;
1118
3.80k
  }
1119
1120
3.80k
  if ((info->insn == M680X_INS_PULU ||
1121
3.80k
      (info->insn == M680X_INS_PULS)) &&
1122
3.80k
    ((reg_bits & 0x80) != 0))
1123
    // PULS xxx,PC or PULU xxx,PC which is like return from
1124
    // subroutine (RTS)
1125
450
    add_insn_group(MI->flat_insn->detail, M680X_GRP_RET);
1126
1127
34.2k
  for (bit_index = 0; bit_index < 8; ++bit_index) {
1128
30.4k
    if (reg_bits & (1 << bit_index))
1129
14.8k
      add_reg_operand(info, reg_to_reg_ids[bit_index]);
1130
30.4k
  }
1131
3.80k
}
1132
1133
static const m680x_reg g_tfr_exg_reg_ids[] = {
1134
  /* 16-bit registers */
1135
  M680X_REG_D, M680X_REG_X,  M680X_REG_Y,  M680X_REG_U,
1136
  M680X_REG_S, M680X_REG_PC, M680X_REG_W,  M680X_REG_V,
1137
  /* 8-bit registers */
1138
  M680X_REG_A, M680X_REG_B,  M680X_REG_CC, M680X_REG_DP,
1139
  M680X_REG_0, M680X_REG_0,  M680X_REG_E,  M680X_REG_F,
1140
};
1141
1142
static void reg_reg09_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1143
1.16k
{
1144
1.16k
  uint8_t regs = 0;
1145
1146
1.16k
  read_byte(info, &regs, (*address)++);
1147
1148
1.16k
  add_reg_operand(info, g_tfr_exg_reg_ids[regs >> 4]);
1149
1.16k
  add_reg_operand(info, g_tfr_exg_reg_ids[regs & 0x0f]);
1150
1151
1.16k
  if ((regs & 0x0f) == 0x05) {
1152
    // EXG xxx,PC or TFR xxx,PC which is like a JMP
1153
223
    add_insn_group(MI->flat_insn->detail, M680X_GRP_JUMP);
1154
223
  }
1155
1.16k
}
1156
1157
1158
static void reg_reg12_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1159
1.59k
{
1160
1.59k
  static const m680x_reg g_tfr_exg12_reg0_ids[] = {
1161
1.59k
    M680X_REG_A, M680X_REG_B,  M680X_REG_CC,  M680X_REG_TMP3,
1162
1.59k
    M680X_REG_D, M680X_REG_X, M680X_REG_Y,  M680X_REG_S,
1163
1.59k
  };
1164
1.59k
  static const m680x_reg g_tfr_exg12_reg1_ids[] = {
1165
1.59k
    M680X_REG_A, M680X_REG_B,  M680X_REG_CC,  M680X_REG_TMP2,
1166
1.59k
    M680X_REG_D, M680X_REG_X, M680X_REG_Y,  M680X_REG_S,
1167
1.59k
  };
1168
1.59k
  uint8_t regs = 0;
1169
1170
1.59k
  read_byte(info, &regs, (*address)++);
1171
1172
  // The opcode of this instruction depends on
1173
  // the msb of its post byte.
1174
1.59k
  if (regs & 0x80)
1175
1.15k
    info->insn = M680X_INS_EXG;
1176
433
  else
1177
433
    info->insn = M680X_INS_TFR;
1178
1179
1.59k
  add_reg_operand(info, g_tfr_exg12_reg0_ids[(regs >> 4) & 0x07]);
1180
1.59k
  add_reg_operand(info, g_tfr_exg12_reg1_ids[regs & 0x07]);
1181
1.59k
}
1182
1183
static void add_rel_operand(m680x_info *info, int16_t offset, uint16_t address)
1184
24.7k
{
1185
24.7k
  cs_m680x *m680x = &info->m680x;
1186
24.7k
  cs_m680x_op *op = &m680x->operands[m680x->op_count++];
1187
1188
24.7k
  op->type = M680X_OP_RELATIVE;
1189
24.7k
  op->size = 0;
1190
24.7k
  op->rel.offset = offset;
1191
24.7k
  op->rel.address = address;
1192
24.7k
}
1193
1194
static void relative8_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1195
23.0k
{
1196
23.0k
  int16_t offset = 0;
1197
1198
23.0k
  read_byte_sign_extended(info, &offset, (*address)++);
1199
23.0k
  add_rel_operand(info, offset, *address + offset);
1200
23.0k
  add_insn_group(MI->flat_insn->detail, M680X_GRP_BRAREL);
1201
1202
23.0k
  if ((info->insn != M680X_INS_BRA) &&
1203
23.0k
    (info->insn != M680X_INS_BSR) &&
1204
23.0k
    (info->insn != M680X_INS_BRN))
1205
19.4k
    add_reg_to_rw_list(MI, M680X_REG_CC, READ);
1206
23.0k
}
1207
1208
static void relative16_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1209
1.72k
{
1210
1.72k
  uint16_t offset = 0;
1211
1212
1.72k
  read_word(info, &offset, *address);
1213
1.72k
  *address += 2;
1214
1.72k
  add_rel_operand(info, (int16_t)offset, *address + offset);
1215
1.72k
  add_insn_group(MI->flat_insn->detail, M680X_GRP_BRAREL);
1216
1217
1.72k
  if ((info->insn != M680X_INS_LBRA) &&
1218
1.72k
    (info->insn != M680X_INS_LBSR) &&
1219
1.72k
    (info->insn != M680X_INS_LBRN))
1220
515
    add_reg_to_rw_list(MI, M680X_REG_CC, READ);
1221
1.72k
}
1222
1223
static const m680x_reg g_rr5_to_reg_ids[] = {
1224
  M680X_REG_X, M680X_REG_Y, M680X_REG_U, M680X_REG_S,
1225
};
1226
1227
static void add_indexed_operand(m680x_info *info, m680x_reg base_reg,
1228
  bool post_inc_dec, uint8_t inc_dec, uint8_t offset_bits,
1229
  uint16_t offset, bool no_comma)
1230
22.4k
{
1231
22.4k
  cs_m680x *m680x = &info->m680x;
1232
22.4k
  cs_m680x_op *op = &m680x->operands[m680x->op_count++];
1233
1234
22.4k
  op->type = M680X_OP_INDEXED;
1235
22.4k
  set_operand_size(info, op, 1);
1236
22.4k
  op->idx.base_reg = base_reg;
1237
22.4k
  op->idx.offset_reg = M680X_REG_INVALID;
1238
22.4k
  op->idx.inc_dec = inc_dec;
1239
1240
22.4k
  if (inc_dec && post_inc_dec)
1241
1.86k
    op->idx.flags |= M680X_IDX_POST_INC_DEC;
1242
1243
22.4k
  if (offset_bits != M680X_OFFSET_NONE) {
1244
12.5k
    op->idx.offset = offset;
1245
12.5k
    op->idx.offset_addr = 0;
1246
12.5k
  }
1247
1248
22.4k
  op->idx.offset_bits = offset_bits;
1249
22.4k
  op->idx.flags |= (no_comma ? M680X_IDX_NO_COMMA : 0);
1250
22.4k
}
1251
1252
// M6800/1/2/3 indexed mode handler
1253
static void indexedX_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1254
8.00k
{
1255
8.00k
  uint8_t offset = 0;
1256
1257
8.00k
  read_byte(info, &offset, (*address)++);
1258
1259
8.00k
  add_indexed_operand(info, M680X_REG_X, false, 0, M680X_OFFSET_BITS_8,
1260
8.00k
    (uint16_t)offset, false);
1261
8.00k
}
1262
1263
static void indexedY_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1264
1.18k
{
1265
1.18k
  uint8_t offset = 0;
1266
1267
1.18k
  read_byte(info, &offset, (*address)++);
1268
1269
1.18k
  add_indexed_operand(info, M680X_REG_Y, false, 0, M680X_OFFSET_BITS_8,
1270
1.18k
    (uint16_t)offset, false);
1271
1.18k
}
1272
1273
// M6809/M6309 indexed mode handler
1274
static void indexed09_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1275
26.9k
{
1276
26.9k
  cs_m680x *m680x = &info->m680x;
1277
26.9k
  cs_m680x_op *op = &m680x->operands[m680x->op_count++];
1278
26.9k
  uint8_t post_byte = 0;
1279
26.9k
  uint16_t offset = 0;
1280
26.9k
  int16_t soffset = 0;
1281
1282
26.9k
  read_byte(info, &post_byte, (*address)++);
1283
1284
26.9k
  op->type = M680X_OP_INDEXED;
1285
26.9k
  set_operand_size(info, op, 1);
1286
26.9k
  op->idx.base_reg = g_rr5_to_reg_ids[(post_byte >> 5) & 0x03];
1287
26.9k
  op->idx.offset_reg = M680X_REG_INVALID;
1288
1289
26.9k
  if (!(post_byte & 0x80)) {
1290
    // n5,R
1291
12.5k
    if ((post_byte & 0x10) == 0x10)
1292
4.62k
      op->idx.offset = post_byte | 0xfff0;
1293
7.95k
    else
1294
7.95k
      op->idx.offset = post_byte & 0x0f;
1295
1296
12.5k
    op->idx.offset_addr = op->idx.offset + *address;
1297
12.5k
    op->idx.offset_bits = M680X_OFFSET_BITS_5;
1298
12.5k
  }
1299
14.3k
  else {
1300
14.3k
    if ((post_byte & 0x10) == 0x10)
1301
5.38k
      op->idx.flags |= M680X_IDX_INDIRECT;
1302
1303
    // indexed addressing
1304
14.3k
    switch (post_byte & 0x1f) {
1305
658
    case 0x00: // ,R+
1306
658
      op->idx.inc_dec = 1;
1307
658
      op->idx.flags |= M680X_IDX_POST_INC_DEC;
1308
658
      break;
1309
1310
385
    case 0x11: // [,R++]
1311
1.14k
    case 0x01: // ,R++
1312
1.14k
      op->idx.inc_dec = 2;
1313
1.14k
      op->idx.flags |= M680X_IDX_POST_INC_DEC;
1314
1.14k
      break;
1315
1316
447
    case 0x02: // ,-R
1317
447
      op->idx.inc_dec = -1;
1318
447
      break;
1319
1320
680
    case 0x13: // [,--R]
1321
1.85k
    case 0x03: // ,--R
1322
1.85k
      op->idx.inc_dec = -2;
1323
1.85k
      break;
1324
1325
382
    case 0x14: // [,R]
1326
874
    case 0x04: // ,R
1327
874
      break;
1328
1329
478
    case 0x15: // [B,R]
1330
1.07k
    case 0x05: // B,R
1331
1.07k
      op->idx.offset_reg = M680X_REG_B;
1332
1.07k
      break;
1333
1334
501
    case 0x16: // [A,R]
1335
1.01k
    case 0x06: // A,R
1336
1.01k
      op->idx.offset_reg = M680X_REG_A;
1337
1.01k
      break;
1338
1339
688
    case 0x1c: // [n8,PCR]
1340
1.67k
    case 0x0c: // n8,PCR
1341
1.67k
      op->idx.base_reg = M680X_REG_PC;
1342
1.67k
      read_byte_sign_extended(info, &soffset, (*address)++);
1343
1.67k
      op->idx.offset_addr = offset + *address;
1344
1.67k
      op->idx.offset = soffset;
1345
1.67k
      op->idx.offset_bits = M680X_OFFSET_BITS_8;
1346
1.67k
      break;
1347
1348
455
    case 0x18: // [n8,R]
1349
1.32k
    case 0x08: // n8,R
1350
1.32k
      read_byte_sign_extended(info, &soffset, (*address)++);
1351
1.32k
      op->idx.offset = soffset;
1352
1.32k
      op->idx.offset_bits = M680X_OFFSET_BITS_8;
1353
1.32k
      break;
1354
1355
306
    case 0x1d: // [n16,PCR]
1356
1.66k
    case 0x0d: // n16,PCR
1357
1.66k
      op->idx.base_reg = M680X_REG_PC;
1358
1.66k
      read_word(info, &offset, *address);
1359
1.66k
      *address += 2;
1360
1.66k
      op->idx.offset_addr = offset + *address;
1361
1.66k
      op->idx.offset = (int16_t)offset;
1362
1.66k
      op->idx.offset_bits = M680X_OFFSET_BITS_16;
1363
1.66k
      break;
1364
1365
932
    case 0x19: // [n16,R]
1366
1.50k
    case 0x09: // n16,R
1367
1.50k
      read_word(info, &offset, *address);
1368
1.50k
      *address += 2;
1369
1.50k
      op->idx.offset = (int16_t)offset;
1370
1.50k
      op->idx.offset_bits = M680X_OFFSET_BITS_16;
1371
1.50k
      break;
1372
1373
289
    case 0x1b: // [D,R]
1374
821
    case 0x0b: // D,R
1375
821
      op->idx.offset_reg = M680X_REG_D;
1376
821
      break;
1377
1378
284
    case 0x1f: // [n16]
1379
284
      op->type = M680X_OP_EXTENDED;
1380
284
      op->ext.indirect = true;
1381
284
      read_word(info, &op->ext.address, *address);
1382
284
      *address += 2;
1383
284
      break;
1384
1385
0
    default:
1386
0
      op->idx.base_reg = M680X_REG_INVALID;
1387
0
      break;
1388
14.3k
    }
1389
14.3k
  }
1390
1391
26.9k
  if (((info->insn == M680X_INS_LEAU) ||
1392
26.9k
      (info->insn == M680X_INS_LEAS) ||
1393
26.9k
      (info->insn == M680X_INS_LEAX) ||
1394
26.9k
      (info->insn == M680X_INS_LEAY)) &&
1395
26.9k
    (m680x->operands[0].reg == M680X_REG_X ||
1396
3.65k
      (m680x->operands[0].reg == M680X_REG_Y)))
1397
    // Only LEAX and LEAY modify CC register
1398
1.97k
    add_reg_to_rw_list(MI, M680X_REG_CC, MODIFY);
1399
26.9k
}
1400
1401
1402
static const m680x_reg g_idx12_to_reg_ids[4] = {
1403
  M680X_REG_X, M680X_REG_Y, M680X_REG_S, M680X_REG_PC,
1404
};
1405
1406
static const m680x_reg g_or12_to_reg_ids[3] = {
1407
  M680X_REG_A, M680X_REG_B, M680X_REG_D
1408
};
1409
1410
// CPU12 indexed mode handler
1411
static void indexed12_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1412
34.6k
{
1413
34.6k
  cs_m680x *m680x = &info->m680x;
1414
34.6k
  cs_m680x_op *op = &m680x->operands[m680x->op_count++];
1415
34.6k
  uint8_t post_byte = 0;
1416
34.6k
  uint8_t offset8 = 0;
1417
1418
34.6k
  read_byte(info, &post_byte, (*address)++);
1419
1420
34.6k
  op->type = M680X_OP_INDEXED;
1421
34.6k
  set_operand_size(info, op, 1);
1422
34.6k
  op->idx.offset_reg = M680X_REG_INVALID;
1423
1424
34.6k
  if (!(post_byte & 0x20)) {
1425
    // n5,R      n5 is a 5-bit signed offset
1426
12.4k
    op->idx.base_reg = g_idx12_to_reg_ids[(post_byte >> 6) & 0x03];
1427
1428
12.4k
    if ((post_byte & 0x10) == 0x10)
1429
5.22k
      op->idx.offset = post_byte | 0xfff0;
1430
7.26k
    else
1431
7.26k
      op->idx.offset = post_byte & 0x0f;
1432
1433
12.4k
    op->idx.offset_addr = op->idx.offset + *address;
1434
12.4k
    op->idx.offset_bits = M680X_OFFSET_BITS_5;
1435
12.4k
  }
1436
22.1k
  else {
1437
22.1k
    if ((post_byte & 0xe0) == 0xe0)
1438
10.4k
      op->idx.base_reg =
1439
10.4k
        g_idx12_to_reg_ids[(post_byte >> 3) & 0x03];
1440
1441
22.1k
    switch (post_byte & 0xe7) {
1442
1.37k
    case 0xe0:
1443
3.31k
    case 0xe1: // n9,R
1444
3.31k
      read_byte(info, &offset8, (*address)++);
1445
3.31k
      op->idx.offset = offset8;
1446
1447
3.31k
      if (post_byte & 0x01) // sign extension
1448
1.94k
        op->idx.offset |= 0xff00;
1449
1450
3.31k
      op->idx.offset_bits = M680X_OFFSET_BITS_9;
1451
1452
3.31k
      if (op->idx.base_reg == M680X_REG_PC)
1453
1.36k
        op->idx.offset_addr = op->idx.offset + *address;
1454
1455
3.31k
      break;
1456
1457
1.53k
    case 0xe3: // [n16,R]
1458
1.53k
      op->idx.flags |= M680X_IDX_INDIRECT;
1459
1460
    // intentionally fall through
1461
3.50k
    case 0xe2: // n16,R
1462
3.50k
      read_word(info, (uint16_t *)&op->idx.offset, *address);
1463
3.50k
      (*address) += 2;
1464
3.50k
      op->idx.offset_bits = M680X_OFFSET_BITS_16;
1465
1466
3.50k
      if (op->idx.base_reg == M680X_REG_PC)
1467
672
        op->idx.offset_addr = op->idx.offset + *address;
1468
1469
3.50k
      break;
1470
1471
938
    case 0xe4: // A,R
1472
1.61k
    case 0xe5: // B,R
1473
2.70k
    case 0xe6: // D,R
1474
2.70k
      op->idx.offset_reg =
1475
2.70k
        g_or12_to_reg_ids[post_byte & 0x03];
1476
2.70k
      break;
1477
1478
905
    case 0xe7: // [D,R]
1479
905
      op->idx.offset_reg = M680X_REG_D;
1480
905
      op->idx.flags |= M680X_IDX_INDIRECT;
1481
905
      break;
1482
1483
11.7k
    default: // n,-r n,+r n,r- n,r+
1484
      // PC is not allowed in this mode
1485
11.7k
      op->idx.base_reg =
1486
11.7k
        g_idx12_to_reg_ids[(post_byte >> 6) & 0x03];
1487
11.7k
      op->idx.inc_dec = post_byte & 0x0f;
1488
1489
11.7k
      if (op->idx.inc_dec & 0x08) // evtl. sign extend value
1490
5.82k
        op->idx.inc_dec |= 0xf0;
1491
1492
11.7k
      if (op->idx.inc_dec >= 0)
1493
5.92k
        op->idx.inc_dec++;
1494
1495
11.7k
      if (post_byte & 0x10)
1496
3.94k
        op->idx.flags |= M680X_IDX_POST_INC_DEC;
1497
1498
11.7k
      break;
1499
1500
22.1k
    }
1501
22.1k
  }
1502
34.6k
}
1503
1504
static void index_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1505
1.09k
{
1506
1.09k
  cs_m680x *m680x = &info->m680x;
1507
1.09k
  cs_m680x_op *op = &m680x->operands[m680x->op_count++];
1508
1509
1.09k
  op->type = M680X_OP_CONSTANT;
1510
1.09k
  read_byte(info, &op->const_val, (*address)++);
1511
1.09k
};
1512
1513
static void direct_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1514
45.0k
{
1515
45.0k
  cs_m680x *m680x = &info->m680x;
1516
45.0k
  cs_m680x_op *op = &m680x->operands[m680x->op_count++];
1517
1518
45.0k
  op->type = M680X_OP_DIRECT;
1519
45.0k
  set_operand_size(info, op, 1);
1520
45.0k
  read_byte(info, &op->direct_addr, (*address)++);
1521
45.0k
};
1522
1523
static void extended_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1524
37.5k
{
1525
37.5k
  cs_m680x *m680x = &info->m680x;
1526
37.5k
  cs_m680x_op *op = &m680x->operands[m680x->op_count++];
1527
1528
37.5k
  op->type = M680X_OP_EXTENDED;
1529
37.5k
  set_operand_size(info, op, 1);
1530
37.5k
  read_word(info, &op->ext.address, *address);
1531
37.5k
  *address += 2;
1532
37.5k
}
1533
1534
static void immediate_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1535
25.4k
{
1536
25.4k
  cs_m680x *m680x = &info->m680x;
1537
25.4k
  cs_m680x_op *op = &m680x->operands[m680x->op_count++];
1538
25.4k
  uint16_t word = 0;
1539
25.4k
  int16_t sword = 0;
1540
1541
25.4k
  op->type = M680X_OP_IMMEDIATE;
1542
25.4k
  set_operand_size(info, op, 1);
1543
1544
25.4k
  switch (op->size) {
1545
21.9k
  case 1:
1546
21.9k
    read_byte_sign_extended(info, &sword, *address);
1547
21.9k
    op->imm = sword;
1548
21.9k
    break;
1549
1550
3.01k
  case 2:
1551
3.01k
    read_word(info, &word, *address);
1552
3.01k
    op->imm = (int16_t)word;
1553
3.01k
    break;
1554
1555
496
  case 4:
1556
496
    read_sdword(info, &op->imm, *address);
1557
496
    break;
1558
1559
0
  default:
1560
0
    op->imm = 0;
1561
0
    CS_ASSERT(0 && "Unexpected immediate byte size");
1562
25.4k
  }
1563
1564
25.4k
  *address += op->size;
1565
25.4k
}
1566
1567
// handler for bit move instructions, e.g: BAND A,5,1,$40  Used by HD6309
1568
static void bit_move_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1569
928
{
1570
928
  static const m680x_reg m680x_reg[] = {
1571
928
    M680X_REG_CC, M680X_REG_A, M680X_REG_B, M680X_REG_INVALID,
1572
928
  };
1573
1574
928
  uint8_t post_byte = 0;
1575
928
  cs_m680x *m680x = &info->m680x;
1576
928
  cs_m680x_op *op;
1577
1578
928
  read_byte(info, &post_byte, *address);
1579
928
  (*address)++;
1580
1581
  // operand[0] = register
1582
928
  add_reg_operand(info, m680x_reg[post_byte >> 6]);
1583
1584
  // operand[1] = bit index in source operand
1585
928
  op = &m680x->operands[m680x->op_count++];
1586
928
  op->type = M680X_OP_CONSTANT;
1587
928
  op->const_val = (post_byte >> 3) & 0x07;
1588
1589
  // operand[2] = bit index in destination operand
1590
928
  op = &m680x->operands[m680x->op_count++];
1591
928
  op->type = M680X_OP_CONSTANT;
1592
928
  op->const_val = post_byte & 0x07;
1593
1594
928
  direct_hdlr(MI, info, address);
1595
928
}
1596
1597
// handler for TFM instruction, e.g: TFM X+,Y+  Used by HD6309
1598
static void tfm_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1599
479
{
1600
479
  static const uint8_t inc_dec_r0[] = {
1601
479
    1, -1, 1, 0,
1602
479
  };
1603
479
  static const uint8_t inc_dec_r1[] = {
1604
479
    1, -1, 0, 1,
1605
479
  };
1606
479
  uint8_t regs = 0;
1607
479
  uint8_t index = (MI->Opcode & 0xff) - 0x38;
1608
1609
479
  read_byte(info, &regs, *address);
1610
1611
479
  add_indexed_operand(info, g_tfr_exg_reg_ids[regs >> 4], true,
1612
479
    inc_dec_r0[index], M680X_OFFSET_NONE, 0, true);
1613
479
  add_indexed_operand(info, g_tfr_exg_reg_ids[regs & 0x0f], true,
1614
479
    inc_dec_r1[index], M680X_OFFSET_NONE, 0, true);
1615
1616
479
  add_reg_to_rw_list(MI, M680X_REG_W, READ | WRITE);
1617
479
}
1618
1619
static void opidx_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1620
2.96k
{
1621
2.96k
  cs_m680x *m680x = &info->m680x;
1622
2.96k
  cs_m680x_op *op = &m680x->operands[m680x->op_count++];
1623
1624
  // bit index is coded in Opcode
1625
2.96k
  op->type = M680X_OP_CONSTANT;
1626
2.96k
  op->const_val = (MI->Opcode & 0x0e) >> 1;
1627
2.96k
}
1628
1629
// handler for bit test and branch instruction. Used by M6805.
1630
// The bit index is part of the opcode.
1631
// Example: BRSET 3,<$40,LOOP
1632
static void opidx_dir_rel_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1633
4.92k
{
1634
4.92k
  cs_m680x *m680x = &info->m680x;
1635
4.92k
  cs_m680x_op *op = &m680x->operands[m680x->op_count++];
1636
1637
  // bit index is coded in Opcode
1638
4.92k
  op->type = M680X_OP_CONSTANT;
1639
4.92k
  op->const_val = (MI->Opcode & 0x0e) >> 1;
1640
4.92k
  direct_hdlr(MI, info, address);
1641
4.92k
  relative8_hdlr(MI, info, address);
1642
1643
4.92k
  add_reg_to_rw_list(MI, M680X_REG_CC, MODIFY);
1644
4.92k
}
1645
1646
static void indexedX0_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1647
8.03k
{
1648
8.03k
  add_indexed_operand(info, M680X_REG_X, false, 0, M680X_OFFSET_NONE,
1649
8.03k
    0, false);
1650
8.03k
}
1651
1652
static void indexedX16_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1653
2.09k
{
1654
2.09k
  uint16_t offset = 0;
1655
1656
2.09k
  read_word(info, &offset, *address);
1657
2.09k
  *address += 2;
1658
2.09k
  add_indexed_operand(info, M680X_REG_X, false, 0, M680X_OFFSET_BITS_16,
1659
2.09k
    offset, false);
1660
2.09k
}
1661
1662
static void imm_rel_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1663
2.77k
{
1664
2.77k
  immediate_hdlr(MI, info, address);
1665
2.77k
  relative8_hdlr(MI, info, address);
1666
2.77k
}
1667
1668
static void indexedS_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1669
600
{
1670
600
  uint8_t offset = 0;
1671
1672
600
  read_byte(info, &offset, (*address)++);
1673
1674
600
  add_indexed_operand(info, M680X_REG_S, false, 0, M680X_OFFSET_BITS_8,
1675
600
    (uint16_t)offset, false);
1676
600
}
1677
1678
static void indexedS16_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1679
218
{
1680
218
  uint16_t offset = 0;
1681
1682
218
  read_word(info, &offset, *address);
1683
218
  address += 2;
1684
1685
218
  add_indexed_operand(info, M680X_REG_S, false, 0, M680X_OFFSET_BITS_16,
1686
218
    offset, false);
1687
218
}
1688
1689
static void indexedX0p_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1690
862
{
1691
862
  add_indexed_operand(info, M680X_REG_X, true, 1, M680X_OFFSET_NONE,
1692
862
    0, true);
1693
862
}
1694
1695
static void indexedXp_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1696
492
{
1697
492
  uint8_t offset = 0;
1698
1699
492
  read_byte(info, &offset, (*address)++);
1700
1701
492
  add_indexed_operand(info, M680X_REG_X, true, 1, M680X_OFFSET_BITS_8,
1702
492
    (uint16_t)offset, false);
1703
492
}
1704
1705
static void imm_idx12_x_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1706
3.90k
{
1707
3.90k
  cs_m680x *m680x = &info->m680x;
1708
3.90k
  cs_m680x_op *op = &m680x->operands[m680x->op_count++];
1709
1710
3.90k
  indexed12_hdlr(MI, info, address);
1711
3.90k
  op->type = M680X_OP_IMMEDIATE;
1712
1713
3.90k
  if (info->insn == M680X_INS_MOVW) {
1714
1.55k
    uint16_t imm16 = 0;
1715
1716
1.55k
    read_word(info, &imm16, *address);
1717
1.55k
    op->imm = (int16_t)imm16;
1718
1.55k
    op->size = 2;
1719
1.55k
  }
1720
2.34k
  else {
1721
2.34k
    uint8_t imm8 = 0;
1722
1723
2.34k
    read_byte(info, &imm8, *address);
1724
2.34k
    op->imm = (int8_t)imm8;
1725
2.34k
    op->size = 1;
1726
2.34k
  }
1727
1728
3.90k
  set_operand_size(info, op, 1);
1729
3.90k
}
1730
1731
static void ext_idx12_x_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1732
2.75k
{
1733
2.75k
  cs_m680x *m680x = &info->m680x;
1734
2.75k
  cs_m680x_op *op0 = &m680x->operands[m680x->op_count++];
1735
2.75k
  uint16_t imm16 = 0;
1736
1737
2.75k
  indexed12_hdlr(MI, info, address);
1738
2.75k
  read_word(info, &imm16, *address);
1739
2.75k
  op0->type = M680X_OP_EXTENDED;
1740
2.75k
  op0->ext.address = (int16_t)imm16;
1741
2.75k
  set_operand_size(info, op0, 1);
1742
2.75k
}
1743
1744
// handler for CPU12 DBEQ/DNBE/IBEQ/IBNE/TBEQ/TBNE instructions.
1745
// Example: DBNE X,$1000
1746
static void loop_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
1747
1.35k
{
1748
1.35k
  static const m680x_reg index_to_reg_id[] = {
1749
1.35k
    M680X_REG_A, M680X_REG_B, M680X_REG_INVALID, M680X_REG_INVALID,
1750
1.35k
    M680X_REG_D, M680X_REG_X, M680X_REG_Y, M680X_REG_S,
1751
1.35k
  };
1752
1.35k
  static const m680x_insn index_to_insn_id[] = {
1753
1.35k
    M680X_INS_DBEQ, M680X_INS_DBNE, M680X_INS_TBEQ, M680X_INS_TBNE,
1754
1.35k
    M680X_INS_IBEQ, M680X_INS_IBNE, M680X_INS_ILLGL, M680X_INS_ILLGL
1755
1.35k
  };
1756
1.35k
  cs_m680x *m680x = &info->m680x;
1757
1.35k
  uint8_t post_byte = 0;
1758
1.35k
  uint8_t rel = 0;
1759
1.35k
  cs_m680x_op *op;
1760
1761
1.35k
  read_byte(info, &post_byte, (*address)++);
1762
1763
1.35k
  info->insn = index_to_insn_id[(post_byte >> 5) & 0x07];
1764
1765
1.35k
  if (info->insn == M680X_INS_ILLGL) {
1766
0
    illegal_hdlr(MI, info, address);
1767
0
  };
1768
1769
1.35k
  read_byte(info, &rel, (*address)++);
1770
1771
1.35k
  add_reg_operand(info, index_to_reg_id[post_byte & 0x07]);
1772
1773
1.35k
  op = &m680x->operands[m680x->op_count++];
1774
1775
1.35k
  op->type = M680X_OP_RELATIVE;
1776
1777
1.35k
  op->rel.offset = (post_byte & 0x10) ? 0xff00 | rel : rel;
1778
1779
1.35k
  op->rel.address = *address + op->rel.offset;
1780
1781
1.35k
  add_insn_group(MI->flat_insn->detail, M680X_GRP_BRAREL);
1782
1.35k
}
1783
1784
static void (*const g_insn_handler[])(MCInst *, m680x_info *, uint16_t *) = {
1785
  illegal_hdlr,
1786
  relative8_hdlr,
1787
  relative16_hdlr,
1788
  immediate_hdlr, // 8-bit
1789
  immediate_hdlr, // 16-bit
1790
  immediate_hdlr, // 32-bit
1791
  direct_hdlr,
1792
  extended_hdlr,
1793
  indexedX_hdlr,
1794
  indexedY_hdlr,
1795
  indexed09_hdlr,
1796
  inherent_hdlr,
1797
  reg_reg09_hdlr,
1798
  reg_bits_hdlr,
1799
  bit_move_hdlr,
1800
  tfm_hdlr,
1801
  opidx_hdlr,
1802
  opidx_dir_rel_hdlr,
1803
  indexedX0_hdlr,
1804
  indexedX16_hdlr,
1805
  imm_rel_hdlr,
1806
  indexedS_hdlr,
1807
  indexedS16_hdlr,
1808
  indexedXp_hdlr,
1809
  indexedX0p_hdlr,
1810
  indexed12_hdlr,
1811
  indexed12_hdlr, // subset of indexed12
1812
  reg_reg12_hdlr,
1813
  loop_hdlr,
1814
  index_hdlr,
1815
  imm_idx12_x_hdlr,
1816
  imm_idx12_x_hdlr,
1817
  ext_idx12_x_hdlr,
1818
}; /* handler function pointers */
1819
1820
/* Disasemble one instruction at address and store in str_buff */
1821
static unsigned int m680x_disassemble(MCInst *MI, m680x_info *info,
1822
  uint16_t address)
1823
323k
{
1824
323k
  cs_m680x *m680x = &info->m680x;
1825
323k
  cs_detail *detail = MI->flat_insn->detail;
1826
323k
  uint16_t base_address = address;
1827
323k
  insn_desc insn_description;
1828
323k
  e_access_mode access_mode;
1829
1830
323k
  if (detail != NULL) {
1831
323k
    memset(detail, 0, offsetof(cs_detail, m680x)+sizeof(cs_m680x));
1832
323k
  }
1833
1834
323k
  memset(&insn_description, 0, sizeof(insn_description));
1835
323k
  memset(m680x, 0, sizeof(*m680x));
1836
323k
  info->insn_size = 1;
1837
1838
323k
  if (decode_insn(info, address, &insn_description)) {
1839
285k
    m680x_reg reg;
1840
1841
285k
    if (insn_description.opcode > 0xff)
1842
16.8k
      address += 2; // 8-bit opcode + page prefix
1843
268k
    else
1844
268k
      address++; // 8-bit opcode only
1845
1846
285k
    info->insn = insn_description.insn;
1847
1848
285k
    MCInst_setOpcode(MI, insn_description.opcode);
1849
1850
285k
    reg = g_insn_props[info->insn].reg0;
1851
1852
285k
    if (reg != M680X_REG_INVALID) {
1853
146k
      if (reg == M680X_REG_HX &&
1854
146k
        (!info->cpu->reg_byte_size[reg]))
1855
390
        reg = M680X_REG_X;
1856
1857
146k
      add_reg_operand(info, reg);
1858
      // First (or second) operand is a register which is
1859
      // part of the mnemonic
1860
146k
      m680x->flags |= M680X_FIRST_OP_IN_MNEM;
1861
146k
      reg = g_insn_props[info->insn].reg1;
1862
1863
146k
      if (reg != M680X_REG_INVALID) {
1864
5.10k
        if (reg == M680X_REG_HX &&
1865
5.10k
          (!info->cpu->reg_byte_size[reg]))
1866
747
          reg = M680X_REG_X;
1867
1868
5.10k
        add_reg_operand(info, reg);
1869
5.10k
        m680x->flags |= M680X_SECOND_OP_IN_MNEM;
1870
5.10k
      }
1871
146k
    }
1872
1873
    // Call addressing mode specific instruction handler
1874
285k
    (g_insn_handler[insn_description.hid[0]])(MI, info,
1875
285k
      &address);
1876
285k
    (g_insn_handler[insn_description.hid[1]])(MI, info,
1877
285k
      &address);
1878
1879
285k
    add_insn_group(detail, g_insn_props[info->insn].group);
1880
1881
285k
    if (g_insn_props[info->insn].cc_modified &&
1882
285k
      (info->cpu->insn_cc_not_modified[0] != info->insn) &&
1883
285k
      (info->cpu->insn_cc_not_modified[1] != info->insn))
1884
175k
      add_reg_to_rw_list(MI, M680X_REG_CC, MODIFY);
1885
1886
285k
    access_mode = g_insn_props[info->insn].access_mode;
1887
1888
    // Fix for M6805 BSET/BCLR. It has a differnt operand order
1889
    // in comparison to the M6811
1890
285k
    if ((info->cpu->insn_cc_not_modified[0] == info->insn) ||
1891
285k
      (info->cpu->insn_cc_not_modified[1] == info->insn))
1892
2.96k
      access_mode = rmmm;
1893
1894
285k
    build_regs_read_write_counts(MI, info, access_mode);
1895
285k
    add_operators_access(MI, info, access_mode);
1896
1897
285k
    if (g_insn_props[info->insn].update_reg_access)
1898
33.1k
      set_changed_regs_read_write_counts(MI, info);
1899
1900
285k
    info->insn_size = (uint8_t)insn_description.insn_size;
1901
1902
285k
    return info->insn_size;
1903
285k
  }
1904
38.1k
  else
1905
38.1k
    MCInst_setOpcode(MI, insn_description.opcode);
1906
1907
  // Illegal instruction
1908
38.1k
  address = base_address;
1909
38.1k
  illegal_hdlr(MI, info, &address);
1910
38.1k
  return 1;
1911
323k
}
1912
1913
// Tables to get the byte size of a register on the CPU
1914
// based on an enum m680x_reg value.
1915
// Invalid registers return 0.
1916
static const uint8_t g_m6800_reg_byte_size[22] = {
1917
  // A  B  E  F  0  D  W  CC DP MD HX H  X  Y  S  U  V  Q  PC T2 T3
1918
  0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 2, 0, 0
1919
};
1920
1921
static const uint8_t g_m6805_reg_byte_size[22] = {
1922
  // A  B  E  F  0  D  W  CC DP MD HX H  X  Y  S  U  V  Q  PC T2 T3
1923
  0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 2, 0, 0
1924
};
1925
1926
static const uint8_t g_m6808_reg_byte_size[22] = {
1927
  // A  B  E  F  0  D  W  CC DP MD HX H  X  Y  S  U  V  Q  PC T2 T3
1928
  0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 1, 1, 0, 2, 0, 0, 0, 2, 0, 0
1929
};
1930
1931
static const uint8_t g_m6801_reg_byte_size[22] = {
1932
  // A  B  E  F  0  D  W  CC DP MD HX H  X  Y  S  U  V  Q  PC T2 T3
1933
  0, 1, 1, 0, 0, 0, 2, 0, 1, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 2, 0, 0
1934
};
1935
1936
static const uint8_t g_m6811_reg_byte_size[22] = {
1937
  // A  B  E  F  0  D  W  CC DP MD HX H  X  Y  S  U  V  Q  PC T2 T3
1938
  0, 1, 1, 0, 0, 0, 2, 0, 1, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 2, 0, 0
1939
};
1940
1941
static const uint8_t g_cpu12_reg_byte_size[22] = {
1942
  // A  B  E  F  0  D  W  CC DP MD HX H  X  Y  S  U  V  Q  PC T2 T3
1943
  0, 1, 1, 0, 0, 0, 2, 0, 1, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 2, 2, 2
1944
};
1945
1946
static const uint8_t g_m6809_reg_byte_size[22] = {
1947
  // A  B  E  F  0  D  W  CC DP MD HX H  X  Y  S  U  V  Q  PC T2 T3
1948
  0, 1, 1, 0, 0, 0, 2, 0, 1, 1, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 0, 0
1949
};
1950
1951
static const uint8_t g_hd6309_reg_byte_size[22] = {
1952
  // A  B  E  F  0  D  W  CC DP MD HX H  X  Y  S  U  V  Q  PC T2 T3
1953
  0, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 0, 0, 2, 2, 2, 2, 2, 4, 2, 0, 0
1954
};
1955
1956
// Table to check for a valid register nibble on the M6809 CPU
1957
// used for TFR and EXG instruction.
1958
static const bool m6809_tfr_reg_valid[16] = {
1959
  true, true, true, true, true,  true,  false, false,
1960
  true, true, true, true, false, false, false, false,
1961
};
1962
1963
static const cpu_tables g_cpu_tables[] = {
1964
  {
1965
    // M680X_CPU_TYPE_INVALID
1966
    NULL,
1967
    { NULL, NULL },
1968
    { 0, 0 },
1969
    { 0x00, 0x00, 0x00 },
1970
    { NULL, NULL, NULL },
1971
    { 0, 0, 0 },
1972
    NULL,
1973
    NULL,
1974
    { M680X_INS_INVLD, M680X_INS_INVLD }
1975
  },
1976
  {
1977
    // M680X_CPU_TYPE_6301
1978
    &g_m6800_inst_page1_table[0],
1979
    { &g_m6801_inst_overlay_table[0], &g_hd6301_inst_overlay_table[0] },
1980
    {
1981
      ARR_SIZE(g_m6801_inst_overlay_table),
1982
      ARR_SIZE(g_hd6301_inst_overlay_table)
1983
    },
1984
    { 0x00, 0x00, 0x00 },
1985
    { NULL, NULL, NULL },
1986
    { 0, 0, 0 },
1987
    &g_m6801_reg_byte_size[0],
1988
    NULL,
1989
    { M680X_INS_INVLD, M680X_INS_INVLD }
1990
  },
1991
  {
1992
    // M680X_CPU_TYPE_6309
1993
    &g_m6809_inst_page1_table[0],
1994
    { &g_hd6309_inst_overlay_table[0], NULL },
1995
    { ARR_SIZE(g_hd6309_inst_overlay_table), 0 },
1996
    { 0x10, 0x11, 0x00 },
1997
    { &g_hd6309_inst_page2_table[0], &g_hd6309_inst_page3_table[0], NULL },
1998
    {
1999
      ARR_SIZE(g_hd6309_inst_page2_table),
2000
      ARR_SIZE(g_hd6309_inst_page3_table),
2001
      0
2002
    },
2003
    &g_hd6309_reg_byte_size[0],
2004
    NULL,
2005
    { M680X_INS_INVLD, M680X_INS_INVLD }
2006
  },
2007
  {
2008
    // M680X_CPU_TYPE_6800
2009
    &g_m6800_inst_page1_table[0],
2010
    { NULL, NULL },
2011
    { 0, 0 },
2012
    { 0x00, 0x00, 0x00 },
2013
    { NULL, NULL, NULL },
2014
    { 0, 0, 0 },
2015
    &g_m6800_reg_byte_size[0],
2016
    NULL,
2017
    { M680X_INS_INVLD, M680X_INS_INVLD }
2018
  },
2019
  {
2020
    // M680X_CPU_TYPE_6801
2021
    &g_m6800_inst_page1_table[0],
2022
    { &g_m6801_inst_overlay_table[0], NULL },
2023
    { ARR_SIZE(g_m6801_inst_overlay_table), 0 },
2024
    { 0x00, 0x00, 0x00 },
2025
    { NULL, NULL, NULL },
2026
    { 0, 0, 0 },
2027
    &g_m6801_reg_byte_size[0],
2028
    NULL,
2029
    { M680X_INS_INVLD, M680X_INS_INVLD }
2030
  },
2031
  {
2032
    // M680X_CPU_TYPE_6805
2033
    &g_m6805_inst_page1_table[0],
2034
    { NULL, NULL },
2035
    { 0, 0 },
2036
    { 0x00, 0x00, 0x00 },
2037
    { NULL, NULL, NULL },
2038
    { 0, 0, 0 },
2039
    &g_m6805_reg_byte_size[0],
2040
    NULL,
2041
    { M680X_INS_BCLR, M680X_INS_BSET }
2042
  },
2043
  {
2044
    // M680X_CPU_TYPE_6808
2045
    &g_m6805_inst_page1_table[0],
2046
    { &g_m6808_inst_overlay_table[0], NULL },
2047
    { ARR_SIZE(g_m6808_inst_overlay_table), 0 },
2048
    { 0x9E, 0x00, 0x00 },
2049
    { &g_m6808_inst_page2_table[0], NULL, NULL },
2050
    { ARR_SIZE(g_m6808_inst_page2_table), 0, 0 },
2051
    &g_m6808_reg_byte_size[0],
2052
    NULL,
2053
    { M680X_INS_BCLR, M680X_INS_BSET }
2054
  },
2055
  {
2056
    // M680X_CPU_TYPE_6809
2057
    &g_m6809_inst_page1_table[0],
2058
    { NULL, NULL },
2059
    { 0, 0 },
2060
    { 0x10, 0x11, 0x00 },
2061
    {
2062
      &g_m6809_inst_page2_table[0],
2063
      &g_m6809_inst_page3_table[0],
2064
      NULL
2065
    },
2066
    {
2067
      ARR_SIZE(g_m6809_inst_page2_table),
2068
      ARR_SIZE(g_m6809_inst_page3_table),
2069
      0
2070
    },
2071
    &g_m6809_reg_byte_size[0],
2072
    &m6809_tfr_reg_valid[0],
2073
    { M680X_INS_INVLD, M680X_INS_INVLD }
2074
  },
2075
  {
2076
    // M680X_CPU_TYPE_6811
2077
    &g_m6800_inst_page1_table[0],
2078
    {
2079
      &g_m6801_inst_overlay_table[0],
2080
      &g_m6811_inst_overlay_table[0]
2081
    },
2082
    {
2083
      ARR_SIZE(g_m6801_inst_overlay_table),
2084
      ARR_SIZE(g_m6811_inst_overlay_table)
2085
    },
2086
    { 0x18, 0x1A, 0xCD },
2087
    {
2088
      &g_m6811_inst_page2_table[0],
2089
      &g_m6811_inst_page3_table[0],
2090
      &g_m6811_inst_page4_table[0]
2091
    },
2092
    {
2093
      ARR_SIZE(g_m6811_inst_page2_table),
2094
      ARR_SIZE(g_m6811_inst_page3_table),
2095
      ARR_SIZE(g_m6811_inst_page4_table)
2096
    },
2097
    &g_m6811_reg_byte_size[0],
2098
    NULL,
2099
    { M680X_INS_INVLD, M680X_INS_INVLD }
2100
  },
2101
  {
2102
    // M680X_CPU_TYPE_CPU12
2103
    &g_cpu12_inst_page1_table[0],
2104
    { NULL, NULL },
2105
    { 0, 0 },
2106
    { 0x18, 0x00, 0x00 },
2107
    { &g_cpu12_inst_page2_table[0], NULL, NULL },
2108
    { ARR_SIZE(g_cpu12_inst_page2_table), 0, 0 },
2109
    &g_cpu12_reg_byte_size[0],
2110
    NULL,
2111
    { M680X_INS_INVLD, M680X_INS_INVLD }
2112
  },
2113
  {
2114
    // M680X_CPU_TYPE_HCS08
2115
    &g_m6805_inst_page1_table[0],
2116
    {
2117
      &g_m6808_inst_overlay_table[0],
2118
      &g_hcs08_inst_overlay_table[0]
2119
    },
2120
    {
2121
      ARR_SIZE(g_m6808_inst_overlay_table),
2122
      ARR_SIZE(g_hcs08_inst_overlay_table)
2123
    },
2124
    { 0x9E, 0x00, 0x00 },
2125
    { &g_hcs08_inst_page2_table[0], NULL, NULL },
2126
    { ARR_SIZE(g_hcs08_inst_page2_table), 0, 0 },
2127
    &g_m6808_reg_byte_size[0],
2128
    NULL,
2129
    { M680X_INS_BCLR, M680X_INS_BSET }
2130
  },
2131
};
2132
2133
static bool m680x_setup_internals(m680x_info *info, e_cpu_type cpu_type,
2134
  uint16_t address,
2135
  const uint8_t *code, uint16_t code_len)
2136
323k
{
2137
323k
  if (cpu_type == M680X_CPU_TYPE_INVALID) {
2138
0
    return false;
2139
0
  }
2140
2141
323k
  info->code = code;
2142
323k
  info->size = code_len;
2143
323k
  info->offset = address;
2144
323k
  info->cpu_type = cpu_type;
2145
2146
323k
  info->cpu = &g_cpu_tables[info->cpu_type];
2147
2148
323k
  return true;
2149
323k
}
2150
2151
bool M680X_getInstruction(csh ud, const uint8_t *code, size_t code_len,
2152
  MCInst *MI, uint16_t *size, uint64_t address, void *inst_info)
2153
323k
{
2154
323k
  unsigned int insn_size = 0;
2155
323k
  e_cpu_type cpu_type = M680X_CPU_TYPE_INVALID; // No default CPU type
2156
323k
  cs_struct *handle = (cs_struct *)ud;
2157
323k
  m680x_info *info = (m680x_info *)handle->printer_info;
2158
2159
323k
  MCInst_clear(MI);
2160
2161
323k
  if (handle->mode & CS_MODE_M680X_6800)
2162
3.15k
    cpu_type = M680X_CPU_TYPE_6800;
2163
2164
320k
  else if (handle->mode & CS_MODE_M680X_6801)
2165
7.11k
    cpu_type = M680X_CPU_TYPE_6801;
2166
2167
312k
  else if (handle->mode & CS_MODE_M680X_6805)
2168
12.1k
    cpu_type = M680X_CPU_TYPE_6805;
2169
2170
300k
  else if (handle->mode & CS_MODE_M680X_6808)
2171
15.9k
    cpu_type = M680X_CPU_TYPE_6808;
2172
2173
284k
  else if (handle->mode & CS_MODE_M680X_HCS08)
2174
14.9k
    cpu_type = M680X_CPU_TYPE_HCS08;
2175
2176
269k
  else if (handle->mode & CS_MODE_M680X_6809)
2177
34.3k
    cpu_type = M680X_CPU_TYPE_6809;
2178
2179
235k
  else if (handle->mode & CS_MODE_M680X_6301)
2180
1.57k
    cpu_type = M680X_CPU_TYPE_6301;
2181
2182
233k
  else if (handle->mode & CS_MODE_M680X_6309)
2183
90.7k
    cpu_type = M680X_CPU_TYPE_6309;
2184
2185
143k
  else if (handle->mode & CS_MODE_M680X_6811)
2186
20.8k
    cpu_type = M680X_CPU_TYPE_6811;
2187
2188
122k
  else if (handle->mode & CS_MODE_M680X_CPU12)
2189
122k
    cpu_type = M680X_CPU_TYPE_CPU12;
2190
2191
323k
  if (cpu_type != M680X_CPU_TYPE_INVALID &&
2192
323k
    m680x_setup_internals(info, cpu_type, (uint16_t)address, code,
2193
323k
      (uint16_t)code_len))
2194
323k
    insn_size = m680x_disassemble(MI, info, (uint16_t)address);
2195
2196
323k
  if (insn_size == 0) {
2197
0
    *size = 1;
2198
0
    return false;
2199
0
  }
2200
2201
  // Make sure we always stay within range
2202
323k
  if (insn_size > code_len) {
2203
36
    *size = (uint16_t)code_len;
2204
36
    return false;
2205
36
  }
2206
323k
  else
2207
323k
    *size = (uint16_t)insn_size;
2208
2209
323k
  return true;
2210
323k
}
2211
2212
cs_err M680X_disassembler_init(cs_struct *ud)
2213
2.88k
{
2214
2.88k
  if (M680X_REG_ENDING != ARR_SIZE(g_m6800_reg_byte_size)) {
2215
0
    CS_ASSERT(M680X_REG_ENDING == ARR_SIZE(g_m6800_reg_byte_size));
2216
2217
0
    return CS_ERR_MODE;
2218
0
  }
2219
2220
2.88k
  if (M680X_REG_ENDING != ARR_SIZE(g_m6801_reg_byte_size)) {
2221
0
    CS_ASSERT(M680X_REG_ENDING == ARR_SIZE(g_m6801_reg_byte_size));
2222
2223
0
    return CS_ERR_MODE;
2224
0
  }
2225
2226
2.88k
  if (M680X_REG_ENDING != ARR_SIZE(g_m6805_reg_byte_size)) {
2227
0
    CS_ASSERT(M680X_REG_ENDING == ARR_SIZE(g_m6805_reg_byte_size));
2228
2229
0
    return CS_ERR_MODE;
2230
0
  }
2231
2232
2.88k
  if (M680X_REG_ENDING != ARR_SIZE(g_m6808_reg_byte_size)) {
2233
0
    CS_ASSERT(M680X_REG_ENDING == ARR_SIZE(g_m6808_reg_byte_size));
2234
2235
0
    return CS_ERR_MODE;
2236
0
  }
2237
2238
2.88k
  if (M680X_REG_ENDING != ARR_SIZE(g_m6811_reg_byte_size)) {
2239
0
    CS_ASSERT(M680X_REG_ENDING == ARR_SIZE(g_m6811_reg_byte_size));
2240
2241
0
    return CS_ERR_MODE;
2242
0
  }
2243
2244
2.88k
  if (M680X_REG_ENDING != ARR_SIZE(g_cpu12_reg_byte_size)) {
2245
0
    CS_ASSERT(M680X_REG_ENDING == ARR_SIZE(g_cpu12_reg_byte_size));
2246
2247
0
    return CS_ERR_MODE;
2248
0
  }
2249
2250
2.88k
  if (M680X_REG_ENDING != ARR_SIZE(g_m6809_reg_byte_size)) {
2251
0
    CS_ASSERT(M680X_REG_ENDING == ARR_SIZE(g_m6809_reg_byte_size));
2252
2253
0
    return CS_ERR_MODE;
2254
0
  }
2255
2256
2.88k
  if (M680X_INS_ENDING != ARR_SIZE(g_insn_props)) {
2257
0
    CS_ASSERT(M680X_INS_ENDING == ARR_SIZE(g_insn_props));
2258
2259
0
    return CS_ERR_MODE;
2260
0
  }
2261
2262
2.88k
  if (M680X_CPU_TYPE_ENDING != ARR_SIZE(g_cpu_tables)) {
2263
0
    CS_ASSERT(M680X_CPU_TYPE_ENDING == ARR_SIZE(g_cpu_tables));
2264
2265
0
    return CS_ERR_MODE;
2266
0
  }
2267
2268
2.88k
  if (HANDLER_ID_ENDING != ARR_SIZE(g_insn_handler)) {
2269
0
    CS_ASSERT(HANDLER_ID_ENDING == ARR_SIZE(g_insn_handler));
2270
2271
0
    return CS_ERR_MODE;
2272
0
  }
2273
2274
2.88k
  if (ACCESS_MODE_ENDING !=  MATRIX_SIZE(g_access_mode_to_access)) {
2275
0
    CS_ASSERT(ACCESS_MODE_ENDING ==
2276
0
      MATRIX_SIZE(g_access_mode_to_access));
2277
2278
0
    return CS_ERR_MODE;
2279
0
  }
2280
2281
2.88k
  return CS_ERR_OK;
2282
2.88k
}
2283
2284
#ifndef CAPSTONE_DIET
2285
void M680X_reg_access(const cs_insn *insn,
2286
  cs_regs regs_read, uint8_t *regs_read_count,
2287
  cs_regs regs_write, uint8_t *regs_write_count)
2288
0
{
2289
0
  if (insn->detail == NULL) {
2290
0
    *regs_read_count = 0;
2291
0
    *regs_write_count = 0;
2292
0
  }
2293
0
  else {
2294
0
    *regs_read_count = insn->detail->regs_read_count;
2295
0
    *regs_write_count = insn->detail->regs_write_count;
2296
2297
0
    memcpy(regs_read, insn->detail->regs_read,
2298
0
      *regs_read_count * sizeof(insn->detail->regs_read[0]));
2299
0
    memcpy(regs_write, insn->detail->regs_write,
2300
0
      *regs_write_count *
2301
0
      sizeof(insn->detail->regs_write[0]));
2302
0
  }
2303
0
}
2304
#endif
2305
2306
#endif
2307