Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.ir;
  
  // SSS FIXME: If we can hide these flags from leaking out to the rest of the codebase,
  // that would be awesome, but I cannot nest this class in an Enum class.
  class OpFlags {
      final static int f_has_side_effect     = 0x0001;
      final static int f_can_raise_exception = 0x0002;
      final static int f_is_marker_op        = 0x0004;
      final static int f_is_jump_or_branch   = 0x0008;
     final static int f_is_return           = 0x0010;
     final static int f_is_exception        = 0x0020;
     final static int f_is_debug_op         = 0x0040;
     final static int f_is_load             = 0x0080;
     final static int f_is_store            = 0x0100;
     final static int f_is_call             = 0x0200;
     final static int f_is_arg_receive      = 0x0400;
     final static int f_modifies_code       = 0x0800;
     final static int f_inline_unfriendly   = 0x1000;
     final static int f_is_book_keeping_op  = 0x4000;
 }
 
 public enum Operation {
 /* Mark a *non-control-flow* instruction as side-effecting if its compuation is not referentially
  * transparent.  In other words, mark it side-effecting if the following is true:
  *
  *   If "r = op(args)" is the instruction I and v is the value produced by the instruction at runtime,
  *   and replacing I with "r = v" will leave the program behavior unchanged.  If so, and we determine
  *   that the value of 'r' is not used anywhere, then it would be safe to get rid of I altogether.
  *
  * So definitions, calls, returns, stores are all side-effecting by this definition */
 
 // ------ Define the operations below ----
     NOP(0),

    
control-flow
 
     JUMP_INDIRECT(.),
     B_UNDEF(.),
     B_NIL(.),
     B_TRUE(.),
     B_FALSE(.),

    
argument receive in methods and blocks
 
     RECV_SELF(0),
     RECV_PRE_REQD_ARG(.),
     RECV_POST_REQD_ARG(.),
     RECV_KW_ARG(.),
     RECV_KW_REST_ARG(.),
     RECV_REST_ARG(.),
     RECV_OPT_ARG(.),
     RECV_CLOSURE(.),
     RECV_EXCEPTION(.),
 
     /* By default, call instructions cannot be deleted even if their results
      * aren't used by anyone unless we know more about what the call is,
      * what it does, etc.  Hence all these are marked side effecting */

    
calls
 
 
     /* specialized calls */
     NORESULT_CALL_1O(. | . | .),

    
returns -- returns unwind stack, etc.
 
     NONLOCAL_RETURN(. | .),
     /* BREAK is a return because it can only be used within closures
      * and the net result is to return from the closure */
     BREAK(. | .),

    
defines
 
marker instructions used to flag/mark places in the code and dont actually get executed
 
     EXC_REGION_START(. | .),
     EXC_REGION_END(. | .),

    
constant operations
 
     LEXICAL_SEARCH_CONST(.),
    INHERITANCE_SEARCH_CONST(.),
    CONST_MISSING(.),
    SEARCH_CONST(.),

    
value loads (SSS FIXME: Do any of these have side effects?)
    GET_GLOBAL_VAR(.),
    GET_FIELD(.),
    BINDING_LOAD(.),
    MASGN_OPT(.),
    MASGN_REQD(.),
    MASGN_REST(.),

    
value stores
    // SSS FIXME: Not all global variable sets can throw exceptions.  Should we split this
    // operation into two different operations?  Those that can throw exceptions and those
    // that cannot.  But, for now, this should be good enough
    BINDING_STORE(. | .),
debugging ops
    LINE_NUM(. | .),

    
JRuby-impl instructions
    COPY(0),
    NOT(0), // ruby NOT operator
    BLOCK_GIVEN(0),
    GET_OBJECT(0),
    GET_BACKREF(0),
    RESTORE_ERROR_INFO(.),
    RAISE_ARGUMENT_ERROR(.),
    CHECK_ARGS_ARRAY_ARITY(.),
    TO_ARY(0),
    ENSURE_RUBY_ARRAY(0),
    SET_RETADDR(0),
    CLASS_VAR_MODULE(0),
    IS_TRUE(0), // checks if the operand is non-null and non-false
    EQQ(0), // (FIXME: Exceptions?) a === call used in when
    RESCUE_EQQ(.), // a === call used in rescue
    GET_ENCODING(0),
    /* Instructions to support defined? */
    SET_WITHIN_DEFINED(.),
    DEFINED_CONSTANT_OR_METHOD(.),
    METHOD_DEFINED(.),
    BACKREF_IS_MATCH_DATA(0),
    CLASS_VAR_IS_DEFINED(0),
    GLOBAL_IS_DEFINED(0),
    HAS_INSTANCE_VAR(0),
    IS_METHOD_BOUND(0),
    METHOD_IS_PUBLIC(0),
    SUPER_METHOD_BOUND(0),
    GET_ERROR_INFO(0),

    
Other JRuby internal primitives for optimizations
    MODULE_GUARD(.), /* a guard acts as a branch */
    METHOD_LOOKUP(0), /* for splitting calls into method-lookup and call -- unused **/
    BOX_VALUE(0), /* primitive value boxing/unboxing -- unused */
    UNBOX_VALUE(0); /* unused */
/* ----------- unused ops ------------------
// primitive alu operations -- unboxed primitive ops (not native ruby)
    ADD(0), SUB(0), MUL(0), DIV(OpFlags.f_can_raise_exception),
 * -----------------------------------------*/
    public final OpClass opClass;
    private int flags;
    Operation(int flags) {
        this. = flags;
        if (this.isArgReceive()) {
            this. = .;
        } else if (this.isBranch()) {
            this. = .;
        } else if (this.isBookKeepingOp()) {
            this. = .;
        } else if (this.isCall()) {
            this. = .;
        } else {
            this. = .;
        }
    }
    public boolean transfersControl() {
        return ( & (. | . | .)) > 0;
    }
    public boolean isLoad() {
        return ( & .) > 0;
    }
    public boolean isStore() {
        return ( & .) > 0;
    }
    public boolean isCall() {
        return ( & .) > 0;
    }
    public boolean isBranch() {
        return ( & .) > 0;
    }
    public boolean isReturn() {
        return ( & .) > 0;
    }
    public boolean isException() {
        return ( & .) > 0;
    }
    public boolean isArgReceive() {
        return ( & .) > 0;
    }
    public boolean startsBasicBlock() {
        return this == ;
    }
    public boolean endsBasicBlock() {
        return transfersControl();
    }
    public boolean hasSideEffects() {
        return ( & .) > 0;
    }
    public boolean isDebugOp() {
        return ( & .) > 0;
    }
    public boolean isBookKeepingOp() {
        return ( & .) > 0;
    }
    // Conservative -- say no only if you know it for sure cannot
    public boolean canRaiseException() {
        return ( & .) > 0;
    }
    public boolean modifiesCode() {
        return ( & .) > 0;
    }
    public boolean inlineUnfriendly() {
        return ( & .) > 0;
    }
    @Override
    public String toString() {
        return name().toLowerCase();
    }
New to GrepCode? Check out our FAQ X