Fix gprof profiling to work with both PBP and PRX executables

  The profiling library was storing addresses that didn't match the ELF
  symbol table, causing psp-gprof to produce empty output.

  Changes:
  - Store ELF-compatible addresses in gmon.out instead of offset-based
  - Add PRX vs PBP detection using page alignment heuristic:
    - PRX: loaded at page-aligned addresses, linked at 0
    - PBP: loaded at specific link address (not page-aligned)
  - Calculate relocation offset for PRX to convert runtime addresses
    back to link-time addresses that match ELF symbols
  - Update __mcount() and timer_handler() to use link-time addresses

  The fix ensures psp-gprof can correctly match profiling data with
  ELF symbols for both standard executables (PBP) and relocatable
  modules (PRX).

tmp

Author: fjtrujy

src/prof/prof.c

@@ -81,6 +81,17 @@ static int initialized = 0;
 extern int _ftext;
 extern int _etext;
 
+/// _start is the entry point defined in both crt0.c and crt0_prx.c
+extern int _start;
+
+/// module_start is only defined in PRX startup code (crt0_prx.c) as an alias for _start
+/// Using weak reference allows us to detect PRX vs PBP at runtime
+/// We also verify module_start == _start to handle the case where a PBP defines its own module_start
+extern int module_start __attribute__((weak));
+
+/// relocation offset: runtime_address - link_address (for PRX)
+static unsigned int reloc_offset;
+
 /* forward declarations */
 __attribute__((__no_instrument_function__, __no_profile_instrument_function__))
 void __gprof_cleanup(void);
@@ -104,20 +115,44 @@ static void initialize()
         memset(&gp, '\0', sizeof(gp));
         gp.state = GMON_PROF_ON;
 
-        /* For PRX modules, the code is relocated at load time.
-           &_ftext and &_etext give us runtime (relocated) addresses.
-           Link-time addresses start at 0 for PSP executables.
-
-           Runtime:   &_ftext = relocated_base, &_etext = relocated_base + text_size
-           Link-time: _ftext = 0, _etext = text_size
-
-           So: lowpc_link = 0
-               highpc_link = &_etext - &_ftext (which equals text_size)
+        /* Detect PRX vs PBP using the module_start symbol.
+           In crt0_prx.c, module_start is defined as an alias for _start,
+           so they share the same address. We check both conditions:
+           1. module_start exists (not NULL)
+           2. module_start and _start are at the same address
+           This handles edge cases where a PBP defines its own module_start function.
+
+           For PRX (relocatable modules):
+           - Linked at address 0 (or small offset like 0x20 for C++)
+           - Relocated at load time to a PAGE-ALIGNED address (e.g., 0x08804000)
+           - reloc_offset = page-aligned load base
+           - link_addr = runtime_addr - reloc_offset
+
+           For PBP (standard executables):
+           - Linked at address 0x08804000 + offset (typically _ftext = 0x0880403c)
+           - Loaded at same address (no relocation)
+           - reloc_offset = 0
+           - link_addr = runtime_addr
         */
         gp.lowpc = (unsigned int)&_ftext;
         gp.highpc = (unsigned int)&_etext;
-        gp.lowpc_link = 0;
-        gp.highpc_link = (unsigned int)&_etext - (unsigned int)&_ftext;
+
+        unsigned int runtime_base = (unsigned int)&_ftext & 0x0FFFFFFF;
+
+        if (&module_start != NULL && (void *)&module_start == (void *)&_start) {
+                /* PRX: code was relocated from near-zero to runtime address.
+                   The load base is page-aligned, so we can compute it by masking
+                   off the page offset. The link-time _ftext is the page offset. */
+                unsigned int page_offset = runtime_base & 0xFFF;
+                reloc_offset = runtime_base - page_offset;  /* Page-aligned load base */
+                gp.lowpc_link = page_offset;                /* Link-time _ftext */
+                gp.highpc_link = (gp.highpc - gp.lowpc) + page_offset;
+        } else {
+                /* PBP: no relocation, addresses match ELF */
+                reloc_offset = 0;
+                gp.lowpc_link = runtime_base;
+                gp.highpc_link = (unsigned int)&_etext & 0x0FFFFFFF;
+        }
         gp.textsize = gp.highpc - gp.lowpc;
         gp.hashfraction = HISTFRACTION;
 
@@ -278,16 +313,17 @@ void __mcount(unsigned int frompc, unsigned int selfpc)
                 return;
         }
 
-        /* Mask upper bits and convert to link-time addresses.
-           Link-time addresses = runtime addresses - gp.lowpc (since lowpc_link = 0) */
-        frompc = (frompc & 0x0FFFFFFF) - gp.lowpc;
-        selfpc = (selfpc & 0x0FFFFFFF) - gp.lowpc;
+        /* Mask upper bits to normalize cached/uncached addresses,
+           then subtract relocation offset to get link-time addresses. */
+        frompc = (frompc & 0x0FFFFFFF) - reloc_offset;
+        selfpc = (selfpc & 0x0FFFFFFF) - reloc_offset;
 
-        /* Check if within text section (using link-time range) */
-        if (frompc <= gp.highpc_link)
+        /* Check if within text section (using link-time addresses) */
+        if (frompc >= gp.lowpc_link && frompc < gp.highpc_link)
         {
                 gp.pc = selfpc;
-                e = frompc / gp.hashfraction;
+                /* Arc index is based on offset within text section */
+                e = (frompc - gp.lowpc_link) / gp.hashfraction;
                 arc = gp.arcs + e;
                 arc->frompc = frompc;
                 arc->selfpc = selfpc;
@@ -300,14 +336,15 @@ void __mcount(unsigned int frompc, unsigned int selfpc)
 __attribute__((__no_instrument_function__, __no_profile_instrument_function__))
 static SceUInt timer_handler(SceUID uid, SceKernelSysClock *requested, SceKernelSysClock *actual, void *common)
 {
-        unsigned int frompc = gp.pc;  /* Already in link-time address */
+        unsigned int pc = gp.pc;  /* Already converted to link-time address by __mcount */
 
         if (gp.state == GMON_PROF_ON)
         {
-                /* Check if within text section (using link-time range) */
-                if (frompc <= gp.highpc_link)
+                /* Check if within text section (using link-time addresses) */
+                if (pc >= gp.lowpc_link && pc < gp.highpc_link)
                 {
-                        int e = frompc / gp.hashfraction;
+                        /* Sample index is based on offset within text section */
+                        int e = (pc - gp.lowpc_link) / gp.hashfraction;
                         gp.samples[e]++;
                 }
         }