source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

   1 //===-- ObjectFileJIT.cpp ---------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/ADT/StringRef.h"
  11
  12 #include "ObjectFileJIT.h"
  13
  14 #include "lldb/Core/ArchSpec.h"
  15 #include "lldb/Core/DataBuffer.h"
  16 #include "lldb/Core/DataBufferHeap.h"
  17 #include "lldb/Core/Debugger.h"
  18 #include "lldb/Core/FileSpecList.h"
  19 #include "lldb/Core/Log.h"
  20 #include "lldb/Core/Module.h"
  21 #include "lldb/Core/ModuleSpec.h"
  22 #include "lldb/Core/PluginManager.h"
  23 #include "lldb/Core/RangeMap.h"
  24 #include "lldb/Core/Section.h"
  25 #include "lldb/Core/StreamFile.h"
  26 #include "lldb/Core/StreamString.h"
  27 #include "lldb/Core/Timer.h"
  28 #include "lldb/Core/UUID.h"
  29 #include "lldb/Host/Host.h"
  30 #include "lldb/Host/FileSpec.h"
  31 #include "lldb/Symbol/ObjectFile.h"
  32 #include "lldb/Target/Platform.h"
  33 #include "lldb/Target/Process.h"
  34 #include "lldb/Target/SectionLoadList.h"
  35 #include "lldb/Target/Target.h"
  36
  37 #ifndef __APPLE__
  38 #include "Utility/UuidCompatibility.h"
  39 #endif
  40
  41 using namespace lldb;
  42 using namespace lldb_private;
  43
  44
  45 void
  46 ObjectFileJIT::Initialize()
  47 {
  48     PluginManager::RegisterPlugin (GetPluginNameStatic(),
  49                                    GetPluginDescriptionStatic(),
  50                                    CreateInstance,
  51                                    CreateMemoryInstance,
  52                                    GetModuleSpecifications);
  53 }
  54
  55 void
  56 ObjectFileJIT::Terminate()
  57 {
  58     PluginManager::UnregisterPlugin (CreateInstance);
  59 }
  60
  61
  62 lldb_private::ConstString
  63 ObjectFileJIT::GetPluginNameStatic()
  64 {
  65     static ConstString g_name("jit");
  66     return g_name;
  67 }
  68
  69 const char *
  70 ObjectFileJIT::GetPluginDescriptionStatic()
  71 {
  72     return "JIT code object file";
  73 }
  74
  75 ObjectFile *
  76 ObjectFileJIT::CreateInstance (const lldb::ModuleSP &module_sp,
  77                                  DataBufferSP& data_sp,
  78                                  lldb::offset_t data_offset,
  79                                  const FileSpec* file,
  80                                  lldb::offset_t file_offset,
  81                                  lldb::offset_t length)
  82 {
  83     // JIT'ed object file is backed by the ObjectFileJITDelegate, never
  84     // read from a file
  85     return NULL;
  86 }
  87
  88 ObjectFile *
  89 ObjectFileJIT::CreateMemoryInstance (const lldb::ModuleSP &module_sp,
  90                                      DataBufferSP& data_sp,
  91                                      const ProcessSP &process_sp,
  92                                      lldb::addr_t header_addr)
  93 {
  94     // JIT'ed object file is backed by the ObjectFileJITDelegate, never
  95     // read from memory
  96     return NULL;
  97 }
  98
  99 size_t
 100 ObjectFileJIT::GetModuleSpecifications (const lldb_private::FileSpec& file,
 101                                         lldb::DataBufferSP& data_sp,
 102                                         lldb::offset_t data_offset,
 103                                         lldb::offset_t file_offset,
 104                                         lldb::offset_t length,
 105                                         lldb_private::ModuleSpecList &specs)
 106 {
 107     // JIT'ed object file can't be read from a file on disk
 108     return 0;
 109 }
 110
 111 ObjectFileJIT::ObjectFileJIT (const lldb::ModuleSP &module_sp,
 112                               const ObjectFileJITDelegateSP &delegate_sp) :
 113     ObjectFile(module_sp, NULL, 0, 0, DataBufferSP(), 0),
 114     m_delegate_wp ()
 115 {
 116     if (delegate_sp)
 117     {
 118         m_delegate_wp = delegate_sp;
 119         m_data.SetByteOrder(delegate_sp->GetByteOrder());
 120         m_data.SetAddressByteSize(delegate_sp->GetAddressByteSize());
 121     }
 122 }
 123
 124 ObjectFileJIT::~ObjectFileJIT()
 125 {
 126 }
 127
 128
 129 bool
 130 ObjectFileJIT::ParseHeader ()
 131 {
 132     // JIT code is never in a file, nor is it required to have any header
 133     return false;
 134 }
 135
 136 ByteOrder
 137 ObjectFileJIT::GetByteOrder () const
 138 {
 139     return m_data.GetByteOrder();
 140 }
 141
 142 bool
 143 ObjectFileJIT::IsExecutable() const
 144 {
 145     return false;
 146 }
 147
 148 uint32_t
 149 ObjectFileJIT::GetAddressByteSize () const
 150 {
 151     return m_data.GetAddressByteSize();
 152 }
 153
 154
 155 Symtab *
 156 ObjectFileJIT::GetSymtab()
 157 {
 158     ModuleSP module_sp(GetModule());
 159     if (module_sp)
 160     {
 161         std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 162         if (m_symtab_ap.get() == NULL)
 163         {
 164             m_symtab_ap.reset(new Symtab(this));
 165             std::lock_guard<std::recursive_mutex> symtab_guard(m_symtab_ap->GetMutex());
 166             ObjectFileJITDelegateSP delegate_sp (m_delegate_wp.lock());
 167             if (delegate_sp)
 168                 delegate_sp->PopulateSymtab(this, *m_symtab_ap);
 169             // TODO: get symbols from delegate
 170             m_symtab_ap->Finalize ();
 171         }
 172     }
 173     return m_symtab_ap.get();
 174 }
 175
 176 bool
 177 ObjectFileJIT::IsStripped ()
 178 {
 179     return false; // JIT code that is in a module is never stripped
 180 }
 181
 182 void
 183 ObjectFileJIT::CreateSections (SectionList &unified_section_list)
 184 {
 185     if (!m_sections_ap.get())
 186     {
 187         m_sections_ap.reset(new SectionList());
 188         ObjectFileJITDelegateSP delegate_sp (m_delegate_wp.lock());
 189         if (delegate_sp)
 190         {
 191             delegate_sp->PopulateSectionList(this, *m_sections_ap);
 192             unified_section_list = *m_sections_ap;
 193         }
 194     }
 195 }
 196
 197 void
 198 ObjectFileJIT::Dump (Stream *s)
 199 {
 200     ModuleSP module_sp(GetModule());
 201     if (module_sp)
 202     {
 203         std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 204         s->Printf("%p: ", static_cast<void*>(this));
 205         s->Indent();
 206         s->PutCString("ObjectFileJIT");
 207
 208         ArchSpec arch;
 209         if (GetArchitecture(arch))
 210             *s << ", arch = " << arch.GetArchitectureName();
 211
 212         s->EOL();
 213
 214         SectionList *sections = GetSectionList();
 215         if (sections)
 216             sections->Dump(s, NULL, true, UINT32_MAX);
 217
 218         if (m_symtab_ap.get())
 219             m_symtab_ap->Dump(s, NULL, eSortOrderNone);
 220     }
 221 }
 222
 223 bool
 224 ObjectFileJIT::GetUUID (lldb_private::UUID* uuid)
 225 {
 226     // TODO: maybe get from delegate, not needed for first pass
 227     return false;
 228 }
 229
 230
 231 uint32_t
 232 ObjectFileJIT::GetDependentModules (FileSpecList& files)
 233 {
 234     // JIT modules don't have dependencies, but they could
 235     // if external functions are called and we know where they are
 236     files.Clear();
 237     return 0;
 238 }
 239
 240 lldb_private::Address
 241 ObjectFileJIT::GetEntryPointAddress ()
 242 {
 243     return Address();
 244 }
 245
 246 lldb_private::Address
 247 ObjectFileJIT::GetHeaderAddress ()
 248 {
 249     return Address();
 250 }
 251
 252
 253
 254 ObjectFile::Type
 255 ObjectFileJIT::CalculateType()
 256 {
 257     return eTypeJIT;
 258 }
 259
 260 ObjectFile::Strata
 261 ObjectFileJIT::CalculateStrata()
 262 {
 263     return eStrataJIT;
 264 }
 265
 266
 267 bool
 268 ObjectFileJIT::GetArchitecture (ArchSpec &arch)
 269 {
 270     ObjectFileJITDelegateSP delegate_sp (m_delegate_wp.lock());
 271     if (delegate_sp)
 272         return delegate_sp->GetArchitecture(arch);
 273     return false;
 274 }
 275
 276 //------------------------------------------------------------------
 277 // PluginInterface protocol
 278 //------------------------------------------------------------------
 279 lldb_private::ConstString
 280 ObjectFileJIT::GetPluginName()
 281 {
 282     return GetPluginNameStatic();
 283 }
 284
 285 uint32_t
 286 ObjectFileJIT::GetPluginVersion()
 287 {
 288     return 1;
 289 }
 290
 291
 292 bool
 293 ObjectFileJIT::SetLoadAddress (Target &target,
 294                                lldb::addr_t value,
 295                                bool value_is_offset)
 296 {
 297     size_t num_loaded_sections = 0;
 298     SectionList *section_list = GetSectionList ();
 299     if (section_list)
 300     {
 301         const size_t num_sections = section_list->GetSize();
 302         // "value" is an offset to apply to each top level segment
 303         for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx)
 304         {
 305             // Iterate through the object file sections to find all
 306             // of the sections that size on disk (to avoid __PAGEZERO)
 307             // and load them
 308             SectionSP section_sp (section_list->GetSectionAtIndex (sect_idx));
 309             if (section_sp &&
 310                 section_sp->GetFileSize() > 0 &&
 311                 section_sp->IsThreadSpecific() == false)
 312             {
 313                 if (target.GetSectionLoadList().SetSectionLoadAddress (section_sp, section_sp->GetFileAddress() + value))
 314                     ++num_loaded_sections;
 315             }
 316         }
 317     }
 318     return num_loaded_sections > 0;
 319 }
 320
 321
 322 size_t
 323 ObjectFileJIT::ReadSectionData (const lldb_private::Section *section,
 324                                 lldb::offset_t section_offset,
 325                                 void *dst,
 326                                 size_t dst_len) const
 327 {
 328     lldb::offset_t file_size = section->GetFileSize();
 329     if (section_offset < file_size)
 330     {
 331         size_t src_len = file_size - section_offset;
 332         if (src_len > dst_len)
 333             src_len = dst_len;
 334         const uint8_t *src = ((uint8_t *)(uintptr_t)section->GetFileOffset()) + section_offset;
 335
 336         memcpy (dst, src, src_len);
 337         return src_len;
 338     }
 339     return 0;
 340 }
 341
 342 size_t
 343 ObjectFileJIT::ReadSectionData (const lldb_private::Section *section,
 344                                 lldb_private::DataExtractor& section_data) const
 345 {
 346     if (section->GetFileSize())
 347     {
 348         const void *src = (void *)(uintptr_t)section->GetFileOffset();
 349
 350         DataBufferSP data_sp (new lldb_private::DataBufferHeap(src, section->GetFileSize()));
 351         if (data_sp)
 352         {
 353             section_data.SetData (data_sp, 0, data_sp->GetByteSize());
 354             section_data.SetByteOrder (GetByteOrder());
 355             section_data.SetAddressByteSize (GetAddressByteSize());
 356             return section_data.GetByteSize();
 357         }
 358     }
 359     section_data.Clear();
 360     return 0;
 361 }
 362