Changeset 7f1c620 in mainline for arch/mips32/src/debugger.c

Timestamp:

2006-07-04T17:17:56Z (19 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

0ffa3ef5

Parents:

991779c5

Message:

Replace old u?? types with respective C99 variants (e.g. uint32_t, int64_t, uintptr_t etc.).

File:

• arch/mips32/src/debugger.c (modified) (10 diffs)

arch/mips32/src/debugger.c

@@ -92 +92 @@
 
 static struct {
-        __u32 andmask;
-        __u32 value;
+        uint32_t andmask;
+        uint32_t value;
 }jmpinstr[] = {
         {0xf3ff0000, 0x41000000}, /* BCzF */
@@ -126 +126 @@
  * @return true - it is jump instruction, false otherwise
  */
-static bool is_jump(__native instr)
+static bool is_jump(unative_t instr)
 {
         int i;
@@ -154 +154 @@
         /* Check, that the breakpoints do not conflict */
         for (i=0; i<BKPOINTS_MAX; i++) {
-                if (breakpoints[i].address == (__address)argv->intval) {
+                if (breakpoints[i].address == (uintptr_t)argv->intval) {
                         printf("Duplicate breakpoint %d.\n", i);
                         spinlock_unlock(&bkpoints_lock);
                         return 0;
-                } else if (breakpoints[i].address == (__address)argv->intval + sizeof(__native) || \
-                           breakpoints[i].address == (__address)argv->intval - sizeof(__native)) {
+                } else if (breakpoints[i].address == (uintptr_t)argv->intval + sizeof(unative_t) || \
+                           breakpoints[i].address == (uintptr_t)argv->intval - sizeof(unative_t)) {
                         printf("Adjacent breakpoints not supported, conflict with %d.\n", i);
                         spinlock_unlock(&bkpoints_lock);
@@ -178 +178 @@
                 return 0;
         }
-        cur->address = (__address) argv->intval;
+        cur->address = (uintptr_t) argv->intval;
         printf("Adding breakpoint on address: %p\n", argv->intval);
-        cur->instruction = ((__native *)cur->address)[0];
-        cur->nextinstruction = ((__native *)cur->address)[1];
+        cur->instruction = ((unative_t *)cur->address)[0];
+        cur->nextinstruction = ((unative_t *)cur->address)[1];
         if (argv == &add_argv) {
                 cur->flags = 0;
@@ -193 +193 @@
 
         /* Set breakpoint */
-        *((__native *)cur->address) = 0x0d;
+        *((unative_t *)cur->address) = 0x0d;
 
         spinlock_unlock(&bkpoint_lock);
@@ -229 +229 @@
                 return 0;
         }
-        ((__u32 *)cur->address)[0] = cur->instruction;
-        ((__u32 *)cur->address)[1] = cur->nextinstruction;
+        ((uint32_t *)cur->address)[0] = cur->instruction;
+        ((uint32_t *)cur->address)[1] = cur->nextinstruction;
 
         cur->address = NULL;
@@ -299 +299 @@
 {
         bpinfo_t *cur = NULL;
-        __address fireaddr = istate->epc;
+        uintptr_t fireaddr = istate->epc;
         int i;
 
@@ -316 +316 @@
                 /* Reinst only breakpoint */
                 if ((breakpoints[i].flags & BKPOINT_REINST) \
-                    && (fireaddr ==breakpoints[i].address+sizeof(__native))) {
+                    && (fireaddr ==breakpoints[i].address+sizeof(unative_t))) {
                         cur = &breakpoints[i];
                         break;
@@ -324 +324 @@
                 if (cur->flags & BKPOINT_REINST) {
                         /* Set breakpoint on first instruction */
-                        ((__u32 *)cur->address)[0] = 0x0d;
+                        ((uint32_t *)cur->address)[0] = 0x0d;
                         /* Return back the second */
-                        ((__u32 *)cur->address)[1] = cur->nextinstruction;
+                        ((uint32_t *)cur->address)[1] = cur->nextinstruction;
                         cur->flags &= ~BKPOINT_REINST;
                         spinlock_unlock(&bkpoint_lock);
@@ -339 +339 @@
 
                 /* Return first instruction back */
-                ((__u32 *)cur->address)[0] = cur->instruction;
+                ((uint32_t *)cur->address)[0] = cur->instruction;
 
                 if (! (cur->flags & BKPOINT_ONESHOT)) {
                         /* Set Breakpoint on next instruction */
-                        ((__u32 *)cur->address)[1] = 0x0d;
+                        ((uint32_t *)cur->address)[1] = 0x0d;
                         cur->flags |= BKPOINT_REINST;
                 }