From 1338cf01a8041c172120d5e5d9bfb26975ab7c0b Mon Sep 17 00:00:00 2001
From: Andrew Bernat <bernat@cs.wisc.edu>
Date: Mon, 15 Oct 2012 13:33:15 -0500
Subject: [PATCH] Compile fix after removing deprecated SymtabAPI methods.

---
 dyninstAPI/src/binaryEdit.C       | 10 +++----
 dyninstAPI/src/image.C            | 36 +++++++++++-----------
 dyninstAPI/src/mapped_object.C    | 16 +++++-----
 dyninstAPI/src/parse-cfg.C        |  2 +-
 dyninstAPI/src/parse-cfg.h        |  2 +-
 dyninstAPI/src/parse-x86.C        |  4 +--
 dyninstAPI/src/unix.C             | 16 +++++-----
 parseAPI/src/SymtabCodeSource.C   | 18 +++++------
 symtabAPI/h/Module.h              | 13 ++++----
 symtabAPI/h/Symbol.h              | 13 ++++----
 symtabAPI/src/AddrLookup.C        |  4 +--
 symtabAPI/src/Module.C            | 31 ++++++-------------
 symtabAPI/src/Object-elf.C        | 42 +++++++++++++-------------
 symtabAPI/src/Object.C            | 12 ++++----
 symtabAPI/src/Region.C            |  5 ----
 symtabAPI/src/Symbol.C            |  8 -----
 symtabAPI/src/Symtab-deprecated.C | 26 ----------------
 symtabAPI/src/Symtab-edit.C       |  4 +--
 symtabAPI/src/Symtab-lookup.C     | 35 ++++------------------
 symtabAPI/src/Symtab.C            | 63 +++++++++++++++++++--------------------
 symtabAPI/src/SymtabReader.C      |  2 +-
 symtabAPI/src/emitElf-64.C        | 32 ++++++++++----------
 symtabAPI/src/emitElf.C           | 33 ++++++++++----------
 symtabAPI/src/emitElfStatic-x86.C |  4 +--
 symtabAPI/src/emitElfStatic.C     | 14 ++++-----
 symtabAPI/src/parseStab.C         |  6 ++--
 26 files changed, 189 insertions(+), 262 deletions(-)

