[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[dotgnu-pnet-commits] libjit ChangeLog jit/jit-alloc.c jit/jit-apply....
|
From: |
Aleksey Demakov |
|
Subject: |
[dotgnu-pnet-commits] libjit ChangeLog jit/jit-alloc.c jit/jit-apply.... |
|
Date: |
Tue, 22 Jan 2008 06:09:10 +0000 |
CVSROOT: /sources/dotgnu-pnet
Module name: libjit
Changes by: Aleksey Demakov <avd> 08/01/22 06:09:09
Modified files:
. : ChangeLog
jit : jit-alloc.c jit-apply.c jit-block.c
jit-context.c jit-debugger.c jit-dump.c
jit-elf-read.c jit-elf-write.c jit-except.c
jit-function.c jit-insn.c jit-intrinsic.c
jit-memory.c jit-meta.c jit-objmodel.c
jit-rules-interp.c jit-string.c jit-type.c
jit-value.c jit-walk.c
jitplus : jit-plus-context.cpp jit-plus-function.cpp
jit-plus-value.cpp
jitdynamic : jit-cpp-mangle.c jit-dynlib.c
Log message:
fix texinfo markup for parameters
CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/libjit/ChangeLog?cvsroot=dotgnu-pnet&r1=1.338&r2=1.339
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-alloc.c?cvsroot=dotgnu-pnet&r1=1.5&r2=1.6
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-apply.c?cvsroot=dotgnu-pnet&r1=1.1.1.1&r2=1.2
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-block.c?cvsroot=dotgnu-pnet&r1=1.7&r2=1.8
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-context.c?cvsroot=dotgnu-pnet&r1=1.8&r2=1.9
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-debugger.c?cvsroot=dotgnu-pnet&r1=1.3&r2=1.4
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-dump.c?cvsroot=dotgnu-pnet&r1=1.15&r2=1.16
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-elf-read.c?cvsroot=dotgnu-pnet&r1=1.3&r2=1.4
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-elf-write.c?cvsroot=dotgnu-pnet&r1=1.1.1.1&r2=1.2
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-except.c?cvsroot=dotgnu-pnet&r1=1.7&r2=1.8
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-function.c?cvsroot=dotgnu-pnet&r1=1.33&r2=1.34
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-insn.c?cvsroot=dotgnu-pnet&r1=1.56&r2=1.57
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-intrinsic.c?cvsroot=dotgnu-pnet&r1=1.4&r2=1.5
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-memory.c?cvsroot=dotgnu-pnet&r1=1.1.1.1&r2=1.2
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-meta.c?cvsroot=dotgnu-pnet&r1=1.1.1.1&r2=1.2
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-objmodel.c?cvsroot=dotgnu-pnet&r1=1.1&r2=1.2
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-rules-interp.c?cvsroot=dotgnu-pnet&r1=1.32&r2=1.33
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-string.c?cvsroot=dotgnu-pnet&r1=1.2&r2=1.3
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-type.c?cvsroot=dotgnu-pnet&r1=1.7&r2=1.8
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-value.c?cvsroot=dotgnu-pnet&r1=1.11&r2=1.12
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-walk.c?cvsroot=dotgnu-pnet&r1=1.2&r2=1.3
http://cvs.savannah.gnu.org/viewcvs/libjit/jitplus/jit-plus-context.cpp?cvsroot=dotgnu-pnet&r1=1.2&r2=1.3
http://cvs.savannah.gnu.org/viewcvs/libjit/jitplus/jit-plus-function.cpp?cvsroot=dotgnu-pnet&r1=1.14&r2=1.15
http://cvs.savannah.gnu.org/viewcvs/libjit/jitplus/jit-plus-value.cpp?cvsroot=dotgnu-pnet&r1=1.2&r2=1.3
http://cvs.savannah.gnu.org/viewcvs/libjit/jitdynamic/jit-cpp-mangle.c?cvsroot=dotgnu-pnet&r1=1.3&r2=1.4
http://cvs.savannah.gnu.org/viewcvs/libjit/jitdynamic/jit-dynlib.c?cvsroot=dotgnu-pnet&r1=1.1&r2=1.2
Patches:
Index: ChangeLog
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/ChangeLog,v
retrieving revision 1.338
retrieving revision 1.339
diff -u -b -r1.338 -r1.339
--- ChangeLog 21 Jan 2008 18:02:53 -0000 1.338
+++ ChangeLog 22 Jan 2008 06:09:07 -0000 1.339
@@ -1,3 +1,8 @@
+2008-01-22 Aleksey Demakov <address@hidden>
+
+ * jit/*.c, jitplus/*.cpp, jitdynamic/*.c: fix texinfo markup for
+ parameters.
+
2008-01-21 Dalibor Topic <address@hidden>
* jit/Makefile.am (libjit_la_SOURCES): add mising jit-rules-interp.h
Index: jit/jit-alloc.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-alloc.c,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -b -r1.5 -r1.6
--- jit/jit-alloc.c 22 Aug 2006 18:02:55 -0000 1.5
+++ jit/jit-alloc.c 22 Jan 2008 06:09:08 -0000 1.6
@@ -67,13 +67,13 @@
@*/
/*@
- * @deftypefun {void *} jit_malloc ({unsigned int} size)
- * Allocate @code{size} bytes of memory from the heap.
+ * @deftypefun {void *} jit_malloc (unsigned int @var{size})
+ * Allocate @var{size} bytes of memory from the heap.
* @end deftypefun
*
- * @deftypefun {type *} jit_new (type)
- * Allocate @code{sizeof(type)} bytes of memory from the heap and
- * cast the return pointer to @code{type *}. This is a macro that
+ * @deftypefun {type *} jit_new (@var{type})
+ * Allocate @code{sizeof(@var{type})} bytes of memory from the heap and
+ * cast the return pointer to @address@hidden *}. This is a macro that
* wraps up the underlying @code{jit_malloc} function and is less
* error-prone when allocating structures.
* @end deftypefun
@@ -84,14 +84,14 @@
}
/*@
- * @deftypefun {void *} jit_calloc ({unsigned int} num, {unsigned int} size)
- * Allocate @code{num * size} bytes of memory from the heap and clear
+ * @deftypefun {void *} jit_calloc (unsigned int @var{num}, unsigned int
@var{size})
+ * Allocate @address@hidden * @var{size}} bytes of memory from the heap and
clear
* them to zero.
* @end deftypefun
*
- * @deftypefun {type *} jit_cnew (type)
- * Allocate @code{sizeof(type)} bytes of memory from the heap and
- * cast the return pointer to @code{type *}. The memory is cleared
+ * @deftypefun {type *} jit_cnew (@var{type})
+ * Allocate @code{sizeof(@var{type})} bytes of memory from the heap and
+ * cast the return pointer to @address@hidden *}. The memory is cleared
* to zero.
* @end deftypefun
@*/
@@ -101,9 +101,9 @@
}
/*@
- * @deftypefun {void *} jit_realloc ({void *} ptr, {unsigned int} size)
- * Re-allocate the memory at @code{ptr} to be @code{size} bytes in size.
- * The memory block at @code{ptr} must have been allocated by a previous
+ * @deftypefun {void *} jit_realloc (void address@hidden, unsigned int
@var{size})
+ * Re-allocate the memory at @var{ptr} to be @var{size} bytes in size.
+ * The memory block at @var{ptr} must have been allocated by a previous
* call to @code{jit_malloc}, @code{jit_calloc}, or @code{jit_realloc}.
* @end deftypefun
@*/
@@ -113,8 +113,8 @@
}
/*@
- * @deftypefun void jit_free ({void *} ptr)
- * Free the memory at @code{ptr}. It is safe to pass a NULL pointer.
+ * @deftypefun void jit_free (void address@hidden)
+ * Free the memory at @var{ptr}. It is safe to pass a NULL pointer.
* @end deftypefun
@*/
void jit_free(void *ptr)
@@ -126,7 +126,7 @@
}
/*@
- * @deftypefun {void *} jit_malloc_exec ({unsigned int} size)
+ * @deftypefun {void *} jit_malloc_exec (unsigned int @var{size})
* Allocate a block of memory that is read/write/executable. Such blocks
* are used to store JIT'ed code, function closures, and other trampolines.
* The size should be a multiple of @code{jit_exec_page_size()}.
@@ -156,9 +156,9 @@
}
/*@
- * @deftypefun void jit_free_exec ({void *} ptr, {unsigned int} size)
+ * @deftypefun void jit_free_exec (void address@hidden, unsigned int
@var{size})
* Free a block of memory that was previously allocated by
- * @code{jit_malloc_exec}. The @code{size} must be identical to the
+ * @code{jit_malloc_exec}. The @var{size} must be identical to the
* original allocated size, as some systems need to know this information
* to be able to free the block.
* @end deftypefun
@@ -176,8 +176,8 @@
}
/*@
- * @deftypefun void jit_flush_exec ({void *} ptr, {unsigned int} size)
- * Flush the contents of the block at @code{ptr} from the CPU's
+ * @deftypefun void jit_flush_exec (void address@hidden, unsigned int
@var{size})
+ * Flush the contents of the block at @var{ptr} from the CPU's
* data and instruction caches. This must be used after the code is
* written to an executable code segment, but before the code is
* executed, to prepare it for execution.
Index: jit/jit-apply.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-apply.c,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -b -r1.1.1.1 -r1.2
--- jit/jit-apply.c 30 Apr 2004 23:29:56 -0000 1.1.1.1
+++ jit/jit-apply.c 22 Jan 2008 06:09:08 -0000 1.2
@@ -379,12 +379,12 @@
}
/*@
- * @deftypefun void jit_apply (jit_type_t signature, {void *} func, {void **}
args, {unsigned int} num_fixed_args, {void *} return_value)
+ * @deftypefun void jit_apply (jit_type_t signature, void address@hidden, void
address@hidden, unsigned int @var{num_fixed_args}, void address@hidden)
* Call a function that has a particular function signature.
- * If the signature has more than @code{num_fixed_args} arguments,
+ * If the signature has more than @var{num_fixed_args} arguments,
* then it is assumed to be a vararg call, with the additional
* arguments passed in the vararg argument area on the stack.
- * The @code{signature} must specify the type of all arguments,
+ * The @var{signature} must specify the type of all arguments,
* including those in the vararg argument area.
* @end deftypefun
@*/
@@ -437,10 +437,10 @@
}
/*@
- * @deftypefun void jit_apply_raw (jit_type_t signature, {void *} func, {void
*} args, {void *} return_value)
+ * @deftypefun void jit_apply_raw (jit_type_t @var{signature}, void
address@hidden, void address@hidden, void address@hidden)
* Call a function, passing a set of raw arguments. This can only
* be used if @code{jit_raw_supported} returns non-zero for the signature.
- * The @code{args} value is assumed to be an array of @code{jit_nint} values
+ * The @var{args} value is assumed to be an array of @code{jit_nint} values
* that correspond to each of the arguments. Raw function calls
* are slightly faster than their non-raw counterparts, but can
* only be used in certain circumstances.
@@ -474,7 +474,7 @@
}
/*@
- * @deftypefun int jit_raw_supported (jit_type_t signature)
+ * @deftypefun int jit_raw_supported (jit_type_t @var{signature})
* Determine if @code{jit_apply_raw} can be used to call functions
* with a particular signature. Returns zero if not.
* @end deftypefun
@@ -810,10 +810,10 @@
#endif /* jit_closure_size */
/*@
- * @deftypefun {void *} jit_closure_create (jit_context_t context, jit_type_t
signature, {jit_closure_func} func, {void *} user_data)
+ * @deftypefun {void *} jit_closure_create (jit_context_t @var{context},
jit_type_t @var{signature}, jit_closure_func @var{func}, void address@hidden)
* Create a closure from a function signature, a closure handling function,
* and a user data value. Returns NULL if out of memory, or if closures are
- * not supported. The @code{func} argument should have the following
+ * not supported. The @var{func} argument should have the following
* prototype:
*
* @example
@@ -826,7 +826,7 @@
* @code{jit_closure_va_list_t} value for accessing the remainder of
* the arguments.
*
- * The memory for the closure will be reclaimed when the @code{context}
+ * The memory for the closure will be reclaimed when the @var{context}
* is destroyed.
* @end deftypefun
@*/
@@ -898,14 +898,14 @@
}
/*@
- * @deftypefun jit_nint jit_closure_va_get_nint (jit_closure_va_list_t va)
- * @deftypefunx jit_nuint jit_closure_va_get_nuint (jit_closure_va_list_t va)
- * @deftypefunx jit_long jit_closure_va_get_long (jit_closure_va_list_t va)
- * @deftypefunx jit_ulong jit_closure_va_get_ulong (jit_closure_va_list_t va)
- * @deftypefunx jit_float32 jit_closure_va_get_float32 (jit_closure_va_list_t
va)
- * @deftypefunx jit_float64 jit_closure_va_get_float64 (jit_closure_va_list_t
va)
- * @deftypefunx jit_nfloat jit_closure_va_get_nfloat (jit_closure_va_list_t va)
- * @deftypefunx {void *} jit_closure_va_get_ptr (jit_closure_va_list_t va)
+ * @deftypefun jit_nint jit_closure_va_get_nint (jit_closure_va_list_t
@var{va})
+ * @deftypefunx jit_nuint jit_closure_va_get_nuint (jit_closure_va_list_t
@var{va})
+ * @deftypefunx jit_long jit_closure_va_get_long (jit_closure_va_list_t
@var{va})
+ * @deftypefunx jit_ulong jit_closure_va_get_ulong (jit_closure_va_list_t
@var{va})
+ * @deftypefunx jit_float32 jit_closure_va_get_float32 (jit_closure_va_list_t
@var{va})
+ * @deftypefunx jit_float64 jit_closure_va_get_float64 (jit_closure_va_list_t
@var{va})
+ * @deftypefunx jit_nfloat jit_closure_va_get_nfloat (jit_closure_va_list_t
@var{va})
+ * @deftypefunx {void *} jit_closure_va_get_ptr (jit_closure_va_list_t
@var{va})
* Get the next value of a specific type from a closure's variable arguments.
* @end deftypefun
@*/
@@ -966,9 +966,9 @@
}
/*@
- * @deftypefun void jit_closure_va_get_struct (jit_closure_va_list_t va, void
*buf, jit_type_t type)
- * Get a structure or union value of a specific @code{type} from a closure's
- * variable arguments, and copy it into @code{buf}.
+ * @deftypefun void jit_closure_va_get_struct (jit_closure_va_list_t @var{va},
void address@hidden, jit_type_t @var{type})
+ * Get a structure or union value of a specific @var{type} from a closure's
+ * variable arguments, and copy it into @var{buf}.
* @end deftypefun
@*/
void jit_closure_va_get_struct
Index: jit/jit-block.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-block.c,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -b -r1.7 -r1.8
--- jit/jit-block.c 26 May 2004 01:19:38 -0000 1.7
+++ jit/jit-block.c 22 Jan 2008 06:09:08 -0000 1.8
@@ -136,8 +136,8 @@
}
/*@
- * @deftypefun jit_function_t jit_block_get_function (jit_block_t block)
- * Get the function that a particular @code{block} belongs to.
+ * @deftypefun jit_function_t jit_block_get_function (jit_block_t @var{block})
+ * Get the function that a particular @var{block} belongs to.
* @end deftypefun
@*/
jit_function_t jit_block_get_function(jit_block_t block)
@@ -153,8 +153,8 @@
}
/*@
- * @deftypefun jit_context_t jit_block_get_context (jit_block_t block)
- * Get the context that a particular @code{block} belongs to.
+ * @deftypefun jit_context_t jit_block_get_context (jit_block_t @var{block})
+ * Get the context that a particular @var{block} belongs to.
* @end deftypefun
@*/
jit_context_t jit_block_get_context(jit_block_t block)
@@ -170,7 +170,7 @@
}
/*@
- * @deftypefun jit_label_t jit_block_get_label (jit_block_t block)
+ * @deftypefun jit_label_t jit_block_get_label (jit_block_t @var{block})
* Get the label associated with a block.
* @end deftypefun
@*/
@@ -187,9 +187,9 @@
}
/*@
- * @deftypefun jit_block_t jit_block_next (jit_function_t func, jit_block_t
previous)
+ * @deftypefun jit_block_t jit_block_next (jit_function_t @var{func},
jit_block_t @var{previous})
* Iterate over the blocks in a function, in order of their creation.
- * The @code{previous} argument should be NULL on the first call.
+ * The @var{previous} argument should be NULL on the first call.
* This function will return NULL if there are no further blocks to iterate.
* @end deftypefun
@*/
@@ -210,9 +210,9 @@
}
/*@
- * @deftypefun jit_block_t jit_block_previous (jit_function_t func,
jit_block_t previous)
+ * @deftypefun jit_block_t jit_block_previous (jit_function_t @var{func},
jit_block_t @var{previous})
* Iterate over the blocks in a function, in reverse order of their creation.
- * The @code{previous} argument should be NULL on the first call.
+ * The @var{previous} argument should be NULL on the first call.
* This function will return NULL if there are no further blocks to iterate.
* @end deftypefun
@*/
@@ -233,8 +233,8 @@
}
/*@
- * @deftypefun jit_block_t jit_block_from_label (jit_function_t func,
jit_label_t label)
- * Get the block that corresponds to a particular @code{label}.
+ * @deftypefun jit_block_t jit_block_from_label (jit_function_t @var{func},
jit_label_t @var{label})
+ * Get the block that corresponds to a particular @var{label}.
* Returns NULL if there is no block associated with the label.
* @end deftypefun
@*/
@@ -305,9 +305,9 @@
}
/*@
- * @deftypefun int jit_block_set_meta (jit_block_t block, int type, {void *}
data, jit_meta_free_func free_data)
+ * @deftypefun int jit_block_set_meta (jit_block_t @var{block}, int
@var{type}, void address@hidden, jit_meta_free_func @var{free_data})
* Tag a block with some metadata. Returns zero if out of memory.
- * If the @code{type} already has some metadata associated with it, then
+ * If the @var{type} already has some metadata associated with it, then
* the previous value will be freed. Metadata may be used to store
* dependency graphs, branch prediction information, or any other
* information that is useful to optimizers or code generators.
@@ -322,9 +322,9 @@
}
/*@
- * @deftypefun {void *} jit_block_get_meta (jit_block_t block, int type)
+ * @deftypefun {void *} jit_block_get_meta (jit_block_t @var{block}, int
@var{type})
* Get the metadata associated with a particular tag. Returns NULL
- * if @code{type} does not have any metadata associated with it.
+ * if @var{type} does not have any metadata associated with it.
* @end deftypefun
@*/
void *jit_block_get_meta(jit_block_t block, int type)
@@ -333,9 +333,9 @@
}
/*@
- * @deftypefun void jit_block_free_meta (jit_block_t block, int type)
+ * @deftypefun void jit_block_free_meta (jit_block_t @var{block}, int
@var{type})
* Free metadata of a specific type on a block. Does nothing if
- * the @code{type} does not have any metadata associated with it.
+ * the @var{type} does not have any metadata associated with it.
* @end deftypefun
@*/
void jit_block_free_meta(jit_block_t block, int type)
@@ -344,7 +344,7 @@
}
/*@
- * @deftypefun int jit_block_is_reachable (jit_block_t block)
+ * @deftypefun int jit_block_is_reachable (jit_block_t @var{block})
* Determine if a block is reachable from some other point in
* its function. Unreachable blocks can be discarded in their
* entirety. If the JIT is uncertain as to whether a block is
@@ -359,7 +359,7 @@
}
/*@
- * @deftypefun int jit_block_ends_in_dead (jit_block_t block)
+ * @deftypefun int jit_block_ends_in_dead (jit_block_t @var{block})
* Determine if a block ends in a "dead" marker. That is, control
* will not fall out through the end of the block.
* @end deftypefun
@@ -370,7 +370,7 @@
}
/*@
- * @deftypefun int jit_block_current_is_dead (jit_function_t func)
+ * @deftypefun int jit_block_current_is_dead (jit_function_t @var{func})
* Determine if the current point in the function is dead. That is,
* there are no existing branches or fall-throughs to this point.
* This differs slightly from @code{jit_block_ends_in_dead} in that
Index: jit/jit-context.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-context.c,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -b -r1.8 -r1.9
--- jit/jit-context.c 21 Dec 2007 06:42:45 -0000 1.8
+++ jit/jit-context.c 22 Jan 2008 06:09:08 -0000 1.9
@@ -93,7 +93,7 @@
}
/*@
- * @deftypefun void jit_context_destroy (jit_context_t context)
+ * @deftypefun void jit_context_destroy (jit_context_t @var{context})
* Destroy a JIT context block and everything that is associated with it.
* It is very important that no threads within the program are currently
* running compiled code when this function is called.
@@ -124,7 +124,7 @@
}
/*@
- * @deftypefun int jit_context_supports_threads (jit_context_t context)
+ * @deftypefun int jit_context_supports_threads (jit_context_t @var{context})
* Determine if the JIT supports threads.
* @end deftypefun
@*/
@@ -134,7 +134,7 @@
}
/*@
- * @deftypefun void jit_context_build_start (jit_context_t context)
+ * @deftypefun void jit_context_build_start (jit_context_t @var{context})
* This routine should be called before you start building a function
* to be JIT'ed. It acquires a lock on the context to prevent other
* threads from accessing the build process, since only one thread
@@ -147,7 +147,7 @@
}
/*@
- * @deftypefun void jit_context_build_end (jit_context_t context)
+ * @deftypefun void jit_context_build_end (jit_context_t @var{context})
* This routine should be called once you have finished building
* and compiling a function and are ready to resume normal execution.
* This routine will release the build lock, allowing other threads
@@ -160,7 +160,7 @@
}
/*@
- * @deftypefun void jit_context_set_on_demand_driver (jit_context_t context,
jit_on_demand_driver_func driver)
+ * @deftypefun void jit_context_set_on_demand_driver (jit_context_t
@var{context}, jit_on_demand_driver_func @var{driver})
* Specify the C function to be called to drive on-demand compilation.
*
* When on-demand compilation is requested the default driver provided by
@@ -215,7 +215,7 @@
}
/*@
- * @deftypefun int jit_context_set_meta (jit_context_t context, int type,
{void *} data, jit_meta_free_func free_data)
+ * @deftypefun int jit_context_set_meta (jit_context_t @var{context}, int
@var{type}, void address@hidden, jit_meta_free_func @var{free_data})
* Tag a context with some metadata. Returns zero if out of memory.
*
* Metadata may be used to store dependency graphs, branch prediction
@@ -224,7 +224,7 @@
* to store information about the context that is specific to the
* virtual machine or language.
*
- * If the @code{type} already has some metadata associated with it, then
+ * If the @var{type} already has some metadata associated with it, then
* the previous value will be freed.
* @end deftypefun
@*/
@@ -236,7 +236,7 @@
}
/*@
- * @deftypefun int jit_context_set_meta_numeric (jit_context_t context, int
type, jit_nuint data)
+ * @deftypefun int jit_context_set_meta_numeric (jit_context_t @var{context},
int @var{type}, jit_nuint @var{data})
* Tag a context with numeric metadata. Returns zero if out of memory.
* This function is more convenient for accessing the context's
* special option values:
@@ -287,9 +287,9 @@
}
/*@
- * @deftypefun {void *} jit_context_get_meta (jit_context_t context, int type)
+ * @deftypefun {void *} jit_context_get_meta (jit_context_t @var{context}, int
@var{type})
* Get the metadata associated with a particular tag. Returns NULL
- * if @code{type} does not have any metadata associated with it.
+ * if @var{type} does not have any metadata associated with it.
* @end deftypefun
@*/
void *jit_context_get_meta(jit_context_t context, int type)
@@ -298,9 +298,9 @@
}
/*@
- * @deftypefun jit_nuint jit_context_get_meta_numeric (jit_context_t context,
int type)
+ * @deftypefun jit_nuint jit_context_get_meta_numeric (jit_context_t
@var{context}, int @var{type})
* Get the metadata associated with a particular tag. Returns zero
- * if @code{type} does not have any metadata associated with it.
+ * if @var{type} does not have any metadata associated with it.
* This version is more convenient for the pre-defined numeric option values.
* @end deftypefun
@*/
@@ -310,9 +310,9 @@
}
/*@
- * @deftypefun void jit_context_free_meta (jit_context_t context, int type)
+ * @deftypefun void jit_context_free_meta (jit_context_t @var{context}, int
@var{type})
* Free metadata of a specific type on a context. Does nothing if
- * the @code{type} does not have any metadata associated with it.
+ * the @var{type} does not have any metadata associated with it.
* @end deftypefun
@*/
void jit_context_free_meta(jit_context_t context, int type)
Index: jit/jit-debugger.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-debugger.c,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -b -r1.3 -r1.4
--- jit/jit-debugger.c 15 Sep 2006 16:17:21 -0000 1.3
+++ jit/jit-debugger.c 22 Jan 2008 06:09:08 -0000 1.4
@@ -32,11 +32,11 @@
breakpoints" into the code when functions are built and compiled. This
is performed using @code{jit_insn_mark_breakpoint}:
address@hidden int jit_insn_mark_breakpoint (jit_function_t func, jit_nint
data1, jit_nint data2)
-Mark the current position in @code{func} as corresponding to a breakpoint
address@hidden int jit_insn_mark_breakpoint (jit_function_t @var{func},
jit_nint @var{data1}, jit_nint @var{data2})
+Mark the current position in @var{func} as corresponding to a breakpoint
location. When a break occurs, the debugging routines are passed
address@hidden, @code{data1}, and @code{data2} as arguments. By convention,
address@hidden is the type of breakpoint (source line, function entry,
address@hidden, @var{data1}, and @var{data2} as arguments. By convention,
address@hidden is the type of breakpoint (source line, function entry,
function exit, etc).
@end deftypefun
@@ -125,9 +125,9 @@
A thread called @code{jit_debugger_detach_self}.
@end table
address@hidden int jit_insn_mark_breakpoint_variable (jit_function_t func,
jit_value_t data1, jit_value_t data2)
address@hidden int jit_insn_mark_breakpoint_variable (jit_function_t
@var{func}, jit_value_t @var{data1}, jit_value_t @var{data2})
This function is similar to @code{jit_insn_mark_breakpoint} except that values
-in @code{data1} and @code{data2} can be computed at runtime. You can use this
+in @var{data1} and @var{data2} can be computed at runtime. You can use this
function for example to get address of local variable.
@end deftypefun
@@ -267,8 +267,8 @@
}
/*@
- * @deftypefun jit_debugger_t jit_debugger_create (jit_context_t context)
- * Create a new debugger instance and attach it to a JIT @code{context}.
+ * @deftypefun jit_debugger_t jit_debugger_create (jit_context_t @var{context})
+ * Create a new debugger instance and attach it to a JIT @var{context}.
* If the context already has a debugger associated with it, then this
* function will return the previous debugger.
* @end deftypefun
@@ -300,7 +300,7 @@
}
/*@
- * @deftypefun void jit_debugger_destroy (jit_debugger_t dbg)
+ * @deftypefun void jit_debugger_destroy (jit_debugger_t @var{dbg})
* Destroy a debugger instance.
* @end deftypefun
@*/
@@ -310,7 +310,7 @@
}
/*@
- * @deftypefun jit_context_t jit_debugger_get_context (jit_debugger_t dbg)
+ * @deftypefun jit_context_t jit_debugger_get_context (jit_debugger_t
@var{dbg})
* Get the JIT context that is associated with a debugger instance.
* @end deftypefun
@*/
@@ -327,8 +327,8 @@
}
/*@
- * @deftypefun jit_debugger_t jit_debugger_from_context (jit_context_t context)
- * Get the debugger that is currently associated with a JIT context,
+ * @deftypefun jit_debugger_t jit_debugger_from_context (jit_context_t
@var{context})
+ * Get the debugger that is currently associated with a JIT @var{context},
* or NULL if there is no debugger associated with the context.
* @end deftypefun
@*/
@@ -345,7 +345,7 @@
}
/*@
- * @deftypefun jit_debugger_thread_id_t jit_debugger_get_self (jit_debugger_t
dbg)
+ * @deftypefun jit_debugger_thread_id_t jit_debugger_get_self (jit_debugger_t
@var{dbg})
* Get the thread identifier associated with the current thread.
* The return values are normally values like 1, 2, 3, etc, allowing
* the user interface to report messages like "thread 3 has stopped
@@ -362,9 +362,9 @@
}
/*@
- * @deftypefun jit_debugger_thread_id_t jit_debugger_get_thread
(jit_debugger_t dbg, {const void *} native_thread)
+ * @deftypefun jit_debugger_thread_id_t jit_debugger_get_thread
(jit_debugger_t @var{dbg}, const void address@hidden)
* Get the thread identifier for a specific native thread. The
- * @code{native_thread} pointer is assumed to point at a block
+ * @var{native_thread} pointer is assumed to point at a block
* of memory containing a native thread handle. This would be a
* @code{pthread_t} on Pthreads platforms or a @code{HANDLE}
* on Win32 platforms. If the native thread has not been seen
@@ -379,7 +379,7 @@
}
/*@
- * @deftypefun int jit_debugger_get_native_thread (jit_debugger_t dbg,
jit_debugger_thread_id_t thread, {void *} native_thread)
+ * @deftypefun int jit_debugger_get_native_thread (jit_debugger_t @var{dbg},
jit_debugger_thread_id_t @var{thread}, void address@hidden)
* Get the native thread handle associated with a debugger thread identifier.
* Returns non-zero if OK, or zero if the debugger thread identifier is not
* yet associated with a native thread handle.
@@ -406,7 +406,7 @@
}
/*@
- * @deftypefun void jit_debugger_set_breakable (jit_debugger_t dbg, {const
void *} native_thread, int flag)
+ * @deftypefun void jit_debugger_set_breakable (jit_debugger_t @var{dbg},
const void address@hidden, int @var{flag})
* Set a flag that indicates if a native thread can stop at breakpoints.
* If set to 1 (the default), breakpoints will be active on the thread.
* If set to 0, breakpoints will be ignored on the thread. Typically
@@ -432,8 +432,8 @@
}
/*@
- * @deftypefun void jit_debugger_attach_self (jit_debugger_t dbg, int
stop_immediately)
- * Attach the current thread to a debugger. If @code{stop_immediately}
+ * @deftypefun void jit_debugger_attach_self (jit_debugger_t @var{dbg}, int
@var{stop_immediately})
+ * Attach the current thread to a debugger. If @var{stop_immediately}
* is non-zero, then the current thread immediately suspends, waiting for
* the user to start it with @code{jit_debugger_run}. This function is
* typically called in a thread's startup code just before any "real work"
@@ -473,7 +473,7 @@
}
/*@
- * @deftypefun void jit_debugger_detach_self (jit_debugger_t dbg)
+ * @deftypefun void jit_debugger_detach_self (jit_debugger_t @var{dbg})
* Detach the current thread from the debugger. This is typically
* called just before the thread exits.
* @end deftypefun
@@ -499,9 +499,9 @@
}
/*@
- * @deftypefun int jit_debugger_wait_event (jit_debugger_t dbg,
{jit_debugger_event_t *} event, jit_nint timeout)
+ * @deftypefun int jit_debugger_wait_event (jit_debugger_t @var{dbg},
jit_debugger_event_t address@hidden, jit_nint @var{timeout})
* Wait for the next debugger event to arrive. Debugger events typically
- * indicate breakpoints that have occurred. The @code{timeout} is in
+ * indicate breakpoints that have occurred. The @var{timeout} is in
* milliseconds, or -1 for an infinite timeout period. Returns non-zero
* if an event has arrived, or zero on timeout.
* @end deftypefun
@@ -532,10 +532,10 @@
}
/*@
- * @deftypefun jit_debugger_breakpoint_id_t jit_debugger_add_breakpoint
(jit_debugger_t dbg, jit_debugger_breakpoint_info_t info)
- * Add a hard breakpoint to a debugger instance. The @code{info} structure
+ * @deftypefun jit_debugger_breakpoint_id_t jit_debugger_add_breakpoint
(jit_debugger_t @var{dbg}, jit_debugger_breakpoint_info_t @var{info})
+ * Add a hard breakpoint to a debugger instance. The @var{info} structure
* defines the conditions under which the breakpoint should fire.
- * The fields of @code{info} are as follows:
+ * The fields of @var{info} are as follows:
*
* @table @code
* @item flags
@@ -589,7 +589,7 @@
}
/*@
- * @deftypefun void jit_debugger_remove_breakpoint (jit_debugger_t dbg,
jit_debugger_breakpoint_id_t id)
+ * @deftypefun void jit_debugger_remove_breakpoint (jit_debugger_t @var{dbg},
jit_debugger_breakpoint_id_t @var{id})
* Remove a previously defined breakpoint from a debugger instance.
* @end deftypefun
@*/
@@ -600,7 +600,7 @@
}
/*@
- * @deftypefun void jit_debugger_remove_all_breakpoints (jit_debugger_t dbg)
+ * @deftypefun void jit_debugger_remove_all_breakpoints (jit_debugger_t
@var{dbg})
* Remove all breakpoints from a debugger instance.
* @end deftypefun
@*/
@@ -610,7 +610,7 @@
}
/*@
- * @deftypefun int jit_debugger_is_alive (jit_debugger_t dbg,
jit_debugger_thread_id_t thread)
+ * @deftypefun int jit_debugger_is_alive (jit_debugger_t @var{dbg},
jit_debugger_thread_id_t @var{thread})
* Determine if a particular thread is still alive.
* @end deftypefun
@*/
@@ -621,7 +621,7 @@
}
/*@
- * @deftypefun int jit_debugger_is_running (jit_debugger_t dbg,
jit_debugger_thread_id_t thread)
+ * @deftypefun int jit_debugger_is_running (jit_debugger_t @var{dbg},
jit_debugger_thread_id_t @var{thread})
* Determine if a particular thread is currently running (non-zero) or
* stopped (zero).
* @end deftypefun
@@ -641,7 +641,7 @@
}
/*@
- * @deftypefun void jit_debugger_run (jit_debugger_t dbg,
jit_debugger_thread_id_t thread)
+ * @deftypefun void jit_debugger_run (jit_debugger_t @var{dbg},
jit_debugger_thread_id_t @var{thread})
* Start the specified thread running, or continue from the last breakpoint.
*
* This function, and the others that follow, sends a request to the specified
@@ -662,7 +662,7 @@
}
/*@
- * @deftypefun void jit_debugger_step (jit_debugger_t dbg,
jit_debugger_thread_id_t thread)
+ * @deftypefun void jit_debugger_step (jit_debugger_t @var{dbg},
jit_debugger_thread_id_t @var{thread})
* Step over a single line of code. If the line performs a method call,
* then this will step into the call. The request will be ignored if
* the thread is currently running.
@@ -682,7 +682,7 @@
}
/*@
- * @deftypefun void jit_debugger_next (jit_debugger_t dbg,
jit_debugger_thread_id_t thread)
+ * @deftypefun void jit_debugger_next (jit_debugger_t @var{dbg},
jit_debugger_thread_id_t @var{thread})
* Step over a single line of code but do not step into method calls.
* The request will be ignored if the thread is currently running.
* @end deftypefun
@@ -701,7 +701,7 @@
}
/*@
- * @deftypefun void jit_debugger_finish (jit_debugger_t dbg,
jit_debugger_thread_id_t thread)
+ * @deftypefun void jit_debugger_finish (jit_debugger_t @var{dbg},
jit_debugger_thread_id_t @var{thread})
* Keep running until the end of the current function. The request will
* be ignored if the thread is currently running.
* @end deftypefun
@@ -720,7 +720,7 @@
}
/*@
- * @deftypefun void jit_debugger_break (jit_debugger_t dbg)
+ * @deftypefun void jit_debugger_break (jit_debugger_t @var{dbg})
* Force an explicit user breakpoint at the current location within the
* current thread. Control returns to the caller when the debugger
* calls one of the above "run" or "step" functions in another thread.
@@ -752,7 +752,7 @@
}
/*@
- * @deftypefun void jit_debugger_quit (jit_debugger_t dbg)
+ * @deftypefun void jit_debugger_quit (jit_debugger_t @var{dbg})
* Sends a request to the thread that called @code{jit_debugger_wait_event}
* indicating that the debugger should quit.
* @end deftypefun
@@ -771,7 +771,7 @@
}
/*@
- * @deftypefun jit_debugger_hook_func jit_debugger_set_hook (jit_context_t
context, jit_debugger_hook_func hook)
+ * @deftypefun jit_debugger_hook_func jit_debugger_set_hook (jit_context_t
@var{context}, jit_debugger_hook_func @var{hook})
* Set a debugger hook on a JIT context. Returns the previous hook.
*
* Debug hooks are a very low-level breakpoint mechanism. Upon reaching each
Index: jit/jit-dump.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-dump.c,v
retrieving revision 1.15
retrieving revision 1.16
diff -u -b -r1.15 -r1.16
--- jit/jit-dump.c 11 Feb 2007 22:54:25 -0000 1.15
+++ jit/jit-dump.c 22 Jan 2008 06:09:08 -0000 1.16
@@ -40,7 +40,7 @@
@*/
/*@
- * @deftypefun void jit_dump_type ({FILE *} stream, jit_type_t type)
+ * @deftypefun void jit_dump_type (FILE address@hidden, jit_type_t @var{type})
* Dump the name of a type to a stdio stream.
* @end deftypefun
@*/
@@ -119,10 +119,10 @@
}
/*@
- * @deftypefun void jit_dump_value ({FILE *} stream, jit_function_t func,
jit_value_t value, const char *prefix)
- * Dump the name of a value to a stdio stream. If @code{prefix} is not
+ * @deftypefun void jit_dump_value (FILE address@hidden, jit_function_t
@var{func}, jit_value_t @var{value}, const char address@hidden)
+ * Dump the name of a value to a stdio stream. If @var{prefix} is not
* NULL, then it indicates a type prefix to add to the value name.
- * If @code{prefix} is NULL, then this function intuits the type prefix.
+ * If @var{prefix} is NULL, then this function intuits the type prefix.
* @end deftypefun
@*/
void jit_dump_value(FILE *stream, jit_function_t func, jit_value_t value,
const char *prefix)
@@ -345,7 +345,7 @@
}
/*@
- * @deftypefun void jit_dump_insn ({FILE *} stream, jit_function_t func,
jit_value_t value)
+ * @deftypefun void jit_dump_insn (FILE address@hidden, jit_function_t
@var{func}, jit_value_t @var{value})
* Dump the contents of an instruction to a stdio stream.
* @end deftypefun
@*/
@@ -741,9 +741,9 @@
#endif /* !JIT_BACKEND_INTERP */
/*@
- * @deftypefun void jit_dump_function ({FILE *} stream, jit_function_t func,
{const char *} name)
+ * @deftypefun void jit_dump_function (FILE address@hidden, jit_function_t
@var{func}, const char address@hidden)
* Dump the three-address instructions within a function to a stream.
- * The @code{name} is attached to the output as a friendly label, but
+ * The @var{name} is attached to the output as a friendly label, but
* has no other significance.
*
* If the function has not been compiled yet, then this will dump the
Index: jit/jit-elf-read.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-elf-read.c,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -b -r1.3 -r1.4
--- jit/jit-elf-read.c 1 Jun 2004 06:46:46 -0000 1.3
+++ jit/jit-elf-read.c 22 Jan 2008 06:09:08 -0000 1.4
@@ -749,8 +749,8 @@
}
/*@
- * @deftypefun int jit_readelf_open ({jit_readelf_t *} readelf, {const char *}
filename, int force)
- * Open the specified @code{filename} and load the ELF binary that is
+ * @deftypefun int jit_readelf_open (jit_readelf_t address@hidden, const char
address@hidden, int @var{force})
+ * Open the specified @var{filename} and load the ELF binary that is
* contained within it. Returns one of the following result codes:
*
* @table @code
@@ -1085,7 +1085,7 @@
}
/*@
- * @deftypefun void jit_readelf_close (jit_readelf_t readelf)
+ * @deftypefun void jit_readelf_close (jit_readelf_t @var{readelf})
* Close an ELF reader, reclaiming all of the memory that was used.
* @end deftypefun
@*/
@@ -1123,7 +1123,7 @@
}
/*@
- * @deftypefun {const char *} jit_readelf_get_name (jit_readelf_t readelf)
+ * @deftypefun {const char *} jit_readelf_get_name (jit_readelf_t
@var{readelf})
* Get the library name that is embedded inside an ELF binary.
* ELF binaries can refer to each other using this name.
* @end deftypefun
@@ -1142,9 +1142,9 @@
}
/*@
- * @deftypefun void *jit_readelf_get_symbol (jit_readelf_t readelf, {const
char *} name)
- * Look up the symbol called @code{name} in the ELF binary represented
- * by @code{readelf}. Returns NULL if the symbol is not present.
+ * @deftypefun void *jit_readelf_get_symbol (jit_readelf_t @var{readelf},
const char address@hidden)
+ * Look up the symbol called @var{name} in the ELF binary represented
+ * by @var{readelf}. Returns NULL if the symbol is not present.
*
* External references from this ELF binary to others are not resolved
* until the ELF binary is loaded into a JIT context using
@@ -1228,7 +1228,7 @@
}
/*@
- * @deftypefun {void *} jit_readelf_get_section (jit_readelf_t readelf, {const
char *} name, {jit_nuint *} size)
+ * @deftypefun {void *} jit_readelf_get_section (jit_readelf_t @var{readelf},
const char address@hidden, jit_nuint address@hidden)
* Get the address and size of a particular section from an ELF binary.
* Returns NULL if the section is not present in the ELF binary.
*
@@ -1286,7 +1286,7 @@
}
/*@
- * @deftypefun {void *} jit_readelf_get_section_by_type (jit_readelf_t
readelf, jit_int type, {jit_nuint *} size)
+ * @deftypefun {void *} jit_readelf_get_section_by_type (jit_readelf_t
@var{readelf}, jit_int @var{type}, jit_nuint address@hidden)
* Get a particular section using its raw ELF section type (i.e. one of
* the @code{SHT_*} constants in @code{jit-elf-defs.h}). This is mostly
* for internal use, but some virtual machines may find it useful for
@@ -1326,9 +1326,9 @@
}
/*@
- * @deftypefun {void *} jit_readelf_map_vaddr (jit_readelf_t readelf,
jit_nuint vaddr)
+ * @deftypefun {void *} jit_readelf_map_vaddr (jit_readelf_t @var{readelf},
jit_nuint @var{vaddr})
* Map a virtual address to an actual address in a loaded ELF binary.
- * Returns NULL if @code{vaddr} could not be mapped.
+ * Returns NULL if @var{vaddr} could not be mapped.
* @end deftypefun
@*/
void *jit_readelf_map_vaddr(jit_readelf_t readelf, jit_nuint vaddr)
@@ -1352,7 +1352,7 @@
}
/*@
- * @deftypefun {unsigned int} jit_readelf_num_needed (jit_readelf_t readelf)
+ * @deftypefun {unsigned int} jit_readelf_num_needed (jit_readelf_t
@var{readelf})
* Get the number of dependent libraries that are needed by this
* ELF binary. The virtual machine will normally need to arrange
* to load these libraries with @code{jit_readelf_open} as well,
@@ -1377,10 +1377,10 @@
}
/*@
- * @deftypefun {const char *} jit_readelf_get_needed (jit_readelf_t readelf,
{unsigned int} index)
- * Get the name of the dependent library at position @code{index} within
+ * @deftypefun {const char *} jit_readelf_get_needed (jit_readelf_t
@var{readelf}, unsigned int @var{index})
+ * Get the name of the dependent library at position @var{index} within
* the needed libraries list of this ELF binary. Returns NULL if
- * the @code{index} is invalid.
+ * the @var{index} is invalid.
* @end deftypefun
@*/
const char *jit_readelf_get_needed(jit_readelf_t readelf, unsigned int index)
@@ -1404,7 +1404,7 @@
}
/*@
- * @deftypefun void jit_readelf_add_to_context (jit_readelf_t readelf,
jit_context_t context)
+ * @deftypefun void jit_readelf_add_to_context (jit_readelf_t @var{readelf},
jit_context_t @var{context})
* Add this ELF binary to a JIT context, so that its contents can be used
* when executing JIT-managed code. The binary will be closed automatically
* if the context is destroyed and @code{jit_readelf_close} has not been
@@ -1759,10 +1759,10 @@
}
/*@
- * @deftypefun int jit_readelf_resolve_all (jit_context_t context, int
print_failures)
+ * @deftypefun int jit_readelf_resolve_all (jit_context_t @var{context}, int
@var{print_failures})
* Resolve all of the cross-library symbol references in ELF binaries
- * that have been added to @code{context} but which were not resolved
- * in the previous call to this function. If @code{print_failures}
+ * that have been added to @var{context} but which were not resolved
+ * in the previous call to this function. If @var{print_failures}
* is non-zero, then diagnostic messages will be written to stdout
* for any symbol resolutions that fail.
*
@@ -1798,14 +1798,14 @@
}
/*@
- * @deftypefun int jit_readelf_register_symbol (jit_context_t context, {const
char *} name, {void *} value, int after)
- * Register @code{value} with @code{name} on the specified @code{context}.
+ * @deftypefun int jit_readelf_register_symbol (jit_context_t @var{context},
const char address@hidden, void address@hidden, int @var{after})
+ * Register @var{value} with @var{name} on the specified @var{context}.
* Whenever symbols are resolved with @code{jit_readelf_resolve_all},
- * and the symbol @code{name} is encountered, @code{value} will be
+ * and the symbol @var{name} is encountered, @var{value} will be
* substituted. Returns zero if out of memory or there is something
* wrong with the parameters.
*
- * If @code{after} is non-zero, then @code{name} will be resolved after all
+ * If @var{after} is non-zero, then @var{name} will be resolved after all
* other ELF libraries; otherwise it will be resolved before the ELF
* libraries.
*
Index: jit/jit-elf-write.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-elf-write.c,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -b -r1.1.1.1 -r1.2
--- jit/jit-elf-write.c 30 Apr 2004 23:30:00 -0000 1.1.1.1
+++ jit/jit-elf-write.c 22 Jan 2008 06:09:08 -0000 1.2
@@ -293,9 +293,9 @@
}
/*@
- * @deftypefun jit_writeelf_t jit_writeelf_create ({const char *} library_name)
+ * @deftypefun jit_writeelf_t jit_writeelf_create (const char address@hidden)
* Create an object to assist with the process of writing an ELF binary.
- * The @code{library_name} will be embedded into the binary. Returns NULL
+ * The @var{library_name} will be embedded into the binary. Returns NULL
* if out of memory.
* @end deftypefun
@*/
@@ -394,8 +394,8 @@
}
/*@
- * @deftypefun void jit_writeelf_destroy (jit_writeelf_t writeelf)
- * Destroy the memory structures that were used while @code{writeelf}
+ * @deftypefun void jit_writeelf_destroy (jit_writeelf_t @var{writeelf})
+ * Destroy the memory structures that were used while @var{writeelf}
* was being built.
* @end deftypefun
@*/
@@ -415,8 +415,8 @@
}
/*@
- * @deftypefun int jit_writeelf_write (jit_writeelf_t writeelf, {const char *}
filename)
- * Write a fully-built ELF binary to @code{filename}. Returns zero
+ * @deftypefun int jit_writeelf_write (jit_writeelf_t @var{writeelf}, const
char address@hidden)
+ * Write a fully-built ELF binary to @var{filename}. Returns zero
* if an error occurred (reason in @code{errno}).
* @end deftypefun
@*/
@@ -427,9 +427,9 @@
}
/*@
- * @deftypefun int jit_writeelf_add_function (jit_writeelf_t writeelf,
jit_function_t func, {const char *} name)
- * Write the code for @code{func} to the ELF binary represented by
- * @code{writeelf}. The function must already be compiled, and its
+ * @deftypefun int jit_writeelf_add_function (jit_writeelf_t @var{writeelf},
jit_function_t @var{func}, const char address@hidden)
+ * Write the code for @var{func} to the ELF binary represented by
+ * @var{writeelf}. The function must already be compiled, and its
* context must have the @code{JIT_OPTION_PRE_COMPILE} option set
* to a non-zero value. Returns zero if out of memory or the
* parameters are invalid.
@@ -443,9 +443,9 @@
}
/*@
- * @deftypefun int jit_writeelf_add_needed (jit_writeelf_t writeelf, {const
char *} library_name)
- * Add @code{library_name} to the list of dependent libraries that are needed
- * when the ELF binary is reloaded. If @code{library_name} is already on
+ * @deftypefun int jit_writeelf_add_needed (jit_writeelf_t @var{writeelf},
const char address@hidden)
+ * Add @var{library_name} to the list of dependent libraries that are needed
+ * when the ELF binary is reloaded. If @var{library_name} is already on
* the list, then this request will be silently ignored. Returns
* zero if out of memory or the parameters are invalid.
* @end deftypefun
@@ -493,12 +493,12 @@
}
/*@
- * @deftypefun int jit_writeelf_write_section (jit_writeelf_t writeelf, {const
char *} name, jit_int type, {const void *} buf, {unsigned int} len, int
discardable)
- * Write auxillary data to a section called @code{name}. If @code{type}
+ * @deftypefun int jit_writeelf_write_section (jit_writeelf_t @var{writeelf},
const char address@hidden, jit_int @var{type}, const void address@hidden,
unsigned int @var{len}, int @var{discardable})
+ * Write auxillary data to a section called @var{name}. If @var{type}
* is not zero, then it indicates an ELF section type. This is used
* by virtual machines to store auxillary data that can be retrieved
* later using @code{jit_readelf_get_section}. If the section already
- * contains data, then this will append the new data. If @code{discardable}
+ * contains data, then this will append the new data. If @var{discardable}
* is non-zero, then it is OK for this section to be discarded when the
* ELF binary is stripped. Returns zero if out of memory or the
* parameters are invalid.
Index: jit/jit-except.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-except.c,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -b -r1.7 -r1.8
--- jit/jit-except.c 23 Mar 2006 18:56:52 -0000 1.7
+++ jit/jit-except.c 22 Jan 2008 06:09:08 -0000 1.8
@@ -80,7 +80,7 @@
}
/*@
- * @deftypefun void jit_exception_set_last (void *object)
+ * @deftypefun void jit_exception_set_last (void address@hidden)
* Set the last exception object that occurred on this thread, so that
* it can be retrieved by a later call to @code{jit_exception_get_last}.
* This is normally used by @code{jit_function_apply} to save the
@@ -109,7 +109,7 @@
}
/*@
- * @deftypefun void jit_exception_throw ({void *} object)
+ * @deftypefun void jit_exception_throw (void address@hidden)
* Throw an exception object within the current thread. As far as
* @code{libjit} is concerned, the exception object is just a pointer.
* The precise meaning of the data at the pointer is determined
@@ -137,7 +137,7 @@
}
/*@
- * @deftypefun void jit_exception_builtin (int exception_type)
+ * @deftypefun void jit_exception_builtin (int @var{exception_type})
* This function is called to report a builtin exception.
* The JIT will automatically embed calls to this function wherever a
* builtin exception needs to be reported.
@@ -244,7 +244,7 @@
}
/*@
- * @deftypefun jit_exception_func jit_exception_set_handler
(jit_exception_func handler)
+ * @deftypefun jit_exception_func jit_exception_set_handler
(jit_exception_func @var{handler})
* Set the builtin exception handler for the current thread.
* Returns the previous exception handler.
* @end deftypefun
@@ -378,7 +378,7 @@
}
/*@
- * @deftypefun {unsigned int} jit_stack_trace_get_size (jit_stack_trace_t
trace)
+ * @deftypefun {unsigned int} jit_stack_trace_get_size (jit_stack_trace_t
@var{trace})
* Get the size of a stack trace.
* @end deftypefun
@*/
@@ -395,11 +395,11 @@
}
/*@
- * @deftypefun jit_function_t jit_stack_trace_get_function (jit_context_t
context, jit_stack_trace_t trace, {unsigned int} posn)
- * Get the function that is at position @code{posn} within a stack trace.
+ * @deftypefun jit_function_t jit_stack_trace_get_function (jit_context_t
@var{context}, jit_stack_trace_t @var{trace}, unsigned int @var{posn})
+ * Get the function that is at position @var{posn} within a stack trace.
* Position 0 is the function that created the stack trace. If this
* returns NULL, then it indicates that there is a native callout at
- * @code{posn} within the stack trace.
+ * @var{posn} within the stack trace.
* @end deftypefun
@*/
jit_function_t jit_stack_trace_get_function
@@ -418,8 +418,8 @@
}
/*@
- * @deftypefun {void *} jit_stack_trace_get_pc (jit_stack_trace_t trace,
{unsigned int} posn)
- * Get the program counter that corresponds to position @code{posn}
+ * @deftypefun {void *} jit_stack_trace_get_pc (jit_stack_trace_t @var{trace},
unsigned int @var{posn})
+ * Get the program counter that corresponds to position @var{posn}
* within a stack trace. This is the point within the function
* where execution had reached at the time of the trace.
* @end deftypefun
@@ -438,10 +438,10 @@
}
/*@
- * @deftypefun {unsigned int} jit_stack_trace_get_offset (jit_stack_trace_t
trace, {unsigned int} posn)
- * Get the bytecode offset that is recorded for position @code{posn}
+ * @deftypefun {unsigned int} jit_stack_trace_get_offset (jit_stack_trace_t
@var{trace}, unsigned int @var{posn})
+ * Get the bytecode offset that is recorded for position @var{posn}
* within a stack trace. This will be @code{JIT_NO_OFFSET} if there
- * is no bytecode offset associated with @code{posn}.
+ * is no bytecode offset associated with @var{posn}.
* @end deftypefun
@*/
unsigned int jit_stack_trace_get_offset
@@ -471,7 +471,7 @@
}
/*@
- * @deftypefun void jit_stack_trace_free (jit_stack_trace_t trace)
+ * @deftypefun void jit_stack_trace_free (jit_stack_trace_t @var{trace})
* Free the memory associated with a stack trace.
* @end deftypefun
@*/
Index: jit/jit-function.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-function.c,v
retrieving revision 1.33
retrieving revision 1.34
diff -u -b -r1.33 -r1.34
--- jit/jit-function.c 21 Dec 2007 06:42:45 -0000 1.33
+++ jit/jit-function.c 22 Jan 2008 06:09:08 -0000 1.34
@@ -29,7 +29,7 @@
#endif
/*@
- * @deftypefun jit_function_t jit_function_create (jit_context_t context,
jit_type_t signature)
+ * @deftypefun jit_function_t jit_function_create (jit_context_t
@var{context}, jit_type_t @var{signature})
* Create a new function block and associate it with a JIT context.
* Returns NULL if out of memory.
*
@@ -136,10 +136,10 @@
}
/*@
- * @deftypefun jit_function_t jit_function_create_nested (jit_context_t
context, jit_type_t signature, jit_function_t parent)
+ * @deftypefun jit_function_t jit_function_create_nested (jit_context_t
@var{context}, jit_type_t @var{signature}, jit_function_t @var{parent})
* Create a new function block and associate it with a JIT context.
* In addition, this function is nested inside the specified
- * @code{parent} function and is able to access its parent's
+ * @var{parent} function and is able to access its parent's
* (and grandparent's) local variables.
*
* The front end is responsible for ensuring that the nested function can
@@ -257,10 +257,10 @@
}
/*@
- * @deftypefun void jit_function_abandon (jit_function_t func)
+ * @deftypefun void jit_function_abandon (jit_function_t @var{func})
* Abandon this function during the build process. This should be called
* when you detect a fatal error that prevents the function from being
- * properly built. The @code{func} object is completely destroyed and
+ * properly built. The @var{func} object is completely destroyed and
* detached from its owning context. The function is left alone if
* it was already compiled.
* @end deftypefun
@@ -285,7 +285,7 @@
}
/*@
- * @deftypefun jit_context_t jit_function_get_context (jit_function_t func)
+ * @deftypefun jit_context_t jit_function_get_context (jit_function_t
@var{func})
* Get the context associated with a function.
* @end deftypefun
@*/
@@ -302,7 +302,7 @@
}
/*@
- * @deftypefun jit_type_t jit_function_get_signature (jit_function_t func)
+ * @deftypefun jit_type_t jit_function_get_signature (jit_function_t
@var{func})
* Get the signature associated with a function.
* @end deftypefun
@*/
@@ -319,7 +319,7 @@
}
/*@
- * @deftypefun int jit_function_set_meta (jit_function_t func, int type, {void
*} data, jit_meta_free_func free_data, int build_only)
+ * @deftypefun int jit_function_set_meta (jit_function_t @var{func}, int
@var{type}, void address@hidden, jit_meta_free_func @var{free_data}, int
@var{build_only})
* Tag a function with some metadata. Returns zero if out of memory.
*
* Metadata may be used to store dependency graphs, branch prediction
@@ -328,13 +328,13 @@
* to store information about the function that is specific to the
* virtual machine or language.
*
- * If the @code{type} already has some metadata associated with it, then
+ * If the @var{type} already has some metadata associated with it, then
* the previous value will be freed.
*
- * If @code{build_only} is non-zero, then the metadata will be freed
+ * If @var{build_only} is non-zero, then the metadata will be freed
* when the function is compiled with @code{jit_function_compile}.
* Otherwise the metadata will persist until the JIT context is destroyed,
- * or @code{jit_function_free_meta} is called for the specified @code{type}.
+ * or @code{jit_function_free_meta} is called for the specified @var{type}.
*
* Metadata type values of 10000 or greater are reserved for internal use.
* @end deftypefun
@@ -358,9 +358,9 @@
}
/*@
- * @deftypefun {void *} jit_function_get_meta (jit_function_t func, int type)
+ * @deftypefun {void *} jit_function_get_meta (jit_function_t @var{func}, int
@var{type})
* Get the metadata associated with a particular tag. Returns NULL
- * if @code{type} does not have any metadata associated with it.
+ * if @var{type} does not have any metadata associated with it.
* @end deftypefun
@*/
void *jit_function_get_meta(jit_function_t func, int type)
@@ -374,9 +374,9 @@
}
/*@
- * @deftypefun void jit_function_free_meta (jit_function_t func, int type)
+ * @deftypefun void jit_function_free_meta (jit_function_t @var{func}, int
@var{type})
* Free metadata of a specific type on a function. Does nothing if
- * the @code{type} does not have any metadata associated with it.
+ * the @var{type} does not have any metadata associated with it.
* @end deftypefun
@*/
void jit_function_free_meta(jit_function_t func, int type)
@@ -389,8 +389,8 @@
}
/*@
- * @deftypefun jit_function_t jit_function_next (jit_context_t context,
jit_function_t prev)
- * Iterate over the defined functions in creation order. The @code{prev}
+ * @deftypefun jit_function_t jit_function_next (jit_context_t @var{context},
jit_function_t @var{prev})
+ * Iterate over the defined functions in creation order. The @var{prev}
* argument should be NULL on the first call. Returns NULL at the end.
* @end deftypefun
@*/
@@ -411,12 +411,11 @@
}
/*@
- * @deftypefun jit_function_t jit_function_previous (jit_context_t context,
jit_function_t prev)
+ * @deftypefun jit_function_t jit_function_previous (jit_context_t
@var{context}, jit_function_t @var{prev})
* Iterate over the defined functions in reverse creation order.
* @end deftypefun
@*/
-jit_function_t jit_function_previous(jit_context_t context,
-
jit_function_t prev)
+jit_function_t jit_function_previous(jit_context_t context, jit_function_t
prev)
{
if(prev)
{
@@ -433,7 +432,7 @@
}
/*@
- * @deftypefun jit_block_t jit_function_get_entry (jit_function_t func)
+ * @deftypefun jit_block_t jit_function_get_entry (jit_function_t @var{func})
* Get the entry block for a function. This is always the first block
* created by @code{jit_function_create}.
* @end deftypefun
@@ -451,7 +450,7 @@
}
/*@
- * @deftypefun jit_block_t jit_function_get_current (jit_function_t func)
+ * @deftypefun jit_block_t jit_function_get_current (jit_function_t @var{func})
* Get the current block for a function. New blocks are created by
* certain @code{jit_insn_xxx} calls.
* @end deftypefun
@@ -469,8 +468,8 @@
}
/*@
- * @deftypefun jit_function_t jit_function_get_nested_parent (jit_function_t
func)
- * Get the nested parent for a function, or NULL if @code{func}
+ * @deftypefun jit_function_t jit_function_get_nested_parent (jit_function_t
@var{func})
+ * Get the nested parent for a function, or NULL if @var{func}
* does not have a nested parent.
* @end deftypefun
@*/
@@ -909,7 +908,7 @@
};
/*@
- * @deftypefun int jit_function_compile (jit_function_t func)
+ * @deftypefun int jit_function_compile (jit_function_t @var{func})
* Compile a function to its executable form. If the function was
* already compiled, then do nothing. Returns zero on error.
*
@@ -958,7 +957,7 @@
}
/*@
- * @deftypefun int jit_function_compile_entry (jit_function_t func, void
**entry_point)
+ * @deftypefun int jit_function_compile_entry (jit_function_t @var{func}, void
address@hidden)
* Compile a function to its executable form but do not make it
* available for invocation yet. It may be made available later
* with @code{jit_function_setup_entry}.
@@ -999,10 +998,10 @@
}
/*@
- * @deftypefun int jit_function_setup_entry (jit_function_t func, void
*entry_point)
+ * @deftypefun int jit_function_setup_entry (jit_function_t @var{func}, void
address@hidden)
* Make a function compiled with @code{jit_function_compile_entry}
* available for invocation and free the resources used for
- * compilation. If @code{entry_point} is null then it only
+ * compilation. If @var{entry_point} is null then it only
* frees the resources.
* @end deftypefun
@*/
@@ -1024,7 +1023,7 @@
}
/*@
- * @deftypefun int jit_function_is_compiled (jit_function_t func)
+ * @deftypefun int jit_function_is_compiled (jit_function_t @var{func})
* Determine if a function has already been compiled.
* @end deftypefun
@*/
@@ -1041,7 +1040,7 @@
}
/*@
- * @deftypefun int jit_function_set_recompilable (jit_function_t func)
+ * @deftypefun int jit_function_set_recompilable (jit_function_t @var{func})
* Mark this function as a candidate for recompilation. That is,
* it is possible that we may call @code{jit_function_compile}
* more than once, to re-optimize an existing function.
@@ -1063,7 +1062,7 @@
}
/*@
- * @deftypefun void jit_function_clear_recompilable (jit_function_t func)
+ * @deftypefun void jit_function_clear_recompilable (jit_function_t @var{func})
* Clear the recompilable flag on this function. Normally you would use
* this once you have decided that the function has been optimized enough,
* and that you no longer intend to call @code{jit_function_compile} again.
@@ -1084,7 +1083,7 @@
}
/*@
- * @deftypefun int jit_function_is_recompilable (jit_function_t func)
+ * @deftypefun int jit_function_is_recompilable (jit_function_t @var{func})
* Determine if this function is recompilable.
* @end deftypefun
@*/
@@ -1119,7 +1118,7 @@
#endif /* JIT_BACKEND_INTERP */
/*@
- * @deftypefun {void *} jit_function_to_closure (jit_function_t func)
+ * @deftypefun {void *} jit_function_to_closure (jit_function_t @var{func})
* Convert a compiled function into a closure that can called directly
* from C. Returns NULL if out of memory, or if closures are not
* supported on this platform.
@@ -1152,7 +1151,7 @@
}
/*@
- * @deftypefun jit_function_t jit_function_from_closure (jit_context_t
context, {void *} closure)
+ * @deftypefun jit_function_t jit_function_from_closure (jit_context_t
@var{context}, void address@hidden)
* Convert a closure back into a function. Returns NULL if the
* closure does not correspond to a function in the specified context.
* @end deftypefun
@@ -1169,11 +1168,11 @@
}
/*@
- * @deftypefun jit_function_t jit_function_from_pc (jit_context_t context,
{void *} pc, {void **} handler)
+ * @deftypefun jit_function_t jit_function_from_pc (jit_context_t
@var{context}, void address@hidden, void address@hidden)
* Get the function that contains the specified program counter location.
* Also return the address of the @code{catch} handler for the same location.
* Returns NULL if the program counter does not correspond to a function
- * under the control of @code{context}.
+ * under the control of @var{context}.
* @end deftypefun
@*/
jit_function_t jit_function_from_pc
@@ -1215,7 +1214,7 @@
}
/*@
- * @deftypefun {void *} jit_function_to_vtable_pointer (jit_function_t func)
+ * @deftypefun {void *} jit_function_to_vtable_pointer (jit_function_t
@var{func})
* Return a pointer that is suitable for referring to this function
* from a vtable. Such pointers should only be used with the
* @code{jit_insn_call_vtable} instruction.
@@ -1247,7 +1246,7 @@
}
/*@
- * @deftypefun jit_function_t jit_function_from_vtable_pointer (jit_context_t
context, {void *} vtable_pointer)
+ * @deftypefun jit_function_t jit_function_from_vtable_pointer (jit_context_t
@var{context}, void address@hidden)
* Convert a vtable_pointer back into a function. Returns NULL if the
* vtable_pointer does not correspond to a function in the specified context.
* @end deftypefun
@@ -1275,8 +1274,8 @@
}
/*@
- * @deftypefun void jit_function_set_on_demand_compiler (jit_function_t func,
jit_on_demand_func on_demand)
- * Specify the C function to be called when @code{func} needs to be
+ * @deftypefun void jit_function_set_on_demand_compiler (jit_function_t
@var{func}, jit_on_demand_func @var{on_demand})
+ * Specify the C function to be called when @var{func} needs to be
* compiled on-demand. This should be set just after the function
* is created, before any build or compile processes begin.
*
@@ -1330,7 +1329,7 @@
}
/*@
- * @deftypefun jit_on_demand_func jit_function_get_on_demand_compiler
(jit_function_t func)
+ * @deftypefun jit_on_demand_func jit_function_get_on_demand_compiler
(jit_function_t @var{func})
* Returns function's on-demand compiler.
* @end deftypefun
@*/
@@ -1401,9 +1400,9 @@
}
/*@
- * @deftypefun int jit_function_apply (jit_function_t func, {void **} args,
{void *} return_area)
- * Call the function @code{func} with the supplied arguments. Each element
- * in @code{args} is a pointer to one of the arguments, and @code{return_area}
+ * @deftypefun int jit_function_apply (jit_function_t @var{func}, void
address@hidden, void address@hidden)
+ * Call the function @var{func} with the supplied arguments. Each element
+ * in @var{args} is a pointer to one of the arguments, and @var{return_area}
* points to a buffer to receive the return value. Returns zero if an
* exception occurred.
*
@@ -1413,15 +1412,15 @@
* is guaranteed to be supported everywhere.
*
* Function applications acts as an exception blocker. If any exceptions
- * occur during the execution of @code{func}, they won't travel up the
+ * occur during the execution of @var{func}, they won't travel up the
* stack any further than this point. This prevents ordinary C code
* from being accidentally presented with a situation that it cannot handle.
* This blocking protection is not present when a function is invoked
* via its closure.
* @end deftypefun
*
- * @deftypefun int jit_function_apply_vararg (jit_function_t func, jit_type_t
signature, {void **} args, {void *} return_area)
- * Call the function @code{func} with the supplied arguments. There may
+ * @deftypefun int jit_function_apply_vararg (jit_function_t @var{func},
jit_type_t @var{signature}, void address@hidden, void address@hidden)
+ * Call the function @var{func} with the supplied arguments. There may
* be more arguments than are specified in the function's original signature,
* in which case the additional values are passed as variable arguments.
* This function is otherwise identical to @code{jit_function_apply}.
@@ -1505,11 +1504,11 @@
#endif /* !JIT_BACKEND_INTERP */
/*@
- * @deftypefun void jit_function_set_optimization_level (jit_function_t func,
{unsigned int} level)
- * Set the optimization level for @code{func}. Increasing values indicate
+ * @deftypefun void jit_function_set_optimization_level (jit_function_t
@var{func}, unsigned int @var{level})
+ * Set the optimization level for @var{func}. Increasing values indicate
* that the @code{libjit} dynamic compiler should expend more effort to
* generate better code for this function. Usually you would increase
- * this value just before forcing @code{func} to recompile.
+ * this value just before forcing @var{func} to recompile.
*
* When the optimization level reaches the value returned by
* @code{jit_function_get_max_optimization_level()}, there is usually
@@ -1518,7 +1517,7 @@
*
* The front end is usually responsible for choosing candidates for
* function inlining. If it has identified more such candidates, then
- * it may still want to recompile @code{func} again even once it has
+ * it may still want to recompile @var{func} again even once it has
* reached the maximum optimization level.
* @end deftypefun
@*/
@@ -1537,8 +1536,8 @@
}
/*@
- * @deftypefun {unsigned int} jit_function_get_optimization_level
(jit_function_t func)
- * Get the current optimization level for @code{func}.
+ * @deftypefun {unsigned int} jit_function_get_optimization_level
(jit_function_t @var{func})
+ * Get the current optimization level for @var{func}.
* @end deftypefun
@*/
unsigned int jit_function_get_optimization_level(jit_function_t func)
@@ -1565,8 +1564,8 @@
}
/*@
- * @deftypefun {jit_label_t} jit_function_reserve_label (jit_function_t func)
- * Allocate a new label for later use within the function @code{func}. Most
+ * @deftypefun {jit_label_t} jit_function_reserve_label (jit_function_t
@var{func})
+ * Allocate a new label for later use within the function @var{func}. Most
* instructions that require a label could perform label allocation themselves.
* A separate label allocation could be useful to fill a jump table with
* identical entries.
Index: jit/jit-insn.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-insn.c,v
retrieving revision 1.56
retrieving revision 1.57
diff -u -b -r1.56 -r1.57
--- jit/jit-insn.c 17 Nov 2007 02:12:36 -0000 1.56
+++ jit/jit-insn.c 22 Jan 2008 06:09:08 -0000 1.57
@@ -888,7 +888,7 @@
}
/*@
- * @deftypefun int jit_insn_get_opcode (jit_insn_t insn)
+ * @deftypefun int jit_insn_get_opcode (jit_insn_t @var{insn})
* Get the opcode that is associated with an instruction.
* @end deftypefun
@*/
@@ -905,7 +905,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_get_dest (jit_insn_t insn)
+ * @deftypefun jit_value_t jit_insn_get_dest (jit_insn_t @var{insn})
* Get the destination value that is associated with an instruction.
* Returns NULL if the instruction does not have a destination.
* @end deftypefun
@@ -923,7 +923,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_get_value1 (jit_insn_t insn)
+ * @deftypefun jit_value_t jit_insn_get_value1 (jit_insn_t @var{insn})
* Get the first argument value that is associated with an instruction.
* Returns NULL if the instruction does not have a first argument value.
* @end deftypefun
@@ -941,7 +941,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_get_value2 (jit_insn_t insn)
+ * @deftypefun jit_value_t jit_insn_get_value2 (jit_insn_t @var{insn})
* Get the second argument value that is associated with an instruction.
* Returns NULL if the instruction does not have a second argument value.
* @end deftypefun
@@ -959,7 +959,7 @@
}
/*@
- * @deftypefun jit_label_t jit_insn_get_label (jit_insn_t insn)
+ * @deftypefun jit_label_t jit_insn_get_label (jit_insn_t @var{insn})
* Get the label for a branch target from an instruction.
* Returns NULL if the instruction does not have a branch target.
* @end deftypefun
@@ -982,7 +982,7 @@
}
/*@
- * @deftypefun jit_function_t jit_insn_get_function (jit_insn_t insn)
+ * @deftypefun jit_function_t jit_insn_get_function (jit_insn_t @var{insn})
* Get the function for a call instruction. Returns NULL if the
* instruction does not refer to a called function.
* @end deftypefun
@@ -1000,7 +1000,7 @@
}
/*@
- * @deftypefun {void *} jit_insn_get_native (jit_insn_t insn)
+ * @deftypefun {void *} jit_insn_get_native (jit_insn_t @var{insn})
* Get the function pointer for a native call instruction.
* Returns NULL if the instruction does not refer to a native
* function call.
@@ -1019,7 +1019,7 @@
}
/*@
- * @deftypefun {const char *} jit_insn_get_name (jit_insn_t insn)
+ * @deftypefun {const char *} jit_insn_get_name (jit_insn_t @var{insn})
* Get the diagnostic name for a function call. Returns NULL
* if the instruction does not have a diagnostic name.
* @end deftypefun
@@ -1037,7 +1037,7 @@
}
/*@
- * @deftypefun jit_type_t jit_insn_get_signature (jit_insn_t insn)
+ * @deftypefun jit_type_t jit_insn_get_signature (jit_insn_t @var{insn})
* Get the signature for a function call instruction. Returns NULL
* if the instruction is not a function call.
* @end deftypefun
@@ -1055,8 +1055,8 @@
}
/*@
- * @deftypefun int jit_insn_dest_is_value (jit_insn_t insn)
- * Returns a non-zero value if the destination for @code{insn} is
+ * @deftypefun int jit_insn_dest_is_value (jit_insn_t @var{insn})
+ * Returns a non-zero value if the destination for @var{insn} is
* actually a source value. This can happen with instructions
* such as @code{jit_insn_store_relative} where the instruction
* needs three source operands, and the real destination is a
@@ -1076,11 +1076,11 @@
}
/*@
- * @deftypefun void jit_insn_label (jit_function_t func, {jit_label_t *} label)
- * Start a new block within the function @code{func} and give it the
- * specified @code{label}. Returns zero if out of memory.
+ * @deftypefun void jit_insn_label (jit_function_t @var{func}, jit_label_t
address@hidden)
+ * Start a new block within the function @var{func} and give it the
+ * specified @var{label}. Returns zero if out of memory.
*
- * If the contents of @code{label} are @code{jit_label_undefined}, then this
+ * If the contents of @var{label} are @code{jit_label_undefined}, then this
* function will allocate a new label for this block. Otherwise it will
* reuse the specified label from a previous branch instruction.
* @end deftypefun
@@ -1152,7 +1152,7 @@
}
/*@
- * @deftypefun int jit_insn_new_block (jit_function_t func)
+ * @deftypefun int jit_insn_new_block (jit_function_t @var{func})
* Start a new basic block, without giving it an explicit label.
* @end deftypefun
@*/
@@ -1347,8 +1347,8 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_load (jit_function_t func, jit_value_t
value)
- * Load the contents of @code{value} into a new temporary, essentially
+ * @deftypefun jit_value_t jit_insn_load (jit_function_t @var{func},
jit_value_t @var{value})
+ * Load the contents of @var{value} into a new temporary, essentially
* duplicating the value. Constants are not duplicated.
* @end deftypefun
@*/
@@ -1371,7 +1371,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_dup (jit_function_t func, jit_value_t
value)
+ * @deftypefun jit_value_t jit_insn_dup (jit_function_t @var{func},
jit_value_t @var{value})
* This is the same as @code{jit_insn_load}, but the name may better
* reflect how it is used in some front ends.
* @end deftypefun
@@ -1382,12 +1382,12 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_load_small (jit_function_t func,
jit_value_t value)
- * If @code{value} is of type @code{sbyte}, @code{byte}, @code{short},
+ * @deftypefun jit_value_t jit_insn_load_small (jit_function_t @var{func},
jit_value_t @var{value})
+ * If @var{value} is of type @code{sbyte}, @code{byte}, @code{short},
* @code{ushort}, a structure, or a union, then make a copy of it and
- * return the temporary copy. Otherwise return @code{value} as-is.
+ * return the temporary copy. Otherwise return @var{value} as-is.
*
- * This is useful where you want to use @code{value} directly without
+ * This is useful where you want to use @var{value} directly without
* duplicating it first. However, certain types usually cannot
* be operated on directly without first copying them elsewhere.
* This function will do that whenever necessary.
@@ -1419,9 +1419,9 @@
}
/*@
- * @deftypefun void jit_insn_store (jit_function_t func, jit_value_t dest,
jit_value_t value)
- * Store the contents of @code{value} at the location referred to by
- * @code{dest}. The @code{dest} should be a @code{jit_value_t} representing a
+ * @deftypefun void jit_insn_store (jit_function_t @var{func}, jit_value_t
@var{dest}, jit_value_t @var{value})
+ * Store the contents of @var{value} at the location referred to by
+ * @var{dest}. The @var{dest} should be a @code{jit_value_t} representing a
* local variable or temporary. Use @code{jit_insn_store_relative} to store
* to a location referred to by a pointer.
* @end deftypefun
@@ -1567,9 +1567,9 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_load_relative (jit_function_t func,
jit_value_t value, jit_nint offset, jit_type_t type)
- * Load a value of the specified @code{type} from the effective address
- * @code{(value + offset)}, where @code{value} is a pointer.
+ * @deftypefun jit_value_t jit_insn_load_relative (jit_function_t @var{func},
jit_value_t @var{value}, jit_nint @var{offset}, jit_type_t @var{type})
+ * Load a value of the specified @var{type} from the effective address
+ * @code{(@var{value} + @var{offset})}, where @var{value} is a pointer.
* @end deftypefun
@*/
jit_value_t jit_insn_load_relative
@@ -1617,9 +1617,9 @@
}
/*@
- * @deftypefun int jit_insn_store_relative (jit_function_t func, jit_value_t
dest, jit_nint offset, jit_value_t value)
- * Store @code{value} at the effective address @code{(dest + offset)},
- * where @code{dest} is a pointer.
+ * @deftypefun int jit_insn_store_relative (jit_function_t @var{func},
jit_value_t @var{dest}, jit_nint @var{offset}, jit_value_t @var{value})
+ * Store @var{value} at the effective address @code{(@var{dest} +
@var{offset})},
+ * where @var{dest} is a pointer.
* @end deftypefun
@*/
int jit_insn_store_relative
@@ -1684,8 +1684,8 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_add_relative (jit_function_t func,
jit_value_t value, jit_nint offset)
- * Add the constant @code{offset} to the specified pointer @code{value}.
+ * @deftypefun jit_value_t jit_insn_add_relative (jit_function_t @var{func},
jit_value_t @var{value}, jit_nint @var{offset})
+ * Add the constant @var{offset} to the specified pointer @var{value}.
* This is functionally identical to calling @code{jit_insn_add}, but
* the JIT can optimize the code better if it knows that the addition
* is being used to perform a relative adjustment on a pointer.
@@ -1725,10 +1725,10 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_load_elem (jit_function_t func,
jit_value_t base_addr, jit_value_t index, jit_type_t elem_type)
- * Load an element of type @code{elem_type} from position @code{index} within
- * the array starting at @code{base_addr}. The effective address of the
- * array element is @code{base_addr + index * sizeof(elem_type)}.
+ * @deftypefun jit_value_t jit_insn_load_elem (jit_function_t @var{func},
jit_value_t @var{base_addr}, jit_value_t @var{index}, jit_type_t
@var{elem_type})
+ * Load an element of type @var{elem_type} from position @var{index} within
+ * the array starting at @var{base_addr}. The effective address of the
+ * array element is @address@hidden + @var{index} * sizeof(@var{elem_type})}.
* @end deftypefun
@*/
jit_value_t jit_insn_load_elem
@@ -1772,12 +1772,13 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_load_elem_address (jit_function_t func,
jit_value_t base_addr, jit_value_t index, jit_type_t elem_type)
- * Load the effective address of an element of type @code{elem_type} at
- * position @code{index} within the array starting at @code{base_addr}.
- * Essentially, this computes the expression @code{base_addr + index *
- * sizeof(elem_type)}, but may be more efficient than performing the
- * steps with @code{jit_insn_mul} and @code{jit_insn_add}.
+ * @deftypefun jit_value_t jit_insn_load_elem_address (jit_function_t
@var{func}, jit_value_t @var{base_addr}, jit_value_t @var{index}, jit_type_t
@var{elem_type})
+ * Load the effective address of an element of type @var{elem_type} at
+ * position @var{index} within the array starting at @var{base_addr}.
+ * Essentially, this computes the expression
+ * @address@hidden + @var{index} * sizeof(@var{elem_type})}, but
+ * may be more efficient than performing the steps with @code{jit_insn_mul}
+ * and @code{jit_insn_add}.
* @end deftypefun
@*/
jit_value_t jit_insn_load_elem_address
@@ -1793,10 +1794,10 @@
}
/*@
- * @deftypefun int jit_insn_store_elem (jit_function_t func, jit_value_t
base_addr, jit_value_t index, jit_value_t value)
- * Store @code{value} at position @code{index} of the array starting at
- * @code{base_addr}. The effective address of the storage location is
- * @code{base_addr + index * sizeof(jit_value_get_type(value))}.
+ * @deftypefun int jit_insn_store_elem (jit_function_t @var{func}, jit_value_t
@var{base_addr}, jit_value_t @var{index}, jit_value_t @var{value})
+ * Store @var{value} at position @var{index} of the array starting at
+ * @var{base_addr}. The effective address of the storage location is
+ * @address@hidden + @var{index} * sizeof(jit_value_get_type(@var{value}))}.
* @end deftypefun
@*/
int jit_insn_store_elem
@@ -1846,8 +1847,8 @@
}
/*@
- * @deftypefun int jit_insn_check_null (jit_function_t func, jit_value_t value)
- * Check @code{value} to see if it is NULL. If it is, then throw the
+ * @deftypefun int jit_insn_check_null (jit_function_t @var{func}, jit_value_t
@var{value})
+ * Check @var{value} to see if it is NULL. If it is, then throw the
* built-in @code{JIT_RESULT_NULL_REFERENCE} exception.
* @end deftypefun
@*/
@@ -1910,7 +1911,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_add (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_add (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Add two values together and return the result in a new temporary value.
* @end deftypefun
@*/
@@ -1937,7 +1938,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_add_ovf (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_add_ovf (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Add two values together and return the result in a new temporary value.
* Throw an exception if overflow occurs.
* @end deftypefun
@@ -1965,7 +1966,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_sub (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_sub (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Subtract two values and return the result in a new temporary value.
* @end deftypefun
@*/
@@ -1992,7 +1993,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_sub_ovf (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_sub_ovf (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Subtract two values and return the result in a new temporary value.
* Throw an exception if overflow occurs.
* @end deftypefun
@@ -2020,7 +2021,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_mul (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_mul (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Multiply two values and return the result in a new temporary value.
* @end deftypefun
@*/
@@ -2047,7 +2048,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_mul_ovf (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_mul_ovf (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Multiply two values and return the result in a new temporary value.
* Throw an exception if overflow occurs.
* @end deftypefun
@@ -2075,7 +2076,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_div (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_div (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Divide two values and return the quotient in a new temporary value.
* Throws an exception on division by zero or arithmetic error
* (an arithmetic error is one where the minimum possible signed
@@ -2105,7 +2106,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_rem (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_rem (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Divide two values and return the remainder in a new temporary value.
* Throws an exception on division by zero or arithmetic error
* (an arithmetic error is one where the minimum possible signed
@@ -2135,7 +2136,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_rem_ieee (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_rem_ieee (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Divide two values and return the remainder in a new temporary value.
* Throws an exception on division by zero or arithmetic error
* (an arithmetic error is one where the minimum possible signed
@@ -2167,7 +2168,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_neg (jit_function_t func, jit_value_t
value1)
+ * @deftypefun jit_value_t jit_insn_neg (jit_function_t @var{func},
jit_value_t @var{value1})
* Negate a value and return the result in a new temporary value.
* @end deftypefun
@*/
@@ -2239,7 +2240,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_and (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_and (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Bitwise AND two values and return the result in a new temporary value.
* @end deftypefun
@*/
@@ -2264,7 +2265,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_or (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_or (jit_function_t @var{func}, jit_value_t
@var{value1}, jit_value_t @var{value2})
* Bitwise OR two values and return the result in a new temporary value.
* @end deftypefun
@*/
@@ -2289,7 +2290,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_xor (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_xor (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Bitwise XOR two values and return the result in a new temporary value.
* @end deftypefun
@*/
@@ -2314,7 +2315,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_not (jit_function_t func, jit_value_t
value1)
+ * @deftypefun jit_value_t jit_insn_not (jit_function_t @var{func},
jit_value_t @var{value1})
* Bitwise NOT a value and return the result in a new temporary value.
* @end deftypefun
@*/
@@ -2339,7 +2340,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_shl (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_shl (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Perform a bitwise left shift on two values and return the
* result in a new temporary value.
* @end deftypefun
@@ -2365,7 +2366,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_shr (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_shr (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Perform a bitwise right shift on two values and return the
* result in a new temporary value. This performs a signed shift
* on signed operators, and an unsigned shift on unsigned operands.
@@ -2392,7 +2393,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_ushr (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_ushr (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Perform a bitwise right shift on two values and return the
* result in a new temporary value. This performs an unsigned
* shift on both signed and unsigned operands.
@@ -2419,7 +2420,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_sshr (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_sshr (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Perform a bitwise right shift on two values and return the
* result in a new temporary value. This performs an signed
* shift on both signed and unsigned operands.
@@ -2446,7 +2447,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_eq (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_eq (jit_function_t @var{func}, jit_value_t
@var{value1}, jit_value_t @var{value2})
* Compare two values for equality and return the result
* in a new temporary value.
* @end deftypefun
@@ -2474,7 +2475,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_ne (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_ne (jit_function_t @var{func}, jit_value_t
@var{value1}, jit_value_t @var{value2})
* Compare two values for inequality and return the result
* in a new temporary value.
* @end deftypefun
@@ -2502,7 +2503,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_lt (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_lt (jit_function_t @var{func}, jit_value_t
@var{value1}, jit_value_t @var{value2})
* Compare two values for less than and return the result
* in a new temporary value.
* @end deftypefun
@@ -2530,7 +2531,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_le (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_le (jit_function_t @var{func}, jit_value_t
@var{value1}, jit_value_t @var{value2})
* Compare two values for less than or equal and return the result
* in a new temporary value.
* @end deftypefun
@@ -2558,7 +2559,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_gt (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_gt (jit_function_t @var{func}, jit_value_t
@var{value1}, jit_value_t @var{value2})
* Compare two values for greater than and return the result
* in a new temporary value.
* @end deftypefun
@@ -2586,7 +2587,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_ge (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_ge (jit_function_t @var{func}, jit_value_t
@var{value1}, jit_value_t @var{value2})
* Compare two values for greater than or equal and return the result
* in a new temporary value.
* @end deftypefun
@@ -2614,7 +2615,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_cmpl (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_cmpl (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Compare two values, and return a -1, 0, or 1 result. If either
* value is "not a number", then -1 is returned.
* @end deftypefun
@@ -2642,7 +2643,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_cmpg (jit_function_t func, jit_value_t
value1, jit_value_t value2)
+ * @deftypefun jit_value_t jit_insn_cmpg (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
* Compare two values, and return a -1, 0, or 1 result. If either
* value is "not a number", then 1 is returned.
* @end deftypefun
@@ -2670,7 +2671,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_to_bool (jit_function_t func, jit_value_t
value1)
+ * @deftypefun jit_value_t jit_insn_to_bool (jit_function_t @var{func},
jit_value_t @var{value1})
* Convert a value into a boolean 0 or 1 result of type @code{jit_type_int}.
* @end deftypefun
@*/
@@ -2744,7 +2745,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_to_not_bool (jit_function_t func,
jit_value_t value1)
+ * @deftypefun jit_value_t jit_insn_to_not_bool (jit_function_t @var{func},
jit_value_t @var{value1})
* Convert a value into a boolean 1 or 0 result of type @code{jit_type_int}
* (i.e. the inverse of @code{jit_insn_to_bool}).
* @end deftypefun
@@ -2879,25 +2880,25 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_acos (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_asin (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_atan (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_atan2 (jit_function_t func, jit_value_t
value1, jit_value_t value2)
- * @deftypefunx jit_value_t jit_insn_ceil (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_cos (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_cosh (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_exp (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_floor (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_log (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_log10 (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_pow (jit_function_t func, jit_value_t
value1, jit_value_t value2)
- * @deftypefunx jit_value_t jit_insn_rint (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_round (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_sin (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_sinh (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_sqrt (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_tan (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_tanh (jit_function_t func, jit_value_t
value1)
+ * @deftypefun jit_value_t jit_insn_acos (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_asin (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_atan (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_atan2 (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
+ * @deftypefunx jit_value_t jit_insn_ceil (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_cos (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_cosh (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_exp (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_floor (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_log (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_log10 (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_pow (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
+ * @deftypefunx jit_value_t jit_insn_rint (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_round (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_sin (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_sinh (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_sqrt (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_tan (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_tanh (jit_function_t @var{func},
jit_value_t @var{value1})
* Apply a mathematical function to floating-point arguments.
* @end deftypefun
@*/
@@ -3246,9 +3247,9 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_is_nan (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_is_finite (jit_function_t func,
jit_value_t value1)
- * @deftypefunx jit_value_t jit_insn_is_inf (jit_function_t func, jit_value_t
value1)
+ * @deftypefun jit_value_t jit_insn_is_nan (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_is_finite (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_is_inf (jit_function_t @var{func},
jit_value_t @var{value1})
* Test a floating point value for not a number, finite, or infinity.
* @end deftypefun
@*/
@@ -3307,10 +3308,10 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_abs (jit_function_t func, jit_value_t
value1)
- * @deftypefunx jit_value_t jit_insn_min (jit_function_t func, jit_value_t
value1, jit_value_t value2)
- * @deftypefunx jit_value_t jit_insn_max (jit_function_t func, jit_value_t
value1, jit_value_t value2)
- * @deftypefunx jit_value_t jit_insn_sign (jit_function_t func, jit_value_t
value1)
+ * @deftypefun jit_value_t jit_insn_abs (jit_function_t @var{func},
jit_value_t @var{value1})
+ * @deftypefunx jit_value_t jit_insn_min (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
+ * @deftypefunx jit_value_t jit_insn_max (jit_function_t @var{func},
jit_value_t @var{value1}, jit_value_t @var{value2})
+ * @deftypefunx jit_value_t jit_insn_sign (jit_function_t @var{func},
jit_value_t @var{value1})
* Calculate the absolute value, minimum, maximum, or sign of the
* specified values.
* @end deftypefun
@@ -3509,7 +3510,7 @@
}
/*@
- * @deftypefun int jit_insn_branch (jit_function_t func, {jit_label_t *} label)
+ * @deftypefun int jit_insn_branch (jit_function_t @var{func}, jit_label_t
address@hidden)
* Terminate the current block by branching unconditionally
* to a specific label. Returns zero if out of memory.
* @end deftypefun
@@ -3546,11 +3547,11 @@
}
/*@
- * @deftypefun int jit_insn_branch_if (jit_function_t func, jit_value_t value,
{jit_label_t *} label)
+ * @deftypefun int jit_insn_branch_if (jit_function_t @var{func}, jit_value_t
@var{value}, jit_label_t address@hidden)
* Terminate the current block by branching to a specific label if
* the specified value is non-zero. Returns zero if out of memory.
*
- * If @code{value} refers to a conditional expression that was created
+ * If @var{value} refers to a conditional expression that was created
* by @code{jit_insn_eq}, @code{jit_insn_ne}, etc, then the conditional
* expression will be replaced by an appropriate conditional branch
* instruction.
@@ -3746,11 +3747,11 @@
}
/*@
- * @deftypefun int jit_insn_branch_if_not (jit_function_t func, jit_value_t
value, {jit_label_t *} label)
+ * @deftypefun int jit_insn_branch_if_not (jit_function_t @var{func},
jit_value_t @var{value}, jit_label_t address@hidden)
* Terminate the current block by branching to a specific label if
* the specified value is zero. Returns zero if out of memory.
*
- * If @code{value} refers to a conditional expression that was created
+ * If @var{value} refers to a conditional expression that was created
* by @code{jit_insn_eq}, @code{jit_insn_ne}, etc, then the conditional
* expression will be replaced by an appropriate conditional branch
* instruction.
@@ -3946,8 +3947,8 @@
}
/*@
- * @deftypefun int jit_insn_jump_table (jit_function_t func, jit_value_t
value, {jit_label_t *} labels, unsigned int num_labels)
- * Branch to a label from the @code{labels} table. The @code{value} is the
+ * @deftypefun int jit_insn_jump_table (jit_function_t @var{func}, jit_value_t
@var{value}, jit_label_t address@hidden, unsigned int @var{num_labels})
+ * Branch to a label from the @var{labels} table. The @var{value} is the
* index of the label. It is allowed to have identical labels in the table.
* If an entry in the table has @code{jit_label_undefined} value then it is
* replaced with a newly allocated label.
@@ -4049,7 +4050,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_address_of (jit_function_t func,
jit_value_t value1)
+ * @deftypefun jit_value_t jit_insn_address_of (jit_function_t @var{func},
jit_value_t @var{value1})
* Get the address of a value into a new temporary.
* @end deftypefun
@*/
@@ -4077,8 +4078,8 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_address_of_label (jit_function_t func,
{jit_label_t *} label)
- * Get the address of @code{label} into a new temporary. This is typically
+ * @deftypefun jit_value_t jit_insn_address_of_label (jit_function_t
@var{func}, jit_label_t address@hidden)
+ * Get the address of @var{label} into a new temporary. This is typically
* used for exception handling, to track where in a function an exception
* was actually thrown.
* @end deftypefun
@@ -4224,7 +4225,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_convert (jit_function_t func, jit_value_t
value, jit_type_t type, int overflow_check)
+ * @deftypefun jit_value_t jit_insn_convert (jit_function_t @var{func},
jit_value_t @var{value}, jit_type_t @var{type}, int @var{overflow_check})
* Convert the contents of a value into a new type, with optional
* overflow checking.
* @end deftypefun
@@ -5353,16 +5354,16 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_call (jit_function_t func, {const char *}
name, jit_function_t jit_func, jit_type_t signature, {jit_value_t *} args,
{unsigned int} num_args, int flags)
- * Call the function @code{jit_func}, which may or may not be translated yet.
- * The @code{name} is for diagnostic purposes only, and can be NULL.
+ * @deftypefun jit_value_t jit_insn_call (jit_function_t @var{func}, const
char address@hidden, jit_function_t @var{jit_func}, jit_type_t @var{signature},
jit_value_t address@hidden, unsigned int @var{num_args}, int @var{flags})
+ * Call the function @var{jit_func}, which may or may not be translated yet.
+ * The @var{name} is for diagnostic purposes only, and can be NULL.
*
- * If @code{signature} is NULL, then the actual signature of @code{jit_func}
+ * If @var{signature} is NULL, then the actual signature of @var{jit_func}
* is used in its place. This is the usual case. However, if the function
* takes a variable number of arguments, then you may need to construct
* an explicit signature for the non-fixed argument values.
*
- * The @code{flags} parameter specifies additional information about the
+ * The @var{flags} parameter specifies additional information about the
* type of call to perform:
*
* @table @code
@@ -5385,7 +5386,7 @@
* to local variables.
* @end table
*
- * If @code{jit_func} has already been compiled, then @code{jit_insn_call}
+ * If @var{jit_func} has already been compiled, then @code{jit_insn_call}
* may be able to intuit some of the above flags for itself. Otherwise
* it is up to the caller to determine when the flags may be appropriate.
* @end deftypefun
@@ -5596,7 +5597,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_call_indirect (jit_function_t func,
jit_value_t value, jit_type_t signature, {jit_value_t *} args, {unsigned int}
num_args, int flags)
+ * @deftypefun jit_value_t jit_insn_call_indirect (jit_function_t @var{func},
jit_value_t @var{value}, jit_type_t @var{signature}, jit_value_t
address@hidden, unsigned int @var{num_args}, int @var{flags})
* Call a function via an indirect pointer.
* @end deftypefun
@*/
@@ -5737,9 +5738,9 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_call_indirect_vtable (jit_function_t func,
jit_value_t value, jit_type_t signature, {jit_value_t *} args, {unsigned int}
num_args, int flags)
+ * @deftypefun jit_value_t jit_insn_call_indirect_vtable (jit_function_t
@var{func}, jit_value_t @var{value}, jit_type_t @var{signature}, jit_value_t
address@hidden, unsigned int @var{num_args}, int @var{flags})
* Call a function via an indirect pointer. This version differs from
- * @code{jit_insn_call_indirect} in that we assume that @code{value}
+ * @code{jit_insn_call_indirect} in that we assume that @var{value}
* contains a pointer that resulted from calling
* @code{jit_function_to_vtable_pointer}. Indirect vtable pointer
* calls may be more efficient on some platforms than regular indirect calls.
@@ -5873,9 +5874,9 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_call_native (jit_function_t func, {const
char *} name, {void *} native_func, jit_type_t signature, {jit_value_t *} args,
{unsigned int} num_args, int exception_return, int flags)
+ * @deftypefun jit_value_t jit_insn_call_native (jit_function_t @var{func},
const char address@hidden, void address@hidden, jit_type_t @var{signature},
jit_value_t address@hidden, unsigned int @var{num_args}, int
@var{exception_return}, int @var{flags})
* Output an instruction that calls an external native function.
- * The @code{name} is for diagnostic purposes only, and can be NULL.
+ * The @var{name} is for diagnostic purposes only, and can be NULL.
* @end deftypefun
@*/
jit_value_t jit_insn_call_native
@@ -6012,7 +6013,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_call_intrinsic (jit_function_t func,
{const char *} name, {void *} intrinsic_func, {const jit_intrinsic_descr_t *}
descriptor, jit_value_t arg1, jit_value_t arg2)
+ * @deftypefun jit_value_t jit_insn_call_intrinsic (jit_function_t @var{func},
const char address@hidden, void address@hidden, const jit_intrinsic_descr_t
address@hidden, jit_value_t @var{arg1}, jit_value_t @var{arg2})
* Output an instruction that calls an intrinsic function. The descriptor
* contains the following fields:
*
@@ -6036,7 +6037,7 @@
* If the constant computation will result in an exception, then
* code is output to cause the exception at runtime.
*
- * The @code{name} is for diagnostic purposes only, and can be NULL.
+ * The @var{name} is for diagnostic purposes only, and can be NULL.
* @end deftypefun
@*/
jit_value_t jit_insn_call_intrinsic
@@ -6217,9 +6218,9 @@
}
/*@
- * @deftypefun int jit_insn_incoming_reg (jit_function_t func, jit_value_t
value, int reg)
- * Output an instruction that notes that the contents of @code{value}
- * can be found in the register @code{reg} at this point in the code.
+ * @deftypefun int jit_insn_incoming_reg (jit_function_t @var{func},
jit_value_t @var{value}, int @var{reg})
+ * Output an instruction that notes that the contents of @var{value}
+ * can be found in the register @var{reg} at this point in the code.
*
* You normally wouldn't call this yourself - it is used internally
* by the CPU back ends to set up the function's entry frame and the
@@ -6238,9 +6239,9 @@
}
/*@
- * @deftypefun int jit_insn_incoming_frame_posn (jit_function_t func,
jit_value_t value, jit_nint frame_offset)
- * Output an instruction that notes that the contents of @code{value}
- * can be found in the stack frame at @code{frame_offset} at this point
+ * @deftypefun int jit_insn_incoming_frame_posn (jit_function_t @var{func},
jit_value_t @var{value}, jit_nint @var{frame_offset})
+ * Output an instruction that notes that the contents of @var{value}
+ * can be found in the stack frame at @var{frame_offset} at this point
* in the code.
*
* You normally wouldn't call this yourself - it is used internally
@@ -6256,9 +6257,9 @@
}
/*@
- * @deftypefun int jit_insn_outgoing_reg (jit_function_t func, jit_value_t
value, int reg)
- * Output an instruction that copies the contents of @code{value}
- * into the register @code{reg} at this point in the code. This is
+ * @deftypefun int jit_insn_outgoing_reg (jit_function_t @var{func},
jit_value_t @var{value}, int @var{reg})
+ * Output an instruction that copies the contents of @var{value}
+ * into the register @var{reg} at this point in the code. This is
* typically used just before making an outgoing subroutine call.
*
* You normally wouldn't call this yourself - it is used internally
@@ -6273,9 +6274,9 @@
}
/*@
- * @deftypefun int jit_insn_outgoing_frame_posn (jit_function_t func,
jit_value_t value, jit_nint frame_offset)
- * Output an instruction that notes that the contents of @code{value}
- * should be stored in the stack frame at @code{frame_offset} at this point
+ * @deftypefun int jit_insn_outgoing_frame_posn (jit_function_t @var{func},
jit_value_t @var{value}, jit_nint @var{frame_offset})
+ * Output an instruction that notes that the contents of @var{value}
+ * should be stored in the stack frame at @var{frame_offset} at this point
* in the code.
*
* You normally wouldn't call this yourself - it is used internally
@@ -6291,9 +6292,9 @@
}
/*@
- * @deftypefun int jit_insn_return_reg (jit_function_t func, jit_value_t
value, int reg)
- * Output an instruction that notes that the contents of @code{value}
- * can be found in the register @code{reg} at this point in the code.
+ * @deftypefun int jit_insn_return_reg (jit_function_t @var{func}, jit_value_t
@var{value}, int @var{reg})
+ * Output an instruction that notes that the contents of @var{value}
+ * can be found in the register @var{reg} at this point in the code.
* This is similar to @code{jit_insn_incoming_reg}, except that it
* refers to return values, not parameter values.
*
@@ -6309,13 +6310,13 @@
}
/*@
- * @deftypefun int jit_insn_setup_for_nested (jit_function_t func, int
nested_level, int reg)
+ * @deftypefun int jit_insn_setup_for_nested (jit_function_t @var{func}, int
@var{nested_level}, int @var{reg})
* Output an instruction to set up for a nested function call.
- * The @code{nested_level} value will be -1 to call a child, zero to call a
- * sibling of @code{func}, 1 to call a sibling of the parent, 2 to call
- * a sibling of the grandparent, etc. If @code{reg} is not -1, then
+ * The @var{nested_level} value will be -1 to call a child, zero to call a
+ * sibling of @var{func}, 1 to call a sibling of the parent, 2 to call
+ * a sibling of the grandparent, etc. If @var{reg} is not -1, then
* it indicates the register to receive the parent frame information.
- * If @code{reg} is -1, then the frame information will be pushed on the stack.
+ * If @var{reg} is -1, then the frame information will be pushed on the stack.
*
* You normally wouldn't call this yourself - it is used internally by the
* CPU back ends to set up the parameters for a nested subroutine call.
@@ -6342,7 +6343,7 @@
}
/*@
- * @deftypefun int jit_insn_flush_struct (jit_function_t func, jit_value_t
value)
+ * @deftypefun int jit_insn_flush_struct (jit_function_t @var{func},
jit_value_t @var{value})
* Flush a small structure return value out of registers and back
* into the local variable frame. You normally wouldn't call this
* yourself - it is used internally by the CPU back ends to handle
@@ -6359,11 +6360,11 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_import (jit_function_t func, jit_value_t
value)
- * Import @code{value} from an outer nested scope into @code{func}. Returns
+ * @deftypefun jit_value_t jit_insn_import (jit_function_t @var{func},
jit_value_t @var{value})
+ * Import @var{value} from an outer nested scope into @var{func}. Returns
* the effective address of the value for local access via a pointer.
* Returns NULL if out of memory or the value is not accessible via a
- * parent, grandparent, or other ancestor of @code{func}.
+ * parent, grandparent, or other ancestor of @var{func}.
* @end deftypefun
@*/
jit_value_t jit_insn_import(jit_function_t func, jit_value_t value)
@@ -6408,7 +6409,7 @@
}
/*@
- * @deftypefun int jit_insn_push (jit_function_t func, jit_value_t value)
+ * @deftypefun int jit_insn_push (jit_function_t @var{func}, jit_value_t
@var{value})
* Push a value onto the function call stack, in preparation for a call.
* You normally wouldn't call this yourself - it is used internally
* by the CPU back ends to set up the stack for a subroutine call.
@@ -6480,18 +6481,17 @@
}
/*@
- * @deftypefun int jit_insn_push_ptr (jit_function_t func, jit_value_t value,
jit_type_t type)
- * Push @code{*value} onto the function call stack, in preparation for a call.
+ * @deftypefun int jit_insn_push_ptr (jit_function_t @var{func}, jit_value_t
@var{value}, jit_type_t @var{type})
+ * Push @address@hidden onto the function call stack, in preparation for a
call.
* This is normally used for returning @code{struct} and @code{union}
* values where you have the effective address of the structure, rather
- * than the structure's contents, in @code{value}.
+ * than the structure's contents, in @var{value}.
*
* You normally wouldn't call this yourself - it is used internally
* by the CPU back ends to set up the stack for a subroutine call.
* @end deftypefun
@*/
-int jit_insn_push_ptr
- (jit_function_t func, jit_value_t value, jit_type_t type)
+int jit_insn_push_ptr(jit_function_t func, jit_value_t value, jit_type_t type)
{
if(!value || !type)
{
@@ -6521,9 +6521,9 @@
}
/*@
- * @deftypefun int jit_insn_set_param (jit_function_t func, jit_value_t value,
jit_nint offset)
- * Set the parameter slot at @code{offset} in the outgoing parameter area
- * to @code{value}. This may be used instead of @code{jit_insn_push}
+ * @deftypefun int jit_insn_set_param (jit_function_t @var{func}, jit_value_t
@var{value}, jit_nint @var{offset})
+ * Set the parameter slot at @var{offset} in the outgoing parameter area
+ * to @var{value}. This may be used instead of @code{jit_insn_push}
* if it is more efficient to store directly to the stack than to push.
* The outgoing parameter area is allocated within the frame when
* the function is first entered.
@@ -6610,9 +6610,9 @@
}
/*@
- * @deftypefun int jit_insn_set_param_ptr (jit_function_t func, jit_value_t
value, jit_type_t type, jit_nint offset)
+ * @deftypefun int jit_insn_set_param_ptr (jit_function_t @var{func},
jit_value_t @var{value}, jit_type_t @var{type}, jit_nint @var{offset})
* Same as @code{jit_insn_set_param_ptr}, except that the parameter is
- * at @code{*value}.
+ * at @address@hidden
* @end deftypefun
@*/
int jit_insn_set_param_ptr
@@ -6648,7 +6648,7 @@
}
/*@
- * @deftypefun int jit_insn_push_return_area_ptr (jit_function_t func)
+ * @deftypefun int jit_insn_push_return_area_ptr (jit_function_t @var{func})
* Push the interpreter's return area pointer onto the stack.
* You normally wouldn't call this yourself - it is used internally
* by the CPU back ends to set up the stack for a subroutine call.
@@ -6660,8 +6660,8 @@
}
/*@
- * @deftypefun int jit_insn_pop_stack (jit_function_t func, jit_nint num_items)
- * Pop @code{num_items} items from the function call stack. You normally
+ * @deftypefun int jit_insn_pop_stack (jit_function_t @var{func}, jit_nint
@var{num_items})
+ * Pop @var{num_items} items from the function call stack. You normally
* wouldn't call this yourself - it is used by CPU back ends to clean up
* the stack after calling a subroutine. The size of an item is specific
* to the back end (it could be bytes, words, or some other measurement).
@@ -6675,7 +6675,7 @@
}
/*@
- * @deftypefun int jit_insn_defer_pop_stack (jit_function_t func, jit_nint
num_items)
+ * @deftypefun int jit_insn_defer_pop_stack (jit_function_t @var{func},
jit_nint @var{num_items})
* This is similar to @code{jit_insn_pop_stack}, except that it tries to
* defer the pop as long as possible. Multiple subroutine calls may
* result in parameters collecting up on the stack, and only being popped
@@ -6694,9 +6694,9 @@
}
/*@
- * @deftypefun int jit_insn_flush_defer_pop (jit_function_t func, jit_nint
num_items)
+ * @deftypefun int jit_insn_flush_defer_pop (jit_function_t @var{func},
jit_nint @var{num_items})
* Flush any deferred items that were scheduled for popping by
- * @code{jit_insn_defer_pop_stack} if there are @code{num_items}
+ * @code{jit_insn_defer_pop_stack} if there are @var{num_items}
* or more items scheduled. You normally wouldn't call this
* yourself - it is used by CPU back ends to clean up the stack just
* prior to a subroutine call when too many items have collected up.
@@ -6721,9 +6721,9 @@
}
/*@
- * @deftypefun int jit_insn_return (jit_function_t func, jit_value_t value)
- * Output an instruction to return @code{value} as the function's result.
- * If @code{value} is NULL, then the function is assumed to return
+ * @deftypefun int jit_insn_return (jit_function_t @var{func}, jit_value_t
@var{value})
+ * Output an instruction to return @var{value} as the function's result.
+ * If @var{value} is NULL, then the function is assumed to return
* @code{void}. If the function returns a structure, this will copy
* the value into the memory at the structure return address.
* @end deftypefun
@@ -6890,11 +6890,11 @@
}
/*@
- * @deftypefun int jit_insn_return_ptr (jit_function_t func, jit_value_t
value, jit_type_t type)
- * Output an instruction to return @code{*value} as the function's result.
+ * @deftypefun int jit_insn_return_ptr (jit_function_t @var{func}, jit_value_t
@var{value}, jit_type_t @var{type})
+ * Output an instruction to return @address@hidden as the function's result.
* This is normally used for returning @code{struct} and @code{union}
* values where you have the effective address of the structure, rather
- * than the structure's contents, in @code{value}.
+ * than the structure's contents, in @var{value}.
* @end deftypefun
@*/
int jit_insn_return_ptr
@@ -6993,7 +6993,7 @@
}
/*@
- * @deftypefun int jit_insn_default_return (jit_function_t func)
+ * @deftypefun int jit_insn_default_return (jit_function_t @var{func})
* Add an instruction to return a default value if control reaches this point.
* This is typically used at the end of a function to ensure that all paths
* return to the caller. Returns zero if out of memory, 1 if a default
@@ -7024,8 +7024,8 @@
}
/*@
- * @deftypefun int jit_insn_throw (jit_function_t func, jit_value_t value)
- * Throw a pointer @code{value} as an exception object. This can also
+ * @deftypefun int jit_insn_throw (jit_function_t @var{func}, jit_value_t
@var{value})
+ * Throw a pointer @var{value} as an exception object. This can also
* be used to "rethrow" an object from a catch handler that is not
* interested in handling the exception.
* @end deftypefun
@@ -7047,7 +7047,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_get_call_stack (jit_function_t func)
+ * @deftypefun jit_value_t jit_insn_get_call_stack (jit_function_t @var{func})
* Get an object that represents the current position in the code,
* and all of the functions that are currently on the call stack.
* This is equivalent to calling @code{jit_exception_get_stack_trace},
@@ -7079,7 +7079,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_thrown_exception (jit_function_t func)
+ * @deftypefun jit_value_t jit_insn_thrown_exception (jit_function_t
@var{func})
* Get the value that holds the most recent thrown exception. This is
* typically used in @code{catch} clauses.
* @end deftypefun
@@ -7333,8 +7333,8 @@
}
/*@
- * @deftypefun int jit_insn_uses_catcher (jit_function_t func)
- * Notify the function building process that @code{func} contains
+ * @deftypefun int jit_insn_uses_catcher (jit_function_t @var{func})
+ * Notify the function building process that @var{func} contains
* some form of @code{catch} clause for catching exceptions. This must
* be called before any instruction that is covered by a @code{try},
* ideally at the start of the function output process.
@@ -7357,8 +7357,8 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_start_catcher (jit_function_t func)
- * Start the catcher block for @code{func}. There should be exactly one
+ * @deftypefun jit_value_t jit_insn_start_catcher (jit_function_t @var{func})
+ * Start the catcher block for @var{func}. There should be exactly one
* catcher block for any function that involves a @code{try}. All
* exceptions that are thrown within the function will cause control
* to jump to this point. Returns a value that holds the exception
@@ -7408,9 +7408,9 @@
}
/*@
- * @deftypefun int jit_insn_branch_if_pc_not_in_range (jit_function_t func,
jit_label_t start_label, jit_label_t end_label, {jit_label_t *} label)
- * Branch to @code{label} if the program counter where an exception occurred
- * does not fall between @code{start_label} and @code{end_label}.
+ * @deftypefun int jit_insn_branch_if_pc_not_in_range (jit_function_t
@var{func}, jit_label_t @var{start_label}, jit_label_t @var{end_label},
jit_label_t address@hidden)
+ * Branch to @var{label} if the program counter where an exception occurred
+ * does not fall between @var{start_label} and @var{end_label}.
* @end deftypefun
@*/
int jit_insn_branch_if_pc_not_in_range
@@ -7473,7 +7473,7 @@
}
/*@
- * @deftypefun int jit_insn_rethrow_unhandled (jit_function_t func)
+ * @deftypefun int jit_insn_rethrow_unhandled (jit_function_t @var{func})
* Rethrow the current exception because it cannot be handled by
* any of the @code{catch} blocks in the current function.
*
@@ -7551,7 +7551,7 @@
}
/*@
- * @deftypefun int jit_insn_start_finally (jit_function_t func, {jit_label_t
*} finally_label)
+ * @deftypefun int jit_insn_start_finally (jit_function_t @var{func},
jit_label_t address@hidden)
* Start a @code{finally} clause.
* @end deftypefun
@*/
@@ -7565,7 +7565,7 @@
}
/*@
- * @deftypefun int jit_insn_return_from_finally (jit_function_t func)
+ * @deftypefun int jit_insn_return_from_finally (jit_function_t @var{func})
* Return from the @code{finally} clause to where it was called from.
* This is usually the last instruction in a @code{finally} clause.
* @end deftypefun
@@ -7592,7 +7592,7 @@
}
/*@
- * @deftypefun int jit_insn_call_finally (jit_function_t func, {jit_label_t *}
finally_label)
+ * @deftypefun int jit_insn_call_finally (jit_function_t @var{func},
jit_label_t address@hidden)
* Call a @code{finally} clause.
* @end deftypefun
@*/
@@ -7635,7 +7635,7 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_start_filter (jit_function_t func,
{jit_label_t *} label, jit_type_t type)
+ * @deftypefun jit_value_t jit_insn_start_filter (jit_function_t @var{func},
jit_label_t address@hidden, jit_type_t @var{type})
* Define the start of a filter. Filters are embedded subroutines within
* functions that are used to filter exceptions in @code{catch} blocks.
*
@@ -7644,7 +7644,7 @@
* access to the local variables of the function, and can use any of
* them in the filtering process.
*
- * This function returns a temporary value of the specified @code{type},
+ * This function returns a temporary value of the specified @var{type},
* indicating the parameter that is supplied to the filter.
* @end deftypefun
@*/
@@ -7662,7 +7662,7 @@
}
/*@
- * @deftypefun int jit_insn_return_from_filter (jit_function_t func,
jit_value_t value)
+ * @deftypefun int jit_insn_return_from_filter (jit_function_t @var{func},
jit_value_t @var{value})
* Return from a filter subroutine with the specified @code{value} as
* its result.
* @end deftypefun
@@ -7689,10 +7689,10 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_call_filter (jit_function_t func,
{jit_label_t *} label, jit_value_t value, jit_type_t type)
- * Call the filter subroutine at @code{label}, passing it @code{value} as
+ * @deftypefun jit_value_t jit_insn_call_filter (jit_function_t @var{func},
jit_label_t address@hidden, jit_value_t @var{value}, jit_type_t @var{type})
+ * Call the filter subroutine at @var{label}, passing it @var{value} as
* its argument. This function returns a value of the specified
- * @code{type}, indicating the filter's result.
+ * @var{type}, indicating the filter's result.
* @end deftypefun
@*/
jit_value_t jit_insn_call_filter
@@ -7744,8 +7744,8 @@
}
/*@
- * @deftypefun int jit_insn_memcpy (jit_function_t func, jit_value_t dest,
jit_value_t src, jit_value_t size)
- * Copy the @code{size} bytes of memory at @code{src} to @code{dest}.
+ * @deftypefun int jit_insn_memcpy (jit_function_t @var{func}, jit_value_t
@var{dest}, jit_value_t @var{src}, jit_value_t @var{size})
+ * Copy the @var{size} bytes of memory at @var{src} to @var{dest}.
* It is assumed that the source and destination do not overlap.
* @end deftypefun
@*/
@@ -7758,8 +7758,8 @@
}
/*@
- * @deftypefun int jit_insn_memmove (jit_function_t func, jit_value_t dest,
jit_value_t src, jit_value_t size)
- * Copy the @code{size} bytes of memory at @code{src} to @code{dest}.
+ * @deftypefun int jit_insn_memmove (jit_function_t @var{func}, jit_value_t
@var{dest}, jit_value_t @var{src}, jit_value_t @var{size})
+ * Copy the @var{size} bytes of memory at @var{src} to @var{dest}.
* This is save to use if the source and destination overlap.
* @end deftypefun
@*/
@@ -7772,8 +7772,8 @@
}
/*@
- * @deftypefun int jit_insn_memset (jit_function_t func, jit_value_t dest,
jit_value_t value, jit_value_t size)
- * Set the @code{size} bytes at @code{dest} to @code{value}.
+ * @deftypefun int jit_insn_memset (jit_function_t @var{func}, jit_value_t
@var{dest}, jit_value_t @var{value}, jit_value_t @var{size})
+ * Set the @var{size} bytes at @var{dest} to @var{value}.
* @end deftypefun
@*/
int jit_insn_memset
@@ -7786,8 +7786,8 @@
}
/*@
- * @deftypefun jit_value_t jit_insn_alloca (jit_function_t func, jit_value_t
size)
- * Allocate @code{size} bytes of memory from the stack.
+ * @deftypefun jit_value_t jit_insn_alloca (jit_function_t @var{func},
jit_value_t @var{size})
+ * Allocate @var{size} bytes of memory from the stack.
* @end deftypefun
@*/
jit_value_t jit_insn_alloca(jit_function_t func, jit_value_t size)
@@ -7864,9 +7864,9 @@
}
/*@
- * @deftypefun int jit_insn_move_blocks_to_end (jit_function_t func,
jit_label_t from_label, jit_label_t to_label)
- * Move all of the blocks between @code{from_label} (inclusive) and
- * @code{to_label} (exclusive) to the end of the current function.
+ * @deftypefun int jit_insn_move_blocks_to_end (jit_function_t @var{func},
jit_label_t @var{from_label}, jit_label_t @var{to_label})
+ * Move all of the blocks between @var{from_label} (inclusive) and
+ * @var{to_label} (exclusive) to the end of the current function.
* This is typically used to move the expression in a @code{while}
* loop to the end of the body, where it can be executed more
* efficiently.
@@ -7911,9 +7911,9 @@
}
/*@
- * @deftypefun int jit_insn_move_blocks_to_start (jit_function_t func,
jit_label_t from_label, jit_label_t to_label)
- * Move all of the blocks between @code{from_label} (inclusive) and
- * @code{to_label} (exclusive) to the start of the current function.
+ * @deftypefun int jit_insn_move_blocks_to_start (jit_function_t @var{func},
jit_label_t @var{from_label}, jit_label_t @var{to_label})
+ * Move all of the blocks between @var{from_label} (inclusive) and
+ * @var{to_label} (exclusive) to the start of the current function.
* This is typically used to move initialization code to the head
* of the function.
* @end deftypefun
@@ -8004,9 +8004,9 @@
}
/*@
- * @deftypefun int jit_insn_mark_offset (jit_function_t func, jit_int offset)
- * Mark the current position in @code{func} as corresponding to the
- * specified bytecode @code{offset}. This value will be returned
+ * @deftypefun int jit_insn_mark_offset (jit_function_t @var{func}, jit_int
@var{offset})
+ * Mark the current position in @var{func} as corresponding to the
+ * specified bytecode @var{offset}. This value will be returned
* by @code{jit_stack_trace_get_offset}, and is useful for associating
* code positions with source line numbers.
* @end deftypefun
@@ -8105,8 +8105,8 @@
}
/*@
- * @deftypefun void jit_insn_iter_init ({jit_insn_iter_t *} iter, jit_block_t
block)
- * Initialize an iterator to point to the first instruction in @code{block}.
+ * @deftypefun void jit_insn_iter_init (jit_insn_iter_t address@hidden,
jit_block_t @var{block})
+ * Initialize an iterator to point to the first instruction in @var{block}.
* @end deftypefun
@*/
void jit_insn_iter_init(jit_insn_iter_t *iter, jit_block_t block)
@@ -8116,8 +8116,8 @@
}
/*@
- * @deftypefun void jit_insn_iter_init_last ({jit_insn_iter_t *} iter,
jit_block_t block)
- * Initialize an iterator to point to the last instruction in @code{block}.
+ * @deftypefun void jit_insn_iter_init_last (jit_insn_iter_t address@hidden,
jit_block_t @var{block})
+ * Initialize an iterator to point to the last instruction in @var{block}.
* @end deftypefun
@*/
void jit_insn_iter_init_last(jit_insn_iter_t *iter, jit_block_t block)
@@ -8127,7 +8127,7 @@
}
/*@
- * @deftypefun jit_insn_t jit_insn_iter_next ({jit_insn_iter_t *} iter)
+ * @deftypefun jit_insn_t jit_insn_iter_next (jit_insn_iter_t address@hidden)
* Get the next instruction in an iterator's block. Returns NULL
* when there are no further instructions in the block.
* @end deftypefun
@@ -8145,7 +8145,7 @@
}
/*@
- * @deftypefun jit_insn_t jit_insn_iter_previous ({jit_insn_iter_t *} iter)
+ * @deftypefun jit_insn_t jit_insn_iter_previous (jit_insn_iter_t
address@hidden)
* Get the previous instruction in an iterator's block. Returns NULL
* when there are no further instructions in the block.
* @end deftypefun
Index: jit/jit-intrinsic.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-intrinsic.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -b -r1.4 -r1.5
--- jit/jit-intrinsic.c 26 May 2007 14:13:23 -0000 1.4
+++ jit/jit-intrinsic.c 22 Jan 2008 06:09:08 -0000 1.5
@@ -92,54 +92,54 @@
#endif
/*@
- * @deftypefun jit_int jit_int_add (jit_int value1, jit_int value2)
- * @deftypefunx jit_int jit_int_sub (jit_int value1, jit_int value2)
- * @deftypefunx jit_int jit_int_mul (jit_int value1, jit_int value2)
- * @deftypefunx jit_int jit_int_neg (jit_int value1)
- * @deftypefunx jit_int jit_int_and (jit_int value1, jit_int value2)
- * @deftypefunx jit_int jit_int_or (jit_int value1, jit_int value2)
- * @deftypefunx jit_int jit_int_xor (jit_int value1, jit_int value2)
- * @deftypefunx jit_int jit_int_not (jit_int value1)
- * @deftypefunx jit_int jit_int_not (jit_int value1)
- * @deftypefunx jit_int jit_int_shl (jit_int value1, jit_uint value2)
- * @deftypefunx jit_int jit_int_shr (jit_int value1, jit_uint value2)
+ * @deftypefun jit_int jit_int_add (jit_int @var{value1}, jit_int @var{value2})
+ * @deftypefunx jit_int jit_int_sub (jit_int @var{value1}, jit_int
@var{value2})
+ * @deftypefunx jit_int jit_int_mul (jit_int @var{value1}, jit_int
@var{value2})
+ * @deftypefunx jit_int jit_int_neg (jit_int @var{value1})
+ * @deftypefunx jit_int jit_int_and (jit_int @var{value1}, jit_int
@var{value2})
+ * @deftypefunx jit_int jit_int_or (jit_int @var{value1}, jit_int @var{value2})
+ * @deftypefunx jit_int jit_int_xor (jit_int @var{value1}, jit_int
@var{value2})
+ * @deftypefunx jit_int jit_int_not (jit_int @var{value1})
+ * @deftypefunx jit_int jit_int_not (jit_int @var{value1})
+ * @deftypefunx jit_int jit_int_shl (jit_int @var{value1}, jit_uint
@var{value2})
+ * @deftypefunx jit_int jit_int_shr (jit_int @var{value1}, jit_uint
@var{value2})
* Perform an arithmetic operation on signed 32-bit integers.
* @end deftypefun
*
- * @deftypefun jit_int jit_int_add_ovf ({jit_int *} result, jit_int value1,
jit_int value2)
- * @deftypefunx jit_int jit_int_sub_ovf ({jit_int *} result, jit_int value1,
jit_int value2)
- * @deftypefunx jit_int jit_int_mul_ovf ({jit_int *} result, jit_int value1,
jit_int value2)
+ * @deftypefun jit_int jit_int_add_ovf (jit_int address@hidden, jit_int
@var{value1}, jit_int @var{value2})
+ * @deftypefunx jit_int jit_int_sub_ovf (jit_int address@hidden, jit_int
@var{value1}, jit_int @var{value2})
+ * @deftypefunx jit_int jit_int_mul_ovf (jit_int address@hidden, jit_int
@var{value1}, jit_int @var{value2})
* Perform an arithmetic operation on two signed 32-bit integers,
* with overflow checking. Returns @code{JIT_RESULT_OK}
* or @code{JIT_RESULT_OVERFLOW}.
* @end deftypefun
*
- * @deftypefun jit_int jit_int_div_ovf ({jit_int *} result, jit_int value1,
jit_int value2)
- * @deftypefunx jit_int jit_int_rem_ovf ({jit_int *} result, jit_int value1,
jit_int value2)
+ * @deftypefun jit_int jit_int_div_ovf (jit_int address@hidden, jit_int
@var{value1}, jit_int @var{value2})
+ * @deftypefunx jit_int jit_int_rem_ovf (jit_int address@hidden, jit_int
@var{value1}, jit_int @var{value2})
* Perform a division or remainder operation on two signed 32-bit integers.
* Returns @code{JIT_RESULT_OK}, @code{JIT_RESULT_DIVISION_BY_ZERO},
* or @code{JIT_RESULT_ARITHMETIC}.
* @end deftypefun
*
- * @deftypefun jit_int jit_int_eq (jit_int value1, jit_int value2)
- * @deftypefunx jit_int jit_int_ne (jit_int value1, jit_int value2)
- * @deftypefunx jit_int jit_int_lt (jit_int value1, jit_int value2)
- * @deftypefunx jit_int jit_int_le (jit_int value1, jit_int value2)
- * @deftypefunx jit_int jit_int_gt (jit_int value1, jit_int value2)
- * @deftypefunx jit_int jit_int_ge (jit_int value1, jit_int value2)
+ * @deftypefun jit_int jit_int_eq (jit_int @var{value1}, jit_int @var{value2})
+ * @deftypefunx jit_int jit_int_ne (jit_int @var{value1}, jit_int @var{value2})
+ * @deftypefunx jit_int jit_int_lt (jit_int @var{value1}, jit_int @var{value2})
+ * @deftypefunx jit_int jit_int_le (jit_int @var{value1}, jit_int @var{value2})
+ * @deftypefunx jit_int jit_int_gt (jit_int @var{value1}, jit_int @var{value2})
+ * @deftypefunx jit_int jit_int_ge (jit_int @var{value1}, jit_int @var{value2})
* Compare two signed 32-bit integers, returning 0 or 1 based
* on their relationship.
* @end deftypefun
*
- * @deftypefun jit_int jit_int_cmp (jit_int value1, jit_int value2)
+ * @deftypefun jit_int jit_int_cmp (jit_int @var{value1}, jit_int @var{value2})
* Compare two signed 32-bit integers and return -1, 0, or 1 based
* on their relationship.
* @end deftypefun
*
- * @deftypefun jit_int jit_int_abs (jit_int value1)
- * @deftypefunx jit_int jit_int_min (jit_int value1, jit_int value2)
- * @deftypefunx jit_int jit_int_max (jit_int value1, jit_int value2)
- * @deftypefunx jit_int jit_int_sign (jit_int value1)
+ * @deftypefun jit_int jit_int_abs (jit_int @var{value1})
+ * @deftypefunx jit_int jit_int_min (jit_int @var{value1}, jit_int
@var{value2})
+ * @deftypefunx jit_int jit_int_max (jit_int @var{value1}, jit_int
@var{value2})
+ * @deftypefunx jit_int jit_int_sign (jit_int @var{value1})
* Calculate the absolute value, minimum, maximum, or sign for
* signed 32-bit integer values.
* @end deftypefun
@@ -356,52 +356,52 @@
}
/*@
- * @deftypefun jit_uint jit_uint_add (jit_uint value1, jit_uint value2)
- * @deftypefunx jit_uint jit_uint_sub (jit_uint value1, jit_uint value2)
- * @deftypefunx jit_uint jit_uint_mul (jit_uint value1, jit_uint value2)
- * @deftypefunx jit_uint jit_uint_neg (jit_uint value1)
- * @deftypefunx jit_uint jit_uint_and (jit_uint value1, jit_uint value2)
- * @deftypefunx jit_uint jit_uint_or (jit_uint value1, jit_uint value2)
- * @deftypefunx jit_uint jit_uint_xor (jit_uint value1, jit_uint value2)
- * @deftypefunx jit_uint jit_uint_not (jit_uint value1)
- * @deftypefunx jit_uint jit_uint_not (jit_uint value1)
- * @deftypefunx jit_uint jit_uint_shl (jit_uint value1, jit_uint value2)
- * @deftypefunx jit_uint jit_uint_shr (jit_uint value1, jit_uint value2)
+ * @deftypefun jit_uint jit_uint_add (jit_uint @var{value1}, jit_uint
@var{value2})
+ * @deftypefunx jit_uint jit_uint_sub (jit_uint @var{value1}, jit_uint
@var{value2})
+ * @deftypefunx jit_uint jit_uint_mul (jit_uint @var{value1}, jit_uint
@var{value2})
+ * @deftypefunx jit_uint jit_uint_neg (jit_uint @var{value1})
+ * @deftypefunx jit_uint jit_uint_and (jit_uint @var{value1}, jit_uint
@var{value2})
+ * @deftypefunx jit_uint jit_uint_or (jit_uint @var{value1}, jit_uint
@var{value2})
+ * @deftypefunx jit_uint jit_uint_xor (jit_uint @var{value1}, jit_uint
@var{value2})
+ * @deftypefunx jit_uint jit_uint_not (jit_uint @var{value1})
+ * @deftypefunx jit_uint jit_uint_not (jit_uint @var{value1})
+ * @deftypefunx jit_uint jit_uint_shl (jit_uint @var{value1}, jit_uint
@var{value2})
+ * @deftypefunx jit_uint jit_uint_shr (jit_uint @var{value1}, jit_uint
@var{value2})
* Perform an arithmetic operation on unsigned 32-bit integers.
* @end deftypefun
*
- * @deftypefun jit_int jit_uint_add_ovf ({jit_uint *} result, jit_uint value1,
jit_uint value2)
- * @deftypefunx jit_int jit_uint_sub_ovf ({jit_uint *} result, jit_uint
value1, jit_uint value2)
- * @deftypefunx jit_int jit_uint_mul_ovf ({jit_uint *} result, jit_uint
value1, jit_uint value2)
+ * @deftypefun jit_int jit_uint_add_ovf (jit_uint address@hidden, jit_uint
@var{value1}, jit_uint @var{value2})
+ * @deftypefunx jit_int jit_uint_sub_ovf (jit_uint address@hidden, jit_uint
@var{value1}, jit_uint @var{value2})
+ * @deftypefunx jit_int jit_uint_mul_ovf (jit_uint address@hidden, jit_uint
@var{value1}, jit_uint @var{value2})
* Perform an arithmetic operation on two unsigned 32-bit integers,
* with overflow checking. Returns @code{JIT_RESULT_OK}
* or @code{JIT_RESULT_OVERFLOW}.
* @end deftypefun
*
- * @deftypefun jit_int jit_uint_div_ovf ({jit_uint *} result, jit_uint value1,
jit_uint value2)
- * @deftypefunx jit_int jit_uint_rem_ovf ({jit_uint *} result, jit_uint
value1, jit_uint value2)
+ * @deftypefun jit_int jit_uint_div_ovf (jit_uint address@hidden, jit_uint
@var{value1}, jit_uint @var{value2})
+ * @deftypefunx jit_int jit_uint_rem_ovf (jit_uint address@hidden, jit_uint
@var{value1}, jit_uint @var{value2})
* Perform a division or remainder operation on two unsigned 32-bit integers.
* Returns @code{JIT_RESULT_OK} or @code{JIT_RESULT_DIVISION_BY_ZERO}
* (@code{JIT_RESULT_ARITHMETIC} is not possible with unsigned integers).
* @end deftypefun
*
- * @deftypefun jit_int jit_uint_eq (jit_uint value1, jit_uint value2)
- * @deftypefunx jit_int jit_uint_ne (jit_uint value1, jit_uint value2)
- * @deftypefunx jit_int jit_uint_lt (jit_uint value1, jit_uint value2)
- * @deftypefunx jit_int jit_uint_le (jit_uint value1, jit_uint value2)
- * @deftypefunx jit_int jit_uint_gt (jit_uint value1, jit_uint value2)
- * @deftypefunx jit_int jit_uint_ge (jit_uint value1, jit_uint value2)
+ * @deftypefun jit_int jit_uint_eq (jit_uint @var{value1}, jit_uint
@var{value2})
+ * @deftypefunx jit_int jit_uint_ne (jit_uint @var{value1}, jit_uint
@var{value2})
+ * @deftypefunx jit_int jit_uint_lt (jit_uint @var{value1}, jit_uint
@var{value2})
+ * @deftypefunx jit_int jit_uint_le (jit_uint @var{value1}, jit_uint
@var{value2})
+ * @deftypefunx jit_int jit_uint_gt (jit_uint @var{value1}, jit_uint
@var{value2})
+ * @deftypefunx jit_int jit_uint_ge (jit_uint @var{value1}, jit_uint
@var{value2})
* Compare two unsigned 32-bit integers, returning 0 or 1 based
* on their relationship.
* @end deftypefun
*
- * @deftypefun jit_int jit_uint_cmp (jit_uint value1, jit_uint value2)
+ * @deftypefun jit_int jit_uint_cmp (jit_uint @var{value1}, jit_uint
@var{value2})
* Compare two unsigned 32-bit integers and return -1, 0, or 1 based
* on their relationship.
* @end deftypefun
*
- * @deftypefun jit_uint jit_uint_min (jit_uint value1, jit_uint value2)
- * @deftypefunx jit_uint jit_uint_max (jit_uint value1, jit_uint value2)
+ * @deftypefun jit_uint jit_uint_min (jit_uint @var{value1}, jit_uint
@var{value2})
+ * @deftypefunx jit_uint jit_uint_max (jit_uint @var{value1}, jit_uint
@var{value2})
* Calculate the minimum or maximum for unsigned 32-bit integer values.
* @end deftypefun
@*/
@@ -557,54 +557,54 @@
}
/*@
- * @deftypefun jit_long jit_long_add (jit_long value1, jit_long value2)
- * @deftypefunx jit_long jit_long_sub (jit_long value1, jit_long value2)
- * @deftypefunx jit_long jit_long_mul (jit_long value1, jit_long value2)
- * @deftypefunx jit_long jit_long_neg (jit_long value1)
- * @deftypefunx jit_long jit_long_and (jit_long value1, jit_long value2)
- * @deftypefunx jit_long jit_long_or (jit_long value1, jit_long value2)
- * @deftypefunx jit_long jit_long_xor (jit_long value1, jit_long value2)
- * @deftypefunx jit_long jit_long_not (jit_long value1)
- * @deftypefunx jit_long jit_long_not (jit_long value1)
- * @deftypefunx jit_long jit_long_shl (jit_long value1, jit_uint value2)
- * @deftypefunx jit_long jit_long_shr (jit_long value1, jit_uint value2)
+ * @deftypefun jit_long jit_long_add (jit_long @var{value1}, jit_long
@var{value2})
+ * @deftypefunx jit_long jit_long_sub (jit_long @var{value1}, jit_long
@var{value2})
+ * @deftypefunx jit_long jit_long_mul (jit_long @var{value1}, jit_long
@var{value2})
+ * @deftypefunx jit_long jit_long_neg (jit_long @var{value1})
+ * @deftypefunx jit_long jit_long_and (jit_long @var{value1}, jit_long
@var{value2})
+ * @deftypefunx jit_long jit_long_or (jit_long @var{value1}, jit_long
@var{value2})
+ * @deftypefunx jit_long jit_long_xor (jit_long @var{value1}, jit_long
@var{value2})
+ * @deftypefunx jit_long jit_long_not (jit_long @var{value1})
+ * @deftypefunx jit_long jit_long_not (jit_long @var{value1})
+ * @deftypefunx jit_long jit_long_shl (jit_long @var{value1}, jit_uint
@var{value2})
+ * @deftypefunx jit_long jit_long_shr (jit_long @var{value1}, jit_uint
@var{value2})
* Perform an arithmetic operation on signed 64-bit integers.
* @end deftypefun
*
- * @deftypefun jit_int jit_long_add_ovf ({jit_long *} result, jit_long value1,
jit_long value2)
- * @deftypefunx jit_int jit_long_sub_ovf ({jit_long *} result, jit_long
value1, jit_long value2)
- * @deftypefunx jit_int jit_long_mul_ovf ({jit_long *} result, jit_long
value1, jit_long value2)
+ * @deftypefun jit_int jit_long_add_ovf (jit_long address@hidden, jit_long
@var{value1}, jit_long @var{value2})
+ * @deftypefunx jit_int jit_long_sub_ovf (jit_long address@hidden, jit_long
@var{value1}, jit_long @var{value2})
+ * @deftypefunx jit_int jit_long_mul_ovf (jit_long address@hidden, jit_long
@var{value1}, jit_long @var{value2})
* Perform an arithmetic operation on two signed 64-bit integers,
* with overflow checking. Returns @code{JIT_RESULT_OK}
* or @code{JIT_RESULT_OVERFLOW}.
* @end deftypefun
*
- * @deftypefun jit_int jit_long_div_ovf ({jit_long *} result, jit_long value1,
jit_long value2)
- * @deftypefunx jit_int jit_long_rem_ovf ({jit_long *} result, jit_long
value1, jit_long value2)
+ * @deftypefun jit_int jit_long_div_ovf (jit_long address@hidden, jit_long
@var{value1}, jit_long @var{value2})
+ * @deftypefunx jit_int jit_long_rem_ovf (jit_long address@hidden, jit_long
@var{value1}, jit_long @var{value2})
* Perform a division or remainder operation on two signed 64-bit integers.
* Returns @code{JIT_RESULT_OK}, @code{JIT_RESULT_DIVISION_BY_ZERO},
* or @code{JIT_RESULT_ARITHMETIC}.
* @end deftypefun
*
- * @deftypefun jit_int jit_long_eq (jit_long value1, jit_long value2)
- * @deftypefunx jit_int jit_long_ne (jit_long value1, jit_long value2)
- * @deftypefunx jit_int jit_long_lt (jit_long value1, jit_long value2)
- * @deftypefunx jit_int jit_long_le (jit_long value1, jit_long value2)
- * @deftypefunx jit_int jit_long_gt (jit_long value1, jit_long value2)
- * @deftypefunx jit_int jit_long_ge (jit_long value1, jit_long value2)
+ * @deftypefun jit_int jit_long_eq (jit_long @var{value1}, jit_long
@var{value2})
+ * @deftypefunx jit_int jit_long_ne (jit_long @var{value1}, jit_long
@var{value2})
+ * @deftypefunx jit_int jit_long_lt (jit_long @var{value1}, jit_long
@var{value2})
+ * @deftypefunx jit_int jit_long_le (jit_long @var{value1}, jit_long
@var{value2})
+ * @deftypefunx jit_int jit_long_gt (jit_long @var{value1}, jit_long
@var{value2})
+ * @deftypefunx jit_int jit_long_ge (jit_long @var{value1}, jit_long
@var{value2})
* Compare two signed 64-bit integers, returning 0 or 1 based
* on their relationship.
* @end deftypefun
*
- * @deftypefun jit_int jit_long_cmp (jit_long value1, jit_long value2)
+ * @deftypefun jit_int jit_long_cmp (jit_long @var{value1}, jit_long
@var{value2})
* Compare two signed 64-bit integers and return -1, 0, or 1 based
* on their relationship.
* @end deftypefun
*
- * @deftypefun jit_long jit_long_abs (jit_long value1)
- * @deftypefunx jit_long jit_long_min (jit_long value1, jit_long value2)
- * @deftypefunx jit_long jit_long_max (jit_long value1, jit_long value2)
- * @deftypefunx jit_int jit_long_sign (jit_long value1)
+ * @deftypefun jit_long jit_long_abs (jit_long @var{value1})
+ * @deftypefunx jit_long jit_long_min (jit_long @var{value1}, jit_long
@var{value2})
+ * @deftypefunx jit_long jit_long_max (jit_long @var{value1}, jit_long
@var{value2})
+ * @deftypefunx jit_int jit_long_sign (jit_long @var{value1})
* Calculate the absolute value, minimum, maximum, or sign for
* signed 64-bit integer values.
* @end deftypefun
@@ -883,52 +883,52 @@
}
/*@
- * @deftypefun jit_ulong jit_ulong_add (jit_ulong value1, jit_ulong value2)
- * @deftypefunx jit_ulong jit_ulong_sub (jit_ulong value1, jit_ulong value2)
- * @deftypefunx jit_ulong jit_ulong_mul (jit_ulong value1, jit_ulong value2)
- * @deftypefunx jit_ulong jit_ulong_neg (jit_ulong value1)
- * @deftypefunx jit_ulong jit_ulong_and (jit_ulong value1, jit_ulong value2)
- * @deftypefunx jit_ulong jit_ulong_or (jit_ulong value1, jit_ulong value2)
- * @deftypefunx jit_ulong jit_ulong_xor (jit_ulong value1, jit_ulong value2)
- * @deftypefunx jit_ulong jit_ulong_not (jit_ulong value1)
- * @deftypefunx jit_ulong jit_ulong_not (jit_ulong value1)
- * @deftypefunx jit_ulong jit_ulong_shl (jit_ulong value1, jit_uint value2)
- * @deftypefunx jit_ulong jit_ulong_shr (jit_ulong value1, jit_uint value2)
+ * @deftypefun jit_ulong jit_ulong_add (jit_ulong @var{value1}, jit_ulong
@var{value2})
+ * @deftypefunx jit_ulong jit_ulong_sub (jit_ulong @var{value1}, jit_ulong
@var{value2})
+ * @deftypefunx jit_ulong jit_ulong_mul (jit_ulong @var{value1}, jit_ulong
@var{value2})
+ * @deftypefunx jit_ulong jit_ulong_neg (jit_ulong @var{value1})
+ * @deftypefunx jit_ulong jit_ulong_and (jit_ulong @var{value1}, jit_ulong
@var{value2})
+ * @deftypefunx jit_ulong jit_ulong_or (jit_ulong @var{value1}, jit_ulong
@var{value2})
+ * @deftypefunx jit_ulong jit_ulong_xor (jit_ulong @var{value1}, jit_ulong
@var{value2})
+ * @deftypefunx jit_ulong jit_ulong_not (jit_ulong @var{value1})
+ * @deftypefunx jit_ulong jit_ulong_not (jit_ulong @var{value1})
+ * @deftypefunx jit_ulong jit_ulong_shl (jit_ulong @var{value1}, jit_uint
@var{value2})
+ * @deftypefunx jit_ulong jit_ulong_shr (jit_ulong @var{value1}, jit_uint
@var{value2})
* Perform an arithmetic operation on unsigned 64-bit integers.
* @end deftypefun
*
- * @deftypefun jit_int jit_ulong_add_ovf ({jit_ulong *} result, jit_ulong
value1, jit_ulong value2)
- * @deftypefunx jit_int jit_ulong_sub_ovf ({jit_ulong *} result, jit_ulong
value1, jit_ulong value2)
- * @deftypefunx jit_int jit_ulong_mul_ovf ({jit_ulong *} result, jit_ulong
value1, jit_ulong value2)
+ * @deftypefun jit_int jit_ulong_add_ovf (jit_ulong address@hidden, jit_ulong
@var{value1}, jit_ulong @var{value2})
+ * @deftypefunx jit_int jit_ulong_sub_ovf (jit_ulong address@hidden, jit_ulong
@var{value1}, jit_ulong @var{value2})
+ * @deftypefunx jit_int jit_ulong_mul_ovf (jit_ulong address@hidden, jit_ulong
@var{value1}, jit_ulong @var{value2})
* Perform an arithmetic operation on two unsigned 64-bit integers,
* with overflow checking. Returns @code{JIT_RESULT_OK}
* or @code{JIT_RESULT_OVERFLOW}.
* @end deftypefun
*
- * @deftypefun jit_int jit_ulong_div_ovf ({jit_ulong *} result, jit_ulong
value1, jit_ulong value2)
- * @deftypefunx jit_int jit_ulong_rem_ovf ({jit_ulong *} result, jit_ulong
value1, jit_ulong value2)
+ * @deftypefun jit_int jit_ulong_div_ovf (jit_ulong address@hidden, jit_ulong
@var{value1}, jit_ulong @var{value2})
+ * @deftypefunx jit_int jit_ulong_rem_ovf (jit_ulong address@hidden, jit_ulong
@var{value1}, jit_ulong @var{value2})
* Perform a division or remainder operation on two unsigned 64-bit integers.
* Returns @code{JIT_RESULT_OK} or @code{JIT_RESULT_DIVISION_BY_ZERO}
* (@code{JIT_RESULT_ARITHMETIC} is not possible with unsigned integers).
* @end deftypefun
*
- * @deftypefun jit_int jit_ulong_eq (jit_ulong value1, jit_ulong value2)
- * @deftypefunx jit_int jit_ulong_ne (jit_ulong value1, jit_ulong value2)
- * @deftypefunx jit_int jit_ulong_lt (jit_ulong value1, jit_ulong value2)
- * @deftypefunx jit_int jit_ulong_le (jit_ulong value1, jit_ulong value2)
- * @deftypefunx jit_int jit_ulong_gt (jit_ulong value1, jit_ulong value2)
- * @deftypefunx jit_int jit_ulong_ge (jit_ulong value1, jit_ulong value2)
+ * @deftypefun jit_int jit_ulong_eq (jit_ulong @var{value1}, jit_ulong
@var{value2})
+ * @deftypefunx jit_int jit_ulong_ne (jit_ulong @var{value1}, jit_ulong
@var{value2})
+ * @deftypefunx jit_int jit_ulong_lt (jit_ulong @var{value1}, jit_ulong
@var{value2})
+ * @deftypefunx jit_int jit_ulong_le (jit_ulong @var{value1}, jit_ulong
@var{value2})
+ * @deftypefunx jit_int jit_ulong_gt (jit_ulong @var{value1}, jit_ulong
@var{value2})
+ * @deftypefunx jit_int jit_ulong_ge (jit_ulong @var{value1}, jit_ulong
@var{value2})
* Compare two unsigned 64-bit integers, returning 0 or 1 based
* on their relationship.
* @end deftypefun
*
- * @deftypefun jit_int jit_ulong_cmp (jit_ulong value1, jit_ulong value2)
+ * @deftypefun jit_int jit_ulong_cmp (jit_ulong @var{value1}, jit_ulong
@var{value2})
* Compare two unsigned 64-bit integers and return -1, 0, or 1 based
* on their relationship.
* @end deftypefun
*
- * @deftypefun jit_ulong jit_ulong_min (jit_ulong value1, jit_ulong value2)
- * @deftypefunx jit_ulong jit_ulong_max (jit_ulong value1, jit_ulong value2)
+ * @deftypefun jit_ulong jit_ulong_min (jit_ulong @var{value1}, jit_ulong
@var{value2})
+ * @deftypefunx jit_ulong jit_ulong_max (jit_ulong @var{value1}, jit_ulong
@var{value2})
* Calculate the minimum or maximum for unsigned 64-bit integer values.
* @end deftypefun
@*/
@@ -1133,42 +1133,42 @@
}
/*@
- * @deftypefun jit_float32 jit_float32_add (jit_float32 value1, jit_float32
value2)
- * @deftypefunx jit_float32 jit_float32_sub (jit_float32 value1, jit_float32
value2)
- * @deftypefunx jit_float32 jit_float32_mul (jit_float32 value1, jit_float32
value2)
- * @deftypefunx jit_float32 jit_float32_div (jit_float32 value1, jit_float32
value2)
- * @deftypefunx jit_float32 jit_float32_rem (jit_float32 value1, jit_float32
value2)
- * @deftypefunx jit_float32 jit_float32_ieee_rem (jit_float32 value1,
jit_float32 value2)
- * @deftypefunx jit_float32 jit_float32_neg (jit_float32 value1)
+ * @deftypefun jit_float32 jit_float32_add (jit_float32 @var{value1},
jit_float32 @var{value2})
+ * @deftypefunx jit_float32 jit_float32_sub (jit_float32 @var{value1},
jit_float32 @var{value2})
+ * @deftypefunx jit_float32 jit_float32_mul (jit_float32 @var{value1},
jit_float32 @var{value2})
+ * @deftypefunx jit_float32 jit_float32_div (jit_float32 @var{value1},
jit_float32 @var{value2})
+ * @deftypefunx jit_float32 jit_float32_rem (jit_float32 @var{value1},
jit_float32 @var{value2})
+ * @deftypefunx jit_float32 jit_float32_ieee_rem (jit_float32 @var{value1},
jit_float32 @var{value2})
+ * @deftypefunx jit_float32 jit_float32_neg (jit_float32 @var{value1})
* Perform an arithmetic operation on 32-bit floating-point values.
* @end deftypefun
*
- * @deftypefun jit_int jit_float32_eq (jit_float32 value1, jit_float32 value2)
- * @deftypefunx jit_int jit_float32_ne (jit_float32 value1, jit_float32 value2)
- * @deftypefunx jit_int jit_float32_lt (jit_float32 value1, jit_float32 value2)
- * @deftypefunx jit_int jit_float32_le (jit_float32 value1, jit_float32 value2)
- * @deftypefunx jit_int jit_float32_gt (jit_float32 value1, jit_float32 value2)
- * @deftypefunx jit_int jit_float32_ge (jit_float32 value1, jit_float32 value2)
+ * @deftypefun jit_int jit_float32_eq (jit_float32 @var{value1}, jit_float32
@var{value2})
+ * @deftypefunx jit_int jit_float32_ne (jit_float32 @var{value1}, jit_float32
@var{value2})
+ * @deftypefunx jit_int jit_float32_lt (jit_float32 @var{value1}, jit_float32
@var{value2})
+ * @deftypefunx jit_int jit_float32_le (jit_float32 @var{value1}, jit_float32
@var{value2})
+ * @deftypefunx jit_int jit_float32_gt (jit_float32 @var{value1}, jit_float32
@var{value2})
+ * @deftypefunx jit_int jit_float32_ge (jit_float32 @var{value1}, jit_float32
@var{value2})
* Compare two 32-bit floating-point values, returning 0 or 1 based
* on their relationship.
* @end deftypefun
*
- * @deftypefun jit_int jit_float32_cmpl (jit_float32 value1, jit_float32
value2)
+ * @deftypefun jit_int jit_float32_cmpl (jit_float32 @var{value1}, jit_float32
@var{value2})
* Compare two 32-bit floating-point values and return -1, 0, or 1 based
* on their relationship. If either value is "not a number",
* then -1 is returned.
* @end deftypefun
*
- * @deftypefun jit_int jit_float32_cmpg (jit_float32 value1, jit_float32
value2)
+ * @deftypefun jit_int jit_float32_cmpg (jit_float32 @var{value1}, jit_float32
@var{value2})
* Compare two 32-bit floating-point values and return -1, 0, or 1 based
* on their relationship. If either value is "not a number",
* then 1 is returned.
* @end deftypefun
*
- * @deftypefun jit_float32 jit_float32_abs (jit_float32 value1)
- * @deftypefunx jit_float32 jit_float32_min (jit_float32 value1, jit_float32
value2)
- * @deftypefunx jit_float32 jit_float32_max (jit_float32 value1, jit_float32
value2)
- * @deftypefunx jit_int jit_float32_sign (jit_float32 value1)
+ * @deftypefun jit_float32 jit_float32_abs (jit_float32 @var{value1})
+ * @deftypefunx jit_float32 jit_float32_min (jit_float32 @var{value1},
jit_float32 @var{value2})
+ * @deftypefunx jit_float32 jit_float32_max (jit_float32 @var{value1},
jit_float32 @var{value2})
+ * @deftypefunx jit_int jit_float32_sign (jit_float32 @var{value1})
* Calculate the absolute value, minimum, maximum, or sign for
* 32-bit floating point values.
* @end deftypefun
@@ -1428,23 +1428,23 @@
}
/*@
- * @deftypefun jit_float32 jit_float32_acos (jit_float32 value1)
- * @deftypefunx jit_float32 jit_float32_asin (jit_float32 value1)
- * @deftypefunx jit_float32 jit_float32_atan (jit_float32 value1)
- * @deftypefunx jit_float32 jit_float32_atan2 (jit_float32 value1, jit_float32
value2)
- * @deftypefunx jit_float32 jit_float32_ceil (jit_float32 value1)
- * @deftypefunx jit_float32 jit_float32_cos (jit_float32 value1)
- * @deftypefunx jit_float32 jit_float32_cosh (jit_float32 value1)
- * @deftypefunx jit_float32 jit_float32_exp (jit_float32 value1)
- * @deftypefunx jit_float32 jit_float32_floor (jit_float32 value1)
- * @deftypefunx jit_float32 jit_float32_log (jit_float32 value1)
- * @deftypefunx jit_float32 jit_float32_log10 (jit_float32 value1)
- * @deftypefunx jit_float32 jit_float32_pow (jit_float32 value1, jit_float32
value2)
- * @deftypefunx jit_float32 jit_float32_sin (jit_float32 value1)
- * @deftypefunx jit_float32 jit_float32_sinh (jit_float32 value1)
- * @deftypefunx jit_float32 jit_float32_sqrt (jit_float32 value1)
- * @deftypefunx jit_float32 jit_float32_tan (jit_float32 value1)
- * @deftypefunx jit_float32 jit_float32_tanh (jit_float32 value1)
+ * @deftypefun jit_float32 jit_float32_acos (jit_float32 @var{value1})
+ * @deftypefunx jit_float32 jit_float32_asin (jit_float32 @var{value1})
+ * @deftypefunx jit_float32 jit_float32_atan (jit_float32 @var{value1})
+ * @deftypefunx jit_float32 jit_float32_atan2 (jit_float32 @var{value1},
jit_float32 @var{value2})
+ * @deftypefunx jit_float32 jit_float32_ceil (jit_float32 @var{value1})
+ * @deftypefunx jit_float32 jit_float32_cos (jit_float32 @var{value1})
+ * @deftypefunx jit_float32 jit_float32_cosh (jit_float32 @var{value1})
+ * @deftypefunx jit_float32 jit_float32_exp (jit_float32 @var{value1})
+ * @deftypefunx jit_float32 jit_float32_floor (jit_float32 @var{value1})
+ * @deftypefunx jit_float32 jit_float32_log (jit_float32 @var{value1})
+ * @deftypefunx jit_float32 jit_float32_log10 (jit_float32 @var{value1})
+ * @deftypefunx jit_float32 jit_float32_pow (jit_float32 @var{value1},
jit_float32 @var{value2})
+ * @deftypefunx jit_float32 jit_float32_sin (jit_float32 @var{value1})
+ * @deftypefunx jit_float32 jit_float32_sinh (jit_float32 @var{value1})
+ * @deftypefunx jit_float32 jit_float32_sqrt (jit_float32 @var{value1})
+ * @deftypefunx jit_float32 jit_float32_tan (jit_float32 @var{value1})
+ * @deftypefunx jit_float32 jit_float32_tanh (jit_float32 @var{value1})
* Apply a mathematical function to one or two 32-bit floating-point values.
* @end deftypefun
@*/
@@ -1581,8 +1581,8 @@
}
/*@
- * @deftypefun jit_float32 jit_float32_rint (jit_float32 value1)
- * Round @code{value1} to the nearest integer. Half-way cases
+ * @deftypefun jit_float32 jit_float32_rint (jit_float32 @var{value1})
+ * Round @var{value1} to the nearest integer. Half-way cases
* are rounded to an even number.
* @end deftypefun
@*/
@@ -1614,8 +1614,8 @@
}
/*@
- * @deftypefun jit_float32 jit_float32_round (jit_float32 value1)
- * Round @code{value1} to the nearest integer. Half-way cases
+ * @deftypefun jit_float32 jit_float32_round (jit_float32 @var{value1})
+ * Round @var{value1} to the nearest integer. Half-way cases
* are rounded away from zero.
* @end deftypefun
@*/
@@ -1707,7 +1707,7 @@
}
/*@
- * @deftypefun jit_int jit_float32_is_finite (jit_float32 value)
+ * @deftypefun jit_int jit_float32_is_finite (jit_float32 @var{value})
* Determine if a 32-bit floating point value is finite, returning
* non-zero if it is, or zero if it is not. If the value is
* "not a number", this function returns zero.
@@ -1736,7 +1736,7 @@
}
/*@
- * @deftypefun jit_int jit_float32_is_nan (jit_float32 value)
+ * @deftypefun jit_int jit_float32_is_nan (jit_float32 @var{value})
* Determine if a 32-bit floating point value is "not a number", returning
* non-zero if it is, or zero if it is not.
* @end deftypefun
@@ -1753,7 +1753,7 @@
}
/*@
- * @deftypefun jit_int jit_float32_is_inf (jit_float32 value)
+ * @deftypefun jit_int jit_float32_is_inf (jit_float32 @var{value})
* Determine if a 32-bit floating point value is infinite or not.
* Returns -1 for negative infinity, 1 for positive infinity,
* and 0 for everything else.
@@ -1793,42 +1793,42 @@
}
/*@
- * @deftypefun jit_float64 jit_float64_add (jit_float64 value1, jit_float64
value2)
- * @deftypefunx jit_float64 jit_float64_sub (jit_float64 value1, jit_float64
value2)
- * @deftypefunx jit_float64 jit_float64_mul (jit_float64 value1, jit_float64
value2)
- * @deftypefunx jit_float64 jit_float64_div (jit_float64 value1, jit_float64
value2)
- * @deftypefunx jit_float64 jit_float64_rem (jit_float64 value1, jit_float64
value2)
- * @deftypefunx jit_float64 jit_float64_ieee_rem (jit_float64 value1,
jit_float64 value2)
- * @deftypefunx jit_float64 jit_float64_neg (jit_float64 value1)
+ * @deftypefun jit_float64 jit_float64_add (jit_float64 @var{value1},
jit_float64 @var{value2})
+ * @deftypefunx jit_float64 jit_float64_sub (jit_float64 @var{value1},
jit_float64 @var{value2})
+ * @deftypefunx jit_float64 jit_float64_mul (jit_float64 @var{value1},
jit_float64 @var{value2})
+ * @deftypefunx jit_float64 jit_float64_div (jit_float64 @var{value1},
jit_float64 @var{value2})
+ * @deftypefunx jit_float64 jit_float64_rem (jit_float64 @var{value1},
jit_float64 @var{value2})
+ * @deftypefunx jit_float64 jit_float64_ieee_rem (jit_float64 @var{value1},
jit_float64 @var{value2})
+ * @deftypefunx jit_float64 jit_float64_neg (jit_float64 @var{value1})
* Perform an arithmetic operation on 64-bit floating-point values.
* @end deftypefun
*
- * @deftypefun jit_int jit_float64_eq (jit_float64 value1, jit_float64 value2)
- * @deftypefunx jit_int jit_float64_ne (jit_float64 value1, jit_float64 value2)
- * @deftypefunx jit_int jit_float64_lt (jit_float64 value1, jit_float64 value2)
- * @deftypefunx jit_int jit_float64_le (jit_float64 value1, jit_float64 value2)
- * @deftypefunx jit_int jit_float64_gt (jit_float64 value1, jit_float64 value2)
- * @deftypefunx jit_int jit_float64_ge (jit_float64 value1, jit_float64 value2)
+ * @deftypefun jit_int jit_float64_eq (jit_float64 @var{value1}, jit_float64
@var{value2})
+ * @deftypefunx jit_int jit_float64_ne (jit_float64 @var{value1}, jit_float64
@var{value2})
+ * @deftypefunx jit_int jit_float64_lt (jit_float64 @var{value1}, jit_float64
@var{value2})
+ * @deftypefunx jit_int jit_float64_le (jit_float64 @var{value1}, jit_float64
@var{value2})
+ * @deftypefunx jit_int jit_float64_gt (jit_float64 @var{value1}, jit_float64
@var{value2})
+ * @deftypefunx jit_int jit_float64_ge (jit_float64 @var{value1}, jit_float64
@var{value2})
* Compare two 64-bit floating-point values, returning 0 or 1 based
* on their relationship.
* @end deftypefun
*
- * @deftypefun jit_int jit_float64_cmpl (jit_float64 value1, jit_float64
value2)
+ * @deftypefun jit_int jit_float64_cmpl (jit_float64 @var{value1}, jit_float64
@var{value2})
* Compare two 64-bit floating-point values and return -1, 0, or 1 based
* on their relationship. If either value is "not a number",
* then -1 is returned.
* @end deftypefun
*
- * @deftypefun jit_int jit_float64_cmpg (jit_float64 value1, jit_float64
value2)
+ * @deftypefun jit_int jit_float64_cmpg (jit_float64 @var{value1}, jit_float64
@var{value2})
* Compare two 64-bit floating-point values and return -1, 0, or 1 based
* on their relationship. If either value is "not a number",
* then 1 is returned.
* @end deftypefun
*
- * @deftypefun jit_float64 jit_float64_abs (jit_float64 value1)
- * @deftypefunx jit_float64 jit_float64_min (jit_float64 value1, jit_float64
value2)
- * @deftypefunx jit_float64 jit_float64_max (jit_float64 value1, jit_float64
value2)
- * @deftypefunx jit_int jit_float64_sign (jit_float64 value1)
+ * @deftypefun jit_float64 jit_float64_abs (jit_float64 @var{value1})
+ * @deftypefunx jit_float64 jit_float64_min (jit_float64 @var{value1},
jit_float64 @var{value2})
+ * @deftypefunx jit_float64 jit_float64_max (jit_float64 @var{value1},
jit_float64 @var{value2})
+ * @deftypefunx jit_int jit_float64_sign (jit_float64 @var{value1})
* Calculate the absolute value, minimum, maximum, or sign for
* 64-bit floating point values.
* @end deftypefun
@@ -2040,23 +2040,23 @@
}
/*@
- * @deftypefun jit_float64 jit_float64_acos (jit_float64 value1)
- * @deftypefunx jit_float64 jit_float64_asin (jit_float64 value1)
- * @deftypefunx jit_float64 jit_float64_atan (jit_float64 value1)
- * @deftypefunx jit_float64 jit_float64_atan2 (jit_float64 value1, jit_float64
value2)
- * @deftypefunx jit_float64 jit_float64_ceil (jit_float64 value1)
- * @deftypefunx jit_float64 jit_float64_cos (jit_float64 value1)
- * @deftypefunx jit_float64 jit_float64_cosh (jit_float64 value1)
- * @deftypefunx jit_float64 jit_float64_exp (jit_float64 value1)
- * @deftypefunx jit_float64 jit_float64_floor (jit_float64 value1)
- * @deftypefunx jit_float64 jit_float64_log (jit_float64 value1)
- * @deftypefunx jit_float64 jit_float64_log10 (jit_float64 value1)
- * @deftypefunx jit_float64 jit_float64_pow (jit_float64 value1, jit_float64
value2)
- * @deftypefunx jit_float64 jit_float64_sin (jit_float64 value1)
- * @deftypefunx jit_float64 jit_float64_sinh (jit_float64 value1)
- * @deftypefunx jit_float64 jit_float64_sqrt (jit_float64 value1)
- * @deftypefunx jit_float64 jit_float64_tan (jit_float64 value1)
- * @deftypefunx jit_float64 jit_float64_tanh (jit_float64 value1)
+ * @deftypefun jit_float64 jit_float64_acos (jit_float64 @var{value1})
+ * @deftypefunx jit_float64 jit_float64_asin (jit_float64 @var{value1})
+ * @deftypefunx jit_float64 jit_float64_atan (jit_float64 @var{value1})
+ * @deftypefunx jit_float64 jit_float64_atan2 (jit_float64 @var{value1},
jit_float64 @var{value2})
+ * @deftypefunx jit_float64 jit_float64_ceil (jit_float64 @var{value1})
+ * @deftypefunx jit_float64 jit_float64_cos (jit_float64 @var{value1})
+ * @deftypefunx jit_float64 jit_float64_cosh (jit_float64 @var{value1})
+ * @deftypefunx jit_float64 jit_float64_exp (jit_float64 @var{value1})
+ * @deftypefunx jit_float64 jit_float64_floor (jit_float64 @var{value1})
+ * @deftypefunx jit_float64 jit_float64_log (jit_float64 @var{value1})
+ * @deftypefunx jit_float64 jit_float64_log10 (jit_float64 @var{value1})
+ * @deftypefunx jit_float64 jit_float64_pow (jit_float64 @var{value1},
jit_float64 @var{value2})
+ * @deftypefunx jit_float64 jit_float64_sin (jit_float64 @var{value1})
+ * @deftypefunx jit_float64 jit_float64_sinh (jit_float64 @var{value1})
+ * @deftypefunx jit_float64 jit_float64_sqrt (jit_float64 @var{value1})
+ * @deftypefunx jit_float64 jit_float64_tan (jit_float64 @var{value1})
+ * @deftypefunx jit_float64 jit_float64_tanh (jit_float64 @var{value1})
* Apply a mathematical function to one or two 64-bit floating-point values.
* @end deftypefun
@*/
@@ -2169,8 +2169,8 @@
}
/*@
- * @deftypefun jit_float64 jit_float64_rint (jit_float64 value1)
- * Round @code{value1} to the nearest integer. Half-way cases
+ * @deftypefun jit_float64 jit_float64_rint (jit_float64 @var{value1})
+ * Round @var{value1} to the nearest integer. Half-way cases
* are rounded to an even number.
* @end deftypefun
@*/
@@ -2202,8 +2202,8 @@
}
/*@
- * @deftypefun jit_float64 jit_float64_round (jit_float64 value1)
- * Round @code{value1} to the nearest integer. Half-way cases
+ * @deftypefun jit_float64 jit_float64_round (jit_float64 @var{value1})
+ * Round @var{value1} to the nearest integer. Half-way cases
* are rounded away from zero.
* @end deftypefun
@*/
@@ -2285,7 +2285,7 @@
}
/*@
- * @deftypefun jit_int jit_float64_is_finite (jit_float64 value)
+ * @deftypefun jit_int jit_float64_is_finite (jit_float64 @var{value})
* Determine if a 64-bit floating point value is finite, returning
* non-zero if it is, or zero if it is not. If the value is
* "not a number", this function returns zero.
@@ -2310,7 +2310,7 @@
}
/*@
- * @deftypefun jit_int jit_float64_is_nan (jit_float64 value)
+ * @deftypefun jit_int jit_float64_is_nan (jit_float64 @var{value})
* Determine if a 64-bit floating point value is "not a number", returning
* non-zero if it is, or zero if it is not.
* @end deftypefun
@@ -2325,7 +2325,7 @@
}
/*@
- * @deftypefun jit_int jit_float64_is_inf (jit_float64 value)
+ * @deftypefun jit_int jit_float64_is_inf (jit_float64 @var{value})
* Determine if a 64-bit floating point value is infinite or not.
* Returns -1 for negative infinity, 1 for positive infinity,
* and 0 for everything else.
@@ -2360,42 +2360,42 @@
}
/*@
- * @deftypefun jit_nfloat jit_nfloat_add (jit_nfloat value1, jit_nfloat value2)
- * @deftypefunx jit_nfloat jit_nfloat_sub (jit_nfloat value1, jit_nfloat
value2)
- * @deftypefunx jit_nfloat jit_nfloat_mul (jit_nfloat value1, jit_nfloat
value2)
- * @deftypefunx jit_nfloat jit_nfloat_div (jit_nfloat value1, jit_nfloat
value2)
- * @deftypefunx jit_nfloat jit_nfloat_rem (jit_nfloat value1, jit_nfloat
value2)
- * @deftypefunx jit_nfloat jit_nfloat_ieee_rem (jit_nfloat value1, jit_nfloat
value2)
- * @deftypefunx jit_nfloat jit_nfloat_neg (jit_nfloat value1)
+ * @deftypefun jit_nfloat jit_nfloat_add (jit_nfloat @var{value1}, jit_nfloat
@var{value2})
+ * @deftypefunx jit_nfloat jit_nfloat_sub (jit_nfloat @var{value1}, jit_nfloat
@var{value2})
+ * @deftypefunx jit_nfloat jit_nfloat_mul (jit_nfloat @var{value1}, jit_nfloat
@var{value2})
+ * @deftypefunx jit_nfloat jit_nfloat_div (jit_nfloat @var{value1}, jit_nfloat
@var{value2})
+ * @deftypefunx jit_nfloat jit_nfloat_rem (jit_nfloat @var{value1}, jit_nfloat
@var{value2})
+ * @deftypefunx jit_nfloat jit_nfloat_ieee_rem (jit_nfloat @var{value1},
jit_nfloat @var{value2})
+ * @deftypefunx jit_nfloat jit_nfloat_neg (jit_nfloat @var{value1})
* Perform an arithmetic operation on native floating-point values.
* @end deftypefun
*
- * @deftypefun jit_int jit_nfloat_eq (jit_nfloat value1, jit_nfloat value2)
- * @deftypefunx jit_int jit_nfloat_ne (jit_nfloat value1, jit_nfloat value2)
- * @deftypefunx jit_int jit_nfloat_lt (jit_nfloat value1, jit_nfloat value2)
- * @deftypefunx jit_int jit_nfloat_le (jit_nfloat value1, jit_nfloat value2)
- * @deftypefunx jit_int jit_nfloat_gt (jit_nfloat value1, jit_nfloat value2)
- * @deftypefunx jit_int jit_nfloat_ge (jit_nfloat value1, jit_nfloat value2)
+ * @deftypefun jit_int jit_nfloat_eq (jit_nfloat @var{value1}, jit_nfloat
@var{value2})
+ * @deftypefunx jit_int jit_nfloat_ne (jit_nfloat @var{value1}, jit_nfloat
@var{value2})
+ * @deftypefunx jit_int jit_nfloat_lt (jit_nfloat @var{value1}, jit_nfloat
@var{value2})
+ * @deftypefunx jit_int jit_nfloat_le (jit_nfloat @var{value1}, jit_nfloat
@var{value2})
+ * @deftypefunx jit_int jit_nfloat_gt (jit_nfloat @var{value1}, jit_nfloat
@var{value2})
+ * @deftypefunx jit_int jit_nfloat_ge (jit_nfloat @var{value1}, jit_nfloat
@var{value2})
* Compare two native floating-point values, returning 0 or 1 based
* on their relationship.
* @end deftypefun
*
- * @deftypefun jit_int jit_nfloat_cmpl (jit_nfloat value1, jit_nfloat value2)
+ * @deftypefun jit_int jit_nfloat_cmpl (jit_nfloat @var{value1}, jit_nfloat
@var{value2})
* Compare two native floating-point values and return -1, 0, or 1 based
* on their relationship. If either value is "not a number",
* then -1 is returned.
* @end deftypefun
*
- * @deftypefun jit_int jit_nfloat_cmpg (jit_nfloat value1, jit_nfloat value2)
+ * @deftypefun jit_int jit_nfloat_cmpg (jit_nfloat @var{value1}, jit_nfloat
@var{value2})
* Compare two native floating-point values and return -1, 0, or 1 based
* on their relationship. If either value is "not a number",
* then 1 is returned.
* @end deftypefun
*
- * @deftypefun jit_nfloat jit_nfloat_abs (jit_nfloat value1)
- * @deftypefunx jit_nfloat jit_nfloat_min (jit_nfloat value1, jit_nfloat
value2)
- * @deftypefunx jit_nfloat jit_nfloat_max (jit_nfloat value1, jit_nfloat
value2)
- * @deftypefunx jit_int jit_nfloat_sign (jit_nfloat value1)
+ * @deftypefun jit_nfloat jit_nfloat_abs (jit_nfloat @var{value1})
+ * @deftypefunx jit_nfloat jit_nfloat_min (jit_nfloat @var{value1}, jit_nfloat
@var{value2})
+ * @deftypefunx jit_nfloat jit_nfloat_max (jit_nfloat @var{value1}, jit_nfloat
@var{value2})
+ * @deftypefunx jit_int jit_nfloat_sign (jit_nfloat @var{value1})
* Calculate the absolute value, minimum, maximum, or sign for
* native floating point values.
* @end deftypefun
@@ -2657,23 +2657,23 @@
}
/*@
- * @deftypefun jit_nfloat jit_nfloat_acos (jit_nfloat value1)
- * @deftypefunx jit_nfloat jit_nfloat_asin (jit_nfloat value1)
- * @deftypefunx jit_nfloat jit_nfloat_atan (jit_nfloat value1)
- * @deftypefunx jit_nfloat jit_nfloat_atan2 (jit_nfloat value1, jit_nfloat
value2)
- * @deftypefunx jit_nfloat jit_nfloat_ceil (jit_nfloat value1)
- * @deftypefunx jit_nfloat jit_nfloat_cos (jit_nfloat value1)
- * @deftypefunx jit_nfloat jit_nfloat_cosh (jit_nfloat value1)
- * @deftypefunx jit_nfloat jit_nfloat_exp (jit_nfloat value1)
- * @deftypefunx jit_nfloat jit_nfloat_floor (jit_nfloat value1)
- * @deftypefunx jit_nfloat jit_nfloat_log (jit_nfloat value1)
- * @deftypefunx jit_nfloat jit_nfloat_log10 (jit_nfloat value1)
- * @deftypefunx jit_nfloat jit_nfloat_pow (jit_nfloat value1, jit_nfloat
value2)
- * @deftypefunx jit_nfloat jit_nfloat_sin (jit_nfloat value1)
- * @deftypefunx jit_nfloat jit_nfloat_sinh (jit_nfloat value1)
- * @deftypefunx jit_nfloat jit_nfloat_sqrt (jit_nfloat value1)
- * @deftypefunx jit_nfloat jit_nfloat_tan (jit_nfloat value1)
- * @deftypefunx jit_nfloat jit_nfloat_tanh (jit_nfloat value1)
+ * @deftypefun jit_nfloat jit_nfloat_acos (jit_nfloat @var{value1})
+ * @deftypefunx jit_nfloat jit_nfloat_asin (jit_nfloat @var{value1})
+ * @deftypefunx jit_nfloat jit_nfloat_atan (jit_nfloat @var{value1})
+ * @deftypefunx jit_nfloat jit_nfloat_atan2 (jit_nfloat @var{value1},
jit_nfloat @var{value2})
+ * @deftypefunx jit_nfloat jit_nfloat_ceil (jit_nfloat @var{value1})
+ * @deftypefunx jit_nfloat jit_nfloat_cos (jit_nfloat @var{value1})
+ * @deftypefunx jit_nfloat jit_nfloat_cosh (jit_nfloat @var{value1})
+ * @deftypefunx jit_nfloat jit_nfloat_exp (jit_nfloat @var{value1})
+ * @deftypefunx jit_nfloat jit_nfloat_floor (jit_nfloat @var{value1})
+ * @deftypefunx jit_nfloat jit_nfloat_log (jit_nfloat @var{value1})
+ * @deftypefunx jit_nfloat jit_nfloat_log10 (jit_nfloat @var{value1})
+ * @deftypefunx jit_nfloat jit_nfloat_pow (jit_nfloat @var{value1}, jit_nfloat
@var{value2})
+ * @deftypefunx jit_nfloat jit_nfloat_sin (jit_nfloat @var{value1})
+ * @deftypefunx jit_nfloat jit_nfloat_sinh (jit_nfloat @var{value1})
+ * @deftypefunx jit_nfloat jit_nfloat_sqrt (jit_nfloat @var{value1})
+ * @deftypefunx jit_nfloat jit_nfloat_tan (jit_nfloat @var{value1})
+ * @deftypefunx jit_nfloat jit_nfloat_tanh (jit_nfloat @var{value1})
* Apply a mathematical function to one or two native floating-point values.
* @end deftypefun
@*/
@@ -2810,8 +2810,8 @@
}
/*@
- * @deftypefun jit_nfloat jit_nfloat_rint (jit_nfloat value1)
- * Round @code{value1} to the nearest integer. Half-way cases
+ * @deftypefun jit_nfloat jit_nfloat_rint (jit_nfloat @var{value1})
+ * Round @var{value1} to the nearest integer. Half-way cases
* are rounded to an even number.
* @end deftypefun
@*/
@@ -2843,8 +2843,8 @@
}
/*@
- * @deftypefun jit_nfloat jit_nfloat_round (jit_nfloat value1)
- * Round @code{value1} to the nearest integer. Half-way cases
+ * @deftypefun jit_nfloat jit_nfloat_round (jit_nfloat @var{value1})
+ * Round @var{value1} to the nearest integer. Half-way cases
* are rounded away from zero.
* @end deftypefun
@*/
@@ -2936,7 +2936,7 @@
}
/*@
- * @deftypefun jit_int jit_nfloat_is_finite (jit_nfloat value)
+ * @deftypefun jit_int jit_nfloat_is_finite (jit_nfloat @var{value})
* Determine if a native floating point value is finite, returning
* non-zero if it is, or zero if it is not. If the value is
* "not a number", this function returns zero.
@@ -2966,7 +2966,7 @@
}
/*@
- * @deftypefun jit_int jit_nfloat_is_nan (jit_nfloat value)
+ * @deftypefun jit_int jit_nfloat_is_nan (jit_nfloat @var{value})
* Determine if a native floating point value is "not a number", returning
* non-zero if it is, or zero if it is not.
* @end deftypefun
@@ -2983,7 +2983,7 @@
}
/*@
- * @deftypefun jit_int jit_nfloat_is_inf (jit_nfloat value)
+ * @deftypefun jit_int jit_nfloat_is_inf (jit_nfloat @var{value})
* Determine if a native floating point value is infinite or not.
* Returns -1 for negative infinity, 1 for positive infinity,
* and 0 for everything else.
@@ -3023,26 +3023,26 @@
}
/*@
- * @deftypefun jit_int jit_int_to_sbyte (jit_int value)
- * @deftypefunx jit_int jit_int_to_ubyte (jit_int value)
- * @deftypefunx jit_int jit_int_to_short (jit_int value)
- * @deftypefunx jit_int jit_int_to_ushort (jit_int value)
- * @deftypefunx jit_int jit_int_to_int (jit_int value)
- * @deftypefunx jit_uint jit_int_to_uint (jit_int value)
- * @deftypefunx jit_long jit_int_to_long (jit_int value)
- * @deftypefunx jit_ulong jit_int_to_ulong (jit_int value)
- * @deftypefunx jit_int jit_uint_to_int (jit_uint value)
- * @deftypefunx jit_uint jit_uint_to_uint (jit_uint value)
- * @deftypefunx jit_long jit_uint_to_long (jit_uint value)
- * @deftypefunx jit_ulong jit_uint_to_ulong (jit_uint value)
- * @deftypefunx jit_int jit_long_to_int (jit_long value)
- * @deftypefunx jit_uint jit_long_to_uint (jit_long value)
- * @deftypefunx jit_long jit_long_to_long (jit_long value)
- * @deftypefunx jit_ulong jit_long_to_ulong (jit_long value)
- * @deftypefunx jit_int jit_ulong_to_int (jit_ulong value)
- * @deftypefunx jit_uint jit_ulong_to_uint (jit_ulong value)
- * @deftypefunx jit_long jit_ulong_to_long (jit_ulong value)
- * @deftypefunx jit_ulong jit_ulong_to_ulong (jit_ulong value)
+ * @deftypefun jit_int jit_int_to_sbyte (jit_int @var{value})
+ * @deftypefunx jit_int jit_int_to_ubyte (jit_int @var{value})
+ * @deftypefunx jit_int jit_int_to_short (jit_int @var{value})
+ * @deftypefunx jit_int jit_int_to_ushort (jit_int @var{value})
+ * @deftypefunx jit_int jit_int_to_int (jit_int @var{value})
+ * @deftypefunx jit_uint jit_int_to_uint (jit_int @var{value})
+ * @deftypefunx jit_long jit_int_to_long (jit_int @var{value})
+ * @deftypefunx jit_ulong jit_int_to_ulong (jit_int @var{value})
+ * @deftypefunx jit_int jit_uint_to_int (jit_uint @var{value})
+ * @deftypefunx jit_uint jit_uint_to_uint (jit_uint @var{value})
+ * @deftypefunx jit_long jit_uint_to_long (jit_uint @var{value})
+ * @deftypefunx jit_ulong jit_uint_to_ulong (jit_uint @var{value})
+ * @deftypefunx jit_int jit_long_to_int (jit_long @var{value})
+ * @deftypefunx jit_uint jit_long_to_uint (jit_long @var{value})
+ * @deftypefunx jit_long jit_long_to_long (jit_long @var{value})
+ * @deftypefunx jit_ulong jit_long_to_ulong (jit_long @var{value})
+ * @deftypefunx jit_int jit_ulong_to_int (jit_ulong @var{value})
+ * @deftypefunx jit_uint jit_ulong_to_uint (jit_ulong @var{value})
+ * @deftypefunx jit_long jit_ulong_to_long (jit_ulong @var{value})
+ * @deftypefunx jit_ulong jit_ulong_to_ulong (jit_ulong @var{value})
* Convert between integer types.
* @end deftypefun
@*/
@@ -3147,26 +3147,26 @@
}
/*@
- * @deftypefun jit_int jit_int_to_sbyte_ovf ({jit_int *result}, jit_int value)
- * @deftypefunx jit_int jit_int_to_ubyte_ovf ({jit_int *result}, jit_int value)
- * @deftypefunx jit_int jit_int_to_short_ovf ({jit_int *result}, jit_int value)
- * @deftypefunx jit_int jit_int_to_ushort_ovf ({jit_int *result}, jit_int
value)
- * @deftypefunx jit_int jit_int_to_int_ovf ({jit_int *result}, jit_int value)
- * @deftypefunx jit_int jit_int_to_uint_ovf ({jit_uint *result}, jit_int value)
- * @deftypefunx jit_int jit_int_to_long_ovf ({jit_long *result}, jit_int value)
- * @deftypefunx jit_int jit_int_to_ulong_ovf ({jit_ulong *result}, jit_int
value)
- * @deftypefunx jit_int jit_uint_to_int_ovf ({jit_int *result}, jit_uint value)
- * @deftypefunx jit_int jit_uint_to_uint_ovf ({jit_uint *result}, jit_uint
value)
- * @deftypefunx jit_int jit_uint_to_long_ovf ({jit_long *result}, jit_uint
value)
- * @deftypefunx jit_int jit_uint_to_ulong_ovf ({jit_ulong *result}, jit_uint
value)
- * @deftypefunx jit_int jit_long_to_int_ovf ({jit_int *result}, jit_long value)
- * @deftypefunx jit_int jit_long_to_uint_ovf ({jit_uint *result}, jit_long
value)
- * @deftypefunx jit_int jit_long_to_long_ovf ({jit_long *result}, jit_long
value)
- * @deftypefunx jit_int jit_long_to_ulong_ovf ({jit_ulong *result}, jit_long
value)
- * @deftypefunx jit_int jit_ulong_to_int_ovf ({jit_int *result}, jit_ulong
value)
- * @deftypefunx jit_int jit_ulong_to_uint_ovf ({jit_uint *result}, jit_ulong
value)
- * @deftypefunx jit_int jit_ulong_to_long_ovf ({jit_long *result}, jit_ulong
value)
- * @deftypefunx jit_int jit_ulong_to_ulong_ovf ({jit_ulong *result}, jit_ulong
value)
+ * @deftypefun jit_int jit_int_to_sbyte_ovf (jit_int address@hidden, jit_int
@var{value})
+ * @deftypefunx jit_int jit_int_to_ubyte_ovf (jit_int address@hidden, jit_int
@var{value})
+ * @deftypefunx jit_int jit_int_to_short_ovf (jit_int address@hidden, jit_int
@var{value})
+ * @deftypefunx jit_int jit_int_to_ushort_ovf (jit_int address@hidden, jit_int
@var{value})
+ * @deftypefunx jit_int jit_int_to_int_ovf (jit_int address@hidden, jit_int
@var{value})
+ * @deftypefunx jit_int jit_int_to_uint_ovf (jit_uint address@hidden, jit_int
@var{value})
+ * @deftypefunx jit_int jit_int_to_long_ovf (jit_long address@hidden, jit_int
@var{value})
+ * @deftypefunx jit_int jit_int_to_ulong_ovf (jit_ulong address@hidden,
jit_int @var{value})
+ * @deftypefunx jit_int jit_uint_to_int_ovf (jit_int address@hidden, jit_uint
@var{value})
+ * @deftypefunx jit_int jit_uint_to_uint_ovf (jit_uint address@hidden,
jit_uint @var{value})
+ * @deftypefunx jit_int jit_uint_to_long_ovf (jit_long address@hidden,
jit_uint @var{value})
+ * @deftypefunx jit_int jit_uint_to_ulong_ovf (jit_ulong address@hidden,
jit_uint @var{value})
+ * @deftypefunx jit_int jit_long_to_int_ovf (jit_int address@hidden, jit_long
@var{value})
+ * @deftypefunx jit_int jit_long_to_uint_ovf (jit_uint address@hidden,
jit_long @var{value})
+ * @deftypefunx jit_int jit_long_to_long_ovf (jit_long address@hidden,
jit_long @var{value})
+ * @deftypefunx jit_int jit_long_to_ulong_ovf (jit_ulong address@hidden,
jit_long @var{value})
+ * @deftypefunx jit_int jit_ulong_to_int_ovf (jit_int address@hidden,
jit_ulong @var{value})
+ * @deftypefunx jit_int jit_ulong_to_uint_ovf (jit_uint address@hidden,
jit_ulong @var{value})
+ * @deftypefunx jit_int jit_ulong_to_long_ovf (jit_long address@hidden,
jit_ulong @var{value})
+ * @deftypefunx jit_int jit_ulong_to_ulong_ovf (jit_ulong address@hidden,
jit_ulong @var{value})
* Convert between integer types with overflow detection.
* @end deftypefun
@*/
@@ -3287,10 +3287,10 @@
}
/*@
- * @deftypefun jit_int jit_nfloat_to_int (jit_nfloat value)
- * @deftypefunx jit_uint jit_nfloat_to_uint (jit_nfloat value)
- * @deftypefunx jit_long jit_nfloat_to_long (jit_nfloat value)
- * @deftypefunx jit_ulong jit_nfloat_to_ulong (jit_nfloat value)
+ * @deftypefun jit_int jit_nfloat_to_int (jit_nfloat @var{value})
+ * @deftypefunx jit_uint jit_nfloat_to_uint (jit_nfloat @var{value})
+ * @deftypefunx jit_long jit_nfloat_to_long (jit_nfloat @var{value})
+ * @deftypefunx jit_ulong jit_nfloat_to_ulong (jit_nfloat @var{value})
* Convert a native floating-point value into an integer.
* @end deftypefun
@*/
@@ -3351,10 +3351,10 @@
}
/*@
- * @deftypefun jit_int jit_nfloat_to_int_ovf ({jit_int *} result, jit_nfloat
value)
- * @deftypefunx jit_uint jit_nfloat_to_uint_ovf ({jit_uint *} result,
jit_nfloat value)
- * @deftypefunx jit_long jit_nfloat_to_long_ovf ({jit_long *} result,
jit_nfloat value)
- * @deftypefunx jit_ulong jit_nfloat_to_ulong_ovf ({jit_ulong *} result,
jit_nfloat value)
+ * @deftypefun jit_int jit_nfloat_to_int_ovf (jit_int address@hidden,
jit_nfloat @var{value})
+ * @deftypefunx jit_uint jit_nfloat_to_uint_ovf (jit_uint address@hidden,
jit_nfloat @var{value})
+ * @deftypefunx jit_long jit_nfloat_to_long_ovf (jit_long address@hidden,
jit_nfloat @var{value})
+ * @deftypefunx jit_ulong jit_nfloat_to_ulong_ovf (jit_ulong address@hidden,
jit_nfloat @var{value})
* Convert a native floating-point value into an integer,
* with overflow detection. Returns @code{JIT_RESULT_OK} if the conversion
* was successful or @code{JIT_RESULT_OVERFLOW} if an overflow occurred.
@@ -3431,10 +3431,10 @@
}
/*@
- * @deftypefun jit_nfloat jit_int_to_nfloat (jit_int value)
- * @deftypefunx jit_nfloat jit_uint_to_nfloat (jit_uint value)
- * @deftypefunx jit_nfloat jit_long_to_nfloat (jit_long value)
- * @deftypefunx jit_nfloat jit_ulong_to_nfloat (jit_ulong value)
+ * @deftypefun jit_nfloat jit_int_to_nfloat (jit_int @var{value})
+ * @deftypefunx jit_nfloat jit_uint_to_nfloat (jit_uint @var{value})
+ * @deftypefunx jit_nfloat jit_long_to_nfloat (jit_long @var{value})
+ * @deftypefunx jit_nfloat jit_ulong_to_nfloat (jit_ulong @var{value})
* Convert an integer into native floating-point value.
* @end deftypefun
@*/
@@ -3469,10 +3469,10 @@
}
/*@
- * @deftypefun jit_nfloat jit_float32_to_nfloat (jit_float32 value)
- * @deftypefunx jit_nfloat jit_float64_to_nfloat (jit_float64 value)
- * @deftypefunx jit_float32 jit_nfloat_to_float32 (jit_nfloat value)
- * @deftypefunx jit_float64 jit_nfloat_to_float64 (jit_nfloat value)
+ * @deftypefun jit_nfloat jit_float32_to_nfloat (jit_float32 @var{value})
+ * @deftypefunx jit_nfloat jit_float64_to_nfloat (jit_float64 @var{value})
+ * @deftypefunx jit_float32 jit_nfloat_to_float32 (jit_nfloat @var{value})
+ * @deftypefunx jit_float64 jit_nfloat_to_float64 (jit_nfloat @var{value})
* Convert between floating-point types.
* @end deftypefun
@*/
Index: jit/jit-memory.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-memory.c,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -b -r1.1.1.1 -r1.2
--- jit/jit-memory.c 30 Apr 2004 23:30:20 -0000 1.1.1.1
+++ jit/jit-memory.c 22 Jan 2008 06:09:08 -0000 1.2
@@ -39,9 +39,9 @@
@*/
/*@
- * @deftypefun {void *} jit_memset ({void *} dest, int ch, {unsigned int} len)
- * Set the @code{len} bytes at @code{dest} to the value @code{ch}.
- * Returns @code{dest}.
+ * @deftypefun {void *} jit_memset (void address@hidden, int @var{ch},
unsigned int @var{len})
+ * Set the @var{len} bytes at @var{dest} to the value @var{ch}.
+ * Returns @var{dest}.
* @end deftypefun
@*/
void *jit_memset(void *dest, int ch, unsigned int len)
@@ -60,10 +60,10 @@
}
/*@
- * @deftypefun {void *} jit_memcpy ({void *} dest, {const void *} src,
{unsigned int} len)
- * Copy the @code{len} bytes at @code{src} to @code{dest}. Returns
- * @code{dest}. The behavior is undefined if the blocks overlap
- * (use @code{jit_memmove} instead for that case).
+ * @deftypefun {void *} jit_memcpy (void address@hidden, const void
address@hidden, unsigned int @var{len})
+ * Copy the @var{len} bytes at @var{src} to @var{dest}. Returns
+ * @var{dest}. The behavior is undefined if the blocks overlap
+ * (use @var{jit_memmove} instead for that case).
* @end deftypefun
@*/
void *jit_memcpy(void *dest, const void *src, unsigned int len)
@@ -86,9 +86,9 @@
}
/*@
- * @deftypefun {void *} jit_memmove ({void *} dest, {const void *} src,
{unsigned int} len)
- * Copy the @code{len} bytes at @code{src} to @code{dest} and handle
- * overlapping blocks correctly. Returns @code{dest}.
+ * @deftypefun {void *} jit_memmove (void address@hidden, const void
address@hidden, unsigned int @var{len})
+ * Copy the @var{len} bytes at @var{src} to @var{dest} and handle
+ * overlapping blocks correctly. Returns @var{dest}.
* @end deftypefun
@*/
void *jit_memmove(void *dest, const void *src, unsigned int len)
@@ -121,8 +121,8 @@
}
/*@
- * @deftypefun int jit_memcmp ({const void *} s1, {const void *} s2, {unsigned
int} len)
- * Compare @code{len} bytes at @code{s1} and @code{s2}, returning a negative,
+ * @deftypefun int jit_memcmp (const void address@hidden, const void
address@hidden, unsigned int @var{len})
+ * Compare @var{len} bytes at @var{s1} and @var{s2}, returning a negative,
* zero, or positive result depending upon their relationship. It is
* system-specific as to whether this function uses signed or unsigned
* byte comparisons.
@@ -152,9 +152,9 @@
}
/*@
- * @deftypefun {void *} jit_memchr ({void *} str, int ch, {unsigned int} len)
- * Search the @code{len} bytes at @code{str} for the first instance of
- * the value @code{ch}. Returns the location of @code{ch} if it was found,
+ * @deftypefun {void *} jit_memchr (void address@hidden, int @var{ch},
unsigned int @var{len})
+ * Search the @var{len} bytes at @var{str} for the first instance of
+ * the value @var{ch}. Returns the location of @var{ch} if it was found,
* or NULL if it was not found.
* @end deftypefun
@*/
Index: jit/jit-meta.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-meta.c,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -b -r1.1.1.1 -r1.2
--- jit/jit-meta.c 30 Apr 2004 23:30:20 -0000 1.1.1.1
+++ jit/jit-meta.c 22 Jan 2008 06:09:08 -0000 1.2
@@ -44,13 +44,13 @@
@*/
/*@
- * @deftypefun int jit_meta_set ({jit_meta_t *}list, int type, {void *}data,
jit_meta_free_func free_data, jit_function_t pool_owner)
- * Set a metadata value on a list. If the @code{type} is already present
- * in the list, then its previous value will be freed. The @code{free_func}
+ * @deftypefun int jit_meta_set (jit_meta_t address@hidden, int @var{type},
void address@hidden, jit_meta_free_func @var{free_data}, jit_function_t
@var{pool_owner})
+ * Set a metadata value on a list. If the @var{type} is already present
+ * in the list, then its previous value will be freed. The @var{free_func}
* is called when the metadata value is freed with @code{jit_meta_free}
* or @code{jit_meta_destroy}. Returns zero if out of memory.
*
- * If @code{pool_owner} is not NULL, then the metadata value will persist
+ * If @var{pool_owner} is not NULL, then the metadata value will persist
* until the specified function is finished building. Normally you would
* set this to NULL.
*
@@ -111,9 +111,9 @@
}
/*@
- * @deftypefun {void *} jit_meta_get (jit_meta_t list, int type)
- * Get the value associated with @code{type} in the specified @code{list}.
- * Returns NULL if @code{type} is not present.
+ * @deftypefun {void *} jit_meta_get (jit_meta_t @var{list}, int @var{type})
+ * Get the value associated with @var{type} in the specified @var{list}.
+ * Returns NULL if @var{type} is not present.
* @end deftypefun
@*/
void *jit_meta_get(jit_meta_t list, int type)
@@ -130,9 +130,9 @@
}
/*@
- * @deftypefun void jit_meta_free ({jit_meta_t *} list, int type)
- * Free the metadata value in the @code{list} that has the
- * specified @code{type}. Does nothing if the @code{type}
+ * @deftypefun void jit_meta_free (jit_meta_t address@hidden, int @var{type})
+ * Free the metadata value in the @var{list} that has the
+ * specified @var{type}. Does nothing if the @var{type}
* is not present.
* @end deftypefun
@*/
@@ -177,8 +177,8 @@
}
/*@
- * @deftypefun void jit_meta_destroy ({jit_meta_t *}list)
- * Destroy all of the metadata values in the specified @code{list}.
+ * @deftypefun void jit_meta_destroy (jit_meta_t address@hidden)
+ * Destroy all of the metadata values in the specified @var{list}.
* @end deftypefun
@*/
void jit_meta_destroy(jit_meta_t *list)
Index: jit/jit-objmodel.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-objmodel.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -b -r1.1 -r1.2
--- jit/jit-objmodel.c 14 May 2004 07:10:59 -0000 1.1
+++ jit/jit-objmodel.c 22 Jan 2008 06:09:09 -0000 1.2
@@ -52,7 +52,7 @@
@*/
/*@
- * @deftypefun void jitom_destroy_model (jit_objmodel_t model)
+ * @deftypefun void jitom_destroy_model (jit_objmodel_t @var{model})
* Destroy an object model handler that is no longer required.
* It is undefined what will happen to the objects and classes
* that were being managed by the object model: they may still persist,
@@ -68,9 +68,9 @@
}
/*@
- * @deftypefun jitom_class_t jitom_get_class_by_name (jit_objmodel_t model,
{const char *} name)
+ * @deftypefun jitom_class_t jitom_get_class_by_name (jit_objmodel_t
@var{model}, const char address@hidden)
* Get the class descriptor from the object model for a class
- * called @code{name}. Returns NULL if the class was not found.
+ * called @var{name}. Returns NULL if the class was not found.
* If the name includes namespace or nested scope qualifiers,
* they must be separated by periods (@code{.}).
* @end deftypefun
@@ -81,7 +81,7 @@
}
/*@
- * @deftypefun {char *} jitom_class_get_name (jit_objmodel_t model,
jitom_class_t klass)
+ * @deftypefun {char *} jitom_class_get_name (jit_objmodel_t @var{model},
jitom_class_t @var{klass})
* Get the name of a particular class. The return value must be freed
* with @code{jit_free}.
* @end deftypefun
@@ -92,7 +92,7 @@
}
/*@
- * @deftypefun int jitom_class_get_modifiers (jit_objmodel_t model,
jitom_class_t klass)
+ * @deftypefun int jitom_class_get_modifiers (jit_objmodel_t @var{model},
jitom_class_t @var{klass})
* Get the access modifiers for a particular class. The following lists
* all access modifiers, for classes, fields and methods:
*
@@ -207,7 +207,7 @@
}
/*@
- * @deftypefun jit_type_t jitom_class_get_type (jit_objmodel_t model,
jitom_class_t klass)
+ * @deftypefun jit_type_t jitom_class_get_type (jit_objmodel_t @var{model},
jitom_class_t @var{klass})
* Get the JIT type descriptor that represents pointer-based
* object references to a class. The object model handler should
* use @code{jitom_type_tag_as_class} to tag the return value.
@@ -221,7 +221,7 @@
}
/*@
- * @deftypefun jit_type_t jitom_class_get_value_type (jit_objmodel_t model,
jitom_class_t klass)
+ * @deftypefun jit_type_t jitom_class_get_value_type (jit_objmodel_t
@var{model}, jitom_class_t @var{klass})
* Get the JIT type descriptor that represents inline stack instances
* of the class. The object model handler should use
* @code{jitom_type_tag_as_value} to tag the return value.
@@ -236,8 +236,8 @@
}
/*@
- * @deftypefun jitom_class_t jitom_class_get_primary_super (jit_objmodel_t
model, jitom_class_t klass)
- * Get the primary superclass for @code{klass}. If the object model supports
+ * @deftypefun jitom_class_t jitom_class_get_primary_super (jit_objmodel_t
@var{model}, jitom_class_t @var{klass})
+ * Get the primary superclass for @var{klass}. If the object model supports
* true multiple inheritance, then this should return the first superclass.
* Note: for the purposes of this function, interfaces are not considered
* superclasses. Use @code{jitom_class_get_interfaces} instead.
@@ -250,9 +250,9 @@
}
/*@
- * @deftypefun {jitom_class_t *} jitom_class_get_all_supers (jit_objmodel_t
model, jitom_class_t klass, {unsigned int *} num)
- * Return an array of all superclasses for @code{klass}, with the number of
- * elements returned in @code{num}. Returns NULL if out of memory.
+ * @deftypefun {jitom_class_t *} jitom_class_get_all_supers (jit_objmodel_t
@var{model}, jitom_class_t @var{klass}, unsigned int address@hidden)
+ * Return an array of all superclasses for @var{klass}, with the number of
+ * elements returned in @var{num}. Returns NULL if out of memory.
* Use @code{jit_free} to free the return array.
* @end deftypefun
@*/
@@ -263,9 +263,9 @@
}
/*@
- * @deftypefun {jitom_class_t *} jitom_class_get_interfaces (jit_objmodel_t
model, jitom_class_t klass, {unsigned int *} num)
- * Return an array of all interfaces for @code{klass}, with the number
- * of elements returned in @code{num}. The list does not include interfaces
+ * @deftypefun {jitom_class_t *} jitom_class_get_interfaces (jit_objmodel_t
@var{model}, jitom_class_t @var{klass}, unsigned int address@hidden)
+ * Return an array of all interfaces for @var{klass}, with the number
+ * of elements returned in @var{num}. The list does not include interfaces
* that are declared on superclasses. Returns NULL if out of memory.
* Use @code{jit_free} to free the return array.
* @end deftypefun
@@ -277,9 +277,9 @@
}
/*@
- * @deftypefun {jitom_field_t *} jitom_class_get_fields (jit_objmodel_t model,
jitom_class_t klass, {unsigned int *} num)
- * Return an array of all fields for @code{klass}, with the number
- * of elements returned in @code{num}. The list does not include fields
+ * @deftypefun {jitom_field_t *} jitom_class_get_fields (jit_objmodel_t
@var{model}, jitom_class_t @var{klass}, unsigned int address@hidden)
+ * Return an array of all fields for @var{klass}, with the number
+ * of elements returned in @var{num}. The list does not include fields
* that are declared on superclasses. Returns NULL if out of memory.
* Use @code{jit_free} to free the return array.
* @end deftypefun
@@ -291,9 +291,9 @@
}
/*@
- * @deftypefun {jitom_method_t *} jitom_class_get_methods (jit_objmodel_t
model, jitom_class_t klass, {unsigned int *} num)
- * Return an array of all methods for @code{klass}, with the number
- * of elements returned in @code{num}. The list does not include methods
+ * @deftypefun {jitom_method_t *} jitom_class_get_methods (jit_objmodel_t
@var{model}, jitom_class_t @var{klass}, unsigned int address@hidden)
+ * Return an array of all methods for @var{klass}, with the number
+ * of elements returned in @var{num}. The list does not include methods
* that are declared on superclasses. Returns NULL if out of memory.
* Use @code{jit_free} to free the return array.
* @end deftypefun
@@ -305,11 +305,11 @@
}
/*@
- * @deftypefun jit_value_t jitom_class_new (jit_objmodel_t model,
jitom_class_t klass, jitom_method_t ctor, jit_function_t func, {jit_value_t *}
args, {unsigned int} num_args, int flags)
- * Add instructions to @code{func} to create a new instance of the
- * specified class. If @code{ctor} is not NULL, then it indicates a
- * constructor that should be invoked with the arguments in @code{args}.
- * If @code{ctor} is NULL, then memory should be allocated, but no
+ * @deftypefun jit_value_t jitom_class_new (jit_objmodel_t @var{model},
jitom_class_t @var{klass}, jitom_method_t @var{ctor}, jit_function_t
@var{func}, jit_value_t address@hidden, unsigned int @var{num_args}, int
@var{flags})
+ * Add instructions to @var{func} to create a new instance of the
+ * specified class. If @var{ctor} is not NULL, then it indicates a
+ * constructor that should be invoked with the arguments in @var{args}.
+ * If @var{ctor} is NULL, then memory should be allocated, but no
* constructor should be invoked. Returns a JIT value representing
* the newly allocated object. The type of the value will be the same
* as the the result from @code{jitom_class_get_type}.
@@ -325,11 +325,11 @@
}
/*@
- * @deftypefun jit_value_t jitom_class_new_value (jit_objmodel_t model,
jitom_class_t klass, jitom_method_t ctor, jit_function_t func, {jit_value_t *}
args, {unsigned int} num_args, int flags)
- * Add instructions to @code{func} to create a new instance of the
- * specified class, inline on the stack. If @code{ctor} is not NULL, then
+ * @deftypefun jit_value_t jitom_class_new_value (jit_objmodel_t @var{model},
jitom_class_t @var{klass}, jitom_method_t @var{ctor}, jit_function_t
@var{func}, jit_value_t address@hidden, unsigned int @var{num_args}, int
@var{flags})
+ * Add instructions to @var{func} to create a new instance of the
+ * specified class, inline on the stack. If @var{ctor} is not NULL, then
* it indicates a constructor that should be invoked with the arguments
- * in @code{args}. If @code{ctor} is NULL, then stack space should be
+ * in @var{args}. If @var{ctor} is NULL, then stack space should be
* allocated, but no constructor should be invoked. Returns a JIT
* value representing the newly allocated stack space. The type of the
* value will be the same as the the result from
@@ -346,9 +346,9 @@
}
/*@
- * @deftypefun int jitom_class_delete (jit_objmodel_t model, jitom_class_t
klass, jit_value_t obj_value)
+ * @deftypefun int jitom_class_delete (jit_objmodel_t @var{model},
jitom_class_t @var{klass}, jit_value_t @var{obj_value})
* Delete an instance of a particular class, calling the destructor if
- * necessary. The @code{obj_value} may be an inline stack value,
+ * necessary. The @var{obj_value} may be an inline stack value,
* in which case the destructor is called, but the memory is not freed.
* Ignored if the class does not have the @code{JITOM_MODIFIER_DELETE}
* modifier.
@@ -365,7 +365,7 @@
}
/*@
- * @deftypefun int jitom_class_add_ref (jit_objmodel_t model, jitom_class_t
klass, jit_value_t obj_value)
+ * @deftypefun int jitom_class_add_ref (jit_objmodel_t @var{model},
jitom_class_t @var{klass}, jit_value_t @var{obj_value})
* Add a reference to a reference-counted object. Ignored if the
* class does not have the @code{JITOM_MODIFIER_REFERENCE_COUNTED} modifier,
* or the value is stored inline on the stack.
@@ -381,7 +381,7 @@
}
/*@
- * @deftypefun {char *} jitom_field_get_name (jit_objmodel_t model,
jitom_class_t klass, jitom_field_t field)
+ * @deftypefun {char *} jitom_field_get_name (jit_objmodel_t @var{model},
jitom_class_t @var{klass}, jitom_field_t @var{field})
* Get the name of a particular object model field. The return value must
* be freed with @code{jit_free}.
* @end deftypefun
@@ -393,7 +393,7 @@
}
/*@
- * @deftypefun jit_type_t jitom_field_get_type (jit_objmodel_t model,
jitom_class_t klass, jitom_field_t field)
+ * @deftypefun jit_type_t jitom_field_get_type (jit_objmodel_t @var{model},
jitom_class_t @var{klass}, jitom_field_t @var{field})
* Get the type of a particular object model field.
* @end deftypefun
@*/
@@ -404,7 +404,7 @@
}
/*@
- * @deftypefun int jitom_field_get_modifiers (jit_objmodel_t model,
jitom_class_t klass, jitom_field_t field)
+ * @deftypefun int jitom_field_get_modifiers (jit_objmodel_t @var{model},
jitom_class_t @var{klass}, jitom_field_t @var{field})
* Get the access modifiers that are associated with a particular
* object model field.
* @end deftypefun
@@ -416,9 +416,9 @@
}
/*@
- * @deftypefun jit_value_t jitom_field_load (jit_objmodel_t model,
jitom_class_t klass, jitom_field_t field, jit_function_t func, jit_value_t
obj_value)
- * Create instructions within @code{func} to effect a load from a
- * field within the object @code{obj_value}. If @code{obj_value} is
+ * @deftypefun jit_value_t jitom_field_load (jit_objmodel_t @var{model},
jitom_class_t @var{klass}, jitom_field_t @var{field}, jit_function_t
@var{func}, jit_value_t @var{obj_value})
+ * Create instructions within @var{func} to effect a load from a
+ * field within the object @var{obj_value}. If @var{obj_value} is
* NULL, then it indicates a static field reference.
*
* If the field has the @code{JITOM_MODIFIER_LITERAL} modifier, then this
@@ -434,9 +434,9 @@
}
/*@
- * @deftypefun jit_value_t jitom_field_load_address (jit_objmodel_t model,
jitom_class_t klass, jitom_field_t field, jit_function_t func, jit_value_t
obj_value)
- * Create instructions within @code{func} to get the address of a
- * field within the object @code{obj_value}. If @code{obj_value} is
+ * @deftypefun jit_value_t jitom_field_load_address (jit_objmodel_t
@var{model}, jitom_class_t @var{klass}, jitom_field_t @var{field},
jit_function_t @var{func}, jit_value_t @var{obj_value})
+ * Create instructions within @var{func} to get the address of a
+ * field within the object @var{obj_value}. If @var{obj_value} is
* NULL, then it indicates that we want the address of a static field.
* Some object models may not support this function, and will return NULL.
* @end deftypefun
@@ -450,9 +450,9 @@
}
/*@
- * @deftypefun int jitom_field_store (jit_objmodel_t model, jitom_class_t
klass, jitom_field_t field, jit_function_t func, jit_value_t obj_value,
jit_value_t value)
- * Create instructions within @code{func} to store @code{value} into a
- * field within the object @code{obj_value}. If @code{obj_value} is
+ * @deftypefun int jitom_field_store (jit_objmodel_t @var{model},
jitom_class_t @var{klass}, jitom_field_t @var{field}, jit_function_t
@var{func}, jit_value_t @var{obj_value}, jit_value_t @var{value})
+ * Create instructions within @var{func} to store @var{value} into a
+ * field within the object @var{obj_value}. If @var{obj_value} is
* NULL, then it indicates a static field store.
* @end deftypefun
@*/
@@ -465,7 +465,7 @@
}
/*@
- * @deftypefun {char *} jitom_method_get_name (jit_objmodel_t model,
jitom_class_t klass, jitom_method_t method)
+ * @deftypefun {char *} jitom_method_get_name (jit_objmodel_t @var{model},
jitom_class_t @var{klass}, jitom_method_t @var{method})
* Get the name of an object model method. The return value must
* be freed with @code{jit_free}.
* @end deftypefun
@@ -477,7 +477,7 @@
}
/*@
- * @deftypefun jit_type_t jitom_method_get_type (jit_objmodel_t model,
jitom_class_t klass, jitom_method_t method)
+ * @deftypefun jit_type_t jitom_method_get_type (jit_objmodel_t @var{model},
jitom_class_t @var{klass}, jitom_method_t @var{method})
* Get the signature type of an object model method. If the method
* is instance-based, then the first argument will be an object reference
* type indicating the @code{this} pointer.
@@ -490,7 +490,7 @@
}
/*@
- * @deftypefun int jitom_method_get_modifiers (jit_objmodel_t model,
jitom_class_t klass, jitom_method_t method)
+ * @deftypefun int jitom_method_get_modifiers (jit_objmodel_t @var{model},
jitom_class_t @var{klass}, jitom_method_t @var{method})
* Get the access modifiers for an object model method.
* @end deftypefun
@*/
@@ -501,11 +501,11 @@
}
/*@
- * @deftypefun jit_value_t jitom_method_invoke (jit_objmodel_t model,
jitom_class_t klass, jitom_method_t method, jit_function_t func, {jit_value_t
*} args, {unsigned int} num_args, int flags)
- * Create instructions within @code{func} to invoke a static or
+ * @deftypefun jit_value_t jitom_method_invoke (jit_objmodel_t @var{model},
jitom_class_t @var{klass}, jitom_method_t @var{method}, jit_function_t
@var{func}, jit_value_t address@hidden, unsigned int @var{num_args}, int
@var{flags})
+ * Create instructions within @var{func} to invoke a static or
* instance method. If an instance method is virtual, then this will
* ignore the virtual property to invoke the designated method directly.
- * The first element in @code{args} should be the @code{this} pointer
+ * The first element in @var{args} should be the @code{this} pointer
* for instance methods.
* @end deftypefun
@*/
@@ -518,9 +518,9 @@
}
/*@
- * @deftypefun jit_value_t jitom_method_invoke_virtual (jit_objmodel_t model,
jitom_class_t klass, jitom_method_t method, jit_function_t func, {jit_value_t
*} args, {unsigned int} num_args, int flags)
- * Create instructions within @code{func} to invoke a virtual or interface
- * method. The first element in @code{args} should be the @code{this}
+ * @deftypefun jit_value_t jitom_method_invoke_virtual (jit_objmodel_t
@var{model}, jitom_class_t @var{klass}, jitom_method_t @var{method},
jit_function_t @var{func}, jit_value_t address@hidden, unsigned int
@var{num_args}, int @var{flags})
+ * Create instructions within @var{func} to invoke a virtual or interface
+ * method. The first element in @var{args} should be the @code{this}
* pointer for the call.
* @end deftypefun
@*/
@@ -543,7 +543,7 @@
} jitom_tag_info;
/*@
- * @deftypefun jit_type_t jitom_type_tag_as_class (jit_type_t type,
jit_objmodel_t model, jitom_class_t klass, int incref)
+ * @deftypefun jit_type_t jitom_type_tag_as_class (jit_type_t @var{type},
jit_objmodel_t @var{model}, jitom_class_t @var{klass}, int @var{incref})
* Tag a JIT type as an object reference belonging to a specific class.
* Returns NULL if there is insufficient memory to tag the type.
* @end deftypefun
@@ -568,7 +568,7 @@
}
/*@
- * @deftypefun jit_type_t jitom_type_tag_as_value (jit_type_t type,
jit_objmodel_t model, jitom_class_t klass, int incref)
+ * @deftypefun jit_type_t jitom_type_tag_as_value (jit_type_t @var{type},
jit_objmodel_t @var{model}, jitom_class_t @var{klass}, int @var{incref})
* Tag a JIT type as an inline static value belonging to a specific class.
* Returns NULL if there is insufficient memory to tag the type.
* @end deftypefun
@@ -593,7 +593,7 @@
}
/*@
- * @deftypefun int jitom_type_is_class (jit_type_t type)
+ * @deftypefun int jitom_type_is_class (jit_type_t @var{type})
* Determine if a type is tagged as an object reference.
* @end deftypefun
@*/
@@ -603,7 +603,7 @@
}
/*@
- * @deftypefun int jitom_type_is_value (jit_type_t type)
+ * @deftypefun int jitom_type_is_value (jit_type_t @var{type})
* Determine if a type is tagged as an inline static value.
* @end deftypefun
@*/
@@ -613,7 +613,7 @@
}
/*@
- * @deftypefun jit_objmodel_t jitom_type_get_model (jit_type_t type)
+ * @deftypefun jit_objmodel_t jitom_type_get_model (jit_type_t @var{type})
* Get the object model associated with a type that was tagged with
* @code{jitom_type_tag_as_class} or @code{jitom_type_tag_as_value}.
* @end deftypefun
@@ -632,7 +632,7 @@
}
/*@
- * @deftypefun jitom_class_t jitom_type_get_class (jit_type_t type)
+ * @deftypefun jitom_class_t jitom_type_get_class (jit_type_t @var{type})
* Get the class associated with a type that was tagged with
* @code{jitom_type_tag_as_class} or @code{jitom_type_tag_as_value}.
* @end deftypefun
Index: jit/jit-rules-interp.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-rules-interp.c,v
retrieving revision 1.32
retrieving revision 1.33
diff -u -b -r1.32 -r1.33
--- jit/jit-rules-interp.c 3 Jan 2008 17:01:16 -0000 1.32
+++ jit/jit-rules-interp.c 22 Jan 2008 06:09:09 -0000 1.33
@@ -106,28 +106,38 @@
@item JIT_REG_CALL_USED
This register will be destroyed by a function call.
address@hidden JIT_REG_START_STACK
-This register is the start of a range of registers that are used in a
-stack-like arrangement. Operations can typically only occur at the
-top of the stack, and may automatically pop values as a side-effect
-of the operation. The stack continues until the next register that is
-marked with @code{JIT_REG_END_STACK}. The starting register must
-also have the @code{JIT_REG_IN_STACK} flag set.
-
address@hidden JIT_REG_END_STACK
-This register is the end of a range of registers that are used in a
-stack-like arrangement. The ending register must also have the
address@hidden flag set.
-
@item JIT_REG_IN_STACK
-This register is in a stack-like arrangement. If neither
address@hidden or @code{JIT_REG_END_STACK} is present,
-then the register is in the "middle" of the stack.
+This register is in a stack-like arrangement.
@item JIT_REG_GLOBAL
This register is a candidate for global register allocation.
@end table
+A CPU may have some registers arranged into a stack. In this case
+operations can typically only occur at the top of the stack, and
+may automatically pop values as a side-effect of the operation.
+An example of such architecture is x87 floating point unit. Such
+CPU requires three additional macros.
+
address@hidden @code
+
address@hidden JIT_REG_STACK
+If defined, this indicates the presence of the register stack.
+
address@hidden JIT_REG_STACK_START
+The index of the first register in the @code{JIT_REG_INFO} array that is used
+in a stack-like arrangement.
+
address@hidden JIT_REG_STACK_END
+The index of the last register in the @code{JIT_REG_INFO} array that is used
+in a stack-like arrangement.
+
address@hidden table
+
+The entries in the @code{JIT_REG_INFO} array from @code{JIT_REG_STACK_START}
+up to @code{JIT_REG_STACK_END} must also have the @code{JIT_REG_IN_STACK}
+flag set.
+
@subsection Other architecture macros
@noindent
@@ -221,7 +231,7 @@
}
/*@
- * @deftypefun void _jit_gen_get_elf_info ({jit_elf_info_t *} info)
+ * @deftypefun void _jit_gen_get_elf_info (jit_elf_info_t address@hidden)
* Get the ELF machine and ABI type information for this platform.
* The @code{machine} field should be set to one of the @code{EM_*}
* values in @code{jit-elf-defs.h}. The @code{abi} field should
@@ -241,7 +251,7 @@
}
/*@
- * @deftypefun int _jit_create_entry_insns (jit_function_t func)
+ * @deftypefun int _jit_create_entry_insns (jit_function_t @var{func})
* Create instructions in the entry block to initialize the
* registers and frame offsets that contain the parameters.
* Returns zero if out of memory.
@@ -361,20 +371,20 @@
}
/*@
- * @deftypefun int _jit_create_call_setup_insns (jit_function_t func,
jit_type_t signature, {jit_value_t *} args, {unsigned int} num_args, int
is_nested, int nested_level, jit_value_t *struct_return, int flags)
- * Create instructions within @code{func} necessary to set up for a
- * function call to a function with the specified @code{signature}.
+ * @deftypefun int _jit_create_call_setup_insns (jit_function_t @var{func},
jit_type_t @var{signature}, jit_value_t address@hidden, unsigned int
@var{num_args}, int @var{is_nested}, int @var{nested_level}, jit_value_t
address@hidden, int @var{flags})
+ * Create instructions within @var{func} necessary to set up for a
+ * function call to a function with the specified @var{signature}.
* Use @code{jit_insn_push} to push values onto the system stack,
* or @code{jit_insn_outgoing_reg} to copy values into call registers.
*
- * If @code{is_nested} is non-zero, then it indicates that we are calling a
+ * If @var{is_nested} is non-zero, then it indicates that we are calling a
* nested function within the current function's nested relationship tree.
- * The @code{nested_level} value will be -1 to call a child, zero to call a
- * sibling of @code{func}, 1 to call a sibling of the parent, 2 to call
+ * The @var{nested_level} value will be -1 to call a child, zero to call a
+ * sibling of @var{func}, 1 to call a sibling of the parent, 2 to call
* a sibling of the grandparent, etc. The @code{jit_insn_setup_for_nested}
* instruction should be used to create the nested function setup code.
*
- * If the function returns a structure by pointer, then @code{struct_return}
+ * If the function returns a structure by pointer, then @var{struct_return}
* must be set to a new local variable that will contain the returned
* structure. Otherwise it should be set to NULL.
* @end deftypefun
@@ -525,8 +535,8 @@
}
/*@
- * @deftypefun int _jit_setup_indirect_pointer (jit_function_t func,
jit_value_t value)
- * Place the indirect function pointer @code{value} into a suitable register
+ * @deftypefun int _jit_setup_indirect_pointer (jit_function_t @var{func},
jit_value_t @var{value})
+ * Place the indirect function pointer @var{value} into a suitable register
* or stack location for a subsequent indirect call.
* @end deftypefun
@*/
@@ -537,16 +547,16 @@
}
/*@
- * @deftypefun int _jit_create_call_return_insns (jit_function_t func,
jit_type_t signature, jit_value_t *args, unsigned int num_args, jit_value_t
return_value, int is_nested)
- * Create instructions within @code{func} to clean up after a function call
- * and to place the function's result into @code{return_value}.
+ * @deftypefun int _jit_create_call_return_insns (jit_function_t @var{func},
jit_type_t @var{signature}, jit_value_t address@hidden, unsigned int
@var{num_args}, jit_value_t @var{return_value}, int @var{is_nested})
+ * Create instructions within @var{func} to clean up after a function call
+ * and to place the function's result into @var{return_value}.
* This should use @code{jit_insn_pop_stack} to pop values off the system
* stack and @code{jit_insn_return_reg} to tell @code{libjit} which
* register contains the return value. In the case of a @code{void}
- * function, @code{return_value} will be NULL.
+ * function, @var{return_value} will be NULL.
*
* Note: the argument values are passed again because it may not be possible
- * to determine how many bytes to pop from the stack from the @code{signature}
+ * to determine how many bytes to pop from the stack from the @var{signature}
* alone; especially if the called function is vararg.
* @end deftypefun
@*/
@@ -617,7 +627,7 @@
}
/*@
- * @deftypefun int _jit_opcode_is_supported (int opcode)
+ * @deftypefun int _jit_opcode_is_supported (int @var{opcode})
* Not all CPU's support all arithmetic, conversion, bitwise, or
* comparison operators natively. For example, most ARM platforms
* need to call out to helper functions to perform floating-point.
@@ -684,10 +694,10 @@
}
/*@
- * @deftypefun {void *} _jit_gen_prolog (jit_gencode_t gen, jit_function_t
func, {void *} buf)
+ * @deftypefun {void *} _jit_gen_prolog (jit_gencode_t @var{gen},
jit_function_t @var{func}, void address@hidden)
* Generate the prolog for a function into a previously-prepared
* buffer area of @code{JIT_PROLOG_SIZE} bytes in size. Returns
- * the start of the prolog, which may be different than @code{buf}.
+ * the start of the prolog, which may be different than @var{buf}.
*
* This function is called at the end of the code generation process,
* not the beginning. At this point, it is known which callee save
@@ -710,7 +720,7 @@
}
/*@
- * @deftypefun void _jit_gen_epilog (jit_gencode_t gen, jit_function_t func)
+ * @deftypefun void _jit_gen_epilog (jit_gencode_t @var{gen}, jit_function_t
@var{func})
* Generate a function epilog, restoring the registers that
* were saved on entry to the function, and then returning.
*
@@ -727,9 +737,9 @@
}
/*@
- * @deftypefun {void *} _jit_gen_redirector (jit_gencode_t gen, jit_function_t
func)
+ * @deftypefun {void *} _jit_gen_redirector (jit_gencode_t @var{gen},
jit_function_t @var{func})
* Generate code for a redirector, which makes an indirect jump
- * to the contents of @code{func->entry_point}. Redirectors
+ * to the contents of @address@hidden>entry_point}. Redirectors
* are used on recompilable functions in place of the regular
* entry point. This allows @code{libjit} to redirect existing
* calls to the new version after recompilation.
@@ -742,9 +752,9 @@
}
/*@
- * @deftypefun void _jit_gen_spill_reg (jit_gencode_t gen, int reg, int
other_reg, jit_value_t value)
+ * @deftypefun void _jit_gen_spill_reg (jit_gencode_t @var{gen}, int
@var{reg}, int @var{other_reg}, jit_value_t @var{value})
* Generate instructions to spill a pseudo register to the local
- * variable frame. If @code{other_reg} is not -1, then it indicates
+ * variable frame. If @var{other_reg} is not -1, then it indicates
* the second register in a 64-bit register pair.
*
* This function will typically call @code{_jit_gen_fix_value} to
@@ -759,10 +769,10 @@
}
/*@
- * @deftypefun void _jit_gen_free_reg (jit_gencode_t gen, int reg, int
other_reg, int value_used)
+ * @deftypefun void _jit_gen_free_reg (jit_gencode_t @var{gen}, int @var{reg},
int @var{other_reg}, int @var{value_used})
* Generate instructions to free a register without spilling its value.
* This is called when a register's contents become invalid, or its
- * value is no longer required. If @code{value_used} is set to a non-zero
+ * value is no longer required. If @var{value_used} is set to a non-zero
* value, then it indicates that the register's value was just used.
* Otherwise, there is a value in the register but it was never used.
*
@@ -779,7 +789,7 @@
}
/*@
- * @deftypefun void _jit_gen_load_value (jit_gencode_t gen, int reg, int
other_reg, jit_value_t value)
+ * @deftypefun void _jit_gen_load_value (jit_gencode_t @var{gen}, int
@var{reg}, int @var{other_reg}, jit_value_t @var{value})
* Generate instructions to load a value into a register. The value will
* either be a constant or a slot in the frame. You should fix frame slots
* with @code{_jit_gen_fix_value}.
@@ -792,8 +802,8 @@
}
/*@
- * @deftypefun void _jit_gen_spill_global (jit_gencode_t gen, jit_value_t
value)
- * Spill the contents of @code{value} from its corresponding global register.
+ * @deftypefun void _jit_gen_spill_global (jit_gencode_t @var{gen}, int
@var{reg}, jit_value_t @var{value})
+ * Spill the contents of @var{value} from its corresponding global register.
* This is used in rare cases when a machine instruction requires its operand
* to be in the specific register that happens to be global. In such cases the
* register is spilled just before the instruction and loaded back immediately
@@ -806,8 +816,8 @@
}
/*@
- * @deftypefun void _jit_gen_load_global (jit_gencode_t gen, jit_value_t value)
- * Load the contents of @code{value} into its corresponding global register.
+ * @deftypefun void _jit_gen_load_global (jit_gencode_t @var{gen}, int
@var{reg}, jit_value_t @var{value})
+ * Load the contents of @var{value} into its corresponding global register.
* This is used at the head of a function to pull parameters out of stack
* slots into their global register copies.
* @end deftypefun
@@ -818,9 +828,9 @@
}
/*@
- * @deftypefun void _jit_gen_exch_top (jit_gencode_t gen, int reg)
+ * @deftypefun void _jit_gen_exch_top (jit_gencode_t @var{gen}, int @var{reg})
* Generate instructions to exchange the contents of the top stack register
- * with a stack register specified by the @code{reg} argument.
+ * with a stack register specified by the @var{reg} argument.
*
* It needs to be implemented only by backends that support stack registers.
* @end deftypefun
@@ -831,7 +841,7 @@
}
/*@
- * @deftypefun void _jit_gen_move_top (jit_gencode_t gen, int reg)
+ * @deftypefun void _jit_gen_move_top (jit_gencode_t @var{gen}, int @var{reg})
* Generate instructions to copy the contents of the top stack register
* into a stack register specified by the @code{reg} argument and pop
* the top register after this. If @code{reg} is equal to the top register
@@ -846,9 +856,9 @@
}
/*@
- * @deftypefun void _jit_gen_spill_top (jit_gencode_t gen, int reg,
jit_value_t value, int pop)
+ * @deftypefun void _jit_gen_spill_top (jit_gencode_t @var{gen}, int
@var{reg}, jit_value_t @var{value}, int @var{pop})
* Generate instructions to spill the top stack register to the local
- * variable frame. The @code{pop} argument indicates if the top register
+ * variable frame. The @var{pop} argument indicates if the top register
* is popped from the stack.
*
* It needs to be implemented only by backends that support stack registers.
@@ -860,7 +870,7 @@
}
/*@
- * @deftypefun void _jit_gen_fix_value (jit_value_t value)
+ * @deftypefun void _jit_gen_fix_value (jit_value_t @var{value})
* Fix the position of a value within the local variable frame.
* If it doesn't already have a position, then assign one for it.
* @end deftypefun
@@ -1017,8 +1027,8 @@
}
/*@
- * @deftypefun void _jit_gen_insn (jit_gencode_t gen, jit_function_t func,
jit_block_t block, jit_insn_t insn)
- * Generate native code for the specified @code{insn}. This function should
+ * @deftypefun void _jit_gen_insn (jit_gencode_t @var{gen}, jit_function_t
@var{func}, jit_block_t @var{block}, jit_insn_t @var{insn})
+ * Generate native code for the specified @var{insn}. This function should
* call the appropriate register allocation routines, output the instruction,
* and then arrange for the result to be placed in an appropriate register
* or memory destination.
@@ -1560,7 +1570,7 @@
}
/*@
- * @deftypefun void _jit_gen_start_block (jit_gencode_t gen, jit_block_t block)
+ * @deftypefun void _jit_gen_start_block (jit_gencode_t @var{gen}, jit_block_t
@var{block})
* Called to notify the back end that the start of a basic block
* has been reached.
* @end deftypefun
@@ -1602,7 +1612,7 @@
}
/*@
- * @deftypefun void _jit_gen_end_block (jit_gencode_t gen)
+ * @deftypefun void _jit_gen_end_block (jit_gencode_t @var{gen})
* Called to notify the back end that the end of a basic block
* has been reached.
* @end deftypefun
@@ -1614,8 +1624,8 @@
}
/*@
- * @deftypefun int _jit_gen_is_global_candidate (jit_type_t type)
- * Determine if @code{type} is a candidate for allocation within
+ * @deftypefun int _jit_gen_is_global_candidate (jit_type_t @var{type})
+ * Determine if @var{type} is a candidate for allocation within
* global registers.
* @end deftypefun
@*/
Index: jit/jit-string.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-string.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -b -r1.2 -r1.3
--- jit/jit-string.c 8 May 2004 01:10:23 -0000 1.2
+++ jit/jit-string.c 22 Jan 2008 06:09:09 -0000 1.3
@@ -43,8 +43,8 @@
@*/
/*@
- * @deftypefun {unsigned int} jit_strlen ({const char *} str)
- * Returns the length of @code{str}.
+ * @deftypefun {unsigned int} jit_strlen (const char address@hidden)
+ * Returns the length of @var{str}.
* @end deftypefun
@*/
unsigned int jit_strlen(const char *str)
@@ -62,8 +62,8 @@
}
/*@
- * @deftypefun {char *} jit_strcpy ({char *} dest, {const char *} src)
- * Copy the string at @code{src} to @code{dest}. Returns @code{dest}.
+ * @deftypefun {char *} jit_strcpy (char address@hidden, const char
address@hidden)
+ * Copy the string at @var{src} to @var{dest}. Returns @var{dest}.
* @end deftypefun
@*/
char *jit_strcpy(char *dest, const char *src)
@@ -83,9 +83,9 @@
}
/*@
- * @deftypefun {char *} jit_strcat ({char *} dest, {const char *} src)
- * Copy the string at @code{src} to the end of the string at @code{dest}.
- * Returns @code{dest}.
+ * @deftypefun {char *} jit_strcat (char address@hidden, const char
address@hidden)
+ * Copy the string at @var{src} to the end of the string at @var{dest}.
+ * Returns @var{dest}.
* @end deftypefun
@*/
char *jit_strcat(char *dest, const char *src)
@@ -105,9 +105,9 @@
}
/*@
- * @deftypefun {char *} jit_strncpy ({char *} dest, {const char *} src,
{unsigned int} len)
- * Copy at most @code{len} characters from the string at @code{src} to
- * @code{dest}. Returns @code{dest}.
+ * @deftypefun {char *} jit_strncpy (char address@hidden, const char
address@hidden, unsigned int @var{len})
+ * Copy at most @var{len} characters from the string at @var{src} to
+ * @var{dest}. Returns @var{dest}.
* @end deftypefun
@*/
char *jit_strncpy(char *dest, const char *src, unsigned int len)
@@ -132,9 +132,9 @@
}
/*@
- * @deftypefun {char *} jit_strdup ({const char *} str)
+ * @deftypefun {char *} jit_strdup (const char address@hidden)
* Allocate a block of memory using @code{jit_malloc} and copy
- * @code{str} into it. Returns NULL if @code{str} is NULL or there
+ * @var{str} into it. Returns NULL if @var{str} is NULL or there
* is insufficient memory to perform the @code{jit_malloc} operation.
* @end deftypefun
@*/
@@ -155,10 +155,10 @@
}
/*@
- * @deftypefun {char *} jit_strndup ({const char *} str, unsigned int len)
+ * @deftypefun {char *} jit_strndup (const char address@hidden, unsigned int
@var{len})
* Allocate a block of memory using @code{jit_malloc} and copy at most
- * @code{len} characters of @code{str} into it. The copied string is then
- * NULL-terminated. Returns NULL if @code{str} is NULL or there
+ * @var{len} characters of @var{str} into it. The copied string is then
+ * NULL-terminated. Returns NULL if @var{str} is NULL or there
* is insufficient memory to perform the @code{jit_malloc} operation.
* @end deftypefun
@*/
@@ -180,8 +180,8 @@
}
/*@
- * @deftypefun int jit_strcmp ({const char *} str1, {const char *} str2)
- * Compare the two strings @code{str1} and @code{str2}, returning
+ * @deftypefun int jit_strcmp (const char address@hidden, const char
address@hidden)
+ * Compare the two strings @var{str1} and @var{str2}, returning
* a negative, zero, or positive value depending upon their relationship.
* @end deftypefun
@*/
@@ -205,10 +205,10 @@
}
/*@
- * @deftypefun int jit_strncmp ({const char *} str1, {const char *} str2,
{unsigned int} len)
- * Compare the two strings @code{str1} and @code{str2}, returning
+ * @deftypefun int jit_strncmp (const char address@hidden, const char
address@hidden, unsigned int @var{len})
+ * Compare the two strings @var{str1} and @var{str2}, returning
* a negative, zero, or positive value depending upon their relationship.
- * At most @code{len} characters are compared.
+ * At most @var{len} characters are compared.
* @end deftypefun
@*/
int jit_strncmp(const char *str1, const char *str2, unsigned int len)
@@ -232,8 +232,8 @@
}
/*@
- * @deftypefun int jit_stricmp ({const char *} str1, {const char *} str2)
- * Compare the two strings @code{str1} and @code{str2}, returning
+ * @deftypefun int jit_stricmp (const char address@hidden, const char
address@hidden)
+ * Compare the two strings @var{str1} and @var{str2}, returning
* a negative, zero, or positive value depending upon their relationship.
* Instances of the English letters A to Z are converted into their
* lower case counterparts before comparison.
@@ -271,10 +271,10 @@
}
/*@
- * @deftypefun int jit_strnicmp ({const char *} str1, {const char *} str2,
{unsigned int} len)
- * Compare the two strings @code{str1} and @code{str2}, returning
+ * @deftypefun int jit_strnicmp (const char address@hidden, const char
address@hidden, unsigned int @var{len})
+ * Compare the two strings @var{str1} and @var{str2}, returning
* a negative, zero, or positive value depending upon their relationship.
- * At most @code{len} characters are compared. Instances of the English
+ * At most @var{len} characters are compared. Instances of the English
* letters A to Z are converted into their lower case counterparts
* before comparison.
* @end deftypefun
@@ -304,9 +304,9 @@
}
/*@
- * @deftypefun {char *} jit_strchr ({const char *} str, int ch)
- * Search @code{str} for the first occurrence of @code{ch}. Returns
- * the address where @code{ch} was found, or NULL if not found.
+ * @deftypefun {char *} jit_strchr (const char address@hidden, int @var{ch})
+ * Search @var{str} for the first occurrence of @var{ch}. Returns
+ * the address where @var{ch} was found, or NULL if not found.
* @end deftypefun
@*/
char *jit_strchr(const char *str, int ch)
@@ -332,9 +332,9 @@
}
/*@
- * @deftypefun {char *} jit_strrchr ({const char *} str, int ch)
- * Search @code{str} for the first occurrence of @code{ch}, starting
- * at the end of the string. Returns the address where @code{ch}
+ * @deftypefun {char *} jit_strrchr (const char address@hidden, int @var{ch})
+ * Search @var{str} for the first occurrence of @var{ch}, starting
+ * at the end of the string. Returns the address where @var{ch}
* was found, or NULL if not found.
* @end deftypefun
@*/
Index: jit/jit-type.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-type.c,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -b -r1.7 -r1.8
--- jit/jit-type.c 12 May 2004 03:00:17 -0000 1.7
+++ jit/jit-type.c 22 Jan 2008 06:09:09 -0000 1.8
@@ -418,8 +418,8 @@
}
/*@
- * @deftypefun jit_type_t jit_type_copy (jit_type_t type)
- * Make a copy of the type descriptor @code{type} by increasing
+ * @deftypefun jit_type_t jit_type_copy (jit_type_t @var{type})
+ * Make a copy of the type descriptor @var{type} by increasing
* its reference count.
* @end deftypefun
@*/
@@ -434,7 +434,7 @@
}
/*@
- * @deftypefun void jit_type_free (jit_type_t type)
+ * @deftypefun void jit_type_free (jit_type_t @var{type})
* Free a type descriptor by decreasing its reference count.
* This function is safe to use on pre-defined types, which are
* never actually freed.
@@ -511,12 +511,12 @@
}
/*@
- * @deftypefun jit_type_t jit_type_create_struct ({jit_type_t *} fields,
{unsigned int} num_fields, int incref)
+ * @deftypefun jit_type_t jit_type_create_struct (jit_type_t address@hidden,
unsigned int @var{num_fields}, int @var{incref})
* Create a type descriptor for a structure. Returns NULL if out of memory.
* If there are no fields, then the size of the structure will be zero.
* It is necessary to add a padding field if the language does not allow
* zero-sized structures. The reference counts on the field types are
- * incremented if @code{incref} is non-zero.
+ * incremented if @var{incref} is non-zero.
*
* The @code{libjit} library does not provide any special support for
* implementing structure inheritance, where one structure extends the
@@ -545,12 +545,12 @@
}
/*@
- * @deftypefun jit_type_t jit_type_create_union ({jit_type_t *} fields,
{unsigned int} num_fields, int incref)
+ * @deftypefun jit_type_t jit_type_create_union (jit_type_t address@hidden,
unsigned int @var{num_fields}, int @var{incref})
* Create a type descriptor for a union. Returns NULL if out of memory.
* If there are no fields, then the size of the union will be zero.
* It is necessary to add a padding field if the language does not allow
* zero-sized unions. The reference counts on the field types are
- * incremented if @code{incref} is non-zero.
+ * incremented if @var{incref} is non-zero.
* @end deftypefun
@*/
jit_type_t jit_type_create_union(jit_type_t *fields, unsigned int num_fields,
@@ -560,17 +560,17 @@
}
/*@
- * @deftypefun jit_type_t jit_type_create_signature (jit_abi_t abi, jit_type_t
return_type, {jit_type_t *} params, {unsigned int} num_params, int incref)
+ * @deftypefun jit_type_t jit_type_create_signature (jit_abi_t @var{abi},
jit_type_t @var{return_type}, jit_type_t address@hidden, unsigned int
@var{num_params}, int @var{incref})
* Create a type descriptor for a function signature. Returns NULL if out
* of memory. The reference counts on the component types are incremented
- * if @code{incref} is non-zero.
+ * if @var{incref} is non-zero.
*
* When used as a structure or union field, function signatures are laid
* out like pointers. That is, they represent a pointer to a function
* that has the specified parameters and return type.
*
* @tindex jit_abi_t
- * The @code{abi} parameter specifies the Application Binary Interface (ABI)
+ * The @var{abi} parameter specifies the Application Binary Interface (ABI)
* that the function uses. It may be one of the following values:
*
* @table @code
@@ -625,10 +625,10 @@
}
/*@
- * @deftypefun jit_type_t jit_type_create_pointer (jit_type_t type, int incref)
+ * @deftypefun jit_type_t jit_type_create_pointer (jit_type_t @var{type}, int
@var{incref})
* Create a type descriptor for a pointer to another type. Returns NULL
- * if out of memory. The reference count on @code{type} is incremented if
- * @code{incref} is non-zero.
+ * if out of memory. The reference count on @var{type} is incremented if
+ * @var{incref} is non-zero.
* @end deftypefun
@*/
jit_type_t jit_type_create_pointer(jit_type_t type, int incref)
@@ -658,7 +658,7 @@
}
/*@
- * @deftypefun jit_type_t jit_type_create_tagged (jit_type_t type, int kind,
{void *} data, jit_meta_free_func free_func, int incref)
+ * @deftypefun jit_type_t jit_type_create_tagged (jit_type_t @var{type}, int
@var{kind}, void address@hidden, jit_meta_free_func @var{free_func}, int
@var{incref})
* Tag a type with some additional user data. Tagging is typically used by
* higher-level programs to embed extra information about a type that
* @code{libjit} itself does not support.
@@ -670,10 +670,10 @@
* it is necessary to do so, without affecting @code{libjit}'s ability
* to compile the code efficiently.
*
- * The @code{kind} is a small positive integer value that the program
- * can use to distinguish multiple tag types. The @code{data} pointer is
- * the actual data that you wish to store. And @code{free_func} is a
- * function that is used to free @code{data} when the type is freed
+ * The @var{kind} is a small positive integer value that the program
+ * can use to distinguish multiple tag types. The @var{data} pointer is
+ * the actual data that you wish to store. And @var{free_func} is a
+ * function that is used to free @var{data} when the type is freed
* with @code{jit_type_free}.
*
* If you need to store more than one piece of information, you can
@@ -688,7 +688,7 @@
* @table @code
* @vindex JIT_TYPETAG_NAME
* @item JIT_TYPETAG_NAME
- * The @code{data} pointer is a @code{char *} string indicating a friendly
+ * The @var{data} pointer is a @code{char *} string indicating a friendly
* name to display for the type.
*
* @vindex JIT_TYPETAG_STRUCT_NAME
@@ -697,7 +697,7 @@
* @item JIT_TYPETAG_STRUCT_NAME
* @itemx JIT_TYPETAG_UNION_NAME
* @itemx JIT_TYPETAG_ENUM_NAME
- * The @code{data} pointer is a @code{char *} string indicating a friendly
+ * The @var{data} pointer is a @code{char *} string indicating a friendly
* name to display for a @code{struct}, @code{union}, or @code{enum} type.
* This is for languages like C that have separate naming scopes for
* typedef's and structures.
@@ -792,8 +792,8 @@
}
/*@
- * @deftypefun int jit_type_set_names (jit_type_t type, {char **} names,
{unsigned int} num_names)
- * Set the field or parameter names for @code{type}. Returns zero
+ * @deftypefun int jit_type_set_names (jit_type_t @var{type}, char
address@hidden, unsigned int @var{num_names})
+ * Set the field or parameter names for @var{type}. Returns zero
* if there is insufficient memory to set the names.
*
* Normally fields are accessed via their index. Field names are a
@@ -837,7 +837,7 @@
}
/*@
- * @deftypefun void jit_type_set_size_and_alignment (jit_type_t type, jit_nint
size, jit_nint alignment)
+ * @deftypefun void jit_type_set_size_and_alignment (jit_type_t @var{type},
jit_nint @var{size}, jit_nint @var{alignment})
* Set the size and alignment information for a structure or union
* type. Use this for performing explicit type layout. Normally
* the size is computed automatically. Ignored if not a
@@ -869,7 +869,7 @@
}
/*@
- * @deftypefun void jit_type_set_offset (jit_type_t type, {unsigned int}
field_index, jit_nuint offset)
+ * @deftypefun void jit_type_set_offset (jit_type_t @var{type}, unsigned int
@var{field_index}, jit_nuint @var{offset})
* Set the offset of a specific structure field. Use this for
* performing explicit type layout. Normally the offset is
* computed automatically. Ignored if not a structure type,
@@ -891,15 +891,15 @@
}
/*@
- * @deftypefun int jit_type_get_kind (jit_type_t type)
- * Get a value that indicates the kind of @code{type}. This allows
+ * @deftypefun int jit_type_get_kind (jit_type_t @var{type})
+ * Get a value that indicates the kind of @var{type}. This allows
* callers to quickly classify a type to determine how it should be
* handled further.
*
* @table @code
* @vindex JIT_TYPE_INVALID
* @item JIT_TYPE_INVALID
- * The value of the @code{type} parameter is NULL.
+ * The value of the @var{type} parameter is NULL.
*
* @vindex JIT_TYPE_VOID
* @item JIT_TYPE_VOID
@@ -978,7 +978,7 @@
* If this function returns @code{JIT_TYPE_FIRST_TAGGED} or higher,
* then the type is tagged and its tag kind is the return value minus
* @code{JIT_TYPE_FIRST_TAGGED}. That is, the following two expressions
- * will be identical if @code{type} is tagged:
+ * will be identical if @var{type} is tagged:
*
* @example
* jit_type_get_tagged_kind(type)
@@ -999,7 +999,7 @@
}
/*@
- * @deftypefun jit_nuint jit_type_get_size (jit_type_t type)
+ * @deftypefun jit_nuint jit_type_get_size (jit_type_t @var{type})
* Get the size of a type in bytes.
* @end deftypefun
@*/
@@ -1027,7 +1027,7 @@
}
/*@
- * @deftypefun jit_nuint jit_type_get_alignment (jit_type_t type)
+ * @deftypefun jit_nuint jit_type_get_alignment (jit_type_t @var{type})
* Get the alignment of a type. An alignment value of 2 indicates
* that the type should be aligned on a two-byte boundary, for example.
* @end deftypefun
@@ -1050,7 +1050,7 @@
}
/*@
- * @deftypefun {unsigned int} jit_type_num_fields (jit_type_t type)
+ * @deftypefun {unsigned int} jit_type_num_fields (jit_type_t @var{type})
* Get the number of fields in a structure or union type.
* @end deftypefun
@*/
@@ -1068,7 +1068,7 @@
}
/*@
- * @deftypefun jit_type_t jit_type_get_field (jit_type_t type, {unsigned int}
field_index)
+ * @deftypefun jit_type_t jit_type_get_field (jit_type_t @var{type}, unsigned
int @var{field_index})
* Get the type of a specific field within a structure or union.
* Returns NULL if not a structure or union, or the index is out of range.
* @end deftypefun
@@ -1087,7 +1087,7 @@
}
/*@
- * @deftypefun jit_nuint jit_type_get_offset (jit_type_t type, {unsigned int}
field_index)
+ * @deftypefun jit_nuint jit_type_get_offset (jit_type_t @var{type}, unsigned
int @var{field_index})
* Get the offset of a specific field within a structure.
* Returns zero if not a structure, or the index is out of range,
* so this is safe to use on non-structure types.
@@ -1111,7 +1111,7 @@
}
/*@
- * @deftypefun {const char *} jit_type_get_name (jit_type_t type, {unsigned
int} index)
+ * @deftypefun {const char *} jit_type_get_name (jit_type_t @var{type},
unsigned int @var{index})
* Get the name of a structure, union, or signature field/parameter.
* Returns NULL if not a structure, union, or signature, the index
* is out of range, or there is no name associated with the component.
@@ -1130,7 +1130,7 @@
}
/*@
- * @deftypefun {unsigned int} jit_type_find_name (jit_type_t type, {const char
*} name)
+ * @deftypefun {unsigned int} jit_type_find_name (jit_type_t @var{type}, const
char address@hidden)
* Find the field/parameter index for a particular name. Returns
* @code{JIT_INVALID_NAME} if the name was not present.
* @end deftypefun
@@ -1158,7 +1158,7 @@
}
/*@
- * @deftypefun {unsigned int} jit_type_num_params (jit_type_t type)
+ * @deftypefun {unsigned int} jit_type_num_params (jit_type_t @var{type})
* Get the number of parameters in a signature type.
* @end deftypefun
@*/
@@ -1175,7 +1175,7 @@
}
/*@
- * @deftypefun jit_type_t jit_type_get_return (jit_type_t type)
+ * @deftypefun jit_type_t jit_type_get_return (jit_type_t @var{type})
* Get the return type from a signature type. Returns NULL if
* not a signature type.
* @end deftypefun
@@ -1193,7 +1193,7 @@
}
/*@
- * @deftypefun jit_type_t jit_type_get_param (jit_type_t type, {unsigned int}
param_index)
+ * @deftypefun jit_type_t jit_type_get_param (jit_type_t @var{type}, unsigned
int @var{param_index})
* Get a specific parameter from a signature type. Returns NULL
* if not a signature type or the index is out of range.
* @end deftypefun
@@ -1212,7 +1212,7 @@
}
/*@
- * @deftypefun jit_abi_t jit_type_get_abi (jit_type_t type)
+ * @deftypefun jit_abi_t jit_type_get_abi (jit_type_t @var{type})
* Get the ABI code from a signature type. Returns @code{jit_abi_cdecl}
* if not a signature type.
* @end deftypefun
@@ -1230,7 +1230,7 @@
}
/*@
- * @deftypefun jit_type_t jit_type_get_ref (jit_type_t type)
+ * @deftypefun jit_type_t jit_type_get_ref (jit_type_t @var{type})
* Get the type that is referred to by a pointer type. Returns NULL
* if not a pointer type.
* @end deftypefun
@@ -1248,7 +1248,7 @@
}
/*@
- * @deftypefun jit_type_t jit_type_get_tagged_type (jit_type_t type)
+ * @deftypefun jit_type_t jit_type_get_tagged_type (jit_type_t @var{type})
* Get the type that underlies a tagged type. Returns NULL
* if not a tagged type.
* @end deftypefun
@@ -1266,9 +1266,9 @@
}
/*@
- * @deftypefun void jit_type_set_tagged_type (jit_type_t type, jit_type_t
underlying)
- * Set the type that underlies a tagged type. Ignored if @code{type}
- * is not a tagged type. If @code{type} already has an underlying
+ * @deftypefun void jit_type_set_tagged_type (jit_type_t @var{type},
jit_type_t @var{underlying})
+ * Set the type that underlies a tagged type. Ignored if @var{type}
+ * is not a tagged type. If @var{type} already has an underlying
* type, then the original is freed.
*
* This function is typically used to flesh out the body of a
@@ -1297,7 +1297,7 @@
}
/*@
- * @deftypefun int jit_type_get_tagged_type (jit_type_t type)
+ * @deftypefun int jit_type_get_tagged_type (jit_type_t @var{type})
* Get the kind of tag that is applied to a tagged type. Returns -1
* if not a tagged type.
* @end deftypefun
@@ -1315,7 +1315,7 @@
}
/*@
- * @deftypefun {void *} jit_type_get_tagged_data (jit_type_t type)
+ * @deftypefun {void *} jit_type_get_tagged_data (jit_type_t @var{type})
* Get the user data is associated with a tagged type. Returns NULL
* if not a tagged type.
* @end deftypefun
@@ -1333,7 +1333,7 @@
}
/*@
- * @deftypefun void jit_type_set_tagged_data (jit_type_t type, {void *} data,
jit_meta_free_func free_fun)
+ * @deftypefun void jit_type_set_tagged_data (jit_type_t @var{type}, void
address@hidden, jit_meta_free_func @var{free_func})
* Set the user data is associated with a tagged type. The original data,
* if any, is freed.
* @end deftypefun
@@ -1357,7 +1357,7 @@
}
/*@
- * @deftypefun int jit_type_is_primitive (jit_type_t type)
+ * @deftypefun int jit_type_is_primitive (jit_type_t @var{type})
* Determine if a type is primitive.
* @end deftypefun
@*/
@@ -1374,7 +1374,7 @@
}
/*@
- * @deftypefun int jit_type_is_struct (jit_type_t type)
+ * @deftypefun int jit_type_is_struct (jit_type_t @var{type})
* Determine if a type is a structure.
* @end deftypefun
@*/
@@ -1391,7 +1391,7 @@
}
/*@
- * @deftypefun int jit_type_is_union (jit_type_t type)
+ * @deftypefun int jit_type_is_union (jit_type_t @var{type})
* Determine if a type is a union.
* @end deftypefun
@*/
@@ -1408,7 +1408,7 @@
}
/*@
- * @deftypefun int jit_type_is_signature (jit_type_t type)
+ * @deftypefun int jit_type_is_signature (jit_type_t @var{type})
* Determine if a type is a function signature.
* @end deftypefun
@*/
@@ -1425,7 +1425,7 @@
}
/*@
- * @deftypefun int jit_type_is_pointer (jit_type_t type)
+ * @deftypefun int jit_type_is_pointer (jit_type_t @var{type})
* Determine if a type is a pointer.
* @end deftypefun
@*/
@@ -1442,7 +1442,7 @@
}
/*@
- * @deftypefun int jit_type_is_tagged (jit_type_t type)
+ * @deftypefun int jit_type_is_tagged (jit_type_t @var{type})
* Determine if a type is a tagged type.
* @end deftypefun
@*/
@@ -1469,7 +1469,7 @@
}
/*@
- * @deftypefun jit_type_t jit_type_normalize (jit_type_t type)
+ * @deftypefun jit_type_t jit_type_normalize (jit_type_t @var{type})
* Normalize a type to its basic numeric form. e.g. "jit_type_nint" is
* turned into "jit_type_int" or "jit_type_long", depending upon
* the underlying platform. Pointers are normalized like "jit_type_nint".
@@ -1523,7 +1523,7 @@
}
/*@
- * @deftypefun jit_type_t jit_type_remove_tags (jit_type_t type)
+ * @deftypefun jit_type_t jit_type_remove_tags (jit_type_t @var{type})
* Remove tags from a type, and return the underlying type.
* This is different from normalization, which will also collapses
* native types to their basic numeric counterparts.
@@ -1539,11 +1539,11 @@
}
/*@
- * @deftypefun jit_type_t jit_type_promote_int (jit_type_t type)
- * If @code{type} is @code{jit_type_sbyte} or @code{jit_type_short},
- * then return @code{jit_type_int}. If @code{type} is
+ * @deftypefun jit_type_t jit_type_promote_int (jit_type_t @var{type})
+ * If @var{type} is @code{jit_type_sbyte} or @code{jit_type_short},
+ * then return @code{jit_type_int}. If @var{type} is
* @code{jit_type_ubyte} or @code{jit_type_ushort}, then return
- * @code{jit_type_uint}. Otherwise return @code{type} as-is.
+ * @code{jit_type_uint}. Otherwise return @var{type} as-is.
* @end deftypefun
@*/
jit_type_t jit_type_promote_int(jit_type_t type)
@@ -1563,7 +1563,7 @@
}
/*@
- * @deftypefun int jit_type_return_via_pointer (jit_type_t type)
+ * @deftypefun int jit_type_return_via_pointer (jit_type_t @var{type})
* Determine if a type should be returned via a pointer if it appears
* as the return type in a signature.
* @end deftypefun
@@ -1596,8 +1596,8 @@
}
/*@
- * @deftypefun int jit_type_has_tag (jit_type_t type, int kind)
- * Determine if @code{type} has a specific kind of tag. This will
+ * @deftypefun int jit_type_has_tag (jit_type_t @var{type}, int @var{kind})
+ * Determine if @var{type} has a specific kind of tag. This will
* resolve multiple levels of tagging.
* @end deftypefun
@*/
Index: jit/jit-value.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-value.c,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -b -r1.11 -r1.12
--- jit/jit-value.c 28 May 2007 02:41:28 -0000 1.11
+++ jit/jit-value.c 22 Jan 2008 06:09:09 -0000 1.12
@@ -207,7 +207,7 @@
}
/*@
- * @deftypefun jit_value_t jit_value_create (jit_function_t func, jit_type_t
type)
+ * @deftypefun jit_value_t jit_value_create (jit_function_t @var{func},
jit_type_t @var{type})
* Create a new value in the context of a function's current block.
* The value initially starts off as a block-specific temporary.
* It will be converted into a function-wide local variable if
@@ -237,11 +237,11 @@
}
/*@
- * @deftypefun jit_value_t jit_value_create_nint_constant (jit_function_t
func, jit_type_t type, jit_nint const_value)
+ * @deftypefun jit_value_t jit_value_create_nint_constant (jit_function_t
@var{func}, jit_type_t @var{type}, jit_nint @var{const_value})
* Create a new native integer constant in the specified function.
* Returns NULL if out of memory.
*
- * The @code{type} parameter indicates the actual type of the constant,
+ * The @var{type} parameter indicates the actual type of the constant,
* if it happens to be something other than @code{jit_type_nint}.
* For example, the following will create an unsigned byte constant:
*
@@ -308,7 +308,7 @@
}
/*@
- * @deftypefun jit_value_t jit_value_create_long_constant (jit_function_t
func, jit_type_t type, jit_long const_value)
+ * @deftypefun jit_value_t jit_value_create_long_constant (jit_function_t
@var{func}, jit_type_t @var{type}, jit_long @var{const_value})
* Create a new 64-bit integer constant in the specified
* function. This can also be used to create constants of
* type @code{jit_type_ulong}. Returns NULL if out of memory.
@@ -338,7 +338,7 @@
}
/*@
- * @deftypefun jit_value_t jit_value_create_float32_constant (jit_function_t
func, jit_type_t type, jit_float32 const_value)
+ * @deftypefun jit_value_t jit_value_create_float32_constant (jit_function_t
@var{func}, jit_type_t @var{type}, jit_float32 @var{const_value})
* Create a new 32-bit floating-point constant in the specified
* function. Returns NULL if out of memory.
* @end deftypefun
@@ -363,7 +363,7 @@
}
/*@
- * @deftypefun jit_value_t jit_value_create_float64_constant (jit_function_t
func, jit_type_t type, jit_float64 const_value)
+ * @deftypefun jit_value_t jit_value_create_float64_constant (jit_function_t
@var{func}, jit_type_t @var{type}, jit_float64 @var{const_value})
* Create a new 64-bit floating-point constant in the specified
* function. Returns NULL if out of memory.
* @end deftypefun
@@ -388,7 +388,7 @@
}
/*@
- * @deftypefun jit_value_t jit_value_create_nfloat_constant (jit_function_t
func, jit_type_t type, jit_nfloat const_value)
+ * @deftypefun jit_value_t jit_value_create_nfloat_constant (jit_function_t
@var{func}, jit_type_t @var{type}, jit_nfloat @var{const_value})
* Create a new native floating-point constant in the specified
* function. Returns NULL if out of memory.
* @end deftypefun
@@ -413,10 +413,10 @@
}
/*@
- * @deftypefun jit_value_t jit_value_create_constant (jit_function_t func,
const jit_constant *const_value)
+ * @deftypefun jit_value_t jit_value_create_constant (jit_function_t
@var{func}, const jit_constant address@hidden)
* Create a new constant from a generic constant structure in the specified
* function. Returns NULL if out of memory or if the type in
- * @code{const_value} is not suitable for a constant.
+ * @var{const_value} is not suitable for a constant.
* @end deftypefun
@*/
jit_value_t jit_value_create_constant
@@ -464,7 +464,7 @@
}
/*@
- * @deftypefun jit_value_t jit_value_get_param (jit_function_t func, {unsigned
int} param)
+ * @deftypefun jit_value_t jit_value_get_param (jit_function_t @var{func},
unsigned int @var{param})
* Get the value that corresponds to a specified function parameter.
* Returns NULL if out of memory.
* @end deftypefun
@@ -515,7 +515,7 @@
}
/*@
- * @deftypefun jit_value_t jit_value_get_struct_pointer (jit_function_t func)
+ * @deftypefun jit_value_t jit_value_get_struct_pointer (jit_function_t
@var{func})
* Get the value that contains the structure return pointer for
* a function. If the function does not have a structure return pointer
* (i.e. structures are returned in registers), then this returns NULL.
@@ -559,7 +559,7 @@
}
/*@
- * @deftypefun int jit_value_is_temporary (jit_value_t value)
+ * @deftypefun int jit_value_is_temporary (jit_value_t @var{value})
* Determine if a value is temporary. i.e. its scope extends
* over a single block within its function.
* @end deftypefun
@@ -570,7 +570,7 @@
}
/*@
- * @deftypefun int jit_value_is_local (jit_value_t value)
+ * @deftypefun int jit_value_is_local (jit_value_t @var{value})
* Determine if a value is local. i.e. its scope extends
* over multiple blocks within its function.
* @end deftypefun
@@ -581,7 +581,7 @@
}
/*@
- * @deftypefun int jit_value_is_constant (jit_value_t value)
+ * @deftypefun int jit_value_is_constant (jit_value_t @var{value})
* Determine if a value is a constant.
* @end deftypefun
@*/
@@ -591,7 +591,7 @@
}
/*@
- * @deftypefun int jit_value_is_parameter (jit_value_t value)
+ * @deftypefun int jit_value_is_parameter (jit_value_t @var{value})
* Determine if a value is a function parameter.
* @end deftypefun
@*/
@@ -601,13 +601,13 @@
}
/*@
- * @deftypefun void jit_value_ref (jit_function_t func, jit_value_t value)
- * Create a reference to the specified @code{value} from the current
- * block in @code{func}. This will convert a temporary value into
- * a local value if @code{value} is being referenced from a different
+ * @deftypefun void jit_value_ref (jit_function_t @var{func}, jit_value_t
@var{value})
+ * Create a reference to the specified @var{value} from the current
+ * block in @var{func}. This will convert a temporary value into
+ * a local value if @var{value} is being referenced from a different
* block than its original.
*
- * It is not necessary that @code{func} be the same function as the
+ * It is not necessary that @var{func} be the same function as the
* one where the value was originally created. It may be a nested
* function, referring to a local variable in its parent function.
* @end deftypefun
@@ -671,7 +671,7 @@
}
/*@
- * @deftypefun void jit_value_set_volatile (jit_value_t value)
+ * @deftypefun void jit_value_set_volatile (jit_value_t @var{value})
* Set a flag on a value to indicate that it is volatile. The contents
* of the value must always be reloaded from memory, never from a
* cached register copy.
@@ -683,7 +683,7 @@
}
/*@
- * @deftypefun int jit_value_is_volatile (jit_value_t value)
+ * @deftypefun int jit_value_is_volatile (jit_value_t @var{value})
* Determine if a value is volatile.
* @end deftypefun
@*/
@@ -693,7 +693,7 @@
}
/*@
- * @deftypefun void jit_value_set_addressable (jit_value_t value)
+ * @deftypefun void jit_value_set_addressable (jit_value_t @var{value})
* Set a flag on a value to indicate that it is addressable.
* This should be used when you want to take the address of a
* value (e.g. @code{&variable} in C). The value is guaranteed
@@ -708,7 +708,7 @@
}
/*@
- * @deftypefun int jit_value_is_addressable (jit_value_t value)
+ * @deftypefun int jit_value_is_addressable (jit_value_t @var{value})
* Determine if a value is addressable.
* @end deftypefun
@*/
@@ -718,7 +718,7 @@
}
/*@
- * @deftypefun jit_type_t jit_value_get_type (jit_value_t value)
+ * @deftypefun jit_type_t jit_value_get_type (jit_value_t @var{value})
* Get the type that is associated with a value.
* @end deftypefun
@*/
@@ -735,8 +735,8 @@
}
/*@
- * @deftypefun jit_function_t jit_value_get_function (jit_value_t value)
- * Get the function which owns a particular @code{value}.
+ * @deftypefun jit_function_t jit_value_get_function (jit_value_t @var{value})
+ * Get the function which owns a particular @var{value}.
* @end deftypefun
@*/
jit_function_t jit_value_get_function(jit_value_t value)
@@ -752,8 +752,8 @@
}
/*@
- * @deftypefun jit_block_t jit_value_get_block (jit_value_t value)
- * Get the block which owns a particular @code{value}.
+ * @deftypefun jit_block_t jit_value_get_block (jit_value_t @var{value})
+ * Get the block which owns a particular @var{value}.
* @end deftypefun
@*/
jit_block_t jit_value_get_block(jit_value_t value)
@@ -769,8 +769,8 @@
}
/*@
- * @deftypefun jit_context_t jit_value_get_context (jit_value_t value)
- * Get the context which owns a particular @code{value}.
+ * @deftypefun jit_context_t jit_value_get_context (jit_value_t @var{value})
+ * Get the context which owns a particular @var{value}.
* @end deftypefun
@*/
jit_context_t jit_value_get_context(jit_value_t value)
@@ -786,8 +786,8 @@
}
/*@
- * @deftypefun jit_constant_t jit_value_get_constant (jit_value_t value)
- * Get the constant value within a particular @code{value}. The returned
+ * @deftypefun jit_constant_t jit_value_get_constant (jit_value_t @var{value})
+ * Get the constant value within a particular @var{value}. The returned
* structure's @code{type} field will be @code{jit_type_void} if
* @code{value} is not a constant.
* @end deftypefun
@@ -860,8 +860,8 @@
}
/*@
- * @deftypefun jit_nint jit_value_get_nint_constant (jit_value_t value)
- * Get the constant value within a particular @code{value}, assuming
+ * @deftypefun jit_nint jit_value_get_nint_constant (jit_value_t @var{value})
+ * Get the constant value within a particular @var{value}, assuming
* that its type is compatible with @code{jit_type_nint}.
* @end deftypefun
@*/
@@ -878,9 +878,9 @@
}
/*@
- * @deftypefun jit_nint jit_value_get_nint_constant (jit_value_t value)
- * Get the constant value within a particular @code{value}, assuming
- * that its type is compatible with @code{jit_type_nint}.
+ * @deftypefun jit_nint jit_value_get_long_constant (jit_value_t @var{value})
+ * Get the constant value within a particular @var{value}, assuming
+ * that its type is compatible with @code{jit_type_long}.
* @end deftypefun
@*/
jit_long jit_value_get_long_constant(jit_value_t value)
@@ -906,8 +906,8 @@
}
/*@
- * @deftypefun jit_float32 jit_value_get_float32_constant (jit_value_t value)
- * Get the constant value within a particular @code{value}, assuming
+ * @deftypefun jit_float32 jit_value_get_float32_constant (jit_value_t
@var{value})
+ * Get the constant value within a particular @var{value}, assuming
* that its type is compatible with @code{jit_type_float32}.
* @end deftypefun
@*/
@@ -925,8 +925,8 @@
}
/*@
- * @deftypefun jit_float64 jit_value_get_float64_constant (jit_value_t value)
- * Get the constant value within a particular @code{value}, assuming
+ * @deftypefun jit_float64 jit_value_get_float64_constant (jit_value_t
@var{value})
+ * Get the constant value within a particular @var{value}, assuming
* that its type is compatible with @code{jit_type_float64}.
* @end deftypefun
@*/
@@ -944,8 +944,8 @@
}
/*@
- * @deftypefun jit_nfloat jit_value_get_nfloat_constant (jit_value_t value)
- * Get the constant value within a particular @code{value}, assuming
+ * @deftypefun jit_nfloat jit_value_get_nfloat_constant (jit_value_t
@var{value})
+ * Get the constant value within a particular @var{value}, assuming
* that its type is compatible with @code{jit_type_nfloat}.
* @end deftypefun
@*/
@@ -963,8 +963,8 @@
}
/*@
- * @deftypefun int jit_value_is_true (jit_value_t value)
- * Determine if @code{value} is constant and non-zero.
+ * @deftypefun int jit_value_is_true (jit_value_t @var{value})
+ * Determine if @var{value} is constant and non-zero.
* @end deftypefun
@*/
int jit_value_is_true(jit_value_t value)
@@ -1023,9 +1023,9 @@
}
/*@
- * @deftypefun int jit_constant_convert ({jit_constant_t *} result, {const
jit_constant_t *} value, jit_type_t type, int overflow_check)
- * Convert a the constant @code{value} into a new @code{type}, and
- * return its value in @code{result}. Returns zero if the conversion
+ * @deftypefun int jit_constant_convert (jit_constant_t address@hidden, const
jit_constant_t address@hidden, jit_type_t @var{type}, int @var{overflow_check})
+ * Convert a the constant @var{value} into a new @var{type}, and
+ * return its value in @var{result}. Returns zero if the conversion
* is not possible, usually due to overflow.
* @end deftypefun
@*/
Index: jit/jit-walk.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-walk.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -b -r1.2 -r1.3
--- jit/jit-walk.c 24 Sep 2006 20:36:51 -0000 1.2
+++ jit/jit-walk.c 22 Jan 2008 06:09:09 -0000 1.3
@@ -119,9 +119,9 @@
@*/
/*@
- * @deftypefun {void *} jit_get_frame_address (unsigned int n)
- * Get the frame address for the call frame @code{n} levels up
- * the stack. Setting @code{n} to zero will retrieve the frame
+ * @deftypefun {void *} jit_get_frame_address (unsigned int @var{n})
+ * Get the frame address for the call frame @var{n} levels up
+ * the stack. Setting @var{n} to zero will retrieve the frame
* address for the current function. Returns NULL if it isn't
* possible to retrieve the address of the specified frame.
* @end deftypefun
@@ -151,8 +151,8 @@
}
/*@
- * @deftypefun {void *} jit_get_next_frame_address ({void *} frame)
- * Get the address of the next frame up the stack from @code{frame}.
+ * @deftypefun {void *} jit_get_next_frame_address (void address@hidden)
+ * Get the address of the next frame up the stack from @var{frame}.
* Returns NULL if it isn't possible to retrieve the address of
* the next frame up the stack.
* @end deftypefun
@@ -170,7 +170,7 @@
}
/*@
- * @deftypefun {void *} jit_get_return_address ({void *} frame)
+ * @deftypefun {void *} jit_get_return_address (void address@hidden)
* Get the return address from a specified frame. The address
* represents the place where execution returns to when the
* specified frame exits. Returns NULL if it isn't possible
@@ -203,11 +203,11 @@
}
/*@
- * @deftypefun int jit_frame_contains_crawl_mark ({void *}frame,
{jit_crawl_mark_t *} mark)
- * Determine if the stack frame that resides just above @code{frame}
- * contains a local variable whose address is @code{mark}. The @code{mark}
+ * @deftypefun int jit_frame_contains_crawl_mark (void address@hidden,
jit_crawl_mark_t address@hidden)
+ * Determine if the stack frame that resides just above @var{frame}
+ * contains a local variable whose address is @var{mark}. The @var{mark}
* parameter should be the address of a local variable that is declared with
- * @code{jit_declare_crawl_mark(name)}.
+ * @code{jit_declare_crawl_mark(@var{name})}.
*
* Crawl marks are used internally by libjit to determine where control
* passes between JIT'ed and ordinary code during an exception throw.
Index: jitplus/jit-plus-context.cpp
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jitplus/jit-plus-context.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -b -r1.2 -r1.3
--- jitplus/jit-plus-context.cpp 20 Dec 2007 13:47:23 -0000 1.2
+++ jitplus/jit-plus-context.cpp 22 Jan 2008 06:09:09 -0000 1.3
@@ -43,12 +43,12 @@
}
/*@
- * @defop Constructor jit_context jit_context (jit_context_t context)
+ * @defop Constructor jit_context jit_context (jit_context_t @var{context})
* Construct a new JIT context by wrapping up an existing raw C context.
* This is useful for importing a context from third party C code
* into a program that prefers to use C++.
*
- * When you this form of construction, @code{jit_context_destroy}
+ * When you use this form of construction, @code{jit_context_destroy}
* will not be called on the context when the @code{jit_context}
* object is destructed. You will need to arrange for that manually.
* @end defop
Index: jitplus/jit-plus-function.cpp
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jitplus/jit-plus-function.cpp,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -b -r1.14 -r1.15
--- jitplus/jit-plus-function.cpp 20 Dec 2007 13:47:23 -0000 1.14
+++ jitplus/jit-plus-function.cpp 22 Jan 2008 06:09:09 -0000 1.15
@@ -52,9 +52,9 @@
jit_type_t const jit_function::end_params = (jit_type_t)0;
/*@
- * @defop Constructor jit_function jit_function ({jit_context& context},
jit_type_t signature)
- * Constructs a new function handler with the specified @code{signature} in
- * the given @code{context}. It then calls @code{create(signature)} to
+ * @defop Constructor jit_function jit_function (jit_context& @var{context},
jit_type_t @var{signature})
+ * Constructs a new function handler with the specified @var{signature} in
+ * the given @var{context}. It then calls @code{create(@var{signature})} to
* create the actual function.
* @end defop
@*/
@@ -69,8 +69,8 @@
}
/*@
- * @defop Constructor jit_function jit_function ({jit_context& context})
- * Constructs a new function handler in the specified @code{context}.
+ * @defop Constructor jit_function jit_function (jit_context& @var{context})
+ * Constructs a new function handler in the specified @var{context}.
* The actual function is not created until you call @code{create()}.
* @end defop
@*/
@@ -82,7 +82,7 @@
}
/*@
- * @defop Constructor jit_function jit_function (jit_function_t func)
+ * @defop Constructor jit_function jit_function (jit_function_t @var{func})
* Constructs a new function handler and wraps it around the specified
* raw C @code{jit_function_t} object. This can be useful for layering
* the C++ on-demand building facility on top of an existing C function.
@@ -129,7 +129,7 @@
@*/
/*@
- * @deftypemethod jit_function {static jit_function *} from_raw
(jit_function_t func)
+ * @deftypemethod jit_function {static jit_function *} from_raw
(jit_function_t @var{func})
* Find the C++ @code{jit_function} object that is associated with a
* raw C @code{jit_function_t} pointer. Returns NULL if there is
* no such object.
@@ -147,7 +147,7 @@
@*/
/*@
- * @deftypemethod jit_function void create (jit_type_t signature)
+ * @deftypemethod jit_function void create (jit_type_t @var{signature})
* Create this function if it doesn't already exist.
* @end deftypemethod
@*/
@@ -241,7 +241,7 @@
}
/*@
- * @deftypemethod jit_function void set_optimization_level ({unsigned int}
level)
+ * @deftypemethod jit_function void set_optimization_level (unsigned int
@var{level})
* @deftypemethodx jit_function {unsigned int} optimization_level () const
* Set or get the optimization level for this function.
* @end deftypemethod
@@ -255,14 +255,14 @@
* Get the closure or vtable pointer form of this function.
* @end deftypemethod
*
- * @deftypemethod jit_function int apply ({void **} args, {void *} result)
- * @deftypemethodx jit_function int apply (jit_type_t signature, {void **}
args, {void *} return_area)
+ * @deftypemethod jit_function int apply (void** @var{args}, void*
@var{result})
+ * @deftypemethodx jit_function int apply (jit_type_t @var{signature}, void**
@var{args}, void* @var{return_area})
* Call this function, applying the specified arguments.
* @end deftypemethod
@*/
/*@
- * @deftypemethod jit_function {static jit_type_t} signature_helper
(jit_type_t return_type, ...)
+ * @deftypemethod jit_function {static jit_type_t} signature_helper
(jit_type_t @var{return_type}, ...)
* You can call this method from @code{create_signature()} to help build the
* correct signature for your function. The first parameter is the return
* type, following by zero or more types for the parameters. The parameter
@@ -364,7 +364,7 @@
return val
/*@
- * @deftypemethod jit_function jit_value new_value (jit_type_t type)
+ * @deftypemethod jit_function jit_value new_value (jit_type_t @var{type})
* Create a new temporary value. This is the C++ counterpart to
* @code{jit_value_create}.
* @end deftypemethod
@@ -375,19 +375,19 @@
}
/*@
- * @deftypemethod jit_function jit_value new_constant (jit_sbyte value,
jit_type_t type)
- * @deftypemethodx jit_function jit_value new_constant (jit_ubyte value,
jit_type_t type)
- * @deftypemethodx jit_function jit_value new_constant (jit_short value,
jit_type_t type)
- * @deftypemethodx jit_function jit_value new_constant (jit_ushort value,
jit_type_t type)
- * @deftypemethodx jit_function jit_value new_constant (jit_int value,
jit_type_t type)
- * @deftypemethodx jit_function jit_value new_constant (jit_uint value,
jit_type_t type)
- * @deftypemethodx jit_function jit_value new_constant (jit_long value,
jit_type_t type)
- * @deftypemethodx jit_function jit_value new_constant (jit_ulong value,
jit_type_t type)
- * @deftypemethodx jit_function jit_value new_constant (jit_float32 value,
jit_type_t type)
- * @deftypemethodx jit_function jit_value new_constant (jit_float64 value,
jit_type_t type)
- * @deftypemethodx jit_function jit_value new_constant (jit_nfloat value,
jit_type_t type)
- * @deftypemethodx jit_function jit_value new_constant ({void *} value,
jit_type_t type)
- * @deftypemethodx jit_function jit_value new_constant ({const
jit_constant_t&} value)
+ * @deftypemethod jit_function jit_value new_constant (jit_sbyte @var{value},
jit_type_t @var{type})
+ * @deftypemethodx jit_function jit_value new_constant (jit_ubyte @var{value},
jit_type_t @var{type})
+ * @deftypemethodx jit_function jit_value new_constant (jit_short @var{value},
jit_type_t @var{type})
+ * @deftypemethodx jit_function jit_value new_constant (jit_ushort
@var{value}, jit_type_t @var{type})
+ * @deftypemethodx jit_function jit_value new_constant (jit_int @var{value},
jit_type_t @var{type})
+ * @deftypemethodx jit_function jit_value new_constant (jit_uint @var{value},
jit_type_t @var{type})
+ * @deftypemethodx jit_function jit_value new_constant (jit_long @var{value},
jit_type_t @var{type})
+ * @deftypemethodx jit_function jit_value new_constant (jit_ulong @var{value},
jit_type_t @var{type})
+ * @deftypemethodx jit_function jit_value new_constant (jit_float32
@var{value}, jit_type_t @var{type})
+ * @deftypemethodx jit_function jit_value new_constant (jit_float64
@var{value}, jit_type_t @var{type})
+ * @deftypemethodx jit_function jit_value new_constant (jit_nfloat
@var{value}, jit_type_t @var{type})
+ * @deftypemethodx jit_function jit_value new_constant (void* @var{value},
jit_type_t @var{type})
+ * @deftypemethodx jit_function jit_value new_constant (const jit_constant_t&
@var{value})
* Create constant values of various kinds. @xref{Values}, for more
* information on creating and managing constants.
* @end deftypemethod
@@ -510,8 +510,8 @@
}
/*@
- * @deftypemethod jit_function jit_value get_param ({unsigned int} param)
- * Get the value that corresponds to parameter @code{param}.
+ * @deftypemethod jit_function jit_value get_param (unsigned int @var{param})
+ * Get the value that corresponds to parameter @var{param}.
* @end deftypemethod
@*/
jit_value jit_function::get_param(unsigned int param)
@@ -542,122 +542,122 @@
}
/*@
- * @deftypemethod jit_function void insn_label ({jit_label&} label)
+ * @deftypemethod jit_function void insn_label (jit_label& @var{label})
* @deftypemethodx jit_function void insn_new_block ()
- * @deftypemethodx jit_function jit_value insn_load ({const jit_value&} value)
- * @deftypemethodx jit_function jit_value insn_dup ({const jit_value&} value)
- * @deftypemethodx jit_function jit_value insn_load_small ({const jit_value&}
value)
- * @deftypemethodx jit_function void store ({const jit_value&} dest, {const
jit_value&} value)
- * @deftypemethodx jit_function jit_value insn_load_relative ({const
jit_value&} value, jit_nint offset, jit_type_t type)
- * @deftypemethodx jit_function void insn_store_relative ({const jit_value&}
dest, jit_nint offset, {const jit_value&} value)
- * @deftypemethodx jit_function jit_value insn_add_relative ({const
jit_value&} value, jit_nint offset)
- * @deftypemethodx jit_function jit_value insn_load_elem ({const jit_value&}
base_addr, {const jit_value&} index, jit_type_t elem_type)
- * @deftypemethodx jit_function jit_value insn_load_elem_address ({const
jit_value&} base_addr, {const jit_value&} index, jit_type_t elem_type)
- * @deftypemethodx jit_function void insn_store_elem ({const jit_value&}
base_addr, {const jit_value&} index, {const jit_value&} value)
- * @deftypemethodx jit_function void insn_check_null ({const jit_value&} value)
- * @deftypemethodx jit_function jit_value insn_add ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_add_ovf ({const jit_value&}
value1, {const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_sub ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_sub_ovf ({const jit_value&}
value1, {const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_mul ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_mul_ovf ({const jit_value&}
value1, {const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_div ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_rem ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_rem_ieee ({const jit_value&}
value1, {const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_neg ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_and ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_or ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_xor ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_not ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_shl ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_shr ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_ushr ({const jit_value&}
value1, {const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_sshr ({const jit_value&}
value1, {const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_eq ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_ne ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_lt ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_le ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_gt ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_ge ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_cmpl ({const jit_value&}
value1, {const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_cmpg ({const jit_value&}
value1, {const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_to_bool ({const jit_value&}
value1)
- * @deftypemethodx jit_function jit_value insn_to_not_bool ({const jit_value&}
value1)
- * @deftypemethodx jit_function jit_value insn_acos ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_asin ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_atan ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_atan2 ({const jit_value&}
value1, {const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_ceil ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_cos ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_cosh ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_exp ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_floor ({const jit_value&}
value1)
- * @deftypemethodx jit_function jit_value insn_log ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_log10 ({const jit_value&}
value1)
- * @deftypemethodx jit_function jit_value insn_pow ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_rint ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_round ({const jit_value&}
value1)
- * @deftypemethodx jit_function jit_value insn_sin ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_sinh ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_sqrt ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_tan ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_tanh ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_is_nan ({const jit_value&}
value1)
- * @deftypemethodx jit_function jit_value insn_is_finite ({const jit_value&}
value1)
- * @deftypemethodx jit_function jit_value insn_is_inf ({const jit_value&}
value1)
- * @deftypemethodx jit_function jit_value insn_abs ({const jit_value&} value1)
- * @deftypemethodx jit_function jit_value insn_min ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_max ({const jit_value&} value1,
{const jit_value&} value2)
- * @deftypemethodx jit_function jit_value insn_sign ({const jit_value&} value1)
- * @deftypemethodx jit_function void insn_branch ({jit_label&} label)
- * @deftypemethodx jit_function void insn_branch_if ({const jit_value&} value,
{jit_label&} label)
- * @deftypemethodx jit_function void insn_branch_if_not ({const jit_value&}
value, {jit_label&} label)
- * @deftypemethodx jit_function jit_value insn_address_of ({const jit_value&}
value1)
- * @deftypemethodx jit_function jit_value insn_address_of_label ({jit_label&}
label)
- * @deftypemethodx jit_function jit_value insn_convert ({const jit_value&}
value, jit_type_t type, int overflow_check)
- * @deftypemethodx jit_function jit_value insn_call ({const char *} name,
jit_function_t jit_func, jit_type_t signature, {jit_value_t *} args, {unsigned
int} num_args, int flags)
- * @deftypemethodx jit_function jit_value insn_call_indirect ({const
jit_value&} value, jit_type_t signature, {jit_value_t *} args, {unsigned int}
num_args, int flags)
- * @deftypemethodx jit_function jit_value insn_call_indirect_vtable ({const
jit_value&} value, jit_type_t signature, {jit_value_t *} args, {unsigned int}
num_args, int flags)
- * @deftypemethodx jit_function jit_value insn_call_native ({const char *}
name, {void *} native_func, jit_type_t signature, {jit_value_t *} args,
{unsigned int} num_args, int flags)
- * @deftypemethodx jit_function jit_value insn_call_intrinsic ({const char *}
name, {void *} intrinsic_func, {const jit_intrinsic_descr_t&} descriptor,
{const jit_value&} arg1, {const jit_value&} arg2)
- * @deftypemethodx jit_function void insn_incoming_reg ({const jit_value&}
value, int reg)
- * @deftypemethodx jit_function void insn_incoming_frame_posn ({const
jit_value&} value, jit_nint posn)
- * @deftypemethodx jit_function void insn_outgoing_reg ({const jit_value&}
value, int reg)
- * @deftypemethodx jit_function void insn_outgoing_frame_posn ({const
jit_value&} value, jit_nint posn)
- * @deftypemethodx jit_function void insn_return_reg ({const jit_value&}
value, int reg)
- * @deftypemethodx jit_function void insn_setup_for_nested (int nested_level,
int reg)
- * @deftypemethodx jit_function void insn_flush_struct ({const jit_value&}
value)
- * @deftypemethodx jit_function jit_value insn_import (jit_value value)
- * @deftypemethodx jit_function void insn_push ({const jit_value&} value)
- * @deftypemethodx jit_function void insn_push_ptr ({const jit_value&} value,
jit_type_t type)
- * @deftypemethodx jit_function void insn_set_param ({const jit_value&} value,
jit_nint offset)
- * @deftypemethodx jit_function void insn_set_param_ptr ({const jit_value&}
value, jit_type_t type, jit_nint offset)
+ * @deftypemethodx jit_function jit_value insn_load (const jit_value&
@var{value})
+ * @deftypemethodx jit_function jit_value insn_dup (const jit_value&
@var{value})
+ * @deftypemethodx jit_function jit_value insn_load_small (const jit_value&
@var{value})
+ * @deftypemethodx jit_function void store (const jit_value& @var{dest}, const
jit_value& @var{value})
+ * @deftypemethodx jit_function jit_value insn_load_relative (const jit_value&
@var{value}, jit_nint @var{offset}, jit_type_t @var{type})
+ * @deftypemethodx jit_function void insn_store_relative (const jit_value&
@var{dest}, jit_nint @var{offset}, const jit_value& @var{value})
+ * @deftypemethodx jit_function jit_value insn_add_relative (const jit_value&
@var{value}, jit_nint @var{offset})
+ * @deftypemethodx jit_function jit_value insn_load_elem (const jit_value&
@var{base_addr}, const jit_value& @var{index}, jit_type_t @var{elem_type})
+ * @deftypemethodx jit_function jit_value insn_load_elem_address (const
jit_value& @var{base_addr}, const jit_value& @var{index}, jit_type_t
@var{elem_type})
+ * @deftypemethodx jit_function void insn_store_elem (const jit_value&
@var{base_addr}, const jit_value& @var{index}, const jit_value& @var{value})
+ * @deftypemethodx jit_function void insn_check_null (const jit_value&
@var{value})
+ * @deftypemethodx jit_function jit_value insn_add (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_add_ovf (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_sub (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_sub_ovf (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_mul (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_mul_ovf (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_div (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_rem (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_rem_ieee (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_neg (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_and (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_or (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_xor (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_not (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_shl (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_shr (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_ushr (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_sshr (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_eq (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_ne (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_lt (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_le (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_gt (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_ge (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_cmpl (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_cmpg (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_to_bool (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_to_not_bool (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_acos (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_asin (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_atan (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_atan2 (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_ceil (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_cos (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_cosh (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_exp (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_floor (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_log (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_log10 (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_pow (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_rint (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_round (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_sin (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_sinh (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_sqrt (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_tan (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_tanh (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_is_nan (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_is_finite (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_is_inf (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_abs (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_min (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_max (const jit_value&
@var{value1}, const jit_value& @var{value2})
+ * @deftypemethodx jit_function jit_value insn_sign (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function void insn_branch (jit_label& @var{label})
+ * @deftypemethodx jit_function void insn_branch_if (const jit_value&
@var{value}, jit_label& @var{label})
+ * @deftypemethodx jit_function void insn_branch_if_not (const jit_value&
value, jit_label& @var{label})
+ * @deftypemethodx jit_function jit_value insn_address_of (const jit_value&
@var{value1})
+ * @deftypemethodx jit_function jit_value insn_address_of_label (jit_label&
@var{label})
+ * @deftypemethodx jit_function jit_value insn_convert (const jit_value&
@var{value}, jit_type_t @var{type}, int @var{overflow_check})
+ * @deftypemethodx jit_function jit_value insn_call (const char* @var{name},
jit_function_t @var{jit_func}, jit_type_t @var{signature}, jit_value_t*
@var{args}, unsigned int @var{num_args}, int @var{flags})
+ * @deftypemethodx jit_function jit_value insn_call_indirect (const jit_value&
@var{value}, jit_type_t @var{signature}, jit_value_t* @var{args}, unsigned int
@var{num_args}, int @var{flags})
+ * @deftypemethodx jit_function jit_value insn_call_indirect_vtable (const
jit_value& @var{value}, jit_type_t @var{signature}, jit_value_t * @var{args},
unsigned int @var{num_args}, int @var{flags})
+ * @deftypemethodx jit_function jit_value insn_call_native (const char*
@var{name}, void* @var{native_func}, jit_type_t @var{signature}, jit_value_t*
@var{args}, unsigned int @var{num_args}, int @var{flags})
+ * @deftypemethodx jit_function jit_value insn_call_intrinsic (const char*
@var{name}, void* @var{intrinsic_func}, const jit_intrinsic_descr_t&
@var{descriptor}, const jit_value& @var{arg1}, const jit_value& @var{arg2})
+ * @deftypemethodx jit_function void insn_incoming_reg (const jit_value&
@var{value}, int @var{reg})
+ * @deftypemethodx jit_function void insn_incoming_frame_posn (const
jit_value& @var{value}, jit_nint @var{posn})
+ * @deftypemethodx jit_function void insn_outgoing_reg (const jit_value&
@var{value}, int @var{reg})
+ * @deftypemethodx jit_function void insn_outgoing_frame_posn (const
jit_value& @var{value}, jit_nint @var{posn})
+ * @deftypemethodx jit_function void insn_return_reg (const jit_value&
@var{value}, int @var{reg})
+ * @deftypemethodx jit_function void insn_setup_for_nested (int
@var{nested_level}, int @var{reg})
+ * @deftypemethodx jit_function void insn_flush_struct (const jit_value&
@var{value})
+ * @deftypemethodx jit_function jit_value insn_import (jit_value @var{value})
+ * @deftypemethodx jit_function void insn_push (const jit_value& @var{value})
+ * @deftypemethodx jit_function void insn_push_ptr (const jit_value&
@var{value}, jit_type_t @var{type})
+ * @deftypemethodx jit_function void insn_set_param (const jit_value&
@var{value}, jit_nint @var{offset})
+ * @deftypemethodx jit_function void insn_set_param_ptr (const jit_value&
@var{value}, jit_type_t @var{type}, jit_nint @var{offset})
* @deftypemethodx jit_function void insn_push_return_area_ptr ()
- * @deftypemethodx jit_function void insn_return ({const jit_value&} value)
+ * @deftypemethodx jit_function void insn_return (const jit_value& @var{value})
* @deftypemethodx jit_function void insn_return ()
- * @deftypemethodx jit_function void insn_return_ptr ({const jit_value&}
value, jit_type_t type)
+ * @deftypemethodx jit_function void insn_return_ptr (const jit_value&
@var{value}, jit_type_t @var{type})
* @deftypemethodx jit_function void insn_default_return ()
- * @deftypemethodx jit_function void insn_throw ({const jit_value&} value)
+ * @deftypemethodx jit_function void insn_throw (const jit_value& @var{value})
* @deftypemethodx jit_function jit_value insn_get_call_stack ()
* @deftypemethodx jit_function jit_value insn_thrown_exception ()
* @deftypemethodx jit_function void insn_uses_catcher ()
* @deftypemethodx jit_function jit_value insn_start_catcher ()
- * @deftypemethodx jit_function void insn_branch_if_pc_not_in_range ({const
jit_label&} start_label, {const jit_label&} end_label, {jit_label&} label)
+ * @deftypemethodx jit_function void insn_branch_if_pc_not_in_range (const
jit_label& @var{start_label}, const jit_label& @var{end_label}, jit_label&
@var{label})
* @deftypemethodx jit_function void insn_rethrow_unhandled ()
- * @deftypemethodx jit_function void insn_start_finally ({jit_label&} label)
+ * @deftypemethodx jit_function void insn_start_finally (jit_label&
@var{label})
* @deftypemethodx jit_function void insn_return_from_finally ()
- * @deftypemethodx jit_function void insn_call_finally ({jit_label&} label)
- * @deftypemethodx jit_function jit_value insn_start_filter ({jit_label&}
label, jit_type_t type)
- * @deftypemethodx jit_function void insn_return_from_filter ({const
jit_value&} value)
- * @deftypemethodx jit_function jit_value insn_call_filter ({jit_label&}
label, {const jit_value&} value, jit_type_t type)
- * @deftypemethodx jit_function void insn_memcpy ({const jit_value&} dest,
{const jit_value&} src, {const jit_value&} size)
- * @deftypemethodx jit_function void insn_memmove ({const jit_value&} dest,
{const jit_value&} src, {const jit_value&} size)
- * @deftypemethodx jit_function void jit_insn_memset ({const jit_value&} dest,
{const jit_value&} value, {const jit_value&} size)
- * @deftypemethodx jit_function jit_value jit_insn_alloca ({const jit_value&}
size)
- * @deftypemethodx jit_function void insn_move_blocks_to_end ({const
jit_label&} from_label, {const jit_label&} to_label)
- * @deftypemethodx jit_function void insn_move_blocks_to_start ({const
jit_label&} from_label, {const jit_label&} to_label)
- * @deftypemethodx jit_function void insn_mark_offset (jit_int offset)
- * @deftypemethodx jit_function void insn_mark_breakpoint (jit_nint data1,
jit_nint data2)
+ * @deftypemethodx jit_function void insn_call_finally (jit_label& @var{label})
+ * @deftypemethodx jit_function jit_value insn_start_filter (jit_label&
@var{label}, jit_type_t @var{type})
+ * @deftypemethodx jit_function void insn_return_from_filter (const jit_value&
@var{value})
+ * @deftypemethodx jit_function jit_value insn_call_filter (jit_label&
@var{label}, const jit_value& @var{value}, jit_type_t @var{type})
+ * @deftypemethodx jit_function void insn_memcpy (const jit_value& @var{dest},
const jit_value& @var{src}, const jit_value& @var{size})
+ * @deftypemethodx jit_function void insn_memmove (const jit_value&
@var{dest}, const jit_value& @var{src}, const jit_value& @var{size})
+ * @deftypemethodx jit_function void jit_insn_memset (const jit_value&
@var{dest}, const jit_value& @var{value}, const jit_value& @var{size})
+ * @deftypemethodx jit_function jit_value jit_insn_alloca (const jit_value&
@var{size})
+ * @deftypemethodx jit_function void insn_move_blocks_to_end (const jit_label&
@var{from_label}, const jit_label& @var{to_label})
+ * @deftypemethodx jit_function void insn_move_blocks_to_start (const
jit_label& @var{from_label}, const jit_label& @var{to_label})
+ * @deftypemethodx jit_function void insn_mark_offset (jit_int @var{offset})
+ * @deftypemethodx jit_function void insn_mark_breakpoint (jit_nint
@var{data1}, jit_nint @var{data2})
* Create instructions of various kinds. @xref{Instructions}, for more
* information on the individual instructions and their arguments.
* @end deftypemethod
Index: jitplus/jit-plus-value.cpp
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jitplus/jit-plus-value.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -b -r1.2 -r1.3
--- jitplus/jit-plus-value.cpp 12 Feb 2007 21:38:45 -0000 1.2
+++ jitplus/jit-plus-value.cpp 22 Jan 2008 06:09:09 -0000 1.3
@@ -31,12 +31,12 @@
Construct an empty value.
@end defop
address@hidden Constructor jit_value jit_value (jit_value_t value)
address@hidden Constructor jit_value jit_value (jit_value_t @var{value})
Construct a value by wrapping up a raw C @code{jit_value_t} object.
@end defop
address@hidden Constructor jit_value jit_value ({const jit_value& value})
-Create a copy of @code{value}.
address@hidden Constructor jit_value jit_value (const jit_value& @var{value})
+Create a copy of @var{value}.
@end defop
@defop Destructor jit_value ~jit_value ()
@@ -44,7 +44,7 @@
value alone.
@end defop
address@hidden Operator jit_value {jit_value& operator=} ({const jit_value&
value})
address@hidden Operator jit_value {jit_value& operator=} (const jit_value&
@var{value})
Copy @code{jit_value} objects.
@end defop
@@ -92,24 +92,24 @@
Extract the constant stored in this value.
@end deftypemethod
address@hidden Operator jit_value {jit_value operator+} ({const jit_value&
value1}, {const jit_value& value2})
address@hidden Operator jit_value {jit_value operator-} ({const jit_value&
value1}, {const jit_value& value2})
address@hidden Operator jit_value {jit_value operator*} ({const jit_value&
value1}, {const jit_value& value2})
address@hidden Operator jit_value {jit_value operator/} ({const jit_value&
value1}, {const jit_value& value2})
address@hidden Operator jit_value {jit_value operator%} ({const jit_value&
value1}, {const jit_value& value2})
address@hidden Operator jit_value {jit_value operator-} ({const jit_value&
value1})
address@hidden Operator jit_value {jit_value operator&} ({const jit_value&
value1}, {const jit_value& value2})
address@hidden Operator jit_value {jit_value operator|} ({const jit_value&
value1}, {const jit_value& value2})
address@hidden Operator jit_value {jit_value operator^} ({const jit_value&
value1}, {const jit_value& value2})
address@hidden Operator jit_value {jit_value operator~} ({const jit_value&
value1})
address@hidden Operator jit_value {jit_value operator<<} ({const jit_value&
value1}, {const jit_value& value2})
address@hidden Operator jit_value {jit_value operator>>} ({const jit_value&
value1}, {const jit_value& value2})
address@hidden Operator jit_value {jit_value operator==} ({const jit_value&
value1}, {const jit_value& value2})
address@hidden Operator jit_value {jit_value operator!=} ({const jit_value&
value1}, {const jit_value& value2})
address@hidden Operator jit_value {jit_value operator<} ({const jit_value&
value1}, {const jit_value& value2})
address@hidden Operator jit_value {jit_value operator<=} ({const jit_value&
value1}, {const jit_value& value2})
address@hidden Operator jit_value {jit_value operator>} ({const jit_value&
value1}, {const jit_value& value2})
address@hidden Operator jit_value {jit_value operator>=} ({const jit_value&
value1}, {const jit_value& value2})
address@hidden Operator jit_value {jit_value operator+} (const jit_value&
@var{value1}, const jit_value& @var{value2})
address@hidden Operator jit_value {jit_value operator-} (const jit_value&
@var{value1}, const jit_value& @var{value2})
address@hidden Operator jit_value {jit_value operator*} (const jit_value&
@var{value1}, const jit_value& @var{value2})
address@hidden Operator jit_value {jit_value operator/} (const jit_value&
@var{value1}, const jit_value& @var{value2})
address@hidden Operator jit_value {jit_value operator%} (const jit_value&
@var{value1}, const jit_value& @var{value2})
address@hidden Operator jit_value {jit_value operator-} (const jit_value&
@var{value1})
address@hidden Operator jit_value {jit_value operator&} (const jit_value&
@var{value1}, const jit_value& @var{value2})
address@hidden Operator jit_value {jit_value operator|} (const jit_value&
@var{value1}, const jit_value& @var{value2})
address@hidden Operator jit_value {jit_value operator^} (const jit_value&
@var{value1}, const jit_value& @var{value2})
address@hidden Operator jit_value {jit_value operator~} (const jit_value&
@var{value1})
address@hidden Operator jit_value {jit_value operator<<} (const jit_value&
@var{value1}, const jit_value& @var{value2})
address@hidden Operator jit_value {jit_value operator>>} (const jit_value&
@var{value1}, const jit_value& @var{value2})
address@hidden Operator jit_value {jit_value operator==} (const jit_value&
@var{value1}, const jit_value& @var{value2})
address@hidden Operator jit_value {jit_value operator!=} (const jit_value&
@var{value1}, const jit_value& @var{value2})
address@hidden Operator jit_value {jit_value operator<} (const jit_value&
@var{value1}, const jit_value& @var{value2})
address@hidden Operator jit_value {jit_value operator<=} (const jit_value&
@var{value1}, const jit_value& @var{value2})
address@hidden Operator jit_value {jit_value operator>} (const jit_value&
@var{value1}, const jit_value& @var{value2})
address@hidden Operator jit_value {jit_value operator>=} (const jit_value&
@var{value1}, const jit_value& @var{value2})
Generate an arithmetic, bitwise, or comparison instruction based on
one or two @code{jit_value} objects. These operators are shortcuts
for calling @code{insn_add}, @code{insn_sub}, etc on the
Index: jitdynamic/jit-cpp-mangle.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jitdynamic/jit-cpp-mangle.c,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -b -r1.3 -r1.4
--- jitdynamic/jit-cpp-mangle.c 28 Aug 2006 14:21:54 -0000 1.3
+++ jitdynamic/jit-cpp-mangle.c 22 Jan 2008 06:09:09 -0000 1.4
@@ -1302,8 +1302,8 @@
#endif
/*@
- * @deftypefun {char *} jit_mangle_global_function ({const char *} name,
jit_type_t signature, int form)
- * Mangle the name of a global C++ function using the specified @code{form}.
+ * @deftypefun {char *} jit_mangle_global_function (const char address@hidden,
jit_type_t @var{signature}, int @var{form})
+ * Mangle the name of a global C++ function using the specified @var{form}.
* Returns NULL if out of memory, or if the form is not supported.
* @end deftypefun
@*/
@@ -1349,8 +1349,8 @@
}
/*@
- * @deftypefun {char *} jit_mangle_member_function ({const char *} class_name,
{const char *} name, jit_type_t signature, int form, int flags)
- * Mangle the name of a C++ member function using the specified @code{form}.
+ * @deftypefun {char *} jit_mangle_member_function (const char address@hidden,
const char address@hidden, jit_type_t @var{signature}, int @var{form}, int
@var{flags})
+ * Mangle the name of a C++ member function using the specified @var{form}.
* Returns NULL if out of memory, or if the form is not supported.
* The following flags may be specified to modify the mangling rules:
*
@@ -1383,17 +1383,17 @@
*
* @vindex JIT_MANGLE_EXPLICIT_THIS
* @item JIT_MANGLE_EXPLICIT_THIS
- * The @code{signature} includes an extra pointer parameter at the start
+ * The @var{signature} includes an extra pointer parameter at the start
* that indicates the type of the @code{this} pointer. This parameter won't
* be included in the final mangled name.
*
* @vindex JIT_MANGLE_IS_CTOR
* @item JIT_MANGLE_IS_CTOR
- * The method is a constructor. The @code{name} parameter will be ignored.
+ * The method is a constructor. The @var{name} parameter will be ignored.
*
* @vindex JIT_MANGLE_IS_DTOR
* @item JIT_MANGLE_IS_DTOR
- * The method is a destructor. The @code{name} parameter will be ignored.
+ * The method is a destructor. The @var{name} parameter will be ignored.
*
* @vindex JIT_MANGLE_BASE
* @item JIT_MANGLE_BASE
@@ -1401,7 +1401,7 @@
* the "complete" entry point.
* @end table
*
- * The @code{class_name} may include namespace and nested parent qualifiers
+ * The @var{class_name} may include namespace and nested parent qualifiers
* by separating them with @code{::} or @code{.}. Class names that involve
* template parameters are not supported yet.
* @end deftypefun
Index: jitdynamic/jit-dynlib.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jitdynamic/jit-dynlib.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -b -r1.1 -r1.2
--- jitdynamic/jit-dynlib.c 8 May 2004 01:36:42 -0000 1.1
+++ jitdynamic/jit-dynlib.c 22 Jan 2008 06:09:09 -0000 1.2
@@ -48,23 +48,23 @@
You must include @code{<jit/jit-dynamic.h>} to use these routines,
and then link with @code{-ljitdynamic -ljit}.
address@hidden jit_dynlib_handle_t jit_dynlib_open ({const char *} name)
-Opens the dynamic library called @code{name}, returning a handle for it.
address@hidden jit_dynlib_handle_t jit_dynlib_open (const char address@hidden)
+Opens the dynamic library called @var{name}, returning a handle for it.
@end deftypefun
address@hidden void jit_dynlib_close (jit_dynlib_handle_t handle)
address@hidden void jit_dynlib_close (jit_dynlib_handle_t @var{handle})
Close a dynamic library.
@end deftypefun
address@hidden {void *} jit_dynlib_get_symbol (jit_dynlib_handle_t handle,
{const char *} symbol)
-Retrieve the symbol @code{name} from the specified dynamic library.
address@hidden {void *} jit_dynlib_get_symbol (jit_dynlib_handle_t
@var{handle}, const char address@hidden)
+Retrieve the symbol @var{symbol} from the specified dynamic library.
Returns NULL if the symbol could not be found. This will try both
-non-prefixed and underscore-prefixed forms of @code{name} on platforms
+non-prefixed and underscore-prefixed forms of @var{symbol} on platforms
where it makes sense to do so, so there is no need for the caller
to perform prefixing.
@end deftypefun
address@hidden void jit_dynlib_set_debug (int flag)
address@hidden void jit_dynlib_set_debug (int @var{flag})
Enable or disable additional debug messages to stderr. Debugging is
disabled by default. Normally the dynamic library routines will silently
report errors via NULL return values, leaving reporting up to the caller.
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [dotgnu-pnet-commits] libjit ChangeLog jit/jit-alloc.c jit/jit-apply....,
Aleksey Demakov <=