X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbearch.h;h=9c0e92446fcb063d95ac7c6deeadf8eafa0bcb09;hb=e629e6d582dcf7d83989409bd5701d1725b6c6c1;hp=534a1df5db046c77ed570b12052dae36866ac95e;hpb=c675b5d864c110cca59fd91351ec318fc19188e0;p=libfirm diff --git a/ir/be/bearch.h b/ir/be/bearch.h index 534a1df5d..9c0e92446 100644 --- a/ir/be/bearch.h +++ b/ir/be/bearch.h @@ -1,7 +1,10 @@ #ifndef _FIRM_BEARCH_H #define _FIRM_BEARCH_H -#include "firm_config.h" +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + #ifdef WITH_LIBCORE #include @@ -21,11 +24,10 @@ typedef struct _arch_register_class_t arch_register_class_t; typedef struct _arch_register_t arch_register_t; -typedef struct _arch_enum_t arch_enum_t; -typedef struct _arch_enum_member_t arch_enum_member_t; typedef struct _arch_isa_if_t arch_isa_if_t; typedef struct _arch_isa_t arch_isa_t; typedef struct _arch_env_t arch_env_t; +typedef struct _arch_irn_ops_if_t arch_irn_ops_if_t; typedef struct _arch_irn_ops_t arch_irn_ops_t; typedef struct _arch_irn_handler_t arch_irn_handler_t; typedef struct _arch_code_generator_t arch_code_generator_t; @@ -35,7 +37,6 @@ struct _be_node_factory_t; typedef enum _arch_register_type_t { arch_register_type_none = 0, - arch_register_type_write_invariant, arch_register_type_caller_saved, /**< The register must be saved by the caller upon a function call. It thus can be overwritten in the called function. */ @@ -44,6 +45,15 @@ typedef enum _arch_register_type_t { arch_register_type_ignore /**< Do not consider this register when allocating. */ } arch_register_type_t; +/** + * Convenience macro to check for register type. + * @param req A pointer to register. + * @param kind The kind of type to check for (see arch_register_type_t). + * @return 1, If register is of given kind, 0 if not. + */ +#define arch_register_type_is(reg, kind) \ + ((reg)->type == arch_register_type_ ## kind) + /** * A register. */ @@ -100,13 +110,6 @@ _arch_register_for_index(const arch_register_class_t *cls, int idx) #define arch_register_for_index(cls, idx) \ _arch_register_for_index(cls, idx) -/** - * Get the register set for a register class. - * @param cls The register class. - * @return The set containing all registers in the class. - */ -#define arch_get_register_set_for_class(cls) ((cls)->set) - typedef enum _arch_operand_type_t { arch_operand_type_invalid, arch_operand_type_memory, @@ -152,7 +155,7 @@ typedef struct _arch_register_req_t { arch_register_req_type_t type; /**< The type of the constraint. */ const arch_register_class_t *cls; /**< The register class this constraint belongs to. */ - int (*limited)(const ir_node *irn, int pos, bitset_t *bs); + void (*limited)(const ir_node *irn, int pos, bitset_t *bs); /**< In case of the 'limited' constraint, this function must put all allowable @@ -175,18 +178,20 @@ typedef enum _arch_irn_class_t { arch_irn_class_reload, arch_irn_class_copy, arch_irn_class_perm, - arch_irn_class_branch + arch_irn_class_branch, + arch_irn_class_call } arch_irn_class_t; /** * Some flags describing a node in more detail. */ typedef enum _arch_irn_flags_t { - arch_irn_flags_spillable = 1, - arch_irn_flags_rematerializable = 2 + arch_irn_flags_dont_spill = 1, /**< This must not be spilled. */ + arch_irn_flags_rematerializable = 2, /**< This should be replicated instead of spilled/reloaded. */ + arch_irn_flags_ignore = 4, /**< Do not consider the node during register allocation. */ } arch_irn_flags_t; -struct _arch_irn_ops_t { +struct _arch_irn_ops_if_t { /** * Get the register requirements for a given operand. @@ -198,7 +203,7 @@ struct _arch_irn_ops_t { * @return The register requirements for the selected operand. * The pointer returned is never NULL. */ - const arch_register_req_t *(*get_irn_reg_req)(const arch_irn_ops_t *self, + const arch_register_req_t *(*get_irn_reg_req)(const void *self, arch_register_req_t *req, const ir_node *irn, int pos); /** @@ -208,7 +213,7 @@ struct _arch_irn_ops_t { * @note If the operand is not a register operand, * the call is ignored. */ - void (*set_irn_reg)(const arch_irn_ops_t *self, ir_node *irn, const arch_register_t *reg); + void (*set_irn_reg)(const void *self, ir_node *irn, const arch_register_t *reg); /** * Get the register allocated for an output operand. @@ -218,14 +223,14 @@ struct _arch_irn_ops_t { * @c arch_register_invalid, if no register has yet been * allocated for this node. */ - const arch_register_t *(*get_irn_reg)(const arch_irn_ops_t *self, const ir_node *irn); + const arch_register_t *(*get_irn_reg)(const void *self, const ir_node *irn); /** * Classify the node. * @param irn The node. * @return A classification. */ - arch_irn_class_t (*classify)(const arch_irn_ops_t *self, const ir_node *irn); + arch_irn_class_t (*classify)(const void *self, const ir_node *irn); /** * Get the flags of a node. @@ -233,10 +238,17 @@ struct _arch_irn_ops_t { * @param irn The node. * @return A set of flags. */ - arch_irn_flags_t (*get_flags)(const arch_irn_ops_t *self, const ir_node *irn); + arch_irn_flags_t (*get_flags)(const void *self, const ir_node *irn); }; +/** + * irn_ops base class. + */ +struct _arch_irn_ops_t { + const arch_irn_ops_if_t *impl; +}; + /** * Get the register requirements for a node. * @param env The architecture environment. @@ -336,9 +348,15 @@ extern arch_irn_class_t arch_irn_classify(const arch_env_t *env, const ir_node * */ extern arch_irn_flags_t arch_irn_get_flags(const arch_env_t *env, const ir_node *irn); +#define arch_irn_is_ignore(env, irn) \ + (arch_irn_get_flags(env, irn) == arch_irn_flags_ignore) + #define arch_irn_has_reg_class(env, irn, pos, cls) \ ((cls) == arch_get_irn_reg_class(env, irn, pos)) +#define arch_irn_consider_in_reg_alloc(env, cls, irn) \ + (arch_irn_has_reg_class(env, irn, -1, cls) && !arch_irn_is_ignore(env, irn)) + /** * Somebody who can be asked about nodes. */ @@ -350,7 +368,7 @@ struct _arch_irn_handler_t { * @param irn Some node. * @return Operations for that irn. */ - const arch_irn_ops_t *(*get_irn_ops)(const arch_irn_handler_t *handler, + const void *(*get_irn_ops)(const arch_irn_handler_t *handler, const ir_node *irn); }; @@ -385,6 +403,16 @@ struct _arch_code_generator_if_t { */ void (*before_ra)(void *self); + /** + * Called after register allocation to lower Spills to Stores + */ + ir_node *(*lower_spill)(void *self, ir_node *spill); + + /** + * Called after register allocation to lower Reloads to Loads + */ + ir_node *(*lower_reload)(void *self, ir_node *reload); + /** * Called after everything happened. * The code generator must also be de-allocated here. @@ -463,7 +491,7 @@ struct _arch_isa_if_t { * @param self The this pointer. * @return Some code generator interface. */ - const arch_code_generator_if_t *(*get_code_generator)(void *self); + const arch_code_generator_if_t *(*get_code_generator_if)(void *self); /** * Get the list scheduler to use. @@ -471,6 +499,14 @@ struct _arch_isa_if_t { * @return The list scheduler selector. */ const list_sched_selector_t *(*get_list_sched_selector)(const void *self); + + /** + * Get the proj number assigned to the register. + * @param self The isa object. + * @param reg The register + * @return The proj number assigned to this register + */ + long (*get_projnum_for_register)(const void *self, const arch_register_t *reg); }; #define arch_isa_get_n_reg_class(isa) ((isa)->impl->get_n_reg_class(isa))