1// PR 39548 verify ssa ICE 2// 3// { dg-do compile { target { lp64 } } } 4// { dg-options "-Wno-error -fno-exceptions -fno-tree-vrp -O2 -fprofile-generate -finline-limit=500 -std=c++98" } 5// 6 7#include <map> 8#include <vector> 9#include <iostream> 10#include <cstdlib> 11using namespace std; 12template<typename _FIter, typename _Tp> _FIter lower_bound(_FIter, _FIter, _Tp&); 13template<class _Key> struct hash { }; 14template<class _Val> struct _Hashtable_node { 15 _Hashtable_node* _M_next; 16 _Val _M_val; 17}; 18static const unsigned long __stl_prime_list[] = { 2, 3, 5 }; 19inline unsigned long prime(unsigned long __n) { 20 const unsigned long* __first = __stl_prime_list; 21 const unsigned long* __last = __stl_prime_list + 29; 22 const unsigned long* pos = lower_bound(__first, __last, __n); 23 return pos == __last ? *(__last - 1) : *pos; 24} 25template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc> struct hashtable { 26 typedef _Key key_type; 27 typedef _Val value_type; 28 typedef _HashFcn hasher; 29 typedef _EqualKey key_equal; 30 typedef size_t size_type; 31 typedef value_type& reference; 32 typedef _Hashtable_node<_Val> _Node; 33 typedef typename _Alloc::template rebind<value_type>::other allocator_type; 34 allocator_type get_allocator() const { } 35 typedef typename _Alloc::template rebind<_Node>::other _Node_Alloc; 36 typedef typename _Alloc::template rebind<_Node*>::other _Nodeptr_Alloc; 37 typedef vector<_Node*, _Nodeptr_Alloc> _Vector_type; 38 _Node_Alloc _M_node_allocator; 39 void _M_put_node(_Node* __p) { 40 _M_node_allocator.deallocate(__p, 1); 41 } 42 hasher _M_hash; 43 key_equal _M_equals; 44 _ExtractKey _M_get_key; 45 _Vector_type _M_buckets; 46 size_type _M_num_elements; 47 hashtable(size_type __n, const _HashFcn& __hf, const _EqualKey& __eql, const allocator_type& __a = allocator_type()) : _M_num_elements(0) { 48 _M_initialize_buckets(__n); 49 } 50 ~hashtable() { clear(); } 51 reference find_or_insert(const value_type& __obj); 52 size_type count(const key_type& __key) const { 53 const size_type __n = _M_bkt_num_key(__key); 54 size_type __result = 0; 55 for (const _Node* __cur = _M_buckets[__n]; __cur; __cur = __cur->_M_next) 56 if (_M_equals(_M_get_key(__cur->_M_val), __key)) ++__result; 57 } 58 size_type erase(const key_type& __key); 59 void clear(); 60 size_type _M_next_size(size_type __n) const { return prime(__n); } 61 void _M_initialize_buckets(size_type __n) { 62 const size_type __n_buckets = _M_next_size(__n); 63 _M_buckets.reserve(__n_buckets); 64 _M_buckets.insert(_M_buckets.end(), __n_buckets, (_Node*) 0); 65 } 66 size_type _M_bkt_num_key(const key_type& __key) const { 67 return _M_bkt_num_key(__key, _M_buckets.size()); 68 } 69 size_type _M_bkt_num_key(const key_type& __key, size_t __n) const { 70 return _M_hash(__key) % __n; 71 } 72 void _M_delete_node(_Node* __n) { 73 this->get_allocator().destroy(&__n->_M_val); 74 _M_put_node(__n); 75 } 76}; 77template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All> typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::size_type hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: erase(const key_type& __key) { 78 const size_type __n = _M_bkt_num_key(__key); 79 _Node* __first = _M_buckets[__n]; 80 if (__first) _Node* __cur = __first; 81} 82template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All> void hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: clear() { 83 for (size_type __i = 0; __i < _M_buckets.size(); ++__i) { 84 _Node* __cur = _M_buckets[__i]; 85 while (__cur != 0) { _M_delete_node(__cur); } 86 } 87} 88template<class _Key, class _Tp, class _HashFn = ::hash<_Key>, class _EqualKey = equal_to<_Key>, class _Alloc = allocator<_Tp> > struct hash_map { 89 typedef hashtable<pair<const _Key, _Tp>,_Key, _HashFn, _Select1st<pair<const _Key, _Tp> >, _EqualKey, _Alloc> _Ht; 90 _Ht _M_ht; 91 typedef typename _Ht::key_type key_type; 92 typedef typename _Ht::value_type value_type; 93 typedef typename _Ht::hasher hasher; 94 typedef typename _Ht::key_equal key_equal; 95 typedef typename _Ht::size_type size_type; 96 typedef typename _Ht::allocator_type allocator_type; 97 hash_map() : _M_ht(100, hasher(), key_equal(), allocator_type()) { } 98 _Tp& operator[](const key_type& __key) { 99 return _M_ht.find_or_insert(value_type(__key, _Tp())).second; 100 } 101 size_type count(const key_type& __key) const { return _M_ht.count(__key); } 102 size_type erase(const key_type& __key) { 103 return _M_ht.erase(__key); 104 } 105}; 106extern size_t strlen (__const char *__s); 107template <class C> struct scoped_ptr { 108 explicit scoped_ptr(C* p = __null) : ptr_(p) { delete ptr_; } 109 void reset(C* p = __null) { 110 if (p != ptr_) { delete ptr_; } 111 } 112 C& operator*() const {} 113 C* operator->() const {} 114 bool operator==(C* p) const { return ptr_ == p; } 115 bool operator!=(C* p) const { return ptr_ != p; } 116 C* ptr_; 117}; 118namespace std { 119class strstreambuf : public basic_streambuf<char, char_traits<char> > { 120}; 121class strstream : public basic_iostream<char> { 122 public: int pcount() const; 123 char* str(); 124 strstreambuf _M_buf; 125}; 126}; 127const int INFO = 0, WARNING = 1, ERROR = 2, FATAL = 3, NUM_SEVERITIES = 4; 128struct foo_1 { 129 foo_1(string* str) : str_(str) { } 130 operator bool() const { 131 return (__builtin_expect(str_ != __null, 0)); 132 } 133 string* str_; 134}; 135template<class t1, class t2> string* Makefoo_1(const t1& v1, const t2& v2, const char* names) { 136 strstream ss; 137 ss << names << " (" << v1 << " vs. " << v2 << ")"; 138 return new string(ss.str(), ss.pcount()); 139} 140template <class t1, class t2> inline string* Check_GTImpl(const t1& v1, const t2& v2, const char* names) { 141 if (v1 > v2) return __null; 142 else return Makefoo_1(v1, v2, names); 143} 144struct blah_54 { 145 blah_54(const char* file, int line, int severity); 146 ~blah_54(); 147 ostream& stream() { }; 148}; 149class blah_0 : public blah_54 { 150 public: blah_0(const char* file, int line); 151 blah_0(const char* file, int line, const foo_1& result); 152}; 153template <class Value, class Key, class HashFcn, class ExtractKey, class EqualKey, class Alloc> class dense_hashtable; 154template <class V, class K, class HF, class ExK, class EqK, class A> struct dense_hashtable_iterator { 155 typedef V* pointer; 156 dense_hashtable_iterator(const dense_hashtable<V,K,HF,ExK,EqK,A> *h, pointer it, pointer it_end, bool advance) : ht(h), pos(it), end(it_end) { 157 if (advance) advance_past_empty_and_deleted(); 158 } 159 pointer operator->() const { } 160 void advance_past_empty_and_deleted() { 161 while ( pos != end && (ht->test_empty(*this) || ht->test_deleted(*this)) ) ++pos; 162 } 163 const dense_hashtable<V,K,HF,ExK,EqK,A> *ht; 164 pointer pos, end; 165}; 166template <class V, class K, class HF, class ExK, class EqK, class A> struct dense_hashtable_const_iterator { 167 typedef dense_hashtable_iterator<V,K,HF,ExK,EqK,A> iterator; 168 typedef dense_hashtable_const_iterator<V,K,HF,ExK,EqK,A> const_iterator; 169 typedef const V& reference; 170 typedef const V* pointer; 171 dense_hashtable_const_iterator(const dense_hashtable<V,K,HF,ExK,EqK,A> *h, pointer it, pointer it_end, bool advance) : ht(h), pos(it), end(it_end) { 172 if (advance) advance_past_empty_and_deleted(); 173 } 174 dense_hashtable_const_iterator(const iterator &it) : pos(it.pos), end(it.end) {} 175 reference operator*() const { return *pos; } 176 pointer operator->() const {} 177 void advance_past_empty_and_deleted() { 178 while ( pos != end && (ht->test_empty(*this) || ht->test_deleted(*this))) ++pos; 179 } 180 const_iterator& operator++() { } 181 bool operator!=(const const_iterator& it) const { } 182 const dense_hashtable<V,K,HF,ExK,EqK,A> *ht; 183 pointer pos, end; 184}; 185template <class Value, class Key, class HashFcn, class ExtractKey, class EqualKey, class Alloc> class dense_hashtable { 186 public: typedef Key key_type; 187 typedef Value value_type; 188 typedef HashFcn hasher; 189 typedef EqualKey key_equal; 190 typedef size_t size_type; 191 typedef dense_hashtable_iterator<Value, Key, HashFcn, ExtractKey, EqualKey, Alloc> iterator; 192 typedef dense_hashtable_const_iterator<Value, Key, HashFcn, ExtractKey, EqualKey, Alloc> const_iterator; 193 static const float HT_OCCUPANCY_FLT; 194 static const float HT_EMPTY_FLT; 195 static const size_t HT_MIN_BUCKETS = 32; 196 iterator end() { 197 return iterator(this, table + num_buckets, table + num_buckets, true); 198 } 199 const_iterator end() const { 200 return const_iterator(this, table + num_buckets, table+num_buckets,true); 201 } 202 void set_value(value_type* dst, const value_type& src) { 203 new(dst) value_type(src); 204 } 205 void destroy_buckets(size_type first, size_type last) { 206 for (; first != last; ++first) table[first].~value_type(); 207 } 208 private: void squash_deleted() { 209 if ( num_deleted ) { 210 dense_hashtable tmp(*this); 211 swap(tmp); 212 } 213 } 214 public: void set_deleted_key(const value_type &val) { squash_deleted(); } 215 bool test_deleted(size_type bucknum) const { 216 return (use_deleted && num_deleted > 0 && equals(get_key(delval), get_key(table[bucknum]))); 217 } 218 bool test_deleted(const const_iterator &it) const { 219 return (use_deleted && num_deleted > 0 && equals(get_key(delval), get_key(*it))); 220 } 221 bool set_deleted(const_iterator &it) { 222 set_value(const_cast<value_type*>(&(*it)), delval); 223 } 224 bool test_empty(size_type bucknum) const { 225 return equals(get_key(emptyval), get_key(table[bucknum])); 226 } 227 bool test_empty(const const_iterator &it) const { 228 return equals(get_key(emptyval), get_key(*it)); 229 } 230 void fill_range_with_empty(value_type* table_start, value_type* table_end) { 231 uninitialized_fill(table_start, table_end, emptyval); 232 } 233 void set_empty(size_type buckstart, size_type buckend) { 234 destroy_buckets(buckstart, buckend); 235 fill_range_with_empty(table + buckstart, table + buckend); 236 } 237 size_type size() const { 238 return num_elements - num_deleted; 239 } 240 size_type bucket_count() const { } 241 static const size_type ILLEGAL_BUCKET = size_type(-1); 242 size_type min_size(size_type num_elts, size_type min_buckets_wanted) { 243 size_type sz = HT_MIN_BUCKETS; 244 while ( sz < min_buckets_wanted || num_elts >= sz * enlarge_resize_percent ) sz *= 2; 245 } 246 void maybe_shrink() { 247 if (shrink_threshold > 0 && (num_elements-num_deleted) < shrink_threshold && bucket_count() > HT_MIN_BUCKETS ) { 248 size_type sz = bucket_count() / 2; 249 sz /= 2; 250 dense_hashtable tmp(*this, sz); 251 swap(tmp); 252 } 253 } 254 void resize_delta(size_type delta, size_type min_buckets_wanted = 0) { 255 if ( consider_shrink ) maybe_shrink(); 256 const size_type needed_size = min_size(num_elements + delta, min_buckets_wanted); 257 if ( needed_size > bucket_count() ) { 258 const size_type resize_to = min_size(num_elements - num_deleted + delta, min_buckets_wanted); 259 dense_hashtable tmp(*this, resize_to); 260 swap(tmp); 261 } 262 } 263 void copy_from(const dense_hashtable &ht, size_type min_buckets_wanted = 0) { 264 clear(); 265 const size_type resize_to = min_size(ht.size(), min_buckets_wanted); 266 num_elements++; 267 } 268 explicit dense_hashtable(size_type n = 0, const HashFcn& hf = HashFcn(), const EqualKey& eql = EqualKey(),const ExtractKey& ext = ExtractKey()) : num_deleted(0), use_deleted(false), use_empty(false), delval(), emptyval(), enlarge_resize_percent(HT_OCCUPANCY_FLT), shrink_resize_percent(HT_EMPTY_FLT), table(__null), num_buckets(min_size(0, n)), num_elements(0) { 269 reset_thresholds(); 270 } 271 dense_hashtable(const dense_hashtable& ht, size_type min_buckets_wanted = 0) : num_deleted(0), use_deleted(ht.use_deleted), use_empty(ht.use_empty), delval(ht.delval), emptyval(ht.emptyval), enlarge_resize_percent(ht.enlarge_resize_percent), shrink_resize_percent(ht.shrink_resize_percent), table(__null), num_buckets(0), num_elements(0) { 272 reset_thresholds(); 273 copy_from(ht, min_buckets_wanted); 274 set_value(&emptyval, ht.emptyval); 275 enlarge_resize_percent = ht.enlarge_resize_percent; 276 copy_from(ht); 277 } 278 ~dense_hashtable() { 279 if (table) { 280 destroy_buckets(0, num_buckets); 281 free(table); 282 } 283 } 284 void swap(dense_hashtable& ht) { 285 std::swap(equals, ht.equals); 286 { 287 value_type tmp; 288 set_value(&delval, ht.delval); 289 set_value(&ht.delval, tmp); 290 set_value(&ht.emptyval, tmp); 291 } 292 std::swap(table, ht.table); 293 std::swap(num_buckets, ht.num_buckets); 294 reset_thresholds(); 295 ht.reset_thresholds(); 296 } 297 void clear() { 298 if (table) destroy_buckets(0, num_buckets); 299 num_buckets = min_size(0,0); 300 set_empty(0, num_buckets); 301 } 302 pair<size_type, size_type> find_position(const key_type &key) const { 303 const size_type bucket_count_minus_one = bucket_count() - 1; 304 size_type bucknum = hash(key) & bucket_count_minus_one; 305 size_type insert_pos = ILLEGAL_BUCKET; 306 while ( 1 ) { 307 if ( test_empty(bucknum) ) { 308 if ( insert_pos == ILLEGAL_BUCKET ) return pair<size_type,size_type>(ILLEGAL_BUCKET, insert_pos); 309 } 310 else if ( test_deleted(bucknum) ) { 311 if ( insert_pos == ILLEGAL_BUCKET ) insert_pos = bucknum; 312 } 313 else if ( equals(key, get_key(table[bucknum])) ) { 314 return pair<size_type,size_type>(bucknum, ILLEGAL_BUCKET); 315 } 316 } 317 } 318 iterator find(const key_type& key) { 319 if ( size() == 0 ) return end(); 320 pair<size_type, size_type> pos = find_position(key); 321 if ( pos.first == ILLEGAL_BUCKET ) return end(); 322 return iterator(this, table + pos.first, table + num_buckets, false); 323 } 324 const_iterator find(const key_type& key) const { 325 if ( size() == 0 ) return end(); 326 pair<size_type, size_type> pos = find_position(key); 327 if ( pos.first == ILLEGAL_BUCKET ) return end(); 328 return const_iterator(this, table + pos.first, table+num_buckets, false); 329 } 330 size_type count(const key_type &key) const { 331 pair<size_type, size_type> pos = find_position(key); } 332 pair<iterator, bool> insert_noresize(const value_type& obj) { 333 const pair<size_type,size_type> pos = find_position(get_key(obj)); 334 if ( pos.first != ILLEGAL_BUCKET) { 335 return pair<iterator,bool>(iterator(this, table + pos.first, table + num_buckets, false), false); 336 } 337 else { 338 if ( test_deleted(pos.second) ) { ++num_elements; } 339 return pair<iterator,bool>(iterator(this, table + pos.second, table + num_buckets, false), true); 340 } 341 } 342 pair<iterator, bool> insert(const value_type& obj) { 343 resize_delta(1); 344 return insert_noresize(obj); 345 } 346 size_type erase(const key_type& key) { 347 const_iterator pos = find(key); 348 if ( pos != end() ) { 349 set_deleted(pos); 350 } 351 } 352 hasher hash; 353 key_equal equals; 354 ExtractKey get_key; 355 size_type num_deleted; 356 bool use_deleted; 357 bool use_empty; 358 value_type delval; 359 value_type emptyval; 360 float enlarge_resize_percent; 361 float shrink_resize_percent; 362 size_type shrink_threshold; 363 size_type enlarge_threshold; 364 value_type *table; 365 size_type num_buckets; 366 size_type num_elements; 367 bool consider_shrink; 368 void reset_thresholds() { 369 enlarge_threshold = static_cast<size_type>(num_buckets * shrink_resize_percent); 370 } 371}; 372template<> struct hash<long> { 373 size_t operator()(long x) const { 374 } 375}; 376template<> struct hash<unsigned long> { 377 size_t operator()(unsigned long x) const { 378 } 379}; 380template <class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = allocator<T> > class dense_hash_map { 381 struct SelectKey { 382 const Key& operator()(const pair<const Key, T>& p) const { 383 return p.first; 384 } 385 }; 386 typedef dense_hashtable<pair<const Key, T>, Key, HashFcn, SelectKey, EqualKey, Alloc> ht; 387 ht rep; 388 public: typedef typename ht::key_type key_type; 389 typedef T data_type; 390 typedef typename ht::value_type value_type; 391 typedef typename ht::size_type size_type; 392 typedef typename ht::iterator iterator; 393 typedef typename ht::const_iterator const_iterator; 394 iterator end() { 395 return rep.end(); 396 } 397 iterator find(const key_type& key) { return rep.find(key); } 398 data_type& operator[](const key_type& key) { 399 iterator it = find(key); 400 return insert(value_type(key, data_type())).first->second; 401 } 402 pair<iterator, bool> insert(const value_type& obj) { 403 return rep.insert(obj); 404 } 405 void set_deleted_key(const key_type& key) { 406 rep.set_deleted_key(value_type(key, data_type())); 407 } 408 size_type erase(const key_type& key) { return rep.erase(key); } 409}; 410template <class Value, class HashFcn = hash<Value>, class EqualKey = equal_to<Value>, class Alloc = allocator<Value> > class dense_hash_set { 411 struct Identity { 412 const Value& operator()(const Value& v) const { return v; } 413 }; 414 typedef dense_hashtable<Value, Value, HashFcn, Identity, EqualKey, Alloc> ht; 415 ht rep; 416 public: typedef typename ht::key_type key_type; 417 typedef typename ht::value_type value_type; 418 typedef typename ht::size_type size_type; 419 typedef typename ht::const_iterator iterator; 420 size_type count(const key_type& key) const { 421 return rep.count(key); 422 } 423 pair<iterator, bool> insert(const value_type& obj) { 424 pair<typename ht::iterator, bool> p = rep.insert(obj); 425 } 426 size_type erase(const key_type& key) { 427 return rep.erase(key); 428 } 429}; 430class linked_ptr_internal { 431 public: bool depart() { if (next_ == this) return true; } 432 mutable linked_ptr_internal const* next_; 433}; 434template <typename T> class linked_ptr { 435 public: explicit linked_ptr(T* ptr = __null) { 436 } 437 ~linked_ptr() { depart(); } 438 T& operator*() const { } 439 T* value_; 440 linked_ptr_internal link_; 441 void depart() { 442 if (link_.depart()) delete value_; 443 } 444}; 445class blah_3 { 446 const char* ptr_; 447 int length_; 448 public: blah_3(const char* str) : ptr_(str), length_((str == __null) ? 0 : static_cast<int>(strlen(str))) { } 449}; 450class blah_5; 451class Bitmap { 452 public: Bitmap(unsigned int size) : array_size_(RequiredArraySize(size)) { } 453 static unsigned int RequiredArraySize(unsigned int num_bits) { return (num_bits + 31) >> 5; } 454 unsigned int array_size_; 455}; 456enum blah_31 { CREATIVE_FORMAT_TEXT_NARROW, kNumblah_31s }; 457enum blah_33 { BLACKLISTED }; 458template <typename EnumT> class blah_55; 459typedef blah_55<blah_31> blah_31Set; 460enum blah_36 { APPROVAL_STATUS_APPROVED, APPROVAL_STATUS_UNKNOWN }; 461enum blah_37 { hahah_INVALID, hahah_KEYWORD }; 462template<typename EnumT> class blah_55 { 463 public: blah_55(int enum_size); 464 bool Insert(EnumT x); 465 const int enum_size_; 466 Bitmap elements_; 467}; 468template<typename EnumT> blah_55<EnumT>::blah_55(int enum_size) :enum_size_(enum_size), elements_(enum_size) { 469 while (foo_1 _result = Check_GTImpl(1, 0, "enum_size" " " ">" " " "0")) blah_0(".h", 1902, _result).stream(); 470}; 471enum blah_38 { 472 ttttttt_9, }; 473class blah_46 { 474 public: blah_46() : hahaha_id_(0), type_(hahah_INVALID), approval_status_(APPROVAL_STATUS_APPROVED) { 475 } 476 blah_46(long cid) : hahaha_id_(cid), type_(hahah_INVALID), approval_status_(APPROVAL_STATUS_APPROVED) { 477 } 478 long id() const { 479 return (static_cast<long>(hahaha_id_) << 16) >> 16; 480 } 481 static const blah_46 kBlacklistedID; 482 bool operator == (const blah_46& x) const { return id() == x.id(); } 483 bool operator < (const blah_46& x) const { return id() < x.id(); } 484 long hahaha_id_ : 48; 485 blah_37 type_ : 8; 486 blah_36 approval_status_ : 4; 487}; 488template <> struct hash<blah_46> { 489 size_t operator()(const blah_46 &x) const { 490 return size_t(x.id()); 491 } 492}; 493class blah_57 { 494 public: blah_57(); 495 void AddReason(blah_33 reason, const blah_3& debug_str, const blah_46& hahaha_id, bool ); 496 void set_collects_multiple_reasons(bool t) { } 497 private: struct foo_3 { 498 string reject_desc; 499 }; 500 foo_3 first_reason_; 501}; 502template <class T> struct foo_5 : public unary_function<T*, long> { 503 long operator()(const T* p) const { 504 long id = reinterpret_cast<long>(p); 505 if (id < 2) return -id; 506 } 507}; 508template <class T> class DensePtrSet : public dense_hashtable<T*, long, hash<long>, foo_5<T>, equal_to<long>, allocator<T*> > { 509 public: DensePtrSet() { 510 this->set_deleted_key(reinterpret_cast<T*>(1)); 511 } 512 const T* Find(long key) const { 513 typename DensePtrSet<T>::const_iterator it = this->find(key); 514 return it != this->end() ? *it : __null; 515 } 516}; 517struct foo_7 { 518 foo_7(bool spell_correction, bool query_broadening, bool previous_query, bool near_aaaaa, bool same_length, float mult, float exp_score) : shengmo_0(spell_correction), shengmo_1(query_broadening), shengmo_2(previous_query), shengmo_3(near_aaaaa), shengmo_4(same_length), multiplier(mult), expansion_score(exp_score) { 519 } 520 int CompareSameKeywordMatch(const foo_7& compare) const; 521 bool shengmo_0, shengmo_1, shengmo_2, shengmo_3, shengmo_4; 522 float multiplier, expansion_score; 523}; 524enum blah_41 { 525 ACP_ECPM_EARLY = 2 }; 526struct foo_8 { unsigned int packed_ctr1; }; 527struct foo_9 { foo_9() {}}; 528class blah_16; 529class blah_17; 530class foo_12 { public: foo_12() {} 531 unsigned long hahaha_id() const {} 532 unsigned int qbb_score() const {} 533 private: static const vector<blah_46> hmmmmh_4; 534 long hahaha_id_ : 40; 535}; 536class foo_13 { 537 public: typedef dense_hash_map<long, int> BestMap; 538 foo_13() { best_rrrrrrr_.set_deleted_key(-1); } 539 void erase(long ad_group_id) { 540 best_rrrrrrr_.erase(ad_group_id); 541 } 542 typedef BestMap::iterator iterator; 543 typedef BestMap::const_iterator const_iterator; 544 const_iterator begin() const { } 545 iterator end() { return best_rrrrrrr_.end(); } 546 iterator find(long ad_group_id) { return best_rrrrrrr_.find(ad_group_id); } 547 const foo_12& GetMatch(const_iterator it) const {} 548 void hmmmmh_27(long ad_group_id, const foo_12& addme); 549 private: BestMap best_rrrrrrr_; 550 vector<foo_12> rrrrrrr_buffer_; 551}; 552struct foo_10 : public dense_hash_set<blah_46> {}; 553class foo_9Set : public DensePtrSet<foo_9> {}; 554typedef map<blah_46, foo_7*> foo_6Data; 555typedef hash_map<long, linked_ptr<blah_57> > RejectedAdGroupMap; 556enum blah_43 {}; 557class foo_14 { 558 public: foo_14(const unsigned int, const blah_16*, const int*); 559 bool GathersMultipleRejectionReasons() const; 560 void hmmmmh_30(blah_46 hahaha_id, blah_38 type); 561 const foo_7* Insertfoo_6(const blah_46 hahaha_id, bool shengmo_0, bool shengmo_1, bool shengmo_2, bool shengmo_3, bool shengmo_4_rewrite, float multiplier, float context_score); 562 void hmmmmh_7(blah_46 hahaha_id, blah_38 type); 563 foo_9* Insertfoo_9(); 564 bool hmmmmh_8(long ad_group_id, const foo_12 &entry); 565 void hmmmmh_9(long ad_group_id); 566 foo_13::iterator hmmmmh_0(long ad_group_id); 567 bool hmmmmh_8(long ad_group_id, foo_13::iterator best, const foo_12& entry); 568 void hmmmmh_5(const blah_46 hahaha_id); 569 void hmmmmh_29(const blah_46 hahaha_id); 570 bool hmmmmh_12(const blah_46 hahaha_id) const; 571 bool hmmmmh_13(const blah_46 hahaha_id) const; 572 const foo_9* Getfoo_9(const blah_46 hahaha_id) const; 573 bool Gathersfoo_9() const {} 574 const foo_10* rrrrrrr_type_data() const {} 575 const foo_10* negative_rrrrrrr_type_data() const {} 576 const foo_10* positive_rrrrrrr_type_data() const {} 577 const foo_9Set* kw_info_set() const { } 578 const foo_6Data* rewrite_data() const {} 579 const vector<blah_17>& query_rectangles() const {} 580 void hmmmmh_14(); 581 void AddQueryRectangle(const blah_17& query_rectangle); 582 void hmmmmh_15(long ad_group_id, const blah_46 hahaha_id, blah_33 reject_class, const char* reject_desc = __null); 583 void hmmmmh_16(const vector<long>& rejected_sssr_ids); 584 void Copy(const foo_14& cmi); 585 void hmmmmh_10(); 586 private: const blah_16* ad_request_; 587 const int* cr_query_; 588 blah_43 gather_flags_; 589 vector<blah_17> query_rectangles_; 590 foo_10 rrrrrrr_type_data_; 591 foo_9Set kw_info_set_; 592 foo_6Data rewrite_data_; 593 scoped_ptr<RejectedAdGroupMap> rejected_sssr_map_; 594 foo_13 ad_group_rrrrrrr_data_; 595 vector<blah_46> geo_hahaha_; 596 bool geo_hahaha_is_sorted_; 597 foo_10 negative_rrrrrrr_type_data_, positive_rrrrrrr_type_data_; 598 scoped_ptr<foo_10> extra_hahaha_set_; 599 int dimension_id_; 600 blah_31Set creative_formats_; 601 scoped_ptr<dense_hash_set<unsigned long> > near_aaaaa_rrrrrrr_fps_; 602 blah_41 comparison_policy_; 603 blah_46 next_virtual_hahaha_id_; 604 vector<void*>* sub_queries_; 605 bool allow_only_whitelisted_customers_, automatic_hahaha_rrrrrrr_; 606 scoped_ptr<blah_5> kw_arena_, expanded_rrrrrrr_arena_; 607}; 608class blah_19 { 609 void hmmmmh_3(); 610 enum blah_45 {}; 611}; 612void blah_19::hmmmmh_3() {} 613class blah_16 { 614 public: int near_aaaaa_rrrrrrr_fps_size() const {} 615 unsigned long near_aaaaa_rrrrrrr_fps(int i) const {} 616}; 617class blah_21 { 618 protected: blah_21(char* first_block, const size_t block_size, bool align_to_page); 619 void* GetMemoryFallback(const size_t size, const int align); 620 void* GetMemory(const size_t size, const int align) { 621 if ( size > 0 && size < remaining_ && align == 1 ) { 622 last_alloc_ = freestart_; 623 } 624 return GetMemoryFallback(size, align); 625 } 626 char* freestart_; 627 char* last_alloc_; 628 size_t remaining_; 629}; 630class blah_5 : blah_21 { 631 public: char* Alloc(const size_t size) { 632 return reinterpret_cast<char*>(GetMemory(size, 1)); 633 } 634}; 635class blah_25 { 636 public: virtual ~blah_25(); 637}; 638class blah_17 : blah_25 { }; 639void Fillfoo_8(const foo_12& x2, struct foo_8* out) { 640 out->packed_ctr1 = x2.qbb_score(); 641} 642const vector<blah_46> foo_12::hmmmmh_4; 643foo_14::foo_14(const unsigned int gather_flags, const blah_16* ad_request, const int* cr_query): ad_request_(ad_request), cr_query_(cr_query), gather_flags_(static_cast<blah_43>(gather_flags)), geo_hahaha_is_sorted_(false), dimension_id_(0), creative_formats_(kNumblah_31s), comparison_policy_(ACP_ECPM_EARLY), sub_queries_(new vector<void*>()), allow_only_whitelisted_customers_(false), automatic_hahaha_rrrrrrr_(false) { 644 hmmmmh_10(); 645} 646void foo_14::hmmmmh_5(const blah_46 hahaha_id) { 647 negative_rrrrrrr_type_data_.insert(hahaha_id); 648} 649void foo_14::hmmmmh_7(blah_46 hahaha_id, blah_38 type) { } 650foo_13::iterator foo_14::hmmmmh_0( long ad_group_id) { 651 return ad_group_rrrrrrr_data_.find(ad_group_id); 652} 653bool foo_14::hmmmmh_8(long ad_group_id, foo_13::iterator best, const foo_12& entry) { 654 rejected_sssr_map_->erase(ad_group_id); 655 ad_group_rrrrrrr_data_.hmmmmh_27(ad_group_id, entry); 656} 657bool foo_14::hmmmmh_8(long ad_group_id, const foo_12& entry) { 658 foo_13::iterator best = hmmmmh_0(ad_group_id); 659} 660void foo_14::hmmmmh_9(long ad_group_id) { 661 ad_group_rrrrrrr_data_.erase(ad_group_id); 662} 663void foo_14::hmmmmh_10() { 664 if (near_aaaaa_rrrrrrr_fps_ != __null) { 665 blah_54(".cc", 226, WARNING).stream() << ""; 666 for (int j = 0; 667 j < ad_request_->near_aaaaa_rrrrrrr_fps_size(); j++) { 668 near_aaaaa_rrrrrrr_fps_->insert(ad_request_->near_aaaaa_rrrrrrr_fps(j)); 669 } 670 } 671} 672const foo_7* foo_14::Insertfoo_6(const blah_46 hahaha_id, bool shengmo_0, bool shengmo_1, bool shengmo_2, bool shengmo_3, bool shengmo_4_rewrite, float multiplier, float context_score) { 673 if (rrrrrrr_type_data_.count(hahaha_id) > 0) return __null; 674 foo_7* new_info = new(expanded_rrrrrrr_arena_->Alloc(sizeof(foo_7))) foo_7(shengmo_0,shengmo_1, shengmo_2, shengmo_3, shengmo_4_rewrite, multiplier, context_score); 675 pair<foo_6Data::iterator, bool> status = rewrite_data_.insert( make_pair(hahaha_id, new_info)); 676 foo_7* inserted = status.first->second; 677 if (!status.second) { 678 if (inserted->CompareSameKeywordMatch(*new_info) < 0) *inserted = *new_info; 679 } 680} 681foo_9* foo_14::Insertfoo_9() { 682 foo_9* info = new(kw_arena_->Alloc(sizeof(foo_9))) foo_9; 683 if (Gathersfoo_9()) kw_info_set_.insert(info); 684 creative_formats_.Insert(CREATIVE_FORMAT_TEXT_NARROW); 685} 686bool foo_14::hmmmmh_12(const blah_46 hahaha_id) const { 687 if (rrrrrrr_type_data_.count(hahaha_id)) return true; 688} 689bool foo_14::hmmmmh_13(const blah_46 hahaha_id) const { 690 if (positive_rrrrrrr_type_data_.count(hahaha_id)) return true; 691} 692const foo_9* foo_14::Getfoo_9(const blah_46 hahaha_id) const { 693 if (Gathersfoo_9()) return kw_info_set_.Find(hahaha_id.id()); 694 static int occurrences_383 = 0, occurrences_mod_n_383 = 0; 695 if (++occurrences_mod_n_383 > 1000) occurrences_mod_n_383 -= 1000; 696} 697void foo_14::hmmmmh_15(long ad_group_id, const blah_46 hahaha_id, blah_33 reject_class, const char* reject_desc) { 698 if (rejected_sssr_map_ == __null) { 699 blah_54("a.cc", 413, ERROR).stream() << "re NULL"; 700 rejected_sssr_map_.reset(new RejectedAdGroupMap); 701 } 702 if (rejected_sssr_map_->count(ad_group_id) == 0) { 703 blah_57* ad_rejection = new blah_57(); 704 ad_rejection->set_collects_multiple_reasons( GathersMultipleRejectionReasons()); 705 (*rejected_sssr_map_)[ad_group_id] = linked_ptr<blah_57>(ad_rejection); 706 } 707 blah_57& ad_rejection = *(*rejected_sssr_map_)[ad_group_id]; 708 ad_rejection.AddReason(reject_class, reject_desc, hahaha_id, false); 709} 710void foo_14::hmmmmh_16(const vector<long>& rejected_sssr_ids) { 711 for (vector<long>::const_iterator it = rejected_sssr_ids.begin(); 712 it != rejected_sssr_ids.end(); ++it) { 713 ad_group_rrrrrrr_data_.erase(*it); 714 for (foo_13::const_iterator it = ad_group_rrrrrrr_data_.begin(); 715 it != ad_group_rrrrrrr_data_.end(); ++it) { 716 hmmmmh_15(it->first, ad_group_rrrrrrr_data_.GetMatch(it).hahaha_id(), BLACKLISTED); 717 } 718 } 719 hmmmmh_30(blah_46::kBlacklistedID, ttttttt_9); 720} 721void foo_14::Copy(const foo_14& cmi) { 722 rrrrrrr_type_data_ = *cmi.rrrrrrr_type_data(); 723 negative_rrrrrrr_type_data_ = *cmi.negative_rrrrrrr_type_data(); 724 positive_rrrrrrr_type_data_ = *cmi.positive_rrrrrrr_type_data(); 725 if (cmi.Gathersfoo_9()) { 726 kw_info_set_ = *cmi.kw_info_set(); 727 rewrite_data_ = *cmi.rewrite_data(); 728 } 729 hmmmmh_14(); 730 for (int i = 0; i < cmi.query_rectangles().size(); 731 ++i) AddQueryRectangle(cmi.query_rectangles()[i]); 732} 733void foo_13::hmmmmh_27(long ad_group_id, const foo_12& addme) { 734 int& best_index = best_rrrrrrr_[ad_group_id]; 735 rrrrrrr_buffer_.push_back(addme); 736} 737void foo_14::hmmmmh_29(const blah_46 hahaha_id) { 738 if (extra_hahaha_set_ != __null) extra_hahaha_set_->erase(hahaha_id); 739} 740