FpDebug: Find line info when dwarf subprogram-tag is missing. Use line info with linker info. This fixes stepping into old-style "TFoo = object ... end"

components/fpdebug/fpdbgclasses.pp

@@ -1727,13 +1727,23 @@ begin
 end;
 
 function TDbgInstance.FindProcSymbol(AAdress: TDbgPtr): TFpSymbol;
+var
+  LI: TFpSymbol;
 begin
   {$PUSH}{$R-}{$Q-}
   AAdress := AAdress;
   {$POP}
-  Result := FDbgInfo.FindProcSymbol(AAdress);
-  if not assigned(Result) then
-    result := FSymbolTableInfo.FindProcSymbol(AAdress);
+  Result := nil;
+  LI := FDbgInfo.FindLineInfo(AAdress);
+  if (LI <> nil) and (LI.Kind in [skFunction, skProcedure]) then begin
+    Result := LI;
+  end
+  else begin
+    Result := FSymbolTableInfo.FindProcSymbol(AAdress);
+    if (Result <> nil) and (Result is TFpSymbolTableProc) then
+      TFpSymbolTableProc(Result).SetLineSym(LI);
+    LI.ReleaseReference;
+  end;
 end;
 
 function TDbgInstance.FindProcStartEndPC(AAdress: TDbgPtr; out AStartPC,
@@ -2844,9 +2854,11 @@ begin
     FStoreStepSrcFilename:=sym.FileName;
     FStoreStepFuncAddr:=sym.Address.Address;
     FStoreStepFuncName:=sym.Name;
+    if sfHasLineAddrRng in sym.Flags then begin
+      FStoreStepStartAddr := sym.LineStartAddress;
+      FStoreStepEndAddr := sym.LineEndAddress;
+    end;
     if sym is TFpSymbolDwarfDataProc then begin
-      FStoreStepStartAddr := TFpSymbolDwarfDataProc(sym).LineStartAddress;
-      FStoreStepEndAddr := TFpSymbolDwarfDataProc(sym).LineEndAddress;
       FStoreStepSrcLineNo := TFpSymbolDwarfDataProc(sym).LineUnfixed;
     end
     else

components/fpdebug/fpdbgdwarf.pas

@@ -943,8 +943,8 @@ DECL = DW_AT_decl_column, DW_AT_decl_file, DW_AT_decl_line
     FStateMachine: TDwarfLineInfoStateMachine;
     FFrameBaseParser: TDwarfLocationExpression;
     FDwarf: TFpDwarfInfo;
-    function GetLineEndAddress: TDBGPtr;
-    function GetLineStartAddress: TDBGPtr;
+    function GetLineEndAddress: TDBGPtr; override;
+    function GetLineStartAddress: TDBGPtr; override;
     function GetLineUnfixed: TDBGPtr;
     function StateMachineValid: Boolean;
     function  ReadVirtuality(out AFlags: TDbgSymbolFlags): Boolean;
@@ -975,8 +975,6 @@ DECL = DW_AT_decl_column, DW_AT_decl_file, DW_AT_decl_line
     function ResolveInternalFinallySymbol(Process: Pointer): TFpSymbol; virtual; // so it can be overriden by the fpc classes
 
     // Contineous (sub-)part of the line
-    property LineStartAddress: TDBGPtr read GetLineStartAddress;
-    property LineEndAddress: TDBGPtr read GetLineEndAddress;
     property LineUnfixed: TDBGPtr read GetLineUnfixed; // with 0 lines
   end;
 
@@ -5982,6 +5980,8 @@ var
   flg: TDbgSymbolFlags;
 begin
   Result := inherited GetFlags;
+  if StateMachineValid then
+    Result := Result + [sfHasLine, sfHasLineAddrRng];
   if ReadVirtuality(flg) then
     Result := Result + flg;
 end;

components/fpdebug/fpdbgdwarfdataclasses.pas

@@ -504,9 +504,9 @@ type
   protected
     procedure Init; virtual;
   public
-    constructor Create(const AName: String; AnInformationEntry: TDwarfInformationEntry);
+    constructor Create(const AName: String; AnInformationEntry: TDwarfInformationEntry); overload;
     constructor Create(const AName: String; AnInformationEntry: TDwarfInformationEntry;
-                       AKind: TDbgSymbolKind; const AAddress: TFpDbgMemLocation);
+                       AKind: TDbgSymbolKind; const AAddress: TFpDbgMemLocation); overload;
     destructor Destroy; override;
 
     function CreateSymbolScope(ALocationContext: TFpDbgLocationContext; ADwarfInfo: TFpDwarfInfo): TFpDbgSymbolScope; virtual; overload;
