Changeset eb5962a for src

Timestamp:

Jun 21, 2022, 1:39:24 PM (3 years ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

b62d1d6

Parents:

1df492a (diff), 1dbbef6 (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

Files:

• AST/Pass.impl.hpp (modified) (5 diffs)
• AST/TypeSubstitution.cpp (modified) (4 diffs)
• AST/TypeSubstitution.hpp (modified) (3 diffs)
• Concurrency/Waitfor.cc (modified) (1 diff)
• Concurrency/Waitfor.h (modified) (1 diff)
• Concurrency/WaitforNew.cpp (added)
• Concurrency/module.mk (modified) (1 diff)
• GenPoly/Specialize.cc (modified) (1 diff)
• InitTweak/FixGlobalInit.cc (modified) (1 diff)
• InitTweak/FixInit.cc (modified) (1 diff)
• InitTweak/InitTweak.cc (modified) (4 diffs)
• InitTweak/InitTweak.h (modified) (1 diff)
• main.cc (modified) (3 diffs)

src/AST/Pass.impl.hpp

@@ -182 +182 @@
 
                 // get the stmts/decls that will need to be spliced in
-                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
-                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0);
-                auto decls_before = __pass::declsToAddBefore( core, 0);
-                auto decls_after  = __pass::declsToAddAfter ( core, 0);
+                auto stmts_before = __pass::stmtsToAddBefore( core, 0 );
+                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0 );
+                auto decls_before = __pass::declsToAddBefore( core, 0 );
+                auto decls_after  = __pass::declsToAddAfter ( core, 0 );
 
                 // These may be modified by subnode but most be restored once we exit this statemnet.
@@ -287 +287 @@
 
                 // get the stmts/decls that will need to be spliced in
-                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
-                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0);
-                auto decls_before = __pass::declsToAddBefore( core, 0);
-                auto decls_after  = __pass::declsToAddAfter ( core, 0);
+                auto stmts_before = __pass::stmtsToAddBefore( core, 0 );
+                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0 );
+                auto decls_before = __pass::declsToAddBefore( core, 0 );
+                auto decls_after  = __pass::declsToAddAfter ( core, 0 );
 
                 // These may be modified by subnode but most be restored once we exit this statemnet.
@@ -317 +317 @@
                                 assert(( empty( stmts_before ) && empty( stmts_after ))
                                     || ( empty( decls_before ) && empty( decls_after )) );
-
-
 
                                 // Take all the statements which should have gone after, N/A for first iteration
