Add missing functions to the C++ API.

diff --git a/ChangeLog b/ChangeLog
index ed4832964435dc9451a7a093a54b7974671c47c1..c1ff0ac5aeb0278e8fb99f55f4f0bc4d38378a0a 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -12,6 +12,9 @@
        * jit/jit-rules-interp.c (_jit_gen_start_block): set the address
        of the exception handler for interpreted code.
 
+       * include/jit/jit-plus.h, jitplus/jit-plus-function.cpp:
+       add missing functions to the C++ API.
+
 2004-05-22  Rhys Weatherley  <rweather@southern-storm.com.au>
 
        * jit/jit-block.c (_jit_block_peephole_branch): don't allow

diff --git a/include/jit/jit-plus.h b/include/jit/jit-plus.h
index 919e918c13621f6ecafbe7bb343c523fe8a7bf33..7202753c3959a6134c78d53dfc5a18ab076ab5e9 100644 (file)
--- a/include/jit/jit-plus.h
+++ b/include/jit/jit-plus.h
@@ -283,6 +283,7 @@ public:
        void insn_branch_if(const jit_value& value, jit_label& label);
        void insn_branch_if_not(const jit_value& value, jit_label& label);
        jit_value insn_address_of(const jit_value& value1);
+       jit_value insn_address_of_label(jit_label& label);
        jit_value insn_convert
                (const jit_value& value, jit_type_t type, int overflow_check=0);
        jit_value insn_call
@@ -302,13 +303,35 @@ public:
                (const char *name, void *intrinsic_func,
                 const jit_intrinsic_descr_t& descriptor,
                 const jit_value& arg1, const jit_value& arg2);
+       void insn_incoming_reg(const jit_value& value, int reg);
+       void insn_incoming_frame_posn(const jit_value& value, jit_nint posn);
+       void insn_outgoing_reg(const jit_value& value, int reg);
+       void insn_return_reg(const jit_value& value, int reg);
+       void insn_setup_for_nested(int nested_level, int reg);
+       void insn_flush_struct(const jit_value& value);
        jit_value insn_import(jit_value value);
+       void insn_push(const jit_value& value);
+       void insn_push_ptr(const jit_value& value, jit_type_t type);
        void insn_return(const jit_value& value);
        void insn_return();
        void insn_return_ptr(const jit_value& value, jit_type_t type);
        void insn_default_return();
        void insn_throw(const jit_value& value);
        jit_value insn_get_call_stack();
+       jit_value insn_thrown_exception();
+       void insn_uses_catcher();
+       jit_value insn_start_catcher();
+       void insn_branch_if_pc_not_in_range
+               (const jit_label& start_label, const jit_label& end_label,
+                jit_label& label);
+       void insn_rethrow_unhandled();
+       void insn_start_finally(jit_label& label);
+       void insn_return_from_finally();
+       void insn_call_finally(jit_label& label);
+       jit_value insn_start_filter(jit_label& label, jit_type_t type);
+       void insn_return_from_filter(const jit_value& value);
+       jit_value insn_call_filter
+               (jit_label& label, const jit_value& value, jit_type_t type);
        void insn_memcpy
                (const jit_value& dest, const jit_value& src, const jit_value& size);
        void insn_memmove
@@ -316,6 +339,10 @@ public:
        void insn_memset
                (const jit_value& dest, const jit_value& value, const jit_value& size);
        jit_value insn_alloca(const jit_value& size);
+       void insn_move_blocks_to_end
+               (const jit_label& from_label, const jit_label& to_label);
+       void insn_move_blocks_to_start
+               (const jit_label& from_label, const jit_label& to_label);
 
 private:
        jit_function_t func;

