Changes in src/SymTab/Autogen.cc [46adb83:6ea87486]

File:

• src/SymTab/Autogen.cc (modified) (15 diffs)

src/SymTab/Autogen.cc

@@ -10 +10 @@
 // Created On       : Thu Mar 03 15:45:56 2016
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Jun 28 15:30:00 2017
-// Update Count     : 61
+// Last Modified On : Fri Jul 14 16:41:00 2017
+// Update Count     : 62
 //
 
@@ -17 +17 @@
 #include <iterator>
 #include "SynTree/Visitor.h"
-#include "SynTree/Attribute.h"
 #include "SynTree/Type.h"
 #include "SynTree/Statement.h"
 #include "SynTree/TypeSubstitution.h"
 #include "Common/utility.h"
-#include "CodeGen/OperatorTable.h"
 #include "AddVisit.h"
 #include "MakeLibCfa.h"
@@ -127 +125 @@
         FunctionType * genDefaultType( Type * paramType ) {
                 FunctionType *ftype = new FunctionType( Type::Qualifiers(), false );
-                ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), paramType->clone() ), nullptr );
+                ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), paramType->clone() ), nullptr );
                 ftype->get_parameters().push_back( dstParam );
 
@@ -178 +176 @@
                         FunctionType * ftype = funcDecl->get_functionType();
                         assert( ! ftype->get_parameters().empty() );
-                        Type * t = InitTweak::getPointerBase( ftype->get_parameters().front()->get_type() );
-                        assert( t );
+                        Type * t = safe_dynamic_cast< PointerType * >( ftype->get_parameters().front()->get_type() )->get_base();
                         map.insert( Mangler::mangleType( t ), true );
                 }
@@ -225 +222 @@
                         FunctionType * ftype = data.genType( refType );
 
-                        if(concurrent_type && CodeGen::isDestructor( data.fname )) {
+                        if(concurrent_type && InitTweak::isDestructor( data.fname )) {
                                 ftype->get_parameters().front()->get_type()->set_mutex( true );
                         }
@@ -277 +274 @@
                 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.
@@ -304 +297 @@
         /// 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<ObjectDecl*>( func->get_functionType()->get_returnVals().front() );
+                }
+
                 InitTweak::InitExpander srcParam( src );
 
-                // assign to destination
-                Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), safe_dynamic_cast< ReferenceType* >( dstParam->get_type() )->get_base()->clone() ) );
+                // assign to destination (and return value if generic)
+                UntypedExpr *derefExpr = UntypedExpr::createDeref( new VariableExpr( dstParam ) );
+                Expression *dstselect = new MemberExpr( field, derefExpr );
                 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
         }
 
@@ -396 +401 @@
         void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) {
                 // Builtins do not use autogeneration.
-                if ( aggregateDecl->get_linkage() == LinkageSpec::Builtin ||
+                if ( aggregateDecl->get_linkage() == LinkageSpec::BuiltinCFA ||
                          aggregateDecl->get_linkage() == LinkageSpec::BuiltinC ) {
                         return;
@@ -413 +418 @@
 
                 // 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 CodeGen::isConstructor( dcl->get_name() ); } );
+                unsigned numCtors = std::count_if( newFuncs.begin(), newFuncs.end(), [](FunctionDecl * dcl) { return InitTweak::isConstructor( dcl->get_name() ); } );
 
                 if ( functionNesting == 0 ) {
@@ -428 +433 @@
                         // 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 ( ! CodeGen::isDestructor( dcl->get_name() ) ) {
+                        if ( ! InitTweak::isDestructor( dcl->get_name() ) ) {
                                 makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), dcl, isDynamicLayout );
                         } else {
                                 makeStructFunctionBody( aggregateDecl->get_members().rbegin(), aggregateDecl->get_members().rend(), dcl, isDynamicLayout, false );
                         }
-                        if ( CodeGen::isAssignment( dcl->get_name() ) ) {
+                        if ( InitTweak::isAssignment( dcl->get_name() ) ) {
                                 // assignment needs to return a value
                                 FunctionType * assignType = dcl->get_functionType();
@@ -462 +467 @@
                                         // 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/choose the correct unnamed member
+                                        // 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.
                                         continue;
                                 }
@@ -478 +485 @@
         void makeUnionFieldsAssignment( ObjectDecl * srcParam, ObjectDecl * dstParam, OutputIterator out ) {
                 UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) );
-                copy->get_args().push_back( new AddressExpr( new VariableExpr( dstParam ) ) );
+                copy->get_args().push_back( new VariableExpr( dstParam ) );
                 copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
                 copy->get_args().push_back( new SizeofExpr( srcParam->get_type()->clone() ) );
@@ -490 +497 @@
                 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 ( CodeGen::isAssignment( funcDecl->get_name() ) ) {
-                        // also generate return statement in assignment
+                if ( returnVal ) {
                         funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
                 }
@@ -502 +512 @@
                 // Make function polymorphic in same parameters as generic union, if applicable
                 const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
-
+                
                 // default ctor/dtor need only first parameter
                 // void ?{}(T *); void ^?{}(T *);
@@ -520 +530 @@
                 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