m68k-opcode.h

早期freebsd实现

/* Opcode table for m68000/m68020 and m68881.
   Copyright (C) 1989, Free Software Foundation.

This file is part of GDB, the GNU Debugger and GAS, the GNU Assembler.

Both GDB and GAS are free software; you can redistribute and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.

GDB and GAS are distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GDB or GAS; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
   

struct m68k_opcode
{
  char *name;
  unsigned long opcode;
  unsigned long  match;
  char *args;
};

/* We store four bytes of opcode for all opcodes because that
   is the most any of them need.  The actual length of an instruction
   is always at least 2 bytes, and is as much longer as necessary to
   hold the operands it has.

   The match component is a mask saying which bits must match
   particular opcode in order for an instruction to be an instance
   of that opcode.

   The args component is a string containing two characters
   for each operand of the instruction.  The first specifies
   the kind of operand; the second, the place it is stored.  */

/* Kinds of operands:
   D  data register only.  Stored as 3 bits.
   A  address register only.  Stored as 3 bits.
   R  either kind of register.  Stored as 4 bits.
   F  floating point coprocessor register only.   Stored as 3 bits.
   O  an offset (or width): immediate data 0-31 or data register.
      Stored as 6 bits in special format for BF... insns.
   +  autoincrement only.  Stored as 3 bits (number of the address register).
   -  autodecrement only.  Stored as 3 bits (number of the address register).
   Q  quick immediate data.  Stored as 3 bits.
      This matches an immediate operand only when value is in range 1 .. 8.
   M  moveq immediate data.  Stored as 8 bits.
      This matches an immediate operand only when value is in range -128..127
   T  trap vector immediate data.  Stored as 4 bits.

   k  K-factor for fmove.p instruction.   Stored as a 7-bit constant or
      a three bit register offset, depending on the field type.

   #  immediate data.  Stored in special places (b, w or l)
      which say how many bits to store.
   ^  immediate data for floating point instructions.   Special places
      are offset by 2 bytes from '#'...
   B  pc-relative address, converted to an offset
      that is treated as immediate data.
   d  displacement and register.  Stores the register as 3 bits
      and stores the displacement in the entire second word.

   C  the CCR.  No need to store it; this is just for filtering validity.
   S  the SR.  No need to store, just as with CCR.
   U  the USP.  No need to store, just as with CCR.

   I  Coprocessor ID.   Not printed if 1.   The Coprocessor ID is always
      extracted from the 'd' field of word one, which means that an extended
      coprocessor opcode can be skipped using the 'i' place, if needed.

   s  System Control register for the floating point coprocessor.
   S  List of system control registers for floating point coprocessor.

   J  Misc register for movec instruction, stored in 'j' format.
	Possible values:
	000	SFC	Source Function Code reg
	001	DFC	Data Function Code reg
	002	CACR	Cache Control Register
	800	USP	User Stack Pointer
	801	VBR	Vector Base reg
	802	CAAR	Cache Address Register
	803	MSP	Master Stack Pointer
	804	ISP	Interrupt Stack Pointer

    L  Register list of the type d0-d7/a0-a7 etc.
       (New!  Improved!  Can also hold fp0-fp7, as well!)
       The assembler tries to see if the registers match the insn by
       looking at where the insn wants them stored.

    l  Register list like L, but with all the bits reversed.
       Used for going the other way. . .

 They are all stored as 6 bits using an address mode and a register number;
 they differ in which addressing modes they match.

   *  all					(modes 0-6,7.*)
   ~  alterable memory				(modes 2-6,7.0,7.1)(not 0,1,7.~)
   %  alterable					(modes 0-6,7.0,7.1)(not 7.~)
   ;  data					(modes 0,2-6,7.*)(not 1)
   @  data, but not immediate			(modes 0,2-6,7.? ? ?)(not 1,7.?)  This may really be ;, the 68020 book says it is
   !  control					(modes 2,5,6,7.*-)(not 0,1,3,4,7.4)
   &  alterable control				(modes 2,5,6,7.0,7.1)(not 0,1,7.? ? ?)
   $  alterable data				(modes 0,2-6,7.0,7.1)(not 1,7.~)
   ?  alterable control, or data register	(modes 0,2,5,6,7.0,7.1)(not 1,3,4,7.~)
   /  control, or data register			(modes 0,2,5,6,7.0,7.1,7.2,7.3)(not 1,3,4,7.4)
*/

/* JF: for the 68851 */
/*
   I didn't use much imagination in choosing the 
   following codes, so many of them aren't very
   mnemonic. -rab

   P  pmmu register
	Possible values:
	000	TC	Translation Control reg
	100	CAL	Current Access Level
	101	VAL	Validate Access Level
	110	SCC	Stack Change Control
	111	AC	Access Control

   W  wide pmmu registers
	Possible values:
	001	DRP	Dma Root Pointer
	010	SRP	Supervisor Root Pointer
	011	CRP	Cpu Root Pointer

   f	function code register
	0	SFC
	1	DFC

   V	VAL register only

   X	BADx, BACx
	100	BAD	Breakpoint Acknowledge Data
	101	BAC	Breakpoint Acknowledge Control

   Y	PSR
   Z	PCSR

   |	memory 		(modes 2-6, 7.*)

*/

