* Prepares the cost matrix dependent on the given mode.
*
* @param p The hungarian object
- * @param mode specify wether to minimize or maximize the costs
+ * @param mode specify whether to minimize or maximize the costs
*/
FIRM_API void hungarian_prepare_cost_matrix(hungarian_problem_t *p,
hungarian_mode_t mode);
FIRM_API void set_irg_state(ir_graph *irg, ir_graph_state_t state);
/** clear some state flags of the graph */
FIRM_API void clear_irg_state(ir_graph *irg, ir_graph_state_t state);
-/** query wether a set of graph state flags are activated */
+/** query whether a set of graph state flags are activated */
FIRM_API int is_irg_state(const ir_graph *irg, ir_graph_state_t state);
/** Set a description for local value n. */
FIRM_API ir_node *optimize_in_place(ir_node *n);
/**
- * checks wether 1 value is the negated other value
+ * checks whether 1 value is the negated other value
*/
FIRM_API int ir_is_negated_value(const ir_node *a, const ir_node *b);
const ir_node *right);
/**
- * tests wether a given Cmp node is an equal/not-equal test with 0
+ * tests whether a given Cmp node is an equal/not-equal test with 0
* (this is a bit tricky because it has to catch x!=0 for the signed case and
* x>0 for the unsigned case)
*/
} ir_align;
/**
- * Returns indication wether entity is aligned in memory.
+ * Returns indication whether entity is aligned in memory.
* @deprecated
*/
FIRM_API ir_align get_entity_aligned(const ir_entity *ent);
/**
- * Sets indication wether entity is aligned in memory
+ * Sets indication whether entity is aligned in memory
* @deprecated
*/
FIRM_API void set_entity_aligned(ir_entity *ent, ir_align a);
FIRM_API int is_compound_type(const ir_type *tp);
/**
- * Checks wether a type is a code type.
+ * Checks whether a type is a code type.
*/
FIRM_API int is_code_type(const ir_type *tp);
* @param bitset the bitset
* @param from first bit to set
* @param to last bit (the first bit which is not set anymore)
- * @param val wether to set to 1 or 0
+ * @param val whether to set to 1 or 0
*/
static inline void rbitset_set_range(unsigned *bitset, size_t from,
size_t to, bool val)
}
/**
- * Tests wether 2 bitsets wether at least 1 bit is set in both.
+ * Tests whether 2 bitsets have at least one common set bit.
*
* @param bitset1 the first bitset
* @param bitset2 the second bitset
}
/**
- * Tests wether all bits set in bitset1 are also set in bitset2.
+ * Tests whether all bits set in bitset1 are also set in bitset2.
*
* @param bitset1 the first bitset
* @param bitset2 the second bitset
}
/**
- * Tests wether a node has a real user and is not just kept by the End or
+ * Tests whether a node has a real user and is not just kept by the End or
* Anchor node
*/
static bool has_real_user(const ir_node *node)
typedef ir_node * (*func_rematerialize) (ir_node *node, ir_node *after);
/**
- * Callback function that checks wether a node modifies the flags
+ * Callback function that checks whether a node modifies the flags
*/
typedef bool (*check_modifies_flags) (const ir_node *node);
permute_values(live_nodes, node, assignment);
}
-/** test wether a node @p n is a copy of the value of node @p of */
+/** test whether a node @p n is a copy of the value of node @p of */
static bool is_copy_of(ir_node *value, ir_node *test_value)
{
allocation_info_t *test_info;
return REMAT_COST_INFINITE;
}
/* never rematerialize a node which modifies the flags.
- * (would be better to test wether the flags are actually live at point
+ * (would be better to test whether the flags are actually live at point
* reloader...)
*/
if (arch_irn_is(insn, modify_flags)) {
/* we have to be at offset 0 */
int my_offset = get_ia32_am_offs_int(store);
if (my_offset != 0) {
- /* TODO here: find out wether there is a store with offset 0 before
- * us and wether we can move it down to our place */
+ /* TODO here: find out whether there is a store with offset 0 before
+ * us and whether we can move it down to our place */
return;
}
ir_mode *ls_mode = get_ia32_ls_mode(store);
};
/**
- * Sparc ABI requires some space which is always available at the top of
+ * SPARC ABI requires some space which is always available at the top of
* the stack. It contains:
* 16*4 bytes space for spilling the register window
- * 1*4 byte holding a pointer to space for agregate returns (the space is
- * always reserved, regardless wether we have an agregate return
+ * 1*4 byte holding a pointer to space for aggregate returns (the space is
+ * always reserved, regardless whether we have an aggregate return
* or not)
* 6*4 bytes Space for spilling parameters 0-5. For the cases when someone
- * takes the adress of a parameter. I guess this is also there so
+ * takes the address of a parameter. I guess this is also there so
* the implementation of va_args gets easier -> We can simply store
* param 0-5 in this spaces and then handle va_next by simply
* incrementing the stack pointer
init = "assert(is_atomic_type(type));"
class Cmp(Binop):
- """Compares its two operands and checks wether a specified
+ """Compares its two operands and checks whether a specified
relation (like less or equal) is fulfilled."""
flags = []
mode = "mode_b"
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")
projects / libfirm / commitdiff