Changeset eba74ba for src/SymTab

Timestamp:

May 25, 2018, 2:51:06 PM (7 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env, with_gc

Children:

cdc4d43

Parents:

3ef35bd (diff), 58e822a (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 remote-tracking branch 'origin/master' into with_gc

Location:

src/SymTab

Files:

• Indexer.cc (modified) (3 diffs)
• Mangler.cc (modified) (9 diffs)

src/SymTab/Indexer.cc

@@ -26 +26 @@
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for cloneAll
+#include "GenPoly/GenPoly.h"
 #include "InitTweak/InitTweak.h"   // for isConstructor, isCopyFunction, isC...
 #include "Mangler.h"               // for Mangler
@@ -377 +378 @@
         }
 
+        bool isFunction( DeclarationWithType * decl ) {
+                return GenPoly::getFunctionType( decl->get_type() );
+        }
+
+        bool isObject( DeclarationWithType * decl ) {
+                return ! isFunction( decl );
+        }
+
+        bool isDefinition( DeclarationWithType * decl ) {
+                if ( FunctionDecl * func = dynamic_cast< FunctionDecl * >( decl ) ) {
+                        // a function is a definition if it has a body
+                        return func->statements;
+                } else {
+                        // an object is a definition if it is not marked extern.
+                        // both objects must be marked extern
+                        return ! decl->get_storageClasses().is_extern;
+                }
+        }
+
         bool addedIdConflicts( Indexer::IdData & existing, DeclarationWithType *added, BaseSyntaxNode * deleteStmt, Indexer::ConflictFunction handleConflicts ) {
                 // 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.id ) )
-                        || (dynamic_cast<FunctionDecl*>( added ) && dynamic_cast<FunctionDecl*>( existing.id ) ) );
+                assert( (isObject( added ) && isObject( existing.id ) )
+                        || ( isFunction( added ) && isFunction( existing.id ) ) );
 
                 if ( LinkageSpec::isOverridable( existing.id->get_linkage() ) ) {
@@ -394 +414 @@
                         }
 
-                        // 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.id );
-                        if ( newentry && oldentry ) {
-                                if ( newentry->get_statements() && oldentry->get_statements() ) {
+                        if ( isDefinition( added ) && isDefinition( existing.id ) ) {
+                                if ( isFunction( added ) ) {
                                         return handleConflicts( existing, "duplicate function definition for " );
-                                } // 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.id );
-                                if ( ! newobj->get_storageClasses().is_extern && ! oldobj->get_storageClasses().is_extern ) {
+                                } else {
                                         return handleConflicts( existing, "duplicate object definition for " );
                                 } // if

src/SymTab/Mangler.cc

@@ -35 +35 @@
                 namespace {
                         /// Mangles names to a unique C identifier
-                        struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler> {
+                        struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler>, public WithGuards {
                                 Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
                                 Mangler( const Mangler & ) = delete;
@@ -55 +55 @@
                                 void postvisit( EnumInstType * aggregateUseType );
                                 void postvisit( TypeInstType * aggregateUseType );
+                                void postvisit( TraitInstType * inst );
                                 void postvisit( TupleType * tupleType );
                                 void postvisit( VarArgsType * varArgsType );
@@ -70 +71 @@
                                 bool typeMode;                  ///< Produce a unique mangled name for a type
                                 bool mangleGenericParams;       ///< Include generic parameters in name mangling if true
+                                bool inFunctionType = false;    ///< Include type qualifiers if false.
 
                                 void mangleDecl( DeclarationWithType *declaration );
@@ -177 +179 @@
                         void Mangler::postvisit( PointerType * pointerType ) {
                                 printQualifiers( pointerType );
-                                mangleName << "P";
+                                // mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers
+                                if ( ! dynamic_cast<FunctionType *>( pointerType->base ) ) mangleName << "P";
                                 maybeAccept( pointerType->base, *visitor );
                         }
@@ -189 +192 @@
 
                         void Mangler::postvisit( ReferenceType * refType ) {
+                                // don't print prefix (e.g. 'R') for reference types so that references and non-references do not overload.
+                                // Further, do not print the qualifiers for a reference type (but do run printQualifers because of TypeDecls, etc.),
+                                // by pretending every reference type is a function parameter.
+                                GuardValue( inFunctionType );
+                                inFunctionType = true;
                                 printQualifiers( refType );
-                                mangleName << "R";
                                 maybeAccept( refType->base, *visitor );
                         }
@@ -206 +213 @@
                                 printQualifiers( functionType );
                                 mangleName << "F";
+                                // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
+                                // since qualifiers on outermost parameter type do not differentiate function types, e.g.,
+                                // void (*)(const int) and void (*)(int) are the same type, but void (*)(const int *) and void (*)(int *) are different
+                                GuardValue( inFunctionType );
+                                inFunctionType = true;
                                 std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() );
                                 acceptAll( returnTypes, *visitor );
@@ -270 +282 @@
                         }
 
+                        void Mangler::postvisit( TraitInstType * inst ) {
+                                printQualifiers( inst );
+                                mangleName << "_Y" << inst->name << "_";
+                        }
+
                         void Mangler::postvisit( TupleType * tupleType ) {
                                 printQualifiers( tupleType );
@@ -304 +321 @@
                                 // skip if not including qualifiers
                                 if ( typeMode ) return;
-
                                 if ( ! type->get_forall().empty() ) {
                                         std::list< std::string > assertionNames;
@@ -337 +353 @@
                                         mangleName << "_";
                                 } // if
-                                if ( type->get_const() ) {
-                                        mangleName << "C";
-                                } // if
-                                if ( type->get_volatile() ) {
-                                        mangleName << "V";
-                                } // if
+                                if ( ! inFunctionType ) {
+                                        // these qualifiers do not distinguish the outermost type of a function parameter
+                                        if ( type->get_const() ) {
+                                                mangleName << "C";
+                                        } // if
+                                        if ( type->get_volatile() ) {
+                                                mangleName << "V";
+                                        } // if
+                                        // Removed due to restrict not affecting function compatibility in GCC
+                                        // if ( type->get_isRestrict() ) {
+                                        //      mangleName << "E";
+                                        // } // if
+                                        if ( type->get_atomic() ) {
+                                                mangleName << "A";
+                                        } // if
+                                }
                                 if ( type->get_mutex() ) {
                                         mangleName << "M";
                                 } // if
-                                // Removed due to restrict not affecting function compatibility in GCC
-                //              if ( type->get_isRestrict() ) {
-                //                      mangleName << "E";
-                //              } // if
                                 if ( type->get_lvalue() ) {
                                         // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
                                         mangleName << "L";
                                 }
-                                if ( type->get_atomic() ) {
-                                        mangleName << "A";
-                                } // if
+
+                                if ( inFunctionType ) {
+                                        // turn off inFunctionType so that types can be differentiated for nested qualifiers
+                                        GuardValue( inFunctionType );
+                                        inFunctionType = false;
+                                }
                         }
                 }       // namespace