Changeset bed4c63e for src/SymTab

Timestamp:

Mar 8, 2016, 5:52:39 PM (9 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc

Children:

ac633d0, ae357ec

Parents:

52c2a72

Message:

Fold IdTable? into indexer

Location:

src/SymTab

Files:

• IdTable.cc (deleted)
• IdTable.h (deleted)
• Indexer.cc (modified) (9 diffs)
• Indexer.h (modified) (1 diff)
• module.mk (modified) (1 diff)

src/SymTab/Indexer.cc

@@ -21 +21 @@
 #include <utility>
 
-#include "IdTable.h"
+#include "Mangler.h"
+
+#include "Common/utility.h"
+
+#include "ResolvExpr/typeops.h"
 
 #include "SynTree/Declaration.h"
@@ -28 +32 @@
 #include "SynTree/Initializer.h"
 #include "SynTree/Statement.h"
-
-#include "Common/utility.h"
 
 #define debugPrint(x) if ( doDebug ) { std::cout << x; }
@@ -41 +43 @@
         }
 
+        typedef std::unordered_map< std::string, DeclarationWithType* > MangleTable;
+        typedef std::unordered_map< std::string, MangleTable > IdTable;
         typedef std::unordered_map< std::string, NamedTypeDecl* > TypeTable;
         typedef std::unordered_map< std::string, StructDecl* > StructTable;
@@ -47 +51 @@
         typedef std::unordered_map< std::string, TraitDecl* > TraitTable;
 
+        void dump( const IdTable &table, std::ostream &os ) {
+                for ( IdTable::const_iterator id = table.begin(); id != table.end(); ++id ) {
+                        for ( MangleTable::const_iterator mangle = id->second.begin(); mangle != id->second.end(); ++mangle ) {
+                                os << mangle->second << std::endl;
+                        }
+                }
+        }
+        
         template< typename Decl >
         void dump( const std::unordered_map< std::string, Decl* > &table, std::ostream &os ) {
@@ -420 +432 @@
         }
 
-
-        void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &list ) const {
+        
+
+        void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &out ) const {
                 if ( ! tables ) return;
+
+                IdTable::const_iterator decls = tables->idTable.find( id );
+                if ( decls != tables->idTable.end() ) {
+                        const MangleTable &mangleTable = decls->second;
+                        for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
+                                out.push_back( decl->second );
+                        }
+                }
                 
-                tables->idTable.lookupId( id, list );
-                tables->base.lookupId( id, list );
-        }
-
-        DeclarationWithType* Indexer::lookupId( const std::string &id) const {
-                if ( ! tables ) return 0;
-                
-                DeclarationWithType *ret = tables->idTable.lookupId(id);
-                return ret ? ret : tables->base.lookupId(id);
+                // get declarations from base indexers
+                tables->base.lookupId( id, out );
         }
 
@@ -470 +484 @@
         }
 
+        DeclarationWithType *Indexer::lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
+                if ( ! tables ) return 0;
+                if ( tables->scope < scope ) return 0;
+
+                IdTable::const_iterator decls = tables->idTable.find( id );
+                if ( decls != tables->idTable.end() ) {
+                        const MangleTable &mangleTable = decls->second;
+                        MangleTable::const_iterator decl = mangleTable.find( mangleName );
+                        if ( decl != mangleTable.end() ) return decl->second;
+                }
+
+                return tables->base.lookupIdAtScope( id, mangleName, scope );
+        }
+
+        bool Indexer::hasCDeclWithName( const std::string &id ) const {
+                if ( ! tables ) return false;
+
+                IdTable::const_iterator decls = tables->idTable.find( id );
+                if ( decls != tables->idTable.end() ) {
+                        const MangleTable &mangleTable = decls->second;
+                        for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
+                                if ( decl->second->get_linkage() == LinkageSpec::C ) return true;
+                        }
+                }
+
+                return tables->base.hasCDeclWithName( id );
+        }
+        
         NamedTypeDecl *Indexer::lookupTypeAtScope( const std::string &id, unsigned long scope ) const {
                 if ( ! tables ) return 0;
@@ -510 +552 @@
         }
 