@@ -516,6 +516,26 @@ type
   end;
   TDbgDwarfSymbolBaseClass = class of TDbgDwarfSymbolBase;
 
+  { TFpSymbolDwarfDataLineInfo }
+  // Not strictly a Symbol...
+
+  TFpSymbolDwarfDataLineInfo = class(TDbgDwarfSymbolBase)
+  private
+    FLine, FNextLine: Cardinal;
+    FLineStartAddress, FLineEndAddress: TDBGPtr;
+    FFile: String;
+    FFound: Boolean;
+  protected
+    function GetFlags: TDbgSymbolFlags; override;
+    //function GetColumn: Cardinal; override;
+    function GetFile: String; override;
+    function GetLine: Cardinal; override;
+    function GetLineStartAddress: TDBGPtr; override;
+    function GetLineEndAddress: TDBGPtr; override;
+  public
+    constructor Create(AnAddress: TDbgPtr; AStateMachine: TDwarfLineInfoStateMachine; ACU: TDwarfCompilationUnit);
+  end;
+
   { TFpSymbolDwarfClassMap
     Provides Symbol and VAlue evaluation classes depending on the compiler
   }
@@ -652,6 +672,7 @@ type
       StateMachines: TFPObjectList; // list of state machines to be freed
     end;
     {$IFDEF DwarfTestAccess} private {$ENDIF}
+    FInitialStateMachine: TDwarfLineInfoStateMachine;
 
     FLineNumberMap: TStringListUTF8Fast;
 
@@ -717,6 +738,7 @@ type
     // Get start/end addresses of proc
     function GetProcStartEnd(const AAddress: TDBGPtr; out AStartPC, AEndPC: TDBGPtr): boolean;
 
+    function HasAddress(AAddress: TDbgPtr; ABuildAddrMap: Boolean = False): Boolean; inline;
     property Valid: Boolean read FValid;
     property FileName: String read FFileName;
     property UnitName: String read GetUnitName;
@@ -770,7 +792,8 @@ type
     function FindSymbolScope(ALocationContext: TFpDbgLocationContext; AAddress: TDbgPtr = 0): TFpDbgSymbolScope; override;
     function FindDwarfProcSymbol(AAddress: TDbgPtr): TDbgDwarfSymbolBase; inline;
     function FindProcSymbol(AAddress: TDbgPtr): TFpSymbol; override; overload;
