Index: src/AST/CVQualifiers.hpp =================================================================== --- src/AST/CVQualifiers.hpp (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/AST/CVQualifiers.hpp (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -27,12 +27,11 @@ Restrict = 1 << 1, Volatile = 1 << 2, - Lvalue = 1 << 3, - Mutex = 1 << 4, - Atomic = 1 << 5, - NumQualifiers = 6 + Mutex = 1 << 3, + Atomic = 1 << 4, + NumQualifiers = 5 }; /// Mask for equivalence-preserving qualfiers - enum { EquivQualifiers = ~(Restrict | Lvalue) }; + enum { EquivQualifiers = ~Restrict }; /// Underlying data for qualifiers @@ -44,5 +43,4 @@ bool is_restrict : 1; bool is_volatile : 1; - bool is_lvalue : 1; bool is_mutex : 1; bool is_atomic : 1; Index: src/AST/Expr.cpp =================================================================== --- src/AST/Expr.cpp (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/AST/Expr.cpp (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -10,6 +10,6 @@ // Created On : Wed May 15 17:00:00 2019 // Last Modified By : Andrew Beach -// Created On : Thr Jun 26 12:12:00 2019 -// Update Count : 3 +// Created On : Fri Oct 4 15:34:00 2019 +// Update Count : 4 // @@ -82,5 +82,4 @@ // base type ret->result = base; - add_qualifiers( ret->result, CV::Lvalue ); } } @@ -131,5 +130,4 @@ // lvalue, retains all levels of reference, and gains a pointer inside the references Type * res = addrType( arg->result ); - res->set_lvalue( false ); // result of & is never an lvalue result = res; } else { @@ -138,5 +136,4 @@ dynamic_cast< const ReferenceType * >( arg->result.get() ) ) { Type * res = addrType( refType->base ); - res->set_lvalue( false ); // result of & is never an lvalue result = res; } else { @@ -230,6 +227,6 @@ // substitute aggregate generic parameters into member type genericSubstitution( aggregate->result ).apply( result ); - // ensure lvalue and appropriate restrictions from aggregate type - add_qualifiers( result, aggregate->result->qualifiers | CV::Lvalue ); + // ensure appropriate restrictions from aggregate type + add_qualifiers( result, aggregate->result->qualifiers ); } @@ -257,7 +254,5 @@ assert( var ); assert( var->get_type() ); - auto r = shallowCopy( var->get_type() ); - r->qualifiers |= CV::Lvalue; - result = r; + result = shallowCopy( var->get_type() ); } @@ -376,5 +371,4 @@ assert( t && i ); result = t; - add_qualifiers( result, CV::Lvalue ); } @@ -397,5 +391,4 @@ // like MemberExpr, TupleIndexExpr is always an lvalue result = type->types[ index ]; - add_qualifiers( result, CV::Lvalue ); } Index: src/AST/Type.hpp =================================================================== --- src/AST/Type.hpp (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/AST/Type.hpp (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -51,5 +51,4 @@ bool is_volatile() const { return qualifiers.is_volatile; } bool is_restrict() const { return qualifiers.is_restrict; } - bool is_lvalue() const { return qualifiers.is_lvalue; } bool is_mutex() const { return qualifiers.is_mutex; } bool is_atomic() const { return qualifiers.is_atomic; } @@ -58,5 +57,4 @@ Type * set_volatile( bool v ) { qualifiers.is_volatile = v; return this; } Type * set_restrict( bool v ) { qualifiers.is_restrict = v; return this; } - Type * set_lvalue( bool v ) { qualifiers.is_lvalue = v; return this; } Type * set_mutex( bool v ) { qualifiers.is_mutex = v; return this; } Type * set_atomic( bool v ) { qualifiers.is_atomic = v; return this; } Index: src/CodeGen/GenType.cc =================================================================== --- src/CodeGen/GenType.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/CodeGen/GenType.cc (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -335,8 +335,4 @@ typeString = "_Atomic " + typeString; } // if - if ( type->get_lvalue() && ! options.genC ) { - // when not generating C code, print lvalue for debugging. - typeString = "lvalue " + typeString; - } } } // namespace CodeGen Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/GenPoly/Box.cc (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -837,5 +837,4 @@ deref->args.push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) ); deref->result = arg->get_type()->clone(); - deref->result->set_lvalue( true ); return deref; } // if Index: src/GenPoly/Lvalue.cc =================================================================== --- src/GenPoly/Lvalue.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/GenPoly/Lvalue.cc (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -54,5 +54,4 @@ delete ret->result; ret->result = base->clone(); - ret->result->set_lvalue( true ); return ret; } else { @@ -167,5 +166,4 @@ ReferenceType * result = strict_dynamic_cast< ReferenceType * >( appExpr->result ); appExpr->result = result->base->clone(); - appExpr->result->set_lvalue( true ); if ( ! inIntrinsic ) { // when not in an intrinsic function, add a cast to @@ -436,5 +434,5 @@ delete ret->result; ret->result = castExpr->result; - ret->result->set_lvalue( true ); // ensure result is lvalue + assert( ret->get_lvalue() ); // ensure result is lvalue castExpr->env = nullptr; castExpr->arg = nullptr; Index: src/Makefile.in =================================================================== --- src/Makefile.in (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/Makefile.in (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -232,5 +232,5 @@ SynTree/Initializer.$(OBJEXT) \ SynTree/TypeSubstitution.$(OBJEXT) SynTree/Attribute.$(OBJEXT) \ - SynTree/DeclReplacer.$(OBJEXT) SynTree/TopLvalue.$(OBJEXT) + SynTree/DeclReplacer.$(OBJEXT) am__objects_8 = CompilationState.$(OBJEXT) $(am__objects_1) \ $(am__objects_2) Concurrency/Keywords.$(OBJEXT) \ @@ -698,6 +698,5 @@ SynTree/TypeSubstitution.cc \ SynTree/Attribute.cc \ - SynTree/DeclReplacer.cc \ - SynTree/TopLvalue.cc + SynTree/DeclReplacer.cc @@ -1030,6 +1029,4 @@ SynTree/DeclReplacer.$(OBJEXT): SynTree/$(am__dirstamp) \ SynTree/$(DEPDIR)/$(am__dirstamp) -SynTree/TopLvalue.$(OBJEXT): SynTree/$(am__dirstamp) \ - SynTree/$(DEPDIR)/$(am__dirstamp) Tuples/$(am__dirstamp): @$(MKDIR_P) Tuples @@ -1343,5 +1340,4 @@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/ReferenceType.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/Statement.Po@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/TopLvalue.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/TupleExpr.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/TupleType.Po@am__quote@ Index: src/ResolvExpr/ResolveAssertions.cc =================================================================== --- src/ResolvExpr/ResolveAssertions.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/ResolvExpr/ResolveAssertions.cc (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -156,5 +156,4 @@ for ( const auto& assn : x.assns ) { // compute conversion cost from satisfying decl to assertion - assert( !assn.match.adjType->get_lvalue() ); k += computeConversionCost( assn.match.adjType, assn.decl->get_type(), false, indexer, x.env ); Index: src/SymTab/Autogen.h =================================================================== --- src/SymTab/Autogen.h (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/SymTab/Autogen.h (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -98,5 +98,5 @@ // type->get_qualifiers() = Type::Qualifiers(); Type * castType = addCast->clone(); - castType->get_qualifiers() -= Type::Qualifiers( Type::Lvalue | Type::Const | Type::Volatile | Type::Restrict | Type::Atomic ); + 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 ReferenceType( Type::Qualifiers(), castType ) ); Index: src/SymTab/ManglerCommon.cc =================================================================== --- src/SymTab/ManglerCommon.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/SymTab/ManglerCommon.cc (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -88,5 +88,4 @@ { Type::Atomic, "DA" }, // A is array, so need something unique for atmoic. For now, go with multiletter DA { Type::Mutex, "X" }, - { Type::Lvalue, "L" }, }; Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/SymTab/Validate.cc (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -81,5 +81,4 @@ #include "SynTree/Label.h" // for operator==, Label #include "SynTree/Mutator.h" // for Mutator -#include "SynTree/TopLvalue.h" // for assertTopLvalue, clearInnerLvalue #include "SynTree/Type.h" // for Type, TypeInstType, EnumInstType #include "SynTree/TypeSubstitution.h" // for TypeSubstitution @@ -309,5 +308,4 @@ PassVisitor fixQual; - assertTopLvalue( translationUnit ); { Stats::Heap::newPass("validate-A"); @@ -318,27 +316,20 @@ acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes_old because it is an indexer and needs correct types for mangling } - assertTopLvalue( translationUnit ); { Stats::Heap::newPass("validate-B"); Stats::Time::BlockGuard guard("validate-B"); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Link Reference To Types", [&]() { acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions }); - clearInnerLvalue( translationUnit ); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Fix Qualified Types", [&]() { mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes_old, because aggregate members are accessed }); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Hoist Structs", [&]() { HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order }); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Eliminate Typedefs", [&]() { EliminateTypedef::eliminateTypedef( translationUnit ); // }); } - assertTopLvalue( translationUnit ); { Stats::Heap::newPass("validate-C"); @@ -349,77 +340,55 @@ InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen } - assertTopLvalue( translationUnit ); { Stats::Heap::newPass("validate-D"); Stats::Time::BlockGuard guard("validate-D"); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Apply Concurrent Keywords", [&]() { Concurrency::applyKeywords( translationUnit ); }); - clearInnerLvalue( translationUnit ); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Forall Pointer Decay", [&]() { acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution }); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Hoist Control Declarations", [&]() { ControlStruct::hoistControlDecls( translationUnit ); // hoist initialization out of for statements; must happen before autogenerateRoutines }); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Generate Autogen routines", [&]() { autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay_old }); - clearInnerLvalue( translationUnit ); - } - assertTopLvalue( translationUnit ); + } { Stats::Heap::newPass("validate-E"); Stats::Time::BlockGuard guard("validate-E"); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Implement Mutex Func", [&]() { Concurrency::implementMutexFuncs( translationUnit ); }); - clearInnerLvalue( translationUnit ); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Implement Thread Start", [&]() { Concurrency::implementThreadStarter( translationUnit ); }); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Compound Literal", [&]() { mutateAll( translationUnit, compoundliteral ); }); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Resolve With Expressions", [&]() { ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables }); - clearInnerLvalue( translationUnit ); - } - assertTopLvalue( translationUnit ); + } { Stats::Heap::newPass("validate-F"); Stats::Time::BlockGuard guard("validate-F"); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Fix Object Type", [&]() { FixObjectType::fix( translationUnit ); }); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Array Length", [&]() { ArrayLength::computeLength( translationUnit ); }); - clearInnerLvalue( translationUnit ); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Find Special Declarations", [&]() { Validate::findSpecialDecls( translationUnit ); }); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Fix Label Address", [&]() { mutateAll( translationUnit, labelAddrFixer ); }); - assertTopLvalue( translationUnit ); Stats::Time::TimeBlock("Handle Attributes", [&]() { Validate::handleAttributes( translationUnit ); }); } - assertTopLvalue( translationUnit ); } @@ -1334,5 +1303,4 @@ void FixObjectType::previsit( ObjectDecl * objDecl ) { Type * new_type = ResolvExpr::resolveTypeof( objDecl->get_type(), indexer ); - new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type objDecl->set_type( new_type ); } @@ -1340,5 +1308,4 @@ void FixObjectType::previsit( FunctionDecl * funcDecl ) { Type * new_type = ResolvExpr::resolveTypeof( funcDecl->type, indexer ); - new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type funcDecl->set_type( new_type ); } @@ -1347,5 +1314,4 @@ if ( typeDecl->get_base() ) { Type * new_type = ResolvExpr::resolveTypeof( typeDecl->get_base(), indexer ); - new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type typeDecl->set_base( new_type ); } // if Index: src/SynTree/AddressExpr.cc =================================================================== --- src/SynTree/AddressExpr.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/SynTree/AddressExpr.cc (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -53,6 +53,4 @@ } // if } - // result of & is never an lvalue - get_result()->set_lvalue( false ); } } Index: src/SynTree/ArrayType.cc =================================================================== --- src/SynTree/ArrayType.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/SynTree/ArrayType.cc (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -26,5 +26,4 @@ ArrayType::ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), base( base ), dimension( dimension ), isVarLen( isVarLen ), isStatic( isStatic ) { - base->set_lvalue( false ); } Index: src/SynTree/CommaExpr.cc =================================================================== --- src/SynTree/CommaExpr.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/SynTree/CommaExpr.cc (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -23,9 +23,5 @@ CommaExpr::CommaExpr( Expression *arg1, Expression *arg2 ) : Expression(), arg1( arg1 ), arg2( arg2 ) { - // xxx - result of a comma expression is never an lvalue, so should set lvalue - // to false on all result types. Actually doing this causes some strange things - // to happen in later passes (particularly, Specialize, Lvalue, and Box). This needs to be looked into. set_result( maybeClone( arg2->get_result() ) ); - // get_type->set_isLvalue( false ); } @@ -41,4 +37,5 @@ bool CommaExpr::get_lvalue() const { // This is wrong by C, but the current implementation uses it. + // (ex: Specialize, Lvalue and Box) return arg2->get_lvalue(); } Index: src/SynTree/Expression.cc =================================================================== --- src/SynTree/Expression.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/SynTree/Expression.cc (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -115,5 +115,4 @@ assert( var->get_type() ); Type * type = var->get_type()->clone(); - type->set_lvalue( true ); // xxx - doesn't quite work yet - get different alternatives with the same cost @@ -125,5 +124,5 @@ // long long int value; // if ( decl->valueOf( var, value ) ) { - // type->set_lvalue( false ); + // type->set_lvalue( false ); // Would have to move to get_lvalue. // } // } @@ -384,5 +383,4 @@ sub.apply( res ); result = res; - result->set_lvalue( true ); result->get_qualifiers() |= aggregate->result->get_qualifiers(); } @@ -433,7 +431,4 @@ // if references are still allowed in the AST, dereference returns a reference ret->set_result( new ReferenceType( Type::Qualifiers(), ret->get_result() ) ); - } else { - // references have been removed, in which case dereference returns an lvalue of the base type. - ret->result->set_lvalue( true ); } } @@ -591,5 +586,4 @@ CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : initializer( initializer ) { assert( type && initializer ); - type->set_lvalue( true ); set_result( type ); } Index: c/SynTree/TopLvalue.cc =================================================================== --- src/SynTree/TopLvalue.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ (revision ) @@ -1,132 +1,0 @@ -// -// 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. -// -// TopLvalue.cc -- Check and force that lvalue is only at the top of types. -// -// Author : Andrew Beach -// Created On : Wed Jul 31 15:49:00 2019 -// Last Modified By : Andrew Beach -// Last Modified On : Wed Aug 7 15:36:00 2019 -// Update Count : 0 -// - -#include - -#include "Common/PassVisitor.h" - -namespace { - class TopLvalue : public WithGuards { - bool inType = false; - public: - void previsit( const BaseSyntaxNode * ) { - if ( inType ) { - GuardValue( inType ); - inType = false; - } - } - - void previsit( const Type * type ) { - if ( inType ) { - assert( !type->get_lvalue() ); - } else { - GuardValue( inType ); - inType = true; - } - } - - }; - - class ClearLvalue : public WithGuards { - bool inType = false; - public: - void previsit( BaseSyntaxNode * ) { - if ( inType ) { - GuardValue( inType ); - inType = false; - } - } - - void previsit( Type * type ) { - if ( !inType ) { - GuardValue( inType ); - inType = true; - } else if ( type->get_lvalue() ) { - type->set_lvalue( false ); - } - } - }; - - class TopLvaluePrint : public WithGuards, public WithShortCircuiting { - bool failed = false; - bool inType = false; - bool typeTop = false; - public: - bool failedAny = false; - void previsit() { - if ( failed ) { - visit_children = false; - } else if ( typeTop ) { - GuardValue( typeTop ); - typeTop = false; - } - } - - void previsit( const BaseSyntaxNode * ) { - previsit(); - if ( inType ) { - GuardValue( inType ); - inType = false; - } - } - - void previsit( const Type * type ) { - previsit(); - if ( inType ) { - if ( type->get_lvalue() ) { - failed = true; - failedAny = true; - visit_children = false; - std::cout << type->location << std::endl; - } - //assert( !type->get_lvalue() ); - } else { - GuardValue( inType ); - inType = true; - typeTop = true; - } - } - - void postvisit( const Type * type ) { - if ( typeTop ) { - if ( failed ) { - std::cout << type->location << std::endl; - type->print( std::cout ); - //assert( !failed ); - failed = false; - } - typeTop = false; - } - } - }; -} - -void assertTopLvalue( const std::list< Declaration * > & translationUnit ) { - PassVisitor< TopLvaluePrint > visitor; - acceptAll( translationUnit, visitor ); - assert( !visitor.pass.failedAny ); -} - -void clearInnerLvalue( std::list< Declaration * > & translationUnit ) { - PassVisitor< ClearLvalue > visitor; - acceptAll( translationUnit, visitor ); -} - - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: c/SynTree/TopLvalue.h =================================================================== --- src/SynTree/TopLvalue.h (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ (revision ) @@ -1,34 +1,0 @@ -// -// 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. -// -// TopLvalue.h -- Check and force that lvalue is only at the top of types. -// -// Author : Andrew Beach -// Created On : Wed Jul 31 16:04:00 2019 -// Last Modified By : Andrew Beach -// Last Modified On : Wed Aug 7 15:26:00 2019 -// Update Count : 0 -// - -#include -class Declaration; - -void assertTopLvalue( const std::list< Declaration * > & translationUnit ); -/* Assert that all lvalue qualifiers are set on the top level. - * - * Does not return if the test fails. - */ - -void clearInnerLvalue( std::list< Declaration * > & translationUnit ); -/* Make all types that are not at the top level rvalues (not-lvalues). - */ - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // - Index: src/SynTree/TupleExpr.cc =================================================================== --- src/SynTree/TupleExpr.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/SynTree/TupleExpr.cc (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -71,6 +71,4 @@ assertf( type->size() > index, "TupleIndexExpr index out of bounds: tuple size %d, requested index %d in expr %s", type->size(), index, toString( tuple ).c_str() ); set_result( (*std::next( type->get_types().begin(), index ))->clone() ); - // like MemberExpr, TupleIndexExpr is always an lvalue - get_result()->set_lvalue( true ); } Index: src/SynTree/Type.cc =================================================================== --- src/SynTree/Type.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/SynTree/Type.cc (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -85,5 +85,5 @@ const char * Type::FuncSpecifiersNames[] = { "inline", "_Noreturn", "fortran" }; const char * Type::StorageClassesNames[] = { "extern", "static", "auto", "register", "_Thread_local" }; -const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic" }; +const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "mutex", "_Atomic" }; Type * Type::stripDeclarator() { Index: src/SynTree/Type.h =================================================================== --- src/SynTree/Type.h (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/SynTree/Type.h (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -102,8 +102,8 @@ }; // StorageClasses - enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Lvalue = 1 << 3, Mutex = 1 << 4, Atomic = 1 << 5, NumTypeQualifier = 6 }; + enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Mutex = 1 << 3, Atomic = 1 << 4, NumTypeQualifier = 5 }; static const char * QualifiersNames[]; union Qualifiers { - enum { Mask = ~(Restrict | Lvalue) }; + enum { Mask = ~Restrict }; unsigned int val; struct { @@ -111,5 +111,4 @@ bool is_restrict : 1; bool is_volatile : 1; - bool is_lvalue : 1; bool is_mutex : 1; bool is_atomic : 1; @@ -153,5 +152,4 @@ bool get_volatile() const { return tq.is_volatile; } bool get_restrict() const { return tq.is_restrict; } - bool get_lvalue() const { return tq.is_lvalue; } bool get_mutex() const { return tq.is_mutex; } bool get_atomic() const { return tq.is_atomic; } @@ -159,5 +157,4 @@ void set_volatile( bool newValue ) { tq.is_volatile = newValue; } void set_restrict( bool newValue ) { tq.is_restrict = newValue; } - void set_lvalue( bool newValue ) { tq.is_lvalue = newValue; } void set_mutex( bool newValue ) { tq.is_mutex = newValue; } void set_atomic( bool newValue ) { tq.is_atomic = newValue; } Index: src/SynTree/module.mk =================================================================== --- src/SynTree/module.mk (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/SynTree/module.mk (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -49,6 +49,5 @@ SynTree/TypeSubstitution.cc \ SynTree/Attribute.cc \ - SynTree/DeclReplacer.cc \ - SynTree/TopLvalue.cc + SynTree/DeclReplacer.cc SRC += $(SRC_SYNTREE) Index: src/Tuples/TupleExpansion.cc =================================================================== --- src/Tuples/TupleExpansion.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/Tuples/TupleExpansion.cc (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Andrew Beach -// Last Modified On : Fri Jul 19 14:39:00 2019 -// Update Count : 22 +// Last Modified On : Fri Oct 4 15:38:00 2019 +// Update Count : 23 // @@ -304,5 +304,5 @@ // produce the TupleType which aggregates the types of the exprs std::list< Type * > types; - Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex ); + Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic | Type::Mutex ); for ( Expression * expr : exprs ) { assert( expr->get_result() ); @@ -323,5 +323,5 @@ std::vector> types; ast::CV::Qualifiers quals{ - ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Lvalue | + ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Atomic | ast::CV::Mutex }; Index: src/main.cc =================================================================== --- src/main.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) +++ src/main.cc (revision 3f3bfe5a8343901bfbae18ba2a227bf47060ed62) @@ -60,5 +60,4 @@ #include "ResolvExpr/Resolver.h" // for resolve #include "SymTab/Validate.h" // for validate -#include "SynTree/TopLvalue.h" // for assertTopLvalue, clearInn... #include "SynTree/Declaration.h" // for Declaration #include "SynTree/Visitor.h" // for acceptAll @@ -260,8 +259,4 @@ Stats::Time::StopBlock(); - //std::cerr << "Post-Parse Check" << std::endl; - clearInnerLvalue( translationUnit ); - assertTopLvalue( translationUnit ); - // add the assignment statement after the initialization of a type parameter PASS( "Validate", SymTab::validate( translationUnit, symtabp ) ); @@ -282,13 +277,8 @@ } // if - assertTopLvalue( translationUnit ); PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) ); - assertTopLvalue( translationUnit ); PASS( "Fix Names", CodeGen::fixNames( translationUnit ) ); - assertTopLvalue( translationUnit ); PASS( "Gen Init", InitTweak::genInit( translationUnit ) ); - assertTopLvalue( translationUnit ); PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( translationUnit ) ); - assertTopLvalue( translationUnit ); if ( libcfap ) { // generate the bodies of cfa library functions @@ -326,11 +316,6 @@ } // if - clearInnerLvalue( translationUnit ); - assertTopLvalue( translationUnit ); - // fix ObjectDecl - replaces ConstructorInit nodes PASS( "Fix Init", InitTweak::fix( translationUnit, buildingLibrary() ) ); - clearInnerLvalue( translationUnit ); - assertTopLvalue( translationUnit ); if ( ctorinitp ) { dump ( translationUnit ); @@ -339,19 +324,12 @@ PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused - assertTopLvalue( translationUnit ); PASS( "Translate EHM" , ControlStruct::translateEHM( translationUnit ) ); - assertTopLvalue( translationUnit ); PASS( "Gen Waitfor" , Concurrency::generateWaitFor( translationUnit ) ); - clearInnerLvalue( translationUnit ); - assertTopLvalue( translationUnit ); PASS( "Convert Specializations", GenPoly::convertSpecializations( translationUnit ) ); // needs to happen before tuple types are expanded - clearInnerLvalue( translationUnit ); - assertTopLvalue( translationUnit ); PASS( "Expand Tuples", Tuples::expandTuples( translationUnit ) ); // xxx - is this the right place for this? - assertTopLvalue( translationUnit ); if ( tuplep ) { @@ -361,5 +339,4 @@ PASS( "Virtual Expand Casts", Virtual::expandCasts( translationUnit ) ); // Must come after translateEHM - assertTopLvalue( translationUnit ); PASS( "Instantiate Generics", GenPoly::instantiateGeneric( translationUnit ) ); @@ -368,9 +345,6 @@ return EXIT_SUCCESS; } // if - clearInnerLvalue( translationUnit ); - assertTopLvalue( translationUnit ); + PASS( "Convert L-Value", GenPoly::convertLvalue( translationUnit ) ); - clearInnerLvalue( translationUnit ); - assertTopLvalue( translationUnit ); if ( bboxp ) { @@ -379,6 +353,4 @@ } // if PASS( "Box", GenPoly::box( translationUnit ) ); - clearInnerLvalue( translationUnit ); - assertTopLvalue( translationUnit ); if ( bcodegenp ) { @@ -392,5 +364,4 @@ CodeTools::fillLocations( translationUnit ); - assertTopLvalue( translationUnit ); PASS( "Code Gen", CodeGen::generate( translationUnit, *output, ! genproto, prettycodegenp, true, linemarks ) );