Changeset 54dd994 for src/InitTweak/InitTweak.cc

Timestamp:

Jun 24, 2019, 10:30:47 AM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

84917e2

Parents:

3c6e417 (diff), 9e0a360 (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

File:

• src/InitTweak/InitTweak.cc (modified) (11 diffs)

src/InitTweak/InitTweak.cc

@@ -22 +22 @@
 
 #include "AST/Expr.hpp"
+#include "AST/Init.hpp"
+#include "AST/Node.hpp"
+#include "AST/Pass.hpp"
 #include "AST/Stmt.hpp"
 #include "AST/Type.hpp"
@@ -84 +87 @@
                 };
 
-                struct InitFlattener : public WithShortCircuiting {
+                struct InitFlattener_old : public WithShortCircuiting {
                         void previsit( SingleInit * singleInit ) {
                                 visit_children = false;
@@ -92 +95 @@
                 };
 
-        }
+                struct InitFlattener_new : public ast::WithShortCircuiting {
+                        std::vector< ast::ptr< ast::Expr > > argList;
+
+                        void previsit( const ast::SingleInit * singleInit ) {
+                                visit_children = false;
+                                argList.emplace_back( singleInit->value );
+                        }
+                };
+
+        } // anonymous namespace
 
         std::list< Expression * > makeInitList( Initializer * init ) {
-                PassVisitor<InitFlattener> flattener;
+                PassVisitor<InitFlattener_old> flattener;
                 maybeAccept( init, flattener );
                 return flattener.pass.argList;
@@ -112 +124 @@
         }
 
