test_main.c - platform/external/valgrind - Gitiles


 /*---------------------------------------------------------------*/
 /*---                                                         ---*/
 /*--- 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;

    LibVEX_Init ( &failure_exit, &log_bytes,
                  1,  /* debug_paranoia */
                  0,  /* 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

	/---------------------------------------------------------------/
	/--- ---/
	/--- 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;

	LibVEX_Init ( &failure_exit, &log_bytes,
	1, /* debug_paranoia */
	0, /* 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