+        bool addedIdConflicts( DeclarationWithType *existing, DeclarationWithType *added ) {
+                // if we're giving the same name mangling to things of different types then there is something wrong
+                assert( (dynamic_cast<ObjectDecl*>( added ) && dynamic_cast<ObjectDecl*>( existing ) )
+                        || (dynamic_cast<FunctionDecl*>( added ) && dynamic_cast<FunctionDecl*>( existing ) ) );
+
+                if ( LinkageSpec::isOverridable( existing->get_linkage() ) ) {
+                        // new definition shadows the autogenerated one, even at the same scope
+                        return false;
+                } else if ( added->get_linkage() != LinkageSpec::C || ResolvExpr::typesCompatible( added->get_type(), existing->get_type(), Indexer() ) ) {
+                        // typesCompatible doesn't really do the right thing here. When checking compatibility of function types,
+                        // we should ignore outermost pointer qualifiers, except _Atomic?
+                        FunctionDecl *newentry = dynamic_cast< FunctionDecl* >( added );
+                        FunctionDecl *oldentry = dynamic_cast< FunctionDecl* >( existing );
+                        if ( newentry && oldentry ) {
+                                if ( newentry->get_statements() && oldentry->get_statements() ) {
+                                        throw SemanticError( "duplicate function definition for ", added );
+                                } // if
+                        } else {
+                                // two objects with the same mangled name defined in the same scope.
+                                // both objects must be marked extern or both must be intrinsic for this to be okay
+                                // xxx - perhaps it's actually if either is intrinsic then this is okay?
+                                //       might also need to be same storage class?
+                                ObjectDecl *newobj = dynamic_cast< ObjectDecl* >( added );
+                                ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( existing );
+                                if ( newobj->get_storageClass() != DeclarationNode::Extern && oldobj->get_storageClass() != DeclarationNode::Extern ) {
+                                        throw SemanticError( "duplicate object definition for ", added );
+                                } // if
+                        } // if
+                } else {
+                        throw SemanticError( "duplicate definition for ", added );
+                } // if
+
+                return true;
+        }
+        
         void Indexer::addId( DeclarationWithType *decl ) {
                 makeWritable();
-                tables->idTable.addDecl( decl );
-                ++tables->size;
+
+                const std::string &name = decl->get_name();
+                std::string mangleName;
+                if ( decl->get_linkage() == LinkageSpec::C ) {
+                        mangleName = name;
+                } else if ( LinkageSpec::isOverridable( decl->get_linkage() ) ) {
+                        // mangle the name without including the appropriate suffix, so overridable routines are placed into the
+                        // same "bucket" as their user defined versions.
+                        mangleName = Mangler::mangle( decl, false );
+                } else {
+                        mangleName = Mangler::mangle( decl );
+                } // if
+
+                DeclarationWithType *existing = lookupIdAtScope( name, mangleName, scope );
+                if ( ! existing || ! addedIdConflicts( existing, decl ) ) {
+                        // this ensures that no two declarations with the same unmangled name both have C linkage
+                        if ( decl->get_linkage() == LinkageSpec::C && hasCDeclWithName( name ) ) {
+                                throw SemanticError( "invalid overload of C function ", decl );
+                        }
+                        
+                        tables->idTable[ name ][ mangleName ] = decl;
+                        ++tables->size;
+                }
         }
 
@@ -650 +748 @@
                         if ( doDebug ) {
                                 cout << "--- Leaving scope " << tables->scope << " containing" << std::endl;
-                                tables->idTable.dump( cout );
+                                dump( tables->idTable, cout );
                                 dump( tables->typeTable, cout );
                                 dump( tables->structTable, cout );
@@ -669 +767 @@
 
             cerr << "===idTable===" << std::endl;
-            if ( tables ) tables->idTable.dump( os );
+            if ( tables ) dump( tables->idTable, os );
             cerr << "===typeTable===" << std::endl;
             if ( tables ) dump( tables->typeTable, os );

src/SymTab/Indexer.h

@@ -80 +80 @@
                 void leaveScope();
 
+                /// Gets all declarations with the given ID
                 void lookupId( const std::string &id, std::list< DeclarationWithType* > &out ) const;
-                DeclarationWithType* lookupId( const std::string &id ) const;
+                /// Gets the top-most type declaration with the given ID
                 NamedTypeDecl *lookupType( const std::string &id ) const;
+                /// Gets the top-most struct declaration with the given ID
                 StructDecl *lookupStruct( const std::string &id ) const;
+                /// Gets the top-most enum declaration with the given ID
                 EnumDecl *lookupEnum( const std::string &id ) const;
+                /// Gets the top-most union declaration with the given ID
                 UnionDecl *lookupUnion( const std::string &id ) const;
+                /// Gets the top-most trait declaration with the given ID
                 TraitDecl *lookupTrait( const std::string &id ) const;
   
                 void print( std::ostream &os, int indent = 0 ) const;
           private:
+                /// looks up a specific mangled ID at the given scope
+                DeclarationWithType *lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
+                /// returns true if there exists a declaration with C linkage and the given name
+                bool hasCDeclWithName( const std::string &id ) const;
                 // equivalents to lookup functions that only look at tables at scope `scope` (which should be >= tables->scope)
                 NamedTypeDecl *lookupTypeAtScope( const std::string &id, unsigned long scope ) const;

src/SymTab/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC += SymTab/IdTable.cc \
-       SymTab/Indexer.cc \
+SRC += SymTab/Indexer.cc \
        SymTab/Mangler.cc \
        SymTab/Validate.cc \