diff -Naur linux-2.6.35.4/arch/x86/include/asm/i387.h linux-2.6.35.4-cs/arch/x86/include/asm/i387.h --- linux-2.6.35.4/arch/x86/include/asm/i387.h 2010-08-26 17:47:12.000000000 -0600 +++ linux-2.6.35.4-cs/arch/x86/include/asm/i387.h 2010-08-30 04:00:09.000000000 -0600 @@ -462,7 +462,11 @@ { if (fpu_allocated(fpu)) return 0; +#if defined(CONFIG_MDB) || defined(CONFIG_MDB_MODULE) + fpu->state = kmem_cache_alloc(task_xstate_cachep, GFP_DMA); +#else fpu->state = kmem_cache_alloc(task_xstate_cachep, GFP_KERNEL); +#endif if (!fpu->state) return -ENOMEM; WARN_ON((unsigned long)fpu->state & 15); diff -Naur linux-2.6.35.4/arch/x86/kernel/apic/io_apic.c linux-2.6.35.4-cs/arch/x86/kernel/apic/io_apic.c --- linux-2.6.35.4/arch/x86/kernel/apic/io_apic.c 2010-08-26 17:47:12.000000000 -0600 +++ linux-2.6.35.4-cs/arch/x86/kernel/apic/io_apic.c 2010-08-30 04:00:09.000000000 -0600 @@ -86,6 +86,8 @@ struct mpc_ioapic mp_ioapics[MAX_IO_APICS]; int nr_ioapics; +EXPORT_SYMBOL(nr_ioapics); + /* IO APIC gsi routing info */ struct mp_ioapic_gsi mp_gsi_routing[MAX_IO_APICS]; @@ -362,12 +364,13 @@ writel(vector, &io_apic->eoi); } -static inline unsigned int io_apic_read(unsigned int apic, unsigned int reg) +unsigned int io_apic_read(unsigned int apic, unsigned int reg) { struct io_apic __iomem *io_apic = io_apic_base(apic); writel(reg, &io_apic->index); return readl(&io_apic->data); } +EXPORT_SYMBOL(io_apic_read); static inline void io_apic_write(unsigned int apic, unsigned int reg, unsigned int value) { diff -Naur linux-2.6.35.4/arch/x86/kernel/dumpstack_64.c linux-2.6.35.4-cs/arch/x86/kernel/dumpstack_64.c --- linux-2.6.35.4/arch/x86/kernel/dumpstack_64.c 2010-08-26 17:47:12.000000000 -0600 +++ linux-2.6.35.4-cs/arch/x86/kernel/dumpstack_64.c 2010-08-30 04:00:09.000000000 -0600 @@ -33,8 +33,14 @@ #endif }; + +#if defined(CONFIG_MDB) || defined(CONFIG_MDB_MODULE) +unsigned long *in_exception_stack(unsigned cpu, unsigned long stack, + unsigned *usedp, char **idp) +#else static unsigned long *in_exception_stack(unsigned cpu, unsigned long stack, unsigned *usedp, char **idp) +#endif { unsigned k; @@ -140,6 +146,16 @@ * severe exception (double fault, nmi, stack fault, debug, mce) hardware stack */ +#if defined(CONFIG_MDB) || defined(CONFIG_MDB_MODULE) +unsigned long *get_irq_stack_end(const unsigned cpu) +{ + return (unsigned long *)per_cpu(irq_stack_ptr, cpu); +} + +EXPORT_SYMBOL(get_irq_stack_end); +EXPORT_SYMBOL(in_exception_stack); +#endif + void dump_trace(struct task_struct *task, struct pt_regs *regs, unsigned long *stack, unsigned long bp, const struct stacktrace_ops *ops, void *data) diff -Naur linux-2.6.35.4/arch/x86/kernel/hw_breakpoint.c linux-2.6.35.4-cs/arch/x86/kernel/hw_breakpoint.c --- linux-2.6.35.4/arch/x86/kernel/hw_breakpoint.c 2010-08-26 17:47:12.000000000 -0600 +++ linux-2.6.35.4-cs/arch/x86/kernel/hw_breakpoint.c 2010-08-30 04:00:09.000000000 -0600 @@ -410,6 +410,12 @@ * NOTIFY_STOP returned for all other cases * */ + +#if defined(CONFIG_MDB) || defined(CONFIG_MDB_MODULE) +int disable_hw_bp_interface = 0; +EXPORT_SYMBOL(disable_hw_bp_interface); +#endif + static int __kprobes hw_breakpoint_handler(struct die_args *args) { int i, cpu, rc = NOTIFY_STOP; @@ -425,6 +431,12 @@ if ((dr6 & DR_TRAP_BITS) == 0) return NOTIFY_DONE; + // if MDB is loaded turn off +#if defined(CONFIG_MDB) || defined(CONFIG_MDB_MODULE) + if (disable_hw_bp_interface) + return NOTIFY_DONE; +#endif + get_debugreg(dr7, 7); /* Disable breakpoints during exception handling */ set_debugreg(0UL, 7); diff -Naur linux-2.6.35.4/arch/x86/kernel/reboot.c linux-2.6.35.4-cs/arch/x86/kernel/reboot.c --- linux-2.6.35.4/arch/x86/kernel/reboot.c 2010-08-26 17:47:12.000000000 -0600 +++ linux-2.6.35.4-cs/arch/x86/kernel/reboot.c 2010-08-30 04:00:09.000000000 -0600 @@ -502,6 +502,7 @@ { cpu_emergency_vmxoff(); } +EXPORT_SYMBOL_GPL(machine_emergency_restart); /* Use NMIs as IPIs to tell all CPUs to disable virtualization */ diff -Naur linux-2.6.35.4/Documentation/sysrq.txt linux-2.6.35.4-cs/Documentation/sysrq.txt --- linux-2.6.35.4/Documentation/sysrq.txt 2010-08-26 17:47:12.000000000 -0600 +++ linux-2.6.35.4-cs/Documentation/sysrq.txt 2010-08-30 04:00:09.000000000 -0600 @@ -63,6 +63,8 @@ * What are the 'command' keys? ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +'a' - Used by Jeff Merkey's Kernel Debugger (mdb). + 'b' - Will immediately reboot the system without syncing or unmounting your disks. diff -Naur linux-2.6.35.4/drivers/char/vt.c linux-2.6.35.4-cs/drivers/char/vt.c --- linux-2.6.35.4/drivers/char/vt.c 2010-08-26 17:47:12.000000000 -0600 +++ linux-2.6.35.4-cs/drivers/char/vt.c 2010-08-30 04:00:09.000000000 -0600 @@ -2461,6 +2461,7 @@ else return kmsg_con; } +EXPORT_SYMBOL(vt_kmsg_redirect); /* * Console on virtual terminal diff -Naur linux-2.6.35.4/include/linux/console.h linux-2.6.35.4-cs/include/linux/console.h --- linux-2.6.35.4/include/linux/console.h 2010-08-26 17:47:12.000000000 -0600 +++ linux-2.6.35.4-cs/include/linux/console.h 2010-08-30 04:00:09.000000000 -0600 @@ -141,11 +141,15 @@ void vcs_remove_sysfs(int index); /* Some debug stub to catch some of the obvious races in the VT code */ +#if defined(CONFIG_MDB) || defined(CONFIG_MDB_MODULE) +#define WARN_CONSOLE_UNLOCKED() +#else #if 1 #define WARN_CONSOLE_UNLOCKED() WARN_ON(!is_console_locked() && !oops_in_progress) #else #define WARN_CONSOLE_UNLOCKED() #endif +#endif /* VESA Blanking Levels */ #define VESA_NO_BLANKING 0 diff -Naur linux-2.6.35.4/kernel/debug/Makefile linux-2.6.35.4-cs/kernel/debug/Makefile --- linux-2.6.35.4/kernel/debug/Makefile 2010-08-26 17:47:12.000000000 -0600 +++ linux-2.6.35.4-cs/kernel/debug/Makefile 2010-08-30 04:00:09.000000000 -0600 @@ -1,6 +1,7 @@ # -# Makefile for the linux kernel debugger +# Makefile for the linux kernel debugger(s) # -obj-$(CONFIG_KGDB) += debug_core.o gdbstub.o +obj-$(CONFIG_KGDB) += debug_core.o gdbstub.o obj-$(CONFIG_KGDB_KDB) += kdb/ +obj-$(CONFIG_MDB) += mdb/ diff -Naur linux-2.6.35.4/kernel/debug/mdb/ansidecl_32.h linux-2.6.35.4-cs/kernel/debug/mdb/ansidecl_32.h --- linux-2.6.35.4/kernel/debug/mdb/ansidecl_32.h 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/ansidecl_32.h 2010-08-30 04:00:09.000000000 -0600 @@ -0,0 +1,383 @@ +/* ANSI and traditional C compatability macros + Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001 + Free Software Foundation, Inc. + This file is part of the GNU C Library. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ + +/* Extracted from binutils 2.16.91.0.2 (OpenSUSE 10.0) and modified for kdb use. + * Any trailing whitespace was removed and #ifdef/ifndef __KERNEL__ added as + * required. + * Keith Owens 15 May 2006 + */ + +/* ANSI and traditional C compatibility macros + + ANSI C is assumed if __STDC__ is #defined. + + Macro ANSI C definition Traditional C definition + ----- ---- - ---------- ----------- - ---------- + ANSI_PROTOTYPES 1 not defined + PTR `void *' `char *' + PTRCONST `void *const' `char *' + LONG_DOUBLE `long double' `double' + const not defined `' + volatile not defined `' + signed not defined `' + VA_START(ap, var) va_start(ap, var) va_start(ap) + + Note that it is safe to write "void foo();" indicating a function + with no return value, in all K+R compilers we have been able to test. + + For declaring functions with prototypes, we also provide these: + + PARAMS ((prototype)) + -- for functions which take a fixed number of arguments. Use this + when declaring the function. When defining the function, write a + K+R style argument list. For example: + + char *strcpy PARAMS ((char *dest, char *source)); + ... + char * + strcpy (dest, source) + char *dest; + char *source; + { ... } + + + VPARAMS ((prototype, ...)) + -- for functions which take a variable number of arguments. Use + PARAMS to declare the function, VPARAMS to define it. For example: + + int printf PARAMS ((const char *format, ...)); + ... + int + printf VPARAMS ((const char *format, ...)) + { + ... + } + + For writing functions which take variable numbers of arguments, we + also provide the VA_OPEN, VA_CLOSE, and VA_FIXEDARG macros. These + hide the differences between K+R and C89 more + thoroughly than the simple VA_START() macro mentioned above. + + VA_OPEN and VA_CLOSE are used *instead of* va_start and va_end. + Immediately after VA_OPEN, put a sequence of VA_FIXEDARG calls + corresponding to the list of fixed arguments. Then use va_arg + normally to get the variable arguments, or pass your va_list object + around. You do not declare the va_list yourself; VA_OPEN does it + for you. + + Here is a complete example: + + int + printf VPARAMS ((const char *format, ...)) + { + int result; + + VA_OPEN (ap, format); + VA_FIXEDARG (ap, const char *, format); + + result = vfprintf (stdout, format, ap); + VA_CLOSE (ap); + + return result; + } + + + You can declare variables either before or after the VA_OPEN, + VA_FIXEDARG sequence. Also, VA_OPEN and VA_CLOSE are the beginning + and end of a block. They must appear at the same nesting level, + and any variables declared after VA_OPEN go out of scope at + VA_CLOSE. Unfortunately, with a K+R compiler, that includes the + argument list. You can have multiple instances of VA_OPEN/VA_CLOSE + pairs in a single function in case you need to traverse the + argument list more than once. + + For ease of writing code which uses GCC extensions but needs to be + portable to other compilers, we provide the GCC_VERSION macro that + simplifies testing __GNUC__ and __GNUC_MINOR__ together, and various + wrappers around __attribute__. Also, __extension__ will be #defined + to nothing if it doesn't work. See below. + + This header also defines a lot of obsolete macros: + CONST, VOLATILE, SIGNED, PROTO, EXFUN, DEFUN, DEFUN_VOID, + AND, DOTS, NOARGS. Don't use them. */ + +#ifndef _ANSIDECL_H +#define _ANSIDECL_H 1 + +/* Every source file includes this file, + so they will all get the switch for lint. */ +/* LINTLIBRARY */ + +/* Using MACRO(x,y) in cpp #if conditionals does not work with some + older preprocessors. Thus we can't define something like this: + +#define HAVE_GCC_VERSION(MAJOR, MINOR) \ + (__GNUC__ > (MAJOR) || (__GNUC__ == (MAJOR) && __GNUC_MINOR__ >= (MINOR))) + +and then test "#if HAVE_GCC_VERSION(2,7)". + +So instead we use the macro below and test it against specific values. */ + +/* This macro simplifies testing whether we are using gcc, and if it + is of a particular minimum version. (Both major & minor numbers are + significant.) This macro will evaluate to 0 if we are not using + gcc at all. */ +#ifndef GCC_VERSION +#define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__) +#endif /* GCC_VERSION */ + +#if defined (__STDC__) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(_WIN32) || (defined(__alpha) && defined(__cplusplus)) +/* All known AIX compilers implement these things (but don't always + define __STDC__). The RISC/OS MIPS compiler defines these things + in SVR4 mode, but does not define __STDC__. */ +/* eraxxon@alumni.rice.edu: The Compaq C++ compiler, unlike many other + C++ compilers, does not define __STDC__, though it acts as if this + was so. (Verified versions: 5.7, 6.2, 6.3, 6.5) */ + +#define ANSI_PROTOTYPES 1 +#define PTR void * +#define PTRCONST void *const +#define LONG_DOUBLE long double + +/* PARAMS is often defined elsewhere (e.g. by libintl.h), so wrap it in + a #ifndef. */ +//#ifndef PARAMS +//#define PARAMS(ARGS) ARGS +//#endif + +#define VPARAMS(ARGS) ARGS +#define VA_START(VA_LIST, VAR) va_start(VA_LIST, VAR) + +/* variadic function helper macros */ +/* "struct Qdmy" swallows the semicolon after VA_OPEN/VA_FIXEDARG's + use without inhibiting further decls and without declaring an + actual variable. */ +#define VA_OPEN(AP, VAR) { va_list AP; va_start(AP, VAR); { struct Qdmy +#define VA_CLOSE(AP) } va_end(AP); } +#define VA_FIXEDARG(AP, T, N) struct Qdmy + +#undef const +#undef volatile +#undef signed + +#ifdef __KERNEL__ +#ifndef __STDC_VERSION__ +#define __STDC_VERSION__ 0 +#endif +#endif /* __KERNEL__ */ + +/* inline requires special treatment; it's in C99, and GCC >=2.7 supports + it too, but it's not in C89. */ +#undef inline +#if __STDC_VERSION__ > 199901L +/* it's a keyword */ +#else +# if GCC_VERSION >= 2007 +# define inline __inline__ /* __inline__ prevents -pedantic warnings */ +# else +# define inline /* nothing */ +# endif +#endif + +/* These are obsolete. Do not use. */ +#ifndef IN_GCC +#define CONST const +#define VOLATILE volatile +#define SIGNED signed + +#define PROTO(type, name, arglist) type name arglist +#define EXFUN(name, proto) name proto +#define DEFUN(name, arglist, args) name(args) +#define DEFUN_VOID(name) name(void) +#define AND , +#define DOTS , ... +#define NOARGS void +#endif /* ! IN_GCC */ + +#else /* Not ANSI C. */ + +#undef ANSI_PROTOTYPES +#define PTR char * +#define PTRCONST PTR +#define LONG_DOUBLE double + +//#define PARAMS(args) () +#define VPARAMS(args) (va_alist) va_dcl +#define VA_START(va_list, var) va_start(va_list) + +#define VA_OPEN(AP, VAR) { va_list AP; va_start(AP); { struct Qdmy +#define VA_CLOSE(AP) } va_end(AP); } +#define VA_FIXEDARG(AP, TYPE, NAME) TYPE NAME = va_arg(AP, TYPE) + +/* some systems define these in header files for non-ansi mode */ +#undef const +#undef volatile +#undef signed +#undef inline +#define const +#define volatile +#define signed +#define inline + +#ifndef IN_GCC +#define CONST +#define VOLATILE +#define SIGNED + +#define PROTO(type, name, arglist) type name () +#define EXFUN(name, proto) name() +#define DEFUN(name, arglist, args) name arglist args; +#define DEFUN_VOID(name) name() +#define AND ; +#define DOTS +#define NOARGS +#endif /* ! IN_GCC */ + +#endif /* ANSI C. */ + +/* Define macros for some gcc attributes. This permits us to use the + macros freely, and know that they will come into play for the + version of gcc in which they are supported. */ + +#if (GCC_VERSION < 2007) +# define __attribute__(x) +#endif + +/* Attribute __malloc__ on functions was valid as of gcc 2.96. */ +#ifndef ATTRIBUTE_MALLOC +# if (GCC_VERSION >= 2096) +# define ATTRIBUTE_MALLOC __attribute__ ((__malloc__)) +# else +# define ATTRIBUTE_MALLOC +# endif /* GNUC >= 2.96 */ +#endif /* ATTRIBUTE_MALLOC */ + +/* Attributes on labels were valid as of gcc 2.93. */ +#ifndef ATTRIBUTE_UNUSED_LABEL +# if (!defined (__cplusplus) && GCC_VERSION >= 2093) +# define ATTRIBUTE_UNUSED_LABEL ATTRIBUTE_UNUSED +# else +# define ATTRIBUTE_UNUSED_LABEL +# endif /* !__cplusplus && GNUC >= 2.93 */ +#endif /* ATTRIBUTE_UNUSED_LABEL */ + +#ifndef ATTRIBUTE_UNUSED +#define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) +#endif /* ATTRIBUTE_UNUSED */ + +/* Before GCC 3.4, the C++ frontend couldn't parse attributes placed after the + identifier name. */ +#if ! defined(__cplusplus) || (GCC_VERSION >= 3004) +# define ARG_UNUSED(NAME) NAME ATTRIBUTE_UNUSED +#else /* !__cplusplus || GNUC >= 3.4 */ +# define ARG_UNUSED(NAME) NAME +#endif /* !__cplusplus || GNUC >= 3.4 */ + +#ifndef ATTRIBUTE_NORETURN +#define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__)) +#endif /* ATTRIBUTE_NORETURN */ + +/* Attribute `nonnull' was valid as of gcc 3.3. */ +#ifndef ATTRIBUTE_NONNULL +# if (GCC_VERSION >= 3003) +# define ATTRIBUTE_NONNULL(m) __attribute__ ((__nonnull__ (m))) +# else +# define ATTRIBUTE_NONNULL(m) +# endif /* GNUC >= 3.3 */ +#endif /* ATTRIBUTE_NONNULL */ + +/* Attribute `pure' was valid as of gcc 3.0. */ +#ifndef ATTRIBUTE_PURE +# if (GCC_VERSION >= 3000) +# define ATTRIBUTE_PURE __attribute__ ((__pure__)) +# else +# define ATTRIBUTE_PURE +# endif /* GNUC >= 3.0 */ +#endif /* ATTRIBUTE_PURE */ + +/* Use ATTRIBUTE_PRINTF when the format specifier must not be NULL. + This was the case for the `printf' format attribute by itself + before GCC 3.3, but as of 3.3 we need to add the `nonnull' + attribute to retain this behavior. */ +#ifndef ATTRIBUTE_PRINTF +#define ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n))) ATTRIBUTE_NONNULL(m) +#define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2) +#define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3) +#define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4) +#define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5) +#define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6) +#endif /* ATTRIBUTE_PRINTF */ + +/* Use ATTRIBUTE_FPTR_PRINTF when the format attribute is to be set on + a function pointer. Format attributes were allowed on function + pointers as of gcc 3.1. */ +#ifndef ATTRIBUTE_FPTR_PRINTF +# if (GCC_VERSION >= 3001) +# define ATTRIBUTE_FPTR_PRINTF(m, n) ATTRIBUTE_PRINTF(m, n) +# else +# define ATTRIBUTE_FPTR_PRINTF(m, n) +# endif /* GNUC >= 3.1 */ +# define ATTRIBUTE_FPTR_PRINTF_1 ATTRIBUTE_FPTR_PRINTF(1, 2) +# define ATTRIBUTE_FPTR_PRINTF_2 ATTRIBUTE_FPTR_PRINTF(2, 3) +# define ATTRIBUTE_FPTR_PRINTF_3 ATTRIBUTE_FPTR_PRINTF(3, 4) +# define ATTRIBUTE_FPTR_PRINTF_4 ATTRIBUTE_FPTR_PRINTF(4, 5) +# define ATTRIBUTE_FPTR_PRINTF_5 ATTRIBUTE_FPTR_PRINTF(5, 6) +#endif /* ATTRIBUTE_FPTR_PRINTF */ + +/* Use ATTRIBUTE_NULL_PRINTF when the format specifier may be NULL. A + NULL format specifier was allowed as of gcc 3.3. */ +#ifndef ATTRIBUTE_NULL_PRINTF +# if (GCC_VERSION >= 3003) +# define ATTRIBUTE_NULL_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n))) +# else +# define ATTRIBUTE_NULL_PRINTF(m, n) +# endif /* GNUC >= 3.3 */ +# define ATTRIBUTE_NULL_PRINTF_1 ATTRIBUTE_NULL_PRINTF(1, 2) +# define ATTRIBUTE_NULL_PRINTF_2 ATTRIBUTE_NULL_PRINTF(2, 3) +# define ATTRIBUTE_NULL_PRINTF_3 ATTRIBUTE_NULL_PRINTF(3, 4) +# define ATTRIBUTE_NULL_PRINTF_4 ATTRIBUTE_NULL_PRINTF(4, 5) +# define ATTRIBUTE_NULL_PRINTF_5 ATTRIBUTE_NULL_PRINTF(5, 6) +#endif /* ATTRIBUTE_NULL_PRINTF */ + +/* Attribute `sentinel' was valid as of gcc 3.5. */ +#ifndef ATTRIBUTE_SENTINEL +# if (GCC_VERSION >= 3005) +# define ATTRIBUTE_SENTINEL __attribute__ ((__sentinel__)) +# else +# define ATTRIBUTE_SENTINEL +# endif /* GNUC >= 3.5 */ +#endif /* ATTRIBUTE_SENTINEL */ + + +#ifndef ATTRIBUTE_ALIGNED_ALIGNOF +# if (GCC_VERSION >= 3000) +# define ATTRIBUTE_ALIGNED_ALIGNOF(m) __attribute__ ((__aligned__ (__alignof__ (m)))) +# else +# define ATTRIBUTE_ALIGNED_ALIGNOF(m) +# endif /* GNUC >= 3.0 */ +#endif /* ATTRIBUTE_ALIGNED_ALIGNOF */ + +/* We use __extension__ in some places to suppress -pedantic warnings + about GCC extensions. This feature didn't work properly before + gcc 2.8. */ +#if GCC_VERSION < 2008 +#define __extension__ +#endif + +#endif /* ansidecl.h */ diff -Naur linux-2.6.35.4/kernel/debug/mdb/ansidecl_64.h linux-2.6.35.4-cs/kernel/debug/mdb/ansidecl_64.h --- linux-2.6.35.4/kernel/debug/mdb/ansidecl_64.h 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/ansidecl_64.h 2010-08-30 04:00:09.000000000 -0600 @@ -0,0 +1,383 @@ +/* ANSI and traditional C compatability macros + Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001 + Free Software Foundation, Inc. + This file is part of the GNU C Library. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ + +/* Extracted from binutils 2.16.91.0.2 (OpenSUSE 10.0) and modified for kdb use. + * Any trailing whitespace was removed and #ifdef/ifndef __KERNEL__ added as + * required. + * Keith Owens 15 May 2006 + */ + +/* ANSI and traditional C compatibility macros + + ANSI C is assumed if __STDC__ is #defined. + + Macro ANSI C definition Traditional C definition + ----- ---- - ---------- ----------- - ---------- + ANSI_PROTOTYPES 1 not defined + PTR `void *' `char *' + PTRCONST `void *const' `char *' + LONG_DOUBLE `long double' `double' + const not defined `' + volatile not defined `' + signed not defined `' + VA_START(ap, var) va_start(ap, var) va_start(ap) + + Note that it is safe to write "void foo();" indicating a function + with no return value, in all K+R compilers we have been able to test. + + For declaring functions with prototypes, we also provide these: + + PARAMS ((prototype)) + -- for functions which take a fixed number of arguments. Use this + when declaring the function. When defining the function, write a + K+R style argument list. For example: + + char *strcpy PARAMS ((char *dest, char *source)); + ... + char * + strcpy (dest, source) + char *dest; + char *source; + { ... } + + + VPARAMS ((prototype, ...)) + -- for functions which take a variable number of arguments. Use + PARAMS to declare the function, VPARAMS to define it. For example: + + int printf PARAMS ((const char *format, ...)); + ... + int + printf VPARAMS ((const char *format, ...)) + { + ... + } + + For writing functions which take variable numbers of arguments, we + also provide the VA_OPEN, VA_CLOSE, and VA_FIXEDARG macros. These + hide the differences between K+R and C89 more + thoroughly than the simple VA_START() macro mentioned above. + + VA_OPEN and VA_CLOSE are used *instead of* va_start and va_end. + Immediately after VA_OPEN, put a sequence of VA_FIXEDARG calls + corresponding to the list of fixed arguments. Then use va_arg + normally to get the variable arguments, or pass your va_list object + around. You do not declare the va_list yourself; VA_OPEN does it + for you. + + Here is a complete example: + + int + printf VPARAMS ((const char *format, ...)) + { + int result; + + VA_OPEN (ap, format); + VA_FIXEDARG (ap, const char *, format); + + result = vfprintf (stdout, format, ap); + VA_CLOSE (ap); + + return result; + } + + + You can declare variables either before or after the VA_OPEN, + VA_FIXEDARG sequence. Also, VA_OPEN and VA_CLOSE are the beginning + and end of a block. They must appear at the same nesting level, + and any variables declared after VA_OPEN go out of scope at + VA_CLOSE. Unfortunately, with a K+R compiler, that includes the + argument list. You can have multiple instances of VA_OPEN/VA_CLOSE + pairs in a single function in case you need to traverse the + argument list more than once. + + For ease of writing code which uses GCC extensions but needs to be + portable to other compilers, we provide the GCC_VERSION macro that + simplifies testing __GNUC__ and __GNUC_MINOR__ together, and various + wrappers around __attribute__. Also, __extension__ will be #defined + to nothing if it doesn't work. See below. + + This header also defines a lot of obsolete macros: + CONST, VOLATILE, SIGNED, PROTO, EXFUN, DEFUN, DEFUN_VOID, + AND, DOTS, NOARGS. Don't use them. */ + +#ifndef _ANSIDECL_H +#define _ANSIDECL_H 1 + +/* Every source file includes this file, + so they will all get the switch for lint. */ +/* LINTLIBRARY */ + +/* Using MACRO(x,y) in cpp #if conditionals does not work with some + older preprocessors. Thus we can't define something like this: + +#define HAVE_GCC_VERSION(MAJOR, MINOR) \ + (__GNUC__ > (MAJOR) || (__GNUC__ == (MAJOR) && __GNUC_MINOR__ >= (MINOR))) + +and then test "#if HAVE_GCC_VERSION(2,7)". + +So instead we use the macro below and test it against specific values. */ + +/* This macro simplifies testing whether we are using gcc, and if it + is of a particular minimum version. (Both major & minor numbers are + significant.) This macro will evaluate to 0 if we are not using + gcc at all. */ +#ifndef GCC_VERSION +#define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__) +#endif /* GCC_VERSION */ + +#if defined (__STDC__) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(_WIN32) || (defined(__alpha) && defined(__cplusplus)) +/* All known AIX compilers implement these things (but don't always + define __STDC__). The RISC/OS MIPS compiler defines these things + in SVR4 mode, but does not define __STDC__. */ +/* eraxxon@alumni.rice.edu: The Compaq C++ compiler, unlike many other + C++ compilers, does not define __STDC__, though it acts as if this + was so. (Verified versions: 5.7, 6.2, 6.3, 6.5) */ + +#define ANSI_PROTOTYPES 1 +#define PTR void * +#define PTRCONST void *const +#define LONG_DOUBLE long double + +/* PARAMS is often defined elsewhere (e.g. by libintl.h), so wrap it in + a #ifndef. */ +//#ifndef PARAMS +//#define PARAMS(ARGS) ARGS +//#endif + +#define VPARAMS(ARGS) ARGS +#define VA_START(VA_LIST, VAR) va_start(VA_LIST, VAR) + +/* variadic function helper macros */ +/* "struct Qdmy" swallows the semicolon after VA_OPEN/VA_FIXEDARG's + use without inhibiting further decls and without declaring an + actual variable. */ +#define VA_OPEN(AP, VAR) { va_list AP; va_start(AP, VAR); { struct Qdmy +#define VA_CLOSE(AP) } va_end(AP); } +#define VA_FIXEDARG(AP, T, N) struct Qdmy + +#undef const +#undef volatile +#undef signed + +#ifdef __KERNEL__ +#ifndef __STDC_VERSION__ +#define __STDC_VERSION__ 0 +#endif +#endif /* __KERNEL__ */ + +/* inline requires special treatment; it's in C99, and GCC >=2.7 supports + it too, but it's not in C89. */ +#undef inline +#if __STDC_VERSION__ > 199901L +/* it's a keyword */ +#else +# if GCC_VERSION >= 2007 +# define inline __inline__ /* __inline__ prevents -pedantic warnings */ +# else +# define inline /* nothing */ +# endif +#endif + +/* These are obsolete. Do not use. */ +#ifndef IN_GCC +#define CONST const +#define VOLATILE volatile +#define SIGNED signed + +#define PROTO(type, name, arglist) type name arglist +#define EXFUN(name, proto) name proto +#define DEFUN(name, arglist, args) name(args) +#define DEFUN_VOID(name) name(void) +#define AND , +#define DOTS , ... +#define NOARGS void +#endif /* ! IN_GCC */ + +#else /* Not ANSI C. */ + +#undef ANSI_PROTOTYPES +#define PTR char * +#define PTRCONST PTR +#define LONG_DOUBLE double + +//#define PARAMS(args) () +#define VPARAMS(args) (va_alist) va_dcl +#define VA_START(va_list, var) va_start(va_list) + +#define VA_OPEN(AP, VAR) { va_list AP; va_start(AP); { struct Qdmy +#define VA_CLOSE(AP) } va_end(AP); } +#define VA_FIXEDARG(AP, TYPE, NAME) TYPE NAME = va_arg(AP, TYPE) + +/* some systems define these in header files for non-ansi mode */ +#undef const +#undef volatile +#undef signed +#undef inline +#define const +#define volatile +#define signed +#define inline + +#ifndef IN_GCC +#define CONST +#define VOLATILE +#define SIGNED + +#define PROTO(type, name, arglist) type name () +#define EXFUN(name, proto) name() +#define DEFUN(name, arglist, args) name arglist args; +#define DEFUN_VOID(name) name() +#define AND ; +#define DOTS +#define NOARGS +#endif /* ! IN_GCC */ + +#endif /* ANSI C. */ + +/* Define macros for some gcc attributes. This permits us to use the + macros freely, and know that they will come into play for the + version of gcc in which they are supported. */ + +#if (GCC_VERSION < 2007) +# define __attribute__(x) +#endif + +/* Attribute __malloc__ on functions was valid as of gcc 2.96. */ +#ifndef ATTRIBUTE_MALLOC +# if (GCC_VERSION >= 2096) +# define ATTRIBUTE_MALLOC __attribute__ ((__malloc__)) +# else +# define ATTRIBUTE_MALLOC +# endif /* GNUC >= 2.96 */ +#endif /* ATTRIBUTE_MALLOC */ + +/* Attributes on labels were valid as of gcc 2.93. */ +#ifndef ATTRIBUTE_UNUSED_LABEL +# if (!defined (__cplusplus) && GCC_VERSION >= 2093) +# define ATTRIBUTE_UNUSED_LABEL ATTRIBUTE_UNUSED +# else +# define ATTRIBUTE_UNUSED_LABEL +# endif /* !__cplusplus && GNUC >= 2.93 */ +#endif /* ATTRIBUTE_UNUSED_LABEL */ + +#ifndef ATTRIBUTE_UNUSED +#define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) +#endif /* ATTRIBUTE_UNUSED */ + +/* Before GCC 3.4, the C++ frontend couldn't parse attributes placed after the + identifier name. */ +#if ! defined(__cplusplus) || (GCC_VERSION >= 3004) +# define ARG_UNUSED(NAME) NAME ATTRIBUTE_UNUSED +#else /* !__cplusplus || GNUC >= 3.4 */ +# define ARG_UNUSED(NAME) NAME +#endif /* !__cplusplus || GNUC >= 3.4 */ + +#ifndef ATTRIBUTE_NORETURN +#define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__)) +#endif /* ATTRIBUTE_NORETURN */ + +/* Attribute `nonnull' was valid as of gcc 3.3. */ +#ifndef ATTRIBUTE_NONNULL +# if (GCC_VERSION >= 3003) +# define ATTRIBUTE_NONNULL(m) __attribute__ ((__nonnull__ (m))) +# else +# define ATTRIBUTE_NONNULL(m) +# endif /* GNUC >= 3.3 */ +#endif /* ATTRIBUTE_NONNULL */ + +/* Attribute `pure' was valid as of gcc 3.0. */ +#ifndef ATTRIBUTE_PURE +# if (GCC_VERSION >= 3000) +# define ATTRIBUTE_PURE __attribute__ ((__pure__)) +# else +# define ATTRIBUTE_PURE +# endif /* GNUC >= 3.0 */ +#endif /* ATTRIBUTE_PURE */ + +/* Use ATTRIBUTE_PRINTF when the format specifier must not be NULL. + This was the case for the `printf' format attribute by itself + before GCC 3.3, but as of 3.3 we need to add the `nonnull' + attribute to retain this behavior. */ +#ifndef ATTRIBUTE_PRINTF +#define ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n))) ATTRIBUTE_NONNULL(m) +#define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2) +#define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3) +#define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4) +#define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5) +#define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6) +#endif /* ATTRIBUTE_PRINTF */ + +/* Use ATTRIBUTE_FPTR_PRINTF when the format attribute is to be set on + a function pointer. Format attributes were allowed on function + pointers as of gcc 3.1. */ +#ifndef ATTRIBUTE_FPTR_PRINTF +# if (GCC_VERSION >= 3001) +# define ATTRIBUTE_FPTR_PRINTF(m, n) ATTRIBUTE_PRINTF(m, n) +# else +# define ATTRIBUTE_FPTR_PRINTF(m, n) +# endif /* GNUC >= 3.1 */ +# define ATTRIBUTE_FPTR_PRINTF_1 ATTRIBUTE_FPTR_PRINTF(1, 2) +# define ATTRIBUTE_FPTR_PRINTF_2 ATTRIBUTE_FPTR_PRINTF(2, 3) +# define ATTRIBUTE_FPTR_PRINTF_3 ATTRIBUTE_FPTR_PRINTF(3, 4) +# define ATTRIBUTE_FPTR_PRINTF_4 ATTRIBUTE_FPTR_PRINTF(4, 5) +# define ATTRIBUTE_FPTR_PRINTF_5 ATTRIBUTE_FPTR_PRINTF(5, 6) +#endif /* ATTRIBUTE_FPTR_PRINTF */ + +/* Use ATTRIBUTE_NULL_PRINTF when the format specifier may be NULL. A + NULL format specifier was allowed as of gcc 3.3. */ +#ifndef ATTRIBUTE_NULL_PRINTF +# if (GCC_VERSION >= 3003) +# define ATTRIBUTE_NULL_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n))) +# else +# define ATTRIBUTE_NULL_PRINTF(m, n) +# endif /* GNUC >= 3.3 */ +# define ATTRIBUTE_NULL_PRINTF_1 ATTRIBUTE_NULL_PRINTF(1, 2) +# define ATTRIBUTE_NULL_PRINTF_2 ATTRIBUTE_NULL_PRINTF(2, 3) +# define ATTRIBUTE_NULL_PRINTF_3 ATTRIBUTE_NULL_PRINTF(3, 4) +# define ATTRIBUTE_NULL_PRINTF_4 ATTRIBUTE_NULL_PRINTF(4, 5) +# define ATTRIBUTE_NULL_PRINTF_5 ATTRIBUTE_NULL_PRINTF(5, 6) +#endif /* ATTRIBUTE_NULL_PRINTF */ + +/* Attribute `sentinel' was valid as of gcc 3.5. */ +#ifndef ATTRIBUTE_SENTINEL +# if (GCC_VERSION >= 3005) +# define ATTRIBUTE_SENTINEL __attribute__ ((__sentinel__)) +# else +# define ATTRIBUTE_SENTINEL +# endif /* GNUC >= 3.5 */ +#endif /* ATTRIBUTE_SENTINEL */ + + +#ifndef ATTRIBUTE_ALIGNED_ALIGNOF +# if (GCC_VERSION >= 3000) +# define ATTRIBUTE_ALIGNED_ALIGNOF(m) __attribute__ ((__aligned__ (__alignof__ (m)))) +# else +# define ATTRIBUTE_ALIGNED_ALIGNOF(m) +# endif /* GNUC >= 3.0 */ +#endif /* ATTRIBUTE_ALIGNED_ALIGNOF */ + +/* We use __extension__ in some places to suppress -pedantic warnings + about GCC extensions. This feature didn't work properly before + gcc 2.8. */ +#if GCC_VERSION < 2008 +#define __extension__ +#endif + +#endif /* ansidecl.h */ diff -Naur linux-2.6.35.4/kernel/debug/mdb/ansidecl.h linux-2.6.35.4-cs/kernel/debug/mdb/ansidecl.h --- linux-2.6.35.4/kernel/debug/mdb/ansidecl.h 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/ansidecl.h 2010-08-30 04:00:09.000000000 -0600 @@ -0,0 +1,5 @@ +#ifdef CONFIG_X86_32 +# include "ansidecl_32.h" +#else +# include "ansidecl_64.h" +#endif diff -Naur linux-2.6.35.4/kernel/debug/mdb/bfd_32.h linux-2.6.35.4-cs/kernel/debug/mdb/bfd_32.h --- linux-2.6.35.4/kernel/debug/mdb/bfd_32.h 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/bfd_32.h 2010-08-30 04:00:09.000000000 -0600 @@ -0,0 +1,4921 @@ +/* DO NOT EDIT! -*- buffer-read-only: t -*- This file is automatically + generated from "bfd-in.h", "init.c", "opncls.c", "libbfd.c", + "bfdio.c", "bfdwin.c", "section.c", "archures.c", "reloc.c", + "syms.c", "bfd.c", "archive.c", "corefile.c", "targets.c", "format.c", + "linker.c" and "simple.c". + Run "make headers" in your build bfd/ to regenerate. */ + +/* Main header file for the bfd library -- portable access to object files. + + Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, + 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. + + Contributed by Cygnus Support. + + This file is part of BFD, the Binary File Descriptor library. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ + +/* Extracted from binutils 2.16.91.0.2 (OpenSUSE 10.0) and modified for kdb use. + * Any trailing whitespace was removed and #ifdef/ifndef __KERNEL__ added as + * required. + * Keith Owens 15 May 2006 + */ + +#ifndef __BFD_H_SEEN__ +#define __BFD_H_SEEN__ + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __KERNEL__ +#include "ansidecl.h" +#else /* __KERNEL__ */ +#include "ansidecl.h" +#include "symcat.h" +#endif /* __KERNEL__ */ +#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE) +#ifndef SABER +/* This hack is to avoid a problem with some strict ANSI C preprocessors. + The problem is, "32_" is not a valid preprocessing token, and we don't + want extra underscores (e.g., "nlm_32_"). The XCONCAT2 macro will + cause the inner CONCAT2 macros to be evaluated first, producing + still-valid pp-tokens. Then the final concatenation can be done. */ +#undef CONCAT4 +#define CONCAT4(a,b,c,d) XCONCAT2(CONCAT2(a,b),CONCAT2(c,d)) +#endif +#endif + +/* The word size used by BFD on the host. This may be 64 with a 32 + bit target if the host is 64 bit, or if other 64 bit targets have + been selected with --enable-targets, or if --enable-64-bit-bfd. */ +#ifdef __KERNEL__ +#define BFD_ARCH_SIZE 32 +#else /* __KERNEL__ */ +#define BFD_ARCH_SIZE 64 +#endif /* __KERNEL__ */ + +/* The word size of the default bfd target. */ +#define BFD_DEFAULT_TARGET_SIZE 32 + +#define BFD_HOST_64BIT_LONG 0 +#define BFD_HOST_LONG_LONG 1 +#if 1 +#define BFD_HOST_64_BIT long long +#define BFD_HOST_U_64_BIT unsigned long long +typedef BFD_HOST_64_BIT bfd_int64_t; +typedef BFD_HOST_U_64_BIT bfd_uint64_t; +#endif + +#if BFD_ARCH_SIZE >= 64 +#define BFD64 +#endif + +#ifndef INLINE +#if __GNUC__ >= 2 +#define INLINE __inline__ +#else +#define INLINE +#endif +#endif + +/* Forward declaration. */ +typedef struct bfd bfd; + +/* Boolean type used in bfd. Too many systems define their own + versions of "boolean" for us to safely typedef a "boolean" of + our own. Using an enum for "bfd_boolean" has its own set of + problems, with strange looking casts required to avoid warnings + on some older compilers. Thus we just use an int. + + General rule: Functions which are bfd_boolean return TRUE on + success and FALSE on failure (unless they're a predicate). */ + +typedef int bfd_boolean; +#undef FALSE +#undef TRUE +#define FALSE 0 +#define TRUE 1 + +#ifdef BFD64 + +#ifndef BFD_HOST_64_BIT + #error No 64 bit integer type available +#endif /* ! defined (BFD_HOST_64_BIT) */ + +typedef BFD_HOST_U_64_BIT bfd_vma; +typedef BFD_HOST_64_BIT bfd_signed_vma; +typedef BFD_HOST_U_64_BIT bfd_size_type; +typedef BFD_HOST_U_64_BIT symvalue; + +#ifndef fprintf_vma +#if BFD_HOST_64BIT_LONG +#define sprintf_vma(s,x) sprintf (s, "%016lx", x) +#define fprintf_vma(f,x) fprintf (f, "%016lx", x) +#else +#define _bfd_int64_low(x) ((unsigned long) (((x) & 0xffffffff))) +#define _bfd_int64_high(x) ((unsigned long) (((x) >> 32) & 0xffffffff)) +#define fprintf_vma(s,x) \ + fprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x)) +#define sprintf_vma(s,x) \ + sprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x)) +#endif +#endif + +#else /* not BFD64 */ + +/* Represent a target address. Also used as a generic unsigned type + which is guaranteed to be big enough to hold any arithmetic types + we need to deal with. */ +typedef unsigned long bfd_vma; + +/* A generic signed type which is guaranteed to be big enough to hold any + arithmetic types we need to deal with. Can be assumed to be compatible + with bfd_vma in the same way that signed and unsigned ints are compatible + (as parameters, in assignment, etc). */ +typedef long bfd_signed_vma; + +typedef unsigned long symvalue; +typedef unsigned long bfd_size_type; + +/* Print a bfd_vma x on stream s. */ +#define fprintf_vma(s,x) fprintf (s, "%08lx", x) +#define sprintf_vma(s,x) sprintf (s, "%08lx", x) + +#endif /* not BFD64 */ + +#define HALF_BFD_SIZE_TYPE \ + (((bfd_size_type) 1) << (8 * sizeof (bfd_size_type) / 2)) + +#ifndef BFD_HOST_64_BIT +/* Fall back on a 32 bit type. The idea is to make these types always + available for function return types, but in the case that + BFD_HOST_64_BIT is undefined such a function should abort or + otherwise signal an error. */ +typedef bfd_signed_vma bfd_int64_t; +typedef bfd_vma bfd_uint64_t; +#endif + +/* An offset into a file. BFD always uses the largest possible offset + based on the build time availability of fseek, fseeko, or fseeko64. */ +typedef BFD_HOST_64_BIT file_ptr; +typedef unsigned BFD_HOST_64_BIT ufile_ptr; + +extern void bfd_sprintf_vma (bfd *, char *, bfd_vma); +extern void bfd_fprintf_vma (bfd *, void *, bfd_vma); + +#define printf_vma(x) fprintf_vma(stdout,x) +#define bfd_printf_vma(abfd,x) bfd_fprintf_vma (abfd,stdout,x) + +typedef unsigned int flagword; /* 32 bits of flags */ +typedef unsigned char bfd_byte; + +/* File formats. */ + +typedef enum bfd_format +{ + bfd_unknown = 0, /* File format is unknown. */ + bfd_object, /* Linker/assembler/compiler output. */ + bfd_archive, /* Object archive file. */ + bfd_core, /* Core dump. */ + bfd_type_end /* Marks the end; don't use it! */ +} +bfd_format; + +/* Values that may appear in the flags field of a BFD. These also + appear in the object_flags field of the bfd_target structure, where + they indicate the set of flags used by that backend (not all flags + are meaningful for all object file formats) (FIXME: at the moment, + the object_flags values have mostly just been copied from backend + to another, and are not necessarily correct). */ + +/* No flags. */ +#define BFD_NO_FLAGS 0x00 + +/* BFD contains relocation entries. */ +#define HAS_RELOC 0x01 + +/* BFD is directly executable. */ +#define EXEC_P 0x02 + +/* BFD has line number information (basically used for F_LNNO in a + COFF header). */ +#define HAS_LINENO 0x04 + +/* BFD has debugging information. */ +#define HAS_DEBUG 0x08 + +/* BFD has symbols. */ +#define HAS_SYMS 0x10 + +/* BFD has local symbols (basically used for F_LSYMS in a COFF + header). */ +#define HAS_LOCALS 0x20 + +/* BFD is a dynamic object. */ +#define DYNAMIC 0x40 + +/* Text section is write protected (if D_PAGED is not set, this is + like an a.out NMAGIC file) (the linker sets this by default, but + clears it for -r or -N). */ +#define WP_TEXT 0x80 + +/* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the + linker sets this by default, but clears it for -r or -n or -N). */ +#define D_PAGED 0x100 + +/* BFD is relaxable (this means that bfd_relax_section may be able to + do something) (sometimes bfd_relax_section can do something even if + this is not set). */ +#define BFD_IS_RELAXABLE 0x200 + +/* This may be set before writing out a BFD to request using a + traditional format. For example, this is used to request that when + writing out an a.out object the symbols not be hashed to eliminate + duplicates. */ +#define BFD_TRADITIONAL_FORMAT 0x400 + +/* This flag indicates that the BFD contents are actually cached in + memory. If this is set, iostream points to a bfd_in_memory struct. */ +#define BFD_IN_MEMORY 0x800 + +/* The sections in this BFD specify a memory page. */ +#define HAS_LOAD_PAGE 0x1000 + +/* This BFD has been created by the linker and doesn't correspond + to any input file. */ +#define BFD_LINKER_CREATED 0x2000 + +/* Symbols and relocation. */ + +/* A count of carsyms (canonical archive symbols). */ +typedef unsigned long symindex; + +/* How to perform a relocation. */ +typedef const struct reloc_howto_struct reloc_howto_type; + +#define BFD_NO_MORE_SYMBOLS ((symindex) ~0) + +/* General purpose part of a symbol X; + target specific parts are in libcoff.h, libaout.h, etc. */ + +#define bfd_get_section(x) ((x)->section) +#define bfd_get_output_section(x) ((x)->section->output_section) +#define bfd_set_section(x,y) ((x)->section) = (y) +#define bfd_asymbol_base(x) ((x)->section->vma) +#define bfd_asymbol_value(x) (bfd_asymbol_base(x) + (x)->value) +#define bfd_asymbol_name(x) ((x)->name) +/*Perhaps future: #define bfd_asymbol_bfd(x) ((x)->section->owner)*/ +#define bfd_asymbol_bfd(x) ((x)->the_bfd) +#define bfd_asymbol_flavour(x) (bfd_asymbol_bfd(x)->xvec->flavour) + +/* A canonical archive symbol. */ +/* This is a type pun with struct ranlib on purpose! */ +typedef struct carsym +{ + char *name; + file_ptr file_offset; /* Look here to find the file. */ +} +carsym; /* To make these you call a carsymogen. */ + +/* Used in generating armaps (archive tables of contents). + Perhaps just a forward definition would do? */ +struct orl /* Output ranlib. */ +{ + char **name; /* Symbol name. */ + union + { + file_ptr pos; + bfd *abfd; + } u; /* bfd* or file position. */ + int namidx; /* Index into string table. */ +}; + +/* Linenumber stuff. */ +typedef struct lineno_cache_entry +{ + unsigned int line_number; /* Linenumber from start of function. */ + union + { + struct bfd_symbol *sym; /* Function name. */ + bfd_vma offset; /* Offset into section. */ + } u; +} +alent; + +/* Object and core file sections. */ + +#define align_power(addr, align) \ + (((addr) + ((bfd_vma) 1 << (align)) - 1) & ((bfd_vma) -1 << (align))) + +typedef struct bfd_section *sec_ptr; + +#define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0) +#define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0) +#define bfd_get_section_lma(bfd, ptr) ((ptr)->lma + 0) +#define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0) +#define bfd_section_name(bfd, ptr) ((ptr)->name) +#define bfd_section_size(bfd, ptr) ((ptr)->size) +#define bfd_get_section_size(ptr) ((ptr)->size) +#define bfd_section_vma(bfd, ptr) ((ptr)->vma) +#define bfd_section_lma(bfd, ptr) ((ptr)->lma) +#define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power) +#define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0) +#define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata) + +#define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0) + +#define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma = (val)), ((ptr)->user_set_vma = TRUE), TRUE) +#define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),TRUE) +#define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),TRUE) +/* Find the address one past the end of SEC. */ +#define bfd_get_section_limit(bfd, sec) \ + (((sec)->rawsize ? (sec)->rawsize : (sec)->size) \ + / bfd_octets_per_byte (bfd)) + +typedef struct stat stat_type; + +typedef enum bfd_print_symbol +{ + bfd_print_symbol_name, + bfd_print_symbol_more, + bfd_print_symbol_all +} bfd_print_symbol_type; + +/* Information about a symbol that nm needs. */ + +typedef struct _symbol_info +{ + symvalue value; + char type; + const char *name; /* Symbol name. */ + unsigned char stab_type; /* Stab type. */ + char stab_other; /* Stab other. */ + short stab_desc; /* Stab desc. */ + const char *stab_name; /* String for stab type. */ +} symbol_info; + +/* Get the name of a stabs type code. */ + +extern const char *bfd_get_stab_name (int); + +/* Hash table routines. There is no way to free up a hash table. */ + +/* An element in the hash table. Most uses will actually use a larger + structure, and an instance of this will be the first field. */ + +struct bfd_hash_entry +{ + /* Next entry for this hash code. */ + struct bfd_hash_entry *next; + /* String being hashed. */ + const char *string; + /* Hash code. This is the full hash code, not the index into the + table. */ + unsigned long hash; +}; + +/* A hash table. */ + +struct bfd_hash_table +{ + /* The hash array. */ + struct bfd_hash_entry **table; + /* The number of slots in the hash table. */ + unsigned int size; + /* A function used to create new elements in the hash table. The + first entry is itself a pointer to an element. When this + function is first invoked, this pointer will be NULL. However, + having the pointer permits a hierarchy of method functions to be + built each of which calls the function in the superclass. Thus + each function should be written to allocate a new block of memory + only if the argument is NULL. */ + struct bfd_hash_entry *(*newfunc) + (struct bfd_hash_entry *, struct bfd_hash_table *, const char *); + /* An objalloc for this hash table. This is a struct objalloc *, + but we use void * to avoid requiring the inclusion of objalloc.h. */ + void *memory; +}; + +/* Initialize a hash table. */ +extern bfd_boolean bfd_hash_table_init + (struct bfd_hash_table *, + struct bfd_hash_entry *(*) (struct bfd_hash_entry *, + struct bfd_hash_table *, + const char *)); + +/* Initialize a hash table specifying a size. */ +extern bfd_boolean bfd_hash_table_init_n + (struct bfd_hash_table *, + struct bfd_hash_entry *(*) (struct bfd_hash_entry *, + struct bfd_hash_table *, + const char *), + unsigned int size); + +/* Free up a hash table. */ +extern void bfd_hash_table_free + (struct bfd_hash_table *); + +/* Look up a string in a hash table. If CREATE is TRUE, a new entry + will be created for this string if one does not already exist. The + COPY argument must be TRUE if this routine should copy the string + into newly allocated memory when adding an entry. */ +extern struct bfd_hash_entry *bfd_hash_lookup + (struct bfd_hash_table *, const char *, bfd_boolean create, + bfd_boolean copy); + +/* Replace an entry in a hash table. */ +extern void bfd_hash_replace + (struct bfd_hash_table *, struct bfd_hash_entry *old, + struct bfd_hash_entry *nw); + +/* Base method for creating a hash table entry. */ +extern struct bfd_hash_entry *bfd_hash_newfunc + (struct bfd_hash_entry *, struct bfd_hash_table *, const char *); + +/* Grab some space for a hash table entry. */ +extern void *bfd_hash_allocate + (struct bfd_hash_table *, unsigned int); + +/* Traverse a hash table in a random order, calling a function on each + element. If the function returns FALSE, the traversal stops. The + INFO argument is passed to the function. */ +extern void bfd_hash_traverse + (struct bfd_hash_table *, + bfd_boolean (*) (struct bfd_hash_entry *, void *), + void *info); + +/* Allows the default size of a hash table to be configured. New hash + tables allocated using bfd_hash_table_init will be created with + this size. */ +extern void bfd_hash_set_default_size (bfd_size_type); + +/* This structure is used to keep track of stabs in sections + information while linking. */ + +struct stab_info +{ + /* A hash table used to hold stabs strings. */ + struct bfd_strtab_hash *strings; + /* The header file hash table. */ + struct bfd_hash_table includes; + /* The first .stabstr section. */ + struct bfd_section *stabstr; +}; + +#define COFF_SWAP_TABLE (void *) &bfd_coff_std_swap_table + +/* User program access to BFD facilities. */ + +/* Direct I/O routines, for programs which know more about the object + file than BFD does. Use higher level routines if possible. */ + +extern bfd_size_type bfd_bread (void *, bfd_size_type, bfd *); +extern bfd_size_type bfd_bwrite (const void *, bfd_size_type, bfd *); +extern int bfd_seek (bfd *, file_ptr, int); +extern file_ptr bfd_tell (bfd *); +extern int bfd_flush (bfd *); +extern int bfd_stat (bfd *, struct stat *); + +/* Deprecated old routines. */ +#if __GNUC__ +#define bfd_read(BUF, ELTSIZE, NITEMS, ABFD) \ + (warn_deprecated ("bfd_read", __FILE__, __LINE__, __FUNCTION__), \ + bfd_bread ((BUF), (ELTSIZE) * (NITEMS), (ABFD))) +#define bfd_write(BUF, ELTSIZE, NITEMS, ABFD) \ + (warn_deprecated ("bfd_write", __FILE__, __LINE__, __FUNCTION__), \ + bfd_bwrite ((BUF), (ELTSIZE) * (NITEMS), (ABFD))) +#else +#define bfd_read(BUF, ELTSIZE, NITEMS, ABFD) \ + (warn_deprecated ("bfd_read", (const char *) 0, 0, (const char *) 0), \ + bfd_bread ((BUF), (ELTSIZE) * (NITEMS), (ABFD))) +#define bfd_write(BUF, ELTSIZE, NITEMS, ABFD) \ + (warn_deprecated ("bfd_write", (const char *) 0, 0, (const char *) 0),\ + bfd_bwrite ((BUF), (ELTSIZE) * (NITEMS), (ABFD))) +#endif +extern void warn_deprecated (const char *, const char *, int, const char *); + +/* Cast from const char * to char * so that caller can assign to + a char * without a warning. */ +#define bfd_get_filename(abfd) ((char *) (abfd)->filename) +#define bfd_get_cacheable(abfd) ((abfd)->cacheable) +#define bfd_get_format(abfd) ((abfd)->format) +#define bfd_get_target(abfd) ((abfd)->xvec->name) +#define bfd_get_flavour(abfd) ((abfd)->xvec->flavour) +#define bfd_family_coff(abfd) \ + (bfd_get_flavour (abfd) == bfd_target_coff_flavour || \ + bfd_get_flavour (abfd) == bfd_target_xcoff_flavour) +#define bfd_big_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG) +#define bfd_little_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_LITTLE) +#define bfd_header_big_endian(abfd) \ + ((abfd)->xvec->header_byteorder == BFD_ENDIAN_BIG) +#define bfd_header_little_endian(abfd) \ + ((abfd)->xvec->header_byteorder == BFD_ENDIAN_LITTLE) +#define bfd_get_file_flags(abfd) ((abfd)->flags) +#define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags) +#define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags) +#define bfd_my_archive(abfd) ((abfd)->my_archive) +#define bfd_has_map(abfd) ((abfd)->has_armap) + +#define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types) +#define bfd_usrdata(abfd) ((abfd)->usrdata) + +#define bfd_get_start_address(abfd) ((abfd)->start_address) +#define bfd_get_symcount(abfd) ((abfd)->symcount) +#define bfd_get_outsymbols(abfd) ((abfd)->outsymbols) +#define bfd_count_sections(abfd) ((abfd)->section_count) + +#define bfd_get_dynamic_symcount(abfd) ((abfd)->dynsymcount) + +#define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char) + +#define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = bool), TRUE) + +extern bfd_boolean bfd_cache_close + (bfd *abfd); +/* NB: This declaration should match the autogenerated one in libbfd.h. */ + +extern bfd_boolean bfd_cache_close_all (void); + +extern bfd_boolean bfd_record_phdr + (bfd *, unsigned long, bfd_boolean, flagword, bfd_boolean, bfd_vma, + bfd_boolean, bfd_boolean, unsigned int, struct bfd_section **); + +/* Byte swapping routines. */ + +bfd_uint64_t bfd_getb64 (const void *); +bfd_uint64_t bfd_getl64 (const void *); +bfd_int64_t bfd_getb_signed_64 (const void *); +bfd_int64_t bfd_getl_signed_64 (const void *); +bfd_vma bfd_getb32 (const void *); +bfd_vma bfd_getl32 (const void *); +bfd_signed_vma bfd_getb_signed_32 (const void *); +bfd_signed_vma bfd_getl_signed_32 (const void *); +bfd_vma bfd_getb16 (const void *); +bfd_vma bfd_getl16 (const void *); +bfd_signed_vma bfd_getb_signed_16 (const void *); +bfd_signed_vma bfd_getl_signed_16 (const void *); +void bfd_putb64 (bfd_uint64_t, void *); +void bfd_putl64 (bfd_uint64_t, void *); +void bfd_putb32 (bfd_vma, void *); +void bfd_putl32 (bfd_vma, void *); +void bfd_putb16 (bfd_vma, void *); +void bfd_putl16 (bfd_vma, void *); + +/* Byte swapping routines which take size and endiannes as arguments. */ + +bfd_uint64_t bfd_get_bits (const void *, int, bfd_boolean); +void bfd_put_bits (bfd_uint64_t, void *, int, bfd_boolean); + +extern bfd_boolean bfd_section_already_linked_table_init (void); +extern void bfd_section_already_linked_table_free (void); + +/* Externally visible ECOFF routines. */ + +#if defined(__STDC__) || defined(ALMOST_STDC) +struct ecoff_debug_info; +struct ecoff_debug_swap; +struct ecoff_extr; +struct bfd_symbol; +struct bfd_link_info; +struct bfd_link_hash_entry; +struct bfd_elf_version_tree; +#endif +extern bfd_vma bfd_ecoff_get_gp_value + (bfd * abfd); +extern bfd_boolean bfd_ecoff_set_gp_value + (bfd *abfd, bfd_vma gp_value); +extern bfd_boolean bfd_ecoff_set_regmasks + (bfd *abfd, unsigned long gprmask, unsigned long fprmask, + unsigned long *cprmask); +extern void *bfd_ecoff_debug_init + (bfd *output_bfd, struct ecoff_debug_info *output_debug, + const struct ecoff_debug_swap *output_swap, struct bfd_link_info *); +extern void bfd_ecoff_debug_free + (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug, + const struct ecoff_debug_swap *output_swap, struct bfd_link_info *); +extern bfd_boolean bfd_ecoff_debug_accumulate + (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug, + const struct ecoff_debug_swap *output_swap, bfd *input_bfd, + struct ecoff_debug_info *input_debug, + const struct ecoff_debug_swap *input_swap, struct bfd_link_info *); +extern bfd_boolean bfd_ecoff_debug_accumulate_other + (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug, + const struct ecoff_debug_swap *output_swap, bfd *input_bfd, + struct bfd_link_info *); +extern bfd_boolean bfd_ecoff_debug_externals + (bfd *abfd, struct ecoff_debug_info *debug, + const struct ecoff_debug_swap *swap, bfd_boolean relocatable, + bfd_boolean (*get_extr) (struct bfd_symbol *, struct ecoff_extr *), + void (*set_index) (struct bfd_symbol *, bfd_size_type)); +extern bfd_boolean bfd_ecoff_debug_one_external + (bfd *abfd, struct ecoff_debug_info *debug, + const struct ecoff_debug_swap *swap, const char *name, + struct ecoff_extr *esym); +extern bfd_size_type bfd_ecoff_debug_size + (bfd *abfd, struct ecoff_debug_info *debug, + const struct ecoff_debug_swap *swap); +extern bfd_boolean bfd_ecoff_write_debug + (bfd *abfd, struct ecoff_debug_info *debug, + const struct ecoff_debug_swap *swap, file_ptr where); +extern bfd_boolean bfd_ecoff_write_accumulated_debug + (void *handle, bfd *abfd, struct ecoff_debug_info *debug, + const struct ecoff_debug_swap *swap, + struct bfd_link_info *info, file_ptr where); + +/* Externally visible ELF routines. */ + +struct bfd_link_needed_list +{ + struct bfd_link_needed_list *next; + bfd *by; + const char *name; +}; + +enum dynamic_lib_link_class { + DYN_NORMAL = 0, + DYN_AS_NEEDED = 1, + DYN_DT_NEEDED = 2, + DYN_NO_ADD_NEEDED = 4, + DYN_NO_NEEDED = 8 +}; + +extern bfd_boolean bfd_elf_record_link_assignment + (struct bfd_link_info *, const char *, bfd_boolean); +extern struct bfd_link_needed_list *bfd_elf_get_needed_list + (bfd *, struct bfd_link_info *); +extern bfd_boolean bfd_elf_get_bfd_needed_list + (bfd *, struct bfd_link_needed_list **); +extern bfd_boolean bfd_elf_size_dynamic_sections + (bfd *, const char *, const char *, const char *, const char * const *, + struct bfd_link_info *, struct bfd_section **, + struct bfd_elf_version_tree *); +extern bfd_boolean bfd_elf_size_dynsym_hash_dynstr + (bfd *, struct bfd_link_info *); +extern void bfd_elf_set_dt_needed_name + (bfd *, const char *); +extern const char *bfd_elf_get_dt_soname + (bfd *); +extern void bfd_elf_set_dyn_lib_class + (bfd *, int); +extern int bfd_elf_get_dyn_lib_class + (bfd *); +extern struct bfd_link_needed_list *bfd_elf_get_runpath_list + (bfd *, struct bfd_link_info *); +extern bfd_boolean bfd_elf_discard_info + (bfd *, struct bfd_link_info *); +extern unsigned int _bfd_elf_default_action_discarded + (struct bfd_section *); + +/* Return an upper bound on the number of bytes required to store a + copy of ABFD's program header table entries. Return -1 if an error + occurs; bfd_get_error will return an appropriate code. */ +extern long bfd_get_elf_phdr_upper_bound + (bfd *abfd); + +/* Copy ABFD's program header table entries to *PHDRS. The entries + will be stored as an array of Elf_Internal_Phdr structures, as + defined in include/elf/internal.h. To find out how large the + buffer needs to be, call bfd_get_elf_phdr_upper_bound. + + Return the number of program header table entries read, or -1 if an + error occurs; bfd_get_error will return an appropriate code. */ +extern int bfd_get_elf_phdrs + (bfd *abfd, void *phdrs); + +/* Create a new BFD as if by bfd_openr. Rather than opening a file, + reconstruct an ELF file by reading the segments out of remote memory + based on the ELF file header at EHDR_VMA and the ELF program headers it + points to. If not null, *LOADBASEP is filled in with the difference + between the VMAs from which the segments were read, and the VMAs the + file headers (and hence BFD's idea of each section's VMA) put them at. + + The function TARGET_READ_MEMORY is called to copy LEN bytes from the + remote memory at target address VMA into the local buffer at MYADDR; it + should return zero on success or an `errno' code on failure. TEMPL must + be a BFD for an ELF target with the word size and byte order found in + the remote memory. */ +extern bfd *bfd_elf_bfd_from_remote_memory + (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep, + int (*target_read_memory) (bfd_vma vma, bfd_byte *myaddr, int len)); + +/* Return the arch_size field of an elf bfd, or -1 if not elf. */ +extern int bfd_get_arch_size + (bfd *); + +/* Return TRUE if address "naturally" sign extends, or -1 if not elf. */ +extern int bfd_get_sign_extend_vma + (bfd *); + +extern struct bfd_section *_bfd_elf_tls_setup + (bfd *, struct bfd_link_info *); + +extern void _bfd_elf_provide_symbol + (struct bfd_link_info *, const char *, bfd_vma, struct bfd_section *); + +extern void _bfd_elf_provide_section_bound_symbols + (struct bfd_link_info *, struct bfd_section *, const char *, const char *); + +extern void _bfd_elf_fix_excluded_sec_syms + (bfd *, struct bfd_link_info *); + +extern bfd_boolean bfd_m68k_elf32_create_embedded_relocs + (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *, + char **); + +/* SunOS shared library support routines for the linker. */ + +extern struct bfd_link_needed_list *bfd_sunos_get_needed_list + (bfd *, struct bfd_link_info *); +extern bfd_boolean bfd_sunos_record_link_assignment + (bfd *, struct bfd_link_info *, const char *); +extern bfd_boolean bfd_sunos_size_dynamic_sections + (bfd *, struct bfd_link_info *, struct bfd_section **, + struct bfd_section **, struct bfd_section **); + +/* Linux shared library support routines for the linker. */ + +extern bfd_boolean bfd_i386linux_size_dynamic_sections + (bfd *, struct bfd_link_info *); +extern bfd_boolean bfd_m68klinux_size_dynamic_sections + (bfd *, struct bfd_link_info *); +extern bfd_boolean bfd_sparclinux_size_dynamic_sections + (bfd *, struct bfd_link_info *); + +/* mmap hacks */ + +struct _bfd_window_internal; +typedef struct _bfd_window_internal bfd_window_internal; + +typedef struct _bfd_window +{ + /* What the user asked for. */ + void *data; + bfd_size_type size; + /* The actual window used by BFD. Small user-requested read-only + regions sharing a page may share a single window into the object + file. Read-write versions shouldn't until I've fixed things to + keep track of which portions have been claimed by the + application; don't want to give the same region back when the + application wants two writable copies! */ + struct _bfd_window_internal *i; +} +bfd_window; + +extern void bfd_init_window + (bfd_window *); +extern void bfd_free_window + (bfd_window *); +extern bfd_boolean bfd_get_file_window + (bfd *, file_ptr, bfd_size_type, bfd_window *, bfd_boolean); + +/* XCOFF support routines for the linker. */ + +extern bfd_boolean bfd_xcoff_link_record_set + (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, bfd_size_type); +extern bfd_boolean bfd_xcoff_import_symbol + (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, bfd_vma, + const char *, const char *, const char *, unsigned int); +extern bfd_boolean bfd_xcoff_export_symbol + (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *); +extern bfd_boolean bfd_xcoff_link_count_reloc + (bfd *, struct bfd_link_info *, const char *); +extern bfd_boolean bfd_xcoff_record_link_assignment + (bfd *, struct bfd_link_info *, const char *); +extern bfd_boolean bfd_xcoff_size_dynamic_sections + (bfd *, struct bfd_link_info *, const char *, const char *, + unsigned long, unsigned long, unsigned long, bfd_boolean, + int, bfd_boolean, bfd_boolean, struct bfd_section **, bfd_boolean); +extern bfd_boolean bfd_xcoff_link_generate_rtinit + (bfd *, const char *, const char *, bfd_boolean); + +/* XCOFF support routines for ar. */ +extern bfd_boolean bfd_xcoff_ar_archive_set_magic + (bfd *, char *); + +/* Externally visible COFF routines. */ + +#if defined(__STDC__) || defined(ALMOST_STDC) +struct internal_syment; +union internal_auxent; +#endif + +extern bfd_boolean bfd_coff_get_syment + (bfd *, struct bfd_symbol *, struct internal_syment *); + +extern bfd_boolean bfd_coff_get_auxent + (bfd *, struct bfd_symbol *, int, union internal_auxent *); + +extern bfd_boolean bfd_coff_set_symbol_class + (bfd *, struct bfd_symbol *, unsigned int); + +extern bfd_boolean bfd_m68k_coff_create_embedded_relocs + (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *, char **); + +/* ARM Interworking support. Called from linker. */ +extern bfd_boolean bfd_arm_allocate_interworking_sections + (struct bfd_link_info *); + +extern bfd_boolean bfd_arm_process_before_allocation + (bfd *, struct bfd_link_info *, int); + +extern bfd_boolean bfd_arm_get_bfd_for_interworking + (bfd *, struct bfd_link_info *); + +/* PE ARM Interworking support. Called from linker. */ +extern bfd_boolean bfd_arm_pe_allocate_interworking_sections + (struct bfd_link_info *); + +extern bfd_boolean bfd_arm_pe_process_before_allocation + (bfd *, struct bfd_link_info *, int); + +extern bfd_boolean bfd_arm_pe_get_bfd_for_interworking + (bfd *, struct bfd_link_info *); + +/* ELF ARM Interworking support. Called from linker. */ +extern bfd_boolean bfd_elf32_arm_allocate_interworking_sections + (struct bfd_link_info *); + +extern bfd_boolean bfd_elf32_arm_process_before_allocation + (bfd *, struct bfd_link_info *, int); + +void bfd_elf32_arm_set_target_relocs + (struct bfd_link_info *, int, char *, int, int); + +extern bfd_boolean bfd_elf32_arm_get_bfd_for_interworking + (bfd *, struct bfd_link_info *); + +extern bfd_boolean bfd_elf32_arm_add_glue_sections_to_bfd + (bfd *, struct bfd_link_info *); + +/* ELF ARM mapping symbol support */ +extern bfd_boolean bfd_is_arm_mapping_symbol_name + (const char * name); + +/* ARM Note section processing. */ +extern bfd_boolean bfd_arm_merge_machines + (bfd *, bfd *); + +extern bfd_boolean bfd_arm_update_notes + (bfd *, const char *); + +extern unsigned int bfd_arm_get_mach_from_notes + (bfd *, const char *); + +/* TI COFF load page support. */ +extern void bfd_ticoff_set_section_load_page + (struct bfd_section *, int); + +extern int bfd_ticoff_get_section_load_page + (struct bfd_section *); + +/* H8/300 functions. */ +extern bfd_vma bfd_h8300_pad_address + (bfd *, bfd_vma); + +/* IA64 Itanium code generation. Called from linker. */ +extern void bfd_elf32_ia64_after_parse + (int); + +extern void bfd_elf64_ia64_after_parse + (int); + +/* This structure is used for a comdat section, as in PE. A comdat + section is associated with a particular symbol. When the linker + sees a comdat section, it keeps only one of the sections with a + given name and associated with a given symbol. */ + +struct coff_comdat_info +{ + /* The name of the symbol associated with a comdat section. */ + const char *name; + + /* The local symbol table index of the symbol associated with a + comdat section. This is only meaningful to the object file format + specific code; it is not an index into the list returned by + bfd_canonicalize_symtab. */ + long symbol; +}; + +extern struct coff_comdat_info *bfd_coff_get_comdat_section + (bfd *, struct bfd_section *); + +/* Extracted from init.c. */ +void bfd_init (void); + +/* Extracted from opncls.c. */ +bfd *bfd_fopen (const char *filename, const char *target, + const char *mode, int fd); + +bfd *bfd_openr (const char *filename, const char *target); + +bfd *bfd_fdopenr (const char *filename, const char *target, int fd); + +bfd *bfd_openstreamr (const char *, const char *, void *); + +bfd *bfd_openr_iovec (const char *filename, const char *target, + void *(*open) (struct bfd *nbfd, + void *open_closure), + void *open_closure, + file_ptr (*pread) (struct bfd *nbfd, + void *stream, + void *buf, + file_ptr nbytes, + file_ptr offset), + int (*close) (struct bfd *nbfd, + void *stream)); + +bfd *bfd_openw (const char *filename, const char *target); + +bfd_boolean bfd_close (bfd *abfd); + +bfd_boolean bfd_close_all_done (bfd *); + +bfd *bfd_create (const char *filename, bfd *templ); + +bfd_boolean bfd_make_writable (bfd *abfd); + +bfd_boolean bfd_make_readable (bfd *abfd); + +unsigned long bfd_calc_gnu_debuglink_crc32 + (unsigned long crc, const unsigned char *buf, bfd_size_type len); + +char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir); + +struct bfd_section *bfd_create_gnu_debuglink_section + (bfd *abfd, const char *filename); + +bfd_boolean bfd_fill_in_gnu_debuglink_section + (bfd *abfd, struct bfd_section *sect, const char *filename); + +/* Extracted from libbfd.c. */ + +/* Byte swapping macros for user section data. */ + +#define bfd_put_8(abfd, val, ptr) \ + ((void) (*((unsigned char *) (ptr)) = (val) & 0xff)) +#define bfd_put_signed_8 \ + bfd_put_8 +#define bfd_get_8(abfd, ptr) \ + (*(unsigned char *) (ptr) & 0xff) +#define bfd_get_signed_8(abfd, ptr) \ + (((*(unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80) + +#define bfd_put_16(abfd, val, ptr) \ + BFD_SEND (abfd, bfd_putx16, ((val),(ptr))) +#define bfd_put_signed_16 \ + bfd_put_16 +#define bfd_get_16(abfd, ptr) \ + BFD_SEND (abfd, bfd_getx16, (ptr)) +#define bfd_get_signed_16(abfd, ptr) \ + BFD_SEND (abfd, bfd_getx_signed_16, (ptr)) + +#define bfd_put_32(abfd, val, ptr) \ + BFD_SEND (abfd, bfd_putx32, ((val),(ptr))) +#define bfd_put_signed_32 \ + bfd_put_32 +#define bfd_get_32(abfd, ptr) \ + BFD_SEND (abfd, bfd_getx32, (ptr)) +#define bfd_get_signed_32(abfd, ptr) \ + BFD_SEND (abfd, bfd_getx_signed_32, (ptr)) + +#define bfd_put_64(abfd, val, ptr) \ + BFD_SEND (abfd, bfd_putx64, ((val), (ptr))) +#define bfd_put_signed_64 \ + bfd_put_64 +#define bfd_get_64(abfd, ptr) \ + BFD_SEND (abfd, bfd_getx64, (ptr)) +#define bfd_get_signed_64(abfd, ptr) \ + BFD_SEND (abfd, bfd_getx_signed_64, (ptr)) + +#define bfd_get(bits, abfd, ptr) \ + ((bits) == 8 ? (bfd_vma) bfd_get_8 (abfd, ptr) \ + : (bits) == 16 ? bfd_get_16 (abfd, ptr) \ + : (bits) == 32 ? bfd_get_32 (abfd, ptr) \ + : (bits) == 64 ? bfd_get_64 (abfd, ptr) \ + : (abort (), (bfd_vma) - 1)) + +#define bfd_put(bits, abfd, val, ptr) \ + ((bits) == 8 ? bfd_put_8 (abfd, val, ptr) \ + : (bits) == 16 ? bfd_put_16 (abfd, val, ptr) \ + : (bits) == 32 ? bfd_put_32 (abfd, val, ptr) \ + : (bits) == 64 ? bfd_put_64 (abfd, val, ptr) \ + : (abort (), (void) 0)) + + +/* Byte swapping macros for file header data. */ + +#define bfd_h_put_8(abfd, val, ptr) \ + bfd_put_8 (abfd, val, ptr) +#define bfd_h_put_signed_8(abfd, val, ptr) \ + bfd_put_8 (abfd, val, ptr) +#define bfd_h_get_8(abfd, ptr) \ + bfd_get_8 (abfd, ptr) +#define bfd_h_get_signed_8(abfd, ptr) \ + bfd_get_signed_8 (abfd, ptr) + +#define bfd_h_put_16(abfd, val, ptr) \ + BFD_SEND (abfd, bfd_h_putx16, (val, ptr)) +#define bfd_h_put_signed_16 \ + bfd_h_put_16 +#define bfd_h_get_16(abfd, ptr) \ + BFD_SEND (abfd, bfd_h_getx16, (ptr)) +#define bfd_h_get_signed_16(abfd, ptr) \ + BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr)) + +#define bfd_h_put_32(abfd, val, ptr) \ + BFD_SEND (abfd, bfd_h_putx32, (val, ptr)) +#define bfd_h_put_signed_32 \ + bfd_h_put_32 +#define bfd_h_get_32(abfd, ptr) \ + BFD_SEND (abfd, bfd_h_getx32, (ptr)) +#define bfd_h_get_signed_32(abfd, ptr) \ + BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr)) + +#define bfd_h_put_64(abfd, val, ptr) \ + BFD_SEND (abfd, bfd_h_putx64, (val, ptr)) +#define bfd_h_put_signed_64 \ + bfd_h_put_64 +#define bfd_h_get_64(abfd, ptr) \ + BFD_SEND (abfd, bfd_h_getx64, (ptr)) +#define bfd_h_get_signed_64(abfd, ptr) \ + BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr)) + +/* Aliases for the above, which should eventually go away. */ + +#define H_PUT_64 bfd_h_put_64 +#define H_PUT_32 bfd_h_put_32 +#define H_PUT_16 bfd_h_put_16 +#define H_PUT_8 bfd_h_put_8 +#define H_PUT_S64 bfd_h_put_signed_64 +#define H_PUT_S32 bfd_h_put_signed_32 +#define H_PUT_S16 bfd_h_put_signed_16 +#define H_PUT_S8 bfd_h_put_signed_8 +#define H_GET_64 bfd_h_get_64 +#define H_GET_32 bfd_h_get_32 +#define H_GET_16 bfd_h_get_16 +#define H_GET_8 bfd_h_get_8 +#define H_GET_S64 bfd_h_get_signed_64 +#define H_GET_S32 bfd_h_get_signed_32 +#define H_GET_S16 bfd_h_get_signed_16 +#define H_GET_S8 bfd_h_get_signed_8 + + +/* Extracted from bfdio.c. */ +long bfd_get_mtime (bfd *abfd); + +long bfd_get_size (bfd *abfd); + +/* Extracted from bfdwin.c. */ +/* Extracted from section.c. */ +typedef struct bfd_section +{ + /* The name of the section; the name isn't a copy, the pointer is + the same as that passed to bfd_make_section. */ + const char *name; + + /* A unique sequence number. */ + int id; + + /* Which section in the bfd; 0..n-1 as sections are created in a bfd. */ + int index; + + /* The next section in the list belonging to the BFD, or NULL. */ + struct bfd_section *next; + + /* The previous section in the list belonging to the BFD, or NULL. */ + struct bfd_section *prev; + + /* The field flags contains attributes of the section. Some + flags are read in from the object file, and some are + synthesized from other information. */ + flagword flags; + +#define SEC_NO_FLAGS 0x000 + + /* Tells the OS to allocate space for this section when loading. + This is clear for a section containing debug information only. */ +#define SEC_ALLOC 0x001 + + /* Tells the OS to load the section from the file when loading. + This is clear for a .bss section. */ +#define SEC_LOAD 0x002 + + /* The section contains data still to be relocated, so there is + some relocation information too. */ +#define SEC_RELOC 0x004 + + /* A signal to the OS that the section contains read only data. */ +#define SEC_READONLY 0x008 + + /* The section contains code only. */ +#define SEC_CODE 0x010 + + /* The section contains data only. */ +#define SEC_DATA 0x020 + + /* The section will reside in ROM. */ +#define SEC_ROM 0x040 + + /* The section contains constructor information. This section + type is used by the linker to create lists of constructors and + destructors used by <>. When a back end sees a symbol + which should be used in a constructor list, it creates a new + section for the type of name (e.g., <<__CTOR_LIST__>>), attaches + the symbol to it, and builds a relocation. To build the lists + of constructors, all the linker has to do is catenate all the + sections called <<__CTOR_LIST__>> and relocate the data + contained within - exactly the operations it would peform on + standard data. */ +#define SEC_CONSTRUCTOR 0x080 + + /* The section has contents - a data section could be + <> | <>; a debug section could be + <> */ +#define SEC_HAS_CONTENTS 0x100 + + /* An instruction to the linker to not output the section + even if it has information which would normally be written. */ +#define SEC_NEVER_LOAD 0x200 + + /* The section contains thread local data. */ +#define SEC_THREAD_LOCAL 0x400 + + /* The section has GOT references. This flag is only for the + linker, and is currently only used by the elf32-hppa back end. + It will be set if global offset table references were detected + in this section, which indicate to the linker that the section + contains PIC code, and must be handled specially when doing a + static link. */ +#define SEC_HAS_GOT_REF 0x800 + + /* The section contains common symbols (symbols may be defined + multiple times, the value of a symbol is the amount of + space it requires, and the largest symbol value is the one + used). Most targets have exactly one of these (which we + translate to bfd_com_section_ptr), but ECOFF has two. */ +#define SEC_IS_COMMON 0x1000 + + /* The section contains only debugging information. For + example, this is set for ELF .debug and .stab sections. + strip tests this flag to see if a section can be + discarded. */ +#define SEC_DEBUGGING 0x2000 + + /* The contents of this section are held in memory pointed to + by the contents field. This is checked by bfd_get_section_contents, + and the data is retrieved from memory if appropriate. */ +#define SEC_IN_MEMORY 0x4000 + + /* The contents of this section are to be excluded by the + linker for executable and shared objects unless those + objects are to be further relocated. */ +#define SEC_EXCLUDE 0x8000 + + /* The contents of this section are to be sorted based on the sum of + the symbol and addend values specified by the associated relocation + entries. Entries without associated relocation entries will be + appended to the end of the section in an unspecified order. */ +#define SEC_SORT_ENTRIES 0x10000 + + /* When linking, duplicate sections of the same name should be + discarded, rather than being combined into a single section as + is usually done. This is similar to how common symbols are + handled. See SEC_LINK_DUPLICATES below. */ +#define SEC_LINK_ONCE 0x20000 + + /* If SEC_LINK_ONCE is set, this bitfield describes how the linker + should handle duplicate sections. */ +#define SEC_LINK_DUPLICATES 0x40000 + + /* This value for SEC_LINK_DUPLICATES means that duplicate + sections with the same name should simply be discarded. */ +#define SEC_LINK_DUPLICATES_DISCARD 0x0 + + /* This value for SEC_LINK_DUPLICATES means that the linker + should warn if there are any duplicate sections, although + it should still only link one copy. */ +#define SEC_LINK_DUPLICATES_ONE_ONLY 0x80000 + + /* This value for SEC_LINK_DUPLICATES means that the linker + should warn if any duplicate sections are a different size. */ +#define SEC_LINK_DUPLICATES_SAME_SIZE 0x100000 + + /* This value for SEC_LINK_DUPLICATES means that the linker + should warn if any duplicate sections contain different + contents. */ +#define SEC_LINK_DUPLICATES_SAME_CONTENTS \ + (SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE) + + /* This section was created by the linker as part of dynamic + relocation or other arcane processing. It is skipped when + going through the first-pass output, trusting that someone + else up the line will take care of it later. */ +#define SEC_LINKER_CREATED 0x200000 + + /* This section should not be subject to garbage collection. */ +#define SEC_KEEP 0x400000 + + /* This section contains "short" data, and should be placed + "near" the GP. */ +#define SEC_SMALL_DATA 0x800000 + + /* Attempt to merge identical entities in the section. + Entity size is given in the entsize field. */ +#define SEC_MERGE 0x1000000 + + /* If given with SEC_MERGE, entities to merge are zero terminated + strings where entsize specifies character size instead of fixed + size entries. */ +#define SEC_STRINGS 0x2000000 + + /* This section contains data about section groups. */ +#define SEC_GROUP 0x4000000 + + /* The section is a COFF shared library section. This flag is + only for the linker. If this type of section appears in + the input file, the linker must copy it to the output file + without changing the vma or size. FIXME: Although this + was originally intended to be general, it really is COFF + specific (and the flag was renamed to indicate this). It + might be cleaner to have some more general mechanism to + allow the back end to control what the linker does with + sections. */ +#define SEC_COFF_SHARED_LIBRARY 0x10000000 + + /* This section contains data which may be shared with other + executables or shared objects. This is for COFF only. */ +#define SEC_COFF_SHARED 0x20000000 + + /* When a section with this flag is being linked, then if the size of + the input section is less than a page, it should not cross a page + boundary. If the size of the input section is one page or more, + it should be aligned on a page boundary. This is for TI + TMS320C54X only. */ +#define SEC_TIC54X_BLOCK 0x40000000 + + /* Conditionally link this section; do not link if there are no + references found to any symbol in the section. This is for TI + TMS320C54X only. */ +#define SEC_TIC54X_CLINK 0x80000000 + + /* End of section flags. */ + + /* Some internal packed boolean fields. */ + + /* See the vma field. */ + unsigned int user_set_vma : 1; + + /* A mark flag used by some of the linker backends. */ + unsigned int linker_mark : 1; + + /* Another mark flag used by some of the linker backends. Set for + output sections that have an input section. */ + unsigned int linker_has_input : 1; + + /* Mark flags used by some linker backends for garbage collection. */ + unsigned int gc_mark : 1; + unsigned int gc_mark_from_eh : 1; + + /* The following flags are used by the ELF linker. */ + + /* Mark sections which have been allocated to segments. */ + unsigned int segment_mark : 1; + + /* Type of sec_info information. */ + unsigned int sec_info_type:3; +#define ELF_INFO_TYPE_NONE 0 +#define ELF_INFO_TYPE_STABS 1 +#define ELF_INFO_TYPE_MERGE 2 +#define ELF_INFO_TYPE_EH_FRAME 3 +#define ELF_INFO_TYPE_JUST_SYMS 4 + + /* Nonzero if this section uses RELA relocations, rather than REL. */ + unsigned int use_rela_p:1; + + /* Bits used by various backends. The generic code doesn't touch + these fields. */ + + /* Nonzero if this section has TLS related relocations. */ + unsigned int has_tls_reloc:1; + + /* Nonzero if this section has a gp reloc. */ + unsigned int has_gp_reloc:1; + + /* Nonzero if this section needs the relax finalize pass. */ + unsigned int need_finalize_relax:1; + + /* Whether relocations have been processed. */ + unsigned int reloc_done : 1; + + /* End of internal packed boolean fields. */ + + /* The virtual memory address of the section - where it will be + at run time. The symbols are relocated against this. The + user_set_vma flag is maintained by bfd; if it's not set, the + backend can assign addresses (for example, in <>, where + the default address for <<.data>> is dependent on the specific + target and various flags). */ + bfd_vma vma; + + /* The load address of the section - where it would be in a + rom image; really only used for writing section header + information. */ + bfd_vma lma; + + /* The size of the section in octets, as it will be output. + Contains a value even if the section has no contents (e.g., the + size of <<.bss>>). */ + bfd_size_type size; + + /* For input sections, the original size on disk of the section, in + octets. This field is used by the linker relaxation code. It is + currently only set for sections where the linker relaxation scheme + doesn't cache altered section and reloc contents (stabs, eh_frame, + SEC_MERGE, some coff relaxing targets), and thus the original size + needs to be kept to read the section multiple times. + For output sections, rawsize holds the section size calculated on + a previous linker relaxation pass. */ + bfd_size_type rawsize; + + /* If this section is going to be output, then this value is the + offset in *bytes* into the output section of the first byte in the + input section (byte ==> smallest addressable unit on the + target). In most cases, if this was going to start at the + 100th octet (8-bit quantity) in the output section, this value + would be 100. However, if the target byte size is 16 bits + (bfd_octets_per_byte is "2"), this value would be 50. */ + bfd_vma output_offset; + + /* The output section through which to map on output. */ + struct bfd_section *output_section; + + /* The alignment requirement of the section, as an exponent of 2 - + e.g., 3 aligns to 2^3 (or 8). */ + unsigned int alignment_power; + + /* If an input section, a pointer to a vector of relocation + records for the data in this section. */ + struct reloc_cache_entry *relocation; + + /* If an output section, a pointer to a vector of pointers to + relocation records for the data in this section. */ + struct reloc_cache_entry **orelocation; + + /* The number of relocation records in one of the above. */ + unsigned reloc_count; + + /* Information below is back end specific - and not always used + or updated. */ + + /* File position of section data. */ + file_ptr filepos; + + /* File position of relocation info. */ + file_ptr rel_filepos; + + /* File position of line data. */ + file_ptr line_filepos; + + /* Pointer to data for applications. */ + void *userdata; + + /* If the SEC_IN_MEMORY flag is set, this points to the actual + contents. */ + unsigned char *contents; + + /* Attached line number information. */ + alent *lineno; + + /* Number of line number records. */ + unsigned int lineno_count; + + /* Entity size for merging purposes. */ + unsigned int entsize; + + /* Points to the kept section if this section is a link-once section, + and is discarded. */ + struct bfd_section *kept_section; + + /* When a section is being output, this value changes as more + linenumbers are written out. */ + file_ptr moving_line_filepos; + + /* What the section number is in the target world. */ + int target_index; + + void *used_by_bfd; + + /* If this is a constructor section then here is a list of the + relocations created to relocate items within it. */ + struct relent_chain *constructor_chain; + + /* The BFD which owns the section. */ + bfd *owner; + + /* A symbol which points at this section only. */ + struct bfd_symbol *symbol; + struct bfd_symbol **symbol_ptr_ptr; + + /* Early in the link process, map_head and map_tail are used to build + a list of input sections attached to an output section. Later, + output sections use these fields for a list of bfd_link_order + structs. */ + union { + struct bfd_link_order *link_order; + struct bfd_section *s; + } map_head, map_tail; +} asection; + +/* These sections are global, and are managed by BFD. The application + and target back end are not permitted to change the values in + these sections. New code should use the section_ptr macros rather + than referring directly to the const sections. The const sections + may eventually vanish. */ +#define BFD_ABS_SECTION_NAME "*ABS*" +#define BFD_UND_SECTION_NAME "*UND*" +#define BFD_COM_SECTION_NAME "*COM*" +#define BFD_IND_SECTION_NAME "*IND*" + +/* The absolute section. */ +extern asection bfd_abs_section; +#define bfd_abs_section_ptr ((asection *) &bfd_abs_section) +#define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr) +/* Pointer to the undefined section. */ +extern asection bfd_und_section; +#define bfd_und_section_ptr ((asection *) &bfd_und_section) +#define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr) +/* Pointer to the common section. */ +extern asection bfd_com_section; +#define bfd_com_section_ptr ((asection *) &bfd_com_section) +/* Pointer to the indirect section. */ +extern asection bfd_ind_section; +#define bfd_ind_section_ptr ((asection *) &bfd_ind_section) +#define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr) + +#define bfd_is_const_section(SEC) \ + ( ((SEC) == bfd_abs_section_ptr) \ + || ((SEC) == bfd_und_section_ptr) \ + || ((SEC) == bfd_com_section_ptr) \ + || ((SEC) == bfd_ind_section_ptr)) + +extern const struct bfd_symbol * const bfd_abs_symbol; +extern const struct bfd_symbol * const bfd_com_symbol; +extern const struct bfd_symbol * const bfd_und_symbol; +extern const struct bfd_symbol * const bfd_ind_symbol; + +/* Macros to handle insertion and deletion of a bfd's sections. These + only handle the list pointers, ie. do not adjust section_count, + target_index etc. */ +#define bfd_section_list_remove(ABFD, S) \ + do \ + { \ + asection *_s = S; \ + asection *_next = _s->next; \ + asection *_prev = _s->prev; \ + if (_prev) \ + _prev->next = _next; \ + else \ + (ABFD)->sections = _next; \ + if (_next) \ + _next->prev = _prev; \ + else \ + (ABFD)->section_last = _prev; \ + } \ + while (0) +#define bfd_section_list_append(ABFD, S) \ + do \ + { \ + asection *_s = S; \ + bfd *_abfd = ABFD; \ + _s->next = NULL; \ + if (_abfd->section_last) \ + { \ + _s->prev = _abfd->section_last; \ + _abfd->section_last->next = _s; \ + } \ + else \ + { \ + _s->prev = NULL; \ + _abfd->sections = _s; \ + } \ + _abfd->section_last = _s; \ + } \ + while (0) +#define bfd_section_list_prepend(ABFD, S) \ + do \ + { \ + asection *_s = S; \ + bfd *_abfd = ABFD; \ + _s->prev = NULL; \ + if (_abfd->sections) \ + { \ + _s->next = _abfd->sections; \ + _abfd->sections->prev = _s; \ + } \ + else \ + { \ + _s->next = NULL; \ + _abfd->section_last = _s; \ + } \ + _abfd->sections = _s; \ + } \ + while (0) +#define bfd_section_list_insert_after(ABFD, A, S) \ + do \ + { \ + asection *_a = A; \ + asection *_s = S; \ + asection *_next = _a->next; \ + _s->next = _next; \ + _s->prev = _a; \ + _a->next = _s; \ + if (_next) \ + _next->prev = _s; \ + else \ + (ABFD)->section_last = _s; \ + } \ + while (0) +#define bfd_section_list_insert_before(ABFD, B, S) \ + do \ + { \ + asection *_b = B; \ + asection *_s = S; \ + asection *_prev = _b->prev; \ + _s->prev = _prev; \ + _s->next = _b; \ + _b->prev = _s; \ + if (_prev) \ + _prev->next = _s; \ + else \ + (ABFD)->sections = _s; \ + } \ + while (0) +#define bfd_section_removed_from_list(ABFD, S) \ + ((S)->next == NULL ? (ABFD)->section_last != (S) : (S)->next->prev != (S)) + +void bfd_section_list_clear (bfd *); + +asection *bfd_get_section_by_name (bfd *abfd, const char *name); + +asection *bfd_get_section_by_name_if + (bfd *abfd, + const char *name, + bfd_boolean (*func) (bfd *abfd, asection *sect, void *obj), + void *obj); + +char *bfd_get_unique_section_name + (bfd *abfd, const char *templat, int *count); + +asection *bfd_make_section_old_way (bfd *abfd, const char *name); + +asection *bfd_make_section_anyway_with_flags + (bfd *abfd, const char *name, flagword flags); + +asection *bfd_make_section_anyway (bfd *abfd, const char *name); + +asection *bfd_make_section_with_flags + (bfd *, const char *name, flagword flags); + +asection *bfd_make_section (bfd *, const char *name); + +bfd_boolean bfd_set_section_flags + (bfd *abfd, asection *sec, flagword flags); + +void bfd_map_over_sections + (bfd *abfd, + void (*func) (bfd *abfd, asection *sect, void *obj), + void *obj); + +asection *bfd_sections_find_if + (bfd *abfd, + bfd_boolean (*operation) (bfd *abfd, asection *sect, void *obj), + void *obj); + +bfd_boolean bfd_set_section_size + (bfd *abfd, asection *sec, bfd_size_type val); + +bfd_boolean bfd_set_section_contents + (bfd *abfd, asection *section, const void *data, + file_ptr offset, bfd_size_type count); + +bfd_boolean bfd_get_section_contents + (bfd *abfd, asection *section, void *location, file_ptr offset, + bfd_size_type count); + +bfd_boolean bfd_malloc_and_get_section + (bfd *abfd, asection *section, bfd_byte **buf); + +bfd_boolean bfd_copy_private_section_data + (bfd *ibfd, asection *isec, bfd *obfd, asection *osec); + +#define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \ + BFD_SEND (obfd, _bfd_copy_private_section_data, \ + (ibfd, isection, obfd, osection)) +bfd_boolean bfd_generic_is_group_section (bfd *, const asection *sec); + +bfd_boolean bfd_generic_discard_group (bfd *abfd, asection *group); + +/* Extracted from archures.c. */ +enum bfd_architecture +{ + bfd_arch_unknown, /* File arch not known. */ + bfd_arch_obscure, /* Arch known, not one of these. */ + bfd_arch_m68k, /* Motorola 68xxx */ +#define bfd_mach_m68000 1 +#define bfd_mach_m68008 2 +#define bfd_mach_m68010 3 +#define bfd_mach_m68020 4 +#define bfd_mach_m68030 5 +#define bfd_mach_m68040 6 +#define bfd_mach_m68060 7 +#define bfd_mach_cpu32 8 +#define bfd_mach_mcf5200 9 +#define bfd_mach_mcf5206e 10 +#define bfd_mach_mcf5307 11 +#define bfd_mach_mcf5407 12 +#define bfd_mach_mcf528x 13 +#define bfd_mach_mcfv4e 14 +#define bfd_mach_mcf521x 15 +#define bfd_mach_mcf5249 16 +#define bfd_mach_mcf547x 17 +#define bfd_mach_mcf548x 18 + bfd_arch_vax, /* DEC Vax */ + bfd_arch_i960, /* Intel 960 */ + /* The order of the following is important. + lower number indicates a machine type that + only accepts a subset of the instructions + available to machines with higher numbers. + The exception is the "ca", which is + incompatible with all other machines except + "core". */ + +#define bfd_mach_i960_core 1 +#define bfd_mach_i960_ka_sa 2 +#define bfd_mach_i960_kb_sb 3 +#define bfd_mach_i960_mc 4 +#define bfd_mach_i960_xa 5 +#define bfd_mach_i960_ca 6 +#define bfd_mach_i960_jx 7 +#define bfd_mach_i960_hx 8 + + bfd_arch_or32, /* OpenRISC 32 */ + + bfd_arch_a29k, /* AMD 29000 */ + bfd_arch_sparc, /* SPARC */ +#define bfd_mach_sparc 1 +/* The difference between v8plus and v9 is that v9 is a true 64 bit env. */ +#define bfd_mach_sparc_sparclet 2 +#define bfd_mach_sparc_sparclite 3 +#define bfd_mach_sparc_v8plus 4 +#define bfd_mach_sparc_v8plusa 5 /* with ultrasparc add'ns. */ +#define bfd_mach_sparc_sparclite_le 6 +#define bfd_mach_sparc_v9 7 +#define bfd_mach_sparc_v9a 8 /* with ultrasparc add'ns. */ +#define bfd_mach_sparc_v8plusb 9 /* with cheetah add'ns. */ +#define bfd_mach_sparc_v9b 10 /* with cheetah add'ns. */ +/* Nonzero if MACH has the v9 instruction set. */ +#define bfd_mach_sparc_v9_p(mach) \ + ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9b \ + && (mach) != bfd_mach_sparc_sparclite_le) +/* Nonzero if MACH is a 64 bit sparc architecture. */ +#define bfd_mach_sparc_64bit_p(mach) \ + ((mach) >= bfd_mach_sparc_v9 && (mach) != bfd_mach_sparc_v8plusb) + bfd_arch_mips, /* MIPS Rxxxx */ +#define bfd_mach_mips3000 3000 +#define bfd_mach_mips3900 3900 +#define bfd_mach_mips4000 4000 +#define bfd_mach_mips4010 4010 +#define bfd_mach_mips4100 4100 +#define bfd_mach_mips4111 4111 +#define bfd_mach_mips4120 4120 +#define bfd_mach_mips4300 4300 +#define bfd_mach_mips4400 4400 +#define bfd_mach_mips4600 4600 +#define bfd_mach_mips4650 4650 +#define bfd_mach_mips5000 5000 +#define bfd_mach_mips5400 5400 +#define bfd_mach_mips5500 5500 +#define bfd_mach_mips6000 6000 +#define bfd_mach_mips7000 7000 +#define bfd_mach_mips8000 8000 +#define bfd_mach_mips9000 9000 +#define bfd_mach_mips10000 10000 +#define bfd_mach_mips12000 12000 +#define bfd_mach_mips16 16 +#define bfd_mach_mips5 5 +#define bfd_mach_mips_sb1 12310201 /* octal 'SB', 01 */ +#define bfd_mach_mipsisa32 32 +#define bfd_mach_mipsisa32r2 33 +#define bfd_mach_mipsisa64 64 +#define bfd_mach_mipsisa64r2 65 + bfd_arch_i386, /* Intel 386 */ +#define bfd_mach_i386_i386 1 +#define bfd_mach_i386_i8086 2 +#define bfd_mach_i386_i386_intel_syntax 3 +#define bfd_mach_x86_64 64 +#define bfd_mach_x86_64_intel_syntax 65 + bfd_arch_we32k, /* AT&T WE32xxx */ + bfd_arch_tahoe, /* CCI/Harris Tahoe */ + bfd_arch_i860, /* Intel 860 */ + bfd_arch_i370, /* IBM 360/370 Mainframes */ + bfd_arch_romp, /* IBM ROMP PC/RT */ + bfd_arch_alliant, /* Alliant */ + bfd_arch_convex, /* Convex */ + bfd_arch_m88k, /* Motorola 88xxx */ + bfd_arch_m98k, /* Motorola 98xxx */ + bfd_arch_pyramid, /* Pyramid Technology */ + bfd_arch_h8300, /* Renesas H8/300 (formerly Hitachi H8/300) */ +#define bfd_mach_h8300 1 +#define bfd_mach_h8300h 2 +#define bfd_mach_h8300s 3 +#define bfd_mach_h8300hn 4 +#define bfd_mach_h8300sn 5 +#define bfd_mach_h8300sx 6 +#define bfd_mach_h8300sxn 7 + bfd_arch_pdp11, /* DEC PDP-11 */ + bfd_arch_powerpc, /* PowerPC */ +#define bfd_mach_ppc 32 +#define bfd_mach_ppc64 64 +#define bfd_mach_ppc_403 403 +#define bfd_mach_ppc_403gc 4030 +#define bfd_mach_ppc_505 505 +#define bfd_mach_ppc_601 601 +#define bfd_mach_ppc_602 602 +#define bfd_mach_ppc_603 603 +#define bfd_mach_ppc_ec603e 6031 +#define bfd_mach_ppc_604 604 +#define bfd_mach_ppc_620 620 +#define bfd_mach_ppc_630 630 +#define bfd_mach_ppc_750 750 +#define bfd_mach_ppc_860 860 +#define bfd_mach_ppc_a35 35 +#define bfd_mach_ppc_rs64ii 642 +#define bfd_mach_ppc_rs64iii 643 +#define bfd_mach_ppc_7400 7400 +#define bfd_mach_ppc_e500 500 + bfd_arch_rs6000, /* IBM RS/6000 */ +#define bfd_mach_rs6k 6000 +#define bfd_mach_rs6k_rs1 6001 +#define bfd_mach_rs6k_rsc 6003 +#define bfd_mach_rs6k_rs2 6002 + bfd_arch_hppa, /* HP PA RISC */ +#define bfd_mach_hppa10 10 +#define bfd_mach_hppa11 11 +#define bfd_mach_hppa20 20 +#define bfd_mach_hppa20w 25 + bfd_arch_d10v, /* Mitsubishi D10V */ +#define bfd_mach_d10v 1 +#define bfd_mach_d10v_ts2 2 +#define bfd_mach_d10v_ts3 3 + bfd_arch_d30v, /* Mitsubishi D30V */ + bfd_arch_dlx, /* DLX */ + bfd_arch_m68hc11, /* Motorola 68HC11 */ + bfd_arch_m68hc12, /* Motorola 68HC12 */ +#define bfd_mach_m6812_default 0 +#define bfd_mach_m6812 1 +#define bfd_mach_m6812s 2 + bfd_arch_z8k, /* Zilog Z8000 */ +#define bfd_mach_z8001 1 +#define bfd_mach_z8002 2 + bfd_arch_h8500, /* Renesas H8/500 (formerly Hitachi H8/500) */ + bfd_arch_sh, /* Renesas / SuperH SH (formerly Hitachi SH) */ +#define bfd_mach_sh 1 +#define bfd_mach_sh2 0x20 +#define bfd_mach_sh_dsp 0x2d +#define bfd_mach_sh2a 0x2a +#define bfd_mach_sh2a_nofpu 0x2b +#define bfd_mach_sh2a_nofpu_or_sh4_nommu_nofpu 0x2a1 +#define bfd_mach_sh2a_nofpu_or_sh3_nommu 0x2a2 +#define bfd_mach_sh2a_or_sh4 0x2a3 +#define bfd_mach_sh2a_or_sh3e 0x2a4 +#define bfd_mach_sh2e 0x2e +#define bfd_mach_sh3 0x30 +#define bfd_mach_sh3_nommu 0x31 +#define bfd_mach_sh3_dsp 0x3d +#define bfd_mach_sh3e 0x3e +#define bfd_mach_sh4 0x40 +#define bfd_mach_sh4_nofpu 0x41 +#define bfd_mach_sh4_nommu_nofpu 0x42 +#define bfd_mach_sh4a 0x4a +#define bfd_mach_sh4a_nofpu 0x4b +#define bfd_mach_sh4al_dsp 0x4d +#define bfd_mach_sh5 0x50 + bfd_arch_alpha, /* Dec Alpha */ +#define bfd_mach_alpha_ev4 0x10 +#define bfd_mach_alpha_ev5 0x20 +#define bfd_mach_alpha_ev6 0x30 + bfd_arch_arm, /* Advanced Risc Machines ARM. */ +#define bfd_mach_arm_unknown 0 +#define bfd_mach_arm_2 1 +#define bfd_mach_arm_2a 2 +#define bfd_mach_arm_3 3 +#define bfd_mach_arm_3M 4 +#define bfd_mach_arm_4 5 +#define bfd_mach_arm_4T 6 +#define bfd_mach_arm_5 7 +#define bfd_mach_arm_5T 8 +#define bfd_mach_arm_5TE 9 +#define bfd_mach_arm_XScale 10 +#define bfd_mach_arm_ep9312 11 +#define bfd_mach_arm_iWMMXt 12 + bfd_arch_ns32k, /* National Semiconductors ns32000 */ + bfd_arch_w65, /* WDC 65816 */ + bfd_arch_tic30, /* Texas Instruments TMS320C30 */ + bfd_arch_tic4x, /* Texas Instruments TMS320C3X/4X */ +#define bfd_mach_tic3x 30 +#define bfd_mach_tic4x 40 + bfd_arch_tic54x, /* Texas Instruments TMS320C54X */ + bfd_arch_tic80, /* TI TMS320c80 (MVP) */ + bfd_arch_v850, /* NEC V850 */ +#define bfd_mach_v850 1 +#define bfd_mach_v850e 'E' +#define bfd_mach_v850e1 '1' + bfd_arch_arc, /* ARC Cores */ +#define bfd_mach_arc_5 5 +#define bfd_mach_arc_6 6 +#define bfd_mach_arc_7 7 +#define bfd_mach_arc_8 8 + bfd_arch_m32c, /* Renesas M16C/M32C. */ +#define bfd_mach_m16c 0x75 +#define bfd_mach_m32c 0x78 + bfd_arch_m32r, /* Renesas M32R (formerly Mitsubishi M32R/D) */ +#define bfd_mach_m32r 1 /* For backwards compatibility. */ +#define bfd_mach_m32rx 'x' +#define bfd_mach_m32r2 '2' + bfd_arch_mn10200, /* Matsushita MN10200 */ + bfd_arch_mn10300, /* Matsushita MN10300 */ +#define bfd_mach_mn10300 300 +#define bfd_mach_am33 330 +#define bfd_mach_am33_2 332 + bfd_arch_fr30, +#define bfd_mach_fr30 0x46523330 + bfd_arch_frv, +#define bfd_mach_frv 1 +#define bfd_mach_frvsimple 2 +#define bfd_mach_fr300 300 +#define bfd_mach_fr400 400 +#define bfd_mach_fr450 450 +#define bfd_mach_frvtomcat 499 /* fr500 prototype */ +#define bfd_mach_fr500 500 +#define bfd_mach_fr550 550 + bfd_arch_mcore, + bfd_arch_ia64, /* HP/Intel ia64 */ +#define bfd_mach_ia64_elf64 64 +#define bfd_mach_ia64_elf32 32 + bfd_arch_ip2k, /* Ubicom IP2K microcontrollers. */ +#define bfd_mach_ip2022 1 +#define bfd_mach_ip2022ext 2 + bfd_arch_iq2000, /* Vitesse IQ2000. */ +#define bfd_mach_iq2000 1 +#define bfd_mach_iq10 2 + bfd_arch_ms1, +#define bfd_mach_ms1 1 +#define bfd_mach_mrisc2 2 + bfd_arch_pj, + bfd_arch_avr, /* Atmel AVR microcontrollers. */ +#define bfd_mach_avr1 1 +#define bfd_mach_avr2 2 +#define bfd_mach_avr3 3 +#define bfd_mach_avr4 4 +#define bfd_mach_avr5 5 + bfd_arch_cr16c, /* National Semiconductor CompactRISC. */ +#define bfd_mach_cr16c 1 + bfd_arch_crx, /* National Semiconductor CRX. */ +#define bfd_mach_crx 1 + bfd_arch_cris, /* Axis CRIS */ +#define bfd_mach_cris_v0_v10 255 +#define bfd_mach_cris_v32 32 +#define bfd_mach_cris_v10_v32 1032 + bfd_arch_s390, /* IBM s390 */ +#define bfd_mach_s390_31 31 +#define bfd_mach_s390_64 64 + bfd_arch_openrisc, /* OpenRISC */ + bfd_arch_mmix, /* Donald Knuth's educational processor. */ + bfd_arch_xstormy16, +#define bfd_mach_xstormy16 1 + bfd_arch_msp430, /* Texas Instruments MSP430 architecture. */ +#define bfd_mach_msp11 11 +#define bfd_mach_msp110 110 +#define bfd_mach_msp12 12 +#define bfd_mach_msp13 13 +#define bfd_mach_msp14 14 +#define bfd_mach_msp15 15 +#define bfd_mach_msp16 16 +#define bfd_mach_msp31 31 +#define bfd_mach_msp32 32 +#define bfd_mach_msp33 33 +#define bfd_mach_msp41 41 +#define bfd_mach_msp42 42 +#define bfd_mach_msp43 43 +#define bfd_mach_msp44 44 + bfd_arch_xtensa, /* Tensilica's Xtensa cores. */ +#define bfd_mach_xtensa 1 + bfd_arch_maxq, /* Dallas MAXQ 10/20 */ +#define bfd_mach_maxq10 10 +#define bfd_mach_maxq20 20 + bfd_arch_last + }; + +typedef struct bfd_arch_info +{ + int bits_per_word; + int bits_per_address; + int bits_per_byte; + enum bfd_architecture arch; + unsigned long mach; + const char *arch_name; + const char *printable_name; + unsigned int section_align_power; + /* TRUE if this is the default machine for the architecture. + The default arch should be the first entry for an arch so that + all the entries for that arch can be accessed via <>. */ + bfd_boolean the_default; + const struct bfd_arch_info * (*compatible) + (const struct bfd_arch_info *a, const struct bfd_arch_info *b); + + bfd_boolean (*scan) (const struct bfd_arch_info *, const char *); + + const struct bfd_arch_info *next; +} +bfd_arch_info_type; + +const char *bfd_printable_name (bfd *abfd); + +const bfd_arch_info_type *bfd_scan_arch (const char *string); + +const char **bfd_arch_list (void); + +const bfd_arch_info_type *bfd_arch_get_compatible + (const bfd *abfd, const bfd *bbfd, bfd_boolean accept_unknowns); + +void bfd_set_arch_info (bfd *abfd, const bfd_arch_info_type *arg); + +enum bfd_architecture bfd_get_arch (bfd *abfd); + +unsigned long bfd_get_mach (bfd *abfd); + +unsigned int bfd_arch_bits_per_byte (bfd *abfd); + +unsigned int bfd_arch_bits_per_address (bfd *abfd); + +const bfd_arch_info_type *bfd_get_arch_info (bfd *abfd); + +const bfd_arch_info_type *bfd_lookup_arch + (enum bfd_architecture arch, unsigned long machine); + +const char *bfd_printable_arch_mach + (enum bfd_architecture arch, unsigned long machine); + +unsigned int bfd_octets_per_byte (bfd *abfd); + +unsigned int bfd_arch_mach_octets_per_byte + (enum bfd_architecture arch, unsigned long machine); + +/* Extracted from reloc.c. */ +typedef enum bfd_reloc_status +{ + /* No errors detected. */ + bfd_reloc_ok, + + /* The relocation was performed, but there was an overflow. */ + bfd_reloc_overflow, + + /* The address to relocate was not within the section supplied. */ + bfd_reloc_outofrange, + + /* Used by special functions. */ + bfd_reloc_continue, + + /* Unsupported relocation size requested. */ + bfd_reloc_notsupported, + + /* Unused. */ + bfd_reloc_other, + + /* The symbol to relocate against was undefined. */ + bfd_reloc_undefined, + + /* The relocation was performed, but may not be ok - presently + generated only when linking i960 coff files with i960 b.out + symbols. If this type is returned, the error_message argument + to bfd_perform_relocation will be set. */ + bfd_reloc_dangerous + } + bfd_reloc_status_type; + + +typedef struct reloc_cache_entry +{ + /* A pointer into the canonical table of pointers. */ + struct bfd_symbol **sym_ptr_ptr; + + /* offset in section. */ + bfd_size_type address; + + /* addend for relocation value. */ + bfd_vma addend; + + /* Pointer to how to perform the required relocation. */ + reloc_howto_type *howto; + +} +arelent; + +enum complain_overflow +{ + /* Do not complain on overflow. */ + complain_overflow_dont, + + /* Complain if the bitfield overflows, whether it is considered + as signed or unsigned. */ + complain_overflow_bitfield, + + /* Complain if the value overflows when considered as signed + number. */ + complain_overflow_signed, + + /* Complain if the value overflows when considered as an + unsigned number. */ + complain_overflow_unsigned +}; + +struct reloc_howto_struct +{ + /* The type field has mainly a documentary use - the back end can + do what it wants with it, though normally the back end's + external idea of what a reloc number is stored + in this field. For example, a PC relative word relocation + in a coff environment has the type 023 - because that's + what the outside world calls a R_PCRWORD reloc. */ + unsigned int type; + + /* The value the final relocation is shifted right by. This drops + unwanted data from the relocation. */ + unsigned int rightshift; + + /* The size of the item to be relocated. This is *not* a + power-of-two measure. To get the number of bytes operated + on by a type of relocation, use bfd_get_reloc_size. */ + int size; + + /* The number of bits in the item to be relocated. This is used + when doing overflow checking. */ + unsigned int bitsize; + + /* Notes that the relocation is relative to the location in the + data section of the addend. The relocation function will + subtract from the relocation value the address of the location + being relocated. */ + bfd_boolean pc_relative; + + /* The bit position of the reloc value in the destination. + The relocated value is left shifted by this amount. */ + unsigned int bitpos; + + /* What type of overflow error should be checked for when + relocating. */ + enum complain_overflow complain_on_overflow; + + /* If this field is non null, then the supplied function is + called rather than the normal function. This allows really + strange relocation methods to be accommodated (e.g., i960 callj + instructions). */ + bfd_reloc_status_type (*special_function) + (bfd *, arelent *, struct bfd_symbol *, void *, asection *, + bfd *, char **); + + /* The textual name of the relocation type. */ + char *name; + + /* Some formats record a relocation addend in the section contents + rather than with the relocation. For ELF formats this is the + distinction between USE_REL and USE_RELA (though the code checks + for USE_REL == 1/0). The value of this field is TRUE if the + addend is recorded with the section contents; when performing a + partial link (ld -r) the section contents (the data) will be + modified. The value of this field is FALSE if addends are + recorded with the relocation (in arelent.addend); when performing + a partial link the relocation will be modified. + All relocations for all ELF USE_RELA targets should set this field + to FALSE (values of TRUE should be looked on with suspicion). + However, the converse is not true: not all relocations of all ELF + USE_REL targets set this field to TRUE. Why this is so is peculiar + to each particular target. For relocs that aren't used in partial + links (e.g. GOT stuff) it doesn't matter what this is set to. */ + bfd_boolean partial_inplace; + + /* src_mask selects the part of the instruction (or data) to be used + in the relocation sum. If the target relocations don't have an + addend in the reloc, eg. ELF USE_REL, src_mask will normally equal + dst_mask to extract the addend from the section contents. If + relocations do have an addend in the reloc, eg. ELF USE_RELA, this + field should be zero. Non-zero values for ELF USE_RELA targets are + bogus as in those cases the value in the dst_mask part of the + section contents should be treated as garbage. */ + bfd_vma src_mask; + + /* dst_mask selects which parts of the instruction (or data) are + replaced with a relocated value. */ + bfd_vma dst_mask; + + /* When some formats create PC relative instructions, they leave + the value of the pc of the place being relocated in the offset + slot of the instruction, so that a PC relative relocation can + be made just by adding in an ordinary offset (e.g., sun3 a.out). + Some formats leave the displacement part of an instruction + empty (e.g., m88k bcs); this flag signals the fact. */ + bfd_boolean pcrel_offset; +}; + +#define HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \ + { (unsigned) C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC } +#define NEWHOWTO(FUNCTION, NAME, SIZE, REL, IN) \ + HOWTO (0, 0, SIZE, 0, REL, 0, complain_overflow_dont, FUNCTION, \ + NAME, FALSE, 0, 0, IN) + +#define EMPTY_HOWTO(C) \ + HOWTO ((C), 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, \ + NULL, FALSE, 0, 0, FALSE) + +#define HOWTO_PREPARE(relocation, symbol) \ + { \ + if (symbol != NULL) \ + { \ + if (bfd_is_com_section (symbol->section)) \ + { \ + relocation = 0; \ + } \ + else \ + { \ + relocation = symbol->value; \ + } \ + } \ + } + +unsigned int bfd_get_reloc_size (reloc_howto_type *); + +typedef struct relent_chain +{ + arelent relent; + struct relent_chain *next; +} +arelent_chain; + +bfd_reloc_status_type bfd_check_overflow + (enum complain_overflow how, + unsigned int bitsize, + unsigned int rightshift, + unsigned int addrsize, + bfd_vma relocation); + +bfd_reloc_status_type bfd_perform_relocation + (bfd *abfd, + arelent *reloc_entry, + void *data, + asection *input_section, + bfd *output_bfd, + char **error_message); + +bfd_reloc_status_type bfd_install_relocation + (bfd *abfd, + arelent *reloc_entry, + void *data, bfd_vma data_start, + asection *input_section, + char **error_message); + +enum bfd_reloc_code_real { + _dummy_first_bfd_reloc_code_real, + + +/* Basic absolute relocations of N bits. */ + BFD_RELOC_64, + BFD_RELOC_32, + BFD_RELOC_26, + BFD_RELOC_24, + BFD_RELOC_16, + BFD_RELOC_14, + BFD_RELOC_8, + +/* PC-relative relocations. Sometimes these are relative to the address +of the relocation itself; sometimes they are relative to the start of +the section containing the relocation. It depends on the specific target. + +The 24-bit relocation is used in some Intel 960 configurations. */ + BFD_RELOC_64_PCREL, + BFD_RELOC_32_PCREL, + BFD_RELOC_24_PCREL, + BFD_RELOC_16_PCREL, + BFD_RELOC_12_PCREL, + BFD_RELOC_8_PCREL, + +/* Section relative relocations. Some targets need this for DWARF2. */ + BFD_RELOC_32_SECREL, + +/* For ELF. */ + BFD_RELOC_32_GOT_PCREL, + BFD_RELOC_16_GOT_PCREL, + BFD_RELOC_8_GOT_PCREL, + BFD_RELOC_32_GOTOFF, + BFD_RELOC_16_GOTOFF, + BFD_RELOC_LO16_GOTOFF, + BFD_RELOC_HI16_GOTOFF, + BFD_RELOC_HI16_S_GOTOFF, + BFD_RELOC_8_GOTOFF, + BFD_RELOC_64_PLT_PCREL, + BFD_RELOC_32_PLT_PCREL, + BFD_RELOC_24_PLT_PCREL, + BFD_RELOC_16_PLT_PCREL, + BFD_RELOC_8_PLT_PCREL, + BFD_RELOC_64_PLTOFF, + BFD_RELOC_32_PLTOFF, + BFD_RELOC_16_PLTOFF, + BFD_RELOC_LO16_PLTOFF, + BFD_RELOC_HI16_PLTOFF, + BFD_RELOC_HI16_S_PLTOFF, + BFD_RELOC_8_PLTOFF, + +/* Relocations used by 68K ELF. */ + BFD_RELOC_68K_GLOB_DAT, + BFD_RELOC_68K_JMP_SLOT, + BFD_RELOC_68K_RELATIVE, + +/* Linkage-table relative. */ + BFD_RELOC_32_BASEREL, + BFD_RELOC_16_BASEREL, + BFD_RELOC_LO16_BASEREL, + BFD_RELOC_HI16_BASEREL, + BFD_RELOC_HI16_S_BASEREL, + BFD_RELOC_8_BASEREL, + BFD_RELOC_RVA, + +/* Absolute 8-bit relocation, but used to form an address like 0xFFnn. */ + BFD_RELOC_8_FFnn, + +/* These PC-relative relocations are stored as word displacements -- +i.e., byte displacements shifted right two bits. The 30-bit word +displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the +SPARC. (SPARC tools generally refer to this as <>.) The +signed 16-bit displacement is used on the MIPS, and the 23-bit +displacement is used on the Alpha. */ + BFD_RELOC_32_PCREL_S2, + BFD_RELOC_16_PCREL_S2, + BFD_RELOC_23_PCREL_S2, + +/* High 22 bits and low 10 bits of 32-bit value, placed into lower bits of +the target word. These are used on the SPARC. */ + BFD_RELOC_HI22, + BFD_RELOC_LO10, + +/* For systems that allocate a Global Pointer register, these are +displacements off that register. These relocation types are +handled specially, because the value the register will have is +decided relatively late. */ + BFD_RELOC_GPREL16, + BFD_RELOC_GPREL32, + +/* Reloc types used for i960/b.out. */ + BFD_RELOC_I960_CALLJ, + +/* SPARC ELF relocations. There is probably some overlap with other +relocation types already defined. */ + BFD_RELOC_NONE, + BFD_RELOC_SPARC_WDISP22, + BFD_RELOC_SPARC22, + BFD_RELOC_SPARC13, + BFD_RELOC_SPARC_GOT10, + BFD_RELOC_SPARC_GOT13, + BFD_RELOC_SPARC_GOT22, + BFD_RELOC_SPARC_PC10, + BFD_RELOC_SPARC_PC22, + BFD_RELOC_SPARC_WPLT30, + BFD_RELOC_SPARC_COPY, + BFD_RELOC_SPARC_GLOB_DAT, + BFD_RELOC_SPARC_JMP_SLOT, + BFD_RELOC_SPARC_RELATIVE, + BFD_RELOC_SPARC_UA16, + BFD_RELOC_SPARC_UA32, + BFD_RELOC_SPARC_UA64, + +/* I think these are specific to SPARC a.out (e.g., Sun 4). */ + BFD_RELOC_SPARC_BASE13, + BFD_RELOC_SPARC_BASE22, + +/* SPARC64 relocations */ +#define BFD_RELOC_SPARC_64 BFD_RELOC_64 + BFD_RELOC_SPARC_10, + BFD_RELOC_SPARC_11, + BFD_RELOC_SPARC_OLO10, + BFD_RELOC_SPARC_HH22, + BFD_RELOC_SPARC_HM10, + BFD_RELOC_SPARC_LM22, + BFD_RELOC_SPARC_PC_HH22, + BFD_RELOC_SPARC_PC_HM10, + BFD_RELOC_SPARC_PC_LM22, + BFD_RELOC_SPARC_WDISP16, + BFD_RELOC_SPARC_WDISP19, + BFD_RELOC_SPARC_7, + BFD_RELOC_SPARC_6, + BFD_RELOC_SPARC_5, +#define BFD_RELOC_SPARC_DISP64 BFD_RELOC_64_PCREL + BFD_RELOC_SPARC_PLT32, + BFD_RELOC_SPARC_PLT64, + BFD_RELOC_SPARC_HIX22, + BFD_RELOC_SPARC_LOX10, + BFD_RELOC_SPARC_H44, + BFD_RELOC_SPARC_M44, + BFD_RELOC_SPARC_L44, + BFD_RELOC_SPARC_REGISTER, + +/* SPARC little endian relocation */ + BFD_RELOC_SPARC_REV32, + +/* SPARC TLS relocations */ + BFD_RELOC_SPARC_TLS_GD_HI22, + BFD_RELOC_SPARC_TLS_GD_LO10, + BFD_RELOC_SPARC_TLS_GD_ADD, + BFD_RELOC_SPARC_TLS_GD_CALL, + BFD_RELOC_SPARC_TLS_LDM_HI22, + BFD_RELOC_SPARC_TLS_LDM_LO10, + BFD_RELOC_SPARC_TLS_LDM_ADD, + BFD_RELOC_SPARC_TLS_LDM_CALL, + BFD_RELOC_SPARC_TLS_LDO_HIX22, + BFD_RELOC_SPARC_TLS_LDO_LOX10, + BFD_RELOC_SPARC_TLS_LDO_ADD, + BFD_RELOC_SPARC_TLS_IE_HI22, + BFD_RELOC_SPARC_TLS_IE_LO10, + BFD_RELOC_SPARC_TLS_IE_LD, + BFD_RELOC_SPARC_TLS_IE_LDX, + BFD_RELOC_SPARC_TLS_IE_ADD, + BFD_RELOC_SPARC_TLS_LE_HIX22, + BFD_RELOC_SPARC_TLS_LE_LOX10, + BFD_RELOC_SPARC_TLS_DTPMOD32, + BFD_RELOC_SPARC_TLS_DTPMOD64, + BFD_RELOC_SPARC_TLS_DTPOFF32, + BFD_RELOC_SPARC_TLS_DTPOFF64, + BFD_RELOC_SPARC_TLS_TPOFF32, + BFD_RELOC_SPARC_TLS_TPOFF64, + +/* Alpha ECOFF and ELF relocations. Some of these treat the symbol or +"addend" in some special way. +For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when +writing; when reading, it will be the absolute section symbol. The +addend is the displacement in bytes of the "lda" instruction from +the "ldah" instruction (which is at the address of this reloc). */ + BFD_RELOC_ALPHA_GPDISP_HI16, + +/* For GPDISP_LO16 ("ignore") relocations, the symbol is handled as +with GPDISP_HI16 relocs. The addend is ignored when writing the +relocations out, and is filled in with the file's GP value on +reading, for convenience. */ + BFD_RELOC_ALPHA_GPDISP_LO16, + +/* The ELF GPDISP relocation is exactly the same as the GPDISP_HI16 +relocation except that there is no accompanying GPDISP_LO16 +relocation. */ + BFD_RELOC_ALPHA_GPDISP, + +/* The Alpha LITERAL/LITUSE relocs are produced by a symbol reference; +the assembler turns it into a LDQ instruction to load the address of +the symbol, and then fills in a register in the real instruction. + +The LITERAL reloc, at the LDQ instruction, refers to the .lita +section symbol. The addend is ignored when writing, but is filled +in with the file's GP value on reading, for convenience, as with the +GPDISP_LO16 reloc. + +The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16. +It should refer to the symbol to be referenced, as with 16_GOTOFF, +but it generates output not based on the position within the .got +section, but relative to the GP value chosen for the file during the +final link stage. + +The LITUSE reloc, on the instruction using the loaded address, gives +information to the linker that it might be able to use to optimize +away some literal section references. The symbol is ignored (read +as the absolute section symbol), and the "addend" indicates the type +of instruction using the register: +1 - "memory" fmt insn +2 - byte-manipulation (byte offset reg) +3 - jsr (target of branch) */ + BFD_RELOC_ALPHA_LITERAL, + BFD_RELOC_ALPHA_ELF_LITERAL, + BFD_RELOC_ALPHA_LITUSE, + +/* The HINT relocation indicates a value that should be filled into the +"hint" field of a jmp/jsr/ret instruction, for possible branch- +prediction logic which may be provided on some processors. */ + BFD_RELOC_ALPHA_HINT, + +/* The LINKAGE relocation outputs a linkage pair in the object file, +which is filled by the linker. */ + BFD_RELOC_ALPHA_LINKAGE, + +/* The CODEADDR relocation outputs a STO_CA in the object file, +which is filled by the linker. */ + BFD_RELOC_ALPHA_CODEADDR, + +/* The GPREL_HI/LO relocations together form a 32-bit offset from the +GP register. */ + BFD_RELOC_ALPHA_GPREL_HI16, + BFD_RELOC_ALPHA_GPREL_LO16, + +/* Like BFD_RELOC_23_PCREL_S2, except that the source and target must +share a common GP, and the target address is adjusted for +STO_ALPHA_STD_GPLOAD. */ + BFD_RELOC_ALPHA_BRSGP, + +/* Alpha thread-local storage relocations. */ + BFD_RELOC_ALPHA_TLSGD, + BFD_RELOC_ALPHA_TLSLDM, + BFD_RELOC_ALPHA_DTPMOD64, + BFD_RELOC_ALPHA_GOTDTPREL16, + BFD_RELOC_ALPHA_DTPREL64, + BFD_RELOC_ALPHA_DTPREL_HI16, + BFD_RELOC_ALPHA_DTPREL_LO16, + BFD_RELOC_ALPHA_DTPREL16, + BFD_RELOC_ALPHA_GOTTPREL16, + BFD_RELOC_ALPHA_TPREL64, + BFD_RELOC_ALPHA_TPREL_HI16, + BFD_RELOC_ALPHA_TPREL_LO16, + BFD_RELOC_ALPHA_TPREL16, + +/* Bits 27..2 of the relocation address shifted right 2 bits; +simple reloc otherwise. */ + BFD_RELOC_MIPS_JMP, + +/* The MIPS16 jump instruction. */ + BFD_RELOC_MIPS16_JMP, + +/* MIPS16 GP relative reloc. */ + BFD_RELOC_MIPS16_GPREL, + +/* High 16 bits of 32-bit value; simple reloc. */ + BFD_RELOC_HI16, + +/* High 16 bits of 32-bit value but the low 16 bits will be sign +extended and added to form the final result. If the low 16 +bits form a negative number, we need to add one to the high value +to compensate for the borrow when the low bits are added. */ + BFD_RELOC_HI16_S, + +/* Low 16 bits. */ + BFD_RELOC_LO16, + +/* High 16 bits of 32-bit pc-relative value */ + BFD_RELOC_HI16_PCREL, + +/* High 16 bits of 32-bit pc-relative value, adjusted */ + BFD_RELOC_HI16_S_PCREL, + +/* Low 16 bits of pc-relative value */ + BFD_RELOC_LO16_PCREL, + +/* MIPS16 high 16 bits of 32-bit value. */ + BFD_RELOC_MIPS16_HI16, + +/* MIPS16 high 16 bits of 32-bit value but the low 16 bits will be sign +extended and added to form the final result. If the low 16 +bits form a negative number, we need to add one to the high value +to compensate for the borrow when the low bits are added. */ + BFD_RELOC_MIPS16_HI16_S, + +/* MIPS16 low 16 bits. */ + BFD_RELOC_MIPS16_LO16, + +/* Relocation against a MIPS literal section. */ + BFD_RELOC_MIPS_LITERAL, + +/* MIPS ELF relocations. */ + BFD_RELOC_MIPS_GOT16, + BFD_RELOC_MIPS_CALL16, + BFD_RELOC_MIPS_GOT_HI16, + BFD_RELOC_MIPS_GOT_LO16, + BFD_RELOC_MIPS_CALL_HI16, + BFD_RELOC_MIPS_CALL_LO16, + BFD_RELOC_MIPS_SUB, + BFD_RELOC_MIPS_GOT_PAGE, + BFD_RELOC_MIPS_GOT_OFST, + BFD_RELOC_MIPS_GOT_DISP, + BFD_RELOC_MIPS_SHIFT5, + BFD_RELOC_MIPS_SHIFT6, + BFD_RELOC_MIPS_INSERT_A, + BFD_RELOC_MIPS_INSERT_B, + BFD_RELOC_MIPS_DELETE, + BFD_RELOC_MIPS_HIGHEST, + BFD_RELOC_MIPS_HIGHER, + BFD_RELOC_MIPS_SCN_DISP, + BFD_RELOC_MIPS_REL16, + BFD_RELOC_MIPS_RELGOT, + BFD_RELOC_MIPS_JALR, + BFD_RELOC_MIPS_TLS_DTPMOD32, + BFD_RELOC_MIPS_TLS_DTPREL32, + BFD_RELOC_MIPS_TLS_DTPMOD64, + BFD_RELOC_MIPS_TLS_DTPREL64, + BFD_RELOC_MIPS_TLS_GD, + BFD_RELOC_MIPS_TLS_LDM, + BFD_RELOC_MIPS_TLS_DTPREL_HI16, + BFD_RELOC_MIPS_TLS_DTPREL_LO16, + BFD_RELOC_MIPS_TLS_GOTTPREL, + BFD_RELOC_MIPS_TLS_TPREL32, + BFD_RELOC_MIPS_TLS_TPREL64, + BFD_RELOC_MIPS_TLS_TPREL_HI16, + BFD_RELOC_MIPS_TLS_TPREL_LO16, + + +/* Fujitsu Frv Relocations. */ + BFD_RELOC_FRV_LABEL16, + BFD_RELOC_FRV_LABEL24, + BFD_RELOC_FRV_LO16, + BFD_RELOC_FRV_HI16, + BFD_RELOC_FRV_GPREL12, + BFD_RELOC_FRV_GPRELU12, + BFD_RELOC_FRV_GPREL32, + BFD_RELOC_FRV_GPRELHI, + BFD_RELOC_FRV_GPRELLO, + BFD_RELOC_FRV_GOT12, + BFD_RELOC_FRV_GOTHI, + BFD_RELOC_FRV_GOTLO, + BFD_RELOC_FRV_FUNCDESC, + BFD_RELOC_FRV_FUNCDESC_GOT12, + BFD_RELOC_FRV_FUNCDESC_GOTHI, + BFD_RELOC_FRV_FUNCDESC_GOTLO, + BFD_RELOC_FRV_FUNCDESC_VALUE, + BFD_RELOC_FRV_FUNCDESC_GOTOFF12, + BFD_RELOC_FRV_FUNCDESC_GOTOFFHI, + BFD_RELOC_FRV_FUNCDESC_GOTOFFLO, + BFD_RELOC_FRV_GOTOFF12, + BFD_RELOC_FRV_GOTOFFHI, + BFD_RELOC_FRV_GOTOFFLO, + BFD_RELOC_FRV_GETTLSOFF, + BFD_RELOC_FRV_TLSDESC_VALUE, + BFD_RELOC_FRV_GOTTLSDESC12, + BFD_RELOC_FRV_GOTTLSDESCHI, + BFD_RELOC_FRV_GOTTLSDESCLO, + BFD_RELOC_FRV_TLSMOFF12, + BFD_RELOC_FRV_TLSMOFFHI, + BFD_RELOC_FRV_TLSMOFFLO, + BFD_RELOC_FRV_GOTTLSOFF12, + BFD_RELOC_FRV_GOTTLSOFFHI, + BFD_RELOC_FRV_GOTTLSOFFLO, + BFD_RELOC_FRV_TLSOFF, + BFD_RELOC_FRV_TLSDESC_RELAX, + BFD_RELOC_FRV_GETTLSOFF_RELAX, + BFD_RELOC_FRV_TLSOFF_RELAX, + BFD_RELOC_FRV_TLSMOFF, + + +/* This is a 24bit GOT-relative reloc for the mn10300. */ + BFD_RELOC_MN10300_GOTOFF24, + +/* This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes +in the instruction. */ + BFD_RELOC_MN10300_GOT32, + +/* This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes +in the instruction. */ + BFD_RELOC_MN10300_GOT24, + +/* This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes +in the instruction. */ + BFD_RELOC_MN10300_GOT16, + +/* Copy symbol at runtime. */ + BFD_RELOC_MN10300_COPY, + +/* Create GOT entry. */ + BFD_RELOC_MN10300_GLOB_DAT, + +/* Create PLT entry. */ + BFD_RELOC_MN10300_JMP_SLOT, + +/* Adjust by program base. */ + BFD_RELOC_MN10300_RELATIVE, + + +/* i386/elf relocations */ + BFD_RELOC_386_GOT32, + BFD_RELOC_386_PLT32, + BFD_RELOC_386_COPY, + BFD_RELOC_386_GLOB_DAT, + BFD_RELOC_386_JUMP_SLOT, + BFD_RELOC_386_RELATIVE, + BFD_RELOC_386_GOTOFF, + BFD_RELOC_386_GOTPC, + BFD_RELOC_386_TLS_TPOFF, + BFD_RELOC_386_TLS_IE, + BFD_RELOC_386_TLS_GOTIE, + BFD_RELOC_386_TLS_LE, + BFD_RELOC_386_TLS_GD, + BFD_RELOC_386_TLS_LDM, + BFD_RELOC_386_TLS_LDO_32, + BFD_RELOC_386_TLS_IE_32, + BFD_RELOC_386_TLS_LE_32, + BFD_RELOC_386_TLS_DTPMOD32, + BFD_RELOC_386_TLS_DTPOFF32, + BFD_RELOC_386_TLS_TPOFF32, + +/* x86-64/elf relocations */ + BFD_RELOC_X86_64_GOT32, + BFD_RELOC_X86_64_PLT32, + BFD_RELOC_X86_64_COPY, + BFD_RELOC_X86_64_GLOB_DAT, + BFD_RELOC_X86_64_JUMP_SLOT, + BFD_RELOC_X86_64_RELATIVE, + BFD_RELOC_X86_64_GOTPCREL, + BFD_RELOC_X86_64_32S, + BFD_RELOC_X86_64_DTPMOD64, + BFD_RELOC_X86_64_DTPOFF64, + BFD_RELOC_X86_64_TPOFF64, + BFD_RELOC_X86_64_TLSGD, + BFD_RELOC_X86_64_TLSLD, + BFD_RELOC_X86_64_DTPOFF32, + BFD_RELOC_X86_64_GOTTPOFF, + BFD_RELOC_X86_64_TPOFF32, + BFD_RELOC_X86_64_GOTOFF64, + BFD_RELOC_X86_64_GOTPC32, + +/* ns32k relocations */ + BFD_RELOC_NS32K_IMM_8, + BFD_RELOC_NS32K_IMM_16, + BFD_RELOC_NS32K_IMM_32, + BFD_RELOC_NS32K_IMM_8_PCREL, + BFD_RELOC_NS32K_IMM_16_PCREL, + BFD_RELOC_NS32K_IMM_32_PCREL, + BFD_RELOC_NS32K_DISP_8, + BFD_RELOC_NS32K_DISP_16, + BFD_RELOC_NS32K_DISP_32, + BFD_RELOC_NS32K_DISP_8_PCREL, + BFD_RELOC_NS32K_DISP_16_PCREL, + BFD_RELOC_NS32K_DISP_32_PCREL, + +/* PDP11 relocations */ + BFD_RELOC_PDP11_DISP_8_PCREL, + BFD_RELOC_PDP11_DISP_6_PCREL, + +/* Picojava relocs. Not all of these appear in object files. */ + BFD_RELOC_PJ_CODE_HI16, + BFD_RELOC_PJ_CODE_LO16, + BFD_RELOC_PJ_CODE_DIR16, + BFD_RELOC_PJ_CODE_DIR32, + BFD_RELOC_PJ_CODE_REL16, + BFD_RELOC_PJ_CODE_REL32, + +/* Power(rs6000) and PowerPC relocations. */ + BFD_RELOC_PPC_B26, + BFD_RELOC_PPC_BA26, + BFD_RELOC_PPC_TOC16, + BFD_RELOC_PPC_B16, + BFD_RELOC_PPC_B16_BRTAKEN, + BFD_RELOC_PPC_B16_BRNTAKEN, + BFD_RELOC_PPC_BA16, + BFD_RELOC_PPC_BA16_BRTAKEN, + BFD_RELOC_PPC_BA16_BRNTAKEN, + BFD_RELOC_PPC_COPY, + BFD_RELOC_PPC_GLOB_DAT, + BFD_RELOC_PPC_JMP_SLOT, + BFD_RELOC_PPC_RELATIVE, + BFD_RELOC_PPC_LOCAL24PC, + BFD_RELOC_PPC_EMB_NADDR32, + BFD_RELOC_PPC_EMB_NADDR16, + BFD_RELOC_PPC_EMB_NADDR16_LO, + BFD_RELOC_PPC_EMB_NADDR16_HI, + BFD_RELOC_PPC_EMB_NADDR16_HA, + BFD_RELOC_PPC_EMB_SDAI16, + BFD_RELOC_PPC_EMB_SDA2I16, + BFD_RELOC_PPC_EMB_SDA2REL, + BFD_RELOC_PPC_EMB_SDA21, + BFD_RELOC_PPC_EMB_MRKREF, + BFD_RELOC_PPC_EMB_RELSEC16, + BFD_RELOC_PPC_EMB_RELST_LO, + BFD_RELOC_PPC_EMB_RELST_HI, + BFD_RELOC_PPC_EMB_RELST_HA, + BFD_RELOC_PPC_EMB_BIT_FLD, + BFD_RELOC_PPC_EMB_RELSDA, + BFD_RELOC_PPC64_HIGHER, + BFD_RELOC_PPC64_HIGHER_S, + BFD_RELOC_PPC64_HIGHEST, + BFD_RELOC_PPC64_HIGHEST_S, + BFD_RELOC_PPC64_TOC16_LO, + BFD_RELOC_PPC64_TOC16_HI, + BFD_RELOC_PPC64_TOC16_HA, + BFD_RELOC_PPC64_TOC, + BFD_RELOC_PPC64_PLTGOT16, + BFD_RELOC_PPC64_PLTGOT16_LO, + BFD_RELOC_PPC64_PLTGOT16_HI, + BFD_RELOC_PPC64_PLTGOT16_HA, + BFD_RELOC_PPC64_ADDR16_DS, + BFD_RELOC_PPC64_ADDR16_LO_DS, + BFD_RELOC_PPC64_GOT16_DS, + BFD_RELOC_PPC64_GOT16_LO_DS, + BFD_RELOC_PPC64_PLT16_LO_DS, + BFD_RELOC_PPC64_SECTOFF_DS, + BFD_RELOC_PPC64_SECTOFF_LO_DS, + BFD_RELOC_PPC64_TOC16_DS, + BFD_RELOC_PPC64_TOC16_LO_DS, + BFD_RELOC_PPC64_PLTGOT16_DS, + BFD_RELOC_PPC64_PLTGOT16_LO_DS, + +/* PowerPC and PowerPC64 thread-local storage relocations. */ + BFD_RELOC_PPC_TLS, + BFD_RELOC_PPC_DTPMOD, + BFD_RELOC_PPC_TPREL16, + BFD_RELOC_PPC_TPREL16_LO, + BFD_RELOC_PPC_TPREL16_HI, + BFD_RELOC_PPC_TPREL16_HA, + BFD_RELOC_PPC_TPREL, + BFD_RELOC_PPC_DTPREL16, + BFD_RELOC_PPC_DTPREL16_LO, + BFD_RELOC_PPC_DTPREL16_HI, + BFD_RELOC_PPC_DTPREL16_HA, + BFD_RELOC_PPC_DTPREL, + BFD_RELOC_PPC_GOT_TLSGD16, + BFD_RELOC_PPC_GOT_TLSGD16_LO, + BFD_RELOC_PPC_GOT_TLSGD16_HI, + BFD_RELOC_PPC_GOT_TLSGD16_HA, + BFD_RELOC_PPC_GOT_TLSLD16, + BFD_RELOC_PPC_GOT_TLSLD16_LO, + BFD_RELOC_PPC_GOT_TLSLD16_HI, + BFD_RELOC_PPC_GOT_TLSLD16_HA, + BFD_RELOC_PPC_GOT_TPREL16, + BFD_RELOC_PPC_GOT_TPREL16_LO, + BFD_RELOC_PPC_GOT_TPREL16_HI, + BFD_RELOC_PPC_GOT_TPREL16_HA, + BFD_RELOC_PPC_GOT_DTPREL16, + BFD_RELOC_PPC_GOT_DTPREL16_LO, + BFD_RELOC_PPC_GOT_DTPREL16_HI, + BFD_RELOC_PPC_GOT_DTPREL16_HA, + BFD_RELOC_PPC64_TPREL16_DS, + BFD_RELOC_PPC64_TPREL16_LO_DS, + BFD_RELOC_PPC64_TPREL16_HIGHER, + BFD_RELOC_PPC64_TPREL16_HIGHERA, + BFD_RELOC_PPC64_TPREL16_HIGHEST, + BFD_RELOC_PPC64_TPREL16_HIGHESTA, + BFD_RELOC_PPC64_DTPREL16_DS, + BFD_RELOC_PPC64_DTPREL16_LO_DS, + BFD_RELOC_PPC64_DTPREL16_HIGHER, + BFD_RELOC_PPC64_DTPREL16_HIGHERA, + BFD_RELOC_PPC64_DTPREL16_HIGHEST, + BFD_RELOC_PPC64_DTPREL16_HIGHESTA, + +/* IBM 370/390 relocations */ + BFD_RELOC_I370_D12, + +/* The type of reloc used to build a constructor table - at the moment +probably a 32 bit wide absolute relocation, but the target can choose. +It generally does map to one of the other relocation types. */ + BFD_RELOC_CTOR, + +/* ARM 26 bit pc-relative branch. The lowest two bits must be zero and are +not stored in the instruction. */ + BFD_RELOC_ARM_PCREL_BRANCH, + +/* ARM 26 bit pc-relative branch. The lowest bit must be zero and is +not stored in the instruction. The 2nd lowest bit comes from a 1 bit +field in the instruction. */ + BFD_RELOC_ARM_PCREL_BLX, + +/* Thumb 22 bit pc-relative branch. The lowest bit must be zero and is +not stored in the instruction. The 2nd lowest bit comes from a 1 bit +field in the instruction. */ + BFD_RELOC_THUMB_PCREL_BLX, + +/* Thumb 7-, 9-, 12-, 20-, 23-, and 25-bit pc-relative branches. +The lowest bit must be zero and is not stored in the instruction. +Note that the corresponding ELF R_ARM_THM_JUMPnn constant has an +"nn" one smaller in all cases. Note further that BRANCH23 +corresponds to R_ARM_THM_CALL. */ + BFD_RELOC_THUMB_PCREL_BRANCH7, + BFD_RELOC_THUMB_PCREL_BRANCH9, + BFD_RELOC_THUMB_PCREL_BRANCH12, + BFD_RELOC_THUMB_PCREL_BRANCH20, + BFD_RELOC_THUMB_PCREL_BRANCH23, + BFD_RELOC_THUMB_PCREL_BRANCH25, + +/* 12-bit immediate offset, used in ARM-format ldr and str instructions. */ + BFD_RELOC_ARM_OFFSET_IMM, + +/* 5-bit immediate offset, used in Thumb-format ldr and str instructions. */ + BFD_RELOC_ARM_THUMB_OFFSET, + +/* Pc-relative or absolute relocation depending on target. Used for +entries in .init_array sections. */ + BFD_RELOC_ARM_TARGET1, + +/* Read-only segment base relative address. */ + BFD_RELOC_ARM_ROSEGREL32, + +/* Data segment base relative address. */ + BFD_RELOC_ARM_SBREL32, + +/* This reloc is used for references to RTTI data from exception handling +tables. The actual definition depends on the target. It may be a +pc-relative or some form of GOT-indirect relocation. */ + BFD_RELOC_ARM_TARGET2, + +/* 31-bit PC relative address. */ + BFD_RELOC_ARM_PREL31, + +/* Relocations for setting up GOTs and PLTs for shared libraries. */ + BFD_RELOC_ARM_JUMP_SLOT, + BFD_RELOC_ARM_GLOB_DAT, + BFD_RELOC_ARM_GOT32, + BFD_RELOC_ARM_PLT32, + BFD_RELOC_ARM_RELATIVE, + BFD_RELOC_ARM_GOTOFF, + BFD_RELOC_ARM_GOTPC, + +/* ARM thread-local storage relocations. */ + BFD_RELOC_ARM_TLS_GD32, + BFD_RELOC_ARM_TLS_LDO32, + BFD_RELOC_ARM_TLS_LDM32, + BFD_RELOC_ARM_TLS_DTPOFF32, + BFD_RELOC_ARM_TLS_DTPMOD32, + BFD_RELOC_ARM_TLS_TPOFF32, + BFD_RELOC_ARM_TLS_IE32, + BFD_RELOC_ARM_TLS_LE32, + +/* These relocs are only used within the ARM assembler. They are not +(at present) written to any object files. */ + BFD_RELOC_ARM_IMMEDIATE, + BFD_RELOC_ARM_ADRL_IMMEDIATE, + BFD_RELOC_ARM_T32_IMMEDIATE, + BFD_RELOC_ARM_SHIFT_IMM, + BFD_RELOC_ARM_SMI, + BFD_RELOC_ARM_SWI, + BFD_RELOC_ARM_MULTI, + BFD_RELOC_ARM_CP_OFF_IMM, + BFD_RELOC_ARM_CP_OFF_IMM_S2, + BFD_RELOC_ARM_ADR_IMM, + BFD_RELOC_ARM_LDR_IMM, + BFD_RELOC_ARM_LITERAL, + BFD_RELOC_ARM_IN_POOL, + BFD_RELOC_ARM_OFFSET_IMM8, + BFD_RELOC_ARM_T32_OFFSET_U8, + BFD_RELOC_ARM_T32_OFFSET_IMM, + BFD_RELOC_ARM_HWLITERAL, + BFD_RELOC_ARM_THUMB_ADD, + BFD_RELOC_ARM_THUMB_IMM, + BFD_RELOC_ARM_THUMB_SHIFT, + +/* Renesas / SuperH SH relocs. Not all of these appear in object files. */ + BFD_RELOC_SH_PCDISP8BY2, + BFD_RELOC_SH_PCDISP12BY2, + BFD_RELOC_SH_IMM3, + BFD_RELOC_SH_IMM3U, + BFD_RELOC_SH_DISP12, + BFD_RELOC_SH_DISP12BY2, + BFD_RELOC_SH_DISP12BY4, + BFD_RELOC_SH_DISP12BY8, + BFD_RELOC_SH_DISP20, + BFD_RELOC_SH_DISP20BY8, + BFD_RELOC_SH_IMM4, + BFD_RELOC_SH_IMM4BY2, + BFD_RELOC_SH_IMM4BY4, + BFD_RELOC_SH_IMM8, + BFD_RELOC_SH_IMM8BY2, + BFD_RELOC_SH_IMM8BY4, + BFD_RELOC_SH_PCRELIMM8BY2, + BFD_RELOC_SH_PCRELIMM8BY4, + BFD_RELOC_SH_SWITCH16, + BFD_RELOC_SH_SWITCH32, + BFD_RELOC_SH_USES, + BFD_RELOC_SH_COUNT, + BFD_RELOC_SH_ALIGN, + BFD_RELOC_SH_CODE, + BFD_RELOC_SH_DATA, + BFD_RELOC_SH_LABEL, + BFD_RELOC_SH_LOOP_START, + BFD_RELOC_SH_LOOP_END, + BFD_RELOC_SH_COPY, + BFD_RELOC_SH_GLOB_DAT, + BFD_RELOC_SH_JMP_SLOT, + BFD_RELOC_SH_RELATIVE, + BFD_RELOC_SH_GOTPC, + BFD_RELOC_SH_GOT_LOW16, + BFD_RELOC_SH_GOT_MEDLOW16, + BFD_RELOC_SH_GOT_MEDHI16, + BFD_RELOC_SH_GOT_HI16, + BFD_RELOC_SH_GOTPLT_LOW16, + BFD_RELOC_SH_GOTPLT_MEDLOW16, + BFD_RELOC_SH_GOTPLT_MEDHI16, + BFD_RELOC_SH_GOTPLT_HI16, + BFD_RELOC_SH_PLT_LOW16, + BFD_RELOC_SH_PLT_MEDLOW16, + BFD_RELOC_SH_PLT_MEDHI16, + BFD_RELOC_SH_PLT_HI16, + BFD_RELOC_SH_GOTOFF_LOW16, + BFD_RELOC_SH_GOTOFF_MEDLOW16, + BFD_RELOC_SH_GOTOFF_MEDHI16, + BFD_RELOC_SH_GOTOFF_HI16, + BFD_RELOC_SH_GOTPC_LOW16, + BFD_RELOC_SH_GOTPC_MEDLOW16, + BFD_RELOC_SH_GOTPC_MEDHI16, + BFD_RELOC_SH_GOTPC_HI16, + BFD_RELOC_SH_COPY64, + BFD_RELOC_SH_GLOB_DAT64, + BFD_RELOC_SH_JMP_SLOT64, + BFD_RELOC_SH_RELATIVE64, + BFD_RELOC_SH_GOT10BY4, + BFD_RELOC_SH_GOT10BY8, + BFD_RELOC_SH_GOTPLT10BY4, + BFD_RELOC_SH_GOTPLT10BY8, + BFD_RELOC_SH_GOTPLT32, + BFD_RELOC_SH_SHMEDIA_CODE, + BFD_RELOC_SH_IMMU5, + BFD_RELOC_SH_IMMS6, + BFD_RELOC_SH_IMMS6BY32, + BFD_RELOC_SH_IMMU6, + BFD_RELOC_SH_IMMS10, + BFD_RELOC_SH_IMMS10BY2, + BFD_RELOC_SH_IMMS10BY4, + BFD_RELOC_SH_IMMS10BY8, + BFD_RELOC_SH_IMMS16, + BFD_RELOC_SH_IMMU16, + BFD_RELOC_SH_IMM_LOW16, + BFD_RELOC_SH_IMM_LOW16_PCREL, + BFD_RELOC_SH_IMM_MEDLOW16, + BFD_RELOC_SH_IMM_MEDLOW16_PCREL, + BFD_RELOC_SH_IMM_MEDHI16, + BFD_RELOC_SH_IMM_MEDHI16_PCREL, + BFD_RELOC_SH_IMM_HI16, + BFD_RELOC_SH_IMM_HI16_PCREL, + BFD_RELOC_SH_PT_16, + BFD_RELOC_SH_TLS_GD_32, + BFD_RELOC_SH_TLS_LD_32, + BFD_RELOC_SH_TLS_LDO_32, + BFD_RELOC_SH_TLS_IE_32, + BFD_RELOC_SH_TLS_LE_32, + BFD_RELOC_SH_TLS_DTPMOD32, + BFD_RELOC_SH_TLS_DTPOFF32, + BFD_RELOC_SH_TLS_TPOFF32, + +/* ARC Cores relocs. +ARC 22 bit pc-relative branch. The lowest two bits must be zero and are +not stored in the instruction. The high 20 bits are installed in bits 26 +through 7 of the instruction. */ + BFD_RELOC_ARC_B22_PCREL, + +/* ARC 26 bit absolute branch. The lowest two bits must be zero and are not +stored in the instruction. The high 24 bits are installed in bits 23 +through 0. */ + BFD_RELOC_ARC_B26, + +/* Mitsubishi D10V relocs. +This is a 10-bit reloc with the right 2 bits +assumed to be 0. */ + BFD_RELOC_D10V_10_PCREL_R, + +/* Mitsubishi D10V relocs. +This is a 10-bit reloc with the right 2 bits +assumed to be 0. This is the same as the previous reloc +except it is in the left container, i.e., +shifted left 15 bits. */ + BFD_RELOC_D10V_10_PCREL_L, + +/* This is an 18-bit reloc with the right 2 bits +assumed to be 0. */ + BFD_RELOC_D10V_18, + +/* This is an 18-bit reloc with the right 2 bits +assumed to be 0. */ + BFD_RELOC_D10V_18_PCREL, + +/* Mitsubishi D30V relocs. +This is a 6-bit absolute reloc. */ + BFD_RELOC_D30V_6, + +/* This is a 6-bit pc-relative reloc with +the right 3 bits assumed to be 0. */ + BFD_RELOC_D30V_9_PCREL, + +/* This is a 6-bit pc-relative reloc with +the right 3 bits assumed to be 0. Same +as the previous reloc but on the right side +of the container. */ + BFD_RELOC_D30V_9_PCREL_R, + +/* This is a 12-bit absolute reloc with the +right 3 bitsassumed to be 0. */ + BFD_RELOC_D30V_15, + +/* This is a 12-bit pc-relative reloc with +the right 3 bits assumed to be 0. */ + BFD_RELOC_D30V_15_PCREL, + +/* This is a 12-bit pc-relative reloc with +the right 3 bits assumed to be 0. Same +as the previous reloc but on the right side +of the container. */ + BFD_RELOC_D30V_15_PCREL_R, + +/* This is an 18-bit absolute reloc with +the right 3 bits assumed to be 0. */ + BFD_RELOC_D30V_21, + +/* This is an 18-bit pc-relative reloc with +the right 3 bits assumed to be 0. */ + BFD_RELOC_D30V_21_PCREL, + +/* This is an 18-bit pc-relative reloc with +the right 3 bits assumed to be 0. Same +as the previous reloc but on the right side +of the container. */ + BFD_RELOC_D30V_21_PCREL_R, + +/* This is a 32-bit absolute reloc. */ + BFD_RELOC_D30V_32, + +/* This is a 32-bit pc-relative reloc. */ + BFD_RELOC_D30V_32_PCREL, + +/* DLX relocs */ + BFD_RELOC_DLX_HI16_S, + +/* DLX relocs */ + BFD_RELOC_DLX_LO16, + +/* DLX relocs */ + BFD_RELOC_DLX_JMP26, + +/* Renesas M16C/M32C Relocations. */ + BFD_RELOC_M16C_8_PCREL8, + BFD_RELOC_M16C_16_PCREL8, + BFD_RELOC_M16C_8_PCREL16, + BFD_RELOC_M16C_8_ELABEL24, + BFD_RELOC_M16C_8_ABS16, + BFD_RELOC_M16C_16_ABS16, + BFD_RELOC_M16C_16_ABS24, + BFD_RELOC_M16C_16_ABS32, + BFD_RELOC_M16C_24_ABS16, + BFD_RELOC_M16C_24_ABS24, + BFD_RELOC_M16C_24_ABS32, + BFD_RELOC_M16C_32_ABS16, + BFD_RELOC_M16C_32_ABS24, + BFD_RELOC_M16C_32_ABS32, + BFD_RELOC_M16C_40_ABS16, + BFD_RELOC_M16C_40_ABS24, + BFD_RELOC_M16C_40_ABS32, + +/* Renesas M32R (formerly Mitsubishi M32R) relocs. +This is a 24 bit absolute address. */ + BFD_RELOC_M32R_24, + +/* This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0. */ + BFD_RELOC_M32R_10_PCREL, + +/* This is an 18-bit reloc with the right 2 bits assumed to be 0. */ + BFD_RELOC_M32R_18_PCREL, + +/* This is a 26-bit reloc with the right 2 bits assumed to be 0. */ + BFD_RELOC_M32R_26_PCREL, + +/* This is a 16-bit reloc containing the high 16 bits of an address +used when the lower 16 bits are treated as unsigned. */ + BFD_RELOC_M32R_HI16_ULO, + +/* This is a 16-bit reloc containing the high 16 bits of an address +used when the lower 16 bits are treated as signed. */ + BFD_RELOC_M32R_HI16_SLO, + +/* This is a 16-bit reloc containing the lower 16 bits of an address. */ + BFD_RELOC_M32R_LO16, + +/* This is a 16-bit reloc containing the small data area offset for use in +add3, load, and store instructions. */ + BFD_RELOC_M32R_SDA16, + +/* For PIC. */ + BFD_RELOC_M32R_GOT24, + BFD_RELOC_M32R_26_PLTREL, + BFD_RELOC_M32R_COPY, + BFD_RELOC_M32R_GLOB_DAT, + BFD_RELOC_M32R_JMP_SLOT, + BFD_RELOC_M32R_RELATIVE, + BFD_RELOC_M32R_GOTOFF, + BFD_RELOC_M32R_GOTOFF_HI_ULO, + BFD_RELOC_M32R_GOTOFF_HI_SLO, + BFD_RELOC_M32R_GOTOFF_LO, + BFD_RELOC_M32R_GOTPC24, + BFD_RELOC_M32R_GOT16_HI_ULO, + BFD_RELOC_M32R_GOT16_HI_SLO, + BFD_RELOC_M32R_GOT16_LO, + BFD_RELOC_M32R_GOTPC_HI_ULO, + BFD_RELOC_M32R_GOTPC_HI_SLO, + BFD_RELOC_M32R_GOTPC_LO, + +/* This is a 9-bit reloc */ + BFD_RELOC_V850_9_PCREL, + +/* This is a 22-bit reloc */ + BFD_RELOC_V850_22_PCREL, + +/* This is a 16 bit offset from the short data area pointer. */ + BFD_RELOC_V850_SDA_16_16_OFFSET, + +/* This is a 16 bit offset (of which only 15 bits are used) from the +short data area pointer. */ + BFD_RELOC_V850_SDA_15_16_OFFSET, + +/* This is a 16 bit offset from the zero data area pointer. */ + BFD_RELOC_V850_ZDA_16_16_OFFSET, + +/* This is a 16 bit offset (of which only 15 bits are used) from the +zero data area pointer. */ + BFD_RELOC_V850_ZDA_15_16_OFFSET, + +/* This is an 8 bit offset (of which only 6 bits are used) from the +tiny data area pointer. */ + BFD_RELOC_V850_TDA_6_8_OFFSET, + +/* This is an 8bit offset (of which only 7 bits are used) from the tiny +data area pointer. */ + BFD_RELOC_V850_TDA_7_8_OFFSET, + +/* This is a 7 bit offset from the tiny data area pointer. */ + BFD_RELOC_V850_TDA_7_7_OFFSET, + +/* This is a 16 bit offset from the tiny data area pointer. */ + BFD_RELOC_V850_TDA_16_16_OFFSET, + +/* This is a 5 bit offset (of which only 4 bits are used) from the tiny +data area pointer. */ + BFD_RELOC_V850_TDA_4_5_OFFSET, + +/* This is a 4 bit offset from the tiny data area pointer. */ + BFD_RELOC_V850_TDA_4_4_OFFSET, + +/* This is a 16 bit offset from the short data area pointer, with the +bits placed non-contiguously in the instruction. */ + BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET, + +/* This is a 16 bit offset from the zero data area pointer, with the +bits placed non-contiguously in the instruction. */ + BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET, + +/* This is a 6 bit offset from the call table base pointer. */ + BFD_RELOC_V850_CALLT_6_7_OFFSET, + +/* This is a 16 bit offset from the call table base pointer. */ + BFD_RELOC_V850_CALLT_16_16_OFFSET, + +/* Used for relaxing indirect function calls. */ + BFD_RELOC_V850_LONGCALL, + +/* Used for relaxing indirect jumps. */ + BFD_RELOC_V850_LONGJUMP, + +/* Used to maintain alignment whilst relaxing. */ + BFD_RELOC_V850_ALIGN, + +/* This is a variation of BFD_RELOC_LO16 that can be used in v850e ld.bu +instructions. */ + BFD_RELOC_V850_LO16_SPLIT_OFFSET, + +/* This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the +instruction. */ + BFD_RELOC_MN10300_32_PCREL, + +/* This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the +instruction. */ + BFD_RELOC_MN10300_16_PCREL, + +/* This is a 8bit DP reloc for the tms320c30, where the most +significant 8 bits of a 24 bit word are placed into the least +significant 8 bits of the opcode. */ + BFD_RELOC_TIC30_LDP, + +/* This is a 7bit reloc for the tms320c54x, where the least +significant 7 bits of a 16 bit word are placed into the least +significant 7 bits of the opcode. */ + BFD_RELOC_TIC54X_PARTLS7, + +/* This is a 9bit DP reloc for the tms320c54x, where the most +significant 9 bits of a 16 bit word are placed into the least +significant 9 bits of the opcode. */ + BFD_RELOC_TIC54X_PARTMS9, + +/* This is an extended address 23-bit reloc for the tms320c54x. */ + BFD_RELOC_TIC54X_23, + +/* This is a 16-bit reloc for the tms320c54x, where the least +significant 16 bits of a 23-bit extended address are placed into +the opcode. */ + BFD_RELOC_TIC54X_16_OF_23, + +/* This is a reloc for the tms320c54x, where the most +significant 7 bits of a 23-bit extended address are placed into +the opcode. */ + BFD_RELOC_TIC54X_MS7_OF_23, + +/* This is a 48 bit reloc for the FR30 that stores 32 bits. */ + BFD_RELOC_FR30_48, + +/* This is a 32 bit reloc for the FR30 that stores 20 bits split up into +two sections. */ + BFD_RELOC_FR30_20, + +/* This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in +4 bits. */ + BFD_RELOC_FR30_6_IN_4, + +/* This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset +into 8 bits. */ + BFD_RELOC_FR30_8_IN_8, + +/* This is a 16 bit reloc for the FR30 that stores a 9 bit short offset +into 8 bits. */ + BFD_RELOC_FR30_9_IN_8, + +/* This is a 16 bit reloc for the FR30 that stores a 10 bit word offset +into 8 bits. */ + BFD_RELOC_FR30_10_IN_8, + +/* This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative +short offset into 8 bits. */ + BFD_RELOC_FR30_9_PCREL, + +/* This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative +short offset into 11 bits. */ + BFD_RELOC_FR30_12_PCREL, + +/* Motorola Mcore relocations. */ + BFD_RELOC_MCORE_PCREL_IMM8BY4, + BFD_RELOC_MCORE_PCREL_IMM11BY2, + BFD_RELOC_MCORE_PCREL_IMM4BY2, + BFD_RELOC_MCORE_PCREL_32, + BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2, + BFD_RELOC_MCORE_RVA, + +/* These are relocations for the GETA instruction. */ + BFD_RELOC_MMIX_GETA, + BFD_RELOC_MMIX_GETA_1, + BFD_RELOC_MMIX_GETA_2, + BFD_RELOC_MMIX_GETA_3, + +/* These are relocations for a conditional branch instruction. */ + BFD_RELOC_MMIX_CBRANCH, + BFD_RELOC_MMIX_CBRANCH_J, + BFD_RELOC_MMIX_CBRANCH_1, + BFD_RELOC_MMIX_CBRANCH_2, + BFD_RELOC_MMIX_CBRANCH_3, + +/* These are relocations for the PUSHJ instruction. */ + BFD_RELOC_MMIX_PUSHJ, + BFD_RELOC_MMIX_PUSHJ_1, + BFD_RELOC_MMIX_PUSHJ_2, + BFD_RELOC_MMIX_PUSHJ_3, + BFD_RELOC_MMIX_PUSHJ_STUBBABLE, + +/* These are relocations for the JMP instruction. */ + BFD_RELOC_MMIX_JMP, + BFD_RELOC_MMIX_JMP_1, + BFD_RELOC_MMIX_JMP_2, + BFD_RELOC_MMIX_JMP_3, + +/* This is a relocation for a relative address as in a GETA instruction or +a branch. */ + BFD_RELOC_MMIX_ADDR19, + +/* This is a relocation for a relative address as in a JMP instruction. */ + BFD_RELOC_MMIX_ADDR27, + +/* This is a relocation for an instruction field that may be a general +register or a value 0..255. */ + BFD_RELOC_MMIX_REG_OR_BYTE, + +/* This is a relocation for an instruction field that may be a general +register. */ + BFD_RELOC_MMIX_REG, + +/* This is a relocation for two instruction fields holding a register and +an offset, the equivalent of the relocation. */ + BFD_RELOC_MMIX_BASE_PLUS_OFFSET, + +/* This relocation is an assertion that the expression is not allocated as +a global register. It does not modify contents. */ + BFD_RELOC_MMIX_LOCAL, + +/* This is a 16 bit reloc for the AVR that stores 8 bit pc relative +short offset into 7 bits. */ + BFD_RELOC_AVR_7_PCREL, + +/* This is a 16 bit reloc for the AVR that stores 13 bit pc relative +short offset into 12 bits. */ + BFD_RELOC_AVR_13_PCREL, + +/* This is a 16 bit reloc for the AVR that stores 17 bit value (usually +program memory address) into 16 bits. */ + BFD_RELOC_AVR_16_PM, + +/* This is a 16 bit reloc for the AVR that stores 8 bit value (usually +data memory address) into 8 bit immediate value of LDI insn. */ + BFD_RELOC_AVR_LO8_LDI, + +/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit +of data memory address) into 8 bit immediate value of LDI insn. */ + BFD_RELOC_AVR_HI8_LDI, + +/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit +of program memory address) into 8 bit immediate value of LDI insn. */ + BFD_RELOC_AVR_HH8_LDI, + +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value +(usually data memory address) into 8 bit immediate value of SUBI insn. */ + BFD_RELOC_AVR_LO8_LDI_NEG, + +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value +(high 8 bit of data memory address) into 8 bit immediate value of +SUBI insn. */ + BFD_RELOC_AVR_HI8_LDI_NEG, + +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value +(most high 8 bit of program memory address) into 8 bit immediate value +of LDI or SUBI insn. */ + BFD_RELOC_AVR_HH8_LDI_NEG, + +/* This is a 16 bit reloc for the AVR that stores 8 bit value (usually +command address) into 8 bit immediate value of LDI insn. */ + BFD_RELOC_AVR_LO8_LDI_PM, + +/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit +of command address) into 8 bit immediate value of LDI insn. */ + BFD_RELOC_AVR_HI8_LDI_PM, + +/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit +of command address) into 8 bit immediate value of LDI insn. */ + BFD_RELOC_AVR_HH8_LDI_PM, + +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value +(usually command address) into 8 bit immediate value of SUBI insn. */ + BFD_RELOC_AVR_LO8_LDI_PM_NEG, + +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value +(high 8 bit of 16 bit command address) into 8 bit immediate value +of SUBI insn. */ + BFD_RELOC_AVR_HI8_LDI_PM_NEG, + +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value +(high 6 bit of 22 bit command address) into 8 bit immediate +value of SUBI insn. */ + BFD_RELOC_AVR_HH8_LDI_PM_NEG, + +/* This is a 32 bit reloc for the AVR that stores 23 bit value +into 22 bits. */ + BFD_RELOC_AVR_CALL, + +/* This is a 16 bit reloc for the AVR that stores all needed bits +for absolute addressing with ldi with overflow check to linktime */ + BFD_RELOC_AVR_LDI, + +/* This is a 6 bit reloc for the AVR that stores offset for ldd/std +instructions */ + BFD_RELOC_AVR_6, + +/* This is a 6 bit reloc for the AVR that stores offset for adiw/sbiw +instructions */ + BFD_RELOC_AVR_6_ADIW, + +/* Direct 12 bit. */ + BFD_RELOC_390_12, + +/* 12 bit GOT offset. */ + BFD_RELOC_390_GOT12, + +/* 32 bit PC relative PLT address. */ + BFD_RELOC_390_PLT32, + +/* Copy symbol at runtime. */ + BFD_RELOC_390_COPY, + +/* Create GOT entry. */ + BFD_RELOC_390_GLOB_DAT, + +/* Create PLT entry. */ + BFD_RELOC_390_JMP_SLOT, + +/* Adjust by program base. */ + BFD_RELOC_390_RELATIVE, + +/* 32 bit PC relative offset to GOT. */ + BFD_RELOC_390_GOTPC, + +/* 16 bit GOT offset. */ + BFD_RELOC_390_GOT16, + +/* PC relative 16 bit shifted by 1. */ + BFD_RELOC_390_PC16DBL, + +/* 16 bit PC rel. PLT shifted by 1. */ + BFD_RELOC_390_PLT16DBL, + +/* PC relative 32 bit shifted by 1. */ + BFD_RELOC_390_PC32DBL, + +/* 32 bit PC rel. PLT shifted by 1. */ + BFD_RELOC_390_PLT32DBL, + +/* 32 bit PC rel. GOT shifted by 1. */ + BFD_RELOC_390_GOTPCDBL, + +/* 64 bit GOT offset. */ + BFD_RELOC_390_GOT64, + +/* 64 bit PC relative PLT address. */ + BFD_RELOC_390_PLT64, + +/* 32 bit rel. offset to GOT entry. */ + BFD_RELOC_390_GOTENT, + +/* 64 bit offset to GOT. */ + BFD_RELOC_390_GOTOFF64, + +/* 12-bit offset to symbol-entry within GOT, with PLT handling. */ + BFD_RELOC_390_GOTPLT12, + +/* 16-bit offset to symbol-entry within GOT, with PLT handling. */ + BFD_RELOC_390_GOTPLT16, + +/* 32-bit offset to symbol-entry within GOT, with PLT handling. */ + BFD_RELOC_390_GOTPLT32, + +/* 64-bit offset to symbol-entry within GOT, with PLT handling. */ + BFD_RELOC_390_GOTPLT64, + +/* 32-bit rel. offset to symbol-entry within GOT, with PLT handling. */ + BFD_RELOC_390_GOTPLTENT, + +/* 16-bit rel. offset from the GOT to a PLT entry. */ + BFD_RELOC_390_PLTOFF16, + +/* 32-bit rel. offset from the GOT to a PLT entry. */ + BFD_RELOC_390_PLTOFF32, + +/* 64-bit rel. offset from the GOT to a PLT entry. */ + BFD_RELOC_390_PLTOFF64, + +/* s390 tls relocations. */ + BFD_RELOC_390_TLS_LOAD, + BFD_RELOC_390_TLS_GDCALL, + BFD_RELOC_390_TLS_LDCALL, + BFD_RELOC_390_TLS_GD32, + BFD_RELOC_390_TLS_GD64, + BFD_RELOC_390_TLS_GOTIE12, + BFD_RELOC_390_TLS_GOTIE32, + BFD_RELOC_390_TLS_GOTIE64, + BFD_RELOC_390_TLS_LDM32, + BFD_RELOC_390_TLS_LDM64, + BFD_RELOC_390_TLS_IE32, + BFD_RELOC_390_TLS_IE64, + BFD_RELOC_390_TLS_IEENT, + BFD_RELOC_390_TLS_LE32, + BFD_RELOC_390_TLS_LE64, + BFD_RELOC_390_TLS_LDO32, + BFD_RELOC_390_TLS_LDO64, + BFD_RELOC_390_TLS_DTPMOD, + BFD_RELOC_390_TLS_DTPOFF, + BFD_RELOC_390_TLS_TPOFF, + +/* Long displacement extension. */ + BFD_RELOC_390_20, + BFD_RELOC_390_GOT20, + BFD_RELOC_390_GOTPLT20, + BFD_RELOC_390_TLS_GOTIE20, + +/* Scenix IP2K - 9-bit register number / data address */ + BFD_RELOC_IP2K_FR9, + +/* Scenix IP2K - 4-bit register/data bank number */ + BFD_RELOC_IP2K_BANK, + +/* Scenix IP2K - low 13 bits of instruction word address */ + BFD_RELOC_IP2K_ADDR16CJP, + +/* Scenix IP2K - high 3 bits of instruction word address */ + BFD_RELOC_IP2K_PAGE3, + +/* Scenix IP2K - ext/low/high 8 bits of data address */ + BFD_RELOC_IP2K_LO8DATA, + BFD_RELOC_IP2K_HI8DATA, + BFD_RELOC_IP2K_EX8DATA, + +/* Scenix IP2K - low/high 8 bits of instruction word address */ + BFD_RELOC_IP2K_LO8INSN, + BFD_RELOC_IP2K_HI8INSN, + +/* Scenix IP2K - even/odd PC modifier to modify snb pcl.0 */ + BFD_RELOC_IP2K_PC_SKIP, + +/* Scenix IP2K - 16 bit word address in text section. */ + BFD_RELOC_IP2K_TEXT, + +/* Scenix IP2K - 7-bit sp or dp offset */ + BFD_RELOC_IP2K_FR_OFFSET, + +/* Scenix VPE4K coprocessor - data/insn-space addressing */ + BFD_RELOC_VPE4KMATH_DATA, + BFD_RELOC_VPE4KMATH_INSN, + +/* These two relocations are used by the linker to determine which of +the entries in a C++ virtual function table are actually used. When +the --gc-sections option is given, the linker will zero out the entries +that are not used, so that the code for those functions need not be +included in the output. + +VTABLE_INHERIT is a zero-space relocation used to describe to the +linker the inheritance tree of a C++ virtual function table. The +relocation's symbol should be the parent class' vtable, and the +relocation should be located at the child vtable. + +VTABLE_ENTRY is a zero-space relocation that describes the use of a +virtual function table entry. The reloc's symbol should refer to the +table of the class mentioned in the code. Off of that base, an offset +describes the entry that is being used. For Rela hosts, this offset +is stored in the reloc's addend. For Rel hosts, we are forced to put +this offset in the reloc's section offset. */ + BFD_RELOC_VTABLE_INHERIT, + BFD_RELOC_VTABLE_ENTRY, + +/* Intel IA64 Relocations. */ + BFD_RELOC_IA64_IMM14, + BFD_RELOC_IA64_IMM22, + BFD_RELOC_IA64_IMM64, + BFD_RELOC_IA64_DIR32MSB, + BFD_RELOC_IA64_DIR32LSB, + BFD_RELOC_IA64_DIR64MSB, + BFD_RELOC_IA64_DIR64LSB, + BFD_RELOC_IA64_GPREL22, + BFD_RELOC_IA64_GPREL64I, + BFD_RELOC_IA64_GPREL32MSB, + BFD_RELOC_IA64_GPREL32LSB, + BFD_RELOC_IA64_GPREL64MSB, + BFD_RELOC_IA64_GPREL64LSB, + BFD_RELOC_IA64_LTOFF22, + BFD_RELOC_IA64_LTOFF64I, + BFD_RELOC_IA64_PLTOFF22, + BFD_RELOC_IA64_PLTOFF64I, + BFD_RELOC_IA64_PLTOFF64MSB, + BFD_RELOC_IA64_PLTOFF64LSB, + BFD_RELOC_IA64_FPTR64I, + BFD_RELOC_IA64_FPTR32MSB, + BFD_RELOC_IA64_FPTR32LSB, + BFD_RELOC_IA64_FPTR64MSB, + BFD_RELOC_IA64_FPTR64LSB, + BFD_RELOC_IA64_PCREL21B, + BFD_RELOC_IA64_PCREL21BI, + BFD_RELOC_IA64_PCREL21M, + BFD_RELOC_IA64_PCREL21F, + BFD_RELOC_IA64_PCREL22, + BFD_RELOC_IA64_PCREL60B, + BFD_RELOC_IA64_PCREL64I, + BFD_RELOC_IA64_PCREL32MSB, + BFD_RELOC_IA64_PCREL32LSB, + BFD_RELOC_IA64_PCREL64MSB, + BFD_RELOC_IA64_PCREL64LSB, + BFD_RELOC_IA64_LTOFF_FPTR22, + BFD_RELOC_IA64_LTOFF_FPTR64I, + BFD_RELOC_IA64_LTOFF_FPTR32MSB, + BFD_RELOC_IA64_LTOFF_FPTR32LSB, + BFD_RELOC_IA64_LTOFF_FPTR64MSB, + BFD_RELOC_IA64_LTOFF_FPTR64LSB, + BFD_RELOC_IA64_SEGREL32MSB, + BFD_RELOC_IA64_SEGREL32LSB, + BFD_RELOC_IA64_SEGREL64MSB, + BFD_RELOC_IA64_SEGREL64LSB, + BFD_RELOC_IA64_SECREL32MSB, + BFD_RELOC_IA64_SECREL32LSB, + BFD_RELOC_IA64_SECREL64MSB, + BFD_RELOC_IA64_SECREL64LSB, + BFD_RELOC_IA64_REL32MSB, + BFD_RELOC_IA64_REL32LSB, + BFD_RELOC_IA64_REL64MSB, + BFD_RELOC_IA64_REL64LSB, + BFD_RELOC_IA64_LTV32MSB, + BFD_RELOC_IA64_LTV32LSB, + BFD_RELOC_IA64_LTV64MSB, + BFD_RELOC_IA64_LTV64LSB, + BFD_RELOC_IA64_IPLTMSB, + BFD_RELOC_IA64_IPLTLSB, + BFD_RELOC_IA64_COPY, + BFD_RELOC_IA64_LTOFF22X, + BFD_RELOC_IA64_LDXMOV, + BFD_RELOC_IA64_TPREL14, + BFD_RELOC_IA64_TPREL22, + BFD_RELOC_IA64_TPREL64I, + BFD_RELOC_IA64_TPREL64MSB, + BFD_RELOC_IA64_TPREL64LSB, + BFD_RELOC_IA64_LTOFF_TPREL22, + BFD_RELOC_IA64_DTPMOD64MSB, + BFD_RELOC_IA64_DTPMOD64LSB, + BFD_RELOC_IA64_LTOFF_DTPMOD22, + BFD_RELOC_IA64_DTPREL14, + BFD_RELOC_IA64_DTPREL22, + BFD_RELOC_IA64_DTPREL64I, + BFD_RELOC_IA64_DTPREL32MSB, + BFD_RELOC_IA64_DTPREL32LSB, + BFD_RELOC_IA64_DTPREL64MSB, + BFD_RELOC_IA64_DTPREL64LSB, + BFD_RELOC_IA64_LTOFF_DTPREL22, + +/* Motorola 68HC11 reloc. +This is the 8 bit high part of an absolute address. */ + BFD_RELOC_M68HC11_HI8, + +/* Motorola 68HC11 reloc. +This is the 8 bit low part of an absolute address. */ + BFD_RELOC_M68HC11_LO8, + +/* Motorola 68HC11 reloc. +This is the 3 bit of a value. */ + BFD_RELOC_M68HC11_3B, + +/* Motorola 68HC11 reloc. +This reloc marks the beginning of a jump/call instruction. +It is used for linker relaxation to correctly identify beginning +of instruction and change some branches to use PC-relative +addressing mode. */ + BFD_RELOC_M68HC11_RL_JUMP, + +/* Motorola 68HC11 reloc. +This reloc marks a group of several instructions that gcc generates +and for which the linker relaxation pass can modify and/or remove +some of them. */ + BFD_RELOC_M68HC11_RL_GROUP, + +/* Motorola 68HC11 reloc. +This is the 16-bit lower part of an address. It is used for 'call' +instruction to specify the symbol address without any special +transformation (due to memory bank window). */ + BFD_RELOC_M68HC11_LO16, + +/* Motorola 68HC11 reloc. +This is a 8-bit reloc that specifies the page number of an address. +It is used by 'call' instruction to specify the page number of +the symbol. */ + BFD_RELOC_M68HC11_PAGE, + +/* Motorola 68HC11 reloc. +This is a 24-bit reloc that represents the address with a 16-bit +value and a 8-bit page number. The symbol address is transformed +to follow the 16K memory bank of 68HC12 (seen as mapped in the window). */ + BFD_RELOC_M68HC11_24, + +/* Motorola 68HC12 reloc. +This is the 5 bits of a value. */ + BFD_RELOC_M68HC12_5B, + +/* NS CR16C Relocations. */ + BFD_RELOC_16C_NUM08, + BFD_RELOC_16C_NUM08_C, + BFD_RELOC_16C_NUM16, + BFD_RELOC_16C_NUM16_C, + BFD_RELOC_16C_NUM32, + BFD_RELOC_16C_NUM32_C, + BFD_RELOC_16C_DISP04, + BFD_RELOC_16C_DISP04_C, + BFD_RELOC_16C_DISP08, + BFD_RELOC_16C_DISP08_C, + BFD_RELOC_16C_DISP16, + BFD_RELOC_16C_DISP16_C, + BFD_RELOC_16C_DISP24, + BFD_RELOC_16C_DISP24_C, + BFD_RELOC_16C_DISP24a, + BFD_RELOC_16C_DISP24a_C, + BFD_RELOC_16C_REG04, + BFD_RELOC_16C_REG04_C, + BFD_RELOC_16C_REG04a, + BFD_RELOC_16C_REG04a_C, + BFD_RELOC_16C_REG14, + BFD_RELOC_16C_REG14_C, + BFD_RELOC_16C_REG16, + BFD_RELOC_16C_REG16_C, + BFD_RELOC_16C_REG20, + BFD_RELOC_16C_REG20_C, + BFD_RELOC_16C_ABS20, + BFD_RELOC_16C_ABS20_C, + BFD_RELOC_16C_ABS24, + BFD_RELOC_16C_ABS24_C, + BFD_RELOC_16C_IMM04, + BFD_RELOC_16C_IMM04_C, + BFD_RELOC_16C_IMM16, + BFD_RELOC_16C_IMM16_C, + BFD_RELOC_16C_IMM20, + BFD_RELOC_16C_IMM20_C, + BFD_RELOC_16C_IMM24, + BFD_RELOC_16C_IMM24_C, + BFD_RELOC_16C_IMM32, + BFD_RELOC_16C_IMM32_C, + +/* NS CRX Relocations. */ + BFD_RELOC_CRX_REL4, + BFD_RELOC_CRX_REL8, + BFD_RELOC_CRX_REL8_CMP, + BFD_RELOC_CRX_REL16, + BFD_RELOC_CRX_REL24, + BFD_RELOC_CRX_REL32, + BFD_RELOC_CRX_REGREL12, + BFD_RELOC_CRX_REGREL22, + BFD_RELOC_CRX_REGREL28, + BFD_RELOC_CRX_REGREL32, + BFD_RELOC_CRX_ABS16, + BFD_RELOC_CRX_ABS32, + BFD_RELOC_CRX_NUM8, + BFD_RELOC_CRX_NUM16, + BFD_RELOC_CRX_NUM32, + BFD_RELOC_CRX_IMM16, + BFD_RELOC_CRX_IMM32, + BFD_RELOC_CRX_SWITCH8, + BFD_RELOC_CRX_SWITCH16, + BFD_RELOC_CRX_SWITCH32, + +/* These relocs are only used within the CRIS assembler. They are not +(at present) written to any object files. */ + BFD_RELOC_CRIS_BDISP8, + BFD_RELOC_CRIS_UNSIGNED_5, + BFD_RELOC_CRIS_SIGNED_6, + BFD_RELOC_CRIS_UNSIGNED_6, + BFD_RELOC_CRIS_SIGNED_8, + BFD_RELOC_CRIS_UNSIGNED_8, + BFD_RELOC_CRIS_SIGNED_16, + BFD_RELOC_CRIS_UNSIGNED_16, + BFD_RELOC_CRIS_LAPCQ_OFFSET, + BFD_RELOC_CRIS_UNSIGNED_4, + +/* Relocs used in ELF shared libraries for CRIS. */ + BFD_RELOC_CRIS_COPY, + BFD_RELOC_CRIS_GLOB_DAT, + BFD_RELOC_CRIS_JUMP_SLOT, + BFD_RELOC_CRIS_RELATIVE, + +/* 32-bit offset to symbol-entry within GOT. */ + BFD_RELOC_CRIS_32_GOT, + +/* 16-bit offset to symbol-entry within GOT. */ + BFD_RELOC_CRIS_16_GOT, + +/* 32-bit offset to symbol-entry within GOT, with PLT handling. */ + BFD_RELOC_CRIS_32_GOTPLT, + +/* 16-bit offset to symbol-entry within GOT, with PLT handling. */ + BFD_RELOC_CRIS_16_GOTPLT, + +/* 32-bit offset to symbol, relative to GOT. */ + BFD_RELOC_CRIS_32_GOTREL, + +/* 32-bit offset to symbol with PLT entry, relative to GOT. */ + BFD_RELOC_CRIS_32_PLT_GOTREL, + +/* 32-bit offset to symbol with PLT entry, relative to this relocation. */ + BFD_RELOC_CRIS_32_PLT_PCREL, + +/* Intel i860 Relocations. */ + BFD_RELOC_860_COPY, + BFD_RELOC_860_GLOB_DAT, + BFD_RELOC_860_JUMP_SLOT, + BFD_RELOC_860_RELATIVE, + BFD_RELOC_860_PC26, + BFD_RELOC_860_PLT26, + BFD_RELOC_860_PC16, + BFD_RELOC_860_LOW0, + BFD_RELOC_860_SPLIT0, + BFD_RELOC_860_LOW1, + BFD_RELOC_860_SPLIT1, + BFD_RELOC_860_LOW2, + BFD_RELOC_860_SPLIT2, + BFD_RELOC_860_LOW3, + BFD_RELOC_860_LOGOT0, + BFD_RELOC_860_SPGOT0, + BFD_RELOC_860_LOGOT1, + BFD_RELOC_860_SPGOT1, + BFD_RELOC_860_LOGOTOFF0, + BFD_RELOC_860_SPGOTOFF0, + BFD_RELOC_860_LOGOTOFF1, + BFD_RELOC_860_SPGOTOFF1, + BFD_RELOC_860_LOGOTOFF2, + BFD_RELOC_860_LOGOTOFF3, + BFD_RELOC_860_LOPC, + BFD_RELOC_860_HIGHADJ, + BFD_RELOC_860_HAGOT, + BFD_RELOC_860_HAGOTOFF, + BFD_RELOC_860_HAPC, + BFD_RELOC_860_HIGH, + BFD_RELOC_860_HIGOT, + BFD_RELOC_860_HIGOTOFF, + +/* OpenRISC Relocations. */ + BFD_RELOC_OPENRISC_ABS_26, + BFD_RELOC_OPENRISC_REL_26, + +/* H8 elf Relocations. */ + BFD_RELOC_H8_DIR16A8, + BFD_RELOC_H8_DIR16R8, + BFD_RELOC_H8_DIR24A8, + BFD_RELOC_H8_DIR24R8, + BFD_RELOC_H8_DIR32A16, + +/* Sony Xstormy16 Relocations. */ + BFD_RELOC_XSTORMY16_REL_12, + BFD_RELOC_XSTORMY16_12, + BFD_RELOC_XSTORMY16_24, + BFD_RELOC_XSTORMY16_FPTR16, + +/* Relocations used by VAX ELF. */ + BFD_RELOC_VAX_GLOB_DAT, + BFD_RELOC_VAX_JMP_SLOT, + BFD_RELOC_VAX_RELATIVE, + +/* Morpho MS1 - 16 bit immediate relocation. */ + BFD_RELOC_MS1_PC16, + +/* Morpho MS1 - Hi 16 bits of an address. */ + BFD_RELOC_MS1_HI16, + +/* Morpho MS1 - Low 16 bits of an address. */ + BFD_RELOC_MS1_LO16, + +/* Morpho MS1 - Used to tell the linker which vtable entries are used. */ + BFD_RELOC_MS1_GNU_VTINHERIT, + +/* Morpho MS1 - Used to tell the linker which vtable entries are used. */ + BFD_RELOC_MS1_GNU_VTENTRY, + +/* msp430 specific relocation codes */ + BFD_RELOC_MSP430_10_PCREL, + BFD_RELOC_MSP430_16_PCREL, + BFD_RELOC_MSP430_16, + BFD_RELOC_MSP430_16_PCREL_BYTE, + BFD_RELOC_MSP430_16_BYTE, + BFD_RELOC_MSP430_2X_PCREL, + BFD_RELOC_MSP430_RL_PCREL, + +/* IQ2000 Relocations. */ + BFD_RELOC_IQ2000_OFFSET_16, + BFD_RELOC_IQ2000_OFFSET_21, + BFD_RELOC_IQ2000_UHI16, + +/* Special Xtensa relocation used only by PLT entries in ELF shared +objects to indicate that the runtime linker should set the value +to one of its own internal functions or data structures. */ + BFD_RELOC_XTENSA_RTLD, + +/* Xtensa relocations for ELF shared objects. */ + BFD_RELOC_XTENSA_GLOB_DAT, + BFD_RELOC_XTENSA_JMP_SLOT, + BFD_RELOC_XTENSA_RELATIVE, + +/* Xtensa relocation used in ELF object files for symbols that may require +PLT entries. Otherwise, this is just a generic 32-bit relocation. */ + BFD_RELOC_XTENSA_PLT, + +/* Xtensa relocations to mark the difference of two local symbols. +These are only needed to support linker relaxation and can be ignored +when not relaxing. The field is set to the value of the difference +assuming no relaxation. The relocation encodes the position of the +first symbol so the linker can determine whether to adjust the field +value. */ + BFD_RELOC_XTENSA_DIFF8, + BFD_RELOC_XTENSA_DIFF16, + BFD_RELOC_XTENSA_DIFF32, + +/* Generic Xtensa relocations for instruction operands. Only the slot +number is encoded in the relocation. The relocation applies to the +last PC-relative immediate operand, or if there are no PC-relative +immediates, to the last immediate operand. */ + BFD_RELOC_XTENSA_SLOT0_OP, + BFD_RELOC_XTENSA_SLOT1_OP, + BFD_RELOC_XTENSA_SLOT2_OP, + BFD_RELOC_XTENSA_SLOT3_OP, + BFD_RELOC_XTENSA_SLOT4_OP, + BFD_RELOC_XTENSA_SLOT5_OP, + BFD_RELOC_XTENSA_SLOT6_OP, + BFD_RELOC_XTENSA_SLOT7_OP, + BFD_RELOC_XTENSA_SLOT8_OP, + BFD_RELOC_XTENSA_SLOT9_OP, + BFD_RELOC_XTENSA_SLOT10_OP, + BFD_RELOC_XTENSA_SLOT11_OP, + BFD_RELOC_XTENSA_SLOT12_OP, + BFD_RELOC_XTENSA_SLOT13_OP, + BFD_RELOC_XTENSA_SLOT14_OP, + +/* Alternate Xtensa relocations. Only the slot is encoded in the +relocation. The meaning of these relocations is opcode-specific. */ + BFD_RELOC_XTENSA_SLOT0_ALT, + BFD_RELOC_XTENSA_SLOT1_ALT, + BFD_RELOC_XTENSA_SLOT2_ALT, + BFD_RELOC_XTENSA_SLOT3_ALT, + BFD_RELOC_XTENSA_SLOT4_ALT, + BFD_RELOC_XTENSA_SLOT5_ALT, + BFD_RELOC_XTENSA_SLOT6_ALT, + BFD_RELOC_XTENSA_SLOT7_ALT, + BFD_RELOC_XTENSA_SLOT8_ALT, + BFD_RELOC_XTENSA_SLOT9_ALT, + BFD_RELOC_XTENSA_SLOT10_ALT, + BFD_RELOC_XTENSA_SLOT11_ALT, + BFD_RELOC_XTENSA_SLOT12_ALT, + BFD_RELOC_XTENSA_SLOT13_ALT, + BFD_RELOC_XTENSA_SLOT14_ALT, + +/* Xtensa relocations for backward compatibility. These have all been +replaced by BFD_RELOC_XTENSA_SLOT0_OP. */ + BFD_RELOC_XTENSA_OP0, + BFD_RELOC_XTENSA_OP1, + BFD_RELOC_XTENSA_OP2, + +/* Xtensa relocation to mark that the assembler expanded the +instructions from an original target. The expansion size is +encoded in the reloc size. */ + BFD_RELOC_XTENSA_ASM_EXPAND, + +/* Xtensa relocation to mark that the linker should simplify +assembler-expanded instructions. This is commonly used +internally by the linker after analysis of a +BFD_RELOC_XTENSA_ASM_EXPAND. */ + BFD_RELOC_XTENSA_ASM_SIMPLIFY, + BFD_RELOC_UNUSED }; +typedef enum bfd_reloc_code_real bfd_reloc_code_real_type; +reloc_howto_type *bfd_reloc_type_lookup + (bfd *abfd, bfd_reloc_code_real_type code); + +const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code); + +/* Extracted from syms.c. */ + +typedef struct bfd_symbol +{ + /* A pointer to the BFD which owns the symbol. This information + is necessary so that a back end can work out what additional + information (invisible to the application writer) is carried + with the symbol. + + This field is *almost* redundant, since you can use section->owner + instead, except that some symbols point to the global sections + bfd_{abs,com,und}_section. This could be fixed by making + these globals be per-bfd (or per-target-flavor). FIXME. */ + struct bfd *the_bfd; /* Use bfd_asymbol_bfd(sym) to access this field. */ + + /* The text of the symbol. The name is left alone, and not copied; the + application may not alter it. */ + const char *name; + + /* The value of the symbol. This really should be a union of a + numeric value with a pointer, since some flags indicate that + a pointer to another symbol is stored here. */ + symvalue value; + + /* Attributes of a symbol. */ +#define BSF_NO_FLAGS 0x00 + + /* The symbol has local scope; <> in <>. The value + is the offset into the section of the data. */ +#define BSF_LOCAL 0x01 + + /* The symbol has global scope; initialized data in <>. The + value is the offset into the section of the data. */ +#define BSF_GLOBAL 0x02 + + /* The symbol has global scope and is exported. The value is + the offset into the section of the data. */ +#define BSF_EXPORT BSF_GLOBAL /* No real difference. */ + + /* A normal C symbol would be one of: + <>, <>, <> or + <>. */ + + /* The symbol is a debugging record. The value has an arbitrary + meaning, unless BSF_DEBUGGING_RELOC is also set. */ +#define BSF_DEBUGGING 0x08 + + /* The symbol denotes a function entry point. Used in ELF, + perhaps others someday. */ +#define BSF_FUNCTION 0x10 + + /* Used by the linker. */ +#define BSF_KEEP 0x20 +#define BSF_KEEP_G 0x40 + + /* A weak global symbol, overridable without warnings by + a regular global symbol of the same name. */ +#define BSF_WEAK 0x80 + + /* This symbol was created to point to a section, e.g. ELF's + STT_SECTION symbols. */ +#define BSF_SECTION_SYM 0x100 + + /* The symbol used to be a common symbol, but now it is + allocated. */ +#define BSF_OLD_COMMON 0x200 + + /* The default value for common data. */ +#define BFD_FORT_COMM_DEFAULT_VALUE 0 + + /* In some files the type of a symbol sometimes alters its + location in an output file - ie in coff a <> symbol + which is also <> symbol appears where it was + declared and not at the end of a section. This bit is set + by the target BFD part to convey this information. */ +#define BSF_NOT_AT_END 0x400 + + /* Signal that the symbol is the label of constructor section. */ +#define BSF_CONSTRUCTOR 0x800 + + /* Signal that the symbol is a warning symbol. The name is a + warning. The name of the next symbol is the one to warn about; + if a reference is made to a symbol with the same name as the next + symbol, a warning is issued by the linker. */ +#define BSF_WARNING 0x1000 + + /* Signal that the symbol is indirect. This symbol is an indirect + pointer to the symbol with the same name as the next symbol. */ +#define BSF_INDIRECT 0x2000 + + /* BSF_FILE marks symbols that contain a file name. This is used + for ELF STT_FILE symbols. */ +#define BSF_FILE 0x4000 + + /* Symbol is from dynamic linking information. */ +#define BSF_DYNAMIC 0x8000 + + /* The symbol denotes a data object. Used in ELF, and perhaps + others someday. */ +#define BSF_OBJECT 0x10000 + + /* This symbol is a debugging symbol. The value is the offset + into the section of the data. BSF_DEBUGGING should be set + as well. */ +#define BSF_DEBUGGING_RELOC 0x20000 + + /* This symbol is thread local. Used in ELF. */ +#define BSF_THREAD_LOCAL 0x40000 + + flagword flags; + + /* A pointer to the section to which this symbol is + relative. This will always be non NULL, there are special + sections for undefined and absolute symbols. */ + struct bfd_section *section; + + /* Back end special data. */ + union + { + void *p; + bfd_vma i; + } + udata; +} +asymbol; + +#define bfd_get_symtab_upper_bound(abfd) \ + BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd)) + +bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym); + +bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name); + +#define bfd_is_local_label_name(abfd, name) \ + BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name)) + +bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym); + +#define bfd_is_target_special_symbol(abfd, sym) \ + BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym)) + +#define bfd_canonicalize_symtab(abfd, location) \ + BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location)) + +bfd_boolean bfd_set_symtab + (bfd *abfd, asymbol **location, unsigned int count); + +void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol); + +#define bfd_make_empty_symbol(abfd) \ + BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) + +asymbol *_bfd_generic_make_empty_symbol (bfd *); + +#define bfd_make_debug_symbol(abfd,ptr,size) \ + BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size)) + +int bfd_decode_symclass (asymbol *symbol); + +bfd_boolean bfd_is_undefined_symclass (int symclass); + +void bfd_symbol_info (asymbol *symbol, symbol_info *ret); + +bfd_boolean bfd_copy_private_symbol_data + (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym); + +#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \ + BFD_SEND (obfd, _bfd_copy_private_symbol_data, \ + (ibfd, isymbol, obfd, osymbol)) + +/* Extracted from bfd.c. */ +struct bfd +{ + /* A unique identifier of the BFD */ + unsigned int id; + + /* The filename the application opened the BFD with. */ + const char *filename; + + /* A pointer to the target jump table. */ + const struct bfd_target *xvec; + + /* The IOSTREAM, and corresponding IO vector that provide access + to the file backing the BFD. */ + void *iostream; + const struct bfd_iovec *iovec; + + /* Is the file descriptor being cached? That is, can it be closed as + needed, and re-opened when accessed later? */ + bfd_boolean cacheable; + + /* Marks whether there was a default target specified when the + BFD was opened. This is used to select which matching algorithm + to use to choose the back end. */ + bfd_boolean target_defaulted; + + /* The caching routines use these to maintain a + least-recently-used list of BFDs. */ + struct bfd *lru_prev, *lru_next; + + /* When a file is closed by the caching routines, BFD retains + state information on the file here... */ + ufile_ptr where; + + /* ... and here: (``once'' means at least once). */ + bfd_boolean opened_once; + + /* Set if we have a locally maintained mtime value, rather than + getting it from the file each time. */ + bfd_boolean mtime_set; + + /* File modified time, if mtime_set is TRUE. */ + long mtime; + + /* Reserved for an unimplemented file locking extension. */ + int ifd; + + /* The format which belongs to the BFD. (object, core, etc.) */ + bfd_format format; + + /* The direction with which the BFD was opened. */ + enum bfd_direction + { + no_direction = 0, + read_direction = 1, + write_direction = 2, + both_direction = 3 + } + direction; + + /* Format_specific flags. */ + flagword flags; + + /* Currently my_archive is tested before adding origin to + anything. I believe that this can become always an add of + origin, with origin set to 0 for non archive files. */ + ufile_ptr origin; + + /* Remember when output has begun, to stop strange things + from happening. */ + bfd_boolean output_has_begun; + + /* A hash table for section names. */ + struct bfd_hash_table section_htab; + + /* Pointer to linked list of sections. */ + struct bfd_section *sections; + + /* The last section on the section list. */ + struct bfd_section *section_last; + + /* The number of sections. */ + unsigned int section_count; + + /* Stuff only useful for object files: + The start address. */ + bfd_vma start_address; + + /* Used for input and output. */ + unsigned int symcount; + + /* Symbol table for output BFD (with symcount entries). */ + struct bfd_symbol **outsymbols; + + /* Used for slurped dynamic symbol tables. */ + unsigned int dynsymcount; + + /* Pointer to structure which contains architecture information. */ + const struct bfd_arch_info *arch_info; + + /* Flag set if symbols from this BFD should not be exported. */ + bfd_boolean no_export; + + /* Stuff only useful for archives. */ + void *arelt_data; + struct bfd *my_archive; /* The containing archive BFD. */ + struct bfd *next; /* The next BFD in the archive. */ + struct bfd *archive_head; /* The first BFD in the archive. */ + bfd_boolean has_armap; + + /* A chain of BFD structures involved in a link. */ + struct bfd *link_next; + + /* A field used by _bfd_generic_link_add_archive_symbols. This will + be used only for archive elements. */ + int archive_pass; + + /* Used by the back end to hold private data. */ + union + { + struct aout_data_struct *aout_data; + struct artdata *aout_ar_data; + struct _oasys_data *oasys_obj_data; + struct _oasys_ar_data *oasys_ar_data; + struct coff_tdata *coff_obj_data; + struct pe_tdata *pe_obj_data; + struct xcoff_tdata *xcoff_obj_data; + struct ecoff_tdata *ecoff_obj_data; + struct ieee_data_struct *ieee_data; + struct ieee_ar_data_struct *ieee_ar_data; + struct srec_data_struct *srec_data; + struct ihex_data_struct *ihex_data; + struct tekhex_data_struct *tekhex_data; + struct elf_obj_tdata *elf_obj_data; + struct nlm_obj_tdata *nlm_obj_data; + struct bout_data_struct *bout_data; + struct mmo_data_struct *mmo_data; + struct sun_core_struct *sun_core_data; + struct sco5_core_struct *sco5_core_data; + struct trad_core_struct *trad_core_data; + struct som_data_struct *som_data; + struct hpux_core_struct *hpux_core_data; + struct hppabsd_core_struct *hppabsd_core_data; + struct sgi_core_struct *sgi_core_data; + struct lynx_core_struct *lynx_core_data; + struct osf_core_struct *osf_core_data; + struct cisco_core_struct *cisco_core_data; + struct versados_data_struct *versados_data; + struct netbsd_core_struct *netbsd_core_data; + struct mach_o_data_struct *mach_o_data; + struct mach_o_fat_data_struct *mach_o_fat_data; + struct bfd_pef_data_struct *pef_data; + struct bfd_pef_xlib_data_struct *pef_xlib_data; + struct bfd_sym_data_struct *sym_data; + void *any; + } + tdata; + + /* Used by the application to hold private data. */ + void *usrdata; + + /* Where all the allocated stuff under this BFD goes. This is a + struct objalloc *, but we use void * to avoid requiring the inclusion + of objalloc.h. */ + void *memory; +}; + +typedef enum bfd_error +{ + bfd_error_no_error = 0, + bfd_error_system_call, + bfd_error_invalid_target, + bfd_error_wrong_format, + bfd_error_wrong_object_format, + bfd_error_invalid_operation, + bfd_error_no_memory, + bfd_error_no_symbols, + bfd_error_no_armap, + bfd_error_no_more_archived_files, + bfd_error_malformed_archive, + bfd_error_file_not_recognized, + bfd_error_file_ambiguously_recognized, + bfd_error_no_contents, + bfd_error_nonrepresentable_section, + bfd_error_no_debug_section, + bfd_error_bad_value, + bfd_error_file_truncated, + bfd_error_file_too_big, + bfd_error_invalid_error_code +} +bfd_error_type; + +bfd_error_type bfd_get_error (void); + +void bfd_set_error (bfd_error_type error_tag); + +const char *bfd_errmsg (bfd_error_type error_tag); + +void bfd_perror (const char *message); + +typedef void (*bfd_error_handler_type) (const char *, ...); + +bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type); + +void bfd_set_error_program_name (const char *); + +bfd_error_handler_type bfd_get_error_handler (void); + +long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect); + +long bfd_canonicalize_reloc + (bfd *abfd, asection *sec, arelent **loc, asymbol **syms); + +void bfd_set_reloc + (bfd *abfd, asection *sec, arelent **rel, unsigned int count); + +bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags); + +int bfd_get_arch_size (bfd *abfd); + +int bfd_get_sign_extend_vma (bfd *abfd); + +bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma); + +unsigned int bfd_get_gp_size (bfd *abfd); + +void bfd_set_gp_size (bfd *abfd, unsigned int i); + +bfd_vma bfd_scan_vma (const char *string, const char **end, int base); + +bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd); + +#define bfd_copy_private_header_data(ibfd, obfd) \ + BFD_SEND (obfd, _bfd_copy_private_header_data, \ + (ibfd, obfd)) +bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd); + +#define bfd_copy_private_bfd_data(ibfd, obfd) \ + BFD_SEND (obfd, _bfd_copy_private_bfd_data, \ + (ibfd, obfd)) +bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd); + +#define bfd_merge_private_bfd_data(ibfd, obfd) \ + BFD_SEND (obfd, _bfd_merge_private_bfd_data, \ + (ibfd, obfd)) +bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags); + +#define bfd_set_private_flags(abfd, flags) \ + BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags)) +#define bfd_sizeof_headers(abfd, reloc) \ + BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc)) + +#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \ + BFD_SEND (abfd, _bfd_find_nearest_line, \ + (abfd, sec, syms, off, file, func, line)) + +#define bfd_find_line(abfd, syms, sym, file, line) \ + BFD_SEND (abfd, _bfd_find_line, \ + (abfd, syms, sym, file, line)) + +#define bfd_find_inliner_info(abfd, file, func, line) \ + BFD_SEND (abfd, _bfd_find_inliner_info, \ + (abfd, file, func, line)) + +#define bfd_debug_info_start(abfd) \ + BFD_SEND (abfd, _bfd_debug_info_start, (abfd)) + +#define bfd_debug_info_end(abfd) \ + BFD_SEND (abfd, _bfd_debug_info_end, (abfd)) + +#define bfd_debug_info_accumulate(abfd, section) \ + BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section)) + +#define bfd_stat_arch_elt(abfd, stat) \ + BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) + +#define bfd_update_armap_timestamp(abfd) \ + BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd)) + +#define bfd_set_arch_mach(abfd, arch, mach)\ + BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach)) + +#define bfd_relax_section(abfd, section, link_info, again) \ + BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again)) + +#define bfd_gc_sections(abfd, link_info) \ + BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info)) + +#define bfd_merge_sections(abfd, link_info) \ + BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info)) + +#define bfd_is_group_section(abfd, sec) \ + BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec)) + +#define bfd_discard_group(abfd, sec) \ + BFD_SEND (abfd, _bfd_discard_group, (abfd, sec)) + +#define bfd_link_hash_table_create(abfd) \ + BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd)) + +#define bfd_link_hash_table_free(abfd, hash) \ + BFD_SEND (abfd, _bfd_link_hash_table_free, (hash)) + +#define bfd_link_add_symbols(abfd, info) \ + BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info)) + +#define bfd_link_just_syms(abfd, sec, info) \ + BFD_SEND (abfd, _bfd_link_just_syms, (sec, info)) + +#define bfd_final_link(abfd, info) \ + BFD_SEND (abfd, _bfd_final_link, (abfd, info)) + +#define bfd_free_cached_info(abfd) \ + BFD_SEND (abfd, _bfd_free_cached_info, (abfd)) + +#define bfd_get_dynamic_symtab_upper_bound(abfd) \ + BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd)) + +#define bfd_print_private_bfd_data(abfd, file)\ + BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file)) + +#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \ + BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols)) + +#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \ + BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \ + dyncount, dynsyms, ret)) + +#define bfd_get_dynamic_reloc_upper_bound(abfd) \ + BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd)) + +#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \ + BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms)) + +extern bfd_byte *bfd_get_relocated_section_contents + (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *, + bfd_boolean, asymbol **); + +bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative); + +struct bfd_preserve +{ + void *marker; + void *tdata; + flagword flags; + const struct bfd_arch_info *arch_info; + struct bfd_section *sections; + struct bfd_section *section_last; + unsigned int section_count; + struct bfd_hash_table section_htab; +}; + +bfd_boolean bfd_preserve_save (bfd *, struct bfd_preserve *); + +void bfd_preserve_restore (bfd *, struct bfd_preserve *); + +void bfd_preserve_finish (bfd *, struct bfd_preserve *); + +/* Extracted from archive.c. */ +symindex bfd_get_next_mapent + (bfd *abfd, symindex previous, carsym **sym); + +bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head); + +bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous); + +/* Extracted from corefile.c. */ +const char *bfd_core_file_failing_command (bfd *abfd); + +int bfd_core_file_failing_signal (bfd *abfd); + +bfd_boolean core_file_matches_executable_p + (bfd *core_bfd, bfd *exec_bfd); + +/* Extracted from targets.c. */ +#define BFD_SEND(bfd, message, arglist) \ + ((*((bfd)->xvec->message)) arglist) + +#ifdef DEBUG_BFD_SEND +#undef BFD_SEND +#define BFD_SEND(bfd, message, arglist) \ + (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \ + ((*((bfd)->xvec->message)) arglist) : \ + (bfd_assert (__FILE__,__LINE__), NULL)) +#endif +#define BFD_SEND_FMT(bfd, message, arglist) \ + (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist) + +#ifdef DEBUG_BFD_SEND +#undef BFD_SEND_FMT +#define BFD_SEND_FMT(bfd, message, arglist) \ + (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \ + (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist) : \ + (bfd_assert (__FILE__,__LINE__), NULL)) +#endif + +enum bfd_flavour +{ + bfd_target_unknown_flavour, + bfd_target_aout_flavour, + bfd_target_coff_flavour, + bfd_target_ecoff_flavour, + bfd_target_xcoff_flavour, + bfd_target_elf_flavour, + bfd_target_ieee_flavour, + bfd_target_nlm_flavour, + bfd_target_oasys_flavour, + bfd_target_tekhex_flavour, + bfd_target_srec_flavour, + bfd_target_ihex_flavour, + bfd_target_som_flavour, + bfd_target_os9k_flavour, + bfd_target_versados_flavour, + bfd_target_msdos_flavour, + bfd_target_ovax_flavour, + bfd_target_evax_flavour, + bfd_target_mmo_flavour, + bfd_target_mach_o_flavour, + bfd_target_pef_flavour, + bfd_target_pef_xlib_flavour, + bfd_target_sym_flavour +}; + +enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN }; + +/* Forward declaration. */ +typedef struct bfd_link_info _bfd_link_info; + +typedef struct bfd_target +{ + /* Identifies the kind of target, e.g., SunOS4, Ultrix, etc. */ + char *name; + + /* The "flavour" of a back end is a general indication about + the contents of a file. */ + enum bfd_flavour flavour; + + /* The order of bytes within the data area of a file. */ + enum bfd_endian byteorder; + + /* The order of bytes within the header parts of a file. */ + enum bfd_endian header_byteorder; + + /* A mask of all the flags which an executable may have set - + from the set <>, <>, ...<>. */ + flagword object_flags; + + /* A mask of all the flags which a section may have set - from + the set <>, <>, ...<>. */ + flagword section_flags; + + /* The character normally found at the front of a symbol. + (if any), perhaps `_'. */ + char symbol_leading_char; + + /* The pad character for file names within an archive header. */ + char ar_pad_char; + + /* The maximum number of characters in an archive header. */ + unsigned short ar_max_namelen; + + /* Entries for byte swapping for data. These are different from the + other entry points, since they don't take a BFD as the first argument. + Certain other handlers could do the same. */ + bfd_uint64_t (*bfd_getx64) (const void *); + bfd_int64_t (*bfd_getx_signed_64) (const void *); + void (*bfd_putx64) (bfd_uint64_t, void *); + bfd_vma (*bfd_getx32) (const void *); + bfd_signed_vma (*bfd_getx_signed_32) (const void *); + void (*bfd_putx32) (bfd_vma, void *); + bfd_vma (*bfd_getx16) (const void *); + bfd_signed_vma (*bfd_getx_signed_16) (const void *); + void (*bfd_putx16) (bfd_vma, void *); + + /* Byte swapping for the headers. */ + bfd_uint64_t (*bfd_h_getx64) (const void *); + bfd_int64_t (*bfd_h_getx_signed_64) (const void *); + void (*bfd_h_putx64) (bfd_uint64_t, void *); + bfd_vma (*bfd_h_getx32) (const void *); + bfd_signed_vma (*bfd_h_getx_signed_32) (const void *); + void (*bfd_h_putx32) (bfd_vma, void *); + bfd_vma (*bfd_h_getx16) (const void *); + bfd_signed_vma (*bfd_h_getx_signed_16) (const void *); + void (*bfd_h_putx16) (bfd_vma, void *); + + /* Format dependent routines: these are vectors of entry points + within the target vector structure, one for each format to check. */ + + /* Check the format of a file being read. Return a <> or zero. */ + const struct bfd_target *(*_bfd_check_format[bfd_type_end]) (bfd *); + + /* Set the format of a file being written. */ + bfd_boolean (*_bfd_set_format[bfd_type_end]) (bfd *); + + /* Write cached information into a file being written, at <>. */ + bfd_boolean (*_bfd_write_contents[bfd_type_end]) (bfd *); + + + /* Generic entry points. */ +#define BFD_JUMP_TABLE_GENERIC(NAME) \ + NAME##_close_and_cleanup, \ + NAME##_bfd_free_cached_info, \ + NAME##_new_section_hook, \ + NAME##_get_section_contents, \ + NAME##_get_section_contents_in_window + + /* Called when the BFD is being closed to do any necessary cleanup. */ + bfd_boolean (*_close_and_cleanup) (bfd *); + /* Ask the BFD to free all cached information. */ + bfd_boolean (*_bfd_free_cached_info) (bfd *); + /* Called when a new section is created. */ + bfd_boolean (*_new_section_hook) (bfd *, sec_ptr); + /* Read the contents of a section. */ + bfd_boolean (*_bfd_get_section_contents) + (bfd *, sec_ptr, void *, file_ptr, bfd_size_type); + bfd_boolean (*_bfd_get_section_contents_in_window) + (bfd *, sec_ptr, bfd_window *, file_ptr, bfd_size_type); + + /* Entry points to copy private data. */ +#define BFD_JUMP_TABLE_COPY(NAME) \ + NAME##_bfd_copy_private_bfd_data, \ + NAME##_bfd_merge_private_bfd_data, \ + NAME##_bfd_copy_private_section_data, \ + NAME##_bfd_copy_private_symbol_data, \ + NAME##_bfd_copy_private_header_data, \ + NAME##_bfd_set_private_flags, \ + NAME##_bfd_print_private_bfd_data + + /* Called to copy BFD general private data from one object file + to another. */ + bfd_boolean (*_bfd_copy_private_bfd_data) (bfd *, bfd *); + /* Called to merge BFD general private data from one object file + to a common output file when linking. */ + bfd_boolean (*_bfd_merge_private_bfd_data) (bfd *, bfd *); + /* Called to copy BFD private section data from one object file + to another. */ + bfd_boolean (*_bfd_copy_private_section_data) + (bfd *, sec_ptr, bfd *, sec_ptr); + /* Called to copy BFD private symbol data from one symbol + to another. */ + bfd_boolean (*_bfd_copy_private_symbol_data) + (bfd *, asymbol *, bfd *, asymbol *); + /* Called to copy BFD private header data from one object file + to another. */ + bfd_boolean (*_bfd_copy_private_header_data) + (bfd *, bfd *); + /* Called to set private backend flags. */ + bfd_boolean (*_bfd_set_private_flags) (bfd *, flagword); + + /* Called to print private BFD data. */ + bfd_boolean (*_bfd_print_private_bfd_data) (bfd *, void *); + + /* Core file entry points. */ +#define BFD_JUMP_TABLE_CORE(NAME) \ + NAME##_core_file_failing_command, \ + NAME##_core_file_failing_signal, \ + NAME##_core_file_matches_executable_p + + char * (*_core_file_failing_command) (bfd *); + int (*_core_file_failing_signal) (bfd *); + bfd_boolean (*_core_file_matches_executable_p) (bfd *, bfd *); + + /* Archive entry points. */ +#define BFD_JUMP_TABLE_ARCHIVE(NAME) \ + NAME##_slurp_armap, \ + NAME##_slurp_extended_name_table, \ + NAME##_construct_extended_name_table, \ + NAME##_truncate_arname, \ + NAME##_write_armap, \ + NAME##_read_ar_hdr, \ + NAME##_openr_next_archived_file, \ + NAME##_get_elt_at_index, \ + NAME##_generic_stat_arch_elt, \ + NAME##_update_armap_timestamp + + bfd_boolean (*_bfd_slurp_armap) (bfd *); + bfd_boolean (*_bfd_slurp_extended_name_table) (bfd *); + bfd_boolean (*_bfd_construct_extended_name_table) + (bfd *, char **, bfd_size_type *, const char **); + void (*_bfd_truncate_arname) (bfd *, const char *, char *); + bfd_boolean (*write_armap) + (bfd *, unsigned int, struct orl *, unsigned int, int); + void * (*_bfd_read_ar_hdr_fn) (bfd *); + bfd * (*openr_next_archived_file) (bfd *, bfd *); +#define bfd_get_elt_at_index(b,i) BFD_SEND (b, _bfd_get_elt_at_index, (b,i)) + bfd * (*_bfd_get_elt_at_index) (bfd *, symindex); + int (*_bfd_stat_arch_elt) (bfd *, struct stat *); + bfd_boolean (*_bfd_update_armap_timestamp) (bfd *); + + /* Entry points used for symbols. */ +#define BFD_JUMP_TABLE_SYMBOLS(NAME) \ + NAME##_get_symtab_upper_bound, \ + NAME##_canonicalize_symtab, \ + NAME##_make_empty_symbol, \ + NAME##_print_symbol, \ + NAME##_get_symbol_info, \ + NAME##_bfd_is_local_label_name, \ + NAME##_bfd_is_target_special_symbol, \ + NAME##_get_lineno, \ + NAME##_find_nearest_line, \ + _bfd_generic_find_line, \ + NAME##_find_inliner_info, \ + NAME##_bfd_make_debug_symbol, \ + NAME##_read_minisymbols, \ + NAME##_minisymbol_to_symbol + + long (*_bfd_get_symtab_upper_bound) (bfd *); + long (*_bfd_canonicalize_symtab) + (bfd *, struct bfd_symbol **); + struct bfd_symbol * + (*_bfd_make_empty_symbol) (bfd *); + void (*_bfd_print_symbol) + (bfd *, void *, struct bfd_symbol *, bfd_print_symbol_type); +#define bfd_print_symbol(b,p,s,e) BFD_SEND (b, _bfd_print_symbol, (b,p,s,e)) + void (*_bfd_get_symbol_info) + (bfd *, struct bfd_symbol *, symbol_info *); +#define bfd_get_symbol_info(b,p,e) BFD_SEND (b, _bfd_get_symbol_info, (b,p,e)) + bfd_boolean (*_bfd_is_local_label_name) (bfd *, const char *); + bfd_boolean (*_bfd_is_target_special_symbol) (bfd *, asymbol *); + alent * (*_get_lineno) (bfd *, struct bfd_symbol *); + bfd_boolean (*_bfd_find_nearest_line) + (bfd *, struct bfd_section *, struct bfd_symbol **, bfd_vma, + const char **, const char **, unsigned int *); + bfd_boolean (*_bfd_find_line) + (bfd *, struct bfd_symbol **, struct bfd_symbol *, + const char **, unsigned int *); + bfd_boolean (*_bfd_find_inliner_info) + (bfd *, const char **, const char **, unsigned int *); + /* Back-door to allow format-aware applications to create debug symbols + while using BFD for everything else. Currently used by the assembler + when creating COFF files. */ + asymbol * (*_bfd_make_debug_symbol) + (bfd *, void *, unsigned long size); +#define bfd_read_minisymbols(b, d, m, s) \ + BFD_SEND (b, _read_minisymbols, (b, d, m, s)) + long (*_read_minisymbols) + (bfd *, bfd_boolean, void **, unsigned int *); +#define bfd_minisymbol_to_symbol(b, d, m, f) \ + BFD_SEND (b, _minisymbol_to_symbol, (b, d, m, f)) + asymbol * (*_minisymbol_to_symbol) + (bfd *, bfd_boolean, const void *, asymbol *); + + /* Routines for relocs. */ +#define BFD_JUMP_TABLE_RELOCS(NAME) \ + NAME##_get_reloc_upper_bound, \ + NAME##_canonicalize_reloc, \ + NAME##_bfd_reloc_type_lookup + + long (*_get_reloc_upper_bound) (bfd *, sec_ptr); + long (*_bfd_canonicalize_reloc) + (bfd *, sec_ptr, arelent **, struct bfd_symbol **); + /* See documentation on reloc types. */ + reloc_howto_type * + (*reloc_type_lookup) (bfd *, bfd_reloc_code_real_type); + + /* Routines used when writing an object file. */ +#define BFD_JUMP_TABLE_WRITE(NAME) \ + NAME##_set_arch_mach, \ + NAME##_set_section_contents + + bfd_boolean (*_bfd_set_arch_mach) + (bfd *, enum bfd_architecture, unsigned long); + bfd_boolean (*_bfd_set_section_contents) + (bfd *, sec_ptr, const void *, file_ptr, bfd_size_type); + + /* Routines used by the linker. */ +#define BFD_JUMP_TABLE_LINK(NAME) \ + NAME##_sizeof_headers, \ + NAME##_bfd_get_relocated_section_contents, \ + NAME##_bfd_relax_section, \ + NAME##_bfd_link_hash_table_create, \ + NAME##_bfd_link_hash_table_free, \ + NAME##_bfd_link_add_symbols, \ + NAME##_bfd_link_just_syms, \ + NAME##_bfd_final_link, \ + NAME##_bfd_link_split_section, \ + NAME##_bfd_gc_sections, \ + NAME##_bfd_merge_sections, \ + NAME##_bfd_is_group_section, \ + NAME##_bfd_discard_group, \ + NAME##_section_already_linked \ + + int (*_bfd_sizeof_headers) (bfd *, bfd_boolean); + bfd_byte * (*_bfd_get_relocated_section_contents) + (bfd *, struct bfd_link_info *, struct bfd_link_order *, + bfd_byte *, bfd_boolean, struct bfd_symbol **); + + bfd_boolean (*_bfd_relax_section) + (bfd *, struct bfd_section *, struct bfd_link_info *, bfd_boolean *); + + /* Create a hash table for the linker. Different backends store + different information in this table. */ + struct bfd_link_hash_table * + (*_bfd_link_hash_table_create) (bfd *); + + /* Release the memory associated with the linker hash table. */ + void (*_bfd_link_hash_table_free) (struct bfd_link_hash_table *); + + /* Add symbols from this object file into the hash table. */ + bfd_boolean (*_bfd_link_add_symbols) (bfd *, struct bfd_link_info *); + + /* Indicate that we are only retrieving symbol values from this section. */ + void (*_bfd_link_just_syms) (asection *, struct bfd_link_info *); + + /* Do a link based on the link_order structures attached to each + section of the BFD. */ + bfd_boolean (*_bfd_final_link) (bfd *, struct bfd_link_info *); + + /* Should this section be split up into smaller pieces during linking. */ + bfd_boolean (*_bfd_link_split_section) (bfd *, struct bfd_section *); + + /* Remove sections that are not referenced from the output. */ + bfd_boolean (*_bfd_gc_sections) (bfd *, struct bfd_link_info *); + + /* Attempt to merge SEC_MERGE sections. */ + bfd_boolean (*_bfd_merge_sections) (bfd *, struct bfd_link_info *); + + /* Is this section a member of a group? */ + bfd_boolean (*_bfd_is_group_section) (bfd *, const struct bfd_section *); + + /* Discard members of a group. */ + bfd_boolean (*_bfd_discard_group) (bfd *, struct bfd_section *); + + /* Check if SEC has been already linked during a reloceatable or + final link. */ + void (*_section_already_linked) (bfd *, struct bfd_section *); + + /* Routines to handle dynamic symbols and relocs. */ +#define BFD_JUMP_TABLE_DYNAMIC(NAME) \ + NAME##_get_dynamic_symtab_upper_bound, \ + NAME##_canonicalize_dynamic_symtab, \ + NAME##_get_synthetic_symtab, \ + NAME##_get_dynamic_reloc_upper_bound, \ + NAME##_canonicalize_dynamic_reloc + + /* Get the amount of memory required to hold the dynamic symbols. */ + long (*_bfd_get_dynamic_symtab_upper_bound) (bfd *); + /* Read in the dynamic symbols. */ + long (*_bfd_canonicalize_dynamic_symtab) + (bfd *, struct bfd_symbol **); + /* Create synthetized symbols. */ + long (*_bfd_get_synthetic_symtab) + (bfd *, long, struct bfd_symbol **, long, struct bfd_symbol **, + struct bfd_symbol **); + /* Get the amount of memory required to hold the dynamic relocs. */ + long (*_bfd_get_dynamic_reloc_upper_bound) (bfd *); + /* Read in the dynamic relocs. */ + long (*_bfd_canonicalize_dynamic_reloc) + (bfd *, arelent **, struct bfd_symbol **); + + /* Opposite endian version of this target. */ + const struct bfd_target * alternative_target; + + /* Data for use by back-end routines, which isn't + generic enough to belong in this structure. */ + const void *backend_data; + +} bfd_target; + +bfd_boolean bfd_set_default_target (const char *name); + +const bfd_target *bfd_find_target (const char *target_name, bfd *abfd); + +const char ** bfd_target_list (void); + +const bfd_target *bfd_search_for_target + (int (*search_func) (const bfd_target *, void *), + void *); + +/* Extracted from format.c. */ +bfd_boolean bfd_check_format (bfd *abfd, bfd_format format); + +bfd_boolean bfd_check_format_matches + (bfd *abfd, bfd_format format, char ***matching); + +bfd_boolean bfd_set_format (bfd *abfd, bfd_format format); + +const char *bfd_format_string (bfd_format format); + +/* Extracted from linker.c. */ +bfd_boolean bfd_link_split_section (bfd *abfd, asection *sec); + +#define bfd_link_split_section(abfd, sec) \ + BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec)) + +void bfd_section_already_linked (bfd *abfd, asection *sec); + +#define bfd_section_already_linked(abfd, sec) \ + BFD_SEND (abfd, _section_already_linked, (abfd, sec)) + +/* Extracted from simple.c. */ +bfd_byte *bfd_simple_get_relocated_section_contents + (bfd *abfd, asection *sec, bfd_byte *outbuf, asymbol **symbol_table); + +#ifdef __cplusplus +} +#endif +#endif diff -Naur linux-2.6.35.4/kernel/debug/mdb/bfd_64.h linux-2.6.35.4-cs/kernel/debug/mdb/bfd_64.h --- linux-2.6.35.4/kernel/debug/mdb/bfd_64.h 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/bfd_64.h 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,4917 @@ +/* DO NOT EDIT! -*- buffer-read-only: t -*- This file is automatically + generated from "bfd-in.h", "init.c", "opncls.c", "libbfd.c", + "bfdio.c", "bfdwin.c", "section.c", "archures.c", "reloc.c", + "syms.c", "bfd.c", "archive.c", "corefile.c", "targets.c", "format.c", + "linker.c" and "simple.c". + Run "make headers" in your build bfd/ to regenerate. */ + +/* Main header file for the bfd library -- portable access to object files. + + Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, + 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. + + Contributed by Cygnus Support. + + This file is part of BFD, the Binary File Descriptor library. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ + +/* Extracted from binutils 2.16.91.0.2 (OpenSUSE 10.0) and modified for kdb use. + * Any trailing whitespace was removed and #ifdef/ifndef __KERNEL__ added as + * required. + * Keith Owens 15 May 2006 + */ + +#ifndef __BFD_H_SEEN__ +#define __BFD_H_SEEN__ + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __KERNEL__ +#include "ansidecl.h" +#else /* __KERNEL__ */ +#include "ansidecl.h" +#include "symcat.h" +#endif /* __KERNEL__ */ +#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE) +#ifndef SABER +/* This hack is to avoid a problem with some strict ANSI C preprocessors. + The problem is, "32_" is not a valid preprocessing token, and we don't + want extra underscores (e.g., "nlm_32_"). The XCONCAT2 macro will + cause the inner CONCAT2 macros to be evaluated first, producing + still-valid pp-tokens. Then the final concatenation can be done. */ +#undef CONCAT4 +#define CONCAT4(a,b,c,d) XCONCAT2(CONCAT2(a,b),CONCAT2(c,d)) +#endif +#endif + +/* The word size used by BFD on the host. This may be 64 with a 32 + bit target if the host is 64 bit, or if other 64 bit targets have + been selected with --enable-targets, or if --enable-64-bit-bfd. */ +#define BFD_ARCH_SIZE 64 + +/* The word size of the default bfd target. */ +#define BFD_DEFAULT_TARGET_SIZE 64 + +#define BFD_HOST_64BIT_LONG 1 +#define BFD_HOST_LONG_LONG 1 +#if 1 +#define BFD_HOST_64_BIT long +#define BFD_HOST_U_64_BIT unsigned long +typedef BFD_HOST_64_BIT bfd_int64_t; +typedef BFD_HOST_U_64_BIT bfd_uint64_t; +#endif + +#if BFD_ARCH_SIZE >= 64 +#define BFD64 +#endif + +#ifndef INLINE +#if __GNUC__ >= 2 +#define INLINE __inline__ +#else +#define INLINE +#endif +#endif + +/* Forward declaration. */ +typedef struct bfd bfd; + +/* Boolean type used in bfd. Too many systems define their own + versions of "boolean" for us to safely typedef a "boolean" of + our own. Using an enum for "bfd_boolean" has its own set of + problems, with strange looking casts required to avoid warnings + on some older compilers. Thus we just use an int. + + General rule: Functions which are bfd_boolean return TRUE on + success and FALSE on failure (unless they're a predicate). */ + +typedef int bfd_boolean; +#undef FALSE +#undef TRUE +#define FALSE 0 +#define TRUE 1 + +#ifdef BFD64 + +#ifndef BFD_HOST_64_BIT + #error No 64 bit integer type available +#endif /* ! defined (BFD_HOST_64_BIT) */ + +typedef BFD_HOST_U_64_BIT bfd_vma; +typedef BFD_HOST_64_BIT bfd_signed_vma; +typedef BFD_HOST_U_64_BIT bfd_size_type; +typedef BFD_HOST_U_64_BIT symvalue; + +#ifndef fprintf_vma +#if BFD_HOST_64BIT_LONG +#define sprintf_vma(s,x) sprintf (s, "%016lx", x) +#define fprintf_vma(f,x) fprintf (f, "%016lx", x) +#else +#define _bfd_int64_low(x) ((unsigned long) (((x) & 0xffffffff))) +#define _bfd_int64_high(x) ((unsigned long) (((x) >> 32) & 0xffffffff)) +#define fprintf_vma(s,x) \ + fprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x)) +#define sprintf_vma(s,x) \ + sprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x)) +#endif +#endif + +#else /* not BFD64 */ + +/* Represent a target address. Also used as a generic unsigned type + which is guaranteed to be big enough to hold any arithmetic types + we need to deal with. */ +typedef unsigned long bfd_vma; + +/* A generic signed type which is guaranteed to be big enough to hold any + arithmetic types we need to deal with. Can be assumed to be compatible + with bfd_vma in the same way that signed and unsigned ints are compatible + (as parameters, in assignment, etc). */ +typedef long bfd_signed_vma; + +typedef unsigned long symvalue; +typedef unsigned long bfd_size_type; + +/* Print a bfd_vma x on stream s. */ +#define fprintf_vma(s,x) fprintf (s, "%08lx", x) +#define sprintf_vma(s,x) sprintf (s, "%08lx", x) + +#endif /* not BFD64 */ + +#define HALF_BFD_SIZE_TYPE \ + (((bfd_size_type) 1) << (8 * sizeof (bfd_size_type) / 2)) + +#ifndef BFD_HOST_64_BIT +/* Fall back on a 32 bit type. The idea is to make these types always + available for function return types, but in the case that + BFD_HOST_64_BIT is undefined such a function should abort or + otherwise signal an error. */ +typedef bfd_signed_vma bfd_int64_t; +typedef bfd_vma bfd_uint64_t; +#endif + +/* An offset into a file. BFD always uses the largest possible offset + based on the build time availability of fseek, fseeko, or fseeko64. */ +typedef BFD_HOST_64_BIT file_ptr; +typedef unsigned BFD_HOST_64_BIT ufile_ptr; + +extern void bfd_sprintf_vma (bfd *, char *, bfd_vma); +extern void bfd_fprintf_vma (bfd *, void *, bfd_vma); + +#define printf_vma(x) fprintf_vma(stdout,x) +#define bfd_printf_vma(abfd,x) bfd_fprintf_vma (abfd,stdout,x) + +typedef unsigned int flagword; /* 32 bits of flags */ +typedef unsigned char bfd_byte; + +/* File formats. */ + +typedef enum bfd_format +{ + bfd_unknown = 0, /* File format is unknown. */ + bfd_object, /* Linker/assembler/compiler output. */ + bfd_archive, /* Object archive file. */ + bfd_core, /* Core dump. */ + bfd_type_end /* Marks the end; don't use it! */ +} +bfd_format; + +/* Values that may appear in the flags field of a BFD. These also + appear in the object_flags field of the bfd_target structure, where + they indicate the set of flags used by that backend (not all flags + are meaningful for all object file formats) (FIXME: at the moment, + the object_flags values have mostly just been copied from backend + to another, and are not necessarily correct). */ + +/* No flags. */ +#define BFD_NO_FLAGS 0x00 + +/* BFD contains relocation entries. */ +#define HAS_RELOC 0x01 + +/* BFD is directly executable. */ +#define EXEC_P 0x02 + +/* BFD has line number information (basically used for F_LNNO in a + COFF header). */ +#define HAS_LINENO 0x04 + +/* BFD has debugging information. */ +#define HAS_DEBUG 0x08 + +/* BFD has symbols. */ +#define HAS_SYMS 0x10 + +/* BFD has local symbols (basically used for F_LSYMS in a COFF + header). */ +#define HAS_LOCALS 0x20 + +/* BFD is a dynamic object. */ +#define DYNAMIC 0x40 + +/* Text section is write protected (if D_PAGED is not set, this is + like an a.out NMAGIC file) (the linker sets this by default, but + clears it for -r or -N). */ +#define WP_TEXT 0x80 + +/* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the + linker sets this by default, but clears it for -r or -n or -N). */ +#define D_PAGED 0x100 + +/* BFD is relaxable (this means that bfd_relax_section may be able to + do something) (sometimes bfd_relax_section can do something even if + this is not set). */ +#define BFD_IS_RELAXABLE 0x200 + +/* This may be set before writing out a BFD to request using a + traditional format. For example, this is used to request that when + writing out an a.out object the symbols not be hashed to eliminate + duplicates. */ +#define BFD_TRADITIONAL_FORMAT 0x400 + +/* This flag indicates that the BFD contents are actually cached in + memory. If this is set, iostream points to a bfd_in_memory struct. */ +#define BFD_IN_MEMORY 0x800 + +/* The sections in this BFD specify a memory page. */ +#define HAS_LOAD_PAGE 0x1000 + +/* This BFD has been created by the linker and doesn't correspond + to any input file. */ +#define BFD_LINKER_CREATED 0x2000 + +/* Symbols and relocation. */ + +/* A count of carsyms (canonical archive symbols). */ +typedef unsigned long symindex; + +/* How to perform a relocation. */ +typedef const struct reloc_howto_struct reloc_howto_type; + +#define BFD_NO_MORE_SYMBOLS ((symindex) ~0) + +/* General purpose part of a symbol X; + target specific parts are in libcoff.h, libaout.h, etc. */ + +#define bfd_get_section(x) ((x)->section) +#define bfd_get_output_section(x) ((x)->section->output_section) +#define bfd_set_section(x,y) ((x)->section) = (y) +#define bfd_asymbol_base(x) ((x)->section->vma) +#define bfd_asymbol_value(x) (bfd_asymbol_base(x) + (x)->value) +#define bfd_asymbol_name(x) ((x)->name) +/*Perhaps future: #define bfd_asymbol_bfd(x) ((x)->section->owner)*/ +#define bfd_asymbol_bfd(x) ((x)->the_bfd) +#define bfd_asymbol_flavour(x) (bfd_asymbol_bfd(x)->xvec->flavour) + +/* A canonical archive symbol. */ +/* This is a type pun with struct ranlib on purpose! */ +typedef struct carsym +{ + char *name; + file_ptr file_offset; /* Look here to find the file. */ +} +carsym; /* To make these you call a carsymogen. */ + +/* Used in generating armaps (archive tables of contents). + Perhaps just a forward definition would do? */ +struct orl /* Output ranlib. */ +{ + char **name; /* Symbol name. */ + union + { + file_ptr pos; + bfd *abfd; + } u; /* bfd* or file position. */ + int namidx; /* Index into string table. */ +}; + +/* Linenumber stuff. */ +typedef struct lineno_cache_entry +{ + unsigned int line_number; /* Linenumber from start of function. */ + union + { + struct bfd_symbol *sym; /* Function name. */ + bfd_vma offset; /* Offset into section. */ + } u; +} +alent; + +/* Object and core file sections. */ + +#define align_power(addr, align) \ + (((addr) + ((bfd_vma) 1 << (align)) - 1) & ((bfd_vma) -1 << (align))) + +typedef struct bfd_section *sec_ptr; + +#define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0) +#define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0) +#define bfd_get_section_lma(bfd, ptr) ((ptr)->lma + 0) +#define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0) +#define bfd_section_name(bfd, ptr) ((ptr)->name) +#define bfd_section_size(bfd, ptr) ((ptr)->size) +#define bfd_get_section_size(ptr) ((ptr)->size) +#define bfd_section_vma(bfd, ptr) ((ptr)->vma) +#define bfd_section_lma(bfd, ptr) ((ptr)->lma) +#define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power) +#define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0) +#define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata) + +#define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0) + +#define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma = (val)), ((ptr)->user_set_vma = TRUE), TRUE) +#define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),TRUE) +#define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),TRUE) +/* Find the address one past the end of SEC. */ +#define bfd_get_section_limit(bfd, sec) \ + (((sec)->rawsize ? (sec)->rawsize : (sec)->size) \ + / bfd_octets_per_byte (bfd)) + +typedef struct stat stat_type; + +typedef enum bfd_print_symbol +{ + bfd_print_symbol_name, + bfd_print_symbol_more, + bfd_print_symbol_all +} bfd_print_symbol_type; + +/* Information about a symbol that nm needs. */ + +typedef struct _symbol_info +{ + symvalue value; + char type; + const char *name; /* Symbol name. */ + unsigned char stab_type; /* Stab type. */ + char stab_other; /* Stab other. */ + short stab_desc; /* Stab desc. */ + const char *stab_name; /* String for stab type. */ +} symbol_info; + +/* Get the name of a stabs type code. */ + +extern const char *bfd_get_stab_name (int); + +/* Hash table routines. There is no way to free up a hash table. */ + +/* An element in the hash table. Most uses will actually use a larger + structure, and an instance of this will be the first field. */ + +struct bfd_hash_entry +{ + /* Next entry for this hash code. */ + struct bfd_hash_entry *next; + /* String being hashed. */ + const char *string; + /* Hash code. This is the full hash code, not the index into the + table. */ + unsigned long hash; +}; + +/* A hash table. */ + +struct bfd_hash_table +{ + /* The hash array. */ + struct bfd_hash_entry **table; + /* The number of slots in the hash table. */ + unsigned int size; + /* A function used to create new elements in the hash table. The + first entry is itself a pointer to an element. When this + function is first invoked, this pointer will be NULL. However, + having the pointer permits a hierarchy of method functions to be + built each of which calls the function in the superclass. Thus + each function should be written to allocate a new block of memory + only if the argument is NULL. */ + struct bfd_hash_entry *(*newfunc) + (struct bfd_hash_entry *, struct bfd_hash_table *, const char *); + /* An objalloc for this hash table. This is a struct objalloc *, + but we use void * to avoid requiring the inclusion of objalloc.h. */ + void *memory; +}; + +/* Initialize a hash table. */ +extern bfd_boolean bfd_hash_table_init + (struct bfd_hash_table *, + struct bfd_hash_entry *(*) (struct bfd_hash_entry *, + struct bfd_hash_table *, + const char *)); + +/* Initialize a hash table specifying a size. */ +extern bfd_boolean bfd_hash_table_init_n + (struct bfd_hash_table *, + struct bfd_hash_entry *(*) (struct bfd_hash_entry *, + struct bfd_hash_table *, + const char *), + unsigned int size); + +/* Free up a hash table. */ +extern void bfd_hash_table_free + (struct bfd_hash_table *); + +/* Look up a string in a hash table. If CREATE is TRUE, a new entry + will be created for this string if one does not already exist. The + COPY argument must be TRUE if this routine should copy the string + into newly allocated memory when adding an entry. */ +extern struct bfd_hash_entry *bfd_hash_lookup + (struct bfd_hash_table *, const char *, bfd_boolean create, + bfd_boolean copy); + +/* Replace an entry in a hash table. */ +extern void bfd_hash_replace + (struct bfd_hash_table *, struct bfd_hash_entry *old, + struct bfd_hash_entry *nw); + +/* Base method for creating a hash table entry. */ +extern struct bfd_hash_entry *bfd_hash_newfunc + (struct bfd_hash_entry *, struct bfd_hash_table *, const char *); + +/* Grab some space for a hash table entry. */ +extern void *bfd_hash_allocate + (struct bfd_hash_table *, unsigned int); + +/* Traverse a hash table in a random order, calling a function on each + element. If the function returns FALSE, the traversal stops. The + INFO argument is passed to the function. */ +extern void bfd_hash_traverse + (struct bfd_hash_table *, + bfd_boolean (*) (struct bfd_hash_entry *, void *), + void *info); + +/* Allows the default size of a hash table to be configured. New hash + tables allocated using bfd_hash_table_init will be created with + this size. */ +extern void bfd_hash_set_default_size (bfd_size_type); + +/* This structure is used to keep track of stabs in sections + information while linking. */ + +struct stab_info +{ + /* A hash table used to hold stabs strings. */ + struct bfd_strtab_hash *strings; + /* The header file hash table. */ + struct bfd_hash_table includes; + /* The first .stabstr section. */ + struct bfd_section *stabstr; +}; + +#define COFF_SWAP_TABLE (void *) &bfd_coff_std_swap_table + +/* User program access to BFD facilities. */ + +/* Direct I/O routines, for programs which know more about the object + file than BFD does. Use higher level routines if possible. */ + +extern bfd_size_type bfd_bread (void *, bfd_size_type, bfd *); +extern bfd_size_type bfd_bwrite (const void *, bfd_size_type, bfd *); +extern int bfd_seek (bfd *, file_ptr, int); +extern file_ptr bfd_tell (bfd *); +extern int bfd_flush (bfd *); +extern int bfd_stat (bfd *, struct stat *); + +/* Deprecated old routines. */ +#if __GNUC__ +#define bfd_read(BUF, ELTSIZE, NITEMS, ABFD) \ + (warn_deprecated ("bfd_read", __FILE__, __LINE__, __FUNCTION__), \ + bfd_bread ((BUF), (ELTSIZE) * (NITEMS), (ABFD))) +#define bfd_write(BUF, ELTSIZE, NITEMS, ABFD) \ + (warn_deprecated ("bfd_write", __FILE__, __LINE__, __FUNCTION__), \ + bfd_bwrite ((BUF), (ELTSIZE) * (NITEMS), (ABFD))) +#else +#define bfd_read(BUF, ELTSIZE, NITEMS, ABFD) \ + (warn_deprecated ("bfd_read", (const char *) 0, 0, (const char *) 0), \ + bfd_bread ((BUF), (ELTSIZE) * (NITEMS), (ABFD))) +#define bfd_write(BUF, ELTSIZE, NITEMS, ABFD) \ + (warn_deprecated ("bfd_write", (const char *) 0, 0, (const char *) 0),\ + bfd_bwrite ((BUF), (ELTSIZE) * (NITEMS), (ABFD))) +#endif +extern void warn_deprecated (const char *, const char *, int, const char *); + +/* Cast from const char * to char * so that caller can assign to + a char * without a warning. */ +#define bfd_get_filename(abfd) ((char *) (abfd)->filename) +#define bfd_get_cacheable(abfd) ((abfd)->cacheable) +#define bfd_get_format(abfd) ((abfd)->format) +#define bfd_get_target(abfd) ((abfd)->xvec->name) +#define bfd_get_flavour(abfd) ((abfd)->xvec->flavour) +#define bfd_family_coff(abfd) \ + (bfd_get_flavour (abfd) == bfd_target_coff_flavour || \ + bfd_get_flavour (abfd) == bfd_target_xcoff_flavour) +#define bfd_big_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG) +#define bfd_little_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_LITTLE) +#define bfd_header_big_endian(abfd) \ + ((abfd)->xvec->header_byteorder == BFD_ENDIAN_BIG) +#define bfd_header_little_endian(abfd) \ + ((abfd)->xvec->header_byteorder == BFD_ENDIAN_LITTLE) +#define bfd_get_file_flags(abfd) ((abfd)->flags) +#define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags) +#define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags) +#define bfd_my_archive(abfd) ((abfd)->my_archive) +#define bfd_has_map(abfd) ((abfd)->has_armap) + +#define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types) +#define bfd_usrdata(abfd) ((abfd)->usrdata) + +#define bfd_get_start_address(abfd) ((abfd)->start_address) +#define bfd_get_symcount(abfd) ((abfd)->symcount) +#define bfd_get_outsymbols(abfd) ((abfd)->outsymbols) +#define bfd_count_sections(abfd) ((abfd)->section_count) + +#define bfd_get_dynamic_symcount(abfd) ((abfd)->dynsymcount) + +#define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char) + +#define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = bool), TRUE) + +extern bfd_boolean bfd_cache_close + (bfd *abfd); +/* NB: This declaration should match the autogenerated one in libbfd.h. */ + +extern bfd_boolean bfd_cache_close_all (void); + +extern bfd_boolean bfd_record_phdr + (bfd *, unsigned long, bfd_boolean, flagword, bfd_boolean, bfd_vma, + bfd_boolean, bfd_boolean, unsigned int, struct bfd_section **); + +/* Byte swapping routines. */ + +bfd_uint64_t bfd_getb64 (const void *); +bfd_uint64_t bfd_getl64 (const void *); +bfd_int64_t bfd_getb_signed_64 (const void *); +bfd_int64_t bfd_getl_signed_64 (const void *); +bfd_vma bfd_getb32 (const void *); +bfd_vma bfd_getl32 (const void *); +bfd_signed_vma bfd_getb_signed_32 (const void *); +bfd_signed_vma bfd_getl_signed_32 (const void *); +bfd_vma bfd_getb16 (const void *); +bfd_vma bfd_getl16 (const void *); +bfd_signed_vma bfd_getb_signed_16 (const void *); +bfd_signed_vma bfd_getl_signed_16 (const void *); +void bfd_putb64 (bfd_uint64_t, void *); +void bfd_putl64 (bfd_uint64_t, void *); +void bfd_putb32 (bfd_vma, void *); +void bfd_putl32 (bfd_vma, void *); +void bfd_putb16 (bfd_vma, void *); +void bfd_putl16 (bfd_vma, void *); + +/* Byte swapping routines which take size and endiannes as arguments. */ + +bfd_uint64_t bfd_get_bits (const void *, int, bfd_boolean); +void bfd_put_bits (bfd_uint64_t, void *, int, bfd_boolean); + +extern bfd_boolean bfd_section_already_linked_table_init (void); +extern void bfd_section_already_linked_table_free (void); + +/* Externally visible ECOFF routines. */ + +#if defined(__STDC__) || defined(ALMOST_STDC) +struct ecoff_debug_info; +struct ecoff_debug_swap; +struct ecoff_extr; +struct bfd_symbol; +struct bfd_link_info; +struct bfd_link_hash_entry; +struct bfd_elf_version_tree; +#endif +extern bfd_vma bfd_ecoff_get_gp_value + (bfd * abfd); +extern bfd_boolean bfd_ecoff_set_gp_value + (bfd *abfd, bfd_vma gp_value); +extern bfd_boolean bfd_ecoff_set_regmasks + (bfd *abfd, unsigned long gprmask, unsigned long fprmask, + unsigned long *cprmask); +extern void *bfd_ecoff_debug_init + (bfd *output_bfd, struct ecoff_debug_info *output_debug, + const struct ecoff_debug_swap *output_swap, struct bfd_link_info *); +extern void bfd_ecoff_debug_free + (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug, + const struct ecoff_debug_swap *output_swap, struct bfd_link_info *); +extern bfd_boolean bfd_ecoff_debug_accumulate + (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug, + const struct ecoff_debug_swap *output_swap, bfd *input_bfd, + struct ecoff_debug_info *input_debug, + const struct ecoff_debug_swap *input_swap, struct bfd_link_info *); +extern bfd_boolean bfd_ecoff_debug_accumulate_other + (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug, + const struct ecoff_debug_swap *output_swap, bfd *input_bfd, + struct bfd_link_info *); +extern bfd_boolean bfd_ecoff_debug_externals + (bfd *abfd, struct ecoff_debug_info *debug, + const struct ecoff_debug_swap *swap, bfd_boolean relocatable, + bfd_boolean (*get_extr) (struct bfd_symbol *, struct ecoff_extr *), + void (*set_index) (struct bfd_symbol *, bfd_size_type)); +extern bfd_boolean bfd_ecoff_debug_one_external + (bfd *abfd, struct ecoff_debug_info *debug, + const struct ecoff_debug_swap *swap, const char *name, + struct ecoff_extr *esym); +extern bfd_size_type bfd_ecoff_debug_size + (bfd *abfd, struct ecoff_debug_info *debug, + const struct ecoff_debug_swap *swap); +extern bfd_boolean bfd_ecoff_write_debug + (bfd *abfd, struct ecoff_debug_info *debug, + const struct ecoff_debug_swap *swap, file_ptr where); +extern bfd_boolean bfd_ecoff_write_accumulated_debug + (void *handle, bfd *abfd, struct ecoff_debug_info *debug, + const struct ecoff_debug_swap *swap, + struct bfd_link_info *info, file_ptr where); + +/* Externally visible ELF routines. */ + +struct bfd_link_needed_list +{ + struct bfd_link_needed_list *next; + bfd *by; + const char *name; +}; + +enum dynamic_lib_link_class { + DYN_NORMAL = 0, + DYN_AS_NEEDED = 1, + DYN_DT_NEEDED = 2, + DYN_NO_ADD_NEEDED = 4, + DYN_NO_NEEDED = 8 +}; + +extern bfd_boolean bfd_elf_record_link_assignment + (struct bfd_link_info *, const char *, bfd_boolean); +extern struct bfd_link_needed_list *bfd_elf_get_needed_list + (bfd *, struct bfd_link_info *); +extern bfd_boolean bfd_elf_get_bfd_needed_list + (bfd *, struct bfd_link_needed_list **); +extern bfd_boolean bfd_elf_size_dynamic_sections + (bfd *, const char *, const char *, const char *, const char * const *, + struct bfd_link_info *, struct bfd_section **, + struct bfd_elf_version_tree *); +extern bfd_boolean bfd_elf_size_dynsym_hash_dynstr + (bfd *, struct bfd_link_info *); +extern void bfd_elf_set_dt_needed_name + (bfd *, const char *); +extern const char *bfd_elf_get_dt_soname + (bfd *); +extern void bfd_elf_set_dyn_lib_class + (bfd *, int); +extern int bfd_elf_get_dyn_lib_class + (bfd *); +extern struct bfd_link_needed_list *bfd_elf_get_runpath_list + (bfd *, struct bfd_link_info *); +extern bfd_boolean bfd_elf_discard_info + (bfd *, struct bfd_link_info *); +extern unsigned int _bfd_elf_default_action_discarded + (struct bfd_section *); + +/* Return an upper bound on the number of bytes required to store a + copy of ABFD's program header table entries. Return -1 if an error + occurs; bfd_get_error will return an appropriate code. */ +extern long bfd_get_elf_phdr_upper_bound + (bfd *abfd); + +/* Copy ABFD's program header table entries to *PHDRS. The entries + will be stored as an array of Elf_Internal_Phdr structures, as + defined in include/elf/internal.h. To find out how large the + buffer needs to be, call bfd_get_elf_phdr_upper_bound. + + Return the number of program header table entries read, or -1 if an + error occurs; bfd_get_error will return an appropriate code. */ +extern int bfd_get_elf_phdrs + (bfd *abfd, void *phdrs); + +/* Create a new BFD as if by bfd_openr. Rather than opening a file, + reconstruct an ELF file by reading the segments out of remote memory + based on the ELF file header at EHDR_VMA and the ELF program headers it + points to. If not null, *LOADBASEP is filled in with the difference + between the VMAs from which the segments were read, and the VMAs the + file headers (and hence BFD's idea of each section's VMA) put them at. + + The function TARGET_READ_MEMORY is called to copy LEN bytes from the + remote memory at target address VMA into the local buffer at MYADDR; it + should return zero on success or an `errno' code on failure. TEMPL must + be a BFD for an ELF target with the word size and byte order found in + the remote memory. */ +extern bfd *bfd_elf_bfd_from_remote_memory + (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep, + int (*target_read_memory) (bfd_vma vma, bfd_byte *myaddr, int len)); + +/* Return the arch_size field of an elf bfd, or -1 if not elf. */ +extern int bfd_get_arch_size + (bfd *); + +/* Return TRUE if address "naturally" sign extends, or -1 if not elf. */ +extern int bfd_get_sign_extend_vma + (bfd *); + +extern struct bfd_section *_bfd_elf_tls_setup + (bfd *, struct bfd_link_info *); + +extern void _bfd_elf_provide_symbol + (struct bfd_link_info *, const char *, bfd_vma, struct bfd_section *); + +extern void _bfd_elf_provide_section_bound_symbols + (struct bfd_link_info *, struct bfd_section *, const char *, const char *); + +extern void _bfd_elf_fix_excluded_sec_syms + (bfd *, struct bfd_link_info *); + +extern bfd_boolean bfd_m68k_elf32_create_embedded_relocs + (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *, + char **); + +/* SunOS shared library support routines for the linker. */ + +extern struct bfd_link_needed_list *bfd_sunos_get_needed_list + (bfd *, struct bfd_link_info *); +extern bfd_boolean bfd_sunos_record_link_assignment + (bfd *, struct bfd_link_info *, const char *); +extern bfd_boolean bfd_sunos_size_dynamic_sections + (bfd *, struct bfd_link_info *, struct bfd_section **, + struct bfd_section **, struct bfd_section **); + +/* Linux shared library support routines for the linker. */ + +extern bfd_boolean bfd_i386linux_size_dynamic_sections + (bfd *, struct bfd_link_info *); +extern bfd_boolean bfd_m68klinux_size_dynamic_sections + (bfd *, struct bfd_link_info *); +extern bfd_boolean bfd_sparclinux_size_dynamic_sections + (bfd *, struct bfd_link_info *); + +/* mmap hacks */ + +struct _bfd_window_internal; +typedef struct _bfd_window_internal bfd_window_internal; + +typedef struct _bfd_window +{ + /* What the user asked for. */ + void *data; + bfd_size_type size; + /* The actual window used by BFD. Small user-requested read-only + regions sharing a page may share a single window into the object + file. Read-write versions shouldn't until I've fixed things to + keep track of which portions have been claimed by the + application; don't want to give the same region back when the + application wants two writable copies! */ + struct _bfd_window_internal *i; +} +bfd_window; + +extern void bfd_init_window + (bfd_window *); +extern void bfd_free_window + (bfd_window *); +extern bfd_boolean bfd_get_file_window + (bfd *, file_ptr, bfd_size_type, bfd_window *, bfd_boolean); + +/* XCOFF support routines for the linker. */ + +extern bfd_boolean bfd_xcoff_link_record_set + (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, bfd_size_type); +extern bfd_boolean bfd_xcoff_import_symbol + (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, bfd_vma, + const char *, const char *, const char *, unsigned int); +extern bfd_boolean bfd_xcoff_export_symbol + (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *); +extern bfd_boolean bfd_xcoff_link_count_reloc + (bfd *, struct bfd_link_info *, const char *); +extern bfd_boolean bfd_xcoff_record_link_assignment + (bfd *, struct bfd_link_info *, const char *); +extern bfd_boolean bfd_xcoff_size_dynamic_sections + (bfd *, struct bfd_link_info *, const char *, const char *, + unsigned long, unsigned long, unsigned long, bfd_boolean, + int, bfd_boolean, bfd_boolean, struct bfd_section **, bfd_boolean); +extern bfd_boolean bfd_xcoff_link_generate_rtinit + (bfd *, const char *, const char *, bfd_boolean); + +/* XCOFF support routines for ar. */ +extern bfd_boolean bfd_xcoff_ar_archive_set_magic + (bfd *, char *); + +/* Externally visible COFF routines. */ + +#if defined(__STDC__) || defined(ALMOST_STDC) +struct internal_syment; +union internal_auxent; +#endif + +extern bfd_boolean bfd_coff_get_syment + (bfd *, struct bfd_symbol *, struct internal_syment *); + +extern bfd_boolean bfd_coff_get_auxent + (bfd *, struct bfd_symbol *, int, union internal_auxent *); + +extern bfd_boolean bfd_coff_set_symbol_class + (bfd *, struct bfd_symbol *, unsigned int); + +extern bfd_boolean bfd_m68k_coff_create_embedded_relocs + (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *, char **); + +/* ARM Interworking support. Called from linker. */ +extern bfd_boolean bfd_arm_allocate_interworking_sections + (struct bfd_link_info *); + +extern bfd_boolean bfd_arm_process_before_allocation + (bfd *, struct bfd_link_info *, int); + +extern bfd_boolean bfd_arm_get_bfd_for_interworking + (bfd *, struct bfd_link_info *); + +/* PE ARM Interworking support. Called from linker. */ +extern bfd_boolean bfd_arm_pe_allocate_interworking_sections + (struct bfd_link_info *); + +extern bfd_boolean bfd_arm_pe_process_before_allocation + (bfd *, struct bfd_link_info *, int); + +extern bfd_boolean bfd_arm_pe_get_bfd_for_interworking + (bfd *, struct bfd_link_info *); + +/* ELF ARM Interworking support. Called from linker. */ +extern bfd_boolean bfd_elf32_arm_allocate_interworking_sections + (struct bfd_link_info *); + +extern bfd_boolean bfd_elf32_arm_process_before_allocation + (bfd *, struct bfd_link_info *, int); + +void bfd_elf32_arm_set_target_relocs + (struct bfd_link_info *, int, char *, int, int); + +extern bfd_boolean bfd_elf32_arm_get_bfd_for_interworking + (bfd *, struct bfd_link_info *); + +extern bfd_boolean bfd_elf32_arm_add_glue_sections_to_bfd + (bfd *, struct bfd_link_info *); + +/* ELF ARM mapping symbol support */ +extern bfd_boolean bfd_is_arm_mapping_symbol_name + (const char * name); + +/* ARM Note section processing. */ +extern bfd_boolean bfd_arm_merge_machines + (bfd *, bfd *); + +extern bfd_boolean bfd_arm_update_notes + (bfd *, const char *); + +extern unsigned int bfd_arm_get_mach_from_notes + (bfd *, const char *); + +/* TI COFF load page support. */ +extern void bfd_ticoff_set_section_load_page + (struct bfd_section *, int); + +extern int bfd_ticoff_get_section_load_page + (struct bfd_section *); + +/* H8/300 functions. */ +extern bfd_vma bfd_h8300_pad_address + (bfd *, bfd_vma); + +/* IA64 Itanium code generation. Called from linker. */ +extern void bfd_elf32_ia64_after_parse + (int); + +extern void bfd_elf64_ia64_after_parse + (int); + +/* This structure is used for a comdat section, as in PE. A comdat + section is associated with a particular symbol. When the linker + sees a comdat section, it keeps only one of the sections with a + given name and associated with a given symbol. */ + +struct coff_comdat_info +{ + /* The name of the symbol associated with a comdat section. */ + const char *name; + + /* The local symbol table index of the symbol associated with a + comdat section. This is only meaningful to the object file format + specific code; it is not an index into the list returned by + bfd_canonicalize_symtab. */ + long symbol; +}; + +extern struct coff_comdat_info *bfd_coff_get_comdat_section + (bfd *, struct bfd_section *); + +/* Extracted from init.c. */ +void bfd_init (void); + +/* Extracted from opncls.c. */ +bfd *bfd_fopen (const char *filename, const char *target, + const char *mode, int fd); + +bfd *bfd_openr (const char *filename, const char *target); + +bfd *bfd_fdopenr (const char *filename, const char *target, int fd); + +bfd *bfd_openstreamr (const char *, const char *, void *); + +bfd *bfd_openr_iovec (const char *filename, const char *target, + void *(*open) (struct bfd *nbfd, + void *open_closure), + void *open_closure, + file_ptr (*pread) (struct bfd *nbfd, + void *stream, + void *buf, + file_ptr nbytes, + file_ptr offset), + int (*close) (struct bfd *nbfd, + void *stream)); + +bfd *bfd_openw (const char *filename, const char *target); + +bfd_boolean bfd_close (bfd *abfd); + +bfd_boolean bfd_close_all_done (bfd *); + +bfd *bfd_create (const char *filename, bfd *templ); + +bfd_boolean bfd_make_writable (bfd *abfd); + +bfd_boolean bfd_make_readable (bfd *abfd); + +unsigned long bfd_calc_gnu_debuglink_crc32 + (unsigned long crc, const unsigned char *buf, bfd_size_type len); + +char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir); + +struct bfd_section *bfd_create_gnu_debuglink_section + (bfd *abfd, const char *filename); + +bfd_boolean bfd_fill_in_gnu_debuglink_section + (bfd *abfd, struct bfd_section *sect, const char *filename); + +/* Extracted from libbfd.c. */ + +/* Byte swapping macros for user section data. */ + +#define bfd_put_8(abfd, val, ptr) \ + ((void) (*((unsigned char *) (ptr)) = (val) & 0xff)) +#define bfd_put_signed_8 \ + bfd_put_8 +#define bfd_get_8(abfd, ptr) \ + (*(unsigned char *) (ptr) & 0xff) +#define bfd_get_signed_8(abfd, ptr) \ + (((*(unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80) + +#define bfd_put_16(abfd, val, ptr) \ + BFD_SEND (abfd, bfd_putx16, ((val),(ptr))) +#define bfd_put_signed_16 \ + bfd_put_16 +#define bfd_get_16(abfd, ptr) \ + BFD_SEND (abfd, bfd_getx16, (ptr)) +#define bfd_get_signed_16(abfd, ptr) \ + BFD_SEND (abfd, bfd_getx_signed_16, (ptr)) + +#define bfd_put_32(abfd, val, ptr) \ + BFD_SEND (abfd, bfd_putx32, ((val),(ptr))) +#define bfd_put_signed_32 \ + bfd_put_32 +#define bfd_get_32(abfd, ptr) \ + BFD_SEND (abfd, bfd_getx32, (ptr)) +#define bfd_get_signed_32(abfd, ptr) \ + BFD_SEND (abfd, bfd_getx_signed_32, (ptr)) + +#define bfd_put_64(abfd, val, ptr) \ + BFD_SEND (abfd, bfd_putx64, ((val), (ptr))) +#define bfd_put_signed_64 \ + bfd_put_64 +#define bfd_get_64(abfd, ptr) \ + BFD_SEND (abfd, bfd_getx64, (ptr)) +#define bfd_get_signed_64(abfd, ptr) \ + BFD_SEND (abfd, bfd_getx_signed_64, (ptr)) + +#define bfd_get(bits, abfd, ptr) \ + ((bits) == 8 ? (bfd_vma) bfd_get_8 (abfd, ptr) \ + : (bits) == 16 ? bfd_get_16 (abfd, ptr) \ + : (bits) == 32 ? bfd_get_32 (abfd, ptr) \ + : (bits) == 64 ? bfd_get_64 (abfd, ptr) \ + : (abort (), (bfd_vma) - 1)) + +#define bfd_put(bits, abfd, val, ptr) \ + ((bits) == 8 ? bfd_put_8 (abfd, val, ptr) \ + : (bits) == 16 ? bfd_put_16 (abfd, val, ptr) \ + : (bits) == 32 ? bfd_put_32 (abfd, val, ptr) \ + : (bits) == 64 ? bfd_put_64 (abfd, val, ptr) \ + : (abort (), (void) 0)) + + +/* Byte swapping macros for file header data. */ + +#define bfd_h_put_8(abfd, val, ptr) \ + bfd_put_8 (abfd, val, ptr) +#define bfd_h_put_signed_8(abfd, val, ptr) \ + bfd_put_8 (abfd, val, ptr) +#define bfd_h_get_8(abfd, ptr) \ + bfd_get_8 (abfd, ptr) +#define bfd_h_get_signed_8(abfd, ptr) \ + bfd_get_signed_8 (abfd, ptr) + +#define bfd_h_put_16(abfd, val, ptr) \ + BFD_SEND (abfd, bfd_h_putx16, (val, ptr)) +#define bfd_h_put_signed_16 \ + bfd_h_put_16 +#define bfd_h_get_16(abfd, ptr) \ + BFD_SEND (abfd, bfd_h_getx16, (ptr)) +#define bfd_h_get_signed_16(abfd, ptr) \ + BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr)) + +#define bfd_h_put_32(abfd, val, ptr) \ + BFD_SEND (abfd, bfd_h_putx32, (val, ptr)) +#define bfd_h_put_signed_32 \ + bfd_h_put_32 +#define bfd_h_get_32(abfd, ptr) \ + BFD_SEND (abfd, bfd_h_getx32, (ptr)) +#define bfd_h_get_signed_32(abfd, ptr) \ + BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr)) + +#define bfd_h_put_64(abfd, val, ptr) \ + BFD_SEND (abfd, bfd_h_putx64, (val, ptr)) +#define bfd_h_put_signed_64 \ + bfd_h_put_64 +#define bfd_h_get_64(abfd, ptr) \ + BFD_SEND (abfd, bfd_h_getx64, (ptr)) +#define bfd_h_get_signed_64(abfd, ptr) \ + BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr)) + +/* Aliases for the above, which should eventually go away. */ + +#define H_PUT_64 bfd_h_put_64 +#define H_PUT_32 bfd_h_put_32 +#define H_PUT_16 bfd_h_put_16 +#define H_PUT_8 bfd_h_put_8 +#define H_PUT_S64 bfd_h_put_signed_64 +#define H_PUT_S32 bfd_h_put_signed_32 +#define H_PUT_S16 bfd_h_put_signed_16 +#define H_PUT_S8 bfd_h_put_signed_8 +#define H_GET_64 bfd_h_get_64 +#define H_GET_32 bfd_h_get_32 +#define H_GET_16 bfd_h_get_16 +#define H_GET_8 bfd_h_get_8 +#define H_GET_S64 bfd_h_get_signed_64 +#define H_GET_S32 bfd_h_get_signed_32 +#define H_GET_S16 bfd_h_get_signed_16 +#define H_GET_S8 bfd_h_get_signed_8 + + +/* Extracted from bfdio.c. */ +long bfd_get_mtime (bfd *abfd); + +long bfd_get_size (bfd *abfd); + +/* Extracted from bfdwin.c. */ +/* Extracted from section.c. */ +typedef struct bfd_section +{ + /* The name of the section; the name isn't a copy, the pointer is + the same as that passed to bfd_make_section. */ + const char *name; + + /* A unique sequence number. */ + int id; + + /* Which section in the bfd; 0..n-1 as sections are created in a bfd. */ + int index; + + /* The next section in the list belonging to the BFD, or NULL. */ + struct bfd_section *next; + + /* The previous section in the list belonging to the BFD, or NULL. */ + struct bfd_section *prev; + + /* The field flags contains attributes of the section. Some + flags are read in from the object file, and some are + synthesized from other information. */ + flagword flags; + +#define SEC_NO_FLAGS 0x000 + + /* Tells the OS to allocate space for this section when loading. + This is clear for a section containing debug information only. */ +#define SEC_ALLOC 0x001 + + /* Tells the OS to load the section from the file when loading. + This is clear for a .bss section. */ +#define SEC_LOAD 0x002 + + /* The section contains data still to be relocated, so there is + some relocation information too. */ +#define SEC_RELOC 0x004 + + /* A signal to the OS that the section contains read only data. */ +#define SEC_READONLY 0x008 + + /* The section contains code only. */ +#define SEC_CODE 0x010 + + /* The section contains data only. */ +#define SEC_DATA 0x020 + + /* The section will reside in ROM. */ +#define SEC_ROM 0x040 + + /* The section contains constructor information. This section + type is used by the linker to create lists of constructors and + destructors used by <>. When a back end sees a symbol + which should be used in a constructor list, it creates a new + section for the type of name (e.g., <<__CTOR_LIST__>>), attaches + the symbol to it, and builds a relocation. To build the lists + of constructors, all the linker has to do is catenate all the + sections called <<__CTOR_LIST__>> and relocate the data + contained within - exactly the operations it would peform on + standard data. */ +#define SEC_CONSTRUCTOR 0x080 + + /* The section has contents - a data section could be + <> | <>; a debug section could be + <> */ +#define SEC_HAS_CONTENTS 0x100 + + /* An instruction to the linker to not output the section + even if it has information which would normally be written. */ +#define SEC_NEVER_LOAD 0x200 + + /* The section contains thread local data. */ +#define SEC_THREAD_LOCAL 0x400 + + /* The section has GOT references. This flag is only for the + linker, and is currently only used by the elf32-hppa back end. + It will be set if global offset table references were detected + in this section, which indicate to the linker that the section + contains PIC code, and must be handled specially when doing a + static link. */ +#define SEC_HAS_GOT_REF 0x800 + + /* The section contains common symbols (symbols may be defined + multiple times, the value of a symbol is the amount of + space it requires, and the largest symbol value is the one + used). Most targets have exactly one of these (which we + translate to bfd_com_section_ptr), but ECOFF has two. */ +#define SEC_IS_COMMON 0x1000 + + /* The section contains only debugging information. For + example, this is set for ELF .debug and .stab sections. + strip tests this flag to see if a section can be + discarded. */ +#define SEC_DEBUGGING 0x2000 + + /* The contents of this section are held in memory pointed to + by the contents field. This is checked by bfd_get_section_contents, + and the data is retrieved from memory if appropriate. */ +#define SEC_IN_MEMORY 0x4000 + + /* The contents of this section are to be excluded by the + linker for executable and shared objects unless those + objects are to be further relocated. */ +#define SEC_EXCLUDE 0x8000 + + /* The contents of this section are to be sorted based on the sum of + the symbol and addend values specified by the associated relocation + entries. Entries without associated relocation entries will be + appended to the end of the section in an unspecified order. */ +#define SEC_SORT_ENTRIES 0x10000 + + /* When linking, duplicate sections of the same name should be + discarded, rather than being combined into a single section as + is usually done. This is similar to how common symbols are + handled. See SEC_LINK_DUPLICATES below. */ +#define SEC_LINK_ONCE 0x20000 + + /* If SEC_LINK_ONCE is set, this bitfield describes how the linker + should handle duplicate sections. */ +#define SEC_LINK_DUPLICATES 0x40000 + + /* This value for SEC_LINK_DUPLICATES means that duplicate + sections with the same name should simply be discarded. */ +#define SEC_LINK_DUPLICATES_DISCARD 0x0 + + /* This value for SEC_LINK_DUPLICATES means that the linker + should warn if there are any duplicate sections, although + it should still only link one copy. */ +#define SEC_LINK_DUPLICATES_ONE_ONLY 0x80000 + + /* This value for SEC_LINK_DUPLICATES means that the linker + should warn if any duplicate sections are a different size. */ +#define SEC_LINK_DUPLICATES_SAME_SIZE 0x100000 + + /* This value for SEC_LINK_DUPLICATES means that the linker + should warn if any duplicate sections contain different + contents. */ +#define SEC_LINK_DUPLICATES_SAME_CONTENTS \ + (SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE) + + /* This section was created by the linker as part of dynamic + relocation or other arcane processing. It is skipped when + going through the first-pass output, trusting that someone + else up the line will take care of it later. */ +#define SEC_LINKER_CREATED 0x200000 + + /* This section should not be subject to garbage collection. */ +#define SEC_KEEP 0x400000 + + /* This section contains "short" data, and should be placed + "near" the GP. */ +#define SEC_SMALL_DATA 0x800000 + + /* Attempt to merge identical entities in the section. + Entity size is given in the entsize field. */ +#define SEC_MERGE 0x1000000 + + /* If given with SEC_MERGE, entities to merge are zero terminated + strings where entsize specifies character size instead of fixed + size entries. */ +#define SEC_STRINGS 0x2000000 + + /* This section contains data about section groups. */ +#define SEC_GROUP 0x4000000 + + /* The section is a COFF shared library section. This flag is + only for the linker. If this type of section appears in + the input file, the linker must copy it to the output file + without changing the vma or size. FIXME: Although this + was originally intended to be general, it really is COFF + specific (and the flag was renamed to indicate this). It + might be cleaner to have some more general mechanism to + allow the back end to control what the linker does with + sections. */ +#define SEC_COFF_SHARED_LIBRARY 0x10000000 + + /* This section contains data which may be shared with other + executables or shared objects. This is for COFF only. */ +#define SEC_COFF_SHARED 0x20000000 + + /* When a section with this flag is being linked, then if the size of + the input section is less than a page, it should not cross a page + boundary. If the size of the input section is one page or more, + it should be aligned on a page boundary. This is for TI + TMS320C54X only. */ +#define SEC_TIC54X_BLOCK 0x40000000 + + /* Conditionally link this section; do not link if there are no + references found to any symbol in the section. This is for TI + TMS320C54X only. */ +#define SEC_TIC54X_CLINK 0x80000000 + + /* End of section flags. */ + + /* Some internal packed boolean fields. */ + + /* See the vma field. */ + unsigned int user_set_vma : 1; + + /* A mark flag used by some of the linker backends. */ + unsigned int linker_mark : 1; + + /* Another mark flag used by some of the linker backends. Set for + output sections that have an input section. */ + unsigned int linker_has_input : 1; + + /* Mark flags used by some linker backends for garbage collection. */ + unsigned int gc_mark : 1; + unsigned int gc_mark_from_eh : 1; + + /* The following flags are used by the ELF linker. */ + + /* Mark sections which have been allocated to segments. */ + unsigned int segment_mark : 1; + + /* Type of sec_info information. */ + unsigned int sec_info_type:3; +#define ELF_INFO_TYPE_NONE 0 +#define ELF_INFO_TYPE_STABS 1 +#define ELF_INFO_TYPE_MERGE 2 +#define ELF_INFO_TYPE_EH_FRAME 3 +#define ELF_INFO_TYPE_JUST_SYMS 4 + + /* Nonzero if this section uses RELA relocations, rather than REL. */ + unsigned int use_rela_p:1; + + /* Bits used by various backends. The generic code doesn't touch + these fields. */ + + /* Nonzero if this section has TLS related relocations. */ + unsigned int has_tls_reloc:1; + + /* Nonzero if this section has a gp reloc. */ + unsigned int has_gp_reloc:1; + + /* Nonzero if this section needs the relax finalize pass. */ + unsigned int need_finalize_relax:1; + + /* Whether relocations have been processed. */ + unsigned int reloc_done : 1; + + /* End of internal packed boolean fields. */ + + /* The virtual memory address of the section - where it will be + at run time. The symbols are relocated against this. The + user_set_vma flag is maintained by bfd; if it's not set, the + backend can assign addresses (for example, in <>, where + the default address for <<.data>> is dependent on the specific + target and various flags). */ + bfd_vma vma; + + /* The load address of the section - where it would be in a + rom image; really only used for writing section header + information. */ + bfd_vma lma; + + /* The size of the section in octets, as it will be output. + Contains a value even if the section has no contents (e.g., the + size of <<.bss>>). */ + bfd_size_type size; + + /* For input sections, the original size on disk of the section, in + octets. This field is used by the linker relaxation code. It is + currently only set for sections where the linker relaxation scheme + doesn't cache altered section and reloc contents (stabs, eh_frame, + SEC_MERGE, some coff relaxing targets), and thus the original size + needs to be kept to read the section multiple times. + For output sections, rawsize holds the section size calculated on + a previous linker relaxation pass. */ + bfd_size_type rawsize; + + /* If this section is going to be output, then this value is the + offset in *bytes* into the output section of the first byte in the + input section (byte ==> smallest addressable unit on the + target). In most cases, if this was going to start at the + 100th octet (8-bit quantity) in the output section, this value + would be 100. However, if the target byte size is 16 bits + (bfd_octets_per_byte is "2"), this value would be 50. */ + bfd_vma output_offset; + + /* The output section through which to map on output. */ + struct bfd_section *output_section; + + /* The alignment requirement of the section, as an exponent of 2 - + e.g., 3 aligns to 2^3 (or 8). */ + unsigned int alignment_power; + + /* If an input section, a pointer to a vector of relocation + records for the data in this section. */ + struct reloc_cache_entry *relocation; + + /* If an output section, a pointer to a vector of pointers to + relocation records for the data in this section. */ + struct reloc_cache_entry **orelocation; + + /* The number of relocation records in one of the above. */ + unsigned reloc_count; + + /* Information below is back end specific - and not always used + or updated. */ + + /* File position of section data. */ + file_ptr filepos; + + /* File position of relocation info. */ + file_ptr rel_filepos; + + /* File position of line data. */ + file_ptr line_filepos; + + /* Pointer to data for applications. */ + void *userdata; + + /* If the SEC_IN_MEMORY flag is set, this points to the actual + contents. */ + unsigned char *contents; + + /* Attached line number information. */ + alent *lineno; + + /* Number of line number records. */ + unsigned int lineno_count; + + /* Entity size for merging purposes. */ + unsigned int entsize; + + /* Points to the kept section if this section is a link-once section, + and is discarded. */ + struct bfd_section *kept_section; + + /* When a section is being output, this value changes as more + linenumbers are written out. */ + file_ptr moving_line_filepos; + + /* What the section number is in the target world. */ + int target_index; + + void *used_by_bfd; + + /* If this is a constructor section then here is a list of the + relocations created to relocate items within it. */ + struct relent_chain *constructor_chain; + + /* The BFD which owns the section. */ + bfd *owner; + + /* A symbol which points at this section only. */ + struct bfd_symbol *symbol; + struct bfd_symbol **symbol_ptr_ptr; + + /* Early in the link process, map_head and map_tail are used to build + a list of input sections attached to an output section. Later, + output sections use these fields for a list of bfd_link_order + structs. */ + union { + struct bfd_link_order *link_order; + struct bfd_section *s; + } map_head, map_tail; +} asection; + +/* These sections are global, and are managed by BFD. The application + and target back end are not permitted to change the values in + these sections. New code should use the section_ptr macros rather + than referring directly to the const sections. The const sections + may eventually vanish. */ +#define BFD_ABS_SECTION_NAME "*ABS*" +#define BFD_UND_SECTION_NAME "*UND*" +#define BFD_COM_SECTION_NAME "*COM*" +#define BFD_IND_SECTION_NAME "*IND*" + +/* The absolute section. */ +extern asection bfd_abs_section; +#define bfd_abs_section_ptr ((asection *) &bfd_abs_section) +#define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr) +/* Pointer to the undefined section. */ +extern asection bfd_und_section; +#define bfd_und_section_ptr ((asection *) &bfd_und_section) +#define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr) +/* Pointer to the common section. */ +extern asection bfd_com_section; +#define bfd_com_section_ptr ((asection *) &bfd_com_section) +/* Pointer to the indirect section. */ +extern asection bfd_ind_section; +#define bfd_ind_section_ptr ((asection *) &bfd_ind_section) +#define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr) + +#define bfd_is_const_section(SEC) \ + ( ((SEC) == bfd_abs_section_ptr) \ + || ((SEC) == bfd_und_section_ptr) \ + || ((SEC) == bfd_com_section_ptr) \ + || ((SEC) == bfd_ind_section_ptr)) + +extern const struct bfd_symbol * const bfd_abs_symbol; +extern const struct bfd_symbol * const bfd_com_symbol; +extern const struct bfd_symbol * const bfd_und_symbol; +extern const struct bfd_symbol * const bfd_ind_symbol; + +/* Macros to handle insertion and deletion of a bfd's sections. These + only handle the list pointers, ie. do not adjust section_count, + target_index etc. */ +#define bfd_section_list_remove(ABFD, S) \ + do \ + { \ + asection *_s = S; \ + asection *_next = _s->next; \ + asection *_prev = _s->prev; \ + if (_prev) \ + _prev->next = _next; \ + else \ + (ABFD)->sections = _next; \ + if (_next) \ + _next->prev = _prev; \ + else \ + (ABFD)->section_last = _prev; \ + } \ + while (0) +#define bfd_section_list_append(ABFD, S) \ + do \ + { \ + asection *_s = S; \ + bfd *_abfd = ABFD; \ + _s->next = NULL; \ + if (_abfd->section_last) \ + { \ + _s->prev = _abfd->section_last; \ + _abfd->section_last->next = _s; \ + } \ + else \ + { \ + _s->prev = NULL; \ + _abfd->sections = _s; \ + } \ + _abfd->section_last = _s; \ + } \ + while (0) +#define bfd_section_list_prepend(ABFD, S) \ + do \ + { \ + asection *_s = S; \ + bfd *_abfd = ABFD; \ + _s->prev = NULL; \ + if (_abfd->sections) \ + { \ + _s->next = _abfd->sections; \ + _abfd->sections->prev = _s; \ + } \ + else \ + { \ + _s->next = NULL; \ + _abfd->section_last = _s; \ + } \ + _abfd->sections = _s; \ + } \ + while (0) +#define bfd_section_list_insert_after(ABFD, A, S) \ + do \ + { \ + asection *_a = A; \ + asection *_s = S; \ + asection *_next = _a->next; \ + _s->next = _next; \ + _s->prev = _a; \ + _a->next = _s; \ + if (_next) \ + _next->prev = _s; \ + else \ + (ABFD)->section_last = _s; \ + } \ + while (0) +#define bfd_section_list_insert_before(ABFD, B, S) \ + do \ + { \ + asection *_b = B; \ + asection *_s = S; \ + asection *_prev = _b->prev; \ + _s->prev = _prev; \ + _s->next = _b; \ + _b->prev = _s; \ + if (_prev) \ + _prev->next = _s; \ + else \ + (ABFD)->sections = _s; \ + } \ + while (0) +#define bfd_section_removed_from_list(ABFD, S) \ + ((S)->next == NULL ? (ABFD)->section_last != (S) : (S)->next->prev != (S)) + +void bfd_section_list_clear (bfd *); + +asection *bfd_get_section_by_name (bfd *abfd, const char *name); + +asection *bfd_get_section_by_name_if + (bfd *abfd, + const char *name, + bfd_boolean (*func) (bfd *abfd, asection *sect, void *obj), + void *obj); + +char *bfd_get_unique_section_name + (bfd *abfd, const char *templat, int *count); + +asection *bfd_make_section_old_way (bfd *abfd, const char *name); + +asection *bfd_make_section_anyway_with_flags + (bfd *abfd, const char *name, flagword flags); + +asection *bfd_make_section_anyway (bfd *abfd, const char *name); + +asection *bfd_make_section_with_flags + (bfd *, const char *name, flagword flags); + +asection *bfd_make_section (bfd *, const char *name); + +bfd_boolean bfd_set_section_flags + (bfd *abfd, asection *sec, flagword flags); + +void bfd_map_over_sections + (bfd *abfd, + void (*func) (bfd *abfd, asection *sect, void *obj), + void *obj); + +asection *bfd_sections_find_if + (bfd *abfd, + bfd_boolean (*operation) (bfd *abfd, asection *sect, void *obj), + void *obj); + +bfd_boolean bfd_set_section_size + (bfd *abfd, asection *sec, bfd_size_type val); + +bfd_boolean bfd_set_section_contents + (bfd *abfd, asection *section, const void *data, + file_ptr offset, bfd_size_type count); + +bfd_boolean bfd_get_section_contents + (bfd *abfd, asection *section, void *location, file_ptr offset, + bfd_size_type count); + +bfd_boolean bfd_malloc_and_get_section + (bfd *abfd, asection *section, bfd_byte **buf); + +bfd_boolean bfd_copy_private_section_data + (bfd *ibfd, asection *isec, bfd *obfd, asection *osec); + +#define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \ + BFD_SEND (obfd, _bfd_copy_private_section_data, \ + (ibfd, isection, obfd, osection)) +bfd_boolean bfd_generic_is_group_section (bfd *, const asection *sec); + +bfd_boolean bfd_generic_discard_group (bfd *abfd, asection *group); + +/* Extracted from archures.c. */ +enum bfd_architecture +{ + bfd_arch_unknown, /* File arch not known. */ + bfd_arch_obscure, /* Arch known, not one of these. */ + bfd_arch_m68k, /* Motorola 68xxx */ +#define bfd_mach_m68000 1 +#define bfd_mach_m68008 2 +#define bfd_mach_m68010 3 +#define bfd_mach_m68020 4 +#define bfd_mach_m68030 5 +#define bfd_mach_m68040 6 +#define bfd_mach_m68060 7 +#define bfd_mach_cpu32 8 +#define bfd_mach_mcf5200 9 +#define bfd_mach_mcf5206e 10 +#define bfd_mach_mcf5307 11 +#define bfd_mach_mcf5407 12 +#define bfd_mach_mcf528x 13 +#define bfd_mach_mcfv4e 14 +#define bfd_mach_mcf521x 15 +#define bfd_mach_mcf5249 16 +#define bfd_mach_mcf547x 17 +#define bfd_mach_mcf548x 18 + bfd_arch_vax, /* DEC Vax */ + bfd_arch_i960, /* Intel 960 */ + /* The order of the following is important. + lower number indicates a machine type that + only accepts a subset of the instructions + available to machines with higher numbers. + The exception is the "ca", which is + incompatible with all other machines except + "core". */ + +#define bfd_mach_i960_core 1 +#define bfd_mach_i960_ka_sa 2 +#define bfd_mach_i960_kb_sb 3 +#define bfd_mach_i960_mc 4 +#define bfd_mach_i960_xa 5 +#define bfd_mach_i960_ca 6 +#define bfd_mach_i960_jx 7 +#define bfd_mach_i960_hx 8 + + bfd_arch_or32, /* OpenRISC 32 */ + + bfd_arch_a29k, /* AMD 29000 */ + bfd_arch_sparc, /* SPARC */ +#define bfd_mach_sparc 1 +/* The difference between v8plus and v9 is that v9 is a true 64 bit env. */ +#define bfd_mach_sparc_sparclet 2 +#define bfd_mach_sparc_sparclite 3 +#define bfd_mach_sparc_v8plus 4 +#define bfd_mach_sparc_v8plusa 5 /* with ultrasparc add'ns. */ +#define bfd_mach_sparc_sparclite_le 6 +#define bfd_mach_sparc_v9 7 +#define bfd_mach_sparc_v9a 8 /* with ultrasparc add'ns. */ +#define bfd_mach_sparc_v8plusb 9 /* with cheetah add'ns. */ +#define bfd_mach_sparc_v9b 10 /* with cheetah add'ns. */ +/* Nonzero if MACH has the v9 instruction set. */ +#define bfd_mach_sparc_v9_p(mach) \ + ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9b \ + && (mach) != bfd_mach_sparc_sparclite_le) +/* Nonzero if MACH is a 64 bit sparc architecture. */ +#define bfd_mach_sparc_64bit_p(mach) \ + ((mach) >= bfd_mach_sparc_v9 && (mach) != bfd_mach_sparc_v8plusb) + bfd_arch_mips, /* MIPS Rxxxx */ +#define bfd_mach_mips3000 3000 +#define bfd_mach_mips3900 3900 +#define bfd_mach_mips4000 4000 +#define bfd_mach_mips4010 4010 +#define bfd_mach_mips4100 4100 +#define bfd_mach_mips4111 4111 +#define bfd_mach_mips4120 4120 +#define bfd_mach_mips4300 4300 +#define bfd_mach_mips4400 4400 +#define bfd_mach_mips4600 4600 +#define bfd_mach_mips4650 4650 +#define bfd_mach_mips5000 5000 +#define bfd_mach_mips5400 5400 +#define bfd_mach_mips5500 5500 +#define bfd_mach_mips6000 6000 +#define bfd_mach_mips7000 7000 +#define bfd_mach_mips8000 8000 +#define bfd_mach_mips9000 9000 +#define bfd_mach_mips10000 10000 +#define bfd_mach_mips12000 12000 +#define bfd_mach_mips16 16 +#define bfd_mach_mips5 5 +#define bfd_mach_mips_sb1 12310201 /* octal 'SB', 01 */ +#define bfd_mach_mipsisa32 32 +#define bfd_mach_mipsisa32r2 33 +#define bfd_mach_mipsisa64 64 +#define bfd_mach_mipsisa64r2 65 + bfd_arch_i386, /* Intel 386 */ +#define bfd_mach_i386_i386 1 +#define bfd_mach_i386_i8086 2 +#define bfd_mach_i386_i386_intel_syntax 3 +#define bfd_mach_x86_64 64 +#define bfd_mach_x86_64_intel_syntax 65 + bfd_arch_we32k, /* AT&T WE32xxx */ + bfd_arch_tahoe, /* CCI/Harris Tahoe */ + bfd_arch_i860, /* Intel 860 */ + bfd_arch_i370, /* IBM 360/370 Mainframes */ + bfd_arch_romp, /* IBM ROMP PC/RT */ + bfd_arch_alliant, /* Alliant */ + bfd_arch_convex, /* Convex */ + bfd_arch_m88k, /* Motorola 88xxx */ + bfd_arch_m98k, /* Motorola 98xxx */ + bfd_arch_pyramid, /* Pyramid Technology */ + bfd_arch_h8300, /* Renesas H8/300 (formerly Hitachi H8/300) */ +#define bfd_mach_h8300 1 +#define bfd_mach_h8300h 2 +#define bfd_mach_h8300s 3 +#define bfd_mach_h8300hn 4 +#define bfd_mach_h8300sn 5 +#define bfd_mach_h8300sx 6 +#define bfd_mach_h8300sxn 7 + bfd_arch_pdp11, /* DEC PDP-11 */ + bfd_arch_powerpc, /* PowerPC */ +#define bfd_mach_ppc 32 +#define bfd_mach_ppc64 64 +#define bfd_mach_ppc_403 403 +#define bfd_mach_ppc_403gc 4030 +#define bfd_mach_ppc_505 505 +#define bfd_mach_ppc_601 601 +#define bfd_mach_ppc_602 602 +#define bfd_mach_ppc_603 603 +#define bfd_mach_ppc_ec603e 6031 +#define bfd_mach_ppc_604 604 +#define bfd_mach_ppc_620 620 +#define bfd_mach_ppc_630 630 +#define bfd_mach_ppc_750 750 +#define bfd_mach_ppc_860 860 +#define bfd_mach_ppc_a35 35 +#define bfd_mach_ppc_rs64ii 642 +#define bfd_mach_ppc_rs64iii 643 +#define bfd_mach_ppc_7400 7400 +#define bfd_mach_ppc_e500 500 + bfd_arch_rs6000, /* IBM RS/6000 */ +#define bfd_mach_rs6k 6000 +#define bfd_mach_rs6k_rs1 6001 +#define bfd_mach_rs6k_rsc 6003 +#define bfd_mach_rs6k_rs2 6002 + bfd_arch_hppa, /* HP PA RISC */ +#define bfd_mach_hppa10 10 +#define bfd_mach_hppa11 11 +#define bfd_mach_hppa20 20 +#define bfd_mach_hppa20w 25 + bfd_arch_d10v, /* Mitsubishi D10V */ +#define bfd_mach_d10v 1 +#define bfd_mach_d10v_ts2 2 +#define bfd_mach_d10v_ts3 3 + bfd_arch_d30v, /* Mitsubishi D30V */ + bfd_arch_dlx, /* DLX */ + bfd_arch_m68hc11, /* Motorola 68HC11 */ + bfd_arch_m68hc12, /* Motorola 68HC12 */ +#define bfd_mach_m6812_default 0 +#define bfd_mach_m6812 1 +#define bfd_mach_m6812s 2 + bfd_arch_z8k, /* Zilog Z8000 */ +#define bfd_mach_z8001 1 +#define bfd_mach_z8002 2 + bfd_arch_h8500, /* Renesas H8/500 (formerly Hitachi H8/500) */ + bfd_arch_sh, /* Renesas / SuperH SH (formerly Hitachi SH) */ +#define bfd_mach_sh 1 +#define bfd_mach_sh2 0x20 +#define bfd_mach_sh_dsp 0x2d +#define bfd_mach_sh2a 0x2a +#define bfd_mach_sh2a_nofpu 0x2b +#define bfd_mach_sh2a_nofpu_or_sh4_nommu_nofpu 0x2a1 +#define bfd_mach_sh2a_nofpu_or_sh3_nommu 0x2a2 +#define bfd_mach_sh2a_or_sh4 0x2a3 +#define bfd_mach_sh2a_or_sh3e 0x2a4 +#define bfd_mach_sh2e 0x2e +#define bfd_mach_sh3 0x30 +#define bfd_mach_sh3_nommu 0x31 +#define bfd_mach_sh3_dsp 0x3d +#define bfd_mach_sh3e 0x3e +#define bfd_mach_sh4 0x40 +#define bfd_mach_sh4_nofpu 0x41 +#define bfd_mach_sh4_nommu_nofpu 0x42 +#define bfd_mach_sh4a 0x4a +#define bfd_mach_sh4a_nofpu 0x4b +#define bfd_mach_sh4al_dsp 0x4d +#define bfd_mach_sh5 0x50 + bfd_arch_alpha, /* Dec Alpha */ +#define bfd_mach_alpha_ev4 0x10 +#define bfd_mach_alpha_ev5 0x20 +#define bfd_mach_alpha_ev6 0x30 + bfd_arch_arm, /* Advanced Risc Machines ARM. */ +#define bfd_mach_arm_unknown 0 +#define bfd_mach_arm_2 1 +#define bfd_mach_arm_2a 2 +#define bfd_mach_arm_3 3 +#define bfd_mach_arm_3M 4 +#define bfd_mach_arm_4 5 +#define bfd_mach_arm_4T 6 +#define bfd_mach_arm_5 7 +#define bfd_mach_arm_5T 8 +#define bfd_mach_arm_5TE 9 +#define bfd_mach_arm_XScale 10 +#define bfd_mach_arm_ep9312 11 +#define bfd_mach_arm_iWMMXt 12 + bfd_arch_ns32k, /* National Semiconductors ns32000 */ + bfd_arch_w65, /* WDC 65816 */ + bfd_arch_tic30, /* Texas Instruments TMS320C30 */ + bfd_arch_tic4x, /* Texas Instruments TMS320C3X/4X */ +#define bfd_mach_tic3x 30 +#define bfd_mach_tic4x 40 + bfd_arch_tic54x, /* Texas Instruments TMS320C54X */ + bfd_arch_tic80, /* TI TMS320c80 (MVP) */ + bfd_arch_v850, /* NEC V850 */ +#define bfd_mach_v850 1 +#define bfd_mach_v850e 'E' +#define bfd_mach_v850e1 '1' + bfd_arch_arc, /* ARC Cores */ +#define bfd_mach_arc_5 5 +#define bfd_mach_arc_6 6 +#define bfd_mach_arc_7 7 +#define bfd_mach_arc_8 8 + bfd_arch_m32c, /* Renesas M16C/M32C. */ +#define bfd_mach_m16c 0x75 +#define bfd_mach_m32c 0x78 + bfd_arch_m32r, /* Renesas M32R (formerly Mitsubishi M32R/D) */ +#define bfd_mach_m32r 1 /* For backwards compatibility. */ +#define bfd_mach_m32rx 'x' +#define bfd_mach_m32r2 '2' + bfd_arch_mn10200, /* Matsushita MN10200 */ + bfd_arch_mn10300, /* Matsushita MN10300 */ +#define bfd_mach_mn10300 300 +#define bfd_mach_am33 330 +#define bfd_mach_am33_2 332 + bfd_arch_fr30, +#define bfd_mach_fr30 0x46523330 + bfd_arch_frv, +#define bfd_mach_frv 1 +#define bfd_mach_frvsimple 2 +#define bfd_mach_fr300 300 +#define bfd_mach_fr400 400 +#define bfd_mach_fr450 450 +#define bfd_mach_frvtomcat 499 /* fr500 prototype */ +#define bfd_mach_fr500 500 +#define bfd_mach_fr550 550 + bfd_arch_mcore, + bfd_arch_ia64, /* HP/Intel ia64 */ +#define bfd_mach_ia64_elf64 64 +#define bfd_mach_ia64_elf32 32 + bfd_arch_ip2k, /* Ubicom IP2K microcontrollers. */ +#define bfd_mach_ip2022 1 +#define bfd_mach_ip2022ext 2 + bfd_arch_iq2000, /* Vitesse IQ2000. */ +#define bfd_mach_iq2000 1 +#define bfd_mach_iq10 2 + bfd_arch_ms1, +#define bfd_mach_ms1 1 +#define bfd_mach_mrisc2 2 + bfd_arch_pj, + bfd_arch_avr, /* Atmel AVR microcontrollers. */ +#define bfd_mach_avr1 1 +#define bfd_mach_avr2 2 +#define bfd_mach_avr3 3 +#define bfd_mach_avr4 4 +#define bfd_mach_avr5 5 + bfd_arch_cr16c, /* National Semiconductor CompactRISC. */ +#define bfd_mach_cr16c 1 + bfd_arch_crx, /* National Semiconductor CRX. */ +#define bfd_mach_crx 1 + bfd_arch_cris, /* Axis CRIS */ +#define bfd_mach_cris_v0_v10 255 +#define bfd_mach_cris_v32 32 +#define bfd_mach_cris_v10_v32 1032 + bfd_arch_s390, /* IBM s390 */ +#define bfd_mach_s390_31 31 +#define bfd_mach_s390_64 64 + bfd_arch_openrisc, /* OpenRISC */ + bfd_arch_mmix, /* Donald Knuth's educational processor. */ + bfd_arch_xstormy16, +#define bfd_mach_xstormy16 1 + bfd_arch_msp430, /* Texas Instruments MSP430 architecture. */ +#define bfd_mach_msp11 11 +#define bfd_mach_msp110 110 +#define bfd_mach_msp12 12 +#define bfd_mach_msp13 13 +#define bfd_mach_msp14 14 +#define bfd_mach_msp15 15 +#define bfd_mach_msp16 16 +#define bfd_mach_msp31 31 +#define bfd_mach_msp32 32 +#define bfd_mach_msp33 33 +#define bfd_mach_msp41 41 +#define bfd_mach_msp42 42 +#define bfd_mach_msp43 43 +#define bfd_mach_msp44 44 + bfd_arch_xtensa, /* Tensilica's Xtensa cores. */ +#define bfd_mach_xtensa 1 + bfd_arch_maxq, /* Dallas MAXQ 10/20 */ +#define bfd_mach_maxq10 10 +#define bfd_mach_maxq20 20 + bfd_arch_last + }; + +typedef struct bfd_arch_info +{ + int bits_per_word; + int bits_per_address; + int bits_per_byte; + enum bfd_architecture arch; + unsigned long mach; + const char *arch_name; + const char *printable_name; + unsigned int section_align_power; + /* TRUE if this is the default machine for the architecture. + The default arch should be the first entry for an arch so that + all the entries for that arch can be accessed via <>. */ + bfd_boolean the_default; + const struct bfd_arch_info * (*compatible) + (const struct bfd_arch_info *a, const struct bfd_arch_info *b); + + bfd_boolean (*scan) (const struct bfd_arch_info *, const char *); + + const struct bfd_arch_info *next; +} +bfd_arch_info_type; + +const char *bfd_printable_name (bfd *abfd); + +const bfd_arch_info_type *bfd_scan_arch (const char *string); + +const char **bfd_arch_list (void); + +const bfd_arch_info_type *bfd_arch_get_compatible + (const bfd *abfd, const bfd *bbfd, bfd_boolean accept_unknowns); + +void bfd_set_arch_info (bfd *abfd, const bfd_arch_info_type *arg); + +enum bfd_architecture bfd_get_arch (bfd *abfd); + +unsigned long bfd_get_mach (bfd *abfd); + +unsigned int bfd_arch_bits_per_byte (bfd *abfd); + +unsigned int bfd_arch_bits_per_address (bfd *abfd); + +const bfd_arch_info_type *bfd_get_arch_info (bfd *abfd); + +const bfd_arch_info_type *bfd_lookup_arch + (enum bfd_architecture arch, unsigned long machine); + +const char *bfd_printable_arch_mach + (enum bfd_architecture arch, unsigned long machine); + +unsigned int bfd_octets_per_byte (bfd *abfd); + +unsigned int bfd_arch_mach_octets_per_byte + (enum bfd_architecture arch, unsigned long machine); + +/* Extracted from reloc.c. */ +typedef enum bfd_reloc_status +{ + /* No errors detected. */ + bfd_reloc_ok, + + /* The relocation was performed, but there was an overflow. */ + bfd_reloc_overflow, + + /* The address to relocate was not within the section supplied. */ + bfd_reloc_outofrange, + + /* Used by special functions. */ + bfd_reloc_continue, + + /* Unsupported relocation size requested. */ + bfd_reloc_notsupported, + + /* Unused. */ + bfd_reloc_other, + + /* The symbol to relocate against was undefined. */ + bfd_reloc_undefined, + + /* The relocation was performed, but may not be ok - presently + generated only when linking i960 coff files with i960 b.out + symbols. If this type is returned, the error_message argument + to bfd_perform_relocation will be set. */ + bfd_reloc_dangerous + } + bfd_reloc_status_type; + + +typedef struct reloc_cache_entry +{ + /* A pointer into the canonical table of pointers. */ + struct bfd_symbol **sym_ptr_ptr; + + /* offset in section. */ + bfd_size_type address; + + /* addend for relocation value. */ + bfd_vma addend; + + /* Pointer to how to perform the required relocation. */ + reloc_howto_type *howto; + +} +arelent; + +enum complain_overflow +{ + /* Do not complain on overflow. */ + complain_overflow_dont, + + /* Complain if the bitfield overflows, whether it is considered + as signed or unsigned. */ + complain_overflow_bitfield, + + /* Complain if the value overflows when considered as signed + number. */ + complain_overflow_signed, + + /* Complain if the value overflows when considered as an + unsigned number. */ + complain_overflow_unsigned +}; + +struct reloc_howto_struct +{ + /* The type field has mainly a documentary use - the back end can + do what it wants with it, though normally the back end's + external idea of what a reloc number is stored + in this field. For example, a PC relative word relocation + in a coff environment has the type 023 - because that's + what the outside world calls a R_PCRWORD reloc. */ + unsigned int type; + + /* The value the final relocation is shifted right by. This drops + unwanted data from the relocation. */ + unsigned int rightshift; + + /* The size of the item to be relocated. This is *not* a + power-of-two measure. To get the number of bytes operated + on by a type of relocation, use bfd_get_reloc_size. */ + int size; + + /* The number of bits in the item to be relocated. This is used + when doing overflow checking. */ + unsigned int bitsize; + + /* Notes that the relocation is relative to the location in the + data section of the addend. The relocation function will + subtract from the relocation value the address of the location + being relocated. */ + bfd_boolean pc_relative; + + /* The bit position of the reloc value in the destination. + The relocated value is left shifted by this amount. */ + unsigned int bitpos; + + /* What type of overflow error should be checked for when + relocating. */ + enum complain_overflow complain_on_overflow; + + /* If this field is non null, then the supplied function is + called rather than the normal function. This allows really + strange relocation methods to be accommodated (e.g., i960 callj + instructions). */ + bfd_reloc_status_type (*special_function) + (bfd *, arelent *, struct bfd_symbol *, void *, asection *, + bfd *, char **); + + /* The textual name of the relocation type. */ + char *name; + + /* Some formats record a relocation addend in the section contents + rather than with the relocation. For ELF formats this is the + distinction between USE_REL and USE_RELA (though the code checks + for USE_REL == 1/0). The value of this field is TRUE if the + addend is recorded with the section contents; when performing a + partial link (ld -r) the section contents (the data) will be + modified. The value of this field is FALSE if addends are + recorded with the relocation (in arelent.addend); when performing + a partial link the relocation will be modified. + All relocations for all ELF USE_RELA targets should set this field + to FALSE (values of TRUE should be looked on with suspicion). + However, the converse is not true: not all relocations of all ELF + USE_REL targets set this field to TRUE. Why this is so is peculiar + to each particular target. For relocs that aren't used in partial + links (e.g. GOT stuff) it doesn't matter what this is set to. */ + bfd_boolean partial_inplace; + + /* src_mask selects the part of the instruction (or data) to be used + in the relocation sum. If the target relocations don't have an + addend in the reloc, eg. ELF USE_REL, src_mask will normally equal + dst_mask to extract the addend from the section contents. If + relocations do have an addend in the reloc, eg. ELF USE_RELA, this + field should be zero. Non-zero values for ELF USE_RELA targets are + bogus as in those cases the value in the dst_mask part of the + section contents should be treated as garbage. */ + bfd_vma src_mask; + + /* dst_mask selects which parts of the instruction (or data) are + replaced with a relocated value. */ + bfd_vma dst_mask; + + /* When some formats create PC relative instructions, they leave + the value of the pc of the place being relocated in the offset + slot of the instruction, so that a PC relative relocation can + be made just by adding in an ordinary offset (e.g., sun3 a.out). + Some formats leave the displacement part of an instruction + empty (e.g., m88k bcs); this flag signals the fact. */ + bfd_boolean pcrel_offset; +}; + +#define HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \ + { (unsigned) C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC } +#define NEWHOWTO(FUNCTION, NAME, SIZE, REL, IN) \ + HOWTO (0, 0, SIZE, 0, REL, 0, complain_overflow_dont, FUNCTION, \ + NAME, FALSE, 0, 0, IN) + +#define EMPTY_HOWTO(C) \ + HOWTO ((C), 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, \ + NULL, FALSE, 0, 0, FALSE) + +#define HOWTO_PREPARE(relocation, symbol) \ + { \ + if (symbol != NULL) \ + { \ + if (bfd_is_com_section (symbol->section)) \ + { \ + relocation = 0; \ + } \ + else \ + { \ + relocation = symbol->value; \ + } \ + } \ + } + +unsigned int bfd_get_reloc_size (reloc_howto_type *); + +typedef struct relent_chain +{ + arelent relent; + struct relent_chain *next; +} +arelent_chain; + +bfd_reloc_status_type bfd_check_overflow + (enum complain_overflow how, + unsigned int bitsize, + unsigned int rightshift, + unsigned int addrsize, + bfd_vma relocation); + +bfd_reloc_status_type bfd_perform_relocation + (bfd *abfd, + arelent *reloc_entry, + void *data, + asection *input_section, + bfd *output_bfd, + char **error_message); + +bfd_reloc_status_type bfd_install_relocation + (bfd *abfd, + arelent *reloc_entry, + void *data, bfd_vma data_start, + asection *input_section, + char **error_message); + +enum bfd_reloc_code_real { + _dummy_first_bfd_reloc_code_real, + + +/* Basic absolute relocations of N bits. */ + BFD_RELOC_64, + BFD_RELOC_32, + BFD_RELOC_26, + BFD_RELOC_24, + BFD_RELOC_16, + BFD_RELOC_14, + BFD_RELOC_8, + +/* PC-relative relocations. Sometimes these are relative to the address +of the relocation itself; sometimes they are relative to the start of +the section containing the relocation. It depends on the specific target. + +The 24-bit relocation is used in some Intel 960 configurations. */ + BFD_RELOC_64_PCREL, + BFD_RELOC_32_PCREL, + BFD_RELOC_24_PCREL, + BFD_RELOC_16_PCREL, + BFD_RELOC_12_PCREL, + BFD_RELOC_8_PCREL, + +/* Section relative relocations. Some targets need this for DWARF2. */ + BFD_RELOC_32_SECREL, + +/* For ELF. */ + BFD_RELOC_32_GOT_PCREL, + BFD_RELOC_16_GOT_PCREL, + BFD_RELOC_8_GOT_PCREL, + BFD_RELOC_32_GOTOFF, + BFD_RELOC_16_GOTOFF, + BFD_RELOC_LO16_GOTOFF, + BFD_RELOC_HI16_GOTOFF, + BFD_RELOC_HI16_S_GOTOFF, + BFD_RELOC_8_GOTOFF, + BFD_RELOC_64_PLT_PCREL, + BFD_RELOC_32_PLT_PCREL, + BFD_RELOC_24_PLT_PCREL, + BFD_RELOC_16_PLT_PCREL, + BFD_RELOC_8_PLT_PCREL, + BFD_RELOC_64_PLTOFF, + BFD_RELOC_32_PLTOFF, + BFD_RELOC_16_PLTOFF, + BFD_RELOC_LO16_PLTOFF, + BFD_RELOC_HI16_PLTOFF, + BFD_RELOC_HI16_S_PLTOFF, + BFD_RELOC_8_PLTOFF, + +/* Relocations used by 68K ELF. */ + BFD_RELOC_68K_GLOB_DAT, + BFD_RELOC_68K_JMP_SLOT, + BFD_RELOC_68K_RELATIVE, + +/* Linkage-table relative. */ + BFD_RELOC_32_BASEREL, + BFD_RELOC_16_BASEREL, + BFD_RELOC_LO16_BASEREL, + BFD_RELOC_HI16_BASEREL, + BFD_RELOC_HI16_S_BASEREL, + BFD_RELOC_8_BASEREL, + BFD_RELOC_RVA, + +/* Absolute 8-bit relocation, but used to form an address like 0xFFnn. */ + BFD_RELOC_8_FFnn, + +/* These PC-relative relocations are stored as word displacements -- +i.e., byte displacements shifted right two bits. The 30-bit word +displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the +SPARC. (SPARC tools generally refer to this as <>.) The +signed 16-bit displacement is used on the MIPS, and the 23-bit +displacement is used on the Alpha. */ + BFD_RELOC_32_PCREL_S2, + BFD_RELOC_16_PCREL_S2, + BFD_RELOC_23_PCREL_S2, + +/* High 22 bits and low 10 bits of 32-bit value, placed into lower bits of +the target word. These are used on the SPARC. */ + BFD_RELOC_HI22, + BFD_RELOC_LO10, + +/* For systems that allocate a Global Pointer register, these are +displacements off that register. These relocation types are +handled specially, because the value the register will have is +decided relatively late. */ + BFD_RELOC_GPREL16, + BFD_RELOC_GPREL32, + +/* Reloc types used for i960/b.out. */ + BFD_RELOC_I960_CALLJ, + +/* SPARC ELF relocations. There is probably some overlap with other +relocation types already defined. */ + BFD_RELOC_NONE, + BFD_RELOC_SPARC_WDISP22, + BFD_RELOC_SPARC22, + BFD_RELOC_SPARC13, + BFD_RELOC_SPARC_GOT10, + BFD_RELOC_SPARC_GOT13, + BFD_RELOC_SPARC_GOT22, + BFD_RELOC_SPARC_PC10, + BFD_RELOC_SPARC_PC22, + BFD_RELOC_SPARC_WPLT30, + BFD_RELOC_SPARC_COPY, + BFD_RELOC_SPARC_GLOB_DAT, + BFD_RELOC_SPARC_JMP_SLOT, + BFD_RELOC_SPARC_RELATIVE, + BFD_RELOC_SPARC_UA16, + BFD_RELOC_SPARC_UA32, + BFD_RELOC_SPARC_UA64, + +/* I think these are specific to SPARC a.out (e.g., Sun 4). */ + BFD_RELOC_SPARC_BASE13, + BFD_RELOC_SPARC_BASE22, + +/* SPARC64 relocations */ +#define BFD_RELOC_SPARC_64 BFD_RELOC_64 + BFD_RELOC_SPARC_10, + BFD_RELOC_SPARC_11, + BFD_RELOC_SPARC_OLO10, + BFD_RELOC_SPARC_HH22, + BFD_RELOC_SPARC_HM10, + BFD_RELOC_SPARC_LM22, + BFD_RELOC_SPARC_PC_HH22, + BFD_RELOC_SPARC_PC_HM10, + BFD_RELOC_SPARC_PC_LM22, + BFD_RELOC_SPARC_WDISP16, + BFD_RELOC_SPARC_WDISP19, + BFD_RELOC_SPARC_7, + BFD_RELOC_SPARC_6, + BFD_RELOC_SPARC_5, +#define BFD_RELOC_SPARC_DISP64 BFD_RELOC_64_PCREL + BFD_RELOC_SPARC_PLT32, + BFD_RELOC_SPARC_PLT64, + BFD_RELOC_SPARC_HIX22, + BFD_RELOC_SPARC_LOX10, + BFD_RELOC_SPARC_H44, + BFD_RELOC_SPARC_M44, + BFD_RELOC_SPARC_L44, + BFD_RELOC_SPARC_REGISTER, + +/* SPARC little endian relocation */ + BFD_RELOC_SPARC_REV32, + +/* SPARC TLS relocations */ + BFD_RELOC_SPARC_TLS_GD_HI22, + BFD_RELOC_SPARC_TLS_GD_LO10, + BFD_RELOC_SPARC_TLS_GD_ADD, + BFD_RELOC_SPARC_TLS_GD_CALL, + BFD_RELOC_SPARC_TLS_LDM_HI22, + BFD_RELOC_SPARC_TLS_LDM_LO10, + BFD_RELOC_SPARC_TLS_LDM_ADD, + BFD_RELOC_SPARC_TLS_LDM_CALL, + BFD_RELOC_SPARC_TLS_LDO_HIX22, + BFD_RELOC_SPARC_TLS_LDO_LOX10, + BFD_RELOC_SPARC_TLS_LDO_ADD, + BFD_RELOC_SPARC_TLS_IE_HI22, + BFD_RELOC_SPARC_TLS_IE_LO10, + BFD_RELOC_SPARC_TLS_IE_LD, + BFD_RELOC_SPARC_TLS_IE_LDX, + BFD_RELOC_SPARC_TLS_IE_ADD, + BFD_RELOC_SPARC_TLS_LE_HIX22, + BFD_RELOC_SPARC_TLS_LE_LOX10, + BFD_RELOC_SPARC_TLS_DTPMOD32, + BFD_RELOC_SPARC_TLS_DTPMOD64, + BFD_RELOC_SPARC_TLS_DTPOFF32, + BFD_RELOC_SPARC_TLS_DTPOFF64, + BFD_RELOC_SPARC_TLS_TPOFF32, + BFD_RELOC_SPARC_TLS_TPOFF64, + +/* Alpha ECOFF and ELF relocations. Some of these treat the symbol or +"addend" in some special way. +For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when +writing; when reading, it will be the absolute section symbol. The +addend is the displacement in bytes of the "lda" instruction from +the "ldah" instruction (which is at the address of this reloc). */ + BFD_RELOC_ALPHA_GPDISP_HI16, + +/* For GPDISP_LO16 ("ignore") relocations, the symbol is handled as +with GPDISP_HI16 relocs. The addend is ignored when writing the +relocations out, and is filled in with the file's GP value on +reading, for convenience. */ + BFD_RELOC_ALPHA_GPDISP_LO16, + +/* The ELF GPDISP relocation is exactly the same as the GPDISP_HI16 +relocation except that there is no accompanying GPDISP_LO16 +relocation. */ + BFD_RELOC_ALPHA_GPDISP, + +/* The Alpha LITERAL/LITUSE relocs are produced by a symbol reference; +the assembler turns it into a LDQ instruction to load the address of +the symbol, and then fills in a register in the real instruction. + +The LITERAL reloc, at the LDQ instruction, refers to the .lita +section symbol. The addend is ignored when writing, but is filled +in with the file's GP value on reading, for convenience, as with the +GPDISP_LO16 reloc. + +The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16. +It should refer to the symbol to be referenced, as with 16_GOTOFF, +but it generates output not based on the position within the .got +section, but relative to the GP value chosen for the file during the +final link stage. + +The LITUSE reloc, on the instruction using the loaded address, gives +information to the linker that it might be able to use to optimize +away some literal section references. The symbol is ignored (read +as the absolute section symbol), and the "addend" indicates the type +of instruction using the register: +1 - "memory" fmt insn +2 - byte-manipulation (byte offset reg) +3 - jsr (target of branch) */ + BFD_RELOC_ALPHA_LITERAL, + BFD_RELOC_ALPHA_ELF_LITERAL, + BFD_RELOC_ALPHA_LITUSE, + +/* The HINT relocation indicates a value that should be filled into the +"hint" field of a jmp/jsr/ret instruction, for possible branch- +prediction logic which may be provided on some processors. */ + BFD_RELOC_ALPHA_HINT, + +/* The LINKAGE relocation outputs a linkage pair in the object file, +which is filled by the linker. */ + BFD_RELOC_ALPHA_LINKAGE, + +/* The CODEADDR relocation outputs a STO_CA in the object file, +which is filled by the linker. */ + BFD_RELOC_ALPHA_CODEADDR, + +/* The GPREL_HI/LO relocations together form a 32-bit offset from the +GP register. */ + BFD_RELOC_ALPHA_GPREL_HI16, + BFD_RELOC_ALPHA_GPREL_LO16, + +/* Like BFD_RELOC_23_PCREL_S2, except that the source and target must +share a common GP, and the target address is adjusted for +STO_ALPHA_STD_GPLOAD. */ + BFD_RELOC_ALPHA_BRSGP, + +/* Alpha thread-local storage relocations. */ + BFD_RELOC_ALPHA_TLSGD, + BFD_RELOC_ALPHA_TLSLDM, + BFD_RELOC_ALPHA_DTPMOD64, + BFD_RELOC_ALPHA_GOTDTPREL16, + BFD_RELOC_ALPHA_DTPREL64, + BFD_RELOC_ALPHA_DTPREL_HI16, + BFD_RELOC_ALPHA_DTPREL_LO16, + BFD_RELOC_ALPHA_DTPREL16, + BFD_RELOC_ALPHA_GOTTPREL16, + BFD_RELOC_ALPHA_TPREL64, + BFD_RELOC_ALPHA_TPREL_HI16, + BFD_RELOC_ALPHA_TPREL_LO16, + BFD_RELOC_ALPHA_TPREL16, + +/* Bits 27..2 of the relocation address shifted right 2 bits; +simple reloc otherwise. */ + BFD_RELOC_MIPS_JMP, + +/* The MIPS16 jump instruction. */ + BFD_RELOC_MIPS16_JMP, + +/* MIPS16 GP relative reloc. */ + BFD_RELOC_MIPS16_GPREL, + +/* High 16 bits of 32-bit value; simple reloc. */ + BFD_RELOC_HI16, + +/* High 16 bits of 32-bit value but the low 16 bits will be sign +extended and added to form the final result. If the low 16 +bits form a negative number, we need to add one to the high value +to compensate for the borrow when the low bits are added. */ + BFD_RELOC_HI16_S, + +/* Low 16 bits. */ + BFD_RELOC_LO16, + +/* High 16 bits of 32-bit pc-relative value */ + BFD_RELOC_HI16_PCREL, + +/* High 16 bits of 32-bit pc-relative value, adjusted */ + BFD_RELOC_HI16_S_PCREL, + +/* Low 16 bits of pc-relative value */ + BFD_RELOC_LO16_PCREL, + +/* MIPS16 high 16 bits of 32-bit value. */ + BFD_RELOC_MIPS16_HI16, + +/* MIPS16 high 16 bits of 32-bit value but the low 16 bits will be sign +extended and added to form the final result. If the low 16 +bits form a negative number, we need to add one to the high value +to compensate for the borrow when the low bits are added. */ + BFD_RELOC_MIPS16_HI16_S, + +/* MIPS16 low 16 bits. */ + BFD_RELOC_MIPS16_LO16, + +/* Relocation against a MIPS literal section. */ + BFD_RELOC_MIPS_LITERAL, + +/* MIPS ELF relocations. */ + BFD_RELOC_MIPS_GOT16, + BFD_RELOC_MIPS_CALL16, + BFD_RELOC_MIPS_GOT_HI16, + BFD_RELOC_MIPS_GOT_LO16, + BFD_RELOC_MIPS_CALL_HI16, + BFD_RELOC_MIPS_CALL_LO16, + BFD_RELOC_MIPS_SUB, + BFD_RELOC_MIPS_GOT_PAGE, + BFD_RELOC_MIPS_GOT_OFST, + BFD_RELOC_MIPS_GOT_DISP, + BFD_RELOC_MIPS_SHIFT5, + BFD_RELOC_MIPS_SHIFT6, + BFD_RELOC_MIPS_INSERT_A, + BFD_RELOC_MIPS_INSERT_B, + BFD_RELOC_MIPS_DELETE, + BFD_RELOC_MIPS_HIGHEST, + BFD_RELOC_MIPS_HIGHER, + BFD_RELOC_MIPS_SCN_DISP, + BFD_RELOC_MIPS_REL16, + BFD_RELOC_MIPS_RELGOT, + BFD_RELOC_MIPS_JALR, + BFD_RELOC_MIPS_TLS_DTPMOD32, + BFD_RELOC_MIPS_TLS_DTPREL32, + BFD_RELOC_MIPS_TLS_DTPMOD64, + BFD_RELOC_MIPS_TLS_DTPREL64, + BFD_RELOC_MIPS_TLS_GD, + BFD_RELOC_MIPS_TLS_LDM, + BFD_RELOC_MIPS_TLS_DTPREL_HI16, + BFD_RELOC_MIPS_TLS_DTPREL_LO16, + BFD_RELOC_MIPS_TLS_GOTTPREL, + BFD_RELOC_MIPS_TLS_TPREL32, + BFD_RELOC_MIPS_TLS_TPREL64, + BFD_RELOC_MIPS_TLS_TPREL_HI16, + BFD_RELOC_MIPS_TLS_TPREL_LO16, + + +/* Fujitsu Frv Relocations. */ + BFD_RELOC_FRV_LABEL16, + BFD_RELOC_FRV_LABEL24, + BFD_RELOC_FRV_LO16, + BFD_RELOC_FRV_HI16, + BFD_RELOC_FRV_GPREL12, + BFD_RELOC_FRV_GPRELU12, + BFD_RELOC_FRV_GPREL32, + BFD_RELOC_FRV_GPRELHI, + BFD_RELOC_FRV_GPRELLO, + BFD_RELOC_FRV_GOT12, + BFD_RELOC_FRV_GOTHI, + BFD_RELOC_FRV_GOTLO, + BFD_RELOC_FRV_FUNCDESC, + BFD_RELOC_FRV_FUNCDESC_GOT12, + BFD_RELOC_FRV_FUNCDESC_GOTHI, + BFD_RELOC_FRV_FUNCDESC_GOTLO, + BFD_RELOC_FRV_FUNCDESC_VALUE, + BFD_RELOC_FRV_FUNCDESC_GOTOFF12, + BFD_RELOC_FRV_FUNCDESC_GOTOFFHI, + BFD_RELOC_FRV_FUNCDESC_GOTOFFLO, + BFD_RELOC_FRV_GOTOFF12, + BFD_RELOC_FRV_GOTOFFHI, + BFD_RELOC_FRV_GOTOFFLO, + BFD_RELOC_FRV_GETTLSOFF, + BFD_RELOC_FRV_TLSDESC_VALUE, + BFD_RELOC_FRV_GOTTLSDESC12, + BFD_RELOC_FRV_GOTTLSDESCHI, + BFD_RELOC_FRV_GOTTLSDESCLO, + BFD_RELOC_FRV_TLSMOFF12, + BFD_RELOC_FRV_TLSMOFFHI, + BFD_RELOC_FRV_TLSMOFFLO, + BFD_RELOC_FRV_GOTTLSOFF12, + BFD_RELOC_FRV_GOTTLSOFFHI, + BFD_RELOC_FRV_GOTTLSOFFLO, + BFD_RELOC_FRV_TLSOFF, + BFD_RELOC_FRV_TLSDESC_RELAX, + BFD_RELOC_FRV_GETTLSOFF_RELAX, + BFD_RELOC_FRV_TLSOFF_RELAX, + BFD_RELOC_FRV_TLSMOFF, + + +/* This is a 24bit GOT-relative reloc for the mn10300. */ + BFD_RELOC_MN10300_GOTOFF24, + +/* This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes +in the instruction. */ + BFD_RELOC_MN10300_GOT32, + +/* This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes +in the instruction. */ + BFD_RELOC_MN10300_GOT24, + +/* This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes +in the instruction. */ + BFD_RELOC_MN10300_GOT16, + +/* Copy symbol at runtime. */ + BFD_RELOC_MN10300_COPY, + +/* Create GOT entry. */ + BFD_RELOC_MN10300_GLOB_DAT, + +/* Create PLT entry. */ + BFD_RELOC_MN10300_JMP_SLOT, + +/* Adjust by program base. */ + BFD_RELOC_MN10300_RELATIVE, + + +/* i386/elf relocations */ + BFD_RELOC_386_GOT32, + BFD_RELOC_386_PLT32, + BFD_RELOC_386_COPY, + BFD_RELOC_386_GLOB_DAT, + BFD_RELOC_386_JUMP_SLOT, + BFD_RELOC_386_RELATIVE, + BFD_RELOC_386_GOTOFF, + BFD_RELOC_386_GOTPC, + BFD_RELOC_386_TLS_TPOFF, + BFD_RELOC_386_TLS_IE, + BFD_RELOC_386_TLS_GOTIE, + BFD_RELOC_386_TLS_LE, + BFD_RELOC_386_TLS_GD, + BFD_RELOC_386_TLS_LDM, + BFD_RELOC_386_TLS_LDO_32, + BFD_RELOC_386_TLS_IE_32, + BFD_RELOC_386_TLS_LE_32, + BFD_RELOC_386_TLS_DTPMOD32, + BFD_RELOC_386_TLS_DTPOFF32, + BFD_RELOC_386_TLS_TPOFF32, + +/* x86-64/elf relocations */ + BFD_RELOC_X86_64_GOT32, + BFD_RELOC_X86_64_PLT32, + BFD_RELOC_X86_64_COPY, + BFD_RELOC_X86_64_GLOB_DAT, + BFD_RELOC_X86_64_JUMP_SLOT, + BFD_RELOC_X86_64_RELATIVE, + BFD_RELOC_X86_64_GOTPCREL, + BFD_RELOC_X86_64_32S, + BFD_RELOC_X86_64_DTPMOD64, + BFD_RELOC_X86_64_DTPOFF64, + BFD_RELOC_X86_64_TPOFF64, + BFD_RELOC_X86_64_TLSGD, + BFD_RELOC_X86_64_TLSLD, + BFD_RELOC_X86_64_DTPOFF32, + BFD_RELOC_X86_64_GOTTPOFF, + BFD_RELOC_X86_64_TPOFF32, + BFD_RELOC_X86_64_GOTOFF64, + BFD_RELOC_X86_64_GOTPC32, + +/* ns32k relocations */ + BFD_RELOC_NS32K_IMM_8, + BFD_RELOC_NS32K_IMM_16, + BFD_RELOC_NS32K_IMM_32, + BFD_RELOC_NS32K_IMM_8_PCREL, + BFD_RELOC_NS32K_IMM_16_PCREL, + BFD_RELOC_NS32K_IMM_32_PCREL, + BFD_RELOC_NS32K_DISP_8, + BFD_RELOC_NS32K_DISP_16, + BFD_RELOC_NS32K_DISP_32, + BFD_RELOC_NS32K_DISP_8_PCREL, + BFD_RELOC_NS32K_DISP_16_PCREL, + BFD_RELOC_NS32K_DISP_32_PCREL, + +/* PDP11 relocations */ + BFD_RELOC_PDP11_DISP_8_PCREL, + BFD_RELOC_PDP11_DISP_6_PCREL, + +/* Picojava relocs. Not all of these appear in object files. */ + BFD_RELOC_PJ_CODE_HI16, + BFD_RELOC_PJ_CODE_LO16, + BFD_RELOC_PJ_CODE_DIR16, + BFD_RELOC_PJ_CODE_DIR32, + BFD_RELOC_PJ_CODE_REL16, + BFD_RELOC_PJ_CODE_REL32, + +/* Power(rs6000) and PowerPC relocations. */ + BFD_RELOC_PPC_B26, + BFD_RELOC_PPC_BA26, + BFD_RELOC_PPC_TOC16, + BFD_RELOC_PPC_B16, + BFD_RELOC_PPC_B16_BRTAKEN, + BFD_RELOC_PPC_B16_BRNTAKEN, + BFD_RELOC_PPC_BA16, + BFD_RELOC_PPC_BA16_BRTAKEN, + BFD_RELOC_PPC_BA16_BRNTAKEN, + BFD_RELOC_PPC_COPY, + BFD_RELOC_PPC_GLOB_DAT, + BFD_RELOC_PPC_JMP_SLOT, + BFD_RELOC_PPC_RELATIVE, + BFD_RELOC_PPC_LOCAL24PC, + BFD_RELOC_PPC_EMB_NADDR32, + BFD_RELOC_PPC_EMB_NADDR16, + BFD_RELOC_PPC_EMB_NADDR16_LO, + BFD_RELOC_PPC_EMB_NADDR16_HI, + BFD_RELOC_PPC_EMB_NADDR16_HA, + BFD_RELOC_PPC_EMB_SDAI16, + BFD_RELOC_PPC_EMB_SDA2I16, + BFD_RELOC_PPC_EMB_SDA2REL, + BFD_RELOC_PPC_EMB_SDA21, + BFD_RELOC_PPC_EMB_MRKREF, + BFD_RELOC_PPC_EMB_RELSEC16, + BFD_RELOC_PPC_EMB_RELST_LO, + BFD_RELOC_PPC_EMB_RELST_HI, + BFD_RELOC_PPC_EMB_RELST_HA, + BFD_RELOC_PPC_EMB_BIT_FLD, + BFD_RELOC_PPC_EMB_RELSDA, + BFD_RELOC_PPC64_HIGHER, + BFD_RELOC_PPC64_HIGHER_S, + BFD_RELOC_PPC64_HIGHEST, + BFD_RELOC_PPC64_HIGHEST_S, + BFD_RELOC_PPC64_TOC16_LO, + BFD_RELOC_PPC64_TOC16_HI, + BFD_RELOC_PPC64_TOC16_HA, + BFD_RELOC_PPC64_TOC, + BFD_RELOC_PPC64_PLTGOT16, + BFD_RELOC_PPC64_PLTGOT16_LO, + BFD_RELOC_PPC64_PLTGOT16_HI, + BFD_RELOC_PPC64_PLTGOT16_HA, + BFD_RELOC_PPC64_ADDR16_DS, + BFD_RELOC_PPC64_ADDR16_LO_DS, + BFD_RELOC_PPC64_GOT16_DS, + BFD_RELOC_PPC64_GOT16_LO_DS, + BFD_RELOC_PPC64_PLT16_LO_DS, + BFD_RELOC_PPC64_SECTOFF_DS, + BFD_RELOC_PPC64_SECTOFF_LO_DS, + BFD_RELOC_PPC64_TOC16_DS, + BFD_RELOC_PPC64_TOC16_LO_DS, + BFD_RELOC_PPC64_PLTGOT16_DS, + BFD_RELOC_PPC64_PLTGOT16_LO_DS, + +/* PowerPC and PowerPC64 thread-local storage relocations. */ + BFD_RELOC_PPC_TLS, + BFD_RELOC_PPC_DTPMOD, + BFD_RELOC_PPC_TPREL16, + BFD_RELOC_PPC_TPREL16_LO, + BFD_RELOC_PPC_TPREL16_HI, + BFD_RELOC_PPC_TPREL16_HA, + BFD_RELOC_PPC_TPREL, + BFD_RELOC_PPC_DTPREL16, + BFD_RELOC_PPC_DTPREL16_LO, + BFD_RELOC_PPC_DTPREL16_HI, + BFD_RELOC_PPC_DTPREL16_HA, + BFD_RELOC_PPC_DTPREL, + BFD_RELOC_PPC_GOT_TLSGD16, + BFD_RELOC_PPC_GOT_TLSGD16_LO, + BFD_RELOC_PPC_GOT_TLSGD16_HI, + BFD_RELOC_PPC_GOT_TLSGD16_HA, + BFD_RELOC_PPC_GOT_TLSLD16, + BFD_RELOC_PPC_GOT_TLSLD16_LO, + BFD_RELOC_PPC_GOT_TLSLD16_HI, + BFD_RELOC_PPC_GOT_TLSLD16_HA, + BFD_RELOC_PPC_GOT_TPREL16, + BFD_RELOC_PPC_GOT_TPREL16_LO, + BFD_RELOC_PPC_GOT_TPREL16_HI, + BFD_RELOC_PPC_GOT_TPREL16_HA, + BFD_RELOC_PPC_GOT_DTPREL16, + BFD_RELOC_PPC_GOT_DTPREL16_LO, + BFD_RELOC_PPC_GOT_DTPREL16_HI, + BFD_RELOC_PPC_GOT_DTPREL16_HA, + BFD_RELOC_PPC64_TPREL16_DS, + BFD_RELOC_PPC64_TPREL16_LO_DS, + BFD_RELOC_PPC64_TPREL16_HIGHER, + BFD_RELOC_PPC64_TPREL16_HIGHERA, + BFD_RELOC_PPC64_TPREL16_HIGHEST, + BFD_RELOC_PPC64_TPREL16_HIGHESTA, + BFD_RELOC_PPC64_DTPREL16_DS, + BFD_RELOC_PPC64_DTPREL16_LO_DS, + BFD_RELOC_PPC64_DTPREL16_HIGHER, + BFD_RELOC_PPC64_DTPREL16_HIGHERA, + BFD_RELOC_PPC64_DTPREL16_HIGHEST, + BFD_RELOC_PPC64_DTPREL16_HIGHESTA, + +/* IBM 370/390 relocations */ + BFD_RELOC_I370_D12, + +/* The type of reloc used to build a constructor table - at the moment +probably a 32 bit wide absolute relocation, but the target can choose. +It generally does map to one of the other relocation types. */ + BFD_RELOC_CTOR, + +/* ARM 26 bit pc-relative branch. The lowest two bits must be zero and are +not stored in the instruction. */ + BFD_RELOC_ARM_PCREL_BRANCH, + +/* ARM 26 bit pc-relative branch. The lowest bit must be zero and is +not stored in the instruction. The 2nd lowest bit comes from a 1 bit +field in the instruction. */ + BFD_RELOC_ARM_PCREL_BLX, + +/* Thumb 22 bit pc-relative branch. The lowest bit must be zero and is +not stored in the instruction. The 2nd lowest bit comes from a 1 bit +field in the instruction. */ + BFD_RELOC_THUMB_PCREL_BLX, + +/* Thumb 7-, 9-, 12-, 20-, 23-, and 25-bit pc-relative branches. +The lowest bit must be zero and is not stored in the instruction. +Note that the corresponding ELF R_ARM_THM_JUMPnn constant has an +"nn" one smaller in all cases. Note further that BRANCH23 +corresponds to R_ARM_THM_CALL. */ + BFD_RELOC_THUMB_PCREL_BRANCH7, + BFD_RELOC_THUMB_PCREL_BRANCH9, + BFD_RELOC_THUMB_PCREL_BRANCH12, + BFD_RELOC_THUMB_PCREL_BRANCH20, + BFD_RELOC_THUMB_PCREL_BRANCH23, + BFD_RELOC_THUMB_PCREL_BRANCH25, + +/* 12-bit immediate offset, used in ARM-format ldr and str instructions. */ + BFD_RELOC_ARM_OFFSET_IMM, + +/* 5-bit immediate offset, used in Thumb-format ldr and str instructions. */ + BFD_RELOC_ARM_THUMB_OFFSET, + +/* Pc-relative or absolute relocation depending on target. Used for +entries in .init_array sections. */ + BFD_RELOC_ARM_TARGET1, + +/* Read-only segment base relative address. */ + BFD_RELOC_ARM_ROSEGREL32, + +/* Data segment base relative address. */ + BFD_RELOC_ARM_SBREL32, + +/* This reloc is used for references to RTTI data from exception handling +tables. The actual definition depends on the target. It may be a +pc-relative or some form of GOT-indirect relocation. */ + BFD_RELOC_ARM_TARGET2, + +/* 31-bit PC relative address. */ + BFD_RELOC_ARM_PREL31, + +/* Relocations for setting up GOTs and PLTs for shared libraries. */ + BFD_RELOC_ARM_JUMP_SLOT, + BFD_RELOC_ARM_GLOB_DAT, + BFD_RELOC_ARM_GOT32, + BFD_RELOC_ARM_PLT32, + BFD_RELOC_ARM_RELATIVE, + BFD_RELOC_ARM_GOTOFF, + BFD_RELOC_ARM_GOTPC, + +/* ARM thread-local storage relocations. */ + BFD_RELOC_ARM_TLS_GD32, + BFD_RELOC_ARM_TLS_LDO32, + BFD_RELOC_ARM_TLS_LDM32, + BFD_RELOC_ARM_TLS_DTPOFF32, + BFD_RELOC_ARM_TLS_DTPMOD32, + BFD_RELOC_ARM_TLS_TPOFF32, + BFD_RELOC_ARM_TLS_IE32, + BFD_RELOC_ARM_TLS_LE32, + +/* These relocs are only used within the ARM assembler. They are not +(at present) written to any object files. */ + BFD_RELOC_ARM_IMMEDIATE, + BFD_RELOC_ARM_ADRL_IMMEDIATE, + BFD_RELOC_ARM_T32_IMMEDIATE, + BFD_RELOC_ARM_SHIFT_IMM, + BFD_RELOC_ARM_SMI, + BFD_RELOC_ARM_SWI, + BFD_RELOC_ARM_MULTI, + BFD_RELOC_ARM_CP_OFF_IMM, + BFD_RELOC_ARM_CP_OFF_IMM_S2, + BFD_RELOC_ARM_ADR_IMM, + BFD_RELOC_ARM_LDR_IMM, + BFD_RELOC_ARM_LITERAL, + BFD_RELOC_ARM_IN_POOL, + BFD_RELOC_ARM_OFFSET_IMM8, + BFD_RELOC_ARM_T32_OFFSET_U8, + BFD_RELOC_ARM_T32_OFFSET_IMM, + BFD_RELOC_ARM_HWLITERAL, + BFD_RELOC_ARM_THUMB_ADD, + BFD_RELOC_ARM_THUMB_IMM, + BFD_RELOC_ARM_THUMB_SHIFT, + +/* Renesas / SuperH SH relocs. Not all of these appear in object files. */ + BFD_RELOC_SH_PCDISP8BY2, + BFD_RELOC_SH_PCDISP12BY2, + BFD_RELOC_SH_IMM3, + BFD_RELOC_SH_IMM3U, + BFD_RELOC_SH_DISP12, + BFD_RELOC_SH_DISP12BY2, + BFD_RELOC_SH_DISP12BY4, + BFD_RELOC_SH_DISP12BY8, + BFD_RELOC_SH_DISP20, + BFD_RELOC_SH_DISP20BY8, + BFD_RELOC_SH_IMM4, + BFD_RELOC_SH_IMM4BY2, + BFD_RELOC_SH_IMM4BY4, + BFD_RELOC_SH_IMM8, + BFD_RELOC_SH_IMM8BY2, + BFD_RELOC_SH_IMM8BY4, + BFD_RELOC_SH_PCRELIMM8BY2, + BFD_RELOC_SH_PCRELIMM8BY4, + BFD_RELOC_SH_SWITCH16, + BFD_RELOC_SH_SWITCH32, + BFD_RELOC_SH_USES, + BFD_RELOC_SH_COUNT, + BFD_RELOC_SH_ALIGN, + BFD_RELOC_SH_CODE, + BFD_RELOC_SH_DATA, + BFD_RELOC_SH_LABEL, + BFD_RELOC_SH_LOOP_START, + BFD_RELOC_SH_LOOP_END, + BFD_RELOC_SH_COPY, + BFD_RELOC_SH_GLOB_DAT, + BFD_RELOC_SH_JMP_SLOT, + BFD_RELOC_SH_RELATIVE, + BFD_RELOC_SH_GOTPC, + BFD_RELOC_SH_GOT_LOW16, + BFD_RELOC_SH_GOT_MEDLOW16, + BFD_RELOC_SH_GOT_MEDHI16, + BFD_RELOC_SH_GOT_HI16, + BFD_RELOC_SH_GOTPLT_LOW16, + BFD_RELOC_SH_GOTPLT_MEDLOW16, + BFD_RELOC_SH_GOTPLT_MEDHI16, + BFD_RELOC_SH_GOTPLT_HI16, + BFD_RELOC_SH_PLT_LOW16, + BFD_RELOC_SH_PLT_MEDLOW16, + BFD_RELOC_SH_PLT_MEDHI16, + BFD_RELOC_SH_PLT_HI16, + BFD_RELOC_SH_GOTOFF_LOW16, + BFD_RELOC_SH_GOTOFF_MEDLOW16, + BFD_RELOC_SH_GOTOFF_MEDHI16, + BFD_RELOC_SH_GOTOFF_HI16, + BFD_RELOC_SH_GOTPC_LOW16, + BFD_RELOC_SH_GOTPC_MEDLOW16, + BFD_RELOC_SH_GOTPC_MEDHI16, + BFD_RELOC_SH_GOTPC_HI16, + BFD_RELOC_SH_COPY64, + BFD_RELOC_SH_GLOB_DAT64, + BFD_RELOC_SH_JMP_SLOT64, + BFD_RELOC_SH_RELATIVE64, + BFD_RELOC_SH_GOT10BY4, + BFD_RELOC_SH_GOT10BY8, + BFD_RELOC_SH_GOTPLT10BY4, + BFD_RELOC_SH_GOTPLT10BY8, + BFD_RELOC_SH_GOTPLT32, + BFD_RELOC_SH_SHMEDIA_CODE, + BFD_RELOC_SH_IMMU5, + BFD_RELOC_SH_IMMS6, + BFD_RELOC_SH_IMMS6BY32, + BFD_RELOC_SH_IMMU6, + BFD_RELOC_SH_IMMS10, + BFD_RELOC_SH_IMMS10BY2, + BFD_RELOC_SH_IMMS10BY4, + BFD_RELOC_SH_IMMS10BY8, + BFD_RELOC_SH_IMMS16, + BFD_RELOC_SH_IMMU16, + BFD_RELOC_SH_IMM_LOW16, + BFD_RELOC_SH_IMM_LOW16_PCREL, + BFD_RELOC_SH_IMM_MEDLOW16, + BFD_RELOC_SH_IMM_MEDLOW16_PCREL, + BFD_RELOC_SH_IMM_MEDHI16, + BFD_RELOC_SH_IMM_MEDHI16_PCREL, + BFD_RELOC_SH_IMM_HI16, + BFD_RELOC_SH_IMM_HI16_PCREL, + BFD_RELOC_SH_PT_16, + BFD_RELOC_SH_TLS_GD_32, + BFD_RELOC_SH_TLS_LD_32, + BFD_RELOC_SH_TLS_LDO_32, + BFD_RELOC_SH_TLS_IE_32, + BFD_RELOC_SH_TLS_LE_32, + BFD_RELOC_SH_TLS_DTPMOD32, + BFD_RELOC_SH_TLS_DTPOFF32, + BFD_RELOC_SH_TLS_TPOFF32, + +/* ARC Cores relocs. +ARC 22 bit pc-relative branch. The lowest two bits must be zero and are +not stored in the instruction. The high 20 bits are installed in bits 26 +through 7 of the instruction. */ + BFD_RELOC_ARC_B22_PCREL, + +/* ARC 26 bit absolute branch. The lowest two bits must be zero and are not +stored in the instruction. The high 24 bits are installed in bits 23 +through 0. */ + BFD_RELOC_ARC_B26, + +/* Mitsubishi D10V relocs. +This is a 10-bit reloc with the right 2 bits +assumed to be 0. */ + BFD_RELOC_D10V_10_PCREL_R, + +/* Mitsubishi D10V relocs. +This is a 10-bit reloc with the right 2 bits +assumed to be 0. This is the same as the previous reloc +except it is in the left container, i.e., +shifted left 15 bits. */ + BFD_RELOC_D10V_10_PCREL_L, + +/* This is an 18-bit reloc with the right 2 bits +assumed to be 0. */ + BFD_RELOC_D10V_18, + +/* This is an 18-bit reloc with the right 2 bits +assumed to be 0. */ + BFD_RELOC_D10V_18_PCREL, + +/* Mitsubishi D30V relocs. +This is a 6-bit absolute reloc. */ + BFD_RELOC_D30V_6, + +/* This is a 6-bit pc-relative reloc with +the right 3 bits assumed to be 0. */ + BFD_RELOC_D30V_9_PCREL, + +/* This is a 6-bit pc-relative reloc with +the right 3 bits assumed to be 0. Same +as the previous reloc but on the right side +of the container. */ + BFD_RELOC_D30V_9_PCREL_R, + +/* This is a 12-bit absolute reloc with the +right 3 bitsassumed to be 0. */ + BFD_RELOC_D30V_15, + +/* This is a 12-bit pc-relative reloc with +the right 3 bits assumed to be 0. */ + BFD_RELOC_D30V_15_PCREL, + +/* This is a 12-bit pc-relative reloc with +the right 3 bits assumed to be 0. Same +as the previous reloc but on the right side +of the container. */ + BFD_RELOC_D30V_15_PCREL_R, + +/* This is an 18-bit absolute reloc with +the right 3 bits assumed to be 0. */ + BFD_RELOC_D30V_21, + +/* This is an 18-bit pc-relative reloc with +the right 3 bits assumed to be 0. */ + BFD_RELOC_D30V_21_PCREL, + +/* This is an 18-bit pc-relative reloc with +the right 3 bits assumed to be 0. Same +as the previous reloc but on the right side +of the container. */ + BFD_RELOC_D30V_21_PCREL_R, + +/* This is a 32-bit absolute reloc. */ + BFD_RELOC_D30V_32, + +/* This is a 32-bit pc-relative reloc. */ + BFD_RELOC_D30V_32_PCREL, + +/* DLX relocs */ + BFD_RELOC_DLX_HI16_S, + +/* DLX relocs */ + BFD_RELOC_DLX_LO16, + +/* DLX relocs */ + BFD_RELOC_DLX_JMP26, + +/* Renesas M16C/M32C Relocations. */ + BFD_RELOC_M16C_8_PCREL8, + BFD_RELOC_M16C_16_PCREL8, + BFD_RELOC_M16C_8_PCREL16, + BFD_RELOC_M16C_8_ELABEL24, + BFD_RELOC_M16C_8_ABS16, + BFD_RELOC_M16C_16_ABS16, + BFD_RELOC_M16C_16_ABS24, + BFD_RELOC_M16C_16_ABS32, + BFD_RELOC_M16C_24_ABS16, + BFD_RELOC_M16C_24_ABS24, + BFD_RELOC_M16C_24_ABS32, + BFD_RELOC_M16C_32_ABS16, + BFD_RELOC_M16C_32_ABS24, + BFD_RELOC_M16C_32_ABS32, + BFD_RELOC_M16C_40_ABS16, + BFD_RELOC_M16C_40_ABS24, + BFD_RELOC_M16C_40_ABS32, + +/* Renesas M32R (formerly Mitsubishi M32R) relocs. +This is a 24 bit absolute address. */ + BFD_RELOC_M32R_24, + +/* This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0. */ + BFD_RELOC_M32R_10_PCREL, + +/* This is an 18-bit reloc with the right 2 bits assumed to be 0. */ + BFD_RELOC_M32R_18_PCREL, + +/* This is a 26-bit reloc with the right 2 bits assumed to be 0. */ + BFD_RELOC_M32R_26_PCREL, + +/* This is a 16-bit reloc containing the high 16 bits of an address +used when the lower 16 bits are treated as unsigned. */ + BFD_RELOC_M32R_HI16_ULO, + +/* This is a 16-bit reloc containing the high 16 bits of an address +used when the lower 16 bits are treated as signed. */ + BFD_RELOC_M32R_HI16_SLO, + +/* This is a 16-bit reloc containing the lower 16 bits of an address. */ + BFD_RELOC_M32R_LO16, + +/* This is a 16-bit reloc containing the small data area offset for use in +add3, load, and store instructions. */ + BFD_RELOC_M32R_SDA16, + +/* For PIC. */ + BFD_RELOC_M32R_GOT24, + BFD_RELOC_M32R_26_PLTREL, + BFD_RELOC_M32R_COPY, + BFD_RELOC_M32R_GLOB_DAT, + BFD_RELOC_M32R_JMP_SLOT, + BFD_RELOC_M32R_RELATIVE, + BFD_RELOC_M32R_GOTOFF, + BFD_RELOC_M32R_GOTOFF_HI_ULO, + BFD_RELOC_M32R_GOTOFF_HI_SLO, + BFD_RELOC_M32R_GOTOFF_LO, + BFD_RELOC_M32R_GOTPC24, + BFD_RELOC_M32R_GOT16_HI_ULO, + BFD_RELOC_M32R_GOT16_HI_SLO, + BFD_RELOC_M32R_GOT16_LO, + BFD_RELOC_M32R_GOTPC_HI_ULO, + BFD_RELOC_M32R_GOTPC_HI_SLO, + BFD_RELOC_M32R_GOTPC_LO, + +/* This is a 9-bit reloc */ + BFD_RELOC_V850_9_PCREL, + +/* This is a 22-bit reloc */ + BFD_RELOC_V850_22_PCREL, + +/* This is a 16 bit offset from the short data area pointer. */ + BFD_RELOC_V850_SDA_16_16_OFFSET, + +/* This is a 16 bit offset (of which only 15 bits are used) from the +short data area pointer. */ + BFD_RELOC_V850_SDA_15_16_OFFSET, + +/* This is a 16 bit offset from the zero data area pointer. */ + BFD_RELOC_V850_ZDA_16_16_OFFSET, + +/* This is a 16 bit offset (of which only 15 bits are used) from the +zero data area pointer. */ + BFD_RELOC_V850_ZDA_15_16_OFFSET, + +/* This is an 8 bit offset (of which only 6 bits are used) from the +tiny data area pointer. */ + BFD_RELOC_V850_TDA_6_8_OFFSET, + +/* This is an 8bit offset (of which only 7 bits are used) from the tiny +data area pointer. */ + BFD_RELOC_V850_TDA_7_8_OFFSET, + +/* This is a 7 bit offset from the tiny data area pointer. */ + BFD_RELOC_V850_TDA_7_7_OFFSET, + +/* This is a 16 bit offset from the tiny data area pointer. */ + BFD_RELOC_V850_TDA_16_16_OFFSET, + +/* This is a 5 bit offset (of which only 4 bits are used) from the tiny +data area pointer. */ + BFD_RELOC_V850_TDA_4_5_OFFSET, + +/* This is a 4 bit offset from the tiny data area pointer. */ + BFD_RELOC_V850_TDA_4_4_OFFSET, + +/* This is a 16 bit offset from the short data area pointer, with the +bits placed non-contiguously in the instruction. */ + BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET, + +/* This is a 16 bit offset from the zero data area pointer, with the +bits placed non-contiguously in the instruction. */ + BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET, + +/* This is a 6 bit offset from the call table base pointer. */ + BFD_RELOC_V850_CALLT_6_7_OFFSET, + +/* This is a 16 bit offset from the call table base pointer. */ + BFD_RELOC_V850_CALLT_16_16_OFFSET, + +/* Used for relaxing indirect function calls. */ + BFD_RELOC_V850_LONGCALL, + +/* Used for relaxing indirect jumps. */ + BFD_RELOC_V850_LONGJUMP, + +/* Used to maintain alignment whilst relaxing. */ + BFD_RELOC_V850_ALIGN, + +/* This is a variation of BFD_RELOC_LO16 that can be used in v850e ld.bu +instructions. */ + BFD_RELOC_V850_LO16_SPLIT_OFFSET, + +/* This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the +instruction. */ + BFD_RELOC_MN10300_32_PCREL, + +/* This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the +instruction. */ + BFD_RELOC_MN10300_16_PCREL, + +/* This is a 8bit DP reloc for the tms320c30, where the most +significant 8 bits of a 24 bit word are placed into the least +significant 8 bits of the opcode. */ + BFD_RELOC_TIC30_LDP, + +/* This is a 7bit reloc for the tms320c54x, where the least +significant 7 bits of a 16 bit word are placed into the least +significant 7 bits of the opcode. */ + BFD_RELOC_TIC54X_PARTLS7, + +/* This is a 9bit DP reloc for the tms320c54x, where the most +significant 9 bits of a 16 bit word are placed into the least +significant 9 bits of the opcode. */ + BFD_RELOC_TIC54X_PARTMS9, + +/* This is an extended address 23-bit reloc for the tms320c54x. */ + BFD_RELOC_TIC54X_23, + +/* This is a 16-bit reloc for the tms320c54x, where the least +significant 16 bits of a 23-bit extended address are placed into +the opcode. */ + BFD_RELOC_TIC54X_16_OF_23, + +/* This is a reloc for the tms320c54x, where the most +significant 7 bits of a 23-bit extended address are placed into +the opcode. */ + BFD_RELOC_TIC54X_MS7_OF_23, + +/* This is a 48 bit reloc for the FR30 that stores 32 bits. */ + BFD_RELOC_FR30_48, + +/* This is a 32 bit reloc for the FR30 that stores 20 bits split up into +two sections. */ + BFD_RELOC_FR30_20, + +/* This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in +4 bits. */ + BFD_RELOC_FR30_6_IN_4, + +/* This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset +into 8 bits. */ + BFD_RELOC_FR30_8_IN_8, + +/* This is a 16 bit reloc for the FR30 that stores a 9 bit short offset +into 8 bits. */ + BFD_RELOC_FR30_9_IN_8, + +/* This is a 16 bit reloc for the FR30 that stores a 10 bit word offset +into 8 bits. */ + BFD_RELOC_FR30_10_IN_8, + +/* This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative +short offset into 8 bits. */ + BFD_RELOC_FR30_9_PCREL, + +/* This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative +short offset into 11 bits. */ + BFD_RELOC_FR30_12_PCREL, + +/* Motorola Mcore relocations. */ + BFD_RELOC_MCORE_PCREL_IMM8BY4, + BFD_RELOC_MCORE_PCREL_IMM11BY2, + BFD_RELOC_MCORE_PCREL_IMM4BY2, + BFD_RELOC_MCORE_PCREL_32, + BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2, + BFD_RELOC_MCORE_RVA, + +/* These are relocations for the GETA instruction. */ + BFD_RELOC_MMIX_GETA, + BFD_RELOC_MMIX_GETA_1, + BFD_RELOC_MMIX_GETA_2, + BFD_RELOC_MMIX_GETA_3, + +/* These are relocations for a conditional branch instruction. */ + BFD_RELOC_MMIX_CBRANCH, + BFD_RELOC_MMIX_CBRANCH_J, + BFD_RELOC_MMIX_CBRANCH_1, + BFD_RELOC_MMIX_CBRANCH_2, + BFD_RELOC_MMIX_CBRANCH_3, + +/* These are relocations for the PUSHJ instruction. */ + BFD_RELOC_MMIX_PUSHJ, + BFD_RELOC_MMIX_PUSHJ_1, + BFD_RELOC_MMIX_PUSHJ_2, + BFD_RELOC_MMIX_PUSHJ_3, + BFD_RELOC_MMIX_PUSHJ_STUBBABLE, + +/* These are relocations for the JMP instruction. */ + BFD_RELOC_MMIX_JMP, + BFD_RELOC_MMIX_JMP_1, + BFD_RELOC_MMIX_JMP_2, + BFD_RELOC_MMIX_JMP_3, + +/* This is a relocation for a relative address as in a GETA instruction or +a branch. */ + BFD_RELOC_MMIX_ADDR19, + +/* This is a relocation for a relative address as in a JMP instruction. */ + BFD_RELOC_MMIX_ADDR27, + +/* This is a relocation for an instruction field that may be a general +register or a value 0..255. */ + BFD_RELOC_MMIX_REG_OR_BYTE, + +/* This is a relocation for an instruction field that may be a general +register. */ + BFD_RELOC_MMIX_REG, + +/* This is a relocation for two instruction fields holding a register and +an offset, the equivalent of the relocation. */ + BFD_RELOC_MMIX_BASE_PLUS_OFFSET, + +/* This relocation is an assertion that the expression is not allocated as +a global register. It does not modify contents. */ + BFD_RELOC_MMIX_LOCAL, + +/* This is a 16 bit reloc for the AVR that stores 8 bit pc relative +short offset into 7 bits. */ + BFD_RELOC_AVR_7_PCREL, + +/* This is a 16 bit reloc for the AVR that stores 13 bit pc relative +short offset into 12 bits. */ + BFD_RELOC_AVR_13_PCREL, + +/* This is a 16 bit reloc for the AVR that stores 17 bit value (usually +program memory address) into 16 bits. */ + BFD_RELOC_AVR_16_PM, + +/* This is a 16 bit reloc for the AVR that stores 8 bit value (usually +data memory address) into 8 bit immediate value of LDI insn. */ + BFD_RELOC_AVR_LO8_LDI, + +/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit +of data memory address) into 8 bit immediate value of LDI insn. */ + BFD_RELOC_AVR_HI8_LDI, + +/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit +of program memory address) into 8 bit immediate value of LDI insn. */ + BFD_RELOC_AVR_HH8_LDI, + +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value +(usually data memory address) into 8 bit immediate value of SUBI insn. */ + BFD_RELOC_AVR_LO8_LDI_NEG, + +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value +(high 8 bit of data memory address) into 8 bit immediate value of +SUBI insn. */ + BFD_RELOC_AVR_HI8_LDI_NEG, + +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value +(most high 8 bit of program memory address) into 8 bit immediate value +of LDI or SUBI insn. */ + BFD_RELOC_AVR_HH8_LDI_NEG, + +/* This is a 16 bit reloc for the AVR that stores 8 bit value (usually +command address) into 8 bit immediate value of LDI insn. */ + BFD_RELOC_AVR_LO8_LDI_PM, + +/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit +of command address) into 8 bit immediate value of LDI insn. */ + BFD_RELOC_AVR_HI8_LDI_PM, + +/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit +of command address) into 8 bit immediate value of LDI insn. */ + BFD_RELOC_AVR_HH8_LDI_PM, + +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value +(usually command address) into 8 bit immediate value of SUBI insn. */ + BFD_RELOC_AVR_LO8_LDI_PM_NEG, + +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value +(high 8 bit of 16 bit command address) into 8 bit immediate value +of SUBI insn. */ + BFD_RELOC_AVR_HI8_LDI_PM_NEG, + +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value +(high 6 bit of 22 bit command address) into 8 bit immediate +value of SUBI insn. */ + BFD_RELOC_AVR_HH8_LDI_PM_NEG, + +/* This is a 32 bit reloc for the AVR that stores 23 bit value +into 22 bits. */ + BFD_RELOC_AVR_CALL, + +/* This is a 16 bit reloc for the AVR that stores all needed bits +for absolute addressing with ldi with overflow check to linktime */ + BFD_RELOC_AVR_LDI, + +/* This is a 6 bit reloc for the AVR that stores offset for ldd/std +instructions */ + BFD_RELOC_AVR_6, + +/* This is a 6 bit reloc for the AVR that stores offset for adiw/sbiw +instructions */ + BFD_RELOC_AVR_6_ADIW, + +/* Direct 12 bit. */ + BFD_RELOC_390_12, + +/* 12 bit GOT offset. */ + BFD_RELOC_390_GOT12, + +/* 32 bit PC relative PLT address. */ + BFD_RELOC_390_PLT32, + +/* Copy symbol at runtime. */ + BFD_RELOC_390_COPY, + +/* Create GOT entry. */ + BFD_RELOC_390_GLOB_DAT, + +/* Create PLT entry. */ + BFD_RELOC_390_JMP_SLOT, + +/* Adjust by program base. */ + BFD_RELOC_390_RELATIVE, + +/* 32 bit PC relative offset to GOT. */ + BFD_RELOC_390_GOTPC, + +/* 16 bit GOT offset. */ + BFD_RELOC_390_GOT16, + +/* PC relative 16 bit shifted by 1. */ + BFD_RELOC_390_PC16DBL, + +/* 16 bit PC rel. PLT shifted by 1. */ + BFD_RELOC_390_PLT16DBL, + +/* PC relative 32 bit shifted by 1. */ + BFD_RELOC_390_PC32DBL, + +/* 32 bit PC rel. PLT shifted by 1. */ + BFD_RELOC_390_PLT32DBL, + +/* 32 bit PC rel. GOT shifted by 1. */ + BFD_RELOC_390_GOTPCDBL, + +/* 64 bit GOT offset. */ + BFD_RELOC_390_GOT64, + +/* 64 bit PC relative PLT address. */ + BFD_RELOC_390_PLT64, + +/* 32 bit rel. offset to GOT entry. */ + BFD_RELOC_390_GOTENT, + +/* 64 bit offset to GOT. */ + BFD_RELOC_390_GOTOFF64, + +/* 12-bit offset to symbol-entry within GOT, with PLT handling. */ + BFD_RELOC_390_GOTPLT12, + +/* 16-bit offset to symbol-entry within GOT, with PLT handling. */ + BFD_RELOC_390_GOTPLT16, + +/* 32-bit offset to symbol-entry within GOT, with PLT handling. */ + BFD_RELOC_390_GOTPLT32, + +/* 64-bit offset to symbol-entry within GOT, with PLT handling. */ + BFD_RELOC_390_GOTPLT64, + +/* 32-bit rel. offset to symbol-entry within GOT, with PLT handling. */ + BFD_RELOC_390_GOTPLTENT, + +/* 16-bit rel. offset from the GOT to a PLT entry. */ + BFD_RELOC_390_PLTOFF16, + +/* 32-bit rel. offset from the GOT to a PLT entry. */ + BFD_RELOC_390_PLTOFF32, + +/* 64-bit rel. offset from the GOT to a PLT entry. */ + BFD_RELOC_390_PLTOFF64, + +/* s390 tls relocations. */ + BFD_RELOC_390_TLS_LOAD, + BFD_RELOC_390_TLS_GDCALL, + BFD_RELOC_390_TLS_LDCALL, + BFD_RELOC_390_TLS_GD32, + BFD_RELOC_390_TLS_GD64, + BFD_RELOC_390_TLS_GOTIE12, + BFD_RELOC_390_TLS_GOTIE32, + BFD_RELOC_390_TLS_GOTIE64, + BFD_RELOC_390_TLS_LDM32, + BFD_RELOC_390_TLS_LDM64, + BFD_RELOC_390_TLS_IE32, + BFD_RELOC_390_TLS_IE64, + BFD_RELOC_390_TLS_IEENT, + BFD_RELOC_390_TLS_LE32, + BFD_RELOC_390_TLS_LE64, + BFD_RELOC_390_TLS_LDO32, + BFD_RELOC_390_TLS_LDO64, + BFD_RELOC_390_TLS_DTPMOD, + BFD_RELOC_390_TLS_DTPOFF, + BFD_RELOC_390_TLS_TPOFF, + +/* Long displacement extension. */ + BFD_RELOC_390_20, + BFD_RELOC_390_GOT20, + BFD_RELOC_390_GOTPLT20, + BFD_RELOC_390_TLS_GOTIE20, + +/* Scenix IP2K - 9-bit register number / data address */ + BFD_RELOC_IP2K_FR9, + +/* Scenix IP2K - 4-bit register/data bank number */ + BFD_RELOC_IP2K_BANK, + +/* Scenix IP2K - low 13 bits of instruction word address */ + BFD_RELOC_IP2K_ADDR16CJP, + +/* Scenix IP2K - high 3 bits of instruction word address */ + BFD_RELOC_IP2K_PAGE3, + +/* Scenix IP2K - ext/low/high 8 bits of data address */ + BFD_RELOC_IP2K_LO8DATA, + BFD_RELOC_IP2K_HI8DATA, + BFD_RELOC_IP2K_EX8DATA, + +/* Scenix IP2K - low/high 8 bits of instruction word address */ + BFD_RELOC_IP2K_LO8INSN, + BFD_RELOC_IP2K_HI8INSN, + +/* Scenix IP2K - even/odd PC modifier to modify snb pcl.0 */ + BFD_RELOC_IP2K_PC_SKIP, + +/* Scenix IP2K - 16 bit word address in text section. */ + BFD_RELOC_IP2K_TEXT, + +/* Scenix IP2K - 7-bit sp or dp offset */ + BFD_RELOC_IP2K_FR_OFFSET, + +/* Scenix VPE4K coprocessor - data/insn-space addressing */ + BFD_RELOC_VPE4KMATH_DATA, + BFD_RELOC_VPE4KMATH_INSN, + +/* These two relocations are used by the linker to determine which of +the entries in a C++ virtual function table are actually used. When +the --gc-sections option is given, the linker will zero out the entries +that are not used, so that the code for those functions need not be +included in the output. + +VTABLE_INHERIT is a zero-space relocation used to describe to the +linker the inheritance tree of a C++ virtual function table. The +relocation's symbol should be the parent class' vtable, and the +relocation should be located at the child vtable. + +VTABLE_ENTRY is a zero-space relocation that describes the use of a +virtual function table entry. The reloc's symbol should refer to the +table of the class mentioned in the code. Off of that base, an offset +describes the entry that is being used. For Rela hosts, this offset +is stored in the reloc's addend. For Rel hosts, we are forced to put +this offset in the reloc's section offset. */ + BFD_RELOC_VTABLE_INHERIT, + BFD_RELOC_VTABLE_ENTRY, + +/* Intel IA64 Relocations. */ + BFD_RELOC_IA64_IMM14, + BFD_RELOC_IA64_IMM22, + BFD_RELOC_IA64_IMM64, + BFD_RELOC_IA64_DIR32MSB, + BFD_RELOC_IA64_DIR32LSB, + BFD_RELOC_IA64_DIR64MSB, + BFD_RELOC_IA64_DIR64LSB, + BFD_RELOC_IA64_GPREL22, + BFD_RELOC_IA64_GPREL64I, + BFD_RELOC_IA64_GPREL32MSB, + BFD_RELOC_IA64_GPREL32LSB, + BFD_RELOC_IA64_GPREL64MSB, + BFD_RELOC_IA64_GPREL64LSB, + BFD_RELOC_IA64_LTOFF22, + BFD_RELOC_IA64_LTOFF64I, + BFD_RELOC_IA64_PLTOFF22, + BFD_RELOC_IA64_PLTOFF64I, + BFD_RELOC_IA64_PLTOFF64MSB, + BFD_RELOC_IA64_PLTOFF64LSB, + BFD_RELOC_IA64_FPTR64I, + BFD_RELOC_IA64_FPTR32MSB, + BFD_RELOC_IA64_FPTR32LSB, + BFD_RELOC_IA64_FPTR64MSB, + BFD_RELOC_IA64_FPTR64LSB, + BFD_RELOC_IA64_PCREL21B, + BFD_RELOC_IA64_PCREL21BI, + BFD_RELOC_IA64_PCREL21M, + BFD_RELOC_IA64_PCREL21F, + BFD_RELOC_IA64_PCREL22, + BFD_RELOC_IA64_PCREL60B, + BFD_RELOC_IA64_PCREL64I, + BFD_RELOC_IA64_PCREL32MSB, + BFD_RELOC_IA64_PCREL32LSB, + BFD_RELOC_IA64_PCREL64MSB, + BFD_RELOC_IA64_PCREL64LSB, + BFD_RELOC_IA64_LTOFF_FPTR22, + BFD_RELOC_IA64_LTOFF_FPTR64I, + BFD_RELOC_IA64_LTOFF_FPTR32MSB, + BFD_RELOC_IA64_LTOFF_FPTR32LSB, + BFD_RELOC_IA64_LTOFF_FPTR64MSB, + BFD_RELOC_IA64_LTOFF_FPTR64LSB, + BFD_RELOC_IA64_SEGREL32MSB, + BFD_RELOC_IA64_SEGREL32LSB, + BFD_RELOC_IA64_SEGREL64MSB, + BFD_RELOC_IA64_SEGREL64LSB, + BFD_RELOC_IA64_SECREL32MSB, + BFD_RELOC_IA64_SECREL32LSB, + BFD_RELOC_IA64_SECREL64MSB, + BFD_RELOC_IA64_SECREL64LSB, + BFD_RELOC_IA64_REL32MSB, + BFD_RELOC_IA64_REL32LSB, + BFD_RELOC_IA64_REL64MSB, + BFD_RELOC_IA64_REL64LSB, + BFD_RELOC_IA64_LTV32MSB, + BFD_RELOC_IA64_LTV32LSB, + BFD_RELOC_IA64_LTV64MSB, + BFD_RELOC_IA64_LTV64LSB, + BFD_RELOC_IA64_IPLTMSB, + BFD_RELOC_IA64_IPLTLSB, + BFD_RELOC_IA64_COPY, + BFD_RELOC_IA64_LTOFF22X, + BFD_RELOC_IA64_LDXMOV, + BFD_RELOC_IA64_TPREL14, + BFD_RELOC_IA64_TPREL22, + BFD_RELOC_IA64_TPREL64I, + BFD_RELOC_IA64_TPREL64MSB, + BFD_RELOC_IA64_TPREL64LSB, + BFD_RELOC_IA64_LTOFF_TPREL22, + BFD_RELOC_IA64_DTPMOD64MSB, + BFD_RELOC_IA64_DTPMOD64LSB, + BFD_RELOC_IA64_LTOFF_DTPMOD22, + BFD_RELOC_IA64_DTPREL14, + BFD_RELOC_IA64_DTPREL22, + BFD_RELOC_IA64_DTPREL64I, + BFD_RELOC_IA64_DTPREL32MSB, + BFD_RELOC_IA64_DTPREL32LSB, + BFD_RELOC_IA64_DTPREL64MSB, + BFD_RELOC_IA64_DTPREL64LSB, + BFD_RELOC_IA64_LTOFF_DTPREL22, + +/* Motorola 68HC11 reloc. +This is the 8 bit high part of an absolute address. */ + BFD_RELOC_M68HC11_HI8, + +/* Motorola 68HC11 reloc. +This is the 8 bit low part of an absolute address. */ + BFD_RELOC_M68HC11_LO8, + +/* Motorola 68HC11 reloc. +This is the 3 bit of a value. */ + BFD_RELOC_M68HC11_3B, + +/* Motorola 68HC11 reloc. +This reloc marks the beginning of a jump/call instruction. +It is used for linker relaxation to correctly identify beginning +of instruction and change some branches to use PC-relative +addressing mode. */ + BFD_RELOC_M68HC11_RL_JUMP, + +/* Motorola 68HC11 reloc. +This reloc marks a group of several instructions that gcc generates +and for which the linker relaxation pass can modify and/or remove +some of them. */ + BFD_RELOC_M68HC11_RL_GROUP, + +/* Motorola 68HC11 reloc. +This is the 16-bit lower part of an address. It is used for 'call' +instruction to specify the symbol address without any special +transformation (due to memory bank window). */ + BFD_RELOC_M68HC11_LO16, + +/* Motorola 68HC11 reloc. +This is a 8-bit reloc that specifies the page number of an address. +It is used by 'call' instruction to specify the page number of +the symbol. */ + BFD_RELOC_M68HC11_PAGE, + +/* Motorola 68HC11 reloc. +This is a 24-bit reloc that represents the address with a 16-bit +value and a 8-bit page number. The symbol address is transformed +to follow the 16K memory bank of 68HC12 (seen as mapped in the window). */ + BFD_RELOC_M68HC11_24, + +/* Motorola 68HC12 reloc. +This is the 5 bits of a value. */ + BFD_RELOC_M68HC12_5B, + +/* NS CR16C Relocations. */ + BFD_RELOC_16C_NUM08, + BFD_RELOC_16C_NUM08_C, + BFD_RELOC_16C_NUM16, + BFD_RELOC_16C_NUM16_C, + BFD_RELOC_16C_NUM32, + BFD_RELOC_16C_NUM32_C, + BFD_RELOC_16C_DISP04, + BFD_RELOC_16C_DISP04_C, + BFD_RELOC_16C_DISP08, + BFD_RELOC_16C_DISP08_C, + BFD_RELOC_16C_DISP16, + BFD_RELOC_16C_DISP16_C, + BFD_RELOC_16C_DISP24, + BFD_RELOC_16C_DISP24_C, + BFD_RELOC_16C_DISP24a, + BFD_RELOC_16C_DISP24a_C, + BFD_RELOC_16C_REG04, + BFD_RELOC_16C_REG04_C, + BFD_RELOC_16C_REG04a, + BFD_RELOC_16C_REG04a_C, + BFD_RELOC_16C_REG14, + BFD_RELOC_16C_REG14_C, + BFD_RELOC_16C_REG16, + BFD_RELOC_16C_REG16_C, + BFD_RELOC_16C_REG20, + BFD_RELOC_16C_REG20_C, + BFD_RELOC_16C_ABS20, + BFD_RELOC_16C_ABS20_C, + BFD_RELOC_16C_ABS24, + BFD_RELOC_16C_ABS24_C, + BFD_RELOC_16C_IMM04, + BFD_RELOC_16C_IMM04_C, + BFD_RELOC_16C_IMM16, + BFD_RELOC_16C_IMM16_C, + BFD_RELOC_16C_IMM20, + BFD_RELOC_16C_IMM20_C, + BFD_RELOC_16C_IMM24, + BFD_RELOC_16C_IMM24_C, + BFD_RELOC_16C_IMM32, + BFD_RELOC_16C_IMM32_C, + +/* NS CRX Relocations. */ + BFD_RELOC_CRX_REL4, + BFD_RELOC_CRX_REL8, + BFD_RELOC_CRX_REL8_CMP, + BFD_RELOC_CRX_REL16, + BFD_RELOC_CRX_REL24, + BFD_RELOC_CRX_REL32, + BFD_RELOC_CRX_REGREL12, + BFD_RELOC_CRX_REGREL22, + BFD_RELOC_CRX_REGREL28, + BFD_RELOC_CRX_REGREL32, + BFD_RELOC_CRX_ABS16, + BFD_RELOC_CRX_ABS32, + BFD_RELOC_CRX_NUM8, + BFD_RELOC_CRX_NUM16, + BFD_RELOC_CRX_NUM32, + BFD_RELOC_CRX_IMM16, + BFD_RELOC_CRX_IMM32, + BFD_RELOC_CRX_SWITCH8, + BFD_RELOC_CRX_SWITCH16, + BFD_RELOC_CRX_SWITCH32, + +/* These relocs are only used within the CRIS assembler. They are not +(at present) written to any object files. */ + BFD_RELOC_CRIS_BDISP8, + BFD_RELOC_CRIS_UNSIGNED_5, + BFD_RELOC_CRIS_SIGNED_6, + BFD_RELOC_CRIS_UNSIGNED_6, + BFD_RELOC_CRIS_SIGNED_8, + BFD_RELOC_CRIS_UNSIGNED_8, + BFD_RELOC_CRIS_SIGNED_16, + BFD_RELOC_CRIS_UNSIGNED_16, + BFD_RELOC_CRIS_LAPCQ_OFFSET, + BFD_RELOC_CRIS_UNSIGNED_4, + +/* Relocs used in ELF shared libraries for CRIS. */ + BFD_RELOC_CRIS_COPY, + BFD_RELOC_CRIS_GLOB_DAT, + BFD_RELOC_CRIS_JUMP_SLOT, + BFD_RELOC_CRIS_RELATIVE, + +/* 32-bit offset to symbol-entry within GOT. */ + BFD_RELOC_CRIS_32_GOT, + +/* 16-bit offset to symbol-entry within GOT. */ + BFD_RELOC_CRIS_16_GOT, + +/* 32-bit offset to symbol-entry within GOT, with PLT handling. */ + BFD_RELOC_CRIS_32_GOTPLT, + +/* 16-bit offset to symbol-entry within GOT, with PLT handling. */ + BFD_RELOC_CRIS_16_GOTPLT, + +/* 32-bit offset to symbol, relative to GOT. */ + BFD_RELOC_CRIS_32_GOTREL, + +/* 32-bit offset to symbol with PLT entry, relative to GOT. */ + BFD_RELOC_CRIS_32_PLT_GOTREL, + +/* 32-bit offset to symbol with PLT entry, relative to this relocation. */ + BFD_RELOC_CRIS_32_PLT_PCREL, + +/* Intel i860 Relocations. */ + BFD_RELOC_860_COPY, + BFD_RELOC_860_GLOB_DAT, + BFD_RELOC_860_JUMP_SLOT, + BFD_RELOC_860_RELATIVE, + BFD_RELOC_860_PC26, + BFD_RELOC_860_PLT26, + BFD_RELOC_860_PC16, + BFD_RELOC_860_LOW0, + BFD_RELOC_860_SPLIT0, + BFD_RELOC_860_LOW1, + BFD_RELOC_860_SPLIT1, + BFD_RELOC_860_LOW2, + BFD_RELOC_860_SPLIT2, + BFD_RELOC_860_LOW3, + BFD_RELOC_860_LOGOT0, + BFD_RELOC_860_SPGOT0, + BFD_RELOC_860_LOGOT1, + BFD_RELOC_860_SPGOT1, + BFD_RELOC_860_LOGOTOFF0, + BFD_RELOC_860_SPGOTOFF0, + BFD_RELOC_860_LOGOTOFF1, + BFD_RELOC_860_SPGOTOFF1, + BFD_RELOC_860_LOGOTOFF2, + BFD_RELOC_860_LOGOTOFF3, + BFD_RELOC_860_LOPC, + BFD_RELOC_860_HIGHADJ, + BFD_RELOC_860_HAGOT, + BFD_RELOC_860_HAGOTOFF, + BFD_RELOC_860_HAPC, + BFD_RELOC_860_HIGH, + BFD_RELOC_860_HIGOT, + BFD_RELOC_860_HIGOTOFF, + +/* OpenRISC Relocations. */ + BFD_RELOC_OPENRISC_ABS_26, + BFD_RELOC_OPENRISC_REL_26, + +/* H8 elf Relocations. */ + BFD_RELOC_H8_DIR16A8, + BFD_RELOC_H8_DIR16R8, + BFD_RELOC_H8_DIR24A8, + BFD_RELOC_H8_DIR24R8, + BFD_RELOC_H8_DIR32A16, + +/* Sony Xstormy16 Relocations. */ + BFD_RELOC_XSTORMY16_REL_12, + BFD_RELOC_XSTORMY16_12, + BFD_RELOC_XSTORMY16_24, + BFD_RELOC_XSTORMY16_FPTR16, + +/* Relocations used by VAX ELF. */ + BFD_RELOC_VAX_GLOB_DAT, + BFD_RELOC_VAX_JMP_SLOT, + BFD_RELOC_VAX_RELATIVE, + +/* Morpho MS1 - 16 bit immediate relocation. */ + BFD_RELOC_MS1_PC16, + +/* Morpho MS1 - Hi 16 bits of an address. */ + BFD_RELOC_MS1_HI16, + +/* Morpho MS1 - Low 16 bits of an address. */ + BFD_RELOC_MS1_LO16, + +/* Morpho MS1 - Used to tell the linker which vtable entries are used. */ + BFD_RELOC_MS1_GNU_VTINHERIT, + +/* Morpho MS1 - Used to tell the linker which vtable entries are used. */ + BFD_RELOC_MS1_GNU_VTENTRY, + +/* msp430 specific relocation codes */ + BFD_RELOC_MSP430_10_PCREL, + BFD_RELOC_MSP430_16_PCREL, + BFD_RELOC_MSP430_16, + BFD_RELOC_MSP430_16_PCREL_BYTE, + BFD_RELOC_MSP430_16_BYTE, + BFD_RELOC_MSP430_2X_PCREL, + BFD_RELOC_MSP430_RL_PCREL, + +/* IQ2000 Relocations. */ + BFD_RELOC_IQ2000_OFFSET_16, + BFD_RELOC_IQ2000_OFFSET_21, + BFD_RELOC_IQ2000_UHI16, + +/* Special Xtensa relocation used only by PLT entries in ELF shared +objects to indicate that the runtime linker should set the value +to one of its own internal functions or data structures. */ + BFD_RELOC_XTENSA_RTLD, + +/* Xtensa relocations for ELF shared objects. */ + BFD_RELOC_XTENSA_GLOB_DAT, + BFD_RELOC_XTENSA_JMP_SLOT, + BFD_RELOC_XTENSA_RELATIVE, + +/* Xtensa relocation used in ELF object files for symbols that may require +PLT entries. Otherwise, this is just a generic 32-bit relocation. */ + BFD_RELOC_XTENSA_PLT, + +/* Xtensa relocations to mark the difference of two local symbols. +These are only needed to support linker relaxation and can be ignored +when not relaxing. The field is set to the value of the difference +assuming no relaxation. The relocation encodes the position of the +first symbol so the linker can determine whether to adjust the field +value. */ + BFD_RELOC_XTENSA_DIFF8, + BFD_RELOC_XTENSA_DIFF16, + BFD_RELOC_XTENSA_DIFF32, + +/* Generic Xtensa relocations for instruction operands. Only the slot +number is encoded in the relocation. The relocation applies to the +last PC-relative immediate operand, or if there are no PC-relative +immediates, to the last immediate operand. */ + BFD_RELOC_XTENSA_SLOT0_OP, + BFD_RELOC_XTENSA_SLOT1_OP, + BFD_RELOC_XTENSA_SLOT2_OP, + BFD_RELOC_XTENSA_SLOT3_OP, + BFD_RELOC_XTENSA_SLOT4_OP, + BFD_RELOC_XTENSA_SLOT5_OP, + BFD_RELOC_XTENSA_SLOT6_OP, + BFD_RELOC_XTENSA_SLOT7_OP, + BFD_RELOC_XTENSA_SLOT8_OP, + BFD_RELOC_XTENSA_SLOT9_OP, + BFD_RELOC_XTENSA_SLOT10_OP, + BFD_RELOC_XTENSA_SLOT11_OP, + BFD_RELOC_XTENSA_SLOT12_OP, + BFD_RELOC_XTENSA_SLOT13_OP, + BFD_RELOC_XTENSA_SLOT14_OP, + +/* Alternate Xtensa relocations. Only the slot is encoded in the +relocation. The meaning of these relocations is opcode-specific. */ + BFD_RELOC_XTENSA_SLOT0_ALT, + BFD_RELOC_XTENSA_SLOT1_ALT, + BFD_RELOC_XTENSA_SLOT2_ALT, + BFD_RELOC_XTENSA_SLOT3_ALT, + BFD_RELOC_XTENSA_SLOT4_ALT, + BFD_RELOC_XTENSA_SLOT5_ALT, + BFD_RELOC_XTENSA_SLOT6_ALT, + BFD_RELOC_XTENSA_SLOT7_ALT, + BFD_RELOC_XTENSA_SLOT8_ALT, + BFD_RELOC_XTENSA_SLOT9_ALT, + BFD_RELOC_XTENSA_SLOT10_ALT, + BFD_RELOC_XTENSA_SLOT11_ALT, + BFD_RELOC_XTENSA_SLOT12_ALT, + BFD_RELOC_XTENSA_SLOT13_ALT, + BFD_RELOC_XTENSA_SLOT14_ALT, + +/* Xtensa relocations for backward compatibility. These have all been +replaced by BFD_RELOC_XTENSA_SLOT0_OP. */ + BFD_RELOC_XTENSA_OP0, + BFD_RELOC_XTENSA_OP1, + BFD_RELOC_XTENSA_OP2, + +/* Xtensa relocation to mark that the assembler expanded the +instructions from an original target. The expansion size is +encoded in the reloc size. */ + BFD_RELOC_XTENSA_ASM_EXPAND, + +/* Xtensa relocation to mark that the linker should simplify +assembler-expanded instructions. This is commonly used +internally by the linker after analysis of a +BFD_RELOC_XTENSA_ASM_EXPAND. */ + BFD_RELOC_XTENSA_ASM_SIMPLIFY, + BFD_RELOC_UNUSED }; +typedef enum bfd_reloc_code_real bfd_reloc_code_real_type; +reloc_howto_type *bfd_reloc_type_lookup + (bfd *abfd, bfd_reloc_code_real_type code); + +const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code); + +/* Extracted from syms.c. */ + +typedef struct bfd_symbol +{ + /* A pointer to the BFD which owns the symbol. This information + is necessary so that a back end can work out what additional + information (invisible to the application writer) is carried + with the symbol. + + This field is *almost* redundant, since you can use section->owner + instead, except that some symbols point to the global sections + bfd_{abs,com,und}_section. This could be fixed by making + these globals be per-bfd (or per-target-flavor). FIXME. */ + struct bfd *the_bfd; /* Use bfd_asymbol_bfd(sym) to access this field. */ + + /* The text of the symbol. The name is left alone, and not copied; the + application may not alter it. */ + const char *name; + + /* The value of the symbol. This really should be a union of a + numeric value with a pointer, since some flags indicate that + a pointer to another symbol is stored here. */ + symvalue value; + + /* Attributes of a symbol. */ +#define BSF_NO_FLAGS 0x00 + + /* The symbol has local scope; <> in <>. The value + is the offset into the section of the data. */ +#define BSF_LOCAL 0x01 + + /* The symbol has global scope; initialized data in <>. The + value is the offset into the section of the data. */ +#define BSF_GLOBAL 0x02 + + /* The symbol has global scope and is exported. The value is + the offset into the section of the data. */ +#define BSF_EXPORT BSF_GLOBAL /* No real difference. */ + + /* A normal C symbol would be one of: + <>, <>, <> or + <>. */ + + /* The symbol is a debugging record. The value has an arbitrary + meaning, unless BSF_DEBUGGING_RELOC is also set. */ +#define BSF_DEBUGGING 0x08 + + /* The symbol denotes a function entry point. Used in ELF, + perhaps others someday. */ +#define BSF_FUNCTION 0x10 + + /* Used by the linker. */ +#define BSF_KEEP 0x20 +#define BSF_KEEP_G 0x40 + + /* A weak global symbol, overridable without warnings by + a regular global symbol of the same name. */ +#define BSF_WEAK 0x80 + + /* This symbol was created to point to a section, e.g. ELF's + STT_SECTION symbols. */ +#define BSF_SECTION_SYM 0x100 + + /* The symbol used to be a common symbol, but now it is + allocated. */ +#define BSF_OLD_COMMON 0x200 + + /* The default value for common data. */ +#define BFD_FORT_COMM_DEFAULT_VALUE 0 + + /* In some files the type of a symbol sometimes alters its + location in an output file - ie in coff a <> symbol + which is also <> symbol appears where it was + declared and not at the end of a section. This bit is set + by the target BFD part to convey this information. */ +#define BSF_NOT_AT_END 0x400 + + /* Signal that the symbol is the label of constructor section. */ +#define BSF_CONSTRUCTOR 0x800 + + /* Signal that the symbol is a warning symbol. The name is a + warning. The name of the next symbol is the one to warn about; + if a reference is made to a symbol with the same name as the next + symbol, a warning is issued by the linker. */ +#define BSF_WARNING 0x1000 + + /* Signal that the symbol is indirect. This symbol is an indirect + pointer to the symbol with the same name as the next symbol. */ +#define BSF_INDIRECT 0x2000 + + /* BSF_FILE marks symbols that contain a file name. This is used + for ELF STT_FILE symbols. */ +#define BSF_FILE 0x4000 + + /* Symbol is from dynamic linking information. */ +#define BSF_DYNAMIC 0x8000 + + /* The symbol denotes a data object. Used in ELF, and perhaps + others someday. */ +#define BSF_OBJECT 0x10000 + + /* This symbol is a debugging symbol. The value is the offset + into the section of the data. BSF_DEBUGGING should be set + as well. */ +#define BSF_DEBUGGING_RELOC 0x20000 + + /* This symbol is thread local. Used in ELF. */ +#define BSF_THREAD_LOCAL 0x40000 + + flagword flags; + + /* A pointer to the section to which this symbol is + relative. This will always be non NULL, there are special + sections for undefined and absolute symbols. */ + struct bfd_section *section; + + /* Back end special data. */ + union + { + void *p; + bfd_vma i; + } + udata; +} +asymbol; + +#define bfd_get_symtab_upper_bound(abfd) \ + BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd)) + +bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym); + +bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name); + +#define bfd_is_local_label_name(abfd, name) \ + BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name)) + +bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym); + +#define bfd_is_target_special_symbol(abfd, sym) \ + BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym)) + +#define bfd_canonicalize_symtab(abfd, location) \ + BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location)) + +bfd_boolean bfd_set_symtab + (bfd *abfd, asymbol **location, unsigned int count); + +void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol); + +#define bfd_make_empty_symbol(abfd) \ + BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) + +asymbol *_bfd_generic_make_empty_symbol (bfd *); + +#define bfd_make_debug_symbol(abfd,ptr,size) \ + BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size)) + +int bfd_decode_symclass (asymbol *symbol); + +bfd_boolean bfd_is_undefined_symclass (int symclass); + +void bfd_symbol_info (asymbol *symbol, symbol_info *ret); + +bfd_boolean bfd_copy_private_symbol_data + (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym); + +#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \ + BFD_SEND (obfd, _bfd_copy_private_symbol_data, \ + (ibfd, isymbol, obfd, osymbol)) + +/* Extracted from bfd.c. */ +struct bfd +{ + /* A unique identifier of the BFD */ + unsigned int id; + + /* The filename the application opened the BFD with. */ + const char *filename; + + /* A pointer to the target jump table. */ + const struct bfd_target *xvec; + + /* The IOSTREAM, and corresponding IO vector that provide access + to the file backing the BFD. */ + void *iostream; + const struct bfd_iovec *iovec; + + /* Is the file descriptor being cached? That is, can it be closed as + needed, and re-opened when accessed later? */ + bfd_boolean cacheable; + + /* Marks whether there was a default target specified when the + BFD was opened. This is used to select which matching algorithm + to use to choose the back end. */ + bfd_boolean target_defaulted; + + /* The caching routines use these to maintain a + least-recently-used list of BFDs. */ + struct bfd *lru_prev, *lru_next; + + /* When a file is closed by the caching routines, BFD retains + state information on the file here... */ + ufile_ptr where; + + /* ... and here: (``once'' means at least once). */ + bfd_boolean opened_once; + + /* Set if we have a locally maintained mtime value, rather than + getting it from the file each time. */ + bfd_boolean mtime_set; + + /* File modified time, if mtime_set is TRUE. */ + long mtime; + + /* Reserved for an unimplemented file locking extension. */ + int ifd; + + /* The format which belongs to the BFD. (object, core, etc.) */ + bfd_format format; + + /* The direction with which the BFD was opened. */ + enum bfd_direction + { + no_direction = 0, + read_direction = 1, + write_direction = 2, + both_direction = 3 + } + direction; + + /* Format_specific flags. */ + flagword flags; + + /* Currently my_archive is tested before adding origin to + anything. I believe that this can become always an add of + origin, with origin set to 0 for non archive files. */ + ufile_ptr origin; + + /* Remember when output has begun, to stop strange things + from happening. */ + bfd_boolean output_has_begun; + + /* A hash table for section names. */ + struct bfd_hash_table section_htab; + + /* Pointer to linked list of sections. */ + struct bfd_section *sections; + + /* The last section on the section list. */ + struct bfd_section *section_last; + + /* The number of sections. */ + unsigned int section_count; + + /* Stuff only useful for object files: + The start address. */ + bfd_vma start_address; + + /* Used for input and output. */ + unsigned int symcount; + + /* Symbol table for output BFD (with symcount entries). */ + struct bfd_symbol **outsymbols; + + /* Used for slurped dynamic symbol tables. */ + unsigned int dynsymcount; + + /* Pointer to structure which contains architecture information. */ + const struct bfd_arch_info *arch_info; + + /* Flag set if symbols from this BFD should not be exported. */ + bfd_boolean no_export; + + /* Stuff only useful for archives. */ + void *arelt_data; + struct bfd *my_archive; /* The containing archive BFD. */ + struct bfd *next; /* The next BFD in the archive. */ + struct bfd *archive_head; /* The first BFD in the archive. */ + bfd_boolean has_armap; + + /* A chain of BFD structures involved in a link. */ + struct bfd *link_next; + + /* A field used by _bfd_generic_link_add_archive_symbols. This will + be used only for archive elements. */ + int archive_pass; + + /* Used by the back end to hold private data. */ + union + { + struct aout_data_struct *aout_data; + struct artdata *aout_ar_data; + struct _oasys_data *oasys_obj_data; + struct _oasys_ar_data *oasys_ar_data; + struct coff_tdata *coff_obj_data; + struct pe_tdata *pe_obj_data; + struct xcoff_tdata *xcoff_obj_data; + struct ecoff_tdata *ecoff_obj_data; + struct ieee_data_struct *ieee_data; + struct ieee_ar_data_struct *ieee_ar_data; + struct srec_data_struct *srec_data; + struct ihex_data_struct *ihex_data; + struct tekhex_data_struct *tekhex_data; + struct elf_obj_tdata *elf_obj_data; + struct nlm_obj_tdata *nlm_obj_data; + struct bout_data_struct *bout_data; + struct mmo_data_struct *mmo_data; + struct sun_core_struct *sun_core_data; + struct sco5_core_struct *sco5_core_data; + struct trad_core_struct *trad_core_data; + struct som_data_struct *som_data; + struct hpux_core_struct *hpux_core_data; + struct hppabsd_core_struct *hppabsd_core_data; + struct sgi_core_struct *sgi_core_data; + struct lynx_core_struct *lynx_core_data; + struct osf_core_struct *osf_core_data; + struct cisco_core_struct *cisco_core_data; + struct versados_data_struct *versados_data; + struct netbsd_core_struct *netbsd_core_data; + struct mach_o_data_struct *mach_o_data; + struct mach_o_fat_data_struct *mach_o_fat_data; + struct bfd_pef_data_struct *pef_data; + struct bfd_pef_xlib_data_struct *pef_xlib_data; + struct bfd_sym_data_struct *sym_data; + void *any; + } + tdata; + + /* Used by the application to hold private data. */ + void *usrdata; + + /* Where all the allocated stuff under this BFD goes. This is a + struct objalloc *, but we use void * to avoid requiring the inclusion + of objalloc.h. */ + void *memory; +}; + +typedef enum bfd_error +{ + bfd_error_no_error = 0, + bfd_error_system_call, + bfd_error_invalid_target, + bfd_error_wrong_format, + bfd_error_wrong_object_format, + bfd_error_invalid_operation, + bfd_error_no_memory, + bfd_error_no_symbols, + bfd_error_no_armap, + bfd_error_no_more_archived_files, + bfd_error_malformed_archive, + bfd_error_file_not_recognized, + bfd_error_file_ambiguously_recognized, + bfd_error_no_contents, + bfd_error_nonrepresentable_section, + bfd_error_no_debug_section, + bfd_error_bad_value, + bfd_error_file_truncated, + bfd_error_file_too_big, + bfd_error_invalid_error_code +} +bfd_error_type; + +bfd_error_type bfd_get_error (void); + +void bfd_set_error (bfd_error_type error_tag); + +const char *bfd_errmsg (bfd_error_type error_tag); + +void bfd_perror (const char *message); + +typedef void (*bfd_error_handler_type) (const char *, ...); + +bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type); + +void bfd_set_error_program_name (const char *); + +bfd_error_handler_type bfd_get_error_handler (void); + +long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect); + +long bfd_canonicalize_reloc + (bfd *abfd, asection *sec, arelent **loc, asymbol **syms); + +void bfd_set_reloc + (bfd *abfd, asection *sec, arelent **rel, unsigned int count); + +bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags); + +int bfd_get_arch_size (bfd *abfd); + +int bfd_get_sign_extend_vma (bfd *abfd); + +bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma); + +unsigned int bfd_get_gp_size (bfd *abfd); + +void bfd_set_gp_size (bfd *abfd, unsigned int i); + +bfd_vma bfd_scan_vma (const char *string, const char **end, int base); + +bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd); + +#define bfd_copy_private_header_data(ibfd, obfd) \ + BFD_SEND (obfd, _bfd_copy_private_header_data, \ + (ibfd, obfd)) +bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd); + +#define bfd_copy_private_bfd_data(ibfd, obfd) \ + BFD_SEND (obfd, _bfd_copy_private_bfd_data, \ + (ibfd, obfd)) +bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd); + +#define bfd_merge_private_bfd_data(ibfd, obfd) \ + BFD_SEND (obfd, _bfd_merge_private_bfd_data, \ + (ibfd, obfd)) +bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags); + +#define bfd_set_private_flags(abfd, flags) \ + BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags)) +#define bfd_sizeof_headers(abfd, reloc) \ + BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc)) + +#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \ + BFD_SEND (abfd, _bfd_find_nearest_line, \ + (abfd, sec, syms, off, file, func, line)) + +#define bfd_find_line(abfd, syms, sym, file, line) \ + BFD_SEND (abfd, _bfd_find_line, \ + (abfd, syms, sym, file, line)) + +#define bfd_find_inliner_info(abfd, file, func, line) \ + BFD_SEND (abfd, _bfd_find_inliner_info, \ + (abfd, file, func, line)) + +#define bfd_debug_info_start(abfd) \ + BFD_SEND (abfd, _bfd_debug_info_start, (abfd)) + +#define bfd_debug_info_end(abfd) \ + BFD_SEND (abfd, _bfd_debug_info_end, (abfd)) + +#define bfd_debug_info_accumulate(abfd, section) \ + BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section)) + +#define bfd_stat_arch_elt(abfd, stat) \ + BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) + +#define bfd_update_armap_timestamp(abfd) \ + BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd)) + +#define bfd_set_arch_mach(abfd, arch, mach)\ + BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach)) + +#define bfd_relax_section(abfd, section, link_info, again) \ + BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again)) + +#define bfd_gc_sections(abfd, link_info) \ + BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info)) + +#define bfd_merge_sections(abfd, link_info) \ + BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info)) + +#define bfd_is_group_section(abfd, sec) \ + BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec)) + +#define bfd_discard_group(abfd, sec) \ + BFD_SEND (abfd, _bfd_discard_group, (abfd, sec)) + +#define bfd_link_hash_table_create(abfd) \ + BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd)) + +#define bfd_link_hash_table_free(abfd, hash) \ + BFD_SEND (abfd, _bfd_link_hash_table_free, (hash)) + +#define bfd_link_add_symbols(abfd, info) \ + BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info)) + +#define bfd_link_just_syms(abfd, sec, info) \ + BFD_SEND (abfd, _bfd_link_just_syms, (sec, info)) + +#define bfd_final_link(abfd, info) \ + BFD_SEND (abfd, _bfd_final_link, (abfd, info)) + +#define bfd_free_cached_info(abfd) \ + BFD_SEND (abfd, _bfd_free_cached_info, (abfd)) + +#define bfd_get_dynamic_symtab_upper_bound(abfd) \ + BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd)) + +#define bfd_print_private_bfd_data(abfd, file)\ + BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file)) + +#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \ + BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols)) + +#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \ + BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \ + dyncount, dynsyms, ret)) + +#define bfd_get_dynamic_reloc_upper_bound(abfd) \ + BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd)) + +#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \ + BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms)) + +extern bfd_byte *bfd_get_relocated_section_contents + (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *, + bfd_boolean, asymbol **); + +bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative); + +struct bfd_preserve +{ + void *marker; + void *tdata; + flagword flags; + const struct bfd_arch_info *arch_info; + struct bfd_section *sections; + struct bfd_section *section_last; + unsigned int section_count; + struct bfd_hash_table section_htab; +}; + +bfd_boolean bfd_preserve_save (bfd *, struct bfd_preserve *); + +void bfd_preserve_restore (bfd *, struct bfd_preserve *); + +void bfd_preserve_finish (bfd *, struct bfd_preserve *); + +/* Extracted from archive.c. */ +symindex bfd_get_next_mapent + (bfd *abfd, symindex previous, carsym **sym); + +bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head); + +bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous); + +/* Extracted from corefile.c. */ +const char *bfd_core_file_failing_command (bfd *abfd); + +int bfd_core_file_failing_signal (bfd *abfd); + +bfd_boolean core_file_matches_executable_p + (bfd *core_bfd, bfd *exec_bfd); + +/* Extracted from targets.c. */ +#define BFD_SEND(bfd, message, arglist) \ + ((*((bfd)->xvec->message)) arglist) + +#ifdef DEBUG_BFD_SEND +#undef BFD_SEND +#define BFD_SEND(bfd, message, arglist) \ + (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \ + ((*((bfd)->xvec->message)) arglist) : \ + (bfd_assert (__FILE__,__LINE__), NULL)) +#endif +#define BFD_SEND_FMT(bfd, message, arglist) \ + (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist) + +#ifdef DEBUG_BFD_SEND +#undef BFD_SEND_FMT +#define BFD_SEND_FMT(bfd, message, arglist) \ + (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \ + (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist) : \ + (bfd_assert (__FILE__,__LINE__), NULL)) +#endif + +enum bfd_flavour +{ + bfd_target_unknown_flavour, + bfd_target_aout_flavour, + bfd_target_coff_flavour, + bfd_target_ecoff_flavour, + bfd_target_xcoff_flavour, + bfd_target_elf_flavour, + bfd_target_ieee_flavour, + bfd_target_nlm_flavour, + bfd_target_oasys_flavour, + bfd_target_tekhex_flavour, + bfd_target_srec_flavour, + bfd_target_ihex_flavour, + bfd_target_som_flavour, + bfd_target_os9k_flavour, + bfd_target_versados_flavour, + bfd_target_msdos_flavour, + bfd_target_ovax_flavour, + bfd_target_evax_flavour, + bfd_target_mmo_flavour, + bfd_target_mach_o_flavour, + bfd_target_pef_flavour, + bfd_target_pef_xlib_flavour, + bfd_target_sym_flavour +}; + +enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN }; + +/* Forward declaration. */ +typedef struct bfd_link_info _bfd_link_info; + +typedef struct bfd_target +{ + /* Identifies the kind of target, e.g., SunOS4, Ultrix, etc. */ + char *name; + + /* The "flavour" of a back end is a general indication about + the contents of a file. */ + enum bfd_flavour flavour; + + /* The order of bytes within the data area of a file. */ + enum bfd_endian byteorder; + + /* The order of bytes within the header parts of a file. */ + enum bfd_endian header_byteorder; + + /* A mask of all the flags which an executable may have set - + from the set <>, <>, ...<>. */ + flagword object_flags; + + /* A mask of all the flags which a section may have set - from + the set <>, <>, ...<>. */ + flagword section_flags; + + /* The character normally found at the front of a symbol. + (if any), perhaps `_'. */ + char symbol_leading_char; + + /* The pad character for file names within an archive header. */ + char ar_pad_char; + + /* The maximum number of characters in an archive header. */ + unsigned short ar_max_namelen; + + /* Entries for byte swapping for data. These are different from the + other entry points, since they don't take a BFD as the first argument. + Certain other handlers could do the same. */ + bfd_uint64_t (*bfd_getx64) (const void *); + bfd_int64_t (*bfd_getx_signed_64) (const void *); + void (*bfd_putx64) (bfd_uint64_t, void *); + bfd_vma (*bfd_getx32) (const void *); + bfd_signed_vma (*bfd_getx_signed_32) (const void *); + void (*bfd_putx32) (bfd_vma, void *); + bfd_vma (*bfd_getx16) (const void *); + bfd_signed_vma (*bfd_getx_signed_16) (const void *); + void (*bfd_putx16) (bfd_vma, void *); + + /* Byte swapping for the headers. */ + bfd_uint64_t (*bfd_h_getx64) (const void *); + bfd_int64_t (*bfd_h_getx_signed_64) (const void *); + void (*bfd_h_putx64) (bfd_uint64_t, void *); + bfd_vma (*bfd_h_getx32) (const void *); + bfd_signed_vma (*bfd_h_getx_signed_32) (const void *); + void (*bfd_h_putx32) (bfd_vma, void *); + bfd_vma (*bfd_h_getx16) (const void *); + bfd_signed_vma (*bfd_h_getx_signed_16) (const void *); + void (*bfd_h_putx16) (bfd_vma, void *); + + /* Format dependent routines: these are vectors of entry points + within the target vector structure, one for each format to check. */ + + /* Check the format of a file being read. Return a <> or zero. */ + const struct bfd_target *(*_bfd_check_format[bfd_type_end]) (bfd *); + + /* Set the format of a file being written. */ + bfd_boolean (*_bfd_set_format[bfd_type_end]) (bfd *); + + /* Write cached information into a file being written, at <>. */ + bfd_boolean (*_bfd_write_contents[bfd_type_end]) (bfd *); + + + /* Generic entry points. */ +#define BFD_JUMP_TABLE_GENERIC(NAME) \ + NAME##_close_and_cleanup, \ + NAME##_bfd_free_cached_info, \ + NAME##_new_section_hook, \ + NAME##_get_section_contents, \ + NAME##_get_section_contents_in_window + + /* Called when the BFD is being closed to do any necessary cleanup. */ + bfd_boolean (*_close_and_cleanup) (bfd *); + /* Ask the BFD to free all cached information. */ + bfd_boolean (*_bfd_free_cached_info) (bfd *); + /* Called when a new section is created. */ + bfd_boolean (*_new_section_hook) (bfd *, sec_ptr); + /* Read the contents of a section. */ + bfd_boolean (*_bfd_get_section_contents) + (bfd *, sec_ptr, void *, file_ptr, bfd_size_type); + bfd_boolean (*_bfd_get_section_contents_in_window) + (bfd *, sec_ptr, bfd_window *, file_ptr, bfd_size_type); + + /* Entry points to copy private data. */ +#define BFD_JUMP_TABLE_COPY(NAME) \ + NAME##_bfd_copy_private_bfd_data, \ + NAME##_bfd_merge_private_bfd_data, \ + NAME##_bfd_copy_private_section_data, \ + NAME##_bfd_copy_private_symbol_data, \ + NAME##_bfd_copy_private_header_data, \ + NAME##_bfd_set_private_flags, \ + NAME##_bfd_print_private_bfd_data + + /* Called to copy BFD general private data from one object file + to another. */ + bfd_boolean (*_bfd_copy_private_bfd_data) (bfd *, bfd *); + /* Called to merge BFD general private data from one object file + to a common output file when linking. */ + bfd_boolean (*_bfd_merge_private_bfd_data) (bfd *, bfd *); + /* Called to copy BFD private section data from one object file + to another. */ + bfd_boolean (*_bfd_copy_private_section_data) + (bfd *, sec_ptr, bfd *, sec_ptr); + /* Called to copy BFD private symbol data from one symbol + to another. */ + bfd_boolean (*_bfd_copy_private_symbol_data) + (bfd *, asymbol *, bfd *, asymbol *); + /* Called to copy BFD private header data from one object file + to another. */ + bfd_boolean (*_bfd_copy_private_header_data) + (bfd *, bfd *); + /* Called to set private backend flags. */ + bfd_boolean (*_bfd_set_private_flags) (bfd *, flagword); + + /* Called to print private BFD data. */ + bfd_boolean (*_bfd_print_private_bfd_data) (bfd *, void *); + + /* Core file entry points. */ +#define BFD_JUMP_TABLE_CORE(NAME) \ + NAME##_core_file_failing_command, \ + NAME##_core_file_failing_signal, \ + NAME##_core_file_matches_executable_p + + char * (*_core_file_failing_command) (bfd *); + int (*_core_file_failing_signal) (bfd *); + bfd_boolean (*_core_file_matches_executable_p) (bfd *, bfd *); + + /* Archive entry points. */ +#define BFD_JUMP_TABLE_ARCHIVE(NAME) \ + NAME##_slurp_armap, \ + NAME##_slurp_extended_name_table, \ + NAME##_construct_extended_name_table, \ + NAME##_truncate_arname, \ + NAME##_write_armap, \ + NAME##_read_ar_hdr, \ + NAME##_openr_next_archived_file, \ + NAME##_get_elt_at_index, \ + NAME##_generic_stat_arch_elt, \ + NAME##_update_armap_timestamp + + bfd_boolean (*_bfd_slurp_armap) (bfd *); + bfd_boolean (*_bfd_slurp_extended_name_table) (bfd *); + bfd_boolean (*_bfd_construct_extended_name_table) + (bfd *, char **, bfd_size_type *, const char **); + void (*_bfd_truncate_arname) (bfd *, const char *, char *); + bfd_boolean (*write_armap) + (bfd *, unsigned int, struct orl *, unsigned int, int); + void * (*_bfd_read_ar_hdr_fn) (bfd *); + bfd * (*openr_next_archived_file) (bfd *, bfd *); +#define bfd_get_elt_at_index(b,i) BFD_SEND (b, _bfd_get_elt_at_index, (b,i)) + bfd * (*_bfd_get_elt_at_index) (bfd *, symindex); + int (*_bfd_stat_arch_elt) (bfd *, struct stat *); + bfd_boolean (*_bfd_update_armap_timestamp) (bfd *); + + /* Entry points used for symbols. */ +#define BFD_JUMP_TABLE_SYMBOLS(NAME) \ + NAME##_get_symtab_upper_bound, \ + NAME##_canonicalize_symtab, \ + NAME##_make_empty_symbol, \ + NAME##_print_symbol, \ + NAME##_get_symbol_info, \ + NAME##_bfd_is_local_label_name, \ + NAME##_bfd_is_target_special_symbol, \ + NAME##_get_lineno, \ + NAME##_find_nearest_line, \ + _bfd_generic_find_line, \ + NAME##_find_inliner_info, \ + NAME##_bfd_make_debug_symbol, \ + NAME##_read_minisymbols, \ + NAME##_minisymbol_to_symbol + + long (*_bfd_get_symtab_upper_bound) (bfd *); + long (*_bfd_canonicalize_symtab) + (bfd *, struct bfd_symbol **); + struct bfd_symbol * + (*_bfd_make_empty_symbol) (bfd *); + void (*_bfd_print_symbol) + (bfd *, void *, struct bfd_symbol *, bfd_print_symbol_type); +#define bfd_print_symbol(b,p,s,e) BFD_SEND (b, _bfd_print_symbol, (b,p,s,e)) + void (*_bfd_get_symbol_info) + (bfd *, struct bfd_symbol *, symbol_info *); +#define bfd_get_symbol_info(b,p,e) BFD_SEND (b, _bfd_get_symbol_info, (b,p,e)) + bfd_boolean (*_bfd_is_local_label_name) (bfd *, const char *); + bfd_boolean (*_bfd_is_target_special_symbol) (bfd *, asymbol *); + alent * (*_get_lineno) (bfd *, struct bfd_symbol *); + bfd_boolean (*_bfd_find_nearest_line) + (bfd *, struct bfd_section *, struct bfd_symbol **, bfd_vma, + const char **, const char **, unsigned int *); + bfd_boolean (*_bfd_find_line) + (bfd *, struct bfd_symbol **, struct bfd_symbol *, + const char **, unsigned int *); + bfd_boolean (*_bfd_find_inliner_info) + (bfd *, const char **, const char **, unsigned int *); + /* Back-door to allow format-aware applications to create debug symbols + while using BFD for everything else. Currently used by the assembler + when creating COFF files. */ + asymbol * (*_bfd_make_debug_symbol) + (bfd *, void *, unsigned long size); +#define bfd_read_minisymbols(b, d, m, s) \ + BFD_SEND (b, _read_minisymbols, (b, d, m, s)) + long (*_read_minisymbols) + (bfd *, bfd_boolean, void **, unsigned int *); +#define bfd_minisymbol_to_symbol(b, d, m, f) \ + BFD_SEND (b, _minisymbol_to_symbol, (b, d, m, f)) + asymbol * (*_minisymbol_to_symbol) + (bfd *, bfd_boolean, const void *, asymbol *); + + /* Routines for relocs. */ +#define BFD_JUMP_TABLE_RELOCS(NAME) \ + NAME##_get_reloc_upper_bound, \ + NAME##_canonicalize_reloc, \ + NAME##_bfd_reloc_type_lookup + + long (*_get_reloc_upper_bound) (bfd *, sec_ptr); + long (*_bfd_canonicalize_reloc) + (bfd *, sec_ptr, arelent **, struct bfd_symbol **); + /* See documentation on reloc types. */ + reloc_howto_type * + (*reloc_type_lookup) (bfd *, bfd_reloc_code_real_type); + + /* Routines used when writing an object file. */ +#define BFD_JUMP_TABLE_WRITE(NAME) \ + NAME##_set_arch_mach, \ + NAME##_set_section_contents + + bfd_boolean (*_bfd_set_arch_mach) + (bfd *, enum bfd_architecture, unsigned long); + bfd_boolean (*_bfd_set_section_contents) + (bfd *, sec_ptr, const void *, file_ptr, bfd_size_type); + + /* Routines used by the linker. */ +#define BFD_JUMP_TABLE_LINK(NAME) \ + NAME##_sizeof_headers, \ + NAME##_bfd_get_relocated_section_contents, \ + NAME##_bfd_relax_section, \ + NAME##_bfd_link_hash_table_create, \ + NAME##_bfd_link_hash_table_free, \ + NAME##_bfd_link_add_symbols, \ + NAME##_bfd_link_just_syms, \ + NAME##_bfd_final_link, \ + NAME##_bfd_link_split_section, \ + NAME##_bfd_gc_sections, \ + NAME##_bfd_merge_sections, \ + NAME##_bfd_is_group_section, \ + NAME##_bfd_discard_group, \ + NAME##_section_already_linked \ + + int (*_bfd_sizeof_headers) (bfd *, bfd_boolean); + bfd_byte * (*_bfd_get_relocated_section_contents) + (bfd *, struct bfd_link_info *, struct bfd_link_order *, + bfd_byte *, bfd_boolean, struct bfd_symbol **); + + bfd_boolean (*_bfd_relax_section) + (bfd *, struct bfd_section *, struct bfd_link_info *, bfd_boolean *); + + /* Create a hash table for the linker. Different backends store + different information in this table. */ + struct bfd_link_hash_table * + (*_bfd_link_hash_table_create) (bfd *); + + /* Release the memory associated with the linker hash table. */ + void (*_bfd_link_hash_table_free) (struct bfd_link_hash_table *); + + /* Add symbols from this object file into the hash table. */ + bfd_boolean (*_bfd_link_add_symbols) (bfd *, struct bfd_link_info *); + + /* Indicate that we are only retrieving symbol values from this section. */ + void (*_bfd_link_just_syms) (asection *, struct bfd_link_info *); + + /* Do a link based on the link_order structures attached to each + section of the BFD. */ + bfd_boolean (*_bfd_final_link) (bfd *, struct bfd_link_info *); + + /* Should this section be split up into smaller pieces during linking. */ + bfd_boolean (*_bfd_link_split_section) (bfd *, struct bfd_section *); + + /* Remove sections that are not referenced from the output. */ + bfd_boolean (*_bfd_gc_sections) (bfd *, struct bfd_link_info *); + + /* Attempt to merge SEC_MERGE sections. */ + bfd_boolean (*_bfd_merge_sections) (bfd *, struct bfd_link_info *); + + /* Is this section a member of a group? */ + bfd_boolean (*_bfd_is_group_section) (bfd *, const struct bfd_section *); + + /* Discard members of a group. */ + bfd_boolean (*_bfd_discard_group) (bfd *, struct bfd_section *); + + /* Check if SEC has been already linked during a reloceatable or + final link. */ + void (*_section_already_linked) (bfd *, struct bfd_section *); + + /* Routines to handle dynamic symbols and relocs. */ +#define BFD_JUMP_TABLE_DYNAMIC(NAME) \ + NAME##_get_dynamic_symtab_upper_bound, \ + NAME##_canonicalize_dynamic_symtab, \ + NAME##_get_synthetic_symtab, \ + NAME##_get_dynamic_reloc_upper_bound, \ + NAME##_canonicalize_dynamic_reloc + + /* Get the amount of memory required to hold the dynamic symbols. */ + long (*_bfd_get_dynamic_symtab_upper_bound) (bfd *); + /* Read in the dynamic symbols. */ + long (*_bfd_canonicalize_dynamic_symtab) + (bfd *, struct bfd_symbol **); + /* Create synthetized symbols. */ + long (*_bfd_get_synthetic_symtab) + (bfd *, long, struct bfd_symbol **, long, struct bfd_symbol **, + struct bfd_symbol **); + /* Get the amount of memory required to hold the dynamic relocs. */ + long (*_bfd_get_dynamic_reloc_upper_bound) (bfd *); + /* Read in the dynamic relocs. */ + long (*_bfd_canonicalize_dynamic_reloc) + (bfd *, arelent **, struct bfd_symbol **); + + /* Opposite endian version of this target. */ + const struct bfd_target * alternative_target; + + /* Data for use by back-end routines, which isn't + generic enough to belong in this structure. */ + const void *backend_data; + +} bfd_target; + +bfd_boolean bfd_set_default_target (const char *name); + +const bfd_target *bfd_find_target (const char *target_name, bfd *abfd); + +const char ** bfd_target_list (void); + +const bfd_target *bfd_search_for_target + (int (*search_func) (const bfd_target *, void *), + void *); + +/* Extracted from format.c. */ +bfd_boolean bfd_check_format (bfd *abfd, bfd_format format); + +bfd_boolean bfd_check_format_matches + (bfd *abfd, bfd_format format, char ***matching); + +bfd_boolean bfd_set_format (bfd *abfd, bfd_format format); + +const char *bfd_format_string (bfd_format format); + +/* Extracted from linker.c. */ +bfd_boolean bfd_link_split_section (bfd *abfd, asection *sec); + +#define bfd_link_split_section(abfd, sec) \ + BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec)) + +void bfd_section_already_linked (bfd *abfd, asection *sec); + +#define bfd_section_already_linked(abfd, sec) \ + BFD_SEND (abfd, _section_already_linked, (abfd, sec)) + +/* Extracted from simple.c. */ +bfd_byte *bfd_simple_get_relocated_section_contents + (bfd *abfd, asection *sec, bfd_byte *outbuf, asymbol **symbol_table); + +#ifdef __cplusplus +} +#endif +#endif diff -Naur linux-2.6.35.4/kernel/debug/mdb/bfd.h linux-2.6.35.4-cs/kernel/debug/mdb/bfd.h --- linux-2.6.35.4/kernel/debug/mdb/bfd.h 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/bfd.h 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,5 @@ +#ifdef CONFIG_X86_32 +# include "bfd_32.h" +#else +# include "bfd_64.h" +#endif diff -Naur linux-2.6.35.4/kernel/debug/mdb/Makefile linux-2.6.35.4-cs/kernel/debug/mdb/Makefile --- linux-2.6.35.4/kernel/debug/mdb/Makefile 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/Makefile 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,5 @@ +# + +obj-$(CONFIG_MDB) += mdb.o + +mdb-y := mdb-main.o mdb-base.o mdb-list.o mdb-logic.o mdb-os.o mdb-ia.o mdb-ia-support.o mdb-ia-apic.o diff -Naur linux-2.6.35.4/kernel/debug/mdb/mdb-base.c linux-2.6.35.4-cs/kernel/debug/mdb/mdb-base.c --- linux-2.6.35.4/kernel/debug/mdb/mdb-base.c 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/mdb-base.c 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,2881 @@ + +/*************************************************************************** +* +* Copyright (c) 2008 Jeff V. Merkey All Rights Reserved. +* jeffmerkey@gmail.com +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation, version 2. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You are free to modify and re-distribute this program in accordance +* with the terms specified in the GNU Public License. The copyright +* contained in this code is required to be present in any derivative +* works and you are required to provide the source code for this +* program as part of any commercial or non-commercial distribution. +* You are required to respect the rights of the Copyright holders +* named within this code. +* +* jeffmerkey@gmail.com is the official maintainer of +* this code. You are encouraged to report any bugs, problems, fixes, +* suggestions, and comments about this software. +* +* AUTHOR : Jeff V. Merkey +* DESCRIP : Merkey's Linux Debugger +* +***************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define __KERNEL_SYSCALLS__ +#include +#include + +#include "mdb.h" +#include "mdb-ia.h" +#include "mdb-list.h" +#include "mdb-ia-proc.h" +#include "mdb-base.h" +#include "mdb-proc.h" +#include "mdb-os.h" +#include "mdb-keyboard.h" + +unsigned long debug_deref; +unsigned long full_deref_toggle; +unsigned long control_toggle; +unsigned long numeric_toggle; +unsigned long user_toggle = 1; +unsigned long general_toggle = 1; +unsigned long line_info_toggle = 1; +unsigned long segment_toggle = 1; +unsigned long reason_toggle = 1; +unsigned long toggle_user_break = 1; + +unsigned long enterKeyACC(unsigned long key, void *stackFrame, + ACCELERATOR *accel) +{ + unsigned char *verbBuffer = &workbuf[0][0]; + register unsigned char *verb, *pp, *vp; + register unsigned long count; + + if (!debugCommand[0]) + { + count = 0; + pp = (unsigned char *)lastDebugCommand; + vp = verb = &verbBuffer[0]; + while (*pp && *pp == ' ' && count++ < 80) + pp++; + + while (*pp && *pp != ' ' && count++ < 80) + *vp++ = *pp++; + *vp = '\0'; + + while (*pp && *pp == ' ' && count++ < 80) + pp++; + + UpcaseString(verb); + if (!strcmp(verb, "P") || (lastCommand == K_F8)) + strcpy((char *)debugCommand, "P"); + else + if (!strcmp(verb, "T") || (lastCommand == K_F7)) + strcpy((char *)debugCommand, "T"); + else + if (!strcmp(verb, "W") || !strcmp(verb, "D") || + !strcmp(verb, "DB") || !strcmp(verb, "DW") || + !strcmp(verb, "DD") || !strcmp(verb, "DDS") || + !strcmp(verb, "DQ") || !strcmp(verb, "DQS") || + !strcmp(verb, "DS") || !strcmp(verb, "DL") || + !strcmp(verb, "U") || !strcmp(verb, "UU") || + !strcmp(verb, "S") || !strcmp(verb, "SS") || + !strcmp(verb, "SSB") || !strcmp(verb, "ID") || + !strcmp(verb, "UX")) { + strcpy((char *)debugCommand, verb); + repeatCommand = 1; + } + } + return 0; + +} + + +unsigned long displayDebuggerHelpHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("displays general help for all commands, or help for a specific command\n"); + DBGPrint("HELP - list all commands\n"); + DBGPrint("HELP command - help for a specific command\n"); + + return 1; +} + +unsigned long displayDebuggerHelp(unsigned char *commandLine, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + + register unsigned long count; + unsigned char *verbBuffer = &workbuf[0][0]; + register unsigned char *verb, *pp, *vp; + + commandLine = &commandLine[parser->debugCommandNameLength]; + while (*commandLine && *commandLine == ' ') + commandLine++; + + count = 0; + pp = commandLine; + vp = verb = &verbBuffer[0]; + while (*pp && *pp == ' ' && count++ < 80) + pp++; + + while (*pp && *pp != ' ' && count++ < 80) + *vp++ = *pp++; + *vp = '\0'; + + while (*pp && *pp == ' ' && count++ < 80) + pp++; + + DebuggerParserHelpRoutine(verb, commandLine); + return 1; + +} + +/* TIMER */ + +struct timer_list debug_timer; + +void debug_timer_callback(void) +{ + debug_timer.expires = jiffies + (HZ * debug_timer.data); + debug_timer.function = (void (*)(unsigned long))debug_timer_callback; + add_timer(&debug_timer); + mdb_breakpoint(); + return; +} + +unsigned long timedBreakpointHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("addtimer - add int3 timer (lockup detection)\n"); + DBGPrint("deltimer - del int3 timer\n"); + return 1; +} + +unsigned long timerBreakpoint(unsigned char *cmd, StackFrame *stackFrame, + unsigned long Exception, DEBUGGER_PARSER *parser) +{ + register int seconds; + unsigned long valid = 0; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (debug_timer.data) + { + DBGPrint("debug timer is already active. seconds = %i\n", + (int)debug_timer.data); + return 1; + } + + seconds = EvaluateNumericExpression(stackFrame, &cmd, &valid); + if (valid) + { + init_timer(&debug_timer); + debug_timer.data = seconds; + debug_timer.expires = jiffies + (HZ * seconds); + debug_timer.function = (void (*)(unsigned long))debug_timer_callback; + add_timer(&debug_timer); + + DBGPrint("debug timer created. seconds = %i\n", seconds); + } + return 1; +} + +unsigned long timerBreakpointClear(unsigned char *cmd, StackFrame *stackFrame, + unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + del_timer(&debug_timer); + debug_timer.data = 0; + DBGPrint("debug timer deleted\n"); + return 1; +} + +/* BT, BTA, BTP */ + +extern int bt_stack(struct task_struct *task, struct pt_regs *regs, + unsigned long *stack); + +unsigned long backTraceHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + + DBGPrint("bt - display stack backtrace\n"); + DBGPrint("bta - display stack backtrace all pids\n"); + DBGPrint("btp - display stack backtrace by pid\n"); + return 1; +} + +unsigned long backTraceAllPID(unsigned char *cmd, StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + struct task_struct *p, *g; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + do_each_thread(g, p) + { + if (p) + { + DBGPrint("Stack backtrace for pid %d\n", p->pid); + if (bt_stack(p, NULL, NULL)) + return 1; + } + } while_each_thread(g, p); + return 1; +} + +unsigned long backTracePID(unsigned char *cmd, StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + int pid; + unsigned long valid = 0; + struct task_struct *p, *g; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + pid = EvaluateNumericExpression(stackFrame, &cmd, &valid); + if (valid) + { + do_each_thread(g, p) + { + if (p && (p->pid == pid)) + { + DBGPrint("Stack backtrace for pid %d\n", p->pid); + bt_stack(p, NULL, NULL); + return 1; + } + } while_each_thread(g, p); + DBGPrint("No process with pid %d found\n", pid); + } + else + DBGPrint("invalid pid entered for backtrace\n"); + + return 1; + +} + +unsigned long backTraceStack(unsigned char *cmd, StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid = 0, address; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + DBGPrint("Stack backtrace for address 0x%08X\n", (unsigned)address); + bt_stack(NULL, NULL, (unsigned long *)address); + return 1; + } + else + { + DBGPrint("Stack backtrace for address 0x%08X\n", + (unsigned)GetStackAddress(stackFrame)); + bt_stack(NULL, NULL, (unsigned long *)GetStackAddress(stackFrame)); + return 1; + } + return 1; +} + +void DisplayASCIITable(void) +{ + + register unsigned long i; + union bhex + { + unsigned int i; + struct btemp { + unsigned one : 1; + unsigned two : 1; + unsigned three : 1; + unsigned four : 1; + unsigned five : 1; + unsigned six : 1; + unsigned seven : 1; + unsigned eight : 1; + } b; + } val; + + DBGPrint("ASCII Table\n"); + for (i = 0; i < 256; i++) + { + val.i = i; + switch (i) + { + + case 0: + if (DBGPrint("| %3i | (0x%02X) | (%1i%1i%1i%1i%1i%1i%1i%1ib) | NULL |", (int)i, (unsigned)i, + (int)val.b.eight, (int)val.b.seven, (int)val.b.six, + (int)val.b.five, (int)val.b.four, (int)val.b.three, + (int)val.b.two, (int)val.b.one)) return; + break; + + case 8: + if (DBGPrint("| %3i | (0x%02X) | (%1i%1i%1i%1i%1i%1i%1i%1ib) | BKSP |", (int)i, (unsigned)i, + (int)val.b.eight, (int)val.b.seven, (int)val.b.six, + (int)val.b.five, (int)val.b.four, (int)val.b.three, + (int)val.b.two, (int)val.b.one)) return; + break; + + case 9: + if (DBGPrint("| %3i | (0x%02X) | (%1i%1i%1i%1i%1i%1i%1i%1ib) | TAB |", (int)i, (unsigned)i, + (int)val.b.eight, (int)val.b.seven, (int)val.b.six, + (int)val.b.five, (int)val.b.four, (int)val.b.three, + (int)val.b.two, (int)val.b.one)) return; + break; + + case 10: + if (DBGPrint("| %3i | (0x%02X) | (%1i%1i%1i%1i%1i%1i%1i%1ib) | |", (int)i, (unsigned)i, + (int)val.b.eight, (int)val.b.seven, (int)val.b.six, + (int)val.b.five, (int)val.b.four, (int)val.b.three, + (int)val.b.two, (int)val.b.one)) return; + break; + + case 13: + if (DBGPrint("| %3i | (0x%02X) | (%1i%1i%1i%1i%1i%1i%1i%1ib) | |", (int)i, (unsigned)i, + (int)val.b.eight, (int)val.b.seven, (int)val.b.six, + (int)val.b.five, (int)val.b.four, (int)val.b.three, + (int)val.b.two, (int)val.b.one)) return; + break; + + case 32: + if (DBGPrint("| %3i | (0x%02X) | (%1i%1i%1i%1i%1i%1i%1i%1ib) | SPACE |", (int)i, (unsigned)i, + (int)val.b.eight, (int)val.b.seven, (int)val.b.six, + (int)val.b.five, (int)val.b.four, (int)val.b.three, + (int)val.b.two, (int)val.b.one)) return; + break; + + default: + if (DBGPrint("| %3i | (0x%02X) | (%1i%1i%1i%1i%1i%1i%1i%1ib) | %c |", (int)i, (unsigned)i, + (int)val.b.eight, (int)val.b.seven, (int)val.b.six, + (int)val.b.five, (int)val.b.four, (int)val.b.three, + (int)val.b.two, (int)val.b.one, (unsigned char) i)) return; + break; + + } + if (DBGPrint("\n")) return; + } + +} + +#if defined(CONFIG_MODULES) + +/* LSMOD, .M */ + +unsigned long listModulesHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint(".M - list loaded modules\n"); + DBGPrint("lsmod - list loaded modules\n"); + DBGPrint("rmmod - unload module\n"); + return 1; +} + +unsigned long listModules(unsigned char *cmd, StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (*cmd) + mdb_modules(cmd, DBGPrint); + else + mdb_modules(NULL, DBGPrint); + return 1; +} + +unsigned long unloadModule(unsigned char *cmd, StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + DBGPrint("Module unload unsupported in this version\n"); + return 0; +} + +#endif + +/* REBOOT */ + +unsigned long rebootSystemHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("reboot - reboot host system\n"); + DBGPrint("reboot force - reboot from current processor\n"); + return 1; +} + + +unsigned long rebootSystem(unsigned char *cmd, StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + extern void machine_emergency_restart(void); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (!strnicmp(cmd, "force", 5)) + { + machine_emergency_restart(); + return 1; + } + + if (!get_processor_id()) + machine_emergency_restart(); + else + DBGPrint("not on processor 0. try 'reboot force' or switch to \n" + "processor 0 with 'cpu 0' or 'nmi 0' commands and issue\n" + "the reboot command again\n"); + return 1; +} + +/* SECTIONS, .S */ + +unsigned long displaySectionsHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("sections - display kernel/module sections\n"); + DBGPrint(".s - display kernel/module sections\n"); + return 1; +} + +unsigned long displaySections(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + DBGPrint("\n"); + return 1; +} + +/* PSW */ + +static inline int mdb_process_cpu(const struct task_struct *p) +{ + unsigned int cpu = task_thread_info(p)->cpu; + if (cpu > NR_CPUS) + cpu = 0; + return cpu; +} + +unsigned long displayProcessSwitchHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + if (commandLine) {} + if (parser) {} + + DBGPrint("pid - switch to another process\n"); + return 1; +} + +unsigned long switchKernelProcess(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + int pid; + struct task_struct *p, *g; + unsigned long valid = 0; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + pid = EvaluateNumericExpression(stackFrame, &cmd, &valid); + if (valid) + { + do_each_thread(g, p) + { + if (p && (p->pid == pid)) + { + DBGPrint("switching to pid %d\n", p->pid); + + DBGPrint("%-*s Pid Parent [*] State %-*s CPU Command\n", + (int)(2*sizeof(void *))+2, "Task Addr", + (int)(2*sizeof(void *))+2, "Thread"); + + if (DBGPrint("0x%p %8d %8d %d %c 0x%p %02u %c%s\n", + (void *)p, + p->pid, + (mdb_verify_rw(p->real_parent, 4) + ? 0 : p->real_parent->pid), + task_curr(p), + (p->state == 0) ? 'R' : + (p->state < 0) ? 'U' : + (p->state & TASK_UNINTERRUPTIBLE) ? 'D' : + (p->state & TASK_STOPPED) ? 'T' : + (p->state & TASK_TRACED) ? 'C' : + (p->exit_state & EXIT_ZOMBIE) ? 'Z' : + (p->exit_state & EXIT_DEAD) ? 'E' : + (p->state & TASK_INTERRUPTIBLE) ? 'S' : + (!p->mm && (p->state & TASK_INTERRUPTIBLE)) + ? 'M' : '?', + (void *)(&p->thread), + mdb_process_cpu(p), + (p == curr_task(smp_processor_id())) ? '*' : ' ', + p->comm)) + return 1; + return 1; + } + } while_each_thread(g, p); + DBGPrint("No process with pid %d found\n", pid); + } + else + DBGPrint("invalid pid entered\n"); + + return 1; + +} + +/* PS, .P */ + +unsigned long displayKernelProcessHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + if (commandLine) {} + if (parser) {} + + DBGPrint("ps - display kernel processes\n"); + DBGPrint(".p - display kernel processes\n"); + return 1; +} + +StackFrame taskFrame[MAX_PROCESSORS]; + +unsigned long displayKernelProcess(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + int pid; + struct task_struct *p, *g; + unsigned long valid = 0; + StackFrame *searchFrame; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + pid = EvaluateNumericExpression(stackFrame, &cmd, &valid); + if (valid) + { + do_each_thread(g, p) + { + if (p && (p->pid == pid)) + { + DBGPrint("%-*s Pid Parent [*] State %-*sCPU Command\n", + (int)(2*sizeof(void *))+2, "Task Addr", + (int)(2*sizeof(void *))+2, "Thread"); + + if (DBGPrint("0x%p %8d %8d %d %c 0x%p %02u %c%s\n", + (void *)p, + p->pid, + (mdb_verify_rw(p->real_parent, 4) ? 0 : p->real_parent->pid), + task_curr(p), + (p->state == 0) ? 'R' : + (p->state < 0) ? 'U' : + (p->state & TASK_UNINTERRUPTIBLE) ? 'D' : + (p->state & TASK_STOPPED) ? 'T' : + (p->state & TASK_TRACED) ? 'C' : + (p->exit_state & EXIT_ZOMBIE) ? 'Z' : + (p->exit_state & EXIT_DEAD) ? 'E' : + (p->state & TASK_INTERRUPTIBLE) ? 'S' : + (!p->mm && (p->state & TASK_INTERRUPTIBLE)) ? 'M' : '?', + (void *)(&p->thread), + mdb_process_cpu(p), + (p == curr_task(smp_processor_id())) ? '*' : ' ', + p->comm)) + return 1; + + searchFrame = &taskFrame[smp_processor_id()]; + ReadTaskFrame(searchFrame, p); + DisplayTSS(searchFrame); +#ifdef CONFIG_X86_32 + disassemble(searchFrame, searchFrame->tIP, 1, -1, 0); +#endif + return 1; + } + } while_each_thread(g, p); + DBGPrint("invalid task pid\n"); + return 1; + } + else + { + DBGPrint("%-*s Pid Parent [*] State %-*sCPU Command\n", + (int)(2*sizeof(void *))+2, "Task Addr", + (int)(2*sizeof(void *))+2, "Thread"); + + do_each_thread(g, p) + { + if (p) + { + if (DBGPrint("0x%p %8d %8d %d %c 0x%p %02u %c%s\n", + (void *)p, + p->pid, + (mdb_verify_rw(p->real_parent, 4) ? 0 : p->real_parent->pid), + task_curr(p), + (p->state == 0) ? 'R' : + (p->state < 0) ? 'U' : + (p->state & TASK_UNINTERRUPTIBLE) ? 'D' : + (p->state & TASK_STOPPED) ? 'T' : + (p->state & TASK_TRACED) ? 'C' : + (p->exit_state & EXIT_ZOMBIE) ? 'Z' : + (p->exit_state & EXIT_DEAD) ? 'E' : + (p->state & TASK_INTERRUPTIBLE) ? 'S' : + (!p->mm && (p->state & TASK_INTERRUPTIBLE)) ? 'M' : '?', + (void *)(&p->thread), + mdb_process_cpu(p), + (p == curr_task(smp_processor_id())) ? '*' : ' ', + p->comm)) + return 1; + } + } while_each_thread(g, p); + } + return 1; + +} + +/* A */ + +unsigned long ascTableHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("a - display ASCII Table\n"); + return 1; +} + + +unsigned long displayASCTable(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + DisplayASCIITable(); + return 1; +} + +typedef struct _LINE_INFO +{ + unsigned long SourcePresent; + unsigned char *SourceLine; + unsigned char *ModuleName; + unsigned long LineNumber; +} LINE_INFO; + +void GetLineInfoFromValue(unsigned long value, LINE_INFO *lineInfo, unsigned long *exact) +{ + if (exact) + *exact = 0; + + if (lineInfo) + { + lineInfo->SourcePresent = 0; + lineInfo->SourceLine = ""; + lineInfo->ModuleName = ""; + lineInfo->LineNumber = 0; + } + return; +} + +unsigned long disassemble(StackFrame *stackFrame, unsigned long p, + unsigned long count, unsigned long use, + unsigned long type) +{ + register unsigned long i; + unsigned char *symbolName; + unsigned char *moduleName; + unsigned long exact = 0; + extern unsigned long line_info_toggle; + LINE_INFO lineInfo; + register int c = get_processor_id(); + + for (i = 0; i < count; i++) + { + GetLineInfoFromValue(p, &lineInfo, &exact); + + if (line_info_toggle && exact) + { + if (lineInfo.SourcePresent && lineInfo.SourceLine) + { + register unsigned long length = strlen(lineInfo.SourceLine); + + i = length > 80 + ? i + 1 + (length / 80) + : i + 1; + + DBGPrint("%s (%s : line %d)\n", + lineInfo.SourceLine, lineInfo.ModuleName, + lineInfo.LineNumber); + + } + else if (line_info_toggle && lineInfo.LineNumber) + { + i++; + DBGPrint("file %s line %d\n", + lineInfo.ModuleName, lineInfo.LineNumber); + } + } + + if (i >= count && count != 1) + break; + + symbolName = GetSymbolFromValue(p, &symbuf[c][0], MAX_SYMBOL_LEN); + if (symbolName) + { + i++; + moduleName = GetModuleInfoFromSymbolValue(p, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + { + if (DBGPrint("%s|%s:\n", moduleName, symbolName)) return p; + } + else + { + if (DBGPrint("%s:\n", symbolName)) return p; + } + } + if (i >= count && count != 1) + break; + + if (unassemble(stackFrame, p, use, &p, type)) return p; + } + + return p; + +} + +unsigned long dumpSearchResults(unsigned char *p, unsigned long count) +{ + + unsigned char *symbolName; + unsigned char *moduleName; + register unsigned long i, r, total; + unsigned char ch; + register int c = get_processor_id(); + + for (r = 0; r < count; r++) + { + symbolName = GetSymbolFromValue((unsigned long) p, &symbuf[c][0], MAX_SYMBOL_LEN); + if (symbolName) + { + moduleName = GetModuleInfoFromSymbolValue((unsigned long) p, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + { + if (DBGPrint("%s|%s:\n", moduleName, symbolName)) return 1; + } + else + { + if (DBGPrint("%s:\n", symbolName)) return 1; + } + if (r++ >= count && count != 1) + break; + } + DBGPrint("%p ", p); + for (total = 0, i = 0; i < 16; i++, total++) + { + DBGPrint("%02X", (unsigned) mdb_getword((unsigned long)&p[i], 1)); + } + DBGPrint(" "); + for (i = 0; i < total; i++) + { + ch = mdb_getword((unsigned long)&p[i], 1); + + if (ch < 32 || ch > 126) DBGPrint("."); + else DBGPrint("%c", ch); + } + if (DBGPrint("\n")) return 1; + + p = (void *)((unsigned long) p + (unsigned long) total); + } + return 0; + +} + +unsigned char *dump(unsigned char *p, unsigned long count) +{ + + unsigned char *symbolName; + unsigned char *moduleName; + register unsigned long i, r, total; + unsigned char ch; + register int c = get_processor_id(); + + for (r = 0; r < count; r++) + { + symbolName = GetSymbolFromValue((unsigned long) p, &symbuf[c][0], MAX_SYMBOL_LEN); + if (symbolName) + { + moduleName = GetModuleInfoFromSymbolValue((unsigned long) p, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("%s|%s:\n", moduleName, symbolName); + else + DBGPrint("%s:\n", symbolName); + if (r++ >= count && count != 1) + break; + } + DBGPrint("%p ", p); + for (total = 0, i = 0; i < 16; i++, total++) + { + DBGPrint("%02X", (unsigned) mdb_getword((unsigned long)&p[i], 1)); + } + DBGPrint(" "); + for (i = 0; i < total; i++) + { + ch = mdb_getword((unsigned long)&p[i], 1); + + if (ch < 32 || ch > 126) DBGPrint("."); + else DBGPrint("%c", ch); + } + DBGPrint("\n"); + + p = (void *)((unsigned long) p + (unsigned long) total); + } + + return p; + +} + +unsigned long dumpWordSearchResults(unsigned char *p, unsigned long count) +{ + + register int i, r; + unsigned short *wp; + unsigned char *symbolName; + unsigned char *moduleName; + unsigned char ch; + register int c = get_processor_id(); + + wp = (unsigned short *) p; + for (r = 0; r < count; r++) + { + symbolName = GetSymbolFromValue((unsigned long) p, &symbuf[c][0], MAX_SYMBOL_LEN); + if (symbolName) + { + moduleName = GetModuleInfoFromSymbolValue((unsigned long) p, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + { + if (DBGPrint("%s|%s:\n", moduleName, symbolName)) return 1; + } + else + { + if (DBGPrint("%s:\n", symbolName)) return 1; + } + if (r++ >= count && count != 1) + break; + } + DBGPrint("%p ", p); + for (i = 0; i < (16 / 2); i++) + { + DBGPrint(" %04X", (unsigned) mdb_getword((unsigned long)&wp[i], 2)); + } + DBGPrint(" "); + for (i = 0; i < 16; i++) + { + ch = mdb_getword((unsigned long)&p[i], 1); + + if (ch < 32 || ch > 126) DBGPrint("."); + else DBGPrint("%c", ch); + } + if (DBGPrint("\n")) return 1; + + p = (void *)((unsigned long) p + (unsigned long) 16); + wp = (unsigned short *) p; + } + + return 0; + +} + +unsigned char *dumpWord(unsigned char *p, unsigned long count) +{ + + register int i, r; + unsigned short *wp; + unsigned char *symbolName; + unsigned char *moduleName; + unsigned char ch; + register int c = get_processor_id(); + + wp = (unsigned short *) p; + for (r = 0; r < count; r++) + { + symbolName = GetSymbolFromValue((unsigned long) p, &symbuf[c][0], MAX_SYMBOL_LEN); + if (symbolName) + { + moduleName = GetModuleInfoFromSymbolValue((unsigned long) p, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("%s|%s:\n", moduleName, symbolName); + else + DBGPrint("%s:\n", symbolName); + if (r++ >= count && count != 1) + break; + } + DBGPrint("%p ", p); + for (i = 0; i < (16 / 2); i++) + { + DBGPrint(" %04X", (unsigned) mdb_getword((unsigned long)&wp[i], 2)); + } + DBGPrint(" "); + for (i = 0; i < 16; i++) + { + ch = mdb_getword((unsigned long)&p[i], 1); + + if (ch < 32 || ch > 126) DBGPrint("."); + else DBGPrint("%c", ch); + } + DBGPrint("\n"); + + p = (void *)((unsigned long) p + (unsigned long) 16); + wp = (unsigned short *) p; + } + + return p; + +} + +unsigned long dumpDoubleSearchResults(unsigned char *p, unsigned long count) +{ + + register int i, r; + unsigned long *lp; + unsigned char *symbolName; + unsigned char *moduleName; + unsigned char ch; + register int c = get_processor_id(); + + lp = (unsigned long *) p; + + for (r = 0; r < count; r++) + { + symbolName = GetSymbolFromValue((unsigned long) p, &symbuf[c][0], MAX_SYMBOL_LEN); + if (symbolName) + { + moduleName = GetModuleInfoFromSymbolValue((unsigned long) p, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + { + if (DBGPrint("%s|%s:\n", moduleName, symbolName)) return 1; + } + else + { + if (DBGPrint("%s:\n", symbolName)) return 1; + } + if (r++ >= count && count != 1) + break; + } + DBGPrint("%p ", p); + for (i = 0; i < (16 / 4); i++) + { + DBGPrint(" %08X", (unsigned) mdb_getword((unsigned long)&lp[i], 4)); + } + DBGPrint(" "); + for (i = 0; i < 16; i++) + { + ch = mdb_getword((unsigned long)&p[i], 1); + + if (ch < 32 || ch > 126) DBGPrint("."); + else DBGPrint("%c", ch); + } + if (DBGPrint("\n")) return 1; + + p = (void *)((unsigned long) p + (unsigned long) 16); + lp = (unsigned long *) p; + } + + return 0; + +} + +unsigned char *dumpQuad(unsigned char *p, unsigned long count) +{ + register int i, r; + uint64_t *lp; + unsigned char *symbolName; + unsigned char *moduleName; + unsigned char ch; + register int c = get_processor_id(); + + lp = (uint64_t *)p; + + for (r = 0; r < count; r++) + { + symbolName = GetSymbolFromValue((unsigned long) p, &symbuf[c][0], MAX_SYMBOL_LEN); + if (symbolName) + { + moduleName = GetModuleInfoFromSymbolValue((unsigned long) p, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("%s|%s:\n", moduleName, symbolName); + else + DBGPrint("%s:\n", symbolName); + if (r++ >= count && count != 1) + break; + } + DBGPrint("%p ", p); + for (i = 0; i < (16 / 8); i++) + { + DBGPrint(" %016llX", (uint64_t) mdb_getqword(&lp[i], 8)); + } + DBGPrint(" "); + for (i = 0; i < 16; i++) + { + ch = mdb_getword((unsigned long)&p[i], 1); + + if (ch < 32 || ch > 126) DBGPrint("."); + else DBGPrint("%c", ch); + } + DBGPrint("\n"); + + p = (void *)((unsigned long) p + (unsigned long) 16); + lp = (uint64_t *) p; + } + + return p; + +} + +unsigned char *dumpDouble(unsigned char *p, unsigned long count) +{ + + register int i, r; + unsigned long *lp; + unsigned char *symbolName; + unsigned char *moduleName; + unsigned char ch; + register int c = get_processor_id(); + + lp = (unsigned long *) p; + + for (r = 0; r < count; r++) + { + symbolName = GetSymbolFromValue((unsigned long) p, &symbuf[c][0], MAX_SYMBOL_LEN); + if (symbolName) + { + moduleName = GetModuleInfoFromSymbolValue((unsigned long) p, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("%s|%s:\n", moduleName, symbolName); + else + DBGPrint("%s:\n", symbolName); + if (r++ >= count && count != 1) + break; + } + DBGPrint("%p ", p); + for (i = 0; i < (16 / 4); i++) + { + DBGPrint(" %08X", (unsigned) mdb_getword((unsigned long)&lp[i], 4)); + } + DBGPrint(" "); + for (i = 0; i < 16; i++) + { + ch = mdb_getword((unsigned long)&p[i], 1); + + if (ch < 32 || ch > 126) DBGPrint("."); + else DBGPrint("%c", ch); + } + DBGPrint("\n"); + + p = (void *)((unsigned long) p + (unsigned long) 16); + lp = (unsigned long *) p; + } + + return p; + +} + +unsigned char *dumpLinkedList(unsigned char *p, unsigned long count, unsigned long offset) +{ + + register int i, r; + unsigned long *lp; + unsigned char ch; + + lp = (unsigned long *) p; + + DBGPrint("Linked List -> [%p + %X] = %08X\n", lp, (unsigned)offset, + (unsigned)mdb_getword((unsigned long)((unsigned long)lp + (unsigned long)offset), 4)); + + for (r = 0; r < count; r++) + { + DBGPrint("%p ", p); + for (i = 0; i < 16; i++) + { + DBGPrint("%02X", (unsigned) mdb_getword((unsigned long)&p[i], 1)); + } + DBGPrint(" "); + for (i = 0; i < 16; i++) + { + ch = mdb_getword((unsigned long)&p[i], 1); + + if (ch < 32 || ch > 126) DBGPrint("."); + else DBGPrint("%c", ch); + } + DBGPrint("\n"); + + p = (void *)((unsigned long) p + (unsigned long) 16); + } + + return (unsigned char *)(mdb_getword((unsigned long)((unsigned long)lp + (unsigned long)offset), 4)); + +} + +unsigned char *dumpQuadStack(StackFrame *stackFrame, unsigned char *p, unsigned long count) +{ + + register int i, r; + uint64_t *lp; + unsigned char ch; + + lp = (uint64_t *)p; + + DBGPrint("Stack = %04lX:%p\n", + (unsigned long)GetStackSegment(stackFrame), p); + + for (r = 0; r < count; r++) + { + DBGPrint("%04X:", (unsigned) GetStackSegment(stackFrame)); + DBGPrint("%p ", p); + for (i = 0; i < (16 / 8); i++) + { + DBGPrint(" %016llX", (uint64_t)mdb_getqword(&lp[i], 8)); + } + DBGPrint(" "); + for (i = 0; i < 16; i++) + { + ch = mdb_getword((unsigned long)&p[i], 1); + + if (ch < 32 || ch > 126) DBGPrint("."); + else DBGPrint("%c", ch); + } + DBGPrint("\n"); + + p = (void *)((unsigned long) p + (unsigned long) 16); + lp = (uint64_t *) p; + } + + return p; + +} + +unsigned char *dumpDoubleStack(StackFrame *stackFrame, unsigned char *p, unsigned long count) +{ + + register int i, r; + unsigned long *lp; + unsigned char ch; + + lp = (unsigned long *) p; + + DBGPrint("Stack = %04lX:%p\n", + (unsigned long)GetStackSegment(stackFrame), p); + + for (r = 0; r < count; r++) + { + DBGPrint("%04X:", (unsigned) GetStackSegment(stackFrame)); + DBGPrint("%p ", p); + for (i = 0; i < (16 / 4); i++) + { + DBGPrint(" %08X", (unsigned) mdb_getword((unsigned long)&lp[i], 4)); + } + DBGPrint(" "); + for (i = 0; i < 16; i++) + { + ch = mdb_getword((unsigned long)&p[i], 1); + + if (ch < 32 || ch > 126) DBGPrint("."); + else DBGPrint("%c", ch); + } + DBGPrint("\n"); + + p = (void *)((unsigned long) p + (unsigned long) 16); + lp = (unsigned long *) p; + } + + return p; + +} + +#ifdef CONFIG_X86_64 +unsigned char *dumpStack(StackFrame *stackFrame, unsigned char *p, unsigned long count) +{ + + register int r; + uint64_t *lp; + + lp = (uint64_t *)p; + + DBGPrint("Stack = %04X:%p\n", (unsigned)GetStackSegment(stackFrame), p); + + for (r = 0; r < count; r++) + { + DBGPrint("%p ", p); + DBGPrint("%016llX ", mdb_getqword((uint64_t *)lp, 8)); + if (DisplayClosestSymbol(mdb_getqword((uint64_t *)lp, 8))) + DBGPrint("\n"); + + p = (void *)((unsigned long) p + (unsigned long) 8); + lp = (uint64_t *) p; + } + + return p; + +} + +#else + +unsigned char *dumpStack(StackFrame *stackFrame, unsigned char *p, unsigned long count) +{ + + register int r; + unsigned long *lp; + + lp = (unsigned long *) p; + + DBGPrint("Stack = %04X:%p\n", (unsigned)GetStackSegment(stackFrame), p); + + for (r = 0; r < count; r++) + { + DBGPrint("%p ", p); + DBGPrint("%08X ", (unsigned) mdb_getword((unsigned long)lp, 4)); + if (DisplayClosestSymbol(mdb_getword((unsigned long)lp, 4))) + DBGPrint("\n"); + + p = (void *)((unsigned long) p + (unsigned long) 4); + lp = (unsigned long *) p; + } + + return p; + +} +#endif + +unsigned long displayToggleHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint(".tb - toggles disable breakpoints in user address space (ON | OFF)\n"); + DBGPrint(".tc - toggles control registers (ON | OFF)\n"); + DBGPrint(".tn - toggles coprocessor registers (ON | OFF)\n"); + DBGPrint(".ts - toggles segment registers (ON | OFF)\n"); + DBGPrint(".tg - toggles general registers (ON | OFF)\n"); + DBGPrint(".tr - toggles display of break reason (ON | OFF)\n"); + DBGPrint(".td - toggles full dereference display (ON | OFF)\n"); + DBGPrint(".tl - toggles source line display (ON | OFF)\n"); + DBGPrint(".tm - toggles user space read/write for pages < PAGE_OFFSET (ON | OFF)\n"); + DBGPrint(".tu - toggles unasm debug display (ON | OFF)\n"); + DBGPrint(".t or .t
- display task state segment (tss)\n"); + DBGPrint(".toggle - show all current toggle settings\n"); + DBGPrint("toggle - show all current toggle settings\n"); + return 1; +} + +unsigned long displayToggleAll(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + DBGPrint("unasm debug display : (%s)\n", + debug_deref ? "ON" : "OFF"); + DBGPrint("full dereferencing info : (%s) \n", + full_deref_toggle ? "ON" : "OFF"); + DBGPrint("source line info : (%s) \n", + line_info_toggle ? "ON" : "OFF"); + DBGPrint("general registers : (%s) \n", + general_toggle ? "ON" : "OFF"); + DBGPrint("disable debugger in userspace : (%s) \n", + toggle_user_break ? "ON" : "OFF"); + DBGPrint("control registers : (%s) \n", + control_toggle ? "ON" : "OFF"); + DBGPrint("user space memory read/write : (%s)\n", + user_toggle ? "ON" : "OFF"); + DBGPrint("coprocessor registers : (%s) \n", + numeric_toggle ? "ON" : "OFF"); + DBGPrint("display break reason : (%s) \n", + reason_toggle ? "ON" : "OFF"); + DBGPrint("segment registers : (%s) \n", + segment_toggle ? "ON" : "OFF"); + + return 1; +} + +/* .TU */ + +unsigned long ProcessTUToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + (debug_deref) + ? (debug_deref = 0) + : (debug_deref = 1); + DBGPrint("unasm dereferencing (%s)\n", debug_deref ? "ON" : "OFF"); + return 1; +} + +/* .TD */ + +unsigned long ProcessTDToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + (full_deref_toggle) + ? (full_deref_toggle = 0) + : (full_deref_toggle = 1); + DBGPrint("full dereferencing info (%s) \n", + full_deref_toggle ? "ON" : "OFF"); + return 1; +} + + +/* .TL */ + +unsigned long ProcessTLToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + (line_info_toggle) + ? (line_info_toggle = 0) + : (line_info_toggle = 1); + DBGPrint("source line info (%s) \n", line_info_toggle ? "ON" : "OFF"); + return 1; + +} + +/* .TG */ + +unsigned long ProcessTGToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + (general_toggle) + ? (general_toggle = 0) + : (general_toggle = 1); + DBGPrint("general registers (%s) \n", general_toggle ? "ON" : "OFF"); + return 1; + +} + +/* .TB */ + +unsigned long ProcessTBToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + (toggle_user_break) + ? (toggle_user_break = 0) + : (toggle_user_break = 1); + DBGPrint("disable breakpoints in user address space (%s) \n", + control_toggle ? "ON" : "OFF"); + return 1; + +} + +/* .TC */ + +unsigned long ProcessTCToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + (control_toggle) + ? (control_toggle = 0) + : (control_toggle = 1); + DBGPrint("control registers (%s) \n", control_toggle ? "ON" : "OFF"); + return 1; + +} + +/* .TM */ + +unsigned long ProcessToggleUser(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + (user_toggle) + ? (user_toggle = 0) + : (user_toggle = 1); + DBGPrint("user space read/write for pages < PAGE_OFFSET (%s)\n", + user_toggle ? "ON" : "OFF"); + return 1; + +} + +/* .TN */ + +unsigned long ProcessTNToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + (numeric_toggle) + ? (numeric_toggle = 0) + : (numeric_toggle = 1); + DBGPrint("coprocessor registers (%s) \n", numeric_toggle ? "ON" : "OFF"); + return 1; + +} + +/* .TR */ + +unsigned long ProcessTRToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + (reason_toggle) + ? (reason_toggle = 0) + : (reason_toggle = 1); + DBGPrint("display break reason (%s) \n", reason_toggle ? "ON" : "OFF"); + return 1; + +} + +/* .TS */ + +unsigned long ProcessTSToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + (segment_toggle) + ? (segment_toggle = 0) + : (segment_toggle = 1); + DBGPrint("segment registers (%s) \n", segment_toggle ? "ON" : "OFF"); + return 1; + +} + +unsigned long displayDebuggerVersionHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint(".v - display version info\n"); + return 1; +} + +/* .V */ + +unsigned long DisplayDebuggerVersion(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + extern unsigned long MajorVersion; + extern unsigned long MinorVersion; + extern unsigned long BuildVersion; + + DBGPrint("Merkey's Kernel Debugger\n"); + DBGPrint("v%02d.%02d.%02d\n", + (int)MajorVersion, (int)MinorVersion, (int)BuildVersion); + DBGPrint("Copyright (C) 2008 Jeffrey Vernon Merkey. " + "All Rights Reserved.\n"); + + return 1; +} + +/* .Z */ + +unsigned long displaySymbolsHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint(".z - display symbol info\n"); + return 1; +} + +unsigned long displaySymbols(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + extern void DumpOSSymbolTableMatch(unsigned char *); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (*cmd) + DumpOSSymbolTableMatch(cmd); + else + DumpOSSymbolTableMatch(NULL); + + return 1; +} + +/* LCPU */ + +unsigned long listProcessors(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register int i; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + DBGPrint("Current Processor: %d\n", get_processor_id()); + DBGPrint("Active Processors: \n"); + for (i = 0; i < MAX_PROCESSORS; i++) + { + if (cpu_online(i)) + DBGPrint(" Processor %d\n", i); + } + return 1; + +} + +unsigned long clearScreenHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("cls - clear the screen\n"); + return 1; +} + +/* CLS */ + +unsigned long clearDebuggerScreen(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + extern void ClearScreen(void); + + ClearScreen(); + return 1; + +} + +unsigned long SearchMemoryHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("sb - search for bytes at address\n"); + DBGPrint("sw - search for words at address\n"); + DBGPrint("sd - search for dwords at address\n"); + return 1; +} + +/* S */ + +/* use local storage and reduce stack space use. these functions are always + called single threaded from the console */ + +unsigned char s_changeBuffer[16]; +unsigned char b_searchBuffer[16]; +unsigned char b_copyBuffer[16]; +unsigned short w_searchBuffer[16]; +unsigned short w_copyBuffer[16]; +unsigned long d_searchBuffer[16]; +unsigned long d_copyBuffer[16]; + +unsigned long SearchMemory(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned char *changeBuffer = s_changeBuffer; + unsigned char *searchBuffer = b_searchBuffer; + unsigned char *copyBuffer = b_copyBuffer; + unsigned long maxlen = sizeof(searchBuffer); + register unsigned char *changeB; + unsigned char *pB; + register unsigned long address, r, value, count, len, i; + unsigned long valid, EndingAddress = (unsigned long)high_memory; + register int key; + extern int mdb_getkey(void); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + memset((unsigned long *)searchBuffer, 0, sizeof(searchBuffer)); + count = 0; + changeB = (unsigned char *) searchBuffer; + changeBuffer[0] = '\0'; + DBGPrint("enter bytes to search for, '.' to end input\n"); + while ((changeBuffer[0] != '.') && (count < maxlen)) + { + for (r = 0; r < 8; r++) + { + DBGPrint("0x"); + + ScreenInputFromKeyboard(&changeBuffer[0], 0, 4); + + if ((changeBuffer[0] == '.') || (changeBuffer[1] == '.')) + break; + + pB = (unsigned char *) &changeBuffer[0]; + len = strlen(pB); + + for (i = 0; i < len; i++) + DBGPrint("\b"); + + value = EvaluateExpression(0, &pB, &valid); + if (valid) + *changeB = (unsigned char) value; + DBGPrint("%02X ", (unsigned char) *changeB); + + changeB++; + if (count++ > maxlen) + break; + } + if (DBGPrint("\n")) return 1; + } + + if (count) + { + DBGPrint("enter start address for search: "); + ScreenInputFromKeyboard(&changeBuffer[0], 0, 16); + pB = (unsigned char *) &changeBuffer[0]; + address = EvaluateExpression(0, &pB, &valid); + if (valid) + { + register unsigned long temp; + + DBGPrint("start address = [%08X]\n", (unsigned)address); + DBGPrint("enter ending address for search: "); + + ScreenInputFromKeyboard(&changeBuffer[0], 0, 16); + pB = (unsigned char *) &changeBuffer[0]; + temp = EvaluateExpression(0, &pB, &valid); + if (valid) + EndingAddress = temp; + + DBGPrint("\nsearching memory from 0x%08X to 0x%08X\n", + (unsigned)address, (unsigned)EndingAddress); + while (address < EndingAddress) + { + read_memory((void *)address, copyBuffer, count); + if (!memcmp(searchBuffer, copyBuffer, count)) + { + if (DBGPrint("match at address [%08X]\n", + (unsigned)address)) return 1; + if (dumpSearchResults((unsigned char *)address, 4)) return 1; + if (DBGPrint("searching\n")) return 1; + } + address++; + if (!(address % 0x100000)) + { + if (DBGPrint("searching memory at address 0x%08X ..." + " Q or q to abort - any key to proceed\n", + (unsigned)address)) return 1; + key = mdb_getkey(); + if (((char)key == 'Q') || ((char)key == 'q')) + break; + } + } + if (DBGPrint("search completed.\n")) return 1; + return 1; + } + if (DBGPrint("invalid start address\n")) return 1; + return 1; + } + if (DBGPrint("no search pattern\n")) return 1; + return 1; + +} + +/* SB */ + +unsigned long SearchMemoryB(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned char *changeBuffer = s_changeBuffer; + unsigned char *searchBuffer = b_searchBuffer; + unsigned char *copyBuffer = b_copyBuffer; + unsigned long maxlen = sizeof(searchBuffer); + register unsigned char *changeB; + unsigned char *pB; + register unsigned long address, r, value, count, len, i; + unsigned long valid, EndingAddress = (unsigned long)high_memory; + register int key; + extern int mdb_getkey(void); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + memset((unsigned long *)searchBuffer, 0, sizeof(searchBuffer)); + count = 0; + changeB = (unsigned char *) searchBuffer; + changeBuffer[0] = '\0'; + DBGPrint("enter bytes to search for, '.' to end input\n"); + while (changeBuffer[0] != '.' && count < maxlen) + { + for (r = 0; r < 8; r++) + { + DBGPrint("0x"); + + ScreenInputFromKeyboard(&changeBuffer[0], 0, 4); + + if ((changeBuffer[0] == '.') || (changeBuffer[1] == '.')) + break; + + pB = (unsigned char *) &changeBuffer[0]; + len = strlen(pB); + for (i = 0; i < len; i++) + DBGPrint("\b"); + + value = EvaluateExpression(0, &pB, &valid); + if (valid) + *changeB = (unsigned char) value; + DBGPrint("%02X ", (unsigned char) *changeB); + + changeB++; + if (count++ > maxlen) + break; + } + if (DBGPrint("\n")) return 1; + } + + if (count) + { + DBGPrint("enter start address for search: "); + ScreenInputFromKeyboard(&changeBuffer[0], 0, 16); + pB = (unsigned char *) &changeBuffer[0]; + address = EvaluateExpression(0, &pB, &valid); + if (valid) + { + register unsigned long temp; + + DBGPrint("start address = [%08X]\n", (unsigned)address); + + DBGPrint("enter ending address for search: "); + ScreenInputFromKeyboard(&changeBuffer[0], 0, 16); + pB = (unsigned char *) &changeBuffer[0]; + temp = EvaluateExpression(0, &pB, &valid); + if (valid) + EndingAddress = temp; + + DBGPrint("\nsearching memory from 0x%08X to 0x%08X\n", + (unsigned)address, (unsigned)EndingAddress); + while (address < EndingAddress) + { + read_memory((void *)address, copyBuffer, count); + if (!memcmp(searchBuffer, copyBuffer, count)) + { + if (DBGPrint("match at address [%08X]\n", + (unsigned)address)) return 1; + if (dumpSearchResults((unsigned char *)address, 4)) return 1; + if (DBGPrint("searching\n")) return 1; + } + address++; + if (!(address % 0x100000)) + { + if (DBGPrint("searching memory at address 0x%08X ..." + " Q or q to abort - any key to proceed\n", + (unsigned)address)) return 1; + key = mdb_getkey(); + if (((char)key == 'Q') || ((char)key == 'q')) + break; + } + } + if (DBGPrint("search completed.\n")) return 1; + return 1; + } + if (DBGPrint("invalid start address\n")) return 1; + return 1; + } + if (DBGPrint("no search pattern\n")) return 1; + return 1; +} + +/* SW */ + +unsigned long SearchMemoryW(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned char *changeBuffer = s_changeBuffer; + unsigned short *searchBuffer = w_searchBuffer; + unsigned short *copyBuffer = w_copyBuffer; + unsigned long maxlen = sizeof(searchBuffer) / sizeof(unsigned short); + register unsigned short *changeW; + unsigned char *pB; + register unsigned long address, r, value, count, len, i; + unsigned long valid, EndingAddress = (unsigned long)high_memory; + register int key; + extern int mdb_getkey(void); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + memset((unsigned long *)searchBuffer, 0, sizeof(searchBuffer)); + count = 0; + changeW = (unsigned short *) searchBuffer; + changeBuffer[0] = '\0'; + DBGPrint("enter words to search for, '.' to end input\n"); + while (changeBuffer[0] != '.' && count < maxlen) + { + for (r = 0; r < 4; r++) + { + DBGPrint("0x"); + + ScreenInputFromKeyboard(&changeBuffer[0], 0, 6); + + if ((changeBuffer[0] == '.') || (changeBuffer[1] == '.') || + (changeBuffer[2] == '.') || (changeBuffer[3] == '.')) + break; + + pB = (unsigned char *) &changeBuffer[0]; + len = strlen(pB); + for (i = 0; i < len; i++) + DBGPrint("\b"); + + value = EvaluateExpression(0, &pB, &valid); + if (valid) + *changeW = value; + DBGPrint("%04X ", *changeW); + + changeW++; + if (count++ > maxlen) + break; + } + if (DBGPrint("\n")) return 1; + } + + if (count) + { + DBGPrint("enter start address for search: "); + ScreenInputFromKeyboard(&changeBuffer[0], 0, 16); + pB = (unsigned char *) &changeBuffer[0]; + address = EvaluateExpression(0, &pB, &valid); + if (valid) + { + register unsigned long temp; + + DBGPrint("start address = [%08X]\n", (unsigned)address); + + DBGPrint("enter ending address for search: "); + ScreenInputFromKeyboard(&changeBuffer[0], 0, 16); + pB = (unsigned char *) &changeBuffer[0]; + temp = EvaluateExpression(0, &pB, &valid); + if (valid) + EndingAddress = temp; + + DBGPrint("searching memory from 0x%08X to 0x%08X\n", + (unsigned)address, (unsigned)EndingAddress); + while (address < EndingAddress) + { + read_memory((void *)address, copyBuffer, count * sizeof(unsigned short)); + if (!memcmp(searchBuffer, copyBuffer, count * sizeof(unsigned short))) + { + if (DBGPrint("match at address [%08X]\n", + (unsigned)address)) return 1; + if (dumpWordSearchResults((unsigned char *)address, 4)) + return 1; + if (DBGPrint("searching\n")) return 1;; + } + address++; + if (!(address % 0x100000)) + { + if (DBGPrint("searching memory at address 0x%08X ..." + " Q or q to abort - any key to proceed\n", + (unsigned)address)) return 1; + key = mdb_getkey(); + if (((char)key == 'Q') || ((char)key == 'q')) + break; + } + } + if (DBGPrint("search completed.\n")) return 1; + return 1; + } + if (DBGPrint("invalid start address\n")) return 1; + return 1; + } + if (DBGPrint("no search pattern\n")) return 1; + return 1; +} + +/* SD */ + +unsigned long SearchMemoryD(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned char *changeBuffer = s_changeBuffer; + register unsigned long *searchBuffer = d_searchBuffer; + register unsigned long *copyBuffer = d_copyBuffer; + register unsigned long maxlen = sizeof(searchBuffer) / sizeof(unsigned long); + register unsigned long *changeD; + unsigned char *pB; + register unsigned long address, r, value, count, len, i; + unsigned long valid, EndingAddress = (unsigned long)high_memory; + register int key; + extern int mdb_getkey(void); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + memset((unsigned long *)searchBuffer, 0, sizeof(searchBuffer)); + count = 0; + changeD = (unsigned long *) searchBuffer; + changeBuffer[0] = '\0'; + DBGPrint("enter dwords to search for, '.' to end input\n"); + while (changeBuffer[0] != '.' && count < maxlen) + { + for (r = 0; r < 2; r++) + { + DBGPrint("0x"); + + ScreenInputFromKeyboard(&changeBuffer[0], 0, 8); + + if ((changeBuffer[0] == '.') || (changeBuffer[1] == '.') || + (changeBuffer[2] == '.') || (changeBuffer[3] == '.') || + (changeBuffer[4] == '.') || (changeBuffer[5] == '.') || + (changeBuffer[6] == '.') || (changeBuffer[7] == '.')) + break; + + pB = (unsigned char *) &changeBuffer[0]; + len = strlen(pB); + for (i = 0; i < len; i++) + DBGPrint("\b"); + + value = EvaluateExpression(0, &pB, &valid); + if (valid) + *changeD = value; + DBGPrint("%08X ", (unsigned)*changeD); + + changeD++; + if (count++ > maxlen) + break; + } + if (DBGPrint("\n")) return 1; + } + + if (count) + { + DBGPrint("enter start address for search: "); + ScreenInputFromKeyboard(&changeBuffer[0], 0, 16); + pB = (unsigned char *) &changeBuffer[0]; + address = EvaluateExpression(0, &pB, &valid); + if (valid) + { + register unsigned long temp; + + DBGPrint("start address = [%08X]\n", (unsigned)address); + + DBGPrint("enter ending address for search: "); + ScreenInputFromKeyboard(&changeBuffer[0], 0, 16); + pB = (unsigned char *) &changeBuffer[0]; + temp = EvaluateExpression(0, &pB, &valid); + if (valid) + EndingAddress = temp; + + DBGPrint("searching memory from 0x%08X to 0x%08X\n", + (unsigned)address, (unsigned)EndingAddress); + while (address < EndingAddress) + { + read_memory((void *)address, copyBuffer, count * sizeof(unsigned long)); + if (!memcmp(searchBuffer, copyBuffer, count * sizeof(unsigned long))) + { + if (DBGPrint("match at address [%08X]\n", + (unsigned)address)) return 1; + if (dumpDoubleSearchResults((unsigned char *)address, 4)) + return 1; + if (DBGPrint("searching\n")) return 1; + } + address++; + if (!(address % 0x100000)) + { + if (DBGPrint("searching memory at address 0x%08X ..." + " Q or q to abort - any key to proceed\n", + (unsigned)address)) return 1; + key = mdb_getkey(); + if (((char)key == 'Q') || ((char)key == 'q')) + break; + } + } + if (DBGPrint("search completed.\n")) return 1; + return 1; + } + if (DBGPrint("invalid start address\n")) return 1; + return 1; + } + if (DBGPrint("no search pattern\n")) return 1; + return 1; +} + + +unsigned long changeMemoryHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("c
- change bytes at address\n"); + DBGPrint("cb
- change bytes at address\n"); + DBGPrint("cw
- change words at address\n"); + DBGPrint("cd
- change dwords at address\n"); + DBGPrint("cq
- change qwords at address\n"); + return 1; +} + +/* CW */ + +unsigned long changeWordValue(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned char *changeBuffer = &workbuf[0][0]; + register unsigned short *changeW, oldW; + unsigned char *pB; + register unsigned long address, r, value, len, i; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + changeW = (unsigned short *) address; + changeBuffer[0] = '\0'; + DBGPrint("enter new value, to skip, or '.' to exit\n"); + while (changeBuffer[0] != '.') + { + DBGPrint("[%p] ", changeW); + for (r = 0; r < 4; r++) + { + oldW = (unsigned short) mdb_getword((unsigned long)changeW, 2); + DBGPrint("(%04X)=", (unsigned) oldW); + + ScreenInputFromKeyboard(&changeBuffer[0], 0, 6); + + if ((changeBuffer[0] == '.') || (changeBuffer[1] == '.') || + (changeBuffer[2] == '.') || (changeBuffer[3] == '.')) + break; + pB = (unsigned char *) &changeBuffer[0]; + len = strlen(pB); + + for (i = 0; i < len; i++) + DBGPrint("\b"); + + value = EvaluateExpression(0, &pB, &valid); + if (valid) + mdb_putword((unsigned long)changeW, value, 2); + DBGPrint("%04X ", (unsigned) mdb_getword((unsigned long)changeW, 2)); + changeW++; + } + if (DBGPrint("\n")) return 1; + } + return 1; + } + DBGPrint("invalid change (word) address\n"); + return 1; +} + +/* CQ */ + +unsigned long changeQuadValue(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned char *changeBuffer = &workbuf[0][0]; + register uint64_t *changeD, oldD; + register unsigned long address, r, value, len, i; + unsigned char *pB; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + changeD = (uint64_t *) address; + changeBuffer[0] = '\0'; + DBGPrint("enter new value, to skip, or '.' to exit\n"); + while (changeBuffer[0] != '.') + { + DBGPrint("[%p] ", changeD); + for (r = 0; r < 2; r++) + { + oldD = mdb_getqword(changeD, 8); + DBGPrint("(%016llX)=", (unsigned) oldD); + + ScreenInputFromKeyboard(&changeBuffer[0], 0, 16); + + if ((changeBuffer[0] == '.') || (changeBuffer[1] == '.') || + (changeBuffer[2] == '.') || (changeBuffer[3] == '.') || + (changeBuffer[4] == '.') || (changeBuffer[5] == '.') || + (changeBuffer[6] == '.') || (changeBuffer[7] == '.') || + (changeBuffer[8] == '.') || (changeBuffer[9] == '.') || + (changeBuffer[10] == '.') || (changeBuffer[11] == '.') || + (changeBuffer[12] == '.') || (changeBuffer[13] == '.') || + (changeBuffer[14] == '.') || (changeBuffer[15] == '.') || + (changeBuffer[16] == '.') || (changeBuffer[17] == '.') || + (changeBuffer[18] == '.') || (changeBuffer[19] == '.') || + (changeBuffer[20] == '.') || (changeBuffer[21] == '.') || + (changeBuffer[22] == '.') || (changeBuffer[23] == '.') || + (changeBuffer[24] == '.') || (changeBuffer[25] == '.') || + (changeBuffer[26] == '.') || (changeBuffer[27] == '.') || + (changeBuffer[28] == '.') || (changeBuffer[29] == '.') || + (changeBuffer[30] == '.') || (changeBuffer[31] == '.')) + break; + + pB = (unsigned char *) &changeBuffer[0]; + len = strlen(pB); + + for (i = 0; i < len; i++) + DBGPrint("\b"); + + value = EvaluateExpression(0, &pB, &valid); + if (valid) + mdb_putqword(changeD, value, 8); + DBGPrint("%016llX ", mdb_getqword(changeD, 8)); + changeD++; + } + if (DBGPrint("\n")) return 1; + } + return 1; + } + DBGPrint("invalid change (qword) address\n"); + return 1; +} + +/* CD */ + +unsigned long changeDoubleValue(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned char *changeBuffer = &workbuf[0][0]; + register unsigned long *changeD, oldD; + register unsigned long address, r, value, len, i; + unsigned char *pB; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + changeD = (unsigned long *) address; + changeBuffer[0] = '\0'; + DBGPrint("enter new value, to skip, or '.' to exit\n"); + while (changeBuffer[0] != '.') + { + DBGPrint("[%p] ", changeD); + for (r = 0; r < 2; r++) + { + oldD = (unsigned long) mdb_getword((unsigned long)changeD, 4); + DBGPrint("(%08X)=", (unsigned) oldD); + + ScreenInputFromKeyboard(&changeBuffer[0], 0, 8); + + if ((changeBuffer[0] == '.') || (changeBuffer[1] == '.') || + (changeBuffer[2] == '.') || (changeBuffer[3] == '.') || + (changeBuffer[4] == '.') || (changeBuffer[5] == '.') || + (changeBuffer[6] == '.') || (changeBuffer[7] == '.')) + break; + + pB = (unsigned char *) &changeBuffer[0]; + len = strlen(pB); + + for (i = 0; i < len; i++) + DBGPrint("\b"); + + value = EvaluateExpression(0, &pB, &valid); + if (valid) + mdb_putword((unsigned long)changeD, value, 4); + DBGPrint("%08X ", (unsigned)mdb_getword((unsigned long)changeD, 4)); + changeD++; + } + if (DBGPrint("\n")) return 1; + } + return 1; + } + DBGPrint("invalid change (dword) address\n"); + return 1; +} + +/* CB */ + +unsigned long changeByteValue(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned char *changeBuffer = &workbuf[0][0]; + register unsigned char *changeB, oldB; + unsigned char *pB; + register unsigned long address, r, value, len, i; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + changeB = (unsigned char *) address; + changeBuffer[0] = '\0'; + DBGPrint("enter new value, to skip, or '.' to exit\n"); + while (changeBuffer[0] != '.') + { + DBGPrint("[%p] ", changeB); + for (r = 0; r < 8; r++) + { + oldB = (unsigned char) mdb_getword((unsigned long)changeB, 1); + DBGPrint("(%02X)=", (unsigned) oldB); + + ScreenInputFromKeyboard(&changeBuffer[0], 0, 4); + + if ((changeBuffer[0] == '.') || (changeBuffer[1] == '.')) + break; + + pB = (unsigned char *) &changeBuffer[0]; + len = strlen(pB); + for (i = 0; i < len; i++) + DBGPrint("\b"); + + value = EvaluateExpression(0, &pB, &valid); + if (valid) + mdb_putword((unsigned long)changeB, value, 1); + DBGPrint("%02X ", (unsigned char) mdb_getword((unsigned long)changeB, 1)); + changeB++; + } + if (DBGPrint("\n")) return 1; + } + return 1; + } + DBGPrint("invalid change (byte) address\n"); + return 1; +} + +/* C */ + +unsigned long changeDefaultValue(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned char *changeBuffer = &workbuf[0][0]; + register unsigned char *changeB, oldB; + unsigned char *pB; + register unsigned long address, r, value, len, i; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + changeB = (unsigned char *) address; + changeBuffer[0] = '\0'; + DBGPrint("enter new value, to skip, or '.' to exit\n"); + while (changeBuffer[0] != '.') + { + DBGPrint("[%p] ", changeB); + for (r = 0; r < 8; r++) + { + oldB = (unsigned char) mdb_getword((unsigned long)changeB, 1); + DBGPrint("(%02X)=", (unsigned char) oldB); + + ScreenInputFromKeyboard(&changeBuffer[0], 0, 4); + + if ((changeBuffer[0] == '.') || (changeBuffer[1] == '.')) + break; + + pB = (unsigned char *) &changeBuffer[0]; + len = strlen(pB); + + for (i = 0; i < len; i++) + DBGPrint("\b"); + + value = EvaluateExpression(0, &pB, &valid); + if (valid) + mdb_putword((unsigned long)changeB, value, 1); + DBGPrint("%02X ", (unsigned char) mdb_getword((unsigned long)changeB, 1)); + changeB++; + } + if (DBGPrint("\n")) return 1; + } + return 1; + } + DBGPrint("invalid change (byte) address\n"); + return 1; + +} + +unsigned long displayCloseHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("?
- display closest symbols to
\n"); + return 1; + +} + +/* ? */ + +unsigned long displayCloseSymbols(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long oldD; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + oldD = EvaluateExpression(stackFrame, &cmd, &valid); + if (!valid) + oldD = GetIP(stackFrame); + DisplayClosestSymbol(oldD); + return 1; + +} + +unsigned long debuggerWalkStack(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; +#ifndef CONFIG_X86_64 + unsigned long address; +#endif + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (repeatCommand) + { + lastDumpAddress = dumpStack(stackFrame, + (unsigned char *)lastDumpAddress, lastDisplayLength); + return 1; + } +#ifdef CONFIG_X86_64 + lastDumpAddress = (unsigned char *) EvaluateExpression(stackFrame, &cmd, &valid); +#else + address = EvaluateExpression(stackFrame, &cmd, &valid); + lastDumpAddress = (unsigned char *) address; +#endif + if (!valid) + lastDumpAddress = (unsigned char *) GetStackAddress(stackFrame); + displayLength = EvaluateExpression(stackFrame, &cmd, &valid); + if (!displayLength || displayLength > 20) + displayLength = 20; + lastDumpAddress = dumpStack(stackFrame, (unsigned char *)lastDumpAddress, displayLength); + return 1; + +} + +unsigned long displayDumpHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("d
<#lines> - dump memory as bytes (8 bit)\n"); + DBGPrint("dw
<#lines> - dump memory as words (16 bit)\n"); + DBGPrint("dd
<#lines> - dump memory as double words (32 bit)\n"); + DBGPrint("dq
<#lines> - dump memory as quad words (64 bit)\n"); + DBGPrint("dl
<#lines> - dump linked list\n"); + DBGPrint("ds
<#lines> - dump stack\n"); + DBGPrint("dds
<#lines> - dump stack double word\n"); + DBGPrint("dqs
<#lines> - dump stack quad word\n"); + DBGPrint("w
- display symbols on the stack\n"); + + return 1; +} + +/* DL */ + +unsigned long debuggerDumpLinkedList(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + extern unsigned char *lastLinkAddress; +#ifndef CONFIG_X86_64 + unsigned long address; +#endif + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (repeatCommand) + { + lastLinkAddress = dumpLinkedList((unsigned char *)lastLinkAddress, lastDisplayLength, 0); + return 1; + } + +#ifdef CONFIG_X86_64 + lastLinkAddress = (unsigned char *) EvaluateNumericExpression(stackFrame, &cmd, &valid); +#else + address = EvaluateNumericExpression(stackFrame, &cmd, &valid); + lastLinkAddress = (unsigned char *) address; +#endif + if (!valid) + lastLinkAddress = (unsigned char *) GetStackAddress(stackFrame); + + displayLength = EvaluateNumericExpression(stackFrame, &cmd, &valid); + if (!displayLength || displayLength > 20) + displayLength = 20; + + lastLinkAddress = dumpLinkedList((unsigned char *)lastLinkAddress, displayLength, 0); + + return 1; + +} + +/* DW */ + +unsigned long debuggerDumpWord(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; +#ifndef CONFIG_X86_64 + unsigned long address; +#endif + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (repeatCommand) + { + lastDumpAddress = dumpWord((unsigned char *)lastDumpAddress, lastDisplayLength); + return 1; + } +#ifdef CONFIG_X86_64 + lastDumpAddress = (unsigned char *) EvaluateExpression(stackFrame, &cmd, &valid); +#else + address = EvaluateExpression(stackFrame, &cmd, &valid); + lastDumpAddress = (unsigned char *) address; +#endif + if (!valid) + lastDumpAddress = (unsigned char *) GetStackAddress(stackFrame); + displayLength = EvaluateExpression(stackFrame, &cmd, &valid); + if (!displayLength || displayLength > 20) + displayLength = 20; + lastDumpAddress = dumpWord((unsigned char *)lastDumpAddress, displayLength); + return 1; +} + +/* DS */ + +unsigned long debuggerDumpStack(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; +#ifndef CONFIG_X86_64 + unsigned long address; +#endif + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (repeatCommand) + { + lastDumpAddress = dumpStack(stackFrame, (unsigned char *)lastDumpAddress, lastDisplayLength); + return 1; + } +#ifdef CONFIG_X86_64 + lastDumpAddress = (unsigned char *) EvaluateExpression(stackFrame, &cmd, &valid); +#else + address = EvaluateExpression(stackFrame, &cmd, &valid); + lastDumpAddress = (unsigned char *) address; +#endif + if (!valid) + lastDumpAddress = (unsigned char *) GetStackAddress(stackFrame); + displayLength = EvaluateExpression(stackFrame, &cmd, &valid); + if (!displayLength || displayLength > 20) + displayLength = 20; + lastDumpAddress = dumpStack(stackFrame, (unsigned char *)lastDumpAddress, displayLength); + return 1; + +} + +/* DDS */ + +unsigned long debuggerDumpDoubleStack(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; +#ifndef CONFIG_X86_64 + unsigned long address; +#endif + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (repeatCommand) + { + lastDumpAddress = dumpDoubleStack(stackFrame, (unsigned char *)lastDumpAddress, + lastDisplayLength); + return 1; + } +#ifdef CONFIG_X86_64 + lastDumpAddress = (unsigned char *) EvaluateExpression(stackFrame, &cmd, &valid); +#else + address = EvaluateExpression(stackFrame, &cmd, &valid); + lastDumpAddress = (unsigned char *) address; +#endif + if (!valid) + lastDumpAddress = (unsigned char *) GetStackAddress(stackFrame); + displayLength = EvaluateExpression(stackFrame, &cmd, &valid); + if (!displayLength || displayLength > 20) + displayLength = 20; + lastDumpAddress = dumpDoubleStack(stackFrame, (unsigned char *)lastDumpAddress, + displayLength); + return 1; + +} + +/* DQS */ + +unsigned long debuggerDumpQuadStack(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; +#ifndef CONFIG_X86_64 + unsigned long address; +#endif + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (repeatCommand) + { + lastDumpAddress = dumpQuadStack(stackFrame, + (unsigned char *)lastDumpAddress, + lastDisplayLength); + return 1; + } +#ifdef CONFIG_X86_64 + lastDumpAddress = (unsigned char *) EvaluateExpression(stackFrame, &cmd, &valid); +#else + address = EvaluateExpression(stackFrame, &cmd, &valid); + lastDumpAddress = (unsigned char *) address; +#endif + if (!valid) + lastDumpAddress = (unsigned char *) GetStackAddress(stackFrame); + displayLength = EvaluateExpression(stackFrame, &cmd, &valid); + if (!displayLength || displayLength > 20) + displayLength = 20; + lastDumpAddress = dumpQuadStack(stackFrame, + (unsigned char *)lastDumpAddress, displayLength); + return 1; + +} + +/* DQ */ + +unsigned long debuggerDumpQuad(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; +#ifndef CONFIG_X86_64 + unsigned long address; +#endif + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (repeatCommand) + { + lastDumpAddress = dumpQuad((unsigned char *)lastDumpAddress, lastDisplayLength); + return 1; + } +#ifdef CONFIG_X86_64 + lastDumpAddress = (unsigned char *) EvaluateExpression(stackFrame, &cmd, &valid); +#else + address = EvaluateExpression(stackFrame, &cmd, &valid); + lastDumpAddress = (unsigned char *) address; +#endif + if (!valid) + lastDumpAddress = (unsigned char *) GetStackAddress(stackFrame); + displayLength = EvaluateExpression(stackFrame, &cmd, &valid); + if (!displayLength || displayLength > 20) + displayLength = 20; + lastDumpAddress = dumpQuad((unsigned char *)lastDumpAddress, displayLength); + return 1; + +} + +/* DD */ + +unsigned long debuggerDumpDouble(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; +#ifndef CONFIG_X86_64 + unsigned long address; +#endif + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (repeatCommand) + { + lastDumpAddress = dumpDouble((unsigned char *)lastDumpAddress, lastDisplayLength); + return 1; + } +#ifdef CONFIG_X86_64 + lastDumpAddress = (unsigned char *) EvaluateExpression(stackFrame, &cmd, &valid); +#else + address = EvaluateExpression(stackFrame, &cmd, &valid); + lastDumpAddress = (unsigned char *) address; +#endif + if (!valid) + lastDumpAddress = (unsigned char *) GetStackAddress(stackFrame); + displayLength = EvaluateExpression(stackFrame, &cmd, &valid); + if (!displayLength || displayLength > 20) + displayLength = 20; + lastDumpAddress = dumpDouble((unsigned char *)lastDumpAddress, displayLength); + return 1; + +} + +/* D */ + +unsigned long debuggerDumpByte(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; +#ifndef CONFIG_X86_64 + unsigned long address; +#endif + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (repeatCommand) + { + lastDumpAddress = dump((unsigned char *)lastDumpAddress, lastDisplayLength); + return 1; + } +#ifdef CONFIG_X86_64 + lastDumpAddress = (unsigned char *) EvaluateExpression(stackFrame, &cmd, &valid); +#else + address = EvaluateExpression(stackFrame, &cmd, &valid); + lastDumpAddress = (unsigned char *) address; +#endif + if (!valid) + lastDumpAddress = (unsigned char *) GetStackAddress(stackFrame); + displayLength = EvaluateExpression(stackFrame, &cmd, &valid); + if (!displayLength || displayLength > 20) + displayLength = 20; + lastDumpAddress = dump((unsigned char *)lastDumpAddress, displayLength); + return 1; + +} + +unsigned long displayDisassembleHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("id
<#lines> - unassemble code (ATT)\n"); + DBGPrint("u
<#lines> - unassemble code (INTEL)\n"); + DBGPrint("ux
<#lines> - unassemble code (32-bit)\n"); + DBGPrint("uu
<#lines> - unassemble code (16-bit)\n"); + return 1; +} + +/* UU */ + +unsigned long processDisassemble16(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (repeatCommand) + { + lastUnasmAddress = disassemble(stackFrame, + (unsigned long)lastUnasmAddress, + lastDisplayLength, 0, 0); + return 1; + } + lastUnasmAddress = EvaluateExpression(stackFrame, &cmd, &valid); + if (!valid) + { + if (!*cmd) + lastUnasmAddress = GetIP(stackFrame); + else + { + DBGPrint("invalid address for unassemble\n"); + return 1; + } + } + displayLength = EvaluateExpression(stackFrame, &cmd, &valid); + if (!displayLength || displayLength > 20) + displayLength = 20; + lastUnasmAddress = disassemble(stackFrame, + (unsigned long)lastUnasmAddress, + displayLength, 0, 0); + return 1; +} + +/* UX */ + +unsigned long processDisassemble32(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (repeatCommand) + { + lastUnasmAddress = disassemble(stackFrame, + (unsigned long)lastUnasmAddress, + lastDisplayLength, 1, 0); + return 1; + } + + lastUnasmAddress = EvaluateExpression(stackFrame, &cmd, &valid); + if (!valid) + { + if (!*cmd) + lastUnasmAddress = GetIP(stackFrame); + else + { + DBGPrint("invalid address for unassemble\n"); + return 1; + } + } + displayLength = EvaluateExpression(stackFrame, &cmd, &valid); + if (!displayLength || displayLength > 20) + displayLength = 20; + lastUnasmAddress = disassemble(stackFrame, + (unsigned long)lastUnasmAddress, + displayLength, 1, 0); + return 1; + +} +/* U */ + +unsigned long processDisassembleAny(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (repeatCommand) + { + lastUnasmAddress = disassemble(stackFrame, + (unsigned long)lastUnasmAddress, + lastDisplayLength, -1, 0); + return 1; + } + + lastUnasmAddress = EvaluateExpression(stackFrame, &cmd, &valid); + if (!valid) + { + if (!*cmd) + lastUnasmAddress = GetIP(stackFrame); + else + { + DBGPrint("invalid address for unassemble\n"); + return 1; + } + } + displayLength = EvaluateExpression(stackFrame, &cmd, &valid); + if (!displayLength || displayLength > 20) + displayLength = 20; + lastUnasmAddress = disassemble(stackFrame, + (unsigned long)lastUnasmAddress, + displayLength, -1, 0); + return 1; + +} +/* ID */ + +unsigned long processDisassembleATT(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + if (repeatCommand) + { + lastUnasmAddress = disassemble(stackFrame, + (unsigned long)lastUnasmAddress, + lastDisplayLength, -1, 1); + return 1; + } + + lastUnasmAddress = EvaluateExpression(stackFrame, &cmd, &valid); + if (!valid) + { + if (!*cmd) + lastUnasmAddress = GetIP(stackFrame); + else + { + DBGPrint("invalid address for unassemble\n"); + return 1; + } + } + displayLength = EvaluateExpression(stackFrame, &cmd, &valid); + if (!displayLength || displayLength > 20) + displayLength = 20; + lastUnasmAddress = disassemble(stackFrame, + (unsigned long)lastUnasmAddress, + displayLength, -1, 1); + return 1; + +} + diff -Naur linux-2.6.35.4/kernel/debug/mdb/mdb-base.h linux-2.6.35.4-cs/kernel/debug/mdb/mdb-base.h --- linux-2.6.35.4/kernel/debug/mdb/mdb-base.h 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/mdb-base.h 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,323 @@ + +/*************************************************************************** +* +* Copyright (c) 2008 Jeff V. Merkey All Rights Reserved. +* jeffmerkey@gmail.com +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation, version 2. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You are free to modify and re-distribute this program in accordance +* with the terms specified in the GNU Public License. The copyright +* contained in this code is required to be present in any derivative +* works and you are required to provide the source code for this +* program as part of any commercial or non-commercial distribution. +* You are required to respect the rights of the Copyright holders +* named within this code. +* +* jeffmerkey@gmail.com is the official maintainer of +* this code. You are encouraged to report any bugs, problems, fixes, +* suggestions, and comments about this software. +* +* AUTHOR : Jeff V. Merkey +* DESCRIP : Merkey's Linux Debugger +* +***************************************************************************/ + +#ifndef _MDB_BASE_H +#define _MDB_BASE_H + +extern unsigned long enterKeyACC(unsigned long key, void *stackFrame, + ACCELERATOR *accel); +extern unsigned long activateRegisterDisplayACC(unsigned long key, void *stackFrame, + ACCELERATOR *accel); + +extern unsigned long displayDebuggerHelpHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayDebuggerHelp(unsigned char *commandLine, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long ascTableHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayASCTable(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayToggleHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayToggleAll(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long ProcessTUToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long ProcessTBToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long ProcessTDToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long ProcessTLToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long ProcessTGToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long ProcessTCToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long ProcessTNToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long ProcessTRToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long ProcessToggleUser(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long ProcessTSToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long ProcessTAToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayDebuggerVersionHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long DisplayDebuggerVersion(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayKernelProcessHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayKernelProcess(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayKernelQueueHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayKernelQueue(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displaySymbolsHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displaySymbols(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayLoaderMapHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayLoaderMap(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayModuleHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayModuleInfo(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayProcessesHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayProcesses(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayRegistersHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayControlRegisters(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long displayAllRegisters(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long displaySegmentRegisters(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long displayNumericRegisters(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long displayGeneralRegisters(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long displayDefaultRegisters(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayAPICHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayAPICInfo(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long listProcessors(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long listProcessorFrame(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long ReasonHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ReasonDisplay(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayMPSHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayMPS(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long clearScreenHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long clearDebuggerScreen(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + + +extern unsigned long SearchMemoryHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long SearchMemory(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long SearchMemoryB(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long SearchMemoryW(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long SearchMemoryD(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long changeMemoryHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long changeWordValue(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long changeDoubleValue(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long changeQuadValue(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long changeByteValue(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long changeDefaultValue(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + + +extern unsigned long displayCloseHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayCloseSymbols(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + + +extern unsigned long displayINTRHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayInterruptTable(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + + +extern unsigned long viewScreensHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayScreenList(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + + +extern unsigned long displayIOAPICHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayIOAPICInfo(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + + + +extern unsigned long displayDumpHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long debuggerWalkStack(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long debuggerDumpLinkedList(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long debuggerDumpWord(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long debuggerDumpStack(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long debuggerDumpDoubleStack(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long debuggerDumpDouble(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long debuggerDumpQuadStack(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long debuggerDumpQuad(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long debuggerDumpByte(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + + +extern unsigned long displayDisassembleHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long processDisassemble16(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long processDisassemble32(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long processDisassembleAny(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long processDisassembleATT(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long rebootSystemHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long rebootSystem(unsigned char *cmd, StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displaySectionsHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displaySections(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long displayKernelProcessHelp(unsigned char *commandLine, + DEBUGGER_PARSER *parser); +extern unsigned long displayKernelProcess(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long displayProcessorStatusHelp(unsigned char *commandLine, + DEBUGGER_PARSER *parser); +extern unsigned long displayProcessorStatus(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long backTraceHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long backTraceAllPID(unsigned char *cmd, StackFrame *stackFrame, + unsigned long Exception, DEBUGGER_PARSER *parser); +extern unsigned long backTracePID(unsigned char *cmd, StackFrame *stackFrame, + unsigned long Exception, DEBUGGER_PARSER *parser); +extern unsigned long backTraceStack(unsigned char *cmd, StackFrame *stackFrame, + unsigned long Exception, DEBUGGER_PARSER *parser); +extern unsigned long timedBreakpointHelp(unsigned char *commandLine, + DEBUGGER_PARSER *parser); +extern unsigned long timerBreakpoint(unsigned char *cmd, + StackFrame *stackFrame, + unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long timerBreakpointClear(unsigned char *cmd, + StackFrame *stackFrame, + unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayProcessSwitchHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long switchKernelProcess(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +#if defined(CONFIG_MODULES) +extern unsigned long listModulesHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long listModules(unsigned char *cmd, StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long unloadModule(unsigned char *cmd, StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +#endif + +#endif diff -Naur linux-2.6.35.4/kernel/debug/mdb/mdb.h linux-2.6.35.4-cs/kernel/debug/mdb/mdb.h --- linux-2.6.35.4/kernel/debug/mdb/mdb.h 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/mdb.h 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,52 @@ + +/*************************************************************************** +* +* Copyright (c) 2008 Jeff V. Merkey All Rights Reserved. +* jeffmerkey@gmail.com +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation, version 2. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You are free to modify and re-distribute this program in accordance +* with the terms specified in the GNU Public License. The copyright +* contained in this code is required to be present in any derivative +* works and you are required to provide the source code for this +* program as part of any commercial or non-commercial distribution. +* You are required to respect the rights of the Copyright holders +* named within this code. +* +* jeffmerkey@gmail.com is the official maintainer of +* this code. You are encouraged to report any bugs, problems, fixes, +* suggestions, and comments about this software. +* +* AUTHOR : Jeff V. Merkey +* DESCRIP : Merkey's Linux Debugger +* +***************************************************************************/ + +#ifndef _MDB_H +#define _MDB_H + +/* screen output function */ +extern int mdb_printf(char *s, ...); +#define DBGPrint mdb_printf + +/* external entry points used by linux */ +#define DEBUGGER_EXCEPTION 1 +#define NMI_EXCEPTION 2 +#define BREAKPOINT_EXCEPTION 3 +#define GENERAL_PROTECTION 13 +#define PAGE_FAULT_EXCEPTION 14 +#define KEYBOARD_ENTRY 19 +#define SOFTWARE_EXCEPTION 22 + +/* internal trace messages */ +#define MDB_DEBUG_DEBUGGER 0 + +#endif diff -Naur linux-2.6.35.4/kernel/debug/mdb/mdb-ia-apic.c linux-2.6.35.4-cs/kernel/debug/mdb/mdb-ia-apic.c --- linux-2.6.35.4/kernel/debug/mdb/mdb-ia-apic.c 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/mdb-ia-apic.c 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,280 @@ + +/*************************************************************************** +* +* Copyright (c) 2008 Jeff V. Merkey All Rights Reserved. +* jeffmerkey@gmail.com +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation, version 2. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You are free to modify and re-distribute this program in accordance +* with the terms specified in the GNU Public License. The copyright +* contained in this code is required to be present in any derivative +* works and you are required to provide the source code for this +* program as part of any commercial or non-commercial distribution. +* You are required to respect the rights of the Copyright holders +* named within this code. +* +* jeffmerkey@gmail.com is the official maintainer of +* this code. You are encouraged to report any bugs, problems, fixes, +* suggestions, and comments about this software. +* +* AUTHOR : Jeff V. Merkey +* DESCRIP : Merkey's Linux Debugger +* +***************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(CONFIG_SMP) +#include +#include +#include +#endif + +#define __KERNEL_SYSCALLS__ +#include +#include + +#include "mdb.h" +#include "mdb-ia.h" +#include "mdb-list.h" +#include "mdb-ia-proc.h" +#include "mdb-base.h" +#include "mdb-proc.h" +#include "mdb-os.h" +#include "mdb-keyboard.h" + +#if defined(CONFIG_SMP) && !defined(CONFIG_X86_ELAN) + +extern unsigned int io_apic_read(unsigned int apic, unsigned int reg); +extern int nr_ioapics; + +unsigned long apic_directed_nmi(unsigned long cpu) +{ + apic->send_IPI_mask(cpumask_of(cpu), + APIC_DM_NMI | APIC_INT_LEVELTRIG | APIC_INT_ASSERT); + apic->send_IPI_mask(cpumask_of(cpu), + APIC_DM_NMI | APIC_INT_LEVELTRIG); + return 0; +} + +void dump_ioapic(unsigned long num) +{ + unsigned long i, val; + + if (num < nr_ioapics) + { + DBGPrint("io_apic registers\n"); + for (i = 0; i <= 0x2F; i++) + { + if ((i & 3) == 0) + DBGPrint("%08X: ", i); + + val = io_apic_read(num, i * 4); + DBGPrint("%08X ", val); + + if ((i & 3) == 3) + DBGPrint("\n"); + } + } + return; +} + +void dump_local_apic(void) +{ + unsigned long i, val; + + DBGPrint("local apic registers\n"); + for (i = 0; i <= 0x3F; i++) + { + if ((i & 3) == 0) + DBGPrint("%08X: ", i); + + val = apic_read(i * 4); + DBGPrint("%08X ", val); + + if ((i & 3) == 3) + DBGPrint("\n"); + } + +} + +void dump_remote_apic(unsigned long cpu) +{ + register unsigned long i, timeout, apicid; + register unsigned long val; + + DBGPrint("remote apic registers processor(%d)\n", cpu); + for (i = 0; i <= 0x3F; i++) + { + if ((i & 3) == 0) + DBGPrint("%08X: ", i); + + apicid = apic->cpu_present_to_apicid(cpu); + if (apicid == BAD_APICID) + { + DBGPrint("BADAPICX "); + continue; + } + + timeout = 0; + while (apic_read(APIC_ICR) & APIC_ICR_BUSY) + { + udelay(100); + if (timeout++ >= 1000) + break; + cpu_relax(); + touch_nmi_watchdog(); + } + + if (timeout >= 1000) + { + DBGPrint("???????? "); + continue; + } + + apic_write(APIC_ICR2, SET_APIC_DEST_FIELD(apicid)); + apic_write(APIC_ICR, i | APIC_DEST_LOGICAL | APIC_DM_REMRD); + + timeout = 0; + while ((apic_read(APIC_ICR) & APIC_ICR_RR_MASK) == APIC_ICR_RR_INPROG) + { + udelay(100); + if (timeout++ >= 1000) + break; + + cpu_relax(); + touch_nmi_watchdog(); + } + + if (timeout >= 1000) + { + DBGPrint("???????? "); + continue; + } + + if ((apic_read(APIC_ICR) & APIC_ICR_RR_MASK) == APIC_ICR_RR_VALID) + { + val = apic_read(APIC_RRR); + DBGPrint("%08X ", val); + } + else + { + DBGPrint("???????? "); + } + + if ((i & 3) == 3) + DBGPrint("\n"); + } + +} + +unsigned long displayAPICHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("apic - display local apic regs\n"); + DBGPrint("apic [p#] - display remote apic regs\n"); + return 1; +} + +/* APIC */ + +unsigned long displayAPICInfo(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long value; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid && ((value >= MAX_PROCESSORS) || !cpu_online(value))) + { + DBGPrint("processor not found\n"); + return 1; + } + if (valid && (value != get_processor_id())) + dump_remote_apic(value); + else + dump_local_apic(); + return 1; +} + +unsigned long displayIOAPICHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("ioapic [#] - display specified ioapic [#] regs\n"); + return 1; +} + +/* IOAPIC */ + +unsigned long displayIOAPICInfo(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long value; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid && !(value < nr_ioapics)) + { + DBGPrint("ioapic not found\n"); + return 1; + } + if (valid) + dump_ioapic(value); + else + dump_ioapic(0); + + return 1; + +} + +#endif /* CONFIG_SMP */ diff -Naur linux-2.6.35.4/kernel/debug/mdb/mdb-ia.c linux-2.6.35.4-cs/kernel/debug/mdb/mdb-ia.c --- linux-2.6.35.4/kernel/debug/mdb/mdb-ia.c 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/mdb-ia.c 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,6741 @@ + +/*************************************************************************** +* +* Copyright (c) 2008 Jeff V. Merkey All Rights Reserved. +* jeffmerkey@gmail.com +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation, version 2. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You are free to modify and re-distribute this program in accordance +* with the terms specified in the GNU Public License. The copyright +* contained in this code is required to be present in any derivative +* works and you are required to provide the source code for this +* program as part of any commercial or non-commercial distribution. +* You are required to respect the rights of the Copyright holders +* named within this code. +* +* jeffmerkey@gmail.com is the official maintainer of +* this code. You are encouraged to report any bugs, problems, fixes, +* suggestions, and comments about this software. +* +* AUTHOR : Jeff V. Merkey +* DESCRIP : Merkey's Linux Debugger +* +***************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(CONFIG_SMP) +#include +#include +#include +#endif + +#define __KERNEL_SYSCALLS__ +#include +#include + +#include "mdb.h" +#include "mdb-ia.h" +#include "mdb-list.h" +#include "mdb-ia-proc.h" +#include "mdb-base.h" +#include "mdb-proc.h" +#include "mdb-os.h" +#include "mdb-keyboard.h" + +unsigned long MajorVersion = 2627; +unsigned long MinorVersion = 9042008; +unsigned long BuildVersion = 6; + +unsigned char *IA32Flags[]= +{ + "CF", 0, "PF", 0, "AF", 0, "ZF", "SF", "TF", "IF", "DF", "OF", + 0, 0, "NT", 0, "RF", "VM", "AC", "VIF","VIP","ID", 0, 0, + 0, +}; + +unsigned char *BreakDescription[]= +{ + "EXECUTE", "WRITE", "IOPORT", "READ/WRITE", +}; + +unsigned char *BreakLengthDescription[]={ + ": 1 BYTE", ": 2 BYTE", ": ??????", ": 4 BYTE", +}; + +unsigned char *ExceptionDescription[]={ + "Divide By Zero", /* 0 */ + "Debugger Exception (INT1)", /* 1 */ + "Non-Maskable Interrupt", /* 2 */ + "Debugger Breakpoint (INT3)", /* 3 */ + "Overflow Exception", /* 4 */ + "Bounds Check", /* 5 */ + "Invalid Opcode", /* 6 */ + "No Coprocessor", /* 7 */ + "Double Fault", /* 8 */ + "Cops Error", /* 9 */ + "Invalid Task State Segment", /* 10 */ + "Segment Not Present", /* 11 */ + "Stack Exception", /* 12 */ + "General Protection", /* 13 */ + "Page Fault", /* 14 */ + "InvalidInterrupt", /* 15 */ + "Coprocessor Error", /* 16 */ + "AlignmentCheck", /* 17 */ + "Machine Check", /* 18 */ + "Enter Debugger Request", /* 19 */ + "Unvectored Exception", /* 20 */ + "Directed NMI Breakpoint", /* 21 */ + "Panic" /* 22 */ +}; +unsigned long exceptions = (sizeof(ExceptionDescription) / sizeof(unsigned char *)); + +unsigned char char32spc[] = { "xxxúxxxúxxxúxxxùxxxúxxxúxxxúxxx " }; +unsigned char flset[] = { "VMRF NT OFDNIETFMIZR AC PE CY" }; +unsigned char floff[] = { " UPID PLNZ PO NC" }; +unsigned char fluse[] = { 1,1,0,1,0,0,1,1,1,1,1,1,0,1,0,1,0,1 }; + +unsigned long MTRR_BASE_REGS[] = { + MTRR_PHYS_BASE_0, MTRR_PHYS_BASE_1, MTRR_PHYS_BASE_2, MTRR_PHYS_BASE_3, + MTRR_PHYS_BASE_4, MTRR_PHYS_BASE_5, MTRR_PHYS_BASE_6, MTRR_PHYS_BASE_7 +}; + +unsigned long MTRR_MASK_VALUES[] = { + MTRR_PHYS_MASK_0, MTRR_PHYS_MASK_1, MTRR_PHYS_MASK_2, MTRR_PHYS_MASK_3, + MTRR_PHYS_MASK_4, MTRR_PHYS_MASK_5, MTRR_PHYS_MASK_6, MTRR_PHYS_MASK_7 +}; + +#define PROCESSOR_INACTIVE 0 +#define PROCESSOR_ACTIVE 1 +#define PROCESSOR_SUSPEND 2 +#define PROCESSOR_RESUME 3 +#define PROCESSOR_DEBUG 4 +#define PROCESSOR_SHUTDOWN 5 +#define PROCESSOR_IPI 6 +#define PROCESSOR_SWITCH 7 +#define PROCESSOR_HOLD 8 + +#define PIC1_DEBUG_MASK 0xFC +#define PIC2_DEBUG_MASK 0xFF + +#define MAX_PICS 3 +#define PIC_0 0x20 +#define PIC_1 0xA0 +#define PIC_2 0x30 +#define MASK_0 0x21 +#define MASK_1 0xA1 +#define MASK_2 0x31 + +unsigned char irq_control[MAX_PICS] = { PIC_0, PIC_1, PIC_2 }; +unsigned char irq_mask[MAX_PICS] = { MASK_0, MASK_1, MASK_2 }; +unsigned char mask_value[MAX_PICS] = { 0xF8, 0xFF, 0xFF }; + +StackFrame ReferenceFrame[MAX_PROCESSORS]; +NUMERIC_FRAME npx[MAX_PROCESSORS]; + +#if defined(CONFIG_SMP) +volatile rlock_t debug_mutex = { SPIN_LOCK_UNLOCKED, -1, 0 }; +#else +volatile rlock_t debug_mutex = { -1, 0 }; +#endif + +atomic_t focusActive; /* cpus is focus */ +atomic_t debuggerActive; /* cpus in the debugger */ +atomic_t debuggerProcessors[MAX_PROCESSORS]; /* cpus in handlers */ +atomic_t nmiProcessors[MAX_PROCESSORS]; /* cpus suspended */ +atomic_t traceProcessors[MAX_PROCESSORS]; /* focus processor mode */ +volatile unsigned long ProcessorHold[MAX_PROCESSORS]; +volatile unsigned long ProcessorState[MAX_PROCESSORS]; + +unsigned char *procState[]={ + "PROCESSOR_INACTIVE", "PROCESSOR_ACTIVE ", "PROCESSOR_SUSPEND ", + "PROCESSOR_RESUME ", "PROCESSOR_DEBUG ", "PROCESSOR_SHUTDOWN", + "PROCESSOR_IPI ", "PROCESSOR_SWITCH ", "PROCESSOR_HOLD ", + "? ", "? ", "? ", + "? ", "? ", "? ", + "? " +}; + +/* debugger commands */ + +DEBUGGER_PARSER backTraceAllPidPE = { +0, 0, backTraceAllPID, backTraceHelp, 0, "BTA", 0, 0, +"display stack backtrace for all processes" , 0 }; + +DEBUGGER_PARSER backTracePidPE = { +0, 0, backTracePID, backTraceHelp, 0, "BTP", 0, 0, +"display stack backtrace by pid" , 0 }; + +DEBUGGER_PARSER backTraceStackPE = { +0, 0, backTraceStack, backTraceHelp, 0, "BT", 0, 0, +"display stack backtrace by address" , 0 }; + +DEBUGGER_PARSER cpuFramePE = { +0, 0, listProcessorFrame, processorCommandHelp, 0, "LR", 0, 0, +"display cpu registers" , 0 }; + +DEBUGGER_PARSER ProcessorPE = { +0, 0, displayProcessorStatus, displayProcessorStatusHelp, 0, "PROCESSORS", 0, 0, +"display processor status" , 0 }; + +DEBUGGER_PARSER HPE = { +0, 0, displayDebuggerHelp, displayDebuggerHelpHelp, 0, "HELP", 0, 0, +"this help screen (type HELP for specific help)" , 0 }; + +DEBUGGER_PARSER HelpPE = { +0, 0, displayDebuggerHelp, displayDebuggerHelpHelp, 0, "H", 0, 0, +"this help screen" , 0 }; + +DEBUGGER_PARSER clearScreenPE = { +0, 0, clearDebuggerScreen, clearScreenHelp, 0, "CLS", 0, 0, +"clear the screen" , 0 }; + +DEBUGGER_PARSER asciiTablePE = { +0, 0, displayASCTable, ascTableHelp, 0, "A", 0, 0, +"display ASCII Table" , 0 }; + +DEBUGGER_PARSER displayToggle1 = { +0, 0, displayToggleAll, displayToggleHelp, 0, ".TOGGLE", 0, 0, +"show all current toggle settings" , 0 }; + +DEBUGGER_PARSER displayToggle2 = { +0, 0, displayToggleAll, displayToggleHelp, 0, "TOGGLE", 0, 0, +"show all current toggle settings" , 0 }; + +DEBUGGER_PARSER TBTogglePE = { +0, 0, ProcessTBToggle, displayToggleHelp, 0, ".TB", 0, 0, +"toggle disable breakpoints in user address space (ON | OFF)" , 0 }; + +DEBUGGER_PARSER TUTogglePE = { +0, 0, ProcessTUToggle, displayToggleHelp, 0, ".TU", 0, 0, +"toggles unasm debug display (ON | OFF)" , 0 }; + +DEBUGGER_PARSER TDTogglePE = { +0, 0, ProcessTDToggle, displayToggleHelp, 0, ".TD", 0, 0, +"toggles full dereference display (ON | OFF)" , 0 }; + +DEBUGGER_PARSER TLTogglePE = { +0, 0, ProcessTLToggle, displayToggleHelp, 0, ".TL", 0, 0, +"toggles source line display (ON | OFF)" , 0 }; + +DEBUGGER_PARSER TGTogglePE = { +0, 0, ProcessTGToggle, displayToggleHelp, 0, ".TG", 0, 0, +"toggles general registers (ON | OFF)" , 0 }; + +DEBUGGER_PARSER TCTogglePE = { +0, 0, ProcessTCToggle, displayToggleHelp, 0, ".TC", 0, 0, +"toggles control registers (ON | OFF)" , 0 }; + +DEBUGGER_PARSER TNTogglePE = { +0, 0, ProcessTNToggle, displayToggleHelp, 0, ".TN", 0, 0, +"toggles coprocessor registers (ON | OFF)" , 0 }; + +DEBUGGER_PARSER TRTogglePE = { +0, 0, ProcessTRToggle, displayToggleHelp, 0, ".TR", 0, 0, +"toggles display of break reason (ON | OFF)" , 0 }; + +DEBUGGER_PARSER TSTogglePE = { +0, 0, ProcessTSToggle, displayToggleHelp, 0, ".TS", 0, 0, +"toggles segment registers (ON | OFF)" , 0 }; + +DEBUGGER_PARSER TATogglePE = { +0, 0, ProcessTAToggle, displayToggleHelp, 0, ".TA", 0, 0, +"toggles all registers (ON | OFF)" , 0 }; + +DEBUGGER_PARSER ToggleUser = { +0, 0, ProcessToggleUser, displayToggleHelp, 0, ".TM", 0, 0, +"toggle memory reads/write to map user space address ranges < PAGE_OFFSET" , 0 }; + +DEBUGGER_PARSER ReasonPE = { +0, 0, ReasonDisplay, ReasonHelp, 0, ".A", 0, 0, +"display break reason" , 0 }; + +DEBUGGER_PARSER TTogglePE = { +0, 0, TSSDisplay, TSSDisplayHelp, 0, ".T", 0, 0, +"display task state segment (tss)" , 0 }; + +DEBUGGER_PARSER versionPE = { +0, 0, DisplayDebuggerVersion, displayDebuggerVersionHelp, 0, ".V", 0, 0, +"display version info" , 0 }; + +#if defined(CONFIG_MODULES) +DEBUGGER_PARSER lsmodPE1 = { +0, 0, listModules, listModulesHelp, 0, ".M", 0, 0, +"list loaded modules" , 0 }; + +DEBUGGER_PARSER lsmodPE2 = { +0, 0, listModules, listModulesHelp, 0, "LSMOD", 0, 0, +"list loaded modules" , 0 }; + +DEBUGGER_PARSER rmmodPE = { +0, 0, unloadModule, listModulesHelp, 0, "RMMOD", 0, 0, +"unload module" , 0 }; +#endif + +DEBUGGER_PARSER rebootPE = { +0, 0, rebootSystem, rebootSystemHelp, 0, "REBOOT", 0, 0, +"reboot host system" , 0 }; + +DEBUGGER_PARSER KernelProcessPE1 = { +0, 0, displayKernelProcess, displayKernelProcessHelp, 0, ".P", 0, 0, +"display kernel processes" , 0 }; + +DEBUGGER_PARSER KernelProcessPE2 = { +0, 0, displayKernelProcess, displayKernelProcessHelp, 0, "PS", 0, 0, +"display kernel processes" , 0 }; + +/* +DEBUGGER_PARSER SwitchProcess = { +0, 0, switchKernelProcess, displayKernelSwitchProcessHelp, 0, "PID", 0, 0, +"switch running kernel process" , 0 }; + +DEBUGGER_PARSER SectionPE1 = { +0, 0, displaySections, displaySectionsHelp, 0, ".S", 0, 0, +"display kernel/module sections" , 0 }; + +DEBUGGER_PARSER SectionPE2 = { +0, 0, displaySections, displaySectionsHelp, 0, "SECTIONS", 0, 0, +"display kernel/module sections" , 0 }; +*/ + +DEBUGGER_PARSER AllSymbolsPE = { +0, 0, displaySymbols, displaySymbolsHelp, 0, "SYMBOL", 0, 0, +"display symbol(s)" , 0 }; + +DEBUGGER_PARSER SymbolsPE = { +0, 0, displaySymbols, displaySymbolsHelp, 0, ".Z", 0, 0, +"display symbol(s)" , 0 }; + +DEBUGGER_PARSER ControlPE = { +0, 0, displayControlRegisters, displayRegistersHelp, 0, "RC", 0, 0, +"display control registers" , 0 }; + +DEBUGGER_PARSER AllPE = { +0, 0, displayAllRegisters, displayRegistersHelp, 0, "RA", 0, 0, +"display all registers" , 0 }; + +DEBUGGER_PARSER SegmentPE = { +0, 0, displaySegmentRegisters, displayRegistersHelp, 0, "RS", 0, 0, +"display segment registers" , 0 }; + +DEBUGGER_PARSER NumericPE = { +0, 0, displayNumericRegisters, displayRegistersHelp, 0, "RN", 0, 0, +"display coprocessor/MMX registers" , 0 }; + +DEBUGGER_PARSER GeneralPE = { +0, 0, displayGeneralRegisters, displayRegistersHelp, 0, "RG", 0, 0, +"display general registers" , 0 }; + +DEBUGGER_PARSER DefaultPE = { +0, 0, displayDefaultRegisters, displayRegistersHelp, 0, "R", 0, 0, +"display registers for a processor" , 0 }; + +DEBUGGER_PARSER SearchMemoryBPE = { +0, 0, SearchMemoryB, SearchMemoryHelp, 0, "SB", 0, 0, +"search memory for pattern (bytes)" , 0 }; + +DEBUGGER_PARSER SearchMemoryWPE = { +0, 0, SearchMemoryW, SearchMemoryHelp, 0, "SW", 0, 0, +"search memory for pattern (words)" , 0 }; + +DEBUGGER_PARSER SearchMemoryDPE = { +0, 0, SearchMemoryD, SearchMemoryHelp, 0, "SD", 0, 0, +"search memory for pattern (dwords)" , 0 }; + +DEBUGGER_PARSER ChangeWordPE = { +0, 0, changeWordValue, changeMemoryHelp, 0, "CW", 0, 0, +"change words at address" , 0 }; + +DEBUGGER_PARSER ChangeDoublePE = { +0, 0, changeDoubleValue, changeMemoryHelp, 0, "CD", 0, 0, +"change dwords at address" , 0 }; + +DEBUGGER_PARSER ChangeBytePE = { +0, 0, changeByteValue, changeMemoryHelp, 0, "CB", 0, 0, +"change bytes at address" , 0 }; + +DEBUGGER_PARSER ChangeDefaultPE = { +0, 0, changeDefaultValue, changeMemoryHelp, 0, "C", 0, 0, +"change bytes at address" , 0 }; + +DEBUGGER_PARSER CloseSymbolsPE = { +0, 0, displayCloseSymbols, displayCloseHelp, 0, "?", 0, 0, +"display closest symbols to
" , 0 }; + +DEBUGGER_PARSER WalkPE = { +0, 0, debuggerWalkStack, displayDumpHelp, 0, "W", 0, 0, +"display symbols on the stack" , 0 }; + +DEBUGGER_PARSER DumpLinkedPE = { +0, 0, debuggerDumpLinkedList, displayDumpHelp, 0, "DL", 0, 0, +"dump linked list" , 0 }; + +DEBUGGER_PARSER DumpWordPE = { +0, 0, debuggerDumpWord, displayDumpHelp, 0, "DW", 0, 0, +"dump memory as words" , 0 }; + +DEBUGGER_PARSER DumpStackPE = { +0, 0, debuggerDumpStack, displayDumpHelp, 0, "DS", 0, 0, +"dump stack" , 0 }; + +DEBUGGER_PARSER DumpDoubleStackPE = { +0, 0, debuggerDumpDoubleStack, displayDumpHelp, 0, "DDS", 0, 0, +"dump stack double word" , 0 }; + +DEBUGGER_PARSER DumpQuadStackPE = { +0, 0, debuggerDumpQuadStack, displayDumpHelp, 0, "DQS", 0, 0, +"dump stack quad word" , 0 }; + +DEBUGGER_PARSER DumpDoublePE = { +0, 0, debuggerDumpDouble, displayDumpHelp, 0, "DD", 0, 0, +"dump memory as double words" , 0 }; + +DEBUGGER_PARSER DumpQuadPE = { +0, 0, debuggerDumpQuad, displayDumpHelp, 0, "DQ", 0, 0, +"dump memory as quad words" , 0 }; + +DEBUGGER_PARSER DumpBytePE = { +0, 0, debuggerDumpByte, displayDumpHelp, 0, "DB", 0, 0, +"dump memory as bytes" , 0 }; + +DEBUGGER_PARSER DumpDefaultPE = { +0, 0, debuggerDumpByte, displayDumpHelp, 0, "D", 0, 0, +"dump memory as bytes" , 0 }; + +DEBUGGER_PARSER Diss16PE = { +0, 0, processDisassemble16, displayDisassembleHelp, 0, "UU", 0, 0, +"unassemble code (16-bit)" , 0 }; + +DEBUGGER_PARSER Diss32PE = { +0, 0, processDisassemble32, displayDisassembleHelp, 0, "UX", 0, 0, +"unassemble code (32-bit)" , 0 }; + +DEBUGGER_PARSER DissAnyPE = { +0, 0, processDisassembleAny, displayDisassembleHelp, 0, "U", 0, 0, +"unassemble code (INTEL)" , 0 }; + +DEBUGGER_PARSER IdPE = { +0, 0, processDisassembleATT, displayDisassembleHelp, 0, "ID", 0, 0, +"unassemble code (ATT)" , 0 }; + +DEBUGGER_PARSER ProceedPE = { +0, 0, processProceed, executeCommandHelp, 0, "P", 0, 0, +"proceed" , -1 }; + +DEBUGGER_PARSER TracePE = { +0, 0, processTrace, executeCommandHelp, 0, "T", 0, 0, +"trace" , -1 }; + +DEBUGGER_PARSER SingleStepPE = { +0, 0, processTrace, executeCommandHelp, 0, "S", 0, 0, +"single step" , -1 }; + +DEBUGGER_PARSER TraceSSPE = { +0, 0, processTrace, executeCommandHelp, 0, "SS", 0, 0, +"single step" , -1 }; + +DEBUGGER_PARSER TraceSSBPE = { +0, 0, processTraceSSB, executeCommandHelp, 0, "SSB", 0, 0, +"single step til branch", -1 }; + +DEBUGGER_PARSER GPE = { +0, 0, processGo, executeCommandHelp, 0, "G", 0, 0, +"g or g til
match" , -1 }; + +DEBUGGER_PARSER GoPE = { +0, 0, processGo, executeCommandHelp, 0, "GO", 0, 0, +"go or go til
match" , -1 }; + +DEBUGGER_PARSER QPE = { +0, 0, processGo, executeCommandHelp, 0, "Q", 0, 0, +"quit debugger until
match" , -1 }; + +DEBUGGER_PARSER XPE = { +0, 0, processGo, executeCommandHelp, 0, "X", 0, 0, +"exit debugger until
match" , -1 }; + +DEBUGGER_PARSER BreakProcessorPE = { +0, 0, breakProcessor, processorCommandHelp, 0, "CPU", 0, 0, +"switch processor" , -1 }; + +DEBUGGER_PARSER ListProcessorsPE = { +0, 0, listProcessors, processorCommandHelp, 0, "LCPU", 0, 0, +"list processors" , 0 }; + +DEBUGGER_PARSER EAXPE = { +0, 0, ChangeEAXRegister, displayEAXHelp, 0, "EAX", 0, -1, +"", 0 }; + +DEBUGGER_PARSER ORIGEAXPE = { +0, 0, ChangeORIGEAXRegister, displayEAXHelp, 0, "ORGEAX", 0, -1, +"", 0 }; + +DEBUGGER_PARSER EBXPE = { +0, 0, ChangeEBXRegister, displayEBXHelp, 0, "EBX", 0, -1, +"", 0 }; + +DEBUGGER_PARSER ECXPE = { +0, 0, ChangeECXRegister, displayECXHelp, 0, "ECX", 0, -1, +"", 0 }; + +DEBUGGER_PARSER EDXPE = { +0, 0, ChangeEDXRegister, displayEDXHelp, 0, "EDX", 0, -1, +"", 0 }; + +DEBUGGER_PARSER ESIPE = { +0, 0, ChangeESIRegister, displayESIHelp, 0, "ESI", 0, -1, +"", 0 }; + +DEBUGGER_PARSER EDIPE = { +0, 0, ChangeEDIRegister, displayEDIHelp, 0, "EDI", 0, -1, +"", 0 }; + +DEBUGGER_PARSER EBPPE = { +0, 0, ChangeEBPRegister, displayEBPHelp, 0, "EBP", 0, -1, +"", 0 }; + +DEBUGGER_PARSER ESPPE = { +0, 0, ChangeESPRegister, displayESPHelp, 0, "ESP", 0, -1, +"", 0 }; + +DEBUGGER_PARSER EIPPE = { +0, 0, ChangeEIPRegister, displayEIPHelp, 0, "EIP", 0, -1, +"", 0 }; + +#ifdef CONFIG_X86_64 +DEBUGGER_PARSER RAXPE = { +0, 0, ChangeRAXRegister, displayRAXHelp, 0, "RAX", 0, -1, +"", 0 }; + +DEBUGGER_PARSER ORIGRAXPE = { +0, 0, ChangeORIGRAXRegister, displayRAXHelp, 0, "ORGRAX", 0, -1, +"", 0 }; + +DEBUGGER_PARSER RBXPE = { +0, 0, ChangeRBXRegister, displayRBXHelp, 0, "RBX", 0, -1, +"", 0 }; + +DEBUGGER_PARSER RCXPE = { +0, 0, ChangeRCXRegister, displayRCXHelp, 0, "RCX", 0, -1, +"", 0 }; + +DEBUGGER_PARSER RDXPE = { +0, 0, ChangeRDXRegister, displayRDXHelp, 0, "RDX", 0, -1, +"", 0 }; + +DEBUGGER_PARSER RSIPE = { +0, 0, ChangeRSIRegister, displayRSIHelp, 0, "RSI", 0, -1, +"", 0 }; + +DEBUGGER_PARSER RDIPE = { +0, 0, ChangeRDIRegister, displayRDIHelp, 0, "RDI", 0, -1, +"", 0 }; + +DEBUGGER_PARSER RBPPE = { +0, 0, ChangeRBPRegister, displayRBPHelp, 0, "RBP", 0, -1, +"", 0 }; + +DEBUGGER_PARSER RSPPE = { +0, 0, ChangeRSPRegister, displayRSPHelp, 0, "RSP", 0, -1, +"", 0 }; + +DEBUGGER_PARSER RIPPE = { +0, 0, ChangeRIPRegister, displayRIPHelp, 0, "RIP", 0, -1, +"", 0 }; + +DEBUGGER_PARSER R8PE = { +0, 0, ChangeR8Register, displayR8Help, 0, "R8", 0, -1, +"", 0 }; + +DEBUGGER_PARSER R9PE = { +0, 0, ChangeR9Register, displayR9Help, 0, "R9", 0, -1, +"", 0 }; + +DEBUGGER_PARSER R10PE = { +0, 0, ChangeR10Register, displayR10Help, 0, "R10", 0, -1, +"", 0 }; + +DEBUGGER_PARSER R11PE = { +0, 0, ChangeR11Register, displayR11Help, 0, "R11", 0, -1, +"", 0 }; + +DEBUGGER_PARSER R12PE = { +0, 0, ChangeR12Register, displayR12Help, 0, "R12", 0, -1, +"", 0 }; + +DEBUGGER_PARSER R13PE = { +0, 0, ChangeR13Register, displayR13Help, 0, "R13", 0, -1, +"", 0 }; + +DEBUGGER_PARSER R14PE = { +0, 0, ChangeR14Register, displayR14Help, 0, "R14", 0, -1, +"", 0 }; + +DEBUGGER_PARSER R15PE = { +0, 0, ChangeR15Register, displayR15Help, 0, "R15", 0, -1, +"", 0 }; + +#endif + +DEBUGGER_PARSER CSPE = { +0, 0, ChangeCSRegister, displayCSHelp, 0, "XCS", 0, -1, +"", 0 }; + +#ifndef CONFIG_X86_64 +DEBUGGER_PARSER DSPE = { +0, 0, ChangeDSRegister, displayDSHelp, 0, "XDS", 0, -1, +"", 0 }; + +DEBUGGER_PARSER ESPE = { +0, 0, ChangeESRegister, displayESHelp, 0, "XES", 0, -1, +"", 0 }; +#endif + +DEBUGGER_PARSER FSPE = { +0, 0, ChangeFSRegister, displayFSHelp, 0, "XFS", 0, -1, +"", 0 }; + +DEBUGGER_PARSER GSPE = { +0, 0, ChangeGSRegister, displayGSHelp, 0, "XGS", 0, -1, +"", 0 }; + +DEBUGGER_PARSER SSPE = { +0, 0, ChangeSSRegister, displaySSHelp, 0, "XSS", 0, -1, +"", 0 }; + +DEBUGGER_PARSER RFPE = { +0, 0, ChangeRFFlag, displayRFHelp, 0, "RF", 0, -1, +"", 0 }; + +DEBUGGER_PARSER TFPE = { +0, 0, ChangeTFFlag, displayTFHelp, 0, "TF", 0, -1, +"", 0 }; + +DEBUGGER_PARSER ZFPE = { +0, 0, ChangeZFFlag, displayZFHelp, 0, "ZF", 0, -1, +"", 0 }; + +DEBUGGER_PARSER SFPE = { +0, 0, ChangeSFFlag, displaySFHelp, 0, "SF", 0, -1, +"", 0 }; + +DEBUGGER_PARSER PFPE = { +0, 0, ChangePFFlag, displayPFHelp, 0, "PF", 0, -1, +"", 0 }; + +DEBUGGER_PARSER CFPE = { +0, 0, ChangeCFFlag, displayCFHelp, 0, "CF", 0, -1, +"", 0 }; + +DEBUGGER_PARSER OFPE = { +0, 0, ChangeOFFlag, displayOFHelp, 0, "OF", 0, -1, +"", 0 }; + +DEBUGGER_PARSER IFPE = { +0, 0, ChangeIFFlag, displayIFHelp, 0, "IF", 0, -1, +"", 0 }; + +DEBUGGER_PARSER IDPE = { +0, 0, ChangeIDFlag, displayIDHelp, 0, "CPUID", 0, -1, +"", 0 }; + +DEBUGGER_PARSER DFPE = { +0, 0, ChangeDFFlag, displayDFHelp, 0, "DF", 0, -1, +"", 0 }; + +DEBUGGER_PARSER NTPE = { +0, 0, ChangeNTFlag, displayNTHelp, 0, "NT", 0, -1, +"", 0 }; + +DEBUGGER_PARSER VMPE = { +0, 0, ChangeVMFlag, displayVMHelp, 0, "VM", 0, -1, +"", 0 }; + +DEBUGGER_PARSER VIFPE = { +0, 0, ChangeVIFFlag, displayVIFHelp, 0, "VIF", 0, -1, +"", 0 }; + +DEBUGGER_PARSER VIPPE = { +0, 0, ChangeVIPFlag, displayVIPHelp, 0, "VIP", 0, -1, +"", 0 }; + +DEBUGGER_PARSER AFPE = { +0, 0, ChangeAFFlag, displayAFHelp, 0, "AF", 0, -1, +"", 0 }; + +DEBUGGER_PARSER ACPE = { +0, 0, ChangeACFlag, displayACHelp, 0, "AC", 0, -1, +"", 0 }; + +DEBUGGER_PARSER MTRRPE = { +0, 0, DisplayMTRRRegisters, displayMTRRHelp, 0, "MTRR", 0, 0, +"display memory type range registers" , 0 }; + +#if defined(CONFIG_SMP) && !defined(CONFIG_X86_ELAN) +DEBUGGER_PARSER APIC_PE = { +0, 0, displayAPICInfo, displayAPICHelp, 0, "APIC", 0, 0, +"display local apic registers", 0 }; + +DEBUGGER_PARSER IOAPIC_PE = { +0, 0, displayIOAPICInfo, displayIOAPICHelp, 0, "IOAPIC", 0, 0, +"display io apic registers", 0 }; + +DEBUGGER_PARSER NMIProcessorPE = { +0, 0, nmiProcessor, processorCommandHelp, 0, "NMI", 0, 0, +"nmi processor (WARNING: See 'help nmi' for instructions)", -1 }; +#endif + +DEBUGGER_PARSER GDTPE = { +0, 0, displayGDT, displayGDTHelp, 0, ".G", 0, 0, +"display global descriptor table" , 0 }; + +DEBUGGER_PARSER IDTPE = { +0, 0, displayIDT, displayIDTHelp, 0, ".I", 0, 0, +"display interrupt descriptor table" , 0 }; + +DEBUGGER_PARSER EvaluatePE = { +0, 0, evaluateExpression, evaluateExpressionHelp, 0, ".E", 0, 0, +"evaluate expression (help .e)" , 0 }; + +DEBUGGER_PARSER InputWordPE = { +0, 0, inputWordPort, portCommandHelp, 0, "IW", 0, 0, +"input word from port" , 0 }; + +DEBUGGER_PARSER InputDoublePE = { +0, 0, inputDoublePort, portCommandHelp, 0, "IL", 0, 0, +"input double word from port" , 0 }; + +DEBUGGER_PARSER InputBytePE = { +0, 0, inputBytePort, portCommandHelp, 0, "IB", 0, 0, +"input byte from port" , 0 }; + +DEBUGGER_PARSER InputPE = { +0, 0, inputPort, portCommandHelp, 0, "I", 0, 0, +"input byte from port" , 0 }; + +DEBUGGER_PARSER OutputWordPE = { +0, 0, outputWordPort, portCommandHelp, 0, "OW", 0, 0, +"output word to port" , 0 }; + +DEBUGGER_PARSER OutputDoublePE = { +0, 0, outputDoublePort, portCommandHelp, 0, "OL", 0, 0, +"output double word to port" , 0 }; + +DEBUGGER_PARSER OutputBytePE = { +0, 0, outputBytePort, portCommandHelp, 0, "OB", 0, 0, +"output byte to port" , 0 }; + +DEBUGGER_PARSER OutputPE = { +0, 0, outputPort, portCommandHelp, 0, "O", 0, 0, +"output byte to port" , 0 }; + +DEBUGGER_PARSER BreakClearAllPE = { +0, 0, breakpointClearAll, breakpointCommandHelp, 0, "BCA", 0, 0, +"clear all breakpoints" , 0 }; + +DEBUGGER_PARSER BreakClearPE = { +0, 0, breakpointClear, breakpointCommandHelp, 0, "BC", 0, 0, +"clear breakpoint" , 0 }; + +DEBUGGER_PARSER BreakMaskPE = { +0, 0, breakpointMask, breakpointCommandHelp, 0, "BM", 0, 0, +"mask breaks for specific processor" , 0 }; + +DEBUGGER_PARSER BW1PE = { +0, 0, breakpointWord1, breakpointCommandHelp, 0, "BW1", 0, -1, +"" , 0 }; + +DEBUGGER_PARSER BW2PE = { +0, 0, breakpointWord2, breakpointCommandHelp, 0, "BW2", 0, -1, +"" , 0 }; + +DEBUGGER_PARSER BW4PE = { +0, 0, breakpointWord4, breakpointCommandHelp, 0, "BW4", 0, -1, +"" , 0 }; + +DEBUGGER_PARSER BWPE = { +0, 0, breakpointWord, breakpointCommandHelp, 0, "BW", 0, 0, +"set write only breakpoint #=1,2 or 4 byte len" , 0 }; + +DEBUGGER_PARSER BR1PE = { +0, 0, breakpointRead1, breakpointCommandHelp, 0, "BR1", 0, -1, +"", 0 }; + +DEBUGGER_PARSER BR2PE = { +0, 0, breakpointRead2, breakpointCommandHelp, 0, "BR2", 0, -1, +"", 0 }; + +DEBUGGER_PARSER BR4PE = { +0, 0, breakpointRead4, breakpointCommandHelp, 0, "BR4", 0, -1, +"", 0 }; + +DEBUGGER_PARSER BRPE = { +0, 0, breakpointRead, breakpointCommandHelp, 0, "BR", 0, 0, +"set read/write breakpoint #=1,2 or 4 byte len" , 0 }; + +DEBUGGER_PARSER BI1PE = { +0, 0, breakpointIO1, breakpointCommandHelp, 0, "BI1", 0, -1, +"", 0 }; + +DEBUGGER_PARSER BI2PE = { +0, 0, breakpointIO2, breakpointCommandHelp, 0, "BI2", 0, -1, +"", 0 }; + +DEBUGGER_PARSER BI4PE = { +0, 0, breakpointIO4, breakpointCommandHelp, 0, "BI4", 0, -1, +"", 0 }; + +DEBUGGER_PARSER BIPE = { +0, 0, breakpointIO, breakpointCommandHelp, 0, "BI", 0, 0, +"set io address breakpoint #=1,2 or 4 byte len" , 0 }; + +DEBUGGER_PARSER breakpointExecutePE = { +0, 0, breakpointExecute, breakpointCommandHelp, 0, "B", 0, 0, +"display all/set execute breakpoint" , 0 }; + +DEBUGGER_PARSER breakShowTemp = { +0, 0, breakpointShowTemp, breakpointCommandHelp, 0, "BST", 0, 0, +"displays temporary breakpoints (proceed/go)" , 0 }; + +DEBUGGER_PARSER breakTimer = { +0, 0, timerBreakpoint, timedBreakpointHelp, 0, "ADDTIMER", 0, 0, +"add a debug timer event" , 0 }; + +DEBUGGER_PARSER breakTimerClear = { +0, 0, timerBreakpointClear, timedBreakpointHelp, 0, "DELTIMER", 0, 0, +"delete a debug timer event" , 0 }; + +/* interactive debugger accelerators */ + +ACCELERATOR traceSSBACC = { +0, 0, processTraceSSBACC, 0, 0, K_F6, 0, +"F6 - Trace/Single Step til Branch" }; + +ACCELERATOR traceACC = { +0, 0, processTraceACC, 0, 0, K_F7, 0, +"F7 - Trace/Single Step" }; + +ACCELERATOR proceedACC = { +0, 0, processProceedACC, 0, 0, K_F8, 0, +"F8 - Proceed" }; + +ACCELERATOR goACC = { +0, 0, processGoACC, 0, 0, K_F9, 0, +"F9 - Go" }; + +ACCELERATOR enterACC = { /* this accelerator handles repeat command */ +0, 0, enterKeyACC, 0, 0, 13, 0, /* processing */ +"Enter - Execute or Repeat a Command" }; + +unsigned char *lastDumpAddress; +unsigned char *lastLinkAddress; +unsigned long lastUnasmAddress; +unsigned long displayLength; +unsigned long lastCommand; +unsigned long lastCommandEntry; +unsigned char lastDebugCommand[100] = {""}; +unsigned long lastDisplayLength; +unsigned char debugCommand[100] = {""}; +unsigned long nextUnasmAddress; +unsigned long pic1Value; +unsigned long pic2Value; +unsigned long BreakReserved[4]; +unsigned long BreakPoints[4]; +unsigned long BreakType[4]; +unsigned long BreakLength[4]; +unsigned long BreakTemp[4]; +unsigned long BreakGo[4]; +unsigned long BreakProceed[4]; +unsigned long BreakMask[MAX_PROCESSORS]; +StackFrame *CurrentFrame[MAX_PROCESSORS]; +unsigned long NestedInterrupts[MAX_PROCESSORS]; +unsigned long ConditionalBreakpoint[4]; +unsigned char BreakCondition[4][256]; +StackFrame lastStackFrame; +unsigned long lastCR0; +unsigned long lastCR2; +unsigned long lastCR4; +unsigned long VirtualDR6; +unsigned long CurrentDR7; +unsigned long CurrentDR6[MAX_PROCESSORS]; +unsigned long repeatCommand; +unsigned long totalLines; +unsigned long debuggerInitialized; +unsigned long ssbmode; + +void mdb_breakpoint(void) +{ + __asm__ __volatile__ ("int $0x03"); +} + +void MDBInitializeDebugger(void) +{ + register unsigned long i; + extern void InitializeDebuggerRegisters(void); + extern unsigned long AddAccelRoutine(ACCELERATOR *); + + lastCommand = 0; + lastCommandEntry = 0; + lastDisplayLength = 0; + + for (i = 0; i < MAX_PROCESSORS; i++) + { + BreakMask[i] = 0; + ProcessorHold[i] = 0; + ProcessorState[i] = 0; + } + + for (i = 0; i < 4; i++) + { + BreakReserved[i] = 0; + BreakPoints[i] = 0; + BreakType[i] = 0; + BreakLength[i] = 0; + BreakProceed[i] = 0; + BreakGo[i] = 0; + BreakTemp[i] = 0; + ConditionalBreakpoint[i] = 0; + BreakCondition[i][0] = '\0'; + } + + InitializeDebuggerRegisters(); + + AddDebuggerCommandParser(&ReasonPE); + AddDebuggerCommandParser(&backTraceAllPidPE); + AddDebuggerCommandParser(&backTracePidPE); + AddDebuggerCommandParser(&backTraceStackPE); + AddDebuggerCommandParser(&cpuFramePE); + AddDebuggerCommandParser(&ProcessorPE); + AddDebuggerCommandParser(&HPE); + AddDebuggerCommandParser(&HelpPE); + AddDebuggerCommandParser(&clearScreenPE); + AddDebuggerCommandParser(&asciiTablePE); + AddDebuggerCommandParser(&displayToggle1); + AddDebuggerCommandParser(&displayToggle2); + AddDebuggerCommandParser(&TBTogglePE); + AddDebuggerCommandParser(&TUTogglePE); + AddDebuggerCommandParser(&TDTogglePE); + AddDebuggerCommandParser(&TLTogglePE); + AddDebuggerCommandParser(&TGTogglePE); + AddDebuggerCommandParser(&TCTogglePE); + AddDebuggerCommandParser(&TNTogglePE); + AddDebuggerCommandParser(&TRTogglePE); + AddDebuggerCommandParser(&TSTogglePE); + AddDebuggerCommandParser(&TATogglePE); + AddDebuggerCommandParser(&ToggleUser); + AddDebuggerCommandParser(&TTogglePE); + AddDebuggerCommandParser(&versionPE); + AddDebuggerCommandParser(&rebootPE); + AddDebuggerCommandParser(&KernelProcessPE1); + AddDebuggerCommandParser(&KernelProcessPE2); +/* + AddDebuggerCommandParser(&SectionPE1); + AddDebuggerCommandParser(&SectionPE2); +*/ + AddDebuggerCommandParser(&AllSymbolsPE); + AddDebuggerCommandParser(&SymbolsPE); + +#if defined(CONFIG_MODULES) + AddDebuggerCommandParser(&lsmodPE1); + AddDebuggerCommandParser(&lsmodPE2); + AddDebuggerCommandParser(&rmmodPE); +#endif + + AddDebuggerCommandParser(&ControlPE); + AddDebuggerCommandParser(&AllPE); + AddDebuggerCommandParser(&SegmentPE); + AddDebuggerCommandParser(&NumericPE); + AddDebuggerCommandParser(&GeneralPE); + AddDebuggerCommandParser(&DefaultPE); + AddDebuggerCommandParser(&SearchMemoryBPE); + AddDebuggerCommandParser(&SearchMemoryWPE); + AddDebuggerCommandParser(&SearchMemoryDPE); + AddDebuggerCommandParser(&ChangeWordPE); + AddDebuggerCommandParser(&ChangeDoublePE); + AddDebuggerCommandParser(&ChangeBytePE); + AddDebuggerCommandParser(&ChangeDefaultPE); + AddDebuggerCommandParser(&CloseSymbolsPE); + AddDebuggerCommandParser(&WalkPE); + AddDebuggerCommandParser(&DumpLinkedPE); + AddDebuggerCommandParser(&DumpWordPE); + AddDebuggerCommandParser(&DumpStackPE); + AddDebuggerCommandParser(&DumpDoubleStackPE); + AddDebuggerCommandParser(&DumpDoublePE); + AddDebuggerCommandParser(&DumpQuadStackPE); + AddDebuggerCommandParser(&DumpQuadPE); + AddDebuggerCommandParser(&DumpBytePE); + AddDebuggerCommandParser(&DumpDefaultPE); + AddDebuggerCommandParser(&Diss16PE); + AddDebuggerCommandParser(&Diss32PE); + AddDebuggerCommandParser(&DissAnyPE); + AddDebuggerCommandParser(&IdPE); + AddDebuggerCommandParser(&ProceedPE); + AddDebuggerCommandParser(&TracePE); + AddDebuggerCommandParser(&SingleStepPE); + AddDebuggerCommandParser(&TraceSSPE); + AddDebuggerCommandParser(&TraceSSBPE); + AddDebuggerCommandParser(&GPE); + AddDebuggerCommandParser(&GoPE); + AddDebuggerCommandParser(&QPE); + AddDebuggerCommandParser(&XPE); + AddDebuggerCommandParser(&BreakProcessorPE); + AddDebuggerCommandParser(&ListProcessorsPE); +#ifdef CONFIG_X86_64 + AddDebuggerCommandParser(&RAXPE); + AddDebuggerCommandParser(&ORIGRAXPE); + AddDebuggerCommandParser(&RBXPE); + AddDebuggerCommandParser(&RCXPE); + AddDebuggerCommandParser(&RDXPE); + AddDebuggerCommandParser(&RSIPE); + AddDebuggerCommandParser(&RDIPE); + AddDebuggerCommandParser(&RBPPE); + AddDebuggerCommandParser(&RSPPE); + AddDebuggerCommandParser(&RIPPE); + AddDebuggerCommandParser(&R8PE); + AddDebuggerCommandParser(&R9PE); + AddDebuggerCommandParser(&R10PE); + AddDebuggerCommandParser(&R11PE); + AddDebuggerCommandParser(&R12PE); + AddDebuggerCommandParser(&R13PE); + AddDebuggerCommandParser(&R14PE); + AddDebuggerCommandParser(&R15PE); +#endif + AddDebuggerCommandParser(&EAXPE); + AddDebuggerCommandParser(&ORIGEAXPE); + AddDebuggerCommandParser(&EBXPE); + AddDebuggerCommandParser(&ECXPE); + AddDebuggerCommandParser(&EDXPE); + AddDebuggerCommandParser(&ESIPE); + AddDebuggerCommandParser(&EDIPE); + AddDebuggerCommandParser(&EBPPE); + AddDebuggerCommandParser(&ESPPE); + AddDebuggerCommandParser(&EIPPE); + AddDebuggerCommandParser(&CSPE); +#ifndef CONFIG_X86_64 + AddDebuggerCommandParser(&DSPE); + AddDebuggerCommandParser(&ESPE); +#endif + AddDebuggerCommandParser(&FSPE); + AddDebuggerCommandParser(&GSPE); + AddDebuggerCommandParser(&SSPE); + AddDebuggerCommandParser(&RFPE); + AddDebuggerCommandParser(&TFPE); + AddDebuggerCommandParser(&ZFPE); + AddDebuggerCommandParser(&SFPE); + AddDebuggerCommandParser(&PFPE); + AddDebuggerCommandParser(&CFPE); + AddDebuggerCommandParser(&OFPE); + AddDebuggerCommandParser(&IFPE); + AddDebuggerCommandParser(&IDPE); + AddDebuggerCommandParser(&DFPE); + AddDebuggerCommandParser(&NTPE); + AddDebuggerCommandParser(&VMPE); + AddDebuggerCommandParser(&VIFPE); + AddDebuggerCommandParser(&VIPPE); + AddDebuggerCommandParser(&AFPE); + AddDebuggerCommandParser(&ACPE); + AddDebuggerCommandParser(&MTRRPE); +#if defined(CONFIG_SMP) && !defined(CONFIG_X86_ELAN) + AddDebuggerCommandParser(&APIC_PE); + AddDebuggerCommandParser(&IOAPIC_PE); + AddDebuggerCommandParser(&NMIProcessorPE); +#endif + AddDebuggerCommandParser(&GDTPE); + AddDebuggerCommandParser(&IDTPE); + AddDebuggerCommandParser(&EvaluatePE); + AddDebuggerCommandParser(&InputWordPE); + AddDebuggerCommandParser(&InputDoublePE); + AddDebuggerCommandParser(&InputBytePE); + AddDebuggerCommandParser(&InputPE); + AddDebuggerCommandParser(&OutputWordPE); + AddDebuggerCommandParser(&OutputDoublePE); + AddDebuggerCommandParser(&OutputBytePE); + AddDebuggerCommandParser(&OutputPE); + AddDebuggerCommandParser(&BreakClearAllPE); + AddDebuggerCommandParser(&BreakClearPE); + AddDebuggerCommandParser(&BreakMaskPE); + AddDebuggerCommandParser(&BW1PE); + AddDebuggerCommandParser(&BW2PE); + AddDebuggerCommandParser(&BW4PE); + AddDebuggerCommandParser(&BWPE); + AddDebuggerCommandParser(&BR1PE); + AddDebuggerCommandParser(&BR2PE); + AddDebuggerCommandParser(&BR4PE); + AddDebuggerCommandParser(&BRPE); + AddDebuggerCommandParser(&BI1PE); + AddDebuggerCommandParser(&BI2PE); + AddDebuggerCommandParser(&BI4PE); + AddDebuggerCommandParser(&BIPE); + AddDebuggerCommandParser(&breakpointExecutePE); + AddDebuggerCommandParser(&breakShowTemp); + AddDebuggerCommandParser(&breakTimer); + AddDebuggerCommandParser(&breakTimerClear); + + AddAccelRoutine(&traceSSBACC); + AddAccelRoutine(&traceACC); + AddAccelRoutine(&proceedACC); + AddAccelRoutine(&goACC); + AddAccelRoutine(&enterACC); + + debuggerInitialized = 1; + return; +} + +void MDBClearDebuggerState(void) +{ + extern void ClearDebuggerRegisters(void); + + ClearDebuggerRegisters(); + debuggerInitialized = 0; + return; +} + + +void ClearTempBreakpoints(void) +{ + register unsigned long i; + + for (i = 0; i < 4; i++) + { + if (BreakTemp[i]) + { + BreakTemp[i] = 0; + BreakReserved[i] = 0; + BreakPoints[i] = 0; + BreakType[i] = 0; + BreakLength[i] = 0; + BreakGo[i] = 0; + BreakProceed[i] = 0; + } + } + SetDebugRegisters(); + return; +} + +unsigned long ValidBreakpoint(unsigned long address) +{ + + register unsigned long i; + + for (i = 0; i < 4; i++) + { + if (!BreakTemp[i]) + if (BreakPoints[i] == address) + return 1; + } + return 0; + +} + +unsigned long GetIP(StackFrame *stackFrame) +{ + return (unsigned long)(stackFrame->tIP); +} + +unsigned long GetStackAddress(StackFrame *stackFrame) +{ + return (unsigned long)(stackFrame->tSP); +} + +unsigned long GetStackSegment(StackFrame *stackFrame) +{ + return (unsigned long)(stackFrame->tSS); +} + +unsigned long SSBUpdate(StackFrame *stackFrame, unsigned long processor) +{ + if (!ssbmode) + return 0; + + if (jmp_active) + { + ssbmode = 0; + return 0; + } + + lastCommand = 'T'; + strcpy(debugCommand, "SSB"); + lastCR0 = ReadCR0(); + lastCR2 = ReadCR2(); + lastCR4 = ReadCR4(); + memmove((void *)&lastStackFrame, stackFrame, + sizeof(StackFrame)); + + stackFrame->tSystemFlags |= (SINGLE_STEP | RESUME); + atomic_inc(&focusActive); + atomic_inc(&traceProcessors[get_processor_id()]); + return -1; +} + +/* F6 */ + +unsigned long processTraceSSBACC(unsigned long key, void *p, ACCELERATOR *accel) +{ + register StackFrame *stackFrame = p; + + DBGPrint("\n"); + ssbmode = 1; + lastCommand = 'T'; + strcpy(debugCommand, "SSB"); + lastCR0 = ReadCR0(); + lastCR2 = ReadCR2(); + lastCR4 = ReadCR4(); + memmove((void *)&lastStackFrame, stackFrame, sizeof(StackFrame)); + + stackFrame->tSystemFlags |= (SINGLE_STEP | RESUME); + + /* set as focus processor for trace, ssb, or proceed */ + atomic_inc(&focusActive); + atomic_inc(&traceProcessors[get_processor_id()]); + return -1; +} + +/* F8 */ + +unsigned long processProceedACC(unsigned long key, void *p, ACCELERATOR *accel) +{ + register StackFrame *stackFrame = p; + register unsigned long i; + + ssbmode = 0; + DBGPrint("\n"); + if (needs_proceed) + { + for (i = 0; i < 4; i++) + { + if (!BreakReserved[i]) + { + BreakReserved[i] = 1; + BreakPoints[i] = nextUnasmAddress; + BreakType[i] = BREAK_EXECUTE; + BreakLength[i] = ONE_BYTE_FIELD; + BreakTemp[i] = 1; + BreakProceed[i] = 1; + SetDebugRegisters(); + lastCommand = 'P'; + strcpy(debugCommand, "P"); + lastCR0 = ReadCR0(); + lastCR2 = ReadCR2(); + lastCR4 = ReadCR4(); + memmove((void *)&lastStackFrame, stackFrame, + sizeof(StackFrame)); + + stackFrame->tSystemFlags &= ~SINGLE_STEP; + stackFrame->tSystemFlags |= RESUME; + + /* set as focus processor for trace, ssb, or proceed */ + atomic_inc(&focusActive); + atomic_inc(&traceProcessors[get_processor_id()]); + return -1; + } + } + DBGPrint("\nNo breakpoint available for Proceed, (single step) instead"); + } + lastCommand = 'P'; + strcpy(debugCommand, "P"); + lastCR0 = ReadCR0(); + lastCR2 = ReadCR2(); + lastCR4 = ReadCR4(); + memmove((void *)&lastStackFrame, stackFrame, + sizeof(StackFrame)); + + stackFrame->tSystemFlags |= (SINGLE_STEP | RESUME); + + /* set as focus processor for trace, ssb, or proceed */ + atomic_inc(&focusActive); + atomic_inc(&traceProcessors[get_processor_id()]); + return -1; +} + +/* F7 */ + +unsigned long processTraceACC(unsigned long key, void *p, ACCELERATOR *accel) +{ + register StackFrame *stackFrame = p; + + ssbmode = 0; + DBGPrint("\n"); + lastCommand = 'T'; + strcpy(debugCommand, "T"); + lastCR0 = ReadCR0(); + lastCR2 = ReadCR2(); + lastCR4 = ReadCR4(); + memmove((void *)&lastStackFrame, stackFrame, + sizeof(StackFrame)); + + stackFrame->tSystemFlags |= (SINGLE_STEP | RESUME); + + /* set as focus processor for trace, ssb, or proceed */ + atomic_inc(&focusActive); + atomic_inc(&traceProcessors[get_processor_id()]); + return -1; +} + +/* F9 */ + +unsigned long processGoACC(unsigned long key, void *p, ACCELERATOR *accel) +{ + register StackFrame *stackFrame = p; + + ssbmode = 0; + DBGPrint("\n"); + ClearTempBreakpoints(); + lastCommand = 'G'; + lastCR0 = ReadCR0(); + lastCR2 = ReadCR2(); + lastCR4 = ReadCR4(); + memmove((void *)&lastStackFrame, stackFrame, sizeof(StackFrame)); + + stackFrame->tSystemFlags &= ~SINGLE_STEP; + stackFrame->tSystemFlags |= RESUME; + return -1; + +} + +unsigned long executeCommandHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("t - trace\n"); + DBGPrint("s - single step\n"); + DBGPrint("ss - single step\n"); + DBGPrint("ssb - single step til branch\n"); + DBGPrint("p - proceed\n"); + DBGPrint("g or g
- go\n"); + DBGPrint("go or go
- go\n"); + DBGPrint("q or q
- quit\n"); + DBGPrint("x or x
- exit\n"); + DBGPrint("F7 - trace\n"); + DBGPrint("F8 - proceed\n"); + DBGPrint("F9 - go\n"); + DBGPrint("\n"); + return 1; +} + +/* P */ + +unsigned long processProceed(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long i; + + ssbmode = 0; + if (needs_proceed) + { + for (i = 0; i < 4; i++) + { + if (!BreakReserved[i]) + { + BreakReserved[i] = 1; + BreakPoints[i] = nextUnasmAddress; + BreakType[i] = BREAK_EXECUTE; + BreakLength[i] = ONE_BYTE_FIELD; + BreakTemp[i] = 1; + BreakProceed[i] = 1; + SetDebugRegisters(); + lastCommand = 'P'; + lastCR0 = ReadCR0(); + lastCR2 = ReadCR2(); + lastCR4 = ReadCR4(); + memmove((void *)&lastStackFrame, stackFrame, + sizeof(StackFrame)); + + stackFrame->tSystemFlags &= ~SINGLE_STEP; + stackFrame->tSystemFlags |= RESUME; + + /* set as focus processor for trace, ssb, or proceed */ + atomic_inc(&focusActive); + atomic_inc(&traceProcessors[get_processor_id()]); + return -1; + } + } + DBGPrint("\nNo breakpoint available for Proceed, (single step) instead"); + } + lastCommand = 'P'; + lastCR0 = ReadCR0(); + lastCR2 = ReadCR2(); + lastCR4 = ReadCR4(); + memmove((void *)&lastStackFrame, stackFrame, + sizeof(StackFrame)); + + stackFrame->tSystemFlags |= (SINGLE_STEP | RESUME); + + /* set as focus processor for trace, ssb, or proceed */ + atomic_inc(&focusActive); + atomic_inc(&traceProcessors[get_processor_id()]); + return -1; + +} + +/* SSB */ + +unsigned long processTraceSSB(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + DBGPrint("\n"); + ssbmode = 1; + lastCommand = 'T'; + lastCR0 = ReadCR0(); + lastCR2 = ReadCR2(); + lastCR4 = ReadCR4(); + memmove((void *)&lastStackFrame, stackFrame, + sizeof(StackFrame)); + + stackFrame->tSystemFlags |= (SINGLE_STEP | RESUME); + + /* set as focus processor for trace, ssb, or proceed */ + atomic_inc(&focusActive); + atomic_inc(&traceProcessors[get_processor_id()]); + return -1; + +} + + +/* T */ + +unsigned long processTrace(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + ssbmode = 0; + lastCommand = 'T'; + lastCR0 = ReadCR0(); + lastCR2 = ReadCR2(); + lastCR4 = ReadCR4(); + memmove((void *)&lastStackFrame, stackFrame, + sizeof(StackFrame)); + + stackFrame->tSystemFlags |= (SINGLE_STEP | RESUME); + + /* set as focus processor for trace, ssb, or proceed */ + atomic_inc(&focusActive); + atomic_inc(&traceProcessors[get_processor_id()]); + return -1; + +} + +/* G */ + +unsigned long processGo(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address; + unsigned long valid; + register unsigned long i; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + ssbmode = 0; + ClearTempBreakpoints(); + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + for (i = 0; i < 4; i++) + { + if (!BreakReserved[i]) + { + BreakReserved[i] = 1; + BreakPoints[i] = address; + BreakType[i] = BREAK_EXECUTE; + BreakLength[i] = ONE_BYTE_FIELD; + BreakTemp[i] = 1; + BreakGo[i] = 1; + SetDebugRegisters(); + DBGPrint("\n"); + lastCommand = 'G'; + lastCR0 = ReadCR0(); + lastCR2 = ReadCR2(); + lastCR4 = ReadCR4(); + memmove((void *)&lastStackFrame, stackFrame, + sizeof(StackFrame)); + + stackFrame->tSystemFlags &= ~SINGLE_STEP; + stackFrame->tSystemFlags |= RESUME; + return -1; + } + } + } + else + { + DBGPrint("\n"); + lastCommand = 'G'; + lastCR0 = ReadCR0(); + lastCR2 = ReadCR2(); + lastCR4 = ReadCR4(); + memmove((void *)&lastStackFrame, stackFrame, + sizeof(StackFrame)); + + stackFrame->tSystemFlags &= ~SINGLE_STEP; + stackFrame->tSystemFlags |= RESUME; + return -1; + } + DBGPrint("no breakpoint available for GO\n"); + return 1; + +} + +unsigned long processorCommandHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("lcpu - list processors\n"); + DBGPrint("cpu [p#] - switch processor\n"); + DBGPrint("lr [p#] - display processor registers\n"); +#if defined(CONFIG_SMP) && !defined(CONFIG_X86_ELAN) + DBGPrint("nmi [p#] - deliver hard nmi exception\n\n"); + DBGPrint("The 'nmi [p#]' command will deliver a level triggered\n"); + DBGPrint("NMI hardware interrupt to a specified processor and system\n"); + DBGPrint("recovery may not be possible in all cases after issuing this\n"); + DBGPrint("command. This command is used to trigger debugger\n"); + DBGPrint("entry on a hard hung processor.\n\n"); + DBGPrint("If you just want to switch processors with a soft NMI\n"); + DBGPrint("exception (which is typically recoverable), then use the\n"); + DBGPrint("'cpu [p#]' command instead. Only use the 'nmi [p#]' command\n"); + DBGPrint("for situations where you need to trigger a hardware NMI to\n"); + DBGPrint("force a hung processor to enter the debugger.\n"); +#endif + return 1; +} + +/* CPU */ + +unsigned long breakProcessor(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long cpunum, cpu = get_processor_id(); + unsigned long valid, i; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + cpunum = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + if (cpunum == cpu) + { + DBGPrint("debugger already running on processor %d\n", (int)cpunum); + return 1; + } + + if ((cpunum > MAX_PROCESSORS) || !(cpu_online(cpunum))) + { + DBGPrint("invalid processor specified\n"); + return 1; + } + + for (i = 0; i < MAX_PROCESSORS; i++) + { + if (cpu_online(i)) + { + if (i == cpunum) + { + ProcessorState[i] = PROCESSOR_SWITCH; + ProcessorHold[cpu] = 1; + barrier(); + break; + } + } + } + DBGPrint("\n"); + lastCommand = 'G'; + lastCR0 = ReadCR0(); + lastCR2 = ReadCR2(); + lastCR4 = ReadCR4(); + memmove((void *)&lastStackFrame, stackFrame, + sizeof(StackFrame)); + return -1; + } + else + { + DBGPrint("no target processor specified\n"); + DBGPrint("Current Processor: %d\n", get_processor_id()); + DBGPrint("Active Processors: "); + + for (i = 0; i < MAX_PROCESSORS; i++) + { + if (cpu_online(i)) + { + if (i) + DBGPrint(", "); + + DBGPrint("%d", i); + } + } + DBGPrint("\n"); + } + return 1; + +} + +#if defined(CONFIG_SMP) && !defined(CONFIG_X86_ELAN) +/* NMI */ + +unsigned long nmiProcessor(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long cpunum, cpu = get_processor_id(); + unsigned long valid, i; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + cpunum = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + if (cpunum == cpu) + { + DBGPrint("debugger already running on processor %d\n", (int)cpunum); + return 1; + } + + if ((cpunum > MAX_PROCESSORS) || !(cpu_online(cpunum))) + { + DBGPrint("invalid processor specified\n"); + return 1; + } + + for (i = 0; i < MAX_PROCESSORS; i++) + { + if (cpu_online(i)) + { + if (i == cpunum) + { + ProcessorState[i] = PROCESSOR_SWITCH; + ProcessorHold[cpu] = 1; + barrier(); +// apic_directed_nmi(i); + break; + } + } + } + DBGPrint("\n"); + lastCommand = 'G'; + lastCR0 = ReadCR0(); + lastCR2 = ReadCR2(); + lastCR4 = ReadCR4(); + memmove((void *)&lastStackFrame, stackFrame, + sizeof(StackFrame)); + return -1; + } + else + { + DBGPrint("no target processor specified\n"); + DBGPrint("Current Processor: %d\n", get_processor_id()); + DBGPrint("Active Processors: "); + + for (i = 0; i < MAX_PROCESSORS; i++) + { + if (cpu_online(i)) + { + if (i) + DBGPrint(", "); + + DBGPrint("%d", i); + } + } + DBGPrint("\n"); + } + return 1; + +} +#endif + +/* LR */ + +extern StackFrame CurrentStackFrame[MAX_PROCESSORS]; + +unsigned long listProcessorFrame(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid, pnum; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + pnum = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid && (pnum < MAX_PROCESSORS) && (cpu_online(pnum))) + { + DBGPrint("Processor Frame %d -> (%X)\n", pnum, + &CurrentStackFrame[pnum]); + DisplayTSS((StackFrame *)&CurrentStackFrame[pnum]); + } + else + DBGPrint("invalid processor frame\n"); + + return 1; + +} + +/* .TA */ + +unsigned long ProcessTAToggle(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + if (general_toggle) + { + general_toggle = 0; + control_toggle = 0; + segment_toggle = 0; + } + else + { + general_toggle = 1; + control_toggle = 1; + segment_toggle = 1; + } + + DBGPrint("general registers (%s) \n", general_toggle ? "ON" : "OFF"); + DBGPrint("control registers (%s) \n", control_toggle ? "ON" : "OFF"); + DBGPrint("segment registers (%s) \n", segment_toggle ? "ON" : "OFF"); + return 1; + +} + +unsigned long TSSDisplayHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint(".t
- display task state regs\n"); + return 1; +} + +/* .T */ + +unsigned long TSSDisplay(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (!valid) + DisplayTSS(stackFrame); + else + DisplayTSS((StackFrame *) address); + + return 1; +} + +unsigned long displayRegistersHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("r - display registers for a processor\n"); + DBGPrint("rc - display control registers \n"); + DBGPrint("rs - display segment registers \n"); + DBGPrint("rg - display general registers \n"); + DBGPrint("ra - display all registers\n"); + DBGPrint("rn - display coprocessor/MMX registers\n"); + + return 1; +} + +/* RC */ + +unsigned long displayControlRegisters(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + DBGPrint("Control Registers\n"); + DisplayControlRegisters(get_processor_id(), stackFrame); + return 1; + +} + +/* RA */ + +unsigned long displayAllRegisters(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long processor = get_processor_id(); + + DBGPrint("General Registers\n"); + DisplayGeneralRegisters(stackFrame); + + DBGPrint("Segment Registers\n"); + DisplaySegmentRegisters(stackFrame); + + DBGPrint("Control Registers\n"); + DisplayControlRegisters(processor, stackFrame); + + if (fpu_present()) + { + DBGPrint("Coprocessor Registers\n"); + DisplayNPXRegisters(processor); + } + else + { + DBGPrint("Coprocessor Not Present\n"); + } + return 1; + +} + + +/* RS */ + +unsigned long displaySegmentRegisters(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + DBGPrint("Segment Registers\n"); + DisplaySegmentRegisters(stackFrame); + return 1; + +} + +/* RN */ + +unsigned long displayNumericRegisters(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + if (fpu_present()) + { + DBGPrint("Coprocessor Registers\n"); + DisplayNPXRegisters(get_processor_id()); + } + else + { + DBGPrint("Coprocessor Not Present\n"); + } + return 1; + +} + +/* RG */ + +unsigned long displayGeneralRegisters(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + DBGPrint("General Registers\n"); + DisplayGeneralRegisters(stackFrame); + return 1; +} + +#ifdef RENDER_NPX_VALUES +double ldexp(double v, int e) +{ + double two = 2.0; + + if (e < 0) + { + e = -e; /* This just might overflow on two-complement machines. */ + if (e < 0) + return 0.0; + + while (e > 0) + { + if (e & 1) + { + v = v / two; + } + two = two * two; + e >>= 1; + } + } + else + if (e > 0) + { + while (e > 0) + { + if (e & 1) + v = v * two; + two = two * two; + e >>= 1; + } + } + return v; +} +#endif + +void DisplayNPXRegisters(unsigned long processor) +{ + register int i; + int tag; + int tos; +#ifdef RENDER_NPX_VALUES + double d; +#endif + + tos = (npx[processor].status >> 11) & 7; + if (tos) {}; + + DBGPrint("Control: 0x%04X Status: 0x%04X Tag: 0x%04X TOS: %i CPU: %i\n", + (unsigned)npx[processor].control & 0xFFFF, + (unsigned)npx[processor].status & 0xFFFF, + (unsigned)npx[processor].tag & 0xFFFF, + (int)tos, (int)processor); + + for (i = 0; i < 8; i++) + { + tos = (npx[processor].status >> 11) & 7; + DBGPrint("st(%d)/MMX%d ", i, (int)((tos + i) % 8)); + + if (npx[processor].reg[i].sign) + DBGPrint("-"); + else + DBGPrint("+"); + + DBGPrint(" %04X %04X %04X %04X e %04X ", + (unsigned)npx[processor].reg[i].sig3, + (unsigned)npx[processor].reg[i].sig2, + (unsigned)npx[processor].reg[i].sig1, + (unsigned)npx[processor].reg[i].sig0, + (unsigned)npx[processor].reg[i].exponent); + + if (tos) {}; + tag = (npx[processor].tag >> (((i + tos) % 8) * 2)) & 3; + switch (tag) + { + + case 0: + DBGPrint("Valid"); +#ifdef RENDER_NPX_VALUES + if (((int) npx[processor].reg[i].exponent - 16382 < 1000) && + ((int) npx[processor].reg[i].exponent - 16382 > -1000)) + { + d = + npx[processor].reg[i].sig3 / 65536.0 + + npx[processor].reg[i].sig2 / 65536.0 / 65536.0 + + npx[processor].reg[i].sig1 / 65536.0 / 65536.0 / 65536.0; + + d = ldexp(d, (int) npx[processor].reg[i].exponent - 16382); + + if (npx[processor].reg[i].sign) + d = -d; + + DBGPrint(" %.16g", d); + } + else + DBGPrint(" (too big to display)"); +#endif + DBGPrint("\n"); + break; + + case 1: + DBGPrint("Zero\n"); + break; + + case 2: + DBGPrint("Special\n"); + break; + + case 3: + DBGPrint("Empty\n"); + break; + } + } +} + +/* R */ + +unsigned long displayDefaultRegisters(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long processor = get_processor_id(); + + DisplayGeneralRegisters(stackFrame); + + if (control_toggle) + DisplayControlRegisters(processor, stackFrame); + + if (numeric_toggle) + DisplayNPXRegisters(processor); + + disassemble(stackFrame, stackFrame->tIP, 1, -1, 0); + return 1; + +} + +void displayRegisters(StackFrame *stackFrame, unsigned long processor) +{ + if (general_toggle) + DisplayGeneralRegisters(stackFrame); + + if (control_toggle) + DisplayControlRegisters(processor, stackFrame); + + if (numeric_toggle) + DisplayNPXRegisters(processor); + +} + +// +// IA32 Registers +// + +unsigned long displayEAXHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* EAX */ + +unsigned long ChangeEAXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tAX = value; + DBGPrint("EAX changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + + +/* ORIGEAX */ + +unsigned long ChangeORIGEAXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tReserved[1] = value; + DBGPrint("ORIGEAX changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + + +unsigned long displayEBXHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* EBX */ + +unsigned long ChangeEBXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tBX = value; + DBGPrint("EBX changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + +unsigned long displayECXHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* ECX */ + +unsigned long ChangeECXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tCX = value; + DBGPrint("ECX changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + + +unsigned long displayEDXHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* EDX */ + +unsigned long ChangeEDXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tDX = value; + DBGPrint("EDX changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + +unsigned long displayESIHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* ESI */ + +unsigned long ChangeESIRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tSI = value; + DBGPrint("ESI changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + + +unsigned long displayEDIHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* EDI */ + +unsigned long ChangeEDIRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tDI = value; + DBGPrint("EDI changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + + +unsigned long displayEBPHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* EBP */ + +unsigned long ChangeEBPRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tBP = value; + DBGPrint("EBP changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + + +unsigned long displayESPHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* ESP */ + +unsigned long ChangeESPRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tSP = value; + DBGPrint("ESP changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + + +unsigned long displayEIPHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* EIP */ + +unsigned long ChangeEIPRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tIP = value; + DBGPrint("EIP changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + +#ifdef CONFIG_X86_64 +// +// X86_64 Registers +// + +unsigned long displayRAXHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* RAX */ + +unsigned long ChangeRAXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tAX = value; + DBGPrint("RAX changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + +/* ORIGRAX */ + +unsigned long ChangeORIGRAXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tReserved[1] = value; + DBGPrint("ORIGRAX changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + + +unsigned long displayRBXHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* RBX */ + +unsigned long ChangeRBXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tBX = value; + DBGPrint("RBX changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + +unsigned long displayRCXHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* RCX */ + +unsigned long ChangeRCXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tCX = value; + DBGPrint("RCX changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + + +unsigned long displayRDXHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* RDX */ + +unsigned long ChangeRDXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tDX = value; + DBGPrint("RDX changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + +unsigned long displayRSIHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* RSI */ + +unsigned long ChangeRSIRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tSI = value; + DBGPrint("RSI changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + + +unsigned long displayRDIHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* RDI */ + +unsigned long ChangeRDIRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tDI = value; + DBGPrint("RDI changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + + +unsigned long displayRBPHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* RBP */ + +unsigned long ChangeRBPRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tBP = value; + DBGPrint("RBP changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + + +unsigned long displayRSPHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* RSP */ + +unsigned long ChangeRSPRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tSP = value; + DBGPrint("RSP changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + + +unsigned long displayRIPHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* RIP */ + +unsigned long ChangeRIPRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->tIP = value; + DBGPrint("RIP changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + +unsigned long displayR8Help(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* R8 */ + +unsigned long ChangeR8Register(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->r8 = value; + DBGPrint("R8 changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + +unsigned long displayR9Help(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* R9 */ + +unsigned long ChangeR9Register(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->r9 = value; + DBGPrint("R9 changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + +unsigned long displayR10Help(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* R10 */ + +unsigned long ChangeR10Register(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->r10 = value; + DBGPrint("R10 changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + +unsigned long displayR11Help(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* R11 */ + +unsigned long ChangeR11Register(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->r11 = value; + DBGPrint("R11 changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + +unsigned long displayR12Help(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* R12 */ + +unsigned long ChangeR12Register(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->r12 = value; + DBGPrint("R12 changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + +unsigned long displayR13Help(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* R13 */ + +unsigned long ChangeR13Register(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->r13 = value; + DBGPrint("R13 changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + +unsigned long displayR14Help(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* R14 */ + +unsigned long ChangeR14Register(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->r14 = value; + DBGPrint("R14 changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + +unsigned long displayR15Help(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* R15 */ + +unsigned long ChangeR15Register(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + stackFrame->r15 = value; + DBGPrint("R15 changed to 0x%X\n", (unsigned)value); + } + else + DBGPrint("invalid change register command or address\n"); + return 1; + +} + +#endif + +// +// Segment Registers +// + +unsigned long displayCSHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* CS */ + +unsigned long ChangeCSRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + register unsigned short oldW; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldW = stackFrame->tCS; + stackFrame->tCS = (unsigned short) value; + DBGPrint("CS: = [%04X] changed to CS: = [%04X]\n", + (unsigned)oldW, (unsigned) value); + } + else + DBGPrint("invalid change segment register command or address\n"); + return 1; + +} + +unsigned long displayDSHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +#ifndef CONFIG_X86_64 +/* DS */ + +unsigned long ChangeDSRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + register unsigned short oldW; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldW = stackFrame->tDS; + stackFrame->tDS = (unsigned short) value; + DBGPrint("DS: = [%04X] changed to DS: = [%04X]\n", + (unsigned)oldW, (unsigned)value); + } + else + DBGPrint("invalid change segment register command or address\n"); + return 1; + +} + +unsigned long displayESHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* ES */ + +unsigned long ChangeESRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + register unsigned short oldW; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldW = stackFrame->tES; + stackFrame->tES = (unsigned short) value; + DBGPrint("ES: = [%04X] changed to ES: = [%04X]\n", + (unsigned)oldW, (unsigned) value); + } + else + DBGPrint("invalid change segment register command or address\n"); + return 1; + +} +#endif + +unsigned long displayFSHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* FS */ + +unsigned long ChangeFSRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + register unsigned short oldW; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldW = stackFrame->tFS; + stackFrame->tFS = (unsigned short) value; + DBGPrint("FS: = [%04X] changed to FS: = [%04X]\n", + (unsigned)oldW, (unsigned)value); + } + else + DBGPrint("invalid change segment register command or address\n"); + return 1; + +} + +unsigned long displayGSHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* GS */ + +unsigned long ChangeGSRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + register unsigned short oldW; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldW = stackFrame->tGS; + stackFrame->tGS = (unsigned short) value; + DBGPrint("GS: = [%04X] changed to GS: = [%04X]\n", + (unsigned)oldW, (unsigned)value); + } + else + DBGPrint("invalid change segment register command or address\n"); + return 1; + +} + +unsigned long displaySSHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* SS */ + +unsigned long ChangeSSRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value; + register unsigned short oldW; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldW = stackFrame->tSS; + stackFrame->tSS = (unsigned short) value; + DBGPrint("SS: = [%04X] changed to SS: = [%04X]\n", + (unsigned)oldW, (unsigned)value); + } + else + DBGPrint("invalid change segment register command or address\n"); + + return 1; + +} + +unsigned long displayRFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* RF */ + +unsigned long ChangeRFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value, oldD; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldD = stackFrame->tSystemFlags & RF_FLAG; + (value) ? (stackFrame->tSystemFlags |= RF_FLAG) : (stackFrame->tSystemFlags &= ~RF_FLAG); + DBGPrint("EFlag RF[%X] changed to (%d)\n", + (unsigned)oldD, (int)value); + } + else + DBGPrint("invalid change flags command\n"); + return 1; + +} + +unsigned long displayTFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* TF */ + +unsigned long ChangeTFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value, oldD; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldD = stackFrame->tSystemFlags & TF_FLAG; + (value) ? (stackFrame->tSystemFlags |= TF_FLAG) : (stackFrame->tSystemFlags &= ~TF_FLAG); + DBGPrint("EFlag TF[%X] changed to (%d)\n", + (unsigned)oldD, (int)value); + } + else + DBGPrint("invalid change flags command\n"); + return 1; + +} + +unsigned long displayZFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* ZF */ + +unsigned long ChangeZFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value, oldD; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldD = stackFrame->tSystemFlags & ZF_FLAG; + (value) ? (stackFrame->tSystemFlags |= ZF_FLAG) : (stackFrame->tSystemFlags &= ~ZF_FLAG); + DBGPrint("EFlag ZF[%X] changed to (%d)\n", + (unsigned)oldD, (int)value); + } + else + DBGPrint("invalid change flags command\n"); + return 1; + +} + +unsigned long displaySFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* SF */ + +unsigned long ChangeSFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value, oldD; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldD = stackFrame->tSystemFlags & SF_FLAG; + (value) ? (stackFrame->tSystemFlags |= SF_FLAG) : (stackFrame->tSystemFlags &= ~SF_FLAG); + DBGPrint("EFlag SF[%X] changed to (%d)\n", + (unsigned)oldD, (int)value); + } + else + DBGPrint("invalid change flags command\n"); + return 1; + +} + +unsigned long displayPFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* PF */ + +unsigned long ChangePFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value, oldD; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldD = stackFrame->tSystemFlags & PF_FLAG; + (value) ? (stackFrame->tSystemFlags |= PF_FLAG) : (stackFrame->tSystemFlags &= ~PF_FLAG); + DBGPrint("EFlag PF[%X] changed to (%d)\n", + (unsigned)oldD, (int)value); + } + else + DBGPrint("invalid change flags command\n"); + return 1; + +} + +unsigned long displayCFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* CF */ + +unsigned long ChangeCFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value, oldD; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldD = stackFrame->tSystemFlags & CF_FLAG; + (value) ? (stackFrame->tSystemFlags |= CF_FLAG) : (stackFrame->tSystemFlags &= ~CF_FLAG); + DBGPrint("EFlag CF[%X] changed to (%d)\n", + (unsigned)oldD, (int)value); + } + else + DBGPrint("invalid change flags command\n"); + return 1; + +} + +unsigned long displayOFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* OF */ + +unsigned long ChangeOFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value, oldD; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldD = stackFrame->tSystemFlags & OF_FLAG; + (value) ? (stackFrame->tSystemFlags |= OF_FLAG) : (stackFrame->tSystemFlags &= ~OF_FLAG); + DBGPrint("EFlag OF[%X] changed to (%d)\n", + (unsigned)oldD, (int)value); + } + else + DBGPrint("invalid change flags command\n"); + return 1; + +} + + +unsigned long displayIFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* IF */ + +unsigned long ChangeIFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value, oldD; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldD = stackFrame->tSystemFlags & IF_FLAG; + (value) ? (stackFrame->tSystemFlags |= IF_FLAG) : (stackFrame->tSystemFlags &= ~IF_FLAG); + DBGPrint("EFlag IF[%X] changed to (%d)\n", + (unsigned)oldD, (int)value); + } + else + DBGPrint("invalid change flags command\n"); + return 1; + +} + +unsigned long displayIDHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* ID */ + +unsigned long ChangeIDFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value, oldD; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldD = stackFrame->tSystemFlags & ID_FLAGS; + (value) ? (stackFrame->tSystemFlags |= ID_FLAGS) : (stackFrame->tSystemFlags &= ~ID_FLAGS); + DBGPrint("EFlag ID[%X] changed to (%d)\n", + (unsigned)oldD, (int)value); + } + else + DBGPrint("invalid change flags command\n"); + return 1; + +} + +unsigned long displayDFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* DF */ + +unsigned long ChangeDFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + + unsigned long valid; + register unsigned long value, oldD; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldD = stackFrame->tSystemFlags & DF_FLAG; + (value) ? (stackFrame->tSystemFlags |= DF_FLAG) : (stackFrame->tSystemFlags &= ~DF_FLAG); + DBGPrint("EFlag DF[%X] changed to (%d)\n", + (unsigned)oldD, (int)value); + } + else + DBGPrint("invalid change flags command\n"); + return 1; + +} + +unsigned long displayNTHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* NT */ + +unsigned long ChangeNTFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value, oldD; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldD = stackFrame->tSystemFlags & NT_FLAG; + (value) ? (stackFrame->tSystemFlags |= NT_FLAG) : (stackFrame->tSystemFlags &= ~NT_FLAG); + DBGPrint("EFlag NT[%X] changed to (%d)\n", + (unsigned)oldD, (int)value); + } + else + DBGPrint("invalid change flags command\n"); + return 1; + +} + +unsigned long displayVMHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* VM */ + +unsigned long ChangeVMFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value, oldD; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldD = stackFrame->tSystemFlags & VM_FLAG; + (value) ? (stackFrame->tSystemFlags |= VM_FLAG) : (stackFrame->tSystemFlags &= ~VM_FLAG); + DBGPrint("EFlag VM[%X] changed to (%d)\n", + (unsigned)oldD, (int)value); + } + else + DBGPrint("invalid change flags command\n"); + return 1; + +} + + +unsigned long displayVIFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* VIF */ + +unsigned long ChangeVIFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value, oldD; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldD = stackFrame->tSystemFlags & VIF_FLAG; + (value) ? (stackFrame->tSystemFlags |= VIF_FLAG) : (stackFrame->tSystemFlags &= ~VIF_FLAG); + DBGPrint("EFlag VIF[%X] changed to (%d)\n", + (unsigned)oldD, (int)value); + } + else + DBGPrint("invalid change flags command\n"); + return 1; + +} + +unsigned long displayVIPHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* VIP */ + +unsigned long ChangeVIPFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value, oldD; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldD = stackFrame->tSystemFlags & VIP_FLAG; + (value) ? (stackFrame->tSystemFlags |= VIP_FLAG) : (stackFrame->tSystemFlags &= ~VIP_FLAG); + DBGPrint("EFlag VIP[%X] changed to (%d)\n", + (unsigned)oldD, (int)value); + } + else + DBGPrint("invalid change flags command\n"); + return 1; + +} + +unsigned long displayAFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* AF */ + +unsigned long ChangeAFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value, oldD; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldD = stackFrame->tSystemFlags & AF_FLAG; + (value) ? (stackFrame->tSystemFlags |= AF_FLAG) : (stackFrame->tSystemFlags &= ~AF_FLAG); + DBGPrint("EFlag AF[%X] changed to (%d)\n", + (unsigned)oldD, (int)value); + } + else + DBGPrint("invalid change flags command\n"); + return 1; + +} + + +unsigned long displayACHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + return 1; +} + +/* AC */ + +unsigned long ChangeACFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long value, oldD; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + oldD = stackFrame->tSystemFlags & AC_FLAG; + (value) ? (stackFrame->tSystemFlags |= AC_FLAG) : (stackFrame->tSystemFlags &= ~AC_FLAG); + DBGPrint("EFlag AC[%X] changed to (%d)\n", + (unsigned)oldD, (int)value); + } + else + DBGPrint("invalid change flags command\n"); + return 1; + +} + +unsigned long displayMTRRHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("mtrr - display memory type range registers\n"); + return 1; +} + +/* MTRR */ + +unsigned long DisplayMTRRRegisters(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + displayMTRRRegisters(); + return 1; + +} + +unsigned long displayGDTHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint(".g or .g
- display global descriptor table\n"); + return 1; +} + +/* .G */ + +unsigned long displayGDT(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + DisplayGDT((unsigned char *) address); + else + DisplayGDT((unsigned char *) 0); + return 1; +} + +unsigned long displayIDTHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint(".i or .i
- display interrupt descriptor table\n"); + return 1; +} + +/* .I */ + +unsigned long displayIDT(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + DisplayIDT((unsigned char *) address); + else + DisplayIDT((unsigned char *) 0); + return 1; +} + +unsigned long evaluateExpressionHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + extern void displayExpressionHelp(void); + + displayExpressionHelp(); + return 1; +} + +/* .E */ + +unsigned long evaluateExpression(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + extern void EvaluateCommandExpression(StackFrame *stackFrame, + unsigned char *cmd); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + EvaluateCommandExpression(stackFrame, cmd); + return 1; +} + +unsigned long portCommandHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("i - input byte from port\n"); + DBGPrint("ib - input byte from port\n"); + DBGPrint("iw - input word from port\n"); + DBGPrint("il - input double word from port\n"); + DBGPrint("o - output byte to port\n"); + DBGPrint("ob - output byte to port\n"); + DBGPrint("ow - output word to port\n"); + DBGPrint("ol - output double word to port\n"); + return 1; +} + +/* IW */ + +unsigned long inputWordPort(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + DBGPrint("inportw (%04X) = %04X\n", + (unsigned)address, (unsigned)inw(address)); + } + else + { + DBGPrint("bad port command\n"); + } + return 1; + +} + +/* ID */ + +unsigned long inputDoublePort(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + DBGPrint("inportd (%04X) = %X\n", + (unsigned)address, (unsigned)inl(address)); + } + else + { + DBGPrint("bad port command\n"); + } + return 1; + +} + +/* IB */ + +unsigned long inputBytePort(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + DBGPrint("inportb (%04X) = %02X\n", + (unsigned)address, (unsigned)inb(address)); + } + else + { + DBGPrint("bad port command\n"); + } + return 1; + +} + +/* I */ + +unsigned long inputPort(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + DBGPrint("inportb (%04X) = %02X\n", + (unsigned)address, (unsigned)inb(address)); + } + else + { + DBGPrint("bad port command\n"); + } + return 1; + +} + +/* OW */ + +unsigned long outputWordPort(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long port, value; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + port = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + DBGPrint("outportw (%04X) = %04X\n", + (unsigned)port, (unsigned)value); + outw(port, value); + return 1; + } + } + else + DBGPrint("bad port command\n"); + + return 1; + +} + +/* OD */ + +unsigned long outputDoublePort(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long port, value; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + port = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + DBGPrint("outportd (%04X) = %X\n", + (unsigned)port, (unsigned)value); + outl(port, value); + return 1; + } + } + else + DBGPrint("bad port command\n"); + + return 1; + +} + +/* OB */ + +unsigned long outputBytePort(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long port, value; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + port = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + DBGPrint("outportb (%04X) = %02X\n", + (unsigned)port, (unsigned)value); + outb(port, value); + return 1; + } + } + else + DBGPrint("bad port command\n"); + + return 1; + +} + +/* O */ + +unsigned long outputPort(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long port, value; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + port = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + value = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + DBGPrint("outportb (%04X) = %02X\n", + (unsigned)port, (unsigned)value); + outb(port, value); + return 1; + } + } + else + DBGPrint("bad port command\n"); + + return 1; + +} + +unsigned long breakpointCommandHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("b - display all breakpoints\n"); + DBGPrint("b
- set execute breakpoint\n"); + DBGPrint("bc [#] (1-4) - clear breakpoint\n"); + DBGPrint("bca - clear all breakpoints\n"); + DBGPrint("br[#]
- set read/write breakpoint #=1,2 or 4 byte len\n"); + DBGPrint("bw[#]
- set write only breakpoint #=1,2 or 4 byte len\n"); + DBGPrint("bi[#]
- set io address breakpoint #=1,2 or 4 byte len\n"); + DBGPrint("bm [p#] - mask breaks for specific processor \n"); + DBGPrint("bst - display temporary (go/proceed) breakpoints\n"); + return 1; +} + +/* BCA */ + +unsigned long breakpointClearAll(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long i; + + for (i = 0; i < 4; i++) + { + BreakReserved[i] = 0; + BreakPoints[i] = 0; + BreakType[i] = 0; + BreakLength[i] = 0; + ConditionalBreakpoint[i] = 0; + } + SetDebugRegisters(); + DBGPrint("all breakpoints cleared\n"); + + return 1; + +} + +/* BC */ + +unsigned long breakpointClear(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + unsigned long valid; + register unsigned long i, address; + register unsigned char *symbolName; + register unsigned char *moduleName; + register int c = get_processor_id(); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + i = address; + if (i < 4) + { + symbolName = GetSymbolFromValue(BreakPoints[i], &symbuf[c][0], + MAX_SYMBOL_LEN); + moduleName = GetModuleInfoFromSymbolValue(BreakPoints[i], + &modbuf[c][0], MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("breakpoint %i at 0x%X (%s %s) %s|%s cleared\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(moduleName) ? (char *)(moduleName) + : (char *)("")), + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + else + DBGPrint("breakpoint %i at 0x%X (%s %s) %s cleared\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + BreakReserved[i] = 0; + BreakPoints[i] = 0; + BreakType[i] = 0; + BreakLength[i] = 0; + ConditionalBreakpoint[i] = 0; + SetDebugRegisters(); + return 1; + } + else + DBGPrint("breakpoint out of range\n"); + return 1; + } + DBGPrint("breakpoint not found\n"); + return 1; +} + +/* BM */ + +unsigned long breakpointMask(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address, pnum, i; + unsigned long valid; + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + pnum = address; + if (pnum < MAX_PROCESSORS) + { + if (BreakMask[pnum]) + BreakMask[pnum] = 0; + else + BreakMask[pnum] = 1; + DBGPrint("processor %i : %s\n", (int)pnum, + BreakMask[pnum] ? "BREAKS_MASKED" : "BREAKS_UNMASKED"); + } + else + DBGPrint("processor (%i) invalid\n", (int)pnum); + } + else + { + for (i = 0; i < MAX_PROCESSORS; i++) + { + DBGPrint("processor %i : %s\n", (int)i, + BreakMask[i] ? "BREAKS_MASKED" : "BREAKS_UNMASKED"); + } + } + return 1; + +} + +/* BW1 */ + +unsigned long breakpointWord1(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address, i, r; + register unsigned char *pB, *symbolName; + register unsigned char *moduleName; + unsigned long valid; + register int c = get_processor_id(); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + for (i = 0; i < 4; i++) + { + if (!BreakReserved[i]) + { + pB = cmd; + EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + ConditionalBreakpoint[i] = 1; + for (r = 0; (r < 255) && (*pB); r++) + BreakCondition[i][r] = *pB++; + BreakCondition[i][r] = '\0'; + } + BreakReserved[i] = 1; + BreakPoints[i] = address; + BreakType[i] = BREAK_WRITE; + BreakLength[i] = ONE_BYTE_FIELD; + symbolName = GetSymbolFromValue(address, &symbuf[c][0], + MAX_SYMBOL_LEN); + moduleName = GetModuleInfoFromSymbolValue(address, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s|%s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(moduleName) ? (char *)(moduleName) + : (char *)("")), + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + else + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + + if (ConditionalBreakpoint[i]) + DBGPrint("if (%s) is TRUE\n", BreakCondition[i]); + + SetDebugRegisters(); + return 1; + } + } + DBGPrint("no breakpoint available\n"); + } + else + DBGPrint("breakpoint parameters invalid\n"); + return 1; + +} + +/* BW2 */ + +unsigned long breakpointWord2(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address, i, r; + register unsigned char *pB, *symbolName; + register unsigned char *moduleName; + unsigned long valid; + register int c = get_processor_id(); + + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + for (i = 0; i < 4; i++) + { + if (!BreakReserved[i]) + { + pB = cmd; + EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + ConditionalBreakpoint[i] = 1; + for (r = 0; (r < 255) && (*pB); r++) + BreakCondition[i][r] = *pB++; + BreakCondition[i][r] = '\0'; + } + BreakReserved[i] = 1; + BreakPoints[i] = address; + BreakType[i] = BREAK_WRITE; + BreakLength[i] = TWO_BYTE_FIELD; + symbolName = GetSymbolFromValue(address, &symbuf[c][0], + MAX_SYMBOL_LEN); + moduleName = GetModuleInfoFromSymbolValue(address, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s|%s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(moduleName) ? (char *)(moduleName) + : (char *)("")), + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + else + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + + if (ConditionalBreakpoint[i]) + DBGPrint("if (%s) is TRUE\n", BreakCondition[i]); + + SetDebugRegisters(); + return 1; + } + } + DBGPrint("no breakpoint available\n"); + } + else + DBGPrint("breakpoint parameters invalid\n"); + return 1; + +} + +/* BW4 */ + +unsigned long breakpointWord4(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address, i, r; + register unsigned char *pB, *symbolName; + register unsigned char *moduleName; + unsigned long valid; + register int c = get_processor_id(); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + for (i = 0; i < 4; i++) + { + if (!BreakReserved[i]) + { + pB = cmd; + EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + ConditionalBreakpoint[i] = 1; + for (r = 0; (r < 255) && (*pB); r++) + BreakCondition[i][r] = *pB++; + BreakCondition[i][r] = '\0'; + } + BreakReserved[i] = 1; + BreakPoints[i] = address; + BreakType[i] = BREAK_WRITE; + BreakLength[i] = FOUR_BYTE_FIELD; + symbolName = GetSymbolFromValue(address, &symbuf[c][0], + MAX_SYMBOL_LEN); + moduleName = GetModuleInfoFromSymbolValue(address, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s|%s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(moduleName) ? (char *)(moduleName) + : (char *)("")), + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + else + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + + if (ConditionalBreakpoint[i]) + DBGPrint("if (%s) is TRUE\n", BreakCondition[i]); + + SetDebugRegisters(); + return 1; + } + } + DBGPrint("no breakpoint available\n"); + } + else + DBGPrint("breakpoint parameters invalid\n"); + return 1; + +} + +/* BW */ + +unsigned long breakpointWord(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address, i, r; + register unsigned char *pB, *symbolName; + register unsigned char *moduleName; + unsigned long valid; + register int c = get_processor_id(); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + for (i = 0; i < 4; i++) + { + if (!BreakReserved[i]) + { + pB = cmd; + EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + ConditionalBreakpoint[i] = 1; + for (r = 0; (r < 255) && (*pB); r++) + BreakCondition[i][r] = *pB++; + BreakCondition[i][r] = '\0'; + } + BreakReserved[i] = 1; + BreakPoints[i] = address; + BreakType[i] = BREAK_WRITE; + BreakLength[i] = ONE_BYTE_FIELD; + symbolName = GetSymbolFromValue(address, &symbuf[c][0], + MAX_SYMBOL_LEN); + moduleName = GetModuleInfoFromSymbolValue(address, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s|%s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(moduleName) ? (char *)(moduleName) + : (char *)("")), + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + else + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + + if (ConditionalBreakpoint[i]) + DBGPrint("if (%s) is TRUE\n", BreakCondition[i]); + + SetDebugRegisters(); + return 1; + } + } + DBGPrint("no breakpoint available\n"); + } + else + DBGPrint("breakpoint parameters invalid\n"); + return 1; + +} + + +/* BR1 */ + +unsigned long breakpointRead1(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address, i, r; + register unsigned char *pB, *symbolName; + register unsigned char *moduleName; + unsigned long valid; + register int c = get_processor_id(); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + for (i = 0; i < 4; i++) + { + if (!BreakReserved[i]) + { + pB = cmd; + EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + ConditionalBreakpoint[i] = 1; + for (r = 0; (r < 255) && (*pB); r++) + BreakCondition[i][r] = *pB++; + BreakCondition[i][r] = '\0'; + } + BreakReserved[i] = 1; + BreakPoints[i] = address; + BreakType[i] = BREAK_READWRITE; + BreakLength[i] = ONE_BYTE_FIELD; + symbolName = GetSymbolFromValue(address, &symbuf[c][0], + MAX_SYMBOL_LEN); + moduleName = GetModuleInfoFromSymbolValue(address, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s|%s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(moduleName) ? (char *)(moduleName) + : (char *)("")), + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + else + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + + if (ConditionalBreakpoint[i]) + DBGPrint("if (%s) is TRUE\n", BreakCondition[i]); + + SetDebugRegisters(); + return 1; + } + } + DBGPrint("no breakpoint available\n"); + } + else + DBGPrint("breakpoint parameters invalid\n"); + return 1; + +} + + +/* BR2 */ + +unsigned long breakpointRead2(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address, i, r; + register unsigned char *pB, *symbolName; + register unsigned char *moduleName; + unsigned long valid; + register int c = get_processor_id(); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + for (i = 0; i < 4; i++) + { + if (!BreakReserved[i]) + { + pB = cmd; + EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + ConditionalBreakpoint[i] = 1; + for (r = 0; (r < 255) && (*pB); r++) + BreakCondition[i][r] = *pB++; + BreakCondition[i][r] = '\0'; + } + BreakReserved[i] = 1; + BreakPoints[i] = address; + BreakType[i] = BREAK_READWRITE; + BreakLength[i] = TWO_BYTE_FIELD; + symbolName = GetSymbolFromValue(address, &symbuf[c][0], + MAX_SYMBOL_LEN); + moduleName = GetModuleInfoFromSymbolValue(address, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s|%s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(moduleName) ? (char *)(moduleName) + : (char *)("")), + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + else + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + + if (ConditionalBreakpoint[i]) + DBGPrint("if (%s) is TRUE\n", BreakCondition[i]); + + SetDebugRegisters(); + return 1; + } + } + DBGPrint("no breakpoint available\n"); + } + else + DBGPrint("breakpoint parameters invalid\n"); + return 1; + +} + + +/* BR4 */ + +unsigned long breakpointRead4(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address, i, r; + register unsigned char *pB, *symbolName; + register unsigned char *moduleName; + unsigned long valid; + register int c = get_processor_id(); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + for (i = 0; i < 4; i++) + { + if (!BreakReserved[i]) + { + pB = cmd; + EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + ConditionalBreakpoint[i] = 1; + for (r = 0; (r < 255) && (*pB); r++) + BreakCondition[i][r] = *pB++; + BreakCondition[i][r] = '\0'; + } + BreakReserved[i] = 1; + BreakPoints[i] = address; + BreakType[i] = BREAK_READWRITE; + BreakLength[i] = FOUR_BYTE_FIELD; + symbolName = GetSymbolFromValue(address, &symbuf[c][0], + MAX_SYMBOL_LEN); + moduleName = GetModuleInfoFromSymbolValue(address, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s|%s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(moduleName) ? (char *)(moduleName) + : (char *)("")), + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + else + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + + if (ConditionalBreakpoint[i]) + DBGPrint("if (%s) is TRUE\n", BreakCondition[i]); + + SetDebugRegisters(); + return 1; + } + } + DBGPrint("no breakpoint available\n"); + } + else + DBGPrint("breakpoint parameters invalid\n"); + return 1; + +} + + +/* BR */ + +unsigned long breakpointRead(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address, i, r; + register unsigned char *pB, *symbolName; + register unsigned char *moduleName; + unsigned long valid; + register int c = get_processor_id(); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + for (i = 0; i < 4; i++) + { + if (!BreakReserved[i]) + { + pB = cmd; + EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + ConditionalBreakpoint[i] = 1; + for (r = 0; (r < 255) && (*pB); r++) + BreakCondition[i][r] = *pB++; + BreakCondition[i][r] = '\0'; + } + BreakReserved[i] = 1; + BreakPoints[i] = address; + BreakType[i] = BREAK_READWRITE; + BreakLength[i] = ONE_BYTE_FIELD; + symbolName = GetSymbolFromValue(address, &symbuf[c][0], + MAX_SYMBOL_LEN); + moduleName = GetModuleInfoFromSymbolValue(address, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s|%s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(moduleName) ? (char *)(moduleName) + : (char *)("")), + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + else + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + + if (ConditionalBreakpoint[i]) + DBGPrint("if (%s) is TRUE\n", BreakCondition[i]); + + SetDebugRegisters(); + return 1; + } + } + DBGPrint("no breakpoint available\n"); + } + else + DBGPrint("breakpoint parameters invalid\n"); + return 1; + +} + +/* BI1 */ + +unsigned long breakpointIO1(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address, i, r; + register unsigned char *pB, *symbolName; + register unsigned char *moduleName; + unsigned long valid; + register int c = get_processor_id(); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + for (i = 0; i < 4; i++) + { + if (!BreakReserved[i]) + { + pB = cmd; + EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + ConditionalBreakpoint[i] = 1; + for (r = 0; (r < 255) && (*pB); r++) + BreakCondition[i][r] = *pB++; + BreakCondition[i][r] = '\0'; + } + BreakReserved[i] = 1; + BreakPoints[i] = address; + BreakType[i] = BREAK_IOPORT; + BreakLength[i] = ONE_BYTE_FIELD; + symbolName = GetSymbolFromValue(address, &symbuf[c][0], + MAX_SYMBOL_LEN); + moduleName = GetModuleInfoFromSymbolValue(address, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s|%s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(moduleName) ? (char *)(moduleName) + : (char *)("")), + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + else + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + + if (ConditionalBreakpoint[i]) + DBGPrint("if (%s) is TRUE\n", BreakCondition[i]); + + SetDebugRegisters(); + return 1; + } + } + DBGPrint("no breakpoint available\n"); + } + else + DBGPrint("breakpoint parameters invalid\n"); + return 1; + +} + +/* BI2 */ + +unsigned long breakpointIO2(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address, i, r; + register unsigned char *pB, *symbolName; + register unsigned char *moduleName; + unsigned long valid; + register int c = get_processor_id(); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + for (i = 0; i < 4; i++) + { + if (!BreakReserved[i]) + { + pB = cmd; + EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + ConditionalBreakpoint[i] = 1; + for (r = 0; (r < 255) && (*pB); r++) + BreakCondition[i][r] = *pB++; + BreakCondition[i][r] = '\0'; + } + BreakReserved[i] = 1; + BreakPoints[i] = address; + BreakType[i] = BREAK_IOPORT; + BreakLength[i] = TWO_BYTE_FIELD; + symbolName = GetSymbolFromValue(address, &symbuf[c][0], + MAX_SYMBOL_LEN); + moduleName = GetModuleInfoFromSymbolValue(address, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s|%s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(moduleName) ? (char *)(moduleName) + : (char *)("")), + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + else + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + + if (ConditionalBreakpoint[i]) + DBGPrint("if (%s) is TRUE\n", BreakCondition[i]); + + SetDebugRegisters(); + return 1; + } + } + DBGPrint("no breakpoint available\n"); + } + else + DBGPrint("breakpoint parameters invalid\n"); + return 1; + +} + +/* BI4 */ + +unsigned long breakpointIO4(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address, i, r; + register unsigned char *pB, *symbolName; + register unsigned char *moduleName; + unsigned long valid; + register int c = get_processor_id(); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + for (i = 0; i < 4; i++) + { + if (!BreakReserved[i]) + { + pB = cmd; + EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + ConditionalBreakpoint[i] = 1; + for (r = 0; (r < 255) && (*pB); r++) + BreakCondition[i][r] = *pB++; + BreakCondition[i][r] = '\0'; + } + BreakReserved[i] = 1; + BreakPoints[i] = address; + BreakType[i] = BREAK_IOPORT; + BreakLength[i] = FOUR_BYTE_FIELD; + symbolName = GetSymbolFromValue(address, &symbuf[c][0], + MAX_SYMBOL_LEN); + moduleName = GetModuleInfoFromSymbolValue(address, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s|%s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(moduleName) ? (char *)(moduleName) + : (char *)("")), + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + else + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + + if (ConditionalBreakpoint[i]) + DBGPrint("if (%s) is TRUE\n", BreakCondition[i]); + + SetDebugRegisters(); + return 1; + } + } + DBGPrint("no breakpoint available\n"); + } + else + DBGPrint("breakpoint parameters invalid\n"); + return 1; + +} + +/* BI */ + +unsigned long breakpointIO(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address, i, r; + register unsigned char *pB, *symbolName; + register unsigned char *moduleName; + unsigned long valid; + register int c = get_processor_id(); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + for (i = 0; i < 4; i++) + { + if (!BreakReserved[i]) + { + pB = cmd; + EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + ConditionalBreakpoint[i] = 1; + for (r = 0; (r < 255) && (*pB); r++) + BreakCondition[i][r] = *pB++; + BreakCondition[i][r] = '\0'; + } + BreakReserved[i] = 1; + BreakPoints[i] = address; + BreakType[i] = BREAK_IOPORT; + BreakLength[i] = ONE_BYTE_FIELD; + symbolName = GetSymbolFromValue(address, &symbuf[c][0], + MAX_SYMBOL_LEN); + moduleName = GetModuleInfoFromSymbolValue(address, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s|%s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(moduleName) ? (char *)(moduleName) + : (char *)("")), + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + else + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + + if (ConditionalBreakpoint[i]) + DBGPrint("if (%s) is TRUE\n", BreakCondition[i]); + + SetDebugRegisters(); + return 1; + } + } + DBGPrint("no breakpoint available\n"); + } + else + DBGPrint("breakpoint parameters invalid\n"); + return 1; + +} + +/* B */ + +unsigned long breakpointExecute(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long address, i, r; + register unsigned char *pB, *symbolName; + register unsigned char *moduleName; + unsigned long valid; + register int c = get_processor_id(); + + cmd = &cmd[parser->debugCommandNameLength]; + while (*cmd && *cmd == ' ') + cmd++; + + address = EvaluateExpression(stackFrame, &cmd, &valid); + if (!valid) + { + register int found = 0; + + for (i = 0; i < 4; i++) + { + if (BreakReserved[i]) + { + symbolName = GetSymbolFromValue(BreakPoints[i], &symbuf[c][0], + MAX_SYMBOL_LEN); + moduleName = GetModuleInfoFromSymbolValue(BreakPoints[i], + &modbuf[c][0], MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("Break %i is at 0x%X (%s %s) %s|%s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(moduleName) ? (char *)(moduleName) + : (char *)("")), + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + else + DBGPrint("Break %i is at 0x%X (%s %s) %s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + + if (ConditionalBreakpoint[i]) + DBGPrint("if (%s) is TRUE\n", BreakCondition[i]); + found = 1; + } + } + if (!found) + DBGPrint("no breakpoints currently defined\n"); + + } + else + { + for (i = 0; i < 4; i++) + { + if (!BreakReserved[i]) + { + pB = cmd; + EvaluateExpression(stackFrame, &cmd, &valid); + if (valid) + { + ConditionalBreakpoint[i] = 1; + for (r = 0; r < 255 && *pB; r++) + BreakCondition[i][r] = *pB++; + BreakCondition[i][r] = '\0'; + } + BreakReserved[i] = 1; + BreakPoints[i] = address; + BreakType[i] = BREAK_EXECUTE; + BreakLength[i] = ONE_BYTE_FIELD; + symbolName = GetSymbolFromValue(address, &symbuf[c][0], + MAX_SYMBOL_LEN); + moduleName = GetModuleInfoFromSymbolValue(address, &modbuf[c][0], + MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s|%s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(moduleName) ? (char *)(moduleName) + : (char *)("")), + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + else + DBGPrint("breakpoint %i set to 0x%X (%s %s) %s\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)(""))); + + if (ConditionalBreakpoint[i]) + DBGPrint("if (%s) is TRUE\n", BreakCondition[i]); + + SetDebugRegisters(); + return 1; + } + } + DBGPrint("no breakpoint available\n"); + } + return 1; + +} + +/* BST */ + +unsigned long breakpointShowTemp(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long i; + register unsigned char *symbolName; + register unsigned char *moduleName; + register int found = 0; + register int c = get_processor_id(); + + for (i = 0; i < 4; i++) + { + if (BreakReserved[i] && BreakTemp[i]) + { + symbolName = GetSymbolFromValue(BreakPoints[i], &symbuf[c][0], + MAX_SYMBOL_LEN); + moduleName = GetModuleInfoFromSymbolValue(BreakPoints[i], + &modbuf[c][0], MAX_SYMBOL_LEN); + if (moduleName) + DBGPrint("Break %i is at 0x%X (%s %s) %s|%s [%s]\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(moduleName) ? (char *)(moduleName) + : (char *)("")), + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)("")), + BreakGo[i] ? "GO" : BreakProceed[i] + ? "PROCEED" : ""); + else + DBGPrint("Break %i is at 0x%X (%s %s) %s [%s]\n", + (int)i, + (unsigned)BreakPoints[i], + BreakDescription[(BreakType[i] & 3)], + BreakLengthDescription[(BreakLength[i] & 3)], + ((char *)(symbolName) ? (char *)(symbolName) + : (char *)("")), + BreakGo[i] ? "GO" : BreakProceed[i] + ? "PROCEED" : ""); + if (ConditionalBreakpoint[i]) + DBGPrint("if (%s) is TRUE\n", BreakCondition[i]); + + found = 1; + } + } + if (!found) + DBGPrint("no temporary breakpoints defined\n"); + + return 1; + +} + +unsigned long displayProcessorStatusHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("displays active processors and their current state\n"); + return 1; +} + +unsigned long displayProcessorStatus(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + register unsigned long i; + + for (i = 0; i < MAX_PROCESSORS; i++) + { + if (cpu_online(i)) + { + DBGPrint("Processor: (%i) State: %s\n", + i, procState[ProcessorState[i] & 0xF]); + } + } + return 1; +} + +void displayMTRRRegisters(void) +{ + register int i; + unsigned long base1, base2; + unsigned long mask1, mask2; + extern unsigned long cpu_mttr_on(void); + + if (cpu_mttr_on()) + { + DBGPrint("memory type range registers\n"); + for (i = 0; i < 8; i++) + { + ReadMSR(MTRR_BASE_REGS[i], &base1, &base2); + ReadMSR(MTRR_MASK_VALUES[i], &mask1, &mask2); + DBGPrint("MTRR_BASE_%i %X:%X MTRR_MASK_%i %X:%X\n", + (int)i, + (unsigned)base1, (unsigned)base2, + (int)i, + (unsigned)mask1, (unsigned)mask2); + } + } + else + DBGPrint("memory type range registers are Pentium Pro/II/Xeon and above\n"); + return; +} + +void DisplayGDT(unsigned char *GDT_ADDRESS) +{ + + register int i, r; + unsigned long count; + unsigned long gdt_pointer; + unsigned short gdt_index; + unsigned char *p; + unsigned char GDTR[16]; + GDT *gdt; +#ifndef CONFIG_X86_64 + TSS *tss; +#endif + union + { + GDT lgdt; + unsigned char data[16]; + } lg; + + +#ifdef CONFIG_X86_64 + ReadGDTR((unsigned long *)&GDTR[0]); + gdt_index = mdb_getword((unsigned long)&GDTR[0], 2); + gdt_pointer = mdb_getword((unsigned long)&GDTR[2], 8); + + DBGPrint("GDTR: %04X:%llX Processor: %i\n", + (unsigned)gdt_index, (unsigned long long)gdt_pointer, + (int)get_processor_id()); + + count = 0; + gdt_index = (gdt_index + 7) / 8; + p = (unsigned char *) gdt_pointer; + for (i = 0; i < gdt_index; i++) + { + if (DBGPrint("%04X(%04i):", (unsigned) count, (int)i)) return; + for (r = 0; r < 16; r++) + lg.data[r] = (unsigned char) mdb_getword((unsigned long)&p[r], 1); + + gdt = (GDT *) &lg.lgdt; + if (DBGPrint( + "0x%04lX%04X%08X seg:%04X dpl:%02X type:%02X p:%02X i:%02X", + gdt->offset_low, + gdt->offset_middle, + gdt->offset_high, + gdt->segment, + gdt->dpl, + gdt->type, + gdt->p, + gdt->ist)) return; + if (DBGPrint("\n")) return; + + p = (void *)((unsigned long) p + (unsigned long) 8); + count += 16; + } + +#else + ReadGDTR((unsigned long *)&GDTR[0]); + gdt_index = mdb_getword((unsigned long)&GDTR[0], 2); + gdt_pointer = mdb_getword((unsigned long)&GDTR[2], 4); + + DBGPrint("GDTR: %04X:%X Processor: %i\n", + (unsigned)gdt_index, (unsigned)gdt_pointer, + (int)get_processor_id()); + + count = 0; + gdt_index = (gdt_index + 7) / 8; + p = (unsigned char *) gdt_pointer; + for (i = 0; i < gdt_index; i++) + { + if (DBGPrint("%X (%04i):", (unsigned) count, (int)i)) return; + for (r = 0; r < 8; r++) + { + lg.data[r] = (unsigned char) mdb_getword((unsigned long)&p[r], 1); + if (DBGPrint(" %02X", (unsigned char) lg.data[r])) return; + } + + gdt = (GDT *) &lg.lgdt; + if ((gdt->GDTType & 0x92) == 0x92) + { + if (DBGPrint(" b:%X lim:%X t:%02X ot:%02X", + ((gdt->Base3 << 24) | (gdt->Base2 << 16) | + (gdt->Base1)), + (((gdt->OtherType & 0xF) << 16) | (gdt->Limit)), + gdt->GDTType, gdt->OtherType)) return; + } + else if ((gdt->GDTType & 0x89) == 0x89) + { + tss = (TSS *) gdt; + if (DBGPrint(" tss:%X lim:%04X t:%02X ot:%02X", + ((tss->TSSBase3 << 24) | (tss->TSSBase2 << 16) | + (tss->TSSBase1)), + tss->TSSLimit, tss->TSSType, + tss->TSSOtherType)) return; + } + if (DBGPrint("\n")) return; + + p = (void *)((unsigned long) p + (unsigned long) 8); + count += 8; + } +#endif + return; + +} + +void DisplayIDT(unsigned char *IDT_ADDRESS) +{ + + register int i, r; + unsigned long count; + unsigned long idt_pointer; + unsigned short idt_index; + unsigned char *p; + unsigned char IDTR[16]; + IDT *idt; +#ifndef CONFIG_X86_64 + TSS_GATE *tss_gate; +#endif + union + { + IDT lidt; + unsigned char data[16]; + } id; + +#ifdef CONFIG_X86_64 + ReadIDTR((unsigned long *)&IDTR[0]); + idt_index = mdb_getword((unsigned long)&IDTR[0], 2); + idt_pointer = mdb_getword((unsigned long)&IDTR[2], 8); + + DBGPrint("IDTR: %04X:%llX Processor: %i\n", + (unsigned)idt_index, (unsigned long long)idt_pointer, + (int)get_processor_id()); + + count = 0; + idt_index = (idt_index + 7) / 8; + p = (unsigned char *) idt_pointer; + for (i = 0; i < idt_index; i++) + { + if (DBGPrint("%04X(%04i):", (unsigned)count, (int)i)) return; + for (r = 0; r < 16; r++) + id.data[r] = mdb_getword((unsigned long)&p[r], 1); + + idt = (IDT *) &id.lidt; + if (DBGPrint( + "0x%04lX%04X%08X seg:%04X dpl:%02X type:%02X p:%02X i:%02X", + idt->offset_low, + idt->offset_middle, + idt->offset_high, + idt->segment, + idt->dpl, + idt->type, + idt->p, + idt->ist)) return; + + if (DBGPrint("\n")) return; + + p = (void *)((unsigned long) p + (unsigned long) 8); + count += 16; + } +#else + ReadIDTR((unsigned long *)&IDTR[0]); + idt_index = mdb_getword((unsigned long)&IDTR[0], 2); + idt_pointer = mdb_getword((unsigned long)&IDTR[2], 4); + + DBGPrint("IDTR: %04X:%X Processor: %i\n", + (unsigned)idt_index, (unsigned)idt_pointer, + (int)get_processor_id()); + + count = 0; + idt_index = (idt_index + 7) / 8; + p = (unsigned char *) idt_pointer; + for (i = 0; i < idt_index; i++) + { + if (DBGPrint("%X (%04i):", (unsigned)count, (int)i)) return; + for (r = 0; r < 8; r++) + { + id.data[r] = mdb_getword((unsigned long)&p[r], 1); + if (DBGPrint(" %02X", (unsigned char) id.data[r])) return; + } + idt = (IDT *) &id.lidt; + if ((idt->IDTFlags & 0x8E) == 0x8E) + { + if (DBGPrint(" b:%X s:%04X t:%02X ot:%02X", + ((idt->IDTHigh << 16) | (idt->IDTLow)), + idt->IDTSegment, + idt->IDTFlags, idt->IDTSkip)) return; + + } + else if ((idt->IDTFlags & 0x85) == 0x85) + { + tss_gate = (TSS_GATE *) idt; + if (DBGPrint(" task_gate: %04X t:%02X", + tss_gate->TSSSelector, tss_gate->TSSFlags)) return; + } + if (DBGPrint("\n")) return; + + p = (void *)((unsigned long) p + (unsigned long) 8); + count += 8; + } +#endif + return; + +} + +void DisplayTSS(StackFrame *stackFrame) +{ +#ifdef CONFIG_X86_64 + unsigned long i, f = 0; + + DBGPrint("Task State Segment at 0x%p\n", stackFrame); + + DBGPrint("RAX: %016lX RBX: %016lX RCX: %016lX\n", + stackFrame->tAX, stackFrame->tBX, stackFrame->tCX); + + DBGPrint("RDX: %016lX RSI: %016lX RDI: %016lX\n", + stackFrame->tDX, stackFrame->tSI, stackFrame->tDI); + + DBGPrint("RSP: %016lX RBP: %016lX R8: %016lX\n", + stackFrame->tSP, stackFrame->tBP, stackFrame->r8); + + DBGPrint(" R9: %016lX R10: %016lX R11: %016lX\n", + stackFrame->r9, stackFrame->r10, stackFrame->r11); + + DBGPrint("R12: %016lX R13: %016lX R14: %016lX\n", + stackFrame->r12, stackFrame->r13, stackFrame->r14); + + DBGPrint("R15: %016lX\n", stackFrame->r15); + + DBGPrint( + "CS: %04X DS: %04X ES: %04X FS: %04X GS: %04X SS: %04X LDT: %04X\n", + (unsigned)stackFrame->tCS, (unsigned)stackFrame->tDS, + (unsigned)stackFrame->tES, (unsigned)stackFrame->tFS, + (unsigned)stackFrame->tGS, (unsigned)stackFrame->tSS, + (unsigned)stackFrame->tLDT); + + DBGPrint("RIP: %016lX FLAGS: %016lX ", + stackFrame->tIP, stackFrame->tSystemFlags); + + DBGPrint(" ("); + for (i = 0; i < 22; i++) + { + if (IA32Flags[i]) + { + if ((stackFrame->tSystemFlags >> i) & 0x00000001) + { + if (f) + DBGPrint(" "); + f = 1; + DBGPrint("%s", IA32Flags[i]); + } + } + } + DBGPrint(")\n"); + + DBGPrint("CR3: %016lX IOMAP: %016lX BLINK: %016lX\n", + (unsigned)stackFrame->tCR3, (unsigned)stackFrame->tIOMap, + (unsigned)stackFrame->tReserved[0]); + +#else + unsigned long i, f = 0; + + DBGPrint("Task State Segment at 0x%p\n", stackFrame); + + DBGPrint("EAX: %08X EBX: %08X ECX: %08X EDX: %08X\n", + (unsigned)stackFrame->tAX, (unsigned)stackFrame->tBX, + (unsigned)stackFrame->tCX, (unsigned)stackFrame->tDX); + + DBGPrint("ESI: %08X EDI: %08X ESP: %08X EBP: %08X\n", + (unsigned)stackFrame->tSI, (unsigned)stackFrame->tDI, + (unsigned)stackFrame->tSP, (unsigned)stackFrame->tBP); + + DBGPrint( + "CS: %04X DS: %04X ES: %04X FS: %04X GS: %04X SS: %04X LDT: %04X\n", + (unsigned)stackFrame->tCS, (unsigned)stackFrame->tDS, + (unsigned)stackFrame->tES, (unsigned)stackFrame->tFS, + (unsigned)stackFrame->tGS, (unsigned)stackFrame->tSS, + (unsigned)stackFrame->tLDT); + + DBGPrint("EIP: %08X FLAGS: %08X ", + (unsigned)stackFrame->tIP, (unsigned)stackFrame->tSystemFlags); + + DBGPrint(" ("); + for (i = 0; i < 22; i++) + { + if (IA32Flags[i]) + { + if ((stackFrame->tSystemFlags >> i) & 0x00000001) + { + if (f) + DBGPrint(" "); + f = 1; + DBGPrint("%s", IA32Flags[i]); + } + } + } + DBGPrint(")\n"); + + DBGPrint("CR3: %08X IOMAP: %08X BLINK: %08X\n", + (unsigned)stackFrame->tCR3, (unsigned)stackFrame->tIOMap, + (unsigned)stackFrame->tReserved[0]); + +#endif +} + +void DisplayGeneralRegisters(StackFrame *stackFrame) +{ +#ifdef CONFIG_X86_64 + unsigned long i, f = 0; + + DBGPrint("RAX: %016lX ", stackFrame->tAX); + DBGPrint("RBX: %016lX ", stackFrame->tBX); + DBGPrint("RCX: %016lX\n", stackFrame->tCX); + DBGPrint("RDX: %016lX ", stackFrame->tDX); + DBGPrint("RSI: %016lX ", stackFrame->tSI); + DBGPrint("RDI: %016lX\n", stackFrame->tDI); + DBGPrint("RSP: %016lX ", stackFrame->tSP); + DBGPrint("RBP: %016lX ", stackFrame->tBP); + DBGPrint(" R8: %016lX\n", stackFrame->r8); + DBGPrint(" R9: %016lX ", stackFrame->r9); + DBGPrint("R10: %016lX ", stackFrame->r10); + DBGPrint("R11: %016lX\n", stackFrame->r11); + DBGPrint("R12: %016lX ", stackFrame->r12); + DBGPrint("R13: %016lX ", stackFrame->r13); + DBGPrint("R14: %016lX\n", stackFrame->r14); + DBGPrint("R15: %016lX ", stackFrame->r15); + + if (segment_toggle) + DisplaySegmentRegisters(stackFrame); + else + DBGPrint("\n"); + + DBGPrint(" IP: %016lX ", stackFrame->tIP); + DBGPrint("FLAGS: %016lX ", stackFrame->tSystemFlags); + + DBGPrint(" ("); + for (i = 0; i < 22; i++) + { + if (IA32Flags[i]) + { + if ((stackFrame->tSystemFlags >> i) & 0x00000001) + { + if (f) + DBGPrint(" "); + f = 1; + DBGPrint("%s", IA32Flags[i]); + } + } + } + DBGPrint(")\n"); + +#else + unsigned long i, f = 0; + + DBGPrint("EAX: %08X ", (unsigned)stackFrame->tAX); + DBGPrint("EBX: %08X ", (unsigned)stackFrame->tBX); + DBGPrint("ECX: %08X ", (unsigned)stackFrame->tCX); + DBGPrint("EDX: %08X\n", (unsigned)stackFrame->tDX); + DBGPrint("ESI: %08X ", (unsigned)stackFrame->tSI); + DBGPrint("EDI: %08X ", (unsigned)stackFrame->tDI); + DBGPrint("ESP: %08X ", (unsigned)stackFrame->tSP); + DBGPrint("EBP: %08X\n", (unsigned)stackFrame->tBP); + + if (segment_toggle) + DisplaySegmentRegisters(stackFrame); + + DBGPrint("EIP: %08X ", (unsigned)stackFrame->tIP); + DBGPrint("EFLAGS: %08X ", (unsigned)stackFrame->tSystemFlags); + + DBGPrint(" ("); + for (i = 0; i < 22; i++) + { + if (IA32Flags[i]) + { + if ((stackFrame->tSystemFlags >> i) & 0x00000001) + { + if (f) + DBGPrint(" "); + f = 1; + DBGPrint("%s", IA32Flags[i]); + } + } + } + DBGPrint(")\n"); +#endif +} + +void DisplaySegmentRegisters(StackFrame *stackFrame) +{ +#ifdef CONFIG_X86_64 + DBGPrint("CS: %04X ", (unsigned)stackFrame->tCS); + DBGPrint("DS: %04X ", (unsigned)stackFrame->tDS); + DBGPrint("ES: %04X ", (unsigned)stackFrame->tES); + DBGPrint("FS: %04X ", (unsigned)stackFrame->tFS); + DBGPrint("GS: %04X ", (unsigned)stackFrame->tGS); + DBGPrint("SS: %04X\n", (unsigned)stackFrame->tSS); +#else + DBGPrint("CS: %04X ", (unsigned)stackFrame->tCS); + DBGPrint("DS: %04X ", (unsigned)stackFrame->tDS); + DBGPrint("ES: %04X ", (unsigned)stackFrame->tES); + DBGPrint("FS: %04X ", (unsigned)stackFrame->tFS); + DBGPrint("GS: %04X ", (unsigned)stackFrame->tGS); + DBGPrint("SS: %04X\n", (unsigned)stackFrame->tSS); +#endif +} + +void DisplayControlRegisters(unsigned long processor, StackFrame *stackFrame) +{ + + unsigned char GDTR[16], IDTR[16]; + + if (stackFrame) {}; + +#ifdef CONFIG_X86_64 + DBGPrint("CR0: %016lX ", ReadCR0()); + DBGPrint("CR2: %016lX ", ReadCR2()); + DBGPrint("CR3: %016lX\n", ReadCR3()); + DBGPrint("CR4: %016lX ", ReadCR4()); + DBGPrint("DR0: %016lX ", ReadDR0()); + DBGPrint("DR1: %016lX\n", ReadDR1()); + DBGPrint("DR2: %016lX ", ReadDR2()); + DBGPrint("DR3: %016lX ", ReadDR3()); + DBGPrint("DR6: %016lX\n", ReadDR6()); + DBGPrint("DR7: %016lX ", ReadDR7()); + DBGPrint("VR6: %016lX ", CurrentDR6[processor]); + DBGPrint("VR7: %016lX\n", CurrentDR7); + + ReadGDTR((unsigned long *)&GDTR[0]); + ReadIDTR((unsigned long *)&IDTR[0]); + + DBGPrint("GDTR: %04X:%llX IDTR: %04X:%llX\n", + (unsigned)*(unsigned short *)&GDTR[0], + *(unsigned long long *)&GDTR[2], + (unsigned)*(unsigned short *)&IDTR[0], + *(unsigned long long *)&IDTR[2]); + DBGPrint("LDTR: %04X TR: %04X\n", + (unsigned)ReadLDTR(), + (unsigned)ReadTR()); +#else + DBGPrint("CR0: %08X ", (unsigned)ReadCR0()); + DBGPrint("CR2: %08X ", (unsigned)ReadCR2()); + DBGPrint("CR3: %08X ", (unsigned)ReadCR3()); + DBGPrint("CR4: %08X\n", (unsigned)ReadCR4()); + DBGPrint("DR0: %08X ", (unsigned)ReadDR0()); + DBGPrint("DR1: %08X ", (unsigned)ReadDR1()); + DBGPrint("DR2: %08X ", (unsigned)ReadDR2()); + DBGPrint("DR3: %08X\n", (unsigned)ReadDR3()); + DBGPrint("DR6: %08X ", (unsigned)ReadDR6()); + DBGPrint("DR7: %08X ", (unsigned)ReadDR7()); + DBGPrint("VR6: %08X ", (unsigned)CurrentDR6[processor]); + DBGPrint("VR7: %08X\n", (unsigned)CurrentDR7); + + DBGPrint("GDTR: %04X:%08X IDTR: %04X:%08X LDTR: %04X TR: %04X\n", + (unsigned)*(unsigned short *)&GDTR[0], + (unsigned)*(unsigned long *)&GDTR[2], + (unsigned)*(unsigned short *)&IDTR[0], + (unsigned)*(unsigned long *)&IDTR[2], + (unsigned)ReadLDTR(), + (unsigned)ReadTR()); +#endif + +} + +unsigned long ConsoleDisplayBreakReason(StackFrame *stackFrame, + unsigned long Exception, + unsigned long processor, + unsigned long lastCommand) +{ + if (last_mdb_oops) + DBGPrint("\nKernel Oops reported (%s)\n", last_mdb_oops); + + if ((CurrentDR6[processor] & B0_BIT) && (CurrentDR7 & G0_BIT) && + Exception == 1) + { + if (BreakGo[0]) + { + DBGPrint("\nBreak at 0x%lX due to - GO breakpoint (0)\n", + stackFrame->tIP); + return 1; + } + else + if (BreakProceed[0]) + { + DBGPrint("\nBreak at 0x%lX due to - Proceed breakpoint (0)\n", + stackFrame->tIP); + return 1; + } + else + if (BreakPoints[0] && ConditionalBreakpoint[0]) + { + DBGPrint("\nBreak at 0x%lX due to - breakpoint 0 (%s)\n", + stackFrame->tIP, + BreakDescription[(BreakType[0] & 3)]); + DBGPrint("expr: %s was TRUE\n", BreakCondition[0]); + return 1; + } + else + if (BreakPoints[0]) + { + DBGPrint("\nBreak at 0x%lX due to - breakpoint 0 (%s)\n", + stackFrame->tIP, + BreakDescription[(BreakType[0] & 3)]); + return 1; + } + else + { + DBGPrint("\nBreak at 0x%lX due to - INT1 breakpoint (B0)\n", + stackFrame->tIP); + return 1; /* not one of ours */ + } + } + else + if ((CurrentDR6[processor] & B1_BIT) && (CurrentDR7 & G1_BIT) && + Exception == 1) + { + if (BreakGo[1]) + { + DBGPrint("\nBreak at 0x%lX due to - GO breakpoint (1)\n", + stackFrame->tIP); + return 1; + } + else + if (BreakProceed[1]) + { + DBGPrint("\nBreak at 0x%lX due to - Proceed breakpoint (1)\n", + stackFrame->tIP); + return 1; + } + else + if (BreakPoints[1] && ConditionalBreakpoint[1]) + { + DBGPrint("\nBreak at 0x%lX due to - breakpoint 1 (%s)\n", + stackFrame->tIP, + BreakDescription[(BreakType[1] & 3)]); + DBGPrint("expr: %s was TRUE\n", BreakCondition[1]); + return 1; + } + else + if (BreakPoints[1]) + { + DBGPrint("\nBreak at 0x%lX due to - breakpoint 1 (%s)\n", + stackFrame->tIP, + BreakDescription[(BreakType[1] & 3)]); + return 1; + } + else + { + DBGPrint("\nBreak at 0x%lX due to - INT1 breakpoint (B1)\n", + stackFrame->tIP); + return 1; /* not one of ours */ + } + } + else + if ((CurrentDR6[processor] & B2_BIT) && (CurrentDR7 & G2_BIT) && + Exception == 1) + { + if (BreakGo[2]) + { + DBGPrint("\nBreak at 0x%lX due to - GO breakpoint (2)\n", + stackFrame->tIP); + return 1; + } + else + if (BreakProceed[2]) + { + DBGPrint("\nBreak at 0x%lX due to - Proceed breakpoint (2)\n", + stackFrame->tIP); + return 1; + } + else + if (BreakPoints[2] && ConditionalBreakpoint[2]) + { + DBGPrint("\nBreak at 0x%lX due to - breakpoint 2 (%s)\n", + stackFrame->tIP, + BreakDescription[(BreakType[2] & 3)]); + DBGPrint("expr: %s was TRUE\n", BreakCondition[2]); + return 1; + } + else + if (BreakPoints[2]) + { + DBGPrint("\nBreak at 0x%lX due to - breakpoint 2 (%s)\n", + stackFrame->tIP, + BreakDescription[(BreakType[2] & 3)]); + return 1; + } + else + { + DBGPrint("\nBreak at 0x%lX due to - INT1 breakpoint (B2)\n", + stackFrame->tIP); + return 1; /* not one of ours */ + } + } + else + if ((CurrentDR6[processor] & B3_BIT) && (CurrentDR7 & G3_BIT) && + Exception == 1) + { + if (BreakGo[3]) + { + DBGPrint("\nBreak at 0x%lX due to - GO breakpoint (3)\n", + stackFrame->tIP); + return 1; + } + else + if (BreakProceed[3]) + { + DBGPrint("\nBreak at 0x%lX due to - Proceed breakpoint (3)\n", + stackFrame->tIP); + return 1; + } + else + if (BreakPoints[3] && ConditionalBreakpoint[3]) + { + DBGPrint("\nBreak at 0x%lX due to - breakpoint 3 (%s)\n", + stackFrame->tIP, + BreakDescription[(BreakType[3] & 3)]); + DBGPrint("expr: %s was TRUE\n", BreakCondition[3]); + return 1; + } + else + if (BreakPoints[3]) + { + DBGPrint("\nBreak at 0x%lX due to - breakpoint 3 (%s)\n", + stackFrame->tIP, + BreakDescription[(BreakType[3] & 3)]); + return 1; + } + else + { + DBGPrint("\nBreak at 0x%lX due to - INT1 breakpoint (B3)\n", + stackFrame->tIP); + return 1; /* not one of ours */ + } + } + else + { + /* if the last command was a Proceed that was converted into a */ + /* single step command, report proceed single step */ + if (lastCommandEntry == 'P' && Exception == 1) + { + DBGPrint("\nBreak at 0x%lX due to - Proceed (single step)\n", + stackFrame->tIP); + return 1; + } + else + if (lastCommandEntry == 'T' && Exception == 1) + { + DBGPrint("\nBreak at 0x%lX due to - Trace (single step)\n", + stackFrame->tIP); + return 1; + } + else + if (lastCommandEntry == K_F8 && Exception == 1) + { + DBGPrint("\nBreak at 0x%lX due to - Proceed (single step)\n", + stackFrame->tIP); + return 1; + } + else + if (lastCommandEntry == K_F7 && Exception == 1) + { + DBGPrint("\nBreak at 0x%lX due to - Trace (single step)\n", + stackFrame->tIP); + return 1; + } + else + if (lastCommandEntry == K_F6 && Exception == 1) + { + DBGPrint("\nBreak at 0x%lX due to - SSB (step til branch)\n", + stackFrame->tIP); + return 1; + } + else + if (Exception == 3) /* not our exception */ + { + DBGPrint("\nBreak at 0x%lX due to - INT3 breakpoint\n", + stackFrame->tIP); + return 1; + } + else + if (Exception == 1) /* not our exception, must be gdb */ + { + DBGPrint("\nBreak at 0x%lX due to - INT1 breakpoint\n", + stackFrame->tIP); + return 1; + } + else + if ((Exception < exceptions) && + ExceptionDescription[Exception % exceptions]) + { + DBGPrint("\nBreak at 0x%lX due to - %s\n", + stackFrame->tIP, + ExceptionDescription[Exception % exceptions]); + return 1; + } + else + { + DBGPrint("\nBreak at 0x%lX due to - %lu\n", + stackFrame->tIP, Exception); + return 1; + } + } + DBGPrint("\nBreak at 0x%lX due to - Unknown Reason\n", + stackFrame->tIP); + return 1; + +} + +unsigned long ReasonHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser) +{ + DBGPrint("display break reason\n"); + return 1; +} + +unsigned long ReasonDisplay(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser) +{ + ConsoleDisplayBreakReason(stackFrame, Exception, get_processor_id(), 0); + return 1; +} + +void ReadStackFrame(void *frame, StackFrame *sf, unsigned long processor) +{ + struct pt_regs *regs = frame; + + sf->tReserved[1] = regs->orig_ax; + sf->tReserved[2] = (unsigned long)regs; + sf->tCR3 = ReadCR3(); + sf->tLDT = ReadLDTR(); + + sf->tIP = regs->ip; + sf->tAX = regs->ax; + sf->tCX = regs->cx; + sf->tDX = regs->dx; + sf->tBX = regs->bx; + sf->tBP = regs->bp; + sf->tSI = regs->si; + sf->tDI = regs->di; + +#ifdef CONFIG_X86_32 + sf->tSystemFlags = regs->flags; + sf->tCS = (unsigned short)regs->cs; + sf->tDS = (unsigned short)regs->ds; + sf->tES = (unsigned short)regs->es; + sf->tFS = ReadFS(); + sf->tGS = ReadGS(); + if (user_mode_vm(regs)) + { + sf->tSS = regs->ss; + sf->tSP = regs->sp; + } else { + sf->tSS = __KERNEL_DS; + sf->tSP = kernel_stack_pointer(regs); + } +#else + sf->r8 = regs->r8; + sf->r9 = regs->r9; + sf->r10 = regs->r10; + sf->r11 = regs->r11; + sf->r12 = regs->r12; + sf->r13 = regs->r13; + sf->r14 = regs->r14; + sf->r15 = regs->r15; + + sf->tSystemFlags = regs->flags; + sf->tCS = regs->cs; + sf->tDS = ReadDS(); + sf->tES = ReadES(); + sf->tFS = ReadFS(); + sf->tGS = ReadGS(); + sf->tSS = regs->ss; + sf->tSP = kernel_stack_pointer(regs); +#endif + /* save state. */ + memmove((void *)&ReferenceFrame[processor], sf, sizeof(StackFrame)); + return; +} + +void ReadTaskFrame(StackFrame *sf, struct task_struct *p) +{ + memset((void *)sf, 0, sizeof(StackFrame)); + + sf->tBP = *(unsigned long *)p->thread.sp; +#ifdef CONFIG_X86_32 + sf->tDS = __KERNEL_DS; + sf->tES = __KERNEL_DS; + sf->tCS = __KERNEL_CS; + sf->tSS = __KERNEL_DS; + sf->tFS = 0xFFFF; + sf->tGS = 0xFFFF; + sf->tIP = p->thread.ip; + sf->tSystemFlags = 0; +#else + sf->tCS = __KERNEL_CS; + sf->tSS = __KERNEL_DS; + sf->tIP = 0; + sf->tSystemFlags = *(unsigned long *)(p->thread.sp + 8); +#endif + sf->tSP = p->thread.sp; + return; +} + +void WriteStackFrame(void *frame, StackFrame *sf, unsigned long processor) +{ + struct pt_regs *regs = frame; + + if (ReferenceFrame[processor].tIP != sf->tIP) + regs->ip = sf->tIP; + if (ReferenceFrame[processor].tReserved[1] != sf->tReserved[1]) + regs->orig_ax = sf->tReserved[1]; + if (ReferenceFrame[processor].tAX != sf->tAX) + regs->ax = sf->tAX; + if (ReferenceFrame[processor].tCX != sf->tCX) + regs->cx = sf->tCX; + if (ReferenceFrame[processor].tDX != sf->tDX) + regs->dx = sf->tDX; + if (ReferenceFrame[processor].tBX != sf->tBX) + regs->bx = sf->tBX; + if (ReferenceFrame[processor].tSP != sf->tSP) + regs->sp = sf->tSP; + if (ReferenceFrame[processor].tBP != sf->tBP) + regs->bp = sf->tBP; + if (ReferenceFrame[processor].tSI != sf->tSI) + regs->si = sf->tSI; + if (ReferenceFrame[processor].tDI != sf->tDI) + regs->di = sf->tDI; + +#ifdef CONFIG_X86_32 + if (ReferenceFrame[processor].tSystemFlags != sf->tSystemFlags) + regs->flags = sf->tSystemFlags; + if (ReferenceFrame[processor].tCS != sf->tCS) + regs->cs = sf->tCS; + if (ReferenceFrame[processor].tDS != sf->tDS) + regs->ds = sf->tDS; + if (ReferenceFrame[processor].tES != sf->tES) + regs->es = sf->tES; + if (ReferenceFrame[processor].tFS != sf->tFS) + regs->fs = sf->tFS; + if (ReferenceFrame[processor].tGS != sf->tGS) + regs->gs = sf->tGS; + if (ReferenceFrame[processor].tSS != sf->tSS) + regs->ss = sf->tSS; +#else + if (ReferenceFrame[processor].r8 != sf->r8) + regs->r8 = sf->r8; + if (ReferenceFrame[processor].r9 != sf->r9) + regs->r9 = sf->r9; + if (ReferenceFrame[processor].r10 != sf->r10) + regs->r10 = sf->r10; + if (ReferenceFrame[processor].r11 != sf->r11) + regs->r11 = sf->r11; + if (ReferenceFrame[processor].r12 != sf->r12) + regs->r12 = sf->r12; + if (ReferenceFrame[processor].r13 != sf->r13) + regs->r13 = sf->r13; + if (ReferenceFrame[processor].r14 != sf->r14) + regs->r14 = sf->r14; + if (ReferenceFrame[processor].r15 != sf->r15) + regs->r15 = sf->r15; + + if (ReferenceFrame[processor].tSystemFlags != sf->tSystemFlags) + regs->flags = sf->tSystemFlags; + if (ReferenceFrame[processor].tCS != sf->tCS) + regs->cs = sf->tCS; + if (ReferenceFrame[processor].tSS != sf->tSS) + regs->ss = sf->tSS; +#endif + return; +} + +void SetDebugRegisters(void) +{ + register int i; + + for (i = 0; i < 4; i++) + { + switch (i) + { + case 0: + if (BreakReserved[i]) + { + CurrentDR7 &= 0xFFF0FFFF; + CurrentDR7 |= G0_BIT; + CurrentDR7 |= ((BreakType[i] << ((i * 4) + 16)) | + (BreakLength[i] << ((i * 4) + 18))); + } + else + { + CurrentDR7 &= 0xFFF0FFFF; + CurrentDR7 &= ~G0_BIT; + CurrentDR7 &= ~L0_BIT; + } + WriteDR0(BreakPoints[i]); + break; + + case 1: + if (BreakReserved[i]) + { + CurrentDR7 &= 0xFF0FFFFF; + CurrentDR7 |= G1_BIT; + CurrentDR7 |= ((BreakType[i] << ((i * 4) + 16)) | + (BreakLength[i] << ((i * 4) + 18))); + } + else + { + CurrentDR7 &= 0xFF0FFFFF; + CurrentDR7 &= ~G1_BIT; + CurrentDR7 &= ~L1_BIT; + } + WriteDR1(BreakPoints[i]); + break; + + case 2: + if (BreakReserved[i]) + { + CurrentDR7 &= 0xF0FFFFFF; + CurrentDR7 |= G2_BIT; + CurrentDR7 |= ((BreakType[i] << ((i * 4) + 16)) | + (BreakLength[i] << ((i * 4) + 18))); + } + else + { + CurrentDR7 &= 0xF0FFFFFF; + CurrentDR7 &= ~G2_BIT; + CurrentDR7 &= ~L2_BIT; + } + WriteDR2(BreakPoints[i]); + break; + + case 3: + if (BreakReserved[i]) + { + CurrentDR7 &= 0x0FFFFFFF; + CurrentDR7 |= G3_BIT; + CurrentDR7 |= ((BreakType[i] << ((i * 4) + 16)) | + (BreakLength[i] << ((i * 4) + 18))); + } + else + { + CurrentDR7 &= 0x0FFFFFFF; + CurrentDR7 &= ~G3_BIT; + CurrentDR7 &= ~L3_BIT; + } + WriteDR3(BreakPoints[i]); + break; + + } + } + return; + +} + +void LoadDebugRegisters(void) +{ + + register int i; + + WriteDR6(0); /* clear last exception status */ + for (i = 0; i < 4; i++) + { + switch (i) + { + case 0: + if (BreakReserved[i]) + WriteDR0(BreakPoints[i]); + break; + + case 1: + if (BreakReserved[i]) + WriteDR1(BreakPoints[i]); + break; + + case 2: + if (BreakReserved[i]) + WriteDR2(BreakPoints[i]); + break; + + case 3: + if (BreakReserved[i]) + WriteDR3(BreakPoints[i]); + break; + } + } + WriteDR7(CurrentDR7); /* set breakpoint enable/disable state */ + +} + +/* + * processor synchronization + * + * We have to handle multiple cpus with active breakpoints + * attempting to access the debugger. We also have to handle + * double faulted situations. + * + */ + +unsigned long debug_lock(volatile rlock_t *rlock, unsigned long p) +{ +#if defined(CONFIG_SMP) + if (!spin_trylock_irqsave((spinlock_t *)&rlock->lock, rlock->flags[p])) + { + if (rlock->processor == p) + { + rlock->count++; +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: debug lock(++) count (%lu) state:%s\n", + rlock->count, (int)p, procState[ProcessorState[p] & 0xF]); +#endif + } + else + { +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: debug trylock FAILED state:%s\n", + (int)p, procState[ProcessorState[p] & 0xF]); +#endif + while (1) + { + mdelay(1); + ProcessorState[p] = PROCESSOR_HOLD; + while (atomic_read(&focusActive) && + !atomic_read(&traceProcessors[p])) + { + cpu_relax(); + } + + if (spin_trylock_irqsave((spinlock_t *)&rlock->lock, + rlock->flags[p])) + break; + } + ProcessorState[p] = PROCESSOR_DEBUG; + rlock->processor = p; + +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: debug spinlock SUCCESS state:%s\n", + (int)p, procState[ProcessorState[p] & 0xF]); +#endif + } + } + else + rlock->processor = p; + +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: debug lock SUCCESS state:%s\n", + (int)p, procState[ProcessorState[p] & 0xF]); +#endif +#endif /* CONFIG_SMP */ + return 1; +} + +void debug_unlock(volatile rlock_t *rlock, unsigned long p) +{ +#if defined(CONFIG_SMP) + if (rlock->processor != p) + { +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: debug unlock FAILED state:%s (%lu/%lu)\n", + (int)p, procState[ProcessorState[p] & 0xF], + rlock->processor, p); +#endif + } + + if (rlock->count) + { + rlock->count--; +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: debug unlock(--) count (%lu) state:%s\n", + (int)p, rlock->count, procState[ProcessorState[p] & 0xF]); +#endif + } + else + { + rlock->processor = -1; + spin_unlock_irqrestore((spinlock_t *)&rlock->lock, rlock->flags[p]); + } +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: debug unlock count (%lu) state:%s\n", + (int)p, rlock->count, procState[ProcessorState[p] & 0xF]); +#endif +#endif /* CONFIG_SMP */ + return; +} + +unsigned long debug_rlock(volatile rlock_t *rlock, unsigned long p) +{ +#if defined(CONFIG_SMP) + if (!spin_trylock_irqsave((spinlock_t *)&rlock->lock, rlock->flags[p])) + { + if (rlock->processor == p) + { + rlock->count++; +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: debug lock(++) count (%lu) state:%s\n", + rlock->count, (int)p, procState[ProcessorState[p] & 0xF]); +#endif + } + else + { +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: debug trylock FAILED state:%s\n", + (int)p, procState[ProcessorState[p] & 0xF]); +#endif + while (1) + { + mdelay(1); + cpu_relax(); + if (spin_trylock_irqsave((spinlock_t *)&rlock->lock, + rlock->flags[p])) + break; + } + rlock->processor = p; + +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: debug spinlock SUCCESS state:%s\n", + (int)p, procState[ProcessorState[p] & 0xF]); +#endif + } + } + else + rlock->processor = p; + +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: debug lock SUCCESS state:%s\n", + (int)p, procState[ProcessorState[p] & 0xF]); +#endif +#endif /* CONFIG_SMP */ + return 1; +} + +void debug_unrlock(volatile rlock_t *rlock, unsigned long p) +{ +#if defined(CONFIG_SMP) + if (rlock->processor != p) + { +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: debug unlock FAILED state:%s (%lu/%lu)\n", + (int)p, procState[ProcessorState[p] & 0xF], + rlock->processor, p); +#endif + } + + if (rlock->count) + { + rlock->count--; +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: debug unlock(--) count (%lu) state:%s\n", + (int)p, rlock->count, procState[ProcessorState[p] & 0xF]); +#endif + } + else + { + rlock->processor = -1; + spin_unlock_irqrestore((spinlock_t *)&rlock->lock, rlock->flags[p]); + } +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: debug unlock count (%lu) state:%s\n", + (int)p, rlock->count, procState[ProcessorState[p] & 0xF]); +#endif +#endif /* CONFIG_SMP */ + return; +} + +unsigned long StopProcessorsExclSelf(unsigned long self) +{ +#if defined(CONFIG_SMP) && !defined(CONFIG_X86_ELAN) + register unsigned long failed; + register int i; + +#if MDB_DEBUG_DEBUGGER + if (atomic_read(&debuggerActive) > 1) + { + DBGPrint("%i: stop processors IPI waiters:%i state:%s\n", + (int)self, (int)atomic_read(&debuggerActive), + procState[ProcessorState[self] & 0xF]); + } + DBGPrint("%i: stop processors ENTER state:%s\n", + (int)self, procState[ProcessorState[self] & 0xF]); +#endif + + /* + You need to delay before issuing NMI and allow any previously + released processors to exit and issue their IRETD before + triggering another NMI event or exception. + + This fix seems to avoid lockup during APIC ICR write on some SMT + capable and dual core laptop computers (Acer 9410). if an ICR xcall + is issued before a target processor has exited an active + exception or if a processor inside an active INT1 exception + receives a directed NMI from the local APIC, it can result in + a hard hang. The reason for this behavior has not been fully + investigated. + + This lockup occurs if more than one processor is currently handling + an INT1 debugger exception and one of the processors gets an NMI + while still inside the INT1 exception (nested exceptions). It + does not happen all the time and appears timing dependent. + + The symptom is a hard bus hang while attempting to write an ICR + command to the local APIC ICR register. The check for a busy bit + in the ICR register succeeds and allows the ICR write to occur + prior to the lockup. + */ + mdelay(1); + + for (i = 0; i < MAX_PROCESSORS; i++) + { + if (cpu_online(i)) + { + if (i != self) + { + /* do not NMI a procesor already spinning inside the + debugger. It may result in a system lockup. */ + if (!atomic_read(&debuggerProcessors[i])) + { + ProcessorHold[i] = 1; + barrier(); +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i:send_IPI_mask ENTER cpu:%lu state:%s\n", + (int)self, i, procState[ProcessorState[i] & 0xF]); +#endif + apic->send_IPI_mask(cpumask_of(i), APIC_DM_NMI); +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i:send_IPI_mask EXIT cpu:%lu state:%s\n", + (int)self, i, procState[ProcessorState[i] & 0xF]); +#endif + } + } + } + } + +#if 0 + /* This code can result in hard system lockup on certain laptop models + * during NMI of the other processors. The cause has not been + * determined. */ + DBGPrint("%i: Send_IPI_allbutself ...", (int)self); + send_IPI_allbutself(APIC_DM_NMI); + DBGPrint(" completed\n"); +#endif + + for (i = 0, failed=0; i < MAX_PROCESSORS; i++) + { + if (cpu_online(i)) + { + if (i != self) + { + register unsigned long msecs = 1000; + + while (!atomic_read(&debuggerProcessors[i]) && msecs) + { + mdelay(1); + msecs--; + } + + if (!msecs) + { + failed++; + DBGPrint("Processor %i could not be halted state:%s\n", + (int)i, procState[ProcessorState[i] & 0xF]); + } + } + } + } +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: stop processors EXITED state:%s\n", + (int)self, procState[ProcessorState[self] & 0xF]); +#endif + + return (unsigned long) failed; +#else + return 0; +#endif +} + +unsigned long FreeProcessorsExclSelf(unsigned long self) +{ +#if defined(CONFIG_SMP) && !defined(CONFIG_X86_ELAN) + register int i; + +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: release processors ENTER state:%s\n", + (int)self, procState[ProcessorState[self] & 0xF]); +#endif + + for (i = 0; i < MAX_PROCESSORS; i++) + { + if (ProcessorState[i] != PROCESSOR_HOLD) + { + ProcessorState[i] = PROCESSOR_RESUME; + barrier(); + } + } + +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: release processors EXITED state:%s\n", + (int)self, procState[ProcessorState[self] & 0xF]); +#endif + + return i; +#else + return MAX_PROCESSORS; +#endif + +} + +unsigned long WaitRestartExclSelf(unsigned long self) +{ +#if defined(CONFIG_SMP) + register unsigned long failed; + register int i; + +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: wait processors ENTERED state:%s\n", + (int)self, procState[ProcessorState[self] & 0xF]); +#endif + + for (i = 0, failed=0; i < MAX_PROCESSORS; i++) + { + if (cpu_online(i)) + { + if (i != self) + { + register unsigned long msecs = 1000; + + smp_rmb(); + while (atomic_read(&nmiProcessors[i]) && msecs) + { + mdelay(1); + msecs--; + } + + if (!msecs) + { + failed++; + DBGPrint("Processor %i did not restart state:%s\n", + (int)i, procState[ProcessorState[i] & 0xF]); + } + } + } + } + +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: wait processors EXITED state:%s\n", + (int)self, procState[ProcessorState[self] & 0xF]); +#endif + + return (unsigned long) failed; +#else + return 0; +#endif +} + +unsigned long enter_debugger(unsigned long exception, StackFrame *stackFrame, + unsigned long processor) +{ + register unsigned long retCode; + + if (debug_lock(&debug_mutex, processor)) + { + /* if the processors were already held in the debugger due to a + * trace, ssb, or proceed session on a focus processor, do not + * nest an xcall NMI or signal (not if you can help it). */ + if (!atomic_read(&traceProcessors[processor])) + StopProcessorsExclSelf(processor); + + retCode = debugger_command_entry(processor, exception, stackFrame); + + /* do not release the processors for active trace, ssb, or proceed + * sessions on a focus processor. */ + if (!atomic_read(&traceProcessors[processor])) + { + FreeProcessorsExclSelf(processor); + WaitRestartExclSelf(processor); + } + debug_unlock(&debug_mutex, processor); + touch_softlockup_watchdog(); + clocksource_touch_watchdog(); + return retCode; + } + touch_softlockup_watchdog(); + clocksource_touch_watchdog(); + return 0; +} + + +unsigned long debugger_entry(unsigned long Exception, StackFrame *stackFrame, + unsigned long processor) +{ + register unsigned long retCode = 1; + unsigned char *cmd; + unsigned long valid; + + atomic_inc(&debuggerActive); + atomic_inc(&debuggerProcessors[processor]); + + ProcessorState[processor] = PROCESSOR_DEBUG; + CurrentFrame[processor] = stackFrame; + + WriteDR7(0); /* disable breakpoints while debugger is running */ + CurrentDR6[processor] = ReadDR6(); + + if (fpu_present()) + save_npx(&npx[processor]); + +MDBLoop:; + switch (Exception) + { + case 1:/* int 1 debug exception */ + if (BreakMask[processor]) + { + stackFrame->tSystemFlags &= ~SINGLE_STEP; + stackFrame->tSystemFlags |= RESUME; + break; + } + else + if ((CurrentDR6[processor] & B0_BIT) && + (CurrentDR7 & G0_BIT) && + (ConditionalBreakpoint[0])) + { + cmd = (unsigned char *)&BreakCondition[0][0]; + if (!EvaluateExpression(stackFrame, &cmd, &valid)) + { + stackFrame->tSystemFlags &= ~SINGLE_STEP; + stackFrame->tSystemFlags |= RESUME; + break; + } + } + else + if ((CurrentDR6[processor] & B1_BIT) && + (CurrentDR7 & G1_BIT) && + (ConditionalBreakpoint[1])) + { + cmd = (unsigned char *)&BreakCondition[1][0]; + if (!EvaluateExpression(stackFrame, &cmd, &valid)) + { + stackFrame->tSystemFlags &= ~SINGLE_STEP; + stackFrame->tSystemFlags |= RESUME; + break; + } + } + else + if ((CurrentDR6[processor] & B2_BIT) && + (CurrentDR7 & G2_BIT) && + (ConditionalBreakpoint[2])) + { + cmd = (unsigned char *)&BreakCondition[2][0]; + if (!EvaluateExpression(stackFrame, &cmd, &valid)) + { + stackFrame->tSystemFlags &= ~SINGLE_STEP; + stackFrame->tSystemFlags |= RESUME; + break; + } + } + else + if ((CurrentDR6[processor] & B3_BIT) && + (CurrentDR7 & G3_BIT) && + (ConditionalBreakpoint[3])) + { + cmd = (unsigned char *)&BreakCondition[3][0]; + if (!EvaluateExpression(stackFrame, &cmd, &valid)) + { + stackFrame->tSystemFlags &= ~SINGLE_STEP; + stackFrame->tSystemFlags |= RESUME; + break; + } + } + enter_debugger(Exception, stackFrame, processor); + break; + + + case 3:/* int 3 breakpoint */ + if (BreakMask[processor]) + { + stackFrame->tSystemFlags &= ~SINGLE_STEP; + stackFrame->tSystemFlags |= RESUME; + break; + } + enter_debugger(Exception, stackFrame, processor); + break; + + case 2: /* nmi */ + barrier(); + if (ProcessorHold[processor]) /* hold processor */ + { + ProcessorHold[processor] = 0; + ProcessorState[processor] = PROCESSOR_SUSPEND; + + /* processor suspend loop */ + smp_wmb(); + atomic_inc(&nmiProcessors[processor]); + while ((ProcessorState[processor] != PROCESSOR_RESUME) && + (ProcessorState[processor] != PROCESSOR_SWITCH)) + { + barrier(); + if ((ProcessorState[processor] == PROCESSOR_RESUME) || + (ProcessorState[processor] == PROCESSOR_SWITCH)) + { + break; + } + cpu_relax(); + } + atomic_dec(&nmiProcessors[processor]); + touch_softlockup_watchdog(); + clocksource_touch_watchdog(); + + if (ProcessorState[processor] == PROCESSOR_SWITCH) + enter_debugger(21, stackFrame, processor); + break; + } + else /* all other nmi exceptions fall through to here */ + enter_debugger(Exception, stackFrame, processor); + break; + + default: + enter_debugger(Exception, stackFrame, processor); + break; + } + + if (ProcessorHold[processor]) + { + Exception = 2; + goto MDBLoop; + } + + LoadDebugRegisters(); + + if (fpu_present()) + load_npx(&npx[processor]); + + CurrentFrame[processor] = 0; + ProcessorState[processor] = PROCESSOR_ACTIVE; + + atomic_dec(&debuggerProcessors[processor]); + atomic_dec(&debuggerActive); + return retCode; + +} + +void InitializeDebuggerRegisters(void) +{ + CurrentDR7 = (DR7DEF | GEXACT | LEXACT); /* set mode to GLOBAL EXACT */ + WriteDR0(0); /* clear out DR0-DR6 */ + WriteDR1(0); + WriteDR2(0); + WriteDR3(0); + WriteDR6(0); + WriteDR7(CurrentDR7); /* set DR7 register */ +} + +void ClearDebuggerRegisters(void) +{ + WriteDR0(0); /* clear out all breakpoints and breakpoint */ + WriteDR1(0); /* registers DR0-DR7 */ + WriteDR2(0); + WriteDR3(0); + WriteDR6(0); + WriteDR7(0); +} + diff -Naur linux-2.6.35.4/kernel/debug/mdb/mdb-ia.h linux-2.6.35.4-cs/kernel/debug/mdb/mdb-ia.h --- linux-2.6.35.4/kernel/debug/mdb/mdb-ia.h 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/mdb-ia.h 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,216 @@ + +/*************************************************************************** +* +* Copyright (c) 2008 Jeff V. Merkey All Rights Reserved. +* jeffmerkey@gmail.com +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation, version 2. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You are free to modify and re-distribute this program in accordance +* with the terms specified in the GNU Public License. The copyright +* contained in this code is required to be present in any derivative +* works and you are required to provide the source code for this +* program as part of any commercial or non-commercial distribution. +* You are required to respect the rights of the Copyright holders +* named within this code. +* +* jeffmerkey@gmail.com is the official maintainer of +* this code. You are encouraged to report any bugs, problems, fixes, +* suggestions, and comments about this software. +* +* AUTHOR : Jeff V. Merkey +* DESCRIP : Merkey's Linux Debugger +* +***************************************************************************/ + +#ifndef _MDB_IA32_H +#define _MDB_IA32_H + +#define MAX_PROCESSORS NR_CPUS +#define SYMBOL_DEBUG 0 + +/* recursive spin lock used by the debugger to gate processors acquiring + * the debugger console. if the lock is already held on the current + * processor when called, increment a use counter. this allows us to + * handle nested exceptions on the same processor without deadlocking */ +typedef struct _RLOCK +{ +#if defined(CONFIG_SMP) + spinlock_t lock; +#endif + unsigned long processor; + unsigned long count; + unsigned long flags[MAX_PROCESSORS]; +} rlock_t; + +#ifdef CONFIG_X86_64 +typedef struct _StackFrame { + unsigned long tReserved[7]; + unsigned long tCR3; + unsigned long tIP; + unsigned long tSystemFlags; + unsigned long tAX; + unsigned long tCX; + unsigned long tDX; + unsigned long tBX; + unsigned long tSP; + unsigned long tBP; + unsigned long tSI; + unsigned long tDI; + unsigned long tES; + unsigned long tCS; + unsigned long tSS; + unsigned long tDS; + unsigned long tFS; + unsigned long tGS; + unsigned long tLDT; + unsigned long tIOMap; + unsigned long r8; + unsigned long r9; + unsigned long r10; + unsigned long r11; + unsigned long r12; + unsigned long r13; + unsigned long r14; + unsigned long r15; +} StackFrame; +#else +typedef struct _StackFrame { + unsigned long tReserved[7]; + unsigned long tCR3; + unsigned long tIP; + unsigned long tSystemFlags; + unsigned long tAX; + unsigned long tCX; + unsigned long tDX; + unsigned long tBX; + unsigned long tSP; + unsigned long tBP; + unsigned long tSI; + unsigned long tDI; + unsigned long tES; + unsigned long tCS; + unsigned long tSS; + unsigned long tDS; + unsigned long tFS; + unsigned long tGS; + unsigned long tLDT; + unsigned long tIOMap; +} StackFrame; +#endif + +/* 128 bytes total size numeric register context */ + +typedef struct _NPXREG { + uint16_t sig0; /* 10 bytes total size this structure */ + uint16_t sig1; + uint16_t sig2; + uint16_t sig3; + uint16_t exponent:15; + uint16_t sign:1; +} NUMERIC_REGISTER_CONTEXT; + +typedef struct _NPX { + uint32_t control; + uint32_t status; + uint32_t tag; + uint32_t eip; + uint32_t cs; + uint32_t dataptr; + uint32_t datasel; + NUMERIC_REGISTER_CONTEXT reg[8]; /* 80 bytes */ + uint32_t pad[5]; +} NUMERIC_FRAME; + +/* 128 bytes total size register context */ + +static inline void _cli(void) +{ + __asm__ __volatile__("cli" : : : "memory"); +} + +static inline void _sti(void) +{ + __asm__ __volatile__("sti" : : : "memory"); +} + + +#ifdef CONFIG_X86_64 +static inline unsigned long get_flags(void) +{ + unsigned long flags; + __asm__ __volatile__( + "pushfq ; popq %0" + : "=g" (flags) + : // no input + ); + return flags; +} + +static inline unsigned long save_flags(void) +{ + unsigned long flags; + + __asm__ __volatile__( + "pushfq ; popq %0" + : "=g" (flags) + : // no input + ); + __asm__ __volatile__("cli" : : : "memory"); + return flags; +} + +static inline void restore_flags(unsigned long flags) +{ + __asm__ __volatile__( + "pushq %0 ; popfq" + : + :"g" (flags) + :"memory", "cc" + ); +} +#else +static inline unsigned long get_flags(void) +{ + unsigned long flags; + __asm__ __volatile__( + "pushfl ; popl %0" + : "=g" (flags) + : // no input + ); + return flags; +} + +static inline unsigned long save_flags(void) +{ + unsigned long flags; + + __asm__ __volatile__( + "pushfl ; popl %0" + : "=g" (flags) + : // no input + ); + __asm__ __volatile__("cli" : : : "memory"); + return flags; +} + +static inline void restore_flags(unsigned long flags) +{ + __asm__ __volatile__( + "pushl %0 ; popfl" + : + :"g" (flags) + :"memory", "cc" + ); +} + +#endif + +#endif diff -Naur linux-2.6.35.4/kernel/debug/mdb/mdb-ia-proc.h linux-2.6.35.4-cs/kernel/debug/mdb/mdb-ia-proc.h --- linux-2.6.35.4/kernel/debug/mdb/mdb-ia-proc.h 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/mdb-ia-proc.h 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,660 @@ + +/*************************************************************************** +* +* Copyright (c) 2008 Jeff V. Merkey All Rights Reserved. +* jeffmerkey@gmail.com +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation, version 2. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You are free to modify and re-distribute this program in accordance +* with the terms specified in the GNU Public License. The copyright +* contained in this code is required to be present in any derivative +* works and you are required to provide the source code for this +* program as part of any commercial or non-commercial distribution. +* You are required to respect the rights of the Copyright holders +* named within this code. +* +* jeffmerkey@gmail.com is the official maintainer of +* this code. You are encouraged to report any bugs, problems, fixes, +* suggestions, and comments about this software. +* +* AUTHOR : Jeff V. Merkey +* DESCRIP : Merkey's Linux Debugger +* +***************************************************************************/ + +#ifndef _MDB_IA32_PROC_H +#define _MDB_IA32_PROC_H + +#define EXT_NMI_PORT 0x0461 +#define NMI_IO_PORT 0x0462 +#define NMI_CONTROL_PORT 0x0C6E +#define NMI_PORT 0x61 +#define PIC1_DEBUG_MASK 0xFC +#define PIC2_DEBUG_MASK 0xFF +#define EXCEPTION_ENTRIES 19 +#define RESUME 0x00010000 +#define NESTED_TASK 0x00004000 +#define SINGLE_STEP 0x00000100 +#define INVALID_EXPRESSION 0 +#define NUMERIC_EXPRESSION 1 +#define BOOLEAN_EXPRESSION 2 + +/* DR7 Breakpoint Type and Length Fields */ + +#define BREAK_EXECUTE 0 +#define BREAK_WRITE 1 +#define BREAK_IOPORT 2 +#define BREAK_READWRITE 3 +#define ONE_BYTE_FIELD 0 +#define TWO_BYTE_FIELD 1 +#define UNDEFINED_FIELD 2 +#define FOUR_BYTE_FIELD 3 + +/* DR7 Register */ + +#define L0_BIT 0x00000001 +#define G0_BIT 0x00000002 +#define L1_BIT 0x00000004 +#define G1_BIT 0x00000008 +#define L2_BIT 0x00000010 +#define G2_BIT 0x00000020 +#define L3_BIT 0x00000040 +#define G3_BIT 0x00000080 +#define LEXACT 0x00000100 +#define GEXACT 0x00000200 +#define GDETECT 0x00002000 +#define DR7DEF 0x00000400 + +/* DR6 Register */ + +#define B0_BIT 0x00000001 +#define B1_BIT 0x00000002 +#define B2_BIT 0x00000004 +#define B3_BIT 0x00000008 + +#define BD_BIT 0x00002000 +#define BS_BIT 0x00004000 +#define BT_BIT 0x00008000 + +/* Memory Type Range Registers (MTRR) */ + +#define MTRR_PHYS_BASE_0 0x200 +#define MTRR_PHYS_MASK_0 0x201 +#define MTRR_PHYS_BASE_1 0x202 +#define MTRR_PHYS_MASK_1 0x203 +#define MTRR_PHYS_BASE_2 0x204 +#define MTRR_PHYS_MASK_2 0x205 +#define MTRR_PHYS_BASE_3 0x206 +#define MTRR_PHYS_MASK_3 0x207 +#define MTRR_PHYS_BASE_4 0x208 +#define MTRR_PHYS_MASK_4 0x209 +#define MTRR_PHYS_BASE_5 0x20A +#define MTRR_PHYS_MASK_5 0x20B +#define MTRR_PHYS_BASE_6 0x20C +#define MTRR_PHYS_MASK_6 0x20D +#define MTRR_PHYS_BASE_7 0x20E +#define MTRR_PHYS_MASK_7 0x20F + +/* IA32 flags settings */ + +#define CF_FLAG 0x00000001 +#define PF_FLAG 0x00000004 +#define AF_FLAG 0x00000010 +#define ZF_FLAG 0x00000040 +#define SF_FLAG 0x00000080 +#define TF_FLAG 0x00000100 /* ss flag */ +#define IF_FLAG 0x00000200 +#define DF_FLAG 0x00000400 +#define OF_FLAG 0x00000800 +#define NT_FLAG 0x00004000 +#define RF_FLAG 0x00010000 /* resume flag */ +#define VM_FLAG 0x00020000 +#define AC_FLAG 0x00040000 +#define VIF_FLAG 0x00080000 +#define VIP_FLAG 0x00100000 +#define ID_FLAGS 0x00200000 + +#ifdef CONFIG_X86_64 + +typedef struct GATE64 { + u16 offset_low; + u16 segment; + unsigned ist : 3, zero0 : 5, type : 5, dpl : 2, p : 1; + u16 offset_middle; + u32 offset_high; + u32 zero1; +} __attribute__((packed)) GATE64; + +typedef struct LDTTSS64 { + u16 limit0; + u16 base0; + unsigned base1 : 8, type : 5, dpl : 2, p : 1; + unsigned limit1 : 4, zero0 : 3, g : 1, base2 : 8; + u32 base3; + u32 zero1; +} __attribute__((packed)) LDTTSS64; + +typedef GATE64 GDT; +typedef GATE64 IDT; +typedef LDTTSS64 LDT; +typedef LDTTSS64 TSS; +typedef LDTTSS64 TSS_GATE; + +#else + +typedef struct DESC + { + union + { + struct + { + unsigned int a; + unsigned int b; + }; + struct + { + u16 limit0; + u16 base0; + unsigned base1: 8, type: 4, s: 1, dpl: 2, p: 1; + unsigned limit: 4, avl: 1, l: 1, d: 1, g: 1, base2: 8; + }; + }; +} __attribute__((packed)) DESC; + +typedef struct _GDT32 { + u16 Limit; /* 0xFFFF */ + u16 Base1; /* 0 */ + u8 Base2; /* 0 */ + u8 GDTType; /* 10010010b */ + u8 OtherType; /* 11001111b */ + u8 Base3; /* 0 */ +} __attribute__((packed)) GDT32; + +typedef struct _IDT32 { + u16 IDTLow; /* 0 */ + u16 IDTSegment; /* 0x08 */ + u8 IDTSkip; /* 0 */ + u8 IDTFlags; /* 10001110b */ + u16 IDTHigh; /* 0 */ +} __attribute__((packed)) IDT32; + +typedef struct _TSS32 { + u16 TSSLimit; /* 0x0080 */ + u16 TSSBase1; /* 0 */ + u8 TSSBase2; /* 0 */ + u8 TSSType; /* 10001001b */ + u8 TSSOtherType; /* 00000000b */ + u8 TSSBase3; /* 0 */ +} __attribute__((packed)) TSS32; + +typedef struct _TSS_GATE32 { + u16 TSSRes1; /* 0 */ + u16 TSSSelector; /* 0 */ + u8 TSSRes2; /* 0 */ + u8 TSSFlags; /* 10000101b */ + u16 TSSRes3; /* 0 */ +} __attribute__((packed)) TSS_GATE32; + +typedef struct _LDT32 { + u16 LDTLimit; /* 0xFFFF */ + u16 LDTBase1; /* 0 */ + u8 LDTBase2; /* 0 */ + u8 LDTGDTType; /* 10000010b */ + u8 LDTOtherType; /* 10001111b */ + u8 LDTBase3; /* 0 */ +} __attribute__((packed)) LDT32; + +typedef GDT32 GDT; +typedef LDT32 LDT; +typedef IDT32 IDT; +typedef TSS32 TSS; +typedef TSS_GATE32 TSS_GATE; + +#endif + +extern unsigned long ReadDR0(void); +extern unsigned long ReadDR1(void); +extern unsigned long ReadDR2(void); +extern unsigned long ReadDR3(void); +extern unsigned long ReadDR6(void); +extern unsigned long ReadDR7(void); +extern void WriteDR0(unsigned long); +extern void WriteDR1(unsigned long); +extern void WriteDR2(unsigned long); +extern void WriteDR3(unsigned long); +extern void WriteDR6(unsigned long); +extern void WriteDR7(unsigned long); +extern unsigned long ReadCR0(void); +extern unsigned long ReadCR2(void); +extern unsigned long ReadCR3(void); +extern unsigned long ReadCR4(void); +extern void ReadGDTR(unsigned long *); +extern void ReadIDTR(unsigned long *); +extern unsigned long ReadLDTR(void); +extern unsigned long ReadTR(void); + +extern void ReadMSR(unsigned long msr, unsigned long *val1, unsigned long *val2); +extern void WriteMSR(unsigned long msr, unsigned long *val1, unsigned long *val2); +extern void MTRROpen(void); +extern void MTRRClose(void); +extern void save_npx(NUMERIC_FRAME *npx); +extern void load_npx(NUMERIC_FRAME *npx); + +extern unsigned long get_processor_id(void); +extern unsigned long get_physical_processor(void); +extern unsigned long fpu_present(void); + +extern void ReadTaskFrame(StackFrame *sf, struct task_struct *p); +extern void DisplayTSS(StackFrame *stackFrame); +extern void DisplayGeneralRegisters(StackFrame *stackFrame); +extern void DisplaySegmentRegisters(StackFrame *stackFrame); +extern void DisplayControlRegisters(unsigned long processor, StackFrame *stackFrame); +extern double ldexp(double v, int e); +extern void DisplayNPXRegisters(unsigned long processor); + +extern unsigned long processProceedACC(unsigned long key, void *stackFrame, + ACCELERATOR *accel); +extern unsigned long processTraceACC(unsigned long key, void *stackFrame, + ACCELERATOR *accel); +extern unsigned long processTraceSSBACC(unsigned long key, void *stackFrame, + ACCELERATOR *accel); +extern unsigned long processGoACC(unsigned long key, void *stackFrame, + ACCELERATOR *accel); + +extern unsigned long executeCommandHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long processProceed(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long processTrace(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long processTraceSSB(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long processGo(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + + +extern unsigned long processorCommandHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long breakProcessor(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long TSSDisplayHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long TSSDisplay(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayEAXHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeEAXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long ChangeORIGEAXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayEBXHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeEBXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayECXHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeECXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayEDXHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeEDXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayESIHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeESIRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayEDIHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeEDIRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayEBPHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeEBPRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayESPHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeESPRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayEIPHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeEIPRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayCSHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeCSRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayDSHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeDSRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayESHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeESRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayFSHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeFSRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayGSHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeGSRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displaySSHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeSSRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayRFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeRFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayTFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeTFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayZFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeZFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displaySFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeSFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayPFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangePFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayCFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeCFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayOFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeOFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayIFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeIFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayIDHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeIDFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayDFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeDFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayNTHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeNTFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayVMHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeVMFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayVIFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeVIFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayVIPHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeVIPFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayAFHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeAFFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayACHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeACFlag(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayMTRRHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long DisplayMTRRRegisters(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayGDTHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayGDT(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayIDTHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayIDT(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long evaluateExpressionHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long evaluateExpression(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayDOSTableHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long displayDOSTable(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long portCommandHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long inputWordPort(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long inputDoublePort(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long inputBytePort(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long inputPort(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long outputWordPort(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long outputDoublePort(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long outputBytePort(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long outputPort(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + + +extern unsigned long breakpointCommandHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long breakpointClearAll(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long breakpointClear(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long breakpointMask(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long breakpointWord1(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long breakpointWord2(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long breakpointWord4(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long breakpointWord(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long breakpointRead1(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long breakpointRead2(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long breakpointRead4(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long breakpointRead(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long breakpointIO1(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long breakpointIO2(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long breakpointIO4(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long breakpointIO(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long breakpointExecute(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long breakpointShowTemp(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern void mdb_breakpoint(void); + +#if defined(CONFIG_SMP) +extern unsigned long displayAPICHelp(unsigned char *commandLine, + DEBUGGER_PARSER *parser); +extern unsigned long displayAPICInfo(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long displayIOAPICInfo(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long nmiProcessor(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long apic_directed_nmi(unsigned long cpu); +extern unsigned long apic_xcall(unsigned long cpu, unsigned long command, + unsigned long type); +#endif + +#ifdef CONFIG_X86_64 +extern unsigned long displayRAXHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeRAXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long ChangeORIGRAXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayRBXHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeRBXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayRCXHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeRCXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayRDXHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeRDXRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayRSIHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeRSIRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayRDIHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeRDIRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayRBPHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeRBPRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayRSPHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeRSPRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayRIPHelp(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeRIPRegister(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); + +extern unsigned long displayR8Help(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeR8Register(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long displayR9Help(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeR9Register(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long displayR10Help(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeR10Register(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long displayR11Help(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeR11Register(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long displayR12Help(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeR12Register(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long displayR13Help(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeR13Register(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long displayR14Help(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeR14Register(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +extern unsigned long displayR15Help(unsigned char *commandLine, DEBUGGER_PARSER *parser); +extern unsigned long ChangeR15Register(unsigned char *cmd, + StackFrame *stackFrame, unsigned long Exception, + DEBUGGER_PARSER *parser); +#endif + +#endif diff -Naur linux-2.6.35.4/kernel/debug/mdb/mdb-ia-support.c linux-2.6.35.4-cs/kernel/debug/mdb/mdb-ia-support.c --- linux-2.6.35.4/kernel/debug/mdb/mdb-ia-support.c 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/mdb-ia-support.c 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,5824 @@ + +/*************************************************************************** +* +* Copyright (c) 2008 Jeff V. Merkey All Rights Reserved. +* jeffmerkey@gmail.com +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation, version 2. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You are free to modify and re-distribute this program in accordance +* with the terms specified in the GNU Public License. The copyright +* contained in this code is required to be present in any derivative +* works and you are required to provide the source code for this +* program as part of any commercial or non-commercial distribution. +* You are required to respect the rights of the Copyright holders +* named within this code. +* +* jeffmerkey@gmail.com is the official maintainer of +* this code. You are encouraged to report any bugs, problems, fixes, +* suggestions, and comments about this software. +* +* AUTHOR : Jeff V. Merkey +* DESCRIP : Merkey's Linux Debugger +* +***************************************************************************/ + +/* Print i386 instructions for GDB, the GNU debugger. + Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, + 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ + +/* Extracted from binutils 2.16.91.0.2 (OpenSUSE 10.0) and modified for kdb use. + * Run through col -b to remove trailing whitespace and various #ifdef/ifndef + * __KERNEL__ added. + * Keith Owens 15 May 2006 + */ + +/* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu) + July 1988 + modified by John Hassey (hassey@dg-rtp.dg.com) + x86-64 support added by Jan Hubicka (jh@suse.cz) + VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */ + +/* The main tables describing the instructions is essentially a copy + of the "Opcode Map" chapter (Appendix A) of the Intel 80386 + Programmers Manual. Usually, there is a capital letter, followed + by a small letter. The capital letter tell the addressing mode, + and the small letter tells about the operand size. Refer to + the Intel manual for details. */ + +/* 06-26-2010 Jeff V. Merkey - port GDB debugger to MDB and add memory + dereferencing, jump labeling, and opcode output. Convert MDB to + conform to Linux hex and decimal notation and display. */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(CONFIG_SMP) +#include +#include +#include +#endif + +#define __KERNEL_SYSCALLS__ +#include +#include + +#include "mdb.h" +#include "mdb-ia.h" +#include "mdb-list.h" +#include "mdb-ia-proc.h" +#include "mdb-base.h" +#include "mdb-proc.h" +#include "mdb-os.h" +#include "mdb-keyboard.h" +#include "mdb-ia-support.h" + +#define MAXLEN 20 +#define abort() BUG() +#ifndef UNIXWARE_COMPAT +#define UNIXWARE_COMPAT 1 +#endif + +// enable MDB enhancements to the GDB base disassembler +#define MDB_ENHANCEMENTS + +extern int print_insn_i386(bfd_vma, disassemble_info *, StackFrame *); +extern int print_insn_i386_att(bfd_vma, disassemble_info *, StackFrame *); +extern int print_insn_i386_intel(bfd_vma, disassemble_info *, StackFrame *); + +static int fetch_data (struct disassemble_info *, bfd_byte *); +static void ckprefix (void); +static const char *prefix_name (int, int); +static int print_insn (bfd_vma, disassemble_info *, StackFrame *); +static void dofloat (int, StackFrame *); +static void OP_ST (int, int, StackFrame *); +static void OP_STi (int, int, StackFrame *); +static int putop (const char *, int); +static void oappend (const char *); +static void append_seg (void); +static void OP_indirE (int, int, StackFrame *); +static void print_operand_value (char *, int, bfd_vma); +static void OP_E (int, int, StackFrame *); +static void OP_G (int, int, StackFrame *); +static bfd_vma get64 (void); +static bfd_signed_vma get32 (void); +static bfd_signed_vma get32s (void); +static int get16 (void); +static void set_op (bfd_vma, int); +static void OP_REG (int, int, StackFrame *); +static void OP_IMREG (int, int, StackFrame *); +static void OP_I (int, int, StackFrame *); +static void OP_I64 (int, int, StackFrame *); +static void OP_sI (int, int, StackFrame *); +static void OP_J (int, int, StackFrame *); +static void OP_SEG (int, int, StackFrame *); +static void OP_DIR (int, int, StackFrame *); +static void OP_OFF (int, int, StackFrame *); +static void OP_OFF64 (int, int, StackFrame *); +static void ptr_reg (int, int, StackFrame *); +static void OP_ESreg (int, int, StackFrame *); +static void OP_DSreg (int, int, StackFrame *); +static void OP_C (int, int, StackFrame *); +static void OP_D (int, int, StackFrame *); +static void OP_T (int, int, StackFrame *); +static void OP_Rd (int, int, StackFrame *); +static void OP_MMX (int, int, StackFrame *); +static void OP_XMM (int, int, StackFrame *); +static void OP_EM (int, int, StackFrame *); +static void OP_EX (int, int, StackFrame *); +static void OP_MS (int, int, StackFrame *); +static void OP_XS (int, int, StackFrame *); +static void OP_M (int, int, StackFrame *); +static void OP_VMX (int, int, StackFrame *); +static void OP_0fae (int, int, StackFrame *); +static void OP_0f07 (int, int, StackFrame *); +static void NOP_Fixup (int, int, StackFrame *); +static void OP_3DNowSuffix (int, int, StackFrame *); +static void OP_SIMD_Suffix (int, int, StackFrame *); +static void SIMD_Fixup (int, int, StackFrame *); +static void PNI_Fixup (int, int, StackFrame *); +static void SVME_Fixup (int, int, StackFrame *); +static void INVLPG_Fixup (int, int, StackFrame *); +static void BadOp (void); +static void SEG_Fixup (int, int, StackFrame *); +static void VMX_Fixup (int, int, StackFrame *); + +struct dis_private { + /* Points to first byte not fetched. */ + bfd_byte *max_fetched; + bfd_byte the_buffer[MAXLEN]; + bfd_vma insn_start; + int orig_sizeflag; +#ifndef __KERNEL__ + jmp_buf bailout; +#endif /* __KERNEL__ */ +}; + +/* The opcode for the fwait instruction, which we treat as a prefix + when we can. */ +#define FWAIT_OPCODE (0x9b) + +/* Set to 1 for 64bit mode disassembly. */ +static int mode_64bit; + +/* Flags for the prefixes for the current instruction. See below. */ +static int prefixes; + +/* REX prefix the current instruction. See below. */ +static int rex; +/* Bits of REX we've already used. */ +static int rex_used; +#define REX_MODE64 8 +#define REX_EXTX 4 +#define REX_EXTY 2 +#define REX_EXTZ 1 +/* Mark parts used in the REX prefix. When we are testing for + empty prefix (for 8bit register REX extension), just mask it + out. Otherwise test for REX bit is excuse for existence of REX + only in case value is nonzero. */ +#define USED_REX(value) \ + { \ + if (value) \ + rex_used |= (rex & value) ? (value) | 0x40 : 0; \ + else \ + rex_used |= 0x40; \ + } + +/* Flags for prefixes which we somehow handled when printing the + current instruction. */ +static int used_prefixes; + +/* Flags stored in PREFIXES. */ +#define PREFIX_REPZ 1 +#define PREFIX_REPNZ 2 +#define PREFIX_LOCK 4 +#define PREFIX_CS 8 +#define PREFIX_SS 0x10 +#define PREFIX_DS 0x20 +#define PREFIX_ES 0x40 +#define PREFIX_FS 0x80 +#define PREFIX_GS 0x100 +#define PREFIX_DATA 0x200 +#define PREFIX_ADDR 0x400 +#define PREFIX_FWAIT 0x800 + +/* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive) + to ADDR (exclusive) are valid. Returns 1 for success, longjmps + on error. */ +#define FETCH_DATA(info, addr) \ + ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \ + ? 1 : fetch_data ((info), (addr))) + +disassemble_info mdb_di; +char disbuf[MAX_PROCESSORS][512]; +char fworkbuf[MAX_PROCESSORS][512]; +char fbytebuf[MAX_PROCESSORS][512]; +char finalbuf[MAX_PROCESSORS][512]; +unsigned long needs_proceed = 0; +unsigned long jmp_active = 0; +unsigned long columns = 0; +void *vaddr = NULL; +extern unsigned long full_deref_toggle; + +static int +fetch_data (struct disassemble_info *info, bfd_byte *addr) +{ + int status; + struct dis_private *priv = (struct dis_private *) info->private_data; + bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer); + + status = (*info->read_memory_func) (start, + priv->max_fetched, + addr - priv->max_fetched, + info); + if (status != 0) + { + /* If we did manage to read at least one byte, then + print_insn_i386 will do something sensible. Otherwise, print + an error. We do that here because this is where we know + STATUS. */ + if (priv->max_fetched == priv->the_buffer) + (*info->memory_error_func) (status, start, info); +#ifndef __KERNEL__ + longjmp (priv->bailout, 1); +#else /* __KERNEL__ */ + /* XXX - what to do? */ + mdb_printf("Hmm. longjmp.\n"); +#endif /* __KERNEL__ */ + } + else + priv->max_fetched = addr; + return 1; +} + +#define XX NULL, 0 + +#define Eb OP_E, b_mode +#define Ev OP_E, v_mode +#define Ed OP_E, d_mode +#define Eq OP_E, q_mode +#define Edq OP_E, dq_mode +#define Edqw OP_E, dqw_mode +#define indirEv OP_indirE, branch_v_mode +#define indirEp OP_indirE, f_mode +#define Em OP_E, m_mode +#define Ew OP_E, w_mode +#define Ma OP_E, v_mode +#define M OP_M, 0 /* lea, lgdt, etc. */ +#define Mp OP_M, f_mode /* 32 or 48 bit memory operand for LDS, LES etc */ +#define Gb OP_G, b_mode +#define Gv OP_G, v_mode +#define Gd OP_G, d_mode +#define Gdq OP_G, dq_mode +#define Gm OP_G, m_mode +#define Gw OP_G, w_mode +#define Rd OP_Rd, d_mode +#define Rm OP_Rd, m_mode +#define Ib OP_I, b_mode +#define sIb OP_sI, b_mode /* sign extened byte */ +#define Iv OP_I, v_mode +#define Iq OP_I, q_mode +#define Iv64 OP_I64, v_mode +#define Iw OP_I, w_mode +#define I1 OP_I, const_1_mode +#define Jb OP_J, b_mode +#define Jv OP_J, v_mode +#define Cm OP_C, m_mode +#define Dm OP_D, m_mode +#define Td OP_T, d_mode +#define Sv SEG_Fixup, v_mode + +#define RMeAX OP_REG, eAX_reg +#define RMeBX OP_REG, eBX_reg +#define RMeCX OP_REG, eCX_reg +#define RMeDX OP_REG, eDX_reg +#define RMeSP OP_REG, eSP_reg +#define RMeBP OP_REG, eBP_reg +#define RMeSI OP_REG, eSI_reg +#define RMeDI OP_REG, eDI_reg +#define RMrAX OP_REG, rAX_reg +#define RMrBX OP_REG, rBX_reg +#define RMrCX OP_REG, rCX_reg +#define RMrDX OP_REG, rDX_reg +#define RMrSP OP_REG, rSP_reg +#define RMrBP OP_REG, rBP_reg +#define RMrSI OP_REG, rSI_reg +#define RMrDI OP_REG, rDI_reg +#define RMAL OP_REG, al_reg +#define RMAL OP_REG, al_reg +#define RMCL OP_REG, cl_reg +#define RMDL OP_REG, dl_reg +#define RMBL OP_REG, bl_reg +#define RMAH OP_REG, ah_reg +#define RMCH OP_REG, ch_reg +#define RMDH OP_REG, dh_reg +#define RMBH OP_REG, bh_reg +#define RMAX OP_REG, ax_reg +#define RMDX OP_REG, dx_reg + +#define eAX OP_IMREG, eAX_reg +#define eBX OP_IMREG, eBX_reg +#define eCX OP_IMREG, eCX_reg +#define eDX OP_IMREG, eDX_reg +#define eSP OP_IMREG, eSP_reg +#define eBP OP_IMREG, eBP_reg +#define eSI OP_IMREG, eSI_reg +#define eDI OP_IMREG, eDI_reg +#define AL OP_IMREG, al_reg +#define AL OP_IMREG, al_reg +#define CL OP_IMREG, cl_reg +#define DL OP_IMREG, dl_reg +#define BL OP_IMREG, bl_reg +#define AH OP_IMREG, ah_reg +#define CH OP_IMREG, ch_reg +#define DH OP_IMREG, dh_reg +#define BH OP_IMREG, bh_reg +#define AX OP_IMREG, ax_reg +#define DX OP_IMREG, dx_reg +#define indirDX OP_IMREG, indir_dx_reg + +#define Sw OP_SEG, w_mode +#define Ap OP_DIR, 0 +#define Ob OP_OFF, b_mode +#define Ob64 OP_OFF64, b_mode +#define Ov OP_OFF, v_mode +#define Ov64 OP_OFF64, v_mode +#define Xb OP_DSreg, eSI_reg +#define Xv OP_DSreg, eSI_reg +#define Yb OP_ESreg, eDI_reg +#define Yv OP_ESreg, eDI_reg +#define DSBX OP_DSreg, eBX_reg + +#define es OP_REG, es_reg +#define ss OP_REG, ss_reg +#define cs OP_REG, cs_reg +#define ds OP_REG, ds_reg +#define fs OP_REG, fs_reg +#define gs OP_REG, gs_reg + +#define MX OP_MMX, 0 +#define XM OP_XMM, 0 +#define EM OP_EM, v_mode +#define EX OP_EX, v_mode +#define MS OP_MS, v_mode +#define XS OP_XS, v_mode +#define VM OP_VMX, q_mode +#define OPSUF OP_3DNowSuffix, 0 +#define OPSIMD OP_SIMD_Suffix, 0 + +#define cond_jump_flag NULL, cond_jump_mode +#define loop_jcxz_flag NULL, loop_jcxz_mode + +/* bits in sizeflag */ +#define SUFFIX_ALWAYS 4 +#define AFLAG 2 +#define DFLAG 1 + +#define b_mode 1 /* byte operand */ +#define v_mode 2 /* operand size depends on prefixes */ +#define w_mode 3 /* word operand */ +#define d_mode 4 /* double word operand */ +#define q_mode 5 /* quad word operand */ +#define t_mode 6 /* ten-byte operand */ +#define x_mode 7 /* 16-byte XMM operand */ +#define m_mode 8 /* d_mode in 32bit, q_mode in 64bit mode. */ +#define cond_jump_mode 9 +#define loop_jcxz_mode 10 +#define dq_mode 11 /* operand size depends on REX prefixes. */ +#define dqw_mode 12 /* registers like dq_mode, memory like w_mode. */ +#define f_mode 13 /* 4- or 6-byte pointer operand */ +#define const_1_mode 14 +#define branch_v_mode 15 /* v_mode for branch. */ + +#define es_reg 100 +#define cs_reg 101 +#define ss_reg 102 +#define ds_reg 103 +#define fs_reg 104 +#define gs_reg 105 + +#define eAX_reg 108 +#define eCX_reg 109 +#define eDX_reg 110 +#define eBX_reg 111 +#define eSP_reg 112 +#define eBP_reg 113 +#define eSI_reg 114 +#define eDI_reg 115 + +#define al_reg 116 +#define cl_reg 117 +#define dl_reg 118 +#define bl_reg 119 +#define ah_reg 120 +#define ch_reg 121 +#define dh_reg 122 +#define bh_reg 123 + +#define ax_reg 124 +#define cx_reg 125 +#define dx_reg 126 +#define bx_reg 127 +#define sp_reg 128 +#define bp_reg 129 +#define si_reg 130 +#define di_reg 131 + +#define rAX_reg 132 +#define rCX_reg 133 +#define rDX_reg 134 +#define rBX_reg 135 +#define rSP_reg 136 +#define rBP_reg 137 +#define rSI_reg 138 +#define rDI_reg 139 + +#define indir_dx_reg 150 + +#define FLOATCODE 1 +#define USE_GROUPS 2 +#define USE_PREFIX_USER_TABLE 3 +#define X86_64_SPECIAL 4 + +#define FLOAT NULL, NULL, FLOATCODE, NULL, 0, NULL, 0 + +#define GRP1b NULL, NULL, USE_GROUPS, NULL, 0, NULL, 0 +#define GRP1S NULL, NULL, USE_GROUPS, NULL, 1, NULL, 0 +#define GRP1Ss NULL, NULL, USE_GROUPS, NULL, 2, NULL, 0 +#define GRP2b NULL, NULL, USE_GROUPS, NULL, 3, NULL, 0 +#define GRP2S NULL, NULL, USE_GROUPS, NULL, 4, NULL, 0 +#define GRP2b_one NULL, NULL, USE_GROUPS, NULL, 5, NULL, 0 +#define GRP2S_one NULL, NULL, USE_GROUPS, NULL, 6, NULL, 0 +#define GRP2b_cl NULL, NULL, USE_GROUPS, NULL, 7, NULL, 0 +#define GRP2S_cl NULL, NULL, USE_GROUPS, NULL, 8, NULL, 0 +#define GRP3b NULL, NULL, USE_GROUPS, NULL, 9, NULL, 0 +#define GRP3S NULL, NULL, USE_GROUPS, NULL, 10, NULL, 0 +#define GRP4 NULL, NULL, USE_GROUPS, NULL, 11, NULL, 0 +#define GRP5 NULL, NULL, USE_GROUPS, NULL, 12, NULL, 0 +#define GRP6 NULL, NULL, USE_GROUPS, NULL, 13, NULL, 0 +#define GRP7 NULL, NULL, USE_GROUPS, NULL, 14, NULL, 0 +#define GRP8 NULL, NULL, USE_GROUPS, NULL, 15, NULL, 0 +#define GRP9 NULL, NULL, USE_GROUPS, NULL, 16, NULL, 0 +#define GRP10 NULL, NULL, USE_GROUPS, NULL, 17, NULL, 0 +#define GRP11 NULL, NULL, USE_GROUPS, NULL, 18, NULL, 0 +#define GRP12 NULL, NULL, USE_GROUPS, NULL, 19, NULL, 0 +#define GRP13 NULL, NULL, USE_GROUPS, NULL, 20, NULL, 0 +#define GRP14 NULL, NULL, USE_GROUPS, NULL, 21, NULL, 0 +#define GRPAMD NULL, NULL, USE_GROUPS, NULL, 22, NULL, 0 +#define GRPPADLCK1 NULL, NULL, USE_GROUPS, NULL, 23, NULL, 0 +#define GRPPADLCK2 NULL, NULL, USE_GROUPS, NULL, 24, NULL, 0 + +#define PREGRP0 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 0, NULL, 0 +#define PREGRP1 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 1, NULL, 0 +#define PREGRP2 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 2, NULL, 0 +#define PREGRP3 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 3, NULL, 0 +#define PREGRP4 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 4, NULL, 0 +#define PREGRP5 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 5, NULL, 0 +#define PREGRP6 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 6, NULL, 0 +#define PREGRP7 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 7, NULL, 0 +#define PREGRP8 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 8, NULL, 0 +#define PREGRP9 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 9, NULL, 0 +#define PREGRP10 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 10, NULL, 0 +#define PREGRP11 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 11, NULL, 0 +#define PREGRP12 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 12, NULL, 0 +#define PREGRP13 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 13, NULL, 0 +#define PREGRP14 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 14, NULL, 0 +#define PREGRP15 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 15, NULL, 0 +#define PREGRP16 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 16, NULL, 0 +#define PREGRP17 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 17, NULL, 0 +#define PREGRP18 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 18, NULL, 0 +#define PREGRP19 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 19, NULL, 0 +#define PREGRP20 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 20, NULL, 0 +#define PREGRP21 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 21, NULL, 0 +#define PREGRP22 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 22, NULL, 0 +#define PREGRP23 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 23, NULL, 0 +#define PREGRP24 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 24, NULL, 0 +#define PREGRP25 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 25, NULL, 0 +#define PREGRP26 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 26, NULL, 0 +#define PREGRP27 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 27, NULL, 0 +#define PREGRP28 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 28, NULL, 0 +#define PREGRP29 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 29, NULL, 0 +#define PREGRP30 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 30, NULL, 0 +#define PREGRP31 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 31, NULL, 0 +#define PREGRP32 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 32, NULL, 0 + +#define X86_64_0 NULL, NULL, X86_64_SPECIAL, NULL, 0, NULL, 0 + +typedef void (*op_rtn) (int bytemode, int sizeflag, StackFrame *); + +struct dis386 { + const char *name; + op_rtn op1; + int bytemode1; + op_rtn op2; + int bytemode2; + op_rtn op3; + int bytemode3; +}; + +/* Upper case letters in the instruction names here are macros. + 'A' => print 'b' if no register operands or suffix_always is true + 'B' => print 'b' if suffix_always is true + 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand + . size prefix + 'E' => print 'e' if 32-bit form of jcxz + 'F' => print 'w' or 'l' depending on address size prefix (loop insns) + 'H' => print ",pt" or ",pn" branch hint + 'I' => honor following macro letter even in Intel mode (implemented only + . for some of the macro letters) + 'J' => print 'l' + 'L' => print 'l' if suffix_always is true + 'N' => print 'n' if instruction has no wait "prefix" + 'O' => print 'd', or 'o' + 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix, + . or suffix_always is true. print 'q' if rex prefix is present. + 'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always + . is true + 'R' => print 'w', 'l' or 'q' ("wd" or "dq" in intel mode) + 'S' => print 'w', 'l' or 'q' if suffix_always is true + 'T' => print 'q' in 64bit mode and behave as 'P' otherwise + 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise + 'W' => print 'b' or 'w' ("w" or "de" in intel mode) + 'X' => print 's', 'd' depending on data16 prefix (for XMM) + 'Y' => 'q' if instruction has an REX 64bit overwrite prefix + + Many of the above letters print nothing in Intel mode. See "putop" + for the details. + + Braces '{' and '}', and vertical bars '|', indicate alternative + mnemonic strings for AT&T, Intel, X86_64 AT&T, and X86_64 Intel + modes. In cases where there are only two alternatives, the X86_64 + instruction is reserved, and "(bad)" is printed. +*/ + +static const struct dis386 dis386[] = { + /* 00 */ + { "addB", Eb, Gb, XX }, + { "addS", Ev, Gv, XX }, + { "addB", Gb, Eb, XX }, + { "addS", Gv, Ev, XX }, + { "addB", AL, Ib, XX }, + { "addS", eAX, Iv, XX }, + { "push{T|}", es, XX, XX }, + { "pop{T|}", es, XX, XX }, + /* 08 */ + { "orB", Eb, Gb, XX }, + { "orS", Ev, Gv, XX }, + { "orB", Gb, Eb, XX }, + { "orS", Gv, Ev, XX }, + { "orB", AL, Ib, XX }, + { "orS", eAX, Iv, XX }, + { "push{T|}", cs, XX, XX }, + { "(bad)", XX, XX, XX }, /* 0x0f extended opcode escape */ + /* 10 */ + { "adcB", Eb, Gb, XX }, + { "adcS", Ev, Gv, XX }, + { "adcB", Gb, Eb, XX }, + { "adcS", Gv, Ev, XX }, + { "adcB", AL, Ib, XX }, + { "adcS", eAX, Iv, XX }, + { "push{T|}", ss, XX, XX }, + { "popT|}", ss, XX, XX }, + /* 18 */ + { "sbbB", Eb, Gb, XX }, + { "sbbS", Ev, Gv, XX }, + { "sbbB", Gb, Eb, XX }, + { "sbbS", Gv, Ev, XX }, + { "sbbB", AL, Ib, XX }, + { "sbbS", eAX, Iv, XX }, + { "push{T|}", ds, XX, XX }, + { "pop{T|}", ds, XX, XX }, + /* 20 */ + { "andB", Eb, Gb, XX }, + { "andS", Ev, Gv, XX }, + { "andB", Gb, Eb, XX }, + { "andS", Gv, Ev, XX }, + { "andB", AL, Ib, XX }, + { "andS", eAX, Iv, XX }, + { "(bad)", XX, XX, XX }, /* SEG ES prefix */ + { "daa{|}", XX, XX, XX }, + /* 28 */ + { "subB", Eb, Gb, XX }, + { "subS", Ev, Gv, XX }, + { "subB", Gb, Eb, XX }, + { "subS", Gv, Ev, XX }, + { "subB", AL, Ib, XX }, + { "subS", eAX, Iv, XX }, + { "(bad)", XX, XX, XX }, /* SEG CS prefix */ + { "das{|}", XX, XX, XX }, + /* 30 */ + { "xorB", Eb, Gb, XX }, + { "xorS", Ev, Gv, XX }, + { "xorB", Gb, Eb, XX }, + { "xorS", Gv, Ev, XX }, + { "xorB", AL, Ib, XX }, + { "xorS", eAX, Iv, XX }, + { "(bad)", XX, XX, XX }, /* SEG SS prefix */ + { "aaa{|}", XX, XX, XX }, + /* 38 */ + { "cmpB", Eb, Gb, XX }, + { "cmpS", Ev, Gv, XX }, + { "cmpB", Gb, Eb, XX }, + { "cmpS", Gv, Ev, XX }, + { "cmpB", AL, Ib, XX }, + { "cmpS", eAX, Iv, XX }, + { "(bad)", XX, XX, XX }, /* SEG DS prefix */ + { "aas{|}", XX, XX, XX }, + /* 40 */ + { "inc{S|}", RMeAX, XX, XX }, + { "inc{S|}", RMeCX, XX, XX }, + { "inc{S|}", RMeDX, XX, XX }, + { "inc{S|}", RMeBX, XX, XX }, + { "inc{S|}", RMeSP, XX, XX }, + { "inc{S|}", RMeBP, XX, XX }, + { "inc{S|}", RMeSI, XX, XX }, + { "inc{S|}", RMeDI, XX, XX }, + /* 48 */ + { "dec{S|}", RMeAX, XX, XX }, + { "dec{S|}", RMeCX, XX, XX }, + { "dec{S|}", RMeDX, XX, XX }, + { "dec{S|}", RMeBX, XX, XX }, + { "dec{S|}", RMeSP, XX, XX }, + { "dec{S|}", RMeBP, XX, XX }, + { "dec{S|}", RMeSI, XX, XX }, + { "dec{S|}", RMeDI, XX, XX }, + /* 50 */ + { "pushS", RMrAX, XX, XX }, + { "pushS", RMrCX, XX, XX }, + { "pushS", RMrDX, XX, XX }, + { "pushS", RMrBX, XX, XX }, + { "pushS", RMrSP, XX, XX }, + { "pushS", RMrBP, XX, XX }, + { "pushS", RMrSI, XX, XX }, + { "pushS", RMrDI, XX, XX }, + /* 58 */ + { "popS", RMrAX, XX, XX }, + { "popS", RMrCX, XX, XX }, + { "popS", RMrDX, XX, XX }, + { "popS", RMrBX, XX, XX }, + { "popS", RMrSP, XX, XX }, + { "popS", RMrBP, XX, XX }, + { "popS", RMrSI, XX, XX }, + { "popS", RMrDI, XX, XX }, + /* 60 */ + { "pusha{P|}", XX, XX, XX }, + { "popa{P|}", XX, XX, XX }, + { "bound{S|}", Gv, Ma, XX }, + { X86_64_0 }, + { "(bad)", XX, XX, XX }, /* seg fs */ + { "(bad)", XX, XX, XX }, /* seg gs */ + { "(bad)", XX, XX, XX }, /* op size prefix */ + { "(bad)", XX, XX, XX }, /* adr size prefix */ + /* 68 */ + { "pushT", Iq, XX, XX }, + { "imulS", Gv, Ev, Iv }, + { "pushT", sIb, XX, XX }, + { "imulS", Gv, Ev, sIb }, + { "ins{b||b|}", Yb, indirDX, XX }, + { "ins{R||R|}", Yv, indirDX, XX }, + { "outs{b||b|}", indirDX, Xb, XX }, + { "outs{R||R|}", indirDX, Xv, XX }, + /* 70 */ + { "joH", Jb, XX, cond_jump_flag }, + { "jnoH", Jb, XX, cond_jump_flag }, + { "jbH", Jb, XX, cond_jump_flag }, + { "jaeH", Jb, XX, cond_jump_flag }, + { "jeH", Jb, XX, cond_jump_flag }, + { "jneH", Jb, XX, cond_jump_flag }, + { "jbeH", Jb, XX, cond_jump_flag }, + { "jaH", Jb, XX, cond_jump_flag }, + /* 78 */ + { "jsH", Jb, XX, cond_jump_flag }, + { "jnsH", Jb, XX, cond_jump_flag }, + { "jpH", Jb, XX, cond_jump_flag }, + { "jnpH", Jb, XX, cond_jump_flag }, + { "jlH", Jb, XX, cond_jump_flag }, + { "jgeH", Jb, XX, cond_jump_flag }, + { "jleH", Jb, XX, cond_jump_flag }, + { "jgH", Jb, XX, cond_jump_flag }, + /* 80 */ + { GRP1b }, + { GRP1S }, + { "(bad)", XX, XX, XX }, + { GRP1Ss }, + { "testB", Eb, Gb, XX }, + { "testS", Ev, Gv, XX }, + { "xchgB", Eb, Gb, XX }, + { "xchgS", Ev, Gv, XX }, + /* 88 */ + { "movB", Eb, Gb, XX }, + { "movS", Ev, Gv, XX }, + { "movB", Gb, Eb, XX }, + { "movS", Gv, Ev, XX }, + { "movQ", Sv, Sw, XX }, + { "leaS", Gv, M, XX }, + { "movQ", Sw, Sv, XX }, + { "popU", Ev, XX, XX }, + /* 90 */ + { "nop", NOP_Fixup, 0, XX, XX }, + { "xchgS", RMeCX, eAX, XX }, + { "xchgS", RMeDX, eAX, XX }, + { "xchgS", RMeBX, eAX, XX }, + { "xchgS", RMeSP, eAX, XX }, + { "xchgS", RMeBP, eAX, XX }, + { "xchgS", RMeSI, eAX, XX }, + { "xchgS", RMeDI, eAX, XX }, + /* 98 */ + { "cW{tR||tR|}", XX, XX, XX }, + { "cR{tO||tO|}", XX, XX, XX }, + { "Jcall{T|}", Ap, XX, XX }, + { "(bad)", XX, XX, XX }, /* fwait */ + { "pushfT", XX, XX, XX }, + { "popfT", XX, XX, XX }, + { "sahf{|}", XX, XX, XX }, + { "lahf{|}", XX, XX, XX }, + /* a0 */ + { "movB", AL, Ob64, XX }, + { "movS", eAX, Ov64, XX }, + { "movB", Ob64, AL, XX }, + { "movS", Ov64, eAX, XX }, + { "movs{b||b|}", Yb, Xb, XX }, + { "movs{R||R|}", Yv, Xv, XX }, + { "cmps{b||b|}", Xb, Yb, XX }, + { "cmps{R||R|}", Xv, Yv, XX }, + /* a8 */ + { "testB", AL, Ib, XX }, + { "testS", eAX, Iv, XX }, + { "stosB", Yb, AL, XX }, + { "stosS", Yv, eAX, XX }, + { "lodsB", AL, Xb, XX }, + { "lodsS", eAX, Xv, XX }, + { "scasB", AL, Yb, XX }, + { "scasS", eAX, Yv, XX }, + /* b0 */ + { "movB", RMAL, Ib, XX }, + { "movB", RMCL, Ib, XX }, + { "movB", RMDL, Ib, XX }, + { "movB", RMBL, Ib, XX }, + { "movB", RMAH, Ib, XX }, + { "movB", RMCH, Ib, XX }, + { "movB", RMDH, Ib, XX }, + { "movB", RMBH, Ib, XX }, + /* b8 */ + { "movS", RMeAX, Iv64, XX }, + { "movS", RMeCX, Iv64, XX }, + { "movS", RMeDX, Iv64, XX }, + { "movS", RMeBX, Iv64, XX }, + { "movS", RMeSP, Iv64, XX }, + { "movS", RMeBP, Iv64, XX }, + { "movS", RMeSI, Iv64, XX }, + { "movS", RMeDI, Iv64, XX }, + /* c0 */ + { GRP2b }, + { GRP2S }, + { "retT", Iw, XX, XX }, + { "retT", XX, XX, XX }, + { "les{S|}", Gv, Mp, XX }, + { "ldsS", Gv, Mp, XX }, + { "movA", Eb, Ib, XX }, + { "movQ", Ev, Iv, XX }, + /* c8 */ + { "enterT", Iw, Ib, XX }, + { "leaveT", XX, XX, XX }, + { "lretP", Iw, XX, XX }, + { "lretP", XX, XX, XX }, + { "int3", XX, XX, XX }, + { "int", Ib, XX, XX }, + { "into{|}", XX, XX, XX }, + { "iretP", XX, XX, XX }, + /* d0 */ + { GRP2b_one }, + { GRP2S_one }, + { GRP2b_cl }, + { GRP2S_cl }, + { "aam{|}", sIb, XX, XX }, + { "aad{|}", sIb, XX, XX }, + { "(bad)", XX, XX, XX }, + { "xlat", DSBX, XX, XX }, + /* d8 */ + { FLOAT }, + { FLOAT }, + { FLOAT }, + { FLOAT }, + { FLOAT }, + { FLOAT }, + { FLOAT }, + { FLOAT }, + /* e0 */ + { "loopneFH", Jb, XX, loop_jcxz_flag }, + { "loopeFH", Jb, XX, loop_jcxz_flag }, + { "loopFH", Jb, XX, loop_jcxz_flag }, + { "jEcxzH", Jb, XX, loop_jcxz_flag }, + { "inB", AL, Ib, XX }, + { "inS", eAX, Ib, XX }, + { "outB", Ib, AL, XX }, + { "outS", Ib, eAX, XX }, + /* e8 */ + { "callT", Jv, XX, XX }, + { "jmpT", Jv, XX, XX }, + { "Jjmp{T|}", Ap, XX, XX }, + { "jmp", Jb, XX, XX }, + { "inB", AL, indirDX, XX }, + { "inS", eAX, indirDX, XX }, + { "outB", indirDX, AL, XX }, + { "outS", indirDX, eAX, XX }, + /* f0 */ + { "(bad)", XX, XX, XX }, /* lock prefix */ + { "icebp", XX, XX, XX }, + { "(bad)", XX, XX, XX }, /* repne */ + { "(bad)", XX, XX, XX }, /* repz */ + { "hlt", XX, XX, XX }, + { "cmc", XX, XX, XX }, + { GRP3b }, + { GRP3S }, + /* f8 */ + { "clc", XX, XX, XX }, + { "stc", XX, XX, XX }, + { "cli", XX, XX, XX }, + { "sti", XX, XX, XX }, + { "cld", XX, XX, XX }, + { "std", XX, XX, XX }, + { GRP4 }, + { GRP5 }, +}; + +static const struct dis386 dis386_twobyte[] = { + /* 00 */ + { GRP6 }, + { GRP7 }, + { "larS", Gv, Ew, XX }, + { "lslS", Gv, Ew, XX }, + { "(bad)", XX, XX, XX }, + { "syscall", XX, XX, XX }, + { "clts", XX, XX, XX }, + { "sysretP", XX, XX, XX }, + /* 08 */ + { "invd", XX, XX, XX }, + { "wbinvd", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "ud2a", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { GRPAMD }, + { "femms", XX, XX, XX }, + { "", MX, EM, OPSUF }, /* See OP_3DNowSuffix. */ + /* 10 */ + { PREGRP8 }, + { PREGRP9 }, + { PREGRP30 }, + { "movlpX", EX, XM, SIMD_Fixup, 'h' }, + { "unpcklpX", XM, EX, XX }, + { "unpckhpX", XM, EX, XX }, + { PREGRP31 }, + { "movhpX", EX, XM, SIMD_Fixup, 'l' }, + /* 18 */ + { GRP14 }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "nopQ", Ev, XX, XX }, + /* 20 */ + { "movL", Rm, Cm, XX }, + { "movL", Rm, Dm, XX }, + { "movL", Cm, Rm, XX }, + { "movL", Dm, Rm, XX }, + { "movL", Rd, Td, XX }, + { "(bad)", XX, XX, XX }, + { "movL", Td, Rd, XX }, + { "(bad)", XX, XX, XX }, + /* 28 */ + { "movapX", XM, EX, XX }, + { "movapX", EX, XM, XX }, + { PREGRP2 }, + { "movntpX", Ev, XM, XX }, + { PREGRP4 }, + { PREGRP3 }, + { "ucomisX", XM,EX, XX }, + { "comisX", XM,EX, XX }, + /* 30 */ + { "wrmsr", XX, XX, XX }, + { "rdtsc", XX, XX, XX }, + { "rdmsr", XX, XX, XX }, + { "rdpmc", XX, XX, XX }, + { "sysenter", XX, XX, XX }, + { "sysexit", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + /* 38 */ + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + /* 40 */ + { "cmovo", Gv, Ev, XX }, + { "cmovno", Gv, Ev, XX }, + { "cmovb", Gv, Ev, XX }, + { "cmovae", Gv, Ev, XX }, + { "cmove", Gv, Ev, XX }, + { "cmovne", Gv, Ev, XX }, + { "cmovbe", Gv, Ev, XX }, + { "cmova", Gv, Ev, XX }, + /* 48 */ + { "cmovs", Gv, Ev, XX }, + { "cmovns", Gv, Ev, XX }, + { "cmovp", Gv, Ev, XX }, + { "cmovnp", Gv, Ev, XX }, + { "cmovl", Gv, Ev, XX }, + { "cmovge", Gv, Ev, XX }, + { "cmovle", Gv, Ev, XX }, + { "cmovg", Gv, Ev, XX }, + /* 50 */ + { "movmskpX", Gdq, XS, XX }, + { PREGRP13 }, + { PREGRP12 }, + { PREGRP11 }, + { "andpX", XM, EX, XX }, + { "andnpX", XM, EX, XX }, + { "orpX", XM, EX, XX }, + { "xorpX", XM, EX, XX }, + /* 58 */ + { PREGRP0 }, + { PREGRP10 }, + { PREGRP17 }, + { PREGRP16 }, + { PREGRP14 }, + { PREGRP7 }, + { PREGRP5 }, + { PREGRP6 }, + /* 60 */ + { "punpcklbw", MX, EM, XX }, + { "punpcklwd", MX, EM, XX }, + { "punpckldq", MX, EM, XX }, + { "packsswb", MX, EM, XX }, + { "pcmpgtb", MX, EM, XX }, + { "pcmpgtw", MX, EM, XX }, + { "pcmpgtd", MX, EM, XX }, + { "packuswb", MX, EM, XX }, + /* 68 */ + { "punpckhbw", MX, EM, XX }, + { "punpckhwd", MX, EM, XX }, + { "punpckhdq", MX, EM, XX }, + { "packssdw", MX, EM, XX }, + { PREGRP26 }, + { PREGRP24 }, + { "movd", MX, Edq, XX }, + { PREGRP19 }, + /* 70 */ + { PREGRP22 }, + { GRP10 }, + { GRP11 }, + { GRP12 }, + { "pcmpeqb", MX, EM, XX }, + { "pcmpeqw", MX, EM, XX }, + { "pcmpeqd", MX, EM, XX }, + { "emms", XX, XX, XX }, + /* 78 */ + { "vmread", Em, Gm, XX }, + { "vmwrite", Gm, Em, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { PREGRP28 }, + { PREGRP29 }, + { PREGRP23 }, + { PREGRP20 }, + /* 80 */ + { "joH", Jv, XX, cond_jump_flag }, + { "jnoH", Jv, XX, cond_jump_flag }, + { "jbH", Jv, XX, cond_jump_flag }, + { "jaeH", Jv, XX, cond_jump_flag }, + { "jeH", Jv, XX, cond_jump_flag }, + { "jneH", Jv, XX, cond_jump_flag }, + { "jbeH", Jv, XX, cond_jump_flag }, + { "jaH", Jv, XX, cond_jump_flag }, + /* 88 */ + { "jsH", Jv, XX, cond_jump_flag }, + { "jnsH", Jv, XX, cond_jump_flag }, + { "jpH", Jv, XX, cond_jump_flag }, + { "jnpH", Jv, XX, cond_jump_flag }, + { "jlH", Jv, XX, cond_jump_flag }, + { "jgeH", Jv, XX, cond_jump_flag }, + { "jleH", Jv, XX, cond_jump_flag }, + { "jgH", Jv, XX, cond_jump_flag }, + /* 90 */ + { "seto", Eb, XX, XX }, + { "setno", Eb, XX, XX }, + { "setb", Eb, XX, XX }, + { "setae", Eb, XX, XX }, + { "sete", Eb, XX, XX }, + { "setne", Eb, XX, XX }, + { "setbe", Eb, XX, XX }, + { "seta", Eb, XX, XX }, + /* 98 */ + { "sets", Eb, XX, XX }, + { "setns", Eb, XX, XX }, + { "setp", Eb, XX, XX }, + { "setnp", Eb, XX, XX }, + { "setl", Eb, XX, XX }, + { "setge", Eb, XX, XX }, + { "setle", Eb, XX, XX }, + { "setg", Eb, XX, XX }, + /* a0 */ + { "pushT", fs, XX, XX }, + { "popT", fs, XX, XX }, + { "cpuid", XX, XX, XX }, + { "btS", Ev, Gv, XX }, + { "shldS", Ev, Gv, Ib }, + { "shldS", Ev, Gv, CL }, + { GRPPADLCK2 }, + { GRPPADLCK1 }, + /* a8 */ + { "pushT", gs, XX, XX }, + { "popT", gs, XX, XX }, + { "rsm", XX, XX, XX }, + { "btsS", Ev, Gv, XX }, + { "shrdS", Ev, Gv, Ib }, + { "shrdS", Ev, Gv, CL }, + { GRP13 }, + { "imulS", Gv, Ev, XX }, + /* b0 */ + { "cmpxchgB", Eb, Gb, XX }, + { "cmpxchgS", Ev, Gv, XX }, + { "lssS", Gv, Mp, XX }, + { "btrS", Ev, Gv, XX }, + { "lfsS", Gv, Mp, XX }, + { "lgsS", Gv, Mp, XX }, + { "movz{bR|x|bR|x}", Gv, Eb, XX }, + { "movz{wR|x|wR|x}", Gv, Ew, XX }, /* yes, there really is movzww ! */ + /* b8 */ + { "(bad)", XX, XX, XX }, + { "ud2b", XX, XX, XX }, + { GRP8 }, + { "btcS", Ev, Gv, XX }, + { "bsfS", Gv, Ev, XX }, + { "bsrS", Gv, Ev, XX }, + { "movs{bR|x|bR|x}", Gv, Eb, XX }, + { "movs{wR|x|wR|x}", Gv, Ew, XX }, /* yes, there really is movsww ! */ + /* c0 */ + { "xaddB", Eb, Gb, XX }, + { "xaddS", Ev, Gv, XX }, + { PREGRP1 }, + { "movntiS", Ev, Gv, XX }, + { "pinsrw", MX, Edqw, Ib }, + { "pextrw", Gdq, MS, Ib }, + { "shufpX", XM, EX, Ib }, + { GRP9 }, + /* c8 */ + { "bswap", RMeAX, XX, XX }, + { "bswap", RMeCX, XX, XX }, + { "bswap", RMeDX, XX, XX }, + { "bswap", RMeBX, XX, XX }, + { "bswap", RMeSP, XX, XX }, + { "bswap", RMeBP, XX, XX }, + { "bswap", RMeSI, XX, XX }, + { "bswap", RMeDI, XX, XX }, + /* d0 */ + { PREGRP27 }, + { "psrlw", MX, EM, XX }, + { "psrld", MX, EM, XX }, + { "psrlq", MX, EM, XX }, + { "paddq", MX, EM, XX }, + { "pmullw", MX, EM, XX }, + { PREGRP21 }, + { "pmovmskb", Gdq, MS, XX }, + /* d8 */ + { "psubusb", MX, EM, XX }, + { "psubusw", MX, EM, XX }, + { "pminub", MX, EM, XX }, + { "pand", MX, EM, XX }, + { "paddusb", MX, EM, XX }, + { "paddusw", MX, EM, XX }, + { "pmaxub", MX, EM, XX }, + { "pandn", MX, EM, XX }, + /* e0 */ + { "pavgb", MX, EM, XX }, + { "psraw", MX, EM, XX }, + { "psrad", MX, EM, XX }, + { "pavgw", MX, EM, XX }, + { "pmulhuw", MX, EM, XX }, + { "pmulhw", MX, EM, XX }, + { PREGRP15 }, + { PREGRP25 }, + /* e8 */ + { "psubsb", MX, EM, XX }, + { "psubsw", MX, EM, XX }, + { "pminsw", MX, EM, XX }, + { "por", MX, EM, XX }, + { "paddsb", MX, EM, XX }, + { "paddsw", MX, EM, XX }, + { "pmaxsw", MX, EM, XX }, + { "pxor", MX, EM, XX }, + /* f0 */ + { PREGRP32 }, + { "psllw", MX, EM, XX }, + { "pslld", MX, EM, XX }, + { "psllq", MX, EM, XX }, + { "pmuludq", MX, EM, XX }, + { "pmaddwd", MX, EM, XX }, + { "psadbw", MX, EM, XX }, + { PREGRP18 }, + /* f8 */ + { "psubb", MX, EM, XX }, + { "psubw", MX, EM, XX }, + { "psubd", MX, EM, XX }, + { "psubq", MX, EM, XX }, + { "paddb", MX, EM, XX }, + { "paddw", MX, EM, XX }, + { "paddd", MX, EM, XX }, + { "(bad)", XX, XX, XX } +}; + +static const unsigned char onebyte_has_modrm[256] = { + /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ + /* ------------------------------- */ + /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */ + /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */ + /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */ + /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */ + /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */ + /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */ + /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */ + /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */ + /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */ + /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */ + /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */ + /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */ + /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */ + /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */ + /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */ + /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */ + /* ------------------------------- */ + /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ +}; + +static const unsigned char twobyte_has_modrm[256] = { + /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ + /* ------------------------------- */ + /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */ + /* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1, /* 1f */ + /* 20 */ 1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, /* 2f */ + /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ + /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */ + /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */ + /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */ + /* 70 */ 1,1,1,1,1,1,1,0,1,1,0,0,1,1,1,1, /* 7f */ + /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ + /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */ + /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */ + /* b0 */ 1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1, /* bf */ + /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */ + /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */ + /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */ + /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */ + /* ------------------------------- */ + /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ +}; + +static const unsigned char twobyte_uses_SSE_prefix[256] = { + /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ + /* ------------------------------- */ + /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ + /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */ + /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0, /* 2f */ + /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ + /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ + /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */ + /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, /* 6f */ + /* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1, /* 7f */ + /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ + /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ + /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ + /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ + /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ + /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */ + /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */ + /* f0 */ 1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0 /* ff */ + /* ------------------------------- */ + /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ +}; + +static char obuf[512]; +static char *obufp; +static char scratchbuf[512]; +static unsigned char *start_codep; +static unsigned char *insn_codep; +static unsigned char *codep; +static disassemble_info *the_info; +static int mod; +static int rm; +static int reg; +static unsigned char need_modrm; + +/* If we are accessing mod/rm/reg without need_modrm set, then the + values are stale. Hitting this abort likely indicates that you + need to update onebyte_has_modrm or twobyte_has_modrm. */ +#define MODRM_CHECK if (!need_modrm) abort () + +static const char **names64; +static const char **names32; +static const char **names16; +static const char **names8; +static const char **names8rex; +static const char **names_seg; +static const char **index16; + +static const char *intel_names64[] = { + "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi", + "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" +}; +static const char *intel_names32[] = { + "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", + "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d" +}; +static const char *intel_names16[] = { + "ax", "cx", "dx", "bx", "sp", "bp", "si", "di", + "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w" +}; +static const char *intel_names8[] = { + "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh", +}; +static const char *intel_names8rex[] = { + "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil", + "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b" +}; +static const char *intel_names_seg[] = { + "es", "cs", "ss", "ds", "fs", "gs", "?", "?", +}; +static const char *intel_index16[] = { + "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx" +}; + +static const char *att_names64[] = { + "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi", + "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15" +}; +static const char *att_names32[] = { + "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi", + "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d" +}; +static const char *att_names16[] = { + "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di", + "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w" +}; +static const char *att_names8[] = { + "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh", +}; +static const char *att_names8rex[] = { + "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil", + "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b" +}; +static const char *att_names_seg[] = { + "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?", +}; +static const char *att_index16[] = { + "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx" +}; + +static const struct dis386 grps[][8] = { + /* GRP1b */ + { + { "addA", Eb, Ib, XX }, + { "orA", Eb, Ib, XX }, + { "adcA", Eb, Ib, XX }, + { "sbbA", Eb, Ib, XX }, + { "andA", Eb, Ib, XX }, + { "subA", Eb, Ib, XX }, + { "xorA", Eb, Ib, XX }, + { "cmpA", Eb, Ib, XX } + }, + /* GRP1S */ + { + { "addQ", Ev, Iv, XX }, + { "orQ", Ev, Iv, XX }, + { "adcQ", Ev, Iv, XX }, + { "sbbQ", Ev, Iv, XX }, + { "andQ", Ev, Iv, XX }, + { "subQ", Ev, Iv, XX }, + { "xorQ", Ev, Iv, XX }, + { "cmpQ", Ev, Iv, XX } + }, + /* GRP1Ss */ + { + { "addQ", Ev, sIb, XX }, + { "orQ", Ev, sIb, XX }, + { "adcQ", Ev, sIb, XX }, + { "sbbQ", Ev, sIb, XX }, + { "andQ", Ev, sIb, XX }, + { "subQ", Ev, sIb, XX }, + { "xorQ", Ev, sIb, XX }, + { "cmpQ", Ev, sIb, XX } + }, + /* GRP2b */ + { + { "rolA", Eb, Ib, XX }, + { "rorA", Eb, Ib, XX }, + { "rclA", Eb, Ib, XX }, + { "rcrA", Eb, Ib, XX }, + { "shlA", Eb, Ib, XX }, + { "shrA", Eb, Ib, XX }, + { "(bad)", XX, XX, XX }, + { "sarA", Eb, Ib, XX }, + }, + /* GRP2S */ + { + { "rolQ", Ev, Ib, XX }, + { "rorQ", Ev, Ib, XX }, + { "rclQ", Ev, Ib, XX }, + { "rcrQ", Ev, Ib, XX }, + { "shlQ", Ev, Ib, XX }, + { "shrQ", Ev, Ib, XX }, + { "(bad)", XX, XX, XX }, + { "sarQ", Ev, Ib, XX }, + }, + /* GRP2b_one */ + { + { "rolA", Eb, I1, XX }, + { "rorA", Eb, I1, XX }, + { "rclA", Eb, I1, XX }, + { "rcrA", Eb, I1, XX }, + { "shlA", Eb, I1, XX }, + { "shrA", Eb, I1, XX }, + { "(bad)", XX, XX, XX }, + { "sarA", Eb, I1, XX }, + }, + /* GRP2S_one */ + { + { "rolQ", Ev, I1, XX }, + { "rorQ", Ev, I1, XX }, + { "rclQ", Ev, I1, XX }, + { "rcrQ", Ev, I1, XX }, + { "shlQ", Ev, I1, XX }, + { "shrQ", Ev, I1, XX }, + { "(bad)", XX, XX, XX}, + { "sarQ", Ev, I1, XX }, + }, + /* GRP2b_cl */ + { + { "rolA", Eb, CL, XX }, + { "rorA", Eb, CL, XX }, + { "rclA", Eb, CL, XX }, + { "rcrA", Eb, CL, XX }, + { "shlA", Eb, CL, XX }, + { "shrA", Eb, CL, XX }, + { "(bad)", XX, XX, XX }, + { "sarA", Eb, CL, XX }, + }, + /* GRP2S_cl */ + { + { "rolQ", Ev, CL, XX }, + { "rorQ", Ev, CL, XX }, + { "rclQ", Ev, CL, XX }, + { "rcrQ", Ev, CL, XX }, + { "shlQ", Ev, CL, XX }, + { "shrQ", Ev, CL, XX }, + { "(bad)", XX, XX, XX }, + { "sarQ", Ev, CL, XX } + }, + /* GRP3b */ + { + { "testA", Eb, Ib, XX }, + { "(bad)", Eb, XX, XX }, + { "notA", Eb, XX, XX }, + { "negA", Eb, XX, XX }, + { "mulA", Eb, XX, XX }, /* Don't print the implicit %al register, */ + { "imulA", Eb, XX, XX }, /* to distinguish these opcodes from other */ + { "divA", Eb, XX, XX }, /* mul/imul opcodes. Do the same for div */ + { "idivA", Eb, XX, XX } /* and idiv for consistency. */ + }, + /* GRP3S */ + { + { "testQ", Ev, Iv, XX }, + { "(bad)", XX, XX, XX }, + { "notQ", Ev, XX, XX }, + { "negQ", Ev, XX, XX }, + { "mulQ", Ev, XX, XX }, /* Don't print the implicit register. */ + { "imulQ", Ev, XX, XX }, + { "divQ", Ev, XX, XX }, + { "idivQ", Ev, XX, XX }, + }, + /* GRP4 */ + { + { "incA", Eb, XX, XX }, + { "decA", Eb, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + }, + /* GRP5 */ + { + { "incQ", Ev, XX, XX }, + { "decQ", Ev, XX, XX }, + { "callT", indirEv, XX, XX }, + { "JcallT", indirEp, XX, XX }, + { "jmpT", indirEv, XX, XX }, + { "JjmpT", indirEp, XX, XX }, + { "pushU", Ev, XX, XX }, + { "(bad)", XX, XX, XX }, + }, + /* GRP6 */ + { + { "sldtQ", Ev, XX, XX }, + { "strQ", Ev, XX, XX }, + { "lldt", Ew, XX, XX }, + { "ltr", Ew, XX, XX }, + { "verr", Ew, XX, XX }, + { "verw", Ew, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX } + }, + /* GRP7 */ + { + { "sgdtIQ", VMX_Fixup, 0, XX, XX }, + { "sidtIQ", PNI_Fixup, 0, XX, XX }, + { "lgdt{Q|Q||}", M, XX, XX }, + { "lidt{Q|Q||}", SVME_Fixup, 0, XX, XX }, + { "smswQ", Ev, XX, XX }, + { "(bad)", XX, XX, XX }, + { "lmsw", Ew, XX, XX }, + { "invlpg", INVLPG_Fixup, w_mode, XX, XX }, + }, + /* GRP8 */ + { + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "btQ", Ev, Ib, XX }, + { "btsQ", Ev, Ib, XX }, + { "btrQ", Ev, Ib, XX }, + { "btcQ", Ev, Ib, XX }, + }, + /* GRP9 */ + { + { "(bad)", XX, XX, XX }, + { "cmpxchg8b", Eq, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "", VM, XX, XX }, /* See OP_VMX. */ + { "vmptrst", Eq, XX, XX }, + }, + /* GRP10 */ + { + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "psrlw", MS, Ib, XX }, + { "(bad)", XX, XX, XX }, + { "psraw", MS, Ib, XX }, + { "(bad)", XX, XX, XX }, + { "psllw", MS, Ib, XX }, + { "(bad)", XX, XX, XX }, + }, + /* GRP11 */ + { + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "psrld", MS, Ib, XX }, + { "(bad)", XX, XX, XX }, + { "psrad", MS, Ib, XX }, + { "(bad)", XX, XX, XX }, + { "pslld", MS, Ib, XX }, + { "(bad)", XX, XX, XX }, + }, + /* GRP12 */ + { + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "psrlq", MS, Ib, XX }, + { "psrldq", MS, Ib, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "psllq", MS, Ib, XX }, + { "pslldq", MS, Ib, XX }, + }, + /* GRP13 */ + { + { "fxsave", Ev, XX, XX }, + { "fxrstor", Ev, XX, XX }, + { "ldmxcsr", Ev, XX, XX }, + { "stmxcsr", Ev, XX, XX }, + { "xsave", Ev, XX, XX }, + { "xrstor", OP_0fae, 0, XX, XX }, + { "mfence", OP_0fae, 0, XX, XX }, + { "clflush", OP_0fae, 0, XX, XX }, + }, + /* GRP14 */ + { + { "prefetchnta", Ev, XX, XX }, + { "prefetcht0", Ev, XX, XX }, + { "prefetcht1", Ev, XX, XX }, + { "prefetcht2", Ev, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + }, + /* GRPAMD */ + { + { "prefetch", Eb, XX, XX }, + { "prefetchw", Eb, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + }, + /* GRPPADLCK1 */ + { + { "xstore-rng", OP_0f07, 0, XX, XX }, + { "xcrypt-ecb", OP_0f07, 0, XX, XX }, + { "xcrypt-cbc", OP_0f07, 0, XX, XX }, + { "xcrypt-ctr", OP_0f07, 0, XX, XX }, + { "xcrypt-cfb", OP_0f07, 0, XX, XX }, + { "xcrypt-ofb", OP_0f07, 0, XX, XX }, + { "(bad)", OP_0f07, 0, XX, XX }, + { "(bad)", OP_0f07, 0, XX, XX }, + }, + /* GRPPADLCK2 */ + { + { "montmul", OP_0f07, 0, XX, XX }, + { "xsha1", OP_0f07, 0, XX, XX }, + { "xsha256", OP_0f07, 0, XX, XX }, + { "(bad)", OP_0f07, 0, XX, XX }, + { "(bad)", OP_0f07, 0, XX, XX }, + { "(bad)", OP_0f07, 0, XX, XX }, + { "(bad)", OP_0f07, 0, XX, XX }, + { "(bad)", OP_0f07, 0, XX, XX }, + } +}; + +static const struct dis386 prefix_user_table[][4] = { + /* PREGRP0 */ + { + { "addps", XM, EX, XX }, + { "addss", XM, EX, XX }, + { "addpd", XM, EX, XX }, + { "addsd", XM, EX, XX }, + }, + /* PREGRP1 */ + { + { "", XM, EX, OPSIMD }, /* See OP_SIMD_SUFFIX. */ + { "", XM, EX, OPSIMD }, + { "", XM, EX, OPSIMD }, + { "", XM, EX, OPSIMD }, + }, + /* PREGRP2 */ + { + { "cvtpi2ps", XM, EM, XX }, + { "cvtsi2ssY", XM, Ev, XX }, + { "cvtpi2pd", XM, EM, XX }, + { "cvtsi2sdY", XM, Ev, XX }, + }, + /* PREGRP3 */ + { + { "cvtps2pi", MX, EX, XX }, + { "cvtss2siY", Gv, EX, XX }, + { "cvtpd2pi", MX, EX, XX }, + { "cvtsd2siY", Gv, EX, XX }, + }, + /* PREGRP4 */ + { + { "cvttps2pi", MX, EX, XX }, + { "cvttss2siY", Gv, EX, XX }, + { "cvttpd2pi", MX, EX, XX }, + { "cvttsd2siY", Gv, EX, XX }, + }, + /* PREGRP5 */ + { + { "divps", XM, EX, XX }, + { "divss", XM, EX, XX }, + { "divpd", XM, EX, XX }, + { "divsd", XM, EX, XX }, + }, + /* PREGRP6 */ + { + { "maxps", XM, EX, XX }, + { "maxss", XM, EX, XX }, + { "maxpd", XM, EX, XX }, + { "maxsd", XM, EX, XX }, + }, + /* PREGRP7 */ + { + { "minps", XM, EX, XX }, + { "minss", XM, EX, XX }, + { "minpd", XM, EX, XX }, + { "minsd", XM, EX, XX }, + }, + /* PREGRP8 */ + { + { "movups", XM, EX, XX }, + { "movss", XM, EX, XX }, + { "movupd", XM, EX, XX }, + { "movsd", XM, EX, XX }, + }, + /* PREGRP9 */ + { + { "movups", EX, XM, XX }, + { "movss", EX, XM, XX }, + { "movupd", EX, XM, XX }, + { "movsd", EX, XM, XX }, + }, + /* PREGRP10 */ + { + { "mulps", XM, EX, XX }, + { "mulss", XM, EX, XX }, + { "mulpd", XM, EX, XX }, + { "mulsd", XM, EX, XX }, + }, + /* PREGRP11 */ + { + { "rcpps", XM, EX, XX }, + { "rcpss", XM, EX, XX }, + { "(bad)", XM, EX, XX }, + { "(bad)", XM, EX, XX }, + }, + /* PREGRP12 */ + { + { "rsqrtps", XM, EX, XX }, + { "rsqrtss", XM, EX, XX }, + { "(bad)", XM, EX, XX }, + { "(bad)", XM, EX, XX }, + }, + /* PREGRP13 */ + { + { "sqrtps", XM, EX, XX }, + { "sqrtss", XM, EX, XX }, + { "sqrtpd", XM, EX, XX }, + { "sqrtsd", XM, EX, XX }, + }, + /* PREGRP14 */ + { + { "subps", XM, EX, XX }, + { "subss", XM, EX, XX }, + { "subpd", XM, EX, XX }, + { "subsd", XM, EX, XX }, + }, + /* PREGRP15 */ + { + { "(bad)", XM, EX, XX }, + { "cvtdq2pd", XM, EX, XX }, + { "cvttpd2dq", XM, EX, XX }, + { "cvtpd2dq", XM, EX, XX }, + }, + /* PREGRP16 */ + { + { "cvtdq2ps", XM, EX, XX }, + { "cvttps2dq",XM, EX, XX }, + { "cvtps2dq",XM, EX, XX }, + { "(bad)", XM, EX, XX }, + }, + /* PREGRP17 */ + { + { "cvtps2pd", XM, EX, XX }, + { "cvtss2sd", XM, EX, XX }, + { "cvtpd2ps", XM, EX, XX }, + { "cvtsd2ss", XM, EX, XX }, + }, + /* PREGRP18 */ + { + { "maskmovq", MX, MS, XX }, + { "(bad)", XM, EX, XX }, + { "maskmovdqu", XM, EX, XX }, + { "(bad)", XM, EX, XX }, + }, + /* PREGRP19 */ + { + { "movq", MX, EM, XX }, + { "movdqu", XM, EX, XX }, + { "movdqa", XM, EX, XX }, + { "(bad)", XM, EX, XX }, + }, + /* PREGRP20 */ + { + { "movq", EM, MX, XX }, + { "movdqu", EX, XM, XX }, + { "movdqa", EX, XM, XX }, + { "(bad)", EX, XM, XX }, + }, + /* PREGRP21 */ + { + { "(bad)", EX, XM, XX }, + { "movq2dq", XM, MS, XX }, + { "movq", EX, XM, XX }, + { "movdq2q", MX, XS, XX }, + }, + /* PREGRP22 */ + { + { "pshufw", MX, EM, Ib }, + { "pshufhw", XM, EX, Ib }, + { "pshufd", XM, EX, Ib }, + { "pshuflw", XM, EX, Ib }, + }, + /* PREGRP23 */ + { + { "movd", Edq, MX, XX }, + { "movq", XM, EX, XX }, + { "movd", Edq, XM, XX }, + { "(bad)", Ed, XM, XX }, + }, + /* PREGRP24 */ + { + { "(bad)", MX, EX, XX }, + { "(bad)", XM, EX, XX }, + { "punpckhqdq", XM, EX, XX }, + { "(bad)", XM, EX, XX }, + }, + /* PREGRP25 */ + { + { "movntq", EM, MX, XX }, + { "(bad)", EM, XM, XX }, + { "movntdq", EM, XM, XX }, + { "(bad)", EM, XM, XX }, + }, + /* PREGRP26 */ + { + { "(bad)", MX, EX, XX }, + { "(bad)", XM, EX, XX }, + { "punpcklqdq", XM, EX, XX }, + { "(bad)", XM, EX, XX }, + }, + /* PREGRP27 */ + { + { "(bad)", MX, EX, XX }, + { "(bad)", XM, EX, XX }, + { "addsubpd", XM, EX, XX }, + { "addsubps", XM, EX, XX }, + }, + /* PREGRP28 */ + { + { "(bad)", MX, EX, XX }, + { "(bad)", XM, EX, XX }, + { "haddpd", XM, EX, XX }, + { "haddps", XM, EX, XX }, + }, + /* PREGRP29 */ + { + { "(bad)", MX, EX, XX }, + { "(bad)", XM, EX, XX }, + { "hsubpd", XM, EX, XX }, + { "hsubps", XM, EX, XX }, + }, + /* PREGRP30 */ + { + { "movlpX", XM, EX, SIMD_Fixup, 'h' }, /* really only 2 operands */ + { "movsldup", XM, EX, XX }, + { "movlpd", XM, EX, XX }, + { "movddup", XM, EX, XX }, + }, + /* PREGRP31 */ + { + { "movhpX", XM, EX, SIMD_Fixup, 'l' }, + { "movshdup", XM, EX, XX }, + { "movhpd", XM, EX, XX }, + { "(bad)", XM, EX, XX }, + }, + /* PREGRP32 */ + { + { "(bad)", XM, EX, XX }, + { "(bad)", XM, EX, XX }, + { "(bad)", XM, EX, XX }, + { "lddqu", XM, M, XX }, + }, +}; + +static const struct dis386 x86_64_table[][2] = { + { + { "arpl", Ew, Gw, XX }, + { "movs{||lq|xd}", Gv, Ed, XX }, + }, +}; + +#ifdef __KERNEL__ +#define INTERNAL_DISASSEMBLER_ERROR "" +#else /* __KERNEL__ */ +#define INTERNAL_DISASSEMBLER_ERROR _("") +#endif /* __KERNEL__ */ + +static void +ckprefix (void) +{ + int newrex; + rex = 0; + prefixes = 0; + used_prefixes = 0; + rex_used = 0; + while (1) + { + FETCH_DATA (the_info, codep + 1); + newrex = 0; + switch (*codep) + { + /* REX prefixes family. */ + case 0x40: + case 0x41: + case 0x42: + case 0x43: + case 0x44: + case 0x45: + case 0x46: + case 0x47: + case 0x48: + case 0x49: + case 0x4a: + case 0x4b: + case 0x4c: + case 0x4d: + case 0x4e: + case 0x4f: + if (mode_64bit) + newrex = *codep; + else + return; + break; + case 0xf3: + prefixes |= PREFIX_REPZ; + break; + case 0xf2: + prefixes |= PREFIX_REPNZ; + break; + case 0xf0: + prefixes |= PREFIX_LOCK; + break; + case 0x2e: + prefixes |= PREFIX_CS; + break; + case 0x36: + prefixes |= PREFIX_SS; + break; + case 0x3e: + prefixes |= PREFIX_DS; + break; + case 0x26: + prefixes |= PREFIX_ES; + break; + case 0x64: + prefixes |= PREFIX_FS; + break; + case 0x65: + prefixes |= PREFIX_GS; + break; + case 0x66: + prefixes |= PREFIX_DATA; + break; + case 0x67: + prefixes |= PREFIX_ADDR; + break; + case FWAIT_OPCODE: + /* fwait is really an instruction. If there are prefixes + before the fwait, they belong to the fwait, *not* to the + following instruction. */ + if (prefixes) + { + prefixes |= PREFIX_FWAIT; + codep++; + return; + } + prefixes = PREFIX_FWAIT; + break; + default: + return; + } + /* Rex is ignored when followed by another prefix. */ + if (rex) + { + oappend (prefix_name (rex, 0)); + oappend (" "); + } + rex = newrex; + codep++; + } +} + +/* Return the name of the prefix byte PREF, or NULL if PREF is not a + prefix byte. */ + +static const char * +prefix_name (int pref, int sizeflag) +{ + switch (pref) + { + /* REX prefixes family. */ + case 0x40: + return "rex"; + case 0x41: + return "rexZ"; + case 0x42: + return "rexY"; + case 0x43: + return "rexYZ"; + case 0x44: + return "rexX"; + case 0x45: + return "rexXZ"; + case 0x46: + return "rexXY"; + case 0x47: + return "rexXYZ"; + case 0x48: + return "rex64"; + case 0x49: + return "rex64Z"; + case 0x4a: + return "rex64Y"; + case 0x4b: + return "rex64YZ"; + case 0x4c: + return "rex64X"; + case 0x4d: + return "rex64XZ"; + case 0x4e: + return "rex64XY"; + case 0x4f: + return "rex64XYZ"; + case 0xf3: + return "repz"; + case 0xf2: + return "repnz"; + case 0xf0: + return "lock"; + case 0x2e: + return "cs"; + case 0x36: + return "ss"; + case 0x3e: + return "ds"; + case 0x26: + return "es"; + case 0x64: + return "fs"; + case 0x65: + return "gs"; + case 0x66: + return (sizeflag & DFLAG) ? "data16" : "data32"; + case 0x67: + if (mode_64bit) + return (sizeflag & AFLAG) ? "addr32" : "addr64"; + else + return (sizeflag & AFLAG) ? "addr16" : "addr32"; + case FWAIT_OPCODE: + return "fwait"; + default: + return NULL; + } +} + +static char op1out[100], op2out[100], op3out[100]; +static int op_ad, op_index[3]; +static int two_source_ops; +static bfd_vma op_address[3]; +static bfd_vma op_riprel[3]; +static bfd_vma start_pc; + +/* + * On the 386's of 1988, the maximum length of an instruction is 15 bytes. + * (see topic "Redundant prefixes" in the "Differences from 8086" + * section of the "Virtual 8086 Mode" chapter.) + * 'pc' should be the address of this instruction, it will + * be used to print the target address if this is a relative jump or call + * The function returns the length of this instruction in bytes. + */ + +static char intel_syntax; +static char open_char; +static char close_char; +static char separator_char; +static char scale_char; + +/* Here for backwards compatibility. When gdb stops using + print_insn_i386_att and print_insn_i386_intel these functions can + disappear, and print_insn_i386 be merged into print_insn. */ +int +print_insn_i386_att (bfd_vma pc, disassemble_info *info, + StackFrame *stackFrame) +{ + intel_syntax = 0; + + return print_insn (pc, info, stackFrame); +} + +int +print_insn_i386_intel (bfd_vma pc, disassemble_info *info, + StackFrame *stackFrame) +{ + intel_syntax = 1; + + return print_insn (pc, info, stackFrame); +} + +int +print_insn_i386 (bfd_vma pc, disassemble_info *info, + StackFrame *stackFrame) +{ + intel_syntax = -1; + + return print_insn (pc, info, stackFrame); +} + +#ifdef MDB_ENHANCEMENTS +static inline int evaluate_jump_condition(StackFrame *stackFrame, + unsigned long val, + char *ubuf, + disassemble_info *info) +{ + if ((!strncasecmp(ubuf, "jbe", 3) && + ((stackFrame->tSystemFlags & ZF_FLAG) || + (stackFrame->tSystemFlags & CF_FLAG))) || + (!strncasecmp(ubuf, "jcxz", 4) && + (!stackFrame->tCX)) || + (!strncasecmp(ubuf, "jecxz", 5) && + (!stackFrame->tCX)) || + (!strncasecmp(ubuf, "jc", 2) && + (stackFrame->tSystemFlags & CF_FLAG)) || + (!strncasecmp(ubuf, "jle", 3) && + ((stackFrame->tSystemFlags & ZF_FLAG) || + ((stackFrame->tSystemFlags & ~SF_FLAG) != + (stackFrame->tSystemFlags & ~OF_FLAG)))) || + (!strncasecmp(ubuf, "jl", 2) && + ((stackFrame->tSystemFlags & ~SF_FLAG) != + (stackFrame->tSystemFlags & ~OF_FLAG))) || + (!strncasecmp(ubuf, "jmp", 3)) || + (!strncasecmp(ubuf, "jge", 3) && + ((stackFrame->tSystemFlags & ~SF_FLAG) == + (stackFrame->tSystemFlags & ~OF_FLAG))) || + (!strncasecmp(ubuf, "jg", 2) && + ((!(stackFrame->tSystemFlags & ZF_FLAG)) && + ((stackFrame->tSystemFlags & ~SF_FLAG) == + (stackFrame->tSystemFlags & ~OF_FLAG)))) || + (!strncasecmp(ubuf, "jnbe", 4) && + (!(stackFrame->tSystemFlags & CF_FLAG)) && + (!(stackFrame->tSystemFlags & ZF_FLAG))) || + (!strncasecmp(ubuf, "jno", 3) && + (!(stackFrame->tSystemFlags & OF_FLAG))) || + (!strncasecmp(ubuf, "jnc", 3) && + (!(stackFrame->tSystemFlags & CF_FLAG))) || + (!strncasecmp(ubuf, "jnz", 3) && + (!(stackFrame->tSystemFlags & ZF_FLAG))) || + (!strncasecmp(ubuf, "jns", 3) && + (!(stackFrame->tSystemFlags & SF_FLAG))) || + (!strncasecmp(ubuf, "jo", 2) && + (stackFrame->tSystemFlags & OF_FLAG)) || + (!strncasecmp(ubuf, "jpe", 3) && + (stackFrame->tSystemFlags & PF_FLAG)) || + (!strncasecmp(ubuf, "jpo", 3) && + (!(stackFrame->tSystemFlags & PF_FLAG))) || + (!strncasecmp(ubuf, "js", 2) && + (stackFrame->tSystemFlags & SF_FLAG)) || + (!strncasecmp(ubuf, "jz", 2) && + (stackFrame->tSystemFlags & ZF_FLAG)) || + (!strncasecmp(ubuf, "loopne", 6) && + (stackFrame->tCX) && + (!(stackFrame->tSystemFlags & ZF_FLAG))) || + (!strncasecmp(ubuf, "loope", 5) && + (stackFrame->tCX) && + (stackFrame->tSystemFlags & ZF_FLAG)) || + (!strncasecmp(ubuf, "loop", 4))) + { + jmp_active = 1; + if (intel_syntax) + (*info->fprintf_func)(info->stream, " (0x%p) %c", (void *)val, + (val < (unsigned long)vaddr) ? 0x18 : 0x19); + else + (*info->fprintf_func)(info->stream, " %c", + (val < (unsigned long)vaddr) ? 0x18 : 0x19); + return 1; + } + return 0; +} + +static inline void output_jmp_address(StackFrame *stackFrame, + unsigned long val, + char *ubuf, + disassemble_info *info) +{ + if (!strncasecmp(ubuf, "j", 1) || !strncasecmp(ubuf, "loop", 4)) + { + if (evaluate_jump_condition(stackFrame, val, ubuf, info)) + return; + + jmp_active = 1; + if (intel_syntax) + (*info->fprintf_func)(info->stream, " (0x%p) %c", (void *)val, + (val < (unsigned long)vaddr) ? 0x18 : 0x19); + else + (*info->fprintf_func)(info->stream, " %c", + (val < (unsigned long)vaddr) ? 0x18 : 0x19); + } + return; +} + +static inline void evaluate_expression_size(int sz, int sizeflag, + unsigned char *deref, + StackFrame *stackFrame) +{ + unsigned char *cmd = deref; + unsigned long long value; + unsigned long valid; + unsigned char *r = NULL; + unsigned char work[16]; + + memset(work, 0, 16); + + value = EvaluateDisassemblyExpression(stackFrame, &cmd, &valid, sz, &r); + if (valid) + { + switch (sz) + { + case 1: + sprintf(scratchbuf, "=0x%02X", (unsigned char)value); + break; + case 2: + sprintf(scratchbuf, "=0x%04X", (unsigned short)value); + break; + case 4: + sprintf(scratchbuf, "=0x%lX", (unsigned long)value); + break; + case 6: +#ifdef CONFIG_X86_64 + // FWORD Pointers are 10 bytes in x86-64, 6 bytes in ia32 + if (r && !mdb_copy(work, r, 10)) + sprintf(scratchbuf, "=0x%02X%02X%02X%02X%02X%02X" + "%02X%02X%02X%02X", + work[0], work[1], work[2], work[3], + work[4], work[5], work[6], work[7], + work[8], work[9]); +#else + if (r && !mdb_copy(work, r, 6)) + sprintf(scratchbuf, "=0x%02X%02X%02X%02X%02X%02X", + work[0], work[1], work[2], + work[3], work[4], work[5]); +#endif + else + sprintf(scratchbuf, "=?"); + break; + case 8: + sprintf(scratchbuf, "=0x%llX", value); + break; + case 10: + if (r && !mdb_copy(work, r, 10)) + sprintf(scratchbuf, + "=0x%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", + work[0], work[1], work[2], + work[3], work[4], work[5], + work[6], work[7], work[8], + work[9]); + else + sprintf(scratchbuf, "=?"); + break; + case 16: + if (r && !mdb_copy(work, r, 16)) + sprintf(scratchbuf, "=0x%02X%02X%02X%02X%02X%02X" + "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", + work[0], work[1], work[2], work[3], + work[4], work[5], work[6], work[7], + work[8], work[9], work[10],work[11], + work[12],work[13],work[14],work[15]); + else + sprintf(scratchbuf, "=?"); + break; + default: + sprintf(scratchbuf, "=0x%lX", (unsigned long)value); + break; + } + oappend (scratchbuf); + } + return; +} + +static inline void evaluate_expression(int bytemode, int sizeflag, + unsigned char *deref, + StackFrame *stackFrame) +{ + unsigned char *cmd = deref; + unsigned long long value; + unsigned long valid; + unsigned long sz = 4; + unsigned char *r = NULL; + unsigned char work[16]; + + memset(work, 0, 16); + + switch (bytemode) + { + // BYTE PTR + case b_mode: + sz = 1; + break; + + // WORD PTR + case w_mode: + case dqw_mode: + sz = 2; + break; + + // QWORD PTR + case branch_v_mode: + case v_mode: + case dq_mode: + USED_REX (REX_MODE64); + if (rex & REX_MODE64) + sz = 8; + // DWORD PTR + else if ((sizeflag & DFLAG) || bytemode == dq_mode) + sz = 4; + // WORD PTR + else + sz = 2; + used_prefixes |= (prefixes & PREFIX_DATA); + break; + // DWORD PTR + case d_mode: + sz = 4; + break; + // QWORD PTR + case q_mode: + sz = 8; + break; + case m_mode: + // QWORD PTR + if (mode_64bit) + sz = 8; + // DWORD PTR + else + sz = 4; + break; + case f_mode: + // FWORD PTR + if (sizeflag & DFLAG) + { + used_prefixes |= (prefixes & PREFIX_DATA); + sz = 6; + } + // DWORD PTR + else + sz = 4; + break; + // TBYTE PTR + case t_mode: + sz = 10; + break; + // XMMWORD PTR + case x_mode: + sz = 16; + break; + // default is DWORD + default: + sz = 4; + break; + } + + value = EvaluateDisassemblyExpression(stackFrame, &cmd, &valid, sz, &r); + if (valid) + { + switch (sz) + { + case 1: + sprintf(scratchbuf, "=0x%02X", (unsigned char)value); + break; + case 2: + sprintf(scratchbuf, "=0x%04X", (unsigned short)value); + break; + case 4: + sprintf(scratchbuf, "=0x%lX", (unsigned long)value); + break; + case 6: +#ifdef CONFIG_X86_64 + // FWORD Pointers are 10 bytes in x86-64, 6 bytes in ia32 + if (r && !mdb_copy(work, r, 10)) + sprintf(scratchbuf, "=0x%02X%02X%02X%02X%02X%02X" + "%02X%02X%02X%02X", + work[0], work[1], work[2], work[3], + work[4], work[5], work[6], work[7], + work[8], work[9]); +#else + if (r && !mdb_copy(work, r, 6)) + sprintf(scratchbuf, "=0x%02X%02X%02X%02X%02X%02X", + work[0], work[1], work[2], + work[3], work[4], work[5]); +#endif + else + sprintf(scratchbuf, "=?"); + break; + case 8: + sprintf(scratchbuf, "=0x%llX", value); + break; + case 10: + if (r && !mdb_copy(work, r, 10)) + sprintf(scratchbuf, + "=0x%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", + work[0], work[1], work[2], + work[3], work[4], work[5], + work[6], work[7], work[8], + work[9]); + else + sprintf(scratchbuf, "=?"); + break; + case 16: + if (r && !mdb_copy(work, r, 16)) + sprintf(scratchbuf, "=0x%02X%02X%02X%02X%02X%02X" + "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", + work[0], work[1], work[2], work[3], + work[4], work[5], work[6], work[7], + work[8], work[9], work[10],work[11], + work[12],work[13],work[14],work[15]); + else + sprintf(scratchbuf, "=?"); + break; + default: + sprintf(scratchbuf, "=0x%lX", (unsigned long)value); + break; + } + oappend (scratchbuf); + } + return; +} + +static inline int evaluate_address_expression(int bytemode, int sizeflag, + unsigned long addr, + unsigned long mask, + StackFrame *stackFrame, + const char *sv) +{ + unsigned char *cmd; + unsigned char *sym_name; + unsigned long offset; + unsigned long long value; + unsigned long valid; + unsigned long sz = 4; + unsigned char *r = NULL; + unsigned char work[16]; + + memset(work, 0, 16); + + switch (bytemode) + { + // BYTE PTR + case b_mode: + sz = 1; + break; + + // WORD PTR + case w_mode: + case dqw_mode: + sz = 2; + break; + + // QWORD PTR + case branch_v_mode: + case v_mode: + case dq_mode: + USED_REX (REX_MODE64); + if (rex & REX_MODE64) + sz = 8; + // DWORD PTR + else if ((sizeflag & DFLAG) || bytemode == dq_mode) + sz = 4; + // WORD PTR + else + sz = 2; + used_prefixes |= (prefixes & PREFIX_DATA); + break; + // DWORD PTR + case d_mode: + sz = 4; + break; + // QWORD PTR + case q_mode: + sz = 8; + break; + case m_mode: + // QWORD PTR + if (mode_64bit) + sz = 8; + // DWORD PTR + else + sz = 4; + break; + case f_mode: + // FWORD PTR + if (sizeflag & DFLAG) + { + used_prefixes |= (prefixes & PREFIX_DATA); + sz = 6; + } + // DWORD PTR + else + sz = 4; + break; + // TBYTE PTR + case t_mode: + sz = 10; + break; + // XMMWORD PTR + case x_mode: + sz = 16; + break; + // default is DWORD + default: + sz = 4; + break; + } + + if (mask) + addr = addr & mask; + + sym_name = GetSymbolFromValueWithOffset(addr, &offset, + &symbuf[get_processor_id()][0], + MAX_SYMBOL_LEN); + if (sym_name && sym_name[0] != ' ') + { + cmd = obufp; + if (sv) + { + oappend(sv); + oappend(":"); + } + oappend ("["); + sprintf(scratchbuf, "%s", sym_name); + oappend (scratchbuf); + if (offset) + { + sprintf(scratchbuf, "+0x%lx", offset); + oappend (scratchbuf); + } + oappend ("]"); + + value = EvaluateDisassemblyExpression(stackFrame, &cmd, &valid, sz, &r); + if (valid) + { + switch (sz) + { + case 1: + sprintf(scratchbuf, "=0x%02X", (unsigned char)value); + break; + case 2: + sprintf(scratchbuf, "=0x%04X", (unsigned short)value); + break; + case 4: + sprintf(scratchbuf, "=0x%lX", (unsigned long)value); + break; + case 6: +#ifdef CONFIG_X86_64 + // FWORD Pointers are 10 bytes in x86-64, 6 bytes in ia32 + if (r && !mdb_copy(work, r, 10)) + sprintf(scratchbuf, "=0x%02X%02X%02X%02X%02X%02X" + "%02X%02X%02X%02X", + work[0], work[1], work[2], work[3], + work[4], work[5], work[6], work[7], + work[8], work[9]); +#else + if (r && !mdb_copy(work, r, 6)) + sprintf(scratchbuf, "=0x%02X%02X%02X%02X%02X%02X", + work[0], work[1], work[2], + work[3], work[4], work[5]); +#endif + else + sprintf(scratchbuf, "=?"); + break; + case 8: + sprintf(scratchbuf, "=0x%llX", value); + break; + case 10: + if (r && !mdb_copy(work, r, 10)) + sprintf(scratchbuf, + "=0x%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", + work[0], work[1], work[2], + work[3], work[4], work[5], + work[6], work[7], work[8], + work[9]); + else + sprintf(scratchbuf, "=?"); + break; + case 16: + if (r && !mdb_copy(work, r, 16)) + sprintf(scratchbuf, "=0x%02X%02X%02X%02X%02X%02X" + "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", + work[0], work[1], work[2], work[3], + work[4], work[5], work[6], work[7], + work[8], work[9], work[10],work[11], + work[12],work[13],work[14],work[15]); + else + sprintf(scratchbuf, "=?"); + break; + default: + sprintf(scratchbuf, "=0x%lX", (unsigned long)value); + break; + } + oappend (scratchbuf); + } + return 1; + } + return 0; +} +#endif + +static int +print_insn (bfd_vma pc, disassemble_info *info, + StackFrame *stackFrame) +{ + const struct dis386 *dp; + int i; + char *first, *second, *third; + int needcomma; + unsigned char uses_SSE_prefix, uses_LOCK_prefix; + int sizeflag; + const char *p; + struct dis_private priv; + + mode_64bit = (info->mach == bfd_mach_x86_64_intel_syntax + || info->mach == bfd_mach_x86_64); + + if (intel_syntax == (char) -1) + intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax + || info->mach == bfd_mach_x86_64_intel_syntax); + + if (info->mach == bfd_mach_i386_i386 + || info->mach == bfd_mach_x86_64 + || info->mach == bfd_mach_i386_i386_intel_syntax + || info->mach == bfd_mach_x86_64_intel_syntax) + priv.orig_sizeflag = AFLAG | DFLAG; + else if (info->mach == bfd_mach_i386_i8086) + priv.orig_sizeflag = 0; + else + abort (); + + for (p = info->disassembler_options; p != NULL; ) + { + if (strncmp (p, "x86-64", 6) == 0) + { + mode_64bit = 1; + priv.orig_sizeflag = AFLAG | DFLAG; + } + else if (strncmp (p, "i386", 4) == 0) + { + mode_64bit = 0; + priv.orig_sizeflag = AFLAG | DFLAG; + } + else if (strncmp (p, "i8086", 5) == 0) + { + mode_64bit = 0; + priv.orig_sizeflag = 0; + } + else if (strncmp (p, "intel", 5) == 0) + { + intel_syntax = 1; + } + else if (strncmp (p, "att", 3) == 0) + { + intel_syntax = 0; + } + else if (strncmp (p, "addr", 4) == 0) + { + if (p[4] == '1' && p[5] == '6') + priv.orig_sizeflag &= ~AFLAG; + else if (p[4] == '3' && p[5] == '2') + priv.orig_sizeflag |= AFLAG; + } + else if (strncmp (p, "data", 4) == 0) + { + if (p[4] == '1' && p[5] == '6') + priv.orig_sizeflag &= ~DFLAG; + else if (p[4] == '3' && p[5] == '2') + priv.orig_sizeflag |= DFLAG; + } + else if (strncmp (p, "suffix", 6) == 0) + priv.orig_sizeflag |= SUFFIX_ALWAYS; + + p = strchr (p, ','); + if (p != NULL) + p++; + } + + if (intel_syntax) + { + names64 = intel_names64; + names32 = intel_names32; + names16 = intel_names16; + names8 = intel_names8; + names8rex = intel_names8rex; + names_seg = intel_names_seg; + index16 = intel_index16; + open_char = '['; + close_char = ']'; + separator_char = '+'; + scale_char = '*'; + } + else + { + names64 = att_names64; + names32 = att_names32; + names16 = att_names16; + names8 = att_names8; + names8rex = att_names8rex; + names_seg = att_names_seg; + index16 = att_index16; + open_char = '('; + close_char = ')'; + separator_char = ','; + scale_char = ','; + } + + /* The output looks better if we put 7 bytes on a line, since that + puts most long word instructions on a single line. */ + info->bytes_per_line = 7; + + info->private_data = &priv; + priv.max_fetched = priv.the_buffer; + priv.insn_start = pc; + + obuf[0] = 0; + op1out[0] = 0; + op2out[0] = 0; + op3out[0] = 0; + + op_index[0] = op_index[1] = op_index[2] = -1; + + the_info = info; + start_pc = pc; + start_codep = priv.the_buffer; + codep = priv.the_buffer; + +#ifndef __KERNEL__ + if (setjmp (priv.bailout) != 0) + { + const char *name; + + /* Getting here means we tried for data but didn't get it. That + means we have an incomplete instruction of some sort. Just + print the first byte as a prefix or a .byte pseudo-op. */ + if (codep > priv.the_buffer) + { + name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag); + if (name != NULL) + (*info->fprintf_func) (info->stream, "%s", name); + else + { + /* Just print the first byte as a .byte instruction. */ + (*info->fprintf_func) (info->stream, ".byte 0x%x", + (unsigned int) priv.the_buffer[0]); + } + + return 1; + } + + return -1; + } +#endif /* __KERNEL__ */ + + obufp = obuf; + ckprefix (); + + insn_codep = codep; + sizeflag = priv.orig_sizeflag; + + FETCH_DATA (info, codep + 1); + two_source_ops = (*codep == 0x62) || (*codep == 0xc8); + + if ((prefixes & PREFIX_FWAIT) + && ((*codep < 0xd8) || (*codep > 0xdf))) + { + const char *name; + + /* fwait not followed by floating point instruction. Print the + first prefix, which is probably fwait itself. */ + name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag); + if (name == NULL) + name = INTERNAL_DISASSEMBLER_ERROR; + (*info->fprintf_func) (info->stream, "%s", name); + return 1; + } + + if (*codep == 0x0f) + { + FETCH_DATA (info, codep + 2); + dp = &dis386_twobyte[*++codep]; + need_modrm = twobyte_has_modrm[*codep]; + uses_SSE_prefix = twobyte_uses_SSE_prefix[*codep]; + uses_LOCK_prefix = (*codep & ~0x02) == 0x20; + } + else + { + dp = &dis386[*codep]; + need_modrm = onebyte_has_modrm[*codep]; + uses_SSE_prefix = 0; + uses_LOCK_prefix = 0; + } + codep++; + + if (!uses_SSE_prefix && (prefixes & PREFIX_REPZ)) + { + oappend ("repz "); + used_prefixes |= PREFIX_REPZ; + } + if (!uses_SSE_prefix && (prefixes & PREFIX_REPNZ)) + { + oappend ("repnz "); + used_prefixes |= PREFIX_REPNZ; + } + if (!uses_LOCK_prefix && (prefixes & PREFIX_LOCK)) + { + oappend ("lock "); + used_prefixes |= PREFIX_LOCK; + } + + if (prefixes & PREFIX_ADDR) + { + sizeflag ^= AFLAG; + if (dp->bytemode3 != loop_jcxz_mode || intel_syntax) + { + if ((sizeflag & AFLAG) || mode_64bit) + oappend ("addr32 "); + else + oappend ("addr16 "); + used_prefixes |= PREFIX_ADDR; + } + } + + if (!uses_SSE_prefix && (prefixes & PREFIX_DATA)) + { + sizeflag ^= DFLAG; + if (dp->bytemode3 == cond_jump_mode + && dp->bytemode1 == v_mode + && !intel_syntax) + { + if (sizeflag & DFLAG) + oappend ("data32 "); + else + oappend ("data16 "); + used_prefixes |= PREFIX_DATA; + } + } + + if (need_modrm) + { + FETCH_DATA (info, codep + 1); + mod = (*codep >> 6) & 3; + reg = (*codep >> 3) & 7; + rm = *codep & 7; + } + + if (dp->name == NULL && dp->bytemode1 == FLOATCODE) + { + dofloat (sizeflag, stackFrame); + } + else + { + int index; + if (dp->name == NULL) + { + switch (dp->bytemode1) + { + case USE_GROUPS: + dp = &grps[dp->bytemode2][reg]; + break; + + case USE_PREFIX_USER_TABLE: + index = 0; + used_prefixes |= (prefixes & PREFIX_REPZ); + if (prefixes & PREFIX_REPZ) + index = 1; + else + { + used_prefixes |= (prefixes & PREFIX_DATA); + if (prefixes & PREFIX_DATA) + index = 2; + else + { + used_prefixes |= (prefixes & PREFIX_REPNZ); + if (prefixes & PREFIX_REPNZ) + index = 3; + } + } + dp = &prefix_user_table[dp->bytemode2][index]; + break; + + case X86_64_SPECIAL: + dp = &x86_64_table[dp->bytemode2][mode_64bit]; + break; + + default: + oappend (INTERNAL_DISASSEMBLER_ERROR); + break; + } + } + + if (putop (dp->name, sizeflag) == 0) + { + obufp = op1out; + op_ad = 2; + if (dp->op1) + (*dp->op1) (dp->bytemode1, sizeflag, stackFrame); + + obufp = op2out; + op_ad = 1; + if (dp->op2) + (*dp->op2) (dp->bytemode2, sizeflag, stackFrame); + + obufp = op3out; + op_ad = 0; + if (dp->op3) + (*dp->op3) (dp->bytemode3, sizeflag, stackFrame); + } + } + + /* See if any prefixes were not used. If so, print the first one + separately. If we don't do this, we'll wind up printing an + instruction stream which does not precisely correspond to the + bytes we are disassembling. */ + if ((prefixes & ~used_prefixes) != 0) + { + const char *name; + + name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag); + if (name == NULL) + name = INTERNAL_DISASSEMBLER_ERROR; + (*info->fprintf_func) (info->stream, "%s", name); + return 1; + } + if (rex & ~rex_used) + { + const char *name; + name = prefix_name (rex | 0x40, priv.orig_sizeflag); + if (name == NULL) + name = INTERNAL_DISASSEMBLER_ERROR; + (*info->fprintf_func) (info->stream, "%s ", name); + } + + obufp = obuf + strlen (obuf); + for (i = strlen (obuf); i < 6; i++) + oappend (" "); + oappend (" "); + (*info->fprintf_func) (info->stream, "%s", obuf); + + /* The enter and bound instructions are printed with operands in the same + order as the intel book; everything else is printed in reverse order. */ + if (intel_syntax || two_source_ops) + { + first = op1out; + second = op2out; + third = op3out; + op_ad = op_index[0]; + op_index[0] = op_index[2]; + op_index[2] = op_ad; + } + else + { + first = op3out; + second = op2out; + third = op1out; + } + needcomma = 0; + if (*first) + { + if (op_index[0] != -1 && !op_riprel[0]) + { + (*info->print_address_func) ((bfd_vma) op_address[op_index[0]], info); +#ifdef MDB_ENHANCEMENTS + if (intel_syntax || two_source_ops) + output_jmp_address(stackFrame, op_address[op_index[0]], obuf, info); +#endif + } + else + (*info->fprintf_func) (info->stream, "%s", first); + needcomma = 1; + } + if (*second) + { + if (needcomma) + (*info->fprintf_func) (info->stream, ","); + if (op_index[1] != -1 && !op_riprel[1]) + { + (*info->fprintf_func) (info->stream, "S:"); + (*info->print_address_func) ((bfd_vma) op_address[op_index[1]], info); + } + else + (*info->fprintf_func) (info->stream, "%s", second); + needcomma = 1; + } + if (*third) + { + if (needcomma) + (*info->fprintf_func) (info->stream, ","); + if (op_index[2] != -1 && !op_riprel[2]) + { + (*info->print_address_func) ((bfd_vma) op_address[op_index[2]], info); +#ifdef MDB_ENHANCEMENTS + if (!intel_syntax && !two_source_ops) + output_jmp_address(stackFrame, op_address[op_index[0]], obuf, info); +#endif + } + else + (*info->fprintf_func) (info->stream, "%s", third); + } + for (i = 0; i < 3; i++) + if (op_index[i] != -1 && op_riprel[i]) + { + (*info->fprintf_func) (info->stream, " # "); + (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep + + op_address[op_index[i]]), info); + } + return codep - priv.the_buffer; +} + +static const char *float_mem[] = { + /* d8 */ + "fadd{s||s|}", + "fmul{s||s|}", + "fcom{s||s|}", + "fcomp{s||s|}", + "fsub{s||s|}", + "fsubr{s||s|}", + "fdiv{s||s|}", + "fdivr{s||s|}", + /* d9 */ + "fld{s||s|}", + "(bad)", + "fst{s||s|}", + "fstp{s||s|}", + "fldenvIC", + "fldcw", + "fNstenvIC", + "fNstcw", + /* da */ + "fiadd{l||l|}", + "fimul{l||l|}", + "ficom{l||l|}", + "ficomp{l||l|}", + "fisub{l||l|}", + "fisubr{l||l|}", + "fidiv{l||l|}", + "fidivr{l||l|}", + /* db */ + "fild{l||l|}", + "fisttp{l||l|}", + "fist{l||l|}", + "fistp{l||l|}", + "(bad)", + "fld{t||t|}", + "(bad)", + "fstp{t||t|}", + /* dc */ + "fadd{l||l|}", + "fmul{l||l|}", + "fcom{l||l|}", + "fcomp{l||l|}", + "fsub{l||l|}", + "fsubr{l||l|}", + "fdiv{l||l|}", + "fdivr{l||l|}", + /* dd */ + "fld{l||l|}", + "fisttp{ll||ll|}", + "fst{l||l|}", + "fstp{l||l|}", + "frstorIC", + "(bad)", + "fNsaveIC", + "fNstsw", + /* de */ + "fiadd", + "fimul", + "ficom", + "ficomp", + "fisub", + "fisubr", + "fidiv", + "fidivr", + /* df */ + "fild", + "fisttp", + "fist", + "fistp", + "fbld", + "fild{ll||ll|}", + "fbstp", + "fistp{ll||ll|}", +}; + +static const unsigned char float_mem_mode[] = { + /* d8 */ + d_mode, + d_mode, + d_mode, + d_mode, + d_mode, + d_mode, + d_mode, + d_mode, + /* d9 */ + d_mode, + 0, + d_mode, + d_mode, + 0, + w_mode, + 0, + w_mode, + /* da */ + d_mode, + d_mode, + d_mode, + d_mode, + d_mode, + d_mode, + d_mode, + d_mode, + /* db */ + d_mode, + d_mode, + d_mode, + d_mode, + 0, + t_mode, + 0, + t_mode, + /* dc */ + q_mode, + q_mode, + q_mode, + q_mode, + q_mode, + q_mode, + q_mode, + q_mode, + /* dd */ + q_mode, + q_mode, + q_mode, + q_mode, + 0, + 0, + 0, + w_mode, + /* de */ + w_mode, + w_mode, + w_mode, + w_mode, + w_mode, + w_mode, + w_mode, + w_mode, + /* df */ + w_mode, + w_mode, + w_mode, + w_mode, + t_mode, + q_mode, + t_mode, + q_mode +}; + +#define ST OP_ST, 0 +#define STi OP_STi, 0 + +#define FGRPd9_2 NULL, NULL, 0, NULL, 0, NULL, 0 +#define FGRPd9_4 NULL, NULL, 1, NULL, 0, NULL, 0 +#define FGRPd9_5 NULL, NULL, 2, NULL, 0, NULL, 0 +#define FGRPd9_6 NULL, NULL, 3, NULL, 0, NULL, 0 +#define FGRPd9_7 NULL, NULL, 4, NULL, 0, NULL, 0 +#define FGRPda_5 NULL, NULL, 5, NULL, 0, NULL, 0 +#define FGRPdb_4 NULL, NULL, 6, NULL, 0, NULL, 0 +#define FGRPde_3 NULL, NULL, 7, NULL, 0, NULL, 0 +#define FGRPdf_4 NULL, NULL, 8, NULL, 0, NULL, 0 + +static const struct dis386 float_reg[][8] = { + /* d8 */ + { + { "fadd", ST, STi, XX }, + { "fmul", ST, STi, XX }, + { "fcom", STi, XX, XX }, + { "fcomp", STi, XX, XX }, + { "fsub", ST, STi, XX }, + { "fsubr", ST, STi, XX }, + { "fdiv", ST, STi, XX }, + { "fdivr", ST, STi, XX }, + }, + /* d9 */ + { + { "fld", STi, XX, XX }, + { "fxch", STi, XX, XX }, + { FGRPd9_2 }, + { "(bad)", XX, XX, XX }, + { FGRPd9_4 }, + { FGRPd9_5 }, + { FGRPd9_6 }, + { FGRPd9_7 }, + }, + /* da */ + { + { "fcmovb", ST, STi, XX }, + { "fcmove", ST, STi, XX }, + { "fcmovbe",ST, STi, XX }, + { "fcmovu", ST, STi, XX }, + { "(bad)", XX, XX, XX }, + { FGRPda_5 }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + }, + /* db */ + { + { "fcmovnb",ST, STi, XX }, + { "fcmovne",ST, STi, XX }, + { "fcmovnbe",ST, STi, XX }, + { "fcmovnu",ST, STi, XX }, + { FGRPdb_4 }, + { "fucomi", ST, STi, XX }, + { "fcomi", ST, STi, XX }, + { "(bad)", XX, XX, XX }, + }, + /* dc */ + { + { "fadd", STi, ST, XX }, + { "fmul", STi, ST, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, +#if UNIXWARE_COMPAT + { "fsub", STi, ST, XX }, + { "fsubr", STi, ST, XX }, + { "fdiv", STi, ST, XX }, + { "fdivr", STi, ST, XX }, +#else + { "fsubr", STi, ST, XX }, + { "fsub", STi, ST, XX }, + { "fdivr", STi, ST, XX }, + { "fdiv", STi, ST, XX }, +#endif + }, + /* dd */ + { + { "ffree", STi, XX, XX }, + { "(bad)", XX, XX, XX }, + { "fst", STi, XX, XX }, + { "fstp", STi, XX, XX }, + { "fucom", STi, XX, XX }, + { "fucomp", STi, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + }, + /* de */ + { + { "faddp", STi, ST, XX }, + { "fmulp", STi, ST, XX }, + { "(bad)", XX, XX, XX }, + { FGRPde_3 }, +#if UNIXWARE_COMPAT + { "fsubp", STi, ST, XX }, + { "fsubrp", STi, ST, XX }, + { "fdivp", STi, ST, XX }, + { "fdivrp", STi, ST, XX }, +#else + { "fsubrp", STi, ST, XX }, + { "fsubp", STi, ST, XX }, + { "fdivrp", STi, ST, XX }, + { "fdivp", STi, ST, XX }, +#endif + }, + /* df */ + { + { "ffreep", STi, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { "(bad)", XX, XX, XX }, + { FGRPdf_4 }, + { "fucomip",ST, STi, XX }, + { "fcomip", ST, STi, XX }, + { "(bad)", XX, XX, XX }, + }, +}; + +static char *fgrps[][8] = { + /* d9_2 0 */ + { + "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", + }, + + /* d9_4 1 */ + { + "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)", + }, + + /* d9_5 2 */ + { + "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)", + }, + + /* d9_6 3 */ + { + "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp", + }, + + /* d9_7 4 */ + { + "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos", + }, + + /* da_5 5 */ + { + "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", + }, + + /* db_4 6 */ + { + "feni(287 only)","fdisi(287 only)","fNclex","fNinit", + "fNsetpm(287 only)","(bad)","(bad)","(bad)", + }, + + /* de_3 7 */ + { + "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", + }, + + /* df_4 8 */ + { + "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", + }, +}; + +static void +dofloat (int sizeflag, StackFrame *stackFrame) +{ + const struct dis386 *dp; + unsigned char floatop; + + floatop = codep[-1]; + + if (mod != 3) + { + int fp_indx = (floatop - 0xd8) * 8 + reg; + + putop (float_mem[fp_indx], sizeflag); + obufp = op1out; + OP_E (float_mem_mode[fp_indx], sizeflag, stackFrame); + return; + } + /* Skip mod/rm byte. */ + MODRM_CHECK; + codep++; + + dp = &float_reg[floatop - 0xd8][reg]; + if (dp->name == NULL) + { + putop (fgrps[dp->bytemode1][rm], sizeflag); + + /* Instruction fnstsw is only one with strange arg. */ + if (floatop == 0xdf && codep[-1] == 0xe0) + strcpy (op1out, names16[0]); + } + else + { + putop (dp->name, sizeflag); + + obufp = op1out; + if (dp->op1) + (*dp->op1) (dp->bytemode1, sizeflag, stackFrame); + obufp = op2out; + if (dp->op2) + (*dp->op2) (dp->bytemode2, sizeflag, stackFrame); + } +} + +static void +OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED, + StackFrame *stackFrame) +{ + oappend ("%st"); +} + +static void +OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED, + StackFrame *stackFrame) +{ + sprintf (scratchbuf, "%%st(%d)", rm); + oappend (scratchbuf + intel_syntax); +} + +/* Capital letters in template are macros. */ +static int +putop (const char *template, int sizeflag) +{ + const char *p; + int alt = 0; + + for (p = template; *p; p++) + { + switch (*p) + { + default: + *obufp++ = *p; + break; + case '{': + alt = 0; + if (intel_syntax) + alt += 1; + if (mode_64bit) + alt += 2; + while (alt != 0) + { + while (*++p != '|') + { + if (*p == '}') + { + /* Alternative not valid. */ + strcpy (obuf, "(bad)"); + obufp = obuf + 5; + return 1; + } + else if (*p == '\0') + abort (); + } + alt--; + } + /* Fall through. */ + case 'I': + alt = 1; + continue; + case '|': + while (*++p != '}') + { + if (*p == '\0') + abort (); + } + break; + case '}': + break; + case 'A': + if (intel_syntax) + break; + if (mod != 3 || (sizeflag & SUFFIX_ALWAYS)) + *obufp++ = 'b'; + break; + case 'B': + if (intel_syntax) + break; + if (sizeflag & SUFFIX_ALWAYS) + *obufp++ = 'b'; + break; + case 'C': + if (intel_syntax && !alt) + break; + if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS)) + { + if (sizeflag & DFLAG) + *obufp++ = intel_syntax ? 'd' : 'l'; + else + *obufp++ = intel_syntax ? 'w' : 's'; + used_prefixes |= (prefixes & PREFIX_DATA); + } + break; + case 'E': /* For jcxz/jecxz */ + if (mode_64bit) + { + if (sizeflag & AFLAG) + *obufp++ = 'r'; + else + *obufp++ = 'e'; + } + else + if (sizeflag & AFLAG) + *obufp++ = 'e'; + used_prefixes |= (prefixes & PREFIX_ADDR); + break; + case 'F': + if (intel_syntax) + break; + if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS)) + { + if (sizeflag & AFLAG) + *obufp++ = mode_64bit ? 'q' : 'l'; + else + *obufp++ = mode_64bit ? 'l' : 'w'; + used_prefixes |= (prefixes & PREFIX_ADDR); + } + break; + case 'H': + if (intel_syntax) + break; + if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS + || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS) + { + used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS); + *obufp++ = ','; + *obufp++ = 'p'; + if (prefixes & PREFIX_DS) + *obufp++ = 't'; + else + *obufp++ = 'n'; + } + break; + case 'J': + if (intel_syntax) + break; + *obufp++ = 'l'; + break; + case 'L': + if (intel_syntax) + break; + if (sizeflag & SUFFIX_ALWAYS) + *obufp++ = 'l'; + break; + case 'N': + if ((prefixes & PREFIX_FWAIT) == 0) + *obufp++ = 'n'; + else + used_prefixes |= PREFIX_FWAIT; + break; + case 'O': + USED_REX (REX_MODE64); + if (rex & REX_MODE64) + *obufp++ = 'o'; + else + *obufp++ = 'd'; + break; + case 'T': + if (intel_syntax) + break; + if (mode_64bit) + { + *obufp++ = 'q'; + break; + } + /* Fall through. */ + case 'P': + if (intel_syntax) + break; + if ((prefixes & PREFIX_DATA) + || (rex & REX_MODE64) + || (sizeflag & SUFFIX_ALWAYS)) + { + USED_REX (REX_MODE64); + if (rex & REX_MODE64) + *obufp++ = 'q'; + else + { + if (sizeflag & DFLAG) + *obufp++ = 'l'; + else + *obufp++ = 'w'; + used_prefixes |= (prefixes & PREFIX_DATA); + } + } + break; + case 'U': + if (intel_syntax) + break; + if (mode_64bit) + { + *obufp++ = 'q'; + break; + } + /* Fall through. */ + case 'Q': + if (intel_syntax && !alt) + break; + USED_REX (REX_MODE64); + if (mod != 3 || (sizeflag & SUFFIX_ALWAYS)) + { + if (rex & REX_MODE64) + *obufp++ = 'q'; + else + { + if (sizeflag & DFLAG) + *obufp++ = intel_syntax ? 'd' : 'l'; + else + *obufp++ = 'w'; + used_prefixes |= (prefixes & PREFIX_DATA); + } + } + break; + case 'R': + USED_REX (REX_MODE64); + if (intel_syntax) + { + if (rex & REX_MODE64) + { + *obufp++ = 'q'; + *obufp++ = 't'; + } + else if (sizeflag & DFLAG) + { + *obufp++ = 'd'; + *obufp++ = 'q'; + } + else + { + *obufp++ = 'w'; + *obufp++ = 'd'; + } + } + else + { + if (rex & REX_MODE64) + *obufp++ = 'q'; + else if (sizeflag & DFLAG) + *obufp++ = 'l'; + else + *obufp++ = 'w'; + } + if (!(rex & REX_MODE64)) + used_prefixes |= (prefixes & PREFIX_DATA); + break; + case 'S': + if (intel_syntax) + break; + if (sizeflag & SUFFIX_ALWAYS) + { + if (rex & REX_MODE64) + *obufp++ = 'q'; + else + { + if (sizeflag & DFLAG) + *obufp++ = 'l'; + else + *obufp++ = 'w'; + used_prefixes |= (prefixes & PREFIX_DATA); + } + } + break; + case 'X': + if (prefixes & PREFIX_DATA) + *obufp++ = 'd'; + else + *obufp++ = 's'; + used_prefixes |= (prefixes & PREFIX_DATA); + break; + case 'Y': + if (intel_syntax) + break; + if (rex & REX_MODE64) + { + USED_REX (REX_MODE64); + *obufp++ = 'q'; + } + break; + /* implicit operand size 'l' for i386 or 'q' for x86-64 */ + case 'W': + /* operand size flag for cwtl, cbtw */ + USED_REX (0); + if (rex) + *obufp++ = 'l'; + else if (sizeflag & DFLAG) + *obufp++ = 'w'; + else + *obufp++ = 'b'; + if (intel_syntax) + { + if (rex) + { + *obufp++ = 'q'; + *obufp++ = 'e'; + } + if (sizeflag & DFLAG) + { + *obufp++ = 'd'; + *obufp++ = 'e'; + } + else + { + *obufp++ = 'w'; + } + } + if (!rex) + used_prefixes |= (prefixes & PREFIX_DATA); + break; + } + alt = 0; + } + *obufp = 0; + return 0; +} + +static void +oappend (const char *s) +{ + strcpy (obufp, s); + obufp += strlen (s); +} + +static void +append_seg (void) +{ + if (prefixes & PREFIX_CS) + { + used_prefixes |= PREFIX_CS; + oappend ("%cs:" + intel_syntax); + } + if (prefixes & PREFIX_DS) + { + used_prefixes |= PREFIX_DS; + oappend ("%ds:" + intel_syntax); + } + if (prefixes & PREFIX_SS) + { + used_prefixes |= PREFIX_SS; + oappend ("%ss:" + intel_syntax); + } + if (prefixes & PREFIX_ES) + { + used_prefixes |= PREFIX_ES; + oappend ("%es:" + intel_syntax); + } + if (prefixes & PREFIX_FS) + { + used_prefixes |= PREFIX_FS; + oappend ("%fs:" + intel_syntax); + } + if (prefixes & PREFIX_GS) + { + used_prefixes |= PREFIX_GS; + oappend ("%gs:" + intel_syntax); + } +} + +static void +OP_indirE (int bytemode, int sizeflag, StackFrame *stackFrame) +{ + if (!intel_syntax) + oappend ("*"); + OP_E (bytemode, sizeflag, stackFrame); +} + +static void +print_operand_value (char *buf, int hex, bfd_vma disp) +{ + if (mode_64bit) + { + if (hex) + { + char tmp[30]; + int i; + buf[0] = '0'; + buf[1] = 'x'; + sprintf_vma (tmp, disp); + for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++); + strcpy (buf + 2, tmp + i); + } + else + { + bfd_signed_vma v = disp; + char tmp[30]; + int i; + if (v < 0) + { + *(buf++) = '-'; + v = -disp; + /* Check for possible overflow on 0x8000000000000000. */ + if (v < 0) + { + strcpy (buf, "9223372036854775808"); + return; + } + } + if (!v) + { + strcpy (buf, "0"); + return; + } + + i = 0; + tmp[29] = 0; + while (v) + { + tmp[28 - i] = (v % 10) + '0'; + v /= 10; + i++; + } + strcpy (buf, tmp + 29 - i); + } + } + else + { + if (hex) + sprintf (buf, "0x%x", (unsigned int) disp); + else + sprintf (buf, "%d", (int) disp); + } +} + +static void +OP_E (int bytemode, int sizeflag, StackFrame *stackFrame) +{ + unsigned char *deref; + + bfd_vma disp; + int add = 0; + int riprel = 0; + USED_REX (REX_EXTZ); + if (rex & REX_EXTZ) + add += 8; + + /* Skip mod/rm byte. */ + MODRM_CHECK; + codep++; + + if (mod == 3) + { + switch (bytemode) + { + case b_mode: + USED_REX (0); + if (rex) + oappend (names8rex[rm + add]); + else + oappend (names8[rm + add]); + break; + case w_mode: + oappend (names16[rm + add]); + break; + case d_mode: + oappend (names32[rm + add]); + break; + case q_mode: + oappend (names64[rm + add]); + break; + case m_mode: + if (mode_64bit) + oappend (names64[rm + add]); + else + oappend (names32[rm + add]); + break; + case branch_v_mode: + if (mode_64bit) + oappend (names64[rm + add]); + else + { + if ((sizeflag & DFLAG) || bytemode != branch_v_mode) + oappend (names32[rm + add]); + else + oappend (names16[rm + add]); + used_prefixes |= (prefixes & PREFIX_DATA); + } + break; + case v_mode: + case dq_mode: + case dqw_mode: + USED_REX (REX_MODE64); + if (rex & REX_MODE64) + oappend (names64[rm + add]); + else if ((sizeflag & DFLAG) || bytemode != v_mode) + oappend (names32[rm + add]); + else + oappend (names16[rm + add]); + used_prefixes |= (prefixes & PREFIX_DATA); + break; + case 0: + break; + default: + oappend (INTERNAL_DISASSEMBLER_ERROR); + break; + } + return; + } + + disp = 0; + append_seg (); + + if ((sizeflag & AFLAG) || mode_64bit) /* 32 bit address mode */ + { + int havesib; + int havebase; + int base; + int index = 0; + int scale = 0; + + havesib = 0; + havebase = 1; + base = rm; + + if (base == 4) + { + havesib = 1; + FETCH_DATA (the_info, codep + 1); + index = (*codep >> 3) & 7; + if (mode_64bit || index != 0x4) + /* When INDEX == 0x4 in 32 bit mode, SCALE is ignored. */ + scale = (*codep >> 6) & 3; + base = *codep & 7; + USED_REX (REX_EXTY); + if (rex & REX_EXTY) + index += 8; + codep++; + } + base += add; + + switch (mod) + { + case 0: + if ((base & 7) == 5) + { + havebase = 0; + if (mode_64bit && !havesib) + riprel = 1; + disp = get32s (); + } + break; + case 1: + FETCH_DATA (the_info, codep + 1); + disp = *codep++; + if ((disp & 0x80) != 0) + disp -= 0x100; + break; + case 2: + disp = get32s (); + break; + } + + if (!intel_syntax) + if (mod != 0 || (base & 7) == 5) + { + print_operand_value (scratchbuf, !riprel, disp); + oappend (scratchbuf); + if (riprel) + { + set_op (disp, 1); + oappend ("(%rip)"); + } + } + + if (havebase || (havesib && (index != 4 || scale != 0))) + { + if (intel_syntax) + { + switch (bytemode) + { + case b_mode: + oappend ("BYTE PTR "); + break; + case w_mode: + case dqw_mode: + oappend ("WORD PTR "); + break; + case branch_v_mode: + case v_mode: + case dq_mode: + USED_REX (REX_MODE64); + if (rex & REX_MODE64) + oappend ("QWORD PTR "); + else if ((sizeflag & DFLAG) || bytemode == dq_mode) + oappend ("DWORD PTR "); + else + oappend ("WORD PTR "); + used_prefixes |= (prefixes & PREFIX_DATA); + break; + case d_mode: + oappend ("DWORD PTR "); + break; + case q_mode: + oappend ("QWORD PTR "); + break; + case m_mode: + if (mode_64bit) + oappend ("QWORD PTR "); + else + oappend ("DWORD PTR "); + break; + case f_mode: + if (sizeflag & DFLAG) + { + used_prefixes |= (prefixes & PREFIX_DATA); + oappend ("FWORD PTR "); + } + else + oappend ("DWORD PTR "); + break; + case t_mode: + oappend ("TBYTE PTR "); + break; + case x_mode: + oappend ("XMMWORD PTR "); + break; + default: + break; + } + } + + // begin dereference + deref = obufp; + *obufp++ = open_char; + if (intel_syntax && riprel) + oappend ("rip + "); + *obufp = '\0'; + if (havebase) + { + oappend (mode_64bit && (sizeflag & AFLAG) + ? names64[base] : names32[base]); + } + if (havesib) + { + if (index != 4) + { + if (!intel_syntax || havebase) + { + *obufp++ = separator_char; + *obufp = '\0'; + } + // check the bottom case and bracket if true + if (scale != 0) + *obufp++ = '('; + oappend (mode_64bit && (sizeflag & AFLAG) + ? names64[index] : names32[index]); + } + if (scale != 0 || (!intel_syntax && index != 4)) + { + *obufp++ = scale_char; + *obufp = '\0'; + sprintf (scratchbuf, "%d", 1 << scale); + oappend (scratchbuf); + + // if we fell through the top case, close the bracket + if (index != 4) + *obufp++ = ')'; + } + + } + if (intel_syntax && disp) + { + if ((bfd_signed_vma) disp > 0) + { + *obufp++ = '+'; + *obufp = '\0'; + } + else if (mod != 1) + { + *obufp++ = '-'; + *obufp = '\0'; + disp = - (bfd_signed_vma) disp; + } + + print_operand_value (scratchbuf, mod != 1, disp); + oappend (scratchbuf); + } + + // end dereference + *obufp++ = close_char; + *obufp = '\0'; +#ifdef MDB_ENHANCEMENTS + if (intel_syntax) + evaluate_expression(bytemode, sizeflag, deref, stackFrame); +#endif + } + else if (intel_syntax) + { + if (mod != 0 || (base & 7) == 5) + { +#ifdef MDB_ENHANCEMENTS + if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS + | PREFIX_ES | PREFIX_FS | PREFIX_GS)) + { + if (!evaluate_address_expression(bytemode, sizeflag, disp, 0, + stackFrame, NULL)) + { + print_operand_value (scratchbuf, 1, disp); + oappend (scratchbuf); + } + } + else + { + if (!evaluate_address_expression(bytemode, sizeflag, disp, 0, + stackFrame, + names_seg[ds_reg - es_reg])) + { + print_operand_value (scratchbuf, 1, disp); + oappend (scratchbuf); + } + } +#else + if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS + | PREFIX_ES | PREFIX_FS | PREFIX_GS)) + ; + else + { + oappend (names_seg[ds_reg - es_reg]); + oappend (":"); + } + print_operand_value (scratchbuf, 1, disp); + oappend (scratchbuf); +#endif + } + } + } + else + { /* 16 bit address mode */ + switch (mod) + { + case 0: + if (rm == 6) + { + disp = get16 (); + if ((disp & 0x8000) != 0) + disp -= 0x10000; + } + break; + case 1: + FETCH_DATA (the_info, codep + 1); + disp = *codep++; + if ((disp & 0x80) != 0) + disp -= 0x100; + break; + case 2: + disp = get16 (); + if ((disp & 0x8000) != 0) + disp -= 0x10000; + break; + } + + if (!intel_syntax) + if (mod != 0 || rm == 6) + { + print_operand_value (scratchbuf, 0, disp); + oappend (scratchbuf); + } + + if (mod != 0 || rm != 6) + { + // begin dereference + deref = obufp; + *obufp++ = open_char; + *obufp = '\0'; + oappend (index16[rm]); + if (intel_syntax && disp) + { + if ((bfd_signed_vma) disp > 0) + { + *obufp++ = '+'; + *obufp = '\0'; + } + else if (mod != 1) + { + *obufp++ = '-'; + *obufp = '\0'; + disp = - (bfd_signed_vma) disp; + } + + print_operand_value (scratchbuf, mod != 1, disp); + oappend (scratchbuf); + } + + // end dereference + *obufp++ = close_char; + *obufp = '\0'; +#ifdef MDB_ENHANCEMENTS + if (intel_syntax) + evaluate_expression(bytemode, sizeflag, deref, stackFrame); +#endif + } + else if (intel_syntax) + { +#ifdef MDB_ENHANCEMENTS + if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS + | PREFIX_ES | PREFIX_FS | PREFIX_GS)) + { + if (!evaluate_address_expression(bytemode, sizeflag, disp, + 0xFFFF, stackFrame, NULL)) + { + print_operand_value (scratchbuf, 1, disp & 0xFFFF); + oappend (scratchbuf); + } + } + else + { + if (!evaluate_address_expression(bytemode, sizeflag, disp, + 0xFFFF, stackFrame, + names_seg[ds_reg - es_reg])) + { + print_operand_value (scratchbuf, 1, disp & 0xFFFF); + oappend (scratchbuf); + } + } +#else + if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS + | PREFIX_ES | PREFIX_FS | PREFIX_GS)) + ; + else + { + oappend (names_seg[ds_reg - es_reg]); + oappend (":"); + } + print_operand_value (scratchbuf, 1, disp & 0xFFFF); + oappend (scratchbuf); +#endif + } + } +} + +static void +OP_G (int bytemode, int sizeflag, + StackFrame *stackFrame) +{ + int add = 0; + USED_REX (REX_EXTX); + if (rex & REX_EXTX) + add += 8; + switch (bytemode) + { + case b_mode: + USED_REX (0); + if (rex) + oappend (names8rex[reg + add]); + else + oappend (names8[reg + add]); + break; + case w_mode: + oappend (names16[reg + add]); + break; + case d_mode: + oappend (names32[reg + add]); + break; + case q_mode: + oappend (names64[reg + add]); + break; + case v_mode: + case dq_mode: + case dqw_mode: + USED_REX (REX_MODE64); + if (rex & REX_MODE64) + oappend (names64[reg + add]); + else if ((sizeflag & DFLAG) || bytemode != v_mode) + oappend (names32[reg + add]); + else + oappend (names16[reg + add]); + used_prefixes |= (prefixes & PREFIX_DATA); + break; + case m_mode: + if (mode_64bit) + oappend (names64[reg + add]); + else + oappend (names32[reg + add]); + break; + default: + oappend (INTERNAL_DISASSEMBLER_ERROR); + break; + } +} + +static bfd_vma +get64 (void) +{ + bfd_vma x; +#ifdef BFD64 + unsigned int a; + unsigned int b; + + FETCH_DATA (the_info, codep + 8); + a = *codep++ & 0xff; + a |= (*codep++ & 0xff) << 8; + a |= (*codep++ & 0xff) << 16; + a |= (*codep++ & 0xff) << 24; + b = *codep++ & 0xff; + b |= (*codep++ & 0xff) << 8; + b |= (*codep++ & 0xff) << 16; + b |= (*codep++ & 0xff) << 24; + x = a + ((bfd_vma) b << 32); +#else + abort (); + x = 0; +#endif + return x; +} + +static bfd_signed_vma +get32 (void) +{ + bfd_signed_vma x = 0; + + FETCH_DATA (the_info, codep + 4); + x = *codep++ & (bfd_signed_vma) 0xff; + x |= (*codep++ & (bfd_signed_vma) 0xff) << 8; + x |= (*codep++ & (bfd_signed_vma) 0xff) << 16; + x |= (*codep++ & (bfd_signed_vma) 0xff) << 24; + return x; +} + +static bfd_signed_vma +get32s (void) +{ + bfd_signed_vma x = 0; + + FETCH_DATA (the_info, codep + 4); + x = *codep++ & (bfd_signed_vma) 0xff; + x |= (*codep++ & (bfd_signed_vma) 0xff) << 8; + x |= (*codep++ & (bfd_signed_vma) 0xff) << 16; + x |= (*codep++ & (bfd_signed_vma) 0xff) << 24; + + x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31); + + return x; +} + +static int +get16 (void) +{ + int x = 0; + + FETCH_DATA (the_info, codep + 2); + x = *codep++ & 0xff; + x |= (*codep++ & 0xff) << 8; + return x; +} + +static void +set_op (bfd_vma op, int riprel) +{ + op_index[op_ad] = op_ad; + if (mode_64bit) + { + op_address[op_ad] = op; + op_riprel[op_ad] = riprel; + } + else + { + /* Mask to get a 32-bit address. */ + op_address[op_ad] = op & 0xffffffff; + op_riprel[op_ad] = riprel & 0xffffffff; + } +} + +static void +OP_REG (int code, int sizeflag, + StackFrame *stackFrame) +{ + const char *s; + int add = 0; + USED_REX (REX_EXTZ); + if (rex & REX_EXTZ) + add = 8; + + switch (code) + { + case indir_dx_reg: + if (intel_syntax) + s = "[dx]"; + else + s = "(%dx)"; + break; + case ax_reg: case cx_reg: case dx_reg: case bx_reg: + case sp_reg: case bp_reg: case si_reg: case di_reg: + s = names16[code - ax_reg + add]; + break; + case es_reg: case ss_reg: case cs_reg: + case ds_reg: case fs_reg: case gs_reg: + s = names_seg[code - es_reg + add]; + break; + case al_reg: case ah_reg: case cl_reg: case ch_reg: + case dl_reg: case dh_reg: case bl_reg: case bh_reg: + USED_REX (0); + if (rex) + s = names8rex[code - al_reg + add]; + else + s = names8[code - al_reg]; + break; + case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg: + case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg: + if (mode_64bit) + { + s = names64[code - rAX_reg + add]; + break; + } + code += eAX_reg - rAX_reg; + /* Fall through. */ + case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg: + case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg: + USED_REX (REX_MODE64); + if (rex & REX_MODE64) + s = names64[code - eAX_reg + add]; + else if (sizeflag & DFLAG) + s = names32[code - eAX_reg + add]; + else + s = names16[code - eAX_reg + add]; + used_prefixes |= (prefixes & PREFIX_DATA); + break; + default: + s = INTERNAL_DISASSEMBLER_ERROR; + break; + } + oappend (s); +} + +static void +OP_IMREG (int code, int sizeflag, + StackFrame *stackFrame) +{ + const char *s; + + switch (code) + { + case indir_dx_reg: + if (intel_syntax) + s = "[dx]"; + else + s = "(%dx)"; + break; + case ax_reg: case cx_reg: case dx_reg: case bx_reg: + case sp_reg: case bp_reg: case si_reg: case di_reg: + s = names16[code - ax_reg]; + break; + case es_reg: case ss_reg: case cs_reg: + case ds_reg: case fs_reg: case gs_reg: + s = names_seg[code - es_reg]; + break; + case al_reg: case ah_reg: case cl_reg: case ch_reg: + case dl_reg: case dh_reg: case bl_reg: case bh_reg: + USED_REX (0); + if (rex) + s = names8rex[code - al_reg]; + else + s = names8[code - al_reg]; + break; + case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg: + case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg: + USED_REX (REX_MODE64); + if (rex & REX_MODE64) + s = names64[code - eAX_reg]; + else if (sizeflag & DFLAG) + s = names32[code - eAX_reg]; + else + s = names16[code - eAX_reg]; + used_prefixes |= (prefixes & PREFIX_DATA); + break; + default: + s = INTERNAL_DISASSEMBLER_ERROR; + break; + } + oappend (s); +} + +static void +OP_I (int bytemode, int sizeflag, + StackFrame *stackFrame) +{ + bfd_signed_vma op; + bfd_signed_vma mask = -1; + + switch (bytemode) + { + case b_mode: + FETCH_DATA (the_info, codep + 1); + op = *codep++; + mask = 0xff; + break; + case q_mode: + if (mode_64bit) + { + op = get32s (); + break; + } + /* Fall through. */ + case v_mode: + USED_REX (REX_MODE64); + if (rex & REX_MODE64) + op = get32s (); + else if (sizeflag & DFLAG) + { + op = get32 (); + mask = 0xffffffff; + } + else + { + op = get16 (); + mask = 0xfffff; + } + used_prefixes |= (prefixes & PREFIX_DATA); + break; + case w_mode: + mask = 0xfffff; + op = get16 (); + break; + case const_1_mode: + if (intel_syntax) + oappend ("1"); + return; + default: + oappend (INTERNAL_DISASSEMBLER_ERROR); + return; + } + + op &= mask; + scratchbuf[0] = '$'; + print_operand_value (scratchbuf + 1, 1, op); + oappend (scratchbuf + intel_syntax); + scratchbuf[0] = '\0'; +} + +static void +OP_I64 (int bytemode, int sizeflag, + StackFrame *stackFrame) +{ + bfd_signed_vma op; + bfd_signed_vma mask = -1; + + if (!mode_64bit) + { + OP_I (bytemode, sizeflag, stackFrame); + return; + } + + switch (bytemode) + { + case b_mode: + FETCH_DATA (the_info, codep + 1); + op = *codep++; + mask = 0xff; + break; + case v_mode: + USED_REX (REX_MODE64); + if (rex & REX_MODE64) + op = get64 (); + else if (sizeflag & DFLAG) + { + op = get32 (); + mask = 0xffffffff; + } + else + { + op = get16 (); + mask = 0xfffff; + } + used_prefixes |= (prefixes & PREFIX_DATA); + break; + case w_mode: + mask = 0xfffff; + op = get16 (); + break; + default: + oappend (INTERNAL_DISASSEMBLER_ERROR); + return; + } + + op &= mask; + scratchbuf[0] = '$'; + print_operand_value (scratchbuf + 1, 1, op); + oappend (scratchbuf + intel_syntax); + scratchbuf[0] = '\0'; +} + +static void +OP_sI (int bytemode, int sizeflag, + StackFrame *stackFrame) +{ + bfd_signed_vma op; + bfd_signed_vma mask = -1; + + switch (bytemode) + { + case b_mode: + FETCH_DATA (the_info, codep + 1); + op = *codep++; + if ((op & 0x80) != 0) + op -= 0x100; + mask = 0xffffffff; + break; + case v_mode: + USED_REX (REX_MODE64); + if (rex & REX_MODE64) + op = get32s (); + else if (sizeflag & DFLAG) + { + op = get32s (); + mask = 0xffffffff; + } + else + { + mask = 0xffffffff; + op = get16 (); + if ((op & 0x8000) != 0) + op -= 0x10000; + } + used_prefixes |= (prefixes & PREFIX_DATA); + break; + case w_mode: + op = get16 (); + mask = 0xffffffff; + if ((op & 0x8000) != 0) + op -= 0x10000; + break; + default: + oappend (INTERNAL_DISASSEMBLER_ERROR); + return; + } + + scratchbuf[0] = '$'; + print_operand_value (scratchbuf + 1, 1, op); + oappend (scratchbuf + intel_syntax); +} + +static void +OP_J (int bytemode, int sizeflag, + StackFrame *stackFrame) +{ + bfd_vma disp; + bfd_vma mask = -1; + + switch (bytemode) + { + case b_mode: + FETCH_DATA (the_info, codep + 1); + disp = *codep++; + if ((disp & 0x80) != 0) + disp -= 0x100; + break; + case v_mode: + if (sizeflag & DFLAG) + disp = get32s (); + else + { + disp = get16 (); + /* For some reason, a data16 prefix on a jump instruction + means that the pc is masked to 16 bits after the + displacement is added! */ + mask = 0xffff; + } + break; + default: + oappend (INTERNAL_DISASSEMBLER_ERROR); + return; + } + disp = (start_pc + codep - start_codep + disp) & mask; + set_op (disp, 0); + print_operand_value (scratchbuf, 1, disp); + oappend (scratchbuf); +} + +static void +OP_SEG (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED, + StackFrame *stackFrame) +{ + oappend (names_seg[reg]); +} + +static void +OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag, + StackFrame *stackFrame) +{ + int seg, offset; + + if (sizeflag & DFLAG) + { + offset = get32 (); + seg = get16 (); + } + else + { + offset = get16 (); + seg = get16 (); + } + used_prefixes |= (prefixes & PREFIX_DATA); + if (intel_syntax) + sprintf (scratchbuf, "0x%x,0x%x", seg, offset); + else + sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset); + oappend (scratchbuf); +} + +static void +OP_OFF (int bytemode ATTRIBUTE_UNUSED, int sizeflag, + StackFrame *stackFrame) +{ + bfd_vma off; + + append_seg (); + + if ((sizeflag & AFLAG) || mode_64bit) + off = get32 (); + else + off = get16 (); + + if (intel_syntax) + { +#ifdef MDB_ENHANCEMENTS + if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS + | PREFIX_ES | PREFIX_FS | PREFIX_GS))) + { + if (!evaluate_address_expression(bytemode, sizeflag, off, + 0, stackFrame, + names_seg[ds_reg - es_reg])) + { + print_operand_value (scratchbuf, 1, off); + oappend (scratchbuf); + } + } + else + { + if (!evaluate_address_expression(bytemode, sizeflag, off, + 0, stackFrame, NULL)) + { + print_operand_value (scratchbuf, 1, off); + oappend (scratchbuf); + } + } +#else + if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS + | PREFIX_ES | PREFIX_FS | PREFIX_GS))) + { + oappend (names_seg[ds_reg - es_reg]); + oappend (":"); + } + print_operand_value (scratchbuf, 1, off); + oappend (scratchbuf); +#endif + } + else + { + print_operand_value (scratchbuf, 1, off); + oappend (scratchbuf); + } +} + +static void +OP_OFF64 (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED, + StackFrame *stackFrame) +{ + bfd_vma off; + + if (!mode_64bit) + { + OP_OFF (bytemode, sizeflag, stackFrame); + return; + } + + append_seg (); + + off = get64 (); + + if (intel_syntax) + { +#ifdef MDB_ENHANCEMENTS + if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS + | PREFIX_ES | PREFIX_FS | PREFIX_GS))) + { + if (!evaluate_address_expression(bytemode, sizeflag, off, + 0, stackFrame, + names_seg[ds_reg - es_reg])) + { + print_operand_value (scratchbuf, 1, off); + oappend (scratchbuf); + } + } + else + { + if (!evaluate_address_expression(bytemode, sizeflag, off, + 0, stackFrame, NULL)) + { + print_operand_value (scratchbuf, 1, off); + oappend (scratchbuf); + } + } +#else + if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS + | PREFIX_ES | PREFIX_FS | PREFIX_GS))) + { + oappend (names_seg[ds_reg - es_reg]); + oappend (":"); + } + print_operand_value (scratchbuf, 1, off); + oappend (scratchbuf); +#endif + } + else + { + print_operand_value (scratchbuf, 1, off); + oappend (scratchbuf); + } +} + +static void +ptr_reg (int code, int sizeflag, StackFrame *stackFrame) +{ + const char *s; + unsigned char *deref; + + // begin dereference + deref = obufp; + *obufp++ = open_char; + used_prefixes |= (prefixes & PREFIX_ADDR); + if (mode_64bit) + { + if (!(sizeflag & AFLAG)) + s = names32[code - eAX_reg]; + else + s = names64[code - eAX_reg]; + } + else if (sizeflag & AFLAG) + s = names32[code - eAX_reg]; + else + s = names16[code - eAX_reg]; + oappend (s); + // end dereference + *obufp++ = close_char; + *obufp = 0; +#ifdef MDB_ENHANCEMENTS + if (intel_syntax) + { + register int size; + + if (mode_64bit) + { + // 32 bit + if (!(sizeflag & AFLAG)) + size = 4; + // 64 bit + else + size = 8; + } + // 32 bit + else if (sizeflag & AFLAG) + size = 4; + // 16 bit + else + size = 2; + + evaluate_expression_size(size, sizeflag, deref, stackFrame); + } +#endif +} + +static void +OP_ESreg (int code, int sizeflag, StackFrame *stackFrame) +{ + if (intel_syntax) + { + if (codep[-1] & 1) + { + USED_REX (REX_MODE64); + used_prefixes |= (prefixes & PREFIX_DATA); + if (rex & REX_MODE64) + oappend ("QWORD PTR "); + else if ((sizeflag & DFLAG)) + oappend ("DWORD PTR "); + else + oappend ("WORD PTR "); + } + else + oappend ("BYTE PTR "); + } + + oappend ("%es:" + intel_syntax); + ptr_reg (code, sizeflag, stackFrame); +} + +static void +OP_DSreg (int code, int sizeflag, StackFrame *stackFrame) +{ + if (intel_syntax) + { + if (codep[-1] != 0xd7 && (codep[-1] & 1)) + { + USED_REX (REX_MODE64); + used_prefixes |= (prefixes & PREFIX_DATA); + if (rex & REX_MODE64) + oappend ("QWORD PTR "); + else if ((sizeflag & DFLAG)) + oappend ("DWORD PTR "); + else + oappend ("WORD PTR "); + } + else + oappend ("BYTE PTR "); + } + + if ((prefixes + & (PREFIX_CS + | PREFIX_DS + | PREFIX_SS + | PREFIX_ES + | PREFIX_FS + | PREFIX_GS)) == 0) + prefixes |= PREFIX_DS; + append_seg (); + ptr_reg (code, sizeflag, stackFrame); +} + +static void +OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED, + StackFrame *stackFrame) +{ + int add = 0; + if (rex & REX_EXTX) + { + USED_REX (REX_EXTX); + add = 8; + } + else if (!mode_64bit && (prefixes & PREFIX_LOCK)) + { + used_prefixes |= PREFIX_LOCK; + add = 8; + } + sprintf (scratchbuf, "%%cr%d", reg + add); + oappend (scratchbuf + intel_syntax); +} + +static void +OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED, + StackFrame *stackFrame) +{ + int add = 0; + USED_REX (REX_EXTX); + if (rex & REX_EXTX) + add = 8; + if (intel_syntax) + sprintf (scratchbuf, "db%d", reg + add); + else + sprintf (scratchbuf, "%%db%d", reg + add); + oappend (scratchbuf); +} + +static void +OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED, + StackFrame *stackFrame) +{ + sprintf (scratchbuf, "%%tr%d", reg); + oappend (scratchbuf + intel_syntax); +} + +static void +OP_Rd (int bytemode, int sizeflag, StackFrame *stackFrame) +{ + if (mod == 3) + OP_E (bytemode, sizeflag, stackFrame); + else + BadOp (); +} + +static void +OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED, + StackFrame *stackFrame) +{ + used_prefixes |= (prefixes & PREFIX_DATA); + if (prefixes & PREFIX_DATA) + { + int add = 0; + USED_REX (REX_EXTX); + if (rex & REX_EXTX) + add = 8; + sprintf (scratchbuf, "%%xmm%d", reg + add); + } + else + sprintf (scratchbuf, "%%mm%d", reg); + oappend (scratchbuf + intel_syntax); +} + +static void +OP_XMM (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED, + StackFrame *stackFrame) +{ + int add = 0; + USED_REX (REX_EXTX); + if (rex & REX_EXTX) + add = 8; + sprintf (scratchbuf, "%%xmm%d", reg + add); + oappend (scratchbuf + intel_syntax); +} + +static void +OP_EM (int bytemode, int sizeflag, StackFrame *stackFrame) +{ + if (mod != 3) + { + if (intel_syntax && bytemode == v_mode) + { + bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode; + used_prefixes |= (prefixes & PREFIX_DATA); + } + OP_E (bytemode, sizeflag, stackFrame); + return; + } + + /* Skip mod/rm byte. */ + MODRM_CHECK; + codep++; + used_prefixes |= (prefixes & PREFIX_DATA); + if (prefixes & PREFIX_DATA) + { + int add = 0; + + USED_REX (REX_EXTZ); + if (rex & REX_EXTZ) + add = 8; + sprintf (scratchbuf, "%%xmm%d", rm + add); + } + else + sprintf (scratchbuf, "%%mm%d", rm); + oappend (scratchbuf + intel_syntax); +} + +static void +OP_EX (int bytemode, int sizeflag, StackFrame *stackFrame) +{ + int add = 0; + if (mod != 3) + { + if (intel_syntax && bytemode == v_mode) + { + switch (prefixes & (PREFIX_DATA|PREFIX_REPZ|PREFIX_REPNZ)) + { + case 0: bytemode = x_mode; break; + case PREFIX_REPZ: bytemode = d_mode; used_prefixes |= PREFIX_REPZ; break; + case PREFIX_DATA: bytemode = x_mode; used_prefixes |= PREFIX_DATA; break; + case PREFIX_REPNZ: bytemode = q_mode; used_prefixes |= PREFIX_REPNZ; break; + default: bytemode = 0; break; + } + } + OP_E (bytemode, sizeflag, stackFrame); + return; + } + USED_REX (REX_EXTZ); + if (rex & REX_EXTZ) + add = 8; + + /* Skip mod/rm byte. */ + MODRM_CHECK; + codep++; + sprintf (scratchbuf, "%%xmm%d", rm + add); + oappend (scratchbuf + intel_syntax); +} + +static void +OP_MS (int bytemode, int sizeflag, StackFrame *stackFrame) +{ + if (mod == 3) + OP_EM (bytemode, sizeflag, stackFrame); + else + BadOp (); +} + +static void +OP_XS (int bytemode, int sizeflag, StackFrame *stackFrame) +{ + if (mod == 3) + OP_EX (bytemode, sizeflag, stackFrame); + else + BadOp (); +} + +static void +OP_M (int bytemode, int sizeflag, StackFrame *stackFrame) +{ + if (mod == 3) + BadOp (); /* bad lea,lds,les,lfs,lgs,lss modrm */ + else + OP_E (bytemode, sizeflag, stackFrame); +} + +static void +OP_0f07 (int bytemode, int sizeflag, StackFrame *stackFrame) +{ + if (mod != 3 || rm != 0) + BadOp (); + else + OP_E (bytemode, sizeflag, stackFrame); +} + +static void +OP_0fae (int bytemode, int sizeflag, StackFrame *stackFrame) +{ + if (mod == 3) + { + if (reg == 5) + strcpy (obuf + strlen (obuf) - sizeof ("xrstor") + 1, "lfence"); + if (reg == 7) + strcpy (obuf + strlen (obuf) - sizeof ("clflush") + 1, "sfence"); + + if (reg < 5 || rm != 0) + { + BadOp (); /* bad sfence, mfence, or lfence */ + return; + } + } + else if (reg != 5 && reg != 7) + { + BadOp (); /* bad xrstor or clflush */ + return; + } + + OP_E (bytemode, sizeflag, stackFrame); +} + +static void +NOP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED, + StackFrame *stackFrame) +{ + /* NOP with REPZ prefix is called PAUSE. */ + if (prefixes == PREFIX_REPZ) + strcpy (obuf, "pause"); +} + +static const char *const Suffix3DNow[] = { +/* 00 */ NULL, NULL, NULL, NULL, +/* 04 */ NULL, NULL, NULL, NULL, +/* 08 */ NULL, NULL, NULL, NULL, +/* 0C */ "pi2fw", "pi2fd", NULL, NULL, +/* 10 */ NULL, NULL, NULL, NULL, +/* 14 */ NULL, NULL, NULL, NULL, +/* 18 */ NULL, NULL, NULL, NULL, +/* 1C */ "pf2iw", "pf2id", NULL, NULL, +/* 20 */ NULL, NULL, NULL, NULL, +/* 24 */ NULL, NULL, NULL, NULL, +/* 28 */ NULL, NULL, NULL, NULL, +/* 2C */ NULL, NULL, NULL, NULL, +/* 30 */ NULL, NULL, NULL, NULL, +/* 34 */ NULL, NULL, NULL, NULL, +/* 38 */ NULL, NULL, NULL, NULL, +/* 3C */ NULL, NULL, NULL, NULL, +/* 40 */ NULL, NULL, NULL, NULL, +/* 44 */ NULL, NULL, NULL, NULL, +/* 48 */ NULL, NULL, NULL, NULL, +/* 4C */ NULL, NULL, NULL, NULL, +/* 50 */ NULL, NULL, NULL, NULL, +/* 54 */ NULL, NULL, NULL, NULL, +/* 58 */ NULL, NULL, NULL, NULL, +/* 5C */ NULL, NULL, NULL, NULL, +/* 60 */ NULL, NULL, NULL, NULL, +/* 64 */ NULL, NULL, NULL, NULL, +/* 68 */ NULL, NULL, NULL, NULL, +/* 6C */ NULL, NULL, NULL, NULL, +/* 70 */ NULL, NULL, NULL, NULL, +/* 74 */ NULL, NULL, NULL, NULL, +/* 78 */ NULL, NULL, NULL, NULL, +/* 7C */ NULL, NULL, NULL, NULL, +/* 80 */ NULL, NULL, NULL, NULL, +/* 84 */ NULL, NULL, NULL, NULL, +/* 88 */ NULL, NULL, "pfnacc", NULL, +/* 8C */ NULL, NULL, "pfpnacc", NULL, +/* 90 */ "pfcmpge", NULL, NULL, NULL, +/* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt", +/* 98 */ NULL, NULL, "pfsub", NULL, +/* 9C */ NULL, NULL, "pfadd", NULL, +/* A0 */ "pfcmpgt", NULL, NULL, NULL, +/* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1", +/* A8 */ NULL, NULL, "pfsubr", NULL, +/* AC */ NULL, NULL, "pfacc", NULL, +/* B0 */ "pfcmpeq", NULL, NULL, NULL, +/* B4 */ "pfmul", NULL, "pfrcpit2", "pfmulhrw", +/* B8 */ NULL, NULL, NULL, "pswapd", +/* BC */ NULL, NULL, NULL, "pavgusb", +/* C0 */ NULL, NULL, NULL, NULL, +/* C4 */ NULL, NULL, NULL, NULL, +/* C8 */ NULL, NULL, NULL, NULL, +/* CC */ NULL, NULL, NULL, NULL, +/* D0 */ NULL, NULL, NULL, NULL, +/* D4 */ NULL, NULL, NULL, NULL, +/* D8 */ NULL, NULL, NULL, NULL, +/* DC */ NULL, NULL, NULL, NULL, +/* E0 */ NULL, NULL, NULL, NULL, +/* E4 */ NULL, NULL, NULL, NULL, +/* E8 */ NULL, NULL, NULL, NULL, +/* EC */ NULL, NULL, NULL, NULL, +/* F0 */ NULL, NULL, NULL, NULL, +/* F4 */ NULL, NULL, NULL, NULL, +/* F8 */ NULL, NULL, NULL, NULL, +/* FC */ NULL, NULL, NULL, NULL, +}; + +static void +OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED, + StackFrame *stackFrame) +{ + const char *mnemonic; + + FETCH_DATA (the_info, codep + 1); + /* AMD 3DNow! instructions are specified by an opcode suffix in the + place where an 8-bit immediate would normally go. ie. the last + byte of the instruction. */ + obufp = obuf + strlen (obuf); + mnemonic = Suffix3DNow[*codep++ & 0xff]; + if (mnemonic) + oappend (mnemonic); + else + { + /* Since a variable sized modrm/sib chunk is between the start + of the opcode (0x0f0f) and the opcode suffix, we need to do + all the modrm processing first, and don't know until now that + we have a bad opcode. This necessitates some cleaning up. */ + op1out[0] = '\0'; + op2out[0] = '\0'; + BadOp (); + } +} + +static const char *simd_cmp_op[] = { + "eq", + "lt", + "le", + "unord", + "neq", + "nlt", + "nle", + "ord" +}; + +static void +OP_SIMD_Suffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED, + StackFrame *stackFrame) +{ + unsigned int cmp_type; + + FETCH_DATA (the_info, codep + 1); + obufp = obuf + strlen (obuf); + cmp_type = *codep++ & 0xff; + if (cmp_type < 8) + { + char suffix1 = 'p', suffix2 = 's'; + used_prefixes |= (prefixes & PREFIX_REPZ); + if (prefixes & PREFIX_REPZ) + suffix1 = 's'; + else + { + used_prefixes |= (prefixes & PREFIX_DATA); + if (prefixes & PREFIX_DATA) + suffix2 = 'd'; + else + { + used_prefixes |= (prefixes & PREFIX_REPNZ); + if (prefixes & PREFIX_REPNZ) + suffix1 = 's', suffix2 = 'd'; + } + } + sprintf (scratchbuf, "cmp%s%c%c", + simd_cmp_op[cmp_type], suffix1, suffix2); + used_prefixes |= (prefixes & PREFIX_REPZ); + oappend (scratchbuf); + } + else + { + /* We have a bad extension byte. Clean up. */ + op1out[0] = '\0'; + op2out[0] = '\0'; + BadOp (); + } +} + +static void +SIMD_Fixup (int extrachar, int sizeflag ATTRIBUTE_UNUSED, + StackFrame *stackFrame) +{ + /* Change movlps/movhps to movhlps/movlhps for 2 register operand + forms of these instructions. */ + if (mod == 3) + { + char *p = obuf + strlen (obuf); + *(p + 1) = '\0'; + *p = *(p - 1); + *(p - 1) = *(p - 2); + *(p - 2) = *(p - 3); + *(p - 3) = extrachar; + } +} + +static void +PNI_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag, StackFrame *stackFrame) +{ + if (mod == 3 && reg == 1 && rm <= 1) + { + /* Override "sidt". */ + char *p = obuf + strlen (obuf) - 4; + + /* We might have a suffix when disassembling with -Msuffix. */ + if (*p == 'i') + --p; + + if (rm) + { + /* mwait %eax,%ecx */ + strcpy (p, "mwait"); + if (!intel_syntax) + strcpy (op1out, names32[0]); + } + else + { + /* monitor %eax,%ecx,%edx" */ + strcpy (p, "monitor"); + if (!intel_syntax) + { + if (!mode_64bit) + strcpy (op1out, names32[0]); + else if (!(prefixes & PREFIX_ADDR)) + strcpy (op1out, names64[0]); + else + { + strcpy (op1out, names32[0]); + used_prefixes |= PREFIX_ADDR; + } + strcpy (op3out, names32[2]); + } + } + if (!intel_syntax) + { + strcpy (op2out, names32[1]); + two_source_ops = 1; + } + + codep++; + } + else + OP_M (0, sizeflag, stackFrame); +} + +static void +SVME_Fixup (int bytemode, int sizeflag, StackFrame *stackFrame) +{ + const char *alt; + char *p; + unsigned char *deref; + + switch (*codep) + { + case 0xd8: + alt = "vmrun"; + break; + case 0xd9: + alt = "vmmcall"; + break; + case 0xda: + alt = "vmload"; + break; + case 0xdb: + alt = "vmsave"; + break; + case 0xdc: + alt = "stgi"; + break; + case 0xdd: + alt = "clgi"; + break; + case 0xde: + alt = "skinit"; + break; + case 0xdf: + alt = "invlpga"; + break; + default: + OP_M (bytemode, sizeflag, stackFrame); + return; + } + /* Override "lidt". */ + p = obuf + strlen (obuf) - 4; + /* We might have a suffix. */ + if (*p == 'i') + --p; + strcpy (p, alt); + if (!(prefixes & PREFIX_ADDR)) + { + ++codep; + return; + } + used_prefixes |= PREFIX_ADDR; + switch (*codep++) + { + case 0xdf: + strcpy (op2out, names32[1]); + two_source_ops = 1; + /* Fall through. */ + case 0xd8: + case 0xda: + case 0xdb: + // begin dereference + deref = obufp; + *obufp++ = open_char; + if (mode_64bit || (sizeflag & AFLAG)) + alt = names32[0]; + else + alt = names16[0]; + strcpy (obufp, alt); + obufp += strlen (alt); + // end dereference + *obufp++ = close_char; + *obufp = '\0'; +#ifdef MDB_ENHANCEMENTS + if (intel_syntax) + evaluate_expression(bytemode, sizeflag, deref, stackFrame); +#endif + break; + } +} + +static void +INVLPG_Fixup (int bytemode, int sizeflag, StackFrame *stackFrame) +{ + const char *alt; + + switch (*codep) + { + case 0xf8: + alt = "swapgs"; + break; + case 0xf9: + alt = "rdtscp"; + break; + default: + OP_M (bytemode, sizeflag, stackFrame); + return; + } + /* Override "invlpg". */ + strcpy (obuf + strlen (obuf) - 6, alt); + codep++; +} + +static void +BadOp (void) +{ + /* Throw away prefixes and 1st. opcode byte. */ + codep = insn_codep + 1; + oappend ("(bad)"); +} + +static void +SEG_Fixup (int extrachar, int sizeflag, StackFrame *stackFrame) +{ + if (mod == 3) + { + /* We need to add a proper suffix with + + movw %ds,%ax + movl %ds,%eax + movq %ds,%rax + movw %ax,%ds + movl %eax,%ds + movq %rax,%ds + */ + const char *suffix; + + if (prefixes & PREFIX_DATA) + suffix = "w"; + else + { + USED_REX (REX_MODE64); + if (rex & REX_MODE64) + suffix = "q"; + else + suffix = "l"; + } + strcat (obuf, suffix); + } + else + { + /* We need to fix the suffix for + + movw %ds,(%eax) + movw %ds,(%rax) + movw (%eax),%ds + movw (%rax),%ds + + Override "mov[l|q]". */ + char *p = obuf + strlen (obuf) - 1; + + /* We might not have a suffix. */ + if (*p == 'v') + ++p; + *p = 'w'; + } + + OP_E (extrachar, sizeflag, stackFrame); +} + +static void +VMX_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag, StackFrame *stackFrame) +{ + if (mod == 3 && reg == 0 && rm >=1 && rm <= 4) + { + /* Override "sgdt". */ + char *p = obuf + strlen (obuf) - 4; + + /* We might have a suffix when disassembling with -Msuffix. */ + if (*p == 'g') + --p; + + switch (rm) + { + case 1: + strcpy (p, "vmcall"); + break; + case 2: + strcpy (p, "vmlaunch"); + break; + case 3: + strcpy (p, "vmresume"); + break; + case 4: + strcpy (p, "vmxoff"); + break; + } + + codep++; + } + else + OP_E (0, sizeflag, stackFrame); +} + +static void +OP_VMX (int bytemode, int sizeflag, StackFrame *stackFrame) +{ + used_prefixes |= (prefixes & (PREFIX_DATA | PREFIX_REPZ)); + if (prefixes & PREFIX_DATA) + strcpy (obuf, "vmclear"); + else if (prefixes & PREFIX_REPZ) + strcpy (obuf, "vmxon"); + else + strcpy (obuf, "vmptrld"); + OP_E (bytemode, sizeflag, stackFrame); +} + +static int mdb_dis_getsym(bfd_vma addr, disassemble_info *dip) +{ + return 0; +} + +static void mdb_printaddress(unsigned long addr, disassemble_info *dip, + int flag, int type) +{ + int spaces = 5; + unsigned char *sym_name; + unsigned long offset; + + sym_name = GetSymbolFromValueWithOffset(addr, &offset, + &symbuf[get_processor_id()][0], + MAX_SYMBOL_LEN); + if (sym_name && sym_name[0] != ' ') + { + if (type) + dip->fprintf_func(dip->stream, "0x%0*lx %s", + (int)(2*sizeof(addr)), addr, sym_name); + else + dip->fprintf_func(dip->stream, "%s", sym_name); + if ((offset) == 0) + spaces += 4; + else + { + unsigned int o = offset; + + while (o >>= 4) + --spaces; + dip->fprintf_func(dip->stream, "+0x%lx", offset); + } + } + else + { + dip->fprintf_func(dip->stream, "0x%lx", addr); + } + + if (flag) + { + if (spaces < 1) + { + spaces = 1; + } + dip->fprintf_func(dip->stream, ":%*s", spaces, " "); + } + return; +} + +int mdb_fprintf(char *out, const char *fmt, ...) +{ + char *work = &fworkbuf[get_processor_id()][0]; + va_list ap; + + *work = '\0'; + va_start(ap, fmt); + vsprintf(work, fmt, ap); + va_end(ap); + + strcat(out, work); + + return 0; +} + +int mdb_id_printinsn_intel(unsigned long pc, disassemble_info *dip, + StackFrame *stackFrame) +{ + register int err, cpu = get_processor_id(); + char *final = &finalbuf[cpu][0]; + long segment, offset; + + // print the address info based on architecture + if ((dip->mach == bfd_mach_i386_i386) || + (dip->mach == bfd_mach_x86_64)) + { + mdb_fprintf(final, "0x%p ", (void *)pc); + } + else + if (dip->mach == bfd_mach_i386_i8086) + { + segment = (((unsigned long)pc >> 4) & 0x0000FFFF); + offset = ((unsigned long)pc & 0x0000000F); + + mdb_fprintf(final, "%04X:%04X ", + (unsigned)segment, (unsigned)offset); + } + + // perform disassembly + err = print_insn_i386_intel(pc, dip, stackFrame); + + // output byte opcodes + mdb_fprintf(final, "%s ", &fbytebuf[cpu][0]); + + do + { + mdb_fprintf(final, " "); + columns++; + } while (columns < 15); + + // output disassembly results + mdb_fprintf(final, "%s ", &disbuf[cpu][0]); + + columns += strlen(&disbuf[cpu][0]); + do + { + mdb_fprintf(final, " "); + columns++; + } while (columns < 45); + + return err; +} + +int mdb_id_printinsn_att(unsigned long pc, disassemble_info *dip, + StackFrame *stackFrame) +{ + mdb_printaddress(pc, dip, 1, 1); + return print_insn_i386_att(pc, dip, stackFrame); +} + +static void mdb_intel_printaddr(bfd_vma addr, disassemble_info *dip) +{ + mdb_printaddress(addr, dip, 0, 0); +} + +static void mdb_dis_printaddr(bfd_vma addr, disassemble_info *dip) +{ + mdb_printaddress(addr, dip, 0, 1); +} + +unsigned short read_memory(void *addr, void *buf, unsigned length) +{ + register unsigned long i; + register unsigned char *s = buf; + + for (i = 0; i < length; i++) + { + if (s) + { + s[i] = (unsigned char) + mdb_getword((unsigned long)((unsigned long)addr + i), 1); + } + } + return 0; +} + +static int mdb_dis_getmem(bfd_vma addr, bfd_byte *buf, unsigned int length, + disassemble_info *dip) +{ + register unsigned long i; + register unsigned char *s = buf; + + for (i = 0; i < length; i++) + { + if (s) + { + s[i] = (unsigned char) + mdb_getword((unsigned long)((unsigned long)addr + i), 1); + vaddr = (void *)((unsigned long)vaddr + 1); + } + } + return 0; +} + +static int mdb_intel_getmem(bfd_vma addr, bfd_byte *buf, unsigned int length, + disassemble_info *dip) +{ + register unsigned long cpu = get_processor_id(); + register unsigned long i; + register unsigned char *s = buf, *fbyte = (char *)&fbytebuf[cpu][0]; + + for (i = 0; i < length; i++) + { + if (s) + { + s[i] = (unsigned char) + mdb_getword((unsigned long)((unsigned long)addr + i), 1); + vaddr = (void *)((unsigned long)vaddr + 1); + + mdb_fprintf(fbyte, "%02X", s[i]); + columns += 2; + } + } + return 0; +} + + +int mdb_dis_fprintf(PTR file, const char *fmt, ...) +{ + unsigned long cpu = get_processor_id(); + va_list ap; + + fworkbuf[cpu][0] = '\0'; + + va_start(ap, fmt); + vsprintf(&fworkbuf[cpu][0], fmt, ap); + va_end(ap); + + strcat(&finalbuf[cpu][0], &fworkbuf[cpu][0]); + + return 0; +} + +int mdb_intel_fprintf(PTR file, const char *fmt, ...) +{ + unsigned long cpu = get_processor_id(); + va_list ap; + + fworkbuf[cpu][0] = '\0'; + + va_start(ap, fmt); + vsprintf(&fworkbuf[cpu][0], fmt, ap); + va_end(ap); + + strcat(&disbuf[cpu][0], &fworkbuf[cpu][0]); + + return 0; +} + +int mdb_dis_fprintf_dummy(PTR file, const char *fmt, ...) +{ + return(0); +} + +int mdb_id_init(disassemble_info *dip, unsigned long type) +{ + dip->stream = NULL; + dip->application_data = NULL; + dip->symbols = NULL; + dip->num_symbols = 0; + dip->flags = 0; + dip->private_data = NULL; + dip->buffer = NULL; + dip->buffer_vma = 0; + dip->buffer_length = 0; + dip->bytes_per_line = 0; + dip->bytes_per_chunk = 0; + dip->insn_info_valid = 0; + dip->branch_delay_insns = 0; + dip->data_size = 0; + dip->insn_type = 0; + dip->target = 0; + dip->target2 = 0; + + if (type) + { + dip->read_memory_func = mdb_dis_getmem; + dip->print_address_func = mdb_dis_printaddr; + dip->fprintf_func = mdb_dis_fprintf; + } + else + { + dip->read_memory_func = mdb_intel_getmem; + dip->print_address_func = mdb_intel_printaddr; + dip->fprintf_func = mdb_intel_fprintf; + } + + dip->symbol_at_address_func = mdb_dis_getsym; + dip->flavour = bfd_target_elf_flavour; + dip->arch = bfd_arch_i386; +#ifdef CONFIG_X86_64 + dip->mach = bfd_mach_x86_64; +#endif +#ifdef CONFIG_X86_32 + dip->mach = bfd_mach_i386_i386; +#endif + dip->endian = BFD_ENDIAN_LITTLE; + dip->display_endian = BFD_ENDIAN_LITTLE; + + return 0; +} + +unsigned long unassemble(StackFrame *stackFrame, unsigned long ip, + unsigned long use, unsigned long *ret, + unsigned long type) +{ + unsigned long cpu = get_processor_id(); + + jmp_active = 0; + columns = 0; + needs_proceed = 0; + disbuf[cpu][0] = '\0'; + fbytebuf[cpu][0] = '\0'; + finalbuf[cpu][0] = '\0'; + + mdb_id_init(&mdb_di, type); + switch (use) + { + case 2: + mdb_di.mach = bfd_mach_x86_64; + break; + + case 1: + mdb_di.mach = bfd_mach_i386_i386; + break; + + case 0: + mdb_di.mach = bfd_mach_i386_i8086; + break; + + default: +#ifdef CONFIG_X86_64 + mdb_di.mach = bfd_mach_x86_64; +#else + mdb_di.mach = bfd_mach_i386_i386; +#endif + break; + } + + vaddr = (void *)ip; + if (type) + (void) mdb_id_printinsn_att(ip, &mdb_di, stackFrame); + else + (void) mdb_id_printinsn_intel(ip, &mdb_di, stackFrame); + + if (!strncasecmp(&disbuf[cpu][0], "call", 4) || + !strncasecmp(&disbuf[cpu][0], "rep", 3) || + !strncasecmp(&disbuf[cpu][0], "int", 3) || + !strncasecmp(&disbuf[cpu][0], "loop", 4)) + { + needs_proceed = 1; + jmp_active = 1; + } + + if (!strncasecmp(&disbuf[cpu][0], "ret", 3)) + jmp_active = 1; + + if (!strncasecmp(&disbuf[cpu][0], "iret", 4) || + !strncasecmp(&disbuf[cpu][0], "sysexit", 7) || + !strncasecmp(&disbuf[cpu][0], "sysret", 6)) + jmp_active = 1; + + if (ret) + *ret = (unsigned long)vaddr; + + if (mdb_printf("%s", &finalbuf[cpu][0])) return 1; + if (mdb_printf("\n")) return 1; + + return 0; +} + + + diff -Naur linux-2.6.35.4/kernel/debug/mdb/mdb-ia-support.h linux-2.6.35.4-cs/kernel/debug/mdb/mdb-ia-support.h --- linux-2.6.35.4/kernel/debug/mdb/mdb-ia-support.h 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/mdb-ia-support.h 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,338 @@ + +/*************************************************************************** +* +* Copyright (c) 2008 Jeff V. Merkey All Rights Reserved. +* jeffmerkey@gmail.com +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation, version 2. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You are free to modify and re-distribute this program in accordance +* with the terms specified in the GNU Public License. The copyright +* contained in this code is required to be present in any derivative +* works and you are required to provide the source code for this +* program as part of any commercial or non-commercial distribution. +* You are required to respect the rights of the Copyright holders +* named within this code. +* +* jeffmerkey@gmail.com is the official maintainer of +* this code. You are encouraged to report any bugs, problems, fixes, +* suggestions, and comments about this software. +* +* AUTHOR : Jeff V. Merkey +* DESCRIP : Merkey's Linux Debugger +* +***************************************************************************/ + +#ifndef DIS_ASM_H +#define DIS_ASM_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "ansidecl.h" +#include "bfd.h" +typedef void FILE; + +typedef int (*fprintf_ftype) (void *, const char*, ...) ATTRIBUTE_FPTR_PRINTF_2; + +enum dis_insn_type { + dis_noninsn, /* Not a valid instruction */ + dis_nonbranch, /* Not a branch instruction */ + dis_branch, /* Unconditional branch */ + dis_condbranch, /* Conditional branch */ + dis_jsr, /* Jump to subroutine */ + dis_condjsr, /* Conditional jump to subroutine */ + dis_dref, /* Data reference instruction */ + dis_dref2 /* Two data references in instruction */ +}; + +/* This struct is passed into the instruction decoding routine, + and is passed back out into each callback. The various fields are used + for conveying information from your main routine into your callbacks, + for passing information into the instruction decoders (such as the + addresses of the callback functions), or for passing information + back from the instruction decoders to their callers. + + It must be initialized before it is first passed; this can be done + by hand, or using one of the initialization macros below. */ + +typedef struct disassemble_info { + fprintf_ftype fprintf_func; + void *stream; + void *application_data; + + /* Target description. We could replace this with a pointer to the bfd, + but that would require one. There currently isn't any such requirement + so to avoid introducing one we record these explicitly. */ + /* The bfd_flavour. This can be bfd_target_unknown_flavour. */ + enum bfd_flavour flavour; + /* The bfd_arch value. */ + enum bfd_architecture arch; + /* The bfd_mach value. */ + unsigned long mach; + /* Endianness (for bi-endian cpus). Mono-endian cpus can ignore this. */ + enum bfd_endian endian; + /* An arch/mach-specific bitmask of selected instruction subsets, mainly + for processors with run-time-switchable instruction sets. The default, + zero, means that there is no constraint. CGEN-based opcodes ports + may use ISA_foo masks. */ + unsigned long insn_sets; + + /* Some targets need information about the current section to accurately + display insns. If this is NULL, the target disassembler function + will have to make its best guess. */ + asection *section; + + /* An array of pointers to symbols either at the location being disassembled + or at the start of the function being disassembled. The array is sorted + so that the first symbol is intended to be the one used. The others are + present for any misc. purposes. This is not set reliably, but if it is + not NULL, it is correct. */ + asymbol **symbols; + /* Number of symbols in array. */ + int num_symbols; + + /* For use by the disassembler. + The top 16 bits are reserved for public use (and are documented here). + The bottom 16 bits are for the internal use of the disassembler. */ + unsigned long flags; +#define INSN_HAS_RELOC 0x80000000 + void *private_data; + + /* Function used to get bytes to disassemble. MEMADDR is the + address of the stuff to be disassembled, MYADDR is the address to + put the bytes in, and LENGTH is the number of bytes to read. + INFO is a pointer to this struct. + Returns an errno value or 0 for success. */ + int (*read_memory_func) + (bfd_vma memaddr, bfd_byte *myaddr, unsigned int length, + struct disassemble_info *info); + + /* Function which should be called if we get an error that we can't + recover from. STATUS is the errno value from read_memory_func and + MEMADDR is the address that we were trying to read. INFO is a + pointer to this struct. */ + void (*memory_error_func) + (int status, bfd_vma memaddr, struct disassemble_info *info); + + /* Function called to print ADDR. */ + void (*print_address_func) + (bfd_vma addr, struct disassemble_info *info); + + /* Function called to determine if there is a symbol at the given ADDR. + If there is, the function returns 1, otherwise it returns 0. + This is used by ports which support an overlay manager where + the overlay number is held in the top part of an address. In + some circumstances we want to include the overlay number in the + address, (normally because there is a symbol associated with + that address), but sometimes we want to mask out the overlay bits. */ + int (* symbol_at_address_func) + (bfd_vma addr, struct disassemble_info * info); + + /* Function called to check if a SYMBOL is can be displayed to the user. + This is used by some ports that want to hide special symbols when + displaying debugging outout. */ + bfd_boolean (* symbol_is_valid) + (asymbol *, struct disassemble_info * info); + + /* These are for buffer_read_memory. */ + bfd_byte *buffer; + bfd_vma buffer_vma; + unsigned int buffer_length; + + /* This variable may be set by the instruction decoder. It suggests + the number of bytes objdump should display on a single line. If + the instruction decoder sets this, it should always set it to + the same value in order to get reasonable looking output. */ + int bytes_per_line; + + /* The next two variables control the way objdump displays the raw data. */ + /* For example, if bytes_per_line is 8 and bytes_per_chunk is 4, the */ + /* output will look like this: + 00: 00000000 00000000 + with the chunks displayed according to "display_endian". */ + int bytes_per_chunk; + enum bfd_endian display_endian; + + /* Number of octets per incremented target address + Normally one, but some DSPs have byte sizes of 16 or 32 bits. */ + unsigned int octets_per_byte; + + /* The number of zeroes we want to see at the end of a section before we + start skipping them. */ + unsigned int skip_zeroes; + + /* The number of zeroes to skip at the end of a section. If the number + of zeroes at the end is between SKIP_ZEROES_AT_END and SKIP_ZEROES, + they will be disassembled. If there are fewer than + SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic + attempt to avoid disassembling zeroes inserted by section + alignment. */ + unsigned int skip_zeroes_at_end; + + /* Results from instruction decoders. Not all decoders yet support + this information. This info is set each time an instruction is + decoded, and is only valid for the last such instruction. + + To determine whether this decoder supports this information, set + insn_info_valid to 0, decode an instruction, then check it. */ + + char insn_info_valid; /* Branch info has been set. */ + char branch_delay_insns; /* How many sequential insn's will run before + a branch takes effect. (0 = normal) */ + char data_size; /* Size of data reference in insn, in bytes */ + enum dis_insn_type insn_type; /* Type of instruction */ + bfd_vma target; /* Target address of branch or dref, if known; + zero if unknown. */ + bfd_vma target2; /* Second target address for dref2 */ + + /* Command line options specific to the target disassembler. */ + char * disassembler_options; + +} disassemble_info; + + +/* Standard disassemblers. Disassemble one instruction at the given + target address. Return number of octets processed. */ +typedef int (*disassembler_ftype) (bfd_vma, disassemble_info *); + +extern int print_insn_big_mips (bfd_vma, disassemble_info *); +extern int print_insn_little_mips (bfd_vma, disassemble_info *); +extern int print_insn_ia64 (bfd_vma, disassemble_info *); +extern int print_insn_i370 (bfd_vma, disassemble_info *); +extern int print_insn_m68hc11 (bfd_vma, disassemble_info *); +extern int print_insn_m68hc12 (bfd_vma, disassemble_info *); +extern int print_insn_m68k (bfd_vma, disassemble_info *); +extern int print_insn_z8001 (bfd_vma, disassemble_info *); +extern int print_insn_z8002 (bfd_vma, disassemble_info *); +extern int print_insn_h8300 (bfd_vma, disassemble_info *); +extern int print_insn_h8300h (bfd_vma, disassemble_info *); +extern int print_insn_h8300s (bfd_vma, disassemble_info *); +extern int print_insn_h8500 (bfd_vma, disassemble_info *); +extern int print_insn_alpha (bfd_vma, disassemble_info *); +extern int print_insn_big_arm (bfd_vma, disassemble_info *); +extern int print_insn_little_arm (bfd_vma, disassemble_info *); +extern int print_insn_sparc (bfd_vma, disassemble_info *); +extern int print_insn_big_a29k (bfd_vma, disassemble_info *); +extern int print_insn_little_a29k (bfd_vma, disassemble_info *); +extern int print_insn_avr (bfd_vma, disassemble_info *); +extern int print_insn_d10v (bfd_vma, disassemble_info *); +extern int print_insn_d30v (bfd_vma, disassemble_info *); +extern int print_insn_dlx (bfd_vma, disassemble_info *); +extern int print_insn_fr30 (bfd_vma, disassemble_info *); +extern int print_insn_hppa (bfd_vma, disassemble_info *); +extern int print_insn_i860 (bfd_vma, disassemble_info *); +extern int print_insn_i960 (bfd_vma, disassemble_info *); +extern int print_insn_ip2k (bfd_vma, disassemble_info *); +extern int print_insn_m32r (bfd_vma, disassemble_info *); +extern int print_insn_m88k (bfd_vma, disassemble_info *); +extern int print_insn_maxq_little (bfd_vma, disassemble_info *); +extern int print_insn_maxq_big (bfd_vma, disassemble_info *); +extern int print_insn_mcore (bfd_vma, disassemble_info *); +extern int print_insn_mmix (bfd_vma, disassemble_info *); +extern int print_insn_mn10200 (bfd_vma, disassemble_info *); +extern int print_insn_mn10300 (bfd_vma, disassemble_info *); +extern int print_insn_ms1 (bfd_vma, disassemble_info *); +extern int print_insn_msp430 (bfd_vma, disassemble_info *); +extern int print_insn_ns32k (bfd_vma, disassemble_info *); +extern int print_insn_crx (bfd_vma, disassemble_info *); +extern int print_insn_openrisc (bfd_vma, disassemble_info *); +extern int print_insn_big_or32 (bfd_vma, disassemble_info *); +extern int print_insn_little_or32 (bfd_vma, disassemble_info *); +extern int print_insn_pdp11 (bfd_vma, disassemble_info *); +extern int print_insn_pj (bfd_vma, disassemble_info *); +extern int print_insn_big_powerpc (bfd_vma, disassemble_info *); +extern int print_insn_little_powerpc (bfd_vma, disassemble_info *); +extern int print_insn_rs6000 (bfd_vma, disassemble_info *); +extern int print_insn_s390 (bfd_vma, disassemble_info *); +extern int print_insn_sh (bfd_vma, disassemble_info *); +extern int print_insn_tic30 (bfd_vma, disassemble_info *); +extern int print_insn_tic4x (bfd_vma, disassemble_info *); +extern int print_insn_tic54x (bfd_vma, disassemble_info *); +extern int print_insn_tic80 (bfd_vma, disassemble_info *); +extern int print_insn_v850 (bfd_vma, disassemble_info *); +extern int print_insn_vax (bfd_vma, disassemble_info *); +extern int print_insn_w65 (bfd_vma, disassemble_info *); +extern int print_insn_xstormy16 (bfd_vma, disassemble_info *); +extern int print_insn_xtensa (bfd_vma, disassemble_info *); +extern int print_insn_sh64 (bfd_vma, disassemble_info *); +extern int print_insn_sh64x_media (bfd_vma, disassemble_info *); +extern int print_insn_frv (bfd_vma, disassemble_info *); +extern int print_insn_iq2000 (bfd_vma, disassemble_info *); +extern int print_insn_m32c (bfd_vma, disassemble_info *); + +extern disassembler_ftype arc_get_disassembler (void *); +extern disassembler_ftype cris_get_disassembler (bfd *); + +extern void print_mips_disassembler_options (FILE *); +extern void print_ppc_disassembler_options (FILE *); +extern void print_arm_disassembler_options (FILE *); +extern void parse_arm_disassembler_option (char *); +extern int get_arm_regname_num_options (void); +extern int set_arm_regname_option (int); +extern int get_arm_regnames (int, const char **, const char **, const char *const **); +extern bfd_boolean arm_symbol_is_valid (asymbol *, struct disassemble_info *); + +/* Fetch the disassembler for a given BFD, if that support is available. */ +extern disassembler_ftype disassembler (bfd *); + +/* Amend the disassemble_info structure as necessary for the target architecture. + Should only be called after initialising the info->arch field. */ +extern void disassemble_init_for_target (struct disassemble_info * info); + +/* Document any target specific options available from the disassembler. */ +extern void disassembler_usage (FILE *); + + +/* This block of definitions is for particular callers who read instructions + into a buffer before calling the instruction decoder. */ + +/* Here is a function which callers may wish to use for read_memory_func. + It gets bytes from a buffer. */ +extern int buffer_read_memory + (bfd_vma, bfd_byte *, unsigned int, struct disassemble_info *); + +/* This function goes with buffer_read_memory. + It prints a message using info->fprintf_func and info->stream. */ +extern void perror_memory (int, bfd_vma, struct disassemble_info *); + + +/* Just print the address in hex. This is included for completeness even + though both GDB and objdump provide their own (to print symbolic + addresses). */ +extern void generic_print_address + (bfd_vma, struct disassemble_info *); + +/* Always true. */ +extern int generic_symbol_at_address + (bfd_vma, struct disassemble_info *); + +/* Also always true. */ +extern bfd_boolean generic_symbol_is_valid + (asymbol *, struct disassemble_info *); + +/* Method to initialize a disassemble_info struct. This should be + called by all applications creating such a struct. */ +extern void init_disassemble_info (struct disassemble_info *info, void *stream, + fprintf_ftype fprintf_func); + +/* For compatibility with existing code. */ +#define INIT_DISASSEMBLE_INFO(INFO, STREAM, FPRINTF_FUNC) \ + init_disassemble_info (&(INFO), (STREAM), (fprintf_ftype) (FPRINTF_FUNC)) +#define INIT_DISASSEMBLE_INFO_NO_ARCH(INFO, STREAM, FPRINTF_FUNC) \ + init_disassemble_info (&(INFO), (STREAM), (fprintf_ftype) (FPRINTF_FUNC)) + + +#ifdef __cplusplus +} +#endif + +#endif /* ! defined (DIS_ASM_H) */ diff -Naur linux-2.6.35.4/kernel/debug/mdb/mdb-keyboard.h linux-2.6.35.4-cs/kernel/debug/mdb/mdb-keyboard.h --- linux-2.6.35.4/kernel/debug/mdb/mdb-keyboard.h 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/mdb-keyboard.h 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,141 @@ + +/*************************************************************************** +* +* Copyright (c) 2008 Jeff V. Merkey All Rights Reserved. +* jeffmerkey@gmail.com +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation, version 2. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You are free to modify and re-distribute this program in accordance +* with the terms specified in the GNU Public License. The copyright +* contained in this code is required to be present in any derivative +* works and you are required to provide the source code for this +* program as part of any commercial or non-commercial distribution. +* You are required to respect the rights of the Copyright holders +* named within this code. +* +* jeffmerkey@gmail.com is the official maintainer of +* this code. You are encouraged to report any bugs, problems, fixes, +* suggestions, and comments about this software. +* +* AUTHOR : Jeff V. Merkey +* DESCRIP : Merkey's Linux Debugger +* +***************************************************************************/ + +#undef KBD_REPORT_ERR /* Report keyboard errors */ +#define KBD_REPORT_UNKN /* Report unknown scan codes */ +#define KBD_REPORT_TIMEOUTS /* Report keyboard timeouts */ +#undef KBD_IS_FOCUS_9000 /* We have the brain-damaged FOCUS-9000 keyboard */ +#undef INITIALIZE_MOUSE /* Define if your PS/2 mouse needs initialization. */ + + +#define KBD_INIT_TIMEOUT 1000 /* Timeout in ms for initializing the keyboard */ +#define KBC_TIMEOUT 250 /* Timeout in ms for sending to keyboard controller */ +#define KBD_TIMEOUT 1000 /* Timeout in ms for keyboard command acknowledge */ + +/* + * Keyboard Controller Registers on normal PCs. + */ + +#define KBD_STATUS_REG 0x64 /* Status register (R) */ +#define KBD_CNTL_REG 0x64 /* Controller command register (W) */ +#define KBD_DATA_REG 0x60 /* Keyboard data register (R/W) */ + +/* + * Keyboard Controller Commands + */ + +#define KBD_CCMD_READ_MODE 0x20 /* Read mode bits */ +#define KBD_CCMD_WRITE_MODE 0x60 /* Write mode bits */ +#define KBD_CCMD_GET_VERSION 0xA1 /* Get controller version */ +#define KBD_CCMD_MOUSE_DISABLE 0xA7 /* Disable mouse interface */ +#define KBD_CCMD_MOUSE_ENABLE 0xA8 /* Enable mouse interface */ +#define KBD_CCMD_TEST_MOUSE 0xA9 /* Mouse interface test */ +#define KBD_CCMD_SELF_TEST 0xAA /* Controller self test */ +#define KBD_CCMD_KBD_TEST 0xAB /* Keyboard interface test */ +#define KBD_CCMD_KBD_DISABLE 0xAD /* Keyboard interface disable */ +#define KBD_CCMD_KBD_ENABLE 0xAE /* Keyboard interface enable */ +#define KBD_CCMD_WRITE_AUX_OBUF 0xD3 /* Write to output buffer as if + initiated by the auxiliary device */ +#define KBD_CCMD_WRITE_MOUSE 0xD4 /* Write the following byte to the mouse */ + +/* + * Keyboard Commands + */ + +#define KBD_CMD_SET_LEDS 0xED /* Set keyboard leds */ +#define KBD_CMD_SET_RATE 0xF3 /* Set typematic rate */ +#define KBD_CMD_ENABLE 0xF4 /* Enable scanning */ +#define KBD_CMD_DISABLE 0xF5 /* Disable scanning */ +#define KBD_CMD_RESET 0xFF /* Reset */ + +/* + * Keyboard Replies + */ + +#define KBD_REPLY_POR 0xAA /* Power on reset */ +#define KBD_REPLY_ACK 0xFA /* Command ACK */ +#define KBD_REPLY_RESEND 0xFE /* Command NACK, send the cmd again */ + +/* + * Status Register Bits + */ + +#define KBD_STAT_OBF 0x01 /* Keyboard output buffer full */ +#define KBD_STAT_IBF 0x02 /* Keyboard input buffer full */ +#define KBD_STAT_SELFTEST 0x04 /* Self test successful */ +#define KBD_STAT_CMD 0x08 /* Last write was a command write (0=data) */ +#define KBD_STAT_UNLOCKED 0x10 /* Zero if keyboard locked */ +#define KBD_STAT_MOUSE_OBF 0x20 /* Mouse output buffer full */ +#define KBD_STAT_GTO 0x40 /* General receive/xmit timeout */ +#define KBD_STAT_PERR 0x80 /* Parity error */ + +#define AUX_STAT_OBF (KBD_STAT_OBF | KBD_STAT_MOUSE_OBF) + +/* + * Controller Mode Register Bits + */ + +#define KBD_MODE_KBD_INT 0x01 /* Keyboard data generate IRQ1 */ +#define KBD_MODE_MOUSE_INT 0x02 /* Mouse data generate IRQ12 */ +#define KBD_MODE_SYS 0x04 /* The system flag (?) */ +#define KBD_MODE_NO_KEYLOCK 0x08 /* The keylock doesn't affect the keyboard if set */ +#define KBD_MODE_DISABLE_KBD 0x10 /* Disable keyboard interface */ +#define KBD_MODE_DISABLE_MOUSE 0x20 /* Disable mouse interface */ +#define KBD_MODE_KCC 0x40 /* Scan code conversion to PC format */ +#define KBD_MODE_RFU 0x80 + +/* + * Mouse Commands + */ + +#define AUX_SET_RES 0xE8 /* Set resolution */ +#define AUX_SET_SCALE11 0xE6 /* Set 1:1 scaling */ +#define AUX_SET_SCALE21 0xE7 /* Set 2:1 scaling */ +#define AUX_GET_SCALE 0xE9 /* Get scaling factor */ +#define AUX_SET_STREAM 0xEA /* Set stream mode */ +#define AUX_SET_SAMPLE 0xF3 /* Set sample rate */ +#define AUX_ENABLE_DEV 0xF4 /* Enable aux device */ +#define AUX_DISABLE_DEV 0xF5 /* Disable aux device */ +#define AUX_RESET 0xFF /* Reset aux device */ +#define AUX_ACK 0xFA /* Command byte ACK. */ + +#define AUX_BUF_SIZE 2048 + /* This might be better divisible by + three to make overruns stay in sync + but then the read function would need + a lock etc - ick */ + +#define kbd_read_input() inb(KBD_DATA_REG) +#define kbd_read_status() inb(KBD_STATUS_REG) +#define kbd_write_output(val) outb(val, KBD_DATA_REG) +#define kbd_write_command(val) outb(val, KBD_CNTL_REG) + diff -Naur linux-2.6.35.4/kernel/debug/mdb/mdb-list.c linux-2.6.35.4-cs/kernel/debug/mdb/mdb-list.c --- linux-2.6.35.4/kernel/debug/mdb/mdb-list.c 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/mdb-list.c 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,635 @@ + +/*************************************************************************** +* +* Copyright (c) 2008 Jeff V. Merkey All Rights Reserved. +* jeffmerkey@gmail.com +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation, version 2. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You are free to modify and re-distribute this program in accordance +* with the terms specified in the GNU Public License. The copyright +* contained in this code is required to be present in any derivative +* works and you are required to provide the source code for this +* program as part of any commercial or non-commercial distribution. +* You are required to respect the rights of the Copyright holders +* named within this code. +* +* jeffmerkey@gmail.com is the official maintainer of +* this code. You are encouraged to report any bugs, problems, fixes, +* suggestions, and comments about this software. +* +* AUTHOR : Jeff V. Merkey +* DESCRIP : Merkey's Linux Debugger +* +***************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define __KERNEL_SYSCALLS__ +#include +#include + +#include "mdb.h" +#include "mdb-ia.h" +#include "mdb-list.h" +#include "mdb-ia-proc.h" +#include "mdb-base.h" +#include "mdb-proc.h" +#include "mdb-os.h" +#include "mdb-keyboard.h" + +#ifdef MDB_ATOMIC +static spinlock_t accelLock = SPIN_LOCK_UNLOCKED; +static long accelflags; +#endif + +ACCELERATOR *accelHead; +ACCELERATOR *accelTail; + +unsigned long AccelRoutine(unsigned long key, void *p) +{ + register ACCELERATOR *accel; + unsigned long retCode; + + accel = accelHead; + while (accel) + { + if (accel->accelFlags && accel->accelRoutine && accel->key == key) + { + retCode = (accel->accelRoutine)(key, p, accel); + return retCode; + } + accel = accel->accelNext; + } + return 0; +} + +void ShowDebuggerAccelerators(void) +{ + register ACCELERATOR *accel; + + DBGPrint("\nDebugger Keystroke Accelerator(s)\n"); + + accel = accelHead; + while (accel) + { + if (accel->shortHelp) + if (DBGPrint("%s\n", accel->shortHelp)) return; + accel = accel->accelNext; + } + return; +} + +unsigned long IsAccelerator(unsigned long key) +{ + register ACCELERATOR *accel; + + accel = accelHead; + while (accel) + { + if (accel->accelFlags && accel->accelRoutine && accel->key == key) + { + return 1; + } + accel = accel->accelNext; + } + return 0; +} + +unsigned long AccelHelpRoutine(unsigned long key) +{ + register ACCELERATOR *accel; + + accel = accelHead; + if (key) /* if we were passed a command string */ + { + while (accel) + { + if (accel->accelFlags && accel->key == key) + { + if (accel->accelRoutineHelp) + { + DBGPrint("Accelerator %08X\n", (unsigned)accel->key); + (accel->accelRoutineHelp)(key, accel); + return 1; + } + DBGPrint("Accelerator %08X\n", (unsigned)accel->key); + return 1; + } + accel = accel->accelNext; + } + DBGPrint("Help for Accelerator [%08X] not found\n", (unsigned)key); + return 1; + } + else + { + DBGPrint("Accelerator(s)\n"); + while (accel) + { + if (accel->accelFlags && accel->key && !accel->supervisorCommand) + DBGPrint("%08X - %s\n", + (unsigned)accel->key, accel->shortHelp); + accel = accel->accelNext; + } + } + return 0; +} + +ACCELERATOR *insertAccel(ACCELERATOR *i, ACCELERATOR *top) +{ + ACCELERATOR *old, *p; + + if (!accelTail) + { + i->accelNext = i->accelPrior = NULL; + accelTail = i; + return i; + } + p = top; + old = NULL; + while (p) + { + if (p->key < i->key) + { + old = p; + p = p->accelNext; + } + else + { + if (p->accelPrior) + { + p->accelPrior->accelNext = i; + i->accelNext = p; + i->accelPrior = p->accelPrior; + p->accelPrior = i; + return top; + } + i->accelNext = p; + i->accelPrior = NULL; + p->accelPrior = i; + return i; + } + } + old->accelNext = i; + i->accelNext = NULL; + i->accelPrior = old; + accelTail = i; + return accelHead; + +} + +unsigned long AddAccelRoutine(ACCELERATOR *newAccel) +{ + register ACCELERATOR *accel; + +#ifdef MDB_ATOMIC + spin_lock_irqsave(&accelLock, accelflags); +#endif + accel = accelHead; + while (accel) + { + if (accel == newAccel || accel->key == newAccel->key) + { +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&accelLock, accelflags); +#endif + return 1; + } + accel = accel->accelNext; + } + newAccel->accelFlags = -1; + accelHead = insertAccel(newAccel, accelHead); + +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&accelLock, accelflags); +#endif + return 0; +} + +unsigned long RemoveAccelRoutine(ACCELERATOR *newAccel) +{ + register ACCELERATOR *accel; + +#ifdef MDB_ATOMIC + spin_lock_irqsave(&accelLock, accelflags); +#endif + accel = accelHead; + while (accel) + { + if (accel == newAccel) /* found, remove from list */ + { + if (accelHead == newAccel) + { + accelHead = (void *) newAccel->accelNext; + if (accelHead) + accelHead->accelPrior = NULL; + else + accelTail = NULL; + } + else + { + newAccel->accelPrior->accelNext = newAccel->accelNext; + if (newAccel != accelTail) + newAccel->accelNext->accelPrior = newAccel->accelPrior; + else + accelTail = newAccel->accelPrior; + } + newAccel->accelNext = newAccel->accelPrior = 0; + newAccel->accelFlags = 0; + +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&accelLock, accelflags); +#endif + return 0; + } + accel = accel->accelNext; + } + +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&accelLock, accelflags); +#endif + return -1; +} + +#ifdef MDB_ATOMIC +static spinlock_t altDebugLock = SPIN_LOCK_UNLOCKED; +static long altflags; +#endif + +ALT_DEBUGGER *altDebugHead; +ALT_DEBUGGER *altDebugTail; + +int AlternateDebuggerRoutine(int reason, int error, void *frame) +{ + register ALT_DEBUGGER *altDebug; + register unsigned long retCode; + unsigned long state; + + state = save_flags(); + altDebug = altDebugHead; + while (altDebug) + { + if (altDebug->AlternateDebugger) + { + retCode = (altDebug->AlternateDebugger)(reason, error, frame); + if (retCode) + { + restore_flags(state); + return retCode; + } + } + altDebug = altDebug->altDebugNext; + } + restore_flags(state); + return 0; +} + +unsigned long AddAlternateDebugger(ALT_DEBUGGER *Debugger) +{ + register ALT_DEBUGGER *altDebug; + +#ifdef MDB_ATOMIC + spin_lock_irqsave(&altDebugLock, altflags); +#endif + altDebug = altDebugHead; + while (altDebug) + { + if (altDebug == Debugger) + { +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&altDebugLock, altflags); +#endif + return 1; + } + altDebug = altDebug->altDebugNext; + } + if (!altDebugHead) + { + altDebugHead = Debugger; + altDebugTail = Debugger; + Debugger->altDebugNext = 0; + Debugger->altDebugPrior = 0; + } + else + { + altDebugTail->altDebugNext = Debugger; + Debugger->altDebugNext = 0; + Debugger->altDebugPrior = altDebugTail; + altDebugTail = Debugger; + } + +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&altDebugLock, altflags); +#endif + return 0; +} + +unsigned long RemoveAlternateDebugger(ALT_DEBUGGER *Debugger) +{ + register ALT_DEBUGGER *altDebug; + +#ifdef MDB_ATOMIC + spin_lock_irqsave(&altDebugLock, altflags); +#endif + altDebug = altDebugHead; + while (altDebug) + { + if (altDebug == Debugger) /* found, remove from list */ + { + if (altDebugHead == Debugger) + { + altDebugHead = (void *) Debugger->altDebugNext; + if (altDebugHead) + altDebugHead->altDebugPrior = NULL; + else + altDebugTail = NULL; + } + else + { + Debugger->altDebugPrior->altDebugNext = Debugger->altDebugNext; + if (Debugger != altDebugTail) + Debugger->altDebugNext->altDebugPrior = Debugger->altDebugPrior; + else + altDebugTail = Debugger->altDebugPrior; + } + Debugger->altDebugNext = Debugger->altDebugPrior = 0; + +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&altDebugLock, altflags); +#endif + return 0; + } + altDebug = altDebug->altDebugNext; + } +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&altDebugLock, altflags); +#endif + return -1; +} + +#ifdef MDB_ATOMIC +static spinlock_t debugParserLock = SPIN_LOCK_UNLOCKED; +static long parserflags; +#endif + +DEBUGGER_PARSER *debugParserHead; +DEBUGGER_PARSER *debugParserTail; + +unsigned long DebuggerParserRoutine(unsigned char *command, unsigned char *commandLine, + StackFrame *stackFrame, unsigned long Exception) +{ + register DEBUGGER_PARSER *debugParser; + register unsigned long retCode, valid = 0, length; + register unsigned char *p; + + p = commandLine; + if (!p) + return 0; + + /* if a passed string is just whitespace, return error */ + while (*p) + { + if ((*p != ' ') && (*p != '\n') && (*p != '\r')) + { + valid = 1; + break; + } + p++; + } + if (!valid) + return 0; + + UpcaseString(command); + length = strlen(command); + + debugParser = debugParserHead; + while (debugParser) + { + if (debugParser->parserFlags && debugParser->DebugCommandParser && + (debugParser->debugCommandNameLength == length) && + (!strcmp(debugParser->debugCommandName, command))) + { + retCode = (debugParser->DebugCommandParser)(commandLine, stackFrame, + Exception, debugParser); + if (retCode) + return retCode; + } + debugParser = debugParser->debugNext; + } + + DBGPrint("unknown mdb command -> %s\n", command); + return 0; +} + +unsigned long DebuggerParserHelpRoutine(unsigned char *command, unsigned char *commandLine) +{ + extern void ShowDebuggerAccelerators(void); + register DEBUGGER_PARSER *debugParser; + register unsigned long length; + + UpcaseString(command); + length = strlen(command); + if (*command) /* if we were passed a command string */ + { + + debugParser = debugParserHead; + while (debugParser) + { + if (debugParser->parserFlags && + (debugParser->debugCommandNameLength == length) && + !strcmp(debugParser->debugCommandName, command)) + { + if (debugParser->DebugCommandParserHelp) + { + DBGPrint("Help for Command %s\n", + debugParser->debugCommandName); + (debugParser->DebugCommandParserHelp)(commandLine, debugParser); + return 1; + } + DBGPrint("Help for Command %s\n", debugParser->debugCommandName); + return 1; + } + debugParser = debugParser->debugNext; + } + + DBGPrint("Help for Command [%s] not found\n", command); + return 1; + } + else + { + DBGPrint("Debugger Command(s)\n"); + + debugParser = debugParserHead; + while (debugParser) + { + if (debugParser->parserFlags && debugParser->debugCommandName && + !debugParser->supervisorCommand) + if (DBGPrint("%15s - %s\n", debugParser->debugCommandName, + debugParser->shortHelp)) return 0; + debugParser = debugParser->debugNext; + } + ShowDebuggerAccelerators(); + } + return 0; +} + +DEBUGGER_PARSER *insertDebuggerParser(DEBUGGER_PARSER *i, DEBUGGER_PARSER *top) +{ + DEBUGGER_PARSER *old, *p; + + if (!debugParserTail) + { + i->debugNext = i->debugPrior = NULL; + debugParserTail = i; + return i; + } + p = top; + old = NULL; + while (p) + { + if (strcmp(p->debugCommandName, i->debugCommandName) < 0) + { + old = p; + p = p->debugNext; + } + else + { + if (p->debugPrior) + { + p->debugPrior->debugNext = i; + i->debugNext = p; + i->debugPrior = p->debugPrior; + p->debugPrior = i; + return top; + } + i->debugNext = p; + i->debugPrior = NULL; + p->debugPrior = i; + return i; + } + } + old->debugNext = i; + i->debugNext = NULL; + i->debugPrior = old; + debugParserTail = i; + return debugParserHead; + +} + +unsigned long AddDebuggerCommandParser(DEBUGGER_PARSER *parser) +{ + register DEBUGGER_PARSER *debugParser; + +#ifdef MDB_ATOMIC + spin_lock_irqsave(&debugParserLock, parserflags); +#endif + parser->parserFlags = -1; + parser->debugCommandNameLength = strlen(parser->debugCommandName); + + debugParser = debugParserHead; + while (debugParser) + { + if (debugParser == parser || + (parser->debugCommandNameLength == + debugParser->debugCommandNameLength && + (!strcmp(parser->debugCommandName, debugParser->debugCommandName)))) + { +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&debugParserLock, parserflags); +#endif + return 1; + } + debugParser = debugParser->debugNext; + } + + debugParserHead = insertDebuggerParser(parser, debugParserHead); + +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&debugParserLock, parserflags); +#endif + return 0; +} + +unsigned long RemoveDebuggerCommandParser(DEBUGGER_PARSER *parser) +{ + register DEBUGGER_PARSER *debugParser; + +#ifdef MDB_ATOMIC + spin_lock_irqsave(&debugParserLock, parserflags); +#endif + debugParser = debugParserHead; + while (debugParser) + { + if (debugParser == parser) /* found, remove from list */ + { + if (debugParserHead == parser) + { + debugParserHead = (void *) parser->debugNext; + if (debugParserHead) + debugParserHead->debugPrior = NULL; + else + debugParserTail = NULL; + } + else + { + parser->debugPrior->debugNext = parser->debugNext; + if (parser != debugParserTail) + parser->debugNext->debugPrior = parser->debugPrior; + else + debugParserTail = parser->debugPrior; + } + parser->debugNext = parser->debugPrior = 0; + parser->parserFlags = 0; + +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&debugParserLock, parserflags); +#endif + return 0; + } + debugParser = debugParser->debugNext; + } +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&debugParserLock, parserflags); +#endif + return -1; +} + diff -Naur linux-2.6.35.4/kernel/debug/mdb/mdb-list.h linux-2.6.35.4-cs/kernel/debug/mdb/mdb-list.h --- linux-2.6.35.4/kernel/debug/mdb/mdb-list.h 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/mdb-list.h 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,100 @@ + +/*************************************************************************** +* +* Copyright (c) 2008 Jeff V. Merkey All Rights Reserved. +* jeffmerkey@gmail.com +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation, version 2. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You are free to modify and re-distribute this program in accordance +* with the terms specified in the GNU Public License. The copyright +* contained in this code is required to be present in any derivative +* works and you are required to provide the source code for this +* program as part of any commercial or non-commercial distribution. +* You are required to respect the rights of the Copyright holders +* named within this code. +* +* jeffmerkey@gmail.com is the official maintainer of +* this code. You are encouraged to report any bugs, problems, fixes, +* suggestions, and comments about this software. +* +* AUTHOR : Jeff V. Merkey +* DESCRIP : Merkey's Linux Debugger +* +***************************************************************************/ + +#ifndef _MDB_LIST +#define _MDB_LIST + +typedef struct _ACCELERATOR +{ + struct _ACCELERATOR *accelNext; + struct _ACCELERATOR *accelPrior; + unsigned long (*accelRoutine)(unsigned long key, void *p, struct _ACCELERATOR *parser); + unsigned long (*accelRoutineHelp)(unsigned long key, struct _ACCELERATOR *parser); + unsigned long accelFlags; + unsigned long key; + unsigned long supervisorCommand; + unsigned char *shortHelp; +} ACCELERATOR; + +typedef struct _ALT_DEBUGGER +{ + struct _ALT_DEBUGGER *altDebugNext; + struct _ALT_DEBUGGER *altDebugPrior; + int (*AlternateDebugger)(int reason, int error, void *frame); +} ALT_DEBUGGER; + +extern int AlternateDebuggerRoutine(int reason, int error, void *frame); +extern unsigned long AddAlternateDebugger(ALT_DEBUGGER *Debugger); +extern unsigned long RemoveAlternateDebugger(ALT_DEBUGGER *Debugger); + +typedef struct _DEBUGGER_PARSER { + struct _DEBUGGER_PARSER *debugNext; + struct _DEBUGGER_PARSER *debugPrior; + unsigned long (*DebugCommandParser)(unsigned char *commandLine, + StackFrame *stackFrame, unsigned long Exception, + struct _DEBUGGER_PARSER *parser); + unsigned long (*DebugCommandParserHelp)(unsigned char *commandLine, + struct _DEBUGGER_PARSER *parser); + unsigned long parserFlags; + unsigned char *debugCommandName; + unsigned long debugCommandNameLength; + unsigned long supervisorCommand; + unsigned char *shortHelp; + unsigned long controlTransfer; +} DEBUGGER_PARSER; + +typedef struct _DEBUGGER_LIST +{ + DEBUGGER_PARSER *head; + DEBUGGER_PARSER *tail; +} DEBUGGER_LIST; + +extern unsigned long DebuggerParserRoutine(unsigned char *command, unsigned char *commandLine, + StackFrame *stackFrame, unsigned long Exception); +extern unsigned long DebuggerParserHelpRoutine(unsigned char *command, unsigned char *commandLine); +extern unsigned long AddDebuggerCommandParser(DEBUGGER_PARSER *parser); +extern unsigned long RemoveDebuggerCommandParser(DEBUGGER_PARSER *parser); + +static inline unsigned long strhash(unsigned char *s, int len, int limit) +{ + register unsigned long h = 0, a = 127, i; + + if (!limit) + return -1; + + for (i = 0; i < len && *s; s++, i++) + h = ((a * h) + *s) % limit; + + return h; +} + +#endif diff -Naur linux-2.6.35.4/kernel/debug/mdb/mdb-logic.c linux-2.6.35.4-cs/kernel/debug/mdb/mdb-logic.c --- linux-2.6.35.4/kernel/debug/mdb/mdb-logic.c 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/mdb-logic.c 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,3116 @@ + +/*************************************************************************** +* +* Copyright (c) 2008 Jeff V. Merkey All Rights Reserved. +* jeffmerkey@gmail.com +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation, version 2. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You are free to modify and re-distribute this program in accordance +* with the terms specified in the GNU Public License. The copyright +* contained in this code is required to be present in any derivative +* works and you are required to provide the source code for this +* program as part of any commercial or non-commercial distribution. +* You are required to respect the rights of the Copyright holders +* named within this code. +* +* jeffmerkey@gmail.com is the official maintainer of +* this code. You are encouraged to report any bugs, problems, fixes, +* suggestions, and comments about this software. +* +* AUTHOR : Jeff V. Merkey +* DESCRIP : Merkey's Linux Debugger +* +***************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define __KERNEL_SYSCALLS__ +#include +#include + +#include "mdb.h" +#include "mdb-ia.h" +#include "mdb-list.h" +#include "mdb-ia-proc.h" +#include "mdb-base.h" +#include "mdb-proc.h" +#include "mdb-os.h" +#include "mdb-keyboard.h" + +#ifdef CONFIG_X86_64 +#define PROCESSOR_WIDTH 64 +#else +#define PROCESSOR_WIDTH 32 +#endif + +#define DEBUG_EXPRESS 0 +#define DEBUG_BOOL 0 +#define DEBUG_LOGICAL 0 +#define DEBUG_LOGICAL_STACK 0 +#define DEBUG_BOOL_STACK 0 + +#define INVALID_EXPRESSION 0 +#define NUMERIC_EXPRESSION 1 +#define BOOLEAN_EXPRESSION 2 + +#define SEG_STACK_SIZE 256 +#define NUM_STACK_SIZE 256 +#define CONTEXT_STACK_SIZE 1024 +#define BOOL_STACK_SIZE 256 +#define LOGICAL_STACK_SIZE 256 + +// 0-127 token values, 8 high bit is reserved as dereference flag +#define NULL_TOKEN 0 +#define NUMBER_TOKEN 1 +#define MINUS_TOKEN 2 +#define PLUS_TOKEN 3 +#define MULTIPLY_TOKEN 4 +#define DIVIDE_TOKEN 5 +#define GREATER_TOKEN 6 +#define LESS_TOKEN 7 +#define XOR_TOKEN 8 +#define AND_TOKEN 9 +#define OR_TOKEN 10 +#define NOT_TOKEN 11 +#define NEG_TOKEN 12 +#define EQUAL_TOKEN 13 +#define LEFT_SHIFT_TOKEN 14 +#define RIGHT_SHIFT_TOKEN 15 +#define SPACE_TOKEN 16 +#define FLAGS_TOKEN 17 +#define AX_TOKEN 18 +#define BX_TOKEN 19 +#define CX_TOKEN 20 +#define DX_TOKEN 21 +#define SI_TOKEN 22 +#define DI_TOKEN 23 +#define BP_TOKEN 24 +#define SP_TOKEN 25 +#define CS_TOKEN 26 +#define DS_TOKEN 27 +#define ES_TOKEN 28 +#define FS_TOKEN 29 +#define GS_TOKEN 30 +#define SS_TOKEN 31 +#define DREF_OPEN_TOKEN 32 +#define DREF_CLOSE_TOKEN 33 +#define MOD_TOKEN 34 +#define NUMBER_END 35 +#define GREATER_EQUAL_TOKEN 36 +#define LESS_EQUAL_TOKEN 37 +#define IP_TOKEN 38 +#define ASSIGNMENT_TOKEN 39 +#define DWORD_TOKEN 40 +#define WORD_TOKEN 41 +#define BYTE_TOKEN 42 +#define LOGICAL_AND_TOKEN 43 +#define LOGICAL_OR_TOKEN 44 +#define CF_TOKEN 45 +#define PF_TOKEN 46 +#define AF_TOKEN 47 +#define ZF_TOKEN 48 +#define SF_TOKEN 49 +#define IF_TOKEN 50 +#define DF_TOKEN 51 +#define OF_TOKEN 52 +#define VM_TOKEN 53 +#define AC_TOKEN 54 +#define BB_TOKEN 55 +#define EB_TOKEN 56 +#define NOT_EQUAL_TOKEN 57 +#define INVALID_NUMBER_TOKEN 58 +#define QWORD_TOKEN 59 +#define R8_TOKEN 60 +#define R9_TOKEN 61 +#define R10_TOKEN 62 +#define R11_TOKEN 63 +#define R12_TOKEN 64 +#define R13_TOKEN 65 +#define R14_TOKEN 66 +#define R15_TOKEN 67 +#define CS_ADDR_TOKEN 68 +#define DS_ADDR_TOKEN 69 +#define ES_ADDR_TOKEN 70 +#define FS_ADDR_TOKEN 71 +#define GS_ADDR_TOKEN 72 +#define SS_ADDR_TOKEN 73 +// limit is 0-127 + +#define CF_FLAG 0x00000001 +#define PF_FLAG 0x00000004 +#define AF_FLAG 0x00000010 +#define ZF_FLAG 0x00000040 +#define SF_FLAG 0x00000080 +#define TF_FLAG 0x00000100 /* ss flag */ +#define IF_FLAG 0x00000200 +#define DF_FLAG 0x00000400 +#define OF_FLAG 0x00000800 +#define NT_FLAG 0x00004000 +#define RF_FLAG 0x00010000 /* resume flag */ +#define VM_FLAG 0x00020000 +#define AC_FLAG 0x00040000 +#define VIF_FLAG 0x00080000 +#define VIP_FLAG 0x00100000 +#define ID_FLAG 0x00200000 + +#define ARCH_PTR 0 +#define ULONG_PTR 1 +#define WORD_PTR 2 +#define BYTE_PTR 3 +#define ULONGLONG_PTR 4 + +#define CLASS_DATA 1 +#define CLASS_ASSIGN 2 +#define CLASS_PARTITION 3 +#define CLASS_ARITHMETIC 4 +#define CLASS_BOOLEAN 5 + +unsigned char *exprDescription[]={ + "INVALID", + "NUMERIC", + "BOOLEAN", + "???????", +}; + +unsigned char *parserDescription[]={ + "NULL_TOKEN", + "NUMBER_TOKEN", + "MINUS_TOKEN", + "PLUS_TOKEN", + "MULTIPLY_TOKEN", + "DIVIDE_TOKEN", + "GREATER_TOKEN", + "LESS_TOKEN", + "XOR_TOKEN", + "AND_TOKEN", + "OR_TOKEN", + "NOT_TOKEN", + "NEG_TOKEN", + "EQUAL_TOKEN", + "LEFT_SHIFT_TOKEN", + "RIGHT_SHIFT_TOKEN", + "SPACE_TOKEN", + "FLAGS_TOKEN", + "AX_TOKEN", + "BX_TOKEN", + "CX_TOKEN", + "DX_TOKEN", + "SI_TOKEN", + "DI_TOKEN", + "BP_TOKEN", + "SP_TOKEN", + "CS_TOKEN", + "DS_TOKEN", + "ES_TOKEN", + "FS_TOKEN", + "GS_TOKEN", + "SS_TOKEN", + "DREF_OPEN_TOKEN", + "DREF_CLOSE_TOKEN", + "MOD_TOKEN", + "NUMBER_END", + "GREATER_EQUAL_TOKEN", + "LESS_EQUAL_TOKEN", + "IP_TOKEN", + "ASSIGNMENT_TOKEN", + "DWORD_TOKEN", + "WORD_TOKEN", + "BYTE_TOKEN", + "LOGICAL_AND_TOKEN", + "LOGICAL_OR_TOKEN", + "CF_TOKEN", + "PF_TOKEN", + "AF_TOKEN", + "ZF_TOKEN", + "SF_TOKEN", + "IF_TOKEN", + "DF_TOKEN", + "OF_TOKEN", + "VM_TOKEN", + "AC_TOKEN", + "BEGIN_BRACKET", + "END_BRACKET", + "NOT_EQUAL_TOKEN", + "INVALID_NUMBER_TOKEN", + "QWORD_TOKEN", + "R8_TOKEN", + "R9_TOKEN", + "R10_TOKEN", + "R11_TOKEN", + "R12_TOKEN", + "R13_TOKEN", + "R14_TOKEN", + "R15_TOKEN", + "CS_ADDR_TOKEN", + "DS_ADDR_TOKEN", + "ES_ADDR_TOKEN", + "FS_ADDR_TOKEN", + "GS_ADDR_TOKEN", + "SS_ADDR_TOKEN", +}; + +static unsigned char TokenIndex[256]; +static unsigned char TokenType[256]; +static unsigned long long TokenValue[256]; +static unsigned long long TokenCount; + +static unsigned long long numStack[NUM_STACK_SIZE]; +static unsigned long long *sp; +static unsigned long long *tos; +static unsigned long long *bos; + +static unsigned long long segStack[SEG_STACK_SIZE]; +static unsigned long long *s_sp; +static unsigned long long *s_tos; +static unsigned long long *s_bos; + +static unsigned long long contextStack[CONTEXT_STACK_SIZE]; +static unsigned long long *c_sp; +static unsigned long long *c_tos; +static unsigned long long *c_bos; + +static unsigned long long booleanStack[BOOL_STACK_SIZE]; +static unsigned long long *b_sp; +static unsigned long long *b_tos; +static unsigned long long *b_bos; + +static unsigned long long logicalStack[LOGICAL_STACK_SIZE]; +static unsigned long long *l_sp; +static unsigned long long *l_tos; +static unsigned long long *l_bos; + +extern unsigned long GetValueFromSymbol(unsigned char *symbolName); +extern unsigned char delim_table[256]; + +#ifdef LINUX_DRIVER +spinlock_t expressLock = SPIN_LOCK_UNLOCKED; +static long flags; +#endif + +static inline unsigned long long GetNumber(unsigned char *p, + unsigned char **rp, + unsigned long *opl, + unsigned long *retCode, + unsigned long mode) +{ + + unsigned char *op, *pp = NULL; + unsigned long long c = 0; + unsigned long decimal = 0, hex_found = 0, invalid = 0, valid = 0; + + pp = op = p; + while (*p) + { + if (!strncasecmp(p, "0x", 2)) + { + hex_found = 1; + p++; + p++; + pp = p; + } + + if (*p == 'X' || *p == 'x') + { + hex_found = 1; + p++; + pp = p; + } + + if (*p >= '0' && *p <= '9') + { + valid++; + p++; + } + else + if (*p >= 'A' && *p <= 'F') + { + hex_found = 1; + valid++; + p++; + } + else + if (*p >= 'a' && *p <= 'f') + { + hex_found = 1; + valid++; + p++; + } + else + if ((*p == 'R') || (*p == 'r')) + { + decimal = 1; + p++; + } + else + if (delim_table[((*p) & 0xFF)]) + break; + else + { + invalid = 1; + break; + } + } + + if (rp) + *rp = p; + if (opl) + *opl = (unsigned long)((unsigned long)p - (unsigned long) op); + + if (invalid && !valid) + { + if (retCode) + *retCode = -1; /* invalid string */ + return 0; + } + + p = pp; + + if (mode) + decimal = 1; + + if (hex_found) + { + /* parse as hex number */ + while (*p) + { + if (*p >= '0' && *p <= '9') + c = (c << 4) | (*p - '0'); + else if (*p >= 'A' && *p <= 'F') + c = (c << 4) | (*p - 'A' + 10); + else if (*p >= 'a' && *p <= 'f') + c = (c << 4) | (*p - 'a' + 10); + else + break; + p++; + } + } + else + if (decimal) + { + /* parse as decimal number */ + while (*p) + { + if (*p >= '0' && *p <= '9') + c = (c * 10) + (*p - '0'); + else + break; + p++; + } + } + else /* default parses as decimal */ + { + /* parse as decimal number */ + while (*p) + { + if (*p >= '0' && *p <= '9') + c = (c * 10) + (*p - '0'); + else + break; + p++; + } + } + + if (retCode) + *retCode = 0; + + return (c); + +} + +static inline unsigned char *parseTokens(StackFrame *stackFrame, + unsigned char *p, + unsigned long mode) +{ + register unsigned long i, value; + unsigned char symbol[256], *s; + unsigned char *tmp, *op; + unsigned long delta, retCode = 0; + + op = p; + TokenCount = 0; + while (TokenCount < 200 && (unsigned long)p - (unsigned long)op < 200) + { + if (isalpha(*p) || *p == '_' || *p == '@' || *p == '$') + { + s = p; + for (i = 0; i < 255; i++) + { + if (delim_table[((s[i]) & 0xFF)]) + break; + + if (!isprint(s[i])) + break; + + symbol[i] = s[i]; + } + symbol[i] = '\0'; + + value = GetValueFromSymbol(symbol); + if (value) + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenValue[TokenCount] = value; + TokenType[TokenCount++] = NUMBER_TOKEN; + p = &s[i]; /* bump the pointer past the symbol */ + } + } + + if (stackFrame) + { + switch (*p) + { + + case '\0': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = NULL_TOKEN; + return (p); + + case ']': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = DREF_CLOSE_TOKEN; + p++; + break; + + case '(': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = BB_TOKEN; + p++; + break; + + case ')': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = EB_TOKEN; + p++; + break; + + case '+': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = PLUS_TOKEN; + p++; + break; + + case '-': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = MINUS_TOKEN; + p++; + break; + + case '*': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = MULTIPLY_TOKEN; + p++; + break; + + case '/': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = DIVIDE_TOKEN; + p++; + break; + + case '%': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = MOD_TOKEN; + p++; + break; + + case '~': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = NEG_TOKEN; + p++; + break; + + case '^': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = XOR_TOKEN; + p++; + break; + + case '!': + p++; + if (*p == '=') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = NOT_EQUAL_TOKEN; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = NOT_TOKEN; + break; + + case ' ': /* drop spaces on the floor */ + p++; + break; + + /* + * These cases require special handling + */ + + case 'p': + case 'P': + p++; + if (*p == 'F' || *p == 'f') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSystemFlags & PF_FLAG; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = PF_TOKEN; + p++; + break; + } + break; + + case 'z': + case 'Z': + p++; + if (*p == 'F' || *p == 'f') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSystemFlags & ZF_FLAG; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = ZF_TOKEN; + p++; + break; + } + break; + + case 'i': + case 'I': + tmp = p; + tmp++; + if (*tmp == 'F' || *tmp == 'f') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSystemFlags & IF_FLAG; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = IF_TOKEN; + p++; + p++; + break; + } + if ((*tmp == 'P' || *tmp == 'p')) + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tIP; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = IP_TOKEN; + p++; + p++; + break; + } + p++; + break; + + case 'o': + case 'O': + p++; + if (*p == 'F' || *p == 'f') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSystemFlags & OF_FLAG; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = OF_TOKEN; + p++; + break; + } + break; + + case 'v': + case 'V': + p++; + if (*p == 'M' || *p == 'm') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSystemFlags & VM_FLAG; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = VM_TOKEN; + p++; + break; + } + break; + + case 'x': + case 'X': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenValue[TokenCount] = GetNumber(p, &p, &delta, &retCode, mode); + ((retCode) ? (TokenType[TokenCount++] = INVALID_NUMBER_TOKEN) + : (TokenType[TokenCount++] = NUMBER_TOKEN)); + break; + + case 'a': + case 'A': + tmp = p; + tmp++; + if ((*tmp == 'F' || *tmp == 'f') && (*(tmp + 1) == ' ' || *(tmp + 1) == '=' )) + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSystemFlags & AF_FLAG; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = AF_TOKEN; + p++; + p++; + break; + } + if ((*tmp == 'C' || *tmp == 'c') && (*(tmp + 1) == ' ' || *(tmp + 1) == '=' )) + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSystemFlags & AC_FLAG; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = AC_TOKEN; + p++; + p++; + break; + } + if ((*tmp == 'X' || *tmp == 'x')) + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tAX; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = AX_TOKEN; + p++; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenValue[TokenCount] = GetNumber(p, &p, &delta, &retCode, mode); + ((retCode) ? (TokenType[TokenCount++] = INVALID_NUMBER_TOKEN) + : (TokenType[TokenCount++] = NUMBER_TOKEN)); + break; + + + case 'b': + case 'B': + tmp = p; + tmp++; + if ((*tmp == 'X' || *tmp == 'x')) + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tBX; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = BX_TOKEN; + p++; + p++; + break; + } + if ((*tmp == 'P' || *tmp == 'p')) + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tBP; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = BP_TOKEN; + p++; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenValue[TokenCount] = GetNumber(p, &p, &delta, &retCode, mode); + ((retCode) ? (TokenType[TokenCount++] = INVALID_NUMBER_TOKEN) + : (TokenType[TokenCount++] = NUMBER_TOKEN)); + break; + + case 'c': + case 'C': + tmp = p; + tmp++; + if (*tmp == 'S' || *tmp == 's') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tCS; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + p++; + p++; + if (*(tmp + 1) == ':') + { + TokenType[TokenCount] = CS_ADDR_TOKEN; + p++; + } + else + TokenType[TokenCount] = CS_TOKEN; + TokenCount++; + break; + } + if ((*tmp == 'X' || *tmp == 'x')) + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tCX; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = CX_TOKEN; + p++; + p++; + break; + } + if ((*tmp == 'F' || *tmp == 'f') && (*(tmp + 1) == ' ' || *(tmp + 1) == '=' )) + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSystemFlags & CF_FLAG; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = CF_TOKEN; + p++; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenValue[TokenCount] = GetNumber(p, &p, &delta, &retCode, mode); + ((retCode) ? (TokenType[TokenCount++] = INVALID_NUMBER_TOKEN) + : (TokenType[TokenCount++] = NUMBER_TOKEN)); + break; + + case 'd': + case 'D': + tmp = p; + tmp++; + if (*tmp == 'S' || *tmp == 's') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tDS; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + p++; + p++; + if (*(tmp + 1) == ':') + { + TokenType[TokenCount] = DS_ADDR_TOKEN; + p++; + } + else + TokenType[TokenCount] = DS_TOKEN; + TokenCount++; + break; + } + if ((*tmp == 'I' || *tmp == 'i')) + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tDI; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = DI_TOKEN; + p++; + p++; + break; + } + if ((*tmp == 'X' || *tmp == 'x')) + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tDX; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = DX_TOKEN; + p++; + p++; + break; + } + if ((*tmp == 'F' || *tmp == 'f') && (*(tmp + 1) == ' ' || *(tmp + 1) == '=' )) + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSystemFlags & DF_FLAG; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = DF_TOKEN; + p++; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenValue[TokenCount] = GetNumber(p, &p, &delta, &retCode, mode); + ((retCode) ? (TokenType[TokenCount++] = INVALID_NUMBER_TOKEN) + : (TokenType[TokenCount++] = NUMBER_TOKEN)); + break; + + case 'e': + case 'E': + tmp = p; + tmp++; + if (*tmp == 'A' || *tmp == 'a') + { + tmp++; + if (*tmp == 'X' || *tmp == 'x') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tAX; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = AX_TOKEN; + p++; + p++; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenValue[TokenCount] = GetNumber(p, &p, &delta, &retCode, + mode); + ((retCode) ? (TokenType[TokenCount++] = INVALID_NUMBER_TOKEN) + : (TokenType[TokenCount++] = NUMBER_TOKEN)); + break; + } + if (*tmp == 'B' || *tmp == 'b') + { + tmp++; + if (*tmp == 'X' || *tmp == 'x') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tBX; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = BX_TOKEN; + p++; + p++; + p++; + break; + } + if (*tmp == 'P' || *tmp == 'p') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tBP; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = BP_TOKEN; + p++; + p++; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenValue[TokenCount] = GetNumber(p, &p, &delta, &retCode, + mode); + ((retCode) ? (TokenType[TokenCount++] = INVALID_NUMBER_TOKEN) + : (TokenType[TokenCount++] = NUMBER_TOKEN)); + break; + } + if (*tmp == 'C' || *tmp == 'c') + { + tmp++; + if (*tmp == 'X' || *tmp == 'x') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tCX; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = CX_TOKEN; + p++; + p++; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenValue[TokenCount] = GetNumber(p, &p, &delta, &retCode, + mode); + ((retCode) ? (TokenType[TokenCount++] = INVALID_NUMBER_TOKEN) + : (TokenType[TokenCount++] = NUMBER_TOKEN)); + break; + } + if (*tmp == 'D' || *tmp == 'd') + { + tmp++; + if (*tmp == 'X' || *tmp == 'x') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tDX; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = DX_TOKEN; + p++; + p++; + p++; + break; + } + if (*tmp == 'I' || *tmp == 'i') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tDI; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = DI_TOKEN; + p++; + p++; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenValue[TokenCount] = GetNumber(p, &p, &delta, &retCode, + mode); + ((retCode) ? (TokenType[TokenCount++] = INVALID_NUMBER_TOKEN) + : (TokenType[TokenCount++] = NUMBER_TOKEN)); + break; + } + if (*tmp == 'S' || *tmp == 's') + { + tmp++; + if (*tmp == 'P' || *tmp == 'p') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSP; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = SP_TOKEN; + p++; + p++; + p++; + break; + } + if (*tmp == 'I' || *tmp == 'i') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSI; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = SI_TOKEN; + p++; + p++; + p++; + break; + } + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tES; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + p++; + p++; + if (*tmp == ':') + { + TokenType[TokenCount] = ES_ADDR_TOKEN; + p++; + } + else + TokenType[TokenCount] = ES_TOKEN; + TokenCount++; + break; + } + if (*tmp == 'I' || *tmp == 'i') + { + tmp++; + if (*tmp == 'P' || *tmp == 'p') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tIP; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = IP_TOKEN; + p++; + p++; + p++; + break; + } + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenValue[TokenCount] = GetNumber(p, &p, &delta, &retCode, mode); + ((retCode) ? (TokenType[TokenCount++] = INVALID_NUMBER_TOKEN) + : (TokenType[TokenCount++] = NUMBER_TOKEN)); + break; + +#ifdef CONFIG_X86_64 + case 'r': + case 'R': + tmp = p; + tmp++; + if (*tmp == 'A' || *tmp == 'a') + { + tmp++; + if (*tmp == 'X' || *tmp == 'x') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tAX; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = AX_TOKEN; + p++; + p++; + p++; + break; + } + } + if (*tmp == 'B' || *tmp == 'b') + { + tmp++; + if (*tmp == 'X' || *tmp == 'x') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tBX; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = BX_TOKEN; + p++; + p++; + p++; + break; + } + if (*tmp == 'P' || *tmp == 'p') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tBP; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = BP_TOKEN; + p++; + p++; + p++; + break; + } + } + if (*tmp == 'C' || *tmp == 'c') + { + tmp++; + if (*tmp == 'X' || *tmp == 'x') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tCX; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = CX_TOKEN; + p++; + p++; + p++; + break; + } + } + if (*tmp == 'D' || *tmp == 'd') + { + tmp++; + if (*tmp == 'X' || *tmp == 'x') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tDX; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = DX_TOKEN; + p++; + p++; + p++; + break; + } + if (*tmp == 'I' || *tmp == 'i') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tDI; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = DI_TOKEN; + p++; + p++; + p++; + break; + } + } + if (*tmp == 'S' || *tmp == 's') + { + tmp++; + if (*tmp == 'P' || *tmp == 'p') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSP; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = SP_TOKEN; + p++; + p++; + p++; + break; + } + if (*tmp == 'I' || *tmp == 'i') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSI; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = SI_TOKEN; + p++; + p++; + p++; + break; + } + } + if (*tmp == 'I' || *tmp == 'i') + { + tmp++; + if (*tmp == 'P' || *tmp == 'p') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tIP; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = IP_TOKEN; + p++; + p++; + p++; + break; + } + } + if (*tmp == '8') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->r8; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = R8_TOKEN; + p++; + p++; + break; + } + if (*tmp == '9') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->r9; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = R9_TOKEN; + p++; + p++; + break; + } + if (*tmp == '1') + { + tmp++; + if (*tmp == '0') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->r10; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = R10_TOKEN; + p++; + p++; + p++; + break; + } + if (*tmp == '1') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->r11; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = R11_TOKEN; + p++; + p++; + p++; + break; + } + if (*tmp == '2') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->r12; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = R12_TOKEN; + p++; + p++; + p++; + break; + } + if (*tmp == '3') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->r13; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = R13_TOKEN; + p++; + p++; + p++; + break; + } + if (*tmp == '4') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->r14; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = R14_TOKEN; + p++; + p++; + p++; + break; + } + if (*tmp == '5') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->r15; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = R15_TOKEN; + p++; + p++; + p++; + break; + } + } + p++; + break; +#endif + + case 'f': + case 'F': + tmp = p; + tmp++; + if (*tmp == 'S' || *tmp == 's') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tFS; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + p++; + p++; + if (*(tmp + 1) == ':') + { + TokenType[TokenCount] = FS_ADDR_TOKEN; + p++; + } + else + TokenType[TokenCount] = FS_TOKEN; + TokenCount++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenValue[TokenCount] = GetNumber(p, &p, &delta, &retCode, mode); + ((retCode) ? (TokenType[TokenCount++] = INVALID_NUMBER_TOKEN) + : (TokenType[TokenCount++] = NUMBER_TOKEN)); + break; + + case 'g': + case 'G': /* GS */ + tmp = p; + tmp++; + if (*tmp == 'S' || *tmp == 's') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tGS; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + p++; + p++; + if (*(tmp + 1) == ':') + { + TokenType[TokenCount] = GS_ADDR_TOKEN; + p++; + } + else + TokenType[TokenCount] = GS_TOKEN; + TokenCount++; + break; + } + p++; + break; + + case 's': + case 'S': + tmp = p; + tmp++; + if (*tmp == 'p' || *tmp == 'P') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSP; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = SP_TOKEN; + p++; + p++; + break; + } + if (*tmp == 'i' || *tmp == 'I') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSI; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = SI_TOKEN; + p++; + p++; + break; + } + if (*tmp == 'f' || *tmp == 'F') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSystemFlags & SF_FLAG; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = SF_TOKEN; + p++; + p++; + break; + } + if (*tmp == 's' || *tmp == 'S') + { + if (stackFrame) + TokenValue[TokenCount] = stackFrame->tSS; + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + p++; + p++; + if (*(tmp + 1) == ':') + { + TokenType[TokenCount] = SS_ADDR_TOKEN; + p++; + } + else + TokenType[TokenCount] = SS_TOKEN; + TokenCount++; + break; + } + p++; + break; + + case '[': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = DREF_OPEN_TOKEN; + p++; + if (*p == 'Q' || *p == 'q') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = QWORD_TOKEN; + p++; + break; + } + if (*p == 'D' || *p == 'd') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = DWORD_TOKEN; + p++; + break; + } + if (*p == 'W' || *p == 'w') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = WORD_TOKEN; + p++; + break; + } + if (*p == 'B' || *p == 'b') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = BYTE_TOKEN; + p++; + break; + } + break; + + case '=': + p++; + if (*p == '=') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = EQUAL_TOKEN; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = ASSIGNMENT_TOKEN; + break; + + case '<': + p++; + if (*p == '<') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = LEFT_SHIFT_TOKEN; + p++; + break; + } + if (*p == '=') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = LESS_EQUAL_TOKEN; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = LESS_TOKEN; + break; + + case '>': + p++; + if (*p == '>') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = RIGHT_SHIFT_TOKEN; + p++; + break; + } + if (*p == '=') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = GREATER_EQUAL_TOKEN; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = GREATER_TOKEN; + break; + + case '|': + p++; + if (*p == '|') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = LOGICAL_OR_TOKEN; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = OR_TOKEN; + break; + + case '&': + p++; + if (*p == '&') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = LOGICAL_AND_TOKEN; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = AND_TOKEN; + break; + + default: /* if we get a default, drop the character on the floor */ + p++; + break; + + } + } + else + { + switch (*p) + { + case '\0': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = NULL_TOKEN; + return (p); + + case ']': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = DREF_CLOSE_TOKEN; + p++; + break; + + case '(': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = BB_TOKEN; + p++; + break; + + case ')': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = EB_TOKEN; + p++; + break; + + case '+': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = PLUS_TOKEN; + p++; + break; + + case '-': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = MINUS_TOKEN; + p++; + break; + + case '*': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = MULTIPLY_TOKEN; + p++; + break; + + case '/': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = DIVIDE_TOKEN; + p++; + break; + + case '%': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = MOD_TOKEN; + p++; + break; + + case '~': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = NEG_TOKEN; + p++; + break; + + case '^': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = XOR_TOKEN; + p++; + break; + + case '!': + p++; + if (*p == '=') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = NOT_EQUAL_TOKEN; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = NOT_TOKEN; + break; + + case ' ': /* drop spaces on the floor */ + p++; + break; + + /* + * These cases require special handling + */ + + case 'x': + case 'X': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case 'a': + case 'A': + case 'b': + case 'B': + case 'c': + case 'C': + case 'd': + case 'D': + case 'e': + case 'E': + case 'f': + case 'F': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenValue[TokenCount] = GetNumber(p, &p, &delta, &retCode, mode); + ((retCode) ? (TokenType[TokenCount++] = INVALID_NUMBER_TOKEN) + : (TokenType[TokenCount++] = NUMBER_TOKEN)); + break; + + case '[': + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = DREF_OPEN_TOKEN; + p++; + if (*p == 'Q' || *p == 'q') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = QWORD_TOKEN; + p++; + break; + } + if (*p == 'D' || *p == 'd') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = DWORD_TOKEN; + p++; + break; + } + if (*p == 'W' || *p == 'w') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = WORD_TOKEN; + p++; + break; + } + if (*p == 'B' || *p == 'b') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = BYTE_TOKEN; + p++; + break; + } + break; + + case '=': + p++; + if (*p == '=') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = EQUAL_TOKEN; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = ASSIGNMENT_TOKEN; + break; + + case '<': + p++; + if (*p == '<') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = LEFT_SHIFT_TOKEN; + p++; + break; + } + if (*p == '=') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = LESS_EQUAL_TOKEN; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = LESS_TOKEN; + break; + + case '>': + p++; + if (*p == '>') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = RIGHT_SHIFT_TOKEN; + p++; + break; + } + if (*p == '=') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = GREATER_EQUAL_TOKEN; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = GREATER_TOKEN; + break; + + case '|': + p++; + if (*p == '|') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = LOGICAL_OR_TOKEN; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = OR_TOKEN; + break; + + case '&': + p++; + if (*p == '&') + { + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = LOGICAL_AND_TOKEN; + p++; + break; + } + TokenIndex[TokenCount] = (unsigned long) ((unsigned long) p - (unsigned long) op); + TokenType[TokenCount++] = AND_TOKEN; + break; + + default: /* if we get a default, drop the character on the floor */ + p++; + break; + + } + } + } + return p; + +} + +void displayExpressionHelp(void) +{ +#ifdef CONFIG_X86_64 + if (DBGPrint("Arithmetic Operators\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("+ add\n")) return; + if (DBGPrint("- subtract\n")) return; + if (DBGPrint("* multiply\n")) return; + if (DBGPrint("/ divide\n")) return; + if (DBGPrint("<< bit shift left\n")) return; + if (DBGPrint(">> bit shift right\n")) return; + if (DBGPrint("| OR operator\n")) return; + if (DBGPrint("& AND operator\n")) return; + if (DBGPrint("^ XOR operator\n")) return; + if (DBGPrint("~ NEG operator\n")) return; + if (DBGPrint("%% MODULO operator\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 1:\n")) return; + if (DBGPrint("(0)> .e (100 + 100)\n")) return; + if (DBGPrint("(0)> result = 0x200 (512)\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 2:\n")) return; + if (DBGPrint("(0)> .e (1 << 20)\n")) return; + if (DBGPrint("(0)> result = 0x00100000 (1,024,000)\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 3:\n")) return; + if (DBGPrint("(0)> .e (FEF023 & 100F)\n")) return; + if (DBGPrint("(0)> result = 0x1003 (4099)\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Boolean Operators (Conditional Breakpoint)\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("== is equal to\n")) return; + if (DBGPrint("!= is not equal to\n")) return; + if (DBGPrint("! is not\n")) return; + if (DBGPrint("> is greater than\n")) return; + if (DBGPrint("< is less than\n")) return; + if (DBGPrint(">= is greater than or equal to\n")) return; + if (DBGPrint("<= if less than or equal to\n")) return; + if (DBGPrint("|| logical OR operator\n")) return; + if (DBGPrint("&& logical AND operator\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("all breakpoint conditions must be enclosed in brackets () to\n")) return; + if (DBGPrint("evaluate correctly\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 1 (Execute Breakpoint):\n")) return; + if (DBGPrint("(0)> b 37000 (RAX == 20 && RBX <= 4000)\n")) return; + if (DBGPrint("breakpoint will activate if condition is true (returns 1)\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 2 (IO Breakpoint):\n")) return; + if (DBGPrint("(0)> bi 3D4 (!RBX && [d RSI+40] != 2000)\n")) return; + if (DBGPrint("breakpoint will activate if condition is true (returns 1)\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Register Operators\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("RAX, RBX, RCX, RDX - general registers\n")) return; + if (DBGPrint(" R8, R9, R10, R11 - general registers\n")) return; + if (DBGPrint("R12, R13, R14, R15 - general registers\n")) return; + if (DBGPrint("RSI, RDI, RBP, RSP - pointer registers\n")) return; + if (DBGPrint("RIP, - instruction pointer or symbol\n")) return; + if (DBGPrint("CS, DS, ES, FS, GS, SS - segment registers\n")) return; + if (DBGPrint("CF, PF, AF, ZF, SF, IF - flags\n")) return; + if (DBGPrint("DF, OF, VM, AC\n")) return; + if (DBGPrint("= - set equal to\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 1:\n")) return; + if (DBGPrint("(0)> RAX = 0032700 \n")) return; + if (DBGPrint("RAX changed to 0x0032700\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 2:\n")) return; + if (DBGPrint("(0)> u thread_switch\n")) return; + if (DBGPrint("unassembles function thread_switch\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 3 (Dump):\n")) return; + if (DBGPrint("(0)> d RBP+RCX\n")) return; + if (DBGPrint("(dumps [RBP + RCX])\n")) return; + if (DBGPrint("[addr] 00 00 00 01 02 04 07 ...\n")) return; + if (DBGPrint("[addr] 00 34 56 00 7A 01 00 ...\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Bracket Operators\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("( begin expression bracket\n")) return; + if (DBGPrint(") end expression bracket\n")) return; + if (DBGPrint("[ begin pointer\n")) return; + if (DBGPrint("] end pointer\n")) return; + if (DBGPrint("q QWORD reference\n")) return; + if (DBGPrint("d DWORD reference\n")) return; + if (DBGPrint("w WORD reference\n")) return; + if (DBGPrint("b BYTE reference\n")) return; + if (DBGPrint("r parse number as decimal not hex flag" + " (e.g. 512r == 200)\n")) return; + if (DBGPrint("Note - QEORD, DWORD, WORD, and BYTE dereference operators must\n")) return; + if (DBGPrint("immediately follow pointer brackets (no spaces)\n")) return; + if (DBGPrint("i.e. [d ] or [w ] or\n")) + return; + if (DBGPrint("[b ], etc.\n")) + return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 1 (dump):\n")) return; + if (DBGPrint("(0)> d [d RAX+100r] \n")) return; + if (DBGPrint("[rax + 100 (dec)] 00 00 00 01 02 04 07 00\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 2 (dump):\n")) return; + if (DBGPrint("(0)> d [w 003400] \n")) return; + if (DBGPrint("[addr (hex)] 00 22 00 01 02 04 07 ...\n")) return; + if (DBGPrint("[addr (hex)] 00 31 A1 00 6A 05 00 ...\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 3 (break):\n")) return; + if (DBGPrint("(0)> b = 7A000 (RAX + RCX == 30) && ([d B8000+50] == 0x07)\n")) return; + if (DBGPrint("breakpoint will activate if condition is true (returns 1)\n")) return; + if (DBGPrint("\n")) return; +#else + if (DBGPrint("Arithmetic Operators\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("+ add\n")) return; + if (DBGPrint("- subtract\n")) return; + if (DBGPrint("* multiply\n")) return; + if (DBGPrint("/ divide\n")) return; + if (DBGPrint("<< bit shift left\n")) return; + if (DBGPrint(">> bit shift right\n")) return; + if (DBGPrint("| OR operator\n")) return; + if (DBGPrint("& AND operator\n")) return; + if (DBGPrint("^ XOR operator\n")) return; + if (DBGPrint("~ NEG operator\n")) return; + if (DBGPrint("%% MODULO operator\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 1:\n")) return; + if (DBGPrint("(0)> .e (100 + 100)\n")) return; + if (DBGPrint("(0)> result = 0x200 (512)\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 2:\n")) return; + if (DBGPrint("(0)> .e (1 << 20)\n")) return; + if (DBGPrint("(0)> result = 0x00100000 (1,024,000)\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 3:\n")) return; + if (DBGPrint("(0)> .e (FEF023 & 100F)\n")) return; + if (DBGPrint("(0)> result = 0x1003 (4099)\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Boolean Operators (Conditional Breakpoint)\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("== is equal to\n")) return; + if (DBGPrint("!= is not equal to\n")) return; + if (DBGPrint("! is not\n")) return; + if (DBGPrint("> is greater than\n")) return; + if (DBGPrint("< is less than\n")) return; + if (DBGPrint(">= is greater than or equal to\n")) return; + if (DBGPrint("<= if less than or equal to\n")) return; + if (DBGPrint("|| logical OR operator\n")) return; + if (DBGPrint("&& logical AND operator\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("all breakpoint conditions must be enclosed in brackets () to\n")) return; + if (DBGPrint("evaluate correctly\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 1 (Execute Breakpoint):\n")) return; + if (DBGPrint("(0)> b 37000 (EAX == 20 && EBX <= 4000)\n")) return; + if (DBGPrint("breakpoint will activate if condition is true (returns 1)\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 2 (IO Breakpoint):\n")) return; + if (DBGPrint("(0)> bi 3D4 (!EBX && [d ESI+40] != 2000)\n")) return; + if (DBGPrint("breakpoint will activate if condition is true (returns 1)\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Register Operators\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("EAX, EBX, ECX, EDX - general registers\n")) return; + if (DBGPrint("ESI, EDI, EBP, ESP - pointer registers\n")) return; + if (DBGPrint("EIP, - instruction pointer or symbol\n")) return; + if (DBGPrint("CS, DS, ES, FS, GS, SS - segment registers\n")) return; + if (DBGPrint("CF, PF, AF, ZF, SF, IF - flags\n")) return; + if (DBGPrint("DF, OF, VM, AC\n")) return; + if (DBGPrint("= - set equal to\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 1:\n")) return; + if (DBGPrint("(0)> EAX = 0032700 \n")) return; + if (DBGPrint("EAX changed to 0x0032700\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 2:\n")) return; + if (DBGPrint("(0)> u thread_switch\n")) return; + if (DBGPrint("unassembles function thread_switch\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 3 (Dump):\n")) return; + if (DBGPrint("(0)> d EBP+ECX\n")) return; + if (DBGPrint("(dumps [d EBP + ECX])\n")) return; + if (DBGPrint("[addr] 00 00 00 01 02 04 07 ...\n")) return; + if (DBGPrint("[addr] 00 34 56 00 7A 01 00 ...\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Bracket Operators\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("( begin expression bracket\n")) return; + if (DBGPrint(") end expression bracket\n")) return; + if (DBGPrint("[ begin pointer\n")) return; + if (DBGPrint("] end pointer\n")) return; + if (DBGPrint("d DWORD reference\n")) return; + if (DBGPrint("w WORD reference\n")) return; + if (DBGPrint("b BYTE reference\n")) return; + if (DBGPrint("r parse number as decimal not hex flag" + " (e.g. 512r == 200)\n")) return; + if (DBGPrint("Note - DWORD, WORD, and BYTE dereference operators must\n")) return; + if (DBGPrint("immediately follow pointer brackets (no spaces)\n")) return; + if (DBGPrint("i.e. [d ] or [w ] or\n")) + return; + if (DBGPrint("[b ], etc.\n")) + return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 1 (dump):\n")) return; + if (DBGPrint("(0)> d [d EAX+100r] \n")) return; + if (DBGPrint("[eax + 100 (dec)] 00 00 00 01 02 04 07 00\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 2 (dump):\n")) return; + if (DBGPrint("(0)> d [w 003400] \n")) return; + if (DBGPrint("[addr (hex)] 00 22 00 01 02 04 07 ...\n")) return; + if (DBGPrint("[addr (hex)] 00 31 A1 00 6A 05 00 ...\n")) return; + if (DBGPrint("\n")) return; + if (DBGPrint("Example 3 (break):\n")) return; + if (DBGPrint("(0)> b = 7A000 (EAX + ECX == 30) && ([d B8000+50] == 0x07)\n")) return; + if (DBGPrint("breakpoint will activate if condition is true (returns 1)\n")) return; + if (DBGPrint("\n")) return; +#endif + return; + +} + +static inline uint64_t deref(unsigned long type, + unsigned long value, + int sizeflag, + unsigned char **result, + unsigned long seg, + unsigned long sv) +{ + uint64_t *pq; + unsigned long *pd; + unsigned short *pw; + unsigned char *pb; + +#if (DEBUG_EXPRESS) + DBGPrint("DEREF: %04X -> %04X:%lX\n", seg, sv, value); +#endif + + // if a sizeflag was specified, override the type field + if (sizeflag) + { + switch (sizeflag) + { + // BYTE + case 1: + pb = (unsigned char *) value; + return (unsigned char) mdb_segment_getword(sv, + (unsigned long)pb, 1); + + // WORD + case 2: + pw = (unsigned short *) value; + return (unsigned short) mdb_segment_getword(sv, + (unsigned long)pw, 2); + + // DWORD + case 4: + pd = (unsigned long *) value; + return (unsigned long) mdb_segment_getword(sv, + (unsigned long)pd, 4); + + // QWORD + case 8: + pq = (uint64_t *) value; + return (uint64_t) mdb_segment_getqword(sv, (uint64_t *)pq, 8); + + // FWORD + case 6: + // TBYTE (floating point) + case 10: + // VMMWORD + case 16: + if (result) + *result = (unsigned char *)value; + return 0; + + // if an unknown sizeflag is passed, then default to type + default: + break; + } + } + + switch (type) + { + case ARCH_PTR: +#ifdef CONFIG_X86_64 + pq = (uint64_t *) value; + return (uint64_t) mdb_segment_getqword(sv, (uint64_t *)pq, 8); +#else + pd = (unsigned long *) value; + return (unsigned long) mdb_segment_getword(sv, (unsigned long)pd, 4); +#endif + case ULONGLONG_PTR: + pq = (uint64_t *) value; + return (uint64_t) mdb_segment_getqword(sv, (uint64_t *)pq, 8); + + case ULONG_PTR: + pd = (unsigned long *) value; + return (unsigned long) mdb_segment_getword(sv, (unsigned long)pd, 4); + + case WORD_PTR: + pw = (unsigned short *) value; + return (unsigned short) mdb_segment_getword(sv, (unsigned long)pw, 2); + + case BYTE_PTR: + pb = (unsigned char *) value; + return (unsigned char) mdb_segment_getword(sv, (unsigned long)pb, 1); + + default: + return 0; + } + +} + +static inline unsigned long SegmentPush(unsigned long i) +{ + if (s_sp > s_bos) + { +#if (DEBUG_EXPRESS) + DBGPrint("spush : \n"); +#endif + return 0; + } + *s_sp = i; +#if (DEBUG_EXPRESS) + DBGPrint("spush : %lX (%d)\n", *s_sp, *s_sp); +#endif + s_sp++; + return 1; +} + +static inline unsigned long SegmentPop(void) +{ + s_sp--; + if (s_sp < s_tos) + { + s_sp++; +#if (DEBUG_EXPRESS) + DBGPrint("spop : \n"); +#endif + return -1; + } +#if (DEBUG_EXPRESS) + DBGPrint("spop : %lX (%d)\n", *s_sp, *s_sp); +#endif + return *s_sp; + +} + +static inline unsigned long ExpressPush(unsigned long long i) +{ + if (sp > bos) + { +#if (DEBUG_EXPRESS) + DBGPrint("push : \n"); +#endif + return 0; + } + *sp = i; +#if (DEBUG_EXPRESS) + DBGPrint("push : %lX (%d)\n", *sp, *sp); +#endif + sp++; + return 1; +} + +static inline unsigned long long ExpressPop(void) +{ + sp--; + if (sp < tos) + { + sp++; +#if (DEBUG_EXPRESS) + DBGPrint("pop : \n"); +#endif + return 0; + } +#if (DEBUG_EXPRESS) + DBGPrint("pop : %lX (%d)\n", *sp, *sp); +#endif + return *sp; + +} + +static inline unsigned long ContextPush(unsigned long long i) +{ + if (c_sp > c_bos) + { +#if (DEBUG_EXPRESS) + DBGPrint("cpush: \n"); +#endif + return 0; + } + *c_sp = i; +#if (DEBUG_EXPRESS) + DBGPrint("cpush: %lX (%d)\n", *c_sp, *c_sp); +#endif + c_sp++; + return 1; +} + +static inline unsigned long long ContextPop(void) +{ + c_sp--; + if (c_sp < c_tos) + { + c_sp++; +#if (DEBUG_EXPRESS) + DBGPrint("cpop : \n"); +#endif + return 0; + } +#if (DEBUG_EXPRESS) + DBGPrint("cpop : %lX (%d)\n", *c_sp, *c_sp); +#endif + return *c_sp; + +} + +static inline unsigned long BooleanPush(unsigned long long i) +{ + if (b_sp > b_bos) + { +#if (DEBUG_BOOL_STACK) + DBGPrint("bpush: \n"); +#endif + return 0; + } + *b_sp = i; +#if (DEBUG_BOOL_STACK) + DBGPrint("bpush: %lX (%d)\n", *b_sp, *b_sp); +#endif + b_sp++; + return 1; +} + +static inline unsigned long long BooleanPop(void) +{ + b_sp--; + if (b_sp < b_tos) + { + b_sp++; +#if (DEBUG_BOOL_STACK) + DBGPrint("bpop : \n"); +#endif + return 0; + } +#if (DEBUG_BOOL_STACK) + DBGPrint("bpop : %lX (%d)\n", *b_sp, *b_sp); +#endif + return *b_sp; + +} + +static inline unsigned long LogicalPush(unsigned long long i) +{ + if (l_sp > l_bos) + { +#if (DEBUG_LOGICAL_STACK) + DBGPrint("lpush: \n"); +#endif + return 0; + } + *l_sp = i; +#if (DEBUG_LOGICAL_STACK) + DBGPrint("lpush: %lX (%d)\n", *l_sp, *l_sp); +#endif + l_sp++; + return 1; +} + +static inline unsigned long long LogicalPop(void) +{ + l_sp--; + if (l_sp < l_tos) + { + l_sp++; +#if (DEBUG_LOGICAL_STACK) + DBGPrint("lpop : \n"); +#endif + return 0; + } +#if (DEBUG_LOGICAL_STACK) + DBGPrint("lpop : %lX (%d)\n", *l_sp, *l_sp); +#endif + return *l_sp; + +} + +static inline void initNumericStacks(void) +{ + + sp = numStack; + tos = sp; + bos = sp + NUM_STACK_SIZE - 1; + + s_sp = segStack; + s_tos = s_sp; + s_bos = s_sp + SEG_STACK_SIZE - 1; + + c_sp = contextStack; + c_tos = c_sp; + c_bos = c_sp + CONTEXT_STACK_SIZE - 1; + + b_sp = booleanStack; + b_tos = b_sp; + b_bos = b_sp + BOOL_STACK_SIZE - 1; + + l_sp = logicalStack; + l_tos = l_sp; + l_bos = l_sp + LOGICAL_STACK_SIZE - 1; + +} + +static inline unsigned long ProcessOperator(unsigned long oper) +{ + unsigned long a, b; + + b = ExpressPop(); + a = ExpressPop(); + switch(oper) + { + case NEG_TOKEN: + break; + + case LEFT_SHIFT_TOKEN: + ExpressPush(a << (b % PROCESSOR_WIDTH)); /* mod (b) to base */ + break; + + case RIGHT_SHIFT_TOKEN: + ExpressPush(a >> (b % PROCESSOR_WIDTH)); /* mob (b) to base */ + break; + + case PLUS_TOKEN: + ExpressPush(a + b); + break; + + case XOR_TOKEN: + ExpressPush(a ^ b); + break; + + case AND_TOKEN: + ExpressPush(a & b); + break; + + case MOD_TOKEN: + if (b) /* if modulo by zero, drop value on the floor */ + ExpressPush(a % b); + else + ExpressPush(0); + break; + + case OR_TOKEN: + ExpressPush(a | b); + break; + + case MINUS_TOKEN: + ExpressPush(a - b); + break; + + case MULTIPLY_TOKEN: + ExpressPush(a * b); + break; + + case DIVIDE_TOKEN: + if (b) /* if divide by zero, drop value on the floor */ + ExpressPush(a / b); + else + ExpressPush(0); + break; + + } + return 0; + +} + +static inline unsigned long ProcessBoolean(unsigned long oper) +{ + + unsigned long a, b; + + b = ExpressPop(); + a = ExpressPop(); + switch(oper) + { + case NOT_TOKEN: + ExpressPush(a == b); /* we pushed an imaginary zero on the stack */ + break; /* this operation returns the boolean for (!x) */ + + case GREATER_TOKEN: + ExpressPush(a > b); + break; + + case LESS_TOKEN: + ExpressPush(a < b); + break; + + case GREATER_EQUAL_TOKEN: + ExpressPush(a >= b); + break; + + case LESS_EQUAL_TOKEN: + ExpressPush(a <= b); + break; + + case EQUAL_TOKEN: + ExpressPush(a == b); + break; + + case NOT_EQUAL_TOKEN: + ExpressPush(a != b); + break; + } + return 0; + +} + +static inline unsigned long ProcessLogical(unsigned long oper) +{ + + unsigned long a, b; + + b = ExpressPop(); + a = ExpressPop(); + switch(oper) + { + case LOGICAL_AND_TOKEN: + ExpressPush(a && b); + break; + + case LOGICAL_OR_TOKEN: + ExpressPush(a || b); + break; + } + return 0; + +} + +static inline unsigned long ParseLogical(unsigned long logicalCount) +{ + + register int i, r; + unsigned long a; + unsigned long c = 0, lastClass = 0, oper = 0; + + for (i = 0; i < logicalCount; i++) + ExpressPush(LogicalPop()); + + for (i = 0, r = 0; i < (logicalCount / 2); i++) + { + a = ExpressPop(); + TokenType[r] = NUMBER_TOKEN; + TokenValue[r++] = a; + a = ExpressPop(); + TokenType[r] = a; /* get the operator type */ + TokenValue[r++] = 0; + } + + initNumericStacks(); + +#if (DEBUG_LOGICAL) + DBGPrint("\n"); +#endif + for (i = 0; i < logicalCount; i++) + { +#if DEBUG_LOGICAL + DBGPrint("token: %02X value: %lX type: %s\n", TokenType[i], + TokenValue[i], parserDescription[TokenType[i]]); +#endif + switch (TokenType[i]) + { + case LOGICAL_AND_TOKEN: + case LOGICAL_OR_TOKEN: + if (lastClass != CLASS_BOOLEAN) + { + lastClass = CLASS_BOOLEAN; + oper = TokenType[i]; + } + continue; + + case NUMBER_TOKEN: + if (lastClass == CLASS_DATA) + { + c = ExpressPop(); + return c; + } + lastClass = CLASS_DATA; + c = TokenValue[i]; + ExpressPush(c); + if (oper) + oper = ProcessLogical(oper); + continue; + + case NULL_TOKEN: + c = ExpressPop(); + return c; + + default: + continue; + } + } + return c; + +} + +static inline unsigned long ParseBoolean(unsigned long booleanCount) +{ + + register int i, r; + unsigned long a, oper = 0; + unsigned long c = 0, lastClass = 0, logicalCount = 0; + + for (i = 0; i < booleanCount; i++) + ExpressPush(BooleanPop()); + + for (i = 0, r = 0; i < (booleanCount / 2); i++) + { + a = ExpressPop(); + TokenType[r] = NUMBER_TOKEN; + TokenValue[r++] = a; + a = ExpressPop(); + TokenType[r] = a; /* get the operator type */ + TokenValue[r++] = 0; + } + + initNumericStacks(); + +#if (DEBUG_BOOL) + DBGPrint("\n"); +#endif + for (i = 0; i < booleanCount; i++) + { +#if DEBUG_BOOL + DBGPrint("token: %02X value: %lX type: %s\n", TokenType[i], + TokenValue[i], parserDescription[TokenType[i]]); +#endif + switch (TokenType[i]) + { + /* partition operators */ + case LOGICAL_AND_TOKEN: + case LOGICAL_OR_TOKEN: + c = ExpressPop(); + LogicalPush(c); + logicalCount++; + LogicalPush(TokenType[i]); + logicalCount++; + ExpressPush(c); + oper = 0; + lastClass = 0; + continue; + + /* boolean operators */ + case NOT_TOKEN: + if (lastClass != CLASS_BOOLEAN) + { + ExpressPush(0); + lastClass = CLASS_BOOLEAN; + oper = TokenType[i]; + } + continue; + + case GREATER_TOKEN: + case LESS_TOKEN: + case GREATER_EQUAL_TOKEN: + case LESS_EQUAL_TOKEN: + case EQUAL_TOKEN: + case NOT_EQUAL_TOKEN: + if (lastClass != CLASS_BOOLEAN) + { + lastClass = CLASS_BOOLEAN; + oper = TokenType[i]; + } + continue; + + case NUMBER_TOKEN: + if (lastClass == CLASS_DATA) + { + c = ExpressPop(); + if (logicalCount) + { + LogicalPush(c); + logicalCount++; + LogicalPush(0); /* push null token */ + logicalCount++; + c = ParseLogical(logicalCount); + return c; + } + return c; + } + lastClass = CLASS_DATA; + c = TokenValue[i]; + ExpressPush(c); + if (oper) + oper = ProcessBoolean(oper); + continue; + + case NULL_TOKEN: + c = ExpressPop(); + if (logicalCount) + { + LogicalPush(c); + logicalCount++; + LogicalPush(0); /* push null token */ + logicalCount++; + c = ParseLogical(logicalCount); + return c; + } + return c; + + default: + continue; + } + } + return c; + +} + +uint64_t Evaluate(StackFrame *stackFrame, + unsigned char **p, + unsigned long *type, + unsigned long mode, + int sizeflag, + unsigned char **result) +{ + register int i; + unsigned long oper = 0, dref = 0, bracket = 0; + unsigned long dref_type = ARCH_PTR, lastClass = 0, lastToken = 0; + unsigned long neg_flag = 0, negative_flag = 0; + uint64_t c; + unsigned long booleanCount = 0, segment = -1, segmentCount = 0, + segment_value = -1; + +#ifdef MDB_ATOMIC + spin_lock_irqsave(&expressLock, flags); +#endif + + if (type) + *type = INVALID_EXPRESSION; +#if (DEBUG_BOOL) + DBGPrint("\n"); +#endif +#if (DEBUG_EXPRESS) + DBGPrint("\np: %lX %s\n", *p, *p); +#endif + parseTokens(stackFrame, *p, mode); + if (TokenCount) + { + initNumericStacks(); + for (i = 0; i < TokenCount; i++) + { +#if (DEBUG_EXPRESS) + DBGPrint("token: %s lastClass: %d\n", parserDescription[TokenType[i]], lastClass); +#endif + switch (TokenType[i]) + { + case INVALID_NUMBER_TOKEN: + goto evaluate_error_exit; + + case NOT_TOKEN: + if (lastClass != CLASS_DATA) + { + if (oper) + oper = ProcessOperator(oper); + c = ExpressPop(); + BooleanPush(c); + booleanCount++; + BooleanPush(TokenType[i]); + booleanCount++; + dref_type = ARCH_PTR; + lastClass = 0; + neg_flag = 0; + negative_flag = 0; + } + lastToken = NOT_TOKEN; + continue; + + /* boolean operators */ + case GREATER_TOKEN: + case LESS_TOKEN: + case GREATER_EQUAL_TOKEN: + case LESS_EQUAL_TOKEN: + case LOGICAL_AND_TOKEN: + case LOGICAL_OR_TOKEN: + case EQUAL_TOKEN: + case NOT_EQUAL_TOKEN: + if (oper) + oper = ProcessOperator(oper); + c = ExpressPop(); + BooleanPush(c); + booleanCount++; + BooleanPush(TokenType[i]); + booleanCount++; + dref_type = ARCH_PTR; + lastClass = 0; + neg_flag = 0; + negative_flag = 0; + lastToken = 0; + continue; + + /* partition operators */ + case QWORD_TOKEN: + if (dref) + dref_type = ULONGLONG_PTR; + lastToken = 0; + continue; + + case DWORD_TOKEN: + if (dref) + dref_type = ULONG_PTR; + lastToken = 0; + continue; + + case WORD_TOKEN: + if (dref) + dref_type = WORD_PTR; + lastToken = 0; + continue; + + case BYTE_TOKEN: + if (dref) + dref_type = BYTE_PTR; + lastToken = 0; + continue; + + case DREF_OPEN_TOKEN: /* push state and nest for de-reference */ + if (lastClass == CLASS_DATA) + { + *p = (unsigned char *)((unsigned long)*p + (unsigned long)TokenIndex[i]); + if (type) + { + if (booleanCount) + *type = BOOLEAN_EXPRESSION; + else + *type = NUMERIC_EXPRESSION; + } + c = ExpressPop(); + if (booleanCount) + { + BooleanPush(c); + booleanCount++; + BooleanPush(0); /* last operator is the null token */ + booleanCount++; + c = ParseBoolean(booleanCount); +#if (DEBUG_BOOL) + DBGPrint("be_N : (%d) = (%s)\n", c, c ? "TRUE" : "FALSE"); +#endif +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&expressLock, flags); +#endif + return c; + } +#if (DEBUG_EXPRESS) + DBGPrint("ee_N : %lX (%d)\n", c, c); +#endif +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&expressLock, flags); +#endif + return c; + } + dref++; + ContextPush(dref_type); + ContextPush(oper); + ContextPush(lastClass); + ContextPush(neg_flag); + ContextPush(negative_flag); + dref_type = ARCH_PTR; + oper = 0; + lastClass = 0; + neg_flag = 0; + negative_flag = 0; + lastToken = 0; + continue; + + case DREF_CLOSE_TOKEN: /* pop state,restore,and complete oper */ + if (!dref) + continue; + + c = deref(dref_type, ExpressPop(), sizeflag, result, + segment, segment_value); + ExpressPush(c); + negative_flag = ContextPop(); + neg_flag = ContextPop(); + ContextPop(); + oper = ContextPop(); + dref_type = ContextPop(); + if (dref) + dref--; + lastClass = CLASS_DATA; + + c = ExpressPop(); + if (negative_flag) + c = 0 - c; + if (neg_flag) + c = ~c; + neg_flag = 0; + negative_flag = 0; + ExpressPush(c); + + if (oper) + oper = ProcessOperator(oper); + lastToken = 0; + continue; + + case BB_TOKEN: + if (lastClass == CLASS_DATA) + { + *p = (unsigned char *)((unsigned long)*p + (unsigned long)TokenIndex[i]); + if (type) + { + if (booleanCount) + *type = BOOLEAN_EXPRESSION; + else + *type = NUMERIC_EXPRESSION; + } + c = ExpressPop(); + if (booleanCount) + { + BooleanPush(c); + booleanCount++; + BooleanPush(0); /* last operator is the null token */ + booleanCount++; + c = ParseBoolean(booleanCount); +#if (DEBUG_BOOL) + DBGPrint("be_N : (%d) = (%s)\n", c, c ? "TRUE" : "FALSE"); +#endif +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&expressLock, flags); +#endif + return c; + } +#if (DEBUG_EXPRESS) + DBGPrint("ee_N : %lX (%d)\n", c, c); +#endif +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&expressLock, flags); +#endif + return c; + } + bracket++; + ContextPush(oper); + ContextPush(lastClass); + ContextPush(neg_flag); + ContextPush(negative_flag); + oper = 0; + lastClass = 0; + neg_flag = 0; + negative_flag = 0; + lastToken = 0; + continue; + + case EB_TOKEN: + if (!bracket) + continue; + negative_flag = ContextPop(); + neg_flag = ContextPop(); + ContextPop(); + oper = ContextPop(); + if (bracket) + bracket--; + lastClass = CLASS_DATA; + c = ExpressPop(); + if (negative_flag) + c = 0 - c; + if (neg_flag) + c = ~c; + neg_flag = 0; + negative_flag = 0; + ExpressPush(c); + if (oper) + oper = ProcessOperator(oper); + lastToken = 0; + continue; + + /* arithmetic operators */ + case NEG_TOKEN: + neg_flag = 1; + lastToken = 0; + continue; + + case MINUS_TOKEN: + if (lastClass == CLASS_ARITHMETIC) + { + lastToken = MINUS_TOKEN; + negative_flag = 1; + continue; + } + if (lastClass != CLASS_ARITHMETIC) + { + lastClass = CLASS_ARITHMETIC; + oper = TokenType[i]; + } + lastToken = 0; + continue; + + case PLUS_TOKEN: + case LEFT_SHIFT_TOKEN: + case RIGHT_SHIFT_TOKEN: + case XOR_TOKEN: + case AND_TOKEN: + case MOD_TOKEN: + case OR_TOKEN: + case MULTIPLY_TOKEN: + case DIVIDE_TOKEN: + if (lastClass != CLASS_ARITHMETIC) + { + lastClass = CLASS_ARITHMETIC; + oper = TokenType[i]; + } + lastToken = 0; + continue; + + /* data operators */ + case CF_TOKEN: + case PF_TOKEN: + case AF_TOKEN: + case ZF_TOKEN: + case SF_TOKEN: + case IF_TOKEN: + case DF_TOKEN: + case OF_TOKEN: + case VM_TOKEN: + case AC_TOKEN: + case IP_TOKEN: + case FLAGS_TOKEN: + case AX_TOKEN: + case BX_TOKEN: + case CX_TOKEN: + case DX_TOKEN: + case SI_TOKEN: + case DI_TOKEN: + case BP_TOKEN: + case SP_TOKEN: + case R8_TOKEN: + case R9_TOKEN: + case R10_TOKEN: + case R11_TOKEN: + case R12_TOKEN: + case R13_TOKEN: + case R14_TOKEN: + case R15_TOKEN: + case NUMBER_TOKEN: + // get the last segment associated with this data token + if (segmentCount) + { + segment = SegmentPop(); + segment_value = SegmentPop(); + segmentCount--; + } + + if (lastClass == CLASS_DATA) + { + *p = (unsigned char *)((unsigned long)*p + (unsigned long)TokenIndex[i]); + if (type) + { + if (booleanCount) + *type = BOOLEAN_EXPRESSION; + else + *type = NUMERIC_EXPRESSION; + } + c = ExpressPop(); + if (booleanCount) + { + BooleanPush(c); + booleanCount++; + BooleanPush(0); /* last operator is the null token */ + booleanCount++; + c = ParseBoolean(booleanCount); +#if (DEBUG_BOOL) + DBGPrint("be_N : (%d) = (%s)\n", c, c ? "TRUE" : "FALSE"); +#endif +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&expressLock, flags); +#endif + return c; + } +#if (DEBUG_EXPRESS) + DBGPrint("ee_N : %lX (%d)\n", c, c); +#endif +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&expressLock, flags); +#endif + return c; + } + lastClass = CLASS_DATA; + c = TokenValue[i]; + if (negative_flag) + c = 0 - c; + if (neg_flag) + c = ~TokenValue[i]; + neg_flag = 0; + negative_flag = 0; + ExpressPush(c); + if (oper) + oper = ProcessOperator(oper); + lastToken = 0; + continue; + + // if a segment token is tagged for derefence, push segment + case CS_ADDR_TOKEN: + case DS_ADDR_TOKEN: + case ES_ADDR_TOKEN: + case FS_ADDR_TOKEN: + case GS_ADDR_TOKEN: + case SS_ADDR_TOKEN: + SegmentPush(TokenValue[i]); + SegmentPush(TokenType[i]); + segmentCount++; + lastToken = 0; + continue; + + case CS_TOKEN: + case DS_TOKEN: + case ES_TOKEN: + case FS_TOKEN: + case GS_TOKEN: + case SS_TOKEN: + if (lastClass == CLASS_DATA) + { + *p = (unsigned char *)((unsigned long)*p + (unsigned long)TokenIndex[i]); + if (type) + { + if (booleanCount) + *type = BOOLEAN_EXPRESSION; + else + *type = NUMERIC_EXPRESSION; + } + c = ExpressPop(); + if (booleanCount) + { + BooleanPush(c); + booleanCount++; + BooleanPush(0); /* last operator is the null token */ + booleanCount++; + c = ParseBoolean(booleanCount); +#if (DEBUG_BOOL) + DBGPrint("be_N : (%d) = (%s)\n", c, c ? "TRUE" : "FALSE"); +#endif +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&expressLock, flags); +#endif + return c; + } +#if (DEBUG_EXPRESS) + DBGPrint("ee_N : %lX (%d)\n", c, c); +#endif +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&expressLock, flags); +#endif + return c; + } + lastClass = CLASS_DATA; + c = TokenValue[i]; + if (negative_flag) + c = 0 - c; + if (neg_flag) + c = ~TokenValue[i]; + neg_flag = 0; + negative_flag = 0; + ExpressPush(c); + if (oper) + oper = ProcessOperator(oper); + lastToken = 0; + continue; + + case NULL_TOKEN: + *p = (unsigned char *)((unsigned long)*p + (unsigned long)TokenIndex[i]); + if (TokenCount > 1 && type) + { + if (booleanCount) + *type = BOOLEAN_EXPRESSION; + else + *type = NUMERIC_EXPRESSION; + } + c = ExpressPop(); + if (booleanCount) + { + BooleanPush(c); + booleanCount++; + BooleanPush(0); /* last operator is the null token */ + booleanCount++; + c = ParseBoolean(booleanCount); +#if (DEBUG_BOOL) + DBGPrint("be_N : (%d) = (%s)\n", c, c ? "TRUE" : "FALSE"); +#endif +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&expressLock, flags); +#endif + return c; + } +#if (DEBUG_EXPRESS) + DBGPrint("ee_N : %lX (%d)\n", c, c); +#endif +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&expressLock, flags); +#endif + return c; + + /* assignment operators */ + case ASSIGNMENT_TOKEN: + lastToken = 0; + continue; + + default: + lastToken = 0; + continue; + } + } + } + +evaluate_error_exit: + if (type) + *type = INVALID_EXPRESSION; + + if (lastToken) {}; + +#ifdef MDB_ATOMIC + spin_unlock_irqrestore(&expressLock, flags); +#endif + return 0; + +} + +uint64_t EvaluateDisassemblyExpression(StackFrame *stackFrame, unsigned char **p, unsigned long *type, int sizeflag, unsigned char **result) +{ + register uint64_t c; +#if DEBUG_EXPRESS + unsigned char *s = *p; +#endif + if (result) + *result = NULL; + c = Evaluate(stackFrame, p, type, 1, sizeflag, result); +#if DEBUG_EXPRESS + DBGPrint("EDE expr: [%s]\n", s); +#endif + return c; +} + +uint64_t EvaluateNumericExpression(StackFrame *stackFrame, unsigned char **p, unsigned long *type) +{ + register uint64_t c; +#if DEBUG_EXPRESS + unsigned char *s = *p; +#endif + c = Evaluate(stackFrame, p, type, 1, 0, NULL); +#if DEBUG_EXPRESS + DBGPrint("ENE expr: [%s]\n", s); +#endif + return c; +} + +uint64_t EvaluateExpression(StackFrame *stackFrame, unsigned char **p, unsigned long *type) +{ + register uint64_t c; +#if DEBUG_EXPRESS + unsigned char *s = *p; +#endif + c = Evaluate(stackFrame, p, type, 0, 0, NULL); +#if DEBUG_EXPRESS + DBGPrint("EE expr: [%s]\n", s); +#endif + return c; +} + +void EvaluateCommandExpression(StackFrame *stackFrame, unsigned char *p) +{ + unsigned char *expr; + unsigned long type; + uint64_t c; + +#if DEBUG_EXPRESS + DBGPrint("expr: [%s]\n", p); +#endif + expr = p; + c = EvaluateExpression(stackFrame, &p, &type); + if (type) + { + DBGPrint("expr: %s = 0x%llX (%lldr) (%s) bool(%i) = %s\n", + expr, c, c, exprDescription[type & 3], + (c) ? 1 : 0, (c) ? "TRUE" : "FALSE"); + } + else + { + DBGPrint("expression parameters invalid\n"); + DBGPrint("expr: %s = 0x%llX (%lldr) (results invalid) (%s)" + " bool(%i) = %s\n", + expr, c, c, exprDescription[type & 3], + (c) ? 1 : 0, (c) ? "TRUE" : "FALSE"); + } + return; + +} diff -Naur linux-2.6.35.4/kernel/debug/mdb/mdb-main.c linux-2.6.35.4-cs/kernel/debug/mdb/mdb-main.c --- linux-2.6.35.4/kernel/debug/mdb/mdb-main.c 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/mdb-main.c 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,758 @@ + +/*************************************************************************** +* +* Copyright (c) 2008 Jeff V. Merkey All Rights Reserved. +* jeffmerkey@gmail.com +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation, version 2. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You are free to modify and re-distribute this program in accordance +* with the terms specified in the GNU Public License. The copyright +* contained in this code is required to be present in any derivative +* works and you are required to provide the source code for this +* program as part of any commercial or non-commercial distribution. +* You are required to respect the rights of the Copyright holders +* named within this code. +* +* jeffmerkey@gmail.com is the official maintainer of +* this code. You are encouraged to report any bugs, problems, fixes, +* suggestions, and comments about this software. +* +* AUTHOR : Jeff V. Merkey +* DESCRIP : Merkey's Linux Debugger +* +***************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(CONFIG_SMP) +#include +#include +#include +#endif + +#define __KERNEL_SYSCALLS__ +#include +#include + +#include "mdb.h" +#include "mdb-ia.h" +#include "mdb-list.h" +#include "mdb-ia-proc.h" +#include "mdb-base.h" +#include "mdb-proc.h" +#include "mdb-os.h" +#include "mdb-keyboard.h" + +extern void MDBInitializeDebugger(void); +extern void MDBClearDebuggerState(void); + +unsigned long TotalSystemMemory; +unsigned long HistoryPointer; +unsigned char HistoryBuffer[16][256]; + /* remember non-repeating commands */ +unsigned char delim_table[256]; +unsigned char workBuffer[256]; +unsigned char verbBuffer[100]; + +StackFrame CurrentStackFrame[MAX_PROCESSORS]; +atomic_t inmdb = { 0 }; +unsigned char *mdb_oops; +unsigned char *last_mdb_oops; + +static inline void set_delimiter(unsigned char c) +{ + delim_table[c & 0xFF] = 1; +} + +void SaveLastCommandInfo(unsigned long processor) +{ + register int i; + + repeatCommand = 0; + lastCommand = toupper(debugCommand[0]); + lastDisplayLength = displayLength; + atomic_set(&focusActive, 0); + atomic_set(&traceProcessors[processor], 0); + + for (i = 0; (i < 80) && (debugCommand[i]); i++) + { + if ((debugCommand[i] == '\n') || (debugCommand[i] == '\r')) + lastDebugCommand[i] = '\0'; + else + lastDebugCommand[i] = debugCommand[i]; + } + lastDebugCommand[i] = '\0'; + + return; +} + +volatile unsigned long flagstate[MAX_PROCESSORS]; +volatile unsigned long debugstate[MAX_PROCESSORS]; +extern void keyboard_reset(void); +extern void keyboard_setup(void); +extern void keyboard_cleanup(void); + +int mdb(int reason, int error, void *frame) +{ + register unsigned long retCode = 0, processor = get_processor_id(); + extern void ReadStackFrame(void *, StackFrame *, unsigned long); + extern void WriteStackFrame(void *, StackFrame *, unsigned long); + + retCode = AlternateDebuggerRoutine(reason, error, frame); + if (retCode) + return retCode; + + last_mdb_oops = NULL; + if (mdb_oops) + { + last_mdb_oops = mdb_oops; + mdb_oops = NULL; + } + + local_irq_save(flagstate[processor]); + + // get the current task context + mdb_current_task = curr_task(smp_processor_id()); + + atomic_inc(&inmdb); + memset(&CurrentStackFrame[processor], 0, sizeof(StackFrame)); + ReadStackFrame(frame, &CurrentStackFrame[processor], processor); + CurrentStackFrame[processor].tReserved[2] = (unsigned long)frame; + retCode = debugger_entry(reason, &CurrentStackFrame[processor], + processor); + WriteStackFrame(frame, &CurrentStackFrame[processor], processor); + atomic_dec(&inmdb); + + local_irq_restore(flagstate[processor]); + + return retCode; +} + +static inline void out_chars(int c, unsigned char ch) +{ + register int i; + + for (i = 0; i < c; i++) + DBGPrint("%c", ch); + return; +} + +static inline void out_copy_chars_limit(int c, unsigned char ch, + unsigned char *s, int limit) +{ + register int i; + + for (i = 0; (i < c) && (i < limit); i++) + s[i] = ch; + s[i] = '\0'; + DBGPrint("%s", s); + return; +} + +static inline void out_buffer_chars_limit(unsigned char *s, int limit) +{ + register int i; + + for (i = 0; (i < strlen(s)) && (i < limit); i++) + DBGPrint("%c", s[i]); + return; +} + +static inline void out_buffer_chars_limit_index(unsigned char *s, int limit, + int index) +{ + register int i; + + for (i = 0; (i < limit) && (s[i]); i++) + DBGPrint("%c", s[index + i]); + return; +} + +static inline void out_string(unsigned char *s) +{ + DBGPrint("%s", s); + return; +} + +static inline void out_char(unsigned char ch) +{ + DBGPrint("%c", ch); + return; +} + +unsigned long ScreenInputFromKeyboard(unsigned char *buf, + unsigned long buf_index, + unsigned long max_index) +{ + register unsigned long key; + register unsigned char *p; + register int i, r, temp; + register unsigned long orig_index, HistoryIndex; + extern unsigned long IsAccelerator(unsigned long); + + if (buf_index > max_index) + return 0; + + if (!max_index) + return 0; + + orig_index = buf_index; + + p = (unsigned char *)((unsigned long)buf + (unsigned long)buf_index); + for (i = 0; i < (max_index - buf_index); i++) + *p++ = '\0'; + + HistoryIndex = HistoryPointer; + while (1) + { + key = mdb_getkey(); + + if ((IsAccelerator(key)) && (key != 13)) + return key; + + switch (key) + { + case 8: /* backspace */ + if (buf_index) + { + register int delta; + + buf_index--; + out_string("\b \b"); + + delta = strlen(buf) - buf_index; + out_chars(delta, ' '); + out_chars(delta, '\b'); + + p = (unsigned char *) &buf[buf_index]; + temp = buf_index; + p++; + while ((*p) && (temp < max_index)) + buf[temp++] = *p++; + buf[temp] = '\0'; + + delta = strlen(buf) - buf_index; + out_buffer_chars_limit_index(buf, delta, buf_index); + out_chars(delta, '\b'); + } + break; + + case K_P7: /* home */ + { + unsigned char *s = &workBuffer[0]; + + out_copy_chars_limit(buf_index, '\b', s, 255); + buf_index = orig_index; + } + break; + + case K_P1: /* end */ + { + unsigned char *s = &workBuffer[0]; + + out_copy_chars_limit(buf_index, '\b', s, 255); + out_buffer_chars_limit(buf, 255); + buf_index = strlen(buf); + } + break; + + case K_P4: /* left arrow */ + if (buf_index) + { + buf_index--; + out_string("\b"); + } + break; + + case K_P6: /* right arrow */ + if (buf_index < strlen(buf)) + { + out_char(buf[buf_index]); + buf_index++; + } + break; + + case K_PDOT: + { + register int delta; + + delta = strlen(buf) - buf_index; + + out_chars(delta, ' '); + out_chars(delta, '\b'); + + p = (unsigned char *) &buf[buf_index]; + temp = buf_index; + p++; + while ((*p) && (temp < max_index)) + buf[temp++] = *p++; + buf[temp] = '\0'; + + delta = strlen(buf) - buf_index; + out_buffer_chars_limit_index(buf, delta, buf_index); + out_chars(delta, '\b'); + } + break; + + case 13: /* enter */ + if (strncmp(HistoryBuffer[(HistoryPointer - 1) & 0xF], buf, + strlen(buf)) || (strlen(buf) != + strlen(HistoryBuffer[(HistoryPointer - 1) & 0xF]))) + { + for (r = 0; r < max_index; r++) + { + if (buf[0]) + HistoryBuffer[HistoryPointer & 0xF][r] = buf[r]; + } + if (buf[0]) + HistoryPointer++; + } + return 13; + + case K_P8: /* up arrow */ + if (HistoryBuffer[(HistoryIndex - 1) & 0xF][0]) + { + unsigned char *s = &workBuffer[0]; + + out_copy_chars_limit(buf_index, '\b', s, 255); + out_copy_chars_limit(buf_index, ' ', s, 255); + out_copy_chars_limit(buf_index, '\b', s, 255); + + HistoryIndex--; + + for (r = 0; r < max_index; r++) + buf[r] = HistoryBuffer[HistoryIndex & 0xF][r]; + buf_index = strlen(buf); + + out_string(buf); + } + break; + + case K_P2: /* down arrow */ + if (HistoryBuffer[HistoryIndex & 0xF][0]) + { + unsigned char *s = &workBuffer[0]; + + out_copy_chars_limit(buf_index, '\b', s, 255); + out_copy_chars_limit(buf_index, ' ', s, 255); + out_copy_chars_limit(buf_index, '\b', s, 255); + + HistoryIndex++; + + for (r = 0; r < max_index; r++) + buf[r] = HistoryBuffer[HistoryIndex & 0xF][r]; + buf_index = strlen(buf); + + out_string(buf); + } + break; + + default: + if ((key > 0x7E) || (key < ' ')) /* if above or below text */ + break; + else + { + if (strlen(buf) < max_index) + { + register int delta; + + for (i=max_index; i > buf_index; i--) + buf[i] = buf[i-1]; + buf[buf_index] = (unsigned char)key; + if (buf_index < max_index) + buf_index++; + + delta = strlen(buf) - buf_index; + out_buffer_chars_limit_index(buf, delta, buf_index); + out_chars(delta, '\b'); + } + } + break; + } + } +} + +unsigned long debugger_command_entry(unsigned long processor, + unsigned long Exception, + StackFrame *stackFrame) +{ + register unsigned char *verb, *pp, *vp; + register unsigned long count, retCode, key; + extern unsigned long reason_toggle; + extern void displayRegisters(StackFrame *, unsigned long); + + if (Exception > 22) + Exception = 20; + + lastUnasmAddress = (unsigned long) GetIP(stackFrame); + lastLinkAddress = lastDumpAddress = + (unsigned char *) GetStackAddress(stackFrame); + lastDisplayLength = displayLength = 20; + lastCommandEntry = lastCommand; + nextline = 0; + pause_mode = 0; + + if (!ssbmode) + { + if (reason_toggle && !ConsoleDisplayBreakReason(stackFrame, + Exception, processor, lastCommand)) + return 0; + displayRegisters(stackFrame, processor); + } + nextUnasmAddress = disassemble(stackFrame, lastUnasmAddress, 1, -1, 0); + ClearTempBreakpoints(); + if (SSBUpdate(stackFrame, processor) == -1) + return 0; + + keyboard_setup(); + while (1) + { + pause_mode = 1; + nextline = 0; + DBGPrint("(%i)> ", (int)processor); + + SaveLastCommandInfo(processor); + key = ScreenInputFromKeyboard((unsigned char *)&debugCommand[0], 0, 80); + if (key) + { + extern unsigned long AccelRoutine(unsigned long key, void *p); + + retCode = AccelRoutine(key, stackFrame); + switch (retCode) + { + case 0: + break; + + case -1: + keyboard_cleanup(); + return retCode; + + default: + DBGPrint("\n"); + continue; + } + } + + if (*debugCommand) + { + count = 0; + pp = (unsigned char *)debugCommand; + vp = verb = &verbBuffer[0]; + while (*pp && *pp == ' ' && count++ < 80) + pp++; + + while (*pp && *pp != ' ' && *pp != '=' && count++ < 80) + *vp++ = *pp++; + *vp = '\0'; + + while (*pp && *pp == ' ' && count++ < 80) + pp++; + + retCode = DebuggerParserRoutine(verb, (unsigned char *)debugCommand, + stackFrame, Exception); + switch (retCode) + { + case -1: + keyboard_cleanup(); + return retCode; + } + } + } +} + +#if MDB_DEBUG_DEBUGGER +unsigned char *kdebug_state[]= +{ + "", + "DIE_OOPS", + "DIE_INT3", + "DIE_DEBUG", + "DIE_PANIC", + "DIE_NMI", + "DIE_DIE", + "DIE_NMIWATCHDOG", + "DIE_KERNELDEBUG", + "DIE_TRAP", + "DIE_GPF", + "DIE_CALL", + "DIE_NMI_IPI", + "DIE_PAGE_FAULT", + "DIE_NMIUNKNOWN", +}; +int kdebug_state_size = sizeof(kdebug_state) / sizeof(unsigned char *); +#endif + +static int mdb_notify(struct notifier_block *nb, unsigned long reason, + void *data) +{ + register struct die_args *args = (struct die_args *)data; + register unsigned long cr3; + register int err = 0; + + // flush the tlb in case we are inside of a memory remap routine + cr3 = ReadCR3(); + WriteCR3(cr3); + + preempt_disable(); + +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: notify reason:%lu\n", (int)get_processor_id(), reason); +#endif + + if (args) + { + unsigned long *lp = (unsigned long *)ERR_PTR(args->err); + + switch (reason) + { + case DIE_DIE: + case DIE_PANIC: + case DIE_OOPS: + mdb_oops = (unsigned char *)args->str; + if (args->regs) + err = mdb(SOFTWARE_EXCEPTION, args->err, args->regs); + else + { + struct pt_regs *regs = get_irq_regs(); + + if (regs) + { + err = mdb(SOFTWARE_EXCEPTION, args->err, regs); + break; + } + + /* if there are no regs passed on DIE_PANIC, or we + * cannot locate a local interrupt context, trigger an + * int 3 breakpoint and get the register context since + * we were apparently called from panic() outside of an + * exception. + */ + mdb_breakpoint(); + } + break; + + case DIE_INT3: + if (toggle_user_break) + { + if (user_mode(args->regs)) + { + preempt_enable(); + return NOTIFY_DONE; + } + } + err = mdb(BREAKPOINT_EXCEPTION, args->err, args->regs); + break; + + case DIE_DEBUG: + if (toggle_user_break) + { + if (user_mode(args->regs)) + { + preempt_enable(); + return NOTIFY_DONE; + } + else + if (test_thread_flag(TIF_SINGLESTEP)) + { + preempt_enable(); + return NOTIFY_DONE; + } + } + if (lp) + VirtualDR6 = *lp; + err = mdb(DEBUGGER_EXCEPTION, args->err, args->regs); + break; + + case DIE_NMI: + case DIE_NMIWATCHDOG: + case DIE_NMIUNKNOWN: + case DIE_NMI_IPI: + err = mdb(NMI_EXCEPTION, args->err, args->regs); + break; + + case DIE_CALL: + err = mdb(KEYBOARD_ENTRY, args->err, args->regs); + break; + + case DIE_KERNELDEBUG: + err = mdb(KEYBOARD_ENTRY, args->err, args->regs); + break; + + case DIE_GPF: + err = mdb(GENERAL_PROTECTION, args->err, args->regs); + break; + + case DIE_PAGE_FAULT: + err = mdb(PAGE_FAULT_EXCEPTION, args->err, args->regs); + break; + + default: + break; + } + } +#if MDB_DEBUG_DEBUGGER + DBGPrint("%i: exit:%lu (%i)\n", (int)p, reason, err); +#endif + + preempt_enable(); + + return (err ? NOTIFY_STOP : NOTIFY_DONE); +} + +static struct notifier_block mdb_notifier = +{ + .notifier_call = mdb_notify, + .priority = 0x7FFFFFFF, +}; + +#ifdef CONFIG_MAGIC_SYSRQ +static void sysrq_mdb(int key, struct tty_struct *tty) +{ +#if MDB_DEBUG_DEBUGGER + register int i, self = get_processor_id(); + + for (i = 0; i < MAX_PROCESSORS; i++) + { + if (cpu_online(i)) + { + if (i == self) + { + apic->send_IPI_mask(cpumask_of(i), APIC_DM_NMI); + return; + } + } + } +#else + mdb_breakpoint(); +#endif + return; +} + +static struct sysrq_key_op sysrq_op = +{ + .handler = sysrq_mdb, + .help_msg = "mdb(A)", + .action_msg = "MDB", +}; +#endif + +extern int disable_hw_bp_interface; + +static int __init mdb_init_module(void) +{ + register int i; + register int ret = 0; + + /* return if debugger already initialized */ + if (debuggerInitialized) + return 0; + + MDBInitializeDebugger(); + + disable_hw_bp_interface = 1; + + ret = register_die_notifier(&mdb_notifier); + if (ret) + { + MDBClearDebuggerState(); + return ret; + } + +#ifdef CONFIG_MAGIC_SYSRQ + register_sysrq_key('a', &sysrq_op); +#endif + + /* initialize delimiter lookup table */ + for (i = 0; i < 256; i++) + delim_table[i] = '\0'; + + set_delimiter('\0'); + set_delimiter('\n'); + set_delimiter('\r'); + set_delimiter('['); + set_delimiter(']'); + set_delimiter('<'); + set_delimiter('>'); + set_delimiter('('); + set_delimiter(')'); + set_delimiter('|'); + set_delimiter('&'); + set_delimiter('='); + set_delimiter('*'); + set_delimiter('+'); + set_delimiter('-'); + set_delimiter('/'); + set_delimiter('%'); + set_delimiter('~'); + set_delimiter('^'); + set_delimiter('!'); + set_delimiter(' '); + + return 0; +} + +static void __exit mdb_exit_module(void) +{ + extern struct timer_list debug_timer; + + del_timer(&debug_timer); + debug_timer.data = 0; + +#ifdef CONFIG_MAGIC_SYSRQ + unregister_sysrq_key('a', &sysrq_op); +#endif + + unregister_die_notifier(&mdb_notifier); + + disable_hw_bp_interface = 0; + + MDBClearDebuggerState(); + + return; +} + +module_init(mdb_init_module); +module_exit(mdb_exit_module); + +MODULE_DESCRIPTION("Merkey's Kernel Debugger"); +MODULE_LICENSE("GPL"); diff -Naur linux-2.6.35.4/kernel/debug/mdb/mdb-os.c linux-2.6.35.4-cs/kernel/debug/mdb/mdb-os.c --- linux-2.6.35.4/kernel/debug/mdb/mdb-os.c 1969-12-31 17:00:00.000000000 -0700 +++ linux-2.6.35.4-cs/kernel/debug/mdb/mdb-os.c 2010-08-30 04:00:10.000000000 -0600 @@ -0,0 +1,1708 @@ + +/*************************************************************************** +* +* Copyright (c) 2008 Jeff V. Merkey All Rights Reserved. +* jeffmerkey@gmail.com +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation, version 2. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You are free to modify and re-distribute this program in accordance +* with the terms specified in the GNU Public License. The copyright +* contained in this code is required to be present in any derivative +* works and you are required to provide the source code for this +* program as part of any commercial or non-commercial distribution. +* You are required to respect the rights of the Copyright holders +* named within this code. +* +* jeffmerkey@gmail.com is the official maintainer of +* this code. You are encouraged to report any bugs, problems, fixes, +* suggestions, and comments about this software. +* +* AUTHOR : Jeff V. Merkey +* DESCRIP : Merkey's Linux Debugger +* +***************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define __KERNEL_SYSCALLS__ +#include +#include + +#include "mdb.h" +#include "mdb-ia.h" +#include "mdb-list.h" +#include "mdb-ia-proc.h" +#include "mdb-base.h" +#include "mdb-proc.h" +#include "mdb-os.h" +#include "mdb-keyboard.h" + +/* module symbol workspace */ +unsigned char symbuf[MAX_PROCESSORS][MAX_SYMBOL_LEN]; +unsigned char modbuf[MAX_PROCESSORS][MAX_SYMBOL_LEN]; +unsigned char workbuf[MAX_PROCESSORS][MAX_SYMBOL_LEN]; +unsigned char traceBuf[MAX_SYMBOL_LEN]; + +#ifdef CONFIG_X86_64 + +/* The form of the top of the frame on the stack */ +struct stack_frame { + struct stack_frame *next_frame; + unsigned long return_address; +}; + +static inline int in_irq_stack(unsigned long *stack, unsigned long *irq_stack, + unsigned long *irq_stack_end) +{ + return (stack >= irq_stack && stack < irq_stack_end); +} + +static inline unsigned long fixup_bp_irq_link(unsigned long bp, +unsigned long *stack, unsigned long *irq_stack, unsigned long *irq_stack_end) +{ +#ifdef CONFIG_FRAME_POINTER + struct stack_frame *frame = (struct stack_frame *)bp; + unsigned long next; + + if (!in_irq_stack(stack, irq_stack, irq_stack_end)) { + if (!probe_kernel_address(&frame->next_frame, next)) + return next; + else + DBGPrint("MDB: bad frame pointer = %p in chain\n", + &frame->next_frame); + } +#endif + return bp; +} + +#define get_bp(bp) asm("movq %%rbp, %0" : "=r" (bp) :) + +extern unsigned long *in_exception_stack(unsigned cpu, unsigned long stack, + unsigned *usedp, char **idp); +extern unsigned long *get_irq_stack_end(const unsigned int cpu); + +void DBGPrint_address(unsigned long address, int reliable) +{ + DBGPrint(" [<%p>] %s%pS\n", (void *) address, + reliable ? "" : "? ", (void *) address); +} + +/* + * x86-64 can have up to three kernel stacks: + * process stack + * interrupt stack + * severe exception (double fault, nmi, stack fault, debug, mce) hardware stack + */ + +static inline int valid_stack_ptr(struct thread_info *tinfo, + void *p, unsigned int size, void *end) +{ + void *t = tinfo; + if (end) { + if (p < end && p >= (end-THREAD_SIZE)) + return 1; + else + return 0; + } + return p > t && p < t + THREAD_SIZE - size; +} + +static inline unsigned long +print_context_stack(struct thread_info *tinfo, unsigned long *stack, + unsigned long bp, unsigned long *end) +{ + struct stack_frame *frame = (struct stack_frame *)bp; + + while (valid_stack_ptr(tinfo, stack, sizeof(*stack), end)) { + unsigned long addr; + + addr = *stack; + if (__kernel_text_address(addr)) { + if ((unsigned long) stack == bp + sizeof(long)) { + touch_nmi_watchdog(); + DBGPrint_address(addr, 1); + frame = frame->next_frame; + bp = (unsigned long) frame; + } else { + touch_nmi_watchdog(); + DBGPrint_address(addr, bp == 0); + } + } + stack++; + } + return bp; +} + +void bt_stack(struct task_struct *task, struct pt_regs *regs, + unsigned long *stack) +{ + unsigned long bp = 0; + const unsigned cpu = get_cpu(); + unsigned long *irq_stack_end = get_irq_stack_end(cpu); + unsigned used = 0; + struct thread_info *tinfo; + + if (!task) + task = current; + + if (!stack) { + unsigned long dummy; + stack = &dummy; + if (task && task != current) + stack = (unsigned long *)task->thread.sp; + } + +#ifdef CONFIG_FRAME_POINTER + if (!bp) + { + if (task == current) + { + /* Grab bp right from our regs */ + get_bp(bp); + } + else + { + /* bp is the last reg pushed by switch_to */ + bp = *(unsigned long *) task->thread.sp; + } + } +#endif + + /* + * Print function call entries in all stacks, starting at the + * current stack address. If the stacks consist of nested + * exceptions + */ + tinfo = task_thread_info(task); + for (;;) + { + char *id; + unsigned long *estack_end; + estack_end = in_exception_stack(cpu, (unsigned long)stack, + &used, &id); + + if (estack_end) { + if (DBGPrint("%s", id)) + break; + + bp = print_context_stack(tinfo, stack, bp, estack_end); + DBGPrint("%s", ""); + + /* + * We link to the next stack via the + * second-to-last pointer (index -2 to end) in the + * exception stack: + */ + stack = (unsigned long *) estack_end[-2]; + continue; + } + + if (irq_stack_end) + { + unsigned long *irq_stack; + irq_stack = irq_stack_end - + (IRQ_STACK_SIZE - 64) / sizeof(*irq_stack); + + if (in_irq_stack(stack, irq_stack, irq_stack_end)) + { + if (DBGPrint("%s", "IRQ")) + break; + + bp = print_context_stack(tinfo, stack, bp, + irq_stack_end); + /* + * We link to the next stack (which would be + * the process stack normally) the last + * pointer (index -1 to end) in the IRQ stack: + */ + + stack = (unsigned long *) (irq_stack_end[-1]); + bp = fixup_bp_irq_link(bp, stack, irq_stack, + irq_stack_end); + irq_stack_end = NULL; + DBGPrint("%s", "EOI"); + continue; + } + } + break; + } + + /* + * This handles the process stack: + */ + bp = print_context_stack(tinfo, stack, bp, NULL); + put_cpu(); +} + +#else + +int valid_stack_ptr(struct thread_info *tinfo, void *p) +{ + return ((p > (void *)tinfo) && (p < (void *)(tinfo + THREAD_SIZE - 3))); +} + +unsigned long print_context_stack(struct thread_info *tinfo, + unsigned long *stack, unsigned long ebp, + unsigned long *rebp) +{ + register unsigned char *symbol; + unsigned long addr, offset; + unsigned char *modname; + +#ifdef CONFIG_FRAME_POINTER + while (valid_stack_ptr(tinfo, (void *)ebp)) + { + addr = mdb_getword((ebp + 4), 4); + + if (DBGPrint("[<%08lx>] ", addr)) + return 1; + + symbol = GetSymbolFromValueOffsetModule(addr, &offset, &modname, + traceBuf, MAX_SYMBOL_LEN); + if (symbol) + { + if (modname) + { + if (offset) + { + if (DBGPrint("%s|%s+0x%X", modname, symbol, offset)) + return 1; + } + else + { + if (DBGPrint("%s|%s", modname, symbol)) + return 1; + } + } + else + { + if (offset) + { + if (DBGPrint("%s+0x%X", symbol, offset)) + return 1; + } + else + { + if (DBGPrint("%s", symbol)) + return 1; + } + } + } + if (DBGPrint("\n")) + return 1; + + if (ebp == mdb_getword(ebp, 4)) + break; + + ebp = mdb_getword(ebp, 4); + } +#else + while (valid_stack_ptr(tinfo, stack)) + { + addr = mdb_getword((unsigned long)stack, 4); + stack++; + + if (__kernel_text_address(addr)) + { + if (DBGPrint("[<%08lx>] ", addr)) + return 1; + + symbol = GetSymbolFromValueOffsetModule(addr, &offset, &modname, + traceBuf, MAX_SYMBOL_LEN); + if (symbol) + { + if (modname) + { + if (offset) + { + if (DBGPrint("%s|%s+0x%X", modname, symbol, offset)) + return 1; + } + else + { + if (DBGPrint("%s|%s", modname, symbol)) + return 1; + } + } + else + { + if (offset) + { + if (DBGPrint("%s+0x%X", symbol, offset)) + return 1; + } + else + { + if (DBGPrint("%s", symbol)) + return 1; + } + } + } + if (DBGPrint("\n")) + return 1; + } + } +#endif + if (rebp) + *rebp = ebp; + + return 0; +} + +int bt_stack(struct task_struct *task, struct pt_regs *regs, + unsigned long *stack) +{ + unsigned long ebp = 0; + + if (!task) + task = current; + + if (!stack) + { + unsigned long dummy; + + stack = &dummy; + if (task && task != current) + { + if (mdb_verify_rw((void *)&task->thread.sp, 4)) + return 0; + + stack = (unsigned long *) + mdb_getword((unsigned long)&task->thread.sp, 4); + } + } + +#ifdef CONFIG_FRAME_POINTER + if (!ebp) + { + if (task == current) + asm ("movl %%ebp, %0" : "=r" (ebp) : ); + else + { + if (mdb_verify_rw((void *)task->thread.sp, 4)) + return 0; + + ebp = (unsigned long)mdb_getword(task->thread.sp, 4); + } + } +#endif + + while (1) + { + struct thread_info *context; + + context = (struct thread_info *) + ((unsigned long)stack & (~(THREAD_SIZE - 1))); + + if (mdb_verify_rw(context, 4)) + return 0; + + if (print_context_stack(context, stack, ebp, &ebp)) + return 1; + + if (mdb_verify_rw(&context->previous_esp, 4)) + return 0; + + stack = (unsigned long *) + mdb_getword((unsigned long)&context->previous_esp, 4); + if (!stack) + break; + + touch_nmi_watchdog(); + } + return 0; +} +#endif + +unsigned char *mdbprompt = "--- More (Q to Quit) ---"; +int nextline; +int pause_mode = 1; + +#if defined(CONFIG_SMP) +volatile rlock_t mdb_mutex = { SPIN_LOCK_UNLOCKED, -1, 0 }; +#else +volatile rlock_t mdb_mutex = { -1, 0 }; +#endif + +extern unsigned long debug_rlock(volatile rlock_t *rlock, unsigned long p); +extern void debug_unrlock(volatile rlock_t *rlock, unsigned long p); +#ifdef CONFIG_MDB_CONSOLE_REDIRECTION +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 33) +extern int vt_kmsg_redirect(int console); +#else +extern int kmsg_redirect; +#endif +#endif + +char mdb_buffer[256]; +char mdb_keystroke[16]; +volatile unsigned long consolestate; + +int mdb_printf(char *fmt, ...) +{ + va_list ap; + int linecount; + struct console *con; +#ifdef CONFIG_MDB_CONSOLE_REDIRECTION +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 33) +#else + int kmsg_redirect_save; +#endif +#endif + + preempt_disable(); + debug_rlock(&mdb_mutex, get_processor_id()); + +#ifdef CONFIG_MDB_CONSOLE_REDIRECTION +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 33) + consolestate = vt_kmsg_redirect(-1); + if (consolestate) + consolestate = vt_kmsg_redirect(0); +#else + kmsg_redirect_save = kmsg_redirect; + kmsg_redirect = 0; +#endif +#endif + linecount = 23; + va_start(ap, fmt); + vsprintf(mdb_buffer, fmt, ap); + va_end(ap); + + for (con = console_drivers; con; con = con->next) + { + if ((con->flags & CON_ENABLED) && con->write && + (cpu_online(get_processor_id()) || + (con->flags & CON_ANYTIME))) + { + con->write(con, mdb_buffer, strlen(mdb_buffer)); + touch_nmi_watchdog(); + } + } + + if (strchr(mdb_buffer, '\n') != NULL) + nextline++; + + if (pause_mode && (nextline == linecount)) + { + nextline = 0; + + for (con = console_drivers; con; con = con->next) + { + if ((con->flags & CON_ENABLED) && con->write && + (cpu_online(get_processor_id()) || + (con->flags & CON_ANYTIME))) + { + con->write(con, mdbprompt, strlen(mdbprompt)); + touch_nmi_watchdog(); + } + } + + mdb_keystroke[0] = (char)mdb_getkey(); + nextline = 1; + if ((mdb_keystroke[0] == 'q') || (mdb_keystroke[0] == 'Q')) + { + for (con = console_drivers; con; con = con->next) + { + if ((con->flags & CON_ENABLED) && con->write && + (cpu_online(get_processor_id()) || + (con->flags & CON_ANYTIME))) + { + con->write(con, "\n", 1); + touch_nmi_watchdog(); + } + } +#ifdef CONFIG_MDB_CONSOLE_REDIRECTION +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 33) + if (consolestate) + vt_kmsg_redirect(consolestate); +#else + kmsg_redirect = kmsg_redirect_save; +#endif +#endif + debug_unrlock(&mdb_mutex, get_processor_id()); + preempt_enable(); + return 1; + } + } +#ifdef CONFIG_MDB_CONSOLE_REDIRECTION +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 33) + if (consolestate) + vt_kmsg_redirect(consolestate); +#else + kmsg_redirect = kmsg_redirect_save; +#endif +#endif + debug_unrlock(&mdb_mutex, get_processor_id()); + preempt_enable(); + return 0; +} + + +int mdb_serial_port; + +int get_modem_char(void) +{ + unsigned char ch; + int status; + + if (mdb_serial_port == 0) + return -1; + + if ((status = inb(mdb_serial_port + UART_LSR)) & UART_LSR_DR) + { + ch = inb(mdb_serial_port + UART_RX); + switch (ch) + { + case 0x7f: + ch = 8; + break; + + case '\t': + ch = ' '; + break; + + case 8: /* backspace */ + break; + + case 13: /* enter */ + DBGPrint("\n"); + break; + + default: + if (!isprint(ch)) + return(-1); + DBGPrint("%c", ch); + break; + } + return ch; + } + return -1; +} + +#if defined(CONFIG_MDB_MODULE) +u_short plain_map[NR_KEYS] = { + 0xf200, 0xf01b, 0xf031, 0xf032, 0xf033, 0xf034, 0xf035, 0xf036, + 0xf037, 0xf038, 0xf039, 0xf030, 0xf02d, 0xf03d, 0xf07f, 0xf009, + 0xfb71, 0xfb77, 0xfb65, 0xfb72, 0xfb74, 0xfb79, 0xfb75, 0xfb69, + 0xfb6f, 0xfb70, 0xf05b, 0xf05d, 0xf201, 0xf702, 0xfb61, 0xfb73, + 0xfb64, 0xfb66, 0xfb67, 0xfb68, 0xfb6a, 0xfb6b, 0xfb6c, 0xf03b, + 0xf027, 0xf060, 0xf700, 0xf05c, 0xfb7a, 0xfb78, 0xfb63, 0xfb76, + 0xfb62, 0xfb6e, 0xfb6d, 0xf02c, 0xf02e, 0xf02f, 0xf700, 0xf30c, + 0xf703, 0xf020, 0xf207, 0xf100, 0xf101, 0xf102, 0xf103, 0xf104, + 0xf105, 0xf106, 0xf107, 0xf108, 0xf109, 0xf208, 0xf209, 0xf307, + 0xf308, 0xf309, 0xf30b, 0xf304, 0xf305, 0xf306, 0xf30a, 0xf301, + 0xf302, 0xf303, 0xf300, 0xf310, 0xf206, 0xf200, 0xf03c, 0xf10a, + 0xf10b, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, + 0xf30e, 0xf702, 0xf30d, 0xf01c, 0xf701, 0xf205, 0xf114, 0xf603, + 0xf118, 0xf601, 0xf602, 0xf117, 0xf600, 0xf119, 0xf115, 0xf116, + 0xf11a, 0xf10c, 0xf10d, 0xf11b, 0xf11c, 0xf110, 0xf311, 0xf11d, + 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, +}; + +u_short shift_map[NR_KEYS] = { + 0xf200, 0xf01b, 0xf021, 0xf040, 0xf023, 0xf024, 0xf025, 0xf05e, + 0xf026, 0xf02a, 0xf028, 0xf029, 0xf05f, 0xf02b, 0xf07f, 0xf009, + 0xfb51, 0xfb57, 0xfb45, 0xfb52, 0xfb54, 0xfb59, 0xfb55, 0xfb49, + 0xfb4f, 0xfb50, 0xf07b, 0xf07d, 0xf201, 0xf702, 0xfb41, 0xfb53, + 0xfb44, 0xfb46, 0xfb47, 0xfb48, 0xfb4a, 0xfb4b, 0xfb4c, 0xf03a, + 0xf022, 0xf07e, 0xf700, 0xf07c, 0xfb5a, 0xfb58, 0xfb43, 0xfb56, + 0xfb42, 0xfb4e, 0xfb4d, 0xf03c, 0xf03e, 0xf03f, 0xf700, 0xf30c, + 0xf703, 0xf020, 0xf207, 0xf10a, 0xf10b, 0xf10c, 0xf10d, 0xf10e, + 0xf10f, 0xf110, 0xf111, 0xf112, 0xf113, 0xf213, 0xf203, 0xf307, + 0xf308, 0xf309, 0xf30b, 0xf304, 0xf305, 0xf306, 0xf30a, 0xf301, + 0xf302, 0xf303, 0xf300, 0xf310, 0xf206, 0xf200, 0xf03e, 0xf10a, + 0xf10b, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, + 0xf30e, 0xf702, 0xf30d, 0xf200, 0xf701, 0xf205, 0xf114, 0xf603, + 0xf20b, 0xf601, 0xf602, 0xf117, 0xf600, 0xf20a, 0xf115, 0xf116, + 0xf11a, 0xf10c, 0xf10d, 0xf11b, 0xf11c, 0xf110, 0xf311, 0xf11d, + 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, +}; + +u_short ctrl_map[NR_KEYS] = { + 0xf200, 0xf200, 0xf200, 0xf000, 0xf01b, 0xf01c, 0xf01d, 0xf01e, + 0xf01f, 0xf07f, 0xf200, 0xf200, 0xf01f, 0xf200, 0xf008, 0xf200, + 0xf011, 0xf017, 0xf005, 0xf012, 0xf014, 0xf019, 0xf015, 0xf009, + 0xf00f, 0xf010, 0xf01b, 0xf01d, 0xf201, 0xf702, 0xf001, 0xf013, + 0xf004, 0xf006, 0xf007, 0xf008, 0xf00a, 0xf00b, 0xf00c, 0xf200, + 0xf007, 0xf000, 0xf700, 0xf01c, 0xf01a, 0xf018, 0xf003, 0xf016, + 0xf002, 0xf00e, 0xf00d, 0xf200, 0xf20e, 0xf07f, 0xf700, 0xf30c, + 0xf703, 0xf000, 0xf207, 0xf100, 0xf101, 0xf102, 0xf103, 0xf104, + 0xf105, 0xf106, 0xf107, 0xf108, 0xf109, 0xf208, 0xf204, 0xf307, + 0xf308, 0xf309, 0xf30b, 0xf304, 0xf305, 0xf306, 0xf30a, 0xf301, + 0xf302, 0xf303, 0xf300, 0xf310, 0xf206, 0xf200, 0xf200, 0xf10a, + 0xf10b, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, + 0xf30e, 0xf702, 0xf30d, 0xf01c, 0xf701, 0xf205, 0xf114, 0xf603, + 0xf118, 0xf601, 0xf602, 0xf117, 0xf600, 0xf119, 0xf115, 0xf116, + 0xf11a, 0xf10c, 0xf10d, 0xf11b, 0xf11c, 0xf110, 0xf311, 0xf11d, + 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, +}; +#endif + +void keyboard_reset(void) +{ + while (kbd_read_status() & KBD_STAT_IBF); + kbd_write_command(KBD_CMD_RESET); + mdelay(1); + while (kbd_read_status() & KBD_STAT_IBF); +} + +void keyboard_setup(void) +{ + int timeout; + unsigned char c; + + while (kbd_read_status() & KBD_STAT_IBF); + kbd_write_command(KBD_CCMD_READ_MODE); + mdelay(1); + while (kbd_read_status() & KBD_STAT_IBF); + for (timeout = 200 * 1000; timeout && + (!(kbd_read_status() & KBD_STAT_OBF)); timeout--); + c = kbd_read_input(); + c &= ~KBD_MODE_KBD_INT; + while (kbd_read_status() & KBD_STAT_IBF); + kbd_write_command(KBD_CCMD_WRITE_MODE); + mdelay(1); + while (kbd_read_status() & KBD_STAT_IBF); + kbd_write_output(c); + mdelay(1); + while (kbd_read_status() & KBD_STAT_IBF); + mdelay(1); +} + +void keyboard_cleanup(void) +{ + int timeout; + unsigned char c; + + while (kbd_read_status() & KBD_STAT_IBF); + kbd_write_command(KBD_CCMD_READ_MODE); + mdelay(1); + while (kbd_read_status() & KBD_STAT_IBF); + for (timeout = 200 * 1000; timeout && + (!(kbd_read_status() & KBD_STAT_OBF)); timeout--); + c = kbd_read_input(); + c |= KBD_MODE_KBD_INT; + while (kbd_read_status() & KBD_STAT_IBF); + kbd_write_command(KBD_CCMD_WRITE_MODE); + mdelay(1); + while (kbd_read_status() & KBD_STAT_IBF); + kbd_write_output(c); + mdelay(1); + while (kbd_read_status() & KBD_STAT_IBF); + mdelay(1); +} + +int mdb_suppress_crlf; +static int get_kbd_char(void) +{ + int scancode, scanstatus; + static int shift_lock; /* CAPS LOCK state (0-off, 1-on) */ + static int shift_key; /* Shift next keypress */ + static int ctrl_key; + u_short keychar; +#if !defined(CONFIG_MDB_MODULE) + extern u_short plain_map[], shift_map[], ctrl_map[]; +#endif + + if ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0) + return -1; + /* + * Fetch the scancode + */ + scancode = inb(KBD_DATA_REG); + scanstatus = inb(KBD_STATUS_REG); + + /* + * Ignore mouse events. + */ + if (scanstatus & KBD_STAT_MOUSE_OBF) + return -1; + + /* + * Ignore release, trigger on make + * (except for shift keys, where we want to + * keep the shift state so long as the key is + * held down). + */ + + if (((scancode & 0x7f) == 0x2a) || + ((scancode & 0x7f) == 0x36)) + { + /* + * Next key may use shift table + */ + if ((scancode & 0x80) == 0) { + shift_key=1; + } else { + shift_key=0; + } + return -1; + } + + if ((scancode & 0x7f) == 0x1d) { + /* + * Left ctrl key + */ + if ((scancode & 0x80) == 0) { + ctrl_key = 1; + } else { + ctrl_key = 0; + } + return -1; + } + + if ((scancode & 0x80) != 0) + return -1; + + scancode &= 0x7f; + + /* + * Translate scancode + */ + + if (scancode == 0x3a) { + /* + * Toggle caps lock + */ + shift_lock ^= 1; + return -1; + } + + if (scancode == 0x0e) { + /* + * Backspace + */ + return 8; + } + + if (scancode == 0xe0) { + return -1; + } + + /* + * For Japanese 86/106 keyboards + * See comment in drivers/char/pc_keyb.c. + * - Masahiro Adegawa + */ + if (scancode == 0x73) { + scancode = 0x59; + } else if (scancode == 0x7d) { + scancode = 0x7c; + } + + if (!shift_lock && !shift_key && !ctrl_key) { + keychar = plain_map[scancode]; + } else if (shift_lock || shift_key) { + keychar = shift_map[scancode]; + } else if (ctrl_key) { + keychar = ctrl_map[scancode]; + } else { + keychar = 0x0020; + DBGPrint("Unknown state/scancode (%d)\n", scancode); + } + + keychar &= 0x0fff; + if (keychar == '\t') + keychar = ' '; + + switch (keychar) + { + case K_F1: + case K_F2: + case K_F3: + case K_F4: + case K_F5: + case K_F6: + case K_F7: + case K_F8: + case K_F9: + case K_F10: + case K_F11: + case K_F12: + return keychar; + default: + break; + } + + switch (KTYP(keychar)) + { + case KT_LETTER: + case KT_LATIN: + if (isprint(keychar)) + break; /* printable characters */ + /* drop through */ + case KT_SPEC: + if (keychar == K_ENTER) + break; + /* drop through */ + case KT_PAD: + switch (keychar) + { + case K_P0: + case K_P1: + case K_P2: + case K_P4: + case K_P6: + case K_P7: + case K_P8: + case K_PDOT: + return keychar; + } + return -1; + + case KT_CUR: + switch (keychar) + { + case K_DOWN: + case K_LEFT: + case K_RIGHT: + case K_UP: + return keychar; + } + return -1; + + default: + return(-1); /* ignore unprintables */ + } + + if ((scancode & 0x7f) == 0x1c) { + /* + * enter key. All done. Absorb the release scancode. + */ + while ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0) + ; + + /* + * Fetch the scancode + */ + scancode = inb(KBD_DATA_REG); + scanstatus = inb(KBD_STATUS_REG); + + while (scanstatus & KBD_STAT_MOUSE_OBF) + { + scancode = inb(KBD_DATA_REG); + scanstatus = inb(KBD_STATUS_REG); + } + + /* enter-release error */ + if (scancode != 0x9c) {} ; + + if (!mdb_suppress_crlf) + DBGPrint("\n"); + return 13; + } + + /* + * echo the character. + */ + DBGPrint("%c", keychar & 0xff); + return keychar & 0xff; +} + +int mdb_getkey(void) +{ + int key = -1; + + for (;;) + { + key = get_kbd_char(); + if (key != -1) + break; + + touch_nmi_watchdog(); + } + return key; +} + +struct task_struct *mdb_current_task = NULL; + +static struct page *mdb_get_user_page(const struct task_struct *tsk, + void *to, int len, int write) +{ + struct mm_struct *mm = tsk->mm; + unsigned int flags; + struct vm_area_struct * vma; + unsigned long start = (unsigned long)to; + + if ((start & PAGE_MASK) != ((start+len) & PAGE_MASK)) + return NULL; + + start = start & PAGE_MASK; + flags = write ? (VM_WRITE | VM_MAYWRITE) : (VM_READ | VM_MAYREAD); + + vma = find_extend_vma(mm, start); + + if (!vma || (vma->vm_flags & VM_IO) || !(flags & vma->vm_flags)) + return NULL; + + return follow_page(vma, start, write ? FOLL_WRITE : 0); +} + +int mdb_user_read(void *to, void *from, size_t size) +{ + struct page *page; + void *vaddr; + + if (!mdb_current_task) + return size; + + page = mdb_get_user_page(mdb_current_task, from, size, 0); + if (!page) + return size; + + vaddr = kmap_atomic(page, KM_TYPE_NR); + memcpy(to, vaddr+ ((unsigned long)from & (PAGE_SIZE - 1)), size); + kunmap_atomic(vaddr, KM_TYPE_NR); + + return 0; +} + +int mdb_user_write(void *to, void *from, size_t size) +{ + struct page *page; + void *vaddr; + + if (!mdb_current_task) + return size; + + page = mdb_get_user_page(mdb_current_task, to, size, 1); + if (!page) + return size; + + vaddr = kmap_atomic(page, KM_TYPE_NR); + memcpy(vaddr+ ((unsigned long)to & (PAGE_SIZE - 1)), from, size); + kunmap_atomic(vaddr, KM_TYPE_NR); + + return 0; +} + +int mdb_copy(void *to, void *from, size_t size) +{ + mm_segment_t oldfs = get_fs(); + int r; + + // map pages to user space if toggle is set and to/from < PAGE_OFFSET + if (user_toggle) + { + if ((unsigned long)from < PAGE_OFFSET) + return mdb_user_read(to, from, size); + + if ((unsigned long)to < PAGE_OFFSET) + return mdb_user_write(to, from, size); + } + + set_fs(KERNEL_DS); + r = __copy_to_user_inatomic(to, from, size); + set_fs(oldfs); + return r; +} + +int mdb_verify_rw(void *addr, size_t size) +{ + unsigned char data[size]; + return (mdb_copy(data, addr, size)); +} + +int mdb_getlword(uint64_t *word, unsigned long addr, size_t size) +{ + int err; + + __u8 w1; + __u16 w2; + __u32 w4; + __u64 w8; + + *word = 0; /* Default value if addr or size is invalid */ + switch (size) { + case 1: + if (!(err = mdb_copy(&w1, (void *)addr, size))) + *word = w1; + break; + case 2: + if (!(err = mdb_copy(&w2, (void *)addr, size))) + *word = w2; + break; + case 4: + if (!(err = mdb_copy(&w4, (void *)addr, size))) + *word = w4; + break; + case 8: + if (!(err = mdb_copy(&w8, (void *)addr, size))) + *word = w8; + break; + default: + err = -EFAULT; + } + return (err); +} + +int mdb_putword(unsigned long addr, unsigned long word, size_t size) +{ + int err; + __u8 w1; + __u16 w2; + __u32 w4; + __u64 w8; + + switch (size) { + case 1: + w1 = word; + err = mdb_copy((void *)addr, &w1, size); + break; + case 2: + w2 = word; + err = mdb_copy((void *)addr, &w2, size); + break; + case 4: + w4 = word; + err = mdb_copy((void *)addr, &w4, size); + break; + case 8: + w8 = word; + err = mdb_copy((void *)addr, &w8, size); + break; + default: + err = -EFAULT; + } + return (err); +} + +int mdb_putqword(uint64_t *addr, uint64_t word, size_t size) +{ + int err; + __u8 w1; + __u16 w2; + __u32 w4; + __u64 w8; + + switch (size) { + case 1: + w1 = word; + err = mdb_copy((void *)addr, &w1, size); + break; + case 2: + w2 = word; + err = mdb_copy((void *)addr, &w2, size); + break; + case 4: + w4 = word; + err = mdb_copy((void *)addr, &w4, size); + break; + case 8: + w8 = word; + err = mdb_copy((void *)addr, &w8, size); + break; + default: + err = -EFAULT; + } + return (err); +} + +uint64_t mdb_getqword(uint64_t *addr, size_t size) +{ + uint64_t data = 0; + register int ret; + + ret = mdb_getlword(&data, (unsigned long)addr, size); + if (ret) + return 0; + + return data; +} + +unsigned long mdb_getword(unsigned long addr, size_t size) +{ + uint64_t data = 0; + register int ret; + + ret = mdb_getlword((uint64_t *)&data, addr, size); + if (ret) + return 0; + + return (unsigned long)data; +} + +uint64_t mdb_segment_getqword(unsigned long sv, uint64_t *addr, size_t size) +{ + uint64_t data = 0; + register int ret; + + ret = mdb_getlword(&data, (unsigned long)addr, size); + if (ret) + return 0; + + return data; +} + +unsigned long mdb_segment_getword(unsigned long sv, unsigned long addr, + size_t size) +{ + uint64_t data = 0; + register int ret; + + ret = mdb_getlword((uint64_t *)&data, addr, size); + if (ret) + return 0; + + return (unsigned long)data; +} + +int DisplayClosestSymbol(unsigned long address) +{ + char *modname; + const char *name; + unsigned long offset = 0, size; + char namebuf[KSYM_NAME_LEN+1]; + + name = kallsyms_lookup(address, &size, &offset, &modname, namebuf); + if (!name) + return -1; + + if (modname) + { + if (offset) + DBGPrint("%s|%s+0x%X\n", modname, name, offset); + else + DBGPrint("%s|%s\n", modname, name); + } + else + { + if (offset) + DBGPrint("%s+0x%X\n", name, offset); + else + DBGPrint("%s\n", name); + } + return 0; +} + +void DumpOSSymbolTableMatch(unsigned char *symbol) +{ + mdb_kallsyms(symbol, DBGPrint); + return; +} + +unsigned long GetValueFromSymbol(unsigned char *symbol) +{ + return ((unsigned long)kallsyms_lookup_name(symbol)); +} + + +unsigned char *GetModuleInfoFromSymbolValue(unsigned long value, unsigned char *buf, unsigned long len) +{ + char *modname; + const char *name; + unsigned long offset, size; + char namebuf[KSYM_NAME_LEN+1]; + + name = kallsyms_lookup(value, &size, &offset, &modname, namebuf); + if (modname && buf) + { + strncpy(buf, modname, len); + return (unsigned char *)buf; + } + return NULL; +} + +unsigned char *GetSymbolFromValue(unsigned long value, unsigned char *buf, unsigned long len) +{ + char *modname; + const char *name; + unsigned long offset, size; + char namebuf[KSYM_NAME_LEN+1]; + + name = kallsyms_lookup(value, &size, &offset, &modname, namebuf); + if (!name) + return NULL; + + if (!offset && buf) + { + strncpy(buf, namebuf, len); + return (unsigned char *)buf; + } + + return NULL; +} + +unsigned char *GetSymbolFromValueWithOffset(unsigned long value, unsigned long *sym_offset, + unsigned char *buf, unsigned long len) +{ + char *modname; + const char *name; + unsigned long offset, size; + char namebuf[KSYM_NAME_LEN+1]; + + name = kallsyms_lookup(value, &size, &offset, &modname, namebuf); + if (!name || !buf) + return NULL; + + if (sym_offset) + *sym_offset = offset; + + strncpy(buf, namebuf, len); + return (unsigned char *)buf; +} + +unsigned char *GetSymbolFromValueOffsetModule(unsigned long value, unsigned long *sym_offset, + unsigned char **module, unsigned char *buf, unsigned long len) +{ + char *modname; + const char *name; + unsigned long offset, size; + char namebuf[KSYM_NAME_LEN+1]; + + name = kallsyms_lookup(value, &size, &offset, &modname, namebuf); + if (!name || !buf) + return NULL; + + if (sym_offset) + *sym_offset = offset; + + if (module) + *module = modname; + + strncpy(buf, namebuf, len); + return (unsigned char *)buf; +} + + +unsigned long get_processor_id(void) +{ +#if defined(CONFIG_SMP) + return raw_smp_processor_id(); +#else + return 0; +#endif +} + +unsigned long get_physical_processor(void) +{ +#if defined(CONFIG_SMP) + return raw_smp_processor_id(); +#else + return 0; +#endif +} + +unsigned long fpu_present(void) +{ + if (boot_cpu_has(X86_FEATURE_FPU)) + return 1; + return 0; +} + +extern unsigned long cpu_mttr_on(void) +{ + if (boot_cpu_has(X86_FEATURE_MTRR)) + return 1; + return 0; +} + +unsigned char *UpcaseString(unsigned char *s) +{ + register int i; + + for (i = 0; i < strlen(s); i++) + s[i] = toupper(s[i]); + return s; + +} +void ClearScreen(void) +{ + mdb_printf("%c%c", 0x1B, 'c'); + return; +} + +unsigned long ReadDS(void) +{ + unsigned short contents = 0; + + __asm__ ("mov %%ds,%0\n\t":"=r"(contents)); + return contents; +} + +unsigned long ReadES(void) +{ + unsigned short contents = 0; + + __asm__ ("mov %%es,%0\n\t":"=r"(contents)); + return contents; +} + +unsigned long ReadFS(void) +{ + unsigned short contents = 0; + + __asm__ ("mov %%fs,%0\n\t":"=r"(contents)); + return contents; +} + +unsigned long ReadGS(void) +{ + unsigned short contents = 0; + + __asm__ ("mov %%gs,%0\n\t":"=r"(contents)); + return contents; +} + +#ifdef CONFIG_X86_64 +unsigned long ReadDR(unsigned long regnum) +{ + unsigned long contents = 0; + + switch(regnum) + { + case 0: + __asm__ ("movq %%db0,%0\n\t":"=r"(contents)); + break; + case 1: + __asm__ ("movq %%db1,%0\n\t":"=r"(contents)); + break; + case 2: + __asm__ ("movq %%db2,%0\n\t":"=r"(contents)); + break; + case 3: + __asm__ ("movq %%db3,%0\n\t":"=r"(contents)); + break; + case 4: + case 5: + break; + case 6: + __asm__ ("movq %%db6,%0\n\t":"=r"(contents)); + break; + case 7: + __asm__ ("movq %%db7,%0\n\t":"=r"(contents)); + break; + default: + break; + } + + return contents; +} + +void WriteDR(int regnum, unsigned long contents) +{ + switch(regnum) + { + case 0: + __asm__ ("movq %0,%%db0\n\t"::"r"(contents)); + break; + case 1: + __asm__ ("movq %0,%%db1\n\t"::"r"(contents)); + break; + case 2: + __asm__ ("movq %0,%%db2\n\t"::"r"(contents)); + break; + case 3: + __asm__ ("movq %0,%%db3\n\t"::"r"(contents)); + break; + case 4: + case 5: + break; + case 6: + __asm__ ("movq %0,%%db6\n\t"::"r"(contents)); + break; + case 7: + __asm__ ("movq %0,%%db7\n\t"::"r"(contents)); + break; + default: + break; + } +} + +unsigned long ReadCR(int regnum) +{ + unsigned long contents = 0; + + switch(regnum) + { + case 0: + __asm__ ("movq %%cr0,%0\n\t":"=r"(contents)); + break; + case 1: + break; + case 2: + __asm__ ("movq %%cr2,%0\n\t":"=r"(contents)); + break; + case 3: + __asm__ ("movq %%cr3,%0\n\t":"=r"(contents)); + break; + case 4: + __asm__ ("movq %%cr4,%0\n\t":"=r"(contents)); + break; + default: + break; + } + return contents; +} + +void WriteCR(int regnum, unsigned long contents) +{ + switch(regnum) + { + case 0: + __asm__ ("movq %0,%%cr0\n\t"::"r"(contents)); + break; + case 1: + break; + case 2: + __asm__ ("movq %0,%%cr2\n\t"::"r"(contents)); + break; + case 3: + __asm__ ("movq %0,%%cr3\n\t"::"r"(contents)); + break; + case 4: + __asm__ ("movq %0,%%cr4\n\t"::"r"(contents)); + break; + default: + break; + } + return; +} + +#else +unsigned long ReadDR(unsigned long regnum) +{ + unsigned long contents = 0; + + switch(regnum) + { + case 0: + __asm__ ("movl %%db0,%0\n\t":"=r"(contents)); + break; + case 1: + __asm__ ("movl %%db1,%0\n\t":"=r"(contents)); + break; + case 2: + __asm__ ("movl %%db2,%0\n\t":"=r"(contents)); + break; + case 3: + __asm__ ("movl %%db3,%0\n\t":"=r"(contents)); + break; + case 4: + case 5: + break; + case 6: + __asm__ ("movl %%db6,%0\n\t":"=r"(contents)); + break; + case 7: + __asm__ ("movl %%db7,%0\n\t":"=r"(contents)); + break; + default: + break; + } + + return contents; +} + +void WriteDR(int regnum, unsigned long contents) +{ + switch(regnum) + { + case 0: + __asm__ ("movl %0,%%db0\n\t"::"r"(contents)); + break; + case 1: + __asm__ ("movl %0,%%db1\n\t"::"r"(contents)); + break; + case 2: + __asm__ ("movl %0,%%db2\n\t"::"r"(contents)); + break; + case 3: + __asm__ ("movl %0,%%db3\n\t"::"r"(contents)); + break; + case 4: + case 5: + break; + case 6: + __asm__ ("movl %0,%%db6\n\t"::"r"(contents)); + break; + case 7: + __asm__ ("movl %0,%%db7\n\t"::"r"(contents)); + break; + default: + break; + } +} + +unsigned long ReadCR(int regnum) +{ + unsigned long contents = 0; + + switch(regnum) + { + case 0: + __asm__ ("movl %%cr0,%0\n\t":"=r"(contents)); + break; + case 1: + break; + case 2: + __asm__ ("movl %%cr2,%0\n\t":"=r"(contents)); + break; + case 3: + __asm__ ("movl %%cr3,%0\n\t":"=r"(contents)); + break; + case 4: + __asm__ ("movl %%cr4,%0\n\t":"=r"(contents)); + break; + default: + break; + } + return contents; +} + +void WriteCR(int regnum, unsigned long contents) +{ + switch(regnum) + { + case 0: + __asm__ ("movl %0,%%cr0\n\t"::"r"(contents)); + break; + case 1: + break; + case 2: + __asm__ ("movl %0,%%cr2\n\t"::"r"(contents)); + break; + case 3: + __asm__ ("movl %0,%%cr3\n\t"::"r"(contents)); + break; + case 4: + __asm__ ("movl %0,%%cr4\n\t"::"r"(contents)); + break; + default: + break; + } + return; +} +#endif + +unsigned long ReadTR(void) +{ + unsigned short tr; + + __asm__ __volatile__("str %0":"=a"(tr)); + + return (unsigned long) tr; +} + +unsigned long ReadLDTR(void) +{ + unsigned short ldt; + + __asm__ __volatile__("sldt %0":"=a"(ldt)); + + return (unsigned long) ldt; +} + +void ReadGDTR(unsigned long *v) +{ + __asm__ __volatile__("sgdt %0":"=m"(*v)); +} + +void ReadIDTR(unsigned long *v) +{ + __asm__ __volatile__("sidt %0":"=m"(*v)); +} + +void save_npx(NUMERIC_FRAME *v) +{ + __asm__ __volatile__("fsave %0":"=m"(*v)); +} + +void load_npx(NUMERIC_FRAME *v) +{ + __asm__ __volatile__("frstor %0":"=m"(*v)); +} + +unsigned long ReadDR6(void) { return (ReadDR(6));