Changes in / [d1b9d78:ed9ecda]

Location:

src

Files:

• SymTab/Indexer.cc (modified) (2 diffs)
• SymTab/Indexer.h (modified) (1 diff)
• SymTab/Mangler.cc (modified) (1 diff)
• libcfa/math (modified) (1 diff)
• libcfa/math.c (modified) (2 diffs)

src/SymTab/Indexer.cc

@@ -526 +526 @@
 
                 return tables->base.hasIncompatibleCDecl( id, mangleName, scope );
-        }
-
-        bool Indexer::hasCompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
-                if ( ! tables ) return false;
-                if ( tables->scope < scope ) 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 ) {
-                                // check for C decls with the same name, skipping
-                                // those with an incompatible type (by mangleName)
-                                if ( decl->second->get_linkage() == LinkageSpec::C && decl->first == mangleName ) return true;
-                        }
-                }
-
-                return tables->base.hasCompatibleCDecl( id, mangleName, scope );
         }
 
@@ -633 +616 @@
                 } // if
 
-                // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage
-                if ( decl->get_linkage() == LinkageSpec::C ) {
-                        // NOTE this is broken in Richard's original code in such a way that it never triggers (it
-                        // doesn't check decls that have the same manglename, and all C-linkage decls are defined to
-                        // have their name as their manglename, hence the error can never trigger).
-                        // The code here is closer to correct, but name mangling would have to be completely
-                        // isomorphic to C type-compatibility, which it may not be.
-                        if ( hasIncompatibleCDecl( name, mangleName, scope ) ) {
-                                throw SemanticError( "conflicting overload of C function ", decl );
-                        }
-                } else {
-                        // Check that a Cforall declaration doesn't overload any C declaration
-                        if ( hasCompatibleCDecl( name, mangleName, scope ) ) {
-                                throw SemanticError( "Cforall declaration hides C function ", decl );
-                        }
-                }
-
-                // Skip repeat declarations of the same identifier
                 DeclarationWithType *existing = lookupIdAtScope( name, mangleName, scope );
-                if ( existing && addedIdConflicts( existing, decl ) ) return;
-
-                // add to indexer
-                tables->idTable[ name ][ mangleName ] = decl;
-                ++tables->size;
+                if ( ! existing || ! addedIdConflicts( existing, decl ) ) {
+                        // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage
+                        if ( decl->get_linkage() == LinkageSpec::C && hasIncompatibleCDecl( name, mangleName, scope ) ) {
+                                throw SemanticError( "invalid overload of C function ", decl );
+                        } // NOTE this is broken in Richard's original code in such a way that it never triggers (it
+                          // doesn't check decls that have the same manglename, and all C-linkage decls are defined to
+                          // have their name as their manglename, hence the error can never trigger).
+                          // The code here is closer to correct, but name mangling would have to be completely
+                          // isomorphic to C type-compatibility, which it may not be.
+
+                        tables->idTable[ name ][ mangleName ] = decl;
+                        ++tables->size;
+                }
         }
 

src/SymTab/Indexer.h

@@ -100 +100 @@
                 /// returns true if there exists a declaration with C linkage and the given name with a different mangled name
                 bool hasIncompatibleCDecl( 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 with the same mangled name
-                bool hasCompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) 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/Mangler.cc

@@ -282 +282 @@
                         mangleName << "V";
                 } // if
-                // Removed due to restrict not affecting function compatibility in GCC
-//              if ( type->get_isRestrict() ) {
-//                      mangleName << "R";
-//              } // if
+                if ( type->get_isRestrict() ) {
+                        mangleName << "R";
+                } // if
                 if ( type->get_isLvalue() ) {
                         mangleName << "L";

src/libcfa/math

@@ -184 +184 @@
 
 float atan2( float, float );
-// extern "C" { double atan2( double, double ); }
+double atan2( double, double );
 long double atan2( long double, long double );
 

src/libcfa/math.c

@@ -23 +23 @@
 long double fabs( long double x ) { return fabsl( x ); }
 float cabs( float _Complex x ) { return cabsf( x ); }
+double cabs( double _Complex x ) { return cabs( x ); }
 long double cabs( long double _Complex x ) { return cabsl( x ); }
 
@@ -158 +159 @@
 
 float atan2( float x, float y ) { return atan2f( x, y ); }
+double atan2( double x, double y ) { return atan2( x, y ); }
 long double atan2( long double x, long double y ) { return atan2l( x, y ); }