Index: src/AST/Convert.cpp =================================================================== --- src/AST/Convert.cpp (revision 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/AST/Convert.cpp (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -168,4 +168,7 @@ auto attr = get().acceptL( node->attributes ); + // This field can be unset very early on (Pre-FixReturnTypes). + auto newType = (type) ? type->clone() : nullptr; + auto decl = new ObjectDecl( node->name, @@ -173,5 +176,5 @@ LinkageSpec::Spec( node->linkage.val ), bfwd, - type->clone(), + newType, nullptr, // prevent infinite loop attr, @@ -1579,11 +1582,12 @@ virtual void visit( const ObjectDecl * old ) override final { + if ( inCache( old ) ) { + return; + } auto&& type = GET_ACCEPT_1(type, Type); auto&& init = GET_ACCEPT_1(init, Init); auto&& bfwd = GET_ACCEPT_1(bitfieldWidth, Expr); auto&& attr = GET_ACCEPT_V(attributes, Attribute); - if ( inCache( old ) ) { - return; - } + auto decl = new ast::ObjectDecl( old->location, Index: src/AST/Decl.hpp =================================================================== --- src/AST/Decl.hpp (revision 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/AST/Decl.hpp (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -315,6 +315,6 @@ EnumDecl( const CodeLocation& loc, const std::string& name, - std::vector>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall, Type * base = nullptr, - std::unordered_map< std::string, long long > enumValues = std::unordered_map< std::string, long long >() ) + std::vector>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall, Type const * base = nullptr, + std::unordered_map< std::string, long long > enumValues = std::unordered_map< std::string, long long >() ) : AggregateDecl( loc, name, std::move(attrs), linkage ), base(base), enumValues(enumValues) {} Index: src/AST/Expr.cpp =================================================================== --- src/AST/Expr.cpp (revision 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/AST/Expr.cpp (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -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/AST/Inspect.cpp =================================================================== --- src/AST/Inspect.cpp (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) +++ src/AST/Inspect.cpp (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -0,0 +1,35 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Inspect.cpp -- Helpers to get information from the AST. +// +// Author : Thierry Delisle +// Created On : Fri Jun 24 13:16:31 2022 +// Last Modified By : Andrew Beach +// Last Modified On : Mon Jun 27 15:35:00 2022 +// Update Count : 1 +// + +#include "AST/Decl.hpp" +#include "AST/Type.hpp" + +#include +#include + +namespace ast { + +bool structHasFlexibleArray( const ast::StructDecl * decl ) { + if(decl->members.size() == 0) return false; + const auto & last = *decl->members.rbegin(); + auto lastd = last.as(); + // I don't know what this is possible, but it might be. + if(!lastd) return false; + auto atype = dynamic_cast(lastd->get_type()); + if(!atype) return false; + return !atype->isVarLen && !atype->dimension; +} + +} // namespace ast Index: src/AST/Inspect.hpp =================================================================== --- src/AST/Inspect.hpp (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) +++ src/AST/Inspect.hpp (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -0,0 +1,23 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Inspect.hpp -- Helpers to get information from the AST. +// +// Author : Thierry Delisle +// Created On : Fri Jun 24 13:16:31 2022 +// Last Modified By : Andrew Beach +// Last Modified On : Mon Jun 27 15:35:00 2022 +// Update Count : 1 +// + +#include "AST/Fwd.hpp" + +namespace ast { + +// Does the structure end in a flexable array declaration? +bool structHasFlexibleArray( const ast::StructDecl * ); + +} Index: src/AST/Pass.impl.hpp =================================================================== --- src/AST/Pass.impl.hpp (revision 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/AST/Pass.impl.hpp (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -681,4 +681,5 @@ if ( __visit_children() ) { // unlike structs, traits, and unions, enums inject their members into the global scope + maybe_accept( node, &EnumDecl::base ); maybe_accept( node, &EnumDecl::params ); maybe_accept( node, &EnumDecl::members ); Index: src/AST/module.mk =================================================================== --- src/AST/module.mk (revision 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/AST/module.mk (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -37,4 +37,6 @@ AST/Init.cpp \ AST/Init.hpp \ + AST/Inspect.cpp \ + AST/Inspect.hpp \ AST/Label.hpp \ AST/LinkageSpec.cpp \ Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/CodeGen/CodeGenerator.cc (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Wed Feb 2 20:30:30 2022 -// Update Count : 541 +// Last Modified By : Andrew Beach +// Last Modified On : Wed Jun 29 14:34:00 2022 +// Update Count : 542 // #include "CodeGenerator.h" @@ -18,4 +18,5 @@ #include // for _List_iterator, list, list<>::it... +#include "AST/Decl.hpp" // for DeclWithType #include "Common/UniqueName.h" // for UniqueName #include "Common/utility.h" // for CodeLocation, toString @@ -294,5 +295,5 @@ } else { if ( obj->get_init() ) { - obj->get_init()->accept( *visitor ); + obj->get_init()->accept( *visitor ); } else { // Should not reach here! @@ -683,8 +684,10 @@ extension( variableExpr ); const OperatorInfo * opInfo; - if ( variableExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && (opInfo = operatorLookup( variableExpr->get_var()->get_name() )) && opInfo->type == OT_CONSTANT ) { + if( dynamic_cast( variableExpr->get_var()->get_type() ) ) { + output << "0"; + } else if ( variableExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && (opInfo = operatorLookup( variableExpr->get_var()->get_name() )) && opInfo->type == OT_CONSTANT ) { output << opInfo->symbol; } else { - // if (dynamic_cast(variableExpr->get_var()->get_type()) + // if (dynamic_cast(variableExpr->get_var()->get_type()) // && dynamic_cast(variableExpr->get_var()->get_type())->baseEnum->base) { // output << '(' <(variableExpr->get_var()->get_type())->baseEnum->base, "", options) << ')'; @@ -1236,4 +1239,13 @@ } // if } + +std::string genName( ast::DeclWithType const * decl ) { + if ( const OperatorInfo * opInfo = operatorLookup( decl->name ) ) { + return opInfo->outputName; + } else { + return decl->name; + } +} + } // namespace CodeGen Index: src/CodeGen/CodeGenerator.h =================================================================== --- src/CodeGen/CodeGenerator.h (revision 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/CodeGen/CodeGenerator.h (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Tue Feb 1 09:23:21 2022 -// Update Count : 64 +// Last Modified By : Andrew Beach +// Last Modified On : Wed Jun 29 14:32:00 2022 +// Update Count : 65 // @@ -26,4 +26,8 @@ #include "SynTree/Visitor.h" // for Visitor #include "SynTree/SynTree.h" // for Visitor Nodes + +namespace ast { + class DeclWithType; +} namespace CodeGen { @@ -182,4 +186,5 @@ /// returns C-compatible name of declaration std::string genName( DeclarationWithType * decl ); + std::string genName( ast::DeclWithType const * decl ); inline std::ostream & operator<<( std::ostream & os, const CodeGenerator::LineEnder & endl ) { Index: src/CodeGen/FixNames.cc =================================================================== --- src/CodeGen/FixNames.cc (revision 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/CodeGen/FixNames.cc (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -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 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/CodeGen/FixNames.h (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -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/CodeGen/GenType.cc =================================================================== --- src/CodeGen/GenType.cc (revision 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/CodeGen/GenType.cc (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -254,5 +254,5 @@ void GenType::postvisit( EnumInstType * enumInst ) { - if ( enumInst->baseEnum->base ) { + if ( enumInst->baseEnum && enumInst->baseEnum->base ) { typeString = genType(enumInst->baseEnum->base, "", options) + typeString; } else { Index: src/Common/Eval.cc =================================================================== --- src/Common/Eval.cc (revision 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/Common/Eval.cc (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Jul 24 15:09:06 2019 -// Update Count : 64 +// Last Modified On : Fri Jul 1 08:41:03 2022 +// Update Count : 117 // @@ -17,4 +17,5 @@ #include "Common/PassVisitor.h" +#include "CodeGen/OperatorTable.h" // access: OperatorInfo #include "AST/Pass.hpp" #include "InitTweak/InitTweak.h" @@ -24,6 +25,9 @@ // Old AST struct EvalOld : public WithShortCircuiting { - long long int value = 0; - bool valid = true; + long long int value = 0; // compose the result of the constant expression + bool valid = true; // true => constant expression and value is the result + // false => not constant expression, e.g., ++i + bool cfavalid = true; // true => constant expression and value computable + // false => constant expression but value not computable, e.g., sizeof(int) void previsit( const BaseSyntaxNode * ) { visit_children = false; } @@ -89,28 +93,77 @@ // New AST struct EvalNew : public ast::WithShortCircuiting { - long long int value = 0; - bool valid = true; + long long int value = 0; // compose the result of the constant expression + bool valid = true; // true => constant expression and value is the result + // false => not constant expression, e.g., ++i + bool cfavalid = true; // true => constant expression and value computable + // false => constant expression but value not computable, e.g., sizeof(int) void previsit( const ast::Node * ) { visit_children = false; } - void postvisit( const ast::Node * ) { valid = false; } - - void postvisit( const ast::ConstantExpr * expr ) { + void postvisit( const ast::Node * ) { cfavalid = valid = false; } + + void postvisit( const ast::UntypedExpr * ) { + assertf( false, "UntypedExpr in constant expression evaluation" ); // FIX ME, resolve variable + } + + void postvisit( const ast::ConstantExpr * expr ) { // only handle int constants value = expr->intValue(); } - void postvisit( const ast::SizeofExpr * expr ) { - if ( expr->expr ) value = eval(expr->expr).first; - else if ( expr->type ) value = eval(expr->expr).first; - else SemanticError( expr->location, ::toString( "Internal error: SizeofExpr has no expression or type value" ) ); - } - - void postvisit( const ast::CastExpr * expr ) { + void postvisit( const ast::SizeofExpr * ) { + // do not change valid or value => let C figure it out + cfavalid = false; + } + + void postvisit( const ast::AlignofExpr * ) { + // do not change valid or value => let C figure it out + cfavalid = false; + } + + void postvisit( const ast::OffsetofExpr * ) { + // do not change valid or value => let C figure it out + cfavalid = false; + } + + void postvisit( const ast::LogicalExpr * expr ) { + std::pair arg1, arg2; + arg1 = eval( expr->arg1 ); + valid &= arg1.second; + if ( ! valid ) return; + arg2 = eval( expr->arg2 ); + valid &= arg2.second; + if ( ! valid ) return; + + if ( expr->isAnd ) { + value = arg1.first && arg2.first; + } else { + value = arg1.first || arg2.first; + } // if + } + + void postvisit( const ast::ConditionalExpr * expr ) { + std::pair arg1, arg2, arg3; + arg1 = eval( expr->arg1 ); + valid &= arg1.second; + if ( ! valid ) return; + arg2 = eval( expr->arg2 ); + valid &= arg2.second; + if ( ! valid ) return; + arg3 = eval( expr->arg3 ); + valid &= arg3.second; + if ( ! valid ) return; + + value = arg1.first ? arg2.first : arg3.first; + } + + void postvisit( const ast::CastExpr * expr ) { + // cfa-cc generates a cast before every constant and many other places, e.g., (int)3, so the cast argument must + // be evaluated to get the constant value. auto arg = eval(expr->arg); valid = arg.second; value = arg.first; - // TODO: perform type conversion on value if valid - } - - void postvisit( const ast::VariableExpr * expr ) { // No hit + cfavalid = false; + } + + void postvisit( const ast::VariableExpr * expr ) { if ( const ast::EnumInstType * inst = dynamic_cast(expr->result.get()) ) { if ( const ast::EnumDecl * decl = inst->base ) { @@ -128,47 +181,90 @@ const std::string & fname = function->name; assertf( expr->args.size() == 1 || expr->args.size() == 2, "Intrinsic function with %zd arguments: %s", expr->args.size(), fname.c_str() ); - std::pair arg1, arg2; - arg1 = eval(expr->args.front()); - valid = valid && arg1.second; - if ( ! valid ) return; - if ( expr->args.size() == 2 ) { + + if ( expr->args.size() == 1 ) { + // pre/postfix operators ++ and -- => assignment, which is not constant + std::pair arg1; + arg1 = eval(expr->args.front()); + valid &= arg1.second; + if ( ! valid ) return; + + if (fname == "+?") { + value = arg1.first; + } else if (fname == "-?") { + value = -arg1.first; + } else if (fname == "~?") { + value = ~arg1.first; + } else if (fname == "!?") { + value = ! arg1.first; + } else { + valid = false; + } // if + } else { // => expr->args.size() == 2 + // infix assignment operators => assignment, which is not constant + std::pair arg1, arg2; + arg1 = eval(expr->args.front()); + valid &= arg1.second; + if ( ! valid ) return; arg2 = eval(expr->args.back()); - valid = valid && arg2.second; - if ( ! valid ) return; - } - if (fname == "?+?") { - value = arg1.first + arg2.first; - } else if (fname == "?-?") { - value = arg1.first - arg2.first; - } else if (fname == "?*?") { - value = arg1.first * arg2.first; - } else if (fname == "?/?") { - value = arg1.first / arg2.first; - } else if (fname == "?%?") { - value = arg1.first % arg2.first; - } else { - valid = false; - } + valid &= arg2.second; + if ( ! valid ) return; + + if (fname == "?+?") { + value = arg1.first + arg2.first; + } else if (fname == "?-?") { + value = arg1.first - arg2.first; + } else if (fname == "?*?") { + value = arg1.first * arg2.first; + } else if (fname == "?/?") { + value = arg1.first / arg2.first; + } else if (fname == "?%?") { + value = arg1.first % arg2.first; + } else if (fname == "?<>?") { + value = arg1.first >> arg2.first; + } else if (fname == "??") { + value = arg1.first > arg2.first; + } else if (fname == "?<=?") { + value = arg1.first <= arg2.first; + } else if (fname == "?>=?") { + value = arg1.first >= arg2.first; + } else if (fname == "?==?") { + value = arg1.first == arg2.first; + } else if (fname == "?!=?") { + value = arg1.first != arg2.first; + } else if (fname == "?&?") { + value = arg1.first & arg2.first; + } else if (fname == "?^?") { + value = arg1.first ^ arg2.first; + } else if (fname == "?|?") { + value = arg1.first | arg2.first; + } else { + valid = false; + } + } // if // TODO: implement other intrinsic functions } }; -std::pair eval( const Expression * expr) { +std::pair eval( const Expression * expr ) { PassVisitor ev; - if (expr) { - expr->accept(ev); - return std::make_pair(ev.pass.value, ev.pass.valid); + if ( expr ) { + expr->accept( ev ); + return std::make_pair( ev.pass.value, ev.pass.valid ); } else { - return std::make_pair(0, false); + return std::make_pair( 0, false ); } } -std::pair eval(const ast::Expr * expr) { +std::pair eval( const ast::Expr * expr ) { ast::Pass ev; - if (expr) { - expr->accept(ev); - return std::make_pair(ev.core.value, ev.core.valid); + if ( expr ) { + expr->accept( ev ); + return std::make_pair( ev.core.value, ev.core.valid ); } else { - return std::make_pair(0, false); + return std::make_pair( 0, false ); } } Index: src/Common/ResolvProtoDump.cpp =================================================================== --- src/Common/ResolvProtoDump.cpp (revision 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/Common/ResolvProtoDump.cpp (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -227,5 +227,5 @@ } - void previsit( const ast::EnumInstType * enumInst) { + void previsit( const ast::EnumInstType * ) { // TODO: Add the meaningful text representation of typed enum ss << (int)ast::BasicType::SignedInt; Index: src/Concurrency/Keywords.h =================================================================== --- src/Concurrency/Keywords.h (revision 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/Concurrency/Keywords.h (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -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 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/ControlStruct/ExceptDecl.cc (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -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 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/ControlStruct/ExceptDecl.h (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -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 ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) +++ src/ControlStruct/ExceptDeclNew.cpp (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -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 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/ControlStruct/HoistControlDecls.hpp (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -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 9e23b446e321a87bbf5f2439c8d555a808d5e53c) +++ src/ControlStruct/MultiLevelExit.cpp (revision ffec1bfd5e6f76604c43a28508c5ddcc64bd3218) @@ -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