source: src/InitTweak/InitTweak.cc @ 6cf27a07

aaron-thesisarm-ehcleanup-dtorsctordeferred_resndemanglerjacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since 6cf27a07 was 6cf27a07, checked in by Rob Schluntz <rschlunt@…>, 6 years ago

reorganize global init so that it is simpler and generates less unnecessary code

  • Property mode set to 100644
File size: 7.9 KB
Line 
1#include "InitTweak.h"
2#include "SynTree/Visitor.h"
3#include "SynTree/Statement.h"
4#include "SynTree/Initializer.h"
5#include "SynTree/Expression.h"
6#include "GenPoly/GenPoly.h"
7
8namespace InitTweak {
9        namespace {
10                class HasDesignations : public Visitor {
11                public:
12                        bool hasDesignations = false;
13                        template<typename Init>
14                        void handleInit( Init * init ) {
15                                if ( ! init->get_designators().empty() ) hasDesignations = true;
16                                else Visitor::visit( init );
17                        }
18                        virtual void visit( SingleInit * singleInit ) { handleInit( singleInit); }
19                        virtual void visit( ListInit * listInit ) { handleInit( listInit); }
20                };
21
22                class InitExpander : public Visitor {
23                        public:
24                        InitExpander() {}
25                        virtual void visit( SingleInit * singleInit );
26                        virtual void visit( ListInit * listInit );
27                        std::list< Expression * > argList;
28                };
29
30                void InitExpander::visit( SingleInit * singleInit ) {
31                        argList.push_back( singleInit->get_value()->clone() );
32                }
33
34                void InitExpander::visit( ListInit * listInit ) {
35                        // xxx - for now, assume no nested list inits
36                        std::list<Initializer*>::iterator it = listInit->begin_initializers();
37                        for ( ; it != listInit->end_initializers(); ++it ) {
38                                (*it)->accept( *this );
39                        }
40                }
41        }
42
43        std::list< Expression * > makeInitList( Initializer * init ) {
44                InitExpander expander;
45                maybeAccept( init, expander );
46                return expander.argList;
47        }
48
49        bool isDesignated( Initializer * init ) {
50                HasDesignations finder;
51                maybeAccept( init, finder );
52                return finder.hasDesignations;
53        }
54
55        bool tryConstruct( ObjectDecl * objDecl ) {
56                return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
57                        (objDecl->get_init() == NULL ||
58                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) &&
59                        ! isDesignated( objDecl->get_init() )
60                        && objDecl->get_storageClass() != DeclarationNode::Extern;
61        }
62
63        Expression * getCtorDtorCall( Statement * stmt ) {
64                if ( stmt == NULL ) return NULL;
65                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
66                        return exprStmt->get_expr();
67                } else if ( CompoundStmt * compoundStmt = dynamic_cast< CompoundStmt * >( stmt ) ) {
68                        // could also be a compound statement with a loop, in the case of an array
69                        if( compoundStmt->get_kids().size() == 2 ) {
70                                // loop variable and loop
71                                ForStmt * forStmt = dynamic_cast< ForStmt * >( compoundStmt->get_kids().back() );
72                                assert( forStmt && forStmt->get_body() );
73                                return getCtorDtorCall( forStmt->get_body() );
74                        } else if ( compoundStmt->get_kids().size() == 1 ) {
75                                // should be the call statement, but in any case there's only one option
76                                return getCtorDtorCall( compoundStmt->get_kids().front() );
77                        } else {
78                                assert( false && "too many statements in compoundStmt for getCtorDtorCall" );
79                        }
80                } if ( ImplicitCtorDtorStmt * impCtorDtorStmt = dynamic_cast< ImplicitCtorDtorStmt * > ( stmt ) ) {
81                        return getCtorDtorCall( impCtorDtorStmt->get_callStmt() );
82                } else {
83                        // should never get here
84                        assert( false && "encountered unknown call statement" );
85                }
86        }
87
88        bool isInstrinsicSingleArgCallStmt( Statement * stmt ) {
89                Expression * callExpr = getCtorDtorCall( stmt );
90                if ( ! callExpr ) return false;
91                ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr );
92                assert( appExpr );
93                VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() );
94                assert( function );
95                // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
96                // will call all member dtors, and some members may have a user defined dtor.
97                FunctionType * funcType = GenPoly::getFunctionType( function->get_var()->get_type() );
98                assert( funcType );
99                return function->get_var()->get_linkage() == LinkageSpec::Intrinsic && funcType->get_parameters().size() == 1;
100        }
101
102        namespace {
103                template<typename CallExpr>
104                Expression *& callArg( CallExpr * callExpr, unsigned int pos ) {
105                        if ( pos >= callExpr->get_args().size() ) assert( false && "asking for argument that doesn't exist. Return NULL/throw exception?" );
106                        for ( Expression *& arg : callExpr->get_args() ) {
107                                if ( pos == 0 ) return arg;
108                                pos--;
109                        }
110                        assert( false );
111                }
112        }
113
114        Expression *& getCallArg( Expression * callExpr, unsigned int pos ) {
115                if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr ) ) {
116                        return callArg( appExpr, pos );
117                } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( callExpr ) ) {
118                        return callArg( untypedExpr, pos );
119                } else {
120                        assert( false && "Unexpected expression type passed to getCallArg" );
121                }
122        }
123
124        namespace {
125                std::string funcName( Expression * func ) {
126                        if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( func ) ) {
127                                return nameExpr->get_name();
128                        } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( func ) ) {
129                                return varExpr->get_var()->get_name();
130                        }       else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( func ) ) {
131                                return funcName( castExpr->get_arg() );
132                        } else {
133                                assert( false && "Unexpected expression type being called as a function in call expression" );
134                        }
135                }
136        }
137
138        std::string getFunctionName( Expression * expr ) {
139                if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
140                        return funcName( appExpr->get_function() );
141                } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * > ( expr ) ) {
142                        return funcName( untypedExpr->get_function() );
143                } else {
144                        std::cerr << expr << std::endl;
145                        assert( false && "Unexpected expression type passed to getFunctionName" );
146                }
147        }
148
149        Type * getPointerBase( Type * type ) {
150                if ( PointerType * ptrType = dynamic_cast< PointerType * >( type ) ) {
151                        return ptrType->get_base();
152                } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
153                        return arrayType->get_base();
154                } else {
155                        return NULL;
156                }
157        }
158
159        Type * isPointerType( Type * type ) {
160                if ( getPointerBase( type ) ) return type;
161                else return NULL;
162        }
163
164        class ConstExprChecker : public Visitor {
165        public:
166                ConstExprChecker() : isConstExpr( true ) {}
167
168                virtual void visit( ApplicationExpr *applicationExpr ) { isConstExpr = false; }
169                virtual void visit( UntypedExpr *untypedExpr ) { isConstExpr = false; }
170                virtual void visit( NameExpr *nameExpr ) { isConstExpr = false; }
171                virtual void visit( CastExpr *castExpr ) { isConstExpr = false; }
172                virtual void visit( LabelAddressExpr *labAddressExpr ) { isConstExpr = false; }
173                virtual void visit( UntypedMemberExpr *memberExpr ) { isConstExpr = false; }
174                virtual void visit( MemberExpr *memberExpr ) { isConstExpr = false; }
175                virtual void visit( VariableExpr *variableExpr ) { isConstExpr = false; }
176                virtual void visit( ConstantExpr *constantExpr ) { /* bottom out */ }
177                // these might be okay?
178                // virtual void visit( SizeofExpr *sizeofExpr );
179                // virtual void visit( AlignofExpr *alignofExpr );
180                // virtual void visit( UntypedOffsetofExpr *offsetofExpr );
181                // virtual void visit( OffsetofExpr *offsetofExpr );
182                // virtual void visit( OffsetPackExpr *offsetPackExpr );
183                // virtual void visit( AttrExpr *attrExpr );
184                // virtual void visit( CommaExpr *commaExpr );
185                // virtual void visit( LogicalExpr *logicalExpr );
186                // virtual void visit( ConditionalExpr *conditionalExpr );
187                virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; }
188                virtual void visit( SolvedTupleExpr *tupleExpr ) { isConstExpr = false; }
189                virtual void visit( TypeExpr *typeExpr ) { isConstExpr = false; }
190                virtual void visit( AsmExpr *asmExpr ) { isConstExpr = false; }
191                virtual void visit( UntypedValofExpr *valofExpr ) { isConstExpr = false; }
192                virtual void visit( CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
193
194                bool isConstExpr;
195        };
196
197        bool isConstExpr( Expression * expr ) {
198                if ( expr ) {
199                        ConstExprChecker checker;
200                        expr->accept( checker );
201                        return checker.isConstExpr;
202                }
203                return true;
204        }
205
206        bool isConstExpr( Initializer * init ) {
207                if ( init ) {
208                        ConstExprChecker checker;
209                        init->accept( checker );
210                        return checker.isConstExpr;
211                } // if
212                // for all intents and purposes, no initializer means const expr
213                return true;
214        }
215
216}
Note: See TracBrowser for help on using the repository browser.