170 lines
9.2 KiB
C
170 lines
9.2 KiB
C
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include "decode.h"
|
|
#include "emulator.h"
|
|
|
|
// Retrieve the bits between positions 'lsb' (inclusive) and 'msb' (exclusive) from a given word
|
|
// as a new zero-extended word.
|
|
static word getBits(word wrd, uint8_t lsb, uint8_t msb) {
|
|
|
|
// Ensure LSB and MSB are within range of word size, and in the correct order
|
|
assert(lsb < msb && msb <= WORD_BITS);
|
|
|
|
wrd &= ((dword) 1 << msb) - 1;
|
|
return wrd >> lsb;
|
|
}
|
|
|
|
// Given a binary word, return its internal representation as an a64instruction struct encoding the same
|
|
// information.
|
|
a64inst_instruction *decode(word wrd) {
|
|
|
|
a64inst_instruction *inst = malloc(sizeof(a64inst_instruction));
|
|
if (inst == NULL) {
|
|
fprintf(stderr, "Ran out of memory while attempting to decode an instruction!\n");
|
|
exit(1);
|
|
}
|
|
|
|
word typeId = getBits(wrd, TYPE_ID_LSB, TYPE_ID_MSB);
|
|
// Halt interpretation
|
|
if (wrd == HALT_WORD) {
|
|
inst->type = a64inst_HALT;
|
|
|
|
// Data Processing Immediate interpretation
|
|
} else if (typeId == DP_IMM_ID) {
|
|
inst->type = a64inst_DPIMMEDIATE;
|
|
inst->data.DPImmediateData.regType = getBits(wrd, DP_WIDTH_LSB, DP_WIDTH_MSB);
|
|
inst->data.DPImmediateData.processOp = getBits(wrd, DP_OP_LSB, DP_OP_MSB);
|
|
inst->data.DPImmediateData.dest = getBits(wrd, DP_DEST_LSB, DP_DEST_MSB);
|
|
|
|
switch(getBits(wrd, DP_IMM_OPTYPE_LSB, DP_IMM_OPTYPE_MSB)) {
|
|
|
|
case DP_IMM_OPTYPE_ARITHM:
|
|
inst->data.DPImmediateData.DPIOpType = a64inst_DPI_ARITHM;
|
|
inst->data.DPImmediateData.processOpData.arithmData.shiftImmediate = getBits(wrd, DP_IMM_ARITHM_SHIFTFLAG_LSB, DP_IMM_ARITHM_SHIFTFLAG_MSB);
|
|
inst->data.DPImmediateData.processOpData.arithmData.immediate = getBits(wrd, DP_IMM_ARITHM_IMMVAL_LSB, DP_IMM_ARITHM_IMMVAL_MSB);
|
|
inst->data.DPImmediateData.processOpData.arithmData.src = getBits(wrd, DP_IMM_ARITHM_DEST_LSB, DP_IMM_ARITHM_DEST_MSB);
|
|
break;
|
|
|
|
case DP_IMM_OPTYPE_WIDEMOV:
|
|
inst->data.DPImmediateData.DPIOpType = a64inst_DPI_WIDEMOV;
|
|
inst->data.DPImmediateData.processOpData.wideMovData.shiftScalar = getBits(wrd, DP_IMM_WIDEMOV_SHIFTSCALAR_LSB, DP_IMM_WIDEMOV_SHIFTSCALAR_MSB);
|
|
inst->data.DPImmediateData.processOpData.wideMovData.immediate = getBits(wrd, DP_IMM_WIDEMOV_IMMVAL_LSB, DP_IMM_WIDEMOV_IMMVAL_MSB);
|
|
break;
|
|
|
|
default:
|
|
fprintf(stderr, "Unknown immediate data processing operation type found!\n");
|
|
exit(1);
|
|
break;
|
|
}
|
|
|
|
} else if (typeId == BRANCH_ID) {
|
|
inst->type = a64inst_BRANCH;
|
|
word branchTypeFlag = getBits(wrd, BRANCH_TYPE_LSB, BRANCH_TYPE_MSB);
|
|
|
|
inst->data.BranchData.BranchType = branchTypeFlag;
|
|
|
|
switch (branchTypeFlag) {
|
|
case a64inst_UNCONDITIONAL:
|
|
inst->data.BranchData.processOpData.unconditionalData.unconditionalOffset = getBits(wrd, BRANCH_UNCONDITIONAL_OFFSET_LSB, BRANCH_UNCONDITIONAL_OFFSET_MSB);
|
|
break;
|
|
|
|
case a64inst_CONDITIONAL:
|
|
inst->data.BranchData.processOpData.conditionalData.offset = getBits(wrd, BRANCH_CONDITIONAL_OFFSET_LSB, BRANCH_CONDITIONAL_OFFSET_MSB);
|
|
|
|
word conditionFlag = getBits(wrd, BRANCH_CONDITIONAL_COND_LSB, BRANCH_CONDITIONAL_COND_MSB);
|
|
|
|
if(conditionFlag <= 1 || (conditionFlag >= 10 && conditionFlag <= 14)) {
|
|
inst->data.BranchData.processOpData.conditionalData.cond = conditionFlag;
|
|
} else {
|
|
fprintf(stderr, "Unknown condition detected!\n");
|
|
exit(1);
|
|
}
|
|
|
|
break;
|
|
|
|
case a64inst_REGISTER:
|
|
inst->data.BranchData.processOpData.registerData.src = getBits(wrd, BRANCH_REGISTER_SRC_LSB, BRANCH_REGISTER_SRC_MSB);
|
|
break;
|
|
|
|
default:
|
|
fprintf(stderr, "Undefined branch type detected!\n");
|
|
exit(1);
|
|
break;
|
|
}
|
|
|
|
// TODO: Some minor code duplication between DPR and DPI data interpretation
|
|
// Data Processing Register interpretation
|
|
} else if (getBits(wrd, DP_REG_LSB, DP_REG_MSB) == 1) {
|
|
inst->type = a64inst_DPREGISTER;
|
|
inst->data.DPRegisterData.regType = getBits(wrd, DP_WIDTH_LSB, DP_WIDTH_MSB);
|
|
inst->data.DPRegisterData.processOp = getBits(wrd, DP_OP_LSB, DP_OP_MSB);
|
|
inst->data.DPRegisterData.dest = getBits(wrd, DP_DEST_LSB, DP_DEST_MSB);
|
|
inst->data.DPRegisterData.src1 = getBits(wrd, DP_REG_SRC1_LSB, DP_REG_SRC1_MSB);
|
|
inst->data.DPRegisterData.src2 = getBits(wrd, DP_REG_SRC2_LSB, DP_REG_SRC2_MSB);
|
|
inst->data.DPRegisterData.DPROpType = getBits(wrd, DP_REG_OPTYPE_LSB, DP_REG_OPTYPE_MSB);
|
|
|
|
a64inst_DPRegister_ArithmLogicData *arithmLogicData = &inst->data.DPRegisterData.processOpData.arithmLogicData;
|
|
|
|
arithmLogicData->type = getBits(wrd, DP_REG_ARITHMLOGIC_ARITHMFLAG_LSB, DP_REG_ARITHMLOGIC_ARITHMFLAG_MSB);
|
|
arithmLogicData->shiftType = getBits(wrd, DP_REG_ARITHMLOGIC_SHIFTTYPE_LSB, DP_REG_ARITHMLOGIC_SHIFTTYPE_MSB);
|
|
arithmLogicData->negShiftedSrc2 = getBits(wrd, DP_REG_ARITHMLOGIC_NEGSRC2FLAG_LSB, DP_REG_ARITHMLOGIC_NEGSRC2FLAG_MSB);
|
|
|
|
switch(inst->data.DPRegisterData.DPROpType) {
|
|
|
|
case a64inst_DPR_ARITHMLOGIC:
|
|
if (arithmLogicData->type == a64inst_DPR_ARITHM && (arithmLogicData->negShiftedSrc2 || arithmLogicData->shiftType == a64inst_ROR)) {
|
|
fprintf(stderr, "Attempting to decode arithmetic DPR instruction with invalid format!\n");
|
|
}
|
|
arithmLogicData->shiftAmount = getBits(wrd, DP_REG_ARITHMLOGIC_SHIFTAMOUNT_LSB, DP_REG_ARITHMLOGIC_SHIFTAMOUNT_MSB);
|
|
break;
|
|
|
|
case a64inst_DPR_MULTIPLY:;
|
|
if (!(inst->data.DPRegisterData.processOp == DP_REG_MULTIPLY_PROCESSOP &&
|
|
arithmLogicData->type == DP_REG_MULTIPLY_ARITHMFLAG &&
|
|
arithmLogicData->shiftType == DP_REG_MULTIPLY_SHIFTTYPE &&
|
|
arithmLogicData->negShiftedSrc2 == DP_REG_MULTIPLY_NEGSRC2FLAG)) {
|
|
fprintf(stderr, "Attempting to decode multiply DPR instruction with invalid format!\n");
|
|
}
|
|
inst->data.DPRegisterData.processOpData.multiplydata.summand = getBits(wrd, DP_REG_MULTIPLY_SUMMAND_LSB, DP_REG_MULTIPLY_SUMMAND_MSB);
|
|
inst->data.DPRegisterData.processOpData.multiplydata.negProd = getBits(wrd, DP_REG_MULTIPLY_NEGPROD_LSB, DP_REG_MULTIPLY_NEGPROD_MSB);
|
|
break;
|
|
}
|
|
|
|
} else {
|
|
// Load and Store, or unknown
|
|
// Ignore unknown for now
|
|
inst->type = a64inst_SINGLETRANSFER;
|
|
inst->data.SingleTransferData.regType = getBits(wrd, SDT_REGTYPE_FLAG_LSB, SDT_REGTYPE_FLAG_MSB);
|
|
inst->data.SingleTransferData.target = getBits(wrd, SDT_TARGET_REG_LSB, SDT_TARGET_REG_MSB);
|
|
|
|
// TODO: Assert that the instruction is a Single Transfer indeed.
|
|
|
|
if(getBits(wrd, SDT_OPTYPE_FLAG_LSB, SDT_OPTYPE_FLAG_MSB) == a64inst_SINGLE_TRANSFER_SINGLE_DATA_TRANSFER) {
|
|
// Single Data Transfer
|
|
inst->data.SingleTransferData.SingleTransferOpType = a64inst_SINGLE_TRANSFER_SINGLE_DATA_TRANSFER;
|
|
inst->data.SingleTransferData.processOpData.singleDataTransferData.transferType = getBits(wrd, SDT_TRANSFER_TYPE_LSB, SDT_TRANSFER_TYPE_MSB);
|
|
inst->data.SingleTransferData.processOpData.singleDataTransferData.base = getBits(wrd, SDT_BASE_REG_LSB, SDT_BASE_REG_MSB);
|
|
if (getBits(wrd, SDT_UNSIGNED_FLAG_LSB, SDT_UNSIGNED_FLAG_MSB) == 1) {
|
|
// Unsigned offset
|
|
inst->data.SingleTransferData.processOpData.singleDataTransferData.addressingMode = a64inst_UNSIGNED_OFFSET;
|
|
inst->data.SingleTransferData.processOpData.singleDataTransferData.a64inst_addressingModeData.unsignedOffset = getBits(wrd, SDT_OFFSET_LSB, SDT_OFFSET_MSB);
|
|
} else if (getBits(wrd, SDT_REGISTER_FLAG_LSB, SDT_REGISTER_FLAG_MSB) == 1) {
|
|
// Register Offset
|
|
inst->data.SingleTransferData.processOpData.singleDataTransferData.addressingMode = a64inst_REGISTER_OFFSET;
|
|
inst->data.SingleTransferData.processOpData.singleDataTransferData.a64inst_addressingModeData.offsetReg = getBits(wrd, SDT_REGISTER_REG_LSB, SDT_REGISTER_REG_MSB);
|
|
} else {
|
|
// Pre-Indexed or Post-Indexed
|
|
inst->data.SingleTransferData.processOpData.singleDataTransferData.addressingMode = getBits(wrd, SDT_INDEXED_ADDRMODE_LSB, SDT_INDEXED_ADDRMODE_MSB);
|
|
inst->data.SingleTransferData.processOpData.singleDataTransferData.a64inst_addressingModeData.indexedOffset = getBits(wrd, SDT_INDEXED_OFFSET_LSB, SDT_INDEXED_OFFSET_MSB);
|
|
}
|
|
} else {
|
|
// Load Literal
|
|
inst->data.SingleTransferData.SingleTransferOpType = a64inst_SINGLE_TRANSFER_LOAD_LITERAL;
|
|
inst->data.SingleTransferData.processOpData.loadLiteralData.offset = getBits(wrd, SDT_LOAD_LITERAL_OFFSET_LSB, SDT_LOAD_LITERAL_OFFSET_MSB);
|
|
}
|
|
}
|
|
|
|
return inst;
|
|
}
|