Fortran language support in lldb

[DavidSpickett]

As prompted by https://discourse.llvm.org/t/flang-fortran-plugin-for-lldb-status/81301, this is a tracking issue for Fortran support. It existing doesn't mean work is being done or not, it's just a place to find the most recent status.

Currently lldb has no specific support for Fortran. All it knows is that there is such a language. We can still display source and line step though.

$ cat /tmp/test.f90
program hello
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
end program hello
$ gfortran /tmp/test.f90 -o /tmp/test -g

I had to lookup what MAIN__ is from objdump, flang uses a different symbol "_QQmain". Perhaps we can grab this from some elf attribute instead.

$ ./bin/lldb /tmp/test -o "b MAIN__" -o "run"
(lldb) target create "/tmp/test"
Current executable set to '/tmp/test' (aarch64).
(lldb) b MAIN__
Breakpoint 1: where = test`MAIN__ + 12, address = 0x0000000000000920
(lldb) run
Process 1824608 launched: '/tmp/test' (aarch64)
Process 1824608 stopped
* thread #1, name = 'test', stop reason = breakpoint 1.1
    frame #0: 0x0000aaaaaaaaa920 test`MAIN__ at test.f90:2:26
   1    program hello
-> 2      print *, 'Hello, World!'
   3      print *, 'Hello, World!'
   4      print *, 'Hello, World!'
   5      print *, 'Hello, World!'
   6      print *, 'Hello, World!'
   7      print *, 'Hello, World!'
warning: This version of LLDB has no plugin for the language "fortran08". Inspection of frame variables will be limited.
(lldb) n
 Hello, World!
Process 1824608 stopped
* thread #1, name = 'test', stop reason = step over
    frame #0: 0x0000aaaaaaaaa96c test`MAIN__ at test.f90:3:26
   1    program hello
   2      print *, 'Hello, World!'
-> 3      print *, 'Hello, World!'
   4      print *, 'Hello, World!'
   5      print *, 'Hello, World!'
   6      print *, 'Hello, World!'
   7      print *, 'Hello, World!'

[DavidSpickett]

warning: This version of LLDB has no plugin for the language "fortran08". Inspection of frame variables will be limited.

Exactly what the consequences of this are, we'll have to investigate.

And note that although flang does produce debug information, at this time I understand that it is not complete. So gfortran is a better bet for lldb work for now.

[DavidSpickett]

I had to lookup what MAIN__ is from objdump, flang uses a different symbol "_QQmain". Perhaps we can grab this from some elf attribute instead.

Without a language plugin we assume it's main which in this case is just the setup function that calls the Fortran program's main.

$ ./bin/lldb /tmp/test -o "process launch --stop-at-user-entry"
<...>
Process 1824875 stopped
* thread #1, name = 'test', stop reason = one-shot breakpoint 1
    frame #0: 0x0000aaaaaaaaacc0 test`main at test.f90:14:17
<...>
-> 14   end program hello
(lldb) bt
* thread #1, name = 'test', stop reason = one-shot breakpoint 1
  * frame #0: 0x0000aaaaaaaaacc0 test`main at test.f90:14:17
    frame #1: 0x0000fffff7cb73fc libc.so.6`__libc_start_call_main<...>
    frame #2: 0x0000fffff7cb74cc libc.so.6`__libc_start_main_impl<...>
    frame #3: 0x0000aaaaaaaaa830 test`_start + 48
