Compile fix after removing deprecated SymtabAPI methods.
[dyninst.git] / symtabAPI / src / Symbol.C
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 #include "symutil.h"
32 #include "Symbol.h"
33 #include "Module.h"
34 #include "Symtab.h"
35 #include "Aggregate.h"
36 #include "Function.h"
37 #include "Variable.h"
38 #include <string>
39 #include "annotations.h"
40
41 #include <iostream>
42
43
44 using namespace Dyninst;
45 using namespace SymtabAPI;
46
47 #if !defined(SERIALIZATION_DISABLED)
48 bool addSymID(SerializerBase *sb, Symbol *sym, Address id)
49 {
50         assert(id);
51         assert(sym);
52         assert(sb);
53
54         SerContextBase *scb = sb->getContext();
55         if (!scb)
56         {
57                 fprintf(stderr, "%s[%d]:  SERIOUS:  FIXME\n", FILE__, __LINE__);
58                 return false;
59         }
60
61         SerContext<Symtab> *scs = dynamic_cast<SerContext<Symtab> *>(scb);
62
63         if (!scs)
64         {
65                 fprintf(stderr, "%s[%d]:  SERIOUS:  FIXME\n", FILE__, __LINE__);
66                 return false;
67         }
68
69         Symtab *st = scs->getScope();
70
71         if (!st)
72         {
73                 fprintf(stderr, "%s[%d]:  SERIOUS:  FIXME\n", FILE__, __LINE__);
74                 return false;
75         }
76
77         dyn_hash_map<Address, Symbol *> *smap = NULL;
78
79         if (!st->getAnnotation(smap, IdToSymAnno))
80         {
81                 smap = new dyn_hash_map<Address, Symbol *>();
82
83                 if (!st->addAnnotation(smap, IdToSymAnno))
84                 {
85                         fprintf(stderr, "%s[%d]:  ERROR:  failed to add IdToSymMap anno to Symtab\n", 
86                                         FILE__, __LINE__);
87                         return false;
88                 }
89         }
90
91         assert(smap);
92
93         if (serializer_debug_flag())
94         {
95                 dyn_hash_map<Address, Symbol *>::iterator iter = smap->find(id);
96                 if (iter != smap->end())
97                 {
98                         fprintf(stderr, "%s[%d]:  WARNING:  already have mapping for IdToSym\n", 
99                                         FILE__, __LINE__);
100                 }
101         }
102
103         (*smap)[id] = sym;
104         return true;
105 }
106
107 Symbol * getSymForID(SerializerBase *sb, Address id)
108 {
109         assert(id);
110         assert(sb);
111
112         SerContextBase *scb = sb->getContext();
113         if (!scb)
114         {
115                 fprintf(stderr, "%s[%d]:  SERIOUS:  FIXME\n", FILE__, __LINE__);
116                 return NULL;
117         }
118
119         SerContext<Symtab> *scs = dynamic_cast<SerContext<Symtab> *>(scb);
120
121         if (!scs)
122         {
123                 fprintf(stderr, "%s[%d]:  SERIOUS:  FIXME\n", FILE__, __LINE__);
124                 return NULL;
125         }
126
127         Symtab *st = scs->getScope();
128
129         if (!st)
130         {
131                 fprintf(stderr, "%s[%d]:  SERIOUS:  FIXME\n", FILE__, __LINE__);
132                 return NULL;
133         }
134
135         dyn_hash_map<Address, Symbol *> *smap = NULL;
136         if (!st->getAnnotation(smap, IdToSymAnno))
137         {
138                 fprintf(stderr, "%s[%d]:  ERROR:  failed to find IdToSymMap anno on Symtab\n", 
139                                 FILE__, __LINE__);
140                 return NULL;
141         }
142         assert(smap);
143         dyn_hash_map<Address, Symbol *>::iterator iter = smap->find(id);
144         if (iter == smap->end())
145         {
146                 fprintf(stderr, "%s[%d]:  ERROR:  failed to find id %p in IdToSymMap\n", 
147                                 FILE__, __LINE__, (void *)id);
148                 return NULL;
149         }
150         return iter->second;
151 }
152 #else
153 bool addSymID(SerializerBase *, Symbol *, Address)
154 {
155    return false;
156 }
157
158 Symbol * getSymForID(SerializerBase *, Address)
159 {
160    return NULL;
161 }
162 #endif
163
164 Symbol *Symbol::magicEmitElfSymbol() {
165         // I have no idea why this is the way it is,
166         // but emitElf needs it...
167         return new Symbol("",
168                         ST_NOTYPE,
169                       SL_LOCAL,
170                       SV_DEFAULT,
171                       0,
172                       NULL,
173                       NULL,
174                       0,
175                       false,
176                       false);
177 }
178     
179 SYMTAB_EXPORT const string& Symbol::getMangledName() const 
180 {
181     return mangledName_;
182 }
183
184 SYMTAB_EXPORT const string& Symbol::getPrettyName() const 
185 {
186     return prettyName_;
187 }
188
189 SYMTAB_EXPORT const string& Symbol::getTypedName() const 
190 {
191     return typedName_;
192 }
193
194 bool Symbol::setOffset(Offset newOffset)
195 {
196     offset_ = newOffset;
197     return true;
198 }
199
200 bool Symbol::setPtrOffset(Offset newOffset)
201 {
202     ptr_offset_ = newOffset;
203     return true;
204 }
205
206 bool Symbol::setLocalTOC(Offset toc)
207 {
208     localTOC_ = toc;
209     return true;
210 }
211
212 SYMTAB_EXPORT bool Symbol::setModule(Module *mod) 
213 {
214     module_ = mod; 
215     return true;
216 }
217
218 SYMTAB_EXPORT bool Symbol::isFunction() const
219 {
220     return (getFunction() != NULL);
221 }
222
223 SYMTAB_EXPORT bool Symbol::setFunction(Function *func)
224 {
225     aggregate_ = func;
226     return true;
227 }
228
229 SYMTAB_EXPORT Function * Symbol::getFunction() const
230 {
231         if (aggregate_ == NULL) 
232                 return NULL;
233     return dynamic_cast<Function *>(aggregate_);
234 }
235
236 SYMTAB_EXPORT bool Symbol::isVariable() const 
237 {
238     return (getVariable() != NULL);
239 }
240
241 SYMTAB_EXPORT bool Symbol::setVariable(Variable *var) 
242 {
243     aggregate_ = var;
244     return true;
245 }
246
247 SYMTAB_EXPORT Variable * Symbol::getVariable() const
248 {
249     return dynamic_cast<Variable *>(aggregate_);
250 }
251
252 SYMTAB_EXPORT bool Symbol::setSize(unsigned ns)
253 {
254         size_ = ns;
255         return true;
256 }
257
258 SYMTAB_EXPORT bool Symbol::setRegion(Region *r)
259 {
260         region_ = r;
261         return true;
262 }
263
264 SYMTAB_EXPORT Symbol::SymbolTag Symbol::tag() const 
265 {
266     return tag_;
267 }
268
269
270 SYMTAB_EXPORT bool Symbol::setSymbolType(SymbolType sType)
271 {
272     if ((sType != ST_UNKNOWN)&&
273         (sType != ST_FUNCTION)&&
274         (sType != ST_OBJECT)&&
275         (sType != ST_MODULE)&&
276         (sType != ST_NOTYPE))
277         return false;
278     
279     SymbolType oldType = type_; 
280     type_ = sType;
281     if (module_ && module_->exec())
282         module_->exec()->changeType(this, oldType);
283
284     // TODO: update aggregate with information
285     
286     return true;
287 }
288
289 SYMTAB_EXPORT bool Symbol::setVersionFileName(std::string &fileName)
290 {
291    std::string *fn_p = NULL;
292    if (getAnnotation(fn_p, SymbolFileNameAnno)) 
293    {
294       if (!fn_p) 
295       {
296          fprintf(stderr, "%s[%d]:  inconsistency here\n", FILE__, __LINE__);
297       }
298       else
299       {
300          fprintf(stderr, "%s[%d]:  WARNING, already have filename set for symbol %s\n", 
301                  FILE__, __LINE__, getMangledName().c_str());
302       }
303       return false;
304    }
305    else
306    {
307       //  not sure if we need to copy here or not, so let's do it...
308       std::string *fn = new std::string(fileName);
309       if (!addAnnotation(fn, SymbolFileNameAnno)) 
310       {
311          fprintf(stderr, "%s[%d]:  failed to add anno here\n", FILE__, __LINE__);
312          return false;
313       }
314       return true;
315    }
316
317    return false;
318 }
319
320 SYMTAB_EXPORT bool Symbol::setVersions(std::vector<std::string> &vers)
321 {
322    std::vector<std::string> *vn_p = NULL;
323    if (getAnnotation(vn_p, SymbolVersionNamesAnno)) 
324    {
325       if (!vn_p) 
326       {
327          fprintf(stderr, "%s[%d]:  inconsistency here\n", FILE__, __LINE__);
328       }
329       else
330          fprintf(stderr, "%s[%d]:  WARNING, already have versions set for symbol %s\n", FILE__, __LINE__, getMangledName().c_str());
331       return false;
332    }
333    else
334    {
335       if (!addAnnotation(&vers, SymbolVersionNamesAnno)) 
336       {
337          fprintf(stderr, "%s[%d]:  failed to add anno here\n", FILE__, __LINE__);
338       }
339    }
340
341    return true;
342 }
343
344 SYMTAB_EXPORT bool Symbol::getVersionFileName(std::string &fileName)
345 {
346    std::string *fn_p = NULL;
347
348    if (getAnnotation(fn_p, SymbolFileNameAnno)) 
349    {
350       if (!fn_p) 
351       {
352          fprintf(stderr, "%s[%d]:  inconsistency here\n", FILE__, __LINE__);
353       }
354       else
355          fileName = *fn_p;
356
357       return true;
358    }
359
360    return false;
361 }
362
363 SYMTAB_EXPORT bool Symbol::getVersions(std::vector<std::string> *&vers)
364 {
365    std::vector<std::string> *vn_p = NULL;
366
367    if (getAnnotation(vn_p, SymbolVersionNamesAnno)) 
368    {
369       if (!vn_p) 
370       {
371          fprintf(stderr, "%s[%d]:  inconsistency here\n", FILE__, __LINE__);
372       }
373       else
374       {
375          vers = vn_p;
376          return true;
377       } 
378    }
379
380    return false;
381 }
382
383 SYMTAB_EXPORT bool Symbol::setMangledName(std::string name)
384 {
385    mangledName_ = name;
386    setStrIndex(-1);
387    return true;
388 }
389 Serializable *Symbol::serialize_impl(SerializerBase *, const char *) THROW_SPEC (SerializerError)
390 {
391    return NULL;
392 }
393
394 void Symbol::restore_module_and_region(SerializerBase *, std::string &, Offset) THROW_SPEC (SerializerError)
395 {
396 }
397
398 std::ostream& Dyninst::SymtabAPI::operator<< (ostream &os, const Symbol &s) 
399 {
400         return os << "{"
401                   << " mangled=" << s.getMangledName()
402                   << " pretty="  << s.getPrettyName()
403                   << " module="  << s.module_
404            //<< " type="    << (unsigned) s.type_
405                   << " type="    << s.symbolType2Str(s.type_)
406            //<< " linkage=" << (unsigned) s.linkage_
407                   << " linkage=" << s.symbolLinkage2Str(s.linkage_)
408                   << " offset=0x"    << hex << s.offset_ << dec
409                   << " size=0x" << hex << s.size_ << dec
410                   << " ptr_offset=0x"    << hex << s.ptr_offset_ << dec
411                   << " localTOC=0x"    << hex << s.localTOC_ << dec
412         //<< " tag="     << (unsigned) s.tag_
413                   << " tag="     << s.symbolTag2Str(s.tag_)
414                   << " isAbs="   << s.isAbsolute_
415                   << " isCommon=" << s.isCommonStorage_
416                   << (s.isFunction() ? " [FUNC]" : "")
417                   << (s.isVariable() ? " [VAR]" : "")
418                   << (s.isInSymtab() ? "[STA]" : "[DYN]")
419                   << " }";
420 }
421
422      Offset tryStart_;
423                unsigned trySize_;
424                          Offset catchStart_;
425                                        bool hasTry_;
426
427 ostream & Dyninst::SymtabAPI::operator<< (ostream &s, const ExceptionBlock &eb) 
428 {
429         s << "tryStart=" << eb.tryStart_ 
430                 << "trySize=" << eb.trySize_ 
431                 << "catchStart=" << eb.catchStart_ 
432                 << "hasTry=" << eb.trySize_ ;
433         return s; 
434 }
435
436 bool Symbol::operator==(const Symbol& s) const
437 {
438         // explicitly ignore tags when comparing symbols
439
440         //  compare sections by offset, not pointer
441         if (!region_ && s.region_) return false;
442         if (region_ && !s.region_) return false;
443         if (region_)
444         {
445                 if (region_->getDiskOffset() != s.region_->getDiskOffset())
446                         return false;
447         }
448
449         // compare modules by name, not pointer
450         if (!module_ && s.module_) return false;
451         if (module_ && !s.module_) return false;
452         if (module_)
453         {
454                 if (module_->fullName() != s.module_->fullName())
455                         return false;
456         }
457
458         return (   (type_    == s.type_)
459                         && (linkage_ == s.linkage_)
460                         && (offset_    == s.offset_)
461                         && (size_    == s.size_)
462                         && (isDynamic_ == s.isDynamic_)
463                         && (isAbsolute_ == s.isAbsolute_)
464                         && (isCommonStorage_ == s.isCommonStorage_)
465                    && (versionHidden_ == s.versionHidden_)
466                         && (mangledName_ == s.mangledName_)
467                         && (prettyName_ == s.prettyName_)
468                         && (typedName_ == s.typedName_));
469 }
470
471 Symtab *Symbol::getSymtab() const { 
472    return module_->exec(); 
473 }
474
475 Symbol::Symbol () :
476   module_(NULL),
477   type_(ST_NOTYPE),
478   internal_type_(0),
479   linkage_(SL_UNKNOWN),
480   visibility_(SV_UNKNOWN),
481   offset_(0),
482   ptr_offset_(0),
483   localTOC_(0),
484   region_(NULL),
485   referring_(NULL),
486   size_(0),
487   isDynamic_(false),
488   isAbsolute_(false),
489   aggregate_(NULL),
490   mangledName_(Symbol::emptyString),
491   prettyName_(Symbol::emptyString),
492   typedName_(Symbol::emptyString),
493   tag_(TAG_UNKNOWN) ,
494   index_(-1),
495   strindex_(-1),
496   isCommonStorage_(false),
497   versionHidden_(false)
498 {
499 }
500
501 Symbol::Symbol(const std::string& name,
502                SymbolType t,
503                SymbolLinkage l,
504                SymbolVisibility v,
505                Offset o,
506                Module *module,
507                Region *r,
508                unsigned s,
509                bool d,
510                bool a,
511                int index,
512                int strindex,
513                bool cs):
514   module_(module),
515   type_(t),
516   internal_type_(0),
517   linkage_(l),
518   visibility_(v),
519   offset_(o),
520   ptr_offset_(0),
521   localTOC_(0),
522   region_(r),
523   referring_(NULL),
524   size_(s),
525   isDynamic_(d),
526   isAbsolute_(a),
527   aggregate_(NULL),
528   mangledName_(name),
529   prettyName_(name),
530   typedName_(name),
531   tag_(TAG_UNKNOWN),
532   index_(index),
533   strindex_(strindex),
534   isCommonStorage_(cs),
535   versionHidden_(false)
536 {
537 }
538
539 Symbol::~Symbol ()
540 {
541         std::string *sfa_p = NULL;
542
543         if (getAnnotation(sfa_p, SymbolFileNameAnno))
544         {
545                 if (!removeAnnotation(SymbolFileNameAnno))
546                 {
547                         fprintf(stderr, "%s[%d]:  failed to remove file name anno\n", 
548                                         FILE__, __LINE__);
549                 }
550                 delete (sfa_p);
551         }
552 }
553
554 void Symbol::setReferringSymbol(Symbol* referringSymbol) 
555 {
556         referring_= referringSymbol;
557 }
558
559 Symbol* Symbol::getReferringSymbol() {
560         return referring_;
561 }