-        class InitExpander::ExpanderImpl {
+std::vector< ast::ptr< ast::Expr > > makeInitList( const ast::Init * init ) {
+        ast::Pass< InitFlattener_new > flattener;
+        maybe_accept( init, flattener );
+        return std::move( flattener.pass.argList );
+}
+
+        class InitExpander_old::ExpanderImpl {
         public:
                 virtual ~ExpanderImpl() = default;
@@ -119 +137 @@
         };
 
-        class InitImpl : public InitExpander::ExpanderImpl {
+        class InitImpl_old : public InitExpander_old::ExpanderImpl {
         public:
-                InitImpl( Initializer * init ) : init( init ) {}
-                virtual ~InitImpl() = default;
+                InitImpl_old( Initializer * init ) : init( init ) {}
+                virtual ~InitImpl_old() = default;
 
                 virtual std::list< Expression * > next( __attribute((unused)) std::list< Expression * > & indices ) {
@@ -136 +154 @@
         };
 
-        class ExprImpl : public InitExpander::ExpanderImpl {
+        class ExprImpl_old : public InitExpander_old::ExpanderImpl {
         public:
-                ExprImpl( Expression * expr ) : arg( expr ) {}
-                virtual ~ExprImpl() { delete arg; }
+                ExprImpl_old( Expression * expr ) : arg( expr ) {}
+                virtual ~ExprImpl_old() { delete arg; }
 
                 virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
@@ -163 +181 @@
         };
 
-        InitExpander::InitExpander( Initializer * init ) : expander( new InitImpl( init ) ) {}
-
-        InitExpander::InitExpander( Expression * expr ) : expander( new ExprImpl( expr ) ) {}
-
-        std::list< Expression * > InitExpander::operator*() {
+        InitExpander_old::InitExpander_old( Initializer * init ) : expander( new InitImpl_old( init ) ) {}
+
+        InitExpander_old::InitExpander_old( Expression * expr ) : expander( new ExprImpl_old( expr ) ) {}
+
+        std::list< Expression * > InitExpander_old::operator*() {
                 return cur;
         }
 
-        InitExpander & InitExpander::operator++() {
+        InitExpander_old & InitExpander_old::operator++() {
                 cur = expander->next( indices );
                 return *this;
@@ -177 +195 @@
 
         // use array indices list to build switch statement
-        void InitExpander::addArrayIndex( Expression * index, Expression * dimension ) {
+        void InitExpander_old::addArrayIndex( Expression * index, Expression * dimension ) {
                 indices.push_back( index );
                 indices.push_back( dimension );
         }
 
-        void InitExpander::clearArrayIndices() {
+        void InitExpander_old::clearArrayIndices() {
                 deleteAll( indices );
                 indices.clear();
         }
 
-        bool InitExpander::addReference() {
+        bool InitExpander_old::addReference() {
                 bool added = false;
                 for ( Expression *& expr : cur ) {
@@ -218 +236 @@
 
                 template< typename OutIterator >
-                void build( UntypedExpr * callExpr, InitExpander::IndexList::iterator idx, InitExpander::IndexList::iterator idxEnd, Initializer * init, OutIterator out ) {
+                void build( UntypedExpr * callExpr, InitExpander_old::IndexList::iterator idx, InitExpander_old::IndexList::iterator idxEnd, Initializer * init, OutIterator out ) {
                         if ( idx == idxEnd ) return;
                         Expression * index = *idx++;
@@ -275 +293 @@
         // remaining elements.
         // To accomplish this, generate switch statement, consuming all of expander's elements
-        Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
+        Statement * InitImpl_old::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
                 if ( ! init ) return nullptr;
                 CompoundStmt * block = new CompoundStmt();
@@ -288 +306 @@
         }
 
-        Statement * ExprImpl::buildListInit( UntypedExpr *, std::list< Expression * > & ) {
+        Statement * ExprImpl_old::buildListInit( UntypedExpr *, std::list< Expression * > & ) {
                 return nullptr;
         }
 
-        Statement * InitExpander::buildListInit( UntypedExpr * dst ) {
+        Statement * InitExpander_old::buildListInit( UntypedExpr * dst ) {
                 return expander->buildListInit( dst, indices );
         }
+
+class InitExpander_new::ExpanderImpl {
+public:
+        virtual ~ExpanderImpl() = default;
+        virtual std::vector< ast::ptr< ast::Expr > > next( IndexList & indices ) = 0;
+        virtual ast::ptr< ast::Stmt > buildListInit( 
+                ast::UntypedExpr * callExpr, IndexList & indices ) = 0;
+};
+
+namespace {
+        template< typename Out >
+        void buildCallExpr( 
+                ast::UntypedExpr * callExpr, const ast::Expr * index, const ast::Expr * dimension, 
+                const ast::Init * init, Out & out
+        ) {
+                const CodeLocation & loc = init->location;
+
+                auto cond = new ast::UntypedExpr{ 
+                        loc, new ast::NameExpr{ loc, "?<?" }, { index, dimension } };
+                
+                std::vector< ast::ptr< ast::Expr > > args = makeInitList( init );
+                splice( callExpr->args, args );
+
+                out.emplace_back( new ast::IfStmt{ loc, cond, new ast::ExprStmt{ loc, callExpr } } );
+
+                out.emplace_back( new ast::ExprStmt{ 
+                        loc, new ast::UntypedExpr{ loc, new ast::NameExpr{ loc, "++?" }, { index } } } );
+        }
+
+        template< typename Out >
+        void build(
+                ast::UntypedExpr * callExpr, const InitExpander_new::IndexList & indices, 
+                const ast::Init * init, Out & out
+        ) {
+                if ( indices.empty() ) return;
+
+                unsigned idx = 0;
+
+                const ast::Expr * index = indices[idx++];
+                assert( idx != indices.size() );
+                const ast::Expr * dimension = indices[idx++];
+
+                if ( idx == indices.size() ) {
+                        if ( auto listInit = dynamic_cast< const ast::ListInit * >( init ) ) {
+                                for ( const ast::Init * init : *listInit ) {
+                                        buildCallExpr( callExpr, index, dimension, init, out );
+                                }
+                        } else {
+                                buildCallExpr( callExpr, index, dimension, init, out );
+                        }
+                } else {
+                        const CodeLocation & loc = init->location;
+
+                        unsigned long cond = 0;
+                        auto listInit = dynamic_cast< const ast::ListInit * >( init );
+                        if ( ! listInit ) { SemanticError( loc, "unbalanced list initializers" ); }
+
+                        static UniqueName targetLabel( "L__autogen__" );
+                        ast::Label switchLabel{ 
+                                loc, targetLabel.newName(), { new ast::Attribute{ "unused" } } };
+                        
+                        std::vector< ast::ptr< ast::Stmt > > branches;
+                        for ( const ast::Init * init : *listInit ) {
+                                auto condition = ast::ConstantExpr::from_ulong( loc, cond );
+                                ++cond;
+
+                                std::vector< ast::ptr< ast::Stmt > > stmts;
+                                build( callExpr, indices, init, stmts );
+                                stmts.emplace_back( 
+                                        new ast::BranchStmt{ loc, ast::BranchStmt::Break, switchLabel } );
+                                branches.emplace_back( new ast::CaseStmt{ loc, condition, std::move( stmts ) } );
+                        }
+                        out.emplace_back( new ast::SwitchStmt{ loc, index, std::move( branches ) } );
+                        out.emplace_back( new ast::NullStmt{ loc, { switchLabel } } );
+                }
+        }
+
+        class InitImpl_new final : public InitExpander_new::ExpanderImpl {
+                ast::ptr< ast::Init > init;
+        public:
+                InitImpl_new( const ast::Init * i ) : init( i ) {}
+
+                std::vector< ast::ptr< ast::Expr > > next( InitExpander_new::IndexList & ) override {
+                        return makeInitList( init );
+                }
+                
+                ast::ptr< ast::Stmt > buildListInit( 
+                        ast::UntypedExpr * callExpr, InitExpander_new::IndexList & indices 
+                ) override {
+                        // If array came with an initializer list, initialize each element. We may have more 
+                        // initializers than elements of the array; need to check at each index that we have 
+                        // not exceeded size. We may have fewer initializers than elements in the array; need 
+                        // to default-construct remaining elements. To accomplish this, generate switch 
+                        // statement consuming all of expander's elements
+
+                        if ( ! init ) return {};
+
+                        std::list< ast::ptr< ast::Stmt > > stmts;
+                        build( callExpr, indices, init, stmts );
+                        if ( stmts.empty() ) {
+                                return {};
+                        } else {
+                                auto block = new ast::CompoundStmt{ init->location, std::move( stmts ) };
+                                init = nullptr;  // consumed in creating the list init
+                                return block;
+                        }
+                }
+        };
+
+        class ExprImpl_new final : public InitExpander_new::ExpanderImpl {
+                ast::ptr< ast::Expr > arg;
+        public:
+                ExprImpl_new( const ast::Expr * a ) : arg( a ) {}
+
+                std::vector< ast::ptr< ast::Expr > > next( 
+                        InitExpander_new::IndexList & indices 
+                ) override {
+                        if ( ! arg ) return {};
+
+                        const CodeLocation & loc = arg->location;
+                        const ast::Expr * expr = arg;
+                        for ( auto it = indices.rbegin(); it != indices.rend(); ++it ) {
+                                // go through indices and layer on subscript exprs ?[?]
+                                ++it;
+                                expr = new ast::UntypedExpr{ 
+                                        loc, new ast::NameExpr{ loc, "?[?]" }, { expr, *it } };
+                        }
+                        return { expr };
+                }
+                
+                ast::ptr< ast::Stmt > buildListInit( 
+                        ast::UntypedExpr *, InitExpander_new::IndexList & 
+                ) override { 
+                        return {};
+                }
+        };
+} // anonymous namespace
+
+InitExpander_new::InitExpander_new( const ast::Init * init )
+: expander( new InitImpl_new{ init } ), crnt(), indices() {}
+
+InitExpander_new::InitExpander_new( const ast::Expr * expr )
+: expander( new ExprImpl_new{ expr } ), crnt(), indices() {}
+
+std::vector< ast::ptr< ast::Expr > > InitExpander_new::operator* () { return crnt; }
+
+InitExpander_new & InitExpander_new::operator++ () {
+        crnt = expander->next( indices );
+        return *this;
+}
+
+/// builds statement which has the same semantics as a C-style list initializer (for array 
+/// initializers) using callExpr as the base expression to perform initialization
+ast::ptr< ast::Stmt > InitExpander_new::buildListInit( ast::UntypedExpr * callExpr ) {
+        return expander->buildListInit( callExpr, indices );
+}
+
+void InitExpander_new::addArrayIndex( const ast::Expr * index, const ast::Expr * dimension ) {
+        indices.emplace_back( index );
+        indices.emplace_back( dimension );
+}
+
+void InitExpander_new::clearArrayIndices() { indices.clear(); }
+
+bool InitExpander_new::addReference() {
+        for ( ast::ptr< ast::Expr > & expr : crnt ) {
+                expr = new ast::AddressExpr{ expr };
+        }
+        return ! crnt.empty();
+}
 
         Type * getTypeofThis( FunctionType * ftype ) {