Remove STAB info
authorBarret Rhoden <brho@cs.berkeley.edu>
Fri, 2 Nov 2018 01:50:50 +0000 (21:50 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Fri, 2 Nov 2018 01:51:48 +0000 (21:51 -0400)
This was old debugging information.  We haven't used it in years.  All
of our kernel PC-to-name lookups use the reflected symbol table.

Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
kern/arch/riscv/kdebug.c
kern/arch/riscv/kernel.ld
kern/arch/x86/kdebug.c
kern/arch/x86/kdebug.h
kern/arch/x86/kernel64.ld
kern/include/stab.h [deleted file]
kern/src/init.c
kern/src/monitor.c

index 2be24b5..fb196cb 100644 (file)
@@ -1,12 +1,9 @@
-#include <stab.h>
 #include <string.h>
 #include <assert.h>
 #include <kdebug.h>
 #include <pmap.h>
 #include <process.h>
 
-#include <ros/memlayout.h>
-
 /* Here's the old backtrace, remove it once gen_backtrace is done: */
 #if 0
 void backtrace(void)
index 521b058..2be5456 100644 (file)
@@ -20,27 +20,6 @@ SECTIONS
                *(.rodata .rodata.* .gnu.linkonce.r.*)
        }
 
-       /* Include debugging information in kernel memory */
-       .stab : {
-               PROVIDE(stab = .);
-               PROVIDE(__STAB_BEGIN__ = .);
-               *(.stab);
-               PROVIDE(estab = .);
-               PROVIDE(__STAB_END__ = .);
-               BYTE(0)         /* Force the linker to allocate space
-                                  for this section */
-       }
-
-       .stabstr : {
-               PROVIDE(stabstr = .);
-               PROVIDE(__STABSTR_BEGIN__ = .);
-               *(.stabstr);
-               PROVIDE(estabstr = .);
-               PROVIDE(__STABSTR_END__ = .);
-               BYTE(0)         /* Force the linker to allocate space
-                                  for this section */
-       }
-
        /* Adjust the address for the data segment to the next page */
        . = ALIGN(0x1000);
 
index c55a52c..64187e6 100644 (file)
@@ -1,4 +1,3 @@
-#include <stab.h>
 #include <string.h>
 #include <assert.h>
 #include <kdebug.h>
@@ -7,302 +6,6 @@
 #include <kmalloc.h>
 #include <arch/uaccess.h>
 
