Compile fix after removing deprecated SymtabAPI methods.
[dyninst.git] / 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