OSDN Git Service

2002-08-22 Benjamin Kosnik <bkoz@redhat.com>
[pf3gnuchains/gcc-fork.git] / 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 }