This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: Fix for PR/39548
> I'm confused. Didn't you say that you had reduced the test case to
> ~8k upthread?
Probably some confusion. I've attached a version at 46.5K and 1035 lines.
I think this could be improved and < 1000 lines should be reachable.
--
Eric Botcazou
// PR 39548 verify ssa ICE
// { dg-do compile }
// { dg-options "-O2 -fno-exceptions -fno-tree-vrp -fprofile-generate" }
#include <map>
#include <vector>
#include <iostream>
using namespace std;
typedef unsigned int uint;
extern void free (void *);
namespace std {
template<typename _FIter, typename _Tp> _FIter lower_bound(_FIter, _FIter, const _Tp&);
}
namespace __gnu_cxx {
template<class _Key> struct hash {};
template<class _Val> struct _Hashtable_node {
_Hashtable_node* _M_next;
_Val _M_val;
};
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc> struct _Hashtable_iterator;
static const unsigned long __stl_prime_list[] = {
1610612741ul, 3221225473ul, 4294967291ul };
inline unsigned long __stl_next_prime(unsigned long __n) {
const unsigned long* __first = __stl_prime_list;
const unsigned long* __last = __stl_prime_list + 29;
const unsigned long* pos = std::lower_bound(__first, __last, __n);
return pos == __last ? *(__last - 1) : *pos;
}
template<class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, class _Alloc> class hashtable {
public: typedef _Key key_type;
typedef _Val value_type;
typedef _HashFcn hasher;
typedef _EqualKey key_equal;
typedef size_t size_type;
typedef value_type& reference;
typedef _Hashtable_node<_Val> _Node;
public: typedef typename _Alloc::template rebind<value_type>::other allocator_type;
allocator_type get_allocator() const {
}
private: typedef typename _Alloc::template rebind<_Node>::other _Node_Alloc;
typedef typename _Alloc::template rebind<_Node*>::other _Nodeptr_Alloc;
typedef vector<_Node*, _Nodeptr_Alloc> _Vector_type;
_Node_Alloc _M_node_allocator;
void _M_put_node(_Node* __p) {
_M_node_allocator.deallocate(__p, 1);
}
private: hasher _M_hash;
key_equal _M_equals;
_ExtractKey _M_get_key;
_Vector_type _M_buckets;
size_type _M_num_elements;
public: typedef _Hashtable_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc> iterator;
hashtable(size_type __n, const _HashFcn& __hf, const _EqualKey& __eql, const allocator_type& __a = allocator_type()) : _M_node_allocator(__a), _M_hash(__hf), _M_equals(__eql), _M_get_key(_ExtractKey()), _M_buckets(__a), _M_num_elements(0) {
_M_initialize_buckets(__n);
}
~hashtable() {
clear();
}
reference find_or_insert(const value_type& __obj);
size_type count(const key_type& __key) const {
const size_type __n = _M_bkt_num_key(__key);
size_type __result = 0;
for (const _Node* __cur = _M_buckets[__n];
__cur;
__cur = __cur->_M_next) if (_M_equals(_M_get_key(__cur->_M_val), __key)) ++__result;
return __result;
}
size_type erase(const key_type& __key);
void clear();
private: size_type _M_next_size(size_type __n) const {
return __stl_next_prime(__n);
}
void _M_initialize_buckets(size_type __n) {
const size_type __n_buckets = _M_next_size(__n);
_M_buckets.reserve(__n_buckets);
_M_buckets.insert(_M_buckets.end(), __n_buckets, (_Node*) 0);
_M_num_elements = 0;
}
size_type _M_bkt_num_key(const key_type& __key) const {
return _M_bkt_num_key(__key, _M_buckets.size());
}
size_type _M_bkt_num_key(const key_type& __key, size_t __n) const {
return _M_hash(__key) % __n;
}
void _M_delete_node(_Node* __n) {
this->get_allocator().destroy(&__n->_M_val);
_M_put_node(__n);
}
};
template<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) {
const size_type __n = _M_bkt_num_key(__key);
_Node* __first = _M_buckets[__n];
if (__first) {
_Node* __cur = __first;
}
}
template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All> void hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: clear() {
if (_M_num_elements == 0) return;
for (size_type __i = 0;
__i < _M_buckets.size();
++__i) {
_Node* __cur = _M_buckets[__i];
while (__cur != 0) { _Node* __next = __cur->_M_next; _M_delete_node(__cur); __cur = __next; }
_M_buckets[__i] = 0;
}
_M_num_elements = 0;
}
using std::equal_to;
}
namespace __gnu_cxx {
using std::_Select1st;
template<class _Key, class _Tp, class _HashFn = hash<_Key>, class _EqualKey = equal_to<_Key>, class _Alloc = allocator<_Tp> > class hash_map {
private: typedef hashtable<pair<const _Key, _Tp>,_Key, _HashFn, _Select1st<pair<const _Key, _Tp> >, _EqualKey, _Alloc> _Ht;
_Ht _M_ht;
public: typedef typename _Ht::key_type key_type;
typedef typename _Ht::value_type value_type;
typedef typename _Ht::hasher hasher;
typedef typename _Ht::key_equal key_equal;
typedef typename _Ht::size_type size_type;
typedef typename _Ht::allocator_type allocator_type;
hash_map() : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
_Tp& operator[](const key_type& __key) {
return _M_ht.find_or_insert(value_type(__key, _Tp())).second;
}
size_type count(const key_type& __key) const { return _M_ht.count(__key); }
size_type erase(const key_type& __key) { return _M_ht.erase(__key); }
};
}
using __gnu_cxx::hash;
using __gnu_cxx::hash_map;
typedef int int32;
typedef long long int64;
typedef unsigned int uint32;
typedef unsigned long long uint64;
extern "C" {
extern void *memset (void *__s, int __c, size_t __n);
extern size_t strlen (__const char *__s);
}
typedef unsigned long int uintptr_t;
typedef uint64 Fprint;
const Fprint kIllegalFprint = static_cast<Fprint>(0);
template <class C> class scoped_ptr {
public: typedef C element_type;
explicit scoped_ptr(C* p = __null) : ptr_(p) {
delete ptr_;
}
void reset(C* p = __null) {
if (p != ptr_) {
delete ptr_;
ptr_ = p;
}
}
C& operator*() const {}
C* operator->() const {}
C* get() const {}
bool operator==(C* p) const { return ptr_ == p; }
bool operator!=(C* p) const { return ptr_ != p; }
private: C* ptr_;
};
using std::equal_to;
using std::unary_function;
using std::ostream;
class RandomBase {};
class ACMRandom : public RandomBase {};
namespace std __attribute__ ((__visibility__ ("default"))) {
class strstreambuf : public basic_streambuf<char, char_traits<char> > {
public: public: explicit strstreambuf(streamsize __initial_capacity = 0);
};
class strstream : public basic_iostream<char> {
public: typedef char char_type;
int pcount() const;
char* str();
private: strstreambuf _M_buf;
};
}
using std::strstream;
class FlagRegisterer {
public: FlagRegisterer(const char* name, const char* type, const char* help, const char* filename, void* current_storage, void* defvalue_storage);
};
typedef int LogSeverity;
const int INFO = 0, WARNING = 1, ERROR = 2, FATAL = 3, NUM_SEVERITIES = 4;
struct foo_1 {
foo_1(string* str) : str_(str) {}
operator bool() const {
return (__builtin_expect(str_ != __null, 0));
}
string* str_;
};
inline unsigned long long GetReferenceableValue(unsigned long long t) {
}
template<class t1, class t2> string* Makefoo_1(const t1& v1, const t2& v2, const char* names) {
strstream ss;
ss << names << " (" << v1 << " vs. " << v2 << ")";
return new string(ss.str(), ss.pcount());
}
template <class t1, class t2> inline string* Check_GTImpl(const t1& v1, const t2& v2, const char* names) {
if (v1 > v2) return __null;
else return Makefoo_1(v1, v2, names);
}
class blah_54 {
public: typedef void (blah_54::*SendMethod)();
blah_54(const char* file, int line, LogSeverity severity, int ctr, SendMethod send_method);
blah_54(const char* file, int line, LogSeverity severity);
~blah_54();
void SendToLog();
ostream& stream() {
};
};
class blah_0 : public blah_54 {
public: blah_0(const char* file, int line);
blah_0(const char* file, int line, const foo_1& result);
};
template <class Value, class Key, class HashFcn, class ExtractKey, class EqualKey, class Alloc> class dense_hashtable;
template <class V, class K, class HF, class ExK, class EqK, class A> struct dense_hashtable_iterator {
public: typedef dense_hashtable_iterator<V,K,HF,ExK,EqK,A> iterator;
typedef V* pointer;
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) { if (advance) advance_past_empty_and_deleted(); }
pointer operator->() const { }
void advance_past_empty_and_deleted() {
while ( pos != end && (ht->test_empty(*this) || ht->test_deleted(*this)) ) ++pos;
}
bool operator==(const iterator& it) const { return pos == it.pos; }
bool operator!=(const iterator& it) const { }
const dense_hashtable<V,K,HF,ExK,EqK,A> *ht;
pointer pos, end;
};
template <class V, class K, class HF, class ExK, class EqK, class A> struct dense_hashtable_const_iterator {
public: typedef dense_hashtable_iterator<V,K,HF,ExK,EqK,A> iterator;
typedef dense_hashtable_const_iterator<V,K,HF,ExK,EqK,A> const_iterator;
typedef const V& reference;
typedef const V* pointer;
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) {
if (advance) advance_past_empty_and_deleted();
}
dense_hashtable_const_iterator(const iterator &it) : ht(it.ht), pos(it.pos), end(it.end) {}
reference operator*() const { return *pos; }
pointer operator->() const {}
void advance_past_empty_and_deleted() {
while ( pos != end && (ht->test_empty(*this) || ht->test_deleted(*this))) ++pos;
}
const_iterator& operator++() {
++pos;
advance_past_empty_and_deleted();
}
bool operator!=(const const_iterator& it) const {}
const dense_hashtable<V,K,HF,ExK,EqK,A> *ht;
pointer pos, end;
};
template <class Value, class Key, class HashFcn, class ExtractKey, class EqualKey, class Alloc> class dense_hashtable {
public: typedef Key key_type;
typedef Value value_type;
typedef HashFcn hasher;
typedef EqualKey key_equal;
typedef size_t size_type;
typedef dense_hashtable_iterator<Value, Key, HashFcn, ExtractKey, EqualKey, Alloc> iterator;
typedef dense_hashtable_const_iterator<Value, Key, HashFcn, ExtractKey, EqualKey, Alloc> const_iterator;
static const float HT_OCCUPANCY_FLT;
static const float HT_EMPTY_FLT;
static const size_t HT_MIN_BUCKETS = 32;
iterator end() {
return iterator(this, table + num_buckets, table + num_buckets, true);
}
const_iterator begin() const {
return const_iterator(this, table, table+num_buckets,true);
}
const_iterator end() const {
return const_iterator(this, table + num_buckets, table+num_buckets,true);
}
private: void set_value(value_type* dst, const value_type& src) {
new(dst) value_type(src);
}
void destroy_buckets(size_type first, size_type last) {
for (; first != last; ++first) table[first].~value_type();
}
private: void squash_deleted() {
if ( num_deleted ) {
dense_hashtable tmp(*this);
swap(tmp);
}
}
public: void set_deleted_key(const value_type &val) {
squash_deleted();
use_deleted = true;
use_deleted = false;
}
bool test_deleted(size_type bucknum) const {
return (use_deleted && num_deleted > 0 && equals(get_key(delval), get_key(table[bucknum])));
}
bool test_deleted(const const_iterator &it) const {
return (use_deleted && num_deleted > 0 && equals(get_key(delval), get_key(*it)));
}
bool set_deleted(const_iterator &it) {
bool retval = !test_deleted(it);
set_value(const_cast<value_type*>(&(*it)), delval);
}
public: bool test_empty(size_type bucknum) const {
return equals(get_key(emptyval), get_key(table[bucknum]));
}
bool test_empty(const const_iterator &it) const {
return equals(get_key(emptyval), get_key(*it));
}
void fill_range_with_empty(value_type* table_start, value_type* table_end) {
uninitialized_fill(table_start, table_end, emptyval);
}
void set_empty(size_type buckstart, size_type buckend) {
destroy_buckets(buckstart, buckend);
fill_range_with_empty(table + buckstart, table + buckend);
}
public: size_type size() const {
return num_elements - num_deleted;
}
size_type bucket_count() const {
return num_buckets;
}
private: static const size_type ILLEGAL_BUCKET = size_type(-1);
private: size_type min_size(size_type num_elts, size_type min_buckets_wanted) {
size_type sz = HT_MIN_BUCKETS;
while ( sz < min_buckets_wanted || num_elts >= sz * enlarge_resize_percent ) sz *= 2;
return sz;
}
void maybe_shrink() {
if (shrink_threshold > 0 && (num_elements-num_deleted) < shrink_threshold && bucket_count() > HT_MIN_BUCKETS ) {
size_type sz = bucket_count() / 2;
sz /= 2;
dense_hashtable tmp(*this, sz);
swap(tmp);
}
consider_shrink = false;
}
void resize_delta(size_type delta, size_type min_buckets_wanted = 0) {
if ( consider_shrink ) maybe_shrink();
if ( bucket_count() > min_buckets_wanted && (num_elements + delta) <= enlarge_threshold ) return;
const size_type needed_size = min_size(num_elements + delta, min_buckets_wanted);
if ( needed_size > bucket_count() ) {
const size_type resize_to = min_size(num_elements - num_deleted + delta, min_buckets_wanted);
dense_hashtable tmp(*this, resize_to);
swap(tmp);
}
}
void copy_from(const dense_hashtable &ht, size_type min_buckets_wanted = 0) {
clear();
const size_type resize_to = min_size(ht.size(), min_buckets_wanted);
if ( resize_to > bucket_count() ) {
num_elements++;
}
}
public: void resize(size_type req_elements) {
}
explicit dense_hashtable(size_type n = 0, const HashFcn& hf = HashFcn(), const EqualKey& eql = EqualKey(), const ExtractKey& ext = ExtractKey()) : hash(hf), equals(eql), get_key(ext), 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) {
reset_thresholds();
}
dense_hashtable(const dense_hashtable& ht, size_type min_buckets_wanted = 0) : hash(ht.hash), equals(ht.equals), get_key(ht.get_key), 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) {
reset_thresholds();
copy_from(ht, min_buckets_wanted);
}
dense_hashtable& operator= (const dense_hashtable& ht) {
set_value(&emptyval, ht.emptyval);
enlarge_resize_percent = ht.enlarge_resize_percent;
shrink_resize_percent = ht.shrink_resize_percent;
copy_from(ht);
}
~dense_hashtable() {
if (table) {
destroy_buckets(0, num_buckets);
free(table);
}
}
void swap(dense_hashtable& ht) {
std::swap(equals, ht.equals);
{
value_type tmp;
set_value(&tmp, delval);
set_value(&delval, ht.delval);
set_value(&ht.delval, tmp);
set_value(&ht.emptyval, tmp);
}
std::swap(table, ht.table);
std::swap(num_buckets, ht.num_buckets);
std::swap(num_elements, ht.num_elements);
reset_thresholds();
ht.reset_thresholds();
}
void clear() {
if (table) destroy_buckets(0, num_buckets);
num_buckets = min_size(0,0);
if (table) {
set_empty(0, num_buckets);
}
reset_thresholds();
num_elements = 0;
num_deleted = 0;
}
private: pair<size_type, size_type> find_position(const key_type &key) const {
const size_type bucket_count_minus_one = bucket_count() - 1;
size_type bucknum = hash(key) & bucket_count_minus_one;
size_type insert_pos = ILLEGAL_BUCKET;
while ( 1 ) {
if ( test_empty(bucknum) ) { if ( insert_pos == ILLEGAL_BUCKET ) return pair<size_type,size_type>(ILLEGAL_BUCKET, insert_pos); }
else if ( test_deleted(bucknum) ) { if ( insert_pos == ILLEGAL_BUCKET ) insert_pos = bucknum; }
else if ( equals(key, get_key(table[bucknum])) ) { return pair<size_type,size_type>(bucknum, ILLEGAL_BUCKET); }
}
}
public: iterator random_element(ACMRandom* r) {
}
iterator find(const key_type& key) {
if ( size() == 0 ) return end();
pair<size_type, size_type> pos = find_position(key);
if ( pos.first == ILLEGAL_BUCKET ) return end();
else return iterator(this, table + pos.first, table + num_buckets, false);
}
const_iterator find(const key_type& key) const {
if ( size() == 0 ) return end();
pair<size_type, size_type> pos = find_position(key);
if ( pos.first == ILLEGAL_BUCKET ) return end();
else return const_iterator(this, table + pos.first, table+num_buckets, false);
}
size_type count(const key_type &key) const {
pair<size_type, size_type> pos = find_position(key);
}
private: pair<iterator, bool> insert_noresize(const value_type& obj) {
const pair<size_type,size_type> pos = find_position(get_key(obj));
if ( pos.first != ILLEGAL_BUCKET) {
return pair<iterator,bool>(iterator(this, table + pos.first, table + num_buckets, false), false);
}
else {
if ( test_deleted(pos.second) ) { ++num_elements; }
return pair<iterator,bool>(iterator(this, table + pos.second, table + num_buckets, false), true);
}
}
public: pair<iterator, bool> insert(const value_type& obj) {
resize_delta(1);
return insert_noresize(obj);
}
size_type erase(const key_type& key) {
const_iterator pos = find(key);
if ( pos != end() ) {
set_deleted(pos);
++num_deleted;
}
}
private: hasher hash;
key_equal equals;
ExtractKey get_key;
size_type num_deleted;
bool use_deleted;
bool use_empty;
value_type delval;
value_type emptyval;
float enlarge_resize_percent;
float shrink_resize_percent;
size_type shrink_threshold;
size_type enlarge_threshold;
value_type *table;
size_type num_buckets;
size_type num_elements;
bool consider_shrink;
void reset_thresholds() {
enlarge_threshold = static_cast<size_type>(num_buckets * shrink_resize_percent);
consider_shrink = false;
}
};
template <class V, class K, class HF, class ExK, class EqK, class A> const float dense_hashtable<V,K,HF,ExK,EqK,A>::HT_EMPTY_FLT = 0.4f * dense_hashtable<V,K,HF,ExK,EqK,A>::HT_OCCUPANCY_FLT;
namespace __gnu_cxx {
template<> struct hash<int64> {
size_t operator()(int64 x) const {}
};
template<> struct hash<uint64> {
size_t operator()(uint64 x) const {}
};
}
template <class Key, class T, class HashFcn = hash<Key>, class EqualKey = equal_to<Key>, class Alloc = allocator<T> > class dense_hash_map {
private: struct SelectKey {
const Key& operator()(const pair<const Key, T>& p) const { return p.first; }
};
typedef dense_hashtable<pair<const Key, T>, Key, HashFcn, SelectKey, EqualKey, Alloc> ht;
ht rep;
public: typedef typename ht::key_type key_type;
typedef T data_type;
typedef typename ht::value_type value_type;
typedef typename ht::size_type size_type;
typedef typename ht::iterator iterator;
typedef typename ht::const_iterator const_iterator;
iterator end() { return rep.end(); }
const_iterator begin() const { return rep.begin(); }
void clear() { rep.clear(); }
iterator find(const key_type& key) { return rep.find(key); }
data_type& operator[](const key_type& key) {
iterator it = find(key);
if (it != end()) {
return insert(value_type(key, data_type())).first->second;
}
}
pair<iterator, bool> insert(const value_type& obj) {
return rep.insert(obj);
}
void set_deleted_key(const key_type& key) {
rep.set_deleted_key(value_type(key, data_type()));
}
size_type erase(const key_type& key) { return rep.erase(key); }
};
template <class Value, class HashFcn = hash<Value>, class EqualKey = equal_to<Value>, class Alloc = allocator<Value> > class dense_hash_set {
private: struct Identity {
const Value& operator()(const Value& v) const { return v; }
};
typedef dense_hashtable<Value, Value, HashFcn, Identity, EqualKey, Alloc> ht;
ht rep;
public: typedef typename ht::key_type key_type;
typedef typename ht::value_type value_type;
typedef typename ht::size_type size_type;
typedef typename ht::const_iterator iterator;
size_type count(const key_type& key) const { return rep.count(key); }
pair<iterator, bool> insert(const value_type& obj) {
pair<typename ht::iterator, bool> p = rep.insert(obj);
}
void set_empty_key(const key_type& key) {}
void set_deleted_key(const key_type& key) { rep.set_deleted_key(key); }
size_type erase(const key_type& key) {
return rep.erase(key);
}
};
class linked_ptr_internal {
public: void join_new() {}
bool depart() { if (next_ == this) return true; }
private: mutable linked_ptr_internal const* next_;
};
template <typename T> class linked_ptr {
public: typedef T element_type;
explicit linked_ptr(T* ptr = __null) {}
~linked_ptr() { depart(); }
void reset(T* ptr = __null) { depart(); }
T* get() const {}
T& operator*() const {}
private: T* value_;
linked_ptr_internal link_;
void depart() { if (link_.depart()) delete value_; }
};
template <class R, class A1> class blah_2 {
public: virtual ~blah_2() {}
virtual R Run(A1) = 0;
};
class blah_3 {
private: const char* ptr_;
int length_;
public: blah_3() {}
blah_3(const char* str) : ptr_(str), length_((str == __null) ? 0 : static_cast<int>(strlen(str))) {}
};
class blah_5;
class Bitmap {
public: Bitmap(uint32 size, bool fill) : array_size_(RequiredArraySize(size)) {}
void SetAll(bool value) {
memset(map_, (value ? 0xFF : 0x00), array_size_ * sizeof(*map_));
}
void Clear() { SetAll(false); }
static uint32 RequiredArraySize(uint32 num_bits) {
return (num_bits + kIntBits - 1) >> kLogIntBits;
}
static const int kIntBits = 32;
static const int kLogIntBits = 5;
uint32* map_;
uint32 array_size_;
};
enum blah_31 {
CREATIVE_FORMAT_TEXT_NARROW = 1, CREATIVE_FORMAT_IMAGE = 2, kNumblah_31s = 13 };
enum blah_32 {
ttttttt_0 = 0, ttttttt_1 = 1, ttttttt_2 = 2, ttttttt_3 };
enum blah_52 {
ttttttt_4 = 0, ttttttt_5 = 1, ttttttt_6 = 2, ttttttt_7 = 3, };
enum blah_33 {
REJECTION_CLASS_UNDEFINED = 0, NOT_REJECTED, BELOWCPM, BLACKLISTED, };
template <typename EnumT> class blah_55;
typedef blah_55<blah_31> blah_31Set;
enum blah_35 {
FAMILY_SAFE, };
enum blah_36 {
APPROVAL_STATUS_APPROVED, APPROVAL_STATUS_UNKNOWN };
enum blah_37 {
hahah_INVALID = 0, hahah_KEYWORD = 1, hahah_PHRASE = 2, hahah_PROXIMITY_TARGET = 15, hahah_POLYGON_TARGET = 16, pppp_CPC_LIVE, BAD_MIN_CPC_UNKNOWN };
template<typename EnumT> class blah_55 {
public: blah_55(int enum_size);
bool Insert(EnumT x);
void Clear() {
elements_.Clear();
}
const int enum_size_;
Bitmap elements_;
};
template<typename EnumT> blah_55<EnumT>::blah_55(int enum_size) : enum_size_(enum_size), elements_(enum_size, false) {
while (foo_1 _result = Check_GTImpl(GetReferenceableValue(enum_size), GetReferenceableValue(0), "enum_size" " " ">" " " "0")) blah_0(".h", 1902, _result).stream();
};
enum blah_38 {
ttttttt_8 = 0, ttttttt_9 = 10, ttttttt_10 = 11, ttttttt_11 = 0, ttttttt_12 = 1, ttttttt_13 = ttttttt_12, };
class blah_46 {
public: static const int kNone = 0;
blah_46() : hahaha_id_(0), type_(hahah_INVALID), approval_status_(APPROVAL_STATUS_APPROVED) {
}
blah_46(int64 cid) : hahaha_id_(cid), type_(hahah_INVALID), approval_status_(APPROVAL_STATUS_APPROVED) {
}
int64 id() const {
return (static_cast<int64>(hahaha_id_) << 16) >> 16;
}
static const blah_46 kBlacklistedID;
bool operator == (const blah_46& x) const { return id() == x.id(); }
bool operator < (const blah_46& x) const { return id() < x.id(); }
friend ostream& operator<<(ostream &s, const blah_46 &x) { return s << x.id(); }
private: int64 hahaha_id_ : 48;
blah_37 type_ : 8;
blah_36 approval_status_ : 4;
};
namespace __gnu_cxx {
template <> struct hash<blah_46> {
size_t operator()(const blah_46 &x) const { return size_t(x.id()); }
};
}
class blah_57 {
public: blah_57();
void AddReason(blah_33 reason, const blah_3& debug_str, const blah_46& hahaha_id, bool );
void set_collects_multiple_reasons(bool t) {
collects_multiple_reasons_ = t;
}
private: struct foo_3 { string reject_desc; };
bool collects_multiple_reasons_;
foo_3 first_reason_;
};
template <class T> struct foo_5 : public unary_function<T*, int64> {
int64 operator()(const T* p) const {
uintptr_t id = reinterpret_cast<uintptr_t>(p);
if (id < 2) return -id;
}
};
template <class T> class DensePtrSet : public dense_hashtable<T*, int64, hash<int64>, foo_5<T>, equal_to<int64>, allocator<T*> > {
public: DensePtrSet() {
this->set_deleted_key(reinterpret_cast<T*>(1));
}
const T* Find(int64 key) const {
typename DensePtrSet<T>::const_iterator it = this->find(key);
return it != this->end() ? *it : __null;
}
};
enum blah_40 { AS_APPROVED = 0, AS_AUTOMATIC = 2, AS_INVALID = 7 };
struct foo_6 { int count; };
struct foo_7 {
foo_7( const foo_6* r, 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) {
}
int CompareSameKeywordMatch(const foo_7& compare) const;
foo_6 related_words_rewrites;
bool shengmo_0;
bool shengmo_1;
bool shengmo_2;
bool shengmo_3;
bool shengmo_4;
float multiplier;
float expansion_score;
};
class foo_12;
class blah_7;
namespace hmmmmh_2 {
enum blah_41 {
ACP_DEFAULT = 0, ACP_ECPM_LATE = 1, ACP_ECPM_EARLY = 2, CALLBACK_BASED_EARLY = 3, ACP_ECPM_EARLY_NO_QB = 4, };
}
struct foo_8 {
foo_8() : agmi1(__null), agmi2(__null), sssr_id(0), packed_ctr1(0) {
}
const foo_12* agmi1;
const foo_12* agmi2;
int64 sssr_id;
uint32 packed_ctr1;
};
typedef blah_2< int, const struct foo_8&> AGCTiebreakerCallback;
class blah_8 {
public: enum blah_42 {
ttttttt_14 = 0, ttttttt_15 = 1, ttttttt_16 = 2, ttttttt_17 = 5, ttttttt_18 = 6, ttttttt_2_REWRITE = 7, ttttttt_20 = 16, };
};
struct foo_9 {
foo_9() {}
const foo_7* expanded_rrrrrrr_info;
};
class blah_13 {};
class blah_14 {
public: blah_14();
~blah_14();
};
namespace hmmmmh_1 {
class blah_15;
}
class blah_16;
class foo_14;
class blah_17;
class foo_12 {
public: foo_12() {}
uint64 hahaha_id() const { return hahaha_id_; }
const foo_9* kw_info() const {}
blah_32 query_coverage() const {}
blah_8::blah_42 rrrrrrr_type() const {}
const foo_7* expanded_rrrrrrr_info() const {
return kw_info_->expanded_rrrrrrr_info; }
bool shengmo_1() const {
return expanded_rrrrrrr_info() && expanded_rrrrrrr_info()->shengmo_1;
}
bool shengmo_6() const {
return expanded_rrrrrrr_info() && expanded_rrrrrrr_info()->shengmo_2;
}
bool shengmo_3_rrrrrrr() const {
return expanded_rrrrrrr_info() && expanded_rrrrrrr_info()->shengmo_3;
}
bool shengmo_8() const { return agc_status_ == AS_AUTOMATIC; }
uint32 qbb_score() const {}
blah_14* hmmmmh_22();
bool shengmo_9() const {}
int shengmo_10() const { if (shengmo_9()) return shengmo_10_; }
int hmmmmh_21(const foo_12& x, bool shengmo_11) const;
int Compare(const foo_12& x, AGCTiebreakerCallback* c, bool shengmo_11, int64 ad_group_id) const;
int hmmmmh_24(const foo_12& x, const foo_14& cmi, AGCTiebreakerCallback* c, int64 ad_group_id) const;
int hmmmmh_23(const foo_12& x, const foo_14& cmi, AGCTiebreakerCallback* c, int64 ad_group_id) const;
private: static const vector<blah_46> hmmmmh_4;
static const foo_9 kEmptyfoo_9;
int64 hahaha_id_ : 40;
int shengmo_10_ : 11;
blah_40 agc_status_ : 3;
const foo_9* kw_info_;
linked_ptr<blah_14> best_geo_rrrrrrr_;
int32 alternate_index_;
friend class foo_13;
};
class foo_13 {
public: typedef dense_hash_map<int64, int> BestMap;
foo_13() { best_rrrrrrr_.set_deleted_key(-1); }
void clear() {
best_rrrrrrr_.clear();
rrrrrrr_buffer_.clear();
}
void erase(int64 ad_group_id) { best_rrrrrrr_.erase(ad_group_id); }
typedef BestMap::iterator iterator;
typedef BestMap::const_iterator const_iterator;
const_iterator begin() const { return best_rrrrrrr_.begin(); }
iterator end() { return best_rrrrrrr_.end(); }
iterator find(int64 ad_group_id) {
return best_rrrrrrr_.find(ad_group_id);
}
const foo_12& GetMatch(const_iterator it) const {
return rrrrrrr_buffer_[it->second];
}
void hmmmmh_27(int64 ad_group_id, const foo_12& addme);
bool hmmmmh_28(iterator best_rrrrrrr, const foo_12& addme);
bool AddAlternateMatch(iterator best_rrrrrrr, const foo_12& addme);
const foo_12* hmmmmh_25(const foo_12& ag_rrrrrrr) const;
foo_12* hmmmmh_26(foo_12* ag_rrrrrrr, foo_14* cmi, int64 ad_group_id);
private: BestMap best_rrrrrrr_;
vector<foo_12> rrrrrrr_buffer_;
};
struct foo_10 : public dense_hash_set<blah_46> {
};
class foo_9Set : public DensePtrSet<foo_9> {
};
typedef map<blah_46, foo_7*> foo_6Data;
typedef hash_map<int64, linked_ptr<blah_57> > RejectedAdGroupMap;
class blah_18 {
};
enum blah_43 {
GATHER_KEYWORD_INFO = 2, GATHER_REWRITES = 4, GATHER_LOCAL_NAMES = 8, GATHER_REJECTED_AD_GROUPS = 16, GATHER_EXPERIMENT_SOURCE = 32 };
class foo_14 {
public: foo_14(const uint32 gather_flags, const blah_16* ad_request, const hmmmmh_1::blah_15* cr_query);
bool GathersMultipleRejectionReasons() const;
void hmmmmh_30(blah_46 hahaha_id, blah_38 type);
const foo_7* Insertfoo_6( const blah_46 hahaha_id, const foo_6* related_words_rewrites, bool shengmo_0, bool shengmo_1, bool shengmo_2, bool shengmo_3, bool shengmo_4_rewrite, float multiplier, float context_score);
void hmmmmh_6(blah_46 hahaha_id, blah_38 type);
void hmmmmh_7(blah_46 hahaha_id, blah_38 type);
foo_9* Insertfoo_9( const blah_46 hahaha_id, const Fprint keyword_fp, blah_32 query_coverage, blah_8::blah_42 rrrrrrr_type, int shengmo_10, uint phrase_mask, const blah_18* sub_query, const foo_7* expanded_rrrrrrr_info, int significant_phrase_weight, float keyword_ctr, const char* kw_text);
bool hmmmmh_8(int64 ad_group_id, const foo_12 &entry);
void hmmmmh_9(int64 ad_group_id);
foo_13::iterator hmmmmh_0(int64 ad_group_id);
bool hmmmmh_8(int64 ad_group_id, foo_13::iterator best, const foo_12& entry);
void hmmmmh_5(const blah_46 hahaha_id);
void hmmmmh_29(const blah_46 hahaha_id);
bool hmmmmh_12(const blah_46 hahaha_id) const;
bool hmmmmh_13(const blah_46 hahaha_id) const;
const foo_9* Getfoo_9(const blah_46 hahaha_id) const;
bool Gathersfoo_9() const {
return gather_flags_ & GATHER_KEYWORD_INFO;
}
bool GathersRejectedAdGroups() const {
return gather_flags_ & GATHER_REJECTED_AD_GROUPS;
}
const foo_10* rrrrrrr_type_data() const {}
const foo_10* negative_rrrrrrr_type_data() const {}
const foo_10* positive_rrrrrrr_type_data() const {}
const foo_9Set* kw_info_set() const {}
const foo_6Data* rewrite_data() const {}
void hmmmmh_17(int count, const int32* values);
void hmmmmh_18(blah_31 creative_format);
const vector<blah_17>& query_rectangles() const {}
void hmmmmh_14();
void AddQueryRectangle(const blah_17& query_rectangle);
bool hmmmmh_11(Fprint fp) const;
void hmmmmh_15(int64 ad_group_id, const blah_46 hahaha_id, blah_33 reject_class, const char* reject_desc = __null);
void hmmmmh_16(const vector<int64>& rejected_sssr_ids);
void Copy(const foo_14& cmi);
int hmmmmh_19(const foo_12& x, const foo_12& y) const;
int hmmmmh_20(const foo_12& x, const foo_12& y, int64 ad_group_id) const;
int CompareKeywordlessfoo_12(const foo_12& x, const foo_12& y) const;
bool automatic_hahaha_rrrrrrr() const {}
void set_automatic_hahaha_rrrrrrr(bool automatic_hahaha_rrrrrrr) {
automatic_hahaha_rrrrrrr_ = automatic_hahaha_rrrrrrr;
}
void hmmmmh_10();
private: const blah_16* ad_request_;
const hmmmmh_1::blah_15* cr_query_;
blah_43 gather_flags_;
vector<blah_17> query_rectangles_;
foo_10 rrrrrrr_type_data_;
foo_9Set kw_info_set_;
foo_6Data rewrite_data_;
scoped_ptr<RejectedAdGroupMap> rejected_sssr_map_;
foo_13 ad_group_rrrrrrr_data_;
vector<blah_46> geo_hahaha_;
bool geo_hahaha_is_sorted_;
foo_10 negative_rrrrrrr_type_data_;
foo_10 positive_rrrrrrr_type_data_;
scoped_ptr<foo_10> extra_hahaha_set_;
int dimension_id_;
blah_31Set creative_formats_;
scoped_ptr<dense_hash_set<Fprint> > near_aaaaa_rrrrrrr_fps_;
hmmmmh_2::blah_41 comparison_policy_;
blah_46 next_virtual_hahaha_id_;
AGCTiebreakerCallback* agc_tiebreaker_cb_;
vector<blah_18*>* sub_queries_;
bool allow_only_whitelisted_customers_;
bool automatic_hahaha_rrrrrrr_;
scoped_ptr<blah_5> kw_arena_;
scoped_ptr<blah_5> expanded_rrrrrrr_arena_;
};
class foo_11 {
struct RoleSet {
RoleSet() { }
dense_hash_set<string> roles_;
};
};
class blah_19 {
void hmmmmh_3();
enum blah_45 {
DEFAULT_DISABLED, DEFAULT_ENABLED, DEFAULT_FORCED, DEFAULT_SUSPENDED, DEFAULT_SUSPENDED_CAN_UNSUSPEND };
blah_45 default_protocol_state_;
};
void blah_19::hmmmmh_3() {
if (default_protocol_state_ != DEFAULT_DISABLED && default_protocol_state_ != DEFAULT_FORCED) {
default_protocol_state_ = DEFAULT_SUSPENDED;
}
}
class blah_16 : blah_13 {
public:
int near_aaaaa_rrrrrrr_fps_size() const {}
uint64 near_aaaaa_rrrrrrr_fps(int i) const {}
};
class blah_21 {
protected: blah_21(char* first_block, const size_t block_size, bool align_to_page);
void* GetMemoryFallback(const size_t size, const int align);
void* GetMemory(const size_t size, const int align) {
if ( size > 0 && size < remaining_ && align == 1 ) {
last_alloc_ = freestart_;
freestart_ += size;
remaining_ -= size;
}
return GetMemoryFallback(size, align);
}
void ReturnMemory(void* memory, const size_t size) {
if ( memory == last_alloc_ && size == freestart_ - last_alloc_ ) {
remaining_ += size;
}
}
char* freestart_;
char* last_alloc_;
size_t remaining_;
};
class blah_5 : blah_21 {
public: char* Alloc(const size_t size) {
return reinterpret_cast<char*>(GetMemory(size, 1));
}
void Free(void* memory, size_t size) {
ReturnMemory(memory, size);
}
};
class blah_25 { public: virtual ~blah_25(); };
class blah_17 : blah_25 {};
static const int32 uuuuuuuuuu_0 = 32768;
int32 uuuuuuuuuu_1 = uuuuuuuuuu_0;
int32 uuuuuuuuuu_2 = uuuuuuuuuu_0;
static FlagRegisterer o_ternate_rrrrrrres( "m", "i", "a" "n", "a", &uuuuuuuuuu_1, &uuuuuuuuuu_2);
static const bool uuuuuuuuuu_3 = true;
bool uuuuuuuuuu_4 = uuuuuuuuuu_3;
bool uuuuuuuuuu_5 = uuuuuuuuuu_3;
static FlagRegisterer o_gather_multiple_rejection_reasons( "g", "b", "w" "d", "a", &uuuuuuuuuu_4, &uuuuuuuuuu_5);
void Fillfoo_8(const foo_12& x1, const foo_12& x2, const int& ad_group_id, struct foo_8* out) { out->packed_ctr1 = x2.qbb_score(); }
const vector<blah_46> foo_12::hmmmmh_4;
const foo_9 foo_12::kEmptyfoo_9;
foo_14::foo_14( const uint32 gather_flags, const blah_16* ad_request, const hmmmmh_1::blah_15* cr_query): ad_request_(ad_request), cr_query_(cr_query), gather_flags_(static_cast<blah_43>(gather_flags)), geo_hahaha_is_sorted_(false), extra_hahaha_set_(__null), dimension_id_(0), creative_formats_(kNumblah_31s), near_aaaaa_rrrrrrr_fps_(__null), comparison_policy_(hmmmmh_2::ACP_ECPM_EARLY), agc_tiebreaker_cb_(__null), sub_queries_(new vector<blah_18*>()), allow_only_whitelisted_customers_(false), automatic_hahaha_rrrrrrr_(false) {
hmmmmh_10();
}
void foo_14::hmmmmh_5(const blah_46 hahaha_id) {
if (extra_hahaha_set_ == __null) {
extra_hahaha_set_.reset(new foo_10());
extra_hahaha_set_->set_deleted_key(blah_46(-1));
}
extra_hahaha_set_->insert(hahaha_id);
}
void foo_14::hmmmmh_6(blah_46 hahaha_id, blah_38 type) {
negative_rrrrrrr_type_data_.insert(hahaha_id);
}
void foo_14::hmmmmh_7(blah_46 hahaha_id, blah_38 type) {
hmmmmh_30(hahaha_id, type);
positive_rrrrrrr_type_data_.insert(hahaha_id);
}
foo_13::iterator foo_14::hmmmmh_0( int64 ad_group_id) {
return ad_group_rrrrrrr_data_.find(ad_group_id);
}
bool foo_14::hmmmmh_8(int64 ad_group_id, foo_13::iterator best, const foo_12& entry) {
if (GathersRejectedAdGroups()) {
rejected_sssr_map_->erase(ad_group_id);
}
if (best == ad_group_rrrrrrr_data_.end()) {
ad_group_rrrrrrr_data_.hmmmmh_27(ad_group_id, entry);
}
return ad_group_rrrrrrr_data_.AddAlternateMatch(best, entry);
}
bool foo_14::hmmmmh_8(int64 ad_group_id, const foo_12& entry) {
foo_13::iterator best = hmmmmh_0(ad_group_id);
return hmmmmh_8(ad_group_id, best, entry);
}
void foo_14::hmmmmh_9(int64 ad_group_id) {
ad_group_rrrrrrr_data_.erase(ad_group_id);
}
void foo_14::hmmmmh_10() {
if (near_aaaaa_rrrrrrr_fps_ != __null) {
blah_54(".cc", 226, WARNING).stream() << "";
near_aaaaa_rrrrrrr_fps_.reset(new dense_hash_set<Fprint>);
for (int j = 0; j < ad_request_->near_aaaaa_rrrrrrr_fps_size(); j++) {
near_aaaaa_rrrrrrr_fps_->insert(ad_request_->near_aaaaa_rrrrrrr_fps(j));
}
}
}
const foo_7* foo_14::Insertfoo_6( const blah_46 hahaha_id, const foo_6* related_words_rewrites, bool shengmo_0, bool shengmo_1, bool shengmo_2, bool shengmo_3, bool shengmo_4_rewrite, float multiplier, float context_score) {
if (rrrrrrr_type_data_.count(hahaha_id) > 0) {
return __null;
}
foo_7* new_info = new(expanded_rrrrrrr_arena_->Alloc(sizeof(foo_7))) foo_7( related_words_rewrites, shengmo_0, shengmo_1, shengmo_2, shengmo_3, shengmo_4_rewrite, multiplier, context_score);
pair<foo_6Data::iterator, bool> status = rewrite_data_.insert( make_pair(hahaha_id, new_info));
foo_7* inserted = status.first->second;
if (!status.second) {
if (inserted->CompareSameKeywordMatch(*new_info) < 0) {
*inserted = *new_info;
}
expanded_rrrrrrr_arena_->Free(new_info, sizeof(foo_7));
}
}
foo_9* foo_14::Insertfoo_9(const blah_46 hahaha_id, const Fprint keyword_fp, blah_32 query_coverage, blah_8::blah_42 rrrrrrr_type, int shengmo_10, uint phrase_mask, const blah_18* sub_query, const foo_7* expanded_rrrrrrr_info, int significant_phrase_weight, float keyword_ctr, const char* kw_text) {
foo_9* info = new(kw_arena_->Alloc(sizeof(foo_9))) foo_9;
if (Gathersfoo_9()) {
kw_info_set_.insert(info);
}
creative_formats_.Insert(CREATIVE_FORMAT_TEXT_NARROW);
}
bool foo_14::hmmmmh_12(const blah_46 hahaha_id) const {
if (rrrrrrr_type_data_.count(hahaha_id)) return true;
}
bool foo_14::hmmmmh_13( const blah_46 hahaha_id) const {
if (positive_rrrrrrr_type_data_.count(hahaha_id)) {
return true;
}
}
const foo_9* foo_14::Getfoo_9( const blah_46 hahaha_id) const {
if (Gathersfoo_9()) {
return kw_info_set_.Find(hahaha_id.id());
}
static int occurrences_383 = 0, occurrences_mod_n_383 = 0;
++occurrences_383;
if (++occurrences_mod_n_383 > 1000) occurrences_mod_n_383 -= 1000;
}
void foo_14::hmmmmh_15(int64 ad_group_id, const blah_46 hahaha_id, blah_33 reject_class, const char* reject_desc) {
if (!GathersRejectedAdGroups()) return;
if (rejected_sssr_map_ == __null) {
blah_54("a.cc", 413, ERROR).stream() << "re NULL";
rejected_sssr_map_.reset(new RejectedAdGroupMap);
}
if (rejected_sssr_map_->count(ad_group_id) == 0) {
blah_57* ad_rejection = new blah_57();
ad_rejection->set_collects_multiple_reasons( GathersMultipleRejectionReasons());
(*rejected_sssr_map_)[ad_group_id] = linked_ptr<blah_57>(ad_rejection);
}
blah_57& ad_rejection = *(*rejected_sssr_map_)[ad_group_id];
ad_rejection.AddReason(reject_class, reject_desc, hahaha_id, false);
}
void foo_14::hmmmmh_16(const vector<int64>& rejected_sssr_ids) {
for (vector<int64>::const_iterator it = rejected_sssr_ids.begin();
it != rejected_sssr_ids.end(); ++it) {
ad_group_rrrrrrr_data_.erase(*it);
for (foo_13::const_iterator it = ad_group_rrrrrrr_data_.begin();
it != ad_group_rrrrrrr_data_.end(); ++it) {
hmmmmh_15(it->first, ad_group_rrrrrrr_data_.GetMatch(it).hahaha_id(), BLACKLISTED);
}
}
ad_group_rrrrrrr_data_.clear();
hmmmmh_30(blah_46::kBlacklistedID, ttttttt_9);
}
void foo_14::Copy(const foo_14& cmi) {
rrrrrrr_type_data_ = *cmi.rrrrrrr_type_data();
negative_rrrrrrr_type_data_ = *cmi.negative_rrrrrrr_type_data();
positive_rrrrrrr_type_data_ = *cmi.positive_rrrrrrr_type_data();
if (cmi.Gathersfoo_9()) {
kw_info_set_ = *cmi.kw_info_set();
rewrite_data_ = *cmi.rewrite_data();
}
hmmmmh_14();
for (int i = 0; i < cmi.query_rectangles().size(); ++i)
AddQueryRectangle(cmi.query_rectangles()[i]);
}
void foo_13::hmmmmh_27(int64 ad_group_id, const foo_12& addme) {
int& best_index = best_rrrrrrr_[ad_group_id];
best_index = rrrrrrr_buffer_.size();
rrrrrrr_buffer_.push_back(addme);
}
void foo_14::hmmmmh_29(const blah_46 hahaha_id) {
if (extra_hahaha_set_ != __null) {
extra_hahaha_set_->erase(hahaha_id);
}
}