[Lldb-commits] [PATCH] D55142: Minidump debugging using the native PDB reader

[Greg Clayton via Phabricator via lldb-commits]

clayborg added a comment.

FYI: my approach to getting symbols to load was a bit different. I always let a simple PlaceholderModule be created, but I played some tricks in the GetObjectFile() method if someone had setting symbols for the module with "target symbols add ..". I will attach my PlaceholderModule so you can see what I had done. Since these modules always must be associated with a target, I keep a weak pointer to the target in the constructor. Then later, if someone does "target symbols add ..." the module will have Module:: m_symfile_spec filled in, so I set the m_platform_file to be m_file, and then move m_symfile_spec into m_file and then call Module::GetObjectFile(). This is nice and clean because you don't have to make up fake symbols to fake sections. When you create the placeholder module it needs the target:

  auto placeholder_module =
      std::make_shared<PlaceholderModule>(module_spec, GetTarget());

Here is the copy of the PlaceholderModule that does what was discussed above:

  //------------------------------------------------------------------
  /// A placeholder module used for minidumps, where the original
  /// object files may not be available (so we can't parse the object
  /// files to extract the set of sections/segments)
  ///
  /// This placeholder module has a single synthetic section (.module_image)
  /// which represents the module memory range covering the whole module.
  //------------------------------------------------------------------
  class PlaceholderModule : public Module {
  public:
    PlaceholderModule(const ModuleSpec &module_spec, Target& target) :
      Module(module_spec.GetFileSpec(), module_spec.GetArchitecture()),
      m_target_wp(target.shared_from_this()),
      m_base_of_image(LLDB_INVALID_ADDRESS), m_size_of_image(0) {
      if (module_spec.GetUUID().IsValid())
        SetUUID(module_spec.GetUUID());
    }
  
    // Creates a synthetic module section covering the whole module image (and
    // sets the section load address as well)
    void CreateImageSection(const MinidumpModule *module) {
      m_base_of_image = module->base_of_image;
      m_size_of_image = module->size_of_image;
      TargetSP target_sp = m_target_wp.lock();
      if (!target_sp)
        return;
      const ConstString section_name(".module_image");
      lldb::SectionSP section_sp(new Section(
          shared_from_this(),     // Module to which this section belongs.
          nullptr,                // ObjectFile
          0,                      // Section ID.
          section_name,           // Section name.
          eSectionTypeContainer,  // Section type.
          module->base_of_image,  // VM address.
          module->size_of_image,  // VM size in bytes of this section.
          0,                      // Offset of this section in the file.
          module->size_of_image,  // Size of the section as found in the file.
          12,                     // Alignment of the section (log2)
          0,                      // Flags for this section.
          1));                    // Number of host bytes per target byte
      section_sp->SetPermissions(ePermissionsExecutable | ePermissionsReadable);
      GetSectionList()->AddSection(section_sp);
      target_sp->GetSectionLoadList().SetSectionLoadAddress(
          section_sp, module->base_of_image);
    }
  
    ObjectFile *GetObjectFile() override {
      // Since there is no object file for these place holder modules, check
      // if the symbol file spec has been set, and if so, then transfer it over
      // to the file spec so the module can make a real object file out of it.
      if (m_symfile_spec) {
        // We need to load the sections once. We check of m_objfile_sp is valid.
        // If it is, we already have loaded the sections. If it isn't, we will
        // load the sections.
        const bool load_sections = !m_objfile_sp;
        if (load_sections) {
          m_platform_file = m_file;
          m_file = m_symfile_spec;
        }
        ObjectFile *obj_file = Module::GetObjectFile();
        if (load_sections && obj_file) {
          TargetSP target_sp = m_target_wp.lock();
          // The first time we create the object file from the external symbol
          // file, we must load its sections and unload the ".module_image"
          // section
          bool changed;
          SetLoadAddress(*target_sp, m_base_of_image, false, changed);
        }
        return obj_file;
      }
      return nullptr;
    }
  
    SectionList *GetSectionList() override {
      return Module::GetUnifiedSectionList();
    }
  protected:
    // In case we need to load the sections in PlaceholderModule::GetObjectFile()
    // after a symbol file has been specified, we might need the target.
    lldb::TargetWP m_target_wp;
    lldb::addr_t m_base_of_image;
    lldb::addr_t m_size_of_image;
  };


CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D55142/new/

https://reviews.llvm.org/D55142