source: src/Validate/Autogen.cpp@ 11ab0b4a

Last change on this file since 11ab0b4a was 14c0f7b, checked in by Andrew Beach <ajbeach@…>, 2 years ago

Added invariant to check that referenced declarations are in scope. This one took a while, I don't remember why forall pointer decay is involved.

  • Property mode set to 100644
File size: 28.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// 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 : Tue Sep 20 16:00:00 2022
13// Update Count : 2
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/Copy.hpp"
28#include "AST/Create.hpp"
29#include "AST/Decl.hpp"
30#include "AST/DeclReplacer.hpp"
31#include "AST/Expr.hpp"
32#include "AST/Inspect.hpp"
33#include "AST/Pass.hpp"
34#include "AST/Stmt.hpp"
35#include "AST/SymbolTable.hpp"
36#include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
37#include "Common/ScopedMap.h" // for ScopedMap<>::const_iterator, Scope...
38#include "Common/utility.h" // for cloneAll, operator+
39#include "GenPoly/ScopedSet.h" // for ScopedSet, ScopedSet<>::iterator
40#include "InitTweak/GenInit.h" // for fixReturnStatements
41#include "InitTweak/InitTweak.h" // for isAssignment, isCopyConstructor
42#include "SymTab/GenImplicitCall.hpp" // for genImplicitCall
43#include "SymTab/Mangler.h" // for Mangler
44#include "CompilationState.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( 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 // if ( auto enumBaseType = enumDecl->base ) {
239 // if ( auto enumBaseTypeAsStructInst = dynamic_cast<const ast::StructInstType *>(enumBaseType.get()) ) {
240 // const ast::StructDecl * structDecl = enumBaseTypeAsStructInst->base.get();
241 // this->previsit( structDecl );
242 // }
243 // }
244
245 ast::EnumInstType enumInst( enumDecl->name );
246 enumInst.base = enumDecl;
247 EnumFuncGenerator gen( enumDecl, &enumInst, functionNesting );
248 gen.generateAndAppendFunctions( declsToAddAfter );
249}
250
251void AutogenerateRoutines_new::previsit( const ast::StructDecl * structDecl ) {
252 visit_children = false;
253 if ( !structDecl->body ) return;
254
255 ast::StructInstType structInst( structDecl->name );
256 structInst.base = structDecl;
257 for ( const ast::TypeDecl * typeDecl : structDecl->params ) {
258 structInst.params.push_back( new ast::TypeExpr(
259 typeDecl->location,
260 new ast::TypeInstType( typeDecl )
261 ) );
262 }
263 StructFuncGenerator gen( structDecl, &structInst, functionNesting );
264 gen.generateAndAppendFunctions( declsToAddAfter );
265}
266
267void AutogenerateRoutines_new::previsit( const ast::UnionDecl * unionDecl ) {
268 visit_children = false;
269 if ( !unionDecl->body ) return;
270
271 ast::UnionInstType unionInst( unionDecl->name );
272 unionInst.base = unionDecl;
273 for ( const ast::TypeDecl * typeDecl : unionDecl->params ) {
274 unionInst.params.push_back( new ast::TypeExpr(
275 unionDecl->location,
276 new ast::TypeInstType( typeDecl )
277 ) );
278 }
279 UnionFuncGenerator gen( unionDecl, &unionInst, functionNesting );
280 gen.generateAndAppendFunctions( declsToAddAfter );
281}
282
283/// Generate ctor/dtors/assign for typedecls, e.g., otype T = int *;
284void AutogenerateRoutines_new::previsit( const ast::TypeDecl * typeDecl ) {
285 if ( !typeDecl->base ) return;
286
287 ast::TypeInstType refType( typeDecl->name, typeDecl );
288 TypeFuncGenerator gen( typeDecl, &refType, functionNesting );
289 gen.generateAndAppendFunctions( declsToAddAfter );
290}
291
292void AutogenerateRoutines_new::previsit( const ast::TraitDecl * ) {
293 // Ensure that we don't add assignment ops for types defined as part of the trait
294 visit_children = false;
295}
296
297void AutogenerateRoutines_new::previsit( const ast::FunctionDecl * ) {
298 // Track whether we're currently in a function.
299 // Can ignore function type idiosyncrasies, because function type can never
300 // declare a new type.
301 functionNesting += 1;
302}
303
304void AutogenerateRoutines_new::postvisit( const ast::FunctionDecl * ) {
305 functionNesting -= 1;
306}
307
308void FuncGenerator::generateAndAppendFunctions(
309 std::list<ast::ptr<ast::Decl>> & decls ) {
310 if ( !shouldAutogen() ) return;
311
312 // Generate the functions (they go into forwards and definitions).
313 genStandardFuncs();
314 genFieldCtors();
315
316 // Now export the lists contents.
317 decls.splice( decls.end(), forwards );
318 decls.splice( decls.end(), definitions );
319}
320
321void FuncGenerator::produceDecl( const ast::FunctionDecl * decl ) {
322 assert( nullptr != decl->stmts );
323 assert( decl->type_params.size() == getGenericParams( type ).size() );
324
325 definitions.push_back( decl );
326}
327
328/// Make a forward declaration of the decl and add it to forwards.
329void FuncGenerator::produceForwardDecl( const ast::FunctionDecl * decl ) {
330 if (0 != functionNesting) return;
331 ast::FunctionDecl * fwd =
332 ( decl->stmts ) ? ast::asForward( decl ) : ast::deepCopy( decl ) ;
333 fwd->fixUniqueId();
334 forwards.push_back( fwd );
335}
336
337void replaceAll( std::vector<ast::ptr<ast::DeclWithType>> & dwts,
338 const ast::DeclReplacer::TypeMap & map ) {
339 for ( auto & dwt : dwts ) {
340 dwt = strict_dynamic_cast<const ast::DeclWithType *>(
341 ast::DeclReplacer::replace( dwt, map ) );
342 }
343}
344
345/// Generates a basic prototype function declaration.
346ast::FunctionDecl * FuncGenerator::genProto( std::string&& name,
347 std::vector<ast::ptr<ast::DeclWithType>>&& params,
348 std::vector<ast::ptr<ast::DeclWithType>>&& returns ) const {
349
350 // Handle generic prameters and assertions, if any.
351 auto const & old_type_params = getGenericParams( type );
352 ast::DeclReplacer::TypeMap oldToNew;
353 std::vector<ast::ptr<ast::TypeDecl>> type_params;
354 std::vector<ast::ptr<ast::DeclWithType>> assertions;
355 for ( auto & old_param : old_type_params ) {
356 ast::TypeDecl * decl = ast::deepCopy( old_param );
357 decl->init = nullptr;
358 splice( assertions, decl->assertions );
359 oldToNew.emplace( old_param, decl );
360 type_params.push_back( decl );
361 }
362 replaceAll( params, oldToNew );
363 replaceAll( returns, oldToNew );
364 replaceAll( assertions, oldToNew );
365
366 ast::FunctionDecl * decl = new ast::FunctionDecl(
367 // Auto-generated routines use the type declaration's location.
368 getLocation(),
369 std::move( name ),
370 std::move( type_params ),
371 std::move( assertions ),
372 std::move( params ),
373 std::move( returns ),
374 // Only a prototype, no body.
375 nullptr,
376 // Use static storage if we are at the top level.
377 (0 < functionNesting) ? ast::Storage::Classes() : ast::Storage::Static,
378 proto_linkage,
379 std::vector<ast::ptr<ast::Attribute>>(),
380 // Auto-generated routines are inline to avoid conflicts.
381 ast::Function::Specs( ast::Function::Inline ) );
382 decl->fixUniqueId();
383 return decl;
384}
385
386ast::ObjectDecl * FuncGenerator::dstParam() const {
387 return new ast::ObjectDecl( getLocation(), "_dst",
388 new ast::ReferenceType( ast::deepCopy( type ) ) );
389}
390
391ast::ObjectDecl * FuncGenerator::srcParam() const {
392 return new ast::ObjectDecl( getLocation(), "_src",
393 ast::deepCopy( type ) );
394}
395
396/// Use the current type T to create `void ?{}(T & _dst)`.
397ast::FunctionDecl * FuncGenerator::genCtorProto() const {
398 return genProto( "?{}", { dstParam() }, {} );
399}
400
401/// Use the current type T to create `void ?{}(T & _dst, T _src)`.
402ast::FunctionDecl * FuncGenerator::genCopyProto() const {
403 return genProto( "?{}", { dstParam(), srcParam() }, {} );
404}
405
406/// Use the current type T to create `void ?{}(T & _dst)`.
407ast::FunctionDecl * FuncGenerator::genDtorProto() const {
408 // The destructor must be mutex on a concurrent type.
409 auto dst = dstParam();
410 if ( isConcurrentType() ) {
411 add_qualifiers( dst->type, ast::CV::Qualifiers( ast::CV::Mutex ) );
412 }
413 return genProto( "^?{}", { dst }, {} );
414}
415
416/// Use the current type T to create `T ?{}(T & _dst, T _src)`.
417ast::FunctionDecl * FuncGenerator::genAssignProto() const {
418 // Only the name is different, so just reuse the generation function.
419 auto retval = srcParam();
420 retval->name = "_ret";
421 return genProto( "?=?", { dstParam(), srcParam() }, { retval } );
422}
423
424// This one can return null if the last field is an unnamed bitfield.
425ast::FunctionDecl * FuncGenerator::genFieldCtorProto(
426 unsigned int fields ) const {
427 assert( 0 < fields );
428 auto aggr = strict_dynamic_cast<const ast::AggregateDecl *>( getDecl() );
429
430 std::vector<ast::ptr<ast::DeclWithType>> params = { dstParam() };
431 for ( unsigned int index = 0 ; index < fields ; ++index ) {
432 auto member = aggr->members[index].strict_as<ast::DeclWithType>();
433 if ( ast::isUnnamedBitfield(
434 dynamic_cast<const ast::ObjectDecl *>( member ) ) ) {
435 if ( index == fields - 1 ) {
436 return nullptr;
437 }
438 continue;
439 }
440
441 auto * paramType = ast::deepCopy( member->get_type() );
442 paramType->attributes.clear();
443 ast::ObjectDecl * param = new ast::ObjectDecl(
444 getLocation(), member->name, paramType );
445 for ( auto & attr : member->attributes ) {
446 if ( attr->isValidOnFuncParam() ) {
447 param->attributes.push_back( attr );
448 }
449 }
450 params.emplace_back( param );
451 }
452 return genProto( "?{}", std::move( params ), {} );
453}
454
455void appendReturnThis( ast::FunctionDecl * decl ) {
456 assert( 1 <= decl->params.size() );
457 assert( 1 == decl->returns.size() );
458 assert( decl->stmts );
459
460 const CodeLocation& location = (decl->stmts->kids.empty())
461 ? decl->stmts->location : decl->stmts->kids.back()->location;
462 const ast::DeclWithType * thisParam = decl->params.front();
463 decl->stmts.get_and_mutate()->push_back(
464 new ast::ReturnStmt( location,
465 new ast::VariableExpr( location, thisParam )
466 )
467 );
468}
469
470void FuncGenerator::genStandardFuncs() {
471 // The order here determines the order that these functions are generated.
472 // Assignment should come last since it uses copy constructor in return.
473 ast::FunctionDecl *(FuncGenerator::*standardProtos[4])() const = {
474 &FuncGenerator::genCtorProto, &FuncGenerator::genCopyProto,
475 &FuncGenerator::genDtorProto, &FuncGenerator::genAssignProto };
476 for ( auto & generator : standardProtos ) {
477 ast::FunctionDecl * decl = (this->*generator)();
478 produceForwardDecl( decl );
479 genFuncBody( decl );
480 if ( CodeGen::isAssignment( decl->name ) ) {
481 appendReturnThis( decl );
482 }
483 produceDecl( decl );
484 }
485}
486
487void StructFuncGenerator::genFieldCtors() {
488 // The field constructors are only generated if the default constructor
489 // and copy constructor are both generated, since the need both.
490 unsigned numCtors = std::count_if( definitions.begin(), definitions.end(),
491 [](const ast::Decl * decl){ return CodeGen::isConstructor( decl->name ); }
492 );
493 if ( 2 != numCtors ) return;
494
495 for ( unsigned int num = 1 ; num <= decl->members.size() ; ++num ) {
496 ast::FunctionDecl * ctor = genFieldCtorProto( num );
497 if ( nullptr == ctor ) {
498 continue;
499 }
500 produceForwardDecl( ctor );
501 makeFieldCtorBody( decl->members.begin(), decl->members.end(), ctor );
502 produceDecl( ctor );
503 }
504}
505
506void StructFuncGenerator::genFuncBody( ast::FunctionDecl * functionDecl ) {
507 // Generate appropriate calls to member constructors and assignment.
508 // Destructor needs to do everything in reverse,
509 // so pass "forward" based on whether the function is a destructor
510 if ( CodeGen::isDestructor( functionDecl->name ) ) {
511 makeFunctionBody( decl->members.rbegin(), decl->members.rend(),
512 functionDecl, SymTab::LoopBackward );
513 } else {
514 makeFunctionBody( decl->members.begin(), decl->members.end(),
515 functionDecl, SymTab::LoopForward );
516 }
517}
518
519ast::ptr<ast::Stmt> StructFuncGenerator::makeMemberOp(
520 const CodeLocation& location, const ast::ObjectDecl * dstParam,
521 const ast::Expr * src, const ast::ObjectDecl * field,
522 ast::FunctionDecl * func, SymTab::LoopDirection direction ) {
523 InitTweak::InitExpander_new srcParam( src );
524 // Assign to destination.
525 ast::MemberExpr * dstSelect = new ast::MemberExpr(
526 location,
527 field,
528 new ast::CastExpr(
529 location,
530 new ast::VariableExpr( location, dstParam ),
531 dstParam->type.strict_as<ast::ReferenceType>()->base
532 )
533 );
534 auto stmt = genImplicitCall(
535 srcParam, dstSelect, location, func->name,
536 field, direction
537 );
538 // This could return the above directly, except the generated code is
539 // built using the structure's members and that means all the scoped
540 // names (the forall parameters) are incorrect. This corrects them.
541 if ( stmt && !decl->params.empty() ) {
542 ast::DeclReplacer::TypeMap oldToNew;
543 for ( auto pair : group_iterate( decl->params, func->type_params ) ) {
544 oldToNew.emplace( std::get<0>(pair), std::get<1>(pair) );
545 }
546 auto node = ast::DeclReplacer::replace( stmt, oldToNew );
547 stmt = strict_dynamic_cast<const ast::Stmt *>( node );
548 }
549 return stmt;
550}
551
552template<typename Iterator>
553void StructFuncGenerator::makeFunctionBody( Iterator current, Iterator end,
554 ast::FunctionDecl * func, SymTab::LoopDirection direction ) {
555 // Trying to get the best code location. Should probably use a helper or
556 // just figure out what that would be given where this is called.
557 assert( nullptr == func->stmts );
558 const CodeLocation& location = func->location;
559
560 ast::CompoundStmt * stmts = new ast::CompoundStmt( location );
561
562 for ( ; current != end ; ++current ) {
563 const ast::ptr<ast::Decl> & member = *current;
564 auto field = member.as<ast::ObjectDecl>();
565 if ( nullptr == field ) {
566 continue;
567 }
568
569 // Don't assign to constant members (but do construct/destruct them).
570 if ( CodeGen::isAssignment( func->name ) ) {
571 // For array types we need to strip off the array layers.
572 const ast::Type * type = field->get_type();
573 while ( auto at = dynamic_cast<const ast::ArrayType *>( type ) ) {
574 type = at->base;
575 }
576 if ( type->is_const() ) {
577 continue;
578 }
579 }
580
581 assert( !func->params.empty() );
582 const ast::ObjectDecl * dstParam =
583 func->params.front().strict_as<ast::ObjectDecl>();
584 const ast::ObjectDecl * srcParam = nullptr;
585 if ( 2 == func->params.size() ) {
586 srcParam = func->params.back().strict_as<ast::ObjectDecl>();
587 }
588
589 ast::MemberExpr * srcSelect = (srcParam) ? new ast::MemberExpr(
590 location, field, new ast::VariableExpr( location, srcParam )
591 ) : nullptr;
592 ast::ptr<ast::Stmt> stmt =
593 makeMemberOp( location, dstParam, srcSelect, field, func, direction );
594
595 if ( nullptr != stmt ) {
596 stmts->kids.push_back( stmt );
597 }
598 }
599
600 func->stmts = stmts;
601}
602
603template<typename Iterator>
604void StructFuncGenerator::makeFieldCtorBody( Iterator current, Iterator end,
605 ast::FunctionDecl * func ) {
606 const CodeLocation& location = func->location;
607 auto & params = func->params;
608 // Need at least the constructed parameter and one field parameter.
609 assert( 2 <= params.size() );
610
611 ast::CompoundStmt * stmts = new ast::CompoundStmt( location );
612
613 auto dstParam = params.front().strict_as<ast::ObjectDecl>();
614 // Skip over the 'this' parameter.
615 for ( auto param = params.begin() + 1 ; current != end ; ++current ) {
616 const ast::ptr<ast::Decl> & member = *current;
617 ast::ptr<ast::Stmt> stmt = nullptr;
618 auto field = member.as<ast::ObjectDecl>();
619 // Not sure why it could be null.
620 // Don't make a function for a parameter that is an unnamed bitfield.
621 if ( nullptr == field || ast::isUnnamedBitfield( field ) ) {
622 continue;
623 // Matching Parameter: Initialize the field by copy.
624 } else if ( params.end() != param ) {
625 const ast::Expr *srcSelect = new ast::VariableExpr(
626 func->location, param->get() );
627 stmt = makeMemberOp( location, dstParam, srcSelect, field, func, SymTab::LoopForward );
628 ++param;
629 // No Matching Parameter: Initialize the field by default constructor.
630 } else {
631 stmt = makeMemberOp( location, dstParam, nullptr, field, func, SymTab::LoopForward );
632 }
633
634 if ( nullptr != stmt ) {
635 stmts->kids.push_back( stmt );
636 }
637 }
638 func->stmts = stmts;
639}
640
641void UnionFuncGenerator::genFieldCtors() {
642 // Field constructors are only generated if default and copy constructor
643 // are generated, since they need access to both
644 unsigned numCtors = std::count_if( definitions.begin(), definitions.end(),
645 []( const ast::Decl * d ){ return CodeGen::isConstructor( d->name ); }
646 );
647 if ( 2 != numCtors ) {
648 return;
649 }
650
651 // Create a constructor which takes the first member type as a
652 // parameter. For example for `union A { int x; char y; };` generate
653 // a function with signature `void ?{}(A *, int)`. This mimics C's
654 // behaviour which initializes the first member of the union.
655
656 // Still, there must be some members.
657 if ( !decl->members.empty() ) {
658 ast::FunctionDecl * ctor = genFieldCtorProto( 1 );
659 if ( nullptr == ctor ) {
660 return;
661 }
662 produceForwardDecl( ctor );
663 auto params = ctor->params;
664 auto dstParam = params.front().strict_as<ast::ObjectDecl>();
665 auto srcParam = params.back().strict_as<ast::ObjectDecl>();
666 ctor->stmts = new ast::CompoundStmt( getLocation(),
667 { makeAssignOp( getLocation(), dstParam, srcParam ) }
668 );
669 produceDecl( ctor );
670 }
671}
672
673void UnionFuncGenerator::genFuncBody( ast::FunctionDecl * functionDecl ) {
674 const CodeLocation& location = functionDecl->location;
675 auto & params = functionDecl->params;
676 if ( InitTweak::isCopyConstructor( functionDecl )
677 || InitTweak::isAssignment( functionDecl ) ) {
678 assert( 2 == params.size() );
679 auto dstParam = params.front().strict_as<ast::ObjectDecl>();
680 auto srcParam = params.back().strict_as<ast::ObjectDecl>();
681 functionDecl->stmts = new ast::CompoundStmt( location,
682 { makeAssignOp( location, dstParam, srcParam ) }
683 );
684 } else {
685 assert( 1 == params.size() );
686 // Default constructor and destructor is empty.
687 functionDecl->stmts = new ast::CompoundStmt( location );
688 // Add unused attribute to parameter to silence warnings.
689 addUnusedAttribute( params.front() );
690
691 // Just an extra step to make the forward and declaration match.
692 if ( forwards.empty() ) return;
693 ast::FunctionDecl * fwd = strict_dynamic_cast<ast::FunctionDecl *>(
694 forwards.back().get_and_mutate() );
695 addUnusedAttribute( fwd->params.front() );
696 }
697}
698
699ast::ExprStmt * UnionFuncGenerator::makeAssignOp( const CodeLocation& location,
700 const ast::ObjectDecl * dstParam, const ast::ObjectDecl * srcParam ) {
701 return new ast::ExprStmt( location, new ast::UntypedExpr(
702 location,
703 new ast::NameExpr( location, "__builtin_memcpy" ),
704 {
705 new ast::AddressExpr( location,
706 new ast::VariableExpr( location, dstParam ) ),
707 new ast::AddressExpr( location,
708 new ast::VariableExpr( location, srcParam ) ),
709 new ast::SizeofExpr( location, srcParam->type ),
710 } ) );
711}
712
713void EnumFuncGenerator::genFieldCtors() {
714 // Enumerations to not have field constructors.
715}
716
717void EnumFuncGenerator::genFuncBody( ast::FunctionDecl * functionDecl ) {
718 const CodeLocation& location = functionDecl->location;
719 auto & params = functionDecl->params;
720 if ( InitTweak::isCopyConstructor( functionDecl )
721 || InitTweak::isAssignment( functionDecl ) ) {
722 assert( 2 == params.size() );
723 auto dstParam = params.front().strict_as<ast::ObjectDecl>();
724 auto srcParam = params.back().strict_as<ast::ObjectDecl>();
725
726 /* This looks like a recursive call, but code-gen will turn it into
727 * a C-style assignment.
728 *
729 * This is still before function pointer type conversion,
730 * so this will have to do it manually.
731 *
732 * It will also reference the parent function declaration, creating
733 * a cycle for references. This also means that the ref-counts are
734 * now non-zero and the declaration will be deleted if it ever
735 * returns to zero.
736 */
737 auto callExpr = new ast::ApplicationExpr( location,
738 ast::VariableExpr::functionPointer( location, functionDecl ),
739 {
740 new ast::VariableExpr( location, dstParam ),
741 new ast::VariableExpr( location, srcParam ),
742 }
743 );
744 functionDecl->stmts = new ast::CompoundStmt( location,
745 { new ast::ExprStmt( location, callExpr ) }
746 );
747 } else {
748 assert( 1 == params.size() );
749 // Default constructor and destructor is empty.
750 functionDecl->stmts = new ast::CompoundStmt( location );
751 // Just add unused attribute to parameter to silence warnings.
752 addUnusedAttribute( params.front() );
753
754 // Just an extra step to make the forward and declaration match.
755 if ( forwards.empty() ) return;
756 ast::FunctionDecl * fwd = strict_dynamic_cast<ast::FunctionDecl *>(
757 forwards.back().get_and_mutate() );
758 addUnusedAttribute( fwd->params.front() );
759 }
760}
761
762void TypeFuncGenerator::genFieldCtors() {
763 // Opaque types do not have field constructors.
764}
765
766void TypeFuncGenerator::genFuncBody( ast::FunctionDecl * functionDecl ) {
767 const CodeLocation& location = functionDecl->location;
768 auto & params = functionDecl->type->params;
769 assertf( 1 == params.size() || 2 == params.size(),
770 "Incorrect number of parameters in autogenerated typedecl function: %zd",
771 params.size() );
772 auto dstParam = params.front().strict_as<ast::ObjectDecl>();
773 auto srcParam = (2 == params.size())
774 ? params.back().strict_as<ast::ObjectDecl>() : nullptr;
775 // Generate appropriate calls to member constructor and assignment.
776 ast::UntypedExpr * expr = new ast::UntypedExpr( location,
777 new ast::NameExpr( location, functionDecl->name )
778 );
779 expr->args.push_back( new ast::CastExpr( location,
780 new ast::VariableExpr( location, dstParam ),
781 new ast::ReferenceType( decl->base )
782 ) );
783 if ( srcParam ) {
784 expr->args.push_back( new ast::CastExpr( location,
785 new ast::VariableExpr( location, srcParam ),
786 decl->base
787 ) );
788 }
789 functionDecl->stmts = new ast::CompoundStmt( location,
790 { new ast::ExprStmt( location, expr ) }
791 );
792}
793
794} // namespace
795
796void autogenerateRoutines( ast::TranslationUnit & translationUnit ) {
797 ast::Pass<AutogenerateRoutines_new>::run( translationUnit );
798}
799
800} // Validate
801
802// Local Variables: //
803// tab-width: 4 //
804// mode: c++ //
805// compile-command: "make install" //
806// End: //
Note: See TracBrowser for help on using the repository browser.