-#include <ros/memlayout.h>
-
-// Beginning of stabs table
-extern const stab_t __STAB_BEGIN__[];
-
-// End of stabs table
-extern const stab_t __STAB_END__[];
-
-// Beginning of string table
-extern const char __STABSTR_BEGIN__[];
-
- // End of string table
-extern const char __STABSTR_END__[];
-
-typedef struct UserStabData {
-       const stab_t *stabs;
-       const stab_t *stab_end;
-       const char *stabstr;
-       const char *stabstr_end;
-} user_stab_data_t;
-
-/* We used to check for a null terminating byte for the entire strings section
- * (due to JOS, I think), but that's not what the spec says: only that all
- * strings are null terminated.  There might be random stuff tacked on at the
- * end.  I had some stabs that seemed valid (lookups worked), that did not have
- * the entire table be null terminated.  Still, something else might be jacked
- * up.  If it turns out that's the case, put the checks in here. */
-static bool stab_table_valid(const char *stabstr, const char *stabstr_end)
-{
-       if (stabstr_end <= stabstr)
-               return FALSE;
-       return TRUE;
-}
-
-// stab_binsearch(stabs, region_left, region_right, type, addr)
-//
-//     Some stab types are arranged in increasing order by instruction
-//     address.  For example, N_FUN stabs (stab entries with n_type ==
-//     N_FUN), which mark functions, and N_SO stabs, which mark source files.
-//
-//     Given an instruction address, this function finds the single stab
-//     entry of type 'type' that contains that address.
-//
-//     The search takes place within the range [*region_left, *region_right].
-//     Thus, to search an entire set of N stabs, you might do:
-//
-//             left = 0;
-//             right = N - 1;     /* rightmost stab */
-//             stab_binsearch(stabs, &left, &right, type, addr);
-//
-//     The search modifies *region_left and *region_right to bracket the
-//     'addr'.  *region_left points to the matching stab that contains
-//     'addr', and *region_right points just before the next stab.  If
-//     *region_left > *region_right, then 'addr' is not contained in any
-//     matching stab.
-//
-//     For example, given these N_SO stabs:
-//             Index  Type   Address
-//             0      SO     f0100000
-//             13     SO     f0100040
-//             117    SO     f0100176
-//             118    SO     f0100178
-//             555    SO     f0100652
-//             556    SO     f0100654
-//             657    SO     f0100849
-//     this code:
-//             left = 0, right = 657;
-//             stab_binsearch(stabs, &left, &right, N_SO, 0xf0100184);
-//     will exit setting left = 118, right = 554.
-//
-static void
-stab_binsearch(const stab_t *stabs,
-               const stab_t *stab_end,
-               int *region_left, int *region_right,
-              int type, uintptr_t addr)
-{
-       int l = *region_left, r = *region_right, any_matches = 0;
-
-       while (l <= r) {
-               int true_m = (l + r) / 2, m = true_m;
-
-               // search for earliest stab with right type
-               while (m >= l && stabs[m].n_type != type)
-                       m--;
-               if (m < l) {    // no match in [l, m]
-                       l = true_m + 1;
-                       continue;
-               }
-
-               // actual binary search
-               any_matches = 1;
-               if (stabs[m].n_value < addr) {
-                       *region_left = m;
-                       l = true_m + 1;
-               } else if (stabs[m].n_value > addr) {
-                       *region_right = m - 1;
-                       r = m - 1;
-               } else {
-                       // exact match for 'addr', but continue loop to find
-                       // *region_right
-                       *region_left = m;
-                       l = m;
-                       addr++;
-               }
-       }
-
-       if (!any_matches)
-               *region_right = *region_left - 1;
-       else {
-               // find rightmost region containing 'addr'
-               for (l = *region_right;
-                    l > *region_left && stabs[l].n_type != type;
-                    l--)
-                       /* do nothing */;
-               *region_left = l;
-       }
-}
-
-
-// debuginfo_eip(addr, info)
-//
-//     Fill in the 'info' structure with information about the specified
-//     instruction address, 'addr'.  Returns 0 if information was found, and
-//     negative if not.  But even if it returns negative it has stored some
-//     information into '*info'.
-//
-int
-debuginfo_eip(uintptr_t addr, eipdebuginfo_t *info)
-{
-       const stab_t *stab_end;
-       const stab_t *stabs;
-       const char *stabstr_end;
-       const char *stabstr;
-       int lfile, rfile, lfun, rfun, lline, rline;
-
-       // Initialize *info
-       info->eip_file = "<unknown>";
-       info->eip_line = 0;
-       info->eip_fn_name = "<unknown>";
-       info->eip_fn_namelen = 9;
-       info->eip_fn_addr = addr;
-       info->eip_fn_narg = 0;
-
-       // Find the relevant set of stabs
-       if (addr >= ULIM) {
-               stab_end = __STAB_END__;
-               stabs = __STAB_BEGIN__;
-               stabstr_end = __STABSTR_END__;
-               stabstr = __STABSTR_BEGIN__;
-       } else {
-               /* TODO: short circuiting this, til our user space apps pack stab data
-                * the kernel knows about */
-               return -1;
-               #if 0
-               // The user-application linker script, user/user.ld,
-               // puts information about the application's stabs (equivalent
-               // to __STAB_BEGIN__, __STAB_END__, __STABSTR_BEGIN__, and
-               // __STABSTR_END__) in a structure located at virtual address
-               // USTABDATA.
-               const user_stab_data_t *usd = (const user_stab_data_t *)USTABDATA;
-
-               // Make sure this memory is valid.
-               // Return -1 if it is not.  Hint: Call user_mem_check.
-               // LAB 3: Your code here.
-
-               stab_end = usd->stab_end;
-               stabs = usd->stabs;
-               stabstr_end = usd->stabstr_end;
-               stabstr = usd->stabstr;
-
-               // Make sure the STABS and string table memory is valid.
-               // LAB 3: Your code here.
-               #endif
-       }
-
-       if (!stab_table_valid(stabstr, stabstr_end))
-               return -1;
-
-       // Now we find the right stabs that define the function containing
-       // 'eip'.  First, we find the basic source file containing 'eip'.
-       // Then, we look in that source file for the function.  Then we look
-       // for the line number.
-
-       // Search the entire set of stabs for the source file (type N_SO).
-       lfile = 0;
-       rfile = (stab_end - stabs) - 1;
-       stab_binsearch(stabs, stab_end, &lfile, &rfile, N_SO, addr);
-       if (lfile == 0)
-               return -1;
-
-       // Search within that file's stabs for the function definition
-       // (N_FUN).
-       lfun = lfile;
-       rfun = rfile;
-       stab_binsearch(stabs, stab_end, &lfun, &rfun, N_FUN, addr);
-
-       if (lfun <= rfun) {
-               // stabs[lfun] points to the function name
-               // in the string table, but check bounds just in case.
-               if (stabs[lfun].n_strx < stabstr_end - stabstr)
-                       info->eip_fn_name = stabstr + stabs[lfun].n_strx;
-               info->eip_fn_addr = stabs[lfun].n_value;
-               addr -= info->eip_fn_addr;
-               // Search within the function definition for the line number.
-               lline = lfun;
-               rline = rfun;
-       } else {
-               // Couldn't find function stab!  Maybe we're in an assembly
-               // file.  Search the whole file for the line number.
-               info->eip_fn_addr = addr;
-               lline = lfile;
-               rline = rfile;
-       }
-       // Ignore stuff after the colon.
-       info->eip_fn_namelen = strfind(info->eip_fn_name, ':') - info->eip_fn_name;
-
-       // Search within [lline, rline] for the line number stab.
-       // If found, set info->eip_line to the right line number.
-       // If not found, return -1.
-       //
-       // Hint:
-       //      There's a particular stabs type used for line numbers.
-       //      Look at the STABS documentation and <inc/stab.h> to find
-       //      which one.
-       // Your code here.
-
-       stab_binsearch(stabs, stab_end, &lline, &rline, N_SLINE, addr);
-       if (lline <= rline)
-               // stabs[lline] points to the line number
-               info->eip_line = stabs[lline].n_value;
-       else
-               return -1;
-
-       // Search backwards from the line number for the relevant filename
-       // stab.
-       // We can't just use the "lfile" stab because inlined functions
-       // can interpolate code from a different file!
-       // Such included source files use the N_SOL stab type.
-       while (lline >= lfile
-              && stabs[lline].n_type != N_SOL
-              && (stabs[lline].n_type != N_SO || !stabs[lline].n_value))
-               lline--;
-       if (lline >= lfile && stabs[lline].n_strx < stabstr_end - stabstr)
-               info->eip_file = stabstr + stabs[lline].n_strx;
-
-       // Set eip_fn_narg to the number of arguments taken by the function,
-       // or 0 if there was no containing function.
-       // Your code here.
-       info->eip_fn_narg = 0;
-       if (lfun <= rfun) {
-               lfun++;
-               while (stabs[lfun++].n_type == N_PSYM)
-                       info->eip_fn_narg++;
-       }
-
-       return 0;
-}
-
-/* Returns a function pointer for a function name matching the given string. */
-void *debug_get_fn_addr(char *fn_name)
-{
-       const struct stab *stab_end = __STAB_END__;
-       const struct stab *stabs = __STAB_BEGIN__;
-       const char *stabstr_end = __STABSTR_END__;
-       const char *stabstr = __STABSTR_BEGIN__;
-
-       static int first_fn_idx = 0;
-       int i = first_fn_idx;
-       int len;
-       const char *stab_fn_name = 0;
-       void *retval = 0;
-
-       if (!stab_table_valid(stabstr, stabstr_end))
-               return 0;
-
-       for (/* i set */; &stabs[i] < stab_end; i++) {
-               if (stabs[i].n_type != N_FUN)
-                       continue;
-               first_fn_idx = first_fn_idx ? first_fn_idx : i;
-               /* broken stab, just keep going */
-               if (!(stabs[i].n_strx < stabstr_end - stabstr))
-                       continue;
-               stab_fn_name = stabstr + stabs[i].n_strx;
-               len = strfind(stab_fn_name, ':') - stab_fn_name;
-               if (!len)
-                       continue;
-               /* we have a match. */
-               if (!strncmp(stab_fn_name, fn_name, len)) {
-                       printd("FN name: %s, Addr: %p\n", stab_fn_name, stabs[i].n_value);
-                       retval = (void*)stabs[i].n_value;
-                       break;
-               }
-       }
-       return retval;
-}
-
 void gen_backtrace(void (*pfunc)(void *, const char *), void *opaque)
 {
        uintptr_t pcs[MAX_BT_DEPTH];
index 187740f..370fefb 100644 (file)
@@ -9,23 +9,6 @@
 #include <ros/common.h>
 #include <arch/x86.h>
 
-#include <stdio.h>
-
-// Debug information about a particular instruction pointer
-typedef struct eipdebuginfo {
-       const char *eip_file;           // Source code filename for EIP
-       int eip_line;                           // Source code linenumber for EIP
-
-       const char *eip_fn_name;        // Name of function containing EIP
-                                                               //  - Note: not null terminated!
-       int eip_fn_namelen;                     // Length of function name
-       uintptr_t eip_fn_addr;          // Address of start of function
-       int eip_fn_narg;                        // Number of function arguments
-} eipdebuginfo_t;
-
-int debuginfo_eip(uintptr_t eip, eipdebuginfo_t *info);
-void *debug_get_fn_addr(char *fn_name);
-
 /* Returns a PC/EIP in the function that called us, preferably near the call
  * site.  Returns 0 when we can't jump back any farther. */
 static inline uintptr_t get_caller_pc(void)
index 402152e..c9224cc 100644 (file)
@@ -38,17 +38,6 @@ SECTIONS
                *(.rodata .rodata.* .gnu.linkonce.r.*)
        }
 
