Re: emitting templates as 'T'? Changed from 3.2 to 3.3

Re: emitting templates as 'T'? Changed from 3.2 to 3.3

[Benjamin Kosnik]

This is a bit surprising, but it's kind of hard to tell what is going on.

If possible, you'll need to make a small test case that shows clearly
what is going on, instead of pointing people to a large project. Then,
you can take that 10-15 line source and enter it into bugzilla.

best,
benjamin

templated specializations get emitted in 3.3?

[bert hubert]

[-- Attachment #1: Type: text/plain, Size: 1053 bytes --]

On Tue, May 27, 2003 at 02:47:33PM -0500, Benjamin Kosnik wrote:
> 
> This is a bit surprising, but it's kind of hard to tell what is going on.
> 
> If possible, you'll need to make a small test case that shows clearly
> what is going on, instead of pointing people to a large project. Then,
> you can take that 10-15 line source and enter it into bugzilla.

Ok, I've isolated the issue, which I'm unsure is a bug at all. GCC 3.3 emits
specialized template methods as regular text symbols.

2.95 and 3.3 do not emit the specialization at all, as far as I can see.

I've attached a small tar.gz which exhibits this. The only real issue
probably is if and where this change in behaviour is documented, and if
there is a way to get the old semantics back.

If this is a bug, I'll file it in bugzilla. Please CC me on any replies as
I'm not on the list and only browse the archives every so often.

		Bert

-- 
http://www.PowerDNS.com      Open source, database driven DNS Software 
http://lartc.org           Linux Advanced Routing & Traffic Control HOWTO

[-- Attachment #2: gcc-issue.tar.gz --]
[-- Type: application/octet-stream, Size: 545 bytes --]

Re: templated specializations get emitted in 3.3?

[Benjamin Kosnik]

I don't think this is a bug. 

What you are doing is providing a definition of a non-inlined member
specialization in a header file: this is just like putting a definition
of a non-inlined class member function in a header. 

Behavior of this has definitely changed, but the current behavior seem
defensible. Note if you add "inline" you'll have consistent behavior.

-benjamin



template<class X> class Box
{
  X content;

public:
  Box()
  { content=0; }

  int print() { return 0; }
};

template<> 
//int
inline int
Box<long>::print() 
{ return 1; }


// g++ head
// default : T
// inline : (no symbol)

// g++ 3.2.2
// default : (no symbol)
// inline : (no symbol)

// icc 7.1
// default : W
/*
00000000 W Box<long>::print()
00000000 d _ZN3BoxIlE5printEv$$LSDA
*/
// inline : (no symbol)

Re: templated specializations get emitted in 3.3?

[Joe Buck]

On Wed, May 28, 2003 at 03:43:27PM -0500, Benjamin Kosnik wrote:
> I don't think this is a bug. 
> 
> What you are doing is providing a definition of a non-inlined member
> specialization in a header file: this is just like putting a definition
> of a non-inlined class member function in a header. 

If that header is included in two or more compilation units, it is a bug
in the user's program (violation of the one-definition rule).

> Behavior of this has definitely changed, but the current behavior seem
> defensible. Note if you add "inline" you'll have consistent behavior.

That seems like the right fix.

Re: templated specializations get emitted in 3.3?

[bert hubert]

On Wed, May 28, 2003 at 02:12:09PM -0700, Joe Buck wrote:
> On Wed, May 28, 2003 at 03:43:27PM -0500, Benjamin Kosnik wrote:

> > What you are doing is providing a definition of a non-inlined member
> > specialization in a header file: this is just like putting a definition
> > of a non-inlined class member function in a header. 
> 
> If that header is included in two or more compilation units, it is a bug
> in the user's program (violation of the one-definition rule).

Ok, thank you both for resolving this so swiftly. I'll be sending the ISIP
authors a patch moving the specializations to inline. I hope google will be
picking up on this conversation as this is a major change of behaviour for
g++ between 3.2 and higher, which is only sparsely documented - even if it
was a misfeature before.

This behavior makes infinitely more sense.

Regards,

bert

-- 
http://www.PowerDNS.com      Open source, database driven DNS Software 
http://lartc.org           Linux Advanced Routing & Traffic Control HOWTO

Re: emitting templates as 'T'? Changed from 3.2 to 3.3

[bert hubert]

Apologies, 

The platform is Debian Unstable on a regular Intel PC:

~$ g++ -v
Reading specs from /usr/lib/gcc-lib/i386-linux/3.3/specs
Configured with: ../src/configure -v
--enable-languages=c,c++,java,f77,pascal,objc,ada,treelang --prefix=/usr
--mandir=/usr/share/man --infodir=/usr/share/info
--with-gxx-include-dir=/usr/include/c++/3.3 --enable-shared
--with-system-zlib --enable-nls --without-included-gettext
--enable-__cxa_atexit --enable-clocale=gnu --enable-debug
--enable-java-gc=boehm --enable-java-awt=xlib --enable-objc-gc i386-linux
Thread model: posix
gcc version 3.3 (Debian)
~$ ld -v
GNU ld version 2.14.90.0.2 20030515 Debian GNU/Linux


The problem does not always exist - a regular small template example creates
W symbols.

Regards,

bert

> You've left out one important piece of information: What platform is
> this?

> On Tue, May 27, 2003 at 04:48:31PM +0200, bert hubert wrote:
>> [previously posted to bugs@gcc.gnu.org which I since realised is mostly the
>> output of bugzilla, and perhaps not the most apropriate forum for my
>> question]

-- 
http://www.PowerDNS.com      Open source, database driven DNS Software 
http://lartc.org           Linux Advanced Routing & Traffic Control HOWTO

Re: emitting templates as 'T'? Changed from 3.2 to 3.3

[Daniel Jacobowitz]

You've left out one important piece of information: What platform is
this?

On Tue, May 27, 2003 at 04:48:31PM +0200, bert hubert wrote:
> [previously posted to bugs@gcc.gnu.org which I since realised is mostly the
> output of bugzilla, and perhaps not the most apropriate forum for my
> question]
> 
> Hi,
> 
> I'm trying to move the ISIP production system
> http://www.isip.msstate.edu/projects/speech/software/ to g++ 3.3 and
> am encountering some problems.
> 
> It appears that where g++ 3.2 did not emit a lot of template functions to
> the .o as 'T', 3.3 often does.
> 
> A somewhat mangled version of the diff between the outputs of nm is below,
> lots of weak symbols suddenly becoming T. This is based on:
> 
> ~/cvs/ISIP/class/math/scalar/MScalar$ g++
> -I/home/ahu/cvs/include -Wall -ftemplate-depth-50 -c -O6 -o
> mscl_02.float.float32~complex-3.3.o mscl_02.cc
> -DISIP_TEMPLATE_TARGET=float,float32 -DISIP_TEMPLATE_T0=float
> -DISIP_TEMPLATE_T1=float32 -DISIP_TEMPLATE_T2=mscl_02.float.float32
> -DISIP_TEMPLATE_float_float32 -DISIP_TEMPLATE_complex
> 
> versus:
> 
> ~/cvs/ISIP/class/math/scalar/MScalar$ g++-3.2
> -I/home/ahu/cvs/include -Wall -ftemplate-depth-50 -c -O6 -o
> mscl_02.float.float32~complex-3.2.o mscl_02.cc
> -DISIP_TEMPLATE_TARGET=float,float32 -DISIP_TEMPLATE_T0=float
> -DISIP_TEMPLATE_T1=float32 -DISIP_TEMPLATE_T2=mscl_02.float.float32
> -DISIP_TEMPLATE_float_float32 -DISIP_TEMPLATE_complex
> 
> Any clues on how to get gcc to do the old thing? I now end up with heaps and
> heaps of duplicate symbols on linking. 
> 
> I tried -fno-implicit-templates, lowering -ftemplate-depth, removing -O,
> playing with -O, -fno-implicit-inline-templates all to no effect.
> 
> Thanks.
> 
> --- 3.2.nm	2003-05-27 14:32:13.000000000 +0200
> +++ 3.3.nm	2003-05-27 14:32:07.000000000 +0200
> @@ -20,227 +20,167 @@
>  U Error::handle(SysString const&, wchar_t const*, long, char*, long, Error::EXIT, SysString const&)
>  U Random::GLOBAL_UNIFORM
>  U Random::GLOBAL_GAUSSIAN
> -W Random::seed(long)
> -W String::String[in-charge](wchar_t const*)
> -W String::String[in-charge](long)
> -W String::~String [in-charge]()
> -W Console::decreaseIndention()
> -W Console::increaseIndention()
>  U Console::put(wchar_t const*)
>  U Console::put(SysString const&)
>  U Console::cons_d
> -W MScalar<double, double>::assign(MScalar<double, double> const&)
> -W bool MScalar<double, double>::assign<double>(double)
> -W MScalar<double, double>::MScalar[in-charge](MScalar<double, double> const&)
> -W MScalar<double, double>::MScalar[in-charge]()
> -W MScalar<double, double>::~MScalar [in-charge]()
> -W MScalar<float, float>::centerClip(float, float, float)
> -W MScalar<float, float>::abs(float)
> -W MScalar<float, float>::add(float, float)
> -W MScalar<float, float>::bls(float, float)
> -W MScalar<float, float>::bor(float, float)
> -W MScalar<float, float>::brs(float, float)
> -W MScalar<float, float>::cos(float)
> -W MScalar<float, float>::div(float, float)
> -W MScalar<float, float>::exp(float)
> -W MScalar<float, float>::exp()
> -W MScalar<float, float>::log(float)
> -W MScalar<float, float>::max(float, float)
> -W MScalar<float, float>::min(float, float)
> -W MScalar<float, float>::mod(float, float)
> -W MScalar<float, float>::neg(float)
> -W MScalar<float, float>::pow(float)
> -W MScalar<float, float>::pow(float, float)
> -W MScalar<float, float>::sin(float)
> -W MScalar<float, float>::sub(float, float)
> -W MScalar<float, float>::tan(float)
> -W MScalar<float, float>::acos(float)
> -W MScalar<float, float>::acos()
> -W MScalar<float, float>::asin(float)
> -W MScalar<float, float>::asin()
> -W MScalar<float, float>::atan(float)
> -W MScalar<float, float>::atan()
> -W MScalar<float, float>::band(float, float)
> -W MScalar<float, float>::bxor(float, float)
> -W float MScalar<float, float>::ceil<float>(float)
> -W MScalar<float, float>::cosh(float)
> -W MScalar<float, float>::exp2(float)
> -W MScalar<float, float>::exp2()
> -W MScalar<float, float>::log2(float)
> -W MScalar<float, float>::mult(float, float)
> +T MScalar<double, double>::bls(double, double)
> +T MScalar<double, double>::bor(double, double)
> +T MScalar<double, double>::brs(double, double)
> +T MScalar<double, double>::mod(double, double)
> +T MScalar<double, double>::band(double, double)
> +T MScalar<double, double>::bxor(double, double)
> +T MScalar<double, double>::bcmpl(double)
> +T MScalar<double, double>::fraction(double)
> +T MScalar<double, double>::operator%=(double)
> +T MScalar<float, float>::bls(float, float)
> +T MScalar<float, float>::bor(float, float)
> +T MScalar<float, float>::brs(float, float)
> +T MScalar<float, float>::mod(float, float)
> +T MScalar<float, float>::band(float, float)
> +T MScalar<float, float>::bxor(float, float)
>  U MScalar<float, float>::rand(Random&)
>  U MScalar<float, float>::rand(float, float, Random&)
> -W MScalar<float, float>::sign(float)
> -W MScalar<float, float>::sinh(float)
> -W MScalar<float, float>::sqrt(float)
> -W MScalar<float, float>::tanh(float)
> -W MScalar<float, float>::acosh(float)
> -W MScalar<float, float>::acosh()
> -W MScalar<float, float>::asinh(float)
> -W MScalar<float, float>::asinh()
> -W MScalar<float, float>::atanh(float)
> -W MScalar<float, float>::atanh()
> -W MScalar<float, float>::bcmpl(float)
> -W MScalar<float, float>::clear(Integral::CMODE)
> -W MScalar<float, float>::exp10(float)
> -W MScalar<float, float>::exp10()
> -W float MScalar<float, float>::floor<float>(float)
> +T MScalar<float, float>::bcmpl(float)
>  U MScalar<float, float>::grand(float, float, Random&)
> -W MScalar<float, float>::limit(float, float, float)
> -W MScalar<float, float>::log10(float)
> -W MScalar<float, float>::log1p(float)
> -W MScalar<float, float>::rceil(float)
> -W float MScalar<float, float>::round<float>(float)
> -W MScalar<float, float>::assign(String const&)
> -W MScalar<float, float>::assign(MScalar<float, float> const&)
> -W bool MScalar<float, float>::assign<MScalar<double, double> >(MScalar<double, double>)
> -W bool MScalar<float, float>::assign<MScalar<unsigned char, unsigned char> >(MScalar<unsigned char, unsigned char>)
> -W bool MScalar<float, float>::assign<MScalar<long, long> >(MScalar<long, long>)
> -W bool MScalar<float, float>::assign<MScalar<unsigned long, unsigned long> >(MScalar<unsigned long, unsigned long>)
> -W bool MScalar<float, float>::assign<MScalar<short, short> >(MScalar<short, short>)
> -W bool MScalar<float, float>::assign<MScalar<unsigned short, unsigned short> >(MScalar<unsigned short, unsigned short>)
> -W bool MScalar<float, float>::assign<MScalar<long long, long long> >(MScalar<long long, long long>)
> -W bool MScalar<float, float>::assign<MScalar<unsigned long long, unsigned long long> >(MScalar<unsigned long long, unsigned long long>)
> -W bool MScalar<float, float>::assign<double>(double)
> -W bool MScalar<float, float>::assign<float>(float)
> -W bool MScalar<float, float>::assign<int>(int)
> -W bool MScalar<float, float>::assign<long>(long)
> -W MScalar<float, float>::rfloor(float)
> -W MScalar<float, float>::square(float)
> -W MScalar<float, float>::square()
> -W MScalar<float, float>::inverse(float)
> -W MScalar<float, float>::inverse()
> -W MScalar<float, float>::fraction(float)
> -W MScalar<float, float>::limitMag(float, float, float)
> +T MScalar<float, float>::fraction(float)
>  U MScalar<float, float>::DEF_VALUE
> -W MScalar<float, float>::factorial(float)
> -W MScalar<float, float>::MScalar[in-charge](float)
> -W MScalar<float, float>::MScalar[in-charge]()
> -W MScalar<float, float>::~MScalar [in-charge]()
> -W MScalar<float, float>::operator/=(float)
> -W MScalar<float, float>::operator-=(float)
> -W MScalar<float, float>::operator*=(float)
> -W MScalar<float, float>::operator--(int)
> -W MScalar<float, float>::operator--()
> -W MScalar<float, float>::operator+=(float)
> -W MScalar<float, float>::operator++(int)
> -W MScalar<float, float>::operator++()
> -W MScalar<float, float>::operator%=(float)
> -W MScalar<unsigned char, unsigned char>::assign(MScalar<unsigned char, unsigned char> const&)
> -W bool MScalar<unsigned char, unsigned char>::assign<unsigned char>(unsigned char)
> -W MScalar<unsigned char, unsigned char>::MScalar[in-charge](MScalar<unsigned char, unsigned char> const&)
> -W MScalar<unsigned char, unsigned char>::MScalar[in-charge]()
> -W MScalar<unsigned char, unsigned char>::~MScalar [in-charge]()
> -W MScalar<long, long>::assign(MScalar<long, long> const&)
> -W bool MScalar<long, long>::assign<long>(long)
> -W MScalar<long, long>::MScalar[in-charge](MScalar<long, long> const&)
> -W MScalar<long, long>::MScalar[in-charge]()
> -W MScalar<long, long>::~MScalar [in-charge]()
> -W MScalar<unsigned long, unsigned long>::assign(MScalar<unsigned long, unsigned long> const&)
> -W bool MScalar<unsigned long, unsigned long>::assign<unsigned long>(unsigned long)
> -W MScalar<unsigned long, unsigned long>::MScalar[in-charge](MScalar<unsigned long, unsigned long> const&)
> -W MScalar<unsigned long, unsigned long>::MScalar[in-charge]()
> -W MScalar<unsigned long, unsigned long>::~MScalar [in-charge]()
> -W MScalar<short, short>::assign(MScalar<short, short> const&)
> -W bool MScalar<short, short>::assign<short>(short)
> -W MScalar<short, short>::MScalar[in-charge](MScalar<short, short> const&)
> -W MScalar<short, short>::MScalar[in-charge]()
> -W MScalar<short, short>::~MScalar [in-charge]()
> -W MScalar<unsigned short, unsigned short>::assign(MScalar<unsigned short, unsigned short> const&)
> -W bool MScalar<unsigned short, unsigned short>::assign<unsigned short>(unsigned short)
> -W MScalar<unsigned short, unsigned short>::MScalar[in-charge](MScalar<unsigned short, unsigned short> const&)
> -W MScalar<unsigned short, unsigned short>::MScalar[in-charge]()
> -W MScalar<unsigned short, unsigned short>::~MScalar [in-charge]()
> -W MScalar<long long, long long>::assign(MScalar<long long, long long> const&)
> -W bool MScalar<long long, long long>::assign<long long>(long long)
> -W MScalar<long long, long long>::MScalar[in-charge](MScalar<long long, long long> const&)
> -W MScalar<long long, long long>::MScalar[in-charge]()
> -W MScalar<long long, long long>::~MScalar [in-charge]()
> -W MScalar<unsigned long long, unsigned long long>::assign(MScalar<unsigned long long, unsigned long long> const&)
> -W bool MScalar<unsigned long long, unsigned long long>::assign<unsigned long long>(unsigned long long)
> -W MScalar<unsigned long long, unsigned long long>::MScalar[in-charge](MScalar<unsigned long long, unsigned long long> const&)
> -W MScalar<unsigned long long, unsigned long long>::MScalar[in-charge]()
> -W MScalar<unsigned long long, unsigned long long>::~MScalar [in-charge]()
> +T MScalar<float, float>::operator%=(float)
> +U MScalar<unsigned char, unsigned char>::CLASS_NAME
> +T MScalar<unsigned char, unsigned char>::abs(unsigned char)
> +T MScalar<unsigned char, unsigned char>::cos(unsigned char)
> +T MScalar<unsigned char, unsigned char>::neg(unsigned char)
> +T MScalar<unsigned char, unsigned char>::sin(unsigned char)
> +T MScalar<unsigned char, unsigned char>::tan(unsigned char)
> +T MScalar<unsigned char, unsigned char>::acos(unsigned char)
> +T MScalar<unsigned char, unsigned char>::asin(unsigned char)
> +T MScalar<unsigned char, unsigned char>::atan(unsigned char)
> +T MScalar<unsigned char, unsigned char>::cosh(unsigned char)
> +T MScalar<unsigned char, unsigned char>::sign(unsigned char)
> +T MScalar<unsigned char, unsigned char>::sinh(unsigned char)
> +T MScalar<unsigned char, unsigned char>::tanh(unsigned char)
> +T MScalar<unsigned char, unsigned char>::acosh(unsigned char)
> +T MScalar<unsigned char, unsigned char>::asinh(unsigned char)
> +T MScalar<unsigned char, unsigned char>::atanh(unsigned char)
> +T MScalar<unsigned char, unsigned char>::rceil(unsigned char)
> +T MScalar<unsigned char, unsigned char>::rfloor(unsigned char)
> +U MScalar<long, long>::CLASS_NAME
> +T MScalar<long, long>::cos(long)
> +T MScalar<long, long>::sin(long)
> +T MScalar<long, long>::tan(long)
> +T MScalar<long, long>::acos(long)
> +T MScalar<long, long>::asin(long)
> +T MScalar<long, long>::atan(long)
> +T MScalar<long, long>::cosh(long)
> +T MScalar<long, long>::sinh(long)
> +T MScalar<long, long>::tanh(long)
> +T MScalar<long, long>::acosh(long)
> +T MScalar<long, long>::asinh(long)
> +T MScalar<long, long>::atanh(long)
> +T MScalar<long, long>::rceil(long)
> +T MScalar<long, long>::rfloor(long)
> +U MScalar<unsigned long, unsigned long>::CLASS_NAME
> +T MScalar<unsigned long, unsigned long>::abs(unsigned long)
> +T MScalar<unsigned long, unsigned long>::cos(unsigned long)
> +T MScalar<unsigned long, unsigned long>::neg(unsigned long)
> +T MScalar<unsigned long, unsigned long>::sin(unsigned long)
> +T MScalar<unsigned long, unsigned long>::tan(unsigned long)
> +T MScalar<unsigned long, unsigned long>::acos(unsigned long)
> +T MScalar<unsigned long, unsigned long>::asin(unsigned long)
> +T MScalar<unsigned long, unsigned long>::atan(unsigned long)
> +T MScalar<unsigned long, unsigned long>::cosh(unsigned long)
> +T MScalar<unsigned long, unsigned long>::sign(unsigned long)
> +T MScalar<unsigned long, unsigned long>::sinh(unsigned long)
> +T MScalar<unsigned long, unsigned long>::tanh(unsigned long)
> +T MScalar<unsigned long, unsigned long>::acosh(unsigned long)
> +T MScalar<unsigned long, unsigned long>::asinh(unsigned long)
> +T MScalar<unsigned long, unsigned long>::atanh(unsigned long)
> +T MScalar<unsigned long, unsigned long>::rceil(unsigned long)
> +T MScalar<unsigned long, unsigned long>::rfloor(unsigned long)
> +U MScalar<short, short>::CLASS_NAME
> +T MScalar<short, short>::cos(short)
> +T MScalar<short, short>::sin(short)
> +T MScalar<short, short>::tan(short)
> +T MScalar<short, short>::acos(short)
> +T MScalar<short, short>::asin(short)
> +T MScalar<short, short>::atan(short)
> +T MScalar<short, short>::cosh(short)
> +T MScalar<short, short>::sinh(short)
> +T MScalar<short, short>::tanh(short)
> +T MScalar<short, short>::acosh(short)
> +T MScalar<short, short>::asinh(short)
> +T MScalar<short, short>::atanh(short)
> +T MScalar<short, short>::rceil(short)
> +T MScalar<short, short>::rfloor(short)
> +U MScalar<unsigned short, unsigned short>::CLASS_NAME
> +T MScalar<unsigned short, unsigned short>::abs(unsigned short)
> +T MScalar<unsigned short, unsigned short>::cos(unsigned short)
> +T MScalar<unsigned short, unsigned short>::neg(unsigned short)
> +T MScalar<unsigned short, unsigned short>::sin(unsigned short)
> +T MScalar<unsigned short, unsigned short>::tan(unsigned short)
> +T MScalar<unsigned short, unsigned short>::acos(unsigned short)
> +T MScalar<unsigned short, unsigned short>::asin(unsigned short)
> +T MScalar<unsigned short, unsigned short>::atan(unsigned short)
> +T MScalar<unsigned short, unsigned short>::cosh(unsigned short)
> +T MScalar<unsigned short, unsigned short>::sign(unsigned short)
> +T MScalar<unsigned short, unsigned short>::sinh(unsigned short)
> +T MScalar<unsigned short, unsigned short>::tanh(unsigned short)
> +T MScalar<unsigned short, unsigned short>::acosh(unsigned short)
> +T MScalar<unsigned short, unsigned short>::asinh(unsigned short)
> +T MScalar<unsigned short, unsigned short>::atanh(unsigned short)
> +T MScalar<unsigned short, unsigned short>::rceil(unsigned short)
> +T MScalar<unsigned short, unsigned short>::rfloor(unsigned short)
> +U MScalar<long long, long long>::CLASS_NAME
> +T MScalar<long long, long long>::cos(long long)
> +T MScalar<long long, long long>::sin(long long)
> +T MScalar<long long, long long>::tan(long long)
> +T MScalar<long long, long long>::acos(long long)
> +T MScalar<long long, long long>::asin(long long)
> +T MScalar<long long, long long>::atan(long long)
> +T MScalar<long long, long long>::cosh(long long)
> +T MScalar<long long, long long>::sinh(long long)
> +T MScalar<long long, long long>::tanh(long long)
> +T MScalar<long long, long long>::acosh(long long)
> +T MScalar<long long, long long>::asinh(long long)
> +T MScalar<long long, long long>::atanh(long long)
> +T MScalar<long long, long long>::rceil(long long)
> +T MScalar<long long, long long>::rfloor(long long)
> +U MScalar<unsigned long long, unsigned long long>::CLASS_NAME
> +T MScalar<unsigned long long, unsigned long long>::abs(unsigned long long)
> +T MScalar<unsigned long long, unsigned long long>::cos(unsigned long long)
> +T MScalar<unsigned long long, unsigned long long>::neg(unsigned long long)
> +T MScalar<unsigned long long, unsigned long long>::sin(unsigned long long)
> +T MScalar<unsigned long long, unsigned long long>::tan(unsigned long long)
> +T MScalar<unsigned long long, unsigned long long>::acos(unsigned long long)
> +T MScalar<unsigned long long, unsigned long long>::asin(unsigned long long)
> +T MScalar<unsigned long long, unsigned long long>::atan(unsigned long long)
> +T MScalar<unsigned long long, unsigned long long>::cosh(unsigned long long)
> +T MScalar<unsigned long long, unsigned long long>::sign(unsigned long long)
> +T MScalar<unsigned long long, unsigned long long>::sinh(unsigned long long)
> +T MScalar<unsigned long long, unsigned long long>::tanh(unsigned long long)
> +T MScalar<unsigned long long, unsigned long long>::acosh(unsigned long long)
> +T MScalar<unsigned long long, unsigned long long>::asinh(unsigned long long)
> +T MScalar<unsigned long long, unsigned long long>::atanh(unsigned long long)
> +T MScalar<unsigned long long, unsigned long long>::rceil(unsigned long long)
> +T MScalar<unsigned long long, unsigned long long>::rfloor(unsigned long long)
>  U Integral::almostEqual(double, double, double, double)
> -W Integral::almostEqual(float, float, double, double)
> -W Integral::cos(double)
> -W Integral::exp(double)
> -W Integral::log(double)
> -W Integral::max(double, double)
> -W Integral::min(double, double)
> -W Integral::pow(double, double)
> -W Integral::sin(double)
> -W Integral::tan(double)
> -W Integral::acos(double)
> -W Integral::asin(double)
> -W Integral::atan(double)
> -W Integral::ceil(double)
> -W Integral::cosh(double)
> -W Integral::exp2(double)
> -W Integral::hash(float, unsigned long)
> -W Integral::log2(double)
> -W Integral::sinh(double)
> -W Integral::sqrt(double)
> -W Integral::tanh(double)
> -W Integral::acosh(double)
> -W Integral::asinh(double)
> -W Integral::atanh(double)
> -W Integral::exp10(double)
> -W Integral::floor(double)
> -W Integral::log10(double)
> -W Integral::log1p(double)
> -W Integral::round(double)
> -W Integral::hash_32(unsigned long, unsigned long)
> -W Integral::fraction(double)
>  U SysString::setCapacity(long)
>  U SysString::assign(wchar_t const*)
>  U SysString::assign(double)
>  U SysString::assign(float)
> -W SysString::concat(wchar_t const*)
>  U SysString::concat(SysString const&)
> -W SysString::concat(double)
>  U SysString::freeMem()
>  U SysString::SysString[in-charge](wchar_t const*)
>  U SysString::SysString[in-charge](long)
>  U SysString::SysString[not-in-charge](long)
> -W SysString::~SysString [in-charge]()
> -W SysString::~SysString [not-in-charge]()
> -W MScalar<double, double>::operator double() const
> -W MScalar<float, float>::almostEqual(float) const
> -W MScalar<float, float>::presentValue(double) const
> -W MScalar<float, float>::eq(MScalar<float, float> const&) const
> -W MScalar<float, float>::eq(float) const
> -W MScalar<float, float>::eq(float, float) const
> -W MScalar<float, float>::ge(float) const
> -W MScalar<float, float>::gt(float) const
> -W MScalar<float, float>::le(float) const
> -W MScalar<float, float>::lt(float) const
> -W MScalar<float, float>::ne(float) const
> -W MScalar<float, float>::get(String&) const
> -W MScalar<float, float>::hash(unsigned long) const
> +T MScalar<SysComplex<double>, double>::presentValue(SysComplex<double>) const
> +T MScalar<SysComplex<float>, float>::presentValue(SysComplex<double>) const
> +T MScalar<SysComplex<long>, long>::presentValue(SysComplex<double>) const
> +T MScalar<double, double>::presentValue(double) const
> +T MScalar<double, double>::operator%(double) const
> +T MScalar<float, float>::presentValue(double) const
>  U MScalar<float, float>::debug(wchar_t const*) const
> -W MScalar<float, float>::operator float() const
> -W MScalar<float, float>::operator/(float) const
> -W MScalar<float, float>::operator==(float) const
> -W MScalar<float, float>::operator>=(float) const
> -W MScalar<float, float>::operator>(float) const
> -W MScalar<float, float>::operator<=(float) const
> -W MScalar<float, float>::operator<(float) const
> -W MScalar<float, float>::operator-(float) const
> -W MScalar<float, float>::operator*(float) const
> -W MScalar<float, float>::operator!=(float) const
> -W MScalar<float, float>::operator+(float) const
> -W MScalar<float, float>::operator%(float) const
> -W MScalar<unsigned char, unsigned char>::operator unsigned char() const
> -W MScalar<long, long>::operator long() const
> -W MScalar<unsigned long, unsigned long>::operator unsigned long() const
> -W MScalar<short, short>::operator short() const
> -W MScalar<unsigned short, unsigned short>::operator unsigned short() const
> -W MScalar<long long, long long>::operator long long() const
> -W MScalar<unsigned long long, unsigned long long>::operator unsigned long long() const
> +T MScalar<float, float>::operator%(float) const
>  U SysString::get(float&) const
> -W std::type_info::operator==(std::type_info const&) const
> -W std::type_info::operator!=(std::type_info const&) const
>  U typeinfo for double
>  U typeinfo for float
>  U typeinfo for unsigned char
> @@ -254,18 +194,14 @@
>  U __gxx_personality_v0
>  U acos
>  U asin
> -U atan
> -U ceil
>  U cos
>  U cosh
>  U exp
> -U floor
>  U log
>  U log10
>  U modf
>  U pow
>  U sin
>  U sinh
> -U sqrt
>  U tan
>  U tanh
> 
> 
> 
> 
> 
> -- 
> http://www.PowerDNS.com      Open source, database driven DNS Software 
> http://lartc.org           Linux Advanced Routing & Traffic Control HOWTO
> 

-- 
Daniel Jacobowitz
MontaVista Software                         Debian GNU/Linux Developer

emitting templates as 'T'? Changed from 3.2 to 3.3

[bert hubert]

[previously posted to bugs@gcc.gnu.org which I since realised is mostly the
output of bugzilla, and perhaps not the most apropriate forum for my
question]

Hi,

I'm trying to move the ISIP production system
http://www.isip.msstate.edu/projects/speech/software/ to g++ 3.3 and
am encountering some problems.

It appears that where g++ 3.2 did not emit a lot of template functions to
the .o as 'T', 3.3 often does.

A somewhat mangled version of the diff between the outputs of nm is below,
lots of weak symbols suddenly becoming T. This is based on:

~/cvs/ISIP/class/math/scalar/MScalar$ g++
-I/home/ahu/cvs/include -Wall -ftemplate-depth-50 -c -O6 -o
mscl_02.float.float32~complex-3.3.o mscl_02.cc
-DISIP_TEMPLATE_TARGET=float,float32 -DISIP_TEMPLATE_T0=float
-DISIP_TEMPLATE_T1=float32 -DISIP_TEMPLATE_T2=mscl_02.float.float32
-DISIP_TEMPLATE_float_float32 -DISIP_TEMPLATE_complex

versus:

~/cvs/ISIP/class/math/scalar/MScalar$ g++-3.2
-I/home/ahu/cvs/include -Wall -ftemplate-depth-50 -c -O6 -o
mscl_02.float.float32~complex-3.2.o mscl_02.cc
-DISIP_TEMPLATE_TARGET=float,float32 -DISIP_TEMPLATE_T0=float
-DISIP_TEMPLATE_T1=float32 -DISIP_TEMPLATE_T2=mscl_02.float.float32
-DISIP_TEMPLATE_float_float32 -DISIP_TEMPLATE_complex

Any clues on how to get gcc to do the old thing? I now end up with heaps and
heaps of duplicate symbols on linking. 

I tried -fno-implicit-templates, lowering -ftemplate-depth, removing -O,
playing with -O, -fno-implicit-inline-templates all to no effect.

Thanks.

--- 3.2.nm	2003-05-27 14:32:13.000000000 +0200
+++ 3.3.nm	2003-05-27 14:32:07.000000000 +0200
@@ -20,227 +20,167 @@
 U Error::handle(SysString const&, wchar_t const*, long, char*, long, Error::EXIT, SysString const&)
 U Random::GLOBAL_UNIFORM
 U Random::GLOBAL_GAUSSIAN
-W Random::seed(long)
-W String::String[in-charge](wchar_t const*)
-W String::String[in-charge](long)
-W String::~String [in-charge]()
-W Console::decreaseIndention()
-W Console::increaseIndention()
 U Console::put(wchar_t const*)
 U Console::put(SysString const&)
 U Console::cons_d
-W MScalar<double, double>::assign(MScalar<double, double> const&)
-W bool MScalar<double, double>::assign<double>(double)
-W MScalar<double, double>::MScalar[in-charge](MScalar<double, double> const&)
-W MScalar<double, double>::MScalar[in-charge]()
-W MScalar<double, double>::~MScalar [in-charge]()
-W MScalar<float, float>::centerClip(float, float, float)
-W MScalar<float, float>::abs(float)
-W MScalar<float, float>::add(float, float)
-W MScalar<float, float>::bls(float, float)
-W MScalar<float, float>::bor(float, float)
-W MScalar<float, float>::brs(float, float)
-W MScalar<float, float>::cos(float)
-W MScalar<float, float>::div(float, float)
-W MScalar<float, float>::exp(float)
-W MScalar<float, float>::exp()
-W MScalar<float, float>::log(float)
-W MScalar<float, float>::max(float, float)
-W MScalar<float, float>::min(float, float)
-W MScalar<float, float>::mod(float, float)
-W MScalar<float, float>::neg(float)
-W MScalar<float, float>::pow(float)
-W MScalar<float, float>::pow(float, float)
-W MScalar<float, float>::sin(float)
-W MScalar<float, float>::sub(float, float)
-W MScalar<float, float>::tan(float)
-W MScalar<float, float>::acos(float)
-W MScalar<float, float>::acos()
-W MScalar<float, float>::asin(float)
-W MScalar<float, float>::asin()
-W MScalar<float, float>::atan(float)
-W MScalar<float, float>::atan()
-W MScalar<float, float>::band(float, float)
-W MScalar<float, float>::bxor(float, float)
-W float MScalar<float, float>::ceil<float>(float)
-W MScalar<float, float>::cosh(float)
-W MScalar<float, float>::exp2(float)
-W MScalar<float, float>::exp2()
-W MScalar<float, float>::log2(float)
-W MScalar<float, float>::mult(float, float)
+T MScalar<double, double>::bls(double, double)
+T MScalar<double, double>::bor(double, double)
+T MScalar<double, double>::brs(double, double)
+T MScalar<double, double>::mod(double, double)
+T MScalar<double, double>::band(double, double)
+T MScalar<double, double>::bxor(double, double)
+T MScalar<double, double>::bcmpl(double)
+T MScalar<double, double>::fraction(double)
+T MScalar<double, double>::operator%=(double)
+T MScalar<float, float>::bls(float, float)
+T MScalar<float, float>::bor(float, float)
+T MScalar<float, float>::brs(float, float)
+T MScalar<float, float>::mod(float, float)
+T MScalar<float, float>::band(float, float)
+T MScalar<float, float>::bxor(float, float)
 U MScalar<float, float>::rand(Random&)
 U MScalar<float, float>::rand(float, float, Random&)
-W MScalar<float, float>::sign(float)
-W MScalar<float, float>::sinh(float)
-W MScalar<float, float>::sqrt(float)
-W MScalar<float, float>::tanh(float)
-W MScalar<float, float>::acosh(float)
-W MScalar<float, float>::acosh()
-W MScalar<float, float>::asinh(float)
-W MScalar<float, float>::asinh()
-W MScalar<float, float>::atanh(float)
-W MScalar<float, float>::atanh()
-W MScalar<float, float>::bcmpl(float)
-W MScalar<float, float>::clear(Integral::CMODE)
-W MScalar<float, float>::exp10(float)
-W MScalar<float, float>::exp10()
-W float MScalar<float, float>::floor<float>(float)
+T MScalar<float, float>::bcmpl(float)
 U MScalar<float, float>::grand(float, float, Random&)
-W MScalar<float, float>::limit(float, float, float)
-W MScalar<float, float>::log10(float)
-W MScalar<float, float>::log1p(float)
-W MScalar<float, float>::rceil(float)
-W float MScalar<float, float>::round<float>(float)
-W MScalar<float, float>::assign(String const&)
-W MScalar<float, float>::assign(MScalar<float, float> const&)
-W bool MScalar<float, float>::assign<MScalar<double, double> >(MScalar<double, double>)
-W bool MScalar<float, float>::assign<MScalar<unsigned char, unsigned char> >(MScalar<unsigned char, unsigned char>)
-W bool MScalar<float, float>::assign<MScalar<long, long> >(MScalar<long, long>)
-W bool MScalar<float, float>::assign<MScalar<unsigned long, unsigned long> >(MScalar<unsigned long, unsigned long>)
-W bool MScalar<float, float>::assign<MScalar<short, short> >(MScalar<short, short>)
-W bool MScalar<float, float>::assign<MScalar<unsigned short, unsigned short> >(MScalar<unsigned short, unsigned short>)
-W bool MScalar<float, float>::assign<MScalar<long long, long long> >(MScalar<long long, long long>)
-W bool MScalar<float, float>::assign<MScalar<unsigned long long, unsigned long long> >(MScalar<unsigned long long, unsigned long long>)
-W bool MScalar<float, float>::assign<double>(double)
-W bool MScalar<float, float>::assign<float>(float)
-W bool MScalar<float, float>::assign<int>(int)
-W bool MScalar<float, float>::assign<long>(long)
-W MScalar<float, float>::rfloor(float)
-W MScalar<float, float>::square(float)
-W MScalar<float, float>::square()
-W MScalar<float, float>::inverse(float)
-W MScalar<float, float>::inverse()
-W MScalar<float, float>::fraction(float)
-W MScalar<float, float>::limitMag(float, float, float)
+T MScalar<float, float>::fraction(float)
 U MScalar<float, float>::DEF_VALUE
-W MScalar<float, float>::factorial(float)
-W MScalar<float, float>::MScalar[in-charge](float)
-W MScalar<float, float>::MScalar[in-charge]()
-W MScalar<float, float>::~MScalar [in-charge]()
-W MScalar<float, float>::operator/=(float)
-W MScalar<float, float>::operator-=(float)
-W MScalar<float, float>::operator*=(float)
-W MScalar<float, float>::operator--(int)
-W MScalar<float, float>::operator--()
-W MScalar<float, float>::operator+=(float)
-W MScalar<float, float>::operator++(int)
-W MScalar<float, float>::operator++()
-W MScalar<float, float>::operator%=(float)
-W MScalar<unsigned char, unsigned char>::assign(MScalar<unsigned char, unsigned char> const&)
-W bool MScalar<unsigned char, unsigned char>::assign<unsigned char>(unsigned char)
-W MScalar<unsigned char, unsigned char>::MScalar[in-charge](MScalar<unsigned char, unsigned char> const&)
-W MScalar<unsigned char, unsigned char>::MScalar[in-charge]()
-W MScalar<unsigned char, unsigned char>::~MScalar [in-charge]()
-W MScalar<long, long>::assign(MScalar<long, long> const&)
-W bool MScalar<long, long>::assign<long>(long)
-W MScalar<long, long>::MScalar[in-charge](MScalar<long, long> const&)
-W MScalar<long, long>::MScalar[in-charge]()
-W MScalar<long, long>::~MScalar [in-charge]()
-W MScalar<unsigned long, unsigned long>::assign(MScalar<unsigned long, unsigned long> const&)
-W bool MScalar<unsigned long, unsigned long>::assign<unsigned long>(unsigned long)
-W MScalar<unsigned long, unsigned long>::MScalar[in-charge](MScalar<unsigned long, unsigned long> const&)
-W MScalar<unsigned long, unsigned long>::MScalar[in-charge]()
-W MScalar<unsigned long, unsigned long>::~MScalar [in-charge]()
-W MScalar<short, short>::assign(MScalar<short, short> const&)
-W bool MScalar<short, short>::assign<short>(short)
-W MScalar<short, short>::MScalar[in-charge](MScalar<short, short> const&)
-W MScalar<short, short>::MScalar[in-charge]()
-W MScalar<short, short>::~MScalar [in-charge]()
-W MScalar<unsigned short, unsigned short>::assign(MScalar<unsigned short, unsigned short> const&)
-W bool MScalar<unsigned short, unsigned short>::assign<unsigned short>(unsigned short)
-W MScalar<unsigned short, unsigned short>::MScalar[in-charge](MScalar<unsigned short, unsigned short> const&)
-W MScalar<unsigned short, unsigned short>::MScalar[in-charge]()
-W MScalar<unsigned short, unsigned short>::~MScalar [in-charge]()
-W MScalar<long long, long long>::assign(MScalar<long long, long long> const&)
-W bool MScalar<long long, long long>::assign<long long>(long long)
-W MScalar<long long, long long>::MScalar[in-charge](MScalar<long long, long long> const&)
-W MScalar<long long, long long>::MScalar[in-charge]()
-W MScalar<long long, long long>::~MScalar [in-charge]()
-W MScalar<unsigned long long, unsigned long long>::assign(MScalar<unsigned long long, unsigned long long> const&)
-W bool MScalar<unsigned long long, unsigned long long>::assign<unsigned long long>(unsigned long long)
-W MScalar<unsigned long long, unsigned long long>::MScalar[in-charge](MScalar<unsigned long long, unsigned long long> const&)
-W MScalar<unsigned long long, unsigned long long>::MScalar[in-charge]()
-W MScalar<unsigned long long, unsigned long long>::~MScalar [in-charge]()
+T MScalar<float, float>::operator%=(float)
+U MScalar<unsigned char, unsigned char>::CLASS_NAME
+T MScalar<unsigned char, unsigned char>::abs(unsigned char)
+T MScalar<unsigned char, unsigned char>::cos(unsigned char)
+T MScalar<unsigned char, unsigned char>::neg(unsigned char)
+T MScalar<unsigned char, unsigned char>::sin(unsigned char)
+T MScalar<unsigned char, unsigned char>::tan(unsigned char)
+T MScalar<unsigned char, unsigned char>::acos(unsigned char)
+T MScalar<unsigned char, unsigned char>::asin(unsigned char)
+T MScalar<unsigned char, unsigned char>::atan(unsigned char)
+T MScalar<unsigned char, unsigned char>::cosh(unsigned char)
+T MScalar<unsigned char, unsigned char>::sign(unsigned char)
+T MScalar<unsigned char, unsigned char>::sinh(unsigned char)
+T MScalar<unsigned char, unsigned char>::tanh(unsigned char)
+T MScalar<unsigned char, unsigned char>::acosh(unsigned char)
+T MScalar<unsigned char, unsigned char>::asinh(unsigned char)
+T MScalar<unsigned char, unsigned char>::atanh(unsigned char)
+T MScalar<unsigned char, unsigned char>::rceil(unsigned char)
+T MScalar<unsigned char, unsigned char>::rfloor(unsigned char)
+U MScalar<long, long>::CLASS_NAME
+T MScalar<long, long>::cos(long)
+T MScalar<long, long>::sin(long)
+T MScalar<long, long>::tan(long)
+T MScalar<long, long>::acos(long)
+T MScalar<long, long>::asin(long)
+T MScalar<long, long>::atan(long)
+T MScalar<long, long>::cosh(long)
+T MScalar<long, long>::sinh(long)
+T MScalar<long, long>::tanh(long)
+T MScalar<long, long>::acosh(long)
+T MScalar<long, long>::asinh(long)
+T MScalar<long, long>::atanh(long)
+T MScalar<long, long>::rceil(long)
+T MScalar<long, long>::rfloor(long)
+U MScalar<unsigned long, unsigned long>::CLASS_NAME
+T MScalar<unsigned long, unsigned long>::abs(unsigned long)
+T MScalar<unsigned long, unsigned long>::cos(unsigned long)
+T MScalar<unsigned long, unsigned long>::neg(unsigned long)
+T MScalar<unsigned long, unsigned long>::sin(unsigned long)
+T MScalar<unsigned long, unsigned long>::tan(unsigned long)
+T MScalar<unsigned long, unsigned long>::acos(unsigned long)
+T MScalar<unsigned long, unsigned long>::asin(unsigned long)
+T MScalar<unsigned long, unsigned long>::atan(unsigned long)
+T MScalar<unsigned long, unsigned long>::cosh(unsigned long)
+T MScalar<unsigned long, unsigned long>::sign(unsigned long)
+T MScalar<unsigned long, unsigned long>::sinh(unsigned long)
+T MScalar<unsigned long, unsigned long>::tanh(unsigned long)
+T MScalar<unsigned long, unsigned long>::acosh(unsigned long)
+T MScalar<unsigned long, unsigned long>::asinh(unsigned long)
+T MScalar<unsigned long, unsigned long>::atanh(unsigned long)
+T MScalar<unsigned long, unsigned long>::rceil(unsigned long)
+T MScalar<unsigned long, unsigned long>::rfloor(unsigned long)
+U MScalar<short, short>::CLASS_NAME
+T MScalar<short, short>::cos(short)
+T MScalar<short, short>::sin(short)
+T MScalar<short, short>::tan(short)
+T MScalar<short, short>::acos(short)
+T MScalar<short, short>::asin(short)
+T MScalar<short, short>::atan(short)
+T MScalar<short, short>::cosh(short)
+T MScalar<short, short>::sinh(short)
+T MScalar<short, short>::tanh(short)
+T MScalar<short, short>::acosh(short)
+T MScalar<short, short>::asinh(short)
+T MScalar<short, short>::atanh(short)
+T MScalar<short, short>::rceil(short)
+T MScalar<short, short>::rfloor(short)
+U MScalar<unsigned short, unsigned short>::CLASS_NAME
+T MScalar<unsigned short, unsigned short>::abs(unsigned short)
+T MScalar<unsigned short, unsigned short>::cos(unsigned short)
+T MScalar<unsigned short, unsigned short>::neg(unsigned short)
+T MScalar<unsigned short, unsigned short>::sin(unsigned short)
+T MScalar<unsigned short, unsigned short>::tan(unsigned short)
+T MScalar<unsigned short, unsigned short>::acos(unsigned short)
+T MScalar<unsigned short, unsigned short>::asin(unsigned short)
+T MScalar<unsigned short, unsigned short>::atan(unsigned short)
+T MScalar<unsigned short, unsigned short>::cosh(unsigned short)
+T MScalar<unsigned short, unsigned short>::sign(unsigned short)
+T MScalar<unsigned short, unsigned short>::sinh(unsigned short)
+T MScalar<unsigned short, unsigned short>::tanh(unsigned short)
+T MScalar<unsigned short, unsigned short>::acosh(unsigned short)
+T MScalar<unsigned short, unsigned short>::asinh(unsigned short)
+T MScalar<unsigned short, unsigned short>::atanh(unsigned short)
+T MScalar<unsigned short, unsigned short>::rceil(unsigned short)
+T MScalar<unsigned short, unsigned short>::rfloor(unsigned short)
+U MScalar<long long, long long>::CLASS_NAME
+T MScalar<long long, long long>::cos(long long)
+T MScalar<long long, long long>::sin(long long)
+T MScalar<long long, long long>::tan(long long)
+T MScalar<long long, long long>::acos(long long)
+T MScalar<long long, long long>::asin(long long)
+T MScalar<long long, long long>::atan(long long)
+T MScalar<long long, long long>::cosh(long long)
+T MScalar<long long, long long>::sinh(long long)
+T MScalar<long long, long long>::tanh(long long)
+T MScalar<long long, long long>::acosh(long long)
+T MScalar<long long, long long>::asinh(long long)
+T MScalar<long long, long long>::atanh(long long)
+T MScalar<long long, long long>::rceil(long long)
+T MScalar<long long, long long>::rfloor(long long)
+U MScalar<unsigned long long, unsigned long long>::CLASS_NAME
+T MScalar<unsigned long long, unsigned long long>::abs(unsigned long long)
+T MScalar<unsigned long long, unsigned long long>::cos(unsigned long long)
+T MScalar<unsigned long long, unsigned long long>::neg(unsigned long long)
+T MScalar<unsigned long long, unsigned long long>::sin(unsigned long long)
+T MScalar<unsigned long long, unsigned long long>::tan(unsigned long long)
+T MScalar<unsigned long long, unsigned long long>::acos(unsigned long long)
+T MScalar<unsigned long long, unsigned long long>::asin(unsigned long long)
+T MScalar<unsigned long long, unsigned long long>::atan(unsigned long long)
+T MScalar<unsigned long long, unsigned long long>::cosh(unsigned long long)
+T MScalar<unsigned long long, unsigned long long>::sign(unsigned long long)
+T MScalar<unsigned long long, unsigned long long>::sinh(unsigned long long)
+T MScalar<unsigned long long, unsigned long long>::tanh(unsigned long long)
+T MScalar<unsigned long long, unsigned long long>::acosh(unsigned long long)
+T MScalar<unsigned long long, unsigned long long>::asinh(unsigned long long)
+T MScalar<unsigned long long, unsigned long long>::atanh(unsigned long long)
+T MScalar<unsigned long long, unsigned long long>::rceil(unsigned long long)
+T MScalar<unsigned long long, unsigned long long>::rfloor(unsigned long long)
 U Integral::almostEqual(double, double, double, double)
-W Integral::almostEqual(float, float, double, double)
-W Integral::cos(double)
-W Integral::exp(double)
-W Integral::log(double)
-W Integral::max(double, double)
-W Integral::min(double, double)
-W Integral::pow(double, double)
-W Integral::sin(double)
-W Integral::tan(double)
-W Integral::acos(double)
-W Integral::asin(double)
-W Integral::atan(double)
-W Integral::ceil(double)
-W Integral::cosh(double)
-W Integral::exp2(double)
-W Integral::hash(float, unsigned long)
-W Integral::log2(double)
-W Integral::sinh(double)
-W Integral::sqrt(double)
-W Integral::tanh(double)
-W Integral::acosh(double)
-W Integral::asinh(double)
-W Integral::atanh(double)
-W Integral::exp10(double)
-W Integral::floor(double)
-W Integral::log10(double)
-W Integral::log1p(double)
-W Integral::round(double)
-W Integral::hash_32(unsigned long, unsigned long)
-W Integral::fraction(double)
 U SysString::setCapacity(long)
 U SysString::assign(wchar_t const*)
 U SysString::assign(double)
 U SysString::assign(float)
-W SysString::concat(wchar_t const*)
 U SysString::concat(SysString const&)
-W SysString::concat(double)
 U SysString::freeMem()
 U SysString::SysString[in-charge](wchar_t const*)
 U SysString::SysString[in-charge](long)
 U SysString::SysString[not-in-charge](long)
-W SysString::~SysString [in-charge]()
-W SysString::~SysString [not-in-charge]()
-W MScalar<double, double>::operator double() const
-W MScalar<float, float>::almostEqual(float) const
-W MScalar<float, float>::presentValue(double) const
-W MScalar<float, float>::eq(MScalar<float, float> const&) const
-W MScalar<float, float>::eq(float) const
-W MScalar<float, float>::eq(float, float) const
-W MScalar<float, float>::ge(float) const
-W MScalar<float, float>::gt(float) const
-W MScalar<float, float>::le(float) const
-W MScalar<float, float>::lt(float) const
-W MScalar<float, float>::ne(float) const
-W MScalar<float, float>::get(String&) const
-W MScalar<float, float>::hash(unsigned long) const
+T MScalar<SysComplex<double>, double>::presentValue(SysComplex<double>) const
+T MScalar<SysComplex<float>, float>::presentValue(SysComplex<double>) const
+T MScalar<SysComplex<long>, long>::presentValue(SysComplex<double>) const
+T MScalar<double, double>::presentValue(double) const
+T MScalar<double, double>::operator%(double) const
+T MScalar<float, float>::presentValue(double) const
 U MScalar<float, float>::debug(wchar_t const*) const
-W MScalar<float, float>::operator float() const
-W MScalar<float, float>::operator/(float) const
-W MScalar<float, float>::operator==(float) const
-W MScalar<float, float>::operator>=(float) const
-W MScalar<float, float>::operator>(float) const
-W MScalar<float, float>::operator<=(float) const
-W MScalar<float, float>::operator<(float) const
-W MScalar<float, float>::operator-(float) const
-W MScalar<float, float>::operator*(float) const
-W MScalar<float, float>::operator!=(float) const
-W MScalar<float, float>::operator+(float) const
-W MScalar<float, float>::operator%(float) const
-W MScalar<unsigned char, unsigned char>::operator unsigned char() const
-W MScalar<long, long>::operator long() const
-W MScalar<unsigned long, unsigned long>::operator unsigned long() const
-W MScalar<short, short>::operator short() const
-W MScalar<unsigned short, unsigned short>::operator unsigned short() const
-W MScalar<long long, long long>::operator long long() const
-W MScalar<unsigned long long, unsigned long long>::operator unsigned long long() const
+T MScalar<float, float>::operator%(float) const
 U SysString::get(float&) const
-W std::type_info::operator==(std::type_info const&) const
-W std::type_info::operator!=(std::type_info const&) const
 U typeinfo for double
 U typeinfo for float
 U typeinfo for unsigned char
@@ -254,18 +194,14 @@
 U __gxx_personality_v0
 U acos
 U asin
-U atan
-U ceil
 U cos
 U cosh
 U exp
-U floor
 U log
 U log10
 U modf
 U pow
 U sin
 U sinh
-U sqrt
 U tan
 U tanh





-- 
http://www.PowerDNS.com      Open source, database driven DNS Software 
http://lartc.org           Linux Advanced Routing & Traffic Control HOWTO