@@ -2116 +2114 @@
         if ( __visit_children() ) {
                 bool mutated = false;
-                std::unordered_map< ast::TypeInstType::TypeEnvKey, ast::ptr< ast::Type > > new_map;
-                for ( const auto & p : node->typeEnv ) {
+                ast::TypeSubstitution::TypeMap new_map;
+                for ( const auto & p : node->typeMap ) {
                         guard_symtab guard { *this };
                         auto new_node = p.second->accept( *this );
@@ -2125 +2123 @@
                 if (mutated) {
                         auto new_node = __pass::mutate<core_t>( node );
-                        new_node->typeEnv.swap( new_map );
+                        new_node->typeMap.swap( new_map );
                         node = new_node;
                 }

src/AST/TypeSubstitution.cpp

@@ -38 +38 @@
 
 void TypeSubstitution::initialize( const TypeSubstitution &src, TypeSubstitution &dest ) {
-        dest.typeEnv.clear();
+        dest.typeMap.clear();
         dest.add( src );
 }
 
 void TypeSubstitution::add( const TypeSubstitution &other ) {
-        for ( TypeEnvType::const_iterator i = other.typeEnv.begin(); i != other.typeEnv.end(); ++i ) {
-                typeEnv[ i->first ] = i->second;
+        for ( TypeMap::const_iterator i = other.typeMap.begin(); i != other.typeMap.end(); ++i ) {
+                typeMap[ i->first ] = i->second;
         } // for
 }
 
 void TypeSubstitution::add( const TypeInstType * formalType, const Type *actualType ) {
-        typeEnv[ *formalType ] = actualType;
+        typeMap[ *formalType ] = actualType;
 }
 
 void TypeSubstitution::add( const TypeInstType::TypeEnvKey & key, const Type * actualType) {
-        typeEnv[ key ] = actualType;
+        typeMap[ key ] = actualType;
 }
 
 void TypeSubstitution::remove( const TypeInstType * formalType ) {
-        TypeEnvType::iterator i = typeEnv.find( *formalType );
-        if ( i != typeEnv.end() ) {
-                typeEnv.erase( *formalType );
-        } // if
-}
-
-const Type *TypeSubstitution::lookup( const TypeInstType * formalType ) const {
-        TypeEnvType::const_iterator i = typeEnv.find( *formalType );
+        TypeMap::iterator i = typeMap.find( *formalType );
+        if ( i != typeMap.end() ) {
+                typeMap.erase( *formalType );
+        } // if
+}
+
+const Type *TypeSubstitution::lookup(
+                const TypeInstType::TypeEnvKey & formalType ) const {
+        TypeMap::const_iterator i = typeMap.find( formalType );
 
         // break on not in substitution set
-        if ( i == typeEnv.end() ) return 0;
+        if ( i == typeMap.end() ) return 0;
 
         // attempt to transitively follow TypeInstType links.
         while ( const TypeInstType *actualType = i->second.as<TypeInstType>()) {
                 // break cycles in the transitive follow
-                if ( *formalType == *actualType ) break;
+                if ( formalType == *actualType ) break;
 
                 // Look for the type this maps to, returning previous mapping if none-such
-                i = typeEnv.find( *actualType );
-                if ( i == typeEnv.end() ) return actualType;
+                i = typeMap.find( *actualType );
+                if ( i == typeMap.end() ) return actualType;
         }
 
@@ -83 +84 @@
 }
 
+const Type *TypeSubstitution::lookup( const TypeInstType * formalType ) const {
+        return lookup( ast::TypeInstType::TypeEnvKey( *formalType ) );
+}
+
 bool TypeSubstitution::empty() const {
-        return typeEnv.empty();
+        return typeMap.empty();
 }
 
@@ -119 +124 @@
                 sub.core.subCount = 0;
                 sub.core.freeOnly = true;
-                for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
+                for ( TypeMap::iterator i = typeMap.begin(); i != typeMap.end(); ++i ) {
                         i->second = i->second->accept( sub );
                 }
@@ -129 +134 @@
         if ( bound != boundVars.end() ) return inst;
 
-        TypeEnvType::const_iterator i = sub.typeEnv.find( *inst );
-        if ( i == sub.typeEnv.end() ) {
+        TypeMap::const_iterator i = sub.typeMap.find( *inst );
+        if ( i == sub.typeMap.end() ) {
                 return inst;
         } else {

src/AST/TypeSubstitution.hpp

@@ -75 +75 @@
         void add( const TypeSubstitution &other );
         void remove( const TypeInstType * formalType );
+        const Type *lookup( const TypeInstType::TypeEnvKey & formalType ) const;
         const Type *lookup( const TypeInstType * formalType ) const;
         bool empty() const;
@@ -104 +105 @@
         friend class Pass;
 
-        typedef std::unordered_map< TypeInstType::TypeEnvKey, ptr<Type> > TypeEnvType;
-        TypeEnvType typeEnv;
+        typedef std::unordered_map< TypeInstType::TypeEnvKey, ptr<Type> > TypeMap;
+        TypeMap typeMap;
 
   public:
-        // has to come after declaration of typeEnv
-        auto begin()       -> decltype( typeEnv.begin() ) { return typeEnv.begin(); }
-        auto   end()       -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
-        auto begin() const -> decltype( typeEnv.begin() ) { return typeEnv.begin(); }
-        auto   end() const -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
+        // has to come after declaration of typeMap
+        auto begin()       -> decltype( typeMap.begin() ) { return typeMap.begin(); }
+        auto   end()       -> decltype( typeMap.  end() ) { return typeMap.  end(); }
+        auto begin() const -> decltype( typeMap.begin() ) { return typeMap.begin(); }
+        auto   end() const -> decltype( typeMap.  end() ) { return typeMap.  end(); }
 
 };
@@ -144 +145 @@
                         if ( const TypeExpr *actual = actualIt->template as<TypeExpr>() ) {
                                 if ( formal->name != "" ) {
-                                        typeEnv[ formal ] = actual->type;
+                                        typeMap[ formal ] = actual->type;
                                 } // if
                         } else {

src/Concurrency/Waitfor.cc

@@ -56 +56 @@
                       |  |
                       |  |
-                            |  |
+                      |  |
                       |  |
                       |  |

src/Concurrency/Waitfor.h

@@ -19 +19 @@
 
 class Declaration;
+namespace ast {
+        class TranslationUnit;
+}
 
 namespace Concurrency {
         void generateWaitFor( std::list< Declaration * > & translationUnit );
+
+void generateWaitFor( ast::TranslationUnit & translationUnit );
 };
 

src/Concurrency/module.mk

@@ -19 +19 @@
         Concurrency/Keywords.cc \
         Concurrency/Keywords.h \
+        Concurrency/WaitforNew.cpp \
         Concurrency/Waitfor.cc \
         Concurrency/Waitfor.h

src/GenPoly/Specialize.cc

@@ -247 +247 @@
                         structureArg( (*actualBegin)->get_type(), argBegin, argEnd, back_inserter( appExpr->get_args() ) );
                 }
+                assertf( argBegin == argEnd, "Did not structure all arguments." );
 
                 appExpr->env = TypeSubstitution::newFromExpr( appExpr, env );

src/InitTweak/FixGlobalInit.cc

@@ -162 +162 @@
                         } // if
                         if ( Statement * ctor = ctorInit->ctor ) {
-                                addDataSectonAttribute( objDecl );
+                                addDataSectionAttribute( objDecl );
                                 initStatements.push_back( ctor );
                                 objDecl->init = nullptr;

src/InitTweak/FixInit.cc

@@ -806 +806 @@
                                                 // The attribute works, and is meant to apply, both for leaving the static local alone,
                                                 // and for hoisting it out as a static global.
-                                                addDataSectonAttribute( objDecl );
+                                                addDataSectionAttribute( objDecl );
 
                                                 // originally wanted to take advantage of gcc nested functions, but

src/InitTweak/InitTweak.cc

@@ -587 +587 @@
 
         bool isConstructable( const ast::Type * type ) {
-                return ! dynamic_cast< const ast::VarArgsType * >( type ) && ! dynamic_cast< const ast::ReferenceType * >( type ) 
+                return ! dynamic_cast< const ast::VarArgsType * >( type ) && ! dynamic_cast< const ast::ReferenceType * >( type )
                 && ! dynamic_cast< const ast::FunctionType * >( type ) && ! Tuples::isTtype( type );
         }
@@ -1025 +1025 @@
                 if (!assign) {
                         auto td = new ast::TypeDecl({}, "T", {}, nullptr, ast::TypeDecl::Dtype, true);
-                        assign = new ast::FunctionDecl({}, "?=?", {}, 
+                        assign = new ast::FunctionDecl({}, "?=?", {},
                         { new ast::ObjectDecl({}, "_dst", new ast::ReferenceType(new ast::TypeInstType("T", td))),
                           new ast::ObjectDecl({}, "_src", new ast::TypeInstType("T", td))},
@@ -1095 +1095 @@
 
                         // address of a variable or member expression is constexpr
-                        if ( ! dynamic_cast< const ast::NameExpr * >( arg ) 
-                        && ! dynamic_cast< const ast::VariableExpr * >( arg ) 
-                        && ! dynamic_cast< const ast::MemberExpr * >( arg ) 
+                        if ( ! dynamic_cast< const ast::NameExpr * >( arg )
+                        && ! dynamic_cast< const ast::VariableExpr * >( arg )
+                        && ! dynamic_cast< const ast::MemberExpr * >( arg )
                         && ! dynamic_cast< const ast::UntypedMemberExpr * >( arg ) ) result = false;
                 }
@@ -1241 +1241 @@
         }
 
-        void addDataSectonAttribute( ObjectDecl * objDecl ) {
+        #if defined( __x86_64 ) || defined( __i386 ) // assembler comment to prevent assembler warning message
+                #define ASM_COMMENT "#"
+        #else // defined( __ARM_ARCH )
+                #define ASM_COMMENT "//"
+        #endif
+        static const char * const data_section =  ".data" ASM_COMMENT;
+        static const char * const tlsd_section = ".tdata" ASM_COMMENT;
+        void addDataSectionAttribute( ObjectDecl * objDecl ) {
+                const bool is_tls = objDecl->get_storageClasses().is_threadlocal;
+                const char * section = is_tls ? tlsd_section : data_section;
                 objDecl->attributes.push_back(new Attribute("section", {
-                        new ConstantExpr( Constant::from_string(".data"
-#if defined( __x86_64 ) || defined( __i386 ) // assembler comment to prevent assembler warning message
-                                        "#"
-#else // defined( __ARM_ARCH )
-                                        "//"
-#endif
-                                ))}));
+                        new ConstantExpr( Constant::from_string( section ) )
+                }));
         }
 
         void addDataSectionAttribute( ast::ObjectDecl * objDecl ) {
+                const bool is_tls = objDecl->storage.is_threadlocal;
+                const char * section = is_tls ? tlsd_section : data_section;
                 objDecl->attributes.push_back(new ast::Attribute("section", {
-                        ast::ConstantExpr::from_string(objDecl->location, ".data"
-#if defined( __x86_64 ) || defined( __i386 ) // assembler comment to prevent assembler warning message
-                                        "#"
-#else // defined( __ARM_ARCH )
-                                        "//"
-#endif
-                                )}));
+                        ast::ConstantExpr::from_string(objDecl->location, section)
+                }));
         }
 

src/InitTweak/InitTweak.h

@@ -127 +127 @@
         ///    .section .data#,"a"
         /// to avoid assembler warning "ignoring changed section attributes for .data"
-        void addDataSectonAttribute( ObjectDecl * objDecl );
+        void addDataSectionAttribute( ObjectDecl * objDecl );
 
         void addDataSectionAttribute( ast::ObjectDecl * objDecl );

src/main.cc

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Apr 29  9:52:00 2022
-// Update Count     : 673
+// Last Modified On : Tue Jun  7 13:29:00 2022
+// Update Count     : 674
 //
 
@@ -447 +447 @@
                         PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( transUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
 
-                        PASS( "Translate Tries" , ControlStruct::translateTries( transUnit ) );
+                        PASS( "Translate Tries", ControlStruct::translateTries( transUnit ) );
+                        PASS( "Gen Waitfor", Concurrency::generateWaitFor( transUnit ) );
 
                         translationUnit = convert( move( transUnit ) );
@@ -517 +518 @@
 
                         PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
-
-                        PASS( "Translate Tries" , ControlStruct::translateTries( translationUnit ) );
+                        PASS( "Translate Tries", ControlStruct::translateTries( translationUnit ) );
+                        PASS( "Gen Waitfor", Concurrency::generateWaitFor( translationUnit ) );
                 }
-
-                PASS( "Gen Waitfor" , Concurrency::generateWaitFor( translationUnit ) );
 
                 PASS( "Convert Specializations",  GenPoly::convertSpecializations( translationUnit ) ); // needs to happen before tuple types are expanded