You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
218 lines
6.8 KiB
218 lines
6.8 KiB
/*
|
|
* Copyright 2016, The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
|
|
#include "apf.h"
|
|
|
|
// If "c" is of a signed type, generate a compile warning that gets promoted to an error.
|
|
// This makes bounds checking simpler because ">= 0" can be avoided. Otherwise adding
|
|
// superfluous ">= 0" with unsigned expressions generates compile warnings.
|
|
#define ENFORCE_UNSIGNED(c) ((c)==(uint32_t)(c))
|
|
|
|
static void print_opcode(const char* opcode) {
|
|
printf("%-6s", opcode);
|
|
}
|
|
|
|
// Mapping from opcode number to opcode name.
|
|
static const char* opcode_names [] = {
|
|
[LDB_OPCODE] = "ldb",
|
|
[LDH_OPCODE] = "ldh",
|
|
[LDW_OPCODE] = "ldw",
|
|
[LDBX_OPCODE] = "ldbx",
|
|
[LDHX_OPCODE] = "ldhx",
|
|
[LDWX_OPCODE] = "ldwx",
|
|
[ADD_OPCODE] = "add",
|
|
[MUL_OPCODE] = "mul",
|
|
[DIV_OPCODE] = "div",
|
|
[AND_OPCODE] = "and",
|
|
[OR_OPCODE] = "or",
|
|
[SH_OPCODE] = "sh",
|
|
[LI_OPCODE] = "li",
|
|
[JMP_OPCODE] = "jmp",
|
|
[JEQ_OPCODE] = "jeq",
|
|
[JNE_OPCODE] = "jne",
|
|
[JGT_OPCODE] = "jgt",
|
|
[JLT_OPCODE] = "jlt",
|
|
[JSET_OPCODE] = "jset",
|
|
[JNEBS_OPCODE] = "jnebs",
|
|
[LDDW_OPCODE] = "lddw",
|
|
[STDW_OPCODE] = "stdw",
|
|
};
|
|
|
|
static void print_jump_target(uint32_t target, uint32_t program_len) {
|
|
if (target == program_len) {
|
|
printf("PASS");
|
|
} else if (target == program_len + 1) {
|
|
printf("DROP");
|
|
} else {
|
|
printf("%u", target);
|
|
}
|
|
}
|
|
|
|
uint32_t apf_disassemble(const uint8_t* program, uint32_t program_len, uint32_t pc) {
|
|
printf("%8u: ", pc);
|
|
|
|
if (pc == program_len) {
|
|
printf("PASS\n");
|
|
return ++pc;
|
|
}
|
|
|
|
if (pc == program_len + 1) {
|
|
printf("DROP\n");
|
|
return ++pc;
|
|
}
|
|
|
|
const uint8_t bytecode = program[pc++];
|
|
const uint32_t opcode = EXTRACT_OPCODE(bytecode);
|
|
#define PRINT_OPCODE() print_opcode(opcode_names[opcode])
|
|
const uint32_t reg_num = EXTRACT_REGISTER(bytecode);
|
|
// All instructions have immediate fields, so load them now.
|
|
const uint32_t len_field = EXTRACT_IMM_LENGTH(bytecode);
|
|
uint32_t imm = 0;
|
|
int32_t signed_imm = 0;
|
|
if (len_field != 0) {
|
|
const uint32_t imm_len = 1 << (len_field - 1);
|
|
for (uint32_t i = 0; i < imm_len && pc < program_len; i++)
|
|
imm = (imm << 8) | program[pc++];
|
|
// Sign extend imm into signed_imm.
|
|
signed_imm = imm << ((4 - imm_len) * 8);
|
|
signed_imm >>= (4 - imm_len) * 8;
|
|
}
|
|
switch (opcode) {
|
|
case LDB_OPCODE:
|
|
case LDH_OPCODE:
|
|
case LDW_OPCODE:
|
|
PRINT_OPCODE();
|
|
printf("r%d, [%u]", reg_num, imm);
|
|
break;
|
|
case LDBX_OPCODE:
|
|
case LDHX_OPCODE:
|
|
case LDWX_OPCODE:
|
|
PRINT_OPCODE();
|
|
printf("r%d, [r1+%u]", reg_num, imm);
|
|
break;
|
|
case JMP_OPCODE:
|
|
PRINT_OPCODE();
|
|
print_jump_target(pc + imm, program_len);
|
|
break;
|
|
case JEQ_OPCODE:
|
|
case JNE_OPCODE:
|
|
case JGT_OPCODE:
|
|
case JLT_OPCODE:
|
|
case JSET_OPCODE:
|
|
case JNEBS_OPCODE: {
|
|
PRINT_OPCODE();
|
|
printf("r0, ");
|
|
// Load second immediate field.
|
|
uint32_t cmp_imm = 0;
|
|
if (reg_num == 1) {
|
|
printf("r1, ");
|
|
} else if (len_field == 0) {
|
|
printf("0, ");
|
|
} else {
|
|
uint32_t cmp_imm_len = 1 << (len_field - 1);
|
|
uint32_t i;
|
|
for (i = 0; i < cmp_imm_len && pc < program_len; i++)
|
|
cmp_imm = (cmp_imm << 8) | program[pc++];
|
|
printf("0x%x, ", cmp_imm);
|
|
}
|
|
if (opcode == JNEBS_OPCODE) {
|
|
print_jump_target(pc + imm + cmp_imm, program_len);
|
|
printf(", ");
|
|
while (cmp_imm--)
|
|
printf("%02x", program[pc++]);
|
|
} else {
|
|
print_jump_target(pc + imm, program_len);
|
|
}
|
|
break;
|
|
}
|
|
case ADD_OPCODE:
|
|
case SH_OPCODE:
|
|
PRINT_OPCODE();
|
|
if (reg_num) {
|
|
printf("r0, r1");
|
|
} else {
|
|
printf("r0, %d", signed_imm);
|
|
}
|
|
break;
|
|
case MUL_OPCODE:
|
|
case DIV_OPCODE:
|
|
case AND_OPCODE:
|
|
case OR_OPCODE:
|
|
PRINT_OPCODE();
|
|
if (reg_num) {
|
|
printf("r0, r1");
|
|
} else {
|
|
printf("r0, %u", imm);
|
|
}
|
|
break;
|
|
case LI_OPCODE:
|
|
PRINT_OPCODE();
|
|
printf("r%d, %d", reg_num, signed_imm);
|
|
break;
|
|
case EXT_OPCODE:
|
|
if (
|
|
// If LDM_EXT_OPCODE is 0 and imm is compared with it, a compiler error will result,
|
|
// instead just enforce that imm is unsigned (so it's always greater or equal to 0).
|
|
#if LDM_EXT_OPCODE == 0
|
|
ENFORCE_UNSIGNED(imm) &&
|
|
#else
|
|
imm >= LDM_EXT_OPCODE &&
|
|
#endif
|
|
imm < (LDM_EXT_OPCODE + MEMORY_ITEMS)) {
|
|
print_opcode("ldm");
|
|
printf("r%d, m[%u]", reg_num, imm - LDM_EXT_OPCODE);
|
|
} else if (imm >= STM_EXT_OPCODE && imm < (STM_EXT_OPCODE + MEMORY_ITEMS)) {
|
|
print_opcode("stm");
|
|
printf("r%d, m[%u]", reg_num, imm - STM_EXT_OPCODE);
|
|
} else switch (imm) {
|
|
case NOT_EXT_OPCODE:
|
|
print_opcode("not");
|
|
printf("r%d", reg_num);
|
|
break;
|
|
case NEG_EXT_OPCODE:
|
|
print_opcode("neg");
|
|
printf("r%d", reg_num);
|
|
break;
|
|
case SWAP_EXT_OPCODE:
|
|
print_opcode("swap");
|
|
break;
|
|
case MOV_EXT_OPCODE:
|
|
print_opcode("mov");
|
|
printf("r%d, r%d", reg_num, reg_num ^ 1);
|
|
break;
|
|
default:
|
|
printf("unknown_ext %u", imm);
|
|
break;
|
|
}
|
|
break;
|
|
case LDDW_OPCODE:
|
|
case STDW_OPCODE:
|
|
PRINT_OPCODE();
|
|
printf("r%u, [r%u+%d]", reg_num, reg_num ^ 1, signed_imm);
|
|
break;
|
|
|
|
// Unknown opcode
|
|
default:
|
|
printf("unknown %u", opcode);
|
|
break;
|
|
}
|
|
printf("\n");
|
|
return pc;
|
|
}
|