diff --git a/dyninstAPI/src/binaryEdit.C b/dyninstAPI/src/binaryEdit.C
index 9ad0490..de0bf73 100644
--- a/dyninstAPI/src/binaryEdit.C
+++ b/dyninstAPI/src/binaryEdit.C
@@ -524,7 +524,7 @@ bool BinaryEdit::writeFile(const std::string &newFileName)
       // Now, we need to copy in the memory of the new segments
       for (unsigned i = 0; i < oldSegs.size(); i++) {
          codeRange *segRange = NULL;
-         if (!memoryTracker_->find(oldSegs[i]->getRegionAddr(), segRange)) {
+         if (!memoryTracker_->find(oldSegs[i]->getMemOffset(), segRange)) {
 #if 0
             // Looks like BSS
             if (newSegs[i].name == ".bss")
@@ -538,7 +538,7 @@ bool BinaryEdit::writeFile(const std::string &newFileName)
 	 memoryTracker* mt = dynamic_cast<memoryTracker*>(segRange);
 	 assert(mt);
 	 if(mt->dirty) {
-            oldSegs[i]->setPtrToRawData(segRange->get_local_ptr(), oldSegs[i]->getDiskSize());
+            oldSegs[i]->setPtrToRawData(segRange->get_local_ptr(), oldSegs[i]->getMemSize());
 	 }
 	 
          //newSegs[i].data = segRange->get_local_ptr();
@@ -745,13 +745,13 @@ bool BinaryEdit::createMemoryBackingStore(mapped_object *obj) {
 
    for (unsigned i = 0; i < regs.size(); i++) {
       memoryTracker *newTracker = NULL;
-      if (regs[i]->getRegionType() == Region::RT_BSS || (regs[i]->getDiskSize() == 0))
+      if (regs[i]->getRegionType() == Region::RT_BSS || (regs[i]->getMemSize() == 0))
       {
          continue;
       }
       else {
-         newTracker = new memoryTracker(regs[i]->getRegionAddr(),
-                                        regs[i]->getDiskSize(),
+         newTracker = new memoryTracker(regs[i]->getMemOffset(),
+                                        regs[i]->getMemSize(),
                                         regs[i]->getPtrToRawData());
          
       }
diff --git a/dyninstAPI/src/image.C b/dyninstAPI/src/image.C
index 4940bfa..6b9777d 100644
--- a/dyninstAPI/src/image.C
+++ b/dyninstAPI/src/image.C
@@ -343,7 +343,7 @@ namespace {
                 struct libc_startup_info * si =
                     (struct libc_startup_info *)(
                         ((Address)dreg->getPtrToRawData()) + 
-                        ss_addr - (Address)dreg->getRegionAddr());
+                        ss_addr - (Address)dreg->getMemOffset())
                 return (Address)si->main_addr;
             }
         }
@@ -396,9 +396,9 @@ void image::findMain()
 	        SymtabCodeSource scs(linkedFile, filt, parseInAllLoadableRegions);
             CodeObject tco(&scs,NULL,NULL,false);
 
-            tco.parse(eReg->getRegionAddr(),false);
+            tco.parse(eReg->getMemOffset(),false);
             set<CodeRegion *> regions;
-            scs.findRegions(eReg->getRegionAddr(),regions);
+            scs.findRegions(eReg->getMemOffset(),regions);
             if(regions.empty()) {
                 // express puzzlement
                 return;
@@ -406,7 +406,7 @@ void image::findMain()
             SymtabCodeRegion * reg = 
                 static_cast<SymtabCodeRegion*>(*regions.begin());
             Function * func = 
-                tco.findFuncByEntry(reg,eReg->getRegionAddr());
+                tco.findFuncByEntry(reg,eReg->getMemOffset());
             if(!func) {
                 // again, puzzlement
                 return;
@@ -557,7 +557,7 @@ void image::findMain()
             if( numCalls != 4 ) {
                 logLine("heuristic for finding global constructor function failed\n");
             }else{
-                Address callAddress = eReg->getRegionAddr() + bytesSeen;
+                Address callAddress = eReg->getMemOffset() + bytesSeen;
                 RegisterAST thePC = RegisterAST(Dyninst::MachRegister::getPC(scs.getArch()));
 
                 Expression::Ptr callTarget = curInsn->getControlFlowTarget();
@@ -623,7 +623,7 @@ void image::findMain()
                                            Symbol::ST_FUNCTION,
                                            Symbol::SL_GLOBAL,
                                            Symbol::SV_DEFAULT, 
-                                           eReg->getRegionAddr(),
+                                           eReg->getMemOffset(),
                                            linkedFile->getDefaultModule(),
                                            eReg,
                                            0 );
@@ -639,7 +639,7 @@ void image::findMain()
 					  Symbol::ST_FUNCTION,
 					  Symbol::SL_GLOBAL, 
 					  Symbol::SV_DEFAULT, 
-					  finisec->getRegionAddr(),
+					  finisec->getMemOffset(),
 					  linkedFile->getDefaultModule(),
 					  finisec, 
 					  0 );
@@ -661,7 +661,7 @@ void image::findMain()
 					Symbol::ST_OBJECT, 
                                          Symbol::SL_GLOBAL, 
                                          Symbol::SV_DEFAULT,
-                                         dynamicsec->getRegionAddr(), 
+                                         dynamicsec->getMemOffset(), 
                                          linkedFile->getDefaultModule(),
                                          dynamicsec, 
                                          0 );
@@ -712,7 +712,7 @@ void image::findMain()
            c--;
        }
        
-       Offset currAddr = sec->getRegionAddr() + c * instruction::size();
+       Offset currAddr = sec->getMemOffset() + c * instruction::size();
        Offset mainAddr = 0;
        
        if( ( IFORM_OP(i) == Bop ) || ( BFORM_OP(i) == BCop ) )
@@ -753,7 +753,7 @@ void image::findMain()
                                   Symbol::ST_FUNCTION,
                                   Symbol::SL_GLOBAL, 
                                   Symbol::SV_DEFAULT, 
-                                  sec->getRegionAddr(), 
+                                  sec->getMemOffset(), 
                                   linkedFile->getDefaultModule(),
                                   sec);
        linkedFile->addSymbol(sym1);
@@ -891,7 +891,7 @@ bool image::addSymtabVariables()
 
        parsing_printf("New variable, mangled %s, module %s...\n",
                       symVar->getAllMangledNames()[0].c_str(),
-                      symVar->getFirstSymbol()->getModuleName().c_str());
+                      symVar->getFirstSymbol()->getModule()->fileName().c_str());
        pdmodule *use = getOrCreateModule(symVar->getModule());
 
        assert(use);
@@ -1018,7 +1018,7 @@ void image::findModByAddr (const Symbol *lookUp, vector<Symbol *> &mods,
     return;
   }
 
-  Address symAddr = lookUp->getAddr();
+  Address symAddr = lookUp->getOffset();
   int index;
   int start = 0;
   int end = mods.size() - 1;
@@ -1027,12 +1027,12 @@ void image::findModByAddr (const Symbol *lookUp, vector<Symbol *> &mods,
   while ((start <= end) && !found) {
     index = (start+end)/2;
     if ((index == last) ||
-	((mods[index]->getAddr() <= symAddr) && 
-	 (mods[index+1]->getAddr() > symAddr))) {
-      modName = mods[index]->getName().c_str();
-      modAddr = mods[index]->getAddr();      
+	((mods[index]->getOffset() <= symAddr) && 
+	 (mods[index+1]->getOffset() > symAddr))) {
+      modName = mods[index]->getMangledName().c_str();
+      modAddr = mods[index]->getOffset();      
       found = true;
-    } else if (symAddr < mods[index]->getAddr()) {
+    } else if (symAddr < mods[index]->getOffset()) {
       end = index - 1;
     } else {
       start = index + 1;
@@ -2007,7 +2007,7 @@ void *image::getPtrToDataInText( Address offset ) const {
     Region *reg = linkedFile->findEnclosingRegion(offset);
     if(reg != NULL) {
         return (void*) ((Address)reg->getPtrToRawData() + offset 
-                        - reg->getRegionAddr());
+                        - reg->getMemOffset());
     }
     return NULL;
 } *//* end getPtrToDataInText() */
diff --git a/dyninstAPI/src/mapped_object.C b/dyninstAPI/src/mapped_object.C
index 2552fac..5709f7b 100644
--- a/dyninstAPI/src/mapped_object.C
+++ b/dyninstAPI/src/mapped_object.C
@@ -1436,7 +1436,7 @@ void mapped_object::expandCodeBytes(SymtabAPI::Region *reg)
 {
     assert(reg);
     void *mappedPtr = reg->getPtrToRawData();
-    Address regStart = reg->getRegionAddr();
+    Address regStart = reg->getMemOffset();
     ParseAPI::Block *cur = NULL;
     ParseAPI::CodeObject *cObj = parse_img()->codeObject();
     ParseAPI::CodeRegion *parseReg = NULL;
@@ -1547,7 +1547,7 @@ void mapped_object::updateCodeBytes(const list<pair<Address,Address> > &owRanges
         Address lastChangeOffset = (*rIter).second -1 -baseAddress;
         Region *curReg = parse_img()->getObject()->findEnclosingRegion
                                                     ( lastChangeOffset );
-        if ( lastChangeOffset - curReg->getRegionAddr() >= curReg->getDiskSize() ) {
+        if ( lastChangeOffset - curReg->getMemOffset() >= curReg->getDiskSize() ) {
             expandRegs.insert(curReg);
         }
     }
@@ -1619,7 +1619,7 @@ void mapped_object::updateCodeBytes(SymtabAPI::Region * symReg)
     set<ParseAPI::CodeRegion*> parseRegs;
 
     void *mappedPtr = symReg->getPtrToRawData();
-    Address regStart = symReg->getRegionAddr();
+    Address regStart = symReg->getMemOffset();
 
     cObj->cs()->findRegions(regStart, parseRegs);
     ParseAPI::CodeRegion *parseReg = * parseRegs.begin();
@@ -1745,7 +1745,7 @@ bool mapped_object::isUpdateNeeded(Address entry)
         comparison_size = nextBlk->start() - (entry-base);
     } else {
         comparison_size = creg->symRegion()->getDiskSize()
-            - ( (entry - base) - creg->symRegion()->getRegionAddr() );
+            - ( (entry - base) - creg->symRegion()->getMemOffset() );
     }
 
     // read until first difference, then see if the difference is to known
@@ -1770,7 +1770,7 @@ bool mapped_object::isUpdateNeeded(Address entry)
     }
     void *mappedPtr = (void*)
                       ((Address)creg->symRegion()->getPtrToRawData() +
-                        (entry - base - creg->symRegion()->getRegionAddr()) );
+                        (entry - base - creg->symRegion()->getMemOffset()) );
     //compare
     if (0 != memcmp(mappedPtr,regBuf,comparison_size) ) {
         updateNeeded = true;
@@ -1805,7 +1805,7 @@ bool mapped_object::isExpansionNeeded(Address entry)
     // if there is uninitialized space in the region,
     // see if the first few bytes have been updated
     Address compareStart =
-        base + reg->getRegionAddr() + reg->getDiskSize();
+        base + reg->getMemOffset() + reg->getDiskSize();
     if (proc()->isMemoryEmulated()) {
         bool valid = false;
         boost::tie(valid, compareStart) = proc()->getMemEm()->translate(compareStart);
@@ -1878,8 +1878,8 @@ bool mapped_object::updateCodeBytesIfNeeded(Address entry)
         (entry - codeBase());
     mal_printf("%s[%d] updating region [%lx %lx] for entry point %lx\n",
                FILE__,__LINE__,
-               reg->getRegionAddr(),
-               reg->getRegionAddr()+reg->getDiskSize(),
+               reg->getMemOffset(),
+               reg->getMemOffset()+reg->getDiskSize(),
                entry);
 
     if ( expand ) {
diff --git a/dyninstAPI/src/parse-cfg.C b/dyninstAPI/src/parse-cfg.C
index 016cf38..4c51d66 100644
--- a/dyninstAPI/src/parse-cfg.C
+++ b/dyninstAPI/src/parse-cfg.C
@@ -87,7 +87,7 @@ parse_func::parse_func(
     CodeRegion * reg,
     InstructionSource * isrc,
     FuncSource src):
-  Function(func->getOffset(),func->getFirstSymbol()->getName(),obj,reg,isrc),
+  Function(func->getOffset(),func->getFirstSymbol()->getMangledName(),obj,reg,isrc),
   func_(func),
   mod_(m),
   image_(i),
diff --git a/dyninstAPI/src/parse-cfg.h b/dyninstAPI/src/parse-cfg.h
index bb5c44b..fe0a02b 100644
--- a/dyninstAPI/src/parse-cfg.h
+++ b/dyninstAPI/src/parse-cfg.h
@@ -238,7 +238,7 @@ class parse_func : public ParseAPI::Function
 
    /*** Function naming ***/
    const string &symTabName() const { 
-       return func_->getFirstSymbol()->getName();
+       return func_->getFirstSymbol()->getMangledName();
    }
    const string &prettyName() const {
        return func_->getFirstSymbol()->getPrettyName();
diff --git a/dyninstAPI/src/parse-x86.C b/dyninstAPI/src/parse-x86.C
index 63c2cce..cbb815f 100644
--- a/dyninstAPI/src/parse-x86.C
+++ b/dyninstAPI/src/parse-x86.C
@@ -465,7 +465,7 @@ func_instance *mapped_object::findGlobalConstructorFunc(const std::string &ctorH
         return NULL;
     }
 
-    Address callAddress = initRegion->getRegionAddr() + bytesSeen;
+    Address callAddress = initRegion->getMemOffset() + bytesSeen;
 
     RegisterAST thePC = RegisterAST(
         Dyninst::MachRegister::getPC(parse_img()->codeObject()->cs()->getArch()));
@@ -570,7 +570,7 @@ func_instance *mapped_object::findGlobalDestructorFunc(const std::string &dtorHa
         return NULL;
     }
 
-    Address callAddress = finiRegion->getRegionAddr() + bytesSeen;
+    Address callAddress = finiRegion->getMemOffset() + bytesSeen;
 
     RegisterAST thePC = RegisterAST(
         Dyninst::MachRegister::getPC(parse_img()->codeObject()->cs()->getArch()));
diff --git a/dyninstAPI/src/unix.C b/dyninstAPI/src/unix.C
index f2d1465..4b83c8a 100644
--- a/dyninstAPI/src/unix.C
+++ b/dyninstAPI/src/unix.C
@@ -821,16 +821,16 @@ void BinaryEdit::makeInitAndFiniIfNeeded()
             lowWaterMark_ += emptyFuncSize;
             linkedFile->findRegion(initsec, ".init.dyninst");
             assert(initsec);
-            linkedFile->addSysVDynamic(DT_INIT, initsec->getRegionAddr());
+            linkedFile->addSysVDynamic(DT_INIT, initsec->getMemOffset());
             startup_printf("%s[%d]: creating .init.dyninst region, region addr 0x%lx\n",
-                           FILE__, __LINE__, initsec->getRegionAddr());
+                           FILE__, __LINE__, initsec->getMemOffset());
         }
-        startup_printf("%s[%d]: ADDING _init at 0x%lx\n", FILE__, __LINE__, initsec->getRegionAddr());
+        startup_printf("%s[%d]: ADDING _init at 0x%lx\n", FILE__, __LINE__, initsec->getMemOffset());
         Symbol *initSym = new Symbol( "_init",
                                       Symbol::ST_FUNCTION,
                                       Symbol::SL_GLOBAL,
                                       Symbol::SV_DEFAULT,
-                                      initsec->getRegionAddr(),
+                                      initsec->getMemOffset(),
                                       linkedFile->getDefaultModule(),
                                       initsec,
                                       UINT_MAX );
@@ -869,17 +869,17 @@ void BinaryEdit::makeInitAndFiniIfNeeded()
             lowWaterMark_ += emptyFuncSize;
             linkedFile->findRegion(finisec, ".fini.dyninst");
             assert(finisec);
-            linkedFile->addSysVDynamic(DT_FINI, finisec->getRegionAddr());
+            linkedFile->addSysVDynamic(DT_FINI, finisec->getMemOffset());
             startup_printf("%s[%d]: creating .fini.dyninst region, region addr 0x%lx\n",
-                           FILE__, __LINE__, finisec->getRegionAddr());
+                           FILE__, __LINE__, finisec->getMemOffset());
 
         }
-        startup_printf("%s[%d]: ADDING _fini at 0x%lx\n", FILE__, __LINE__, finisec->getRegionAddr());
+        startup_printf("%s[%d]: ADDING _fini at 0x%lx\n", FILE__, __LINE__, finisec->getMemOffset());
         Symbol *finiSym = new Symbol( "_fini",
                                       Symbol::ST_FUNCTION,
                                       Symbol::SL_GLOBAL,
                                       Symbol::SV_DEFAULT,
-                                      finisec->getRegionAddr(),
+                                      finisec->getMemOffset(),
                                       linkedFile->getDefaultModule(),
                                       finisec,
                                       UINT_MAX );
diff --git a/parseAPI/src/SymtabCodeSource.C b/parseAPI/src/SymtabCodeSource.C
index f9afa0a..02fdd51 100644
--- a/parseAPI/src/SymtabCodeSource.C
+++ b/parseAPI/src/SymtabCodeSource.C
@@ -111,7 +111,7 @@ SymtabCodeRegion::getPtrToInstruction(const Address addr) const
 
     if(isCode(addr))
         return (void*)((Address)_region->getPtrToRawData() + 
-                       addr - _region->getRegionAddr());
+                       addr - _region->getMemOffset());
     else if(isData(addr))
         return getPtrToData(addr);
     else
@@ -125,7 +125,7 @@ SymtabCodeRegion::getPtrToData(const Address addr) const
 
     if(isData(addr))
         return (void*)((Address)_region->getPtrToRawData() +
-                        addr - _region->getRegionAddr());
+                        addr - _region->getMemOffset());
     else
         return NULL;
 }