(lldb) dis
test`main:
->  0xaaaaaaaaacc0 <+0>:  stp    x29, x30, [sp, #-0x20]!
<...>
    0xaaaaaaaaace8 <+40>: bl     0xaaaaaaaaa7c0 ; symbol stub for: _gfortran_set_options
    0xaaaaaaaaacec <+44>: bl     0xaaaaaaaaa914 ; MAIN__     <<<<< Branch to actual main.
<...>
    0xaaaaaaaaacf8 <+56>: ret

This is one thing a language plugin could fix. See in GetUserEntryPointName in lldb/include/lldb/Target/Language.h.

[llvmbot]

@llvm/issue-subscribers-lldb

Author: David Spickett (DavidSpickett)

As prompted by https://discourse.llvm.org/t/flang-fortran-plugin-for-lldb-status/81301, this is a tracking issue for Fortran support. It existing doesn't mean work is being done or not, it's just a place to find the most recent status.

Currently lldb has no specific support for Fortran. All it knows is that there is such a language. We can still display source and line step though.

$ cat /tmp/test.f90
program hello
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
  print *, 'Hello, World!'
end program hello
$ gfortran /tmp/test.f90 -o /tmp/test -g

I had to lookup what MAIN__ is from objdump, flang uses a different symbol "_QQmain". Perhaps we can grab this from some elf attribute instead.

$ ./bin/lldb /tmp/test -o "b MAIN__" -o "run"
(lldb) target create "/tmp/test"
Current executable set to '/tmp/test' (aarch64).
(lldb) b MAIN__
Breakpoint 1: where = test`MAIN__ + 12, address = 0x0000000000000920
(lldb) run
Process 1824608 launched: '/tmp/test' (aarch64)
Process 1824608 stopped
* thread #<!-- -->1, name = 'test', stop reason = breakpoint 1.1
    frame #<!-- -->0: 0x0000aaaaaaaaa920 test`MAIN__ at test.f90:2:26
   1    program hello
-&gt; 2      print *, 'Hello, World!'
   3      print *, 'Hello, World!'
   4      print *, 'Hello, World!'
   5      print *, 'Hello, World!'
   6      print *, 'Hello, World!'
   7      print *, 'Hello, World!'
warning: This version of LLDB has no plugin for the language "fortran08". Inspection of frame variables will be limited.
(lldb) n
 Hello, World!
Process 1824608 stopped
* thread #<!-- -->1, name = 'test', stop reason = step over
    frame #<!-- -->0: 0x0000aaaaaaaaa96c test`MAIN__ at test.f90:3:26
   1    program hello
   2      print *, 'Hello, World!'
-&gt; 3      print *, 'Hello, World!'
   4      print *, 'Hello, World!'
   5      print *, 'Hello, World!'
   6      print *, 'Hello, World!'
   7      print *, 'Hello, World!'

[tschuett]

This is awesome stuff. I found:
https://spclgitlab.ethz.ch/open-climate-compiler/llvm-project/-/blob/52c0f55d615f74ce640ff7449c730089107a263e/lldb/www/adding-language-support.html
which is not in the current LLVM repository.

[DavidSpickett]

GDB's feature set is described here.

Biggest thing is case insensitivty. gfortran does include this DW_AT_identifier_case attribute but I reckon we can just assume case insensitivty if we see a fortran language tag.