diff --git a/jitplus/jit-plus-function.cpp b/jitplus/jit-plus-function.cpp
index 2a574c5169c1dd7c8f9d7f43ccf03fbbb9384edf..ddd47a3b98c3643d53ce5d8656baf4029887f2cf 100644 (file)
--- a/jitplus/jit-plus-function.cpp
+++ b/jitplus/jit-plus-function.cpp
@@ -628,23 +628,45 @@ jit_value jit_function::get_struct_pointer()
  * @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_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_return ({const jit_value&} 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_default_return ()
  * @deftypemethodx jit_function void insn_throw ({const jit_value&} 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_rethrow_unhandled ()
+ * @deftypemethodx jit_function void insn_start_finally ({jit_label&} 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 void insn_memmove ({const jit_value&} dest, {const jit_value&} src, {const jit_value&} size)
- * @deftypemethodx void jit_insn_memset ({const jit_value&} dest, {const jit_value&} value, {const jit_value&} size)
- * @deftypemethodx jit_value jit_insn_alloca ({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)
  * Create instructions of various kinds.  @xref{Instructions}, for more
  * information on the individual instructions and their arguments.
  * @end deftypemethod
@@ -1063,6 +1085,11 @@ jit_value jit_function::insn_address_of(const jit_value& value1)
        value_wrap(jit_insn_address_of(func, value1.raw()));
 }
 
+jit_value jit_function::insn_address_of_label(jit_label& label)
+{
+       value_wrap(jit_insn_address_of_label(func, label.rawp()));
+}
+
 jit_value jit_function::insn_convert
        (const jit_value& value, jit_type_t type, int overflow_check)
 {
@@ -1111,11 +1138,72 @@ jit_value jit_function::insn_call_intrinsic
                (func, name, intrinsic_func, &descriptor, arg1.raw(), arg2.raw()));
 }
 
+void jit_function::insn_incoming_reg(const jit_value& value, int reg)
+{
+       if(!jit_insn_incoming_reg(func, value.raw(), reg))
+       {
+               out_of_memory();
+       }
+}
+
+void jit_function::insn_incoming_frame_posn
+       (const jit_value& value, jit_nint posn)
+{
+       if(!jit_insn_incoming_frame_posn(func, value.raw(), posn))
+       {
+               out_of_memory();
+       }
+}
+
+void jit_function::insn_outgoing_reg(const jit_value& value, int reg)
+{
+       if(!jit_insn_outgoing_reg(func, value.raw(), reg))
+       {
+               out_of_memory();
+       }
+}
+
+void jit_function::insn_return_reg(const jit_value& value, int reg)
+{
+       if(!jit_insn_return_reg(func, value.raw(), reg))
+       {
+               out_of_memory();
+       }
+}
+
+void jit_function::insn_setup_for_nested(int nested_level, int reg)
+{
+}
+
+void jit_function::insn_flush_struct(const jit_value& value)
+{
+       if(!jit_insn_flush_struct(func, value.raw()))
+       {
+               out_of_memory();
+       }
+}
+
 jit_value jit_function::insn_import(jit_value value)
 {
        value_wrap(jit_insn_import(func, value.raw()));
 }
 
+void jit_function::insn_push(const jit_value& value)
+{
+       if(!jit_insn_push(func, value.raw()))
+       {
+               out_of_memory();
+       }
+}
+
+void jit_function::insn_push_ptr(const jit_value& value, jit_type_t type)
+{
+       if(!jit_insn_push_ptr(func, value.raw(), type))
+       {
+               out_of_memory();
+       }
+}
+
 void jit_function::insn_return(const jit_value& value)
 {
        if(!jit_insn_return(func, value.raw()))
@@ -1161,6 +1249,86 @@ jit_value jit_function::insn_get_call_stack()
        value_wrap(jit_insn_get_call_stack(func));
 }
 
+jit_value jit_function::insn_thrown_exception()
+{
+       value_wrap(jit_insn_thrown_exception(func));
+}
+
+void jit_function::insn_uses_catcher()
+{
+       if(!jit_insn_uses_catcher(func))
+       {
+               out_of_memory();
+       }
+}
+
+jit_value jit_function::insn_start_catcher()
+{
+       value_wrap(jit_insn_start_catcher(func));
+}
+
+void jit_function::insn_branch_if_pc_not_in_range
+       (const jit_label& start_label, const jit_label& end_label,
+        jit_label& label)
+{
+       if(!jit_insn_branch_if_pc_not_in_range
+                       (func, start_label.raw(), end_label.raw(), label.rawp()))
+       {
+               out_of_memory();
+       }
+}
+
+void jit_function::insn_rethrow_unhandled()
+{
+       if(!jit_insn_rethrow_unhandled(func))
+       {
+               out_of_memory();
+       }
+}
+
+void jit_function::insn_start_finally(jit_label& label)
+{
+       if(!jit_insn_start_finally(func, label.rawp()))
+       {
+               out_of_memory();
+       }
+}
+
+void jit_function::insn_return_from_finally()
+{
+       if(!jit_insn_return_from_finally(func))
+       {
+               out_of_memory();
+       }
+}
+
+void jit_function::insn_call_finally(jit_label& label)
+{
+       if(!jit_insn_call_finally(func, label.rawp()))
+       {
+               out_of_memory();
+       }
+}
+
+jit_value jit_function::insn_start_filter(jit_label& label, jit_type_t type)
+{
+       value_wrap(jit_insn_start_filter(func, label.rawp(), type));
+}
+
+void jit_function::insn_return_from_filter(const jit_value& value)
+{
+       if(!jit_insn_return_from_filter(func, value.raw()))
+       {
+               out_of_memory();
+       }
+}
+
+jit_value jit_function::insn_call_filter
+       (jit_label& label, const jit_value& value, jit_type_t type)
+{
+       value_wrap(jit_insn_call_filter(func, label.rawp(), value.raw(), type));
+}
+
 void jit_function::insn_memcpy
        (const jit_value& dest, const jit_value& src, const jit_value& size)
 {
@@ -1193,6 +1361,24 @@ jit_value jit_function::insn_alloca(const jit_value& size)
        value_wrap(jit_insn_alloca(func, size.raw()));
 }
 
+void jit_function::insn_move_blocks_to_end
+       (const jit_label& from_label, const jit_label& to_label)
+{
+       if(!jit_insn_move_blocks_to_end(func, from_label.raw(), to_label.raw()))
+       {
+               out_of_memory();
+       }
+}
+
+void jit_function::insn_move_blocks_to_start
+       (const jit_label& from_label, const jit_label& to_label)
+{
+       if(!jit_insn_move_blocks_to_start(func, from_label.raw(), to_label.raw()))
+       {
+               out_of_memory();
+       }
+}
+
 void jit_function::register_on_demand()
 {
        jit_function_set_on_demand_compiler(func, on_demand_compiler);