| |
| /*---------------------------------------------------------------*/ |
| /*--- ---*/ |
| /*--- This file (test_main.c) is ---*/ |
| /*--- Copyright (c) 2004 OpenWorks LLP. All rights reserved. ---*/ |
| /*--- ---*/ |
| /*---------------------------------------------------------------*/ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <assert.h> |
| |
| #include "libvex_basictypes.h" |
| #include "libvex.h" |
| |
| /*---------------------------------------------------------------*/ |
| /*--- Test ---*/ |
| /*---------------------------------------------------------------*/ |
| |
| |
| __attribute__ ((noreturn)) |
| static |
| void failure_exit ( void ) |
| { |
| fprintf(stdout, "VEX did failure_exit. Bye.\n"); |
| exit(1); |
| } |
| |
| static |
| void log_bytes ( Char* bytes, Int nbytes ) |
| { |
| fwrite ( bytes, 1, nbytes, stdout ); |
| } |
| |
| #define N_LINEBUF 10000 |
| static Char linebuf[N_LINEBUF]; |
| |
| #define N_ORIGBUF 1000 |
| #define N_TRANSBUF 5000 |
| |
| static UChar origbuf[N_ORIGBUF]; |
| static UChar transbuf[N_TRANSBUF]; |
| |
| static Bool verbose = True; |
| |
| int main ( int argc, char** argv ) |
| { |
| FILE* f; |
| Int i; |
| UInt u, sum; |
| Addr32 orig_addr; |
| Int bb_number; |
| Int orig_nbytes, trans_used, orig_used; |
| TranslateResult tres; |
| VexControl vcon; |
| |
| if (argc != 2) { |
| fprintf(stderr, "usage: vex file.org\n"); |
| exit(1); |
| } |
| f = fopen(argv[1], "r"); |
| if (!f) { |
| fprintf(stderr, "can't open `%s'\n", argv[1]); |
| exit(1); |
| } |
| |
| /* Run with default params. However, we can't allow bb chasing |
| since that causes the front end to get segfaults when it tries |
| to read code outside the initial BB we hand it. */ |
| LibVEX_default_VexControl ( &vcon ); |
| vcon.guest_chase_thresh = 0; |
| vcon.iropt_level = 2; |
| |
| LibVEX_Init ( &failure_exit, &log_bytes, |
| 1, /* debug_paranoia */ |
| 1, /* verbosity */ |
| //False, |
| True, /* valgrind support */ |
| &vcon ); |
| |
| #if 0 |
| {extern void test_asm86(void); |
| test_asm86(); |
| return 0; |
| } |
| #endif |
| |
| while (!feof(f)) { |
| fgets(linebuf, N_LINEBUF,f); |
| //printf("%s", linebuf); |
| assert(linebuf[0] != 0); |
| if (linebuf[0] != '.') continue; |
| /* first line is: . bb-number bb-addr n-bytes */ |
| assert(3 == sscanf(&linebuf[1], " %d %x %d\n", |
| & bb_number, |
| & orig_addr, & orig_nbytes )); |
| assert(orig_nbytes >= 1); |
| assert(!feof(f)); |
| fgets(linebuf, N_LINEBUF,f); |
| assert(linebuf[0] == '.'); |
| /* second line is: . byte byte byte etc */ |
| //printf("%s", linebuf); |
| if (verbose) |
| printf("============ Basic Block %d, " |
| "Start %x, nbytes %2d ============", |
| bb_number, orig_addr, orig_nbytes); |
| assert(orig_nbytes >= 1 && orig_nbytes <= N_ORIGBUF); |
| for (i = 0; i < orig_nbytes; i++) { |
| assert(1 == sscanf(&linebuf[2 + 3*i], "%x", &u)); |
| origbuf[i] = (UChar)u; |
| } |
| |
| if (bb_number == 10000) break; |
| { |
| for (i = 0; i < 1; i++) |
| tres = |
| LibVEX_Translate ( InsnSetX86, InsnSetX86, |
| origbuf, (Addr64)orig_addr, &orig_used, |
| transbuf, N_TRANSBUF, &trans_used, |
| NULL, NULL, 0 ); |
| if (tres != TransOK) |
| printf("\ntres = %d\n", (Int)tres); |
| assert(tres == TransOK); |
| assert(orig_used == orig_nbytes); |
| } |
| sum = 0; |
| for (i = 0; i < trans_used; i++) |
| sum += (UInt)transbuf[i]; |
| printf ( " %6.2f ... %d\n", (double)trans_used / (double)orig_used, sum ); |
| } |
| |
| fclose(f); |
| printf("\n"); |
| LibVEX_ClearTemporary(True); |
| |
| #if 0 |
| Int* p; |
| Int i, j, n = 0; |
| LibVEX_Init ( &failure_exit, &log_bytes, |
| 1, 1, False, 10 ); |
| for (j = 0; j < 5000; j++) { |
| LibVEX_Clear(False); |
| for (i = 0; i < 2000; i++) { |
| n++; |
| p = LibVEX_Alloc(16); |
| p[0] = p[1] = p[2] = p[3] = 44; |
| } |
| } |
| LibVEX_Clear(True); |
| printf("Did %d allocs\n", n); |
| #endif |
| return 0; |
| } |
| |
| /*---------------------------------------------------------------*/ |
| /*--- Test (old) ---*/ |
| /*---------------------------------------------------------------*/ |
| |
| #if 0 |
| |
| #include "libvex_basictypes.h" |
| #include "ir_defs.h" |
| #include "host_regs.h" |
| #include "x86h_defs.h" |
| |
| |
| /* HACK */ |
| extern |
| HInstrArray* /* not really, but for the time being ... */ |
| iselBB_X86Instr ( IRBB* bb ); |
| |
| |
| int main ( void ) |
| { |
| HInstrArray* vcode; |
| IRBB* bb; |
| IRTypeEnv* env = newIRTypeEnv(); |
| |
| IRTemp t0 = 0; |
| IRTemp t1 = 1; |
| IRTemp t2 = 2; |
| |
| addToIRTypeEnv ( env, t0, Ity_I32 ); |
| addToIRTypeEnv ( env, t1, Ity_I32 ); |
| addToIRTypeEnv ( env, t2, Ity_I32 ); |
| |
| IRStmt* s10 = IRStmt_Tmp(t0, IRExpr_Const(IRConst_U32(0x2000))); |
| IRStmt* s11 = IRStmt_Tmp(t1, IRExpr_Const(IRConst_U32(0x2001))); |
| IRStmt* s12 = IRStmt_Tmp(t2, IRExpr_Const(IRConst_U32(0x2002))); |
| |
| IRStmt* s1 = IRStmt_Put(8,4, IRExpr_Const(IRConst_U32(99)) ); |
| #if 0 |
| IRStmt* s2 = IRStmt_Put(7,4, IRExpr_Binop(Iop_Add32, |
| IRExpr_Tmp(t1), |
| IRExpr_Const(IRConst_U32(55)))); |
| #endif |
| |
| IRStmt* s2 = IRStmt_Put(9,4, |
| IRExpr_Binop(Iop_Shl32, |
| IRExpr_Tmp(t0), |
| IRExpr_Binop(Iop_Add32, |
| IRExpr_Tmp(t1), |
| IRExpr_Tmp(t2)))); |
| |
| |
| s10->link = s11; |
| s11->link = s12; |
| s12->link = s1; |
| s1->link = s2; |
| |
| bb = mk_IRBB(env, s10, IRNext_UJump(IRConst_U32(-65565))); |
| |
| printf("bb is ...\n"); |
| ppIRBB(stdout, bb); |
| printf("\n"); |
| |
| if (0) |
| vcode = iselBB_X86Instr(bb); |
| else |
| { |
| Int i; |
| HReg vr0 = mkHReg(0, HRcInt, True); |
| HReg vr1 = mkHReg(1, HRcInt, True); |
| HReg vr2 = mkHReg(2, HRcInt, True); |
| HReg vr3 = mkHReg(3, HRcInt, True); |
| HReg eax = hregX86_EAX(); |
| HReg ebx = hregX86_EBX(); |
| HReg ecx = hregX86_ECX(); |
| HReg edx = hregX86_EDX(); |
| HReg ebp = hregX86_EBP(); |
| vcode = newHInstrArray(); |
| vcode->n_vregs = 4; |
| |
| addHInstr(vcode, X86Instr_Alu32R(Xalu_MOV, |
| X86RMI_Imm(0x10001), vr0)); |
| addHInstr(vcode, X86Instr_Alu32R(Xalu_MOV, |
| X86RMI_Imm(0x10101), vr1)); |
| addHInstr(vcode, X86Instr_Alu32R(Xalu_MOV, |
| X86RMI_Imm(0x10201), vr2)); |
| addHInstr(vcode, X86Instr_Alu32R(Xalu_MOV, |
| X86RMI_Imm(0x10301), vr3)); |
| |
| addHInstr(vcode, X86Instr_Alu32R(Xalu_MOV, |
| X86RMI_Imm(0x99999), eax)); |
| addHInstr(vcode, X86Instr_Alu32R(Xalu_MOV, |
| X86RMI_Imm(0x99999), edx)); |
| |
| addHInstr(vcode, X86Instr_Alu32M(Xalu_MOV, |
| X86RI_Reg(vr0), |
| X86AMode_IR(0x100, ebp))); |
| addHInstr(vcode, X86Instr_Alu32M(Xalu_MOV, |
| X86RI_Reg(vr1), |
| X86AMode_IR(0x101, ebp))); |
| addHInstr(vcode, X86Instr_Alu32M(Xalu_MOV, |
| X86RI_Reg(vr2), |
| X86AMode_IR(0x101, ebp))); |
| addHInstr(vcode, X86Instr_Alu32M(Xalu_MOV, |
| X86RI_Reg(vr3), |
| X86AMode_IR(0x101, ebp))); |
| printf("\nBefore\n"); |
| for (i = 0; i < vcode->arr_used; i++) { |
| ppX86Instr(stdout, vcode->arr[i]); |
| printf("\n"); |
| } |
| printf("\n"); |
| } |
| |
| { |
| Int i; |
| HInstrArray* rcode; |
| HReg rregs_to_use[4]; |
| rregs_to_use[0] = hregX86_EAX(); |
| rregs_to_use[1] = hregX86_EBX(); |
| rregs_to_use[2] = hregX86_ECX(); |
| rregs_to_use[3] = hregX86_EDX(); |
| |
| rcode = |
| doRegisterAllocation(vcode, |
| rregs_to_use, 3, /* rregs */ |
| isMove_X86Instr, |
| getRegUsage_X86Instr, |
| mapRegs_X86Instr, |
| genSpill_X86, |
| genReload_X86 |
| ); |
| |
| printf("\nAfter\n"); |
| for (i = 0; i < rcode->arr_used; i++) { |
| ppX86Instr(stdout, rcode->arr[i]); |
| printf("\n"); |
| } |
| printf("\n"); |
| } |
| |
| return 0; |
| } |
| #endif |