748 lines
22 KiB
C
748 lines
22 KiB
C
#include <u.h>
|
|
#include <libc.h>
|
|
#include <bio.h>
|
|
#include <mach.h>
|
|
|
|
typedef struct Opcode Opcode;
|
|
struct Opcode
|
|
{
|
|
char *p;
|
|
char *o;
|
|
char *a;
|
|
};
|
|
|
|
typedef struct Instr Instr;
|
|
struct Instr
|
|
{
|
|
Opcode *op;
|
|
Map *map;
|
|
uvlong addr;
|
|
ulong w;
|
|
|
|
char *curr; /* fill point in buffer */
|
|
char *end; /* end of buffer */
|
|
};
|
|
|
|
static void format(char*, Instr*, char*);
|
|
static char FRAMENAME[] = ".frame";
|
|
|
|
/*
|
|
* Arm64-specific debugger interface
|
|
*/
|
|
static char* arm64excep(Map*, Rgetter);
|
|
static int arm64foll(Map*, uvlong, Rgetter, uvlong*);
|
|
static int arm64inst(Map*, uvlong, char, char*, int);
|
|
static int arm64das(Map*, uvlong, char*, int);
|
|
static int arm64instlen(Map*, uvlong);
|
|
|
|
/*
|
|
* Debugger interface
|
|
*/
|
|
Machdata arm64mach =
|
|
{
|
|
{0x00, 0x00, 0x20, 0xD4}, /* break point 0xD4200000 */
|
|
4, /* break point size */
|
|
leswab, /* short to local byte order */
|
|
leswal, /* long to local byte order */
|
|
leswav, /* long to local byte order */
|
|
risctrace, /* C traceback */
|
|
riscframe, /* Frame finder */
|
|
arm64excep, /* print exception */
|
|
0, /* breakpoint fixup */
|
|
0, /* single precision float printer */
|
|
0, /* double precision float printer */
|
|
arm64foll, /* following addresses */
|
|
arm64inst, /* print instruction */
|
|
arm64das, /* dissembler */
|
|
arm64instlen, /* instruction size */
|
|
};
|
|
|
|
static Opcode opcodes[] =
|
|
{
|
|
"0AA10000AAAAAAAAAAAAAAAAAAAddddd", "ADR", "$%A,R%d",
|
|
"1PP10000PPPPPPPPPPPPPPPPPPPddddd", "ADRP", "$%P,R%d",
|
|
"00011000lllllllllllllllllllddddd", "MOVWU", "%l,R%d",
|
|
"01011000LLLLLLLLLLLLLLLLLLLddddd", "MOV", "%L,R%d",
|
|
"10011000lllllllllllllllllllddddd", "MOVW", "%l,R%d",
|
|
"11011000lllllllllllllllllllddddd", "PRFM", "%l,$%d",
|
|
"1111100100uuuuuuuuuuuu11111ddddd", "MOV", "R%d,%u(SP)",
|
|
"1111100100uuuuuuuuuuuunnnnnddddd", "MOV", "R%d,%u(R%n)",
|
|
"WW11100100uuuuuuuuuuuu11111ddddd", "MOV%WU", "R%d,%u(SP)",
|
|
"WW11100100uuuuuuuuuuuunnnnnddddd", "MOV%WU", "R%d,%u(R%n)",
|
|
"1111100101uuuuuuuuuuuu11111ddddd", "MOV", "%u(SP),R%d",
|
|
"1111100101uuuuuuuuuuuunnnnnddddd", "MOV", "%u(R%n),R%d",
|
|
"WW11100101uuuuuuuuuuuu11111ddddd", "MOV%WU", "%u(SP),R%d",
|
|
"WW11100101uuuuuuuuuuuunnnnnddddd", "MOV%WU", "%u(R%n),R%d",
|
|
"WW11100110uuuuuuuuuuuu11111ddddd", "MOV%W", "%u(SP),R%d",
|
|
"WW11100110uuuuuuuuuuuunnnnnddddd", "MOV%W", "%u(R%n),R%d",
|
|
"11111000000ooooooooo0011111ddddd", "MOV", "R%d,%o(SP)",
|
|
"11111000000ooooooooo00nnnnnddddd", "MOV", "R%d,%o(R%n)",
|
|
"WW111000000ooooooooo0011111ddddd", "MOV%W", "R%d,%o(SP)",
|
|
"WW111000000ooooooooo00nnnnnddddd", "MOV%W", "R%d,%o(R%n)",
|
|
"11111000010ooooooooo0011111ddddd", "MOV", "%o(SP),R%d",
|
|
"11111000010ooooooooo00nnnnnddddd", "MOV", "%o(R%n),R%d",
|
|
"WW111000010ooooooooo0011111ddddd", "MOV%WU", "%o(SP),R%d",
|
|
"WW111000010ooooooooo00nnnnnddddd", "MOV%WU", "%o(R%n),R%d",
|
|
"WW111000100ooooooooo0011111ddddd", "MOV%W", "%o(SP),R%d",
|
|
"WW111000100ooooooooo00nnnnnddddd", "MOV%W", "%o(R%n),R%d",
|
|
"11111000000ooooooooo0111111ddddd", "MOV", "R%d,(SP)%o!",
|
|
"WW111000000ooooooooo0111111ddddd", "MOV%WU", "R%d,(SP)%o!",
|
|
"WW111000000ooooooooo01nnnnnddddd", "MOV%WU", "R%d,(R%n)%o!",
|
|
"11111000000ooooooooo1111111ddddd", "MOV", "R%d,%o(SP)!",
|
|
"WW111000000ooooooooo1111111ddddd", "MOV%WU", "R%d,%o(SP)!",
|
|
"WW111000000ooooooooo11nnnnnddddd", "MOV%WU", "R%d,%o(R%n)!",
|
|
"11111000010ooooooooo0111111ddddd", "MOV", "(SP)%o!,R%d",
|
|
"11111000010ooooooooo01nnnnnddddd", "MOV", "(R%n)%o!,R%d",
|
|
"WW111000010ooooooooo0111111ddddd", "MOV%WU", "(SP)%o!,R%d",
|
|
"WW111000010ooooooooo01nnnnnddddd", "MOV%WU", "(R%n)%o!,R%d",
|
|
"WW111000100ooooooooo0111111ddddd", "MOV%W", "(SP)%o!,R%d",
|
|
"WW111000100ooooooooo01nnnnnddddd", "MOV%W", "(R%n)%o!,R%d",
|
|
"11111000010ooooooooo1111111ddddd", "MOV", "%o(SP)!,R%d",
|
|
"11111000010ooooooooo11nnnnnddddd", "MOV", "%o(R%n)!,R%d",
|
|
"WW111000010ooooooooo1111111ddddd", "MOV%WU", "%o(SP)!,R%d",
|
|
"WW111000010ooooooooo11nnnnnddddd", "MOV%WU", "%o(R%n)!,R%d",
|
|
"WW111000100ooooooooo1111111ddddd", "MOV%W", "%o(SP)!,R%d",
|
|
"WW111000100ooooooooo11nnnnnddddd", "MOV%W", "%o(R%n)!,R%d",
|
|
"11111000001mmmmmeeei10nnnnnddddd", "MOV", "R%d,(R%n)(R%m%e)",
|
|
"11111000111mmmmmeeei10nnnnnddddd", "MOV", "(R%n)(R%m%e),R%d",
|
|
"WW111000001mmmmmeeei10nnnnnddddd", "MOV%W", "R%d,(R%n)(R%m%e)",
|
|
"WW111000011mmmmmeeei10nnnnnddddd", "MOV%WU", "(R%n)(R%m%e),R%d",
|
|
"WW111000101mmmmmeeei10nnnnnddddd", "MOV%W", "(R%n)(R%m%e),R%d",
|
|
"WW111000111mmmmmeeei10nnnnnddddd", "MOV%WW", "(R%n)(R%m%e),R%d",
|
|
"W00100101ssKKKKKKKKKKKKKKKKddddd", "MOVN%W", "$%K,R%d",
|
|
"W10100101ssKKKKKKKKKKKKKKKKddddd", "MOVZ%W", "$%K,R%d",
|
|
"W11100101ssKKKKKKKKKKKKKKKKddddd", "MOVK%W", "$%K,R%d",
|
|
"W0010001--00000000000011111ddddd", "MOV%W", "SP,R%d",
|
|
"W0010001--000000000000nnnnn11111", "MOV%W", "R%n,SP",
|
|
"0110100011ooooooommmmm11111ddddd", "MOVPSW", "(SP)%o!,R%d,R%m",
|
|
"0110100011ooooooommmmmnnnnnddddd", "MOVPSW", "(R%n)%o!,R%d,R%m",
|
|
"0110100101ooooooommmmm11111ddddd", "MOVPSW", "%o(SP),R%d,R%m",
|
|
"0110100101ooooooommmmmnnnnnddddd", "MOVPSW", "%o(R%n),R%d,R%m",
|
|
"0110100111ooooooommmmm11111ddddd", "MOVPSW", "%o(SP)!,R%d,R%m",
|
|
"0110100111ooooooommmmmnnnnnddddd", "MOVPSW", "%o(R%n)!,R%d,R%m",
|
|
"W010100010ooooooommmmm11111ddddd", "MOVP%W", "R%d,R%m,(SP)%o!",
|
|
"W010100010ooooooommmmmnnnnnddddd", "MOVP%W", "R%d,R%m,(R%n)%o!",
|
|
"W010100100ooooooommmmm11111ddddd", "MOVP%W", "R%d,R%m,%o(SP)",
|
|
"W010100100ooooooommmmmnnnnnddddd", "MOVP%W", "R%d,R%m,%o(R%n)",
|
|
"W010100110ooooooommmmm11111ddddd", "MOVP%W", "R%d,R%m,%o(SP)!",
|
|
"W010100110ooooooommmmmnnnnnddddd", "MOVP%W", "R%d,R%m,%o(R%n)!",
|
|
"W010100011ooooooommmmm11111ddddd", "MOVP%W", "(SP)%o!,R%d,R%m",
|
|
"W010100011ooooooommmmmnnnnnddddd", "MOVP%W", "(R%n)%o!,R%d,R%m",
|
|
"W010100101ooooooommmmm11111ddddd", "MOVP%W", "%o(SP),R%d,R%m",
|
|
"W010100101ooooooommmmmnnnnnddddd", "MOVP%W", "%o(R%n),R%d,R%m",
|
|
"W010100111ooooooommmmm11111ddddd", "MOVP%W", "%o(SP)!,R%d,R%m",
|
|
"W010100111ooooooommmmmnnnnnddddd", "MOVP%W", "%o(R%n)!,R%d,R%m",
|
|
"W0010001ssIIIIIIIIIIII1111111111", "ADD%W", "$%I,SP,SP",
|
|
"W0010001ssIIIIIIIIIIII11111ddddd", "ADD%W", "$%I,SP,R%d",
|
|
"W0010001ssIIIIIIIIIIIInnnnn11111", "ADD%W", "$%I,R%n,SP",
|
|
"W0110001ssIIIIIIIIIIII1111111111", "ADDS%W", "$%I,SP,SP",
|
|
"W0110001ssIIIIIIIIIIII11111ddddd", "ADDS%W", "$%I,SP,R%d",
|
|
"W0110001ssIIIIIIIIIIIInnnnn11111", "ADDS%W", "$%I,R%n,SP",
|
|
"W1010001ssIIIIIIIIIIII1111111111", "SUB%W", "$%I,SP,SP",
|
|
"W1010001ssIIIIIIIIIIII11111ddddd", "SUB%W", "$%I,SP,R%d",
|
|
"W1010001ssIIIIIIIIIIIInnnnn11111", "SUB%W", "$%I,R%n,SP",
|
|
"W1110001ssIIIIIIIIIIII1111111111", "CMP%W", "$%I,SP",
|
|
"W1110001ssIIIIIIIIIIIInnnnn11111", "CMP%W", "$%I,R%n",
|
|
"W1110001ssIIIIIIIIIIII11111ddddd", "SUBS%W", "$%I,SP,R%d",
|
|
"W0010001ssIIIIIIIIIIIInnnnnddddd", "ADD%W", "$%I,R%n,R%d",
|
|
"W0110001ssIIIIIIIIIIIInnnnnddddd", "ADDS%W", "$%I,R%n,R%d",
|
|
"W1010001ssIIIIIIIIIIIInnnnnddddd", "SUB%W", "$%I,R%n,R%d",
|
|
"W1110001ssIIIIIIIIIIIInnnnnddddd", "SUBS%W", "$%I,R%n,R%d",
|
|
"W00100100MMMMMMMMMMMMMnnnnn11111", "AND%W", "$%M,R%n,SP",
|
|
"W01100100MMMMMMMMMMMMMnnnnn11111", "ORR%W", "$%M,R%n,SP",
|
|
"W10100100MMMMMMMMMMMMMnnnnn11111", "EOR%W", "$%M,R%n,SP",
|
|
"W11100100MMMMMMMMMMMMMnnnnn11111", "ANDS%W", "$%M,R%n,SP",
|
|
"W00100100MMMMMMMMMMMMMnnnnnddddd", "AND%W", "$%M,R%n,R%d",
|
|
"W01100100MMMMMMMMMMMMMnnnnnddddd", "ORR%W", "$%M,R%n,R%d",
|
|
"W10100100MMMMMMMMMMMMMnnnnnddddd", "EOR%W", "$%M,R%n,R%d",
|
|
"W11100100MMMMMMMMMMMMMnnnnnddddd", "ANDS%W", "$%M,R%n,R%d",
|
|
"1001001101000000011111nnnnnddddd", "SXTW", "R%n,R%d",
|
|
"0101001100iiiiii011111nnnnnddddd", "LSRW", "$%i,R%n,R%d",
|
|
"1101001101iiiiii111111nnnnnddddd", "LSR", "$%i,R%n,R%d",
|
|
"W00100110-iiiiiijjjjjjnnnnnddddd", "SBFM%W", "$%i,$%j,R%n,R%d",
|
|
"W01100110-iiiiiijjjjjjnnnnnddddd", "BFM%W", "$%i,$%j,R%n,R%d",
|
|
"W10100110-iiiiiijjjjjjnnnnnddddd", "UBFM%W", "$%i,$%j,R%n,R%d",
|
|
"W1011010000mmmmm00000011111ddddd", "NGC%W", "R%m,R%d",
|
|
"W1111010000mmmmm00000011111ddddd", "NGCS%W", "R%m,R%d",
|
|
"W0011010000mmmmm000000nnnnnddddd", "ADC%W", "R%m,R%n,R%d",
|
|
"W0111010000mmmmm000000nnnnnddddd", "ADCS%W", "R%m,R%n,R%d",
|
|
"W1011010000mmmmm000000nnnnnddddd", "SBC%W", "R%m,R%n,R%d",
|
|
"W1111010000mmmmm000000nnnnnddddd", "SBCS%W", "R%m,R%n,R%d",
|
|
"W0101011ss0mmmmmiiiiiinnnnn11111", "CMN%W", "R%m%s,R%n",
|
|
"W1101011ss0mmmmmiiiiiinnnnn11111", "CMP%W", "R%m%s,R%n",
|
|
"W1001011ss0mmmmmiiiiii11111ddddd", "NEG%W", "R%m%s,R%d",
|
|
"W1101011ss0mmmmmiiiiii11111ddddd", "NEGS%W", "R%m%s,R%d",
|
|
"W0001011ss0mmmmmiiiiiinnnnnddddd", "ADD%W", "R%m%s,R%n,R%d",
|
|
"W0101011ss0mmmmmiiiiiinnnnnddddd", "ADDS%W", "R%m%s,R%n,R%d",
|
|
"W1001011ss0mmmmmiiiiiinnnnnddddd", "SUB%W", "R%m%s,R%n,R%d",
|
|
"W1101011ss0mmmmmiiiiiinnnnnddddd", "SUBS%W", "R%m%s,R%n,R%d",
|
|
"W0001011001mmmmmeeeiii1111111111", "ADD%W", "R%m%e,SP,SP",
|
|
"W0001011001mmmmmeeeiii11111ddddd", "ADD%W", "R%m%e,SP,R%d",
|
|
"W0001011001mmmmmeeeiiinnnnn11111", "ADD%W", "R%m%e,R%n,SP",
|
|
"W0101011001mmmmmeeeiii1111111111", "ADDS%W", "R%m%e,SP,SP",
|
|
"W0101011001mmmmmeeeiii11111ddddd", "ADDS%W", "R%m%e,SP,R%d",
|
|
"W0101011001mmmmmeeeiiinnnnn11111", "ADDS%W", "R%m%e,R%n,SP",
|
|
"W1001011001mmmmmeeeiii1111111111", "SUB%W", "R%m%e,SP,SP",
|
|
"W1001011001mmmmmeeeiii11111ddddd", "SUB%W", "R%m%e,SP,R%d",
|
|
"W1001011001mmmmmeeeiiinnnnn11111", "SUB%W", "R%m%e,R%n,SP",
|
|
"W1101011001mmmmmeeeiii1111111111", "SUBS%W", "R%m%e,SP,SP",
|
|
"W1101011001mmmmmeeeiii11111ddddd", "SUBS%W", "R%m%e,SP,R%d",
|
|
"W1101011001mmmmmeeeiiinnnnn11111", "SUBS%W", "R%m%e,R%n,SP",
|
|
"W0001011001mmmmmeeeiiinnnnnddddd", "ADD%W", "R%m%e,R%n,R%d",
|
|
"W0101011001mmmmmeeeiiinnnnnddddd", "ADDS%W", "R%m%e,R%n,R%d",
|
|
"W1001011001mmmmmeeeiiinnnnnddddd", "SUB%W", "R%m%e,R%n,R%d",
|
|
"W1101011001mmmmmeeeiiinnnnnddddd", "SUBS%W", "R%m%e,R%n,R%d",
|
|
"W0101010000mmmmm-0000011111ddddd", "MOV%W", "R%m,R%d",
|
|
"W0101010ss1mmmmmiiiiii11111ddddd", "NVM%W", "R%m%s,R%d",
|
|
"W1101010ss0mmmmmiiiiiinnnnn11111", "TST%W", "R%m%s,R%n",
|
|
"W0001010ss0mmmmmiiiiiinnnnnddddd", "AND%W", "R%m%s,R%n,R%d",
|
|
"W1101010ss0mmmmmiiiiiinnnnnddddd", "ANDS%W", "R%m%s,R%n,R%d",
|
|
"W0001010ss1mmmmmiiiiiinnnnnddddd", "BIC%W", "R%m%s,R%n,R%d",
|
|
"W1101010ss1mmmmmiiiiiinnnnnddddd", "BICS%W", "R%m%s,R%n,R%d",
|
|
"W1001010ss0mmmmmiiiiiinnnnnddddd", "EOR%W", "R%m%s,R%n,R%d",
|
|
"W1001010ss1mmmmmiiiiiinnnnnddddd", "EON%W", "R%m%s,R%n,R%d",
|
|
"W0101010ss0mmmmmiiiiiinnnnnddddd", "ORR%W", "R%m%s,R%n,R%d",
|
|
"W0101010ss1mmmmmiiiiiinnnnnddddd", "ORN%W", "R%m%s,R%n,R%d",
|
|
"W0011010110mmmmm001000nnnnnddddd", "LSL%W", "R%m,R%n,R%d",
|
|
"W0011010110mmmmm001001nnnnnddddd", "LSR%W", "R%m,R%n,R%d",
|
|
"W0011010110mmmmm001010nnnnnddddd", "ASR%W", "R%m,R%n,R%d",
|
|
"W0011010110mmmmm001011nnnnnddddd", "ROR%W", "R%m,R%n,R%d",
|
|
"W0011010110mmmmm000010nnnnnddddd", "UDIV%W", "R%m,R%n,R%d",
|
|
"W0011010110mmmmm000011nnnnnddddd", "SDIV%W", "R%m,R%n,R%d",
|
|
"W0011011000mmmmm011111nnnnnddddd", "MUL%W", "R%m,R%n,R%d",
|
|
"W0011011000mmmmm111111nnnnnddddd", "MNEG%W", "R%m,R%n,R%d",
|
|
"W0011011000mmmmm0aaaaannnnnddddd", "MADD%W", "R%m,R%n,R%a,R%d",
|
|
"W0011011000mmmmm1aaaaannnnnddddd", "MSUB%W", "R%m,R%n,R%a,R%d",
|
|
"10011011001mmmmm011111nnnnnddddd", "SMULL", "R%m,R%n,R%d",
|
|
"10011011001mmmmm111111nnnnnddddd", "SMNEGL", "R%m,R%n,R%d",
|
|
"10011011001mmmmm0aaaaannnnnddddd", "SMADDL", "R%m,R%n,R%a,R%d",
|
|
"10011011001mmmmm1aaaaannnnnddddd", "SMSUBL", "R%m,R%n,R%a,R%d",
|
|
"10011011101mmmmm011111nnnnnddddd", "UMULL", "R%m,R%n,R%d",
|
|
"10011011101mmmmm111111nnnnnddddd", "UMNEGL", "R%m,R%n,R%d",
|
|
"10011011101mmmmm0aaaaannnnnddddd", "UMADDL", "R%m,R%n,R%a,R%d",
|
|
"10011011101mmmmm1aaaaannnnnddddd", "UMSUBL", "R%m,R%n,R%a,R%d",
|
|
"W0110100TTTTTTTTTTTTTTTTTTTddddd", "CBZ%W", "R%d,%T",
|
|
"W0110101TTTTTTTTTTTTTTTTTTTddddd", "CBNZ%W", "R%d,%T",
|
|
"01010100TTTTTTTTTTTTTTTTTTT0CCCC", "B%C", "%T",
|
|
"000101TTTTTTTTTTTTTTTTTTTTTTTTTT", "B", "%T",
|
|
"100101TTTTTTTTTTTTTTTTTTTTTTTTTT", "BL", "%T",
|
|
"1101011000011111000000nnnnn00000", "BR", "R%n",
|
|
"1101011000111111000000nnnnn00000", "BLR", "R%n",
|
|
"11010110010111110000001111000000", "RETURN", nil,
|
|
"1101011001011111000000nnnnn00000", "RET", "R%n",
|
|
"11010110100111110000001111100000", "ERET", nil,
|
|
"11010110101111110000001111100000", "DRPS", nil,
|
|
"11010100000iiiiiiiiiiiiiiii00001", "SVC", "$%i",
|
|
"11010100000iiiiiiiiiiiiiiii00010", "HVC", "$%i",
|
|
"11010100000iiiiiiiiiiiiiiii00011", "SMC", "$%i",
|
|
"11010100001iiiiiiiiiiiiiiii00000", "BRK", "$%i",
|
|
"11010100010iiiiiiiiiiiiiiii00000", "HLT", "$%i",
|
|
"11010100101iiiiiiiiiiiiiiii00001", "DCPS1", "$%i",
|
|
"11010100101iiiiiiiiiiiiiiii00010", "DCPS2", "$%i",
|
|
"11010100101iiiiiiiiiiiiiiii00011", "DCPS3", "$%i",
|
|
"11010101000000110010000000011111", "NOP", nil,
|
|
"11010101000000110010000000111111", "YIELD", nil,
|
|
"11010101000000110010000001011111", "WFE", nil,
|
|
"11010101000000110010000001111111", "WFI", nil,
|
|
"11010101000000110010000010011111", "SEV", nil,
|
|
"11010101000000110010000010111111", "SEVL", nil,
|
|
"11010101000000110011xxxx01011111", "CLREX", "$%x",
|
|
"11010101000000110011xxxx10011111", "DSB", "$%x",
|
|
"11010101000000110011xxxx10111111", "DMB", "$%x",
|
|
"11010101000000110011xxxx11011111", "ISB", "$%x",
|
|
"1101010100001YYYYYYYYYYYYYY11111", "SYS", "%Y",
|
|
"1101010100001YYYYYYYYYYYYYYddddd", "SYS", "R%d,%Y",
|
|
"1101010100101YYYYYYYYYYYYYYddddd", "SYSL", "%Y,R%d",
|
|
"11010101000000000100xxxx10111111", "MSR", "$%x,SP",
|
|
"11010101000000110100xxxx11011111", "MSR", "$%x,DAIFSet",
|
|
"11010101000000110100xxxx11111111", "MSR", "$%x,DAIFClr",
|
|
"11010101000YYYYYYYYYYYYYYYYddddd", "MSR", "R%d,%Y",
|
|
"11010101001YYYYYYYYYYYYYYYYddddd", "MRS", "%Y,R%d",
|
|
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "WORD", "$%x",
|
|
};
|
|
|
|
#define SYSARG5(op0,op1,Cn,Cm,op2) ((op0)<<19|(op1)<<16|(Cn)<<12|(Cm)<<8|(op2)<<5)
|
|
|
|
static ulong
|
|
smask(char *s, char c)
|
|
{
|
|
ulong m;
|
|
int i;
|
|
|
|
m = 0;
|
|
for(i=0; i<32 && *s != '\0'; i++, s++)
|
|
m |= (*s == c)<<(31-i);
|
|
return m;
|
|
}
|
|
|
|
static int
|
|
nbits(ulong v)
|
|
{
|
|
int n = 0;
|
|
while(v != 0){
|
|
v &= v-1;
|
|
n++;
|
|
}
|
|
return n;
|
|
}
|
|
|
|
static int
|
|
nones(ulong v)
|
|
{
|
|
int n = 0;
|
|
while(v & 1){
|
|
v >>= 1;
|
|
n++;
|
|
}
|
|
return n;
|
|
}
|
|
|
|
static int
|
|
nshift(ulong m)
|
|
{
|
|
if(m == 0 || m == ~0UL)
|
|
return 0;
|
|
return nones(~m);
|
|
}
|
|
|
|
static ulong
|
|
unshift(ulong w, ulong m)
|
|
{
|
|
int s = nshift(m);
|
|
w >>= s, m >>= s;
|
|
if((m+1 & m) != 0){ // 0bxxx0000yyyyyy -> 0byyyyyyxxx
|
|
ulong b = (1UL<<nones(m))-1;
|
|
return ((w & b) << nbits(m & ~b)) | unshift(w, m & ~b);
|
|
}
|
|
return w & m;
|
|
}
|
|
|
|
static long
|
|
sext(ulong u, int n)
|
|
{
|
|
long l = (long)u;
|
|
if(n > 0){
|
|
l <<= sizeof(l)*8 - n;
|
|
l >>= sizeof(l)*8 - n;
|
|
}
|
|
return l;
|
|
}
|
|
|
|
static char*
|
|
arm64excep(Map *, Rgetter)
|
|
{
|
|
// uvlong c = (*rget)(map, "TYPE");
|
|
return "???";
|
|
}
|
|
|
|
static int
|
|
decode(Map *map, uvlong pc, Instr *i)
|
|
{
|
|
static ulong tab[2*nelem(opcodes)];
|
|
static int once;
|
|
ulong w, j;
|
|
|
|
if(!once){
|
|
Opcode *o;
|
|
|
|
/* precalculate value/mask table */
|
|
for(j=0, o=opcodes; j<nelem(tab); j+=2, o++){
|
|
tab[j] = smask(o->p, '1');
|
|
tab[j|1] = tab[j] | smask(o->p, '0');
|
|
}
|
|
|
|
once = 1;
|
|
}
|
|
|
|
if(get4(map, pc, &w) < 0) {
|
|
werrstr("can't read instruction: %r");
|
|
return -1;
|
|
}
|
|
i->addr = pc;
|
|
i->map = map;
|
|
i->w = w;
|
|
|
|
for(j=0; j<nelem(tab); j+=2){
|
|
if((w & tab[j|1]) == tab[j]){
|
|
i->op = &opcodes[j/2];
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/* should not happen */
|
|
return 0;
|
|
}
|
|
|
|
#pragma varargck argpos bprint 2
|
|
|
|
static void
|
|
bprint(Instr *i, char *fmt, ...)
|
|
{
|
|
va_list arg;
|
|
|
|
va_start(arg, fmt);
|
|
i->curr = vseprint(i->curr, i->end, fmt, arg);
|
|
va_end(arg);
|
|
}
|
|
|
|
static
|
|
char* shtype[4] =
|
|
{
|
|
"<<", ">>", "->", "@>"
|
|
};
|
|
|
|
static
|
|
char* rextype[8] =
|
|
{
|
|
"UB", "UH", "UW", "UX",
|
|
"SB", "SH", "SW", "SX"
|
|
};
|
|
|
|
static
|
|
char* scond[16] =
|
|
{
|
|
"EQ", "NE", "HS", "LO",
|
|
"MI", "PL", "VS", "VC",
|
|
"HI", "LS", "GE", "LT",
|
|
"GT", "LE", "", "NV",
|
|
};
|
|
|
|
static uvlong
|
|
decodebitmask(int n, int s, int r)
|
|
{
|
|
uvlong w;
|
|
int e;
|
|
|
|
if(n)
|
|
n = 6;
|
|
else {
|
|
for(n = 5; n >= 1 && ((~s & 0x3F) & (1<<n)) == 0; n--)
|
|
;
|
|
}
|
|
e = 1 << n;
|
|
s &= e-1;
|
|
r &= e-1;
|
|
|
|
w = 1ULL << s;
|
|
w |= w-1;
|
|
|
|
if(r != 0){
|
|
w = (w >> r) | (w << (e-r));
|
|
if(e < 64)
|
|
w &= (1ULL << e)-1;
|
|
}
|
|
while(e < 64){
|
|
w |= w << e;
|
|
e <<= 1;
|
|
}
|
|
return w;
|
|
}
|
|
|
|
static void
|
|
format(char *mnemonic, Instr *i, char *f)
|
|
{
|
|
Symbol s;
|
|
uvlong v;
|
|
ulong w, u, m;
|
|
|
|
if(mnemonic)
|
|
format(0, i, mnemonic);
|
|
if(f == 0)
|
|
return;
|
|
if(mnemonic)
|
|
if(i->curr < i->end)
|
|
*i->curr++ = '\t';
|
|
for ( ; *f && i->curr < i->end; f++) {
|
|
if(*f != '%') {
|
|
*i->curr++ = *f;
|
|
continue;
|
|
}
|
|
m = smask(i->op->p, *++f);
|
|
u = unshift(i->w, m);
|
|
switch (*f) {
|
|
case 'C': // Condition
|
|
bprint(i, "%s", scond[u & 15]);
|
|
break;
|
|
|
|
case 'W': // Width
|
|
if(nbits(m) == 1) u += 2;
|
|
u &= 3;
|
|
if(u < 3)
|
|
*i->curr++ = "BHW"[u];
|
|
break;
|
|
|
|
case 'd': // Register Numbers
|
|
case 'n':
|
|
case 'a':
|
|
case 'm':
|
|
bprint(i, "%lud", u);
|
|
break;
|
|
|
|
case 's': // Register shift
|
|
w = unshift(i->w, smask(i->op->p, 'i'));
|
|
if(w != 0)
|
|
bprint(i, "%s%lud", shtype[u & 3], w);
|
|
break;
|
|
|
|
case 'e': // Register extension
|
|
u &= 7;
|
|
bprint(i, ".%s", rextype[u]);
|
|
w = unshift(i->w, smask(i->op->p, 'i'));
|
|
if(w != 0 && u == 2+(i->w>>31))
|
|
bprint(i, "<<%lud", w);
|
|
break;
|
|
|
|
case 'M': // Bitmask
|
|
v = decodebitmask((u>>12)&1, u&0x3F, (u>>6)&0x3F);
|
|
if((i->w & (1<<31)) == 0)
|
|
v &= 0xFFFFFFFF;
|
|
bprint(i, "%llux", v);
|
|
break;
|
|
|
|
case 'I': // Shifted Immediate (12 bit)
|
|
case 'K': // Shifted Immediate (16 bit)
|
|
w = unshift(i->w, smask(i->op->p, 's'));
|
|
if(u != 0 && w != 0)
|
|
bprint(i, "(%lux<<%ld)", u, w*(*f == 'I' ? 12 : 16));
|
|
else
|
|
bprint(i, "%lud", u);
|
|
break;
|
|
|
|
case 'o': // Signed byte offset
|
|
w = nbits(m);
|
|
bprint(i, "%ld", sext(u, w) << (w == 7 ? 2 + (i->w>>31) : 0));
|
|
break;
|
|
case 'u': // Unsigned offset
|
|
u <<= (i->w >> 30)&3;
|
|
/* wet floor */
|
|
case 'i': // Decimal
|
|
case 'j':
|
|
bprint(i, "%lud", u);
|
|
break;
|
|
|
|
case 'x': // Hex
|
|
bprint(i, "%lux", u);
|
|
break;
|
|
|
|
case 'l': // 32-bit Literal
|
|
if(get4(i->map, i->addr + sext(u, nbits(m))*4, &w) < 0)
|
|
goto Ptext;
|
|
bprint(i, "$%lux", w);
|
|
break;
|
|
case 'L': // 64-bit Literal
|
|
if(get8(i->map, i->addr + sext(u, nbits(m))*4, &v) < 0)
|
|
goto Ptext;
|
|
bprint(i, "$%llux", v);
|
|
break;
|
|
case 'T': // Text address (PC relative)
|
|
Ptext:
|
|
v = i->addr + sext(u, nbits(m))*4;
|
|
if(findsym(v, CTEXT, &s)){
|
|
bprint(i, "%s", s.name);
|
|
if(v < s.value)
|
|
bprint(i, "%llx", v - s.value);
|
|
else if(v > s.value)
|
|
bprint(i, "+%llx", v - s.value);
|
|
bprint(i, "(SB)");
|
|
break;
|
|
}
|
|
bprint(i, "%llux(SB)", v);
|
|
break;
|
|
case 'A': // Data address (PC relative)
|
|
v = i->addr + sext(u, nbits(m));
|
|
goto Pdata;
|
|
case 'P': // Page address (PC relative)
|
|
v = i->addr + ((vlong)sext(u, nbits(m)) << 12);
|
|
Pdata:
|
|
if(findsym(v, CANY, &s)){
|
|
bprint(i, "%s", s.name);
|
|
if(v < s.value)
|
|
bprint(i, "%llx", v - s.value);
|
|
else if(v > s.value)
|
|
bprint(i, "+%llx", v - s.value);
|
|
bprint(i, "(SB)");
|
|
break;
|
|
}
|
|
bprint(i, "%llux(SB)", v);
|
|
break;
|
|
|
|
case 'Y':
|
|
if(nbits(m) == 14){ // SYS/SYSL operands
|
|
bprint(i, "%lud,%lud,%lud,%lud",
|
|
(u>>(4+4+3))&7, // op1
|
|
(u>>(4+3))&15, // CRn
|
|
(u>>3)&15, // CRm
|
|
(u)&7); // op2
|
|
break;
|
|
}
|
|
/* see /sys/src/cmd/7c/7.out.h */
|
|
switch(i->w & m){
|
|
case SYSARG5(3,3,4,2,1): bprint(i, "DAIF"); break;
|
|
case SYSARG5(3,3,4,2,0): bprint(i, "NZCV"); break;
|
|
case SYSARG5(3,3,4,4,1): bprint(i, "FPSR"); break;
|
|
case SYSARG5(3,3,4,4,0): bprint(i, "FPCR"); break;
|
|
case SYSARG5(3,0,4,0,0): bprint(i, "SPSR_EL1"); break;
|
|
case SYSARG5(3,0,4,0,1): bprint(i, "ELR_EL1"); break;
|
|
case SYSARG5(3,4,4,0,0): bprint(i, "SPSR_EL2"); break;
|
|
case SYSARG5(3,4,4,0,1): bprint(i, "ELR_EL2"); break;
|
|
case SYSARG5(3,0,4,2,2): bprint(i, "CurrentEL"); break;
|
|
case SYSARG5(3,0,4,1,0): bprint(i, "SP_EL0"); break;
|
|
case SYSARG5(3,0,4,2,0): bprint(i, "SPSel"); break;
|
|
default: bprint(i, "SPR(%lux)", i->w & m);
|
|
}
|
|
break;
|
|
|
|
case '\0':
|
|
*i->curr++ = '%';
|
|
return;
|
|
|
|
default:
|
|
bprint(i, "%%%c", *f);
|
|
break;
|
|
}
|
|
}
|
|
*i->curr = 0;
|
|
}
|
|
|
|
static int
|
|
printins(Map *map, uvlong pc, char *buf, int n)
|
|
{
|
|
Instr i[1];
|
|
|
|
i->curr = buf;
|
|
i->end = buf+n-1;
|
|
if(decode(map, pc, i) < 0)
|
|
return -1;
|
|
format(i->op->o, i, i->op->a);
|
|
return 4;
|
|
}
|
|
|
|
static int
|
|
arm64inst(Map *map, uvlong pc, char modifier, char *buf, int n)
|
|
{
|
|
USED(modifier);
|
|
return printins(map, pc, buf, n);
|
|
}
|
|
|
|
static int
|
|
arm64das(Map *map, uvlong pc, char *buf, int n)
|
|
{
|
|
Instr i[1];
|
|
|
|
i->curr = buf;
|
|
i->end = buf+n;
|
|
if(decode(map, pc, i) < 0)
|
|
return -1;
|
|
if(i->end-i->curr > 8)
|
|
i->curr = _hexify(buf, i->w, 7);
|
|
*i->curr = 0;
|
|
return 4;
|
|
}
|
|
|
|
static int
|
|
arm64instlen(Map*, uvlong)
|
|
{
|
|
return 4;
|
|
}
|
|
|
|
static uvlong
|
|
readreg(Instr *i, Rgetter rget, int rc)
|
|
{
|
|
ulong m;
|
|
uvlong v;
|
|
char reg[4];
|
|
snprint(reg, sizeof(reg), "R%lud", unshift(i->w, smask(i->op->p, rc)));
|
|
v = (*rget)(i->map, reg);
|
|
m = smask(i->op->p, 'W');
|
|
if(m != 0 && unshift(i->w, m) == 0)
|
|
v &= 0xFFFFFFFFULL;
|
|
return v;
|
|
}
|
|
|
|
static int
|
|
passcond(Instr *i, Rgetter rget)
|
|
{
|
|
uvlong psr;
|
|
uchar n;
|
|
uchar z;
|
|
uchar c;
|
|
uchar v;
|
|
|
|
psr = (*rget)(i->map, "PSR");
|
|
n = (psr >> 31) & 1;
|
|
z = (psr >> 30) & 1;
|
|
c = (psr >> 29) & 1;
|
|
v = (psr >> 28) & 1;
|
|
|
|
switch(unshift(i->w, smask(i->op->p, 'C'))) {
|
|
default:
|
|
case 0: return z;
|
|
case 1: return !z;
|
|
case 2: return c;
|
|
case 3: return !c;
|
|
case 4: return n;
|
|
case 5: return !n;
|
|
case 6: return v;
|
|
case 7: return !v;
|
|
case 8: return c && !z;
|
|
case 9: return !c || z;
|
|
case 10: return n == v;
|
|
case 11: return n != v;
|
|
case 12: return !z && (n == v);
|
|
case 13: return z || (n != v);
|
|
case 14: return 1;
|
|
case 15: return 0;
|
|
}
|
|
}
|
|
|
|
static uvlong
|
|
jumptarg(Instr *i)
|
|
{
|
|
ulong m = smask(i->op->p, 'T');
|
|
return i->addr + sext(unshift(i->w, m), m)*4;
|
|
}
|
|
|
|
static int
|
|
arm64foll(Map *map, uvlong pc, Rgetter rget, uvlong *foll)
|
|
{
|
|
Instr i[1];
|
|
char *o;
|
|
|
|
if(decode(map, pc, i) < 0)
|
|
return -1;
|
|
|
|
o = i->op->o;
|
|
if(strcmp(o, "ERET") == 0)
|
|
return -1;
|
|
|
|
if(strcmp(o, "RET") == 0 || strcmp(o, "BR") == 0 || strcmp(o, "BLR") == 0){
|
|
foll[0] = readreg(i, rget, 'n');
|
|
return 1;
|
|
}
|
|
if(strcmp(o, "B") == 0 || strcmp(o, "BL") == 0){
|
|
foll[0] = jumptarg(i);
|
|
return 1;
|
|
}
|
|
if(strcmp(o, "B%C") == 0){
|
|
if(passcond(i, rget)){
|
|
foll[0] = jumptarg(i);
|
|
return 1;
|
|
}
|
|
}
|
|
if(strcmp(o, "CBZ%W") == 0){
|
|
if(readreg(i, rget, 'd') == 0){
|
|
foll[0] = jumptarg(i);
|
|
return 1;
|
|
}
|
|
}
|
|
if(strcmp(o, "CBNZ%W") == 0){
|
|
if(readreg(i, rget, 'd') != 0){
|
|
foll[0] = jumptarg(i);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
foll[0] = i->addr+4;
|
|
return 1;
|
|
}
|