Better symbol status, address range in modules view.

Author: vadimcn

extension/modulesView.ts

@@ -80,22 +80,22 @@ export class ModuleTreeDataProvider extends DisposableSubscriber
             let module = element as Module;
             let props = [];
             if (module.path)
-                props.push(new ModuleProperty('path', module.path));
+                props.push(new ModuleProperty('Path', module.path));
             if (module.version)
-                props.push(new ModuleProperty('version', module.version));
+                props.push(new ModuleProperty('Version', module.version));
+            if (module.addressRange)
+                props.push(new ModuleProperty('Address range', module.addressRange));
             if (module.symbolStatus)
-                props.push(new ModuleProperty('symbols', module.symbolStatus));
+                props.push(new ModuleProperty('Symbols', module.symbolStatus));
             if (module.symbolFilePath)
-                props.push(new ModuleProperty('symbol file path', module.symbolFilePath));
-            if (module.addressRange)
-                props.push(new ModuleProperty('load address', module.addressRange));
+                props.push(new ModuleProperty('Symbol file', module.symbolFilePath));
             return props;
         }
     }
 
     getTreeItem(element: Element): TreeItem {
         if (element instanceof ModuleProperty) {
-            let item = new TreeItem(`${element.key}: ${element.value}`);
+            let item = new TreeItem(`${element.key}:  ${element.value}`);
             item.contextValue = 'lldb.moduleProperty';
             return item;
         } else {

src/codelldb/src/debug_session.rs

@@ -1623,27 +1623,45 @@ impl DebugSession {
     }
 
     fn make_module_detail(&self, module: &SBModule) -> Module {
-        let mut msg = Module {
+        let mut mod_info = Module {
             id: ModuleId::String(self.module_id(&module)),
             name: module.file_spec().filename().display().to_string(),
             path: Some(module.file_spec().path().display().to_string()),
             ..Default::default()
         };
 
-        let header_addr = module.object_header_address();
-        if header_addr.is_valid() {
-            msg.address_range = Some(format!("{:X}", header_addr.load_address(&self.target)));
+        let version = module.version();
+        if !version.is_empty() {
+            let version_str = version.iter().map(u32::to_string).collect::<Vec<_>>().join(".");
+            mod_info.version = Some(version_str);
         }
 
-        let symbols = module.symbol_file_spec();
-        if symbols.is_valid() {
-            msg.symbol_status = Some("Symbols loaded.".into());
-            msg.symbol_file_path = Some(module.symbol_file_spec().path().display().to_string());
+        let range_start = module.object_header_address().load_address(&self.target);
+        let mut range_end = range_start;
+        for section in module.sections() {
+            let sec_start = section.load_address(&self.target);
+            if sec_start != INVALID_ADDRESS {
+                let sec_end = sec_start + section.byte_size() as Address;
+                range_end = cmp::max(range_end, sec_end);
+            }
+        }
+        mod_info.address_range = Some(format!("{:X} - {:X}", range_start, range_end));
+
+        let symbol_status = if module.num_compile_units() > 0 {
+            "Source debug info"
+        } else if module.num_symbols() > 0 {
+            "Public symbols only"
         } else {
-            msg.symbol_status = Some("Symbols not found".into())
+            "No symbols"
+        };
+        mod_info.symbol_status = Some(symbol_status.into());
+
+        let symbol_file = module.symbol_file_spec();
+        if symbol_file.is_valid() {
+            mod_info.symbol_file_path = Some(module.symbol_file_spec().path().display().to_string());
         }
 
-        msg
+        mod_info
     }
 
     fn handle_thread_event(&mut self, event: &SBThreadEvent) {

src/lldb/src/sb/sbmodule.rs

@@ -15,6 +15,16 @@ impl SBModule {
             unsafe { Some(get_str(ptr)) }
         }
     }
+    pub fn version(&self) -> Vec<u32> {
+        let mut versions = [0; 16];
+        let ptr = versions.as_mut_ptr();
+        let len = versions.len();
+        let count = cpp!(unsafe [self as "SBModule*", ptr as "uint32_t*", len as "size_t"] -> u32 as "uint32_t" {
+            return self->GetVersion(ptr, len);
+        });
+        let count = std::cmp::min(count as usize, versions.len());
+        Vec::from(&versions[..count])
+    }
     pub fn file_spec(&self) -> SBFileSpec {
         cpp!(unsafe [self as "SBModule*"] -> SBFileSpec as "SBFileSpec" {
             return self->GetFileSpec();
@@ -66,6 +76,19 @@ impl SBModule {
     pub fn compile_units<'a>(&'a self) -> impl Iterator<Item = SBCompileUnit> + 'a {
         SBIterator::new(self.num_compile_units(), move |index| self.compile_unit_at_index(index))
     }
+    pub fn num_sections(&self) -> u32 {
+        cpp!(unsafe [self as "SBModule*"] -> u32 as "uint32_t" {
+                return self->GetNumSections();
+        })
+    }
+    pub fn section_at_index(&self, index: u32) -> SBSection {
+        cpp!(unsafe [self as "SBModule*", index as "uint32_t"] -> SBSection as "SBSection" {
+            return self->GetSectionAtIndex(index);
+        })
+    }
+    pub fn sections<'a>(&'a self) -> impl Iterator<Item = SBSection> + 'a {
+        SBIterator::new(self.num_sections(), move |index| self.section_at_index(index))
+    }
 }
 
 impl IsValid for SBModule {