Expression* CombineSummationPass::RemoveValue(Expression* original,
VariableSymbol* v)
{
assert(original != NULL) ;
assert(v != NULL) ;
BinaryExpression* binExp = dynamic_cast<BinaryExpression*>(original) ;
if (binExp == NULL)
{
return NULL ;
}
Expression* leftSide = binExp->get_source1() ;
Expression* rightSide = binExp->get_source2() ;
// Check to see if we are the correct format
LoadVariableExpression* leftVar =
dynamic_cast<LoadVariableExpression*>(leftSide) ;
LoadVariableExpression* rightVar =
dynamic_cast<LoadVariableExpression*>(rightSide) ;
if (leftVar != NULL && leftVar->get_source() == v)
{
binExp->set_source2(NULL) ;
return rightSide ;
}
if (rightVar != NULL && rightVar->get_source() == v)
{
binExp->set_source1(NULL) ;
return leftSide ;
}
// Recursively go through and find the value
Expression* leftSideReplacement = RemoveValue(leftSide, v) ;
if (leftSideReplacement != NULL)
{
binExp->set_source2(leftSideReplacement) ;
return binExp ;
}
Expression* rightSideReplacement = RemoveValue(rightSide, v) ;
if (rightSideReplacement != NULL)
{
binExp->set_source2(rightSideReplacement) ;
return binExp ;
}
return NULL ;
}
static
String handle_static_binary_expression(CPrintStyleModule *state,
const SuifObject *obj)
{
BinaryExpression *expr = to<BinaryExpression>(obj);
LString opc = expr->get_opcode();
String src_string1 = state->print_to_string(expr->get_source1());
String src_string2 = state->print_to_string(expr->get_source2());
// Should we special case: add, mod, etc?
for (size_t i = 0; i < NUM_BINARY_OPER; i++ ) {
if (*(binary_oper_table[i]._oper) == opc) {
const char *op_char = binary_oper_table[i]._op_char;
return(String("(") + src_string1 + op_char + src_string2 + ")");
}
}
return(String(opc) + "(" + src_string1 + "," + src_string2 + ")");
}
VariableSymbol* ReferenceCleanupPass::FindVariable(Expression* e)
{
LoadVariableExpression* lve = dynamic_cast<LoadVariableExpression*>(e) ;
BinaryExpression* be = dynamic_cast<BinaryExpression*>(e) ;
if (lve != NULL)
{
return lve->get_source() ;
}
if (be != NULL)
{
return FindVariable(be->get_source1()) ;
}
FormattedText tmpText ;
e->print(tmpText) ;
std::cout << tmpText.get_value() << std::endl ;
return NULL ;
}
bool CombineSummationPass::IsSummation(Expression* e, VariableSymbol* v)
{
assert(e != NULL) ;
assert(v != NULL) ;
BinaryExpression* binExp = dynamic_cast<BinaryExpression*>(e) ;
if (binExp == NULL)
{
return false ;
}
if (binExp->get_opcode() != LString("add"))
{
return false ;
}
Expression* leftSide = binExp->get_source1() ;
Expression* rightSide = binExp->get_source2() ;
LoadVariableExpression* leftLoadVar =
dynamic_cast<LoadVariableExpression*>(leftSide) ;
LoadVariableExpression* rightLoadVar =
dynamic_cast<LoadVariableExpression*>(rightSide) ;
if (leftLoadVar != NULL && leftLoadVar->get_source() == v)
{
return true ;
}
if (rightLoadVar != NULL && rightLoadVar->get_source() == v)
{
return true ;
}
return IsSummation(leftSide, v) || IsSummation(rightSide, v) ;
}
/* Another helper function for print_var_def(). This function
* expects that it will need to add a return before printing
* anything, and it expects that you will add a return after
* it is done.
* It returns the number of bits of initialization data that it
* generates.
*/
int
PrinterX86::process_value_block(ValueBlock *vblk)
{
int bits_filled = 0;
if (is_a<ExpressionValueBlock>(vblk)) {
// An ExpressionValueBlock either holds a constant value or a
// simple expression representing either an address relative to
// a symbol or a pointer generated by conversion from an integer
// constant (presumably zero).
ExpressionValueBlock *evb = (ExpressionValueBlock*)vblk;
Expression *exp = evb->get_expression();
if (is_a<IntConstant>(exp)) {
IntConstant *ic = (IntConstant*)exp;
bits_filled = print_size_directive(ic->get_result_type());
fprint(out, ic->get_value());
cur_opnd_cnt++;
}
else if (is_a<FloatConstant>(exp)) {
FloatConstant *fc = (FloatConstant*)exp;
bits_filled = print_size_directive(fc->get_result_type());
fputs(fc->get_value().c_str(), out);
cur_opnd_cnt++;
}
else {
// We use non-constant ExpressionValueBlocks to hold a symbolic
// address, optionally with an offset, or a pointer initializer
// consisting of a `convert' expression.
// A SymbolAddressExpression represents a plain symbolic
// address.
// An address obtained by conversion from another type is a
// unary expression with opcode "convert".
// A symbol+delta is represented by an add whose first operand
// is the load-address and whose second is an IntConstant
// expression.
// No other kind of "expression" is recognized.
if (is_a<UnaryExpression>(exp)) {
UnaryExpression *ux = (UnaryExpression*)exp;
claim(ux->get_opcode() == k_convert,
"unexpected unary expression in expression block");
DataType *tt = ux->get_result_type(); // target type
claim(is_kind_of<PointerType>(tt),
"unexpected target type when converting initializer");
exp = ux->get_source();
if (is_a<IntConstant>(exp)) {
IntConstant *ic = (IntConstant*)exp;
bits_filled = print_size_directive(tt);
fprint(out, ic->get_value());
cur_opnd_cnt++;
return bits_filled;
}
// Fall through to handle symbol-relative address, on the
// assumption that the front end validated the conversion.
}
SymbolAddressExpression *sax;
long delta;
if (is_a<BinaryExpression>(exp)) {
BinaryExpression *bx = (BinaryExpression*)exp;
claim(bx->get_opcode() == k_add,
"unexpected binary expression in expression block");
Expression *s1 = bx->get_source1();
Expression *s2 = bx->get_source2();
sax = to<SymbolAddressExpression>(s1);
delta = to<IntConstant>(s2)->get_value().c_long();
} else if (is_a<SymbolAddressExpression>(exp)) {
sax = (SymbolAddressExpression*)exp;
delta = 0;
} else {
claim(false, "unexpected kind of expression block");
}
Sym *sym = sax->get_addressed_symbol();
// symbol initialization
bits_filled = print_size_directive(type_ptr);
print_sym(sym);
if (delta != 0) {
fprintf(out, "%+ld", delta);
}
// always force the start of a new data directive
cur_opcode = opcode_null;
cur_opnd_cnt = 0;
}
}
else if (is_a<MultiValueBlock>(vblk)) {
MultiValueBlock *mvb = (MultiValueBlock*)vblk;
for (int i = 0; i < mvb->get_sub_block_count(); i++ ) {
int offset = mvb->get_sub_block(i).first.c_int();
claim(offset >= bits_filled);
if (bits_filled < offset) // pad to offset
bits_filled += print_bit_filler(offset - bits_filled);
bits_filled += process_value_block(mvb->get_sub_block(i).second);
}
int all_bits = get_bit_size(mvb->get_type());
if (all_bits > bits_filled)
bits_filled += print_bit_filler(all_bits - bits_filled);
} else if (is_a<RepeatValueBlock>(vblk)) {
// Simplifying assumption: We now expect the front-end
// to remove initialization code of large arrays of zeros.
RepeatValueBlock *rvb = (RepeatValueBlock*)vblk;
int repeat_cnt = rvb->get_num_repetitions();
if (repeat_cnt > 1) { // insert .repeat pseudo-op
fprintf(out, "\n\t%s\t%d", x86_opcode_names[REPEAT], repeat_cnt);
cur_opcode = opcode_null; // force new data directive
}
// actual data directive
bits_filled = repeat_cnt * process_value_block(rvb->get_sub_block());
if (repeat_cnt > 1) { // insert .endr pseudo-op
fprintf(out, "\n\t%s", x86_opcode_names[ENDR]);
cur_opcode = opcode_null; // force new data directive
}
} else if (is_a<UndefinedValueBlock>(vblk)) {
bits_filled += print_bit_filler(get_bit_size(vblk->get_type()));
} else {
claim(false, "unexpected kind of ValueBlock");
}
return bits_filled;
}
