UChar modrm = getUChar(delta);
IRTemp arg64 = newTemp(Ity_I64);
UInt rG = gregOfRexRM(pfx,modrm);
- UChar* mbV = isAvx ? "v" : "";
+ HChar* mbV = isAvx ? "v" : "";
if (epartIsReg(modrm)) {
UInt rE = eregOfRexRM(pfx,modrm);
assign( arg64, getXMMRegLane64(rE, 0) );
HChar dis_buf[50];
IRTemp srcVec = newTemp(Ity_V128);
UChar modrm = getUChar(delta);
- UChar* mbV = isAvx ? "v" : "";
- UChar how = xIsZ ? 'z' : 's';
+ HChar* mbV = isAvx ? "v" : "";
+ HChar how = xIsZ ? 'z' : 's';
UInt rG = gregOfRexRM(pfx, modrm);
if ( epartIsReg(modrm) ) {
UInt rE = eregOfRexRM(pfx, modrm);
HChar dis_buf[50];
IRTemp srcVec = newTemp(Ity_V128);
UChar modrm = getUChar(delta);
- UChar* mbV = isAvx ? "v" : "";
- UChar how = xIsZ ? 'z' : 's';
+ HChar* mbV = isAvx ? "v" : "";
+ HChar how = xIsZ ? 'z' : 's';
UInt rG = gregOfRexRM(pfx, modrm);
if ( epartIsReg(modrm) ) {
HChar dis_buf[50];
IRTemp srcBytes = newTemp(Ity_I32);
UChar modrm = getUChar(delta);
- UChar* mbV = isAvx ? "v" : "";
+ HChar* mbV = isAvx ? "v" : "";
UInt rG = gregOfRexRM(pfx, modrm);
if ( epartIsReg( modrm ) ) {
HChar dis_buf[50];
IRTemp srcVec = newTemp(Ity_V128);
UChar modrm = getUChar(delta);
- UChar* mbV = isAvx ? "v" : "";
+ HChar* mbV = isAvx ? "v" : "";
UInt rG = gregOfRexRM(pfx, modrm);
if ( epartIsReg( modrm ) ) {
IRTemp srcI64 = newTemp(Ity_I64);
IRTemp srcVec = newTemp(Ity_V128);
UChar modrm = getUChar(delta);
- UChar* mbV = isAvx ? "v" : "";
- UChar how = xIsZ ? 'z' : 's';
+ HChar* mbV = isAvx ? "v" : "";
+ HChar how = xIsZ ? 'z' : 's';
UInt rG = gregOfRexRM(pfx, modrm);
/* Compute both srcI64 -- the value to expand -- and srcVec -- same
thing in a V128, with arbitrary junk in the top 64 bits. Use
HChar dis_buf[50];
IRTemp srcVec = newTemp(Ity_V128);
UChar modrm = getUChar(delta);
- UChar* mbV = isAvx ? "v" : "";
- UChar how = xIsZ ? 'z' : 's';
+ HChar* mbV = isAvx ? "v" : "";
+ HChar how = xIsZ ? 'z' : 's';
UInt rG = gregOfRexRM(pfx, modrm);
if ( epartIsReg(modrm) ) {
UInt rE = eregOfRexRM(pfx, modrm);
HChar dis_buf[50];
IRTemp srcBytes = newTemp(Ity_I16);
UChar modrm = getUChar(delta);
- UChar* mbV = isAvx ? "v" : "";
+ HChar* mbV = isAvx ? "v" : "";
UInt rG = gregOfRexRM(pfx, modrm);
if ( epartIsReg(modrm) ) {
UInt rE = eregOfRexRM(pfx, modrm);
HChar dis_buf[50];
IRTemp srcVec = newTemp(Ity_V128);
UChar modrm = getUChar(delta);
- UChar* mbV = isAvx ? "v" : "";
+ HChar* mbV = isAvx ? "v" : "";
UInt rG = gregOfRexRM(pfx, modrm);
if ( epartIsReg(modrm) ) {
UInt rE = eregOfRexRM(pfx, modrm);
Int alen = 0;
HChar dis_buf[50];
UChar modrm = getUChar(delta);
- UChar* mbV = isAvx ? "v" : "";
+ HChar* mbV = isAvx ? "v" : "";
IRTemp sV = newTemp(Ity_V128);
IRTemp sHi = newTemp(Ity_I64);
IRTemp sLo = newTemp(Ity_I64);
IRTemp xmm_vec = newTemp(Ity_V128);
IRTemp sel_lane = newTemp(Ity_I32);
IRTemp shr_lane = newTemp(Ity_I32);
- UChar* mbV = isAvx ? "v" : "";
+ HChar* mbV = isAvx ? "v" : "";
UChar modrm = getUChar(delta);
IRTemp t3, t2, t1, t0;
Int imm8;
UInt rD = gregOfRexRM(pfx, modrm);
IRTemp tD = newTemp(Ity_V256);
Bool isA = have66noF2noF3(pfx);
- UChar ch = isA ? 'a' : 'u';
+ HChar ch = isA ? 'a' : 'u';
if (epartIsReg(modrm)) {
UInt rS = eregOfRexRM(pfx, modrm);
delta += 1;
UInt rD = gregOfRexRM(pfx, modrm);
IRTemp tD = newTemp(Ity_V128);
Bool isA = have66noF2noF3(pfx);
- UChar ch = isA ? 'a' : 'u';
+ HChar ch = isA ? 'a' : 'u';
if (epartIsReg(modrm)) {
UInt rS = eregOfRexRM(pfx, modrm);
delta += 1;
UInt rS = gregOfRexRM(pfx, modrm);
IRTemp tS = newTemp(Ity_V256);
Bool isA = have66noF2noF3(pfx);
- UChar ch = isA ? 'a' : 'u';
+ HChar ch = isA ? 'a' : 'u';
assign(tS, getYMMReg(rS));
if (epartIsReg(modrm)) {
UInt rD = eregOfRexRM(pfx, modrm);
UInt rS = gregOfRexRM(pfx, modrm);
IRTemp tS = newTemp(Ity_V128);
Bool isA = have66noF2noF3(pfx);
- UChar ch = isA ? 'a' : 'u';
+ HChar ch = isA ? 'a' : 'u';
assign(tS, getXMMReg(rS));
if (epartIsReg(modrm)) {
UInt rD = eregOfRexRM(pfx, modrm);
IRTemp dV = newTemp(Ity_V128);
IRTemp sHi, sLo, dHi, dLo;
sHi = sLo = dHi = dLo = IRTemp_INVALID;
- UChar ch = '?';
+ HChar ch = '?';
Int laneszB = 0;
UChar modrm = getUChar(delta);
UInt rG = gregOfRexRM(pfx,modrm);
vassert(rN < 16);
vassert(bU < 2);
vassert(imm12 < 0x1000);
- UChar opChar = bU == 1 ? '+' : '-';
+ HChar opChar = bU == 1 ? '+' : '-';
DIS(buf, "[r%u, #%c%u]", rN, opChar, imm12);
return
binop( (bU == 1 ? Iop_Add32 : Iop_Sub32),
vassert(rM < 16);
vassert(sh2 < 4);
vassert(imm5 < 32);
- UChar opChar = bU == 1 ? '+' : '-';
+ HChar opChar = bU == 1 ? '+' : '-';
IRExpr* index = NULL;
switch (sh2) {
case 0: /* LSL */
vassert(rN < 16);
vassert(bU < 2);
vassert(imm8 < 0x100);
- UChar opChar = bU == 1 ? '+' : '-';
+ HChar opChar = bU == 1 ? '+' : '-';
DIS(buf, "[r%u, #%c%u]", rN, opChar, imm8);
return
binop( (bU == 1 ? Iop_Add32 : Iop_Sub32),
vassert(rN < 16);
vassert(bU < 2);
vassert(rM < 16);
- UChar opChar = bU == 1 ? '+' : '-';
+ HChar opChar = bU == 1 ? '+' : '-';
IRExpr* index = getIRegA(rM);
DIS(buf, "[r%u, %c r%u]", rN, opChar, rM);
return binop(bU == 1 ? Iop_Add32 : Iop_Sub32,
block are tagged with a 1 bit.
*/
static Bool compute_ITSTATE ( /*OUT*/UInt* itstate,
- /*OUT*/UChar* ch1,
- /*OUT*/UChar* ch2,
- /*OUT*/UChar* ch3,
+ /*OUT*/HChar* ch1,
+ /*OUT*/HChar* ch2,
+ /*OUT*/HChar* ch3,
UInt firstcond, UInt mask )
{
vassert(firstcond <= 0xF);
IROp addOp;
IROp andOp;
IROp shOp;
- char regType = Q ? 'q' : 'd';
+ HChar regType = Q ? 'q' : 'd';
if (size == 3)
return False;
/* VQADD */
IROp op, op2;
IRTemp tmp;
- char reg_t = Q ? 'q' : 'd';
+ HChar reg_t = Q ? 'q' : 'd';
if (Q) {
switch (size) {
case 0:
UInt newITSTATE = 0;
/* This is the ITSTATE represented as described in
libvex_guest_arm.h. It is not the ARM ARM representation. */
- UChar c1 = '.';
- UChar c2 = '.';
- UChar c3 = '.';
+ HChar c1 = '.';
+ HChar c2 = '.';
+ HChar c3 = '.';
Bool valid = compute_ITSTATE( &newITSTATE, &c1, &c2, &c3,
firstcond, mask );
if (valid && firstcond != 0xF/*NV*/) {
case 0x1A0: // xvsubdp (VSX Vector Subtract Double-Precision)
{
IROp mOp;
- Char * oper_name;
+ HChar * oper_name;
switch (opc2) {
case 0x1E0:
mOp = Iop_DivF64;
*/
Bool negate;
IROp mOp = Iop_INVALID;
- Char * oper_name = NULL;
+ HChar * oper_name = NULL;
Bool mdp = False;
switch (opc2) {
IRTemp t3, t2, t1, t0;
Bool msp = False;
Bool negate;
- Char * oper_name = NULL;
+ HChar * oper_name = NULL;
IROp mOp = Iop_INVALID;
switch (opc2) {
case 0x104: case 0x124:
/*
* Helper function for vector/scalar double precision fp round to integer instructions.
*/
-static IRExpr * _do_vsx_fp_roundToInt(IRTemp frB_I64, UInt opc2, UChar * insn_suffix)
+static IRExpr * _do_vsx_fp_roundToInt(IRTemp frB_I64, UInt opc2, HChar * insn_suffix)
{
/* The same rules apply for x{s|v}rdpi{m|p|c|z} as for floating point round operations (fri{m|n|p|z}). */
IRTemp frBLo_I64 = newTemp(Ity_I64);
IRExpr * frD_fp_roundHi = NULL;
IRExpr * frD_fp_roundLo = NULL;
- UChar * insn_suffix = NULL;
+ HChar * insn_suffix = NULL;
assign( frBHi_I64, unop( Iop_V128HIto64, getVSReg( XB ) ) );
frD_fp_roundHi = _do_vsx_fp_roundToInt(frBHi_I64, opc2, insn_suffix);
case 0x152: // xvrspip (VSX Vector Round to SinglePrecision Integer using round toward +Infinity)
case 0x132: // xvrspiz (VSX Vector Round to SinglePrecision Integer using round toward Zero)
{
- UChar * insn_suffix = NULL;
+ HChar * insn_suffix = NULL;
IROp op;
if (opc2 != 0x156) {
// Use pre-defined IRop's for vrfi{m|n|p|z}
{
IRTemp frB_I64 = newTemp(Ity_I64);
IRExpr * frD_fp_round = NULL;
- UChar * insn_suffix = NULL;
+ HChar * insn_suffix = NULL;
assign(frB_I64, unop(Iop_V128HIto64, mkexpr( vB )));
frD_fp_round = _do_vsx_fp_roundToInt(frB_I64, opc2, insn_suffix);
case 0x48: // xxmrghw (VSX Merge High Word)
case 0xc8: // xxmrglw (VSX Merge Low Word)
{
- char type = (opc2 == 0x48) ? 'h' : 'l';
+ HChar type = (opc2 == 0x48) ? 'h' : 'l';
IROp word_op = (opc2 == 0x48) ? Iop_V128HIto64 : Iop_V128to64;
IRTemp a64 = newTemp(Ity_I64);
IRTemp ahi32 = newTemp(Ity_I32);
struct vsx_insn {
UInt opcode;
- Char * name;
+ HChar * name;
};
// ATTENTION: Keep this array sorted on the opcocde!!!