56 uint64_t old_pc, low_pc = ((size_t)
ic - (
size_t)
57 cpu->
cd.
alpha.cur_ic_page) /
sizeof(
struct alpha_instr_call);
68 }
else if (
cpu->
pc != old_pc) {
72 alpha_pc_to_pointers(
cpu);
85 uint64_t old_pc =
cpu->
pc, low_pc;
90 low_pc = ((size_t)
ic - (
size_t)
91 cpu->
cd.
alpha.cur_ic_page) /
sizeof(
struct alpha_instr_call);
96 *((int64_t *)
ic->arg[0]) =
cpu->
pc;
97 cpu->
pc = *((int64_t *)
ic->arg[1]);
103 if ((old_pc & ~mask_within_page) == (
cpu->
pc & ~mask_within_page)) {
105 ((
cpu->
pc & mask_within_page) >> 2);
108 alpha_pc_to_pointers(
cpu);
133 uint64_t old_pc =
cpu->
pc;
138 cpu->
pc = *((int64_t *)
ic->arg[1]);
144 if ((old_pc & ~mask_within_page) == (
cpu->
pc & ~mask_within_page)) {
146 ((
cpu->
pc & mask_within_page) >> 2);
149 alpha_pc_to_pointers(
cpu);
176 low_pc = ((size_t)
ic - (
size_t)
177 cpu->
cd.
alpha.cur_ic_page) /
sizeof(
struct alpha_instr_call);
181 cpu->
pc += (int32_t)
ic->arg[0];
184 alpha_pc_to_pointers(
cpu);
199 low_pc = ((size_t)
ic - (
size_t)
200 cpu->
cd.
alpha.cur_ic_page) /
sizeof(
struct alpha_instr_call);
206 *((int64_t *)
ic->arg[1]) =
cpu->
pc + 4;
208 cpu->
pc += (int32_t)
ic->arg[0];
211 alpha_pc_to_pointers(
cpu);
223 if (*((int64_t *)
ic->arg[1]) == 0)
236 if (*((int64_t *)
ic->arg[1]) & 1)
249 if (!(*((int64_t *)
ic->arg[1]) & 1))
262 if (*((int64_t *)
ic->arg[1]) != 0)
275 if (*((int64_t *)
ic->arg[1]) <= 0)
288 if (*((int64_t *)
ic->arg[1]) < 0)
301 if (*((int64_t *)
ic->arg[1]) >= 0)
314 if (*((int64_t *)
ic->arg[1]) > 0)
326 cpu->
cd.
alpha.next_ic = (
struct alpha_instr_call *)
ic->arg[0];
337 X(br_return_samepage)
341 low_pc = ((size_t)
ic - (
size_t)
342 cpu->
cd.
alpha.cur_ic_page) /
sizeof(
struct alpha_instr_call);
346 *((int64_t *)
ic->arg[1]) =
cpu->
pc + 4;
348 cpu->
cd.
alpha.next_ic = (
struct alpha_instr_call *)
ic->arg[0];
360 if (*((int64_t *)
ic->arg[1]) == 0)
373 if (*((int64_t *)
ic->arg[1]) & 1)
386 if (!(*((int64_t *)
ic->arg[1]) & 1))
399 if (*((int64_t *)
ic->arg[1]) != 0)
412 if (*((int64_t *)
ic->arg[1]) <= 0)
425 if (*((int64_t *)
ic->arg[1]) < 0)
439 if (*((int64_t *)
ic->arg[1]) >= 0)
452 if (*((int64_t *)
ic->arg[1]) > 0)
492 reg(
ic->arg[0]) =
reg(
ic->arg[2]) & 0x7fffffffffffffffULL;
496 reg(
ic->arg[0]) =
reg(
ic->arg[2]) ^ 0x8000000000000000ULL;
552 if (fa.
nan | fb.
nan || fb.
f == 0)
569 reg(
ic->arg[0]) = res;
581 reg(
ic->arg[0]) = res;
593 reg(
ic->arg[0]) = res;
617 int32_t a =
reg(
ic->arg[1]);
618 int32_t b =
reg(
ic->arg[2]);
619 reg(
ic->arg[0]) = (int64_t)(int32_t)(a * b);
623 int32_t a =
reg(
ic->arg[1]);
624 int32_t b =
ic->arg[2];
625 reg(
ic->arg[0]) = (int64_t)(int32_t)(a * b);
655 uint64_t reshi = 0, reslo = 0;
656 uint64_t s1 =
reg(
ic->arg[1]), s2 =
reg(
ic->arg[2]);
659 for (i=0; i<64; i++) {
660 bit = (s1 & 0x8000000000000000ULL)? 1 : 0;
665 uint64_t old_reslo = reslo;
667 if (reslo < old_reslo)
673 reshi += (reslo & 0x8000000000000000ULL? 1 : 0);
678 reg(
ic->arg[0]) = reshi;
691 reg(
ic->arg[0]) =
reg(
ic->arg[1]) + (int64_t)(int32_t)
ic->arg[2];
704 reg(
ic->arg[0]) = (int64_t)(int32_t)
ic->arg[2];
748 alpha_pc_to_pointers(
cpu);
768 uint64_t
addr, low_pc;
772 void (*samepage_function)(
struct cpu *,
struct alpha_instr_call *);
773 int opcode, ra, rb, func, rc, imm,
load, loadstore_type, fp, llsc;
776 low_pc = ((size_t)
ic - (
size_t)
cpu->
cd.
alpha.cur_ic_page)
777 /
sizeof(
struct alpha_instr_call);
795 page = l3->host_load[x3];
800 memcpy(ib, page + (addr & 8191),
sizeof(ib));
805 fatal(
"to_be_translated(): read failed: TODO\n");
813 uint32_t *p = (uint32_t *) ib;
817 #define DYNTRANS_TO_BE_TRANSLATED_HEAD 819 #undef DYNTRANS_TO_BE_TRANSLATED_HEAD 822 opcode = (iword >> 26) & 63;
823 ra = (iword >> 21) & 31;
824 rb = (iword >> 16) & 31;
825 func = (iword >> 5) & 0x7ff;
827 imm = iword & 0xffff;
832 ic->arg[0] = (size_t) (iword & 0x3ffffff);
847 ic->arg[2] = (ssize_t)(int16_t)imm;
863 ic->arg[2] = (ssize_t)(int16_t)imm;
881 loadstore_type = 0; fp = 0; load = 0; llsc = 0;
883 case 0x0a: loadstore_type = 0; load = 1;
break;
884 case 0x0c: loadstore_type = 1; load = 1;
break;
885 case 0x0d: loadstore_type = 1;
break;
886 case 0x0e: loadstore_type = 0;
break;
887 case 0x22: loadstore_type = 2; load = 1; fp = 1;
break;
888 case 0x23: loadstore_type = 3; load = 1; fp = 1;
break;
889 case 0x26: loadstore_type = 2; fp = 1;
break;
890 case 0x27: loadstore_type = 3; fp = 1;
break;
891 case 0x28: loadstore_type = 2; load = 1;
break;
892 case 0x29: loadstore_type = 3; load = 1;
break;
893 case 0x2a: loadstore_type = 2; load = llsc = 1;
break;
894 case 0x2b: loadstore_type = 3; load = llsc = 1;
break;
895 case 0x2c: loadstore_type = 2;
break;
896 case 0x2d: loadstore_type = 3;
break;
897 case 0x2e: loadstore_type = 2; llsc = 1;
break;
898 case 0x2f: loadstore_type = 3; llsc = 1;
break;
901 loadstore_type + (imm==0? 4 : 0) + 8 * load
914 ic->arg[2] = (ssize_t)(int16_t)imm;
924 ic->arg[2] = (size_t)((rb << 3) + (func >> 8));
927 switch (func & 0xff) {
928 case 0x00:
ic->f =
instr(addl);
break;
929 case 0x02:
ic->f =
instr(s4addl);
break;
930 case 0x09:
ic->f =
instr(subl);
break;
931 case 0x0b:
ic->f =
instr(s4subl);
break;
932 case 0x0f:
ic->f =
instr(cmpbge);
break;
933 case 0x12:
ic->f =
instr(s8addl);
break;
934 case 0x1b:
ic->f =
instr(s8subl);
break;
935 case 0x1d:
ic->f =
instr(cmpult);
break;
936 case 0x20:
ic->f =
instr(addq);
break;
937 case 0x22:
ic->f =
instr(s4addq);
break;
938 case 0x29:
ic->f =
instr(subq);
break;
939 case 0x2b:
ic->f =
instr(s4subq);
break;
940 case 0x2d:
ic->f =
instr(cmpeq);
break;
941 case 0x32:
ic->f =
instr(s8addq);
break;
942 case 0x3b:
ic->f =
instr(s8subq);
break;
943 case 0x3d:
ic->f =
instr(cmpule);
break;
944 case 0x4d:
ic->f =
instr(cmplt);
break;
946 case 0x6d:
ic->f =
instr(cmple);
break;
948 case 0x80:
ic->f =
instr(addl_imm);
break;
949 case 0x82:
ic->f =
instr(s4addl_imm);
break;
950 case 0x89:
ic->f =
instr(subl_imm);
break;
951 case 0x8b:
ic->f =
instr(s4subl_imm);
break;
952 case 0x8f:
ic->f =
instr(cmpbge_imm);
break;
953 case 0x92:
ic->f =
instr(s8addl_imm);
break;
954 case 0x9b:
ic->f =
instr(s8subl_imm);
break;
955 case 0x9d:
ic->f =
instr(cmpult_imm);
break;
956 case 0xa0:
ic->f =
instr(addq_imm);
break;
957 case 0xa2:
ic->f =
instr(s4addq_imm);
break;
958 case 0xa9:
ic->f =
instr(subq_imm);
break;
959 case 0xab:
ic->f =
instr(s4subq_imm);
break;
960 case 0xad:
ic->f =
instr(cmpeq_imm);
break;
961 case 0xb2:
ic->f =
instr(s8addq_imm);
break;
962 case 0xbb:
ic->f =
instr(s8subq_imm);
break;
963 case 0xbd:
ic->f =
instr(cmpule_imm);
break;
964 case 0xcd:
ic->f =
instr(cmplt_imm);
break;
965 case 0xed:
ic->f =
instr(cmple_imm);
break;
968 fatal(
"[ Alpha: unimplemented function 0x%03x " 969 "for opcode 0x%02x ]\n", func, opcode);
981 ic->arg[2] = (size_t)((rb << 3) + (func >> 8));
984 switch (func & 0xff) {
985 case 0x00:
ic->f =
instr(and);
break;
986 case 0x08:
ic->f =
instr(andnot);
break;
987 case 0x14:
ic->f =
instr(cmovlbs);
break;
988 case 0x16:
ic->f =
instr(cmovlbc);
break;
996 case 0x24:
ic->f =
instr(cmoveq);
break;
997 case 0x26:
ic->f =
instr(cmovne);
break;
998 case 0x28:
ic->f =
instr(ornot);
break;
999 case 0x40:
ic->f =
instr(xor);
break;
1000 case 0x44:
ic->f =
instr(cmovlt);
break;
1001 case 0x46:
ic->f =
instr(cmovge);
break;
1002 case 0x48:
ic->f =
instr(xornot);
break;
1003 case 0x64:
ic->f =
instr(cmovle);
break;
1004 case 0x66:
ic->f =
instr(cmovgt);
break;
1005 case 0x80:
ic->f =
instr(and_imm);
break;
1006 case 0x88:
ic->f =
instr(andnot_imm);
break;
1007 case 0x94:
ic->f =
instr(cmovlbs_imm);
break;
1008 case 0x96:
ic->f =
instr(cmovlbc_imm);
break;
1009 case 0xa0:
ic->f =
instr(or_imm);
break;
1010 case 0xa4:
ic->f =
instr(cmoveq_imm);
break;
1011 case 0xa6:
ic->f =
instr(cmovne_imm);
break;
1012 case 0xa8:
ic->f =
instr(ornot_imm);
break;
1013 case 0xc0:
ic->f =
instr(xor_imm);
break;
1014 case 0xc4:
ic->f =
instr(cmovlt_imm);
break;
1015 case 0xc6:
ic->f =
instr(cmovge_imm);
break;
1016 case 0xc8:
ic->f =
instr(xornot_imm);
break;
1017 case 0xe4:
ic->f =
instr(cmovle_imm);
break;
1018 case 0xe6:
ic->f =
instr(cmovgt_imm);
break;
1019 case 0xec:
ic->f =
instr(implver);
break;
1021 fatal(
"[ Alpha: unimplemented function 0x%03x " 1022 "for opcode 0x%02x ]\n", func, opcode);
1034 ic->arg[2] = (size_t)((rb << 3) + (func >> 8));
1037 switch (func & 0xff) {
1038 case 0x02:
ic->f =
instr(mskbl);
break;
1039 case 0x06:
ic->f =
instr(extbl);
break;
1040 case 0x0b:
ic->f =
instr(insbl);
break;
1041 case 0x12:
ic->f =
instr(mskwl);
break;
1042 case 0x16:
ic->f =
instr(extwl);
break;
1043 case 0x1b:
ic->f =
instr(inswl);
break;
1044 case 0x22:
ic->f =
instr(mskll);
break;
1045 case 0x26:
ic->f =
instr(extll);
break;
1046 case 0x2b:
ic->f =
instr(insll);
break;
1047 case 0x30:
ic->f =
instr(zap);
break;
1048 case 0x31:
ic->f =
instr(zapnot);
break;
1049 case 0x32:
ic->f =
instr(mskql);
break;
1050 case 0x34:
ic->f =
instr(srl);
break;
1051 case 0x36:
ic->f =
instr(extql);
break;
1053 case 0x3b:
ic->f =
instr(insql);
break;
1054 case 0x3c:
ic->f =
instr(sra);
break;
1055 case 0x52:
ic->f =
instr(mskwh);
break;
1056 case 0x57:
ic->f =
instr(inswh);
break;
1057 case 0x5a:
ic->f =
instr(extwh);
break;
1058 case 0x62:
ic->f =
instr(msklh);
break;
1059 case 0x67:
ic->f =
instr(inslh);
break;
1060 case 0x6a:
ic->f =
instr(extlh);
break;
1061 case 0x72:
ic->f =
instr(mskqh);
break;
1062 case 0x77:
ic->f =
instr(insqh);
break;
1063 case 0x7a:
ic->f =
instr(extqh);
break;
1064 case 0x82:
ic->f =
instr(mskbl_imm);
break;
1065 case 0x86:
ic->f =
instr(extbl_imm);
break;
1066 case 0x8b:
ic->f =
instr(insbl_imm);
break;
1067 case 0x92:
ic->f =
instr(mskwl_imm);
break;
1068 case 0x96:
ic->f =
instr(extwl_imm);
break;
1069 case 0x9b:
ic->f =
instr(inswl_imm);
break;
1070 case 0xa2:
ic->f =
instr(mskll_imm);
break;
1071 case 0xa6:
ic->f =
instr(extll_imm);
break;
1072 case 0xab:
ic->f =
instr(insll_imm);
break;
1073 case 0xb0:
ic->f =
instr(zap_imm);
break;
1074 case 0xb1:
ic->f =
instr(zapnot_imm);
break;
1075 case 0xb2:
ic->f =
instr(mskql_imm);
break;
1076 case 0xb4:
ic->f =
instr(srl_imm);
break;
1077 case 0xb6:
ic->f =
instr(extql_imm);
break;
1078 case 0xb9:
ic->f =
instr(sll_imm);
break;
1079 case 0xbb:
ic->f =
instr(insql_imm);
break;
1080 case 0xbc:
ic->f =
instr(sra_imm);
break;
1081 case 0xd2:
ic->f =
instr(mskwh_imm);
break;
1082 case 0xd7:
ic->f =
instr(inswh_imm);
break;
1083 case 0xda:
ic->f =
instr(extwh_imm);
break;
1084 case 0xe2:
ic->f =
instr(msklh_imm);
break;
1085 case 0xe7:
ic->f =
instr(inslh_imm);
break;
1086 case 0xea:
ic->f =
instr(extlh_imm);
break;
1087 case 0xf2:
ic->f =
instr(mskqh_imm);
break;
1088 case 0xf7:
ic->f =
instr(insqh_imm);
break;
1089 case 0xfa:
ic->f =
instr(extqh_imm);
break;
1091 fatal(
"[ Alpha: unimplemented function 0x%03x " 1092 "for opcode 0x%02x ]\n", func, opcode);
1104 ic->arg[2] = (size_t)((rb << 3) + (func >> 8));
1109 switch (func & 0xff) {
1110 case 0x00:
ic->f =
instr(mull);
break;
1111 case 0x20:
ic->f =
instr(mulq);
break;
1112 case 0x30:
ic->f =
instr(umulh);
break;
1113 case 0x80:
ic->f =
instr(mull_imm);
break;
1114 case 0xa0:
ic->f =
instr(mulq_imm);
break;
1116 fatal(
"[ Alpha: unimplemented function 0x%03x " 1117 "for opcode 0x%02x ]\n", func, opcode);
1129 switch (func & 0x7ff) {
1130 case 0x02f:
ic->f =
instr(cvttq_c);
break;
1131 case 0x0a0:
ic->f =
instr(addt);
break;
1132 case 0x0a1:
ic->f =
instr(subt);
break;
1133 case 0x0a2:
ic->f =
instr(mult);
break;
1134 case 0x0a3:
ic->f =
instr(divt);
break;
1135 case 0x0a5:
ic->f =
instr(cmpteq);
break;
1136 case 0x0a6:
ic->f =
instr(cmptlt);
break;
1137 case 0x0a7:
ic->f =
instr(cmptle);
break;
1138 case 0x0be:
ic->f =
instr(cvtqt);
break;
1140 fatal(
"[ Alpha: unimplemented function 0x%03x " 1141 "for opcode 0x%02x ]\n", func, opcode);
1153 switch (func & 0x7ff) {
1156 if (ra == 31 && rb == 31)
1165 fatal(
"[ Alpha: unimplemented function 0x%03x " 1166 "for opcode 0x%02x ]\n", func, opcode);
1171 switch (iword & 0xffff) {
1185 fatal(
"[ Alpha: unimplemented function 0x%03x " 1186 "for opcode 0x%02x ]\n", func, opcode);
1191 switch ((iword >> 14) & 3) {
1211 fatal(
"[ Alpha: unimpl JSR type %i, ra=%i " 1212 "rb=%i ]\n", ((iword >> 14) & 3), ra, rb);
1235 samepage_function =
instr(br_samepage);
1238 samepage_function =
instr(br_return_samepage);
1243 samepage_function =
instr(blbc_samepage);
1249 samepage_function =
instr(beq_samepage);
1253 samepage_function =
instr(blt_samepage);
1257 samepage_function =
instr(ble_samepage);
1261 samepage_function =
instr(blbs_samepage);
1267 samepage_function =
instr(bne_samepage);
1271 samepage_function =
instr(bge_samepage);
1275 samepage_function =
instr(bgt_samepage);
1282 ic->arg[0] = (iword & 0x001fffff) << 2;
1284 if (
ic->arg[0] & 0x00400000)
1285 ic->arg[0] |= 0xffffffffff800000ULL;
1287 ic->arg[0] = (size_t)(
ic->arg[0] + 4);
1290 uint64_t mask_within_page =
1292 uint64_t old_pc =
addr;
1293 uint64_t new_pc = old_pc + (int32_t)
ic->arg[0];
1294 if ((old_pc & ~mask_within_page) ==
1295 (new_pc & ~mask_within_page)) {
1296 ic->f = samepage_function;
1297 ic->arg[0] = (size_t) (
1299 ((new_pc & mask_within_page) >> 2));
1304 fatal(
"[ UNIMPLEMENTED Alpha opcode 0x%x ]\n", opcode);
1309 #define DYNTRANS_TO_BE_TRANSLATED_TAIL 1311 #undef DYNTRANS_TO_BE_TRANSLATED_TAIL void fatal(const char *fmt,...)
void COMBINE() nop(struct cpu *cpu, struct mips_instr_call *ic, int low_addr)
struct arm_instr_call * ic
void COMBINE() sll(struct cpu *cpu, struct mips_instr_call *ic, int low_addr)
#define DYNTRANS_L2_64_TABLE
void ieee_interpret_float_value(uint64_t x, struct ieee_float_value *fvp, int fmt)
#define ALPHA_INSTR_ALIGNMENT_SHIFT
void alpha_palcode(struct cpu *cpu, uint32_t palcode)
void(* alpha_mov_r_r[32 *31])(struct cpu *, struct alpha_instr_call *)
int translation_readahead
#define ALPHA_IC_ENTRIES_PER_PAGE
int(* memory_rw)(struct cpu *cpu, struct memory *mem, uint64_t vaddr, unsigned char *data, size_t len, int writeflag, int cache_flags)
void(* alpha_loadstore[32])(struct cpu *, struct alpha_instr_call *)
void cpu_functioncall_trace(struct cpu *cpu, uint64_t f)
struct alpha_cpu_type_def cpu_type
void cpu_functioncall_trace_return(struct cpu *cpu)
#define CACHE_INSTRUCTION
void load(FILE *fh, unsigned char *ptr, unsigned long sz)
uint64_t ieee_store_float_value(double nf, int fmt, int nan)
addr & if(addr >=0x24 &&page !=NULL)
#define DYNTRANS_L3_64_TABLE