Index: src/SymTab/Autogen.cc =================================================================== --- src/SymTab/Autogen.cc (revision 6d49ea3165b7fb8906721da9a6f6949632d35140) +++ src/SymTab/Autogen.cc (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -13,4 +13,5 @@ // Update Count : 62 // + #include "Autogen.h" @@ -24,13 +25,18 @@ #include // for vector -#include "AddVisit.h" // for addVisit -#include "Common/ScopedMap.h" // for ScopedMap -#include "GenPoly/DeclMutator.h" // for DeclMutator -#include "GenPoly/ScopedSet.h" // for ScopedSet -#include "Parser/LinkageSpec.h" // for AutoGen, Intrinsic, Spec -#include "SymTab/Mangler.h" // for mangleType -#include "SynTree/Statement.h" // for SwitchStmt (ptr only), CompoundStmt -#include "SynTree/Type.h" // for Type, ArrayType, Type::StorageClasses -#include "SynTree/Visitor.h" // for Visitor +#include "AddVisit.h" // for addVisit +#include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign +#include "Common/ScopedMap.h" // for ScopedMap<>::const_iterator, Scope... +#include "Common/utility.h" // for cloneAll, operator+ +#include "GenPoly/DeclMutator.h" // for DeclMutator +#include "GenPoly/ScopedSet.h" // for ScopedSet, ScopedSet<>::iterator +#include "SymTab/Mangler.h" // for Mangler +#include "SynTree/Attribute.h" // For Attribute +#include "SynTree/Mutator.h" // for maybeMutate +#include "SynTree/Statement.h" // for CompoundStmt, ReturnStmt, ExprStmt +#include "SynTree/Type.h" // for FunctionType, Type, TypeInstType +#include "SynTree/Visitor.h" // for maybeAccept, Visitor, acceptAll + +class Attribute; namespace SymTab { @@ -130,5 +136,5 @@ FunctionType * genDefaultType( Type * paramType ) { FunctionType *ftype = new FunctionType( Type::Qualifiers(), false ); - ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), paramType->clone() ), nullptr ); + ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), paramType->clone() ), nullptr ); ftype->get_parameters().push_back( dstParam ); @@ -150,13 +156,4 @@ ftype->get_returnVals().push_back( returnVal ); return ftype; - } - - /// true if the aggregate's layout is dynamic - template< typename AggrDecl > - bool hasDynamicLayout( AggrDecl * aggregateDecl ) { - for ( TypeDecl * param : aggregateDecl->get_parameters() ) { - if ( param->isComplete() ) return true; - } - return false; } @@ -181,5 +178,6 @@ FunctionType * ftype = funcDecl->get_functionType(); assert( ! ftype->get_parameters().empty() ); - Type * t = safe_dynamic_cast< PointerType * >( ftype->get_parameters().front()->get_type() )->get_base(); + Type * t = InitTweak::getPointerBase( ftype->get_parameters().front()->get_type() ); + assert( t ); map.insert( Mangler::mangleType( t ), true ); } @@ -227,5 +225,5 @@ FunctionType * ftype = data.genType( refType ); - if(concurrent_type && InitTweak::isDestructor( data.fname )) { + if(concurrent_type && CodeGen::isDestructor( data.fname )) { ftype->get_parameters().front()->get_type()->set_mutex( true ); } @@ -279,4 +277,8 @@ FunctionType *copyCtorType = genCopyType( refType->clone() ); + // add unused attribute to parameters of default constructor and destructor + ctorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) ); + dtorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) ); + // xxx - should we also generate void ?{}(E *, int) and E ?{}(E *, E)? // right now these cases work, but that might change. @@ -301,27 +303,15 @@ /// generates a single struct member operation (constructor call, destructor call, assignment call) - void makeStructMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool isDynamicLayout, bool forward = true ) { - ObjectDecl * returnVal = NULL; - if ( ! func->get_functionType()->get_returnVals().empty() ) { - returnVal = dynamic_cast( func->get_functionType()->get_returnVals().front() ); - } - + void makeStructMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool forward = true ) { InitTweak::InitExpander srcParam( src ); - // assign to destination (and return value if generic) - UntypedExpr *derefExpr = UntypedExpr::createDeref( new VariableExpr( dstParam ) ); - Expression *dstselect = new MemberExpr( field, derefExpr ); + // assign to destination + Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), safe_dynamic_cast< ReferenceType* >( dstParam->get_type() )->get_base()->clone() ) ); genImplicitCall( srcParam, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward ); - - if ( isDynamicLayout && returnVal ) { - // xxx - there used to be a dereference on returnVal, but this seems to have been wrong? - Expression *retselect = new MemberExpr( field, new VariableExpr( returnVal ) ); - genImplicitCall( srcParam, retselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward ); - } // if } /// generates the body of a struct function by iterating the struct members (via parameters) - generates default ctor, copy ctor, assignment, and dtor bodies, but NOT field ctor bodies template - void makeStructFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool isDynamicLayout, bool forward = true ) { + void makeStructFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool forward = true ) { for ( ; member != end; ++member ) { if ( DeclarationWithType *field = dynamic_cast< DeclarationWithType * >( *member ) ) { // otherwise some form of type declaration, e.g. Aggregate @@ -359,5 +349,5 @@ Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : NULL; - makeStructMemberOp( dstParam, srcselect, field, func, isDynamicLayout, forward ); + makeStructMemberOp( dstParam, srcselect, field, func, forward ); } // if } // for @@ -367,5 +357,5 @@ /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields. template - void makeStructFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func, bool isDynamicLayout ) { + void makeStructFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func ) { FunctionType * ftype = func->get_functionType(); std::list & params = ftype->get_parameters(); @@ -393,9 +383,9 @@ // matching parameter, initialize field with copy ctor Expression *srcselect = new VariableExpr(*parameter); - makeStructMemberOp( dstParam, srcselect, field, func, isDynamicLayout ); + makeStructMemberOp( dstParam, srcselect, field, func ); ++parameter; } else { // no matching parameter, initialize field with default ctor - makeStructMemberOp( dstParam, NULL, field, func, isDynamicLayout ); + makeStructMemberOp( dstParam, NULL, field, func ); } } @@ -413,5 +403,4 @@ // Make function polymorphic in same parameters as generic struct, if applicable const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions - bool isDynamicLayout = hasDynamicLayout( aggregateDecl ); // NOTE this flag is an incredibly ugly kludge; we should fix the assignment signature instead (ditto for union) // generate each of the functions based on the supplied FuncData objects @@ -423,5 +412,5 @@ // field ctors are only generated if default constructor and copy constructor are both generated - unsigned numCtors = std::count_if( newFuncs.begin(), newFuncs.end(), [](FunctionDecl * dcl) { return InitTweak::isConstructor( dcl->get_name() ); } ); + unsigned numCtors = std::count_if( newFuncs.begin(), newFuncs.end(), [](FunctionDecl * dcl) { return CodeGen::isConstructor( dcl->get_name() ); } ); if ( functionNesting == 0 ) { @@ -438,10 +427,10 @@ // generate appropriate calls to member ctor, assignment // destructor needs to do everything in reverse, so pass "forward" based on whether the function is a destructor - if ( ! InitTweak::isDestructor( dcl->get_name() ) ) { - makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), dcl, isDynamicLayout ); + if ( ! CodeGen::isDestructor( dcl->get_name() ) ) { + makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), dcl ); } else { - makeStructFunctionBody( aggregateDecl->get_members().rbegin(), aggregateDecl->get_members().rend(), dcl, isDynamicLayout, false ); - } - if ( InitTweak::isAssignment( dcl->get_name() ) ) { + makeStructFunctionBody( aggregateDecl->get_members().rbegin(), aggregateDecl->get_members().rend(), dcl, false ); + } + if ( CodeGen::isAssignment( dcl->get_name() ) ) { // assignment needs to return a value FunctionType * assignType = dcl->get_functionType(); @@ -472,12 +461,10 @@ // our inheritance model. I think the correct way to handle this is to // cast the structure to the type of the member and let the resolver - // figure out whether it's valid and have a pass afterwards that fixes - // the assignment to use pointer arithmetic with the offset of the - // member, much like how generic type members are handled. + // figure out whether it's valid/choose the correct unnamed member continue; } memCtorType->get_parameters().push_back( new ObjectDecl( member->get_name(), Type::StorageClasses(), LinkageSpec::Cforall, 0, member->get_type()->clone(), 0 ) ); FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting ); - makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor, isDynamicLayout ); + makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor ); declsToAdd.push_back( ctor ); } @@ -490,5 +477,5 @@ void makeUnionFieldsAssignment( ObjectDecl * srcParam, ObjectDecl * dstParam, OutputIterator out ) { UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) ); - copy->get_args().push_back( new VariableExpr( dstParam ) ); + copy->get_args().push_back( new AddressExpr( new VariableExpr( dstParam ) ) ); copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) ); copy->get_args().push_back( new SizeofExpr( srcParam->get_type()->clone() ) ); @@ -502,11 +489,8 @@ ObjectDecl * dstParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() ); ObjectDecl * srcParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() ); - ObjectDecl * returnVal = nullptr; - if ( ! ftype->get_returnVals().empty() ) { - returnVal = safe_dynamic_cast< ObjectDecl * >( ftype->get_returnVals().front() ); - } makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( funcDecl->get_statements()->get_kids() ) ); - if ( returnVal ) { + if ( CodeGen::isAssignment( funcDecl->get_name() ) ) { + // also generate return statement in assignment funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) ); } @@ -535,4 +519,8 @@ cloneAll( typeParams, copyCtorType->get_forall() ); cloneAll( typeParams, assignType->get_forall() ); + + // add unused attribute to parameters of default constructor and destructor + ctorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) ); + dtorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) ); // Routines at global scope marked "static" to prevent multiple definitions is separate translation units Index: src/SymTab/Autogen.h =================================================================== --- src/SymTab/Autogen.h (revision 6d49ea3165b7fb8906721da9a6f6949632d35140) +++ src/SymTab/Autogen.h (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -40,4 +40,11 @@ extern Type * SizeType; + /// intrinsic dereference operator for unqualified types - set when *? function is seen in FindSpecialDeclarations. + /// Useful for creating dereference ApplicationExprs without a full resolver pass. + extern FunctionDecl * dereferenceOperator; + + // temporary + FunctionType * genAssignType( Type * paramType ); + /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. template< typename OutputIterator > @@ -48,35 +55,33 @@ template< typename OutputIterator > Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) { - // want to be able to generate assignment, ctor, and dtor generically, - // so fname is either ?=?, ?{}, or ^?{} - UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) ); + // want to be able to generate assignment, ctor, and dtor generically, + // so fname is either ?=?, ?{}, or ^?{} + UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) ); - // do something special for unnamed members - dstParam = new AddressExpr( dstParam ); - if ( addCast ) { - // cast to T* with qualifiers removed, so that qualified objects can be constructed - // and destructed with the same functions as non-qualified objects. - // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument - // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever - // remove lvalue as a qualifier, this can change to - // type->get_qualifiers() = Type::Qualifiers(); - assert( type ); - Type * castType = type->clone(); - castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic ); - castType->set_lvalue( true ); // xxx - might not need this - dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) ); - } - fExpr->get_args().push_back( dstParam ); + if ( addCast ) { + // cast to T& with qualifiers removed, so that qualified objects can be constructed + // and destructed with the same functions as non-qualified objects. + // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument + // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever + // remove lvalue as a qualifier, this can change to + // type->get_qualifiers() = Type::Qualifiers(); + assert( type ); + Type * castType = type->clone(); + castType->get_qualifiers() -= Type::Qualifiers( Type::Lvalue | Type::Const | Type::Volatile | Type::Restrict | Type::Atomic ); + // castType->set_lvalue( true ); // xxx - might not need this + dstParam = new CastExpr( dstParam, new ReferenceType( Type::Qualifiers(), castType ) ); + } + fExpr->get_args().push_back( dstParam ); - Statement * listInit = srcParam.buildListInit( fExpr ); + Statement * listInit = srcParam.buildListInit( fExpr ); - std::list< Expression * > args = *++srcParam; - fExpr->get_args().splice( fExpr->get_args().end(), args ); + std::list< Expression * > args = *++srcParam; + fExpr->get_args().splice( fExpr->get_args().end(), args ); - *out++ = new ExprStmt( noLabels, fExpr ); + *out++ = new ExprStmt( noLabels, fExpr ); - srcParam.clearArrayIndices(); + srcParam.clearArrayIndices(); - return listInit; + return listInit; } @@ -114,5 +119,5 @@ UntypedExpr *inc = new UntypedExpr( update ); - inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) ); + inc->get_args().push_back( new VariableExpr( index ) ); UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) ); Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision 6d49ea3165b7fb8906721da9a6f6949632d35140) +++ src/SymTab/Indexer.cc (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -23,4 +23,5 @@ #include // for pair, make_pair, move +#include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign #include "Common/SemanticError.h" // for SemanticError #include "Common/utility.h" // for cloneAll @@ -111,5 +112,5 @@ void Indexer::removeSpecialOverrides( const std::string &id, std::list< DeclarationWithType * > & out ) const { // only need to perform this step for constructors, destructors, and assignment functions - if ( ! InitTweak::isCtorDtorAssign( id ) ) return; + if ( ! CodeGen::isCtorDtorAssign( id ) ) return; // helpful data structure @@ -139,5 +140,5 @@ decls.push_back( DeclBall{ function, isUserDefinedFunc, isDefaultCtor, isDtor, isCopyFunc } ); existsUserDefinedFunc = existsUserDefinedFunc || isUserDefinedFunc; - existsUserDefinedCtor = existsUserDefinedCtor || (isUserDefinedFunc && InitTweak::isConstructor( function->get_name() ) ); + existsUserDefinedCtor = existsUserDefinedCtor || (isUserDefinedFunc && CodeGen::isConstructor( function->get_name() ) ); existsUserDefinedDtor = existsUserDefinedDtor || (isUserDefinedFunc && isDtor); existsUserDefinedCopyFunc = existsUserDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc); @@ -157,5 +158,6 @@ assert( ! params.empty() ); // use base type of pointer, so that qualifiers on the pointer type aren't considered. - Type * base = safe_dynamic_cast< PointerType * >( params.front()->get_type() )->get_base(); + Type * base = InitTweak::getPointerBase( params.front()->get_type() ); + assert( base ); funcMap[ Mangler::mangle( base ) ] += function; } else { Index: src/SymTab/Mangler.cc =================================================================== --- src/SymTab/Mangler.cc (revision 6d49ea3165b7fb8906721da9a6f6949632d35140) +++ src/SymTab/Mangler.cc (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -132,4 +132,10 @@ mangleName << "A0"; maybeAccept( arrayType->get_base(), *this ); + } + + void Mangler::visit( ReferenceType *refType ) { + printQualifiers( refType ); + mangleName << "R"; + maybeAccept( refType->get_base(), *this ); } @@ -303,5 +309,5 @@ // Removed due to restrict not affecting function compatibility in GCC // if ( type->get_isRestrict() ) { -// mangleName << "R"; +// mangleName << "E"; // } // if if ( type->get_lvalue() ) { Index: src/SymTab/Mangler.h =================================================================== --- src/SymTab/Mangler.h (revision 6d49ea3165b7fb8906721da9a6f6949632d35140) +++ src/SymTab/Mangler.h (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -42,4 +42,5 @@ virtual void visit( PointerType *pointerType ); virtual void visit( ArrayType *arrayType ); + virtual void visit( ReferenceType *refType ); virtual void visit( FunctionType *functionType ); virtual void visit( StructInstType *aggregateUseType ); Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision 6d49ea3165b7fb8906721da9a6f6949632d35140) +++ src/SymTab/Validate.cc (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -47,4 +47,5 @@ #include "CodeGen/CodeGenerator.h" // for genName +#include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign #include "Common/PassVisitor.h" // for PassVisitor, WithDeclsToAdd #include "Common/ScopedMap.h" // for ScopedMap @@ -239,4 +240,10 @@ }; + + FunctionDecl * dereferenceOperator = nullptr; + struct FindSpecialDeclarations final { + void previsit( FunctionDecl * funcDecl ); + }; + void validate( std::list< Declaration * > &translationUnit, bool doDebug ) { PassVisitor epc; @@ -245,4 +252,5 @@ PassVisitor compoundliteral; PassVisitor genericParams; + PassVisitor finder; EliminateTypedef::eliminateTypedef( translationUnit ); @@ -261,4 +269,5 @@ acceptAll( translationUnit, fpd ); ArrayLength::computeLength( translationUnit ); + acceptAll( translationUnit, finder ); } @@ -821,13 +830,13 @@ std::list< DeclarationWithType * > ¶ms = funcType->get_parameters(); - if ( InitTweak::isCtorDtorAssign( funcDecl->get_name() ) ) { + if ( CodeGen::isCtorDtorAssign( funcDecl->get_name() ) ) { // TODO: also check /=, etc. if ( params.size() == 0 ) { throw SemanticError( "Constructors, destructors, and assignment functions require at least one parameter ", funcDecl ); } - PointerType * ptrType = dynamic_cast< PointerType * >( params.front()->get_type() ); - if ( ! ptrType || ptrType->is_array() ) { - throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a pointer ", funcDecl ); + ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() ); + if ( ! refType ) { + throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a reference ", funcDecl ); } - if ( InitTweak::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) { + if ( CodeGen::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) { throw SemanticError( "Constructors and destructors cannot have explicit return values ", funcDecl ); } @@ -945,4 +954,15 @@ } } + + void FindSpecialDeclarations::previsit( FunctionDecl * funcDecl ) { + if ( ! dereferenceOperator ) { + if ( funcDecl->get_name() == "*?" && funcDecl->get_linkage() == LinkageSpec::Intrinsic ) { + FunctionType * ftype = funcDecl->get_functionType(); + if ( ftype->get_parameters().size() == 1 && ftype->get_parameters().front()->get_type()->get_qualifiers() == Type::Qualifiers() ) { + dereferenceOperator = funcDecl; + } + } + } + } } // namespace SymTab