--- Gnu-Mach/ddb/db_break.c	2020/09/02 04:43:17	1.1.1.2
+++ Gnu-Mach/ddb/db_break.c	2020/09/02 04:48:19	1.1.1.4
@@ -27,7 +27,7 @@
  *	Author: David B. Golub, Carnegie Mellon University
  *	Date:	7/90
  */
-#include "mach_kdb.h"
+
 #if MACH_KDB
 
 
@@ -36,6 +36,7 @@
  */
 #include <mach/boolean.h>
 #include <machine/db_machdep.h>
+#include <machine/db_interface.h>
 #include <ddb/db_lex.h>
 #include <ddb/db_break.h>
 #include <ddb/db_access.h>
@@ -43,6 +44,9 @@
 #include <ddb/db_variables.h>
 #include <ddb/db_command.h>
 #include <ddb/db_task_thread.h>
+#include <ddb/db_output.h>
+#include <ddb/db_cond.h>
+#include <ddb/db_expr.h>
 
 #define	NBREAKPOINTS	100
 #define NTHREAD_LIST	(NBREAKPOINTS*3)
@@ -60,7 +64,7 @@ static int				db_breakpoint_number = 0;
 db_breakpoint_t
 db_breakpoint_alloc()
 {
-	register db_breakpoint_t	bkpt;
+	db_breakpoint_t	bkpt;
 
 	if ((bkpt = db_free_breakpoints) != 0) {
 	    db_free_breakpoints = bkpt->link;
@@ -78,7 +82,7 @@ db_breakpoint_alloc()
 
 void
 db_breakpoint_free(bkpt)
-	register db_breakpoint_t	bkpt;
+	db_breakpoint_t	bkpt;
 {
 	bkpt->link = db_free_breakpoints;
 	db_free_breakpoints = bkpt;
@@ -86,11 +90,12 @@ db_breakpoint_free(bkpt)
 
 static int
 db_add_thread_breakpoint(bkpt, task_thd, count, task_bpt)
-	register db_breakpoint_t bkpt;
+	const db_breakpoint_t bkpt;
 	vm_offset_t task_thd;
+	int count;
 	boolean_t task_bpt;
 {
-	register db_thread_breakpoint_t tp;
+	db_thread_breakpoint_t tp;
 
 	if (db_thread_break_init == FALSE) {
 	    for (tp = db_thread_break_list;
@@ -116,13 +121,12 @@ db_add_thread_breakpoint(bkpt, task_thd,
 }
 
 static int
-db_delete_thread_breakpoint(bkpt, task_thd)
-	register db_breakpoint_t bkpt;
-	vm_offset_t task_thd;
+db_delete_thread_breakpoint(
+	db_breakpoint_t bkpt,
+	vm_offset_t 	task_thd)
 {
-	register db_thread_breakpoint_t tp;
-	register db_thread_breakpoint_t *tpp;
-	void	 db_cond_free();
+	db_thread_breakpoint_t tp;
+	db_thread_breakpoint_t *tpp;
 
 	if (task_thd == 0) {
 	    /* delete all the thread-breakpoints */
@@ -150,13 +154,13 @@ db_delete_thread_breakpoint(bkpt, task_t
 	}
 }
 
-static db_thread_breakpoint_t
+static db_thread_breakpoint_t __attribute__ ((pure))
 db_find_thread_breakpoint(bkpt, thread)
-	db_breakpoint_t bkpt;
-	thread_t thread;
+	const db_breakpoint_t bkpt;
+	const thread_t thread;
 {
-	register db_thread_breakpoint_t tp;
-	register task_t task = (thread == THREAD_NULL)? TASK_NULL: thread->task;
+	db_thread_breakpoint_t tp;
+	task_t task = (thread == THREAD_NULL)? TASK_NULL: thread->task;
 
 	for (tp = bkpt->threads; tp; tp = tp->tb_next) {
 	    if (tp->tb_is_task) {
@@ -172,24 +176,24 @@ db_find_thread_breakpoint(bkpt, thread)
 
 db_thread_breakpoint_t
 db_find_thread_breakpoint_here(task, addr)
-	task_t		task;
+	const task_t	task;
 	db_addr_t	addr;
 {
 	db_breakpoint_t bkpt;
 
-	bkpt = db_find_breakpoint(task, (db_addr_t)addr);
+	bkpt = db_find_breakpoint(task, addr);
 	if (bkpt == 0)
 	    return(0);
 	return(db_find_thread_breakpoint(bkpt, current_thread()));
 }
 
 db_thread_breakpoint_t
-db_find_breakpoint_number(num, bkptp)
-	int num;
-	db_breakpoint_t *bkptp;
+db_find_breakpoint_number(
+	int 		num,
+	db_breakpoint_t *bkptp)
 {
-	register db_thread_breakpoint_t tp;
-	register db_breakpoint_t bkpt;
+	db_thread_breakpoint_t tp;
+	db_breakpoint_t bkpt;
 
 	for (bkpt = db_breakpoint_list; bkpt != 0; bkpt = bkpt->link) {
 	    for (tp = bkpt->threads; tp; tp = tp->tb_next) {
@@ -204,10 +208,10 @@ db_find_breakpoint_number(num, bkptp)
 }
 
 static void
-db_force_delete_breakpoint(bkpt, task_thd, is_task)
-	db_breakpoint_t	bkpt;
-	vm_offset_t  task_thd;
-	boolean_t is_task;
+db_force_delete_breakpoint(
+	db_breakpoint_t	bkpt,
+	vm_offset_t  	task_thd,
+	boolean_t 	is_task)
 {
 	db_printf("deleted a stale breakpoint at ");
 	if (bkpt->task == TASK_NULL || db_lookup_task(bkpt->task) >= 0)
@@ -223,10 +227,10 @@ db_force_delete_breakpoint(bkpt, task_th
 }
 
 void
-db_check_breakpoint_valid()
+db_check_breakpoint_valid(void)
 {
-	register db_thread_breakpoint_t tbp, tbp_next;
-	register db_breakpoint_t bkpt, *bkptp;
+	db_thread_breakpoint_t tbp, tbp_next;
+	db_breakpoint_t bkpt, *bkptp;
 
 	bkptp = &db_breakpoint_list;
 	for (bkpt = *bkptp; bkpt; bkpt = *bkptp) {
@@ -262,15 +266,15 @@ db_check_breakpoint_valid()
 	}
 }
 
-void
+db_breakpoint_t
 db_set_breakpoint(task, addr, count, thread, task_bpt)
-	task_t		task;
+	const task_t	task;
 	db_addr_t	addr;
 	int		count;
-	thread_t	thread;
+	const thread_t	thread;
 	boolean_t	task_bpt;
 {
-	register db_breakpoint_t bkpt;
+	db_breakpoint_t bkpt;
 	db_breakpoint_t alloc_bkpt = 0;
 	vm_offset_t task_thd;
 
@@ -279,17 +283,17 @@ db_set_breakpoint(task, addr, count, thr
 	    if (thread == THREAD_NULL
 		|| db_find_thread_breakpoint(bkpt, thread)) {
 		db_printf("Already set.\n");
-		return;
+		return NULL;
 	    }
 	} else {
 	    if (!DB_CHECK_ACCESS(addr, BKPT_SIZE, task)) {
 		db_printf("Cannot set break point at %X\n", addr);
-		return;
+		return NULL;
 	    }
 	    alloc_bkpt = bkpt = db_breakpoint_alloc();
 	    if (bkpt == 0) {
 		db_printf("Too many breakpoints.\n");
-		return;
+		return NULL;
 	    }
 	    bkpt->task = task;
 	    bkpt->flags = (task && thread == THREAD_NULL)?
@@ -304,23 +308,25 @@ db_set_breakpoint(task, addr, count, thr
 	    if (alloc_bkpt)
 		db_breakpoint_free(alloc_bkpt);
 	    db_printf("Too many thread_breakpoints.\n");
+	    return NULL;
 	} else {
 	    db_printf("set breakpoint #%d\n", db_breakpoint_number);
 	    if (alloc_bkpt) {
 		bkpt->link = db_breakpoint_list;
 		db_breakpoint_list = bkpt;
 	    }
+	    return bkpt;
 	}
 }
 
 void
 db_delete_breakpoint(task, addr, task_thd)
-	task_t	task;
+	const task_t	task;
 	db_addr_t	addr;
 	vm_offset_t	task_thd;
 {
-	register db_breakpoint_t	bkpt;
-	register db_breakpoint_t	*prev;
+	db_breakpoint_t	bkpt;
+	db_breakpoint_t	*prev;
 
 	for (prev = &db_breakpoint_list; (bkpt = *prev) != 0;
 					     prev = &bkpt->link) {
@@ -344,12 +350,12 @@ db_delete_breakpoint(task, addr, task_th
 	}
 }
 
-db_breakpoint_t
+db_breakpoint_t __attribute__ ((pure))
 db_find_breakpoint(task, addr)
-	task_t	task;
+	const task_t	task;
 	db_addr_t	addr;
 {
-	register db_breakpoint_t	bkpt;
+	db_breakpoint_t	bkpt;
 
 	for (bkpt = db_breakpoint_list; bkpt != 0; bkpt = bkpt->link) {
 	    if ((bkpt->task == task
@@ -362,10 +368,10 @@ db_find_breakpoint(task, addr)
 
 boolean_t
 db_find_breakpoint_here(task, addr)
-	task_t		task;
+	const task_t	task;
 	db_addr_t	addr;
 {
-	register db_breakpoint_t	bkpt;
+	db_breakpoint_t	bkpt;
 
 	for (bkpt = db_breakpoint_list; bkpt != 0; bkpt = bkpt->link) {
 	    if ((bkpt->task == task
@@ -373,7 +379,7 @@ db_find_breakpoint_here(task, addr)
                 && bkpt->address == addr)
 		return(TRUE);
 	    if ((bkpt->flags & BKPT_USR_GLOBAL) == 0 &&
-		  DB_PHYS_EQ(task, (vm_offset_t)addr, bkpt->task, (vm_offset_t)bkpt->address))
+		  DB_PHYS_EQ(task, addr, bkpt->task, bkpt->address))
 		return (TRUE);
 	}
 	return(FALSE);
@@ -382,10 +388,10 @@ db_find_breakpoint_here(task, addr)
 boolean_t	db_breakpoints_inserted = TRUE;
 
 void
-db_set_breakpoints()
+db_set_breakpoints(void)
 {
-	register db_breakpoint_t bkpt;
-	register task_t	task;
+	db_breakpoint_t bkpt;
+	task_t		task;
 	db_expr_t	inst;
 	task_t		cur_task;
 
@@ -427,10 +433,10 @@ db_set_breakpoints()
 }
 
 void
-db_clear_breakpoints()
+db_clear_breakpoints(void)
 {
-	register db_breakpoint_t bkpt, *bkptp;
-	register task_t	task;
+	db_breakpoint_t bkpt, *bkptp;
+	task_t		task;
 	task_t		cur_task;
 	db_expr_t	inst;
 
@@ -476,11 +482,11 @@ db_clear_breakpoints()
  * so the breakpoint does not have to be on the breakpoint list.
  */
 db_breakpoint_t
-db_set_temp_breakpoint(task, addr)
-	task_t		task;
-	db_addr_t	addr;
+db_set_temp_breakpoint(
+	task_t		task,
+	db_addr_t	addr)
 {
-	register db_breakpoint_t	bkpt;
+	db_breakpoint_t	bkpt;
 
 	bkpt = db_breakpoint_alloc();
 	if (bkpt == 0) {
@@ -505,9 +511,9 @@ db_set_temp_breakpoint(task, addr)
 }
 
 void
-db_delete_temp_breakpoint(task, bkpt)
-	task_t		task;
-	db_breakpoint_t	bkpt;
+db_delete_temp_breakpoint(
+	task_t		task,
+	db_breakpoint_t	bkpt)
 {
 	db_put_task_value(bkpt->address, BKPT_SIZE, bkpt->bkpt_inst, task);
 	db_delete_thread_breakpoint(bkpt, 0);
@@ -518,9 +524,9 @@ db_delete_temp_breakpoint(task, bkpt)
  * List breakpoints.
  */
 void
-db_list_breakpoints()
+db_list_breakpoints(void)
 {
-	register db_breakpoint_t	bkpt;
+	db_breakpoint_t	bkpt;
 
 	if (db_breakpoint_list == 0) {
 	    db_printf("No breakpoints set\n");
@@ -532,9 +538,9 @@ db_list_breakpoints()
 	     bkpt != 0;
 	     bkpt = bkpt->link)
 	{
-	    register 	db_thread_breakpoint_t tp;
-	    int		task_id;
-	    int		thread_id;
+	    db_thread_breakpoint_t 	tp;
+	    int				task_id;
+	    int				thread_id;
 
 	    if (bkpt->threads) {
 		for (tp = bkpt->threads; tp; tp = tp->tb_next) {
@@ -592,9 +598,9 @@ db_list_breakpoints()
 /* Delete breakpoint */
 /*ARGSUSED*/
 void
-db_delete_cmd()
+db_delete_cmd(void)
 {
-	register n;
+	int n;
 	thread_t thread;
 	vm_offset_t task_thd;
 	boolean_t user_global = FALSE;
@@ -675,9 +681,9 @@ db_breakpoint_cmd(addr, have_addr, count
 	db_expr_t	addr;
 	int		have_addr;
 	db_expr_t	count;
-	char *		modif;
+	const char *	modif;
 {
-	register n;
+	int n;
 	thread_t thread;
 	boolean_t user_global = db_option(modif, 'U');
 	boolean_t task_bpt = db_option(modif, 'T');
@@ -725,7 +731,7 @@ db_breakpoint_cmd(addr, have_addr, count
 
 /* list breakpoints */
 void
-db_listbreak_cmd()
+db_listbreak_cmd(void)
 {
 	db_list_breakpoints();
 }