source: src/Validate/Autogen.cpp @ 8bee858

ADTast-experimentalpthread-emulation
Last change on this file since 8bee858 was e8616b6, checked in by Andrew Beach <ajbeach@…>, 2 years ago

Changed the default Linkage on ast::ObjectDecl? from C to Cforall. There appears to be only one internal name that actually needed to be C.

  • Property mode set to 100644
File size: 27.0 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// Autogen.cpp -- Generate automatic routines for data types.
8//
9// Author           : Andrew Beach
10// Created On       : Thu Dec  2 13:44:00 2021
11// Last Modified By : Andrew Beach
12// Last Modified On : Thr Jan 27  9:29:00 2022
13// Update Count     : 1
14//
15
16#include "Autogen.hpp"
17
18#include <algorithm>               // for count_if
19#include <cassert>                 // for strict_dynamic_cast, assert, assertf
20#include <iterator>                // for back_insert_iterator, back_inserter
21#include <list>                    // for list, _List_iterator, list<>::iter...
22#include <set>                     // for set, _Rb_tree_const_iterator
23#include <utility>                 // for pair
24#include <vector>                  // for vector
25
26#include "AST/Attribute.hpp"
27#include "AST/Decl.hpp"
28#include "AST/DeclReplacer.hpp"
29#include "AST/Expr.hpp"
30#include "AST/Inspect.hpp"
31#include "AST/Pass.hpp"
32#include "AST/Stmt.hpp"
33#include "AST/SymbolTable.hpp"
34#include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
35#include "Common/ScopedMap.h"      // for ScopedMap<>::const_iterator, Scope...
36#include "Common/utility.h"        // for cloneAll, operator+
37#include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::iterator
38#include "InitTweak/GenInit.h"     // for fixReturnStatements
39#include "InitTweak/InitTweak.h"   // for isAssignment, isCopyConstructor
40#include "SymTab/Mangler.h"        // for Mangler
41#include "CompilationState.h"
42
43// TODO: The other new ast function should be moved over to this file.
44#include "SymTab/Autogen.h"
45
46namespace Validate {
47
48namespace {
49
50// --------------------------------------------------------------------------
51struct AutogenerateRoutines_new final :
52                public ast::WithDeclsToAdd<>,
53                public ast::WithShortCircuiting {
54        void previsit( const ast::EnumDecl * enumDecl );
55        void previsit( const ast::StructDecl * structDecl );
56        void previsit( const ast::UnionDecl * structDecl );
57        void previsit( const ast::TypeDecl * typeDecl );
58        void previsit( const ast::TraitDecl * traitDecl );
59        void previsit( const ast::FunctionDecl * functionDecl );
60        void postvisit( const ast::FunctionDecl * functionDecl );
61
62private:
63        // Current level of nested functions.
64        unsigned int functionNesting = 0;
65};
66
67// --------------------------------------------------------------------------
68/// Class used to generate functions for a particular declaration.
69/// Note it isn't really stored, it is just a class for organization and to
70/// help pass around some of the common arguments.
71class FuncGenerator {
72public:
73        std::list<ast::ptr<ast::Decl>> forwards;
74        std::list<ast::ptr<ast::Decl>> definitions;
75
76        FuncGenerator( const ast::Type * type, unsigned int functionNesting ) :
77                type( type ), functionNesting( functionNesting )
78        {}
79
80        /// Generate functions (and forward decls.) and append them to the list.
81        void generateAndAppendFunctions( std::list<ast::ptr<ast::Decl>> & );
82
83        virtual bool shouldAutogen() const = 0;
84protected:
85        const ast::Type * type;
86        unsigned int functionNesting;
87        ast::Linkage::Spec proto_linkage = ast::Linkage::AutoGen;
88
89        // Internal helpers:
90        void genStandardFuncs();
91        void produceDecl( const ast::FunctionDecl * decl );
92        void produceForwardDecl( const ast::FunctionDecl * decl );
93
94        const CodeLocation& getLocation() const { return getDecl()->location; }
95        ast::FunctionDecl * genProto( const std::string& name,
96                std::vector<ast::ptr<ast::DeclWithType>>&& params,
97                std::vector<ast::ptr<ast::DeclWithType>>&& returns ) const;
98
99        ast::ObjectDecl * dstParam() const;
100        ast::ObjectDecl * srcParam() const;
101        ast::FunctionDecl * genCtorProto() const;
102        ast::FunctionDecl * genCopyProto() const;
103        ast::FunctionDecl * genDtorProto() const;
104        ast::FunctionDecl * genAssignProto() const;
105        ast::FunctionDecl * genFieldCtorProto( unsigned int fields ) const;
106
107        // Internal Hooks:
108        virtual void genFuncBody( ast::FunctionDecl * decl ) = 0;
109        virtual void genFieldCtors() = 0;
110        virtual bool isConcurrentType() const { return false; }
111        virtual const ast::Decl * getDecl() const = 0;
112};
113
114class StructFuncGenerator final : public FuncGenerator {
115        const ast::StructDecl * decl;
116public:
117        StructFuncGenerator( const ast::StructDecl * decl,
118                        const ast::StructInstType * type,
119                        unsigned int functionNesting ) :
120                FuncGenerator( type, functionNesting ), decl( decl )
121        {}
122
123        // Built-ins do not use autogeneration.
124        bool shouldAutogen() const final { return !decl->linkage.is_builtin && !structHasFlexibleArray(decl); }
125private:
126        void genFuncBody( ast::FunctionDecl * decl ) final;
127        void genFieldCtors() final;
128        bool isConcurrentType() const final {
129                return decl->is_thread() || decl->is_monitor();
130        }
131        virtual const ast::Decl * getDecl() const final { return decl; }
132
133        /// Generates a single struct member operation.
134        /// (constructor call, destructor call, assignment call)
135        // This is managed because it uses another helper that returns a ast::ptr.
136        ast::ptr<ast::Stmt> makeMemberOp(
137                const CodeLocation& location,
138                const ast::ObjectDecl * dstParam, const ast::Expr * src,
139                const ast::ObjectDecl * field, ast::FunctionDecl * func,
140                SymTab::LoopDirection direction );
141
142        /// Generates the body of a struct function by iterating the struct members
143        /// (via parameters). Generates default constructor, copy constructor,
144        /// copy assignment, and destructor bodies. No field constructor bodies.
145        template<typename Iterator>
146        void makeFunctionBody( Iterator member, Iterator end,
147                        ast::FunctionDecl * func, SymTab::LoopDirection direction );
148
149        /// Generate the body of a constructor which takes parameters that match
150        /// fields. (With arguments for one to all of the fields.)
151        template<typename Iterator>
152        void makeFieldCtorBody( Iterator member, Iterator end,
153                        ast::FunctionDecl * func );
154};
155
156class UnionFuncGenerator final : public FuncGenerator {
157        const ast::UnionDecl * decl;
158public:
159        UnionFuncGenerator( const ast::UnionDecl * decl,
160                        const ast::UnionInstType * type,
161                        unsigned int functionNesting ) :
162                FuncGenerator( type, functionNesting ), decl( decl )
163        {}
164
165        // Built-ins do not use autogeneration.
166        bool shouldAutogen() const final { return !decl->linkage.is_builtin; }
167private:
168        void genFuncBody( ast::FunctionDecl * decl ) final;
169        void genFieldCtors() final;
170        const ast::Decl * getDecl() const final { return decl; }
171
172        /// Generate a single union assignment expression (using memcpy).
173        ast::ExprStmt * makeAssignOp( const CodeLocation& location,
174                const ast::ObjectDecl * dstParam, const ast::ObjectDecl * srcParam );
175};
176
177class EnumFuncGenerator final : public FuncGenerator {
178        const ast::EnumDecl * decl;
179public:
180        EnumFuncGenerator( const ast::EnumDecl * decl,
181                        const ast::EnumInstType * type,
182                        unsigned int functionNesting ) :
183                FuncGenerator( type, functionNesting ), decl( decl )
184        {
185                // TODO: These functions are somewhere between instrinsic and autogen,
186                // could possibly use a new linkage type. For now we just make the
187                // basic ones intrinsic to code-gen them as C assignments.
188                const auto & real_type = decl->base;
189                const auto & basic = real_type.as<ast::BasicType>();
190                if(!real_type || (basic && basic->isInteger())) proto_linkage = ast::Linkage::Intrinsic;
191        }
192
193        bool shouldAutogen() const final { return true; }
194private:
195        void genFuncBody( ast::FunctionDecl * decl ) final;
196        void genFieldCtors() final;
197        const ast::Decl * getDecl() const final { return decl; }
198};
199
200class TypeFuncGenerator final : public FuncGenerator {
201        const ast::TypeDecl * decl;
202public:
203        TypeFuncGenerator( const ast::TypeDecl * decl,
204                        ast::TypeInstType * type,
205                        unsigned int functionNesting ) :
206                FuncGenerator( type, functionNesting ), decl( decl )
207        {}
208
209        bool shouldAutogen() const final { return true; }
210        void genFieldCtors() final;
211private:
212        void genFuncBody( ast::FunctionDecl * decl ) final;
213        const ast::Decl * getDecl() const final { return decl; }
214};
215
216// --------------------------------------------------------------------------
217const std::vector<ast::ptr<ast::TypeDecl>>& getGenericParams( const ast::Type * t ) {
218        if ( auto inst = dynamic_cast< const ast::StructInstType * >( t ) ) {
219                return inst->base->params;
220        } else if ( auto inst = dynamic_cast< const ast::UnionInstType * >( t ) ) {
221                return inst->base->params;
222        }
223        static std::vector<ast::ptr<ast::TypeDecl>> const empty;
224        return empty;
225}
226
227/// Changes the node inside a pointer so that it has the unused attribute.
228void addUnusedAttribute( ast::ptr<ast::DeclWithType> & declPtr ) {
229        ast::DeclWithType * decl = declPtr.get_and_mutate();
230        decl->attributes.push_back( new ast::Attribute( "unused" ) );
231}
232
233// --------------------------------------------------------------------------
234void AutogenerateRoutines_new::previsit( const ast::EnumDecl * enumDecl ) {
235        // Must visit children (enum constants) to add them to the symbol table.
236        if ( !enumDecl->body ) return;
237
238        ast::EnumInstType enumInst( enumDecl->name );
239        enumInst.base = enumDecl;
240        EnumFuncGenerator gen( enumDecl, &enumInst, functionNesting );
241        gen.generateAndAppendFunctions( declsToAddAfter );
242}
243
244void AutogenerateRoutines_new::previsit( const ast::StructDecl * structDecl ) {
245        visit_children = false;
246        if ( !structDecl->body ) return;
247
248        ast::StructInstType structInst( structDecl->name );
249        structInst.base = structDecl;
250        for ( const ast::TypeDecl * typeDecl : structDecl->params ) {
251                structInst.params.push_back( new ast::TypeExpr(
252                        typeDecl->location,
253                        new ast::TypeInstType( typeDecl )
254                ) );
255        }
256        StructFuncGenerator gen( structDecl, &structInst, functionNesting );
257        gen.generateAndAppendFunctions( declsToAddAfter );
258}
259
260void AutogenerateRoutines_new::previsit( const ast::UnionDecl * unionDecl ) {
261        visit_children = false;
262        if ( !unionDecl->body ) return;
263
264        ast::UnionInstType unionInst( unionDecl->name );
265        unionInst.base = unionDecl;
266        for ( const ast::TypeDecl * typeDecl : unionDecl->params ) {
267                unionInst.params.push_back( new ast::TypeExpr(
268                        unionDecl->location,
269                        new ast::TypeInstType( typeDecl )
270                ) );
271        }
272        UnionFuncGenerator gen( unionDecl, &unionInst, functionNesting );
273        gen.generateAndAppendFunctions( declsToAddAfter );
274}
275
276/// Generate ctor/dtors/assign for typedecls, e.g., otype T = int *;
277void AutogenerateRoutines_new::previsit( const ast::TypeDecl * typeDecl ) {
278        if ( !typeDecl->base ) return;
279
280        ast::TypeInstType refType( typeDecl->name, typeDecl );
281        TypeFuncGenerator gen( typeDecl, &refType, functionNesting );
282        gen.generateAndAppendFunctions( declsToAddAfter );
283}
284
285void AutogenerateRoutines_new::previsit( const ast::TraitDecl * ) {
286        // Ensure that we don't add assignment ops for types defined as part of the trait
287        visit_children = false;
288}
289
290void AutogenerateRoutines_new::previsit( const ast::FunctionDecl * ) {
291        // Track whether we're currently in a function.
292        // Can ignore function type idiosyncrasies, because function type can never
293        // declare a new type.
294        functionNesting += 1;
295}
296
297void AutogenerateRoutines_new::postvisit( const ast::FunctionDecl * ) {
298        functionNesting -= 1;
299}
300
301void FuncGenerator::generateAndAppendFunctions(
302                std::list<ast::ptr<ast::Decl>> & decls ) {
303        if ( !shouldAutogen() ) return;
304
305        // Generate the functions (they go into forwards and definitions).
306        genStandardFuncs();
307        genFieldCtors();
308
309        // Now export the lists contents.
310        decls.splice( decls.end(), forwards );
311        decls.splice( decls.end(), definitions );
312}
313
314void FuncGenerator::produceDecl( const ast::FunctionDecl * decl ) {
315        assert( nullptr != decl->stmts );
316
317        definitions.push_back( decl );
318}
319
320/// Make a forward declaration of the decl and add it to forwards.
321void FuncGenerator::produceForwardDecl( const ast::FunctionDecl * decl ) {
322        if (0 != functionNesting) return;
323        ast::FunctionDecl * fwd = ast::deepCopy( decl );
324        fwd->stmts = nullptr;
325        fwd->fixUniqueId();
326        forwards.push_back( fwd );
327}
328
329/// Generates a basic prototype function declaration.
330ast::FunctionDecl * FuncGenerator::genProto( const std::string& name,
331                std::vector<ast::ptr<ast::DeclWithType>>&& params,
332                std::vector<ast::ptr<ast::DeclWithType>>&& returns ) const {
333
334        // Handle generic prameters and assertions, if any.
335        auto const & old_type_params = getGenericParams( type );
336        std::vector<ast::ptr<ast::TypeDecl>> type_params;
337        std::vector<ast::ptr<ast::DeclWithType>> assertions;
338        for ( auto & old_param : old_type_params ) {
339                ast::TypeDecl * decl = ast::deepCopy( old_param );
340                for ( auto assertion : decl->assertions ) {
341                        assertions.push_back( assertion );
342                }
343                decl->assertions.clear();
344                type_params.push_back( decl );
345        }
346        // TODO: The values in params and returns still may point at the old
347        // generic params, that does not appear to be an issue but perhaps it
348        // should be addressed.
349
350        ast::FunctionDecl * decl = new ast::FunctionDecl(
351                // Auto-generated routines use the type declaration's location.
352                getLocation(),
353                name,
354                std::move( type_params ),
355                std::move( assertions ),
356                std::move( params ),
357                std::move( returns ),
358                // Only a prototype, no body.
359                nullptr,
360                // Use static storage if we are at the top level.
361                (0 < functionNesting) ? ast::Storage::Classes() : ast::Storage::Static,
362                proto_linkage,
363                std::vector<ast::ptr<ast::Attribute>>(),
364                // Auto-generated routines are inline to avoid conflicts.
365                ast::Function::Specs( ast::Function::Inline ) );
366        decl->fixUniqueId();
367        return decl;
368}
369
370ast::ObjectDecl * FuncGenerator::dstParam() const {
371        return new ast::ObjectDecl( getLocation(), "_dst",
372                new ast::ReferenceType( ast::deepCopy( type ) ) );
373}
374
375ast::ObjectDecl * FuncGenerator::srcParam() const {
376        return new ast::ObjectDecl( getLocation(), "_src",
377                ast::deepCopy( type ) );
378}
379
380/// Use the current type T to create `void ?{}(T & _dst)`.
381ast::FunctionDecl * FuncGenerator::genCtorProto() const {
382        return genProto( "?{}", { dstParam() }, {} );
383}
384
385/// Use the current type T to create `void ?{}(T & _dst, T _src)`.
386ast::FunctionDecl * FuncGenerator::genCopyProto() const {
387        return genProto( "?{}", { dstParam(), srcParam() }, {} );
388}
389
390/// Use the current type T to create `void ?{}(T & _dst)`.
391ast::FunctionDecl * FuncGenerator::genDtorProto() const {
392        // The destructor must be mutex on a concurrent type.
393        auto dst = dstParam();
394        if ( isConcurrentType() ) {
395                add_qualifiers( dst->type, ast::CV::Qualifiers( ast::CV::Mutex ) );
396        }
397        return genProto( "^?{}", { dst }, {} );
398}
399
400/// Use the current type T to create `T ?{}(T & _dst, T _src)`.
401ast::FunctionDecl * FuncGenerator::genAssignProto() const {
402        // Only the name is different, so just reuse the generation function.
403        auto retval = srcParam();
404        retval->name = "_ret";
405        return genProto( "?=?", { dstParam(), srcParam() }, { retval } );
406}
407
408// This one can return null if the last field is an unnamed bitfield.
409ast::FunctionDecl * FuncGenerator::genFieldCtorProto(
410                unsigned int fields ) const {
411        assert( 0 < fields );
412        auto aggr = strict_dynamic_cast<const ast::AggregateDecl *>( getDecl() );
413
414        std::vector<ast::ptr<ast::DeclWithType>> params = { dstParam() };
415        for ( unsigned int index = 0 ; index < fields ; ++index ) {
416                auto member = aggr->members[index].strict_as<ast::DeclWithType>();
417                if ( SymTab::isUnnamedBitfield(
418                                dynamic_cast<const ast::ObjectDecl *>( member ) ) ) {
419                        if ( index == fields - 1 ) {
420                                return nullptr;
421                        }
422                        continue;
423                }
424
425                auto * paramType = ast::deepCopy( member->get_type() );
426                paramType->attributes.clear();
427                ast::ObjectDecl * param = new ast::ObjectDecl(
428                        getLocation(), member->name, paramType );
429                for ( auto & attr : member->attributes ) {
430                        if ( attr->isValidOnFuncParam() ) {
431                                param->attributes.push_back( attr );
432                        }
433                }
434                params.emplace_back( param );
435        }
436        return genProto( "?{}", std::move( params ), {} );
437}
438
439void appendReturnThis( ast::FunctionDecl * decl ) {
440        assert( 1 <= decl->params.size() );
441        assert( 1 == decl->returns.size() );
442        assert( decl->stmts );
443
444        const CodeLocation& location = (decl->stmts->kids.empty())
445                ? decl->stmts->location : decl->stmts->kids.back()->location;
446        const ast::DeclWithType * thisParam = decl->params.front();
447        decl->stmts.get_and_mutate()->push_back(
448                new ast::ReturnStmt( location,
449                        new ast::VariableExpr( location, thisParam )
450                )
451        );
452}
453
454void FuncGenerator::genStandardFuncs() {
455        // The order here determines the order that these functions are generated.
456        // Assignment should come last since it uses copy constructor in return.
457        ast::FunctionDecl *(FuncGenerator::*standardProtos[4])() const = {
458                        &FuncGenerator::genCtorProto, &FuncGenerator::genCopyProto,
459                        &FuncGenerator::genDtorProto, &FuncGenerator::genAssignProto };
460        for ( auto & generator : standardProtos ) {
461                ast::FunctionDecl * decl = (this->*generator)();
462                produceForwardDecl( decl );
463                genFuncBody( decl );
464                if ( CodeGen::isAssignment( decl->name ) ) {
465                        appendReturnThis( decl );
466                }
467                produceDecl( decl );
468        }
469}
470
471void StructFuncGenerator::genFieldCtors() {
472        // The field constructors are only generated if the default constructor
473        // and copy constructor are both generated, since the need both.
474        unsigned numCtors = std::count_if( definitions.begin(), definitions.end(),
475                [](const ast::Decl * decl){ return CodeGen::isConstructor( decl->name ); }
476        );
477        if ( 2 != numCtors ) return;
478
479        for ( unsigned int num = 1 ; num <= decl->members.size() ; ++num ) {
480                ast::FunctionDecl * ctor = genFieldCtorProto( num );
481                if ( nullptr == ctor ) {
482                        continue;
483                }
484                produceForwardDecl( ctor );
485                makeFieldCtorBody( decl->members.begin(), decl->members.end(), ctor );
486                produceDecl( ctor );
487        }
488}
489
490void StructFuncGenerator::genFuncBody( ast::FunctionDecl * functionDecl ) {
491        // Generate appropriate calls to member constructors and assignment.
492        // Destructor needs to do everything in reverse,
493        // so pass "forward" based on whether the function is a destructor
494        if ( CodeGen::isDestructor( functionDecl->name ) ) {
495                makeFunctionBody( decl->members.rbegin(), decl->members.rend(),
496                        functionDecl, SymTab::LoopBackward );
497        } else {
498                makeFunctionBody( decl->members.begin(), decl->members.end(),
499                        functionDecl, SymTab::LoopForward );
500        }
501}
502
503ast::ptr<ast::Stmt> StructFuncGenerator::makeMemberOp(
504                const CodeLocation& location, const ast::ObjectDecl * dstParam,
505                const ast::Expr * src, const ast::ObjectDecl * field,
506                ast::FunctionDecl * func, SymTab::LoopDirection direction ) {
507        InitTweak::InitExpander_new srcParam( src );
508        // Assign to destination.
509        ast::Expr * dstSelect = new ast::MemberExpr(
510                location,
511                field,
512                new ast::CastExpr(
513                        location,
514                        new ast::VariableExpr( location, dstParam ),
515                        dstParam->type.strict_as<ast::ReferenceType>()->base
516                )
517        );
518        return genImplicitCall(
519                srcParam, dstSelect, location, func->name,
520                field, direction
521        );
522}
523
524template<typename Iterator>
525void StructFuncGenerator::makeFunctionBody( Iterator current, Iterator end,
526                ast::FunctionDecl * func, SymTab::LoopDirection direction ) {
527        // Trying to get the best code location. Should probably use a helper or
528        // just figure out what that would be given where this is called.
529        assert( nullptr == func->stmts );
530        const CodeLocation& location = func->location;
531
532        ast::CompoundStmt * stmts = new ast::CompoundStmt( location );
533
534        for ( ; current != end ; ++current ) {
535                const ast::ptr<ast::Decl> & member = *current;
536                auto field = member.as<ast::ObjectDecl>();
537                if ( nullptr == field ) {
538                        continue;
539                }
540
541                // Don't assign to constant members (but do construct/destruct them).
542                if ( CodeGen::isAssignment( func->name ) ) {
543                        // For array types we need to strip off the array layers.
544                        const ast::Type * type = field->get_type();
545                        while ( auto at = dynamic_cast<const ast::ArrayType *>( type ) ) {
546                                type = at->base;
547                        }
548                        if ( type->is_const() ) {
549                                continue;
550                        }
551                }
552
553                assert( !func->params.empty() );
554                const ast::ObjectDecl * dstParam =
555                        func->params.front().strict_as<ast::ObjectDecl>();
556                const ast::ObjectDecl * srcParam = nullptr;
557                if ( 2 == func->params.size() ) {
558                        srcParam = func->params.back().strict_as<ast::ObjectDecl>();
559                }
560
561                ast::Expr * srcSelect = (srcParam) ? new ast::MemberExpr(
562                        location, field, new ast::VariableExpr( location, srcParam )
563                ) : nullptr;
564                ast::ptr<ast::Stmt> stmt =
565                        makeMemberOp( location, dstParam, srcSelect, field, func, direction );
566
567                if ( nullptr != stmt ) {
568                        stmts->kids.push_back( stmt );
569                }
570        }
571
572        func->stmts = stmts;
573}
574
575template<typename Iterator>
576void StructFuncGenerator::makeFieldCtorBody( Iterator current, Iterator end,
577                ast::FunctionDecl * func ) {
578        const CodeLocation& location = func->location;
579        auto & params = func->params;
580        // Need at least the constructed parameter and one field parameter.
581        assert( 2 <= params.size() );
582
583        ast::CompoundStmt * stmts = new ast::CompoundStmt( location );
584
585        auto dstParam = params.front().strict_as<ast::ObjectDecl>();
586        // Skip over the 'this' parameter.
587        for ( auto param = params.begin() + 1 ; current != end ; ++current ) {
588                const ast::ptr<ast::Decl> & member = *current;
589                ast::ptr<ast::Stmt> stmt = nullptr;
590                auto field = member.as<ast::ObjectDecl>();
591                // Not sure why it could be null.
592                // Don't make a function for a parameter that is an unnamed bitfield.
593                if ( nullptr == field || SymTab::isUnnamedBitfield( field ) ) {
594                        continue;
595                // Matching Parameter: Initialize the field by copy.
596                } else if ( params.end() != param ) {
597                        const ast::Expr *srcSelect = new ast::VariableExpr(
598                                func->location, param->get() );
599                        stmt = makeMemberOp( location, dstParam, srcSelect, field, func, SymTab::LoopForward );
600                        ++param;
601                // No Matching Parameter: Initialize the field by default constructor.
602                } else {
603                        stmt = makeMemberOp( location, dstParam, nullptr, field, func, SymTab::LoopForward );
604                }
605
606                if ( nullptr != stmt ) {
607                        stmts->kids.push_back( stmt );
608                }
609        }
610        func->stmts = stmts;
611}
612
613void UnionFuncGenerator::genFieldCtors() {
614        // Field constructors are only generated if default and copy constructor
615        // are generated, since they need access to both
616        unsigned numCtors = std::count_if( definitions.begin(), definitions.end(),
617                []( const ast::Decl * d ){ return CodeGen::isConstructor( d->name ); }
618        );
619        if ( 2 != numCtors ) {
620                return;
621        }
622
623        // Create a constructor which takes the first member type as a
624        // parameter. For example for `union A { int x; char y; };` generate
625        // a function with signature `void ?{}(A *, int)`. This mimics C's
626        // behaviour which initializes the first member of the union.
627
628        // Still, there must be some members.
629        if ( !decl->members.empty() ) {
630                ast::FunctionDecl * ctor = genFieldCtorProto( 1 );
631                if ( nullptr == ctor ) {
632                        return;
633                }
634                produceForwardDecl( ctor );
635                auto params = ctor->params;
636                auto dstParam = params.front().strict_as<ast::ObjectDecl>();
637                auto srcParam = params.back().strict_as<ast::ObjectDecl>();
638                ctor->stmts = new ast::CompoundStmt( getLocation(),
639                        { makeAssignOp( getLocation(), dstParam, srcParam ) }
640                );
641                produceDecl( ctor );
642        }
643}
644
645void UnionFuncGenerator::genFuncBody( ast::FunctionDecl * functionDecl ) {
646        const CodeLocation& location = functionDecl->location;
647        auto & params = functionDecl->params;
648        if ( InitTweak::isCopyConstructor( functionDecl )
649                        || InitTweak::isAssignment( functionDecl ) ) {
650                assert( 2 == params.size() );
651                auto dstParam = params.front().strict_as<ast::ObjectDecl>();
652                auto srcParam = params.back().strict_as<ast::ObjectDecl>();
653                functionDecl->stmts = new ast::CompoundStmt( location,
654                        { makeAssignOp( location, dstParam, srcParam ) }
655                );
656        } else {
657                assert( 1 == params.size() );
658                // Default constructor and destructor is empty.
659                functionDecl->stmts = new ast::CompoundStmt( location );
660                // Add unused attribute to parameter to silence warnings.
661                addUnusedAttribute( params.front() );
662
663                // Just an extra step to make the forward and declaration match.
664                if ( forwards.empty() ) return;
665                ast::FunctionDecl * fwd = strict_dynamic_cast<ast::FunctionDecl *>(
666                        forwards.back().get_and_mutate() );
667                addUnusedAttribute( fwd->params.front() );
668        }
669}
670
671ast::ExprStmt * UnionFuncGenerator::makeAssignOp( const CodeLocation& location,
672                const ast::ObjectDecl * dstParam, const ast::ObjectDecl * srcParam ) {
673        return new ast::ExprStmt( location, new ast::UntypedExpr(
674                location,
675                new ast::NameExpr( location, "__builtin_memcpy" ),
676                {
677                        new ast::AddressExpr( location,
678                                new ast::VariableExpr( location, dstParam ) ),
679                        new ast::AddressExpr( location,
680                                new ast::VariableExpr( location, srcParam ) ),
681                        new ast::SizeofExpr( location, srcParam->type ),
682                } ) );
683}
684
685void EnumFuncGenerator::genFieldCtors() {
686        // Enumerations to not have field constructors.
687}
688
689void EnumFuncGenerator::genFuncBody( ast::FunctionDecl * functionDecl ) {
690        const CodeLocation& location = functionDecl->location;
691        auto & params = functionDecl->params;
692        if ( InitTweak::isCopyConstructor( functionDecl )
693                        || InitTweak::isAssignment( functionDecl ) ) {
694                assert( 2 == params.size() );
695                auto dstParam = params.front().strict_as<ast::ObjectDecl>();
696                auto srcParam = params.back().strict_as<ast::ObjectDecl>();
697
698                /* This looks like a recursive call, but code-gen will turn it into
699                 * a C-style assignment.
700                 *
701                 * This is still before function pointer type conversion,
702                 * so this will have to do it manually.
703                 *
704                 * It will also reference the parent function declaration, creating
705                 * a cycle for references. This also means that the ref-counts are
706                 * now non-zero and the declaration will be deleted if it ever
707                 * returns to zero.
708                 */
709                auto callExpr = new ast::ApplicationExpr( location,
710                        ast::VariableExpr::functionPointer( location, functionDecl ),
711                        {
712                                new ast::VariableExpr( location, dstParam ),
713                                new ast::VariableExpr( location, srcParam ),
714                        }
715                );
716                functionDecl->stmts = new ast::CompoundStmt( location,
717                        { new ast::ExprStmt( location, callExpr ) }
718                );
719        } else {
720                assert( 1 == params.size() );
721                // Default constructor and destructor is empty.
722                functionDecl->stmts = new ast::CompoundStmt( location );
723                // Just add unused attribute to parameter to silence warnings.
724                addUnusedAttribute( params.front() );
725
726                // Just an extra step to make the forward and declaration match.
727                if ( forwards.empty() ) return;
728                ast::FunctionDecl * fwd = strict_dynamic_cast<ast::FunctionDecl *>(
729                        forwards.back().get_and_mutate() );
730                addUnusedAttribute( fwd->params.front() );
731        }
732}
733
734void TypeFuncGenerator::genFieldCtors() {
735        // Opaque types do not have field constructors.
736}
737
738void TypeFuncGenerator::genFuncBody( ast::FunctionDecl * functionDecl ) {
739        const CodeLocation& location = functionDecl->location;
740        auto & params = functionDecl->type->params;
741        assertf( 1 == params.size() || 2 == params.size(),
742                "Incorrect number of parameters in autogenerated typedecl function: %zd",
743                params.size() );
744        auto dstParam = params.front().strict_as<ast::ObjectDecl>();
745        auto srcParam = (2 == params.size())
746                ? params.back().strict_as<ast::ObjectDecl>() : nullptr;
747        // Generate appropriate calls to member constructor and assignment.
748        ast::UntypedExpr * expr = new ast::UntypedExpr( location,
749                new ast::NameExpr( location, functionDecl->name )
750        );
751        expr->args.push_back( new ast::CastExpr( location,
752                new ast::VariableExpr( location, dstParam ),
753                new ast::ReferenceType( decl->base )
754        ) );
755        if ( srcParam ) {
756                expr->args.push_back( new ast::CastExpr( location,
757                        new ast::VariableExpr( location, srcParam ),
758                        decl->base
759                ) );
760        }
761        functionDecl->stmts = new ast::CompoundStmt( location,
762                { new ast::ExprStmt( location, expr ) }
763        );
764}
765
766} // namespace
767
768void autogenerateRoutines( ast::TranslationUnit & translationUnit ) {
769        ast::Pass<AutogenerateRoutines_new>::run( translationUnit );
770}
771
772} // Validate
773
774// Local Variables: //
775// tab-width: 4 //
776// mode: c++ //
777// compile-command: "make install" //
778// End: //
Note: See TracBrowser for help on using the repository browser.