Changeset 7e23d0a for src/SymTab

Timestamp:

Nov 25, 2015, 2:53:26 PM (10 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:

32d281d, 704c9dd

Parents:

02ec390 (diff), 5189888 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/SymTab

Files:

• IdTable.cc (modified) (5 diffs)
• Mangler.cc (modified) (5 diffs)
• Mangler.h (modified) (4 diffs)
• Validate.cc (modified) (14 diffs)

src/SymTab/IdTable.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 17:04:02 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sun May 17 17:07:43 2015
-// Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Oct 07 12:21:13 2015
+// Update Count     : 73
 //
 
@@ -37 +37 @@
                         for ( InnerTableType::iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) {
                                 std::stack< DeclEntry >& entry = inner->second;
+                                // xxx - should be while?
                                 if ( ! entry.empty() && entry.top().second == scopeLevel ) {
                                         entry.pop();
@@ -52 +53 @@
                 if ( decl->get_linkage() == LinkageSpec::C ) {
                         manglename = name;
+                } else if ( LinkageSpec::isOverridable( decl->get_linkage() ) ) {
+                        // mangle the name without including the appropriate suffix
+                        // this will make it so that overridable routines are placed
+                        // into the same "bucket" as their user defined versions.
+                        manglename = Mangler::mangle( decl, false );
                 } else {
                         manglename = Mangler::mangle( decl );
@@ -60 +66 @@
 
                 if ( it == declTable.end() ) {
+                        // first time this name mangling has been defined
                         declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) );
                 } else {
                         std::stack< DeclEntry >& entry = it->second;
                         if ( ! entry.empty() && entry.top().second == scopeLevel ) {
-                                if ( decl->get_linkage() != LinkageSpec::C || ResolvExpr::typesCompatible( decl->get_type(), entry.top().first->get_type(), Indexer() ) ) {
+                                // if we're giving the same name mangling to things of
+                                //  different types then there is something wrong
+                                Declaration *old = entry.top().first;
+                                assert( (dynamic_cast<ObjectDecl*>( decl ) && dynamic_cast<ObjectDecl*>( old ) )
+                                  || (dynamic_cast<FunctionDecl*>( decl ) && dynamic_cast<FunctionDecl*>( old ) ) );
+
+                                if ( LinkageSpec::isOverridable( old->get_linkage() ) ) {
+                                        // new definition shadows the autogenerated one, even at the same scope
+                                        declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) );
+                                } else if ( decl->get_linkage() != LinkageSpec::C || ResolvExpr::typesCompatible( decl->get_type(), entry.top().first->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* >( decl );
-                                        FunctionDecl *old = dynamic_cast< FunctionDecl* >( entry.top().first );
-                                        if ( newentry && old && newentry->get_statements() && old->get_statements() ) {
-                                                throw SemanticError( "duplicate function definition for ", decl );
+                                        FunctionDecl *oldentry = dynamic_cast< FunctionDecl* >( old );
+                                        if ( newentry && oldentry ) {
+                                                if ( newentry->get_statements() && oldentry->get_statements() ) {
+                                                        throw SemanticError( "duplicate function definition for 1 ", decl );
+                                                } // 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* >( decl );
-                                                ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( entry.top().first );
-                                                if ( newobj && oldobj && newobj->get_init() && oldobj->get_init() ) {
-                                                        throw SemanticError( "duplicate definition for ", decl );
+                                                ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( old );
+                                                if (newobj->get_storageClass() != DeclarationNode::Extern && oldobj->get_storageClass() != DeclarationNode::Extern ) {
+                                                        throw SemanticError( "duplicate definition for 3 ", decl );
                                                 } // if
                                         } // if
@@ -80 +104 @@
                                 } // if
                         } else {
+                                // new scope level - shadow existing definition
                                 declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) );
                         } // if
                 } // if
-                // ensure the set of routines with C linkage cannot be overloaded
+                // this ensures that no two declarations with the same unmangled name both have C linkage
                 for ( InnerTableType::iterator i = declTable.begin(); i != declTable.end(); ++i ) {
                         if ( ! i->second.empty() && i->second.top().first->get_linkage() == LinkageSpec::C && declTable.size() > 1 ) {

src/SymTab/Mangler.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:40:29 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jun  8 15:12:12 2015
-// Update Count     : 8
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Aug 19 15:52:24 2015
+// Update Count     : 19
 //
 
@@ -30 +30 @@
 
 namespace SymTab {
-        Mangler::Mangler() : nextVarNum( 0 ), isTopLevel( true ) {
+        Mangler::Mangler( bool mangleOverridable ) : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ) {
         }
 
@@ -41 +41 @@
                 nextVarNum = rhs.nextVarNum;
                 isTopLevel = rhs.isTopLevel;
+                mangleOverridable = rhs.mangleOverridable;
         }
 
@@ -59 +60 @@
                 mangleName << "__";
                 maybeAccept( declaration->get_type(), *this );
+                if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) {
+                        // want to be able to override autogenerated and intrinsic routines,
+                        // so they need a different name mangling
+                        if ( declaration->get_linkage() == LinkageSpec::AutoGen ) {
+                                mangleName << "autogen__";
+                        } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) {
+                                mangleName << "intrinsic__";
+                        } else {
+                                // if we add another kind of overridable function, this has to change
+                                assert( false );
+                        } // if
+                }
                 isTopLevel = wasTopLevel;
         }
@@ -214 +227 @@
                                 varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
                                 for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
-                                        Mangler sub_mangler;
+                                        Mangler sub_mangler( mangleOverridable );
                                         sub_mangler.nextVarNum = nextVarNum;
                                         sub_mangler.isTopLevel = false;

src/SymTab/Mangler.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:44:03 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jun  8 14:47:14 2015
-// Update Count     : 5
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Aug 19 15:48:46 2015
+// Update Count     : 14
 //
 
@@ -25 +25 @@
           public:
                 template< typename SynTreeClass >
-            static std::string mangle( SynTreeClass *decl ); // interface to clients
+            static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true ); // interface to clients
 
 ///   using Visitor::visit;
