int main(int argc, char* argv[]) {
SgProject* proj = frontend(argc,argv);
SgFunctionDeclaration* mainDecl = SageInterface::findMain(proj);
SgFunctionDefinition* mainDef = mainDecl->get_definition();
// std::vector<SgNode*> dotExps = NodeQuery::querySubTree(mainDef, V_SgDotExp);
std::vector<SgNode*> varRefs = NodeQuery::querySubTree(mainDef,V_SgVarRefExp);
int classExps = 0;
for (unsigned int i = 0; i < varRefs.size(); i++) {
if (isSgClassType(isSgVarRefExp(varRefs[i])->get_type())) {
SgClassType* ct = isSgClassType(isSgVarRefExp(varRefs[i])->get_type());
std::cout << "name of ref: " << isSgVarRefExp(varRefs[i])->get_symbol()->get_name().getString() << std::endl;
if (SageInterface::isStructType(ct)) {
SgDeclarationStatement* decl = isSgType(ct)->getAssociatedDeclaration();
SgDeclarationStatement* defining_decl = decl->get_definingDeclaration();
if (!(defining_decl->isNameOnly())) {
if (isSgClassDeclaration(defining_decl)) {
if (isSgClassDeclaration(defining_decl)->get_definition()) {
SgDeclarationStatementPtrList member_stats = isSgClassDeclaration(defining_decl)->get_definition()->get_members();
SgDeclarationStatementPtrList::iterator j = member_stats.begin();
for (; j != member_stats.end(); j++) {
SgDeclarationStatement* d = isSgDeclarationStatement(*j);
std::cout << "decl stat name: " << d->class_name() << std::endl;
SgInitializedNamePtrList init_lst = isSgVariableDeclaration(d)->get_variables();
SgInitializedNamePtrList::iterator k = init_lst.begin();
std::cout << "variables in initialized name ptr list..." << std::endl;
for (; k != init_lst.end(); k++) {
std::cout << isSgInitializedName(*k)->get_name().getString() << std::endl;
std::cout << isSgInitializedName(*k)->get_type()->class_name() << std::endl;
}
}
classExps+=1;
}
}
}
}
}
}
std::cout << "num class_exp: " << classExps << std::endl;
return 0;
}
bool ClangToSageTranslator::VisitTranslationUnitDecl(clang::TranslationUnitDecl * translation_unit_decl, SgNode ** node) {
#if DEBUG_VISIT_DECL
std::cerr << "ClangToSageTranslator::VisitTranslationUnitDecl" << std::endl;
#endif
if (*node != NULL) {
std::cerr << "Runtime error: The TranslationUnitDecl is already associated to a SAGE node." << std::endl;
return false;
}
// Create the SAGE node: SgGlobal
if (p_global_scope != NULL) {
std::cerr << "Runtime error: Global Scope have already been set !" << std::endl;
return false;
}
*node = p_global_scope = new SgGlobal();
p_decl_translation_map.insert(std::pair<clang::Decl *, SgNode *>(translation_unit_decl, p_global_scope));
// Traverse the children
SageBuilder::pushScopeStack(*node);
clang::DeclContext * decl_context = (clang::DeclContext *)translation_unit_decl; // useless but more clear
bool res = true;
clang::DeclContext::decl_iterator it;
for (it = decl_context->decls_begin(); it != decl_context->decls_end(); it++) {
if (*it == NULL) continue;
SgNode * child = Traverse(*it);
SgDeclarationStatement * decl_stmt = isSgDeclarationStatement(child);
if (decl_stmt == NULL && child != NULL) {
std::cerr << "Runtime error: the node produce for a clang::Decl is not a SgDeclarationStatement !" << std::endl;
std::cerr << " class = " << child->class_name() << std::endl;
res = false;
}
else if (child != NULL) {
// FIXME This is a hack to avoid autonomous decl of unnamed type to being added to the global scope....
SgClassDeclaration * class_decl = isSgClassDeclaration(child);
if (class_decl != NULL && (class_decl->get_name() == "" || class_decl->get_isUnNamed())) continue;
SgEnumDeclaration * enum_decl = isSgEnumDeclaration(child);
if (enum_decl != NULL && (enum_decl->get_name() == "" || enum_decl->get_isUnNamed())) continue;
p_global_scope->append_declaration(decl_stmt);
}
}
SageBuilder::popScopeStack();
// Traverse the class hierarchy
return VisitDecl(translation_unit_decl, node) && res;
}
const SgClassDeclaration *Type::getClassDeclaration() const {
if( const SgClassType *ct = isSgClassType(t_) ) {
if( const SgDeclarationStatement *dec = ct->get_declaration() ) {
if( const SgClassDeclaration *cdec = isSgClassDeclaration( dec ) ) {
//std::cout << "SgClassDeclaration: it's a declaration at line " << cdec->get_file_info()->get_line() << std::endl;
return cdec;
}
}
}
return 0;
}
//XXX problem? definition of class is retroactive to earlier forward declarations.
//XXX compare line numbers?
const SgClassDefinition *Type::getClassDefinition() const {
//std::cout << "getClassDefinition: "; //XXX
if( const SgClassDeclaration *cdec = getClassDeclaration() ) {
//std::cout << "it's a class declaration at line " << cdec->get_file_info()->get_line(); //XXX
if( const SgDeclarationStatement *defdec = cdec->get_definingDeclaration() ) {
//std::cout << " and it has a defining declaration at line " << defdec->get_file_info()->get_line(); //XXX
if( const SgClassDeclaration *defcdec = isSgClassDeclaration( defdec ) ) {
//std::cout << " and that's a class definition at line " << defcdec->get_file_info()->get_line(); //XXX
//std::cout << std::endl; //XXX
return cdec->get_definition();
}
}
}
//std::cout << std::endl; //XXX
return 0;
}
void
SgClassDeclaration::fixupCopy_symbols(SgNode* copy, SgCopyHelp & help) const
{
#if DEBUG_FIXUP_COPY
printf ("Inside of SgClassDeclaration::fixupCopy_symbols() for class = %s = %p = %s copy = %p (defining = %p firstNondefining = %p) \n",
this->get_name().str(),this,this->class_name().c_str(),copy,this->get_definingDeclaration(),this->get_firstNondefiningDeclaration());
#endif
SgClassDeclaration* classDeclaration_copy = isSgClassDeclaration(copy);
ROSE_ASSERT(classDeclaration_copy != NULL);
SgClassDefinition* classDefinition_original = this->get_definition();
SgClassDefinition* classDefinition_copy = classDeclaration_copy->get_definition();
// Call the base class fixupCopy member function
SgDeclarationStatement::fixupCopy_symbols(copy,help);
if (isForward() == false)
{
classDefinition_original->fixupCopy_symbols(classDefinition_copy,help);
}
}
Sage<SgMemberFunctionDeclaration>::build_scopes_t Driver<Sage>::getBuildScopes<SgMemberFunctionDeclaration>(const Sage<SgMemberFunctionDeclaration>::object_desc_t & desc) {
Sage<SgMemberFunctionDeclaration>::build_scopes_t result;
assert(desc.parent != NULL);
{
SgClassDeclaration * class_decl = desc.parent->get_declaration();
assert(class_decl != NULL);
class_decl = isSgClassDeclaration(class_decl->get_definingDeclaration());
assert(class_decl != NULL);
SgClassDefinition * class_defn = isSgClassDefinition(class_decl->get_definition());
assert(class_defn != NULL);
result.decl_scope = class_defn;
}
if (desc.create_definition) {
size_t file_id = desc.file_id;
if (file_id == 0) {
std::map<SgSymbol *, size_t>::iterator it_symbol_to_file_id = p_symbol_to_file_id_map.find(desc.parent);
assert(it_symbol_to_file_id != p_symbol_to_file_id_map.end());
file_id = it_symbol_to_file_id->second;
}
assert(file_id != 0);
std::map<size_t, SgSourceFile *>::iterator it_file = id_to_file_map.find(file_id);
assert(it_file != id_to_file_map.end());
SgSourceFile * defn_file = it_file->second;
assert(defn_file != NULL);
result.defn_scope = defn_file->get_globalScope();
}
else result.defn_scope = NULL;
return result;
}
SgJavaParameterizedType *AstParameterizedTypeAttribute::findOrInsertParameterizedType(std::vector<SgTemplateParameter *> *new_args_ptr) {
//
// Keep track of parameterized types in a table so as not to duplicate them.
//
for (std::list<SgJavaParameterizedType *>::iterator type_it = parameterizedTypes.begin(); type_it != parameterizedTypes.end(); type_it++) {
if (argumentsMatch((*type_it) -> get_type_list(), new_args_ptr)) {
return (*type_it);
}
}
//
// This parameterized type does not yet exist. Create it, store it in the table and return it.
//
SgClassDeclaration *classDeclaration = isSgClassDeclaration(genericType -> getAssociatedDeclaration());
ROSE_ASSERT(classDeclaration != NULL);
SgTemplateParameterList *typeParameterList = (new_args_ptr == NULL ? NULL : new SgTemplateParameterList());
if (new_args_ptr != NULL) {
typeParameterList -> set_args(*new_args_ptr);
}
SgJavaParameterizedType *parameterized_type = new SgJavaParameterizedType(classDeclaration, genericType, typeParameterList);
parameterizedTypes.push_front(parameterized_type);
return parameterized_type;
}
bool ClangToSageTranslator::VisitRecordDecl(clang::RecordDecl * record_decl, SgNode ** node) {
#if DEBUG_VISIT_DECL
std::cerr << "ClangToSageTranslator::VisitRecordDecl" << std::endl;
#endif
// FIXME May have to check the symbol table first, because of out-of-order traversal of C++ classes (Could be done in CxxRecord class...)
bool res = true;
SgClassDeclaration * sg_class_decl = NULL;
// Find previous declaration
clang::RecordDecl * prev_record_decl = record_decl->getPreviousDeclaration();
SgClassSymbol * sg_prev_class_sym = isSgClassSymbol(GetSymbolFromSymbolTable(prev_record_decl));
SgClassDeclaration * sg_prev_class_decl = sg_prev_class_sym == NULL ? NULL : isSgClassDeclaration(sg_prev_class_sym->get_declaration());
SgClassDeclaration * sg_first_class_decl = sg_prev_class_decl == NULL ? NULL : isSgClassDeclaration(sg_prev_class_decl->get_firstNondefiningDeclaration());
SgClassDeclaration * sg_def_class_decl = sg_prev_class_decl == NULL ? NULL : isSgClassDeclaration(sg_prev_class_decl->get_definingDeclaration());
ROSE_ASSERT(sg_first_class_decl != NULL || sg_def_class_decl == NULL);
bool had_prev_decl = sg_first_class_decl != NULL;
// Name
SgName name(record_decl->getNameAsString());
// Type of class
SgClassDeclaration::class_types type_of_class;
switch (record_decl->getTagKind()) {
case clang::TTK_Struct:
type_of_class = SgClassDeclaration::e_struct;
break;
case clang::TTK_Class:
type_of_class = SgClassDeclaration::e_class;
break;
case clang::TTK_Union:
type_of_class = SgClassDeclaration::e_union;
break;
default:
std::cerr << "Runtime error: RecordDecl can only be a struct/class/union." << std::endl;
res = false;
}
// Build declaration(s)
sg_class_decl = new SgClassDeclaration(name, type_of_class, NULL, NULL);
sg_class_decl->set_scope(SageBuilder::topScopeStack());
sg_class_decl->set_parent(SageBuilder::topScopeStack());
SgClassType * type = NULL;
if (sg_first_class_decl != NULL) {
type = sg_first_class_decl->get_type();
}
else {
type = SgClassType::createType(sg_class_decl);
}
ROSE_ASSERT(type != NULL);
sg_class_decl->set_type(type);
if (record_decl->isAnonymousStructOrUnion()) sg_class_decl->set_isUnNamed(true);
if (!had_prev_decl) {
sg_first_class_decl = sg_class_decl;
sg_first_class_decl->set_firstNondefiningDeclaration(sg_first_class_decl);
sg_first_class_decl->set_definingDeclaration(NULL);
sg_first_class_decl->set_definition(NULL);
sg_first_class_decl->setForward();
if (!record_decl->field_empty()) {
sg_def_class_decl = new SgClassDeclaration(name, type_of_class, type, NULL);
sg_def_class_decl->set_scope(SageBuilder::topScopeStack());
if (record_decl->isAnonymousStructOrUnion()) sg_def_class_decl->set_isUnNamed(true);
sg_def_class_decl->set_parent(SageBuilder::topScopeStack());
sg_class_decl = sg_def_class_decl; // we return thew defining decl
sg_def_class_decl->set_firstNondefiningDeclaration(sg_first_class_decl);
sg_def_class_decl->set_definingDeclaration(sg_def_class_decl);
sg_first_class_decl->set_definingDeclaration(sg_def_class_decl);
setCompilerGeneratedFileInfo(sg_first_class_decl);
}
}
else if (!record_decl->field_empty()) {
if (sg_def_class_decl != NULL) {
delete sg_class_decl;
*node = sg_def_class_decl;
return true;
}
sg_def_class_decl = sg_class_decl;
sg_def_class_decl->set_firstNondefiningDeclaration(sg_first_class_decl);
sg_def_class_decl->set_definingDeclaration(sg_def_class_decl);
sg_first_class_decl->set_definingDeclaration(sg_def_class_decl);
}
else // second (or more) non-defining declaration
return false; // FIXME ROSE need only one non-defining declaration (SageBuilder don't let me build another one....)
// Update symbol table
if (!had_prev_decl) {
SgScopeStatement * scope = SageBuilder::topScopeStack();
SgClassSymbol * class_symbol = new SgClassSymbol(sg_first_class_decl);
scope->insert_symbol(name, class_symbol);
}
// Build ClassDefinition
if (!record_decl->field_empty()) {
SgClassDefinition * sg_class_def = isSgClassDefinition(sg_def_class_decl->get_definition());
if (sg_class_def == NULL) {
sg_class_def = SageBuilder::buildClassDefinition_nfi(sg_def_class_decl);
}
sg_def_class_decl->set_definition(sg_class_def);
ROSE_ASSERT(sg_class_def->get_symbol_table() != NULL);
applySourceRange(sg_class_def, record_decl->getSourceRange());
SageBuilder::pushScopeStack(sg_class_def);
clang::RecordDecl::field_iterator it;
for (it = record_decl->field_begin(); it != record_decl->field_end(); it++) {
SgNode * tmp_field = Traverse(*it);
SgDeclarationStatement * field_decl = isSgDeclarationStatement(tmp_field);
ROSE_ASSERT(field_decl != NULL);
sg_class_def->append_member(field_decl);
field_decl->set_parent(sg_class_def);
}
SageBuilder::popScopeStack();
}
ROSE_ASSERT(sg_class_decl->get_definingDeclaration() == NULL || isSgClassDeclaration(sg_class_decl->get_definingDeclaration())->get_definition() != NULL);
ROSE_ASSERT(sg_first_class_decl->get_definition() == NULL);
ROSE_ASSERT(sg_def_class_decl == NULL || sg_def_class_decl->get_definition() != NULL);
*node = sg_class_decl;
return VisitTagDecl(record_decl, node) && res;
}
SgSymbol * ClangToSageTranslator::GetSymbolFromSymbolTable(clang::NamedDecl * decl) {
if (decl == NULL) return NULL;
SgScopeStatement * scope = SageBuilder::topScopeStack();
SgName name(decl->getNameAsString());
#if DEBUG_SYMBOL_TABLE_LOOKUP
std::cerr << "Lookup symbol for: " << name << std::endl;
#endif
if (name == "") {
return NULL;
}
std::list<SgScopeStatement *>::reverse_iterator it;
SgSymbol * sym = NULL;
switch (decl->getKind()) {
case clang::Decl::Typedef:
{
it = SageBuilder::ScopeStack.rbegin();
while (it != SageBuilder::ScopeStack.rend() && sym == NULL) {
sym = (*it)->lookup_typedef_symbol(name);
it++;
}
break;
}
case clang::Decl::Var:
case clang::Decl::ParmVar:
{
it = SageBuilder::ScopeStack.rbegin();
while (it != SageBuilder::ScopeStack.rend() && sym == NULL) {
sym = (*it)->lookup_variable_symbol(name);
it++;
}
break;
}
case clang::Decl::Function:
{
SgType * tmp_type = buildTypeFromQualifiedType(((clang::FunctionDecl *)decl)->getType());
SgFunctionType * type = isSgFunctionType(tmp_type);
ROSE_ASSERT(type);
it = SageBuilder::ScopeStack.rbegin();
while (it != SageBuilder::ScopeStack.rend() && sym == NULL) {
sym = (*it)->lookup_function_symbol(name, type);
it++;
}
break;
}
case clang::Decl::Field:
{
SgClassDeclaration * sg_class_decl = isSgClassDeclaration(Traverse(((clang::FieldDecl *)decl)->getParent()));
ROSE_ASSERT(sg_class_decl != NULL);
if (sg_class_decl->get_definingDeclaration() == NULL)
std::cerr << "Runtime Error: cannot find the definition of the class/struct associate to the field: " << name << std::endl;
else {
scope = isSgClassDeclaration(sg_class_decl->get_definingDeclaration())->get_definition();
// TODO: for C++, if 'scope' is in 'SageBuilder::ScopeStack': problem!!!
// It means that we are currently building the class
while (scope != NULL && sym == NULL) {
sym = scope->lookup_variable_symbol(name);
scope = scope->get_scope();
}
}
break;
}
case clang::Decl::CXXRecord:
case clang::Decl::Record:
{
it = SageBuilder::ScopeStack.rbegin();
while (it != SageBuilder::ScopeStack.rend() && sym == NULL) {
sym = (*it)->lookup_class_symbol(name);
it++;
}
break;
}
case clang::Decl::Label:
{
// Should not be reach as we use Traverse to retrieve Label (they are "terminal" statements) (it avoids the problem of forward use of label: goto before declaration)
name = SgName(((clang::LabelDecl *)decl)->getStmt()->getName());
it = SageBuilder::ScopeStack.rbegin();
while (it != SageBuilder::ScopeStack.rend() && sym == NULL) {
sym = (*it)->lookup_label_symbol(name);
it++;
}
break;
}
case clang::Decl::EnumConstant:
{
name = SgName(((clang::EnumConstantDecl *)decl)->getName());
it = SageBuilder::ScopeStack.rbegin();
while (it != SageBuilder::ScopeStack.rend() && sym == NULL) {
sym = (*it)->lookup_enum_field_symbol(name);
it++;
}
break;
}
case clang::Decl::Enum:
{
name = SgName(((clang::EnumDecl *)decl)->getName());
it = SageBuilder::ScopeStack.rbegin();
while (it != SageBuilder::ScopeStack.rend() && sym == NULL) {
sym = (*it)->lookup_enum_symbol(name);
it++;
}
break;
}
default:
std::cerr << "Runtime Error: Unknown type of Decl. (" << decl->getDeclKindName() << ")" << std::endl;
}
return sym;
}
void
FixupAstSymbolTables::visit ( SgNode* node )
{
// DQ (6/27/2005): Output the local symbol table from each scope.
// printf ("node = %s \n",node->sage_class_name());
SgScopeStatement* scope = isSgScopeStatement(node);
if (scope != NULL)
{
#if 0
printf ("AST Fixup: Fixup Symbol Table for %p = %s at: \n",scope,scope->class_name().c_str());
#endif
SgSymbolTable* symbolTable = scope->get_symbol_table();
if (symbolTable == NULL)
{
#if 0
printf ("AST Fixup: Fixup Symbol Table for %p = %s at: \n",scope,scope->class_name().c_str());
scope->get_file_info()->display("Symbol Table Location");
#endif
SgSymbolTable* tempSymbolTable = new SgSymbolTable();
ROSE_ASSERT(tempSymbolTable != NULL);
// name this table as compiler generated! The name is a static member used to store
// state for the next_symbol() functions. It is meaningless to set these.
// tempSymbolTable->set_name("compiler-generated symbol table");
scope->set_symbol_table(tempSymbolTable);
// reset the symbolTable using the get_symbol_table() member function
symbolTable = scope->get_symbol_table();
ROSE_ASSERT(symbolTable != NULL);
// DQ (2/16/2006): Set this parent directly (now tested)
symbolTable->set_parent(scope);
ROSE_ASSERT(symbolTable->get_parent() != NULL);
}
ROSE_ASSERT(symbolTable != NULL);
if (symbolTable->get_parent() == NULL)
{
printf ("Warning: Fixing up symbolTable, calling symbolTable->set_parent() (parent not previously set) \n");
symbolTable->set_parent(scope);
}
ROSE_ASSERT(symbolTable->get_parent() != NULL);
// Make sure that the internal hash table used in the symbol table is also present!
if (symbolTable->get_table() == NULL)
{
// DQ (6/27/2005): There are a lot of these built, perhaps more than we really need!
#if 0
printf ("AST Fixup: Building internal Symbol Table hash table (rose_hash_multimap) for %p = %s at: \n",
scope,scope->sage_class_name());
scope->get_file_info()->display("Symbol Table Location");
#endif
rose_hash_multimap* internalHashTable = new rose_hash_multimap();
ROSE_ASSERT(internalHashTable != NULL);
symbolTable->set_table(internalHashTable);
}
ROSE_ASSERT(symbolTable->get_table() != NULL);
SgSymbolTable::BaseHashType* internalTable = symbolTable->get_table();
ROSE_ASSERT(internalTable != NULL);
// DQ (6/23/2011): Note: Declarations that reference types that have not been seen yet may be placed into the
// wronge scope, then later when we see the correct scope we have a symbol in two or more symbol tables. The
// code below detects and fixes this problem.
// DQ (6/16/2011): List of symbols we need to remove from symbol tables where they are multibily represented.
std::vector<SgSymbol*> listOfSymbolsToRemove;
// DQ (6/12/2011): Fixup symbol table by removing symbols that are not associated with a declaration in the current scope.
int idx = 0;
SgSymbolTable::hash_iterator i = internalTable->begin();
while (i != internalTable->end())
{
// DQ: removed SgName casting operator to char*
// cout << "[" << idx << "] " << (*i).first.str();
ROSE_ASSERT ( (*i).first.str() != NULL );
ROSE_ASSERT ( isSgSymbol( (*i).second ) != NULL );
// printf ("Symbol number: %d (pair.first (SgName) = %s) pair.second (SgSymbol) sage_class_name() = %s \n",
// idx,(*i).first.str(),(*i).second->sage_class_name());
SgSymbol* symbol = isSgSymbol((*i).second);
ROSE_ASSERT ( symbol != NULL );
// We have to look at each type of symbol separately! This is because there is no virtual function,
// the reason for this is that each get_declaration() function returns a different type!
// ROSE_ASSERT ( symbol->get_declaration() != NULL );
switch(symbol->variantT())
{
case V_SgClassSymbol:
{
SgClassSymbol* classSymbol = isSgClassSymbol(symbol);
ROSE_ASSERT(classSymbol != NULL);
ROSE_ASSERT(classSymbol->get_declaration() != NULL);
SgDeclarationStatement* declarationToFindInScope = NULL;
// Search for the declaration in the associated scope.
declarationToFindInScope = classSymbol->get_declaration();
ROSE_ASSERT(declarationToFindInScope != NULL);
SgClassDeclaration* classDeclaration = isSgClassDeclaration(declarationToFindInScope);
ROSE_ASSERT(classDeclaration != NULL);
SgName name = classDeclaration->get_name();
// SgType* declarationType = declarationToFindInScope->get_type();
SgType* declarationType = classDeclaration->get_type();
ROSE_ASSERT(declarationType != NULL);
if (declarationToFindInScope->get_definingDeclaration() != NULL)
{
declarationToFindInScope = declarationToFindInScope->get_definingDeclaration();
SgClassDeclaration* definingClassDeclaration = isSgClassDeclaration(declarationToFindInScope);
ROSE_ASSERT(definingClassDeclaration != NULL);
// SgType* definingDeclarationType = declarationToFindInScope->get_type();
SgType* definingDeclarationType = definingClassDeclaration->get_type();
ROSE_ASSERT(definingDeclarationType != NULL);
// DQ (6/22/2011): This assertion fails for CompileTests/copyAST_tests/copytest2007_24.C
// A simple rule that all declarations should follow (now that we have proper global type tables).
// ROSE_ASSERT(definingDeclarationType == declarationType);
if (definingDeclarationType != declarationType)
{
printf ("In fixupSymbolTables.C: Note that definingDeclarationType != declarationType \n");
}
}
SgNamedType* namedType = isSgNamedType(declarationType);
ROSE_ASSERT(namedType != NULL);
SgDeclarationStatement* declarationAssociatedToType = namedType->get_declaration();
ROSE_ASSERT(declarationAssociatedToType != NULL);
#if 0
printf ("Found a symbol without a matching declaration in the current scope (declList): declarationToFindInScope = %p = %s \n",declarationToFindInScope,declarationToFindInScope->class_name().c_str());
printf ("Symbol number: %d (pair.first (SgName) = %s) pair.second (SgSymbol) class_name() = %s \n",idx,(*i).first.str(),(*i).second->class_name().c_str());
#endif
SgScopeStatement* scopeOfDeclarationToFindInScope = declarationToFindInScope->get_scope();
SgScopeStatement* scopeOfDeclarationAssociatedWithType = declarationAssociatedToType->get_scope();
#if 0
printf ("declarationToFindInScope = %p declarationToFindInScope->get_scope() = %p = %s \n",declarationToFindInScope,declarationToFindInScope->get_scope(),declarationToFindInScope->get_scope()->class_name().c_str());
printf ("declarationAssociatedToType = %p declarationAssociatedToType->get_scope() = %p = %s \n",declarationAssociatedToType,declarationAssociatedToType->get_scope(),declarationAssociatedToType->get_scope()->class_name().c_str());
#endif
if (scopeOfDeclarationToFindInScope != scopeOfDeclarationAssociatedWithType)
{
// DQ (6/12/2011): Houston, we have a problem! The trick is to fix it...
// A symbol has been placed into a scope when we could not be certain which scope it should be placed.
// We have a default of placing such symbols into the global scope, but it might be better to just have
// a special scope where such symbols could be placed so that we could have them separate from the global
// scope and then fix them up more clearly.
// Note that test2011_80.C still fails but the AST is at least correct (I think).
SgGlobal* scopeOfDeclarationToFindInScope_GlobalScope = isSgGlobal(scopeOfDeclarationToFindInScope);
// SgGlobal* scopeOfDeclarationAssociatedWithType_GlobalScope = isSgGlobal(scopeOfDeclarationAssociatedWithType);
if (scopeOfDeclarationToFindInScope_GlobalScope != NULL)
{
// In general which ever scope is the global scope is where the error is...???
// This is because when we don't know where to put a symbol (e.g. from a declaration of a pointer) we put it into global scope.
// There is even an agrument that this is correct as a default for C/C++, but only if it must exist (see test2011_80.C).
// Remove the symbol from the symbol table of the global scope.
printf ("Remove the associated symbol in the current symbol table \n");
// DQ (6/22/2011): This assertion fails for CompileTests/copyAST_tests/copytest2007_24.C
// ROSE_ASSERT (declarationToFindInScope->get_scope() == declarationAssociatedToType->get_scope());
if (declarationToFindInScope->get_scope() != declarationAssociatedToType->get_scope())
printf ("In fixupSymbolTables.C: Note that declarationToFindInScope->get_scope() != declarationAssociatedToType->get_scope() \n");
}
else
{
listOfSymbolsToRemove.push_back(classSymbol);
}
}
// ROSE_ASSERT (declarationToFindInScope->get_scope() == declarationAssociatedToType->get_scope());
break;
}
default:
{
// It night be there are are no other types of symbols to consider...
// printf ("Ignoring non SgClassSymbols (fixupSymbolTables.C) symbol = %s \n",symbol->class_name().c_str());
// ROSE_ASSERT(false);
}
}
// Increment iterator!
i++;
// Increment counter!
idx++;
}
// DQ (6/18/2011): Now that we are through with the symbol table we can support removal of any
// identified problematic symbol without worrying about STL iterator invalidation.
for (size_t j = 0; j < listOfSymbolsToRemove.size(); j++)
{
// Remove these symbols.
SgSymbol* removeSymbol = listOfSymbolsToRemove[j];
ROSE_ASSERT(removeSymbol != NULL);
SgSymbolTable* associatedSymbolTable = isSgSymbolTable(removeSymbol->get_parent());
ROSE_ASSERT(associatedSymbolTable != NULL);
ROSE_ASSERT(associatedSymbolTable == symbolTable);
associatedSymbolTable->remove(removeSymbol);
printf ("Redundant symbol removed...from symbol table \n");
// ROSE_ASSERT(false);
}
#if 0
// debugging
symbolTable->print("In FixupAstSymbolTables::visit(): printing out the symbol tables");
#endif
}
}
void
CompassAnalyses::VariableNameEqualsDatabaseName::Traversal::
visit(SgNode* node)
{
if( isSgAssignInitializer(node) != NULL )
assignExp = node;
if( isSgAssignOp(node) != NULL )
assignExp = node;
SgFunctionCallExp* funcCall = isSgFunctionCallExp(node);
// See if we have a dot expression or arrow expression which
// accesses the desired member function in the class we are looking for.
if ( funcCall != NULL )
{
SgExpression* funcExp = funcCall->get_function();
if ( ( isSgDotExp(funcExp) != NULL ) | ( isSgArrowExp(funcExp) != NULL ) )
{
SgBinaryOp* binOp = isSgBinaryOp(funcExp);
SgExpression* rhsOp = binOp->get_rhs_operand();
// SgExpression* lhsOp = binOp->get_lhs_operand();
if ( SgMemberFunctionRefExp* funcRef = isSgMemberFunctionRefExp(rhsOp) )
{
// std::cout << "c1\n" ;
SgMemberFunctionSymbol* funcSymbol = funcRef->get_symbol();
ROSE_ASSERT(funcSymbol->get_declaration() != NULL);
// DQ (1/16/2008): Note that the defining declaration need not exist (see test2001_11.C)
// ROSE_ASSERT(funcSymbol->get_declaration()->get_definingDeclaration() != NULL);
if (funcSymbol->get_declaration()->get_definingDeclaration() != NULL)
{
SgMemberFunctionDeclaration* funcDecl = isSgMemberFunctionDeclaration(funcSymbol->get_declaration()->get_definingDeclaration());
ROSE_ASSERT( funcDecl != NULL );
SgClassDefinition* clDef = isSgClassDefinition(funcDecl->get_scope());
SgClassDeclaration* clDecl = isSgClassDeclaration(clDef->get_declaration());
// SgClassDeclaration* clDecl = funcDecl->get_associatedClassDeclaration();
ROSE_ASSERT( clDecl != NULL );
std::string className = clDecl->get_name().getString();
ROSE_ASSERT(funcDecl != NULL);
std::string functionName = funcDecl->get_name().getString();
// If the class is the class we are looking for see if the member function
// access is to the member function we are interested in.
// std::cout << "className = " << className << std::endl;
// std::cout << "functionName = " << functionName << std::endl;
if ( (className == classToLookFor) && ( functionName == memberFunctionToLookFor ) )
{
SgExprListExp* actualArgs = funcCall->get_args();
SgExpressionPtrList& actualExpArgs = actualArgs->get_expressions ();
ROSE_ASSERT(actualExpArgs.size() == 1);
Rose_STL_Container<SgNode*> nodeLst = NodeQuery::querySubTree(*actualExpArgs.begin(), V_SgStringVal);
ROSE_ASSERT( nodeLst.size() > 0);
SgStringVal* actualArg = isSgStringVal(*nodeLst.begin());
ROSE_ASSERT(actualArg != NULL);
std::string stringArg = actualArg->get_value();
std::cout << "arg:" << stringArg << std::endl;
std::string varName;
// SgInitializedName* initName = NULL;
if ( SgAssignInitializer* assignInit = isSgAssignInitializer(assignExp) )
{
SgInitializedName* initName = isSgInitializedName(assignInit->get_parent());
ROSE_ASSERT(initName != NULL);
varName = initName->get_name().getString();
}
else
{
if ( SgAssignOp* assignOp = isSgAssignOp(assignExp) )
{
SgExpression* lhsOp = assignOp->get_lhs_operand();
SgVarRefExp* varRef = isSgVarRefExp(lhsOp);
ROSE_ASSERT(varRef!=NULL);
SgVariableSymbol* varSymbol = varRef->get_symbol();
ROSE_ASSERT(varSymbol != NULL);
SgInitializedName* initName = varSymbol->get_declaration();
varName = initName->get_name().getString();
}
}
if (varName != "")
{
// we are only interested in the part of the argument after the last ":"
// Database scopes in ALE3D are separated by ":"
size_t posCol = stringArg.find_last_of(':');
if (posCol != std::string::npos)
stringArg = stringArg.substr(posCol+1);
//Find violations to the rule
if ( stringArg != varName)
{
output->addOutput(new CheckerOutput(assignExp));
std::cout << "violation" << varName << std::endl;
}
else
{
std::cout << "non=violation" << varName << std::endl;
}
}
}
}
}
}
}
} // End of the visit function.
void
FixupSelfReferentialMacrosInAST::visit ( SgNode* node )
{
// DQ (3/11/2006): Set NULL pointers where we would like to have none.
// printf ("In FixupSelfReferentialMacrosInAST::visit(): node = %s \n",node->class_name().c_str());
ROSE_ASSERT(node != NULL);
switch (node->variantT())
{
case V_SgInitializedName:
{
SgInitializedName* initializedName = isSgInitializedName(node);
ROSE_ASSERT(initializedName != NULL);
SgType* type = initializedName->get_type()->stripType();
SgClassType* classType = isSgClassType(type);
if (classType != NULL)
{
SgClassDeclaration* targetClassDeclaration = isSgClassDeclaration(classType->get_declaration());
SgName className = targetClassDeclaration->get_name();
// printf ("In FixupSelfReferentialMacrosInAST::visit(): Found a class declaration name = %s \n",className.str());
// For sudo_exec_pty.c also look for siginfo
if (className == "sigaction" || className == "siginfo")
{
// printf ("In FixupSelfReferentialMacrosInAST::visit(): Found a sigaction type \n");
// Note we could also check that the declaration came from a known header file.
SgStatement* associatedStatement = isSgStatement(initializedName->get_parent());
if (associatedStatement != NULL)
{
// Add a macro to undefine the "#define sa_handler __sigaction_handler.sa_handler" macro.
// printf ("In FixupSelfReferentialMacrosInAST::visit(): Add a macro to undefine the macro #define sa_handler __sigaction_handler.sa_handler \n");
// PreprocessingInfo* macro = new PreprocessingInfo(DirectiveType, const std::string & inputString,const std::string & filenameString, int line_no , int col_no,int nol, RelativePositionType relPos );
PreprocessingInfo::DirectiveType directiveType = PreprocessingInfo::CpreprocessorUndefDeclaration;
// We are puting out all macros anytime we see either type. This might be too much...
// From the sigaction.h file (included by signal.h):
addMacro(associatedStatement,"#undef sa_handler\n",directiveType);
addMacro(associatedStatement,"#undef sa_sigaction\n",directiveType);
// From the siginfo.h file (included by signal.h):
addMacro(associatedStatement,"#undef si_pid\n", directiveType);
addMacro(associatedStatement,"#undef si_uid\n", directiveType);
addMacro(associatedStatement,"#undef si_timerid\n",directiveType);
addMacro(associatedStatement,"#undef si_overrun\n",directiveType);
addMacro(associatedStatement,"#undef si_status\n", directiveType);
addMacro(associatedStatement,"#undef si_utime\n", directiveType);
addMacro(associatedStatement,"#undef si_stime\n", directiveType);
addMacro(associatedStatement,"#undef si_value\n", directiveType);
addMacro(associatedStatement,"#undef si_int\n", directiveType);
addMacro(associatedStatement,"#undef si_ptr\n", directiveType);
addMacro(associatedStatement,"#undef si_addr\n", directiveType);
addMacro(associatedStatement,"#undef si_band\n", directiveType);
addMacro(associatedStatement,"#undef si_fd\n", directiveType);
}
}
}
}
default:
{
// printf ("Not handled in FixupSelfReferentialMacrosInAST::visit(%s) \n",node->class_name().c_str());
}
}
}
void instr(SgProject* project, Rose_STL_Container<SgType*> types)
{
SgGlobal* global = SI::getFirstGlobalScope(project);
std::string prefix("rtc_ti_"); //struct prefix
std::string ti_type_str("struct rtc_typeinfo*");
SgType* ti_type = SB::buildOpaqueType(ti_type_str,global);
//Insert declarations from the typechecking library.
//void minalloc_check(unsigned long long addr)
SgFunctionDeclaration* minalloc_check_decl = SB::buildNondefiningFunctionDeclaration(
SgName("minalloc_check"),
SgTypeVoid::createType(),
SB::buildFunctionParameterList(
SB::buildInitializedName("addr",SB::buildUnsignedLongLongType())),
global,NULL);
SI::prependStatement(minalloc_check_decl,global);
//void typetracker_add(unsigned long long addr, struct rtc_typeinfo* ti);
SgFunctionDeclaration* typetracker_add_decl = SB::buildNondefiningFunctionDeclaration(
SgName("typetracker_add"),
SgTypeVoid::createType(),
SB::buildFunctionParameterList(
SB::buildInitializedName("addr",SB::buildUnsignedLongLongType()),
SB::buildInitializedName("ti",ti_type)),
global,NULL);
SI::prependStatement(typetracker_add_decl,global);
//void setBaseType(rtc_typeinfo* ti, rtc_typeinfo* base)
SgFunctionDeclaration* setBaseType_decl = SB::buildNondefiningFunctionDeclaration(
SgName("setBaseType"),
SgTypeVoid::createType(),
SB::buildFunctionParameterList(
SB::buildInitializedName("ti",ti_type),
SB::buildInitializedName("base",ti_type)),
global,NULL);
SI::prependStatement(setBaseType_decl,global);
//struct rtc_typeinfo* ti_init(const char* a, size_t sz, int c)
SgFunctionDeclaration* ti_init_decl = SB::buildNondefiningFunctionDeclaration(
SgName("ti_init"),
ti_type,
SB::buildFunctionParameterList(
// SB::buildInitializedName("a",SB::buildPointerType(SB::buildConstType(SB::buildCharType()))),
SB::buildInitializedName("a",SB::buildPointerType(SB::buildCharType())),
// SB::buildInitializedName("sz", SB::buildOpaqueType("size_t",global)),
SB::buildInitializedName("sz", SB::buildLongLongType()),
SB::buildInitializedName("c", SB::buildIntType())),
global,NULL);
SI::prependStatement(ti_init_decl,global);
//void traverseAndPrint()
SgFunctionDeclaration* traverseAndPrint_decl = SB::buildNondefiningFunctionDeclaration(
SgName("traverseAndPrint"),SgTypeVoid::createType(),SB::buildFunctionParameterList(),global,NULL);
SI::prependStatement(traverseAndPrint_decl,global);
//non-defining declaration of rtc_init_typeinfo
SgName init_name("rtc_init_typeinfo");
SgFunctionDeclaration* init_nondef = SB::buildNondefiningFunctionDeclaration(init_name,SgTypeVoid::createType(),SB::buildFunctionParameterList(),global,NULL);
SI::prependStatement(init_nondef,global);
//call to rtc_init_typeinfo placed in main function.
SgFunctionDeclaration* maindecl = SI::findMain(project);
SgExprStatement* initcall = SB::buildFunctionCallStmt(init_name,SgTypeVoid::createType(),NULL,maindecl->get_definition());
maindecl->get_definition()->prepend_statement(initcall);
//defining declaration of rtc_init_typeinfo
SgFunctionDeclaration* init_definingDecl = new SgFunctionDeclaration(new Sg_File_Info(SI::getEnclosingFileNode(global)->getFileName()),init_name,init_nondef->get_type(),NULL);
init_definingDecl->set_firstNondefiningDeclaration(init_nondef);
SgFunctionDefinition* init_definition = new SgFunctionDefinition(new Sg_File_Info(SI::getEnclosingFileNode(global)->getFileName()),init_definingDecl,SB::buildBasicBlock());
init_definingDecl->set_definition(init_definition);
SI::appendStatement(init_definingDecl,global);
std::vector<std::string> lst;
for(unsigned int index = 0; index < types.size(); index++)
{
SgType* ptr = types[index];
ptr = ptr->stripTypedefsAndModifiers();
if(!shouldInstrumentType(ptr))
continue;
std::string nameStr = prefix + Util::getNameForType(ptr).getString();
if(!contains(lst,nameStr))
{
SgVariableDeclaration* decl = SB::buildVariableDeclaration(nameStr,ti_type,NULL,global);
SI::prependStatement(decl,global);
lst.push_back(nameStr);
}
}
for(unsigned int index = 0; index < types.size(); index++)
{
SgType* ptr = types[index];
ptr = ptr->stripTypedefsAndModifiers();
if(!shouldInstrumentType(ptr))
continue;
std::string typeNameStr = Util::getNameForType(ptr).getString();
std::string structNameStr = prefix + Util::getNameForType(ptr).getString();
if(contains(lst,structNameStr))
{
SgExpression* lhs;
SgExpression* rhs;
//In case of an anonymous struct or union, we create a local, named version of the declaration so we can know its size.
SgClassDeclaration* altDecl = NULL;
if(isSgNamedType(ptr) && isSgClassDeclaration(isSgNamedType(ptr)->get_declaration()) && isSgClassDeclaration(isSgNamedType(ptr)->get_declaration())->get_isUnNamed())
{
SgClassDeclaration* originalDecl = isSgClassDeclaration(isSgNamedType(ptr)->get_declaration()->get_definingDeclaration());
SgName altDecl_name(typeNameStr + "_def");
altDecl = new SgClassDeclaration(new Sg_File_Info(SI::getEnclosingFileNode(global)->getFileName()),altDecl_name,originalDecl->get_class_type());
SgClassDefinition* altDecl_definition = SB::buildClassDefinition(altDecl);
SgDeclarationStatementPtrList originalMembers = originalDecl->get_definition()->get_members();
for(SgDeclarationStatementPtrList::iterator it = originalMembers.begin(); it != originalMembers.end(); it++)
{
SgDeclarationStatement* member = *it;
SgDeclarationStatement* membercpy = isSgDeclarationStatement(SI::copyStatement(member));
altDecl_definition->append_member(membercpy);
}
SgClassDeclaration* altDecl_nondef = new SgClassDeclaration(new Sg_File_Info(SI::getEnclosingFileNode(global)->getFileName()),altDecl_name,originalDecl->get_class_type());
altDecl_nondef->set_scope(global);
altDecl->set_scope(global);
altDecl->set_firstNondefiningDeclaration(altDecl_nondef);
altDecl_nondef->set_firstNondefiningDeclaration(altDecl_nondef);
altDecl->set_definingDeclaration(altDecl);
altDecl_nondef->set_definingDeclaration(altDecl);
SgClassType* altDecl_ct = SgClassType::createType(altDecl_nondef);
altDecl->set_type(altDecl_ct);
altDecl_nondef->set_type(altDecl_ct);
altDecl->set_isUnNamed(false);
altDecl_nondef->set_isUnNamed(false);
altDecl_nondef->set_forward(true);
SgSymbol* sym = new SgClassSymbol(altDecl_nondef);
global->insert_symbol(altDecl_name, sym);
altDecl->set_linkage("C");
altDecl_nondef->set_linkage("C");
ROSE_ASSERT(sym && sym->get_symbol_basis() == altDecl_nondef);
ROSE_ASSERT(altDecl->get_definingDeclaration() == altDecl);
ROSE_ASSERT(altDecl->get_firstNondefiningDeclaration() == altDecl_nondef);
ROSE_ASSERT(altDecl->search_for_symbol_from_symbol_table() == sym);
ROSE_ASSERT(altDecl->get_definition() == altDecl_definition);
ROSE_ASSERT(altDecl->get_scope() == global && altDecl->get_scope() == altDecl_nondef->get_scope());
ROSE_ASSERT(altDecl_ct->get_declaration() == altDecl_nondef);
//For some reason, this is not working...
//global->append_statement(altDecl);
//global->prepend_statement(altDecl_nondef);
//SI::setOneSourcePositionForTransformation(altDecl);
//SI::setOneSourcePositionForTransformation(altDecl_nondef);
}
SgType* baseType;
if(isSgPointerType(ptr))
baseType = ptr->dereference();
else
baseType = ptr->findBaseType();
baseType = baseType->stripTypedefsAndModifiers();
if(baseType == NULL || baseType == ptr)
{
//In this case, there is no base type.
rhs = SB::buildFunctionCallExp(SgName("ti_init"),SgTypeVoid::createType(),SB::buildExprListExp(
SB::buildStringVal(ptr->unparseToString()),
((altDecl == NULL && !isSgTypeVoid(ptr)) ? (SgExpression*) SB::buildSizeOfOp(types[index]) : (SgExpression*) SB::buildIntVal(-1)),
SB::buildIntVal(getClassification(ptr))
),init_definition);
}
else
{
//The type has a base type.
std::string baseStructNameStr = prefix + Util::getNameForType(baseType).getString();
rhs = SB::buildFunctionCallExp(SgName("ti_init"),ti_type,SB::buildExprListExp(
SB::buildStringVal(ptr->unparseToString()),
((altDecl == NULL && !isSgTypeVoid(ptr)) ? (SgExpression*) SB::buildSizeOfOp(types[index]) : (SgExpression*) SB::buildIntVal(-1)),
SB::buildIntVal(getClassification(ptr))
),init_definition);
SgExprStatement* set_BT = SB::buildFunctionCallStmt(SgName("setBaseType"),ti_type,SB::buildExprListExp(
SB::buildVarRefExp(structNameStr),
SB::buildVarRefExp(baseStructNameStr)),
init_definition);
init_definition->append_statement(set_BT);
}
lhs = SB::buildVarRefExp(structNameStr);
SgExprStatement* assignstmt = SB::buildAssignStatement(lhs,rhs);
init_definition->prepend_statement(assignstmt);
std::remove(lst.begin(),lst.end(),structNameStr);
}
}
}
void
FixupSelfReferentialMacrosInAST::visit ( SgNode* node )
{
// DQ (3/11/2006): Set NULL pointers where we would like to have none.
// printf ("In FixupSelfReferentialMacrosInAST::visit(): node = %s \n",node->class_name().c_str());
ROSE_ASSERT(node != NULL);
switch (node->variantT())
{
case V_SgInitializedName:
{
SgInitializedName* initializedName = isSgInitializedName(node);
ROSE_ASSERT(initializedName != NULL);
SgType* type = initializedName->get_type()->stripType();
SgClassType* classType = isSgClassType(type);
if (classType != NULL)
{
SgClassDeclaration* targetClassDeclaration = isSgClassDeclaration(classType->get_declaration());
SgName className = targetClassDeclaration->get_name();
// printf ("In FixupSelfReferentialMacrosInAST::visit(): Found a class declaration name = %s \n",className.str());
if (className == "sigaction")
{
// printf ("In FixupSelfReferentialMacrosInAST::visit(): Found a sigaction type \n");
// Note we could also check that the declaration came from a known header file.
SgStatement* associatedStatement = isSgStatement(initializedName->get_parent());
if (associatedStatement != NULL)
{
// Add a macro to undefine the "#define sa_handler __sigaction_handler.sa_handler" macro.
// printf ("In FixupSelfReferentialMacrosInAST::visit(): Add a macro to undefine the macro #define sa_handler __sigaction_handler.sa_handler \n");
// PreprocessingInfo* macro = new PreprocessingInfo(DirectiveType, const std::string & inputString,const std::string & filenameString, int line_no , int col_no,int nol, RelativePositionType relPos );
PreprocessingInfo::DirectiveType directiveType = PreprocessingInfo::CpreprocessorUndefDeclaration;
std::string macroString = "#undef sa_handler\n";
std::string filenameString = "macro_call_fixupSelfReferentialMacrosInAST";
int line_no = 1;
int col_no = 1;
int nol = 1;
PreprocessingInfo::RelativePositionType relPos = PreprocessingInfo::before;
PreprocessingInfo* macro = new PreprocessingInfo(directiveType,macroString,filenameString,line_no,col_no,nol,relPos);
// printf ("Attaching CPP directive %s to IR node %p as attributes. \n",PreprocessingInfo::directiveTypeName(macro->getTypeOfDirective()).c_str(),associatedStatement);
associatedStatement->addToAttachedPreprocessingInfo(macro);
#if 0
printf ("Exiting as a test! \n");
ROSE_ASSERT(false);
#endif
}
}
}
}
default:
{
// printf ("Not handled in FixupSelfReferentialMacrosInAST::visit(%s) \n",node->class_name().c_str());
}
}
}
int main(int argc, char **argv)
{
SgProject *project = frontend(argc, argv);
// Instantiate a class hierarchy wrapper.
ClassHierarchyWrapper classHierarchy( project );
std::list<SgNode *> nodes2 = NodeQuery::querySubTree(project,
V_SgVariableDefinition);
for (std::list<SgNode *>::iterator it = nodes2.begin();
it != nodes2.end(); ++it ) {
SgNode *n = *it;
ROSE_ASSERT(n != NULL);
SgVariableDefinition *varDefn =
isSgVariableDefinition(n);
ROSE_ASSERT(varDefn != NULL);
std::cout << "Var defn: " << varDefn->unparseToCompleteString() << std::endl;
}
std::list<SgNode *> nodes1 = NodeQuery::querySubTree(project,
V_SgVariableDeclaration);
for (std::list<SgNode *>::iterator it = nodes1.begin();
it != nodes1.end(); ++it ) {
SgNode *n = *it;
ROSE_ASSERT(n != NULL);
SgVariableDeclaration *varDecl =
isSgVariableDeclaration(n);
ROSE_ASSERT(varDecl != NULL);
SgInitializedNamePtrList &variables =
varDecl->get_variables();
SgInitializedNamePtrList::iterator varIter;
for (varIter = variables.begin();
varIter != variables.end(); ++varIter) {
SgNode *var = *varIter;
ROSE_ASSERT(var != NULL);
SgInitializedName *initName =
isSgInitializedName(var);
ROSE_ASSERT(initName != NULL);
if ( isSgClassType(initName->get_type()) ) {
SgClassType *classType = isSgClassType(initName->get_type());
ROSE_ASSERT(classType != NULL);
SgDeclarationStatement *declStmt = classType->get_declaration();
ROSE_ASSERT(declStmt != NULL);
SgClassDeclaration *classDeclaration = isSgClassDeclaration(declStmt);
ROSE_ASSERT(classDeclaration != NULL);
// std::cout << "From var decl got: " << classDeclaration->unparseToCompleteString() << std::endl;
SgClassDefinition *classDefinition =
classDeclaration->get_definition();
if ( classDefinition != NULL ) {
std::cout << "From var decl got: " << classDefinition->unparseToCompleteString() << std::endl;
}
}
}
}
std::list<SgNode *> nodes = NodeQuery::querySubTree(project,
V_SgClassDeclaration);
for (std::list<SgNode *>::iterator it = nodes.begin();
it != nodes.end(); ++it ) {
SgNode *n = *it;
ROSE_ASSERT(n != NULL);
SgClassDeclaration *classDeclaration1 =
isSgClassDeclaration(n);
ROSE_ASSERT(classDeclaration1 != NULL);
SgDeclarationStatement *definingDecl =
classDeclaration1->get_definingDeclaration();
if ( definingDecl == NULL )
continue;
SgClassDeclaration *classDeclaration =
isSgClassDeclaration(definingDecl);
ROSE_ASSERT(classDeclaration != NULL);
SgClassDefinition *classDefinition =
classDeclaration->get_definition();
ROSE_ASSERT(classDefinition != NULL);
std::cout << "Calling getSubclasses on " << classDefinition->unparseToCompleteString() << std::endl;
SgClassDefinitionPtrList subclasses =
classHierarchy.getSubclasses(classDefinition);
// Iterate over all subclasses.
for (SgClassDefinitionPtrList::iterator subclassIt = subclasses.begin();
subclassIt != subclasses.end(); ++subclassIt) {
SgClassDefinition *subclass = *subclassIt;
ROSE_ASSERT(subclass != NULL);
std::cout << "subclass" << std::endl;
}
}
#if 0
#if 0
std::list<SgNode *> nodes = NodeQuery::querySubTree(project,
V_SgClassDefinition);
for (std::list<SgNode *>::iterator it = nodes.begin();
it != nodes.end(); ++it ) {
SgNode *n = *it;
ROSE_ASSERT(n != NULL);
SgClassDefinition *classDefinition =
isSgClassDefinition(n);
ROSE_ASSERT(classDefinition != NULL);
std::cout << "Calling getSubclasses on " << classDefinition->unparseToCompleteString() << std::endl;
SgClassDefinitionPtrList subclasses =
classHierarchy.getSubclasses(classDefinition);
// Iterate over all subclasses.
for (SgClassDefinitionPtrList::iterator subclassIt = subclasses.begin();
subclassIt != subclasses.end(); ++subclassIt) {
SgClassDefinition *subclass = *subclassIt;
ROSE_ASSERT(subclass != NULL);
std::cout << "subclass" << std::endl;
}
}
#else
// Collect all function/method invocations.
std::list<SgNode *> nodes = NodeQuery::querySubTree(project,
V_SgFunctionCallExp);
unsigned int numCallSites = 0;
unsigned int numMonomorphicCallSites = 0;
unsigned int numPossibleResolutions = 0;
// Visit each call site.
for (std::list<SgNode *>::iterator it = nodes.begin();
it != nodes.end(); ++it ) {
SgNode *n = *it;
ROSE_ASSERT(n != NULL);
SgFunctionCallExp *functionCallExp =
isSgFunctionCallExp(n);
ROSE_ASSERT(functionCallExp != NULL);
// We are only interested in examining method invocations.
bool isDotExp = false;
if ( !isMethodCall(functionCallExp, isDotExp) )
continue;
numCallSites++;
// Certainly can be resolved to the static method.
numPossibleResolutions++;
if ( isDotExp ) {
// If this is a dot expression (i.e., a.foo()), we can
// statically determine its type.
numMonomorphicCallSites++;
continue;
}
// Retrieve the static function declaration.
SgFunctionDeclaration *functionDeclaration =
getFunctionDeclaration(functionCallExp);
// Ensure it is actually a method declaration.
SgMemberFunctionDeclaration *memberFunctionDeclaration =
isSgMemberFunctionDeclaration(functionDeclaration);
ROSE_ASSERT(memberFunctionDeclaration != NULL);
unsigned int numOverridesForMethod = 0;
if ( ( isVirtual(functionDeclaration) ) ||
( isDeclaredVirtualWithinAncestor(functionDeclaration) ) ) {
SgClassDefinition *classDefinition =
isSgClassDefinition(memberFunctionDeclaration->get_scope());
ROSE_ASSERT(classDefinition != NULL);
SgClassDefinitionPtrList subclasses =
classHierarchy.getSubclasses(classDefinition);
// Iterate over all subclasses.
for (SgClassDefinitionPtrList::iterator subclassIt = subclasses.begin();
subclassIt != subclasses.end(); ++subclassIt) {
SgClassDefinition *subclass = *subclassIt;
ROSE_ASSERT(subclass != NULL);
std::cout << "subclass" << std::endl;
// Iterate over all of the methods defined in this subclass.
SgDeclarationStatementPtrList &decls =
subclass->get_members();
for (SgDeclarationStatementPtrList::iterator declIter = decls.begin();
declIter != decls.end(); ++declIter) {
SgDeclarationStatement *declStmt = *declIter;
ROSE_ASSERT(declStmt != NULL);
SgMemberFunctionDeclaration *method =
isSgMemberFunctionDeclaration(declStmt);
if ( method == NULL ) {
continue;
}
// Determine whether subclass of the class defining this
// method overrides the method.
if ( methodOverridesVirtualMethod(method,
memberFunctionDeclaration) ) {
numOverridesForMethod++;
}
}
}
if ( numOverridesForMethod == 0 )
numMonomorphicCallSites++;
numPossibleResolutions += numOverridesForMethod;
std::cout << "Method invocation has " << numOverridesForMethod + 1 << " possible resolutions " << std::endl;
std::cout << functionCallExp->unparseToCompleteString() << std::endl;
}
}
#endif
#endif
return 0;
}
void
FixupSelfReferentialMacrosInAST::visit ( SgNode* node )
{
// DQ (3/11/2006): Set NULL pointers where we would like to have none.
// printf ("In FixupSelfReferentialMacrosInAST::visit(): node = %s \n",node->class_name().c_str());
ROSE_ASSERT(node != NULL);
switch (node->variantT())
{
case V_SgInitializedName:
{
SgInitializedName* initializedName = isSgInitializedName(node);
ROSE_ASSERT(initializedName != NULL);
SgType* type = initializedName->get_type()->stripType();
SgClassType* classType = isSgClassType(type);
if (classType != NULL)
{
SgClassDeclaration* targetClassDeclaration = isSgClassDeclaration(classType->get_declaration());
SgName className = targetClassDeclaration->get_name();
// printf ("In FixupSelfReferentialMacrosInAST::visit(): Found a class declaration name = %s \n",className.str());
// For sudo_exec_pty.c also look for siginfo
if (className == "sigaction" || className == "siginfo")
{
// printf ("In FixupSelfReferentialMacrosInAST::visit(): Found a sigaction type \n");
// Note we could also check that the declaration came from a known header file.
SgStatement* associatedStatement = isSgStatement(initializedName->get_parent());
if (associatedStatement != NULL)
{
// Add a macro to undefine the "#define sa_handler __sigaction_handler.sa_handler" macro.
// printf ("In FixupSelfReferentialMacrosInAST::visit(): Add a macro to undefine the macro #define sa_handler __sigaction_handler.sa_handler \n");
// PreprocessingInfo* macro = new PreprocessingInfo(DirectiveType, const std::string & inputString,const std::string & filenameString, int line_no , int col_no,int nol, RelativePositionType relPos );
PreprocessingInfo::DirectiveType directiveType = PreprocessingInfo::CpreprocessorUndefDeclaration;
// We are puting out all macros anytime we see either type. This might be too much...
// From the sigaction.h file (included by signal.h):
addMacro(associatedStatement,"#undef sa_handler\n",directiveType);
addMacro(associatedStatement,"#undef sa_sigaction\n",directiveType);
// From the siginfo.h file (included by signal.h):
addMacro(associatedStatement,"#undef si_pid\n", directiveType);
addMacro(associatedStatement,"#undef si_uid\n", directiveType);
addMacro(associatedStatement,"#undef si_timerid\n",directiveType);
addMacro(associatedStatement,"#undef si_overrun\n",directiveType);
addMacro(associatedStatement,"#undef si_status\n", directiveType);
addMacro(associatedStatement,"#undef si_utime\n", directiveType);
addMacro(associatedStatement,"#undef si_stime\n", directiveType);
addMacro(associatedStatement,"#undef si_value\n", directiveType);
addMacro(associatedStatement,"#undef si_int\n", directiveType);
addMacro(associatedStatement,"#undef si_ptr\n", directiveType);
addMacro(associatedStatement,"#undef si_addr\n", directiveType);
addMacro(associatedStatement,"#undef si_band\n", directiveType);
addMacro(associatedStatement,"#undef si_fd\n", directiveType);
}
}
}
}
default:
{
// printf ("Not handled in FixupSelfReferentialMacrosInAST::visit(%s) \n",node->class_name().c_str());
}
}
#if 0
// DQ (12/30/2013): Comments and CPP directives have not yet been attached to the AST, so we can't process them here.
// SgLocatedNode* locatedNode = isSgLocatedNode(node);
// if (locatedNode != NULL)
SgStatement* stmt = isSgStatement(node);
if (stmt != NULL)
{
// Find all #define statements and look for self referencing macros
int numberOfComments = -1;
if (stmt->getAttachedPreprocessingInfo() != NULL)
numberOfComments = stmt->getAttachedPreprocessingInfo()->size();
std::string s = std::string(" --- startOfConstruct: file = " ) + stmt->get_startOfConstruct()->get_filenameString()
+ " raw filename = " + stmt->get_startOfConstruct()->get_raw_filename()
+ " raw line = " + StringUtility::numberToString(stmt->get_startOfConstruct()->get_raw_line())
+ " raw column = " + StringUtility::numberToString(stmt->get_startOfConstruct()->get_raw_col())
+ " #comments = " + StringUtility::numberToString(numberOfComments)
+ " \n ";
AttachedPreprocessingInfoType* comments = stmt->getAttachedPreprocessingInfo();
if (comments != NULL)
{
printf ("Found attached comments (at %p of type: %s): \n",stmt,stmt->class_name().c_str());
AttachedPreprocessingInfoType::iterator i;
for (i = comments->begin(); i != comments->end(); i++)
{
ROSE_ASSERT ( (*i) != NULL );
printf (" Attached Comment (relativePosition=%s): %s\n",
((*i)->getRelativePosition() == PreprocessingInfo::before) ? "before" : "after",
(*i)->getString().c_str());
printf ("Comment/Directive getNumberOfLines = %d getColumnNumberOfEndOfString = %d \n",(*i)->getNumberOfLines(),(*i)->getColumnNumberOfEndOfString());
(*i)->get_file_info()->display("comment/directive location");
}
}
else
{
printf ("No attached comments (at %p of type: %s): \n",stmt,stmt->class_name().c_str());
}
}
#endif
}
