344 lines
17 KiB
C++
344 lines
17 KiB
C++
//===-- SymbolVendorMacOSX.cpp ----------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "SymbolVendorMacOSX.h"
|
|
|
|
#include <libxml/parser.h>
|
|
#include <libxml/tree.h>
|
|
#include <string.h>
|
|
|
|
#include <AvailabilityMacros.h>
|
|
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/ModuleSpec.h"
|
|
#include "lldb/Core/PluginManager.h"
|
|
#include "lldb/Core/Section.h"
|
|
#include "lldb/Core/StreamString.h"
|
|
#include "lldb/Core/Timer.h"
|
|
#include "lldb/Host/Host.h"
|
|
#include "lldb/Host/Symbols.h"
|
|
#include "lldb/Symbol/ObjectFile.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
//----------------------------------------------------------------------
|
|
// SymbolVendorMacOSX constructor
|
|
//----------------------------------------------------------------------
|
|
SymbolVendorMacOSX::SymbolVendorMacOSX(const lldb::ModuleSP &module_sp) :
|
|
SymbolVendor (module_sp)
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Destructor
|
|
//----------------------------------------------------------------------
|
|
SymbolVendorMacOSX::~SymbolVendorMacOSX()
|
|
{
|
|
}
|
|
|
|
|
|
static bool
|
|
UUIDsMatch(Module *module, ObjectFile *ofile)
|
|
{
|
|
if (module && ofile)
|
|
{
|
|
// Make sure the UUIDs match
|
|
lldb_private::UUID dsym_uuid;
|
|
|
|
if (!ofile->GetUUID(&dsym_uuid))
|
|
{
|
|
Host::SystemLog (Host::eSystemLogWarning,
|
|
"warning: failed to get the uuid for object file: '%s'\n",
|
|
ofile->GetFileSpec().GetFilename().GetCString());
|
|
return false;
|
|
}
|
|
|
|
if (dsym_uuid == module->GetUUID())
|
|
return true;
|
|
|
|
// Emit some warning messages since the UUIDs do not match!
|
|
const FileSpec &m_file_spec = module->GetFileSpec();
|
|
const FileSpec &o_file_spec = ofile->GetFileSpec();
|
|
StreamString ss_m_path, ss_o_path;
|
|
m_file_spec.Dump(&ss_m_path);
|
|
o_file_spec.Dump(&ss_o_path);
|
|
|
|
StreamString ss_m_uuid, ss_o_uuid;
|
|
module->GetUUID().Dump(&ss_m_uuid);
|
|
dsym_uuid.Dump(&ss_o_uuid);
|
|
Host::SystemLog (Host::eSystemLogWarning,
|
|
"warning: UUID mismatch detected between module '%s' (%s) and:\n\t'%s' (%s)\n",
|
|
ss_m_path.GetData(), ss_m_uuid.GetData(), ss_o_path.GetData(), ss_o_uuid.GetData());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void
|
|
ReplaceDSYMSectionsWithExecutableSections (ObjectFile *exec_objfile, ObjectFile *dsym_objfile)
|
|
{
|
|
// We need both the executable and the dSYM to live off of the
|
|
// same section lists. So we take all of the sections from the
|
|
// executable, and replace them in the dSYM. This allows section
|
|
// offset addresses that come from the dSYM to automatically
|
|
// get updated as images (shared libraries) get loaded and
|
|
// unloaded.
|
|
SectionList *exec_section_list = exec_objfile->GetSectionList();
|
|
SectionList *dsym_section_list = dsym_objfile->GetSectionList();
|
|
if (exec_section_list && dsym_section_list)
|
|
{
|
|
const uint32_t num_exec_sections = dsym_section_list->GetSize();
|
|
uint32_t exec_sect_idx;
|
|
for (exec_sect_idx = 0; exec_sect_idx < num_exec_sections; ++exec_sect_idx)
|
|
{
|
|
SectionSP exec_sect_sp(exec_section_list->GetSectionAtIndex(exec_sect_idx));
|
|
if (exec_sect_sp.get())
|
|
{
|
|
// Try and replace any sections that exist in both the executable
|
|
// and in the dSYM with those from the executable. If we fail to
|
|
// replace the one in the dSYM, then add the executable section to
|
|
// the dSYM.
|
|
if (dsym_section_list->ReplaceSection(exec_sect_sp->GetID(), exec_sect_sp, 0) == false)
|
|
dsym_section_list->AddSection(exec_sect_sp);
|
|
}
|
|
}
|
|
|
|
dsym_section_list->Finalize(); // Now that we're done adding sections, finalize to build fast-lookup caches
|
|
}
|
|
}
|
|
|
|
void
|
|
SymbolVendorMacOSX::Initialize()
|
|
{
|
|
PluginManager::RegisterPlugin (GetPluginNameStatic(),
|
|
GetPluginDescriptionStatic(),
|
|
CreateInstance);
|
|
}
|
|
|
|
void
|
|
SymbolVendorMacOSX::Terminate()
|
|
{
|
|
PluginManager::UnregisterPlugin (CreateInstance);
|
|
}
|
|
|
|
|
|
const char *
|
|
SymbolVendorMacOSX::GetPluginNameStatic()
|
|
{
|
|
return "symbol-vendor.macosx";
|
|
}
|
|
|
|
const char *
|
|
SymbolVendorMacOSX::GetPluginDescriptionStatic()
|
|
{
|
|
return "Symbol vendor for MacOSX that looks for dSYM files that match executables.";
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
// CreateInstance
|
|
//
|
|
// Platforms can register a callback to use when creating symbol
|
|
// vendors to allow for complex debug information file setups, and to
|
|
// also allow for finding separate debug information files.
|
|
//----------------------------------------------------------------------
|
|
SymbolVendor*
|
|
SymbolVendorMacOSX::CreateInstance (const lldb::ModuleSP &module_sp)
|
|
{
|
|
if (!module_sp)
|
|
return NULL;
|
|
|
|
Timer scoped_timer (__PRETTY_FUNCTION__,
|
|
"SymbolVendorMacOSX::CreateInstance (module = %s/%s)",
|
|
module_sp->GetFileSpec().GetDirectory().AsCString(),
|
|
module_sp->GetFileSpec().GetFilename().AsCString());
|
|
SymbolVendorMacOSX* symbol_vendor = new SymbolVendorMacOSX(module_sp);
|
|
if (symbol_vendor)
|
|
{
|
|
char path[PATH_MAX];
|
|
path[0] = '\0';
|
|
|
|
// Try and locate the dSYM file on Mac OS X
|
|
ObjectFile * obj_file = module_sp->GetObjectFile();
|
|
if (obj_file)
|
|
{
|
|
Timer scoped_timer2 ("SymbolVendorMacOSX::CreateInstance () locate dSYM",
|
|
"SymbolVendorMacOSX::CreateInstance (module = %s/%s) locate dSYM",
|
|
module_sp->GetFileSpec().GetDirectory().AsCString(),
|
|
module_sp->GetFileSpec().GetFilename().AsCString());
|
|
|
|
// First check to see if the module has a symbol file in mind already.
|
|
// If it does, then we MUST use that.
|
|
FileSpec dsym_fspec (module_sp->GetSymbolFileFileSpec());
|
|
|
|
ObjectFileSP dsym_objfile_sp;
|
|
if (!dsym_fspec)
|
|
{
|
|
// No symbol file was specified in the module, lets try and find
|
|
// one ourselves.
|
|
const FileSpec &file_spec = obj_file->GetFileSpec();
|
|
if (file_spec)
|
|
{
|
|
ModuleSpec module_spec(file_spec, module_sp->GetArchitecture());
|
|
module_spec.GetUUID() = module_sp->GetUUID();
|
|
dsym_fspec = Symbols::LocateExecutableSymbolFile (module_spec);
|
|
if (module_spec.GetSourceMappingList().GetSize())
|
|
{
|
|
module_sp->GetSourceMappingList().Append (module_spec.GetSourceMappingList (), true);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dsym_fspec)
|
|
{
|
|
DataBufferSP dsym_file_data_sp;
|
|
dsym_objfile_sp = ObjectFile::FindPlugin(module_sp, &dsym_fspec, 0, dsym_fspec.GetByteSize(), dsym_file_data_sp);
|
|
if (UUIDsMatch(module_sp.get(), dsym_objfile_sp.get()))
|
|
{
|
|
char dsym_path[PATH_MAX];
|
|
if (module_sp->GetSourceMappingList().IsEmpty() && dsym_fspec.GetPath(dsym_path, sizeof(dsym_path)))
|
|
{
|
|
lldb_private::UUID dsym_uuid;
|
|
if (dsym_objfile_sp->GetUUID(&dsym_uuid))
|
|
{
|
|
char uuid_cstr_buf[64];
|
|
const char *uuid_cstr = dsym_uuid.GetAsCString (uuid_cstr_buf, sizeof(uuid_cstr_buf));
|
|
if (uuid_cstr)
|
|
{
|
|
char *resources = strstr (dsym_path, "/Contents/Resources/");
|
|
if (resources)
|
|
{
|
|
char dsym_uuid_plist_path[PATH_MAX];
|
|
resources[strlen("/Contents/Resources/")] = '\0';
|
|
snprintf(dsym_uuid_plist_path, sizeof(dsym_uuid_plist_path), "%s%s.plist", dsym_path, uuid_cstr);
|
|
FileSpec dsym_uuid_plist_spec(dsym_uuid_plist_path, false);
|
|
if (dsym_uuid_plist_spec.Exists())
|
|
{
|
|
xmlDoc *doc = ::xmlReadFile (dsym_uuid_plist_path, NULL, 0);
|
|
if (doc)
|
|
{
|
|
char DBGBuildSourcePath[PATH_MAX];
|
|
char DBGSourcePath[PATH_MAX];
|
|
DBGBuildSourcePath[0] = '\0';
|
|
DBGSourcePath[0] = '\0';
|
|
for (xmlNode *node = doc->children; node; node = node ? node->next : NULL)
|
|
{
|
|
if (node->type == XML_ELEMENT_NODE)
|
|
{
|
|
if (node->name && strcmp((const char*)node->name, "plist") == 0)
|
|
{
|
|
xmlNode *dict_node = node->children;
|
|
while (dict_node && dict_node->type != XML_ELEMENT_NODE)
|
|
dict_node = dict_node->next;
|
|
if (dict_node && dict_node->name && strcmp((const char *)dict_node->name, "dict") == 0)
|
|
{
|
|
for (xmlNode *key_node = dict_node->children; key_node; key_node = key_node->next)
|
|
{
|
|
if (key_node && key_node->type == XML_ELEMENT_NODE && key_node->name)
|
|
{
|
|
if (strcmp((const char *)key_node->name, "key") == 0)
|
|
{
|
|
const char *key_name = (const char *)::xmlNodeGetContent(key_node);
|
|
if (strcmp(key_name, "DBGBuildSourcePath") == 0)
|
|
{
|
|
xmlNode *value_node = key_node->next;
|
|
while (value_node && value_node->type != XML_ELEMENT_NODE)
|
|
value_node = value_node->next;
|
|
if (value_node && value_node->name)
|
|
{
|
|
if (strcmp((const char *)value_node->name, "string") == 0)
|
|
{
|
|
const char *node_content = (const char *)::xmlNodeGetContent(value_node);
|
|
if (node_content)
|
|
{
|
|
strncpy(DBGBuildSourcePath, node_content, sizeof(DBGBuildSourcePath));
|
|
}
|
|
}
|
|
key_node = value_node;
|
|
}
|
|
}
|
|
else if (strcmp(key_name, "DBGSourcePath") == 0)
|
|
{
|
|
xmlNode *value_node = key_node->next;
|
|
while (value_node && value_node->type != XML_ELEMENT_NODE)
|
|
value_node = value_node->next;
|
|
if (value_node && value_node->name)
|
|
{
|
|
if (strcmp((const char *)value_node->name, "string") == 0)
|
|
{
|
|
const char *node_content = (const char *)::xmlNodeGetContent(value_node);
|
|
if (node_content)
|
|
{
|
|
FileSpec resolved_source_path(node_content, true);
|
|
resolved_source_path.GetPath(DBGSourcePath, sizeof(DBGSourcePath));
|
|
}
|
|
}
|
|
key_node = value_node;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
::xmlFreeDoc (doc);
|
|
|
|
if (DBGBuildSourcePath[0] && DBGSourcePath[0])
|
|
{
|
|
module_sp->GetSourceMappingList().Append (ConstString(DBGBuildSourcePath), ConstString(DBGSourcePath), true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ReplaceDSYMSectionsWithExecutableSections (obj_file, dsym_objfile_sp.get());
|
|
symbol_vendor->AddSymbolFileRepresentation(dsym_objfile_sp);
|
|
return symbol_vendor;
|
|
}
|
|
}
|
|
|
|
// Just create our symbol vendor using the current objfile as this is either
|
|
// an executable with no dSYM (that we could locate), an executable with
|
|
// a dSYM that has a UUID that doesn't match.
|
|
symbol_vendor->AddSymbolFileRepresentation(obj_file->shared_from_this());
|
|
}
|
|
}
|
|
return symbol_vendor;
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
// PluginInterface protocol
|
|
//------------------------------------------------------------------
|
|
const char *
|
|
SymbolVendorMacOSX::GetPluginName()
|
|
{
|
|
return "SymbolVendorMacOSX";
|
|
}
|
|
|
|
const char *
|
|
SymbolVendorMacOSX::GetShortPluginName()
|
|
{
|
|
return GetPluginNameStatic();
|
|
}
|
|
|
|
uint32_t
|
|
SymbolVendorMacOSX::GetPluginVersion()
|
|
{
|
|
return 1;
|
|
}
|
|
|