[gdb] Better module handling

This makes GDB's module handling behave more similar to the one in
Windows:
- With all GDB versions, we check if a module is loaded before looking
  it up in GDB.
- In GDB 8.4+ (not yet released), we only look for a type/symbol in the
  requested module (this is not possible in older GDB versions).

Author: cbiesinger

server/JsDbg.Gdb/JsDbg.py

@@ -60,6 +60,42 @@ def __init__(self, symbol, frame):
             GdbSymbolResult(symbol, frame))
 
 
+def FindObjfileForName(name):
+    for objfile in gdb.objfiles():
+        if JsDbgBase.FormatModule(objfile.filename) == name:
+            return objfile
+    return None
+
+
+def FindGdbSymbol(module, symbol):
+    objfile = FindObjfileForName(module)
+    if objfile is None:
+        return None
+    # GDB 8.4 and later let us look up symbols per-objfile; use that if
+    # possible. Also, only 8.4 and later let us look for symbols with static
+    # linkage. So in older versions we have to use gdb.lookup_symbol.
+    if hasattr(objfile, 'lookup_static_symbol'):
+        # We try static first, because in practice most of the symbols we look
+        # up here are static (or in an anonymous namespace, which is equivalent)
+        sym = objfile.lookup_static_symbol(symbol)
+        if sym is None:
+            sym = objfile.lookup_global_symbol(symbol)
+    else:
+        (sym, _) = gdb.lookup_symbol(symbol)
+    return sym
+
+
+def FindGdbType(module, type_name):
+    # Types are also symbols, so we just look them up as symbols. This is
+    # what GDB does internally.
+    type_symbol = FindGdbSymbol(module, type_name)
+    if type_symbol is None:
+        return None
+    if type_symbol.addr_class != gdb.SYMBOL_LOC_TYPEDEF:
+        return None
+    return type_symbol.type
+
+
 def DebuggerQuery(tag, command):
     # pi exec('print(\\'{0}~\\' + str({1}))')
     try:
@@ -114,7 +150,10 @@ def ExecuteGdbCommand(cmd):
 
 
 def GetAllFields(module, type, includeBaseTypes):
-    t = gdb.lookup_type(type)
+    t = FindGdbType(module, type)
+    if t is None:
+        return None
+
     fields = t.fields()
     resultFields = []
     for field in fields:
@@ -167,20 +206,24 @@ def GetBaseTypesFromGdbType(module, type, extra_bitoffset=0):
 
 
 def GetBaseTypes(module, type_name):
-    try:
-        t = gdb.lookup_type(type_name)
-    except:
+    t = FindGdbType(module, type_name)
+    if t is None:
         # Type is a base type?
-        return [JsDbgTypes.BaseTypeResult(module, type_name, 0)]
+        return [JsDbgTypes.SBaseTypeResult(module, type_name, 0)]
 
     return GetBaseTypesFromGdbType(module, t)
 
 def IsTypeEnum(module, type):
-    t = gdb.lookup_type(type)
+    t = FindGdbType(module, type)
+    if t is None:
+        return False
     return t.code == gdb.TYPE_CODE_ENUM
 
 def LookupField(module, type, field):
-    t = gdb.lookup_type(type)
+    t = FindGdbType(module, type)
+    if t is None:
+        return None
+
     fields = t.fields()
     while fields:
         match = list(filter(lambda x: x.name == field, fields))
@@ -200,21 +243,18 @@ def LookupField(module, type, field):
         fields = [f for m in match for f in m.type.fields()]
 
 def LookupGlobalSymbol(module, symbol):
-    # We can't use lookup_global_symbol because that does not work for symbols
-    # with local linkage, such as those in an anonymous namespace.
-    # https://sourceware.org/bugzilla/show_bug.cgi?id=24474
-    (sym, _) = gdb.lookup_symbol(symbol)
+    sym = FindGdbSymbol(module, symbol)
     if sym is None:
         return None
     return GdbSymbolResult(sym)
 
 
 def GetModuleForName(module):
-    for objfile in gdb.objfiles():
-        if JsDbgBase.FormatModule(objfile.filename) == module:
-            # Python has no API to find the base address
-            # https://sourceware.org/bugzilla/show_bug.cgi?id=24481
-            return JsDbgTypes.SModule(module, 0)
+    objfile = FindObjfileForName(module)
+    if objfile:
+        # Python has no API to find the base address
+        # https://sourceware.org/bugzilla/show_bug.cgi?id=24481
+        return JsDbgTypes.SModule(module, 0)
     return None
 
 
@@ -252,12 +292,16 @@ def LookupTypeSize(module, typename):
     if (typename.endswith("*")):
         t = gdb.lookup_type("void")
         return t.reference().sizeof
-    t = gdb.lookup_type(typename)
+    t = FindGdbType(module, typename)
+    if t is None:
+        return None
     return t.sizeof
 
 
 def LookupConstants(module, type, value):