@@ -181,7 +181,7 @@ SymtabCodeRegion::isData(const Address addr) const
 Address
 SymtabCodeRegion::offset() const
 {
-    return _region->getRegionAddr();
+    return _region->getMemOffset();
 }
 
 Address
@@ -371,7 +371,7 @@ SymtabCodeSource::init_regions(hint_filt * filt , bool allLoadedRegions)
     parsing_printf("[%s:%d] processing %d symtab regions in %s\n",
         FILE__,__LINE__,regs.size(),_symtab->name().c_str());
     for(rit = regs.begin(); rit != regs.end(); ++rit) {
-        parsing_printf("   %lx %s",(*rit)->getRegionAddr(),
+        parsing_printf("   %lx %s",(*rit)->getMemOffset(),
             (*rit)->getRegionName().c_str());
     
         // XXX only TEXT, DATA, TEXTDATA?
@@ -395,7 +395,7 @@ SymtabCodeSource::init_regions(hint_filt * filt , bool allLoadedRegions)
 
         if(HASHDEF(rmap,*rit)) {
             parsing_printf("[%s:%d] duplicate region at address %lx\n",
-                FILE__,__LINE__,(*rit)->getRegionAddr());
+                FILE__,__LINE__,(*rit)->getMemOffset());
         }
         CodeRegion * cr = new SymtabCodeRegion(_symtab,*rit);
         rmap[*rit] = cr;
@@ -452,7 +452,7 @@ SymtabCodeSource::init_hints(dyn_hash_map<void*, CodeRegion*> & rmap,
         }
         if(!HASHDEF(rmap,sr)) {
             parsing_printf("[%s:%d] unrecognized Region %lx in function %lx\n",
-                FILE__,__LINE__,sr->getRegionAddr(),(*fsit)->getOffset());
+                FILE__,__LINE__,sr->getMemOffset(),(*fsit)->getOffset());
             continue;
         }
         CodeRegion * cr = rmap[sr];
