rename packages/ to recipes/ per earlier agreement

See links below for more details:
http://thread.gmane.org/gmane.comp.handhelds.openembedded/21326
http://thread.gmane.org/gmane.comp.handhelds.openembedded/21816

Signed-off-by: Denys Dmytriyenko <denis@denix.org>
Acked-by: Mike Westerhof <mwester@dls.net>
Acked-by: Philip Balister <philip@balister.org>
Acked-by: Khem Raj <raj.khem@gmail.com>
Acked-by: Marcin Juszkiewicz <hrw@openembedded.org>
Acked-by: Koen Kooi <koen@openembedded.org>
Acked-by: Frans Meulenbroeks <fransmeulenbroeks@gmail.com>

1 files changed, 306 insertions, 0 deletions

diff --git a/recipes/gdb/gdb-6.6/early_debug_in_nptl.patch b/recipes/gdb/gdb-6.6/early_debug_in_nptl.patch
new file mode 100644
index 0000000000..c53f0d8ad5
--- /dev/null
+++ b/recipes/gdb/gdb-6.6/early_debug_in_nptl.patch
@@ -0,0 +1,306 @@
+http://sourceware.org/ml/gdb-patches/2007-06/msg00479.html
+
+Index: gdb/linux-thread-db.c
+===================================================================
+--- gdb/linux-thread-db.c.orig	2006-10-20 03:08:14.000000000 +0200
++++ gdb/linux-thread-db.c	2008-03-01 14:45:52.000000000 +0100
+@@ -213,6 +213,21 @@
+     }
+ }
+ 
++/* Return 1 if any threads have been registered.  There may be none if
++   the threading library is not fully initialized yet.  */
++
++static int
++have_threads_callback (struct thread_info *thread, void *dummy)
++{
++  return 1;
++}
++
++static int
++have_threads (void)
++{
++  return iterate_over_threads (have_threads_callback, NULL) != NULL;
++}
++
+ /* A callback function for td_ta_thr_iter, which we use to map all
+    threads to LWPs.
+ 
+@@ -700,23 +715,6 @@
+ }
+ 
+ static void
+-thread_db_attach (char *args, int from_tty)
+-{
+-  target_beneath->to_attach (args, from_tty);
+-
+-  /* Destroy thread info; it's no longer valid.  */
+-  init_thread_list ();
+-
+-  /* The child process is now the actual multi-threaded
+-     program.  Snatch its process ID...  */
+-  proc_handle.pid = GET_PID (inferior_ptid);
+-
+-  /* ...and perform the remaining initialization steps.  */
+-  enable_thread_event_reporting ();
+-  thread_db_find_new_threads ();
+-}
+-
+-static void
+ detach_thread (ptid_t ptid, int verbose)
+ {
+   struct thread_info *thread_info;
+@@ -742,14 +740,13 @@
+   disable_thread_event_reporting ();
+ 
+   /* There's no need to save & restore inferior_ptid here, since the
+-     inferior is supposed to be survive this function call.  */
++     inferior is not supposed to survive this function call.  */
+   inferior_ptid = lwp_from_thread (inferior_ptid);
+ 
+-  /* Forget about the child's process ID.  We shouldn't need it
+-     anymore.  */
+-  proc_handle.pid = 0;
+-
+   target_beneath->to_detach (args, from_tty);
++
++  /* Should this be done by detach_command?  */
++  target_mourn_inferior ();
+ }
+ 
+ static int
+@@ -870,12 +867,6 @@
+ 
+   ptid = target_beneath->to_wait (ptid, ourstatus);
+ 
+-  if (proc_handle.pid == 0)
+-    /* The current child process isn't the actual multi-threaded
+-       program yet, so don't try to do any special thread-specific
+-       post-processing and bail out early.  */
+-    return ptid;
+-
+   if (ourstatus->kind == TARGET_WAITKIND_EXITED
+     || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
+     return pid_to_ptid (-1);
+@@ -889,23 +880,32 @@
+       return pid_to_ptid (GET_PID (ptid));
+     }
+ 
++  /* If we do not know about the main thread yet, this would be a good time to
++     find it.  */
++  if (ourstatus->kind == TARGET_WAITKIND_STOPPED && !have_threads ())
++    thread_db_find_new_threads ();
++
+   if (ourstatus->kind == TARGET_WAITKIND_STOPPED
+       && ourstatus->value.sig == TARGET_SIGNAL_TRAP)
+     /* Check for a thread event.  */
+     check_event (ptid);
+ 
+-  if (!ptid_equal (trap_ptid, null_ptid))
+-    trap_ptid = thread_from_lwp (trap_ptid);
++  if (have_threads ())
++    {
++      /* Change ptids back into the higher level PID + TID format.  If
++	 the thread is dead and no longer on the thread list, we will
++	 get back a dead ptid.  This can occur if the thread death
++	 event gets postponed by other simultaneous events.  In such a
++	 case, we want to just ignore the event and continue on.  */
++
++      if (!ptid_equal (trap_ptid, null_ptid))
++	trap_ptid = thread_from_lwp (trap_ptid);
++
++      ptid = thread_from_lwp (ptid);
++      if (GET_PID (ptid) == -1)
++	ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
++    }
+ 
+-  /* Change the ptid back into the higher level PID + TID format.
+-     If the thread is dead and no longer on the thread list, we will 
+-     get back a dead ptid.  This can occur if the thread death event
+-     gets postponed by other simultaneous events.  In such a case, 
+-     we want to just ignore the event and continue on.  */
+-  ptid = thread_from_lwp (ptid);
+-  if (GET_PID (ptid) == -1)
+-    ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
+-  
+   return ptid;
+ }
+ 
+@@ -944,30 +944,6 @@
+ }
+ 
+ static void
+-thread_db_create_inferior (char *exec_file, char *allargs, char **env,
+-			   int from_tty)
+-{
+-  unpush_target (&thread_db_ops);
+-  using_thread_db = 0;
+-  target_beneath->to_create_inferior (exec_file, allargs, env, from_tty);
+-}
+-
+-static void
+-thread_db_post_startup_inferior (ptid_t ptid)
+-{
+-  if (proc_handle.pid == 0)
+-    {
+-      /* The child process is now the actual multi-threaded
+-         program.  Snatch its process ID...  */
+-      proc_handle.pid = GET_PID (ptid);
+-
+-      /* ...and perform the remaining initialization steps.  */
+-      enable_thread_event_reporting ();
+-      thread_db_find_new_threads ();
+-    }
+-}
+-
+-static void
+ thread_db_mourn_inferior (void)
+ {
+   /* Forget about the child's process ID.  We shouldn't need it
+@@ -1002,6 +978,22 @@
+ 
+   ptid = ptid_build (GET_PID (inferior_ptid), ti.ti_lid, ti.ti_tid);
+ 
++  if (ti.ti_tid == 0)
++    {
++      /* A thread ID of zero means that this is the main thread, but
++	 glibc has not yet initialized thread-local storage and the
++	 pthread library.  We do not know what the thread's TID will
++	 be yet.  Just enable event reporting and otherwise ignore
++	 it.  */
++
++      err = td_thr_event_enable_p (th_p, 1);
++      if (err != TD_OK)
++	error (_("Cannot enable thread event reporting for %s: %s"),
++	       target_pid_to_str (ptid), thread_db_err_str (err));
++
++      return 0;
++    }
++
+   if (!in_thread_list (ptid))
+     attach_thread (ptid, th_p, &ti, 1);
+ 
+@@ -1058,6 +1050,16 @@
+   return NULL;
+ }
+ 
++/* Return 1 if this thread has the same LWP as the passed PTID.  */
++
++static int
++same_ptid_callback (struct thread_info *thread, void *arg)
++{
++  ptid_t *ptid_p = arg;
++
++  return GET_LWP (thread->ptid) == GET_LWP (*ptid_p);
++}
++
+ /* Get the address of the thread local variable in load module LM which
+    is stored at OFFSET within the thread local storage for thread PTID.  */
+ 
+@@ -1066,6 +1068,21 @@
+ 				    CORE_ADDR lm,
+ 				    CORE_ADDR offset)
+ {
++  /* If we have not discovered any threads yet, check now.  */
++  if (!is_thread (ptid) && !have_threads ())
++    thread_db_find_new_threads ();
++
++  /* Try to find a matching thread if we still have the LWP ID instead
++     of the thread ID.  */
++  if (!is_thread (ptid))
++    {
++      struct thread_info *thread;
++
++      thread = iterate_over_threads (same_ptid_callback, &ptid);
++      if (thread != NULL)
++	ptid = thread->ptid;
++    }
++
+   if (is_thread (ptid))
+     {
+       td_err_e err;
+@@ -1125,14 +1142,11 @@
+   thread_db_ops.to_shortname = "multi-thread";
+   thread_db_ops.to_longname = "multi-threaded child process.";
+   thread_db_ops.to_doc = "Threads and pthreads support.";
+-  thread_db_ops.to_attach = thread_db_attach;
+   thread_db_ops.to_detach = thread_db_detach;
+   thread_db_ops.to_resume = thread_db_resume;
+   thread_db_ops.to_wait = thread_db_wait;
+   thread_db_ops.to_xfer_partial = thread_db_xfer_partial;
+   thread_db_ops.to_kill = thread_db_kill;
+-  thread_db_ops.to_create_inferior = thread_db_create_inferior;
+-  thread_db_ops.to_post_startup_inferior = thread_db_post_startup_inferior;
+   thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior;
+   thread_db_ops.to_find_new_threads = thread_db_find_new_threads;
+   thread_db_ops.to_pid_to_str = thread_db_pid_to_str;
+Index: gdb/gdbserver/thread-db.c
+===================================================================
+--- gdb/gdbserver/thread-db.c.orig	2006-10-17 18:02:27.000000000 +0200
++++ gdb/gdbserver/thread-db.c	2008-03-01 14:44:41.000000000 +0100
+@@ -40,6 +40,7 @@
+ /* Connection to the libthread_db library.  */
+ static td_thragent_t *thread_agent;
+ 
++static void thread_db_find_new_threads (void);
+ static int find_new_threads_callback (const td_thrhandle_t *th_p, void *data);
+ 
+ static char *
+@@ -134,6 +135,8 @@
+   td_event_msg_t msg;
+   td_err_e err;
+   struct inferior_linux_data *tdata;
++  struct thread_info *inferior;
++  struct process_info *process;
+ 
+   if (debug_threads)
+     fprintf (stderr, "Thread creation event.\n");
+@@ -149,6 +152,14 @@
+     fprintf (stderr, "thread getmsg err: %s\n",
+ 	     thread_db_err_str (err));
+ 
++  /* If we do not know about the main thread yet, this would be a good time to
++     find it.  We need to do this to pick up the main thread before any newly
++     created threads.  */
++  inferior = (struct thread_info *) all_threads.head;
++  process = get_thread_process (inferior);
++  if (process->thread_known == 0)
++    thread_db_find_new_threads ();
++
+   /* msg.event == TD_EVENT_CREATE */
+ 
+   find_new_threads_callback (msg.th_p, NULL);
+@@ -231,8 +242,24 @@
+     {
+       inferior = (struct thread_info *) all_threads.head;
+       process = get_thread_process (inferior);
++
+       if (process->thread_known == 0)
+ 	{
++	  /* If the new thread ID is zero, a final thread ID will be
++	     available later.  Do not enable thread debugging yet.  */
++	  if (ti_p->ti_tid == 0)
++	    {
++	      err = td_thr_event_enable (th_p, 1);
++	      if (err != TD_OK)
++		error ("Cannot enable thread event reporting for %d: %s",
++		       ti_p->ti_lid, thread_db_err_str (err));
++	      return;
++	    }
++
++	  if (process->lwpid != ti_p->ti_lid)
++	    fatal ("PID mismatch!  Expected %ld, got %ld",
++		   (long) process->lwpid, (long) ti_p->ti_lid);
++
+ 	  /* Switch to indexing the threads list by TID.  */
+ 	  change_inferior_id (&all_threads, ti_p->ti_tid);
+ 	  goto found;
+@@ -331,6 +358,8 @@
+ 
+   process = get_thread_process (thread);
+   if (!process->thread_known)
++    thread_db_find_new_threads ();
++  if (!process->thread_known)
+     return TD_NOTHR;
+ 
+   err = td_thr_tls_get_addr (&process->th, (psaddr_t) load_module, offset,