static int
mem2str(operand_mem_val_t const *val, operand_mem_tag_t const *tag, int size,
bool rex_used, char *buf, int buflen)
{
char *ptr = buf, *end = buf + buflen;
char base_reg[16] = "";
char index_reg[16] = "";
if (val->segtype == segtype_sel) {
size_t seglen;
seglen = seg2str(val->seg.sel, tag->seg.sel, ptr, end - ptr);
if (seglen) {
ptr += seglen;
*ptr++ = ':';
}
} else if (val->segtype == segtype_desc) {
if (tag->seg.desc) {
ptr += snprintf(ptr, end - ptr, "C%d", val->seg.desc);
} else {
ptr += snprintf(ptr, end - ptr, "%d:", val->seg.desc);
}
}
*ptr='\0';
if (tag->disp) {
ptr += snprintf(ptr, end - ptr, "C%d", (int)val->disp);
} else {
if (val->disp) {
ptr += snprintf(ptr, end - ptr, "%llu", val->disp);
}
}
if (val->base != -1) {
reg2str(val->base, tag->base, val->addrsize, rex_used, base_reg,
sizeof base_reg);
} else {
snprintf(base_reg, sizeof base_reg, "%s", "");
}
if (val->index != -1) {
reg2str(val->index, tag->index, val->addrsize, rex_used, index_reg,
sizeof index_reg);
}
if (val->base != -1 || val->index != -1) {
ptr += snprintf(ptr, end - ptr, "(");
}
if (val->index != -1) {
ptr += snprintf(ptr, end - ptr, "%s,%s,%d", base_reg, index_reg, val->scale);
} else if (val->base != -1) {
ptr += snprintf(ptr, end - ptr, "%s", base_reg);
}
if (val->base != -1 || val->index != -1) {
ptr += snprintf(ptr, end - ptr, ")");
}
return ptr - buf;
}
std::string reg2str(int color, me::Op::Type type)
{
me::Reg reg(type, -1);
reg.color_ = color;
return reg2str(®);
}
static inline void out_reg(IVState *s, enum Reg reg, unsigned v)
{
const char *name = reg2str(reg);
g_test_message("%x -> *%s\n", v, name);
qpci_io_writel(s->dev, s->reg_bar, reg, v);
}
std::string ptr_index2str(me::Reg* reg, me::Reg* index, size_t offset)
{
swiftAssert(reg->type_ == me::Op::R_PTR, "must be an R_PTR here");
std::ostringstream oss;
if (offset)
oss << offset;
oss << '(' << reg2str(reg);
if (index)
oss << ", " << reg2str(index);
oss << ')';
return oss.str();
}
std::string spilledReg2str(int color, me::Op::Type type)
{
me::Reg reg(type, -1);
reg.isSpilled_ = true;
reg.color_ = color;
return reg2str(®);
}
static inline unsigned in_reg(IVState *s, enum Reg reg)
{
const char *name = reg2str(reg);
unsigned res;
res = qpci_io_readl(s->dev, s->reg_bar, reg);
g_test_message("*%s -> %x\n", name, res);
return res;
}
std::string memvar_index2str(me::MemVar* memVar, me::Reg* index, size_t offset)
{
std::ostringstream oss;
oss << x64_stacklayout->color2MemSlot_[memVar->color_].offset_ + offset
<< "(%rsp";
if (index)
oss << ", " << reg2str(index);
oss << ')';
return oss.str();
}
int
operand2str(operand_t const *op, char *buf, size_t size)
{
char *ptr = buf, *end = buf + size;
switch (op->type) {
case invalid:
DBE(INSN, dprintk("(inval)"));
break;
case op_reg:
ptr += reg2str(op->val.reg, op->tag.reg, op->size, op->rex_used,
ptr, end - ptr);
DBE(INSN, dprintk("(reg) %s", buf));
break;
case op_seg:
ptr += seg2str(op->val.seg, op->tag.seg, ptr, end - ptr);
DBE(INSN, dprintk("(seg) %s", buf));
break;
case op_mem:
ptr += mem2str(&op->val.mem, &op->tag.mem, op->size, op->rex_used, ptr,
end - ptr);
DBE(INSN, dprintk("(mem) %s", buf));
break;
case op_imm:
ptr += imm2str(op->val.imm, op->tag.imm, ptr, end - ptr);
DBE(INSN, dprintk("(imm) %s", buf));
break;
case op_pcrel:
ptr += pcrel2str(op->val.pcrel, op->tag.pcrel, ptr, end - ptr);
DBE(INSN, dprintk("(pcrel) %s", buf));
break;
case op_cr:
ptr += cr2str(op->val.cr, op->tag.cr, ptr, end - ptr);
DBE(INSN, dprintk("(cr) %s", buf));
break;
case op_db:
ptr += db2str(op->val.db, op->tag.db, ptr, end - ptr);
DBE(INSN, dprintk("(db) %s", buf));
break;
case op_tr:
ptr += tr2str(op->val.tr, op->tag.tr, ptr, end - ptr);
DBE(INSN, dprintk("(tr) %s", buf));
break;
case op_mmx:
ptr += mmx2str(op->val.mmx, op->tag.mmx, ptr, end - ptr);
DBE(INSN, dprintk("(mm) %s", buf));
break;
case op_xmm:
ptr += xmm2str(op->val.xmm, op->tag.xmm, ptr, end - ptr);
DBE(INSN, dprintk("(xmm) %s", buf));
break;
case op_3dnow:
ptr += op3dnow2str(op->val.d3now, op->tag.d3now, ptr, end - ptr);
DBE(INSN, dprintk("(3dnow) %s", buf));
break;
case op_prefix:
ptr += prefix2str(op->val.prefix, op->tag.prefix, ptr, end - ptr);
break;
case op_st:
ptr += st2str(op->val.st, op->tag.st, ptr, end - ptr);
break;
default:
dprintk("Invalid op->type[%d]\n", op->type);
ASSERT(0);
}
return ptr - buf;
}
void File::reset(Sti_t &i)
{
m_data[reg2str(Symbol::cnt)].resize(1);
m_data[reg2str(Symbol::cnt)].resize(1);
m_data[reg2str(Symbol::eq)].resize(1);
m_data[reg2str(Symbol::neq)].resize(1);
m_data[reg2str(Symbol::lt)].resize(1);
m_data[reg2str(Symbol::st)].resize(1);
m_data[reg2str(Symbol::ptr)].resize(1);
m_data[reg2str(Symbol::mrk)].resize(1);
m_data[reg2str(Symbol::size)].resize(1);
m_data[reg2str(Symbol::next)].resize(1);
m_data[reg2str(Symbol::prev)].resize(1);
m_data[reg2str(Symbol::and_statement)].resize(1);
m_data[reg2str(Symbol::or_statement)].resize(1);
m_data[reg2str(Symbol::xor_statement)].resize(1);
m_data[reg2str(Symbol::not_statement)].resize(1);
m_data[reg2str(Symbol::capt)].resize(1);
m_data[reg2str(Symbol::drf)].resize(1);
m_data[reg2str(Symbol::cntnt)].resize(1);
m_data[reg2str(Symbol::odir)].resize(1);
m_data[reg2str(Symbol::isdr)].resize(1);
m_data[reg2str(Symbol::extp)].resize(1);
m_data[reg2str(Symbol::fln)].resize(1);
m_data[reg2str(Symbol::match)].resize(1);
m_data[reg2str(Symbol::get)].resize(1);
m_data[reg2str(Symbol::set)].resize(1);
m_data[reg2str(Symbol::hght)].resize(1);
// getRegister(Symbol::cnt) = 0;
// getRegister(Symbol::eq) = 0;
// getRegister(Symbol::neq) = 0;
// getRegister(Symbol::lt) = 0;
// getRegister(Symbol::st) = 0;
getRegister(Symbol::ptr) = 0;
getRegister(Symbol::mrk) = 0;
// getRegister(Symbol::size) = 0;
getRegister(Symbol::next) = 0;
getRegister(Symbol::prev) = 0;
// getRegister(Symbol::and_statement) = 0;
// getRegister(Symbol::or_statement) = 0;
// getRegister(Symbol::xor_statement) = 0;
// getRegister(Symbol::not_statement) = 0;
// getRegister(Symbol::capt) = "";
// getRegister(Symbol::drf) = " ";
// getRegister(Symbol::cntnt) = 0;
// getRegister(Symbol::odir) = "";
// getRegister(Symbol::isdr) = 0;
// getRegister(Symbol::extp) = 0;
// getRegister(Symbol::fln) = 0;
// getRegister(Symbol::match) = 0;
// getRegister(Symbol::get) = 0;
// getRegister(Symbol::set) = 0;
// getRegister(Symbol::hght) = 0;
}
