Pointer comparison. 2006-12-5(Tue)

• Abstract: This is a bit complicated bug. So I just tell you a story. I truck down this bug for two weeks. The program crashes. But it happens:
  • Only in Linux 32bit + gcc
  • Not Linux 64 bit + icc
  • Not Windows + VC
  • If I added a member variable, it's gone.
  • If I added a virtual to a member function, it's gone.
  • A specific data only revels this bug.
• The last story, number initialization story was a nice experience for me. But this story is not. This was the tough one. The program was C++. I need to debug it or I need to re-write whole program. I think the programmer has no idea about interface and object oriented programming. All the members are public. He or she wrote his/her own container classes with old C style.
• This sometimes happens at some high ability programmers. Some programmers can handle many variables at once. So they do not need to use encapsulation, also not need to use abstraction.
• I can not debug such a program. I forget variable names if they do not in my screen. So, I made them local and private. Member variables are kind of global for me, because they appear in any other member functions.
• The bug was crash, only in gcc Linux. Other environment, e.g., Windows vc7.1 and Linux + icc 9.0 have no crash.
• But still it may easier to find a bug than rewrite all the module. But I found this bug is somehow by writing own program. I could not find the bug for a week, then I start to write subroutines. That routines should do the same thing, but according to my own understanding. The data structure is checked by my code each time. Finally I found a difference. It is in a set lookup. I did not doubt std::set part has a problem since it used so widely and stable.
• Let's see the part of the code.

       // some class      
       class ANode {
       public:
         /// constructor
         ANode() : d_id(-1){}
         /// constructor
         ANode(int id) : d_id(id){}
         /// destructor
         ~ANode(){}
       public:
         int  d_id;
         int  d_dummy_int[3];
         char d_dummy_char;
       };
  
       // comparison function for std::set 
       struct ltptr {
         bool operator()(const ANode* ptr0, const ANode* ptr1) const {
           return ptr0 - ptr1;
         }
       };
       
       // ... somewhere in the code
       std::set< ANode*, ltptr > ptrset;
       

• The pointer comparison of course is only valid the objects are in an array. In this case it is not. However, set only needs difference of the pointers. They are addresses, they are numbers, is it a really problem?
• I thought the next way. Is there a case hex numbers could be not total ordered? I did not noticed this.
• Pointer comparison is divided by sizeof(obj), and what is the type of that? What happens if it is not dividable? This is the bug!
• There is a case, two pointers are next values,

       p0 - p1 = 0x804c0e8 - 0x804c008 = -1431655756
       

  0x804c0e8 > 0x804c008, but the result is minus value! This is gcc 3.3.4, Linux 32 bit case.
• I slightly doubt during the debugging the gcc has some bugs. But it turns out, gcc new() could compactly allocable objects than others, that means the memory gap is less than other compiler. So, memory usage is effective than others. But, it causes this bug. The standard said it is illegal to use to compare pointers not in an array. So, other compiler and environment is working is just coincidence.
• This is tough. It should not be that. However, one solution could be to cast the pointer to (ptrdiff_t). But this is not so good anyway.