@@ -50 +50 @@
                 int nextVarNum;
                 bool isTopLevel;
+                bool mangleOverridable;
   
-                Mangler();
+                Mangler( bool mangleOverridable );
                 Mangler( const Mangler & );
   
@@ -61 +62 @@
 
         template< typename SynTreeClass >
-        std::string Mangler::mangle( SynTreeClass *decl ) {
-                Mangler mangler;
+        std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable ) {
+                Mangler mangler( mangleOverridable );
                 maybeAccept( decl, mangler );
                 return mangler.get_mangleName();

src/SymTab/Validate.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:50:04 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Aug 11 16:59:35 2015
-// Update Count     : 196
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri Nov 20 16:33:52 2015
+// Update Count     : 201
 //
 
@@ -54 +54 @@
 #include "MakeLibCfa.h"
 #include "TypeEquality.h"
+#include "ResolvExpr/typeops.h"
 
 #define debugPrint( x ) if ( doDebug ) { std::cout << x; }
@@ -125 +126 @@
         };
 
-        class AddStructAssignment : public Visitor {
+        class AutogenerateRoutines : public Visitor {
           public:
                 /// Generates assignment operators for aggregate types as required
-                static void addStructAssignment( std::list< Declaration * > &translationUnit );
+                static void autogenerateRoutines( std::list< Declaration * > &translationUnit );
 
                 std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
@@ -151 +152 @@
                 virtual void visit( CatchStmt *catchStmt );
 
-                AddStructAssignment() : functionNesting( 0 ) {}
+                AutogenerateRoutines() : functionNesting( 0 ) {}
           private:
                 template< typename StmtClass > void visitStatement( StmtClass *stmt );
@@ -195 +196 @@
                 acceptAll( translationUnit, pass1 );
                 acceptAll( translationUnit, pass2 );
-                // need to collect all of the assignment operators prior to
-                // this point and only generate assignment operators if one doesn't exist
-                AddStructAssignment::addStructAssignment( translationUnit );
+                AutogenerateRoutines::autogenerateRoutines( translationUnit );
                 acceptAll( translationUnit, pass3 );
         }
@@ -501 +500 @@
         static const std::list< std::string > noLabels;
 
-        void AddStructAssignment::addStructAssignment( std::list< Declaration * > &translationUnit ) {
-                AddStructAssignment visitor;
+        void AutogenerateRoutines::autogenerateRoutines( std::list< Declaration * > &translationUnit ) {
+                AutogenerateRoutines visitor;
                 acceptAndAdd( translationUnit, visitor, false );
         }
@@ -704 +703 @@
         }
 
-        void AddStructAssignment::visit( EnumDecl *enumDecl ) {
+        void AutogenerateRoutines::visit( EnumDecl *enumDecl ) {
                 if ( ! enumDecl->get_members().empty() ) {
                         EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() );
@@ -713 +712 @@
         }
 
-        void AddStructAssignment::visit( StructDecl *structDecl ) {
+        void AutogenerateRoutines::visit( StructDecl *structDecl ) {
                 if ( ! structDecl->get_members().empty() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
                         StructInstType *structInst = new StructInstType( Type::Qualifiers(), structDecl->get_name() );
@@ -722 +721 @@
         }
 
-        void AddStructAssignment::visit( UnionDecl *unionDecl ) {
+        void AutogenerateRoutines::visit( UnionDecl *unionDecl ) {
                 if ( ! unionDecl->get_members().empty() ) {
                         UnionInstType *unionInst = new UnionInstType( Type::Qualifiers(), unionDecl->get_name() );
@@ -730 +729 @@
         }
 
-        void AddStructAssignment::visit( TypeDecl *typeDecl ) {
+        void AutogenerateRoutines::visit( TypeDecl *typeDecl ) {
                 CompoundStmt *stmts = 0;
                 TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false );
@@ -758 +757 @@
         }
 
-        void AddStructAssignment::visit( FunctionType *) {
+        void AutogenerateRoutines::visit( FunctionType *) {
                 // ensure that we don't add assignment ops for types defined as part of the function
         }
 
-        void AddStructAssignment::visit( PointerType *) {
+        void AutogenerateRoutines::visit( PointerType *) {
                 // ensure that we don't add assignment ops for types defined as part of the pointer
         }
 
-        void AddStructAssignment::visit( ContextDecl *) {
+        void AutogenerateRoutines::visit( ContextDecl *) {
                 // ensure that we don't add assignment ops for types defined as part of the context
         }
 
         template< typename StmtClass >
-        inline void AddStructAssignment::visitStatement( StmtClass *stmt ) {
+        inline void AutogenerateRoutines::visitStatement( StmtClass *stmt ) {
                 std::set< std::string > oldStructs = structsDone;
                 addVisit( stmt, *this );
@@ -777 +776 @@
         }
 
-        void AddStructAssignment::visit( FunctionDecl *functionDecl ) {
+        void AutogenerateRoutines::visit( FunctionDecl *functionDecl ) {
                 maybeAccept( functionDecl->get_functionType(), *this );
                 acceptAll( functionDecl->get_oldDecls(), *this );
@@ -785 +784 @@
         }
 
-        void AddStructAssignment::visit( CompoundStmt *compoundStmt ) {
+        void AutogenerateRoutines::visit( CompoundStmt *compoundStmt ) {
                 visitStatement( compoundStmt );
         }
 
-        void AddStructAssignment::visit( IfStmt *ifStmt ) {
+        void AutogenerateRoutines::visit( IfStmt *ifStmt ) {
                 visitStatement( ifStmt );
         }
 
-        void AddStructAssignment::visit( WhileStmt *whileStmt ) {
+        void AutogenerateRoutines::visit( WhileStmt *whileStmt ) {
                 visitStatement( whileStmt );
         }
 
-        void AddStructAssignment::visit( ForStmt *forStmt ) {
+        void AutogenerateRoutines::visit( ForStmt *forStmt ) {
                 visitStatement( forStmt );
         }
 
-        void AddStructAssignment::visit( SwitchStmt *switchStmt ) {
+        void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) {
                 visitStatement( switchStmt );
         }
 
-        void AddStructAssignment::visit( ChooseStmt *switchStmt ) {
+        void AutogenerateRoutines::visit( ChooseStmt *switchStmt ) {
                 visitStatement( switchStmt );
         }
 
-        void AddStructAssignment::visit( CaseStmt *caseStmt ) {
+        void AutogenerateRoutines::visit( CaseStmt *caseStmt ) {
                 visitStatement( caseStmt );
         }
 
-        void AddStructAssignment::visit( CatchStmt *cathStmt ) {
+        void AutogenerateRoutines::visit( CatchStmt *cathStmt ) {
                 visitStatement( cathStmt );
         }
@@ -857 +856 @@
                         Type * t1 = tyDecl->get_base();
                         Type * t2 = typedefNames[ tyDecl->get_name() ].first->get_base();
-                        if ( ! typeEquals( t1, t2, true ) ) {
+                        if ( ! ResolvExpr::typesCompatible( t1, t2, Indexer() ) ) {
                                 throw SemanticError( "cannot redefine typedef: " + tyDecl->get_name() );
                         }