/ - Diff - qemu - Greek Research and Technology Network's projects

+    }
     /* Print one coprocessor instruction on INFO->STREAM.
        Return true if the instuction matched, false if this is not a
        Return true if the instruction matched, false if this is not a
        recognised coprocessor instruction.  */
     static bfd_boolean
-...
+    }
     /* Print one neon instruction on INFO->STREAM.
        Return true if the instuction matched, false if this is not a
        Return true if the instruction matched, false if this is not a
        recognised neon instruction.  */
     static bfd_boolean
-...
     	    n = last_mapping_sym - 1;
     	  /* No mapping symbol found at this address.  Look backwards
     	     for a preceeding one.  */
     	     for a preceding one.  */
     	  for (; n >= 0; n--)
+    	    {
     	      if (get_sym_code_type (info, n, &type))

     #define CPU_INTERRUPT_TGT_EXT_4   0x1000
     /* Several target-specific internal interrupts.  These differ from the
        preceeding target-specific interrupts in that they are intended to
        preceding target-specific interrupts in that they are intended to
        originate from within the cpu itself, typically in response to some
        instruction being executed.  These, therefore, are not masked while
        single-stepping within the debugger.  */

     #ifndef CPU_COMMON_H
     #define CPU_COMMON_H 1
     /* CPU interfaces that are target indpendent.  */
     /* CPU interfaces that are target independent.  */
     #ifdef TARGET_PHYS_ADDR_BITS
     #include "targphys.h"

              * (related to the time left until the next event) has passed.  This
              * rt_clock timer will do this.  This avoids that the warps are too
              * visible externally---for example, you will not be sending network
              * packets continously instead of every 100ms.
              * packets continuously instead of every 100ms.
              */
             qemu_mod_timer(icount_warp_timer, vm_clock_warp_start + deadline);
         } else {

b/exec-memory.h
1	1	/*
2		* Internal memory managment interfaces
	2	* Internal memory management interfaces
3	3	*
4	4	* Copyright 2011 Red Hat, Inc. and/or its affiliates
5	5	*

      */
     /* There are two kinds of delay slot nullification: normal which is
      * controled by the nullification bit, and conditional, which depends
      * controlled by the nullification bit, and conditional, which depends
      * on the direction of the branch and its success or failure.
+     *
      * NONE is unfortunately #defined in the hiux system include files.

     /* NOTE: The mcf5200 family programmer's reference manual does not
        indicate the byte form of the movea instruction is invalid (as it
        is on 68000 family cpus).  However, experiments on the 5202 yeild
        is on 68000 family cpus).  However, experiments on the 5202 yield
        unexpected results.  The value is copied, but it is not sign extended
        (as is done with movea.w) and the top three bytes in the address
        register are not disturbed.  I don't know if this is the intended

b/main-loop.h
111	111	* qemu_add_wait_object.
112	112	*
113	113	* Polling callbacks really have nothing Windows specific in them, but
114		* as they are a hack and are currenly not necessary under POSIX systems,
	114	* as they are a hack and are currently not necessary under POSIX systems,
115	115	* they are only available when QEMU is running under Windows.
116	116	*
117	117	* @func: The function that does the polling, and returns 1 to force

             return -1;
+        }
         TRACE("Negotation succeeded.");
         TRACE("Negotiation succeeded.");
         return 0;
+    }
-...
         uint64_t magic, s;
         uint16_t tmp;
         TRACE("Receiving negotation.");
         TRACE("Receiving negotiation.");
         if (read_sync(csock, buf, 8) != 8) {
             LOG("read failed");

b/qemu-io.c
445	445	}
446	446
447	447	if ((pattern_count < 0) \|\| (pattern_count + pattern_offset > count)) {
448		printf("pattern verfication range exceeds end of read data\n");
	448	printf("pattern verification range exceeds end of read data\n");
449	449	return 0;
450	450	}
451	451

                     printf("%s=%" PRId64 " ", list->name, list->value.n);
                     break;
                 default:
                     printf("%s=(unkown type) ", list->name);
                     printf("%s=(unknown type) ", list->name);
                     break;
+            }
             list++;

b/qerror.c
223	223	},
224	224	{
225	225	.error_fmt = QERR_UNDEFINED_ERROR,
226		.desc = "An undefined error has ocurred",
	226	.desc = "An undefined error has occurred",
227	227	},
228	228	{
229	229	.error_fmt = QERR_UNSUPPORTED,

+    }
     /*
      * this funtion has three return values:
      * this function has three return values:
      *   negative: there was one error, and we have -errno.
      *   0 : We haven't finished, caller have to go again
      *   1 : We have finished, we can go to complete phase

         QString *str;
         ud1.integer = 42;
         ud1.string = strdup("fourty two");
         ud1.string = strdup("forty two");
         /* sanity check */
         mo = qmp_output_visitor_new();
-...
         g_assert(obj);
         qobject_decref(obj);
         ud2.string = strdup("fourty three");
         ud2.dict.string = strdup("fourty four");
         ud2.string = strdup("forty three");
         ud2.dict.string = strdup("forty four");
         ud2.dict.dict.userdef = ud1_p;
         ud2.dict.dict.string = strdup("fourty five");
         ud2.dict.dict.string = strdup("forty five");
         ud2.dict.has_dict2 = true;
         ud2.dict.dict2.userdef = ud1_p;
         ud2.dict.dict2.string = strdup("fourty six");
         ud2.dict.dict2.string = strdup("forty six");
         /* c type -> qobject */
         mo = qmp_output_visitor_new();

             /* Allowed boot devices are:
              * a-b: floppy disk drives
              * c-f: IDE disk drives
              * g-m: machine implementation dependant drives
              * g-m: machine implementation dependent drives
              * n-p: network devices
              * It's up to each machine implementation to check if the given boot
              * devices match the actual hardware implementation and firmware

Archipelago » qemu