Adding upstream version 2.06.upstream/2.06upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

5 files changed, 846 insertions, 0 deletions

diff --git a/grub-core/gdb/cstub.c b/grub-core/gdb/cstub.c
new file mode 100644
index 0000000..b64acd7
--- /dev/null
+++ b/grub-core/gdb/cstub.c
@@ -0,0 +1,366 @@
+/* cstub.c - machine independent portion of remote GDB stub */
+/*
+ *  Copyright (C) 2006  Lubomir Kundrak
+ *
+ *  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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <grub/misc.h>
+#include <grub/cpu/gdb.h>
+#include <grub/gdb.h>
+#include <grub/serial.h>
+#include <grub/backtrace.h>
+
+static const char hexchars[] = "0123456789abcdef";
+int grub_gdb_regs[GRUB_MACHINE_NR_REGS];
+
+#define GRUB_GDB_COMBUF_SIZE 400	/* At least sizeof(grub_gdb_regs)*2 are needed for
+					   register packets.  */
+static char grub_gdb_inbuf[GRUB_GDB_COMBUF_SIZE + 1];
+static char grub_gdb_outbuf[GRUB_GDB_COMBUF_SIZE + 1];
+
+struct grub_serial_port *grub_gdb_port;
+
+static int
+hex (char ch)
+{
+  if ((ch >= 'a') && (ch <= 'f'))
+    return (ch - 'a' + 10);
+  if ((ch >= '0') && (ch <= '9'))
+    return (ch - '0');
+  if ((ch >= 'A') && (ch <= 'F'))
+    return (ch - 'A' + 10);
+  return (-1);
+}
+
+/* Scan for the sequence $<data>#<checksum>.  */
+static char *
+grub_gdb_getpacket (void)
+{
+  char *buffer = &grub_gdb_inbuf[0];
+  unsigned char checksum;
+  unsigned char xmitcsum;
+  int count;
+  int ch;
+
+  while (1)
+    {
+      /* Wait around for the start character, ignore all other
+         characters.  */
+      while ((ch = grub_serial_port_fetch (grub_gdb_port)) != '$');
+
+    retry:
+      checksum = 0;
+      xmitcsum = -1;
+      count = 0;
+
+      /* Now read until a # or end of buffer is found.  */
+      while (count < GRUB_GDB_COMBUF_SIZE)
+	{
+	  do
+	    ch = grub_serial_port_fetch (grub_gdb_port);
+	  while (ch < 0);
+	  if (ch == '$')
+	    goto retry;
+	  if (ch == '#')
+	    break;
+	  checksum += ch;
+	  buffer[count] = ch;
+	  count = count + 1;
+	}
+      buffer[count] = 0;
+      if (ch == '#')
+	{
+	  do
+	    ch = grub_serial_port_fetch (grub_gdb_port);
+	  while (ch < 0);
+	  xmitcsum = hex (ch) << 4;
+	  do
+	    ch = grub_serial_port_fetch (grub_gdb_port);
+	  while (ch < 0);
+	  xmitcsum += hex (ch);
+
+	  if (checksum != xmitcsum)
+	    grub_serial_port_put (grub_gdb_port, '-');	/* Failed checksum.  */
+	  else
+	    {
+	      grub_serial_port_put (grub_gdb_port, '+');	/* Successful transfer.  */
+
+	      /* If a sequence char is present, reply the sequence ID.  */
+	      if (buffer[2] == ':')
+		{
+		  grub_serial_port_put (grub_gdb_port, buffer[0]);
+		  grub_serial_port_put (grub_gdb_port, buffer[1]);
+
+		  return &buffer[3];
+		}
+	      return &buffer[0];
+	    }
+	}
+    }
+}
+
+/* Send the packet in buffer.  */
+static void
+grub_gdb_putpacket (char *buffer)
+{
+  grub_uint8_t checksum;
+
+  /* $<packet info>#<checksum>.  */
+  do
+    {
+      char *ptr;
+      grub_serial_port_put (grub_gdb_port, '$');
+      checksum = 0;
+
+      for (ptr = buffer; *ptr; ptr++)
+	{
+	  grub_serial_port_put (grub_gdb_port, *ptr);
+	  checksum += *ptr;
+	}
+
+      grub_serial_port_put (grub_gdb_port, '#');
+      grub_serial_port_put (grub_gdb_port, hexchars[checksum >> 4]);
+      grub_serial_port_put (grub_gdb_port, hexchars[checksum & 0xf]);
+    }
+  while (grub_serial_port_fetch (grub_gdb_port) != '+');
+}
+
+/* Convert the memory pointed to by mem into hex, placing result in buf.
+   Return a pointer to the last char put in buf (NULL).  */
+static char *
+grub_gdb_mem2hex (char *mem, char *buf, grub_size_t count)
+{
+  grub_size_t i;
+  unsigned char ch;
+
+  for (i = 0; i < count; i++)
+    {
+      ch = *mem++;
+      *buf++ = hexchars[ch >> 4];
+      *buf++ = hexchars[ch % 16];
+    }
+  *buf = 0;
+  return (buf);
+}
+
+/* Convert the hex array pointed to by buf into binary to be placed in mem.
+   Return a pointer to the character after the last byte written.  */
+static char *
+grub_gdb_hex2mem (char *buf, char *mem, int count)
+{
+  int i;
+  unsigned char ch;
+
+  for (i = 0; i < count; i++)
+    {
+      ch = hex (*buf++) << 4;
+      ch = ch + hex (*buf++);
+      *mem++ = ch;
+    }
+  return (mem);
+}
+
+/* Convert hex characters to int and return the number of characters
+   processed.  */
+static int
+grub_gdb_hex2int (char **ptr, grub_uint64_t *int_value)
+{
+  int num_chars = 0;
+  int hex_value;
+
+  *int_value = 0;
+
+  while (**ptr)
+    {
+      hex_value = hex (**ptr);
+      if (hex_value >= 0)
+	{
+	  *int_value = (*int_value << 4) | hex_value;
+	  num_chars++;
+	}
+      else
+	break;
+
+      (*ptr)++;
+    }
+
+  return (num_chars);
+}
+
+/* This function does all command procesing for interfacing to gdb.  */
+void __attribute__ ((regparm(3)))
+grub_gdb_trap (int trap_no)
+{
+  unsigned int sig_no;
+  int stepping;
+  grub_uint64_t addr;
+  grub_uint64_t length;
+  char *ptr;
+
+  if (!grub_gdb_port)
+    {
+      grub_printf ("Unhandled exception 0x%x at ", trap_no);
+      grub_backtrace_print_address ((void *) grub_gdb_regs[PC]);
+      grub_printf ("\n");
+      grub_backtrace_pointer ((void *) grub_gdb_regs[EBP]);
+      grub_fatal ("Unhandled exception");
+    }
+
+  sig_no = grub_gdb_trap2sig (trap_no);
+
+  ptr = grub_gdb_outbuf;
+
+  /* Reply to host that an exception has occurred.  */
+
+  *ptr++ = 'T';	/* Notify gdb with signo, PC, FP and SP.  */
+
+  *ptr++ = hexchars[sig_no >> 4];
+  *ptr++ = hexchars[sig_no & 0xf];
+
+  /* Stack pointer.  */
+  *ptr++ = hexchars[SP];
+  *ptr++ = ':';
+  ptr = grub_gdb_mem2hex ((char *) &grub_gdb_regs[ESP], ptr, 4);
+  *ptr++ = ';';
+
+  /* Frame pointer.  */
+  *ptr++ = hexchars[FP];
+  *ptr++ = ':';
+  ptr = grub_gdb_mem2hex ((char *) &grub_gdb_regs[EBP], ptr, 4);
+  *ptr++ = ';';
+
+  /* Program counter.  */
+  *ptr++ = hexchars[PC];
+  *ptr++ = ':';
+  ptr = grub_gdb_mem2hex ((char *) &grub_gdb_regs[PC], ptr, 4);
+  *ptr++ = ';';
+
+  *ptr = '\0';
+
+  grub_gdb_putpacket (grub_gdb_outbuf);
+
+  stepping = 0;
+
+  while (1)
+    {
+      grub_gdb_outbuf[0] = 0;
+      ptr = grub_gdb_getpacket ();
+
+      switch (*ptr++)
+	{
+	case '?':
+	  grub_gdb_outbuf[0] = 'S';
+	  grub_gdb_outbuf[1] = hexchars[sig_no >> 4];
+	  grub_gdb_outbuf[2] = hexchars[sig_no & 0xf];
+	  grub_gdb_outbuf[3] = 0;
+	  break;
+
+	/* Return values of the CPU registers.  */
+	case 'g':
+	  grub_gdb_mem2hex ((char *) grub_gdb_regs, grub_gdb_outbuf,
+			    sizeof (grub_gdb_regs));
+	  break;
+
+	/* Set values of the CPU registers -- return OK.  */
+	case 'G':
+	  grub_gdb_hex2mem (ptr, (char *) grub_gdb_regs,
+			    sizeof (grub_gdb_regs));
+	  grub_strcpy (grub_gdb_outbuf, "OK");
+	  break;
+
+	/* Set the value of a single CPU register -- return OK.  */
+	case 'P':
+	  {
+	    grub_uint64_t regno;
+
+	    if (grub_gdb_hex2int (&ptr, &regno) && *ptr++ == '=')
+	      if (regno < GRUB_MACHINE_NR_REGS)
+		{
+		  grub_gdb_hex2mem (ptr, (char *) &grub_gdb_regs[regno], 4);
+		  grub_strcpy (grub_gdb_outbuf, "OK");
+		  break;
+		}
+	    /* FIXME: GDB requires setting orig_eax. I don't know what's
+	       this register is about. For now just simulate setting any
+	       registers.  */
+	    grub_strcpy (grub_gdb_outbuf, /*"E01"*/ "OK");
+	    break;
+	  }
+
+	/* mAA..AA,LLLL: Read LLLL bytes at address AA..AA.  */
+	case 'm':
+	  /* Try to read %x,%x.  Set ptr = 0 if successful.  */
+	  if (grub_gdb_hex2int (&ptr, &addr))
+	    if (*(ptr++) == ',')
+	      if (grub_gdb_hex2int (&ptr, &length))
+		{
+		  ptr = 0;
+		  grub_gdb_mem2hex ((char *) (grub_addr_t) addr,
+				    grub_gdb_outbuf, length);
+		}
+	  if (ptr)
+	    grub_strcpy (grub_gdb_outbuf, "E01");
+	  break;
+
+	/* MAA..AA,LLLL: Write LLLL bytes at address AA.AA -- return OK.  */
+	case 'M':
+	  /* Try to read %x,%x.  Set ptr = 0 if successful.  */
+	  if (grub_gdb_hex2int (&ptr, &addr))
+	    if (*(ptr++) == ',')
+	      if (grub_gdb_hex2int (&ptr, &length))
+		if (*(ptr++) == ':')
+		  {
+		    grub_gdb_hex2mem (ptr, (char *) (grub_addr_t) addr, length);
+		    grub_strcpy (grub_gdb_outbuf, "OK");
+		    ptr = 0;
+		  }
+	  if (ptr)
+	    {
+	      grub_strcpy (grub_gdb_outbuf, "E02");
+	    }
+	  break;
+
+	/* sAA..AA: Step one instruction from AA..AA(optional).  */
+	case 's':
+	  stepping = 1;
+	  /* FALLTHROUGH */
+
+	/* cAA..AA: Continue at address AA..AA(optional).  */
+	case 'c':
+	  /* try to read optional parameter, pc unchanged if no parm */
+	  if (grub_gdb_hex2int (&ptr, &addr))
+	    grub_gdb_regs[PC] = addr;
+
+	  /* Clear the trace bit.  */
+	  grub_gdb_regs[PS] &= 0xfffffeff;
+
+	  /* Set the trace bit if we're stepping.  */
+	  if (stepping)
+	    grub_gdb_regs[PS] |= 0x100;
+
+	  return;
+
+	/* Kill the program.  */
+	case 'k':
+	  /* Do nothing.  */
+	  return;
+	}
+
+      /* Reply to the request.  */
+      grub_gdb_putpacket (grub_gdb_outbuf);
+    }
+}
+
diff --git a/grub-core/gdb/gdb.c b/grub-core/gdb/gdb.c
new file mode 100644
index 0000000..1818cb6
--- /dev/null
+++ b/grub-core/gdb/gdb.c
@@ -0,0 +1,104 @@
+/* gdb.c - gdb remote stub module */
+/*
+ *  Copyright (C) 2003  Free Software Foundation, Inc.
+ *  Copyright (C) 2006  Lubomir Kundrak
+ *
+ *  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 3 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <grub/types.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/err.h>
+#include <grub/dl.h>
+#include <grub/normal.h>
+#include <grub/term.h>
+#include <grub/cpu/gdb.h>
+#include <grub/gdb.h>
+#include <grub/serial.h>
+#include <grub/i18n.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static grub_err_t
+grub_cmd_gdbstub (struct grub_command *cmd __attribute__ ((unused)),
+		  int argc, char **args)
+{
+  struct grub_serial_port *port;
+  if (argc < 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "port required");
+  port = grub_serial_find (args[0]);
+  if (!port)
+    return grub_errno;
+  grub_gdb_port = port;
+  /* TRANSLATORS: at this position GRUB waits for the user to do an action
+     in remote debugger, namely to tell it to establish connection.  */
+  grub_puts_ (N_("Now connect the remote debugger, please."));
+  grub_gdb_breakpoint ();
+  return 0;
+}
+
+static grub_err_t
+grub_cmd_gdbstop (struct grub_command *cmd __attribute__ ((unused)),
+		  int argc __attribute__ ((unused)),
+		  char **args __attribute__ ((unused)))
+{
+  grub_gdb_port = NULL;
+  return 0;
+}
+
+static grub_err_t
+grub_cmd_gdb_break (struct grub_command *cmd __attribute__ ((unused)),
+		    int argc __attribute__ ((unused)),
+		    char **args __attribute__ ((unused)))
+{
+  if (!grub_gdb_port)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "No GDB stub is running");
+  grub_gdb_breakpoint ();
+  return 0;
+}
+
+static grub_command_t cmd, cmd_stop, cmd_break;
+
+GRUB_MOD_INIT (gdb)
+{
+  grub_gdb_idtinit ();
+  cmd = grub_register_command_lockdown ("gdbstub", grub_cmd_gdbstub,
+					N_("PORT"),
+					/*
+					 * TRANSLATORS: GDB stub is a small part of
+					 * GDB functionality running on local host
+					 * which allows remote debugger to
+					 * connect to it.
+					 */
+					N_("Start GDB stub on given port"));
+  cmd_break = grub_register_command_lockdown ("gdbstub_break", grub_cmd_gdb_break,
+					      /*
+					       * TRANSLATORS: this refers to triggering
+					       * a breakpoint so that the user will land
+					       * into GDB.
+					       */
+					      0, N_("Break into GDB"));
+  cmd_stop = grub_register_command_lockdown ("gdbstub_stop", grub_cmd_gdbstop,
+					     0, N_("Stop GDB stub"));
+}
+
+GRUB_MOD_FINI (gdb)
+{
+  grub_unregister_command (cmd);
+  grub_unregister_command (cmd_stop);
+  grub_gdb_idtrestore ();
+}
+
diff --git a/grub-core/gdb/i386/idt.c b/grub-core/gdb/i386/idt.c
new file mode 100644
index 0000000..69bfcb0
--- /dev/null
+++ b/grub-core/gdb/i386/idt.c
@@ -0,0 +1,78 @@
+/* idt.c - routines for constructing IDT fot the GDB stub */
+/*
+ *  Copyright (C) 2006  Lubomir Kundrak
+ *
+ *  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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <grub/machine/memory.h>
+#include <grub/misc.h>
+#include <grub/cpu/gdb.h>
+#include <grub/gdb.h>
+
+static struct grub_cpu_interrupt_gate grub_gdb_idt[GRUB_GDB_LAST_TRAP + 1]
+  __attribute__ ((aligned(16)));
+
+/* Sets up a gate descriptor in the IDT table.  */
+static void
+grub_idt_gate (struct grub_cpu_interrupt_gate *gate, void (*offset) (void),
+	       grub_uint16_t selector, grub_uint8_t type, grub_uint8_t dpl)
+{
+  gate->offset_lo = (int) offset & 0xffff;
+  gate->selector = selector & 0xffff;
+  gate->unused = 0;
+  gate->gate = (type & 0x1f) | ((dpl & 0x3) << 5) | 0x80;
+  gate->offset_hi = ((int) offset >> 16) & 0xffff;
+}
+
+static struct grub_cpu_idt_descriptor grub_gdb_orig_idt_desc
+  __attribute__ ((aligned(16)));
+static struct grub_cpu_idt_descriptor grub_gdb_idt_desc
+  __attribute__ ((aligned(16)));
+
+/* Set up interrupt and trap handler descriptors in IDT.  */
+void
+grub_gdb_idtinit (void)
+{
+  int i;
+  grub_uint16_t seg;
+
+  asm volatile ("xorl %%eax, %%eax\n"
+		"mov %%cs, %%ax\n" :"=a" (seg));
+
+  for (i = 0; i <= GRUB_GDB_LAST_TRAP; i++)
+    {
+      grub_idt_gate (&grub_gdb_idt[i],
+		     grub_gdb_trapvec[i], seg,
+                     GRUB_CPU_TRAP_GATE, 0);
+    }
+
+  grub_gdb_idt_desc.base = (grub_addr_t) grub_gdb_idt;
+  grub_gdb_idt_desc.limit = sizeof (grub_gdb_idt) - 1;
+  asm volatile ("sidt %0" : : "m" (grub_gdb_orig_idt_desc));
+  asm volatile ("lidt %0" : : "m" (grub_gdb_idt_desc));
+}
+
+void
+grub_gdb_idtrestore (void)
+{
+  asm volatile ("lidt %0" : : "m" (grub_gdb_orig_idt_desc));
+}
+
+void
+grub_gdb_breakpoint (void)
+{
+  asm volatile ("int $3");
+}
diff --git a/grub-core/gdb/i386/machdep.S b/grub-core/gdb/i386/machdep.S
new file mode 100644
index 0000000..f96d2b9
--- /dev/null
+++ b/grub-core/gdb/i386/machdep.S
@@ -0,0 +1,245 @@
+/* machdep.S - machine dependent assembly routines for the GDB stub */
+/*
+ *  Copyright (C) 2006  Lubomir Kundrak
+ *
+ *  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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <grub/cpu/gdb.h>
+#include <grub/symbol.h>
+
+#define EC_PRESENT	1
+#define EC_ABSENT	0
+
+#define GRUB_GDB_STACKSIZE	40000
+
+#define SEP ,
+
+#ifdef __APPLE__
+	.zerofill __DATA, __bss, LOCAL(grub_gdb_stack_end), GRUB_GDB_STACKSIZE, 4
+	LOCAL(grub_gdb_stack) = LOCAL(grub_gdb_stack_end)
+#else
+/*
+ * The .data index for the address vector.
+ */
+
+#define	VECTOR		1
+
+	.bss
+	.space GRUB_GDB_STACKSIZE
+VARIABLE(grub_gdb_stack)
+#endif
+
+/*
+ * Supplemental macros for register saving/restoration
+ * on exception handler entry/leave.
+ */
+
+#ifdef __APPLE__
+.macro save32
+#define REG $0
+#define NDX $1
+#else
+.macro save32 reg ndx
+#define REG \reg
+#define NDX \ndx
+#endif
+	movl REG, EXT_C(grub_gdb_regs)+(NDX * 4)
+.endm
+
+#undef REG
+#undef NDX
+
+#ifdef __APPLE__
+.macro save16
+#define REG $0
+#define NDX $1
+#else
+.macro save16 reg ndx
+#define REG \reg
+#define NDX \ndx
+#endif
+	xorl %eax, %eax
+	movw REG, EXT_C(grub_gdb_regs)+(NDX * 4)
+	movw %ax, EXT_C(grub_gdb_regs)+(NDX * 4 + 2)
+	movl EXT_C(grub_gdb_regs)+(EAX * 4), %eax
+.endm
+
+#undef REG
+#undef NDX
+
+#ifdef __APPLE__
+.macro load32
+#define NDX $0
+#define REG $1
+#else
+.macro load32 ndx reg
+#define REG \reg
+#define NDX \ndx
+#endif
+	movl EXT_C(grub_gdb_regs)+(NDX * 4), REG
+.endm
+
+#undef REG
+#undef NDX
+
+#ifdef __APPLE__
+.macro load16
+#define NDX $0
+#define REG $1
+#else
+.macro load16 ndx reg 
+#define NDX \ndx
+#define REG \reg
+#endif
+	movw EXT_C(grub_gdb_regs)+(NDX * 4), REG
+.endm
+
+#undef REG
+#undef NDX
+
+.macro save_context
+	save32 %eax, EAX
+
+	save32 %ecx, ECX
+	save32 %edx, EDX
+	save32 %ebx, EBX
+	save32 %ebp, EBP
+	save32 %esi, ESI
+	save32 %edi, EDI
+
+	popl %ebx
+	save32 %ebx, EIP
+	popl %ebx
+	save32 %ebx, CS
+	popl %ebx
+	save32 %ebx, EFLAGS
+
+	save32 %esp, ESP
+
+	save16 %ds, DS
+	save16 %es, ES
+	save16 %fs, FS
+	save16 %gs, GS
+	save16 %ss, SS
+.endm
+
+.macro load_context
+	load16 SS, %ss
+	load32 ESP, %esp
+
+	load32 EBP, %ebp
+	load32 ESI, %esi
+	load32 EDI, %edi
+
+	load16 DS, %ds
+	load16 ES, %es
+	load16 FS, %fs
+	load16 GS, %gs
+
+	load32 EFLAGS, %eax
+	pushl %eax
+	load32 CS, %eax
+	pushl %eax
+	load32 EIP, %eax
+	pushl %eax
+
+	load32 EBX, %ebx
+	load32 EDX, %edx
+	load32 ECX, %ecx
+	load32 EAX, %eax
+.endm
+
+/*
+ * This macro creates handlers for a given range of exception numbers
+ * and adds their addresses to the grub_gdb_trapvec array.
+ */
+
+#ifdef __APPLE__
+.macro ent
+#define EC $0
+#define BEG $1
+#define END $2
+#else
+.macro ent ec beg end=0
+#define EC \ec
+#define BEG \beg
+#define END \end
+#endif
+
+	/*
+	 * Wrapper body itself.
+	 */
+
+	.text
+1:	
+	.if EC
+		add MACRO_DOLLAR(4), %esp
+	.endif
+
+	save_context
+#ifdef __APPLE__
+	mov	$LOCAL(grub_gdb_stack), %esp
+#else
+	mov	$EXT_C(grub_gdb_stack), %esp
+#endif
+	mov	$(BEG), %eax	/* trap number */
+	call	EXT_C(grub_gdb_trap)
+	load_context
+	iret
+
+	/*
+	 * Address entry in trapvec array.
+	 */
+
+#ifdef __APPLE__
+	.section __DATA, VECTOR
+#else
+       .data VECTOR
+#endif
+	.long 1b
+
+	/*
+	 * Next... (recursion).
+	 */
+
+	.if END-BEG > 0
+#ifdef __APPLE__
+		ent EC, (BEG+1), END
+#else
+		ent \ec "(\beg+1)" \end
+#endif
+	.endif
+.endm
+
+/*
+ * Here does the actual construction of the address array and handlers
+ * take place.
+ */
+#ifdef __APPLE__
+	.section __DATA, VECTOR
+#else
+       .data VECTOR
+#endif
+VARIABLE(grub_gdb_trapvec)
+	ent EC_ABSENT,	0, 7
+	ent EC_PRESENT,	8
+	ent EC_ABSENT,	9
+	ent EC_PRESENT,	10, 14
+	/*
+	 * You may have to split this further or as(1)
+	 * will complain about nesting being too deep.
+	 */
+	ent EC_ABSENT,	15, GRUB_GDB_LAST_TRAP
diff --git a/grub-core/gdb/i386/signal.c b/grub-core/gdb/i386/signal.c
new file mode 100644
index 0000000..1ac3bbd
--- /dev/null
+++ b/grub-core/gdb/i386/signal.c
@@ -0,0 +1,53 @@
+/* idt.c - routines for constructing IDT fot the GDB stub */
+/*
+ *  Copyright (C) 2006  Lubomir Kundrak
+ *
+ *  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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <grub/machine/memory.h>
+#include <grub/misc.h>
+#include <grub/cpu/gdb.h>
+#include <grub/gdb.h>
+
+/* Converting CPU trap number to UNIX signal number as
+   described in System V ABI i386 Processor Supplement, 3-25.  */
+unsigned int
+grub_gdb_trap2sig (int trap_no)
+{
+  const int signals[] = {
+    SIGFPE,			/* 0:   Divide error fault              */
+    SIGTRAP,			/* 1:   Single step trap fault          */
+    SIGABRT,			/* 2:   # Nonmaskable interrupt         */
+    SIGTRAP,			/* 3:   Breakpoint trap                 */
+    SIGSEGV,			/* 4:   Overflow trap                   */
+    SIGSEGV,			/* 5:   Bounds check fault              */
+    SIGILL,			/* 6:   Invalid opcode fault            */
+    SIGFPE,			/* 7:   No coprocessor fault            */
+    SIGABRT,			/* 8:   # Double fault abort            */
+    SIGSEGV,			/* 9:   Coprocessor overrun abort       */
+    SIGSEGV,			/* 10:  Invalid TSS fault               */
+    SIGSEGV,			/* 11:  Segment not present fault       */
+    SIGSEGV,			/* 12:  Stack exception fault           */
+    SIGSEGV,			/* 13:  General protection fault abort  */
+    SIGSEGV,			/* 14:  Page fault                      */
+    SIGABRT,			/* 15:  (reserved)                      */
+    SIGFPE,			/* 16:  Coprocessor error fault         */
+    SIGUSR1			/* other                                */
+  };
+
+  return signals[trap_no < 17 ? trap_no : 17];
+}
+