source: src/ControlStruct/ExceptDecl.cc@ 0fba0d4

ADT ast-experimental enum forall-pointer-decay pthread-emulation qualifiedEnum
Last change on this file since 0fba0d4 was da602aec, checked in by Henry Xue <y58xue@…>, 4 years ago

Fix forall variant extern vtable decls
  • Property mode set to 100644
File size: 13.0 KB
RevLine 
[0c730d9]1//
2// Cforall Version 1.0.0 Copyright (C) 2016 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// ExceptDecl.cc --
8//
9// Author : Henry Xue
10// Created On : Tue Jul 20 04:10:50 2021
11// Last Modified By : Henry Xue
[da602aec]12// Last Modified On : Tue Aug 03 10:42:26 2021
13// Update Count : 4
[0c730d9]14//
15
16#include "ExceptDecl.h"
17
[98233b3]18#include <cassert> // for assert
19#include <string> // for string
20#include <sstream> // for stringstream
21
[0c730d9]22#include "Common/PassVisitor.h" // for PassVisitor
[98233b3]23#include "Common/utility.h" // for cloneAll
[0c730d9]24#include "SynTree/Mutator.h" // for mutateAll
25#include "Virtual/Tables.h" // for helpers
26
27namespace ControlStruct {
28
[98233b3]29const std::list< Expression *> & makeParameters(
30 const std::list< TypeDecl *> & forallClause
31) {
32 auto parameters = new std::list< Expression *>();
33 for ( auto it = forallClause.begin(); it != forallClause.end(); it++ ) {
34 parameters->emplace_back( new TypeExpr(
35 new TypeInstType( noQualifiers, ( *it )->get_name(), false )
36 ) );
[0c730d9]37 }
[98233b3]38 return *parameters;
[0c730d9]39}
40
[98233b3]41TypeInstType * makeExceptInstType(
42 const std::string & exceptionName,
43 const std::list< Expression *> & parameters
44) {
45 TypeInstType * exceptInstType = new TypeInstType(
46 noQualifiers,
47 exceptionName,
48 false
[0c730d9]49 );
[98233b3]50 cloneAll( parameters, exceptInstType->parameters );
51 return exceptInstType;
[0c730d9]52}
53
[98233b3]54// void (*copy)(exception_name parameters * this, exception_name parameters * that);
55FunctionType * makeCopyFnType(
56 const std::string & exceptionName,
57 const std::list< Expression *> & parameters
58) {
[0c730d9]59 FunctionType * copyFnType = new FunctionType( noQualifiers, false );
60 copyFnType->get_parameters().push_back( new ObjectDecl(
61 "this",
62 noStorageClasses,
63 LinkageSpec::Cforall,
64 nullptr,
65 new PointerType( noQualifiers,
[98233b3]66 makeExceptInstType( exceptionName, parameters ) ),
[0c730d9]67 nullptr
68 ) );
69 copyFnType->get_parameters().push_back( new ObjectDecl(
[98233b3]70 "that",
[0c730d9]71 noStorageClasses,
72 LinkageSpec::Cforall,
73 nullptr,
74 new PointerType( noQualifiers,
[98233b3]75 makeExceptInstType( exceptionName, parameters ) ),
[0c730d9]76 nullptr
77 ) );
78 copyFnType->get_returnVals().push_back( new ObjectDecl(
79 "",
80 noStorageClasses,
81 LinkageSpec::Cforall,
82 nullptr,
83 new VoidType( noQualifiers ),
84 nullptr
85 ) );
[98233b3]86 return copyFnType;
87}
[0c730d9]88
[98233b3]89// void (*^?{})(exception_name parameters & this);
90FunctionType * makeDtorFnType(
91 const std::string & exceptionName,
92 const std::list< Expression *> & parameters
93) {
[0c730d9]94 FunctionType * dtorFnType = new FunctionType( noQualifiers, false );
95 dtorFnType->get_parameters().push_back( new ObjectDecl(
96 "this",
97 noStorageClasses,
98 LinkageSpec::Cforall,
99 nullptr,
100 new ReferenceType( noQualifiers,
[98233b3]101 makeExceptInstType( exceptionName, parameters ) ),
[0c730d9]102 nullptr
103 ) );
104 dtorFnType->get_returnVals().push_back( new ObjectDecl(
105 "",
106 noStorageClasses,
107 LinkageSpec::Cforall,
108 nullptr,
109 new VoidType( noQualifiers ),
110 nullptr
111 ) );
[98233b3]112 return dtorFnType;
113}
[0c730d9]114
[98233b3]115// const char * (*msg)(exception_name parameters * this);
116FunctionType * makeMsgFnType(
117 const std::string & exceptionName,
118 const std::list< Expression *> & parameters
119) {
[0c730d9]120 FunctionType * msgFnType = new FunctionType( noQualifiers, false );
121 msgFnType->get_parameters().push_back( new ObjectDecl(
122 "this",
123 noStorageClasses,
124 LinkageSpec::Cforall,
125 nullptr,
126 new PointerType( noQualifiers,
[98233b3]127 makeExceptInstType( exceptionName, parameters ) ),
[0c730d9]128 nullptr
129 ) );
130 msgFnType->get_returnVals().push_back( new ObjectDecl(
131 "",
132 noStorageClasses,
133 LinkageSpec::Cforall,
134 nullptr,
[98233b3]135 new PointerType( noQualifiers,
136 new BasicType( Type::Const, BasicType::Char ) ),
137 nullptr
138 ) );
139 return msgFnType;
140}
141
142StructDecl * ehmTypeIdStruct(
143 const std::string & exceptionName,
144 const std::list< TypeDecl *> & forallClause
145) {
146 StructDecl * structDecl = new StructDecl( Virtual::typeIdType( exceptionName ) );
147 structDecl->members.push_back( new ObjectDecl(
148 "parent",
149 noStorageClasses,
150 LinkageSpec::Cforall,
151 nullptr,
152 new PointerType( noQualifiers,
153 new TypeInstType( Type::Const, "__cfavir_type_info", false ) ),
[0c730d9]154 nullptr
155 ) );
[98233b3]156 structDecl->set_body( true );
157 cloneAll( forallClause, structDecl->parameters );
158 return structDecl;
159}
160
161ObjectDecl * ehmTypeIdValue(
162 const std::string & exceptionName,
163 const std::list< Expression *> & parameters
164) {
165 StructInstType * typeIdType = new StructInstType(
166 Type::Const,
167 Virtual::typeIdType( exceptionName )
168 );
169 cloneAll( parameters, typeIdType->parameters );
170 return new ObjectDecl(
171 Virtual::typeIdName( exceptionName ),
172 noStorageClasses,
173 LinkageSpec::Cforall,
174 nullptr,
175 typeIdType,
176 new ListInit( { new SingleInit(
177 new AddressExpr( new NameExpr( "__cfatid_exception_t" ) )
178 ) }, {}, true ),
179 { new Attribute( "cfa_linkonce" ) }
180 );
181}
182
183StructDecl * ehmExceptionStructDecl(
184 const std::string & exceptionName,
185 const std::list< TypeDecl *> & forallClause
186) {
187 StructDecl * structDecl = new StructDecl( exceptionName );
188 cloneAll( forallClause, structDecl->parameters );
189 return structDecl;
190}
191
192StructDecl * ehmVirtualTableStruct(
193 const std::string & exceptionName,
194 const std::list< TypeDecl *> & forallClause,
195 const std::list< Expression *> & parameters
196) {
197 StructInstType * typeIdType = new StructInstType(
198 Type::Const,
199 Virtual::typeIdType( exceptionName )
200 );
201 cloneAll( parameters, typeIdType->parameters );
202 ObjectDecl * typeId = new ObjectDecl(
203 "__cfavir_typeid",
204 noStorageClasses,
205 LinkageSpec::Cforall,
206 nullptr,
207 new PointerType( noQualifiers, typeIdType ),
208 nullptr
209 );
210 ObjectDecl * size = new ObjectDecl(
211 "size",
212 noStorageClasses,
213 LinkageSpec::Cforall,
214 nullptr,
215 new TypeInstType( noQualifiers, "size_t", false ),
216 nullptr
217 );
218 ObjectDecl * copy = new ObjectDecl(
219 "copy",
220 noStorageClasses,
221 LinkageSpec::Cforall,
222 nullptr,
223 new PointerType( noQualifiers,
224 makeCopyFnType( exceptionName, parameters ) ),
225 nullptr
226 );
227 ObjectDecl * dtor = new ObjectDecl(
228 "^?{}",
229 noStorageClasses,
230 LinkageSpec::Cforall,
231 nullptr,
232 new PointerType( noQualifiers,
233 makeDtorFnType( exceptionName, parameters ) ),
234 nullptr
235 );
[0c730d9]236 ObjectDecl * msg = new ObjectDecl(
237 "msg",
238 noStorageClasses,
239 LinkageSpec::Cforall,
240 nullptr,
[98233b3]241 new PointerType( noQualifiers,
242 makeMsgFnType( exceptionName, parameters ) ),
[0c730d9]243 nullptr
244 );
245 StructDecl * structDecl = new StructDecl( Virtual::vtableTypeName( exceptionName ) );
246 structDecl->members.push_back( typeId );
247 structDecl->members.push_back( size );
248 structDecl->members.push_back( copy );
249 structDecl->members.push_back( dtor );
250 structDecl->members.push_back( msg );
251 structDecl->set_body( true );
[98233b3]252 cloneAll( forallClause, structDecl->parameters );
[0c730d9]253 return structDecl;
254}
255
[98233b3]256StructDecl * ehmExceptionStruct(
257 const std::string & exceptionName,
258 const std::list< TypeDecl *> & forallClause,
259 const std::list< Expression *> & parameters,
260 const std::list< Declaration *> & members
261) {
262 StructInstType * vtableType = new StructInstType(
263 Type::Const,
264 Virtual::vtableTypeName( exceptionName )
265 );
266 cloneAll( parameters, vtableType->parameters );
[0c730d9]267 StructDecl * structDecl = new StructDecl( exceptionName );
268 structDecl->members = members;
269 structDecl->members.push_front( new ObjectDecl(
270 "virtual_table",
271 noStorageClasses,
272 LinkageSpec::Cforall,
273 nullptr,
[98233b3]274 new PointerType( noQualifiers, vtableType ),
[0c730d9]275 nullptr
276 ) );
277 structDecl->set_body( true );
[98233b3]278 cloneAll( forallClause, structDecl->parameters );
[0c730d9]279 return structDecl;
280}
281
[da602aec]282ObjectDecl * ehmTypeIdExtern(
283 const std::string & exceptionName,
284 const std::list< Expression *> & parameters
285) {
286 StructInstType * typeIdType = new StructInstType(
287 Type::Const,
288 Virtual::typeIdType( exceptionName )
289 );
290 cloneAll( parameters, typeIdType->parameters );
291 return new ObjectDecl(
292 Virtual::typeIdName( exceptionName ),
293 Type::Extern,
294 LinkageSpec::Cforall,
295 nullptr,
296 typeIdType,
297 nullptr,
298 { new Attribute( "cfa_linkonce" ) }
299 );
300}
301
[98233b3]302ObjectDecl * ehmExternVtable(
303 const std::string & exceptionName,
304 const std::list< Expression *> & parameters,
305 const std::string & tableName
306) {
307 StructInstType * vtableType = new StructInstType(
308 Type::Const,
309 Virtual::vtableTypeName( exceptionName )
310 );
311 cloneAll( parameters, vtableType->parameters );
[aa882e7e]312 return new ObjectDecl(
313 tableName,
314 Type::Extern,
315 LinkageSpec::Cforall,
316 nullptr,
[98233b3]317 vtableType,
[aa882e7e]318 nullptr
319 );
320}
321
[98233b3]322FunctionDecl * ehmDefineCopy(
323 const std::string & exceptionName,
324 const std::list< Expression *> & parameters
325) {
[aa882e7e]326 return new FunctionDecl(
327 "copy",
328 noStorageClasses,
329 LinkageSpec::Cforall,
[98233b3]330 makeCopyFnType( exceptionName, parameters ),
[aa882e7e]331 new CompoundStmt( {
332 new ExprStmt( new UntypedExpr( new NameExpr( "?=?" ), {
333 new UntypedExpr( new NameExpr( "*?" ), { new NameExpr( "this" ) } ),
334 new UntypedExpr( new NameExpr( "*?" ), { new NameExpr( "that" ) } )
335 } ) )
336 } )
337 );
338}
339
[98233b3]340FunctionDecl * ehmDefineMsg(
341 const std::string & exceptionName,
342 const std::list< Expression *> & parameters
343) {
344 std::stringstream msg;
345 msg << exceptionName;
346 if ( !parameters.empty() ) { // forall variant, add parameters
347 msg << "(";
348 for ( auto it = parameters.begin(); it != parameters.end(); it++ ) {
349 ( *it )->print( msg );
350 if ( it + 1 == parameters.end() ) {
351 msg << ")"; // end of list, close bracket
352 } else {
353 msg << ", "; // otherwise use comma as separator
354 }
355 }
356 }
[aa882e7e]357 return new FunctionDecl(
358 "msg",
359 noStorageClasses,
360 LinkageSpec::Cforall,
[98233b3]361 makeMsgFnType( exceptionName, parameters ),
[aa882e7e]362 new CompoundStmt( {
[98233b3]363 new ReturnStmt( new ConstantExpr( Constant::from_string( msg.str() ) ) )
[aa882e7e]364 } )
365 );
366}
367
[98233b3]368ObjectDecl * ehmVirtualTable(
369 const std::string & exceptionName,
370 const std::list< Expression *> & parameters,
371 const std::string & tableName
372) {
373 StructInstType * sizeofType = new StructInstType( noQualifiers, exceptionName );
374 cloneAll( parameters, sizeofType->parameters );
[aa882e7e]375 std::list< Initializer *> inits {
376 new SingleInit( new AddressExpr(
377 new NameExpr( Virtual::typeIdName( exceptionName ) ) ) ),
[98233b3]378 new SingleInit( new SizeofExpr( sizeofType ) ),
[aa882e7e]379 new SingleInit( new NameExpr( "copy" ) ),
380 new SingleInit( new NameExpr( "^?{}" ) ),
381 new SingleInit( new NameExpr( "msg" ) )
382 };
383 std::list< Designation *> desig {
384 new Designation( { new NameExpr( "__cfavir_typeid" ) } ),
385 new Designation( { new NameExpr( "size" ) } ),
386 new Designation( { new NameExpr( "copy" ) } ),
387 new Designation( { new NameExpr( "^?{}" ) } ),
388 new Designation( { new NameExpr( "msg" ) } )
389 };
[98233b3]390 StructInstType * vtableType = new StructInstType(
391 Type::Const,
392 Virtual::vtableTypeName( exceptionName )
393 );
394 cloneAll( parameters, vtableType->parameters );
[aa882e7e]395 return new ObjectDecl(
396 tableName,
397 noStorageClasses,
398 LinkageSpec::Cforall,
399 nullptr,
[98233b3]400 vtableType,
[aa882e7e]401 new ListInit( inits, desig )
402 );
403}
404
[0c730d9]405class ExceptDeclCore : public WithDeclsToAdd {
406public:
[98233b3]407 // translates exception decls
408 Declaration * postmutate( StructDecl * structDecl );
409
410 // translates vtable decls
411 DeclarationWithType * postmutate( ObjectDecl * objectDecl );
[0c730d9]412};
413
414Declaration * ExceptDeclCore::postmutate( StructDecl * structDecl ) {
415 if ( structDecl->is_exception() ) {
[aa882e7e]416 const std::string & exceptionName = structDecl->get_name();
[98233b3]417 const std::list< TypeDecl *> & forallClause = structDecl->get_parameters();
418 const std::list< Expression *> & parameters = makeParameters( forallClause );
419 const std::list< Declaration *> & members = structDecl->get_members();
420
421 declsToAddBefore.push_back( ehmTypeIdStruct( exceptionName, forallClause ) );
422 if ( forallClause.empty() ) { // non-forall variant
423 declsToAddBefore.push_back( ehmTypeIdValue( exceptionName, parameters ) );
424 }
425 declsToAddBefore.push_back( ehmExceptionStructDecl( exceptionName, forallClause ) );
426 declsToAddBefore.push_back( ehmVirtualTableStruct( exceptionName, forallClause, parameters ) );
427 return ehmExceptionStruct( exceptionName, forallClause, parameters, members );
[0c730d9]428 }
429 return structDecl;
430}
431
[aa882e7e]432DeclarationWithType * ExceptDeclCore::postmutate( ObjectDecl * objectDecl ) {
433 // Check if it is VTableType
434 VTableType * vtableType = dynamic_cast< VTableType *>( objectDecl->get_type() );
435 if ( vtableType ) {
436 TypeInstType * base = dynamic_cast< TypeInstType *>( vtableType->get_base() );
437 assert( base ); // should be a TypeInstType
438 const std::string & exceptionName = base->get_name();
439 const std::string & tableName = objectDecl->get_name();
[98233b3]440 const std::list< Expression *> parameters = base->get_parameters();
441
442 if ( objectDecl->get_storageClasses().is_extern ) { // if extern
[da602aec]443 if ( !parameters.empty() ) { // forall variant
444 declsToAddBefore.push_back( ehmTypeIdExtern( exceptionName, parameters ) );
445 }
[98233b3]446 return ehmExternVtable( exceptionName, parameters, tableName );
447 }
448 // else, non-extern
449 if ( !parameters.empty() ) { // forall variant
450 declsToAddBefore.push_back( ehmTypeIdValue( exceptionName, parameters ) );
[aa882e7e]451 }
[98233b3]452 declsToAddBefore.push_back( ehmDefineCopy( exceptionName, parameters ) );
453 declsToAddBefore.push_back( ehmDefineMsg( exceptionName, parameters ) );
454 return ehmVirtualTable( exceptionName, parameters, tableName );
[aa882e7e]455 }
456 return objectDecl;
457}
458
[0c730d9]459void translateExcept( std::list< Declaration *> & translationUnit ) {
460 PassVisitor<ExceptDeclCore> translator;
461 mutateAll( translationUnit, translator );
462}
463
464}
Note: See TracBrowser for help on using the repository browser.