Gcc/linker error

Question

Hi, the code below causes a very strange error:
if compiled in debug mode with zerolink, the compiler succeeds, but the executable cannot be debugged (it crashes at runtime with a zerolink error).
if compiled in release mode, ld gives explicitly an error, it cannot find the compile-time constant NOT_FOUND.
I think the compiler successfully deduces the value of the constant, but it does not mark it as "resolved", so the linker tries to find an explicit initialization, as for any static data member.
Bizarre, if I change the line
static const position_t NOT_FOUND = (-1U);
to
static const int NOT_FOUND = (-1);
it works. some types are accepted (int, unsigned int), some are not (long, size_t, a typedef).
This is definitely a bug.
Do you know how can I post it to Apple? Thanks
M.H.
#include <algorithm>
#include <vector>
#include <valarray>
#include <stdexcept>
#include <iostream>
template <typename code_t>
class hierarchy_map
typedef unsigned int position_t;
std::vector<code_t> data_;
std::vector<position_t> father_;
public:
typedef position_t position_type;
static const position_t NOT_FOUND = (-1U);
position_type find(const code_t c) const
const position_type result = std::lowerbound(data.begin(), data_.end(), c) - data_.begin();
return data_[result] == c ? result : NOT_FOUND;
hierarchy_map(std::vector< std::pair<code_t, code_t> >& v)
: father_(v.size()), data_(v.size())
std::stable_sort(v.begin(), v.end());
for (position_type i=0;i<v.size(); ++i)
data_ = v.first;
position_type n = 0;
position_type c = NOT_FOUND;
for (position_type i=0;i<v.size(); ++i)
if (c == NOT_FOUND || father_[c] != v.second)
c = find(v.second);
father_ = c;
if (c == NOT_FOUND && (++n)>1)
throw std::logic_error("multiple roots");
v.clear();
position_type path_length(const code_t c) const
position_type cpos = find(c);
position_type n = 0;
while (cpos != NOT_FOUND)
++n;
cpos = father_[ find(data_[cpos]) ];
return n;
template <typename T>
std::valarray<T> path(const code_t c) const
const position_type n = path_length(c);
if (n==0)
throw std::outofrange("unknown code");
std::valarray<T> result(T(), n);
position_type cpos = find(c);
for (position_type i=n; i>0; )
result[--i] = cpos;
cpos = father_[ find(data_[cpos]) ];
return result;
bool less(const code_t c1, const code_t c2) const
const position_type p1 = find(c1);
const position_type p2 = find(c2);
if (p1==NOT_FOUND || p2==NOT_FOUND)
throw std::outofrange("unknown code");
return (father_[p1] == father_[p2]) && (p1 < p2);
// test if c1 is included in c2, i.e. if c1 is a child of c2
bool inclusion(const code_t c1, const code_t c2) const
const position_type p2 = find(c2);
if (p2 == NOT_FOUND)
throw std::outofrange("unknown code");
position_type p1 = find(c1);
while (p1 != NOT_FOUND)
if (p1 == p2)
return true;
p1 = father_[ find(data_[p1]) ];
return false;
// path1 is a subpath of path2 if it's longer
template <typename T>
static bool inclusion(const std::valarray<T>& path1, const std::valarray<T>& path2)
if (path1.size() < path2.size())
return false;
for (position_type i=0; i<path2.size(); ++i)
if (path1 != path2)
return false;
return true;
int main(int argc, char* argv[])
typedef std::pair<int, int> pair_t;
std::vector<pair_t> temp;
temp.pushback(pairt(232,-1));
temp.pushback(pairt(543,232));
temp.pushback(pairt(676,232));
temp.pushback(pairt(111,676));
temp.pushback(pairt(222,676));
double h = 3.14;
hierarchy_map<int> HM(temp);
std::valarray<double> p1 = HM.path<double>(111);
std::valarray<double> p2 = HM.path<double>(676);
bool t1 = hierarchy_map<int>::inclusion(p1, p2);
return 0;

Answer 1

https://bugreport.apple.com/cgi-bin/WebObjects/RadarWeb.woa
http://bugreporter.apple.com