0x0000000c: DW_TAG_compile_unit
              DW_AT_producer    ("GNU Fortran2008 11.4.0 <..>)
              DW_AT_language    (DW_LANG_Fortran08)
              DW_AT_identifier_case     (DW_ID_down_case)
              DW_AT_name        ("/tmp/test.f90")

I tried debugging the program in https://learnxinyminutes.com/docs/fortran/ using gdb. Main thing is a few new types:

(gdb) ptype str_b
type = character*30
(gdb) p str_b
$3 = 'qwerty keyboard', ' ' <repeats 15 times>
<...>
(gdb) p w
$17 = (0,1)
(gdb) ptype w
type = complex(kind=4)
<...>
(gdb) p array2d
$19 = ((-nan(0x7ff180), 9.18340949e-41, 2.73641686e-21) (-5.13387004e+19, -nan(0x7ff180), 9.18340949e-41))

These are desrcibed in the DWARF so I hope we can rely on the type it gives us for that. The "kind" is a compiler specific value, and GDB follows the gfortran mappings here. If we do need to know them, we could look at DW_AT_producer. The kind is included in the type name string already as well.

0x0000003b:     DW_TAG_variable
                  DW_AT_name    ("apple")
                  DW_AT_decl_file       ("/tmp/test.f90")
                  DW_AT_decl_line       (320)
                  DW_AT_decl_column     (17)
                  DW_AT_linkage_name    ("__fruit_MOD_apple")
                  DW_AT_type    (0x0000008a "real(kind=4)")

0x0000008a:   DW_TAG_base_type
                DW_AT_byte_size (0x04)
                DW_AT_encoding  (DW_ATE_float)
                DW_AT_name      ("real(kind=4)")

flang does not currently include the kind:

0x000008e3:   DW_TAG_base_type
                DW_AT_name      ("real")
                DW_AT_encoding  (DW_ATE_float)
                DW_AT_byte_size (0x10)

I did not find any marker in the object file to say "this is the start of the user's fortran code". The entry point is set to _start as you'd expect for a Linux binary:

$ readelf -e /tmp/test
ELF Header:
<...>
  Entry point address:               0xd40
<...>

0000000000000d40 <_start>:
     d40:       d503201f        nop

I did not see anything online that suggests GDB can find the address of MAIN__ automatically either. So process launch --stop-at-user-entry will have to look at DW_AT_producer and/or lookup in a list of known "fortran main" symbol names. This is also a problem I've seen with rust binaries.

Though the basic types can probably be crammed into a C type system, we will need to be able to compile fortran expressions for example a /= b (a not equal to b). The size of that work is unknown, TypeSystemClang is approaching 10k lines but we may be able to re-use a lot of it. For a first attempt we could ignore expressions, any that happen to be valid C may work.

Edit: apparently not (but maybe we could bodge this to use the C one)

(lldb) n
Process 1849877 stopped
* thread #1, name = 'test', stop reason = step over
    frame #0: 0x0000aaaaaaaaa8ac test`MAIN__ at test.f90:6:17
   3
   4        v = 1
   5        x = 2
-> 6        b = MOD(v, x)
   7
   8    end program example
(lldb) p v
error: Could not find type system for language fortran08: TypeSystem for language fortran08 doesn't exist

There are some intrinsics like KIND:

(gdb) p KIND(j)
$2 = 4

GDB doesn't implement all the fortran intrinsics, which makes me wonder if these are actual functions we can call from some runtime library, or need to re-implement with what we know from the debug information. KIND I assume the compiler could just insert a constant, MOD that would have to run at runtime is replaced by a library call:

program example
    real :: v, x 

    v = 1
    x = 2
    b = MOD(v, x)

end program example

$ objdump -d /tmp/test

/tmp/test:     file format elf64-littleaarch64


Disassembly of section .text:

0000000000000000 <MAIN__>:
<..>
  20:   94000000        bl      0 <fmodf>
<...>

Which comes from glibc:

$ readelf -s /lib/aarch64-linux-gnu/libgfortran.so.5 | grep -i mod
<...>
   169: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND fmodf@GLIBC_2.17 (11)

But assuming we are invoking flang as a library to compile expressions, this will be handled for us.

[DavidSpickett]

This is awesome stuff. I found:
https://spclgitlab.ethz.ch/open-climate-compiler/llvm-project/-/blob/52c0f55d615f74ce640ff7449c730089107a263e/lldb/www/adding-language-support.html
which is not in the current LLVM repository.

Nice! This got removed in e078c95 when we stopped having the website in the repo, must have been missed because it only had an html copy.

I'll see if it's worth bringing back.

[DavidSpickett]

Newer versions (I used 15.1 here) of GDB have an info main:

(gdb) info main
example

This is looking for the DW_AT_main_subprogram to be set on some subprogram. This is a DWARFv4 feature.

0x00000084:   DW_TAG_subprogram
                DW_AT_name      ("example")
                DW_AT_decl_file ("/tmp/test.f90")
                DW_AT_decl_line (1)
                DW_AT_decl_column       (15)
                DW_AT_main_subprogram   (true)
                DW_AT_calling_convention        (DW_CC_program)

We can use this to implement process launch --stop-at-user-entry.

[DavidSpickett]

Small addition to the finding main question, there is another attribute gdb might be looking for: #111350 (comment)