bool ClangToSageTranslator::VisitTypedefDecl(clang::TypedefDecl * typedef_decl, SgNode ** node) {
#if DEBUG_VISIT_DECL
std::cerr << "ClangToSageTranslator::VisitTypedefDecl" << std::endl;
#endif
bool res = true;
SgName name(typedef_decl->getNameAsString());
SgType * type = buildTypeFromQualifiedType(typedef_decl->getUnderlyingType());
SgTypedefDeclaration * sg_typedef_decl = SageBuilder::buildTypedefDeclaration_nfi(name, type, SageBuilder::topScopeStack());
if (isSgClassType(type)) {
std::map<SgClassType *, bool>::iterator bool_it = p_class_type_decl_first_see_in_type.find(isSgClassType(type));
ROSE_ASSERT(bool_it != p_class_type_decl_first_see_in_type.end());
if (bool_it->second) {
sg_typedef_decl->set_declaration(isSgNamedType(type)->get_declaration()->get_definingDeclaration());
sg_typedef_decl->set_typedefBaseTypeContainsDefiningDeclaration(true);
}
}
else if (isSgEnumType(type)) {
std::map<SgEnumType *, bool>::iterator bool_it = p_enum_type_decl_first_see_in_type.find(isSgEnumType(type));
ROSE_ASSERT(bool_it != p_enum_type_decl_first_see_in_type.end());
if (bool_it->second) {
sg_typedef_decl->set_declaration(isSgEnumType(type)->get_declaration()->get_definingDeclaration());
sg_typedef_decl->set_typedefBaseTypeContainsDefiningDeclaration(true);
}
}
*node = sg_typedef_decl;
return VisitTypedefNameDecl(typedef_decl, node) && res;
}
bool ClangToSageTranslator::VisitFieldDecl(clang::FieldDecl * field_decl, SgNode ** node) {
#if DEBUG_VISIT_DECL
std::cerr << "ClangToSageTranslator::VisitFieldDecl" << std::endl;
#endif
bool res = true;
SgName name(field_decl->getNameAsString());
SgType * type = buildTypeFromQualifiedType(field_decl->getType());
clang::Expr * init_expr = field_decl->getInClassInitializer();
SgNode * tmp_init = Traverse(init_expr);
SgExpression * expr = isSgExpression(tmp_init);
// TODO expression list if aggregated initializer !
if (tmp_init != NULL && expr == NULL) {
std::cerr << "Runtime error: not a SgInitializer..." << std::endl;
res = false;
}
SgInitializer * init = expr != NULL ? SageBuilder::buildAssignInitializer_nfi(expr, expr->get_type()) : NULL;
if (init != NULL)
applySourceRange(init, init_expr->getSourceRange());
// Cannot use 'SageBuilder::buildVariableDeclaration' because of anonymous field
// *node = SageBuilder::buildVariableDeclaration(name, type, init, SageBuilder::topScopeStack());
// Build it by hand...
SgVariableDeclaration * var_decl = new SgVariableDeclaration(name, type, init);
if (isSgClassType(type)) {
std::map<SgClassType *, bool>::iterator bool_it = p_class_type_decl_first_see_in_type.find(isSgClassType(type));
ROSE_ASSERT(bool_it != p_class_type_decl_first_see_in_type.end());
if (bool_it->second) {
var_decl->set_baseTypeDefiningDeclaration(isSgNamedType(type)->get_declaration()->get_definingDeclaration());
var_decl->set_variableDeclarationContainsBaseTypeDefiningDeclaration(true);
}
}
else if (isSgEnumType(type)) {
std::map<SgEnumType *, bool>::iterator bool_it = p_enum_type_decl_first_see_in_type.find(isSgEnumType(type));
ROSE_ASSERT(bool_it != p_enum_type_decl_first_see_in_type.end());
if (bool_it->second) {
var_decl->set_baseTypeDefiningDeclaration(isSgEnumType(type)->get_declaration()->get_definingDeclaration());
var_decl->set_variableDeclarationContainsBaseTypeDefiningDeclaration(true);
}
}
var_decl->set_firstNondefiningDeclaration(var_decl);
var_decl->set_parent(SageBuilder::topScopeStack());
ROSE_ASSERT(var_decl->get_variables().size() == 1);
SgInitializedName * init_name = var_decl->get_variables()[0];
ROSE_ASSERT(init_name != NULL);
init_name->set_scope(SageBuilder::topScopeStack());
applySourceRange(init_name, field_decl->getSourceRange());
SgVariableDefinition * var_def = isSgVariableDefinition(init_name->get_declptr());
ROSE_ASSERT(var_def != NULL);
applySourceRange(var_def, field_decl->getSourceRange());
SgVariableSymbol * var_symbol = new SgVariableSymbol(init_name);
SageBuilder::topScopeStack()->insert_symbol(name, var_symbol);
*node = var_decl;
return VisitDeclaratorDecl(field_decl, node) && res;
}
bool ClangToSageTranslator::VisitVarDecl(clang::VarDecl * var_decl, SgNode ** node) {
#if DEBUG_VISIT_DECL
std::cerr << "ClangToSageTranslator::VisitVarDecl" << std::endl;
#endif
bool res = true;
// Create the SAGE node: SgVariableDeclaration
SgName name(var_decl->getNameAsString());
SgType * type = buildTypeFromQualifiedType(var_decl->getType());
clang::Expr * init_expr = var_decl->getInit();
SgNode * tmp_init = Traverse(init_expr);
SgExpression * expr = isSgExpression(tmp_init);
if (tmp_init != NULL && expr == NULL) {
std::cerr << "Runtime error: not a SgInitializer..." << std::endl; // TODO
res = false;
}
SgExprListExp * expr_list_expr = isSgExprListExp(expr);
SgInitializer * init = NULL;
if (expr_list_expr != NULL)
init = SageBuilder::buildAggregateInitializer(expr_list_expr, type);
else if (expr != NULL)
init = SageBuilder::buildAssignInitializer_nfi(expr, expr->get_type());
if (init != NULL)
applySourceRange(init, init_expr->getSourceRange());
SgVariableDeclaration * sg_var_decl = new SgVariableDeclaration(name, type, init); // scope: obtain from the scope stack.
if (isSgClassType(type)) {
std::map<SgClassType *, bool>::iterator bool_it = p_class_type_decl_first_see_in_type.find(isSgClassType(type));
ROSE_ASSERT(bool_it != p_class_type_decl_first_see_in_type.end());
if (bool_it->second) {
sg_var_decl->set_baseTypeDefiningDeclaration(isSgNamedType(type)->get_declaration()->get_definingDeclaration());
sg_var_decl->set_variableDeclarationContainsBaseTypeDefiningDeclaration(true);
}
}
else if (isSgEnumType(type)) {
std::map<SgEnumType *, bool>::iterator bool_it = p_enum_type_decl_first_see_in_type.find(isSgEnumType(type));
ROSE_ASSERT(bool_it != p_enum_type_decl_first_see_in_type.end());
if (bool_it->second) {
sg_var_decl->set_baseTypeDefiningDeclaration(isSgEnumType(type)->get_declaration()->get_definingDeclaration());
sg_var_decl->set_variableDeclarationContainsBaseTypeDefiningDeclaration(true);
}
}
sg_var_decl->set_firstNondefiningDeclaration(sg_var_decl);
sg_var_decl->set_parent(SageBuilder::topScopeStack());
ROSE_ASSERT(sg_var_decl->get_variables().size() == 1);
SgInitializedName * init_name = sg_var_decl->get_variables()[0];
ROSE_ASSERT(init_name != NULL);
init_name->set_scope(SageBuilder::topScopeStack());
applySourceRange(init_name, var_decl->getSourceRange());
SgVariableDefinition * var_def = isSgVariableDefinition(init_name->get_declptr());
ROSE_ASSERT(var_def != NULL);
applySourceRange(var_def, var_decl->getSourceRange());
SgVariableSymbol * var_symbol = new SgVariableSymbol(init_name);
SageBuilder::topScopeStack()->insert_symbol(name, var_symbol);
*node = sg_var_decl;
return VisitDeclaratorDecl(var_decl, node) && res;
}
void ModelBuilder::add(Model::model_t & model, SgType * sg_type) {
SgModifierType * modifier_type = isSgModifierType(sg_type);
if (modifier_type != NULL) {
add(model, modifier_type->get_base_type());
return;
}
Model::type_t element = Model::build<Model::e_model_type>();
element->node->type = sg_type;
SgNamedType * named_type = isSgNamedType(sg_type);
SgArrayType * array_type = isSgArrayType(sg_type);
SgPointerType * pointer_type = isSgPointerType(sg_type);
SgReferenceType * reference_type = isSgReferenceType(sg_type);
if (named_type != NULL) {
SgClassType * class_type = isSgClassType(named_type);
SgEnumType * enum_type = isSgEnumType(named_type);
SgTypedefType * typedef_type = isSgTypedefType(named_type);
SgDeclarationStatement * decl_stmt = named_type->get_declaration()->get_firstNondefiningDeclaration();
assert(decl_stmt != NULL);
SgSymbol * decl_sym = decl_stmt->get_symbol_from_symbol_table();
assert(decl_sym != NULL);
if (class_type != NULL) {
element->node->kind = Model::node_t<Model::e_model_type>::e_class_type;
SgClassSymbol * class_sym = isSgClassSymbol(decl_sym);
assert(class_sym != NULL);
element->node->base_class = model.lookup_class(class_sym);
if (element->node->base_class == NULL) {
add(model, class_sym);
element->node->base_class = model.lookup_class(class_sym);
}
assert(element->node->base_class != NULL);
}
else if (enum_type != NULL) {
element->node->kind = Model::node_t<Model::e_model_type>::e_enum_type;
SgEnumSymbol * enum_sym = isSgEnumSymbol(decl_sym);
assert(enum_sym != NULL);
element->node->enum_symbol = enum_sym;
}
else if (typedef_type != NULL) {
element->node->kind = Model::node_t<Model::e_model_type>::e_typedef_type;
SgTypedefSymbol * typedef_sym = isSgTypedefSymbol(decl_sym);
assert(typedef_sym != NULL);
element->node->typedef_symbol = typedef_sym;
element->node->base_type = model.lookup_type(typedef_type->get_base_type());
if (element->node->base_type == NULL) {
add(model, typedef_type->get_base_type());
element->node->base_type = model.lookup_type(typedef_type->get_base_type());
}
assert(element->node->base_type != NULL);
}
else assert(false);
}
else if (array_type != NULL) {
element->node->kind = Model::node_t<Model::e_model_type>::e_array_type;
element->node->base_type = model.lookup_type(array_type->get_base_type());
if (element->node->base_type == NULL) {
add(model, array_type->get_base_type());
element->node->base_type = model.lookup_type(array_type->get_base_type());
}
assert(element->node->base_type != NULL);
}
else if (pointer_type != NULL) {
element->node->kind = Model::node_t<Model::e_model_type>::e_pointer_type;
element->node->base_type = model.lookup_type(pointer_type->get_base_type());
if (element->node->base_type == NULL) {
add(model, pointer_type->get_base_type());
element->node->base_type = model.lookup_type(pointer_type->get_base_type());
}
assert(element->node->base_type != NULL);
}
else if (reference_type != NULL) {
element->node->kind = Model::node_t<Model::e_model_type>::e_reference_type;
element->node->base_type = model.lookup_type(reference_type->get_base_type());
if (element->node->base_type == NULL) {
add(model, reference_type->get_base_type());
element->node->base_type = model.lookup_type(reference_type->get_base_type());
}
assert(element->node->base_type != NULL);
}
else {
element->node->kind = Model::node_t<Model::e_model_type>::e_native_type;
}
element->scope->parent.a_namespace = NULL; /// \todo
model.types.push_back(element);
}
const SgEnumDeclaration *Type::getEnumDeclaration() const {
if( const SgEnumType *enumt = isSgEnumType( t_ ) )
return isSgEnumDeclaration( enumt->get_declaration() );
return 0;
}
bool Type::isEnum() const {
return isSgEnumType(t_) != 0;
}
std::string writeSgBinaryOpZ3(SgBinaryOp* op, SgExpression* lhs, SgExpression* rhs) {
std::stringstream ss;
std::string opStr;
bool compAssign = false;
if (isSgCompoundAssignOp(op)) {
compAssign = true;
opStr = getSgCompoundAssignOp(isSgCompoundAssignOp(op));
}
else {
opStr = getSgBinaryOp(op);
}
ROSE_ASSERT(opStr != "unknown");
std::string rhsstring;
std::string lhsstring;
lhsstring = getSgExpressionString(lhs);
SgType* lhstyp;
SgType* rhstyp;
if (isSgArrayType(lhs->get_type())) {
lhstyp = isSgArrayType(lhs->get_type())->get_base_type();
}
else {
lhstyp = lhs->get_type();
}
if (isSgArrayType(rhs->get_type())) {
rhstyp = isSgArrayType(rhs->get_type())->get_base_type();
}
else {
rhstyp = rhs->get_type();
}
if (isSgEnumType(lhs->get_type())) {
}
else {
ROSE_ASSERT(lhstyp == rhstyp);
}
if (isSgValueExp(rhs)) {
rhsstring = getSgValueExp(isSgValueExp(rhs));
}
else if (isSgUnaryOp(rhs)) {
rhsstring = getSgUnaryOp(isSgUnaryOp(rhs));
}
else {
rhsstring = getSgExpressionString(rhs);
}
if (opStr == "/" && lhstyp->isIntegerType()) {
opStr = "cdiv";
}
if (opStr == "assign" || compAssign) {
if (isSgVarRefExp(lhs)) {
SgVarRefExp* lhsSgVarRefExp = isSgVarRefExp(lhs);
int instances = SymbolToInstances[lhsSgVarRefExp->get_symbol()];
std::stringstream instanceName;
SymbolToInstances[lhsSgVarRefExp->get_symbol()] = instances + 1;
std::string lhsname = SymbolToZ3[lhsSgVarRefExp->get_symbol()];
instanceName << lhsname << "_" << (instances+1);
SgType* varType = lhsSgVarRefExp->get_type();
std::string typeZ3;
if (varType->isFloatType()) {
typeZ3 = "Real";
}
else if (varType->isIntegerType()) {
typeZ3 = "Int";
}
else if (isSgEnumType(varType)) {
typeZ3 = isSgEnumType(varType)->get_name().getString();
}
else {
typeZ3 = "Unknown";
}
ss << "(declare-fun " << instanceName.str() << " () " << typeZ3 << ")\n";
if (!compAssign) {
ss << "(assert (= " << instanceName.str() << " " << rhsstring << "))";
}
else {
std::stringstream oldInstanceName;
oldInstanceName << lhsname << "_" << instances;
ss << "(assert (= " << instanceName.str() << " (" << opStr << " " << oldInstanceName.str() << " " << rhsstring << ")))";
}
}
else {
ROSE_ASSERT(isSgPntrArrRefExp(lhs));
std::string u_type;
SgPntrArrRefExp* lhspntr = isSgPntrArrRefExp(lhs);
SgVarRefExp* varlhspntr = isSgVarRefExp(lhspntr->get_lhs_operand());
SgArrayType* arrTy = isSgArrayType(varlhspntr->get_type());
if (arrTy->get_base_type()->isIntegerType()) {
u_type = "Int";
}
else if (arrTy->get_base_type()->isFloatType()) {
u_type = "Real";
}
else {
std::cout << "unknown base type for array" << std::endl;
ROSE_ASSERT(false);
}
std::stringstream oldInstanceName;
SgVarRefExp* varexp = isSgVarRefExp((isSgPntrArrRefExp(lhs))->get_lhs_operand());
oldInstanceName << SymbolToZ3[varexp->get_symbol()] << "_" << SymbolToInstances[varexp->get_symbol()];
int instances = SymbolToInstances[varexp->get_symbol()];
std::stringstream instanceName;
SymbolToInstances[varexp->get_symbol()] = instances + 1;
std::string lhsname = SymbolToZ3[varexp->get_symbol()];
instanceName << lhsname << "_" << instances+1;
ss << "(declare-const " << instanceName.str() << " (Array Int " << u_type << "))\n ";
std::string indexstring = getSgExpressionString(isSgPntrArrRefExp(lhs)->get_rhs_operand());
ss << "(assert (= (store " << oldInstanceName.str() << " " << indexstring << " " << rhsstring << ") " << instanceName.str() << "))";
}
}
else if (opStr == "neq") {
ss << "(not (= " << lhsstring << " " << rhsstring << "))";
}
else if (opStr == "or" || opStr == "and") {
std::stringstream val_stream;
if (pathNodeTruthValue.find(op) != pathNodeTruthValue.end()) {
bool logic_val = pathNodeTruthValue[op];
//std::cout << ";and/or lhsstring " << lhsstring << "\n";
//std::cout << ";and/or rhsstring " << rhsstring << "\n";
if (opStr == "and") {
if (logic_val) {
std::string p_decl = "(assert (= " + lhsstring + " true))";
declarations.push_back(p_decl);
ss << rhsstring;
//ss << "(and " << lhsstring << " " << rhsstring << ")";
}
else {
std::string p_decl = "(assert (= " + lhsstring + " false))";
declarations.push_back(p_decl);
ss << "false";
}
}
else {
if (logic_val) {
std::string p_decl = "(assert (= " + lhsstring + " true))";
declarations.push_back(p_decl);
ss << "true";
}
else {
std::string p_decl = "(assert (= " + lhsstring + " false))";
declarations.push_back(p_decl);
ss << rhsstring;
}
}
}
else {
ss << "";
}
}
else {
ss << "(" << opStr << " " << lhsstring << " " << rhsstring << ")";
}
return ss.str();
}
std::string initializeVariable(SgInitializedName* initName) {
//if array type we need to get the index expression
std::string index_expression_string;
std::stringstream nameStringStream;
SgName initNameName = initName->get_qualified_name();
SgSymbol* initNameSym = initName->search_for_symbol_from_symbol_table();
if (variablesOfNameX.find(initNameName.getString()) == variablesOfNameX.end()) {
nameStringStream << initNameName.getString() << "_0";
variablesOfNameX[initNameName.getString()] = 1;
}
else {
int occurrence = variablesOfNameX[initNameName.getString()];
nameStringStream << initNameName.getString() << "_" << occurrence;
variablesOfNameX[initNameName.getString()] = occurrence+1;
}
SymbolToZ3[initNameSym] = nameStringStream.str();
SymbolToInstances[initNameSym] = 0;
SgType* initNameType = initName->get_type();
std::string typeZ3;
if (initNameType->isIntegerType()) {
typeZ3 = "Int";
}
else if (initNameType->isFloatType()) {
typeZ3 = "Real";
}
else if (isSgArrayType(initNameType)) {
SgArrayType* arrTyp = isSgArrayType(initNameType);
ROSE_ASSERT(arrTyp != NULL);
SgType* underlying_type = arrTyp->get_base_type();
std::string array_typeZ3;
if (underlying_type->isIntegerType()) {
array_typeZ3 = "Int";
}
else if (underlying_type->isFloatType()) {
array_typeZ3 = "Real";
}
else {
std::cout << "unknown underlying type of array!" << std::endl;
std::cout << underlying_type->class_name() << std::endl;
ROSE_ASSERT(false);
}
SgExpression* ind = arrTyp->get_index();
std::stringstream arrStr;
index_expression_string = getSgExpressionString(ind);
typeZ3 = "(Array Int " + array_typeZ3 + ")";
}
else if (isSgClassType(initNameType)) {
std::cout << "structs are not yet implemented" << std::endl;
ROSE_ASSERT(false);
}
else if (isSgPointerType(initNameType)) {
std::cout << "pointers are not yet implemented" << std::endl;
ROSE_ASSERT(false);
}
else if (isSgEnumType(initNameType)) {
SgEnumType* et = isSgEnumType(initNameType);
SgEnumDeclaration* enum_d = isSgEnumDeclaration(et->getAssociatedDeclaration());
getSgDeclarationStatement(enum_d);
typeZ3 = et->get_name().getString();
}
else {
std::cout << "unknown type: " << initNameType->class_name() << std::endl;
ROSE_ASSERT(false);
}
std::string name = nameStringStream.str() + "_0";
std::stringstream streamZ3;
if (isSgArrayType(initNameType)) {
streamZ3 << "(declare-const " << name << " " << typeZ3 << ")";
streamZ3 << "\n(declare-fun " << name << "_len () Int)";
streamZ3 << "\n(assert (= " << name << "_len " << index_expression_string << "))";
#ifdef ARRAY_TEST
std::cout << "arrStream: " << streamZ3.str() << std::endl;
#endif
}
else if (isSgEnumType(initNameType)) {
streamZ3 << "(declare-const " << name << " " << typeZ3 << ")";
}
else {
streamZ3 << "(declare-fun " << name << " () " << typeZ3 << ")";
}
return streamZ3.str();
}
