Changeset 35cd219
- Timestamp:
- Feb 14, 2017, 3:58:01 PM (7 years ago)
- 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:
- cf97ccb, efd60d67
- Parents:
- 9bb90a86 (diff), e58dfb9 (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. - Location:
- src
- Files:
-
- 4 edited
-
CodeTools/DeclStats.cc (modified) (9 diffs)
-
Common/ScopedMap.h (modified) (1 diff)
-
Common/VectorMap.h (modified) (4 diffs)
-
GenPoly/InstantiateGeneric.cc (modified) (1 diff)
Legend:
- Unmodified
- Added
- Removed
-
src/CodeTools/DeclStats.cc
r9bb90a86 r35cd219 18 18 #include <iostream> 19 19 #include <map> 20 #include <sstream> 20 21 #include <string> 21 22 #include <unordered_map> … … 71 72 return *this; 72 73 } 73 74 /// Update based on a declaration list75 ArgPackStats& operator+= ( std::list<DeclarationWithType*>& decls ) {76 unsigned nn = 0;77 unsigned nn_basic = 0;78 unsigned nn_poly = 0;79 for ( auto decl : decls ) {80 nn += decl->get_type()->size();81 if ( dynamic_cast<BasicType*>( decl->get_type() ) ) ++nn_basic;82 else if ( GenPoly::hasPolyBase( decl->get_type() ) ) ++nn_poly;83 }84 ++n.at( nn );85 ++n_basic.at( nn_basic );86 ++n_poly.at( nn_poly );87 if ( nn > 0 ) {88 ++p_basic[ nn_basic*100/nn ];89 ++p_poly[ nn_poly*100/nn ];90 }91 92 return *this;93 }94 74 }; 95 75 … … 100 80 /// Count of declarations with each name 101 81 std::unordered_map<std::string, unsigned> by_name; 82 /// Count of uses of each basic type 83 std::unordered_map<std::string, unsigned> basic_type_names; 84 /// Count of uses of each non-basic type 85 std::unordered_map<std::string, unsigned> compound_type_names; 102 86 /// Stats for the parameter list 103 87 ArgPackStats params; … … 112 96 ArgPackStats assn_returns; 113 97 114 Stats() : n_decls(0), n_type_params(), by_name(), params(), returns(), n_assns(), assn_params(), assn_returns() {}98 Stats() : n_decls(0), n_type_params(), by_name(), basic_type_names(), compound_type_names(), params(), returns(), n_assns(), assn_params(), assn_returns() {} 115 99 116 100 public: … … 119 103 sum( n_type_params, o.n_type_params ); 120 104 sum( by_name, o.by_name ); 105 sum( basic_type_names, o.basic_type_names ); 106 sum( compound_type_names, o.compound_type_names ); 121 107 sum( params, o.params ); 122 108 sum( returns, o.returns ); … … 133 119 Stats total; 134 120 135 void analyzeFunc( FunctionType* fnTy, ArgPackStats& params, ArgPackStats& returns ) { 136 params += fnTy->get_parameters(); 137 returns += fnTy->get_returnVals(); 121 /// Update arg pack stats based on a declaration list 122 void analyze( Stats& stats, ArgPackStats& pstats, std::list<DeclarationWithType*>& decls ) { 123 unsigned n = 0; 124 unsigned n_basic = 0; 125 unsigned n_poly = 0; 126 for ( auto decl : decls ) { 127 n += decl->get_type()->size(); 128 if ( BasicType* bt = dynamic_cast<BasicType*>( decl->get_type() ) ) { 129 ++n_basic; 130 std::stringstream ss; 131 bt->print( ss ); 132 ++stats.basic_type_names[ ss.str() ]; 133 } else if ( GenPoly::hasPolyBase( decl->get_type() ) ) { 134 ++n_poly; 135 } else { 136 std::stringstream ss; 137 decl->get_type()->print( ss ); 138 ++stats.compound_type_names[ ss.str() ]; 139 } 140 } 141 ++pstats.n.at( n ); 142 ++pstats.n_basic.at( n_basic ); 143 ++pstats.n_poly.at( n_poly ); 144 if ( n > 0 ) { 145 ++pstats.p_basic[ n_basic*100/n ]; 146 ++pstats.p_poly[ n_poly*100/n ]; 147 } 148 } 149 150 void analyzeFunc( FunctionType* fnTy, Stats& stats, ArgPackStats& params, ArgPackStats& returns ) { 151 analyze( stats, params, fnTy->get_parameters() ); 152 analyze( stats, returns, fnTy->get_returnVals() ); 138 153 } 139 154 … … 164 179 assnTy = assnDecl->get_functionType(); 165 180 } 166 if ( assnTy ) analyzeFunc( assnTy, stats .assn_params, stats.assn_returns );181 if ( assnTy ) analyzeFunc( assnTy, stats, stats.assn_params, stats.assn_returns ); 167 182 } 168 183 } … … 171 186 ++stats.by_name[ decl->get_name() ]; 172 187 173 analyzeFunc( fnTy, stats .params, stats.returns );188 analyzeFunc( fnTy, stats, stats.params, stats.returns ); 174 189 } 175 190 … … 266 281 printAll("unique_names", [](const Stats& stats) { return stats.by_name.size(); }); 267 282 printAllSparseHisto("overloads", [](const Stats& stats) { return stats.by_name; }); 283 printAll("basic_type_names", [](const Stats& stats) { return stats.basic_type_names.size(); }); 284 printAllSparseHisto("basic_type_uses", [](const Stats& stats) { return stats.basic_type_names; }); 285 printAll("compound_type_names", [](const Stats& stats) { return stats.compound_type_names.size(); }); 286 printAllSparseHisto("compound_type_uses", [](const Stats& stats) { return stats.compound_type_names; }); 268 287 printAllPack("params", [](const Stats& stats) { return stats.params; }); 269 288 printAllPack("returns", [](const Stats& stats) { return stats.returns; }); -
src/Common/ScopedMap.h
r9bb90a86 r35cd219 230 230 } 231 231 232 /// Finds the given key in the provided scope; returns end() for none such 233 iterator findAt( size_type scope, const Key& key ) { 234 typename Scope::iterator val = scopes[scope].find( key ); 235 if ( val != scopes[scope].end() ) return iterator( scopes, val, scope ); 236 return end(); 237 } 238 const_iterator findAt( size_type scope, const Key& key ) const { 239 return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->findAt( scope, key ) ); 240 } 241 232 242 /// Finds the given key in the outermost scope inside the given scope where it occurs 233 243 iterator findNext( const_iterator &it, const Key &key ) { -
src/Common/VectorMap.h
r9bb90a86 r35cd219 38 38 typedef const const_value_type* const_pointer; 39 39 40 class iterator : public std::iterator< std:: bidirectional_iterator_tag,40 class iterator : public std::iterator< std::random_access_iterator_tag, 41 41 value_type, 42 43 44 42 difference_type, 43 pointer, 44 reference > { 45 45 friend class VectorMap; 46 46 friend class const_iterator; … … 74 74 iterator operator-- (int) { iterator tmp = *this; --(*this); return tmp; } 75 75 76 iterator& operator+= (difference_type i) { 77 // SHENANIGANS: same reasons as operator++ 78 new(&data) value_type{ (data.first + i), *(&data.second + i) }; 79 return *this; 80 } 81 82 iterator operator+ (difference_type i) const { iterator tmp = *this; return tmp += i; } 83 84 iterator& operator-= (difference_type i) { 85 // SHENANIGANS: same reasons as operator++ 86 new(&data) value_type{ (data.first - i), *(&data.second - i) }; 87 return *this; 88 } 89 90 iterator operator- (difference_type i) const { iterator tmp = *this; return tmp -= i; } 91 92 difference_type operator- (const iterator& o) const { return data.first - o.data.first; } 93 94 value_type operator[] (difference_type i) const { 95 // SHENANIGANS: same reasons as operator++ 96 return value_type{ (data.first + i), *(&data.second + i) }; 97 } 98 76 99 bool operator== (const iterator& o) const { 77 100 return data.first == o.data.first && &data.second == &o.data.second; 78 101 } 102 79 103 bool operator!= (const iterator& that) const { return !(*this == that); } 104 105 bool operator< (const iterator& o) const { return data.first < o.data.first; } 106 107 bool operator> (const iterator& o) const { return data.first > o.data.first; } 108 109 bool operator<= (const iterator& o) const { return data.first <= o.data.first; } 110 111 bool operator>= (const iterator& o) const { return data.first >= o.data.first; } 80 112 }; 81 113 … … 118 150 const_iterator operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; } 119 151 152 const_iterator& operator+= (difference_type i) { 153 // SHENANIGANS: same reasons as iterator::operator++ 154 new(&data) const_value_type{ (data.first + i), *(&data.second + i) }; 155 return *this; 156 } 157 158 const_iterator operator+ (difference_type i) const { 159 const_iterator tmp = *this; return tmp += i; 160 } 161 162 const_iterator& operator-= (difference_type i) { 163 // SHENANIGANS: same reasons as iterator::operator++ 164 new(&data) const_value_type{ (data.first - i), *(&data.second - i) }; 165 return *this; 166 } 167 168 const_iterator operator- (difference_type i) const { 169 const_iterator tmp = *this; return tmp -= i; 170 } 171 172 difference_type operator- (const const_iterator& o) const { 173 return data.first - o.data.first; 174 } 175 176 const_value_type operator[] (difference_type i) const { 177 // SHENANIGANS: same reasons as iterator::operator++ 178 return const_value_type{ (data.first + i), *(&data.second + i) }; 179 } 180 120 181 bool operator== (const const_iterator& o) const { 121 182 return data.first == o.data.first && &data.second == &o.data.second; 122 183 } 184 123 185 bool operator!= (const const_iterator& that) const { return !(*this == that); } 186 187 bool operator< (const const_iterator& o) const { return data.first < o.data.first; } 188 189 bool operator> (const const_iterator& o) const { return data.first > o.data.first; } 190 191 bool operator<= (const const_iterator& o) const { return data.first <= o.data.first; } 192 193 bool operator>= (const const_iterator& o) const { return data.first >= o.data.first; } 124 194 }; 125 195 … … 163 233 }; 164 234 235 template<typename T> 236 typename VectorMap<T>::iterator operator+ (typename VectorMap<T>::difference_type i, 237 const typename VectorMap<T>::iterator& it) { 238 return it + i; 239 } 240 241 template<typename T> 242 typename VectorMap<T>::const_iterator operator+ (typename VectorMap<T>::difference_type i, 243 const typename VectorMap<T>::const_iterator& it) { 244 return it + i; 245 } 246 165 247 #endif // _VECTORMAP_H 166 248 -
src/GenPoly/InstantiateGeneric.cc
r9bb90a86 r35cd219 122 122 /// Adds a value for a (key, typeList) pair to the current scope 123 123 void insert( Key *key, const std::list< TypeExpr* > ¶ms, Value *value ) { 124 instantiations[ key ].push_back( Instantiation( TypeList( params ), value ) ); 124 auto it = instantiations.findAt( instantiations.currentScope(), key ); 125 if ( it == instantiations.end() ) { 126 instantiations.insert( key, ValueList{ Instantiation{ TypeList( params ), value } } ); 127 } else { 128 it->second.push_back( Instantiation{ TypeList( params ), value } ); 129 } 125 130 } 126 131 };
Note: See TracChangeset
for help on using the changeset viewer.
