source: src/ControlStruct/ExceptDeclNew.cpp@ b7c53a9d

Last change on this file since b7c53a9d was bccd70a, checked in by Andrew Beach <ajbeach@…>, 2 years ago

Removed internal code from TypeSubstitution header. It caused a chain of include problems, which have been corrected.
  • Property mode set to 100644
File size: 15.2 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2018 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// ExceptDeclNew.cpp --
8//
9// Author : Andrew Beach
10// Created On : Tue Jul 12 15:50:00 2022
11// Last Modified By : Andrew Beach
12// Last Modified On : Mon Jul 18 11:01:00 2022
13// Update Count : 0
14//
15
16#include "ExceptDecl.h"
17
18#include <sstream>
19
20#include "AST/Copy.hpp"
21#include "AST/Decl.hpp"
22#include "AST/Pass.hpp"
23#include "AST/Print.hpp"
24#include "AST/Type.hpp"
25#include "Virtual/Tables.h"
26
27namespace ControlStruct {
28
29namespace {
30
31std::vector<ast::ptr<ast::Expr>> forallToParams(
32 std::vector<ast::ptr<ast::TypeDecl>> const & forall ) {
33 return map_range<std::vector<ast::ptr<ast::Expr>>>( forall,
34 []( ast::ptr<ast::TypeDecl> const & decl ) {
35 return new ast::TypeExpr( decl->location,
36 new ast::TypeInstType( decl->name, decl->kind ) );
37 }
38 );
39}
40
41// A slightly argumented extra constructor, adds a deepCopy.
42ast::StructInstType * namedStructInstType(
43 std::string const & name, ast::CV::Qualifiers qualifiers,
44 std::vector<ast::ptr<ast::Expr>> const & params ) {
45 ast::StructInstType * type = new ast::StructInstType( name, qualifiers );
46 for ( ast::ptr<ast::Expr> const & param : params ) {
47 type->params.push_back( ast::deepCopy( param ) );
48 }
49 return type;
50}
51
52ast::StructInstType * createExceptionInstType(
53 std::string const & exceptionName,
54 std::vector<ast::ptr<ast::Expr>> const & params ) {
55 return namedStructInstType( exceptionName, ast::CV::Qualifiers(), params );
56}
57
58ast::StructInstType * createVTableInstType(
59 std::string const & exceptionName,
60 std::vector<ast::ptr<ast::Expr>> const & params ) {
61 std::string name = Virtual::vtableTypeName( exceptionName );
62 return namedStructInstType( name, ast::CV::Const, params );
63}
64
65ast::StructInstType * createTypeIdInstType(
66 std::string const & exceptionName,
67 std::vector<ast::ptr<ast::Expr>> const & params ) {
68 std::string name = Virtual::typeIdType( exceptionName );
69 return namedStructInstType( name, ast::CV::Const, params );
70}
71
72ast::FunctionType const * createCopyFuncType(
73 std::string const & exceptionName,
74 std::vector<ast::ptr<ast::Expr>> const & params ) {
75 ast::FunctionType * type = new ast::FunctionType( ast::FixedArgs );
76 type->params.push_back( new ast::PointerType(
77 createExceptionInstType( exceptionName, params ) ) );
78 type->params.push_back( new ast::PointerType(
79 createExceptionInstType( exceptionName, params ) ) );
80 type->returns.push_back( new ast::VoidType() );
81 return type;
82}
83
84ast::FunctionType const * createDtorFuncType(
85 std::string const & exceptionName,
86 std::vector<ast::ptr<ast::Expr>> const & params ) {
87 ast::FunctionType * type = new ast::FunctionType( ast::FixedArgs );
88 type->params.push_back( new ast::ReferenceType(
89 createExceptionInstType( exceptionName, params ) ) );
90 type->returns.push_back( new ast::VoidType() );
91 return type;
92}
93
94ast::FunctionType const * createMsgFuncType(
95 std::string const & exceptionName,
96 std::vector<ast::ptr<ast::Expr>> const & params ) {
97 ast::FunctionType * type = new ast::FunctionType( ast::FixedArgs );
98 type->params.push_back( new ast::PointerType(
99 createExceptionInstType( exceptionName, params ) ) );
100 type->returns.push_back( new ast::PointerType(
101 new ast::BasicType( ast::BasicType::Char, ast::CV::Const ) ) );
102 return type;
103}
104
105ast::StructDecl const * createTypeIdStruct(
106 CodeLocation const & location,
107 std::string const & exceptionName,
108 std::vector<ast::ptr<ast::TypeDecl>> const & forallClause ) {
109 ast::StructDecl * decl = new ast::StructDecl( location,
110 Virtual::typeIdType( exceptionName ) );
111 decl->members.push_back( new ast::ObjectDecl(
112 location,
113 "parent",
114 new ast::PointerType(
115 new ast::StructInstType( "__cfavir_type_info", ast::CV::Const ) )
116 ) );
117 decl->body = true;
118 for ( ast::ptr<ast::TypeDecl> const & param : forallClause ) {
119 decl->params.push_back( ast::deepCopy( param ) );
120 }
121 return decl;
122}
123
124ast::ObjectDecl const * createTypeIdValue(
125 CodeLocation const & location,
126 std::string const & exceptionName,
127 std::vector<ast::ptr<ast::Expr>> const & params ) {
128 ast::StructInstType * typeIdType =
129 createTypeIdInstType( exceptionName, params );
130 return new ast::ObjectDecl(
131 location,
132 Virtual::typeIdName( exceptionName ),
133 typeIdType,
134 new ast::ListInit( location, {
135 new ast::SingleInit( location,
136 new ast::AddressExpr( location,
137 new ast::NameExpr( location, "__cfatid_exception_t" ) ),
138 ast::MaybeConstruct ),
139 }, {}, ast::MaybeConstruct ),
140 ast::Storage::Classes(),
141 ast::Linkage::Cforall,
142 nullptr,
143 { new ast::Attribute( "cfa_linkonce" ) }
144 );
145}
146
147ast::StructDecl const * createExceptionStructForward(
148 CodeLocation const & location,
149 std::string const & exceptionName,
150 std::vector<ast::ptr<ast::TypeDecl>> const & forall ) {
151 ast::StructDecl * decl = new ast::StructDecl( location, exceptionName );
152 for ( ast::ptr<ast::TypeDecl> const & param : forall ) {
153 decl->params.push_back( ast::deepCopy( param ) );
154 }
155 return decl;
156}
157
158ast::StructDecl const * createVirtualTableStruct(
159 CodeLocation const & location,
160 std::string const & exceptionName,
161 std::vector<ast::ptr<ast::TypeDecl>> const & forall,
162 std::vector<ast::ptr<ast::Expr>> const & params ) {
163 ast::StructInstType * typeIdType =
164 createTypeIdInstType( exceptionName, params );
165 ast::ObjectDecl * typeId = new ast::ObjectDecl(
166 location,
167 "__cfavir_typeid",
168 new ast::PointerType( typeIdType )
169 );
170 ast::ObjectDecl * size = new ast::ObjectDecl(
171 location,
172 "size",
173 new ast::TypeInstType( "size_t", ast::TypeDecl::Dtype )
174 );
175 ast::ObjectDecl * copy = new ast::ObjectDecl(
176 location,
177 "copy",
178 new ast::PointerType( createCopyFuncType( exceptionName, params ) )
179 );
180 ast::ObjectDecl * dtor = new ast::ObjectDecl(
181 location,
182 "^?{}",
183 new ast::PointerType( createDtorFuncType( exceptionName, params ) )
184 );
185 ast::ObjectDecl * msg = new ast::ObjectDecl(
186 location,
187 "msg",
188 new ast::PointerType( createMsgFuncType( exceptionName, params ) )
189 );
190 ast::StructDecl * decl = new ast::StructDecl(
191 location,
192 Virtual::vtableTypeName( exceptionName ) );
193 decl->members.push_back( typeId );
194 decl->members.push_back( size );
195 decl->members.push_back( copy );
196 decl->members.push_back( dtor );
197 decl->members.push_back( msg );
198 decl->body = true;
199 for ( ast::ptr<ast::TypeDecl> const & param : forall ) {
200 decl->params.push_back( param );
201 }
202 return decl;
203}
204
205ast::StructDecl const * createExceptionStruct(
206 CodeLocation const & location,
207 std::string const & exceptionName,
208 std::vector<ast::ptr<ast::TypeDecl>> const & forallClause,
209 std::vector<ast::ptr<ast::Expr>> const & params,
210 std::vector<ast::ptr<ast::Decl>> const & members ) {
211 ast::StructDecl * decl = new ast::StructDecl( location, exceptionName );
212 decl->members.push_back( new ast::ObjectDecl(
213 location,
214 "virtual_table",
215 new ast::PointerType(
216 createVTableInstType( exceptionName, params ) )
217 ) );
218 for ( ast::ptr<ast::Decl> const & member : members ) {
219 decl->members.push_back( ast::deepCopy( member ) );
220 }
221 decl->body = true;
222 for ( ast::ptr<ast::TypeDecl> const & param : forallClause ) {
223 decl->params.push_back( ast::deepCopy( param ) );
224 }
225 return decl;
226}
227
228ast::ObjectDecl const * createExternTypeId(
229 CodeLocation const & location,
230 std::string const & exceptionName,
231 std::vector<ast::ptr<ast::Expr>> const & params ) {
232 return new ast::ObjectDecl(
233 location,
234 Virtual::typeIdName( exceptionName ),
235 createVTableInstType( exceptionName, params ),
236 nullptr,
237 ast::Storage::Extern,
238 ast::Linkage::Cforall,
239 nullptr,
240 { new ast::Attribute( "cfa_linkonce" ) }
241 );
242}
243
244ast::ObjectDecl const * createExternVTable(
245 CodeLocation const & location,
246 std::string const & exceptionName,
247 std::vector<ast::ptr<ast::Expr>> const & params,
248 std::string const & tableName ) {
249 return new ast::ObjectDecl(
250 location,
251 tableName,
252 createVTableInstType( exceptionName, params ),
253 nullptr,
254 ast::Storage::Extern,
255 ast::Linkage::Cforall
256 );
257}
258
259ast::FunctionDecl const * createCopy(
260 CodeLocation const & location,
261 std::string const & exceptionName,
262 std::vector<ast::ptr<ast::Expr>> const & params ) {
263 return new ast::FunctionDecl(
264 location,
265 "copy",
266 {/* forall */},
267 {/* assertions */},
268 {
269 new ast::ObjectDecl(
270 location,
271 "this",
272 new ast::PointerType(
273 createExceptionInstType( exceptionName, params ) )
274 ),
275 new ast::ObjectDecl(
276 location,
277 "that",
278 new ast::PointerType(
279 createExceptionInstType( exceptionName, params ) )
280 ),
281 },
282 {
283 new ast::ObjectDecl( location, "", new ast::VoidType() ),
284 },
285 new ast::CompoundStmt( location, {
286 new ast::ExprStmt( location,
287 new ast::UntypedExpr( location,
288 new ast::NameExpr( location, "?=?" ),
289 {
290 new ast::UntypedExpr( location,
291 new ast::NameExpr( location, "*?" ),
292 { new ast::NameExpr( location, "this" ) } ),
293 new ast::UntypedExpr( location,
294 new ast::NameExpr( location, "*?" ),
295 { new ast::NameExpr( location, "that" ) } ),
296 }
297 )
298 ),
299 } ),
300 ast::Storage::Classes(),
301 ast::Linkage::Cforall
302 );
303}
304
305ast::FunctionDecl const * createMsg(
306 CodeLocation const & location,
307 std::string const & exceptionName,
308 std::vector<ast::ptr<ast::Expr>> const & params ) {
309 std::stringstream msg;
310 msg << exceptionName;
311 // The forall variant, add parameters to the string.
312 if ( !params.empty() ) {
313 msg << "(";
314 bool first = true;
315 for ( auto & param : params ) {
316 // Seperator Logic: A comma proceeds all but the first object.
317 if ( first ) {
318 first = false;
319 } else {
320 msg << ", ";
321 }
322
323 ast::print( msg, param.get() );
324 }
325 msg << ")";
326 }
327 return new ast::FunctionDecl(
328 location,
329 "msg",
330 {/* forall */},
331 {/* assertions */},
332 {
333 new ast::ObjectDecl(
334 location,
335 "this",
336 new ast::PointerType(
337 createExceptionInstType( exceptionName, params ) )
338 ),
339 },
340 {
341 new ast::ObjectDecl(
342 location,
343 "",
344 new ast::PointerType(
345 new ast::BasicType( ast::BasicType::Char, ast::CV::Const ) )
346 ),
347 },
348 new ast::CompoundStmt( location, {
349 new ast::ReturnStmt( location,
350 ast::ConstantExpr::from_string( location, msg.str() )
351 ),
352 } ),
353 ast::Storage::Classes(),
354 ast::Linkage::Cforall
355 );
356}
357
358ast::ObjectDecl const * createVirtualTable(
359 CodeLocation const & location,
360 std::string const & exceptionName,
361 std::vector<ast::ptr<ast::Expr>> const & params,
362 std::string const & tableName ) {
363 ast::StructInstType * sizeType = new ast::StructInstType( exceptionName );
364 for ( ast::ptr<ast::Expr> const & param : params ) {
365 sizeType->params.push_back( ast::deepCopy( param ) );
366 }
367 std::vector<ast::ptr<ast::Init>> inits {
368 new ast::SingleInit( location,
369 new ast::AddressExpr( location,
370 new ast::NameExpr( location,
371 Virtual::typeIdName( exceptionName ) ) ) ),
372 new ast::SingleInit( location,
373 new ast::SizeofExpr( location, sizeType ) ),
374 new ast::SingleInit( location,
375 new ast::NameExpr( location, "copy" ) ),
376 new ast::SingleInit( location,
377 new ast::NameExpr( location, "^?{}" ) ),
378 new ast::SingleInit( location,
379 new ast::NameExpr( location, "msg" ) ),
380 };
381 std::vector<ast::ptr<ast::Designation>> dsigs {
382 new ast::Designation( location, {
383 new ast::NameExpr( location, "__cfavir_typeid" ) } ),
384 new ast::Designation( location, {
385 new ast::NameExpr( location, "size" ) } ),
386 new ast::Designation( location, {
387 new ast::NameExpr( location, "copy" ) } ),
388 new ast::Designation( location, {
389 new ast::NameExpr( location, "^?{}" ) } ),
390 new ast::Designation( location, {
391 new ast::NameExpr( location, "msg" ) } ),
392 };
393 return new ast::ObjectDecl(
394 location,
395 tableName,
396 createVTableInstType( exceptionName, params ),
397 new ast::ListInit( location, std::move( inits ), std::move( dsigs ) )
398 );
399}
400
401struct ExceptDeclCore : public ast::WithDeclsToAdd<> {
402 ast::StructDecl const * transformExcept( ast::StructDecl const * decl );
403 ast::ObjectDecl const * transformVTable(
404 ast::ObjectDecl const * decl, ast::VTableType const * type );
405
406 ast::StructDecl const * postvisit( ast::StructDecl const * decl ) {
407 // Exceptions don't get their own node type, so filter that.
408 if ( ast::AggregateDecl::Exception == decl->kind ) {
409 return transformExcept( decl );
410 }
411 return decl;
412 }
413
414 ast::ObjectDecl const * postvisit( ast::ObjectDecl const * decl ) {
415 // Modify remaining objects that have a vtable type.
416 if ( auto * type = decl->type.as<ast::VTableType>() ) {
417 return transformVTable( decl, type );
418 }
419 return decl;
420 }
421};
422
423ast::StructDecl const * ExceptDeclCore::transformExcept(
424 ast::StructDecl const * decl ) {
425 CodeLocation const & location = decl->location;
426 std::string const & exceptionName = decl->name;
427 std::vector<ast::ptr<ast::TypeDecl>> const & forall = decl->params;
428 std::vector<ast::ptr<ast::Expr>> params = forallToParams( forall );
429 std::vector<ast::ptr<ast::Decl>> const & members = decl->members;
430
431 declsToAddBefore.push_back(
432 createTypeIdStruct( location, exceptionName, forall ) );
433 if ( forall.empty() ) {
434 // Non-forall variant.
435 declsToAddBefore.push_back(
436 createTypeIdValue( location, exceptionName, params ) );
437 }
438 declsToAddBefore.push_back(
439 createExceptionStructForward( location, exceptionName, forall ) );
440 declsToAddBefore.push_back(
441 createVirtualTableStruct( location, exceptionName, forall, params ) );
442 return createExceptionStruct( location, exceptionName, forall, params, members );
443}
444
445ast::ObjectDecl const * ExceptDeclCore::transformVTable(
446 ast::ObjectDecl const * decl, ast::VTableType const * type ) {
447 CodeLocation const & location = decl->location;
448 auto base = type->base.strict_as<ast::TypeInstType>();
449 std::string const & exceptionName = base->name;
450 std::vector<ast::ptr<ast::Expr>> const & params = base->params;
451 std::string const & tableName = decl->name;
452
453 if ( decl->storage.is_extern ) {
454 // Unique type-ids are only needed for polymorphic instances.
455 if ( !params.empty() ) {
456 declsToAddBefore.push_back(
457 createExternTypeId( location, exceptionName, params ) );
458 }
459 return createExternVTable( location, exceptionName, params, tableName );
460 } else {
461 // Unique type-ids are only needed for polymorphic instances.
462 if ( !params.empty() ) {
463 declsToAddBefore.push_back(
464 createTypeIdValue( location, exceptionName, params ) );
465 }
466 declsToAddBefore.push_back(
467 createCopy( location, exceptionName, params ) );
468 declsToAddBefore.push_back(
469 createMsg( location, exceptionName, params ) );
470 return createVirtualTable(
471 location, exceptionName, params, tableName );
472 }
473}
474
475struct VTableCore {
476 ast::StructInstType const * postvisit( ast::VTableType const * type ) {
477 auto inst = type->base.as<ast::BaseInstType>();
478
479 std::string vtableName = Virtual::vtableTypeName( inst->name );
480 auto newType = new ast::StructInstType( vtableName );
481 for ( ast::ptr<ast::Expr> const & param : inst->params ) {
482 newType->params.push_back( param );
483 }
484
485 return newType;
486 }
487};
488
489} // namespace
490
491void translateExcept( ast::TranslationUnit & translationUnit ) {
492 // Can I combine these?
493 // Second pass really only covers what the first has missed.
494 // Maybe if the first one is all previsits and the second all postvisit.
495 ast::Pass<ExceptDeclCore>::run( translationUnit );
496 ast::Pass<VTableCore>::run( translationUnit );
497}
498
499} // namespace ControlStruct
500
501// Local Variables: //
502// tab-width: 4 //
503// mode: c++ //
504// compile-command: "make install" //
505// End: //
Note: See TracBrowser for help on using the repository browser.