[boost] [optional] generates unnessesary code for trivial types

Subject: [boost] [optional] generates unnessesary code for trivial types
From: Hite, Christopher (Christopher.Hite_at_[hidden])
Date: 2012-01-25 12:28:45

When decompiling my code I noticed a bunch of unnessesary code caused by boost::optional.

1) deconstruction
typedef boost::optional<int> optional_int;

void deconstruct_boost_optional(optional_int& o){
        o.~optional_int();
}

One would expect this to do nothing.  Instead gcc 4.6.0  with O3 generates:

        if(m_initialized){
                // do nothing
                m_initialized = false;
        }

00000000 <deconstruct_boost_optional(boost::optional<int>&)>:
   0:   8b 44 24 04             mov    0x4(%esp),%eax
   4:   80 38 00                cmpb   $0x0,(%eax)
   7:   74 03                   je     c <deconstruct_boost_optional(boost::optional<int>&)+0xc>
   9:   c6 00 00                movb   $0x0,(%eax)
   c:   f3 c3                   repz ret

This one could be easily fixed by removing the bit that sets m_initialized to false, since we're deconstructing anyway.

2) assignment also generates these problems:

void assign_boost_optional(optional_int& o){
        o=13;
}

Here there's a semantic issue: we have to decide to use the copy constructor or operator=.  This is also wasteful for POD types or any type which has_trivial_copy<>.

3) Even more expensive is if we want to copy an optional<int>

void assign_boost_optional(optional_int& a,optional_int& b){
        a=b;
}

00000000 <assign_boost_optional(boost::optional<int>&, boost::optional<int>&)>:
   0:   8b 44 24 04             mov    0x4(%esp),%eax
   4:   8b 54 24 08             mov    0x8(%esp),%edx
   8:   80 38 00                cmpb   $0x0,(%eax)
   b:   74 0b                   je     18 <assign_boost_optional(boost::optional<int>&, boost::optional<int>&)+0x18>
   d:   80 3a 00                cmpb   $0x0,(%edx)
  10:   75 16                   jne    28 <assign_boost_optional(boost::optional<int>&, boost::optional<int>&)+0x28>
  12:   c6 00 00                movb   $0x0,(%eax)
  15:   c3                      ret
  16:   66 90                   xchg   %ax,%ax
  18:   80 3a 00                cmpb   $0x0,(%edx)
  1b:   74 09                   je     26 <assign_boost_optional(boost::optional<int>&, boost::optional<int>&)+0x26>
  1d:   8b 52 04                mov    0x4(%edx),%edx
  20:   c6 00 01                movb   $0x1,(%eax)
  23:   89 50 04                mov    %edx,0x4(%eax)
  26:   f3 c3                   repz ret
  28:   8b 52 04                mov    0x4(%edx),%edx
  2b:   89 50 04                mov    %edx,0x4(%eax)
  2e:   c3                      ret

Three possible branches!  Theoretically single 64 bit copy do the job.  I'm tempted to say: it would be best if for any T has_trivial_copy< optional<T> > iff has_trivial_copy<T>.  It might make a sense to make an exception for huge T, where the copying an unused T is more expensive than the branching.

4) has_trivial_destructor<T> should impl has_trivial_destructor< optional<T> > , but this is hard to implement without specialization of optional.

Checking has_trivial_destructor might take care of the complexity of optional<T&> since has_trivial_destructor< T& >.

I'd be willing to fix #1.  The other issues need some discussion.

Chris