-    type = gdb.lookup_type(type)
+    type = FindGdbType(module, type)
+    if type is None:
+        return None
     if type.code != gdb.TYPE_CODE_ENUM:
         return None
     values = []
@@ -275,7 +319,9 @@ def LookupConstants(module, type, value):
 
 def LookupConstant(module, typename, constantName):
     if typename:
-        type = gdb.lookup_type(typename)
+        type = FindGdbType(module, typename)
+        if type is None:
+            return None
         # Values in enum classes are stored as type::eFoo;
         # regular enums as just eFoo.
         matches = [f for f in type.fields() if f.name.endswith("::" + constantName) or f.name == constantName]

server/JsDbg.Stdio/StdioDebugger.cs

@@ -113,6 +113,8 @@ public async Task<IEnumerable<SFieldResult>> GetAllFields(string module, string
             NotifyDebuggerMessage(String.Format("Looking up fields for {0}...", typename));
 
             string pythonResult = await this.QueryDebuggerPython(String.Format("GetAllFields(\"{0}\",\"{1}\",{2})",module, typename, includeBaseTypes ? "True" : "False"));
+            if (pythonResult == "None")
+                throw new DebuggerException(String.Format("No type {0}!{1}", module, typename));
 
             List<string> objects = ParsePythonObjectArrayToStrings(pythonResult);
             List<SFieldResult> result = new List<SFieldResult>();
@@ -139,6 +141,8 @@ public async Task<IEnumerable<SBaseTypeResult>> GetBaseTypes(string module, stri
             NotifyDebuggerMessage(String.Format("Looking up base types for {0}...", typeName));
 
             string pythonResult = await this.QueryDebuggerPython(String.Format("GetBaseTypes(\"{0}\",\"{1}\")", module, typeName));
+            if (pythonResult == "None")
+                throw new DebuggerException(String.Format("No type {0}!{1}", module, typeName));
 
             List<string> objects = ParsePythonObjectArrayToStrings(pythonResult);
             List<SBaseTypeResult> result = new List<SBaseTypeResult>();
@@ -177,6 +181,8 @@ public async Task<IEnumerable<SConstantResult>> LookupConstants(string module, s
             NotifyDebuggerMessage(String.Format("Looking up name for {0}({1})...", type, constantValue));
 
             string pythonResult = await this.QueryDebuggerPython(String.Format("LookupConstants(\"{0}\", \"{1}\", {2})", module, type, constantValue));
+            if (pythonResult == "None")
+                throw new DebuggerException(String.Format("Error looking up constant value {0} on {1}!{2}", constantValue, module, type));
 
             List<string> objects = ParsePythonObjectArrayToStrings(pythonResult);
             List<SConstantResult> result = new List<SConstantResult>();
@@ -198,6 +204,8 @@ public async Task<SConstantResult> LookupConstant(string module, string type, st
             NotifyDebuggerMessage(String.Format("Looking up value for constant {0}...", constantName));
 
             string response = await this.QueryDebuggerPython(String.Format("LookupConstant(\"{0}\",\"{1}\",\"{2}\")", module, type == null ? "None" : type , constantName));
+            if (response == "None")
+                throw new DebuggerException(String.Format("Error looking up constant {0} on {1}!{2}", constantName, module, type));
 
             SConstantResult result = new SConstantResult();
             result.ConstantName = constantName;
@@ -262,6 +270,8 @@ public async Task<SSymbolResult> LookupGlobalSymbol(string module, string symbol
 
         public async Task<SModule> GetModuleForName(string module) {
             string pythonResult = await this.QueryDebuggerPython(String.Format("GetModuleForName(\"{0}\")", module));
+            if (pythonResult == "None")
+                throw new DebuggerException(String.Format("No module {0}", module));
 
             Debug.Assert(pythonResult[0] == '{');
             int fieldEndIndex = pythonResult.IndexOf('}');
@@ -335,7 +345,6 @@ public async Task<SSymbolNameAndDisplacement> LookupSymbolName(ulong pointer) {
             NotifyDebuggerMessage(String.Format("Looking up symbol at 0x{0:x}...", pointer));
 
             string response = await this.QueryDebuggerPython(String.Format("LookupSymbolName(0x{0:x})",pointer));
-
             if (response == "None")
                 throw new DebuggerException(String.Format("Address 0x{0:x} is not a symbol", pointer));
 
@@ -365,6 +374,8 @@ public async Task<uint> LookupTypeSize(string module, string typename) {
             NotifyDebuggerMessage(String.Format("Looking up sizeof({0})...", typename));
 
             string pythonResponse = await this.QueryDebuggerPython(String.Format("LookupTypeSize(\"{0}\",\"{1}\")", module, typename));
+            if (pythonResponse == "None")
+                throw new DebuggerException(String.Format("No type {0}!{1}", module, typename));
 
             return UInt32.Parse(pythonResponse);
         }