bool AvailableCodeEliminationPass::ProcessStatementList(StatementList* s) { assert(s != NULL) ; bool changed = false ; list<int> statementsToRemove ; for (int i = 0 ; i < s->get_statement_count() ; ++i) { Statement* currentStatement = s->get_statement(i) ; assert(currentStatement != NULL) ; // Collect all output variables list<VariableSymbol*> currentOutputs = AllDefinedVariables(currentStatement); // See if there are any uses and or definitions bool hasUses = false ; bool hasDefs = false ; list<VariableSymbol*>::iterator varIter = currentOutputs.begin() ; while (varIter != currentOutputs.end()) { hasUses |= IsUsedBeforeDefined(s, i+1, *varIter) ; hasDefs |= HasDefs(s, i+1, *varIter) ; ++varIter ; } // If this statement happens to be a store statement, call the // appropriate functions for this as well. StoreStatement* currentStore = dynamic_cast<StoreStatement*>(currentStatement) ; if (currentStore != NULL) { hasUses |= HasUses(s, i+1, currentStore->get_destination_address()) ; hasDefs |= HasDefs(s, i+1, currentStore->get_destination_address()) ; } // If no uses, but definitions, mark this statement for removal if (hasUses == false && hasDefs == true) { // Put them in reverse order so when we remove them we don't mess // up the numbering statementsToRemove.push_front(i) ; changed = true ; } } // Now actually remove all statements that are marked as available list<int>::iterator removeIter = statementsToRemove.begin() ; while (removeIter != statementsToRemove.end()) { // Delete? delete s->remove_statement(*removeIter) ; ++removeIter ; } return changed ; }
bool IfConversionPass2::ConvertArrayStoreIf(IfStatement* toConvert) { Statement* thenPart = Denormalize(toConvert->get_then_part()) ; Statement* elsePart = Denormalize(toConvert->get_else_part()) ; StoreStatement* thenStore = dynamic_cast<StoreStatement*>(thenPart) ; StoreStatement* elseStore = dynamic_cast<StoreStatement*>(elsePart) ; assert(thenStore != NULL) ; assert(elseStore != NULL) ; ArrayReferenceExpression* thenRef = dynamic_cast<ArrayReferenceExpression*>(thenStore->get_destination_address()) ; ArrayReferenceExpression* elseRef = dynamic_cast<ArrayReferenceExpression*>(elseStore->get_destination_address()) ; assert(thenRef != NULL) ; assert(elseRef != NULL) ; // Verify that these array references are to the same location. if (!EquivalentExpressions(thenRef, elseRef)) { return false ; } // This will hopefully be scalar replaced later, but for now we just need // to do something... // What I need is the qualified element type of the array. QualifiedType* qualType = create_qualified_type(theEnv, thenRef->get_result_type()) ; StoreStatement* replacement = CreateBoolCall(thenRef) ; // Append the arguments to the call expression CallExpression* callExpr = dynamic_cast<CallExpression*>(replacement->get_value()) ; assert(callExpr != NULL) ; Expression* thenStoreValue = thenStore->get_value() ; thenStore->set_value(NULL) ; callExpr->append_argument(thenStoreValue) ; Expression* elseStoreValue = elseStore->get_value() ; elseStore->set_value(NULL) ; callExpr->append_argument(elseStoreValue) ; Expression* condition = toConvert->get_condition() ; toConvert->set_condition(NULL) ; callExpr->append_argument(condition) ; // Replace the if toConvert->get_parent()->replace(toConvert, replacement) ; return true ; }
static String handle_static_store_statement(CPrintStyleModule *state, const SuifObject *obj) { StoreStatement *stmt = to<StoreStatement>(obj); String return_str = "*("; return_str += state->print_to_string(stmt->get_destination_address()); return_str += ") = "; return_str += state->print_to_string(stmt->get_value()); return(return_str); }
bool IfConversionPass2::ConvertStoreIf(IfStatement* toConvert) { Statement* thenPart = Denormalize(toConvert->get_then_part()) ; StoreStatement* thenStore = dynamic_cast<StoreStatement*>(thenPart) ; assert(thenStore != NULL) ; Expression* destination = thenStore->get_destination_address() ; if (dynamic_cast<FieldAccessExpression*>(destination) != NULL) { return ConvertStructStoreIf(toConvert) ; } else if (dynamic_cast<ArrayReferenceExpression*>(destination) != NULL) { return ConvertArrayStoreIf(toConvert) ; } else { OutputError("Unsupported if detected!") ; assert(0) ; return false ; // To avoid a warning } }
bool IfConversionPass2::ConvertStructStoreIf(IfStatement* toConvert) { Statement* thenPart = Denormalize(toConvert->get_then_part()) ; Statement* elsePart = Denormalize(toConvert->get_else_part()) ; StoreStatement* thenStore = dynamic_cast<StoreStatement*>(thenPart) ; StoreStatement* elseStore = dynamic_cast<StoreStatement*>(elsePart) ; assert(thenStore != NULL) ; assert(elseStore != NULL) ; FieldAccessExpression* thenField = dynamic_cast<FieldAccessExpression*>(thenStore->get_destination_address()); FieldAccessExpression* elseField = dynamic_cast<FieldAccessExpression*>(elseStore->get_destination_address()); assert(thenField != NULL) ; assert(elseField != NULL) ; // Check to make sure that each field access is accessing the same field if (thenField->get_field() != elseField->get_field()) { return false ; } CallStatement* replacement = CreateBoolCall(thenField->get_field()) ; // Append the arguments Expression* thenStoreValue = thenStore->get_value() ; thenStore->set_value(NULL) ; replacement->append_argument(thenStoreValue) ; Expression* elseStoreValue = elseStore->get_value() ; elseStore->set_value(NULL) ; replacement->append_argument(elseStoreValue) ; Expression* condition = toConvert->get_condition() ; toConvert->set_condition(NULL) ; replacement->append_argument(condition) ; toConvert->get_parent()->replace(toConvert, replacement) ; return true ; }