Alien-LibJIT
view release on metacpan or search on metacpan
libjit/COPYING view on Meta::CPAN
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
libjit/COPYING.LESSER view on Meta::CPAN
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
libjit/COPYING.LESSER view on Meta::CPAN
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
libjit/doc/libjit.texi view on Meta::CPAN
compiler that performs greater levels of optimization.
If you no longer intend to recompile the function, you should call
@code{jit_function_clear_recompilable} so that @code{libjit} can
manage the function more efficiently from then on.
The exact conditions under which a function should be recompiled
are not specified by @code{libjit}. It may be because the function
has been called several times and has reached some threshold.
Or it may be because some other function that it calls has become a
candidate for inlining. It is up to the front end to decide when
recompilation is warranted, usually based on language-specific
heuristics.
@c -----------------------------------------------------------------------
@node Tutorial 4, Tutorial 5, Tutorial 3, Tutorials
@section Tutorial 4 - mul_add, C++ version
@cindex mul_add C++ tutorial
While @code{libjit} can be easily accessed from C++ programs using
libjit/jit/jit-debugger.c view on Meta::CPAN
@item
Event thread which calls @code{jit_debugger_wait_event} to receive
notifications of breakpoints and other interesting events.
@item
User interface thread which calls functions like @code{jit_debugger_run},
@code{jit_debugger_step}, etc, to control the debug process.
@end enumerate
These two threads should be set to "unbreakable" with a call to
@code{jit_debugger_set_breakable}. This prevents them from accidentally
stopping at a breakpoint, which would cause a system deadlock.
Other housekeeping threads, such as a finalization thread, should
also be set to "unbreakable" for the same reason.
@noindent
Events have the following members:
@table @code
@item type
The type of event (see the next table for details).
libjit/jit/jit-debugger.c view on Meta::CPAN
}
}
/*@
* @deftypefun void jit_debugger_set_breakable (jit_debugger_t @var{dbg}, const void *@var{native_thread}, 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
* this is used to mark threads associated with the debugger's user
* interface, or the virtual machine's finalization thread, so that they
* aren't accidentally suspended by the debugger (which might cause a
* deadlock).
* @end deftypefun
@*/
void jit_debugger_set_breakable
(jit_debugger_t dbg, const void *native_thread, int flag)
{
jit_debugger_thread_t th;
jit_debugger_thread_id_t id;
id = jit_debugger_get_thread(dbg, native_thread);
lock_debugger(dbg);
libjit/jit/jit-debugger.c view on Meta::CPAN
}
unlock_debugger(dbg);
}
/*@
* @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
* breakpoint in a function, a user-supplied hook function is called.
* It is up to the hook function to decide whether to stop execution
* or to ignore the breakpoint. The hook function has the following
* prototype:
*
* @example
* void hook(jit_function_t func, jit_nint data1, jit_nint data2);
* @end example
*
* The @code{func} argument indicates the function that the breakpoint
* occurred within. The @code{data1} and @code{data2} arguments are
* those supplied to @code{jit_insn_mark_breakpoint}. The debugger can use
libjit/jit/jit-function.c view on Meta::CPAN
{
if(func)
{
func->is_recompilable = 1;
}
}
/*@
* @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.
*
* Future uses of the function with @code{jit_insn_call} will output a
* direct call to the function, which is more efficient than calling
* its recompilable version. Pre-existing calls to the function may still
* use redirection stubs, and will remain so until the pre-existing
* functions are themselves recompiled.
* @end deftypefun
@*/
void jit_function_clear_recompilable(jit_function_t func)
libjit/jit/jit-function.c view on Meta::CPAN
* exception occurred.
*
* This is the primary means for executing a function from ordinary
* C code without creating a closure first with @code{jit_function_to_closure}.
* Closures may not be supported on all platforms, but function application
* is guaranteed to be supported everywhere.
*
* Function applications acts as an exception blocker. If any exceptions
* 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 @var{func}, jit_type_t @var{signature}, void **@var{args}, void *@var{return_area})
* 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}.
* @end deftypefun
libjit/jit/jit-insn.c view on Meta::CPAN
static int create_call_setup_insns
(jit_function_t func, jit_function_t callee, jit_type_t signature,
jit_value_t *args, unsigned int num_args,
int is_nested, int nesting_level, jit_value_t *struct_return, int flags)
{
jit_value_t *new_args;
jit_value_t value;
unsigned int arg_num;
/* If we are performing a tail call, then duplicate the argument
values so that we don't accidentally destroy parameters in
situations like func(x, y) -> func(y, x) */
if((flags & JIT_CALL_TAIL) != 0 && num_args > 0)
{
new_args = (jit_value_t *)alloca(sizeof(jit_value_t) * num_args);
for(arg_num = 0; arg_num < num_args; ++arg_num)
{
value = args[arg_num];
if(value && value->is_parameter)
{
value = jit_insn_dup(func, value);
libjit/jit/jit-rules-arm.ins view on Meta::CPAN
/*
* Branch opcodes.
*/
JIT_OP_BR: branch /*spill_before*/
[] -> {
/* ARM_CC_AL == "always branch" */
output_branch(func, &inst, ARM_CC_AL, insn);
/* Flush the constant pool now, to minimize the probability that
it is accidentally flushed in the middle of a loop body */
jit_gen_save_inst_ptr(gen, inst);
flush_constants(gen, 1);
jit_gen_load_inst_ptr(gen, inst);
}
JIT_OP_BR_IFALSE: branch
[reg] -> {
arm_test_reg_imm8(inst, ARM_CMP, $1, 0);
output_branch(func, &inst, ARM_CC_EQ, insn);
}
libjit/jit/jit-rules-arm.ins view on Meta::CPAN
}
jump_to_epilog(gen, &inst, block);
jit_gen_save_inst_ptr(gen, inst);
}
JIT_OP_RETURN_SMALL_STRUCT: note
[reg, imm, clobber("r0", "r1")] -> {
//$1: address of the struct to be returned
//$2: size of the struct to be returned
//Prevent the accidental overwriting of the address
int temp_reg = $1;
if(temp_reg < 3)
{
arm_mov_reg_reg(inst, ARM_WORK, temp_reg);
temp_reg = ARM_WORK;
}
//Copy the struct to the return register in a way that's appropriate to its size
switch($2)
{
libjit/jit/jit-rules-interp.c view on Meta::CPAN
info->abi_version = JIT_OPCODE_VERSION;
}
/*@
* @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.
*
* This function is called when a builder is initialized. It should
* scan the signature and decide which register or frame position
* contains each of the parameters and then call either
* @code{jit_insn_incoming_reg} or @code{jit_insn_incoming_frame_posn}
* to notify @code{libjit} of the location.
* @end deftypefun
@*/
int _jit_create_entry_insns(jit_function_t func)
{
jit_type_t signature = func->signature;
jit_type_t type;
jit_nint offset;
libjit/jit/jit-rules.c view on Meta::CPAN
{
return 0;
}
passing->offset += sizeof(void *);
}
return 1;
}
/*
* Force the remaining word registers out into temporary values,
* to protect them from being accidentally overwritten by the code
* that deals with multi-word parameters.
*/
static int force_remaining_out
(jit_function_t func, jit_param_passing_t *passing)
{
unsigned int index = passing->index;
jit_value_t value;
while(index < passing->max_regs && passing->word_regs[index] != -1)
{
if(passing->word_values[index] != 0)
( run in 1.744 second using v1.01-cache-2.11-cpan-de7293f3b23 )