Changeset 0633cf2 for src/SymTab

Timestamp:

Feb 28, 2019, 5:13:47 PM (5 years ago)

Author:

tdelisle <tdelisle@…>

Branches:

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

Children:

0050a5f

Parents:

5509ff4 (diff), 79de2210 (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

Location:

src/SymTab

Files:

• Indexer.cc (modified) (8 diffs)
• ManglerCommon.cc (modified) (1 diff)
• Validate.cc (modified) (2 diffs)
• module.mk (modified) (1 diff)

src/SymTab/Indexer.cc

@@ -26 +26 @@
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for cloneAll
+#include "Common/Stats/Counter.h" // for counters
 #include "GenPoly/GenPoly.h"
 #include "InitTweak/InitTweak.h"   // for isConstructor, isCopyFunction, isC...
@@ -41 +42 @@
 
 namespace SymTab {
+
+        // Statistics block
+        namespace {
+                auto idtable_group = new Stats::Counters::CounterGroup("IdTable");
+                auto idtable_find  = new Stats::Counters::SimpleCounter("Find calls", idtable_group);
+                auto idtable_size  = new Stats::Counters::AverageCounter<double>("Average Size", idtable_group);
+                auto idtable_key   = new Stats::Counters::AverageCounter<double>("Average Key Size", idtable_group);
+
+                auto indexers_group = new Stats::Counters::CounterGroup("Indexers");
+                auto indexers_count = new Stats::Counters::SimpleCounter("Count", indexers_group);
+                auto indexers_size  = new Stats::Counters::AverageCounter<double>("Average Size", indexers_group);
+                auto indexers_depth_a  = new Stats::Counters::AverageCounter<double>("Average Depth", indexers_group);
+                auto indexers_depth_m  = new Stats::Counters::MaxCounter<size_t>("Max Depth", indexers_group);
+        }
+
         std::ostream & operator<<( std::ostream & out, const Indexer::IdData & data ) {
                 return out << "(" << data.id << "," << data.baseExpr << ")";
@@ -197 +213 @@
         }
 
-        Indexer::Indexer() : tables( 0 ), scope( 0 ) {}
-
-        Indexer::Indexer( const Indexer &that ) : doDebug( that.doDebug ), tables( newRef( that.tables ) ), scope( that.scope ) {}
+        Indexer::Indexer() : tables( 0 ), scope( 0 ) {
+                (*indexers_count)++;
+        }
+
+        Indexer::Indexer( const Indexer &that ) : doDebug( that.doDebug ), tables( newRef( that.tables ) ), scope( that.scope ) {
+                (*indexers_count)++;
+        }
 
         Indexer::Indexer( Indexer &&that ) : doDebug( that.doDebug ), tables( that.tables ), scope( that.scope ) {
@@ -206 +226 @@
 
         Indexer::~Indexer() {
+                if(tables) {
+                        indexers_size->push( tables->idTable.size() );
+                        size_t depth = 1;
+                        for( auto crnt = tables->base.tables; crnt; crnt = crnt->base.tables ) {
+                                ++depth;
+                        }
+                        indexers_depth_a->push( depth );
+                        indexers_depth_m->push( depth );
+                }
                 deleteRef( tables );
         }
@@ -237 +266 @@
                 while ( searchTables ) {
 
+                        (*idtable_find)++;
+                        idtable_key->push( id.size() );
+                        idtable_size->push( searchTables->idTable.size() );
                         IdTable::const_iterator decls = searchTables->idTable.find( id );
                         if ( decls != searchTables->idTable.end() ) {
@@ -313 +345 @@
                 if ( tables->scope < scope ) return nullptr;
 
+                (*idtable_find)++;
+                idtable_key->push( id.size() );
+                idtable_size->push( tables->idTable.size() );
                 IdTable::const_iterator decls = tables->idTable.find( id );
                 if ( decls != tables->idTable.end() ) {
@@ -331 +366 @@
                 if ( tables->scope < scope ) return false;
 
+                (*idtable_find)++;
+                idtable_key->push( id.size() );
+                idtable_size->push( tables->idTable.size() );
                 IdTable::const_iterator decls = tables->idTable.find( id );
                 if ( decls != tables->idTable.end() ) {
@@ -347 +385 @@
                 if ( tables->scope < scope ) return false;
 
+                (*idtable_find)++;
+                idtable_key->push( id.size() );
+                idtable_size->push( tables->idTable.size() );
                 IdTable::const_iterator decls = tables->idTable.find( id );
                 if ( decls != tables->idTable.end() ) {

src/SymTab/ManglerCommon.cc

@@ -24 +24 @@
 
                         // GENERATED START, DO NOT EDIT
-                        // GENERATED BY BasicTypes-gen.cc
+                        // GENERATED BY ../../main/src/BasicTypes-gen.cc
                         // NOTES ON MANGLING:
                         // * Itanium spec says that Float80 encodes to "e" (like LongDouble), but the distinct lengths cause resolution problems.

src/SymTab/Validate.cc

@@ -49 +49 @@
 #include "CodeGen/OperatorTable.h"     // for isCtorDtor, isCtorDtorAssign
 #include "ControlStruct/Mutate.h"      // for ForExprMutator
+#include "Common/Stats.h"              // for Stats::Heap
 #include "Common/PassVisitor.h"        // for PassVisitor, WithDeclsToAdd
 #include "Common/ScopedMap.h"          // for ScopedMap
@@ -303 +304 @@
                 PassVisitor<FixQualifiedTypes> fixQual;
 
+                Stats::Heap::newPass("validate-A");
                 acceptAll( translationUnit, hoistDecls );
                 ReplaceTypedef::replaceTypedef( translationUnit );
                 ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
                 acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes because it is an indexer and needs correct types for mangling
+                Stats::Heap::newPass("validate-B");
                 acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
                 mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes, because aggregate members are accessed
                 HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
                 EliminateTypedef::eliminateTypedef( translationUnit ); //
+                Stats::Heap::newPass("validate-C");
                 acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes
                 VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
                 ReturnChecker::checkFunctionReturns( translationUnit );
                 InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
+                Stats::Heap::newPass("validate-D");
                 Concurrency::applyKeywords( translationUnit );
                 acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
                 ControlStruct::hoistControlDecls( translationUnit );  // hoist initialization out of for statements; must happen before autogenerateRoutines
                 autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay
+                Stats::Heap::newPass("validate-E");
                 Concurrency::implementMutexFuncs( translationUnit );
                 Concurrency::implementThreadStarter( translationUnit );
                 mutateAll( translationUnit, compoundliteral );
                 ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables
+                Stats::Heap::newPass("validate-F");
                 FixObjectType::fix( translationUnit );
                 ArrayLength::computeLength( translationUnit );

src/SymTab/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC += SymTab/Indexer.cc \
-       SymTab/Mangler.cc \
-       SymTab/ManglerCommon.cc \
-       SymTab/Validate.cc \
-       SymTab/FixFunction.cc \
-       SymTab/Autogen.cc
+SRC_SYMTAB = \
+      SymTab/Autogen.cc \
+      SymTab/FixFunction.cc \
+      SymTab/Indexer.cc \
+      SymTab/Mangler.cc \
+      SymTab/ManglerCommon.cc \
+      SymTab/Validate.cc
+
+SRC += $(SRC_SYMTAB)
+SRCDEMANGLE += $(SRC_SYMTAB) SymTab/Demangle.cc