source: src/InitTweak/InitTweak.cc @ 37273c8

Last change on this file since 37273c8 was 37273c8, checked in by Andrew Beach <ajbeach@…>, 5 months ago

Removed the old-ast-compatable FunctionDecl? constructor. However, enough cases pass nothing polymorphic along some of the uses of the constructor now go to a new monomorphic function constructor.

  • Property mode set to 100644
File size: 16.2 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// InitTweak.cc --
8//
9// Author           : Rob Schluntz
10// Created On       : Fri May 13 11:26:36 2016
11// Last Modified By : Andrew Beach
12// Last Modified On : Wed Sep 22  9:50:00 2022
13// Update Count     : 21
14//
15
16#include "InitTweak.h"
17
18#include <algorithm>               // for find, all_of
19#include <cassert>                 // for assertf, assert, strict_dynamic_cast
20#include <iostream>                // for ostream, cerr, endl
21#include <iterator>                // for back_insert_iterator, back_inserter
22#include <memory>                  // for __shared_ptr
23#include <vector>
24
25#include "AST/Expr.hpp"
26#include "AST/Init.hpp"
27#include "AST/Inspect.hpp"
28#include "AST/Node.hpp"
29#include "AST/Pass.hpp"
30#include "AST/Stmt.hpp"
31#include "AST/Type.hpp"
32#include "CodeGen/OperatorTable.h" // for isConstructor, isDestructor, isCto...
33#include "Common/SemanticError.h"  // for SemanticError
34#include "Common/ToString.hpp"     // for toCString
35#include "Common/UniqueName.h"     // for UniqueName
36#include "GenPoly/GenPoly.h"       // for getFunctionType
37#include "ResolvExpr/Unify.h"      // for typesCompatibleIgnoreQualifiers
38#include "Tuples/Tuples.h"         // for Tuples::isTtype
39
40namespace InitTweak {
41
42// Forward declared, because it is used as a parent type.
43class InitExpander::ExpanderImpl {
44public:
45        virtual ~ExpanderImpl() = default;
46        virtual std::vector< ast::ptr< ast::Expr > > next( IndexList & indices ) = 0;
47        virtual ast::ptr< ast::Stmt > buildListInit(
48                ast::UntypedExpr * callExpr, IndexList & indices ) = 0;
49};
50
51namespace {
52        struct HasDesignations : public ast::WithShortCircuiting {
53                bool result = false;
54
55                void previsit( const ast::Node * ) {
56                        // Short circuit if we already know there are designations.
57                        if ( result ) visit_children = false;
58                }
59
60                void previsit( const ast::Designation * des ) {
61                        // Short circuit if we already know there are designations.
62                        if ( result ) visit_children = false;
63                        else if ( !des->designators.empty() ) {
64                                result = true;
65                                visit_children = false;
66                        }
67                }
68        };
69
70        struct InitDepthChecker {
71                bool result = true;
72                const ast::Type * type;
73                int curDepth = 0, maxDepth = 0;
74                InitDepthChecker( const ast::Type * type ) : type( type ) {
75                        const ast::Type * t = type;
76                        while ( auto at = dynamic_cast< const ast::ArrayType * >( t ) ) {
77                                maxDepth++;
78                                t = at->base;
79                        }
80                        maxDepth++;
81                }
82                void previsit( ast::ListInit const * ) {
83                        curDepth++;
84                        if ( curDepth > maxDepth ) result = false;
85                }
86                void postvisit( ast::ListInit const * ) {
87                        curDepth--;
88                }
89        };
90
91        struct InitFlattener : public ast::WithShortCircuiting {
92                std::vector< ast::ptr< ast::Expr > > argList;
93
94                void previsit( const ast::SingleInit * singleInit ) {
95                        visit_children = false;
96                        argList.emplace_back( singleInit->value );
97                }
98        };
99
100        template< typename Out >
101        void buildCallExpr(
102                ast::UntypedExpr * callExpr, const ast::Expr * index, const ast::Expr * dimension,
103                const ast::Init * init, Out & out
104        ) {
105                const CodeLocation & loc = init->location;
106
107                auto cond = new ast::UntypedExpr{
108                        loc, new ast::NameExpr{ loc, "?<?" }, { index, dimension } };
109
110                std::vector< ast::ptr< ast::Expr > > args = makeInitList( init );
111                splice( callExpr->args, args );
112
113                out.emplace_back( new ast::IfStmt{ loc, cond, new ast::ExprStmt{ loc, callExpr } } );
114
115                out.emplace_back( new ast::ExprStmt{
116                        loc, new ast::UntypedExpr{ loc, new ast::NameExpr{ loc, "++?" }, { index } } } );
117        }
118
119        template< typename Out >
120        void build(
121                ast::UntypedExpr * callExpr, const InitExpander::IndexList & indices,
122                const ast::Init * init, Out & out
123        ) {
124                if ( indices.empty() ) return;
125
126                unsigned idx = 0;
127
128                const ast::Expr * index = indices[idx++];
129                assert( idx != indices.size() );
130                const ast::Expr * dimension = indices[idx++];
131
132                if ( idx == indices.size() ) {
133                        if ( auto listInit = dynamic_cast< const ast::ListInit * >( init ) ) {
134                                for ( const ast::Init * init : *listInit ) {
135                                        buildCallExpr( shallowCopy(callExpr), index, dimension, init, out );
136                                }
137                        } else {
138                                buildCallExpr( shallowCopy(callExpr), index, dimension, init, out );
139                        }
140                } else {
141                        const CodeLocation & loc = init->location;
142
143                        unsigned long cond = 0;
144                        auto listInit = dynamic_cast< const ast::ListInit * >( init );
145                        if ( ! listInit ) { SemanticError( loc, "unbalanced list initializers" ); }
146
147                        static UniqueName targetLabel( "L__autogen__" );
148                        ast::Label switchLabel{
149                                loc, targetLabel.newName(), { new ast::Attribute{ "unused" } } };
150
151                        std::vector< ast::ptr< ast::CaseClause > > branches;
152                        for ( const ast::Init * init : *listInit ) {
153                                auto condition = ast::ConstantExpr::from_ulong( loc, cond );
154                                ++cond;
155
156                                std::vector< ast::ptr< ast::Stmt > > stmts;
157                                build( callExpr, indices, init, stmts );
158                                stmts.emplace_back(
159                                        new ast::BranchStmt{ loc, ast::BranchStmt::Break, switchLabel } );
160                                branches.emplace_back( new ast::CaseClause{ loc, condition, std::move( stmts ) } );
161                        }
162                        out.emplace_back( new ast::SwitchStmt{ loc, index, std::move( branches ) } );
163                        out.emplace_back( new ast::NullStmt{ loc, { switchLabel } } );
164                }
165        }
166
167        class InitImpl final : public InitExpander::ExpanderImpl {
168                ast::ptr< ast::Init > init;
169        public:
170                InitImpl( const ast::Init * i ) : init( i ) {}
171
172                std::vector< ast::ptr< ast::Expr > > next( InitExpander::IndexList & ) override {
173                        return makeInitList( init );
174                }
175
176                ast::ptr< ast::Stmt > buildListInit(
177                        ast::UntypedExpr * callExpr, InitExpander::IndexList & indices
178                ) override {
179                        // If array came with an initializer list, initialize each element. We may have more
180                        // initializers than elements of the array; need to check at each index that we have
181                        // not exceeded size. We may have fewer initializers than elements in the array; need
182                        // to default-construct remaining elements. To accomplish this, generate switch
183                        // statement consuming all of expander's elements
184
185                        if ( ! init ) return {};
186
187                        std::list< ast::ptr< ast::Stmt > > stmts;
188                        build( callExpr, indices, init, stmts );
189                        if ( stmts.empty() ) {
190                                return {};
191                        } else {
192                                auto block = new ast::CompoundStmt{ init->location, std::move( stmts ) };
193                                init = nullptr;  // consumed in creating the list init
194                                return block;
195                        }
196                }
197        };
198
199        class ExprImpl final : public InitExpander::ExpanderImpl {
200                ast::ptr< ast::Expr > arg;
201        public:
202                ExprImpl( const ast::Expr * a ) : arg( a ) {}
203
204                std::vector< ast::ptr< ast::Expr > > next(
205                        InitExpander::IndexList & indices
206                ) override {
207                        if ( !arg ) return {};
208
209                        const CodeLocation & loc = arg->location;
210                        const ast::Expr * expr = arg;
211                        for ( auto it = indices.rbegin(); it != indices.rend(); ++it ) {
212                                // Go through indices and layer on subscript exprs ?[?].
213                                ++it;
214                                expr = new ast::UntypedExpr{
215                                        loc, new ast::NameExpr{ loc, "?[?]" }, { expr, *it } };
216                        }
217                        return { expr };
218                }
219
220                ast::ptr< ast::Stmt > buildListInit(
221                        ast::UntypedExpr *, InitExpander::IndexList &
222                ) override {
223                        return {};
224                }
225        };
226
227        struct CallFinder final {
228                std::vector< const ast::Expr * > matches;
229                const std::vector< std::string > names;
230
231                CallFinder( std::vector< std::string > && ns ) : matches(), names( std::move(ns) ) {}
232
233                void handleCallExpr( const ast::Expr * expr ) {
234                        std::string fname = getFunctionName( expr );
235                        if ( std::find( names.begin(), names.end(), fname ) != names.end() ) {
236                                matches.emplace_back( expr );
237                        }
238                }
239
240                void postvisit( const ast::ApplicationExpr * expr ) { handleCallExpr( expr ); }
241                void postvisit( const ast::UntypedExpr *     expr ) { handleCallExpr( expr ); }
242        };
243
244        template <typename Predicate>
245        bool allofCtorDtor( const ast::Stmt * stmt, const Predicate & pred ) {
246                std::vector< const ast::Expr * > callExprs = collectCtorDtorCalls( stmt );
247                return std::all_of( callExprs.begin(), callExprs.end(), pred );
248        }
249
250        struct ConstExprChecker : public ast::WithShortCircuiting {
251                // Most expressions are not const-expr.
252                void previsit( const ast::Expr * ) { result = false; visit_children = false; }
253
254                void previsit( const ast::AddressExpr *addressExpr ) {
255                        visit_children = false;
256                        const ast::Expr * arg = addressExpr->arg;
257
258                        // Address of a variable or member expression is const-expr.
259                        if ( !dynamic_cast< const ast::NameExpr * >( arg )
260                                && !dynamic_cast< const ast::VariableExpr * >( arg )
261                                && !dynamic_cast< const ast::MemberExpr * >( arg )
262                                && !dynamic_cast< const ast::UntypedMemberExpr * >( arg ) ) result = false;
263                }
264
265                // These expressions may be const expr, depending on their children.
266                void previsit( const ast::SizeofExpr * ) {}
267                void previsit( const ast::AlignofExpr * ) {}
268                void previsit( const ast::UntypedOffsetofExpr * ) {}
269                void previsit( const ast::OffsetofExpr * ) {}
270                void previsit( const ast::OffsetPackExpr * ) {}
271                void previsit( const ast::CommaExpr * ) {}
272                void previsit( const ast::LogicalExpr * ) {}
273                void previsit( const ast::ConditionalExpr * ) {}
274                void previsit( const ast::CastExpr * ) {}
275                void previsit( const ast::ConstantExpr * ) {}
276
277                void previsit( const ast::VariableExpr * varExpr ) {
278                        visit_children = false;
279
280                        if ( auto inst = varExpr->result.as<ast::EnumInstType>() ) {
281                                long long int value;
282                                if ( inst->base->valueOf( varExpr->var, value ) ) {
283                                        // enumerators are const expr
284                                        return;
285                                }
286                        }
287                        result = false;
288                }
289
290                bool result = true;
291        };
292} // namespace
293
294bool isAssignment( const ast::FunctionDecl * decl ) {
295        return CodeGen::isAssignment( decl->name ) && isCopyFunction( decl );
296}
297
298bool isDestructor( const ast::FunctionDecl * decl ) {
299        return CodeGen::isDestructor( decl->name );
300}
301
302bool isDefaultConstructor( const ast::FunctionDecl * decl ) {
303        return CodeGen::isConstructor( decl->name ) && 1 == decl->params.size();
304}
305
306bool isCopyConstructor( const ast::FunctionDecl * decl ) {
307        return CodeGen::isConstructor( decl->name ) && 2 == decl->params.size();
308}
309
310bool isCopyFunction( const ast::FunctionDecl * decl ) {
311        const ast::FunctionType * ftype = decl->type;
312        if ( ftype->params.size() != 2 ) return false;
313
314        const ast::Type * t1 = ast::getPointerBase( ftype->params.front() );
315        if ( ! t1 ) return false;
316        const ast::Type * t2 = ftype->params.back();
317
318        return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2 );
319}
320
321const ast::Type * getTypeofThis( const ast::FunctionType * ftype ) {
322        assertf( ftype, "getTypeofThis: nullptr ftype" );
323        const std::vector<ast::ptr<ast::Type>> & params = ftype->params;
324        assertf( !params.empty(), "getTypeofThis: ftype with 0 parameters: %s",
325                        toCString( ftype ) );
326        const ast::ReferenceType * refType =
327                params.front().strict_as<ast::ReferenceType>();
328        return refType->base;
329}
330
331const ast::ObjectDecl * getParamThis(const ast::FunctionDecl * func) {
332        assertf( func, "getParamThis: nullptr ftype" );
333        auto & params = func->params;
334        assertf( !params.empty(), "getParamThis: ftype with 0 parameters: %s", toCString( func ));
335        return params.front().strict_as<ast::ObjectDecl>();
336}
337
338// looks like some other such codegen uses UntypedExpr and does not create fake function. should revisit afterwards
339// following passes may accidentally resolve this expression if returned as untyped...
340ast::Expr * createBitwiseAssignment(const ast::Expr * dst, const ast::Expr * src) {
341        static ast::ptr<ast::FunctionDecl> assign = nullptr;
342        if (!assign) {
343                auto td = new ast::TypeDecl(CodeLocation(), "T", {}, nullptr, ast::TypeDecl::Dtype, true);
344                assign = new ast::FunctionDecl(CodeLocation(), "?=?", {td}, {},
345                { new ast::ObjectDecl(CodeLocation(), "_dst", new ast::ReferenceType(new ast::TypeInstType("T", td))),
346                  new ast::ObjectDecl(CodeLocation(), "_src", new ast::TypeInstType("T", td))},
347                { new ast::ObjectDecl(CodeLocation(), "_ret", new ast::TypeInstType("T", td))}, nullptr, {}, ast::Linkage::Intrinsic);
348        }
349        if (dst->result.as<ast::ReferenceType>()) {
350                for (int depth = dst->result->referenceDepth(); depth > 0; depth--) {
351                        dst = new ast::AddressExpr(dst);
352                }
353        } else {
354                dst = new ast::CastExpr(dst, new ast::ReferenceType(dst->result, {}));
355        }
356        if (src->result.as<ast::ReferenceType>()) {
357                for (int depth = src->result->referenceDepth(); depth > 0; depth--) {
358                        src = new ast::AddressExpr(src);
359                }
360        }
361        auto var = ast::VariableExpr::functionPointer(dst->location, assign);
362        auto app = new ast::ApplicationExpr(dst->location, var, {dst, src});
363        // Skip the resolver, just set the result to the correct type.
364        app->result = ast::deepCopy( src->result );
365        return app;
366}
367
368std::vector< ast::ptr< ast::Expr > > makeInitList( const ast::Init * init ) {
369        ast::Pass< InitFlattener > flattener;
370        maybe_accept( init, flattener );
371        return std::move( flattener.core.argList );
372}
373
374bool tryConstruct( const ast::DeclWithType * dwt ) {
375        auto objDecl = dynamic_cast< const ast::ObjectDecl * >( dwt );
376        if ( !objDecl ) return false;
377        return (objDecl->init == nullptr ||
378                        ( objDecl->init != nullptr && objDecl->init->maybeConstructed ))
379                && !objDecl->storage.is_extern
380                && isConstructable( objDecl->type );
381}
382
383bool isConstructable( const ast::Type * type ) {
384        return !dynamic_cast< const ast::VarArgsType * >( type ) && !dynamic_cast< const ast::ReferenceType * >( type )
385                && !dynamic_cast< const ast::FunctionType * >( type ) && !Tuples::isTtype( type );
386}
387
388bool isDesignated( const ast::Init * init ) {
389//      return ( init ) ? ast::Pass<HasDesignations>::read( init ) : false;
390        ast::Pass<HasDesignations> finder;
391        maybe_accept( init, finder );
392        return finder.core.result;
393}
394
395bool checkInitDepth( const ast::ObjectDecl * objDecl ) {
396//      return ( objDecl->init ) ? ast::Pass<InitDepthChecker::read( objDecl->init, objDecl->type ) : true;
397        ast::Pass<InitDepthChecker> checker( objDecl->type );
398        maybe_accept( objDecl->init.get(), checker );
399        return checker.core.result;
400}
401
402bool isIntrinsicSingleArgCallStmt( const ast::Stmt * stmt ) {
403        return allofCtorDtor( stmt, []( const ast::Expr * callExpr ){
404                if ( const ast::ApplicationExpr * appExpr = isIntrinsicCallExpr( callExpr ) ) {
405                        const ast::FunctionType * funcType =
406                                GenPoly::getFunctionType( appExpr->func->result );
407                        assert( funcType );
408                        return funcType->params.size() == 1;
409                }
410                return false;
411        });
412}
413
414std::vector< const ast::Expr * > collectCtorDtorCalls( const ast::Stmt * stmt ) {
415        ast::Pass< CallFinder > finder{ std::vector< std::string >{ "?{}", "^?{}" } };
416        maybe_accept( stmt, finder );
417        return std::move( finder.core.matches );
418}
419
420bool isConstExpr( const ast::Expr * expr ) {
421        return ( expr ) ? ast::Pass<ConstExprChecker>::read( expr ) : true;
422}
423
424bool isConstExpr( const ast::Init * init ) {
425        // for all intents and purposes, no initializer means const expr
426        return ( init ) ? ast::Pass<ConstExprChecker>::read( init ) : true;
427}
428
429#if defined( __x86_64 ) || defined( __i386 ) // assembler comment to prevent assembler warning message
430        #define ASM_COMMENT "#"
431#else // defined( __ARM_ARCH )
432        #define ASM_COMMENT "//"
433#endif
434static const char * const data_section =  ".data" ASM_COMMENT;
435static const char * const tlsd_section = ".tdata" ASM_COMMENT;
436
437void addDataSectionAttribute( ast::ObjectDecl * objDecl ) {
438        const bool is_tls = objDecl->storage.is_threadlocal_any();
439        const char * section = is_tls ? tlsd_section : data_section;
440        objDecl->attributes.push_back(new ast::Attribute("section", {
441                ast::ConstantExpr::from_string(objDecl->location, section)
442        }));
443}
444
445InitExpander::InitExpander( const ast::Init * init )
446: expander( new InitImpl{ init } ), crnt(), indices() {}
447
448InitExpander::InitExpander( const ast::Expr * expr )
449: expander( new ExprImpl{ expr } ), crnt(), indices() {}
450
451std::vector< ast::ptr< ast::Expr > > InitExpander::operator* () { return crnt; }
452
453InitExpander & InitExpander::operator++ () {
454        crnt = expander->next( indices );
455        return *this;
456}
457
458/// builds statement which has the same semantics as a C-style list initializer (for array
459/// initializers) using callExpr as the base expression to perform initialization
460ast::ptr< ast::Stmt > InitExpander::buildListInit( ast::UntypedExpr * callExpr ) {
461        return expander->buildListInit( callExpr, indices );
462}
463
464void InitExpander::addArrayIndex( const ast::Expr * index, const ast::Expr * dimension ) {
465        indices.emplace_back( index );
466        indices.emplace_back( dimension );
467}
468
469void InitExpander::clearArrayIndices() { indices.clear(); }
470
471bool InitExpander::addReference() {
472        for ( ast::ptr< ast::Expr > & expr : crnt ) {
473                expr = new ast::AddressExpr{ expr };
474        }
475        return !crnt.empty();
476}
477
478} // namespace InitTweak
Note: See TracBrowser for help on using the repository browser.