("count", "number of objects to allocate" ),
]
outs = [
- ("M", "memory result", "pn_Generic_M"),
- ("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
- ("X_except", "control flow when exception occured", "pn_Generic_X_except"),
- ("res", "pointer to newly allocated memory", "pn_Generic_other"),
+ ("M", "memory result"),
+ ("res", "pointer to newly allocated memory"),
+ ("X_regular", "control flow when no exception occurs"),
+ ("X_except", "control flow when exception occured"),
]
attrs = [
dict(
)
]
flags = [ "fragile", "uses_memory" ]
- pinned = "yes"
+ pinned = "exception"
+ throws_init = "false"
+ pinned_init = "op_pin_state_pinned"
attr_struct = "alloc_attr"
class Anchor(Op):
they are set to Bad, and the actual removal is left to the control flow
optimisation phase. Block, Phi, Tuple with only Bad inputs however are
replaced by Bad right away."""
- mode = "mode_T"
- flags = [ "cfopcode", "start_block", "dump_noblock" ]
+ flags = [ "start_block", "dump_noblock" ]
pinned = "yes"
knownBlock = True
block = "get_irg_start_block(irg)"
- singleton = True
attr_struct = "bad_attr"
init = '''
res->attr.bad.irg.irg = irg;
("upper", "upper bound (exclusive)"),
]
outs = [
- ("M", "memory result", "pn_Generic_M"),
- ("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
- ("X_except", "control flow when exception occured", "pn_Generic_X_except"),
- ("res", "the checked index", "pn_Generic_other"),
+ ("M", "memory result"),
+ ("res", "the checked index"),
+ ("X_regular", "control flow when no exception occurs"),
+ ("X_except", "control flow when exception occured"),
]
flags = [ "fragile", "highlevel" ]
pinned = "exception"
pinned_init = "op_pin_state_pinned"
+ throws_init = "false"
attr_struct = "bound_attr"
attrs_name = "bound"
]
arity = "variable"
outs = [
- ("M", "memory result", "pn_Generic_M"),
- ("1_result", "first result", "pn_Generic_other"),
+ ("M", "memory result"),
+ ("1_result", "first result"),
]
flags = [ "uses_memory" ]
attrs = [
]
arity = "variable"
outs = [
- ("M", "memory result", "pn_Generic_M"),
- ("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
- ("X_except", "control flow when exception occured", "pn_Generic_X_except"),
- ("T_result", "tuple containing all results", "pn_Generic_other"),
- ("P_value_res_base", "pointer to memory register containing copied results passed by value"),
+ ("M", "memory result"),
+ ("T_result", "tuple containing all results"),
+ ("X_regular", "control flow when no exception occurs"),
+ ("X_except", "control flow when exception occured"),
]
flags = [ "fragile", "uses_memory" ]
attrs = [
attr_struct = "call_attr"
pinned = "memory"
pinned_init = "op_pin_state_pinned"
+ throws_init = "false"
init = '''
assert((get_unknown_type() == type) || is_Method_type(type));
'''
init = "assert(is_atomic_type(type));"
class Cmp(Binop):
- """Returns the relation of 2 operands"""
- outs = [
- ("False", "always false", "0"),
- ("Eq", "equal", "1"),
- ("Lt", "less", "2"),
- ("Le", "less or equal", "pn_Cmp_Eq|pn_Cmp_Lt"),
- ("Gt", "greater", "4"),
- ("Ge", "greater or equal", "pn_Cmp_Eq|pn_Cmp_Gt"),
- ("Lg", "less or greater ('not equal' for integer numbers)", "pn_Cmp_Lt|pn_Cmp_Gt"),
- ("Leg", "less, equal or greater ('not unordered')", "pn_Cmp_Lt|pn_Cmp_Eq|pn_Cmp_Gt"),
- ("Uo", "unordered", "8"),
- ("Ue", "unordered or equal", "pn_Cmp_Uo|pn_Cmp_Eq"),
- ("Ul", "unordered or less", "pn_Cmp_Uo|pn_Cmp_Lt"),
- ("Ule", "unordered, less or equal", "pn_Cmp_Uo|pn_Cmp_Lt|pn_Cmp_Eq"),
- ("Ug", "unordered or greater", "pn_Cmp_Uo|pn_Cmp_Gt"),
- ("Uge", "onordered, greater or equal", "pn_Cmp_Uo|pn_Cmp_Gt|pn_Cmp_Eq"),
- ("Ne", "unordered, less or greater ('not equal' for floatingpoint numbers)", "pn_Cmp_Uo|pn_Cmp_Lt|pn_Cmp_Gt"),
- ("True", "always true", "15"),
- ]
+ """Compares its two operands and checks whether a specified
+ relation (like less or equal) is fulfilled."""
flags = []
+ mode = "mode_b"
+ attrs = [
+ dict(
+ type = "ir_relation",
+ name = "relation",
+ comment = "Comparison relation"
+ )
+ ]
+ attr_struct = "cmp_attr"
class Cond(Op):
"""Conditionally change control flow. There are two versions of this node:
pinned = "yes"
attrs = [
dict(
- name = "cmp",
- type = "pn_Cmp",
- comment = "compare operation",
+ name = "relation",
+ type = "ir_relation",
+ comment = "relation of value to bound",
),
]
attr_struct = "confirm_attr"
("src", "source address"),
]
outs = [
- ("M", "memory result", "pn_Generic_M"),
- ("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
- ("X_except", "control flow when exception occured", "pn_Generic_X_except"),
+ ("M", "memory result"),
+ ("X_regular", "control flow when no exception occurs"),
+ ("X_except", "control flow when exception occured"),
]
flags = [ "fragile", "uses_memory" ]
attrs = [
attrs_name = "copyb"
pinned = "memory"
pinned_init = "op_pin_state_pinned"
+ throws_init = "false"
class Div(Op):
"""returns the quotient of its 2 operands"""
("right", "second operand"),
]
outs = [
- ("M", "memory result", "pn_Generic_M"),
- ("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
- ("X_except", "control flow when exception occured", "pn_Generic_X_except"),
- ("res", "result of computation", "pn_Generic_other"),
+ ("M", "memory result"),
+ ("res", "result of computation"),
+ ("X_regular", "control flow when no exception occurs"),
+ ("X_except", "control flow when exception occured"),
]
flags = [ "fragile", "uses_memory" ]
attrs_name = "div"
]
attr_struct = "div_attr"
pinned = "exception"
+ throws_init = "false"
op_index = 1
arity_override = "oparity_binary"
ins = [
("target", "target address of the jump"),
]
- flags = [ "cfopcode", "forking", "keep" ]
+ flags = [ "cfopcode", "forking", "keep", "unknown_jump" ]
class InstOf(Op):
- """Tests wether an object is an instance of a class-type"""
+ """Tests whether an object is an instance of a class-type"""
ins = [
("store", "memory dependency"),
("obj", "pointer to object being queried")
]
outs = [
- ("M", "memory result", "pn_Generic_M"),
- ("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
- ("X_except", "control flow when exception occured", "pn_Generic_X_except"),
- ("res", "checked object pointer", "pn_Generic_other"),
+ ("M", "memory result"),
+ ("res", "checked object pointer"),
+ ("X_regular", "control flow when no exception occurs"),
+ ("X_except", "control flow when exception occured"),
]
flags = [ "highlevel" ]
attrs = [
("ptr", "address to load from"),
]
outs = [
- ("M", "memory result", "pn_Generic_M"),
- ("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
- ("X_except", "control flow when exception occured", "pn_Generic_X_except"),
- ("res", "result of load operation", "pn_Generic_other"),
+ ("M", "memory result"),
+ ("res", "result of load operation"),
+ ("X_regular", "control flow when no exception occurs"),
+ ("X_except", "control flow when exception occured"),
]
flags = [ "fragile", "uses_memory" ]
pinned = "exception"
dict(
type = "ir_mode*",
name = "mode",
- java_name = "load_mode",
comment = "mode of the value to be loaded",
),
+ dict(
+ type = "ir_volatility",
+ name = "volatility",
+ comment = "volatile loads are a visible side-effect and may not be optimized",
+ init = "flags & cons_volatile ? volatility_is_volatile : volatility_non_volatile",
+ ),
+ dict(
+ type = "ir_align",
+ name = "unaligned",
+ comment = "pointers to unaligned loads don't need to respect the load-mode/type alignments",
+ init = "flags & cons_unaligned ? align_non_aligned : align_is_aligned",
+ ),
]
attr_struct = "load_attr"
constructor_args = [
),
]
pinned_init = "flags & cons_floats ? op_pin_state_floats : op_pin_state_pinned"
- init = '''
- res->attr.load.volatility = flags & cons_volatile ? volatility_is_volatile : volatility_non_volatile;
- res->attr.load.aligned = flags & cons_unaligned ? align_non_aligned : align_is_aligned;
- '''
+ throws_init = "(flags & cons_throws_exception) != 0"
class Minus(Unop):
"""returns the difference between its operands"""
("right", "second operand"),
]
outs = [
- ("M", "memory result", "pn_Generic_M"),
- ("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
- ("X_except", "control flow when exception occured", "pn_Generic_X_except"),
- ("res", "result of computation", "pn_Generic_other"),
+ ("M", "memory result"),
+ ("res", "result of computation"),
+ ("X_regular", "control flow when no exception occurs"),
+ ("X_except", "control flow when exception occured"),
]
flags = [ "fragile", "uses_memory" ]
attrs_name = "mod"
]
attr_struct = "mod_attr"
pinned = "exception"
+ throws_init = "false"
op_index = 1
arity_override = "oparity_binary"
("exo_ptr", "pointer to exception object to be thrown"),
]
outs = [
- ("M", "memory result", "pn_Generic_M"),
- ("X", "control flow to exception handler", "pn_Generic_X_regular"),
+ ("M", "memory result"),
+ ("X", "control flow to exception handler"),
]
flags = [ "highlevel", "cfopcode" ]
pinned = "yes"
("X_initial_exec", "control flow"),
("M", "initial memory"),
("P_frame_base", "frame base pointer"),
- ("P_tls", "pointer to thread local storage segment"),
("T_args", "function arguments")
]
mode = "mode_T"
("value", "value to store"),
]
outs = [
- ("M", "memory result", "pn_Generic_M"),
- ("X_regular", "control flow when no exception occurs", "pn_Generic_X_regular"),
- ("X_except", "control flow when exception occured", "pn_Generic_X_except"),
+ ("M", "memory result"),
+ ("X_regular", "control flow when no exception occurs"),
+ ("X_except", "control flow when exception occured"),
]
flags = [ "fragile", "uses_memory" ]
pinned = "exception"
attr_struct = "store_attr"
pinned_init = "flags & cons_floats ? op_pin_state_floats : op_pin_state_pinned"
+ throws_init = "(flags & cons_throws_exception) != 0"
+ attrs = [
+ dict(
+ type = "ir_volatility",
+ name = "volatility",
+ comment = "volatile stores are a visible side-effect and may not be optimized",
+ init = "flags & cons_volatile ? volatility_is_volatile : volatility_non_volatile",
+ ),
+ dict(
+ type = "ir_align",
+ name = "unaligned",
+ comment = "pointers to unaligned stores don't need to respect the load-mode/type alignments",
+ init = "flags & cons_unaligned ? align_non_aligned : align_is_aligned",
+ ),
+ ]
constructor_args = [
dict(
type = "ir_cons_flags",
comment = "specifies alignment, volatility and pin state",
),
]
- init = '''
- res->attr.store.volatility = flags & cons_volatile ? volatility_is_volatile : volatility_non_volatile;
- res->attr.store.aligned = flags & cons_unaligned ? align_non_aligned : align_is_aligned;
- '''
class Sub(Binop):
"""returns the difference of its operands"""
following Proj nodes have not to be changed. (They are hard to find due to
the implementation with pointers in only one direction.) The Tuple node is
smaller than any other node, so that a node can be changed into a Tuple by
- just changing it's opcode and giving it a new in array."""
+ just changing its opcode and giving it a new in array."""
arity = "variable"
mode = "mode_T"
pinned = "no"
knownBlock = True
pinned = "yes"
block = "get_irg_start_block(irg)"
- flags = [ "cfopcode", "start_block", "constlike", "dump_noblock" ]
+ flags = [ "start_block", "constlike", "dump_noblock" ]
# Prepare node list
projects / libfirm / blobdiff