/* Places to put an operand, for non-general operands:
   s  source, low bits of first word.
   d  dest, shifted 9 in first word
   1  second word, shifted 12
   2  second word, shifted 6
   3  second word, shifted 0
   4  third word, shifted 12
   5  third word, shifted 6
   6  third word, shifted 0
   7  second word, shifted 7
   8  second word, shifted 10
   D  store in both place 1 and place 3; for divul and divsl.
   b  second word, low byte
   w  second word (entire)
   l  second and third word (entire)
   g  branch offset for bra and similar instructions.
      The place to store depends on the magnitude of offset.
   t  store in both place 7 and place 8; for floating point operations
   c  branch offset for cpBcc operations.
      The place to store is word two if bit six of word one is zero,
      and words two and three if bit six of word one is one.
   i  Increment by two, to skip over coprocessor extended operands.   Only
      works with the 'I' format.
   k  Dynamic K-factor field.   Bits 6-4 of word 2, used as a register number.
      Also used for dynamic fmovem instruction.
   C  floating point coprocessor constant - 7 bits.  Also used for static
      K-factors...
   j  Movec register #, stored in 12 low bits of second word.

 Places to put operand, for general operands:
   d  destination, shifted 6 bits in first word
   b  source, at low bit of first word, and immediate uses one byte
   w  source, at low bit of first word, and immediate uses two bytes
   l  source, at low bit of first word, and immediate uses four bytes
   s  source, at low bit of first word.
      Used sometimes in contexts where immediate is not allowed anyway.
   f  single precision float, low bit of 1st word, immediate uses 4 bytes
   F  double precision float, low bit of 1st word, immediate uses 8 bytes
   x  extended precision float, low bit of 1st word, immediate uses 12 bytes
   p  packed float, low bit of 1st word, immediate uses 12 bytes
*/

#define one(x) ((x) << 16)
#define two(x, y) (((x) << 16) + y)

/*
	*** DANGER WILL ROBINSON ***

   The assembler requires that all instances of the same mnemonic must be
   consecutive.  If they aren't, the assembler will bomb at runtime
 */
struct m68k_opcode m68k_opcodes[] =
{
{"abcd",	one(0140400),		one(0170770),		"DsDd"},
{"abcd",	one(0140410),		one(0170770),		"-s-d"},

		/* Add instructions */
{"addal",	one(0150700),		one(0170700),		"*lAd"},
{"addaw",	one(0150300),		one(0170700),		"*wAd"},
{"addib",	one(0003000),		one(0177700),		"#b$b"},
{"addil",	one(0003200),		one(0177700),		"#l$l"},
{"addiw",	one(0003100),		one(0177700),		"#w$w"},
{"addqb",	one(0050000),		one(0170700),		"Qd$b"},
{"addql",	one(0050200),		one(0170700),		"Qd%l"},
{"addqw",	one(0050100),		one(0170700),		"Qd%w"},

{"addb",	one(0050000),		one(0170700),		"Qd$b"},	/* addq written as add */
{"addb",	one(0003000),		one(0177700),		"#b$b"},	/* addi written as add */
{"addb",	one(0150000),		one(0170700),		";bDd"},	/* addb <ea>,	Dd */
{"addb",	one(0150400),		one(0170700),		"Dd~b"},	/* addb Dd,	<ea> */

{"addw",	one(0050100),		one(0170700),		"Qd%w"},	/* addq written as add */
{"addw",	one(0003100),		one(0177700),		"#w$w"},	/* addi written as add */
{"addw",	one(0150300),		one(0170700),		"*wAd"},	/* adda written as add */
{"addw",	one(0150100),		one(0170700),		"*wDd"},	/* addw <ea>,	Dd */
{"addw",	one(0150500),		one(0170700),		"Dd~w"},	/* addw Dd,	<ea> */

{"addl",	one(0050200),		one(0170700),		"Qd%l"},	/* addq written as add */
{"addl",	one(0003200),		one(0177700),		"#l$l"},	/* addi written as add */
{"addl",	one(0150700),		one(0170700),		"*lAd"},	/* adda written as add */
{"addl",	one(0150200),		one(0170700),		"*lDd"},	/* addl <ea>,	Dd */
{"addl",	one(0150600),		one(0170700),		"Dd~l"},	/* addl Dd,	<ea> */

{"addxb",	one(0150400),		one(0170770),		"DsDd"},
{"addxb",	one(0150410),		one(0170770),		"-s-d"},
{"addxl",	one(0150600),		one(0170770),		"DsDd"},
{"addxl",	one(0150610),		one(0170770),		"-s-d"},
{"addxw",	one(0150500),		one(0170770),		"DsDd"},
{"addxw",	one(0150510),		one(0170770),		"-s-d"},

{"andib",	one(0001000),		one(0177700),		"#b$b"},
{"andib",	one(0001074),		one(0177777),		"#bCb"},	/* andi to ccr */
{"andiw",	one(0001100),		one(0177700),		"#w$w"},
{"andiw",	one(0001174),		one(0177777),		"#wSw"},	/* andi to sr */
{"andil",	one(0001200),		one(0177700),		"#l$l"},

{"andb",	one(0001000),		one(0177700),		"#b$b"},	/* andi written as or */
{"andb",	one(0001074),		one(0177777),		"#bCb"},	/* andi to ccr */
{"andb",	one(0140000),		one(0170700),		";bDd"},	/* memory to register */
{"andb",	one(0140400),		one(0170700),		"Dd~b"},	/* register to memory */