Add support for handling absolute symbols in ELF

[tberghammer]

Summary

Add support for handling absolute symbols in ELF

Most address represented in lldb as section plus offset and handling of
absolute addresses is problematic in several location because of lack
of necessary information (e.g. Target) or because of performance issues.

This CL change the way ObjectFileELF handle the absolute symbols with
creating a pseudo section for each symbol. With this change all existing
code designed to work with addresses in the form of section plus offset
will work with absolute symbols as well.

[clayborg]

We should probably make it such that if a section has the type eSectionTypeAbsoluteAddress that we do the right thing inside the following functions:

Section::GetLoadBaseAddress(...);
Section::Slide(...);

SectionLoadList::SetSectionLoadAddress(...);
SectionLoadList::GetSectionLoadAddress(...);
SectionLoadList::SetSectionUnloaded(...);
SectionLoadList::ResolveLoadAddress(...);

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2092 ↗

(On Diff #48498)

This variable has a really bad name. We should change "symbol_idx" to "section_idx" and make this const:

const Elf64_Half section_idx = symbol.st_shndx;

2291 ↗

(On Diff #48498)

Shouldn't this just be:

if (!symbol_section_sp && symbol.st_shndx != SHN_UNDEF  && symbol.st_size != 0)

We need to know if a symbol has an address and it only has an address if symbol.st_shndx != SHN_UNDEF. All other section types mean that the symbol actually has an address

[tberghammer]

In D17450#357477, @clayborg wrote:

We should probably make it such that if a section has the type eSectionTypeAbsoluteAddress that we do the right thing inside the following functions:
Section::GetLoadBaseAddress(...);
Section::Slide(...);
SectionLoadList::SetSectionLoadAddress(...);
SectionLoadList::GetSectionLoadAddress(...);
SectionLoadList::SetSectionUnloaded(...);
SectionLoadList::ResolveLoadAddress(...);

I don't think any of these function should behave differently for absolute sections. For example calling SetSectionLoadAddress on an absolute section wouldn't make too much sense but I think they should still behave the same way and the caller of them have to make sure they are not called with incorrect values (see ObjectFileELF.cpp:931). For any other function you mentioned the type of the section shouldn't matter at all. We can possibly add some assert to some of these functions to verify they are not called in incorrect scenarios but I am not sure it is a good idea (changing a soft failure to a crash)

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2092 ↗

(On Diff #48498)

Done

2291 ↗

(On Diff #48498)

I agree that my original condition is wrong but I think it should be the following because we want to create a virtual section for absolute symbols only:

if (symbol_section_sp == nullptr && symbol.st_shndx == SHN_ABS && symbol.st_size != 0)

lldb/trunk/include/lldb/lldb-enumerations.h

enum SectionType
         eSectionTypeELFDynamicSymbols,    // Elf SHT_DYNSYM section
         eSectionTypeELFRelocationEntries, // Elf SHT_REL or SHT_REL section
         eSectionTypeELFDynamicLinkInfo,   // Elf SHT_DYNAMIC section
         eSectionTypeEHFrame,
         eSectionTypeARMexidx,
         eSectionTypeARMextab,
         eSectionTypeCompactUnwind,        // compact unwind section in Mach-O, __TEXT,__unwind_info
         eSectionTypeGoSymtab,
+        eSectionTypeAbsoluteAddress,      // Dummy section for symbols with absolute address
         eSectionTypeOther
     };
 
     FLAGS_ENUM(EmulateInstructionOptions)
     {
         eEmulateInstructionOptionNone               = (0u),
         eEmulateInstructionOptionAutoAdvancePC      = (1u << 0),
         eEmulateInstructionOptionIgnoreConditions   = (1u << 1)

lldb/trunk/source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

while (jit_relevant_entry != 0)
 
             char jit_name[64];
             snprintf(jit_name, 64, "JIT(0x%" PRIx64 ")", symbolfile_addr);
             module_sp = m_process->ReadModuleFromMemory(
                 FileSpec(jit_name, false), symbolfile_addr, symbolfile_size);
 
             if (module_sp && module_sp->GetObjectFile())
             {
-                bool changed;
+                // load the symbol table right away
+                module_sp->GetObjectFile()->GetSymtab();
+
                 m_jit_objects.insert(std::make_pair(symbolfile_addr, module_sp));
                 if (module_sp->GetObjectFile()->GetPluginName() == ConstString("mach-o"))
                 {
                     ObjectFile *image_object_file = module_sp->GetObjectFile();
                     if (image_object_file)
                     {
                         const SectionList *section_list = image_object_file->GetSectionList ();
                         if (section_list)
                         {
                             uint64_t vmaddrheuristic = 0;
                             uint64_t lower = (uint64_t)-1;
                             uint64_t upper = 0;
                             updateSectionLoadAddress(*section_list, target, symbolfile_addr, symbolfile_size,
                                 vmaddrheuristic, lower, upper);
                         }
                     }
                 }
                 else
                 {
+                    bool changed = false;
                     module_sp->SetLoadAddress(target, 0, true, changed);
                 }
 
-                // load the symbol table right away
-                module_sp->GetObjectFile()->GetSymtab();
-
                 module_list.AppendIfNeeded(module_sp);
 
                 ModuleList module_list;
                 module_list.Append(module_sp);
                 target.ModulesDidLoad(module_list);
             }
             else
             {

lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

if (module_sp)
             const size_t num_sections = section_list->GetSize();
             size_t sect_idx = 0;
 
             for (sect_idx = 0; sect_idx < num_sections; ++sect_idx)
             {
                 // Iterate through the object file sections to find all
                 // of the sections that have SHF_ALLOC in their flag bits.
                 SectionSP section_sp (section_list->GetSectionAtIndex (sect_idx));
-                // if (section_sp && !section_sp->IsThreadSpecific())
                 if (section_sp && section_sp->Test(SHF_ALLOC))
                 {
-                    lldb::addr_t load_addr = section_sp->GetFileAddress() + value;
+                    lldb::addr_t load_addr = section_sp->GetFileAddress();
+                    // We don't want to update the load address of a section with type
+                    // eSectionTypeAbsoluteAddress as they already have the absolute load address
+                    // already specified
+                    if (section_sp->GetType() != eSectionTypeAbsoluteAddress)
+                        load_addr += value;
 
                     // On 32-bit systems the load address have to fit into 4 bytes. The rest of
                     // the bytes are the overflow from the addition.
                     if (GetAddressByteSize() == 4)
                         load_addr &= 0xFFFFFFFF;
 
                     if (target.GetSectionLoadList().SetSectionLoadAddress (section_sp, load_addr))
                         ++num_loaded_sections;
ObjectFileELF::ParseSymbols (Symtab *symtab,
     // use for the debugger and they are causing a lot of trouble.
     // Filtering can't be restricted to Android because this special object file don't contain the
     // note section specifying the environment to Android but the custom extension and file name
     // makes it highly unlikely that this will collide with anything else.
     bool skip_oatdata_oatexec = m_file.GetFilename() == ConstString("system@[e-mail]");
 
     ArchSpec arch;
     GetArchitecture(arch);
+    ModuleSP module_sp(GetModule());
+    SectionList* module_section_list = module_sp ? module_sp->GetSectionList() : nullptr;
 
     // Local cache to avoid doing a FindSectionByName for each symbol. The "const char*" key must
     // came from a ConstString object so they can be compared by pointer
     std::unordered_map<const char*, lldb::SectionSP> section_name_to_section;
 
     unsigned i;
     for (i = 0; i < num_symbols; ++i)
     {
for (i = 0; i < num_symbols; ++i)
 
         // Skipping oatdata and oatexec sections if it is requested. See details above the
         // definition of skip_oatdata_oatexec for the reasons.
         if (skip_oatdata_oatexec && (::strcmp(symbol_name, "oatdata") == 0 || ::strcmp(symbol_name, "oatexec") == 0))
             continue;
 
         SectionSP symbol_section_sp;
         SymbolType symbol_type = eSymbolTypeInvalid;
-        Elf64_Half symbol_idx = symbol.st_shndx;
+        Elf64_Half section_idx = symbol.st_shndx;
 
-        switch (symbol_idx)
+        switch (section_idx)
         {
         case SHN_ABS:
             symbol_type = eSymbolTypeAbsolute;
             break;
         case SHN_UNDEF:
             symbol_type = eSymbolTypeUndefined;
             break;
         default:
-            symbol_section_sp = section_list->GetSectionAtIndex(symbol_idx);
+            symbol_section_sp = section_list->GetSectionAtIndex(section_idx);
             break;
         }
 
         // If a symbol is undefined do not process it further even if it has a STT type
         if (symbol_type != eSymbolTypeUndefined)
         {
             switch (symbol.getType())
             {
for (i = 0; i < num_symbols; ++i)
                     else if (symbol_type == eSymbolTypeData)
                         m_address_class_map[symbol.st_value] = eAddressClassData;
                     else
                         m_address_class_map[symbol.st_value] = eAddressClassUnknown;
                 }
             }
         }
 
-        // symbol_value_offset may contain 0 for ARM symbols or -1 for
-        // THUMB symbols. See above for more details.
+        // symbol_value_offset may contain 0 for ARM symbols or -1 for THUMB symbols. See above for
+        // more details.
         uint64_t symbol_value = symbol.st_value + symbol_value_offset;
+
+        if (symbol_section_sp == nullptr && section_idx == SHN_ABS && symbol.st_size != 0)
+        {
+            // We don't have a section for a symbol with non-zero size. Create a new section for it
+            // so the address range covered by the symbol is also covered by the module (represented
+            // through the section list). It is needed so module lookup for the addresses covered
+            // by this symbol will be successfull. This case happens for absolute symbols.
+            ConstString fake_section_name(std::string(".absolute.") + symbol_name);
+            symbol_section_sp = std::make_shared<Section>(module_sp,
+                                                          this,
+                                                          SHN_ABS,
+                                                          fake_section_name,
+                                                          eSectionTypeAbsoluteAddress,
+                                                          symbol_value,
+                                                          symbol.st_size,
+                                                          0, 0, 0,
+                                                          SHF_ALLOC);
+
+            module_section_list->AddSection(symbol_section_sp);
+            section_list->AddSection(symbol_section_sp);
+        }
+
         if (symbol_section_sp && CalculateType() != ObjectFile::Type::eTypeObjectFile)
             symbol_value -= symbol_section_sp->GetFileAddress();
 
-        if (symbol_section_sp)
-        {
-            ModuleSP module_sp(GetModule());
-            if (module_sp)
-            {
-                SectionList *module_section_list = module_sp->GetSectionList();
-                if (module_section_list && module_section_list != section_list)
-                {
-                    const ConstString &sect_name = symbol_section_sp->GetName();
-                    auto section_it = section_name_to_section.find(sect_name.GetCString());
-                    if (section_it == section_name_to_section.end())
-                        section_it = section_name_to_section.emplace(
-                            sect_name.GetCString(),
-                            module_section_list->FindSectionByName (sect_name)).first;
-                    if (section_it->second && section_it->second->GetFileSize())
-                        symbol_section_sp = section_it->second;
-                }
-            }
-        }
+        if (symbol_section_sp && module_section_list && module_section_list != section_list)
 
         bool is_global = symbol.getBinding() == STB_GLOBAL;
         uint32_t flags = symbol.st_other << 8 | symbol.st_info | additional_flags;
         bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false;
 
         llvm::StringRef symbol_ref(symbol_name);
 
         // Symbol names may contain @VERSION suffixes. Find those and strip them temporarily.

lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

if (symtab)
                         return eAddressClassDebug;
 
                     case eSectionTypeEHFrame:
                     case eSectionTypeARMexidx:
                     case eSectionTypeARMextab:
                     case eSectionTypeCompactUnwind:
                         return eAddressClassRuntime;
 
+                    case eSectionTypeAbsoluteAddress:
                     case eSectionTypeELFSymbolTable:
                     case eSectionTypeELFDynamicSymbols:
                     case eSectionTypeELFRelocationEntries:
                     case eSectionTypeELFDynamicLinkInfo:
                     case eSectionTypeOther:
                         return eAddressClassUnknown;
                     }
                 }

lldb/trunk/source/Symbol/ObjectFile.cpp

if (symtab)
                     case eSectionTypeDWARFAppleNamespaces:
                     case eSectionTypeDWARFAppleObjC:
                         return eAddressClassDebug;
                     case eSectionTypeEHFrame:
                     case eSectionTypeARMexidx:
                     case eSectionTypeARMextab:
                     case eSectionTypeCompactUnwind:
                         return eAddressClassRuntime;
+                    case eSectionTypeAbsoluteAddress:
                     case eSectionTypeELFSymbolTable:
                     case eSectionTypeELFDynamicSymbols:
                     case eSectionTypeELFRelocationEntries:
                     case eSectionTypeELFDynamicLinkInfo:
                     case eSectionTypeOther:
                         return eAddressClassUnknown;
                     }
                 }

lldb/trunk/source/Utility/ConvertEnum.cpp

switch (sect_type)
         case eSectionTypeARMexidx:
             return "ARM.exidx";
         case eSectionTypeARMextab:
             return "ARM.extab";
         case eSectionTypeCompactUnwind:
             return "compact-unwind";
         case eSectionTypeGoSymtab:
             return "go-symtab";
+        case eSectionTypeAbsoluteAddress:
+            return "absolute";
         case eSectionTypeOther:
             return "regular";
     }
     return "unknown";
 }