Changeset bff227f

Timestamp:

Jul 21, 2017, 3:57:11 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

9191a8e

Parents:

53a8e68

Message:

Refactor operator predicates into OperatorTable?.cc

Location:

src

Files:

• CodeGen/OperatorTable.cc (modified) (2 diffs)
• CodeGen/OperatorTable.h (modified) (2 diffs)
• Concurrency/Keywords.cc (modified) (2 diffs)
• GenPoly/Box.cc (modified) (2 diffs)
• InitTweak/FixInit.cc (modified) (5 diffs)
• InitTweak/GenInit.cc (modified) (2 diffs)
• InitTweak/InitTweak.h (modified) (1 diff)
• SymTab/Autogen.cc (modified) (5 diffs)
• SymTab/Indexer.cc (modified) (3 diffs)
• SymTab/Validate.cc (modified) (4 diffs)
• Tuples/TupleAssignment.cc (modified) (2 diffs)

src/CodeGen/OperatorTable.cc ¶

@@ -14 +14 @@
 //
 
-#include <map>      // for map, _Rb_tree_const_iterator, map<>::const_iterator
-#include <utility>  // for pair
+#include <algorithm>  // for any_of
+#include <map>        // for map, _Rb_tree_const_iterator, map<>::const_iterator
+#include <utility>    // for pair
 
 #include "OperatorTable.h"
@@ -91 +92 @@
                 } // if
         }
