symtabAPI/src/Module.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 <string.h>
  32
  33 #include "Annotatable.h"
  34 #include "Module.h"
  35 #include "Symtab.h"
  36 #include "Collections.h"
  37 #include "Function.h"
  38 #include "Variable.h"
  39 #include "LineInformation.h"
  40 #include "symutil.h"
  41 #include "annotations.h"
  42
  43 #include "common/h/pathName.h"
  44 #include "common/h/serialize.h"
  45
  46 using namespace Dyninst;
  47 using namespace Dyninst::SymtabAPI;
  48 using namespace std;
  49
  50 static SymtabError serr;
  51
  52
  53 bool Module::findSymbol(std::vector<Symbol *> &found,
  54                         const std::string& name,
  55                         Symbol::SymbolType sType,
  56                         NameType nameType,
  57                         bool isRegex,
  58                         bool checkCase,
  59                         bool includeUndefined) {
  60     unsigned orig_size = found.size();
  61     std::vector<Symbol *> obj_syms;
  62
  63     if (exec()->findSymbol(obj_syms, name, sType, nameType, isRegex, checkCase, includeUndefined)) {
  64         //fprintf(stderr, "%s[%d]:  no symbols matching %s found\n", FILE__, __LINE__, name.c_str());
  65         return false;
  66     }
  67
  68     for (unsigned i = 0; i < obj_syms.size(); i++) {
  69         if (obj_syms[i]->getModule() == this)
  70             found.push_back(obj_syms[i]);
  71     }
  72
  73     if (found.size() > orig_size)
  74         return true;
  75
  76     return false;
  77 }
  78
  79 bool Module::getAllSymbols(std::vector<Symbol *> &found) {
  80     unsigned orig_size = found.size();
  81     std::vector<Symbol *> obj_syms;
  82
  83     if (!exec()->getAllSymbols(obj_syms)) {
  84         //fprintf(stderr, "%s[%d]:  no symbols matching %s found\n", FILE__, __LINE__, name.c_str());
  85         return false;
  86     }
  87
  88     for (unsigned i = 0; i < obj_syms.size(); i++) {
  89         if (obj_syms[i]->getModule() == this)
  90             found.push_back(obj_syms[i]);
  91     }
  92
  93     if (found.size() > orig_size)
  94         return true;
  95
  96     return false;
  97 }
  98
  99 const std::string &Module::fileName() const
 100 {
 101    return fileName_;
 102 }
 103
 104 const std::string &Module::fullName() const
 105 {
 106    return fullName_;
 107 }
 108
 109  Symtab *Module::exec() const
 110 {
 111    return exec_;
 112 }
 113
 114 supportedLanguages Module::language() const
 115 {
 116    return language_;
 117 }
 118
 119 bool Module::hasLineInformation()
 120 {
 121    LineInformation *li =  NULL;
 122    if (getAnnotation(li, ModuleLineInfoAnno))
 123    {
 124       if (!li)
 125       {
 126          fprintf(stderr, "%s[%d]:  weird inconsistency with getAnnotation here\n",
 127                FILE__, __LINE__);
 128          return false;
 129       }
 130
 131       if (li->getSize())
 132       {
 133          return true;
 134       }
 135    }
 136
 137    return false;
 138 }
 139
 140 bool Module::getAddressRanges(std::vector<pair<Offset, Offset> >&ranges,
 141       std::string lineSource, unsigned int lineNo)
 142 {
 143    unsigned int originalSize = ranges.size();
 144
 145    LineInformation *lineInformation = getLineInformation();
 146    if (lineInformation)
 147       lineInformation->getAddressRanges( lineSource.c_str(), lineNo, ranges );
 148
 149    if ( ranges.size() != originalSize )
 150       return true;
 151
 152    return false;
 153 }
 154
 155 bool Module::getSourceLines(std::vector<Statement *> &lines, Offset addressInRange)
 156 {
 157    unsigned int originalSize = lines.size();
 158
 159    LineInformation *lineInformation = getLineInformation();
 160    if (lineInformation)
 161       lineInformation->getSourceLines( addressInRange, lines );
 162
 163    if ( lines.size() != originalSize )
 164       return true;
 165
 166    return false;
 167 }
 168
 169 bool Module::getSourceLines(std::vector<LineNoTuple> &lines, Offset addressInRange)
 170 {
 171    unsigned int originalSize = lines.size();
 172
 173    LineInformation *lineInformation = getLineInformation();
 174    if (lineInformation)
 175       lineInformation->getSourceLines( addressInRange, lines );
 176
 177    if ( lines.size() != originalSize )
 178       return true;
 179
 180    return false;
 181 }
 182
 183 bool Module::getStatements(std::vector<Statement *> &statements)
 184 {
 185         unsigned initial_size = statements.size();
 186         LineInformation *li = getLineInformation();
 187
 188         if (!li)
 189         {
 190                 //fprintf(stderr, "%s[%d]:  WARNING:  no line info for module %s\n", FILE__, __LINE__, fileName_.c_str());
 191                 //annotationsReport();
 192                 return false;
 193         }
 194
 195 #if 0
 196         statements.resize(initial_size + li->getSize());
 197
 198         int index = initial_size;
 199
 200         for (LineInformation::const_iterator i = li->begin();
 201                         i != li->end();
 202                         ++i)
 203         {
 204                 //statements[index].start_addr = (*i).first.first;
 205                 //statements[index].end_addr = (*i).first.second;
 206                 statements[index] = const_cast<Statement *>(&(*i).second);
 207                 index++;
 208         }
 209 #endif
 210         for (LineInformation::const_iterator i = li->begin();
 211                         i != li->end();
 212                         ++i)
 213         {
 214                 statements.push_back(const_cast<Statement *>(&(i->second)));
 215         }
 216
 217         return (statements.size() > initial_size);
 218 }
 219
 220 vector<Type *> *Module::getAllTypes()
 221 {
 222         exec_->parseTypesNow();
 223
 224         typeCollection *tc = NULL;
 225         if (!getAnnotation(tc, ModuleTypeInfoAnno))
 226         {
 227                 return NULL;
 228         }
 229         if (!tc)
 230         {
 231                 fprintf(stderr, "%s[%d]:  failed to getAnnotation here\n", FILE__, __LINE__);
 232                 return NULL;
 233         }
 234
 235         return tc->getAllTypes();
 236 }
 237
 238 vector<pair<string, Type *> > *Module::getAllGlobalVars()
 239 {
 240         exec_->parseTypesNow();
 241
 242         typeCollection *tc = NULL;
 243         if (!getAnnotation(tc, ModuleTypeInfoAnno))
 244    {
 245       return NULL;
 246    }
 247    if (!tc)
 248    {
 249       fprintf(stderr, "%s[%d]:  failed to addAnnotation here\n", FILE__, __LINE__);
 250       return NULL;
 251    }
 252
 253    return tc->getAllGlobalVariables();
 254 }
 255
 256 typeCollection *Module::getModuleTypes()
 257 {
 258         exec_->parseTypesNow();
 259         return getModuleTypesPrivate();
 260 }
 261
 262 typeCollection *Module::getModuleTypesPrivate()
 263 {
 264    typeCollection *tc = NULL;
 265    if (!getAnnotation(tc, ModuleTypeInfoAnno))
 266    {
 267       return NULL;
 268    }
 269
 270    return tc;
 271 }
 272
 273 bool Module::findType(Type *&type, std::string name)
 274 {
 275         typeCollection *tc = getModuleTypes();
 276         if (!tc) return false;
 277
 278    type = tc->findType(name);
 279
 280    if (type == NULL)
 281       return false;
 282
 283    return true;
 284 }
 285
 286 bool Module::findVariableType(Type *&type, std::string name)
 287 {
 288         typeCollection *tc = getModuleTypes();
 289         if (!tc) return false;
 290
 291         type = tc->findVariableType(name);
 292
 293    if (type == NULL)
 294       return false;
 295
 296    return true;
 297 }
 298
 299
 300 bool Module::setLineInfo(LineInformation *lineInfo)
 301 {
 302    LineInformation *li =  NULL;
 303
 304    if (!getAnnotation(li, ModuleLineInfoAnno))
 305    {
 306       if (li)
 307       {
 308          return false;
 309       }
 310
 311       if (!addAnnotation(lineInfo, ModuleLineInfoAnno))
 312       {
 313          return false;
 314       }
 315
 316       return true;
 317    }
 318
 319    if (li != lineInfo)
 320    {
 321            fprintf(stderr, "%s[%d]:  REMOVED DELETE\n", FILE__, __LINE__);
 322      //delete li;
 323    }
 324
 325    if (!addAnnotation(lineInfo, ModuleLineInfoAnno))
 326    {
 327      fprintf(stderr, "%s[%d]:  failed to add lineInfo annotation\n", FILE__, __LINE__);
 328      return false;
 329    }
 330
 331    return false;
 332 }
 333
 334 LineInformation *Module::getLineInformation()
 335 {
 336         if (!exec_->isLineInfoValid_)
 337         {
 338                 //fprintf(stderr, "%s[%d]:  TRIGGERING FL INFO PARSE\n", FILE__, __LINE__);
 339                 exec_->parseLineInformation();
 340         }
 341
 342         if (!exec_->isLineInfoValid_)
 343         {
 344                 fprintf(stderr, "%s[%d]:  FIXME\n", FILE__, __LINE__);
 345                 return NULL;
 346         }
 347
 348         LineInformation *li =  NULL;
 349         if (getAnnotation(li, ModuleLineInfoAnno))
 350         {
 351                 if (!li)
 352                 {
 353                         fprintf(stderr, "%s[%d]:  weird inconsistency with getAnnotation here\n",
 354                                         FILE__, __LINE__);
 355                         return NULL;
 356                 }
 357
 358                 if (!li->getSize())
 359                 {
 360                         fprintf(stderr, "%s[%d]:  EMPTY LINE INFO ANNO\n", FILE__, __LINE__);
 361                         return NULL;
 362                 }
 363         }
 364
 365         return li;
 366 }
 367
 368 bool Module::findLocalVariable(std::vector<localVar *>&vars, std::string name)
 369 {
 370         std::vector<Function *>mod_funcs;
 371
 372         if (!exec_->getAllFunctions(mod_funcs))
 373         {
 374                 return false;
 375         }
 376
 377         unsigned origSize = vars.size();
 378
 379         for (unsigned int i = 0; i < mod_funcs.size(); i++)
 380         {
 381                 mod_funcs[i]->findLocalVariable(vars, name);
 382         }
 383
 384         if (vars.size() > origSize)
 385                 return true;
 386
 387         return false;
 388 }
 389
 390 Module::Module(supportedLanguages lang, Offset adr,
 391       std::string fullNm, Symtab *img) :
 392    fullName_(fullNm),
 393    language_(lang),
 394    addr_(adr),
 395    exec_(img)
 396 {
 397    fileName_ = extract_pathname_tail(fullNm);
 398 }
 399
 400 Module::Module() :
 401    fileName_(""),
 402    fullName_(""),
 403    language_(lang_Unknown),
 404    addr_(0),
 405    exec_(NULL)
 406 {
 407 }
 408
 409 Module::Module(const Module &mod) :
 410    LookupInterface(),
 411    Serializable(),
 412    MODULE_ANNOTATABLE_CLASS(),
 413    fileName_(mod.fileName_),
 414    fullName_(mod.fullName_),
 415    language_(mod.language_),
 416    addr_(mod.addr_),
 417    exec_(mod.exec_)
 418 {
 419    //  Copy annotations here or no?
 420 }
 421
 422 Module::~Module()
 423 {
 424    LineInformation *li =  NULL;
 425    if (getAnnotation(li, ModuleLineInfoAnno))
 426    {
 427       if (li)
 428       {
 429                   if (!removeAnnotation(ModuleLineInfoAnno))
 430                   {
 431                           fprintf(stderr, "%s[%d]:  FIXME:  failed to remove LineInfo\n",
 432                                           FILE__, __LINE__);
 433                   }
 434                   else
 435                   {
 436                           fprintf(stderr, "%s[%d]:  removed delete for %p\n", FILE__, __LINE__, li);
 437                           delete li;
 438                   }
 439       }
 440    }
 441         typeCollection *tc = NULL;
 442         if (getAnnotation(tc, ModuleTypeInfoAnno))
 443         {
 444                 if (tc)
 445                 {
 446                         if (!removeAnnotation(ModuleTypeInfoAnno))
 447                         {
 448                                 fprintf(stderr, "%s[%d]:  FIXME:  failed to remove LineInfo\n",
 449                                                 FILE__, __LINE__);
 450                         }
 451                         else
 452                                 delete tc;
 453                 }
 454         }
 455 }
 456
 457 bool Module::isShared() const
 458 {
 459    return exec_->getObjectType() == obj_SharedLib;
 460 }
 461
 462 bool Module::getAllSymbolsByType(std::vector<Symbol *> &found, Symbol::SymbolType sType)
 463 {
 464    unsigned orig_size = found.size();
 465    std::vector<Symbol *> obj_syms;
 466
 467    if (!exec()->getAllSymbolsByType(obj_syms, sType))
 468       return false;
 469
 470    for (unsigned i = 0; i < obj_syms.size(); i++)
 471    {
 472       if (obj_syms[i]->getModule() == this)
 473          found.push_back(obj_syms[i]);
 474    }
 475
 476    if (found.size() > orig_size)
 477    {
 478       return true;
 479    }
 480
 481    serr = No_Such_Symbol;
 482    return false;
 483 }
 484
 485 bool Module::getAllFunctions(std::vector<Function *> &ret)
 486 {
 487     return exec()->getAllFunctions(ret);
 488 }
 489
 490 bool Module::operator==(Module &mod)
 491 {
 492    LineInformation *li =  NULL;
 493    LineInformation *li_src =  NULL;
 494    bool get_anno_res = false, get_anno_res_src = false;
 495    get_anno_res = getAnnotation(li, ModuleLineInfoAnno);
 496    get_anno_res_src = mod.getAnnotation(li_src, ModuleLineInfoAnno);
 497
 498    if (get_anno_res != get_anno_res_src)
 499    {
 500       fprintf(stderr, "%s[%d]:  weird inconsistency with getAnnotation here\n",
 501             FILE__, __LINE__);
 502       return false;
 503    }
 504
 505    if (li)
 506    {
 507       if (!li_src)
 508       {
 509          fprintf(stderr, "%s[%d]:  weird inconsistency with getAnnotation here\n",
 510                FILE__, __LINE__);
 511          return false;
 512       }
 513
 514       if (li->getSize() != li_src->getSize())
 515          return false;
 516
 517       if ((li != li_src))
 518          return false;
 519    }
 520    else
 521    {
 522       if (li_src)
 523       {
 524          fprintf(stderr, "%s[%d]:  weird inconsistency with getAnnotation here\n",
 525                FILE__, __LINE__);
 526          return false;
 527       }
 528    }
 529
 530    if (exec_ && !mod.exec_) return false;
 531    if (!exec_ && mod.exec_) return false;
 532    if (exec_)
 533    {
 534            if (exec_->file() != mod.exec_->file()) return false;
 535            if (exec_->name() != mod.exec_->name()) return false;
 536    }
 537
 538    return (
 539          (language_==mod.language_)
 540          && (addr_==mod.addr_)
 541          && (fullName_==mod.fullName_)
 542          && (fileName_==mod.fileName_)
 543          );
 544 }
 545
 546 bool Module::setName(std::string newName)
 547 {
 548    fullName_ = newName;
 549    fileName_ = extract_pathname_tail(fullName_);
 550    return true;
 551 }
 552
 553 void Module::setLanguage(supportedLanguages lang)
 554 {
 555    language_ = lang;
 556 }
 557
 558 Offset Module::addr() const
 559 {
 560    return addr_;
 561 }
 562
 563 bool Module::setDefaultNamespacePrefix(string str)
 564 {
 565     return exec_->setDefaultNamespacePrefix(str);
 566 }
 567
 568 bool Module::findVariablesByName(std::vector<Variable *> &ret, const std::string& name,
 569                                  NameType nameType,
 570                                  bool isRegex,
 571                                  bool checkCase) {
 572   bool succ = false;
 573   std::vector<Variable *> tmp;
 574
 575   if (!exec()->findVariablesByName(tmp, name, nameType, isRegex, checkCase)) {
 576     return false;
 577   }
 578   for (unsigned i = 0; i < tmp.size(); i++) {
 579     if (tmp[i]->getModule() == this) {
 580       ret.push_back(tmp[i]);
 581       succ = true;
 582     }
 583   }
 584   return succ;
 585 }
 586
 587 #if !defined(SERIALIZATION_DISABLED)
 588 Serializable * Module::serialize_impl(SerializerBase *sb, const char *tag) THROW_SPEC (SerializerError)
 589 {
 590    ifxml_start_element(sb, tag);
 591    gtranslate(sb, fileName_, "fileName");
 592    gtranslate(sb, fullName_, "fullName");
 593    gtranslate(sb, addr_, "Address");
 594    gtranslate(sb, language_, supportedLanguages2Str, "Language");
 595    ifxml_end_element(sb, tag);
 596
 597    if (sb->isInput())
 598    {
 599            SerContextBase *scb = sb->getContext();
 600            if (!scb)
 601            {
 602                    fprintf(stderr, "%s[%d]:  SERIOUS:  FIXME\n", FILE__, __LINE__);
 603                    SER_ERR("FIXME");
 604            }
 605
 606            SerContext<Symtab> *scs = dynamic_cast<SerContext<Symtab> *>(scb);
 607
 608            if (!scs)
 609            {
 610                    fprintf(stderr, "%s[%d]:  SERIOUS:  FIXME\n", FILE__, __LINE__);
 611                    SER_ERR("FIXME");
 612            }
 613
 614            Symtab *st = scs->getScope();
 615
 616            if (!st)
 617            {
 618                    fprintf(stderr, "%s[%d]:  FIXME\n", FILE__, __LINE__);
 619                    SER_ERR("getScope");
 620            }
 621
 622            exec_ = st;
 623    }
 624    return NULL;
 625 }
 626
 627 Serializable *Statement::serialize_impl(SerializerBase *sb, const char *tag) THROW_SPEC(SerializerError)
 628 {
 629         ifxml_start_element(sb, tag);
 630         gtranslate(sb, file_, "file");
 631         gtranslate(sb, line_, "line");
 632         gtranslate(sb, column, "column");
 633         gtranslate(sb, start_addr_, "startAddress");
 634         gtranslate(sb, end_addr_, "endAddress");
 635         ifxml_end_element(sb, tag);
 636         return NULL;
 637 }
 638
 639 #else
 640
 641 Serializable *Module::serialize_impl(SerializerBase *, const char *) THROW_SPEC (SerializerError)
 642 {
 643    return NULL;
 644 }
 645
 646 Serializable *Statement::serialize_impl(SerializerBase *, const char *) THROW_SPEC(SerializerError)
 647 {
 648    return NULL;
 649 }
 650
 651 #endif