-       /* TODO: add some debug info.  i hear stabs are 32 bit only, so we'll need
-        * to bring in some dwarves.  for now, hack in the symbols to compile. */
-       .stab : {
-               PROVIDE(__STAB_BEGIN__ = .);
-               PROVIDE(__STAB_END__ = .);
-       }
-       .stabstr : {
-               PROVIDE(__STABSTR_BEGIN__ = .);
-               PROVIDE(__STABSTR_END__ = .);
-       }
-
        /* Adjust the address for the data segment to the next page */
        . = ALIGN(0x1000);
 
diff --git a/kern/include/stab.h b/kern/include/stab.h
deleted file mode 100644 (file)
index 12fcf43..0000000
+++ /dev/null
@@ -1,48 +0,0 @@
-#pragma once
-#include <ros/common.h>
-
-// <inc/stab.h>
-// STABS debugging info
-
-// The ROS kernel debugger can understand some debugging information
-// in the STABS format.  For more information on this format, see
-// http://sources.redhat.com/gdb/onlinedocs/stabs_toc.html
-
-// The constants below define some symbol types used by various debuggers
-// and compilers.  ROS uses the N_SO, N_SOL, N_FUN, and N_SLINE types.
-
-#define        N_GSYM          0x20    // global symbol
-#define        N_FNAME         0x22    // F77 function name
-#define        N_FUN           0x24    // procedure name
-#define        N_STSYM         0x26    // data segment variable
-#define        N_LCSYM         0x28    // bss segment variable
-#define        N_MAIN          0x2a    // main function name
-#define        N_PC            0x30    // global Pascal symbol
-#define        N_RSYM          0x40    // register variable
-#define        N_SLINE         0x44    // text segment line number
-#define        N_DSLINE        0x46    // data segment line number
-#define        N_BSLINE        0x48    // bss segment line number
-#define        N_SSYM          0x60    // structure/union element
-#define        N_SO            0x64    // main source file name
-#define        N_LSYM          0x80    // stack variable
-#define        N_BINCL         0x82    // include file beginning
-#define        N_SOL           0x84    // included source file name
-#define        N_PSYM          0xa0    // parameter variable
-#define        N_EINCL         0xa2    // include file end
-#define        N_ENTRY         0xa4    // alternate entry point
-#define        N_LBRAC         0xc0    // left bracket
-#define        N_EXCL          0xc2    // deleted include file
-#define        N_RBRAC         0xe0    // right bracket
-#define        N_BCOMM         0xe2    // begin common
-#define        N_ECOMM         0xe4    // end common
-#define        N_ECOML         0xe8    // end common (local name)
-#define        N_LENG          0xfe    // length of preceding entry
-
-// Entries in the STABS table are formatted as follows.
-typedef struct stab {
-       uint32_t n_strx;        // index into string table of name
-       uint8_t n_type;         // type of symbol
-       uint8_t n_other;        // misc info (usually empty)
-       uint16_t n_desc;        // description field
-       uintptr_t n_value;      // value of symbol
-} stab_t;
index 81c1c59..01aeb02 100644 (file)
@@ -8,7 +8,6 @@
 #include <arch/topology.h>
 #include <arch/console.h>
 #include <multiboot.h>
-#include <stab.h>
 #include <smp.h>
 
 #include <time.h>
index 34bc68c..7bc7eb2 100644 (file)
@@ -2,7 +2,6 @@
 // controlling the kernel and exploring the system interactively.
 
 #include <arch/arch.h>
-#include <stab.h>
 #include <smp.h>
 #include <arch/console.h>