IV87935: SEGMENTATION FAULT WITH STL <ALGORITHM> SORT

XL C/C++ for AIX Fix Pack 17 (November 2016 Update) for 12.1
XL C/C++ for AIX Fix Pack 18 (February 2017 Update) for 12.1
XL C/C++ for AIX Fix Pack 19 (August 2017 Update) for 12.1
XL C/C++ for AIX Fix Pack 20 (March 2018 Update) for 12.1
XL C/C++ for AIX Fix Pack 21 (January 2019 Update) for 12.1

APAR status

• Closed as program error.

Error description

• A segmentation fault may be seen when using the STL <algorithm>
  sort() function.  A C++ standard-conforming change was made to
  the sort() function in the XL C/C++ for AIX, V12.1.0.3 PTF
  release for performance reasons.  Code not conforming to the
  standard for sort() usage may encounter issues.
  
  
  Sorting data structures 16 elements in size or smaller is not
  affected.
  
  
  Per C++03 subclause 25.3 [lib.alg.sorting] paragraphs 3 and 4,
  the comparison operation should produce !comp(x, x) for all x.
  
  
  In the following test case, the Comp() comparison function uses
  (ret <= 0) to compare the elements, when a comparison of (ret <
  0) should be used to be standard-conforming.  This may affect
  comparison design in some scenarios.
  
  
  
     === TEST CASE ===
  
  #include <iostream>
  #include <cstring>
  #include <algorithm>
  
  using namespace std;
  
  struct element
  {
     char val1[100];
     char val2[100];
  };
  
  int compare_element(const struct element *p1,
                      const struct element *p2)
  {
   int ret = 0;
  
   if( !(ret = strcmp(((struct element *)p1)->val1,
        ((struct element *)p2)->val1))
          &&
       !(ret = strcmp(((struct element *)p1)->val2,
        ((struct element *)p2)->val2)) )
   {}
  
     return ret;
  }
  
  struct Comp
  {
   bool operator() (const struct element& x,
                    const struct element& y)
   {
     int ret = compare_element(&x, &y);
  
     if (ret <= 0) return(true); // SHOULD BE (ret < 0)
  
     return(false);
   }
  };
  
  int main()
  {
   static struct element array[] = {
      {"a","a"}, {"b","b"}, {"c","c"}, {"d","d"},
      {"e","e"}, {"f","f"}, {"g","g"}, {"h","h"},
      {"i","i"}, {"j","j"}, {"k","k"}, {"l","l"},
      {"m","m"}, {"n","n"}, {"o","o"}, {"p","p"},
      {"q","q"}
   };
  
   int nCount = sizeof(array)/sizeof(struct element);
   cout << "Array Size: " << nCount << endl;
  
   struct element *sort_array = (struct element *)malloc(nCount);
   for(int i = 0; i < nCount; i++) sort_array[i] = array[i];
  
   sort(sort_array, sort_array + nCount, Comp());
  
   return 0;
  }
  
  
  $ xlC test.cpp
  $ ./a.out
  Array Size: 17
  Segmentation fault (core dumped)
  $
  

Local fix

• Modify code to be standard-conforming.
  

Problem summary

• PROBLEM DESCRIPTION:
  Some non-standard conforming code may encounter issues with the
  new STL <algorithm> sort() implementation compared to the
  previous implementation.
  
  USERS AFFECTED:
  Users with non-standard conforming code.
  

Problem conclusion

• For users who are unable to modify their code, the macro
  __IBMCPP_USE_DEPRECATED_STD_SORT_IMPL has been included to
  restore the previous STL <algorithm> sort() behaviour.  The
  macro can be defined in-source with a #define before including
  <algorithm>, or can be included in compile options with
  -D__IBMCPP_USE_DEPRECATED_STD_SORT_IMPL .
  

Temporary fix

Comments

APAR Information

• APAR is sysrouted FROM one or more of the following:

  IV77602

• APAR is sysrouted TO one or more of the following:

  PI67565

Fix information

• Fixed component name

  XL C/C++ FOR AI

• Fixed component ID

  5725C7200

Applicable component levels