Changeset fc12f05 for src/ResolvExpr/SpecCost.cc

Timestamp:

Nov 13, 2023, 3:43:43 AM (23 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

25f2798

Parents:

0030b508 (diff), 2174191 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/ResolvExpr/SpecCost.cc (modified) (1 diff)

src/ResolvExpr/SpecCost.cc

@@ -21 +21 @@
 #include "AST/Pass.hpp"
 #include "AST/Type.hpp"
-#include "Common/PassVisitor.h"
-#include "SynTree/Declaration.h"
-#include "SynTree/Expression.h"
-#include "SynTree/Type.h"
 
 namespace ResolvExpr {
-
-        /// Counts specializations in a type
-        class CountSpecs : public WithShortCircuiting, public WithVisitorRef<CountSpecs> {
-                int count = -1;  ///< specialization count (-1 for none)
-
-        public:
-                int get_count() const { return count >= 0 ? count : 0; }
-
-                // mark specialization of base type
-                void postvisit(PointerType*) { if ( count >= 0 ) ++count; }
-
-                // mark specialization of base type
-                void postvisit(ArrayType*) { if ( count >= 0 ) ++count; }
-
-                // mark specialization of base type
-                void postvisit(ReferenceType*) { if ( count >= 0 ) ++count; }
-
-                void postvisit(StructInstType*) { if ( count >= 0 ) ++count; }
-                void postvisit(UnionInstType*) { if ( count >= 0 ) ++count; }
-
-        private:
-                // takes minimum non-negative count over parameter/return list
-                void takeminover( int& mincount, std::list<DeclarationWithType*>& dwts ) {
-                        for ( DeclarationWithType* dwt : dwts ) {
-                                count = -1;
-                                maybeAccept( dwt->get_type(), *visitor );
-                                if ( count != -1 && count < mincount ) mincount = count;
-                        }
-                }
-
-        public:
-                // take minimal specialization value over ->returnVals and ->parameters
-                void previsit(FunctionType* fty) {
-                        int mincount = std::numeric_limits<int>::max();
-                        takeminover( mincount, fty->parameters );
-                        takeminover( mincount, fty->returnVals );
-                        // add another level to mincount if set
-                        count = mincount < std::numeric_limits<int>::max() ? mincount + 1 : -1;
-                        // already visited children
-                        visit_children = false;
-                }
-
-        private:
-                // returns minimum non-negative count + 1 over type parameters (-1 if none such)
-                int minover( std::list<Expression*>& parms ) {
-                        int mincount = std::numeric_limits<int>::max();
-                        for ( Expression* parm : parms ) {
-                                count = -1;
-                                maybeAccept( parm->result, *visitor );
-                                if ( count != -1 && count < mincount ) mincount = count;
-                        }
-                        return mincount < std::numeric_limits<int>::max() ? mincount + 1 : -1;
-                }
-
-        public:
-                // look for polymorphic parameters
-                void previsit(StructInstType* sty) {
-                        count = minover( sty->parameters );
-                }
-
-                // look for polymorphic parameters
-                void previsit(UnionInstType* uty) {
-                        count = minover( uty->parameters );
-                }
-
-                // note polymorphic type (which may be specialized)
-                // xxx - maybe account for open/closed type variables
-                void postvisit(TypeInstType*) { count = 0; }
-
-                // take minimal specialization over elements
-                // xxx - maybe don't increment, tuple flattening doesn't necessarily specialize
-                void previsit(TupleType* tty) {
-                        int mincount = std::numeric_limits<int>::max();
-                        for ( Type* ty : tty->types ) {
-                                count = -1;
-                                maybeAccept( ty, *visitor );
-                                if ( count != -1 && count < mincount ) mincount = count;
-                        }
-                        count = mincount < std::numeric_limits<int>::max() ? mincount + 1 : -1;
-                        visit_children = false;
-                }
-        };
-
-        /// Returns the (negated) specialization cost for a given type
-        int specCost( Type* ty ) {
-                PassVisitor<CountSpecs> counter;
-                maybeAccept( ty, *counter.pass.visitor );
-                return counter.pass.get_count();
-        }
 
 namespace {