-    function  FindProcStartEndPC(const AAddress: TDbgPtr; out AStartPC, AEndPC: TDBGPtr): boolean; override;
+    function FindProcStartEndPC(const AAddress: TDbgPtr; out AStartPC, AEndPC: TDBGPtr): boolean; override;
+    function FindLineInfo(AAddress: TDbgPtr): TFpSymbol; override;
 
     //function FindSymbol(const AName: String): TDbgSymbol; override; overload;
     function GetLineAddresses(const AFileName: String; ALine: Cardinal; var AResultList: TDBGPtrArray;
@@ -3721,19 +3744,13 @@ var
   CU: TDwarfCompilationUnit;
   Iter: TLockedMapIterator;
   Info: PDwarfAddressInfo;
-  MinMaxSet: boolean;
 begin
   Result := nil;
   for n := 0 to FCompilationUnits.Count - 1 do
   begin
     CU := TDwarfCompilationUnit(FCompilationUnits[n]);
-    CU.WaitForScopeScan;
-    if not CU.Valid then Continue;
-    MinMaxSet := CU.FMinPC <> CU.FMaxPC;
-    if MinMaxSet and ((AAddress < CU.FMinPC) or (AAddress > CU.FMaxPC))
-    then Continue;
-
-    CU.BuildAddressMap;
+    if not CU.HasAddress(AAddress, True) then
+      Continue;
 
     Iter := TLockedMapIterator.Create(CU.FAddressMap);
     try
@@ -3766,22 +3783,85 @@ function TFpDwarfInfo.FindProcStartEndPC(const AAddress: TDbgPtr; out AStartPC,
 var
   n: Integer;
   CU: TDwarfCompilationUnit;
-  MinMaxSet: boolean;
 begin
   for n := 0 to FCompilationUnits.Count - 1 do
   begin
     CU := TDwarfCompilationUnit(FCompilationUnits[n]);
-    CU.WaitForScopeScan;
-    if not CU.Valid then Continue;
-    MinMaxSet := CU.FMinPC <> CU.FMaxPC;
-    if MinMaxSet and ((AAddress < CU.FMinPC) or (AAddress > CU.FMaxPC))
-    then Continue;
+    if not CU.HasAddress(AAddress, True) then
+      Continue;
 
     Result := CU.GetProcStartEnd(AAddress, AStartPC, AEndPC);
     if Result then exit;
   end;
 end;
 
+function TFpDwarfInfo.FindLineInfo(AAddress: TDbgPtr): TFpSymbol;
+var
+  n: Integer;
+  CU: TDwarfCompilationUnit;
+  Iter: TLockedMapIterator;
+  Info: PDwarfAddressInfo;
+  SM: TDwarfLineInfoStateMachine;
+begin
+  Result := nil;
+  for n := 0 to FCompilationUnits.Count - 1 do
+  begin
+    CU := TDwarfCompilationUnit(FCompilationUnits[n]);
+    if not CU.HasAddress(AAddress, True) then
+      Continue;
+
+    Iter := TLockedMapIterator.Create(CU.FAddressMap);
+    try
+      if not Iter.Locate(AAddress)
+      then begin
+        if not Iter.BOM
+        then Iter.Previous;
+      end;
+
+      SM := nil;
+      if not Iter.BOM then begin
+        // iter is at the closest defined address before AAddress
+        Info := Iter.DataPtr;
+
+        if AAddress <= Info^.EndPC then begin
+          // TDbgDwarfProcSymbol
+          Result := Cu.DwarfSymbolClassMap.CreateProcSymbol(CU, Iter.DataPtr, AAddress, Self);
+          if Result<>nil then
+            break;
+        end;
+
+        CU.BuildLineInfo(Info, False);
+        SM := Info^.StateMachine;
+      end
+      else
+      if (CU.FMinPC <> CU.FMaxPC) and (CU.FMinPC<>0) and (CU.FMaxPC <> 0) and
+         (AAddress >= CU.FMinPC) and (AAddress < CU.FMaxPC) and
+         (CU.FInitialStateMachine <> nil)
+      then begin
+        Iter.First;
+        if not Iter.BOM then begin
+          Info := Iter.DataPtr;
+          if (AAddress >= Info^.StartPC) then
+            continue;
+        end;
+        if (AAddress >= CU.FInitialStateMachine.Address)
+        then
+          SM := CU.FInitialStateMachine;
+      end;
+
+      if SM <> nil then begin
+        SM := SM.Clone;
+        Result := TFpSymbolDwarfDataLineInfo.Create(AAddress, SM, CU);
+        if not (sfHasLine in Result.Flags) then
+          ReleaseRefAndNil(Result);
+        Break;
+      end;
+    finally
+      Iter.Free;
+    end;
+  end;
+end;
+
 function TFpDwarfInfo.FindDwarfUnitSymbol(AAddress: TDbgPtr
   ): TDbgDwarfSymbolBase;
 var
@@ -3997,6 +4077,84 @@ begin
   Result := nil;
 end;
 
+{ TFpSymbolDwarfDataLineInfo }
+
+function TFpSymbolDwarfDataLineInfo.GetFlags: TDbgSymbolFlags;
+begin
+  Result := [];
+  if FFound then
+    Result := Result + [sfHasLine, sfHasLineAddrRng];
+end;
+
+function TFpSymbolDwarfDataLineInfo.GetFile: String;
+begin
+  Result := FFile;
+end;
+
+function TFpSymbolDwarfDataLineInfo.GetLine: Cardinal;
+begin
+  Result := FLine;
+  if Result = 0 then
+    Result := FNextLine;
+end;
+
+function TFpSymbolDwarfDataLineInfo.GetLineStartAddress: TDBGPtr;
+begin
+  Result := FLineStartAddress;
+end;
+
+function TFpSymbolDwarfDataLineInfo.GetLineEndAddress: TDBGPtr;
+begin
+  Result := FLineEndAddress;
+end;
+
+constructor TFpSymbolDwarfDataLineInfo.Create(AnAddress: TDbgPtr;
+  AStateMachine: TDwarfLineInfoStateMachine; ACU: TDwarfCompilationUnit);
+var
+  SM2: TDwarfLineInfoStateMachine;
+  SM2val: Boolean;
+begin
+  inherited Create('', skNone, TargetLoc(AnAddress));
+  FCU := ACU;
+  //Init;
+
+
+  if AStateMachine = nil then
+    exit;
+
+  if AnAddress < AStateMachine.Address
+  then begin
+    AStateMachine.Free;
+    Exit;    // The address we want to find is before the start pos ??
+  end;
+
+  SM2 := AStateMachine.Clone;
+
+  repeat
+    SM2val := SM2.NextLine;
+    if (not AStateMachine.EndSequence) and
+       ( (AnAddress = AStateMachine.Address) or
+         ( (AnAddress > AStateMachine.Address) and
+           SM2val and (AnAddress < SM2.Address)
+         )
+       )
+    then begin
+      // found
+      FFound := True;
+      FFile := AStateMachine.FileName;
+      FLine := AStateMachine.Line;
+      FNextLine := SM2.Line;
+      FLineStartAddress := AStateMachine.Address;
+      FLineEndAddress := SM2.Address;
+
+      break;
+    end;
+  until not AStateMachine.NextLine;
+
+  AStateMachine.Free;
+  SM2.Free;
+end;
+
 { TDwarfLineInfoStateMachine }
 
 function TDwarfLineInfoStateMachine.Clone: TDwarfLineInfoStateMachine;
@@ -4691,6 +4849,10 @@ begin
       end;
     end;
   end;
+  if FLineInfo.StateMachine <> nil then
+    FInitialStateMachine := FLineInfo.StateMachine.Clone;
+    if FInitialStateMachine <> nil then
+      FInitialStateMachine.NextLine;
 
   if LocateAttribute(Scope.Entry, DW_AT_low_pc, AttribList, Attrib, Form)
   then ReadAddressValue(Attrib, Form, FMinPC);
@@ -4724,6 +4886,7 @@ begin
   FreeAndNil(FAbbrevList);
   FreeAndNil(FAddressMap);
   FreeLineNumberMap;
+  FreeAndNil(FInitialStateMachine);
   FreeAndNil(FLineInfo.StateMachines);
   FreeAndNil(FLineInfo.StateMachine);
   FreeAndNil(FLineInfo.Directories);
@@ -4998,6 +5161,28 @@ begin
   end;
 end;
 
+function TDwarfCompilationUnit.HasAddress(AAddress: TDbgPtr;
+  ABuildAddrMap: Boolean): Boolean;
+begin
+  Result := Valid and
+            ( (FMinPC = FMaxPC) or
+              ((AAddress >= FMinPC) and (AAddress <= FMaxPC))
+            );
+
+  if not Result then
+    exit;
+
+  if not ABuildAddrMap then
+    exit;
+
+  WaitForScopeScan;
+  Result := Valid;
+  if not Result then
+    exit;
+
+  BuildAddressMap;
+end;
+
 function TDwarfCompilationUnit.ReadValue(AAttribute: Pointer; AForm: Cardinal; out AValue: Cardinal): Boolean;
 begin
   Result := True;

components/fpdebug/fpdbginfo.pas

@@ -72,7 +72,9 @@ type
     sfOut,
     sfpropGet,
     sfPropSet,
-    sfPropStored
+    sfPropStored,
+    sfHasLine,
+    sfHasLineAddrRng
   );
   TDbgSymbolFlags = set of TDbgSymbolFlag;
 
@@ -362,6 +364,8 @@ type
     function GetFile: String; virtual;
     function GetFlags: TDbgSymbolFlags; virtual;
     function GetLine: Cardinal; virtual;
+    function GetLineEndAddress: TDBGPtr; virtual;
+    function GetLineStartAddress: TDBGPtr; virtual;
     function GetParent: TFpSymbol; virtual;
 
     function GetValueObject: TFpValue; virtual;
@@ -408,6 +412,8 @@ type
     // Location
     property FileName: String read GetFile;
     property Line: Cardinal read GetLine;
+    property LineStartAddress: TDBGPtr read GetLineStartAddress;
+    property LineEndAddress: TDBGPtr read GetLineEndAddress;
     property Column: Cardinal read GetColumn;
     // Methods for structures (record / class / enum)
     //         array: each member represents an index (enum or subrange) and has low/high bounds
@@ -599,6 +605,7 @@ type
     function FindSymbolScope(ALocationContext: TFpDbgLocationContext; {%H-}AAddress: TDbgPtr = 0): TFpDbgSymbolScope; virtual;
     function FindProcSymbol(AAddress: TDbgPtr): TFpSymbol; virtual; overload;
     function FindProcSymbol(const {%H-}AName: String): TFpSymbol; virtual; overload;
+    function FindLineInfo(AAddress: TDbgPtr): TFpSymbol; virtual;
 
     function  FindProcStartEndPC(const AAddress: TDbgPtr; out AStartPC, AEndPC: TDBGPtr): boolean; virtual;
 
@@ -1376,6 +1383,16 @@ begin
   Result := FSymbolType;
 end;
 
+function TFpSymbol.GetLineEndAddress: TDBGPtr;
+begin
+  Result := 0;
+end;
+
+function TFpSymbol.GetLineStartAddress: TDBGPtr;
+begin
+  Result := 0;
+end;
+
 function TFpSymbol.GetHasOrdinalValue: Boolean;
 begin
   Result := False;
@@ -1752,6 +1769,11 @@ begin
   Result := nil;
 end;
 
+function TDbgInfo.FindLineInfo(AAddress: TDbgPtr): TFpSymbol;
+begin
+  Result := nil;
+end;
+
 function TDbgInfo.FindProcStartEndPC(const AAddress: TDbgPtr; out AStartPC,
   AEndPC: TDBGPtr): boolean;
 begin

components/fpdebug/fpdbgsymtablecontext.pas

@@ -20,8 +20,18 @@ type
   { TFpSymbolTableProc }
 
   TFpSymbolTableProc = class(TFpSymbol)
+  private
+    FLineSym: TFpSymbol;
+  protected
+    function GetFlags: TDbgSymbolFlags; override;
+    function GetLine: Cardinal; override;
+    function GetLineStartAddress: TDBGPtr; override;
+    function GetLineEndAddress: TDBGPtr; override;
+    function GetFile: String; override;
   public
     constructor Create(const AName: String; AnAddr: TDbgPtr);
+    destructor Destroy; override;
+    procedure SetLineSym(ASym: TFpSymbol);
   end;
 
   TFpSymbolInfo = class;
@@ -58,6 +68,41 @@ implementation
 
 { TFpSymbolTableProc }
 
+function TFpSymbolTableProc.GetFlags: TDbgSymbolFlags;
+begin
+  Result := inherited GetFlags;
+  if FLineSym <> nil then
+    Result := Result + FLineSym.Flags * [sfHasLine, sfHasLineAddrRng];
+end;
+
+function TFpSymbolTableProc.GetLine: Cardinal;
+begin
+  Result := inherited GetLine;
+  if FLineSym <> nil then
+    Result := FLineSym.Line;
+end;
+
+function TFpSymbolTableProc.GetLineStartAddress: TDBGPtr;
+begin
+  Result := inherited GetLineStartAddress;
+  if FLineSym <> nil then
+    Result := FLineSym.LineStartAddress;
+end;
+
+function TFpSymbolTableProc.GetLineEndAddress: TDBGPtr;
+begin
+  Result := inherited GetLineEndAddress;
+  if FLineSym <> nil then
+    Result := FLineSym.LineEndAddress;
+end;
+
+function TFpSymbolTableProc.GetFile: String;
+begin
+  Result := inherited GetFile;
+  if FLineSym <> nil then
+    Result := FLineSym.FileName;
+end;
+
 constructor TFpSymbolTableProc.Create(const AName: String; AnAddr: TDbgPtr);
 begin
   inherited Create(AName);
@@ -66,6 +111,19 @@ begin
   SetSymbolType(stType);
 end;
 
+destructor TFpSymbolTableProc.Destroy;
+begin
+  inherited Destroy;
+  FLineSym.ReleaseReference;
+end;
+
+procedure TFpSymbolTableProc.SetLineSym(ASym: TFpSymbol);
+begin
+  FLineSym := ASym;
+  if FLineSym <> nil then
+    FLineSym.AddReference;
+end;
+
 { TFpSymbolContext }
 
 function TFpSymbolContext.GetSizeOfAddress: Integer;