@@ -460,8 +460,8 @@ SymtabCodeSource::init_hints(dyn_hash_map<void*, CodeRegion*> & rmap,
         {
             parsing_printf("\t<%lx> skipped non-code, region [%lx,%lx)\n",
                 (*fsit)->getOffset(),
-                sr->getRegionAddr(),
-                sr->getRegionAddr()+sr->getDiskSize());
+                sr->getMemOffset(),
+                sr->getMemOffset()+sr->getDiskSize());
         } else {
             _hints.push_back( Hint((*fsit)->getOffset(),
                                cr,
@@ -746,7 +746,7 @@ SymtabCodeSource::resizeRegion(SymtabAPI::Region *sr, Address newDiskSize)
 {
     // find region
     std::set<CodeRegion*> regions;
-    findRegions(sr->getRegionAddr(), regions);
+    findRegions(sr->getMemOffset(), regions);
     bool found_it = false;
     set<CodeRegion*>::iterator rit = regions.begin();
     for (; rit != regions.end(); rit++) {
diff --git a/symtabAPI/h/Module.h b/symtabAPI/h/Module.h
index b9676ad..2939872 100644
--- a/symtabAPI/h/Module.h
+++ b/symtabAPI/h/Module.h
@@ -132,12 +132,13 @@ class Module : public LookupInterface,
 	SYMTAB_EXPORT ~Module();
 
 	// Symbol output methods
-	SYMTAB_EXPORT virtual bool findSymbolByType(std::vector<Symbol *> &ret, 
-			const std::string& name,
-			Symbol::SymbolType sType, 
-			NameType nameType = anyName,
-			bool isRegex = false, 
-			bool checkCase = false);
+	SYMTAB_EXPORT virtual bool findSymbol(std::vector<Symbol *> &ret, 
+                                              const std::string& name,
+                                              Symbol::SymbolType sType = Symbol::ST_UNKNOWN, 
+                                              NameType nameType = anyName,
+                                              bool isRegex = false, 
+                                              bool checkCase = false,
+                                              bool includeUndefined = false);
 	SYMTAB_EXPORT virtual bool getAllSymbolsByType(std::vector<Symbol *> &ret, 
 			Symbol::SymbolType sType);
 	SYMTAB_EXPORT virtual bool getAllSymbols(std::vector<Symbol *> &ret);
diff --git a/symtabAPI/h/Symbol.h b/symtabAPI/h/Symbol.h
index c854839..f4c31ef 100644
--- a/symtabAPI/h/Symbol.h
+++ b/symtabAPI/h/Symbol.h
@@ -266,12 +266,13 @@ class LookupInterface
       SYMTAB_EXPORT LookupInterface();
       SYMTAB_EXPORT virtual bool getAllSymbolsByType(std::vector<Symbol *> &ret,
             Symbol::SymbolType sType) = 0;
-      SYMTAB_EXPORT virtual bool findSymbolByType(std::vector<Symbol *> &ret,
-            const std::string& name,
-            Symbol::SymbolType sType,
-            bool isMangled = false,
-            bool isRegex = false,
-            bool checkCase = false) = 0;
+      SYMTAB_EXPORT virtual bool findSymbol(std::vector<Symbol *> &ret,
+                                            const std::string& name,
+                                            Symbol::SymbolType sType = Symbol::ST_UNKNOWN,
+                                            NameType nameType = anyName,
+                                            bool isRegex = false,
+                                            bool checkCase = false,
+                                            bool includeUndefined = false) = 0;
       SYMTAB_EXPORT virtual bool findType(Type *&type, std::string name) = 0;
       SYMTAB_EXPORT virtual bool findVariableType(Type *&type, std::string name)= 0;
 
diff --git a/symtabAPI/src/AddrLookup.C b/symtabAPI/src/AddrLookup.C
index 834a208..0828d0a 100644
--- a/symtabAPI/src/AddrLookup.C
+++ b/symtabAPI/src/AddrLookup.C
@@ -98,7 +98,7 @@ bool AddressLookup::getAddress(Symtab *tab, Symbol *sym, Address &addr)
 
 bool sort_by_addr(const Symbol* a, const Symbol* b)
 {
-   return a->getAddr() < b->getAddr();
+   return a->getOffset() < b->getOffset();
 }
 
 vector<Symbol *> *AddressLookup::getSymsVector(LoadedLib *lib)
@@ -185,7 +185,7 @@ bool AddressLookup::getSymbol(Address addr, Symbol* &sym, Symtab* &tab, bool clo
          break;
       last_mid = mid;
       
-      Offset cur_off = (*symbols)[mid]->getAddr();
+      Offset cur_off = (*symbols)[mid]->getOffset();
       
       if (addr == cur_off) {
          sym = (*symbols)[mid];
diff --git a/symtabAPI/src/Module.C b/symtabAPI/src/Module.C
index bc55a08..0a65efc 100644
--- a/symtabAPI/src/Module.C
+++ b/symtabAPI/src/Module.C
@@ -49,31 +49,18 @@ using namespace std;
 
 static SymtabError serr;
 
-bool Module::findSymbolByType(std::vector<Symbol *> &found, 
-      const std::string& name,
-      Symbol::SymbolType sType, 
-      bool isMangled,
-      bool isRegex, 
-      bool checkCase)
-{
-    return findSymbolByType(found,
-                            name,
-                            sType,
-                            isMangled ? mangledName : prettyName,
-                            isRegex,
-                            checkCase);
-}
-
-bool Module::findSymbolByType(std::vector<Symbol *> &found, 
-                              const std::string& name,
-                              Symbol::SymbolType sType, 
-                              NameType nameType,
-                              bool isRegex,
-                              bool checkCase) {
+
+bool Module::findSymbol(std::vector<Symbol *> &found, 
+                        const std::string& name,
+                        Symbol::SymbolType sType, 
+                        NameType nameType,
+                        bool isRegex,
+                        bool checkCase,
+                        bool includeUndefined) {
     unsigned orig_size = found.size();
     std::vector<Symbol *> obj_syms;
     
-    if (exec()->findSymbolByType(obj_syms, name, sType, nameType == 0, isRegex, checkCase)) {
+    if (exec()->findSymbol(obj_syms, name, sType, nameType, isRegex, checkCase, includeUndefined)) {
         //fprintf(stderr, "%s[%d]:  no symbols matching %s found\n", FILE__, __LINE__, name.c_str());
         return false;
     }
diff --git a/symtabAPI/src/Object-elf.C b/symtabAPI/src/Object-elf.C
index 4c17458..450fad7 100644
--- a/symtabAPI/src/Object-elf.C
+++ b/symtabAPI/src/Object-elf.C
@@ -221,8 +221,8 @@ Elf_X_Shdr *Object::getRegionHdrByIndex(unsigned index)
 bool Object::isRegionPresent(Offset segmentStart, Offset segmentSize, unsigned segPerms){
   bool present = false;
   for(unsigned i = 0; i < regions_.size() ;i++){
-    if((regions_[i]->getRegionAddr() >= segmentStart) && 
-       ((regions_[i]->getRegionAddr()+regions_[i]->getDiskSize()) <= (segmentStart+segmentSize))){
+    if((regions_[i]->getDiskOffset() >= segmentStart) && 
+       ((regions_[i]->getDiskOffset()+regions_[i]->getDiskSize()) <= (segmentStart+segmentSize))){
       present = true;
       regions_[i]->setRegionPermissions(getSegmentPerms(segPerms));
     }
@@ -951,8 +951,8 @@ bool Object::loaded_elf(Offset& txtaddr, Offset& dataddr,
   sort(allRegionHdrs.begin(), allRegionHdrs.end(), SectionHeaderSortFunction());
 
   for (unsigned j = 0 ; j < regions_.size() ; j++) {
-    if (secAddrTagMapping.find(regions_[j]->getRegionAddr()) != secAddrTagMapping.end()) {
-      secTagRegionMapping[secAddrTagMapping[regions_[j]->getRegionAddr()]] = regions_[j];
+    if (secAddrTagMapping.find(regions_[j]->getDiskOffset()) != secAddrTagMapping.end()) {
+      secTagRegionMapping[secAddrTagMapping[regions_[j]->getDiskOffset()]] = regions_[j];
     }
   }
 
@@ -1900,7 +1900,7 @@ bool lookUpSymbol( std::vector< Symbol *>& allsymbols, Offset& addr )
 {
   for( unsigned i = 0; i < allsymbols.size(); i++ )
     {
-      if( allsymbols[ i ]->getAddr() == addr )
+      if( allsymbols[ i ]->getOffset() == addr )
 	{
 	  return true;
 	}
@@ -1971,7 +1971,7 @@ void Object::handle_opd_relocations(){
       if((*sym_it)->getPtrOffset() == (*rel_it).rel_addr()) {
 	i = 0;
 	while (i < regions_.size()) {
-	  if(regions_[i]->getRegionName().compare((*rel_it).getDynSym()->getName()) == 0){
+	  if(regions_[i]->getRegionName().compare((*rel_it).getDynSym()->getMangledName()) == 0){
 	    Region *targetRegion = regions_[i];
 	    Offset regionOffset = targetRegion->getDiskOffset()+(*rel_it).addend();
 	    (*sym_it)->setRegion(targetRegion);
@@ -2106,7 +2106,7 @@ bool Object::parse_symbols(Elf_X_Data &symdata, Elf_X_Data &strdata,
 
     	  if(stype == Symbol::ST_SECTION && sec != NULL) {
 	  	  	sname = sec->getRegionName();
-			soffset = sec->getRegionAddr();
+			soffset = sec->getDiskOffset();
           } 
 
          if (stype == Symbol::ST_MODULE) {
@@ -3071,7 +3071,8 @@ bool Object::fix_global_symbol_modules_static_stab(Elf_X_Shdr* stabscnp, Elf_X_S
 		/* If there's only one, apply regardless. */
 		if ( syms.size() == 1 ) 
                   { 
-		    symbols_[SymName][0]->setModuleName(module); 
+                     // TODO: set module
+//		    symbols_[SymName][0]->setModuleName(module); 
                   }
 		else 
                   {
@@ -3079,7 +3080,8 @@ bool Object::fix_global_symbol_modules_static_stab(Elf_X_Shdr* stabscnp, Elf_X_S
 		      {
                         if ( syms[i]->getLinkage() == Symbol::SL_GLOBAL ) 
 			  {
-			    symbols_[SymName][i]->setModuleName(module);
+                             // TODO: set module
+//			    symbols_[SymName][i]->setModuleName(module);
 			    count++;
 			  }
 		      }
@@ -5018,16 +5020,16 @@ void Object::parseStabTypes(Symtab *obj)
 	  currentFunctionName = new string(tmp);
 	  // Shouldn't this be a function name lookup?
 	  std::vector<Symbol *>syms;
-	  if(!obj->findSymbolByType(syms, 
+	  if(!obj->findSymbol(syms, 
 				    *currentFunctionName, 
 				    Symbol::ST_FUNCTION,
 				    mangledName)) {
-	    if(!obj->findSymbolByType(syms, 
+	    if(!obj->findSymbol(syms, 
 				      "_"+*currentFunctionName, 
 				      Symbol::ST_FUNCTION,
 				      mangledName)) {
 	      string fortranName = *currentFunctionName + string("_");
-	      if (obj->findSymbolByType(syms, 
+	      if (obj->findSymbol(syms, 
 					fortranName,
 					Symbol::ST_FUNCTION,
 					mangledName)) {
@@ -5057,11 +5059,11 @@ void Object::parseStabTypes(Symtab *obj)
 
 	//TODO? change this. findLocalVar will cause an infinite loop
 	std::vector<Symbol *>vars;
-	if(!obj->findSymbolByType(vars, 
+	if(!obj->findSymbol(vars, 
 				  *commonBlockName, 
 				  Symbol::ST_OBJECT,
 				  mangledName)) {
-	  if(!obj->findSymbolByType(vars, 
+	  if(!obj->findSymbol(vars, 
 				    *commonBlockName, 
 				    Symbol::ST_OBJECT,
 				    mangledName,
@@ -5089,11 +5091,11 @@ void Object::parseStabTypes(Symtab *obj)
       case N_ECOMM: {
 	//copy this set of fields
 	assert(currentFunctionName);
-	if(!obj->findSymbolByType(bpfv, 
+	if(!obj->findSymbol(bpfv, 
 				  *currentFunctionName, 
 				  Symbol::ST_FUNCTION,
 				  mangledName)) {
-	  if(!obj->findSymbolByType(bpfv, 
+	  if(!obj->findSymbol(bpfv, 
 				    *currentFunctionName, 
 				    Symbol::ST_FUNCTION, 
 				    mangledName,
@@ -5102,7 +5104,7 @@ void Object::parseStabTypes(Symtab *obj)
 	  }
 	  else{
 	    Symbol *func = bpfv[0];
-	    commonBlock->endCommonBlock(func, (void *)commonBlockVar->getAddr());
+	    commonBlock->endCommonBlock(func, (void *)commonBlockVar->getOffset());
 	  }    
 	} else {
 	  if (bpfv.size() > 1) {
@@ -5111,7 +5113,7 @@ void Object::parseStabTypes(Symtab *obj)
 	    //                     __FILE__, __LINE__, bpfv.size(), currentFunctionName->c_str());
 	  }
 	  Symbol *func = bpfv[0];
-	  commonBlock->endCommonBlock(func, (void *)commonBlockVar->getAddr());
+	  commonBlock->endCommonBlock(func, (void *)commonBlockVar->getOffset());
 	}
 	//TODO?? size for local variables??
 	//       // update size if needed
@@ -5394,7 +5396,7 @@ bool Object::parse_all_relocations(Elf_X &elf, Elf_X_Shdr *dynsym_scnp,
                 if( sym_it != dynsymByIndex.end() ) {
                     sym = sym_it->second;
    	 	    if(sym->getType() == Symbol::ST_SECTION) {
-			name = sym->getSec()->getRegionName().c_str();
+			name = sym->getRegion()->getRegionName().c_str();
 	            }		 
                 }
             }else if( strtab && curSymHdr->sh_offset() == symtab_offset ) {
@@ -5405,7 +5407,7 @@ bool Object::parse_all_relocations(Elf_X &elf, Elf_X_Shdr *dynsym_scnp,
                 if( sym_it != symtabByIndex.end() ) {
                     sym = sym_it->second;
    	 	    if(sym->getType() == Symbol::ST_SECTION) {
-			name = sym->getSec()->getRegionName().c_str();
+			name = sym->getRegion()->getRegionName().c_str();
 		    }
                 }
             }
diff --git a/symtabAPI/src/Object.C b/symtabAPI/src/Object.C
index c2d51ee..d1d08c7 100644
--- a/symtabAPI/src/Object.C
+++ b/symtabAPI/src/Object.C
@@ -69,19 +69,19 @@ void print_symbols( std::vector< Symbol *>& allsymbols ) {
     }
     for (unsigned i=0; i<allsymbols.size(); i++) {
         sym = allsymbols[i];
-        modname = sym->getModuleName();
+        modname = (sym->getModule() ? sym->getModule()->fileName() : "");
         //if (sym->getName() == "__gmon_start__") {
         //if (modname == "libspecial.so" || modname == "libprofile.so") {
         //if (sym->getLinkage() == Symbol::SL_WEAK) {
         //if (sym->isInDynSymtab()) {
         if (1) {
             fprintf(fd, "%-20s  %-15s  0x%08x  %5u  %3u", 
-                sym->getName().substr(0,20).c_str(), 
+                    sym->getMangledName().substr(0,20).c_str(), 
                 //modname.size() > 15 ? modname.substr(modname.size()-15,15).c_str() : modname.c_str(),
                 "",
-                (unsigned)sym->getAddr(),
+                (unsigned)sym->getOffset(),
                 (unsigned)sym->getSize(),
-                sym->getSec() ? sym->getSec()->getRegionNumber() : 0
+                    sym->getRegion() ? sym->getRegion()->getRegionNumber() : 0
                 );
             switch (sym->getType()) {
                 case Symbol::ST_FUNCTION: fprintf(fd, "  FUN"); break;
@@ -163,8 +163,8 @@ const char *Dyninst::SymtabAPI::supportedLanguages2Str(supportedLanguages s)
 bool Dyninst::SymtabAPI::symbol_compare(const Symbol *s1, const Symbol *s2) 
 {
     // select the symbol with the lowest address
-    Offset s1_addr = s1->getAddr();
-    Offset s2_addr = s2->getAddr();
+    Offset s1_addr = s1->getOffset();
+    Offset s2_addr = s2->getOffset();
     if (s1_addr > s2_addr)
     	return false;
     if (s1_addr < s2_addr)
diff --git a/symtabAPI/src/Region.C b/symtabAPI/src/Region.C
index a274a50..e2342c7 100644
--- a/symtabAPI/src/Region.C
+++ b/symtabAPI/src/Region.C
@@ -236,11 +236,6 @@ std::string Region::getRegionName() const
     return name_;
 }
 
-Offset Region::getRegionAddr() const
-{
-        return memOff_;
-}
-
 Offset Region::getDiskOffset() const
 {
     return diskOff_;
diff --git a/symtabAPI/src/Symbol.C b/symtabAPI/src/Symbol.C
index 9af66ca..0525f88 100644
--- a/symtabAPI/src/Symbol.C
+++ b/symtabAPI/src/Symbol.C
@@ -191,14 +191,6 @@ SYMTAB_EXPORT const string& Symbol::getTypedName() const
     return typedName_;
 }
 
-SYMTAB_EXPORT const string& Symbol::getModuleName() const 
-{
-    if (module_)
-        return module_->fullName();
-    else
-        return emptyString;
-}
-
 bool Symbol::setOffset(Offset newOffset)
 {
     offset_ = newOffset;
diff --git a/symtabAPI/src/Symtab-deprecated.C b/symtabAPI/src/Symtab-deprecated.C
index 01bedc3..cf3e767 100644
--- a/symtabAPI/src/Symtab-deprecated.C
+++ b/symtabAPI/src/Symtab-deprecated.C
@@ -56,29 +56,3 @@
 using namespace Dyninst;
 using namespace Dyninst::SymtabAPI;
 using namespace std;
-
-extern SymtabError serr;
-
-bool Symtab::findFuncByEntryOffset(std::vector<Symbol *>& ret, const Offset entry)
-{
-    Function *func;
-    if (!findFuncByEntryOffset(func, entry)) {
-        serr = No_Such_Function;
-        return false;
-    }
-    func->getSymbols(ret);
-    return true;
-}
-
-bool Symtab::findSymbolByType(std::vector<Symbol *> &ret,
-                              const std::string& name,
-                              Symbol::SymbolType sType,
-                              bool isMangled,
-                              bool isRegex,
-                              bool checkCase) {
-    NameType nameType;
-    if (isMangled) nameType = mangledName;
-    else nameType = prettyName;
-
-    return findSymbol(ret, name, sType, nameType, isRegex, checkCase);
-}
diff --git a/symtabAPI/src/Symtab-edit.C b/symtabAPI/src/Symtab-edit.C
index 05265d4..5526ad6 100644
--- a/symtabAPI/src/Symtab-edit.C
+++ b/symtabAPI/src/Symtab-edit.C
@@ -67,7 +67,7 @@ bool Symtab::changeType(Symbol *sym, Symbol::SymbolType oldType)
     switch (oldType) {
     case Symbol::ST_FUNCTION: {
         Function *func = NULL;
-        if (findFuncByEntryOffset(func, sym->getAddr())) {
+        if (findFuncByEntryOffset(func, sym->getOffset())) {
             // Remove this symbol from the function
             func->removeSymbol(sym);
             // What if we removed the last symbol from the function?
@@ -78,7 +78,7 @@ bool Symtab::changeType(Symbol *sym, Symbol::SymbolType oldType)
     case Symbol::ST_TLS:
     case Symbol::ST_OBJECT: {
         Variable *var = NULL;
-        if (findVariableByOffset(var, sym->getAddr())) {
+        if (findVariableByOffset(var, sym->getOffset())) {
             var->removeSymbol(sym);
             // See above
         }
diff --git a/symtabAPI/src/Symtab-lookup.C b/symtabAPI/src/Symtab-lookup.C
index 84344f6..de5c6be 100644
--- a/symtabAPI/src/Symtab-lookup.C
+++ b/symtabAPI/src/Symtab-lookup.C
@@ -111,7 +111,7 @@ bool Symtab::findSymbol(std::vector<Symbol *> &ret, const std::string& name,
 
        for (unsigned i = 0; i < everyDefinedSymbol.size(); i++) {
           if (nameType & mangledName) {
-             if (regexEquiv(name, everyDefinedSymbol[i]->getName(), checkCase))
+             if (regexEquiv(name, everyDefinedSymbol[i]->getMangledName(), checkCase))
                 candidates.push_back(everyDefinedSymbol[i]);
 
           }
@@ -505,41 +505,16 @@ bool Symtab::findRegionByEntry(Region *&ret, const Offset offset)
  */
 Region *Symtab::findEnclosingRegion(const Offset where)
 {
-#if defined (os_aix) // regions overlap so do sequential search
-    // try code regions first, then data, regions_ vector as last resort
-    for (unsigned rIdx=0; rIdx < codeRegions_.size(); rIdx++) {
-        if (where >= codeRegions_[rIdx]->getRegionAddr() &&
-            where < (codeRegions_[rIdx]->getRegionAddr() 
-                     + codeRegions_[rIdx]->getMemSize())) {
-            return codeRegions_[rIdx];
-        }
-    }
-    for (unsigned rIdx=0; rIdx < dataRegions_.size(); rIdx++) {
-        if (where >= dataRegions_[rIdx]->getRegionAddr() &&
-            where < (dataRegions_[rIdx]->getRegionAddr() 
-                     + dataRegions_[rIdx]->getMemSize())) {
-            return dataRegions_[rIdx];
-        }
-    }
-    for (unsigned rIdx=0; rIdx < regions_.size(); rIdx++) {
-        if (where >= regions_[rIdx]->getRegionAddr() &&
-            where < (regions_[rIdx]->getRegionAddr() 
-                     + regions_[rIdx]->getMemSize())) {
-            return regions_[rIdx];
-        }
-    }
-    return NULL;
-#endif
     int first = 0; 
     int last = regions_.size() - 1;
     while (last >= first) {
         Region *curreg = regions_[(first + last) / 2];
-        if (where >= curreg->getRegionAddr()
-            && where < (curreg->getRegionAddr()
+        if (where >= curreg->getMemOffset()
+            && where < (curreg->getMemOffset()
                         + curreg->getMemSize())) {
             return curreg;
         }
-        else if (where < curreg->getRegionAddr()) {
+        else if (where < curreg->getMemOffset()) {
             last = ((first + last) / 2) - 1;
         }
         else {/* where >= (cursec->getSecAddr()
@@ -569,7 +544,7 @@ bool Symtab::findRegion(Region *&ret, const Offset addr, const unsigned long siz
 {
    ret = NULL;
    for(unsigned index=0;index<regions_.size();index++) {
-      if(regions_[index]->getRegionAddr() == addr && regions_[index]->getMemSize() == size) {
+      if(regions_[index]->getMemOffset() == addr && regions_[index]->getMemSize() == size) {
          if (ret) {
 #if 0
             cerr << "Error: region inconsistency" << endl;
diff --git a/symtabAPI/src/Symtab.C b/symtabAPI/src/Symtab.C
index 4083ad8..4278137 100644
--- a/symtabAPI/src/Symtab.C
+++ b/symtabAPI/src/Symtab.C
@@ -640,7 +640,7 @@ bool Symtab::extractSymbolsFromFile(Object *linkedFile, std::vector<Symbol *> &r
       // We also have undefined symbols for the static binary case.
 
 #if !defined(os_vxworks)
-      if (sym->getSec() == NULL && !sym->isAbsolute() && !sym->isCommonStorage()) {
+      if (sym->getRegion() == NULL && !sym->isAbsolute() && !sym->isCommonStorage()) {
          undefDynSyms.push_back(sym);
          continue;
       }
@@ -797,7 +797,7 @@ bool Symtab::demangleSymbol(Symbol *&sym) {
 
    // This is a bit of a hack; we're trying to demangle undefined symbols which don't necessarily
    // have a ST_FUNCTION type. 
-   if (sym->getSec() == NULL && !sym->isAbsolute() && !sym->isCommonStorage())
+   if (sym->getRegion() == NULL && !sym->isAbsolute() && !sym->isCommonStorage())
       typed_demangle = true;
 
    if (typed_demangle) {
@@ -858,7 +858,7 @@ bool Symtab::addSymbolToIndices(Symbol *&sym, bool undefined)
       symsByTypedName[sym->getTypedName()].push_back(sym);
 #if !defined(os_vxworks)    
       // VxWorks doesn't know symbol addresses until object is loaded.
-      symsByOffset[sym->getAddr()].push_back(sym);
+      symsByOffset[sym->getOffset()].push_back(sym);
 #endif
    }
    else {
@@ -883,7 +883,7 @@ bool Symtab::addSymbolToAggregates(Symbol *&sym)
         //   Keep module information 
 
         Function *func = NULL;
-        findFuncByEntryOffset(func, sym->getAddr());
+        findFuncByEntryOffset(func, sym->getOffset());
         if (!func) {
             // Create a new function
             // Also, update the symbol to point to this function.
@@ -892,7 +892,7 @@ bool Symtab::addSymbolToAggregates(Symbol *&sym)
 
             everyFunction.push_back(func);
             sorted_everyFunction = false;
-            funcsByOffset[sym->getAddr()] = func;
+            funcsByOffset[sym->getOffset()] = func;
         }
         else {
             /* XXX 
@@ -919,14 +919,14 @@ bool Symtab::addSymbolToAggregates(Symbol *&sym)
     case Symbol::ST_OBJECT: {
         // The same as the above, but with variables.
         Variable *var = NULL;
-        findVariableByOffset(var, sym->getAddr());
+        findVariableByOffset(var, sym->getOffset());
         if (!var) {
             // Create a new function
             // Also, update the symbol to point to this function.
             var = new Variable(sym);
             
             everyVariable.push_back(var);
-            varsByOffset[sym->getAddr()] = var;
+            varsByOffset[sym->getOffset()] = var;
         }
         else {
             /* XXX
@@ -1358,9 +1358,9 @@ Symtab::Symtab(char *, size_t, std::string , Offset, bool &, void *)
 
 bool sort_reg_by_addr(const Region* a, const Region* b)
 {
-  if (a->getRegionAddr() == b->getRegionAddr())
+  if (a->getMemOffset() == b->getMemOffset())
     return a->getMemSize() < b->getMemSize();
-  return a->getRegionAddr() < b->getRegionAddr();
+  return a->getMemOffset() < b->getMemOffset();
 }
 
 extern void print_symbols( std::vector< Symbol *>& allsymbols );
@@ -1445,7 +1445,7 @@ bool Symtab::extractInfo(Object *linkedFile)
            }
         }
 
-        regionsByEntryAddr[regions_[index]->getRegionAddr()] = regions_[index];
+        regionsByEntryAddr[regions_[index]->getMemOffset()] = regions_[index];
 
         if (regions_[index]->getRegionType() == Region::RT_REL) 
         {
@@ -1636,7 +1636,7 @@ Symtab::Symtab(const Symtab& obj) :
       regions_.push_back(new Region(*(obj.regions_[i])));
 
    for (i=0;i<regions_.size();i++)
-      regionsByEntryAddr[regions_[i]->getRegionAddr()] = regions_[i];
+      regionsByEntryAddr[regions_[i]->getMemOffset()] = regions_[i];
 
    // TODO FIXME: copying symbols/Functions/Variables
 
@@ -1694,19 +1694,19 @@ bool Symtab::isCode(const Offset where)  const
    while (last >= first) 
    {
       Region *curreg = codeRegions_[(first + last) / 2];
-      if (where >= curreg->getRegionAddr()
-            && where < (curreg->getRegionAddr()
-               + curreg->getDiskSize())) 
+      if (where >= curreg->getMemOffset()
+            && where < (curreg->getMemOffset()
+               + curreg->getMemSize())) 
       {
          if (curreg->getRegionType() == Region::RT_BSS)
             return false;
          return true;
       }
-      else if (where < curreg->getRegionAddr()) 
+      else if (where < curreg->getMemOffset()) 
       {
          last = ((first + last) / 2) - 1;
       }
-      else if (where >= (curreg->getRegionAddr() + curreg->getMemSize()))
+      else if (where >= (curreg->getMemOffset() + curreg->getMemSize()))
       {
          first = ((first + last) / 2) + 1;
       }
@@ -1739,12 +1739,12 @@ bool Symtab::isData(const Offset where)  const
    {
       Region *curreg = dataRegions_[(first + last) / 2];
 
-      if (     (where >= curreg->getRegionAddr())
-            && (where < (curreg->getRegionAddr() + curreg->getDiskSize())))
+      if (     (where >= curreg->getMemOffset())
+            && (where < (curreg->getMemOffset() + curreg->getMemSize())))
       {
          return true;
       }
-      else if (where < curreg->getRegionAddr()) 
+      else if (where < curreg->getMemOffset()) 
       {
          last = ((first + last) / 2) - 1;
       }
@@ -2754,18 +2754,18 @@ SYMTAB_EXPORT bool Symtab::fixup_RegionAddr(const char* name, Offset memOffset,
     }
 
 #if defined(_MSC_VER)
-    regionsByEntryAddr.erase(sec->getRegionAddr());
+    regionsByEntryAddr.erase(sec->getMemOffset());
 #endif
 
     /* DEBUG
     fprintf(stderr, "Fixing region %s from 0x%x [0x%x] to 0x%x [0x%x]\n",
-            name, sec->getRegionAddr(), sec->getDiskSize(), memOffset,
+            name, sec->getMemOffset(), sec->getMemSize(), memOffset,
             memSize); // */
     sec->setMemOffset(memOffset);
     sec->setMemSize(memSize);
 
 #if defined(_MSC_VER)
-    regionsByEntryAddr[sec->getRegionAddr()] = sec;
+    regionsByEntryAddr[sec->getMemOffset()] = sec;
 #endif
 
     std::sort(codeRegions_.begin(), codeRegions_.end(), sort_reg_by_addr);
@@ -2854,9 +2854,8 @@ SYMTAB_EXPORT Offset Symtab::getFreeOffset(unsigned size)
 
    for (unsigned i = 0; i < regions_.size(); i++) 
    {
-      //Offset end = regions_[i]->getRegionAddr() + regions_[i]->getDiskSize();
-      Offset end = regions_[i]->getRegionAddr() + regions_[i]->getMemSize();
-      if (regions_[i]->getRegionAddr() == 0) 
+      Offset end = regions_[i]->getMemOffset() + regions_[i]->getMemSize();
+      if (regions_[i]->getMemOffset() == 0) 
          continue;
 
       prevSecoffset = secoffset;
@@ -2875,7 +2874,7 @@ SYMTAB_EXPORT Offset Symtab::getFreeOffset(unsigned size)
       }
 
       /*fprintf(stderr, "%d: secAddr 0x%lx, size %d, end 0x%lx, looking for %d\n",
-        i, regions_[i]->getSecAddr(), regions_[i]->getSecSize(),
+        i, regions_[i]->getRegionAddr(), regions_[i]->getRegionSize(),
         end,size);*/
 
       if (end > highWaterMark) 
@@ -2886,12 +2885,12 @@ SYMTAB_EXPORT Offset Symtab::getFreeOffset(unsigned size)
       }
 
       if (     (i < (regions_.size()-2)) 
-               && ((end + size) < regions_[i+1]->getRegionAddr())) 
+               && ((end + size) < regions_[i+1]->getMemOffset())) 
       {
          /*      fprintf(stderr, "Found a hole between sections %d and %d\n",
                  i, i+1);
                  fprintf(stderr, "End at 0x%lx, next one at 0x%lx\n",
-                 end, regions_[i+1]->getSecAddr());
+                 end, regions_[i+1]->getRegionAddr());
          */   
          newSectionInsertPoint = i+1;
          highWaterMark = end;
@@ -3092,7 +3091,7 @@ void Symtab::rebuild_region_indexes(SerializerBase *sb) THROW_SPEC (SerializerEr
 		//  entry addr might require some special attn on windows, since it
 		//  is not the disk offset but the actual mem addr, which is going to be
 		//  different after deserialize.  Probably have to look it up again.
-		regionsByEntryAddr[r->getRegionAddr()] = r;
+		regionsByEntryAddr[r->getMemOffset()] = r;
 	}
 
 	std::sort(codeRegions_.begin(), codeRegions_.end(), sort_reg_by_addr);
@@ -3383,7 +3382,7 @@ bool relocationEntry::operator==(const relocationEntry &r) const
 	if (!dynref_ && r.dynref_) return false;
 	if (dynref_)
 	{
-		if (dynref_->getName() != r.dynref_->getName()) return false;
+		if (dynref_->getMangledName() != r.dynref_->getMangledName()) return false;
 		if (dynref_->getOffset() != r.dynref_->getOffset()) return false;
 	}
 
@@ -3470,7 +3469,7 @@ Serializable *relocationEntry::serialize_impl(SerializerBase *, const char *) TH
 ostream & Dyninst::SymtabAPI::operator<< (ostream &os, const relocationEntry &r) 
 {
     if( r.getDynSym() != NULL ) {
-        os << "Name: " << setw(20) << ( "'" + r.getDynSym()->getName() + "'" );
+        os << "Name: " << setw(20) << ( "'" + r.getDynSym()->getMangledName() + "'" );
     }else{
         os << "Name: " << setw(20) << r.name();
     }
@@ -3768,7 +3767,7 @@ SYMTAB_EXPORT bool Symtab::addExternalSymbolReference(Symbol *externalSym, Regio
     // Bernat, 7SEP2010 - according to Matt, these symbols should have
     // type "undefined", which means a region of NULL. Changing
     // from "localRegion" to NULL. 
-    Symbol *symRef = new Symbol(externalSym->getName(),
+    Symbol *symRef = new Symbol(externalSym->getMangledName(),
                                 externalSym->getType(),
                                 Symbol::SL_GLOBAL,
                                 Symbol::SV_DEFAULT,
diff --git a/symtabAPI/src/SymtabReader.C b/symtabAPI/src/SymtabReader.C
index 3c32a97..614b99d 100644
--- a/symtabAPI/src/SymtabReader.C
+++ b/symtabAPI/src/SymtabReader.C
@@ -242,7 +242,7 @@ Dyninst::Address SymtabReader::getSectionAddress(Section_t sec)
 {
    Region *region = (Region *) sec.v1;
    assert(region);
-   return region->getRegionAddr();
+   return region->getMemOffset();
 }
 
 std::string SymtabReader::getSectionName(Section_t sec)
diff --git a/symtabAPI/src/emitElf-64.C b/symtabAPI/src/emitElf-64.C
index 172ef7d..30a8a2a 100644
--- a/symtabAPI/src/emitElf-64.C
+++ b/symtabAPI/src/emitElf-64.C
@@ -248,20 +248,20 @@ bool emitElf64::createElfSymbol(Symbol *symbol, unsigned strIndex, vector<Elf64_
   if (symbol->getPtrOffset()) {
     sym->st_value = symbol->getPtrOffset() + library_adjust;
   }
-  else if (symbol->getAddr()) {
-       sym->st_value = symbol->getAddr() + library_adjust;
+  else if (symbol->getOffset()) {
+       sym->st_value = symbol->getOffset() + library_adjust;
   }
 
   sym->st_size = symbol->getSize();
   sym->st_other = ELF64_ST_VISIBILITY(elfSymVisibility(symbol->getVisibility()));
   sym->st_info = (unsigned char) ELF64_ST_INFO(elfSymBind(symbol->getLinkage()), elfSymType(symbol));
 
-  if (symbol->getSec())
+  if (symbol->getRegion())
     {
 #if defined(os_freebsd)
-      sym->st_shndx = (Elf64_Half) symbol->getSec()->getRegionNumber();
+      sym->st_shndx = (Elf64_Half) symbol->getRegion()->getRegionNumber();
 #else
-      sym->st_shndx = (Elf64_Section) symbol->getSec()->getRegionNumber();
+      sym->st_shndx = (Elf64_Section) symbol->getRegion()->getRegionNumber();
 #endif
     }
   else if (symbol->isAbsolute())
@@ -277,7 +277,7 @@ bool emitElf64::createElfSymbol(Symbol *symbol, unsigned strIndex, vector<Elf64_
 
   if (dynSymFlag) 
     {
-      //printf("dynamic symbol: %s\n", symbol->getName().c_str());
+      //printf("dynamic symbol: %s\n", symbol->getMangledName().c_str());
 
       char msg[2048];
       char *mpos = msg;
@@ -306,7 +306,7 @@ bool emitElf64::createElfSymbol(Symbol *symbol, unsigned strIndex, vector<Elf64_
 	      if (vers->size() > 0)
 		{
 		  // new verdef entry
-		  mpos += sprintf(mpos, "verdef: symbol=%s  version=%s ", symbol->getName().c_str(), (*vers)[0].c_str());
+		  mpos += sprintf(mpos, "verdef: symbol=%s  version=%s ", symbol->getMangledName().c_str(), (*vers)[0].c_str());
 		  if (verdefEntries.find((*vers)[0]) != verdefEntries.end())
 		    {
 		      unsigned short index = verdefEntries[(*vers)[0]];
@@ -346,7 +346,7 @@ bool emitElf64::createElfSymbol(Symbol *symbol, unsigned strIndex, vector<Elf64_
 	{           
 	  //verneed entry
 	  mpos += sprintf(mpos, "need: symbol=%s    filename=%s\n", 
-			  symbol->getName().c_str(), fileName.c_str());
+			  symbol->getMangledName().c_str(), fileName.c_str());
 
 	  vector<string> *vers;
 
@@ -1760,12 +1760,12 @@ bool emitElf64::createSymbolTables(Symtab *obj, vector<Symbol *>&allSymbols)
   for(i=0; i<allSymSymbols.size();i++) {
     //allSymSymbols[i]->setStrIndex(symbolNamesLength);
     createElfSymbol(allSymSymbols[i], symbolNamesLength, symbols);
-    symbolStrs.push_back(allSymSymbols[i]->getName());
-    symbolNamesLength += allSymSymbols[i]->getName().length()+1;
+    symbolStrs.push_back(allSymSymbols[i]->getMangledName());
+    symbolNamesLength += allSymSymbols[i]->getMangledName().length()+1;
   }
   for(i=0; i<allDynSymbols.size();i++) {
     createElfSymbol(allDynSymbols[i], allDynSymbols[i]->getStrIndex(), dynsymbols, true);
-    dynSymNameMapping[allDynSymbols[i]->getName().c_str()] = allDynSymbols[i]->getIndex();
+    dynSymNameMapping[allDynSymbols[i]->getMangledName().c_str()] = allDynSymbols[i]->getIndex();
     dynsymVector.push_back(allDynSymbols[i]);
   }
 
@@ -1965,9 +1965,9 @@ bool emitElf64::createSymbolTables(Symtab *obj, vector<Symbol *>&allSymbols)
           for(newRegIter = newRegs.begin(); newRegIter != newRegs.end();
               ++newRegIter)
           {
-              if( (*newRegIter)->getRegionAddr() > lastRegionAddr ) {
-                  lastRegionAddr = (*newRegIter)->getRegionAddr();
-                  lastRegionSize = (*newRegIter)->getMemSize();
+              if( (*newRegIter)->getDiskOffset() > lastRegionAddr ) {
+                  lastRegionAddr = (*newRegIter)->getDiskOffset();
+                  lastRegionSize = (*newRegIter)->getDiskSize();
               }
           }
 
@@ -2337,13 +2337,13 @@ void emitElf64::createHashSection(Symtab *obj, Elf64_Word *&hashsecData, unsigne
   hashsecData[1] = (Elf64_Word)nchains;
   i = 0;
   for (iter = dynSymbols.begin(); iter != dynSymbols.end(); iter++, i++) {
-    if((*iter)->getName().empty()) continue;
+    if((*iter)->getMangledName().empty()) continue;
     unsigned index = (*iter)->getIndex();
     if ((find(originalHashEntries.begin(),originalHashEntries.end(),index) == originalHashEntries.end()) && 
 	(index < obj->getObject()->getDynsymSize())) {
 	continue;
     }
-    key = elfHash((*iter)->getName().c_str()) % nbuckets;
+    key = elfHash((*iter)->getMangledName().c_str()) % nbuckets;
     if (lastHash.find(key) != lastHash.end()) {
       hashsecData[2+nbuckets+lastHash[key]] = i;
     }
diff --git a/symtabAPI/src/emitElf.C b/symtabAPI/src/emitElf.C
index 763bb00..bbaca6b 100644
--- a/symtabAPI/src/emitElf.C
+++ b/symtabAPI/src/emitElf.C
@@ -272,19 +272,19 @@ bool emitElf::createElfSymbol(Symbol *symbol, unsigned strIndex, vector<Elf32_Sy
   Elf32_Sym *sym = new Elf32_Sym();
   sym->st_name = strIndex;
 
-  sym->st_value = symbol->getAddr();
-  if (symbol->getAddr())
-       sym->st_value = symbol->getAddr() + library_adjust;
+  sym->st_value = symbol->getOffset();
+  if (symbol->getOffset())
+       sym->st_value = symbol->getOffset() + library_adjust;
   sym->st_size = symbol->getSize();
   sym->st_other = ELF32_ST_VISIBILITY(elfSymVisibility(symbol->getVisibility()));
   sym->st_info = (unsigned char) ELF32_ST_INFO(elfSymBind(symbol->getLinkage()), elfSymType (symbol));
 
-  if (symbol->getSec())
+  if (symbol->getRegion())
     {
 #if defined(os_freebsd)
-      sym->st_shndx = (Elf32_Half) symbol->getSec()->getRegionNumber();
+      sym->st_shndx = (Elf32_Half) symbol->getRegion()->getRegionNumber();
 #else
-      sym->st_shndx = (Elf32_Section) symbol->getSec()->getRegionNumber();
+      sym->st_shndx = (Elf32_Section) symbol->getRegion()->getRegionNumber();
 #endif
     }
   else if (symbol->isAbsolute())
@@ -329,7 +329,7 @@ bool emitElf::createElfSymbol(Symbol *symbol, unsigned strIndex, vector<Elf32_Sy
 	      if (vers->size() > 0)
 		{
 		  // new verdef entry
-		  mpos += sprintf(mpos, "verdef: symbol=%s  version=%s ", symbol->getName().c_str(), (*vers)[0].c_str());
+		  mpos += sprintf(mpos, "verdef: symbol=%s  version=%s ", symbol->getMangledName().c_str(), (*vers)[0].c_str());
 		  if (verdefEntries.find((*vers)[0]) != verdefEntries.end())
 		    {
 		      unsigned short index = verdefEntries[(*vers)[0]];
@@ -369,7 +369,7 @@ bool emitElf::createElfSymbol(Symbol *symbol, unsigned strIndex, vector<Elf32_Sy
 	{           
 	  //verneed entry
 	  mpos += sprintf(mpos, "need: symbol=%s    filename=%s\n", 
-			  symbol->getName().c_str(), fileName.c_str());
+			  symbol->getMangledName().c_str(), fileName.c_str());
 
 	  vector<string> *vers;
 
@@ -1905,12 +1905,12 @@ bool emitElf::createSymbolTables(Symtab *obj, vector<Symbol *>&allSymbols)
   for(i=0; i<allSymSymbols.size();i++) {
     //allSymSymbols[i]->setStrIndex(symbolNamesLength);
     createElfSymbol(allSymSymbols[i], symbolNamesLength, symbols);
-    symbolStrs.push_back(allSymSymbols[i]->getName());
-    symbolNamesLength += allSymSymbols[i]->getName().length()+1;
+    symbolStrs.push_back(allSymSymbols[i]->getMangledName());
+    symbolNamesLength += allSymSymbols[i]->getMangledName().length()+1;
   }
   for(i=0; i<allDynSymbols.size();i++) {
     createElfSymbol(allDynSymbols[i], allDynSymbols[i]->getStrIndex(), dynsymbols, true);
-    dynSymNameMapping[allDynSymbols[i]->getName().c_str()] = allDynSymbols[i]->getIndex();
+    dynSymNameMapping[allDynSymbols[i]->getMangledName().c_str()] = allDynSymbols[i]->getIndex();
     dynsymVector.push_back(allDynSymbols[i]);
   }
 
@@ -2116,9 +2116,10 @@ bool emitElf::createSymbolTables(Symtab *obj, vector<Symbol *>&allSymbols)
           for(newRegIter = newRegs.begin(); newRegIter != newRegs.end();
               ++newRegIter)
           {
-              if( (*newRegIter)->getRegionAddr() > lastRegionAddr ) {
-                  lastRegionAddr = (*newRegIter)->getRegionAddr();
-                  lastRegionSize = (*newRegIter)->getMemSize();
+              if( (*newRegIter)->getDiskOffset() > lastRegionAddr ) {
+                  lastRegionAddr = (*newRegIter)->getDiskOffset();
+                  // FIXME: this was memSize, but seems like it should be diskSize
+                  lastRegionSize = (*newRegIter)->getDiskSize();
               }
           }
 
@@ -2475,13 +2476,13 @@ void emitElf::createHashSection(Symtab *obj, Elf32_Word *&hashsecData, unsigned
   hashsecData[1] = (Elf32_Word)nchains;
   i = 0;
   for (iter = dynSymbols.begin(); iter != dynSymbols.end(); iter++, i++) {
-    if((*iter)->getName().empty()) continue;
+    if((*iter)->getMangledName().empty()) continue;
     unsigned index = (*iter)->getIndex();
     if ((find(originalHashEntries.begin(),originalHashEntries.end(),index) == originalHashEntries.end()) && 
 	(index < obj->getObject()->getDynsymSize())) {
 	continue;
     }
-    key = elfHash((*iter)->getName().c_str()) % nbuckets;
+    key = elfHash((*iter)->getMangledName().c_str()) % nbuckets;
     if (lastHash.find(key) != lastHash.end()) {
       hashsecData[2+nbuckets+lastHash[key]] = i;
       //printf("hash entry:  %d: %s  =>  %u (%u)\n", (*iter)->getIndex(), (*iter)->getName().c_str(), key, nbuckets+lastHash[key]);
diff --git a/symtabAPI/src/emitElfStatic-x86.C b/symtabAPI/src/emitElfStatic-x86.C
index 9b7fcab..48c53f7 100644
--- a/symtabAPI/src/emitElfStatic-x86.C
+++ b/symtabAPI/src/emitElfStatic-x86.C
@@ -93,7 +93,7 @@ static bool computeCtorDtorAddress(relocationEntry &rel, Offset globalOffset,
         if( lmap.newCtorRegions.size() > 0 ) {
             symbolOffset = lmap.ctorRegionOffset + globalOffset;
         }else if( lmap.originalCtorRegion != NULL ) {
-            symbolOffset = lmap.originalCtorRegion->getRegionAddr();
+            symbolOffset = lmap.originalCtorRegion->getDiskOffset();
         }else{
             errMsg = "Failed to locate original .ctors Region -- cannot apply relocation";
             return false;
@@ -103,7 +103,7 @@ static bool computeCtorDtorAddress(relocationEntry &rel, Offset globalOffset,
         if( lmap.newDtorRegions.size() > 0 ) {
             symbolOffset = lmap.dtorRegionOffset + globalOffset;
         }else if( lmap.originalDtorRegion != NULL ) {
-            symbolOffset = lmap.originalDtorRegion->getRegionAddr();
+            symbolOffset = lmap.originalDtorRegion->getDiskOffset();
         }else{
             errMsg = "Failed to locate original .dtors Region -- cannot apply relocation";
             return false;
diff --git a/symtabAPI/src/emitElfStatic.C b/symtabAPI/src/emitElfStatic.C
index 263385a..ad172df 100644
--- a/symtabAPI/src/emitElfStatic.C
+++ b/symtabAPI/src/emitElfStatic.C
@@ -120,7 +120,7 @@ char *emitElfStatic::linkStatic(Symtab *target,
         // This is true, only if other regions have already been added
         vector<Region *>::iterator newReg_it;
         for(newReg_it = newRegs.begin(); newReg_it != newRegs.end(); ++newReg_it) {
-            Offset newRegEndAddr = (*newReg_it)->getMemSize() + (*newReg_it)->getRegionAddr();
+            Offset newRegEndAddr = (*newReg_it)->getMemSize() + (*newReg_it)->getDiskOffset();
             if( newRegEndAddr > globalOffset ) {
                 globalOffset = newRegEndAddr;
             }
@@ -1181,7 +1181,7 @@ bool emitElfStatic::applyRelocations(Symtab *target, vector<Symtab *> &relocatab
 	    if ((rel_it->rel_addr() < (*reg_it)->getMemOffset()) ||
 		(rel_it->rel_addr() >= ((*reg_it)->getMemOffset() + (*reg_it)->getMemSize()))) continue;
             if( !archSpecificRelocation(target, target, regionData, *rel_it,
-                        rel_it->rel_addr() - (*reg_it)->getRegionAddr(),
+                        rel_it->rel_addr() - (*reg_it)->getDiskOffset(),
                         rel_it->rel_addr(), globalOffset, lmap, errMsg) )
             {
                 err = Relocation_Computation_Failure;
@@ -1477,9 +1477,9 @@ bool emitElfUtils::updateHeapVariables(Symtab *obj, unsigned long newSecsEndAddr
     {
         Region *symRegion = (*heapSymsIter)->getRegion();
         Offset symOffset = (*heapSymsIter)->getOffset(); 
-        if( symOffset < symRegion->getRegionAddr() ) continue;
+        if( symOffset < symRegion->getDiskOffset() ) continue;
 
-        Offset regOffset = symOffset - symRegion->getRegionAddr();
+        Offset regOffset = symOffset - symRegion->getDiskOffset();
         unsigned char *regData = reinterpret_cast<unsigned char *>(symRegion->getPtrToRawData());
         Offset heapAddr;
         memcpy(&heapAddr, &regData[regOffset], sizeof(Offset));
@@ -1524,7 +1524,7 @@ bool emitElfUtils::updateRelocation(Symtab *obj, relocationEntry &rel, int libra
                 break;
             case R_X86_64_JUMP_SLOT:
                 if( !adjustValInRegion(targetRegion, 
-                           rel.rel_addr() - targetRegion->getRegionAddr(),
+                           rel.rel_addr() - targetRegion->getDiskOffset(),
                            addressWidth, library_adjust) )
                 {
                     rewrite_printf("Failed to update relocation\n");
@@ -1540,7 +1540,7 @@ bool emitElfUtils::updateRelocation(Symtab *obj, relocationEntry &rel, int libra
             case R_386_RELATIVE:
                 // On x86, addends are stored in their target location
                 if( !adjustValInRegion(targetRegion, 
-                           rel.rel_addr() - targetRegion->getRegionAddr(),
+                           rel.rel_addr() - targetRegion->getDiskOffset(),
                            addressWidth, library_adjust) )
                 {
                     rewrite_printf("Failed to update relocation\n");
@@ -1549,7 +1549,7 @@ bool emitElfUtils::updateRelocation(Symtab *obj, relocationEntry &rel, int libra
                 break;
             case R_386_JMP_SLOT:
                 if( !adjustValInRegion(targetRegion, 
-                           rel.rel_addr() - targetRegion->getRegionAddr(),
+                           rel.rel_addr() - targetRegion->getDiskOffset(),
                            addressWidth, library_adjust) )
                 {
                     rewrite_printf("Failed to update relocation\n");
diff --git a/symtabAPI/src/parseStab.C b/symtabAPI/src/parseStab.C
index 083281b..f34a61f 100644
--- a/symtabAPI/src/parseStab.C
+++ b/symtabAPI/src/parseStab.C
@@ -447,7 +447,7 @@ std::string Dyninst::SymtabAPI::parseStabString(Module *mod, int linenum, char *
 
                std::vector<Function *>fpv;
                if (!mod->exec()->findFunctionsByName(fpv, symt_current_mangled_func_name))
-               //if (!mod->findSymbolByType(fpv, symt_current_mangled_func_name, Symbol::ST_FUNCTION, true)) 
+               //if (!mod->findSymbol(fpv, symt_current_mangled_func_name, Symbol::ST_FUNCTION, true)) 
                {
                   std::string modName = mod->fileName();
 
@@ -621,11 +621,11 @@ std::string Dyninst::SymtabAPI::parseStabString(Module *mod, int linenum, char *
                {
                   Symtab *img = mod->exec();
                   std::vector<Symbol *>syms;
-                  if (img->findSymbolByType(syms, 
+                  if (img->findSymbol(syms, 
                                             nameTrailer,
                                             Symbol::ST_OBJECT,
                                             mangledName) ||
-		      img->findSymbolByType(syms, 
+		      img->findSymbol(syms, 
                                             nameTrailer,
                                             Symbol::ST_OBJECT, 
                                             mangledName,
-- 
1.8.3.1