Implement ObjectFilePECOFF::GetEntryPointAddress.

[zturner]

Looks pretty non-controversial. Does this fix anything? Seems like there should be a test that breaks somehow if this doesn't work. I don't know off the top of my head what the debugger command is "get the address of the entry point", but presumably it was broken before this patch?

[clayborg]

ObjectFilePECOFF::GetEntryPointAddress() is not implemented correctly. See inlined comments.

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

823 ↗

(On Diff #50075)

You will need to convert the file address "m_coff_header_opt.entry" into a section offset address before returning this. See ObjectFileELF::GetEntryPointAddress() for info on how to do this correctly and also how to cache the entry address in case it is asked for multiple time. ObjectFileELF has an instance variable "Address m_entry_point_address;" that it will populate once and lazily and return it is we have resolved the address, otherwise it will resolve the file address using the section list.

[clayborg]

lldb_private::Address is a section offset address class. We use section offset addresses everywhere. We also have the notion of three types of addresses: file address, load address and host address.

File addresses are virtual addresses as they are found in the object files (ELF, PECOFF, mach-o). They don't mean anything to the debugger because you will load your object file at various addresses as you are debugging. So we like to store the address as ".text + 0x123". Then when you load your shared library during runtime, the ".text" section will get slid by some offset. The target tracks where each shared library loads each of its sections and can turn a load address, or an address from a live process, into a section offset address. So load addresses can be resolved back into section + offset when running. A host address is when we stored constant data in the LLDB process itself. So in order to be able to slide your shared library around when running, we store all addresses as lldb_private::Address objects to facilite this. Targets can resolve a load address into a lldb_private::Address. When parsing things in object files, you must always translate any file addresses into lldb_private::Addresses (in symbols, debug info for functions and line entries, entry point addresses and much more).

Your function was causing an implicit constructor to be called on Address:

Address (lldb::addr_t abs_addr);

This will always result in a Address that has no section with an m_offset set to "abs_addr", meaning this is an absolute address that never slides.

[jingham]

We use the entry point address as the place to stop when we call functions by hand in the target. That's one place which is legit TEXT, but we are pretty sure the code you are calling will never call. So if the entry point address isn't set correctly we probably won't be able to call any functions by hand.

Jim

[zturner]

I was hoping there would be something like image headers that would just
display various information about the image, but it looks like we don't
have such a command that I can find. Seems like being able to find out the
entry point of a certain module would be useful.

[sas]

Yep, @jingham is right, I need this for expression evaluation. I'll do the change @clayborg requested.

[sas]

FWIW, I didn't cache this value because in the current form it is just returning some data that is already cached by ParseHeader(). If I split it in section/offset address, it might be required.

[sas]

Change implementation according to @clayborg's comments.

[clayborg]

Looks good.

lldb/trunk/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h

//    GetAddressClass (lldb::addr_t file_addr);
     GetArchitecture(lldb_private::ArchSpec &arch) override;
     
     bool
     GetUUID(lldb_private::UUID* uuid) override;
     
     uint32_t
     GetDependentModules(lldb_private::FileSpecList& files) override;
     
-//    virtual lldb_private::Address
-//    GetEntryPointAddress ();
+    virtual lldb_private::Address
+    GetEntryPointAddress () override;
     
     ObjectFile::Type
     CalculateType() override;
     
     ObjectFile::Strata
     CalculateStrata() override;
     
     //------------------------------------------------------------------
protected:
   typedef SectionHeaderColl::iterator     SectionHeaderCollIter;
   typedef SectionHeaderColl::const_iterator SectionHeaderCollConstIter;
 private:
   dos_header_t    m_dos_header;
   coff_header_t   m_coff_header;
   coff_opt_header_t m_coff_header_opt;
   SectionHeaderColl m_sect_headers;
     lldb::addr_t    m_image_base;
+    lldb_private::Address m_entry_point_address;
 };
 
 #endif // liblldb_ObjectFilePECOFF_h_

lldb/trunk/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

ObjectFilePECOFF::ObjectFilePECOFF (const lldb::ModuleSP &module_sp,
                                     lldb::offset_t data_offset,
                                     const FileSpec* file, 
                                     lldb::offset_t file_offset,
                                     lldb::offset_t length) :
     ObjectFile (module_sp, file, file_offset, length, data_sp, data_offset),
     m_dos_header (),
     m_coff_header (),
     m_coff_header_opt (),
-    m_sect_headers ()
+    m_sect_headers (),
+    m_entry_point_address ()
 {
     ::memset (&m_dos_header, 0, sizeof(m_dos_header));
     ::memset (&m_coff_header, 0, sizeof(m_coff_header));
     ::memset (&m_coff_header_opt, 0, sizeof(m_coff_header_opt));
 }
 
 
 ObjectFilePECOFF::~ObjectFilePECOFF()

 }
 
 uint32_t
 ObjectFilePECOFF::GetDependentModules (FileSpecList& files)
 {
     return 0;
 }
 
+lldb_private::Address
+ObjectFilePECOFF::GetEntryPointAddress ()
+{
+    if (m_entry_point_address.IsValid())
+        return m_entry_point_address;
+
+    if (!ParseHeader() || !IsExecutable())
+        return m_entry_point_address;
+
+    SectionList *section_list = GetSectionList();
+    addr_t offset = m_coff_header_opt.entry;
+
+    if (!section_list)
+        m_entry_point_address.SetOffset(offset);
+    else
+        m_entry_point_address.ResolveAddressUsingFileSections(offset, section_list);
+    return m_entry_point_address;
+}
+
 
 //----------------------------------------------------------------------
 // Dump
 //
 // Dump the specifics of the runtime file container (such as any headers
 // segments, sections, etc).
 //----------------------------------------------------------------------
 void