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 }