libstdc++-v3/testsuite/abi_check.cc

   1 // Utility for libstdc++ ABI analysis -*- C++ -*-
   2
   3 // Copyright (C) 2002 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 2, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING.  If not, write to the Free
  18 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19 // USA.
  20
  21 // As a special exception, you may use this file as part of a free software
  22 // library without restriction.  Specifically, if other files instantiate
  23 // templates or use macros or inline functions from this file, or you compile
  24 // this file and link it with other files to produce an executable, this
  25 // file does not by itself cause the resulting executable to be covered by
  26 // the GNU General Public License.  This exception does not however
  27 // invalidate any other reasons why the executable file might be covered by
  28 // the GNU General Public License.
  29
  30 // Benjamin Kosnik  <bkoz@redhat.com>
  31
  32 #include <string>
  33 #include <ext/hash_map>
  34 #include <deque>
  35 #include <sstream>
  36 #include <fstream>
  37 #include <iostream>
  38 #include <cxxabi.h>
  39
  40 struct symbol_info
  41 {
  42   enum category { none, function, object, error };
  43   category      type;
  44   std::string   name;
  45   std::string   name_demangled;
  46   std::string   version;
  47   int           size;
  48
  49   symbol_info() : type(none), size(0) { }
  50
  51   symbol_info(const symbol_info& other)
  52   : type(other.type), name(other.name), name_demangled(other.name_demangled),
  53   version(other.version), size(other.size) { }
  54 };
  55
  56 bool
  57 operator==(const symbol_info& lhs, const symbol_info& rhs)
  58 {
  59   bool ret = true;
  60
  61   // Check to see if symbol_infos are compatible.
  62   ret &= lhs.type == rhs.type;
  63   ret &= lhs.name == rhs.name;
  64   ret &= lhs.size == rhs.size;
  65
  66   // Expect something more sophisticated eventually.
  67   ret &= lhs.version == rhs.version;
  68   return ret;
  69 }
  70
  71 bool
  72 operator!=(const symbol_info& lhs, const symbol_info& rhs)
  73 { return !(lhs == rhs); }
  74
  75 template<typename _CharT, typename _Traits>
  76   std::basic_ostream<_CharT, _Traits>&
  77   operator<<(std::basic_ostream<_CharT, _Traits>& os, symbol_info& si)
  78   {
  79     using namespace std;
  80     os << si.type << endl;
  81     os << si.name << endl;
  82     os << si.name_demangled << endl;
  83     os << si.version << endl;
  84     os << si.size << endl;
  85     return os;
  86   }
  87
  88 const char*
  89 demangle(const std::string& mangled)
  90 {
  91   const char* name;
  92   if (mangled[0] != '_' && mangled[1] != 'Z')
  93     {
  94       // This is not a mangled symbol, thus has "C" linkage.
  95       name = mangled.c_str();
  96     }
  97   else
  98     {
  99       // Use __cxa_demangle to demangle.
 100       int status = 0;
 101       name = abi::__cxa_demangle(mangled.c_str(), 0, 0, &status);
 102       if (!name)
 103         {
 104           switch (status)
 105             {
 106             case 0:
 107               name = "error code = 0: success";
 108               break;
 109             case -1:
 110               name = "error code = -1: memory allocation failure";
 111               break;
 112             case -2:
 113               name = "error code = -2: invalid mangled name";
 114               break;
 115             case -3:
 116               name = "error code = -3: invalid arguments";
 117               break;
 118             default:
 119               name = "error code unknown - who knows what happened";
 120             }
 121         }
 122     }
 123   return name;
 124 }
 125
 126 void
 127 line_to_symbol_info(std::string& input, symbol_info& output)
 128 {
 129   using namespace std;
 130   const char delim = ':';
 131   const char version_delim = '@';
 132   const string::size_type npos = string::npos;
 133   string::size_type n = 0;
 134
 135   // Set the type.
 136   if (input.find("FUNC") == 0)
 137     output.type = symbol_info::function;
 138   else if (input.find("OBJECT") == 0)
 139     output.type = symbol_info::object;
 140   else
 141     output.type = symbol_info::error;
 142   n = input.find_first_of(delim);
 143   if (n != npos)
 144     input.erase(input.begin(), input.begin() + n + 1);
 145
 146   // Iff object, get size info.
 147   if (output.type == symbol_info::object)
 148     {
 149       n = input.find_first_of(delim);
 150       if (n != npos)
 151         {
 152           string size(input.begin(), input.begin() + n);
 153           istringstream iss(size);
 154           int x;
 155           iss >> x;
 156           if (iss.good())
 157             output.size = x;
 158           input.erase(input.begin(), input.begin() + n + 1);
 159         }
 160     }
 161
 162   // Set the name.
 163   n = input.find_first_of(version_delim);
 164   if (n != npos)
 165     {
 166       // Found version string.
 167       output.name = string(input.begin(), input.begin() + n);
 168       n = input.find_last_of(version_delim);
 169       input.erase(input.begin(), input.begin() + n + 1);
 170
 171       // Set version name.
 172       output.version = input;
 173     }
 174   else
 175     {
 176       // No versioning info.
 177       output.name = string(input.begin(), input.end());
 178       input.erase(input.begin(), input.end());
 179     }
 180
 181   // Set the demangled name.
 182   output.name_demangled = demangle(output.name);
 183 }
 184
 185 typedef std::deque<std::string>                         symbol_names;
 186 typedef __gnu_cxx::hash_map<const char*, symbol_info>   symbol_infos;
 187
 188 void
 189 collect_symbol_data(const char* file, symbol_infos& symbols,
 190                     symbol_names& names)
 191 {
 192   // Parse list of symbols in file into vectors of symbol_info.
 193   // For 3.2.0 on x86/linux, this usually is
 194   // 947 non-weak symbols
 195   // 2084 weak symbols
 196   using namespace std;
 197   ifstream ifs(file);
 198   if (ifs.is_open())
 199     {
 200       // Organize input into container of symbol_info objects.
 201       const string empty;
 202       string line = empty;
 203       while (getline(ifs, line).good())
 204         {
 205           symbol_info symbol;
 206           line_to_symbol_info(line, symbol);
 207           symbols[symbol.name.c_str()] = symbol;
 208           names.push_back(symbol.name);
 209           line = empty;
 210         }
 211     }
 212 }
 213
 214
 215 int main(int argc, char** argv)
 216 {
 217   using namespace std;
 218
 219   // Get arguments.
 220   if (argc != 2)
 221     {
 222       cerr << "Usage:  abi_check baseline_file" << endl;
 223       exit(1);
 224     }
 225   const char* baseline_file = argv[1];
 226   const char* test_file = "current_symbols.txt";
 227   const char* test_lib = "../src/.libs/libstdc++.so";
 228
 229   // Get list of symbols.
 230   // Assume external symbol list computed "as if" by
 231   /*
 232    readelf -s -W libstdc++.so | sed '/\.dynsym/,/^$/p;d' | egrep -v
 233    ' (LOCAL|UND) ' | awk '{ if ($4 == "FUNC" || $4 == "NOTYPE") printf
 234    "%s:%s\n", $4, $8; else if ($4 == "OBJECT") printf "%s:%s:%s\n", $4,
 235    $3, $8;}' | sort >& current_symbols.txt
 236    */
 237   const char quote = '"';
 238   const char bslash = '\\';
 239   ostringstream cmd;
 240   cmd << "readelf -s -W " << test_lib << " | sed '/" << bslash
 241       << ".dynsym/,/^$/p;d' | egrep -v ' (LOCAL|UND) ' | "
 242       << "awk '{ if ($4 == " << quote << "FUNC" << quote << "|| $4 == "
 243       << quote << "NOTYPE" << quote << ") printf " << quote << "%s:%s"
 244       << bslash << "n" << quote << ", $4, $8; else if ($4 == "
 245       << quote << "OBJECT" << quote << ") printf " << quote
 246       << "%s:%s:%s" << bslash << "n" << quote << ", $4, $3, $8;}' | "
 247       << "sort >& " << test_file;
 248   if (system(cmd.str().c_str()) != 0)
 249     {
 250       cerr << "Unable to generate the list of exported symbols." << endl;
 251       exit(2);
 252     }
 253
 254   // Input both list of symbols into container.
 255   symbol_infos  baseline_symbols;
 256   symbol_names  baseline_names;
 257   symbol_infos  test_symbols;
 258   symbol_names  test_names;
 259   collect_symbol_data(baseline_file, baseline_symbols, baseline_names);
 260   collect_symbol_data(test_file, test_symbols, test_names);
 261
 262   // Basic sanity check. (Was: error checking, what's that?)
 263   const symbol_names::size_type baseline_size = baseline_names.size();
 264   const symbol_names::size_type test_size = test_names.size();
 265   if (!baseline_size || !test_size)
 266     {
 267       cerr << "Problems parsing the list of exported symbols." << endl;
 268       exit(2);
 269     }
 270
 271   // Sort out names.
 272   // Assuming baseline_names, test_names are both unique w/ no duplicates.
 273   //
 274   // The pairs of names in shared_names are needed to do lookups on
 275   // the hash tables of common symbols to do compares.
 276   //
 277   // The names added to missing_names are baseline_names not found in
 278   // test_names
 279   // -> symbols that have been deleted.
 280   //
 281   // The names left in test_names are names not in baseline_names
 282   // -> symbols that have been added.
 283   typedef pair<string, string> string_pair;
 284   vector<string_pair> shared_names;
 285   symbol_names missing_names;
 286   for (size_t i = 0; i < baseline_size; ++i)
 287     {
 288       symbol_names::iterator end = test_names.end();
 289       symbol_names::iterator it = find(test_names.begin(), end,
 290                                        baseline_names[i]);
 291       if (it != end)
 292         {
 293           // Found.
 294           shared_names.push_back(string_pair(baseline_names[i], *it));
 295           test_names.erase(it);
 296         }
 297       else
 298         missing_names.push_back(baseline_names[i]);
 299     }
 300
 301   // Check common names for detailed compatibility.
 302   const vector<string_pair>::size_type shared_size = shared_names.size();
 303   typedef pair<symbol_info, symbol_info> symbol_pair;
 304   vector<symbol_pair> incompatible;
 305   for (size_t i = 0; i < shared_size; ++i)
 306     {
 307       symbol_info binfo = baseline_symbols[shared_names[i].first.c_str()];
 308       symbol_info tinfo = test_symbols[shared_names[i].second.c_str()];
 309       if (binfo != tinfo)
 310         incompatible.push_back(symbol_pair(binfo, tinfo));
 311     }
 312
 313   // Output data.
 314   cout << test_names.size() << " added symbols " << endl;
 315   for (size_t j = 0; j < test_names.size() ; ++j)
 316     cout << '\t' << test_names[j] << endl;
 317
 318   cout << missing_names.size() << " missing symbols " << endl;
 319   for (size_t j = 0; j < missing_names.size() ; ++j)
 320     cout << '\t' << missing_names[j] << endl;
 321
 322   cout << incompatible.size() << " incompatible symbols " << endl;
 323   for (size_t j = 0; j < incompatible.size() ; ++j)
 324     {
 325       cout << "baseline symbol_info:" << endl;
 326       cout << incompatible[j].first << endl;
 327       cout << "test symbol_info:" << endl;
 328       cout << incompatible[j].second << endl;
 329     }
 330
 331   return 0;
 332 }