Index: doc/theses/thierry_delisle_PhD/thesis/text/existing.tex =================================================================== --- doc/theses/thierry_delisle_PhD/thesis/text/existing.tex (revision d67735510bcb770552b5898e5b45fc6bc07534aa) +++ doc/theses/thierry_delisle_PhD/thesis/text/existing.tex (revision 6726a3a9cf8ffacc8cccb80819bb2c1d2687cfed) @@ -14,5 +14,7 @@ \section{Naming Convention} -Scheduling has been studied by various communities concentrating on different incarnation of the same problems. As a result, there are no standard naming conventions for scheduling that is respected across these communities. This document uses the term \newterm{\Gls{at}} to refer to the abstract objects being scheduled and the term \newterm{\Gls{proc}} to refer to the concrete objects executing these \ats. +Scheduling has been studied by various communities concentrating on different incarnation of the same problems. +As a result, there are no standard naming conventions for scheduling that is respected across these communities. +This document uses the term \newterm{\Gls{at}} to refer to the abstract objects being scheduled and the term \newterm{\Gls{proc}} to refer to the concrete objects executing these \ats. \section{Static Scheduling} @@ -26,5 +28,6 @@ \section{Dynamic Scheduling} \newterm{Dynamic schedulers} determine \ats dependencies and costs during scheduling, if at all. -Hence, unlike static scheduling, \ats dependencies are conditional and detected at runtime. This detection takes the form of observing new \ats(s) in the system and determining dependencies from their behaviour, including suspending or halting a \ats that dynamically detects unfulfilled dependencies. +Hence, unlike static scheduling, \ats dependencies are conditional and detected at runtime. +This detection takes the form of observing new \ats(s) in the system and determining dependencies from their behaviour, including suspending or halting a \ats that dynamically detects unfulfilled dependencies. Furthermore, each \ats has the responsibility of adding dependent \ats back into the system once dependencies are fulfilled. As a consequence, the scheduler often has an incomplete view of the system, seeing only \ats with no pending dependencies. Index: doc/theses/thierry_delisle_PhD/thesis/text/io.tex =================================================================== --- doc/theses/thierry_delisle_PhD/thesis/text/io.tex (revision d67735510bcb770552b5898e5b45fc6bc07534aa) +++ doc/theses/thierry_delisle_PhD/thesis/text/io.tex (revision 6726a3a9cf8ffacc8cccb80819bb2c1d2687cfed) @@ -1,4 +1,4 @@ \chapter{User Level \io} -As mentioned in Section~\ref{prev:io}, user-Level \io requires multiplexing the \io operations of many \glspl{thrd} onto fewer \glspl{proc} using asynchronous \io operations. +As mentioned in Section~\ref{prev:io}, user-level \io requires multiplexing the \io operations of many \glspl{thrd} onto fewer \glspl{proc} using asynchronous \io operations. Different operating systems offer various forms of asynchronous operations and, as mentioned in Chapter~\ref{intro}, this work is exclusively focused on the Linux operating-system. @@ -72,5 +72,5 @@ \paragraph{\lstinline{poll}} is the next oldest option, and takes as input an array of structures containing the FD numbers rather than their position in an array of bits, allowing a more compact input for interest sets that contain widely spaced FDs. -(For small interest sets with densely packed FDs, the @select@ bit mask can take less storage, and hence, copy less information into the kernel.) +For small interest sets with densely packed FDs, the @select@ bit mask can take less storage, and hence, copy less information into the kernel. Furthermore, @poll@ is non-destructive, so the array of structures does not have to be re-initialize on every call. Like @select@, @poll@ suffers from the limitation that the interest set cannot be changed by other \gls{kthrd}, while a manager thread is blocked in @poll@. @@ -277,8 +277,6 @@ While this example is artificial, in the presence of many \glspl{thrd}, it is possible for this problem to arise ``in the wild''. Furthermore, this pattern is difficult to reliably detect and avoid. -Once in this situation, the only escape is to interrupted the spinning \gls{thrd}, either directly or via some regular preemption (\eg time slicing). +Once in this situation, the only escape is to interrupted the spinning \gls{thrd}, either directly or via some regular preemption, \eg time slicing. Having to interrupt \glspl{thrd} for this purpose is costly, the latency can be large between interrupts, and the situation may be hard to detect. -% However, a more important reason why interrupting the \gls{thrd} is not a satisfying solution is that the \gls{proc} is using the instance it is tied to. -% If it were to use it, then helping could be done as part of the usage. Interrupts are needed here entirely because the \gls{proc} is tied to an instance it is not using. Therefore, a more satisfying solution is for the \gls{thrd} submitting the operation to notice that the instance is unused and simply go ahead and use it. @@ -301,5 +299,4 @@ Free SQEs, \ie, SQEs that are not currently being used to represent a request, can be written to safely and have a field called @user_data@ that the kernel only reads to copy to @cqe@s. Allocation also requires no ordering guarantee as all free SQEs are interchangeable. -% This requires a simple concurrent bag. The only added complexity is that the number of SQEs is fixed, which means allocation can fail. @@ -310,5 +307,5 @@ Once an SQE is filled in, it is added to the submission ring buffer, an operation that is not thread-safe, and then the kernel must be notified using the @io_uring_enter@ system call. -The submission ring buffer is the same size as the pre-allocated SQE buffer, therefore pushing to the ring buffer cannot fail because it is invalid to have the same \lstinline{sqe} multiple times in a ring buffer. +The submission ring buffer is the same size as the pre-allocated SQE buffer, therefore pushing to the ring buffer cannot fail because it would mean a \lstinline{sqe} multiple times in the ring buffer, which is undefined behaviour. However, as mentioned, the system call itself can fail with the expectation that it can be retried once some submitted operations complete. @@ -346,10 +343,10 @@ While instance borrowing looks similar to work sharing and stealing, I think it is different enough to warrant a different verb to avoid confusion.} -In this approach, each cluster (see Figure~\ref{fig:system}) owns a pool of @io_uring@ instances managed by an \newterm{arbiter}. +In this approach, each cluster, see Figure~\ref{fig:system}, owns a pool of @io_uring@ instances managed by an \newterm{arbiter}. When a \gls{thrd} attempts to issue an \io operation, it ask for an instance from the arbiter and issues requests to that instance. This instance is now bound to the \gls{proc} the \gls{thrd} is running on. This binding is kept until the arbiter decides to revoke it, taking back the instance and reverting the \gls{proc} to its initial state with respect to \io. This tight coupling means that synchronization can be minimal since only one \gls{proc} can use the instance at a time, akin to the private instances approach. -However, it differs in that revocation by the arbiter (an interrupt) means this approach does not suffer from the deadlock scenario described above. +However, it differs in that revocation by the arbiter means this approach does not suffer from the deadlock scenario described above. Arbitration is needed in the following cases: @@ -377,5 +374,5 @@ \paragraph{External Submissions} are handled by the arbiter by revoking the appropriate instance and adding the submission to the submission ring. -However, there is no need to immediately revoke the instance. +However, there is no need to immediately revoke the instance. External submissions must simply be added to the ring before the next system call, \ie, when the submission ring is flushed. This means whoever is responsible for the system call, first checks if the instance has any external submissions. @@ -453,5 +450,4 @@ \section{Interface} - The last important part of the \io subsystem is its interface. There are multiple approaches that can be offered to programmers, each with advantages and disadvantages. Index: src/AST/Expr.cpp =================================================================== --- src/AST/Expr.cpp (revision d67735510bcb770552b5898e5b45fc6bc07534aa) +++ src/AST/Expr.cpp (revision 6726a3a9cf8ffacc8cccb80819bb2c1d2687cfed) @@ -272,5 +272,5 @@ // Adjust the length of the string for the terminator. const Expr * strSize = from_ulong( loc, str.size() + 1 ); - const Type * strType = new ArrayType( charType, strSize, FixedLen, StaticDim ); + const Type * strType = new ArrayType( charType, strSize, FixedLen, DynamicDim ); const std::string strValue = "\"" + str + "\""; return new ConstantExpr( loc, strType, strValue, std::nullopt ); Index: src/CodeGen/FixNames.cc =================================================================== --- src/CodeGen/FixNames.cc (revision d67735510bcb770552b5898e5b45fc6bc07534aa) +++ src/CodeGen/FixNames.cc (revision 6726a3a9cf8ffacc8cccb80819bb2c1d2687cfed) @@ -5,11 +5,11 @@ // file "LICENCE" distributed with Cforall. // -// FixNames.cc -- +// FixNames.cc -- Adjustments to typed declarations. // // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Andrew Beach -// Last Modified On : Fri Oct 29 15:49:00 2021 -// Update Count : 23 +// Last Modified On : Wed Jul 20 11:49:00 2022 +// Update Count : 24 // @@ -87,5 +87,5 @@ /// Does work with the main function and scopeLevels. -class FixNames_new : public ast::WithGuards { +class FixNames_new final { int scopeLevel = 1; @@ -103,14 +103,10 @@ const ast::FunctionDecl *postvisit( const ast::FunctionDecl *functionDecl ) { - // This store is used to ensure a maximum of one call to mutate. - ast::FunctionDecl * mutDecl = nullptr; + if ( FixMain::isMain( functionDecl ) ) { + auto mutDecl = ast::mutate( functionDecl ); - if ( shouldSetScopeLevel( functionDecl ) ) { - mutDecl = ast::mutate( functionDecl ); - mutDecl->scopeLevel = scopeLevel; - } - - if ( FixMain::isMain( functionDecl ) ) { - if ( !mutDecl ) { mutDecl = ast::mutate( functionDecl ); } + if ( shouldSetScopeLevel( mutDecl ) ) { + mutDecl->scopeLevel = scopeLevel; + } int nargs = mutDecl->params.size(); @@ -124,10 +120,19 @@ ) ); + + return mutDecl; + } else if ( shouldSetScopeLevel( functionDecl ) ) { + return ast::mutate_field( functionDecl, &ast::FunctionDecl::scopeLevel, scopeLevel ); + } else { + return functionDecl; } - return mutDecl ? mutDecl : functionDecl; } void previsit( const ast::CompoundStmt * ) { - GuardValue( scopeLevel ) += 1; + scopeLevel += 1; + } + + void postvisit( const ast::CompoundStmt * ) { + scopeLevel -= 1; } }; Index: src/CodeGen/FixNames.h =================================================================== --- src/CodeGen/FixNames.h (revision d67735510bcb770552b5898e5b45fc6bc07534aa) +++ src/CodeGen/FixNames.h (revision 6726a3a9cf8ffacc8cccb80819bb2c1d2687cfed) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// FixNames.h -- +// FixNames.h -- Adjustments to typed declarations. // // Author : Richard C. Bilson @@ -26,5 +26,6 @@ /// mangles object and function names void fixNames( std::list< Declaration* > & translationUnit ); - void fixNames( ast::TranslationUnit & translationUnit ); +/// Sets scope levels and fills in main's default return. +void fixNames( ast::TranslationUnit & translationUnit ); } // namespace CodeGen Index: src/Concurrency/Keywords.h =================================================================== --- src/Concurrency/Keywords.h (revision d67735510bcb770552b5898e5b45fc6bc07534aa) +++ src/Concurrency/Keywords.h (revision 6726a3a9cf8ffacc8cccb80819bb2c1d2687cfed) @@ -28,9 +28,9 @@ void implementThreadStarter( std::list< Declaration * > & translationUnit ); -/// Implement the sue-like keywords and the suspend keyword. +/// Implement the sue-like keywords and the suspend keyword. Pre-Autogen void implementKeywords( ast::TranslationUnit & translationUnit ); -/// Implement the mutex parameters and mutex statement. +/// Implement the mutex parameters and mutex statement. Post-Autogen void implementMutex( ast::TranslationUnit & translationUnit ); -/// Add the thread starter code to constructors. +/// Add the thread starter code to constructors. Post-Autogen void implementThreadStarter( ast::TranslationUnit & translationUnit ); }; Index: src/ControlStruct/ExceptDecl.cc =================================================================== --- src/ControlStruct/ExceptDecl.cc (revision d67735510bcb770552b5898e5b45fc6bc07534aa) +++ src/ControlStruct/ExceptDecl.cc (revision 6726a3a9cf8ffacc8cccb80819bb2c1d2687cfed) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// ExceptDecl.cc -- +// ExceptDecl.cc -- Handles declarations of exception types. // // Author : Henry Xue Index: src/ControlStruct/ExceptDecl.h =================================================================== --- src/ControlStruct/ExceptDecl.h (revision d67735510bcb770552b5898e5b45fc6bc07534aa) +++ src/ControlStruct/ExceptDecl.h (revision 6726a3a9cf8ffacc8cccb80819bb2c1d2687cfed) @@ -5,11 +5,11 @@ // file "LICENCE" distributed with Cforall. // -// ExceptDecl.h -- +// ExceptDecl.h -- Handles declarations of exception types. // // Author : Henry Xue // Created On : Tue Jul 20 04:10:50 2021 -// Last Modified By : Henry Xue -// Last Modified On : Tue Jul 20 04:10:50 2021 -// Update Count : 1 +// Last Modified By : Andrew Beach +// Last Modified On : Tue Jul 12 15:49:00 2022 +// Update Count : 2 // @@ -20,5 +20,12 @@ class Declaration; +namespace ast { + class TranslationUnit; +} + namespace ControlStruct { - void translateExcept( std::list< Declaration *> & translationUnit ); +/// Unfold exception declarations into raw structure declarations. +/// Also builds vtable declarations and converts vtable types. +void translateExcept( std::list< Declaration *> & translationUnit ); +void translateExcept( ast::TranslationUnit & translationUnit ); } Index: src/ControlStruct/ExceptDeclNew.cpp =================================================================== --- src/ControlStruct/ExceptDeclNew.cpp (revision 6726a3a9cf8ffacc8cccb80819bb2c1d2687cfed) +++ src/ControlStruct/ExceptDeclNew.cpp (revision 6726a3a9cf8ffacc8cccb80819bb2c1d2687cfed) @@ -0,0 +1,544 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2018 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// ExceptDeclNew.cpp -- +// +// Author : Andrew Beach +// Created On : Tue Jul 12 15:50:00 2022 +// Last Modified By : Andrew Beach +// Last Modified On : Mon Jul 18 11:01:00 2022 +// Update Count : 0 +// + +#include "ExceptDecl.h" + +#include "AST/Decl.hpp" +#include "AST/Pass.hpp" +#include "AST/Print.hpp" +#include "AST/Type.hpp" +#include "Virtual/Tables.h" + +namespace ControlStruct { + +namespace { + +std::vector> forallToParams( + std::vector> const & forall ) { + return map_range>>( forall, + []( ast::ptr const & decl ) { + return new ast::TypeExpr( decl->location, + new ast::TypeInstType( decl->name, decl->kind ) ); + } + ); +} + +// A slightly argumented extra constructor, adds a deepCopy. +ast::StructInstType * namedStructInstType( + std::string const & name, ast::CV::Qualifiers qualifiers, + std::vector> const & params ) { + ast::StructInstType * type = new ast::StructInstType( name, qualifiers ); + for ( ast::ptr const & param : params ) { + type->params.push_back( ast::deepCopy( param ) ); + } + return type; +} + +ast::StructInstType * createExceptionInstType( + std::string const & exceptionName, + std::vector> const & params ) { + return namedStructInstType( exceptionName, ast::CV::Qualifiers(), params ); +} + +ast::StructInstType * createVTableInstType( + std::string const & exceptionName, + std::vector> const & params ) { + std::string name = Virtual::vtableTypeName( exceptionName ); + return namedStructInstType( name, ast::CV::Const, params ); +} + +ast::StructInstType * createTypeIdInstType( + std::string const & exceptionName, + std::vector> const & params ) { + std::string name = Virtual::typeIdType( exceptionName ); + return namedStructInstType( name, ast::CV::Const, params ); +} + +ast::FunctionType const * createCopyFuncType( + std::string const & exceptionName, + std::vector> const & params ) { + ast::FunctionType * type = new ast::FunctionType( ast::FixedArgs ); + type->params.push_back( new ast::PointerType( + createExceptionInstType( exceptionName, params ) ) ); + type->params.push_back( new ast::PointerType( + createExceptionInstType( exceptionName, params ) ) ); + type->returns.push_back( new ast::VoidType() ); + return type; +} + +ast::FunctionType const * createDtorFuncType( + std::string const & exceptionName, + std::vector> const & params ) { + ast::FunctionType * type = new ast::FunctionType( ast::FixedArgs ); + type->params.push_back( new ast::ReferenceType( + createExceptionInstType( exceptionName, params ) ) ); + type->returns.push_back( new ast::VoidType() ); + return type; +} + +ast::FunctionType const * createMsgFuncType( + std::string const & exceptionName, + std::vector> const & params ) { + ast::FunctionType * type = new ast::FunctionType( ast::FixedArgs ); + type->params.push_back( new ast::PointerType( + createExceptionInstType( exceptionName, params ) ) ); + type->returns.push_back( new ast::PointerType( + new ast::BasicType( ast::BasicType::Char, ast::CV::Const ) ) ); + return type; +} + +ast::StructDecl const * createTypeIdStruct( + CodeLocation const & location, + std::string const & exceptionName, + std::vector> const & forallClause ) { + ast::StructDecl * decl = new ast::StructDecl( location, + Virtual::typeIdType( exceptionName ) ); + decl->members.push_back( new ast::ObjectDecl( + location, + "parent", + new ast::PointerType( + new ast::StructInstType( "__cfavir_type_info", ast::CV::Const ) ), + nullptr, + ast::Storage::Classes(), + ast::Linkage::Cforall + ) ); + decl->body = true; + for ( ast::ptr const & param : forallClause ) { + decl->params.push_back( ast::deepCopy( param ) ); + } + return decl; +} + +ast::ObjectDecl const * createTypeIdValue( + CodeLocation const & location, + std::string const & exceptionName, + std::vector> const & params ) { + ast::StructInstType * typeIdType = + createTypeIdInstType( exceptionName, params ); + return new ast::ObjectDecl( + location, + Virtual::typeIdName( exceptionName ), + typeIdType, + new ast::ListInit( location, { + new ast::SingleInit( location, + new ast::AddressExpr( location, + new ast::NameExpr( location, "__cfatid_exception_t" ) ), + ast::MaybeConstruct ), + }, {}, ast::MaybeConstruct ), + ast::Storage::Classes(), + ast::Linkage::Cforall, + nullptr, + { new ast::Attribute( "cfa_linkonce" ) } + ); +} + +ast::StructDecl const * createExceptionStructForward( + CodeLocation const & location, + std::string const & exceptionName, + std::vector> const & forall ) { + ast::StructDecl * decl = new ast::StructDecl( location, exceptionName ); + for ( ast::ptr const & param : forall ) { + decl->params.push_back( ast::deepCopy( param ) ); + } + return decl; +} + +ast::StructDecl const * createVirtualTableStruct( + CodeLocation const & location, + std::string const & exceptionName, + std::vector> const & forall, + std::vector> const & params ) { + ast::StructInstType * typeIdType = + createTypeIdInstType( exceptionName, params ); + ast::ObjectDecl * typeId = new ast::ObjectDecl( + location, + "__cfavir_typeid", + new ast::PointerType( typeIdType ), + nullptr, + ast::Storage::Classes(), + ast::Linkage::Cforall + ); + ast::ObjectDecl * size = new ast::ObjectDecl( + location, + "size", + new ast::TypeInstType( "size_t", ast::TypeDecl::Dtype ), + nullptr, + ast::Storage::Classes(), + ast::Linkage::Cforall + ); + ast::ObjectDecl * copy = new ast::ObjectDecl( + location, + "copy", + new ast::PointerType( createCopyFuncType( exceptionName, params ) ), + nullptr, + ast::Storage::Classes(), + ast::Linkage::Cforall + ); + ast::ObjectDecl * dtor = new ast::ObjectDecl( + location, + "^?{}", + new ast::PointerType( createDtorFuncType( exceptionName, params ) ), + nullptr, + ast::Storage::Classes(), + ast::Linkage::Cforall + ); + ast::ObjectDecl * msg = new ast::ObjectDecl( + location, + "msg", + new ast::PointerType( createMsgFuncType( exceptionName, params ) ), + nullptr, + ast::Storage::Classes(), + ast::Linkage::Cforall + ); + ast::StructDecl * decl = new ast::StructDecl( + location, + Virtual::vtableTypeName( exceptionName ) ); + decl->members.push_back( typeId ); + decl->members.push_back( size ); + decl->members.push_back( copy ); + decl->members.push_back( dtor ); + decl->members.push_back( msg ); + decl->body = true; + for ( ast::ptr const & param : forall ) { + decl->params.push_back( param ); + } + return decl; +} + +ast::StructDecl const * createExceptionStruct( + CodeLocation const & location, + std::string const & exceptionName, + std::vector> const & forallClause, + std::vector> const & params, + std::vector> const & members ) { + ast::StructDecl * decl = new ast::StructDecl( location, exceptionName ); + decl->members.push_back( new ast::ObjectDecl( + location, + "virtual_table", + new ast::PointerType( + createVTableInstType( exceptionName, params ) ), + nullptr, + ast::Storage::Classes(), + ast::Linkage::Cforall + ) ); + for ( ast::ptr const & member : members ) { + decl->members.push_back( ast::deepCopy( member ) ); + } + decl->body = true; + for ( ast::ptr const & param : forallClause ) { + decl->params.push_back( ast::deepCopy( param ) ); + } + return decl; +} + +ast::ObjectDecl const * createExternTypeId( + CodeLocation const & location, + std::string const & exceptionName, + std::vector> const & params ) { + return new ast::ObjectDecl( + location, + Virtual::typeIdName( exceptionName ), + createVTableInstType( exceptionName, params ), + nullptr, + ast::Storage::Extern, + ast::Linkage::Cforall, + nullptr, + { new ast::Attribute( "cfa_linkonce" ) } + ); +} + +ast::ObjectDecl const * createExternVTable( + CodeLocation const & location, + std::string const & exceptionName, + std::vector> const & params, + std::string const & tableName ) { + return new ast::ObjectDecl( + location, + tableName, + createVTableInstType( exceptionName, params ), + nullptr, + ast::Storage::Extern, + ast::Linkage::Cforall + ); +} + +ast::FunctionDecl const * createCopy( + CodeLocation const & location, + std::string const & exceptionName, + std::vector> const & params ) { + return new ast::FunctionDecl( + location, + "copy", + {/* forall */}, + {/* assertions */}, + { + new ast::ObjectDecl( + location, + "this", + new ast::PointerType( + createExceptionInstType( exceptionName, params ) ), + nullptr, + ast::Storage::Classes(), + ast::Linkage::Cforall + ), + new ast::ObjectDecl( + location, + "that", + new ast::PointerType( + createExceptionInstType( exceptionName, params ) ), + nullptr, + ast::Storage::Classes(), + ast::Linkage::Cforall + ), + }, + { + new ast::ObjectDecl( + location, + "", + new ast::VoidType(), + nullptr, + ast::Storage::Classes(), + ast::Linkage::Cforall + ), + }, + new ast::CompoundStmt( location, { + new ast::ExprStmt( location, + new ast::UntypedExpr( location, + new ast::NameExpr( location, "?=?" ), + { + new ast::UntypedExpr( location, + new ast::NameExpr( location, "*?" ), + { new ast::NameExpr( location, "this" ) } ), + new ast::UntypedExpr( location, + new ast::NameExpr( location, "*?" ), + { new ast::NameExpr( location, "that" ) } ), + } + ) + ), + } ), + ast::Storage::Classes(), + ast::Linkage::Cforall + ); +} + +ast::FunctionDecl const * createMsg( + CodeLocation const & location, + std::string const & exceptionName, + std::vector> const & params ) { + std::stringstream msg; + msg << exceptionName; + // The forall variant, add parameters to the string. + if ( !params.empty() ) { + msg << "("; + bool first = true; + for ( auto & param : params ) { + // Seperator Logic: A comma proceeds all but the first object. + if ( first ) { + first = false; + } else { + msg << ", "; + } + + ast::print( msg, param.get() ); + } + msg << ")"; + } + return new ast::FunctionDecl( + location, + "msg", + {/* forall */}, + {/* assertions */}, + { + new ast::ObjectDecl( + location, + "this", + new ast::PointerType( + createExceptionInstType( exceptionName, params ) ), + nullptr, + ast::Storage::Classes(), + ast::Linkage::Cforall + ), + }, + { + new ast::ObjectDecl( + location, + "", + new ast::PointerType( + new ast::BasicType( ast::BasicType::Char, ast::CV::Const ) ), + nullptr, + ast::Storage::Classes(), + ast::Linkage::Cforall + ), + }, + new ast::CompoundStmt( location, { + new ast::ReturnStmt( location, + ast::ConstantExpr::from_string( location, msg.str() ) + ), + } ), + ast::Storage::Classes(), + ast::Linkage::Cforall + ); +} + +ast::ObjectDecl const * createVirtualTable( + CodeLocation const & location, + std::string const & exceptionName, + std::vector> const & params, + std::string const & tableName ) { + ast::StructInstType * sizeType = new ast::StructInstType( exceptionName ); + for ( ast::ptr const & param : params ) { + sizeType->params.push_back( ast::deepCopy( param ) ); + } + std::vector> inits { + new ast::SingleInit( location, + new ast::AddressExpr( location, + new ast::NameExpr( location, + Virtual::typeIdName( exceptionName ) ) ) ), + new ast::SingleInit( location, + new ast::SizeofExpr( location, sizeType ) ), + new ast::SingleInit( location, + new ast::NameExpr( location, "copy" ) ), + new ast::SingleInit( location, + new ast::NameExpr( location, "^?{}" ) ), + new ast::SingleInit( location, + new ast::NameExpr( location, "msg" ) ), + }; + std::vector> dsigs { + new ast::Designation( location, { + new ast::NameExpr( location, "__cfavir_typeid" ) } ), + new ast::Designation( location, { + new ast::NameExpr( location, "size" ) } ), + new ast::Designation( location, { + new ast::NameExpr( location, "copy" ) } ), + new ast::Designation( location, { + new ast::NameExpr( location, "^?{}" ) } ), + new ast::Designation( location, { + new ast::NameExpr( location, "msg" ) } ), + }; + return new ast::ObjectDecl( + location, + tableName, + createVTableInstType( exceptionName, params ), + new ast::ListInit( location, std::move( inits ), std::move( dsigs ) ), + ast::Storage::Classes(), + ast::Linkage::Cforall + ); +} + +struct ExceptDeclCore : public ast::WithDeclsToAdd<> { + ast::StructDecl const * transformExcept( ast::StructDecl const * decl ); + ast::ObjectDecl const * transformVTable( + ast::ObjectDecl const * decl, ast::VTableType const * type ); + + ast::StructDecl const * postvisit( ast::StructDecl const * decl ) { + // Exceptions don't get their own node type, so filter that. + if ( ast::AggregateDecl::Exception == decl->kind ) { + return transformExcept( decl ); + } + return decl; + } + + ast::ObjectDecl const * postvisit( ast::ObjectDecl const * decl ) { + // Modify remaining objects that have a vtable type. + if ( auto * type = decl->type.as() ) { + return transformVTable( decl, type ); + } + return decl; + } +}; + +ast::StructDecl const * ExceptDeclCore::transformExcept( + ast::StructDecl const * decl ) { + CodeLocation const & location = decl->location; + std::string const & exceptionName = decl->name; + std::vector> const & forall = decl->params; + std::vector> params = forallToParams( forall ); + std::vector> const & members = decl->members; + + declsToAddBefore.push_back( + createTypeIdStruct( location, exceptionName, forall ) ); + if ( forall.empty() ) { + // Non-forall variant. + declsToAddBefore.push_back( + createTypeIdValue( location, exceptionName, params ) ); + } + declsToAddBefore.push_back( + createExceptionStructForward( location, exceptionName, forall ) ); + declsToAddBefore.push_back( + createVirtualTableStruct( location, exceptionName, forall, params ) ); + return createExceptionStruct( location, exceptionName, forall, params, members ); +} + +ast::ObjectDecl const * ExceptDeclCore::transformVTable( + ast::ObjectDecl const * decl, ast::VTableType const * type ) { + CodeLocation const & location = decl->location; + auto base = type->base.strict_as(); + std::string const & exceptionName = base->name; + std::vector> const & params = base->params; + std::string const & tableName = decl->name; + + if ( decl->storage.is_extern ) { + // Unique type-ids are only needed for polymorphic instances. + if ( !params.empty() ) { + declsToAddBefore.push_back( + createExternTypeId( location, exceptionName, params ) ); + } + return createExternVTable( location, exceptionName, params, tableName ); + } else { + // Unique type-ids are only needed for polymorphic instances. + if ( !params.empty() ) { + declsToAddBefore.push_back( + createTypeIdValue( location, exceptionName, params ) ); + } + declsToAddBefore.push_back( + createCopy( location, exceptionName, params ) ); + declsToAddBefore.push_back( + createMsg( location, exceptionName, params ) ); + return createVirtualTable( + location, exceptionName, params, tableName ); + } +} + +struct VTableCore { + ast::StructInstType const * postvisit( ast::VTableType const * type ) { + auto inst = type->base.as(); + + std::string vtableName = Virtual::vtableTypeName( inst->name ); + auto newType = new ast::StructInstType( vtableName ); + for ( ast::ptr const & param : inst->params ) { + newType->params.push_back( param ); + } + + return newType; + } +}; + +} // namespace + +void translateExcept( ast::TranslationUnit & translationUnit ) { + // Can I combine these? + // Second pass really only covers what the first has missed. + // Maybe if the first one is all previsits and the second all postvisit. + ast::Pass::run( translationUnit ); + ast::Pass::run( translationUnit ); +} + +} // namespace ControlStruct + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/ControlStruct/HoistControlDecls.hpp =================================================================== --- src/ControlStruct/HoistControlDecls.hpp (revision d67735510bcb770552b5898e5b45fc6bc07534aa) +++ src/ControlStruct/HoistControlDecls.hpp (revision 6726a3a9cf8ffacc8cccb80819bb2c1d2687cfed) @@ -21,5 +21,6 @@ namespace ControlStruct { -// Hoist declarations out of control flow statements into compound statement. +/// Hoist declarations out of control flow statements into compound statement. +/// Must happen before auto-gen routines are added. void hoistControlDecls( ast::TranslationUnit & translationUnit ); } // namespace ControlStruct Index: src/ControlStruct/MultiLevelExit.cpp =================================================================== --- src/ControlStruct/MultiLevelExit.cpp (revision d67735510bcb770552b5898e5b45fc6bc07534aa) +++ src/ControlStruct/MultiLevelExit.cpp (revision 6726a3a9cf8ffacc8cccb80819bb2c1d2687cfed) @@ -149,6 +149,5 @@ }; -NullStmt * labelledNullStmt( - const CodeLocation & cl, const Label & label ) { +NullStmt * labelledNullStmt( const CodeLocation & cl, const Label & label ) { return new NullStmt( cl, vector