+
+        /// determines if a given function name is one of the operator types between [begin, end)
+        template<typename Iterator>
+        bool isOperatorType( const std::string & funcName, Iterator begin, Iterator end ) {
+                OperatorInfo info;
+                if ( operatorLookup( funcName, info ) ) {
+                        return std::find( begin, end, info.type ) != end;
+                }
+                return false;
+        }
+
+        bool isConstructor( const std::string & funcName ) {
+                static OperatorType types[] = { OT_CTOR };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+
+        bool isDestructor( const std::string & funcName ) {
+                static OperatorType types[] = { OT_DTOR };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+
+        bool isAssignment( const std::string & funcName ) {
+                static OperatorType types[] = { OT_PREFIXASSIGN, OT_POSTFIXASSIGN, OT_INFIXASSIGN };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+
+        bool isCtorDtor( const std::string & funcName ) {
+                static OperatorType types[] = { OT_CTOR, OT_DTOR };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+
+        bool isCtorDtorAssign( const std::string & funcName ) {
+                static OperatorType types[] = { OT_CTOR, OT_DTOR, OT_PREFIXASSIGN, OT_POSTFIXASSIGN, OT_INFIXASSIGN };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
 } // namespace CodeGen
 

src/CodeGen/OperatorTable.h ¶

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// OperatorTable.h -- 
+// OperatorTable.h --
 //
 // Author           : Richard C. Bilson
@@ -43 +43 @@
 
         bool operatorLookup( std::string funcName, OperatorInfo &info );
+
+        bool isConstructor( const std::string & );
+        bool isDestructor( const std::string & );
+        bool isAssignment( const std::string & );
+        bool isCtorDtor( const std::string & );
+        bool isCtorDtorAssign( const std::string & );
 } // namespace CodeGen
 

src/Concurrency/Keywords.cc ¶

@@ -22 +22 @@
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for deleteAll, map_range
-#include "InitTweak/InitTweak.h"   // for isConstructor
+#include "CodeGen/OperatorTable.h" // for isConstructor
+#include "InitTweak/InitTweak.h"   // for getPointerBase
 #include "Parser/LinkageSpec.h"    // for Cforall
 #include "SymTab/AddVisit.h"       // for acceptAndAdd
@@ -522 +523 @@
                 Visitor::visit(decl);
 
-                if( ! InitTweak::isConstructor(decl->get_name()) ) return;
+                if( ! CodeGen::isConstructor(decl->get_name()) ) return;
 
                 DeclarationWithType * param = decl->get_functionType()->get_parameters().front();

src/GenPoly/Box.cc ¶

@@ -55 +55 @@
 #include "Common/UniqueName.h"
 #include "Common/utility.h"
+
+#include "CodeGen/OperatorTable.h"
 
 #include "InitTweak/InitTweak.h"
@@ -567 +569 @@
                         // To compound the issue, the right side can be *x, etc. because of lvalue-returning functions
                         if ( UntypedExpr * assign = dynamic_cast< UntypedExpr * >( commaExpr->get_arg1() ) ) {
-                                if ( InitTweak::isAssignment( InitTweak::getFunctionName( assign ) ) ) {
+                                if ( CodeGen::isAssignment( InitTweak::getFunctionName( assign ) ) ) {
                                         assert( assign->get_args().size() == 2 );
                                         if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( assign->get_args().back() ) ) {

src/InitTweak/FixInit.cc ¶

@@ -26 +26 @@
 #include "FixGlobalInit.h"
 #include "CodeGen/GenType.h"  // for warning/error messages
+#include "CodeGen/OperatorTable.h"
 #include "Common/PassVisitor.h"
 #include "GenPoly/DeclMutator.h"
@@ -363 +364 @@
                                         FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
                                         assert( ftype );
-                                        if ( isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
+                                        if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
                                                 Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
                                                 Type * t2 = ftype->get_parameters().back()->get_type();
@@ -372 +373 @@
                                                         return appExpr;
                                                 } // if
-                                        } else if ( isDestructor( funcDecl->get_name() ) ) {
+                                        } else if ( CodeGen::isDestructor( funcDecl->get_name() ) ) {
                                                 // correctness: never copy construct arguments to a destructor
                                                 return appExpr;
@@ -975 +976 @@
                         if ( ! funcDecl ) return false;
                         if ( ! funcDecl->get_statements() ) return false;
-                        return isCtorDtor( funcDecl->get_name() ) && ! LinkageSpec::isOverridable( funcDecl->get_linkage() );
+                        return CodeGen::isCtorDtor( funcDecl->get_name() ) && ! LinkageSpec::isOverridable( funcDecl->get_linkage() );
                 }
 
@@ -992 +993 @@
 
                         function = funcDecl;
-                        isCtor = isConstructor( function->get_name() );
+                        isCtor = CodeGen::isConstructor( function->get_name() );
                         if ( checkWarnings( function ) ) {
                                 FunctionType * type = function->get_functionType();

src/InitTweak/GenInit.cc ¶

@@ -21 +21 @@
 
 #include "Common/PassVisitor.h"
+#include "CodeGen/OperatorTable.h"
 
 #include "GenPoly/DeclMutator.h"
@@ -235 +236 @@
         void CtorDtor::handleDWT( DeclarationWithType * dwt ) {
                 // if this function is a user-defined constructor or destructor, mark down the type as "managed"
-                if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && isCtorDtor( dwt->get_name() ) ) {
+                if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && CodeGen::isCtorDtor( dwt->get_name() ) ) {
                         std::list< DeclarationWithType * > & params = GenPoly::getFunctionType( dwt->get_type() )->get_parameters();
                         assert( ! params.empty() );

src/InitTweak/InitTweak.h ¶

@@ -26 +26 @@
 // helper functions for initialization
 namespace InitTweak {
-        bool isConstructor( const std::string & );
-        bool isDestructor( const std::string & );
-        bool isAssignment( const std::string & );
-        bool isCtorDtor( const std::string & );
-        bool isCtorDtorAssign( const std::string & );
-
         FunctionDecl * isAssignment( Declaration * decl );
         FunctionDecl * isDestructor( Declaration * decl );

src/SymTab/Autogen.cc ¶

@@ -21 +21 @@
 #include "SynTree/TypeSubstitution.h"
 #include "Common/utility.h"
+#include "CodeGen/OperatorTable.h"
 #include "AddVisit.h"
 #include "MakeLibCfa.h"
@@ -223 +224 @@
                         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 );
                         }
@@ -407 +408 @@
 
                 // 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 ) {
@@ -422 +423 @@
                         // 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() ) ) {
+                        if ( ! CodeGen::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 ( InitTweak::isAssignment( dcl->get_name() ) ) {
+                        if ( CodeGen::isAssignment( dcl->get_name() ) ) {
                                 // assignment needs to return a value
                                 FunctionType * assignType = dcl->get_functionType();
@@ -486 +487 @@
 
                 makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( funcDecl->get_statements()->get_kids() ) );
-                if ( InitTweak::isAssignment( funcDecl->get_name() ) ) {
+                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 ) ) );

src/SymTab/Indexer.cc ¶

@@ -26 +26 @@
 
 #include "Common/utility.h"
+
+#include "CodeGen/OperatorTable.h"
 
 #include "ResolvExpr/typeops.h"
@@ -112 +114 @@
         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
@@ -140 +142 @@
                                 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);

src/SymTab/Validate.cc ¶

@@ -43 +43 @@
 
 #include "CodeGen/CodeGenerator.h"
+#include "CodeGen/OperatorTable.h"
 
 #include "Common/PassVisitor.h"
@@ -52 +53 @@
 
 #include "GenPoly/DeclMutator.h"
-
-#include "InitTweak/InitTweak.h"
 
 #include "AddVisit.h"
@@ -827 +826 @@
                 std::list< DeclarationWithType * > &params = 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 );
@@ -835 +834 @@
                                 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 );
                         }

src/Tuples/TupleAssignment.cc ¶

@@ -22 +22 @@
 #include "Explode.h"
 #include "Common/SemanticError.h"
+#include "CodeGen/OperatorTable.h"
 #include "InitTweak/InitTweak.h"
 #include "InitTweak/GenInit.h"
@@ -110 +111 @@
         void TupleAssignSpotter::spot( UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities ) {
                 if (  NameExpr *op = dynamic_cast< NameExpr * >(expr->get_function()) ) {
-                        if ( InitTweak::isCtorDtorAssign( op->get_name() ) ) {
+                        if ( CodeGen::isCtorDtorAssign( op->get_name() ) ) {
                                 fname = op->get_name();
                                 for ( std::list<ResolvExpr::AltList>::const_iterator ali = possibilities.begin(); ali != possibilities.end(); ++ali ) {
                                         if ( ali->size() == 0 ) continue; // AlternativeFinder will natrually handle this case, if it's legal
-                                        if ( ali->size() <= 1 && InitTweak::isAssignment( op->get_name() ) ) {
+                                        if ( ali->size() <= 1 && CodeGen::isAssignment( op->get_name() ) ) {
                                                 // what does it mean if an assignment takes 1 argument? maybe someone defined such a function, in which case AlternativeFinder will naturally handle it
                                                 continue;