void EmitTmpHelper(HWord tmp, IntTyStateHint hint, HWord eip, Addr addr)
{
  IntType newTy = 0;
  
  /* Check whether rhs arg has a tyvar */ 
  if (getVarOf(locToHashKey(tmp,eip,TmpLoc)) == -1)
    {
      /* No, so add one */ 
      setVarOf(locToHashKey(tmp,eip,TmpLoc),curtyvar);
      curtyvar++;
    }

  newTy = setTypeOfToMeet(getVarOf(locToHashKey(tmp,eip,TmpLoc)),hint); 

  if (newTy == Bot)
    {
      /* Check whether the tyvar has a addr */
      if(getAddrOf(getVarOf(locToHashKey(tmp,eip,TmpLoc))) == 0)
	{
	  /* No, so add one*/
	  setAddrOf(getVarOf(locToHashKey(tmp,eip,TmpLoc)),addr);
	} 
    }

  return; 
}
void EmitLoadTmp2AddrHelper(HWord lhs, HWord addr, HWord eip)
{
  if (getVarOf(locToHashKey(addr,0,MemLoc)) == -1)
    {
	setVarOf(locToHashKey(addr,0,MemLoc),curtyvar);
	curtyvar++;
    }
  setVarOf(locToHashKey(lhs,eip,TmpLoc),getVarOf(locToHashKey(addr,0,MemLoc)));
  return; 
}
void EmitRdTmpTmp2TmpHelper(HWord lhs, HWord rhs, HWord eip)
{
  if (getVarOf(locToHashKey(rhs,eip,TmpLoc)) == -1)
    {
	setVarOf(locToHashKey(rhs,eip,TmpLoc),curtyvar);
	curtyvar++;
    }
  setVarOf(locToHashKey(lhs,eip,TmpLoc),getVarOf(locToHashKey(rhs,eip,TmpLoc)));
  return;
}
void EmitGetTmp2RegHelper(HWord lhs_tmp, HWord offset, HWord eip)
{
  if (getVarOf(locToHashKey(offset,0,RegLoc)) == -1)
    {
	setVarOf(locToHashKey(offset,0,RegLoc),curtyvar);
	curtyvar++;
    }
  setVarOf(locToHashKey(lhs_tmp,eip,TmpLoc),getVarOf(locToHashKey(offset,0,RegLoc)));
  return;
}
void EmitStoreAddr2TmpHelper(HWord addr, HWord tmpname, HWord eip)
{
  /* Check whether tmp has a tyvar */ 
  if (getVarOf(locToHashKey(tmpname,eip,TmpLoc)) == -1)
    {
      /* No, so add one */ 
      setVarOf(locToHashKey(tmpname,eip,TmpLoc),curtyvar);
      curtyvar++;
    }

  setVarOf( locToHashKey(addr,0,MemLoc),
	    getVarOf(locToHashKey(tmpname,eip,TmpLoc))); 
  
  return; 
}
void EmitPutTmpHelper(HWord offset, HWord tmpname, HWord eip)
{
  /* Check whether tmpname has a tyvar */ 
   if (getVarOf(locToHashKey(tmpname,eip,TmpLoc)) == -1)
    {
      /* No, so add one */ 
      setVarOf(locToHashKey(tmpname,eip,TmpLoc),curtyvar);
      curtyvar++;
    }

   setVarOf( locToHashKey(offset,0,RegLoc),
	     getVarOf(locToHashKey(tmpname,eip,TmpLoc))); 

   return;
}
Exemple #7
0
void ufDestroy(ufOgNode * element)
{
  HWord hashkey; 
  ufOgHashNode * delHashNode; 
  vassert(element != NULL); 
  vassert(element != NULL); 

  //  VG_(printf)("XXX ufDestroy %u %u \n", element->tmpName, element->bbExecNum); 
  hashkey = locToHashKey(element->tmpName, element->bbExecNum, TmpLoc);

  // delete x from H 
  delHashNode = VG_(HT_remove)(ufOgHash, hashkey); 
  if (delHashNode)
  {
    VG_(free)(delHashNode); 
  }

  // delete x from LiveTempVarNodes
  //  delHashNode = VG_(HT_remove)(ufOgLiveTempVarNodes, hashkey); 
  // if (delHashNode)
  //{
  //  VG_(free)(delHashNode); 
  //}
  // free x itself
  VG_(free)(element); 
}
void EmitBinopTmpConstTypeHelper(HWord lhs, HWord op, HWord tmp, HWord eip)
{
  IntType lhsType = Top;
  IntType arg1Type = Top;
  IntType constType = Top;

  arg1Type = getTypeOf(getVarOf(locToHashKey(tmp,eip,TmpLoc)));
  lhsType = BinopTypeStateFunc(op, arg1Type, constType);

  /* Check whether lhs arg has a tyvar */ 
  if (getVarOf(locToHashKey(tmp,eip,TmpLoc)) == -1)
    {
      /* No, so add one */ 
      setVarOf(locToHashKey(tmp,eip,TmpLoc),curtyvar);
      curtyvar++;
    }
  setTypeOf(getVarOf(locToHashKey(lhs,eip,TmpLoc)),lhsType);
  
  return;
}
void EmitStackHelper(Addr stackAddr, SizeT len)
{
   int i;

   for (i = 0; i < len; i++)
     {
       setVarOf(locToHashKey(stackAddr+i,0,MemLoc),curtyvar);  
       curtyvar++;
     }

   return; 
}
Exemple #10
0
void EmitStoreAddr2ConstHelper(HWord addr)
{
  setVarOf(locToHashKey(addr,0,MemLoc),curtyvar);
  curtyvar++;
  return;
}
Exemple #11
0
void EmitPutConstHelper(HWord offset, HWord eip)
{
   clearVarOf(locToHashKey(offset,0,RegLoc));
   return;
}
Exemple #12
0
void EmitNewTmpTyvarHelper(HWord lhs, HWord eip)
{
  setVarOf(locToHashKey(lhs,eip,TmpLoc),curtyvar);
  curtyvar++;
}
Exemple #13
0
void AddGetHelper(IRSB* sb, IRTemp lhs, Int offset, Addr addr)
{
  ULong offset_cur = (HWord)offset;
  ULong lhs_int = (HWord)lhs;
  IRDirty* d1,*d2;
 
  d1 = unsafeIRDirty_0_N(0, "EmitGetTmp2RegHelper",
		        &EmitGetTmp2RegHelper,
		        mkIRExprVec_3(
				      mkIRExpr_HWord(lhs_int),
				      mkIRExpr_HWord(offset_cur),
				      mkIRExpr_HWord(counter)
				     )
		       );
  setHelperAnns(d1);
  addStmtToIRSB(sb,IRStmt_Dirty(d1));
  
  Addr relateaddr = getAddrOf(getVarOf(locToHashKey(offset_cur,0,RegLoc)));

  ThreadId tid = VG_(get_running_tid)();
  tl_assert(VG_INVALID_THREADID != tid);
  ThreadState* tst = VG_(get_ThreadState)(tid);

//  SizeT argRDI = tst->arch.vex.guest_RDI;
//  SizeT argRSI = tst->arch.vex.guest_RSI;
  VexGuestArchState* t = &(tst->arch.vex);
  ULong argRDI;
  ULong argRSI;
/*
  if(offset == 64)
  {
	argRSI = *(&(t->guest_RSI));
	VG_(message)(Vg_UserMsg, "argRSI         %ld \n", argRSI);
	VG_(message)(Vg_UserMsg, "(SSizeT)argRSI %ld \n", (SSizeT)argRSI);
  }
*/
  //VG_(message)(Vg_UserMsg, "addr is %lx \n", addr);

  if(isRealloc)
    {
	if(argNum == 1 && offset == 64)
	  {
		//argRSI = *(&(tst->arch.vex) + offset);
		argRSI = *(&(t->guest_RSI));
//		VG_(message)(Vg_UserMsg, "realloc arg %lu \n", argRSI);
/*		if((SSizeT)argRSI < 0)
		  {
			VG_(message)(Vg_UserMsg, "ERROR realloc arg %ld ", (SSizeT)argRSI);
			//VG_printf("ERROR realloc arg %ld ",(SSizeT)argRSI);
			if(relateaddr != 0)
			  VG_(message)(Vg_UserMsg, "(come from 0x%lx)", relateaddr);
			  //VG_printf("(come from 0x%x)",relateaddr);
			VG_(message)(Vg_UserMsg, "\n");
		 	//VG_printf("\n");
		  	
		  }	
*/
		
  		d2 = unsafeIRDirty_0_N(2, "trace_error",
		        		&trace_error,
		        		mkIRExprVec_3(
				      			mkIRExpr_HWord(argRSI),
							mkIRExpr_HWord(addr),
				      			mkIRExpr_HWord(relateaddr)
				     			)
					);
  		setHelperAnns(d2);
  		addStmtToIRSB(sb,IRStmt_Dirty(d2));	

		argNum--;
		isRealloc = 0;	
	  }
    }
  else if(argNum > 0)
    {
	if(offset == 72)
	  {
		argRDI = *(&(t->guest_RDI));
//		VG_(message)(Vg_UserMsg, "alloc arg %lu \n", argRDI);
/*		if((SSizeT)argRDI < 0)
		  {
			VG_(message)(Vg_UserMsg, "ERROR malloc/calloc/new/[] new first arg %ld ", (SSizeT)argRDI);
			//VG_printf("ERROR malloc/calloc/new/[] new first arg %ld ",(SSizeT)argRDI);
			if(relateaddr != 0)
			  VG_(message)(Vg_UserMsg, "(come from 0x%lx)", relateaddr);
			  //VG_printf("(come from 0x%x)",relateaddr);
			VG_(message)(Vg_UserMsg, "\n");
		 	//VG_printf("\n");
		  	
		  }
*/
  		d2 = unsafeIRDirty_0_N(2, "trace_error",
		        		&trace_error,
		        		mkIRExprVec_3(
				      			mkIRExpr_HWord(argRDI),
							mkIRExpr_HWord(addr),
				      			mkIRExpr_HWord(relateaddr)
				     			)
					);
  		setHelperAnns(d2);
  		addStmtToIRSB(sb,IRStmt_Dirty(d2));

		argNum--;
	  }
	else if(offset == 64)
	  {
		argRSI = *(&(t->guest_RSI));
//		VG_(message)(Vg_UserMsg, "alloc arg %lu \n", argRSI);
/*		if((SSizeT)argRSI < 0)
		  {
			VG_(message)(Vg_UserMsg, "ERROR calloc/memalign second arg %ld ", (SSizeT)argRSI);
			//VG_printf("ERROR calloc/memalign second arg %ld ",(SSizeT)argRSI);
			if(relateaddr != -1)
		 	  VG_(message)(Vg_UserMsg, "(come from 0x%lx)", relateaddr);
			  //VG_printf("(come from 0x%x)",relateaddr);
			VG_(message)(Vg_UserMsg, "\n");
		 	//VG_printf("\n");
		  	
		  }
*/
  		d2 = unsafeIRDirty_0_N(2, "trace_error",
		        		&trace_error,
		        		mkIRExprVec_3(
				      			mkIRExpr_HWord(argRSI),
							mkIRExpr_HWord(addr),
				      			mkIRExpr_HWord(relateaddr)
				     			)
					);
  		setHelperAnns(d2);
  		addStmtToIRSB(sb,IRStmt_Dirty(d2));

		argNum--;
	  }
    }

  return;
}