("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"),
]
flags = [ "fragile", "uses_memory" ]
attrs = [
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"
pinned_init = "op_pin_state_pinned"
class Div(Op):
- """returns the quotient of its 2 operands, integer version"""
+ """returns the quotient of its 2 operands"""
ins = [
("mem", "memory dependency"),
("left", "first operand"),
("res", "result of computation", "pn_Generic_other"),
]
flags = [ "fragile", "uses_memory" ]
- attrs_name = "divmod"
+ attrs_name = "div"
attrs = [
dict(
type = "ir_mode*",
init = "0",
)
]
- attr_struct = "divmod_attr"
- pinned = "exception"
- op_index = 1
- arity_override = "oparity_binary"
-
-class DivMod(Op):
- """divides its 2 operands and computes the remainder of the division"""
- ins = [
- ("mem", "memory dependency"),
- ("left", "first operand"),
- ("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_div", "result of computation a/b", "pn_Generic_other"),
- ("res_mod", "result of computation a%b"),
- ]
- flags = [ "fragile", "uses_memory" ]
- attrs_name = "divmod"
- attrs = [
- dict(
- type = "ir_mode*",
- name = "resmode",
- comment = "mode of the result value",
- ),
- ]
- attr_struct = "divmod_attr"
+ attr_struct = "div_attr"
pinned = "exception"
op_index = 1
arity_override = "oparity_binary"
flags = [ "cfopcode", "forking", "keep" ]
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")
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;
- '''
class Minus(Unop):
"""returns the difference between its operands"""
("res", "result of computation", "pn_Generic_other"),
]
flags = [ "fragile", "uses_memory" ]
- attrs_name = "divmod"
+ attrs_name = "mod"
attrs = [
dict(
type = "ir_mode*",
comment = "mode of the result",
),
]
- attr_struct = "divmod_attr"
+ attr_struct = "mod_attr"
pinned = "exception"
op_index = 1
arity_override = "oparity_binary"
]
attr_struct = "proj_attr"
-class Quot(Op):
- """returns the quotient of its 2 operands, floatingpoint version"""
- ins = [
- ("mem", "memory dependency"),
- ("left", "first operand"),
- ("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"),
- ]
- flags = [ "fragile", "uses_memory" ]
- attrs_name = "divmod"
- attrs = [
- dict(
- type = "ir_mode*",
- name = "resmode",
- comment = "mode of the result value",
- ),
- ]
- attr_struct = "divmod_attr"
- pinned = "exception"
- op_index = 1
- arity_override = "oparity_binary"
-
class Raise(Op):
"""Raises an exception. Unconditional change of control flow. Writes an
explicit Except variable to memory to pass it to the exception handler.
("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"
pinned = "exception"
attr_struct = "store_attr"
pinned_init = "flags & cons_floats ? op_pin_state_floats : op_pin_state_pinned"
+ 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"
projects / libfirm / blobdiff