Changeset 8884112


Ignore:
Timestamp:
Jul 13, 2016, 1:43:57 PM (5 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
d1b9d78
Parents:
a3e1f8f
Message:

Indexer now produces errors on CFA functions that overload C functions, does not consider restrict qualifier to break compatibility

Location:
src
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • src/SymTab/Indexer.cc

    ra3e1f8f r8884112  
    527527
    528528                return tables->base.hasIncompatibleCDecl( id, mangleName, scope );
     529        }
     530
     531        bool Indexer::hasCompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
     532                if ( ! tables ) return false;
     533                if ( tables->scope < scope ) return false;
     534
     535                IdTable::const_iterator decls = tables->idTable.find( id );
     536                if ( decls != tables->idTable.end() ) {
     537                        const MangleTable &mangleTable = decls->second;
     538                        for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
     539                                // check for C decls with the same name, skipping
     540                                // those with an incompatible type (by mangleName)
     541                                if ( decl->second->get_linkage() == LinkageSpec::C && decl->first == mangleName ) return true;
     542                        }
     543                }
     544
     545                return tables->base.hasCompatibleCDecl( id, mangleName, scope );
    529546        }
    530547
     
    617634                } // if
    618635
     636                // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage
     637                if ( decl->get_linkage() == LinkageSpec::C ) {
     638                        // NOTE this is broken in Richard's original code in such a way that it never triggers (it
     639                        // doesn't check decls that have the same manglename, and all C-linkage decls are defined to
     640                        // have their name as their manglename, hence the error can never trigger).
     641                        // The code here is closer to correct, but name mangling would have to be completely
     642                        // isomorphic to C type-compatibility, which it may not be.
     643                        if ( hasIncompatibleCDecl( name, mangleName, scope ) ) {
     644                                throw SemanticError( "conflicting overload of C function ", decl );
     645                        }
     646                } else {
     647                        // Check that a Cforall declaration doesn't overload any C declaration
     648                        if ( hasCompatibleCDecl( name, mangleName, scope ) ) {
     649                                throw SemanticError( "Cforall declaration hides C function ", decl );
     650                        }
     651                }
     652
     653                // Skip repeat declarations of the same identifier
    619654                DeclarationWithType *existing = lookupIdAtScope( name, mangleName, scope );
    620                 if ( ! existing || ! addedIdConflicts( existing, decl ) ) {
    621                         // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage
    622                         if ( decl->get_linkage() == LinkageSpec::C && hasIncompatibleCDecl( name, mangleName, scope ) ) {
    623                                 throw SemanticError( "invalid overload of C function ", decl );
    624                         } // NOTE this is broken in Richard's original code in such a way that it never triggers (it
    625                           // doesn't check decls that have the same manglename, and all C-linkage decls are defined to
    626                           // have their name as their manglename, hence the error can never trigger).
    627                           // The code here is closer to correct, but name mangling would have to be completely
    628                           // isomorphic to C type-compatibility, which it may not be.
    629 
    630                         tables->idTable[ name ][ mangleName ] = decl;
    631                         ++tables->size;
    632                 }
     655                if ( existing && addedIdConflicts( existing, decl ) ) return;
     656
     657                // add to indexer
     658                tables->idTable[ name ][ mangleName ] = decl;
     659                ++tables->size;
    633660        }
    634661
  • src/SymTab/Indexer.h

    ra3e1f8f r8884112  
    100100                /// returns true if there exists a declaration with C linkage and the given name with a different mangled name
    101101                bool hasIncompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
     102                /// returns true if there exists a declaration with C linkage and the given name with the same mangled name
     103                bool hasCompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
    102104                // equivalents to lookup functions that only look at tables at scope `scope` (which should be >= tables->scope)
    103105                NamedTypeDecl *lookupTypeAtScope( const std::string &id, unsigned long scope ) const;
  • src/SymTab/Mangler.cc

    ra3e1f8f r8884112  
    282282                        mangleName << "V";
    283283                } // if
    284                 if ( type->get_isRestrict() ) {
    285                         mangleName << "R";
    286                 } // if
     284                // Removed due to restrict not affecting function compatibility in GCC
     285//              if ( type->get_isRestrict() ) {
     286//                      mangleName << "R";
     287//              } // if
    287288                if ( type->get_isLvalue() ) {
    288289                        mangleName << "L";
  • src/libcfa/math

    ra3e1f8f r8884112  
    184184
    185185float atan2( float, float );
    186 double atan2( double, double );
     186// extern "C" { double atan2( double, double ); }
    187187long double atan2( long double, long double );
    188188
  • src/libcfa/math.c

    ra3e1f8f r8884112  
    2323long double fabs( long double x ) { return fabsl( x ); }
    2424float cabs( float _Complex x ) { return cabsf( x ); }
    25 double cabs( double _Complex x ) { return cabs( x ); }
    2625long double cabs( long double _Complex x ) { return cabsl( x ); }
    2726
     
    159158
    160159float atan2( float x, float y ) { return atan2f( x, y ); }
    161 double atan2( double x, double y ) { return atan2( x, y ); }
    162160long double atan2( long double x, long double y ) { return atan2l( x, y ); }
    163161
Note: See TracChangeset for help on using the changeset viewer.