libfirminclude_HEADERS = \
analyze_irg_args.h \
be.h \
+ begin.h \
callgraph.h \
cdep.h \
cgana.h \
compound_path.h \
dbginfo.h \
+ end.h \
execfreq.h \
execution_frequency.h \
field_temperature.h \
irtypeinfo.h \
irvrfy.h \
lowering.h \
- old_fctnames.h \
pseudo_irg.h \
rta.h \
seqnumbers.h \
libfirminclude_adtdir=$(includedir)/libfirm/adt
libfirminclude_adt_HEADERS = \
- adt/align.h \
adt/array.h \
adt/bipartite.h \
adt/cpset.h \
adt/hashptr.h \
adt/hashset.h \
adt/hungarian.h \
- adt/impl.h \
adt/iterator.h \
adt/list.h \
adt/obstack.h \
adt/obst.h \
- adt/offset.h \
adt/pdeq.h \
adt/plist.h \
adt/pmap.h \
adt/pset_new.h \
adt/set.h \
adt/unionfind.h \
- adt/util.h \
adt/xmalloc.h
#include "fourcc.h"
#include "xmalloc.h"
+#include "../begin.h"
+
/**
* Creates a flexible array.
*
*/
#define ARR_SET_CLEAR(arr) ARR_SHRINKLEN(arr, 0)
-#endif /* FIRM_ADT_ARRAY_H */
+#include "../end.h"
+
+#endif
#ifndef FIRM_ADT_BIPARTITE_H
#define FIRM_ADT_BIPARTITE_H
+#include "../begin.h"
+
typedef struct _bipartite_t bipartite_t;
bipartite_t *bipartite_new(int n_left, int n_right);
*/
void bipartite_dump(const char *name, const bipartite_t *gr);
+#include "../end.h"
+
#endif /* _BIPARTITE_H */
#ifndef FIRM_ADT_CPSET_H
#define FIRM_ADT_CPSET_H
+#include "../begin.h"
+
/**
* The type of a cpset compare function.
*
*/
void cpset_remove_iterator(cpset_t *cpset, const cpset_iterator_t *iterator);
-#endif /* FIRM_ADT_CPSET_H */
+#include "../end.h"
+
+#endif
#ifndef FIRM_ADT_ESET_H
#define FIRM_ADT_ESET_H
+#include "../begin.h"
+
/**
* "eset" is a set of addresses. The addresses are used for element
* compare and hash calculation.
/** Inserts all elements of source into target (union). Does NOT work if NULL is contained in source. */
void eset_insert_all(eset *target, eset *source);
+#include "../end.h"
+
#endif
#ifndef FIRM_ADT_GAUSSJORDAN_H
#define FIRM_ADT_GAUSSJORDAN_H
+#include "../begin.h"
+
/**
* solves a system of linear equations and returns 0 if successful
*
*/
int firm_gaussjordansolve(double *A, double *b, int nsize);
+#include "../end.h"
+
#endif
#include <stdio.h>
+#include "../begin.h"
+
typedef struct _gs_matrix_t gs_matrix_t;
/**
void gs_matrix_export(const gs_matrix_t *m, double *nw, int size);
-#endif /*MATRIX_H_*/
+#include "../end.h"
+
+#endif
#ifndef FIRM_ADT_HASHPTR_H
#define FIRM_ADT_HASHPTR_H
+#include "../begin.h"
+
#define _FIRM_FNV_OFFSET_BASIS 2166136261U
#define _FIRM_FNV_FNV_PRIME 16777619U
*/
#define HASH_COMBINE(a,b) _hash_combine(a, b)
+#include "../end.h"
+
#endif
#ifndef FIRM_ADT_HUNGARIAN_H
#define FIRM_ADT_HUNGARIAN_H
+#include "../begin.h"
+
#define HUNGARIAN_MODE_MINIMIZE_COST 0
#define HUNGARIAN_MODE_MAXIMIZE_UTIL 1
*/
void hungarian_print_cost_matrix(hungarian_problem_t *p, int cost_width);
-#endif /* _HUNGARIAN_H_ */
+#include "../end.h"
+
+#endif
#include "fourcc.h"
+#include "../begin.h"
+
/**
* The iterator magic word.
*/
*/
extern const iterator_t *pset_iterator;
+#include "../end.h"
+
#endif
#include <stdlib.h>
+#include "../begin.h"
+
typedef struct list_head list_head;
struct list_head {
struct list_head *next, *prev;
&pos->member != (head); \
pos = n, n = list_entry(n->member.next, type, member))
+#include "../end.h"
#endif
#ifndef _OBSTACK_H
#define _OBSTACK_H 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-\f
+#include "../begin.h"
+
/* We need the type of a pointer subtraction. If __PTRDIFF_TYPE__ is
defined, as with GNU C, use that; that way we don't pollute the
namespace with <stddef.h>'s symbols. Otherwise, include <stddef.h>
int obstack_vprintf(struct obstack *obst, const char *fmt, va_list ap);
int obstack_printf(struct obstack *obst, const char *fmt, ...);
-#ifdef __cplusplus
-} /* C++ */
-#endif
+#include "../end.h"
#endif /* obstack.h */
#ifndef FIRM_ADT_PDEQ_H
#define FIRM_ADT_PDEQ_H
+#include "../begin.h"
+
/**
* The type of the pointer compare function.
*
*/
#define stack_empty(st) pdeq_empty(wq)
+#include "../end.h"
+
#endif
#include <stddef.h>
#include "obst.h"
+#include "../begin.h"
+
typedef struct _plist_element plist_element_t;
typedef struct _plist plist_t;
#define foreach_plist(list, el) \
for (el = plist_first(list); el; el = plist_element_get_next(el))
-#endif /*_PLIST_H_*/
+#include "../end.h"
+
+#endif
#ifndef FIRM_ADT_PMAP_H
#define FIRM_ADT_PMAP_H
+#include "../begin.h"
+
/** A map which maps addresses to addresses. */
typedef struct pmap pmap;
*/
void pmap_break(pmap *map);
+#include "../end.h"
+
#endif
#ifndef FIRM_ADT_PQUEUE_H
#define FIRM_ADT_PQUEUE_H
+#include "../begin.h"
+
typedef struct _pqueue_t pqueue_t;
/**
*/
int pqueue_empty(const pqueue_t *q);
+#include "../end.h"
+
#endif
#include "hashptr.h"
#include "iterator.h"
+#include "../begin.h"
+
/**
* The default comparison function for pointers.
* @param x A pointer.
# define PSET_TRACE
#endif /* !(DEBUG && HAVE_GNU_MALLOC) */
+#include "../end.h"
+
#endif
#ifndef FIRM_ADT_PSET_NEW_H
#define FIRM_ADT_PSET_NEW_H
+#include "../begin.h"
+
#define HashSet pset_new_t
#define HashSetIterator pset_new_iterator_t
#define ValueType void*
ptr = pset_new_iterator_next(&iter); \
ptr != NULL; ptr = pset_new_iterator_next(&iter))
+#include "../end.h"
+
#endif
#include <stddef.h>
+#include "../begin.h"
+
/**
* The abstract type of a set.
*
# define SET_TRACE
#endif /* !(DEBUG && HAVE_GNU_MALLOC) */
+#include "../end.h"
+
#endif
#include <assert.h>
+#include "../begin.h"
+
/**
* Call this to initialize an array of @p count elements to be used by the
* union find functions.
return repr;
}
+#include "../end.h"
+
#endif
#ifndef FIRM_ADT_XMALLOC_H
#define FIRM_ADT_XMALLOC_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
+/* Includes for alloca() */
+#ifdef _WIN32
+#include <malloc.h>
+#endif
+#ifdef HAVE_ALLOCA_H
+#include <alloca.h>
+#endif
+
+#include "../begin.h"
+
/* xmalloc() & friends. */
void *xmalloc(size_t size);
#define OALLOCFZ(obst, type, member, n) ((type*)memset(OALLOCF((obst), type, member, (n)), 0, offsetof(type, member) + sizeof(*((type*)0)->member) * (n)))
-/* Includes for alloca() */
-#ifdef _WIN32
-#include <malloc.h>
-#endif
-#ifdef HAVE_ALLOCA_H
-#include <alloca.h>
-#endif
-
-#ifdef __cplusplus
-}
-#endif
+#include "../end.h"
#endif
#include "irgraph.h"
#include "firm_types.h"
#include "typerep.h"
+#include "begin.h"
/**
* Returns for a method with pointer parameter
* If the pos'th parameter is NOT of a pointer type, ptr_access_none
* is returned;
*/
-ptr_access_kind get_method_param_access(ir_entity *ent, int pos);
+FIRM_DLL ptr_access_kind get_method_param_access(ir_entity *ent, int pos);
/**
* Analyze how pointer arguments of a given
*
* @param irg The ir graph to analyze.
*/
-void analyze_irg_args(ir_graph *irg);
+FIRM_DLL void analyze_irg_args(ir_graph *irg);
/**
* Returns for a method the 'weight' that every parameter
*
* The values are calculation on demand only.
*/
-unsigned get_method_param_weight(ir_entity *ent, int pos);
+FIRM_DLL unsigned get_method_param_weight(ir_entity *ent, int pos);
/**
* Analyze the parameters of a given ir graph.
*
* @param irg The ir graph to analyze.
*/
-void analyze_irg_args_weight(ir_graph *irg);
+FIRM_DLL void analyze_irg_args_weight(ir_graph *irg);
+
+#include "end.h"
#endif
#include <stdio.h>
#include "irarch.h"
#include "lowering.h"
+#include "begin.h"
typedef enum {
ASM_CONSTRAINT_FLAG_SUPPORTS_REGISTER = 0x0001,
/**
* Register the Firm backend command line options.
*/
-void be_opt_register(void);
+FIRM_DLL void be_opt_register(void);
/**
* Parse one backend argument.
*/
-int be_parse_arg(const char *arg);
+FIRM_DLL int be_parse_arg(const char *arg);
/**
* Return the backend configuration parameter.
* @return libFirm configuration parameters for the selected
* backend
*/
-const backend_params *be_get_backend_param(void);
+FIRM_DLL const backend_params *be_get_backend_param(void);
/**
* Main interface to the frontend.
*/
-void be_main(FILE *output, const char *compilation_unit_name);
+FIRM_DLL void be_main(FILE *output, const char *compilation_unit_name);
/**
* parse assembler constraint strings and returns flags (so the frontend knows
* which operands are inputs/outputs and whether memory is required)
*/
-asm_constraint_flags_t be_parse_asm_constraints(const char *constraints);
+FIRM_DLL asm_constraint_flags_t be_parse_asm_constraints(const char *constraints);
/**
* tests whether a string is a valid clobber in an ASM instruction
*/
-int be_is_valid_clobber(const char *clobber);
+FIRM_DLL int be_is_valid_clobber(const char *clobber);
typedef struct be_main_env_t be_main_env_t;
typedef struct be_options_t be_options_t;
+#include "end.h"
+
#endif
--- /dev/null
+/*
+ * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
+ *
+ * This file is part of libFirm.
+ *
+ * This file may be distributed and/or modified under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * Licensees holding valid libFirm Professional Edition licenses may use
+ * this file in accordance with the libFirm Commercial License.
+ * Agreement provided with the Software.
+ *
+ * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.
+ */
+
+/**
+ * @file
+ * @brief Should be included in all public firm headers at the beginning
+ * @author Matthias Braun
+ * @version $Id$
+ */
+#ifndef FIRM_BEGIN_H
+#define FIRM_BEGIN_H
+
+/**
+ * @def FIRM_DLL
+ * Declaration specifier which marks a function/variable as being publicly
+ * visible outside the firm library/dll
+ */
+#ifdef FIRM_BUILD_DLL
+ #ifdef _WIN32
+ #define FIRM_DLL extern __declspec(dllexport)
+ #else
+ #define FIRM_DLL extern __attribute__((visibility("default")))
+ #endif
+#else
+ #ifdef _WIN32
+ #define FIRM_DLL extern __declspec(dllimport)
+ #else
+ #define FIRM_DLL
+ #endif
+#endif
+
+/* mark declarations as C function */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#endif
#define FIRM_ANA_CALLGRAPH_H
#include "firm_types.h"
+#include "begin.h"
/** Flag to indicate state of callgraph. */
typedef enum {
} irp_callgraph_state;
/** Returns the callgraph state of the program representation. */
-irp_callgraph_state get_irp_callgraph_state(void);
+FIRM_DLL irp_callgraph_state get_irp_callgraph_state(void);
/** Sets the callgraph state of the program representation. */
-void set_irp_callgraph_state(irp_callgraph_state s);
+FIRM_DLL void set_irp_callgraph_state(irp_callgraph_state s);
/** Returns the number of procedures that call the given irg. */
-int get_irg_n_callers(const ir_graph *irg);
+FIRM_DLL int get_irg_n_callers(const ir_graph *irg);
/** Returns the caller at position pos. */
ir_graph *get_irg_caller(const ir_graph *irg, int pos);
/** Returns non-zero if the caller at position pos is "a backedge", i.e. a recursion. */
-int is_irg_caller_backedge(const ir_graph *irg, int pos);
+FIRM_DLL int is_irg_caller_backedge(const ir_graph *irg, int pos);
/** Returns non-zero if the irg has a backedge caller. */
-int has_irg_caller_backedge(const ir_graph *irg);
+FIRM_DLL int has_irg_caller_backedge(const ir_graph *irg);
/** Returns the maximal loop depth of call nodes that call along this edge. */
-int get_irg_caller_loop_depth(const ir_graph *irg, int pos);
+FIRM_DLL int get_irg_caller_loop_depth(const ir_graph *irg, int pos);
/** Returns the number of procedures that are called by the given irg. */
-int get_irg_n_callees(const ir_graph *irg);
+FIRM_DLL int get_irg_n_callees(const ir_graph *irg);
/** Returns the callee at position pos. */
-ir_graph *get_irg_callee(const ir_graph *irg, int pos);
+FIRM_DLL ir_graph *get_irg_callee(const ir_graph *irg, int pos);
/** Returns non-zero if the callee at position pos is "a backedge", i.e. a recursion. */
-int is_irg_callee_backedge(const ir_graph *irg, int pos);
+FIRM_DLL int is_irg_callee_backedge(const ir_graph *irg, int pos);
/** Returns non-zero if the irg has a backedge callee. */
-int has_irg_callee_backedge(const ir_graph *irg);
+FIRM_DLL int has_irg_callee_backedge(const ir_graph *irg);
/** Returns the maximal loop depth of call nodes that call along this edge. */
-int get_irg_callee_loop_depth(const ir_graph *irg, int pos);
+FIRM_DLL int get_irg_callee_loop_depth(const ir_graph *irg, int pos);
/** Returns the maximal loop depth of all paths from an external visible method to
this irg. */
-int get_irg_loop_depth(const ir_graph *irg);
+FIRM_DLL int get_irg_loop_depth(const ir_graph *irg);
/** Returns the maximal recursion depth of all paths from an external visible method to
this irg. */
-int get_irg_recursion_depth(const ir_graph *irg);
+FIRM_DLL int get_irg_recursion_depth(const ir_graph *irg);
/** Returns the method execution frequency of a graph. */
-double get_irg_method_execution_frequency(const ir_graph *irg);
+FIRM_DLL double get_irg_method_execution_frequency(const ir_graph *irg);
/**
* Construct the callgraph. Expects callee information, i.e.,
* irg_callee_info_consistent must be set. This can be computed with
* cgana().
*/
-void compute_callgraph(void);
+FIRM_DLL void compute_callgraph(void);
/** Destruct the callgraph. */
-void free_callgraph(void);
+FIRM_DLL void free_callgraph(void);
/** A function type for functions passed to the callgraph walker. */
* @param post - walker function, executed after the predecessor of a node are visited
* @param env - environment, passed to pre and post
*/
-void callgraph_walk(callgraph_walk_func *pre, callgraph_walk_func *post,
- void *env);
+FIRM_DLL void callgraph_walk(callgraph_walk_func *pre,
+ callgraph_walk_func *post, void *env);
/**
* Compute the backedges that represent recursions and a looptree.
*/
-void find_callgraph_recursions(void);
+FIRM_DLL void find_callgraph_recursions(void);
/** Compute interprocedural performance estimates.
*
*
* Expects the main irg is set, see set_irp_main_irg();
**/
-void compute_performance_estimates(void);
+FIRM_DLL void compute_performance_estimates(void);
/** Computes the interprocedural loop nesting information.
*
*
* Expects the main irg is set, see set_irp_main_irg();
*/
-void analyse_loop_nesting_depth(void);
+FIRM_DLL void analyse_loop_nesting_depth(void);
/** The state of loop nesting depth. */
typedef enum {
} loop_nesting_depth_state;
/** Returns the nesting depth state of the program representation. */
-loop_nesting_depth_state get_irp_loop_nesting_depth_state(void);
+FIRM_DLL loop_nesting_depth_state get_irp_loop_nesting_depth_state(void);
/** Sets the nesting depth state of the program representation. */
-void set_irp_loop_nesting_depth_state(loop_nesting_depth_state s);
+FIRM_DLL void set_irp_loop_nesting_depth_state(loop_nesting_depth_state s);
/** Marks the nesting depth state of the program representation as inconsistent. */
-void set_irp_loop_nesting_depth_state_inconsistent(void);
+FIRM_DLL void set_irp_loop_nesting_depth_state_inconsistent(void);
-#endif /* _CALLGRAPH_H_ */
+#include "end.h"
+
+#endif
#define FIRM_ANA_CDEP_H
#include "firm_types.h"
+#include "begin.h"
/**
* An entry in the control dependence list.
};
/** Compute the control dependence graph for a graph. */
-void compute_cdep(ir_graph *irg);
+FIRM_DLL void compute_cdep(ir_graph *irg);
/** Free the control dependence info. */
-void free_cdep(ir_graph *irg);
+FIRM_DLL void free_cdep(ir_graph *irg);
/**
* Return a list of all control dependences of a block.
*/
-ir_cdep *find_cdep(const ir_node *block);
+FIRM_DLL ir_cdep *find_cdep(const ir_node *block);
/**
* Replace the control dependence info of old by the info of nw.
*/
-void exchange_cdep(ir_node *old, const ir_node *nw);
+FIRM_DLL void exchange_cdep(ir_node *old, const ir_node *nw);
/**
* Check whether dependee is (directly) control dependent on candidate.
* @param dependee the (possible) dependent block
* @param candidate the (possible) block on which dependee is dependent
*/
-int is_cdep_on(const ir_node *dependee, const ir_node *candidate);
+FIRM_DLL int is_cdep_on(const ir_node *dependee, const ir_node *candidate);
/**
* Check whether dependee is (possible iterated) control dependent on candidate.
* @param dependee the (possible) dependent block
* @param candidate the (possible) block on which dependee is dependent
*/
-int is_iterated_cdep_on(ir_node *dependee, ir_node *candidate);
+FIRM_DLL int is_iterated_cdep_on(ir_node *dependee, ir_node *candidate);
/**
* If block is control dependent on exactly one node, return this node, else NULL.
*
* @param block the block to check
*/
-ir_node *get_unique_cdep(const ir_node *block);
+FIRM_DLL ir_node *get_unique_cdep(const ir_node *block);
/**
* Check if the given block is control dependent of more than one node.
*
* @param block the block to check
*/
-int has_multiple_cdep(const ir_node *block);
+FIRM_DLL int has_multiple_cdep(const ir_node *block);
+
+#include "end.h"
#endif
#define FIRM_ANA_CGANA_H
#include "firm_types.h"
+#include "begin.h"
/* Methoden sind "frei", wenn ihr Funktionszeiger (potentiell)
* "explizit" bekannt ist, d.h.:
* - Replace (Sel-method(Alloc)) by SymConst-entity.
* - Replaces Sel-method by SymConst-entity if the method is never overwritten.
*/
-void cgana(int *len, ir_entity ***free_methods);
+FIRM_DLL void cgana(int *len, ir_entity ***free_methods);
/** Free callee information.
*
* in all call nodes to NULL. Else it happens that the field contains
* pointers to other than firm arrays.
*/
-void free_callee_info(ir_graph *irg);
-void free_irp_callee_info(void);
+FIRM_DLL void free_callee_info(ir_graph *irg);
+FIRM_DLL void free_irp_callee_info(void);
/* Optimize the address expressions passed to call nodes.
* Performs only the optimizations done by cgana. */
-void opt_call_addrs(void);
+FIRM_DLL void opt_call_addrs(void);
+
+#include "end.h"
#endif
#define FIRM_COMPOUND_PATHS_H
#include "firm_types.h"
+#include "begin.h"
typedef struct compound_graph_path compound_graph_path, *ir_compound_graph_path_ptr;
* @deprecated
* Creates a new compound graph path of given length.
*/
-compound_graph_path *new_compound_graph_path(ir_type *tp, int length);
+FIRM_DLL compound_graph_path *new_compound_graph_path(ir_type *tp, int length);
/**
* @deprecated
* Returns non-zero if an object is a compound graph path
*/
-int is_compound_graph_path(const void *thing);
+FIRM_DLL int is_compound_graph_path(const void *thing);
/**
* @deprecated
* Frees a graph path object
*/
-void free_compound_graph_path(compound_graph_path *gr);
+FIRM_DLL void free_compound_graph_path(compound_graph_path *gr);
/**
* @deprecated
* Returns the length of a graph path
*/
-int get_compound_graph_path_length(const compound_graph_path *gr);
+FIRM_DLL int get_compound_graph_path_length(const compound_graph_path *gr);
/**
* @deprecated
* @deprecated
* Set the entity node of an compound graph path at position pos.
*/
-void set_compound_graph_path_node(compound_graph_path *gr, int pos, ir_entity *node);
+FIRM_DLL void set_compound_graph_path_node(compound_graph_path *gr, int pos,
+ ir_entity *node);
/**
* @deprecated
* Get the index of an compound graph path at position pos.
*/
-int get_compound_graph_path_array_index(const compound_graph_path *gr, int pos);
+FIRM_DLL int get_compound_graph_path_array_index(const compound_graph_path *gr, int pos);
/**
* @deprecated
* Set the index of an compound graph path at position pos.
*/
-void set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index);
+FIRM_DLL void set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index);
/**
* @deprecated
* Get the type of an compound graph path.
*/
-ir_type *get_compound_graph_path_type(const compound_graph_path *gr);
+FIRM_DLL ir_type *get_compound_graph_path_type(const compound_graph_path *gr);
/**
* @deprecated
* Checks whether the path up to pos is correct. If the path contains a NULL,
* assumes the path is not complete and returns non-zero.
*/
-int is_proper_compound_graph_path(compound_graph_path *gr, int pos);
+FIRM_DLL int is_proper_compound_graph_path(compound_graph_path *gr, int pos);
/**
* @deprecated
* A value of a compound entity is a pair of a value and the description of the
* corresponding access path to the member of the compound.
*/
-void add_compound_ent_value_w_path(ir_entity *ent, ir_node *val, compound_graph_path *path);
-void set_compound_ent_value_w_path(ir_entity *ent, ir_node *val, compound_graph_path *path, int pos);
+FIRM_DLL void add_compound_ent_value_w_path(ir_entity *ent, ir_node *val, compound_graph_path *path);
+FIRM_DLL void set_compound_ent_value_w_path(ir_entity *ent, ir_node *val, compound_graph_path *path, int pos);
/**
* @deprecated
* Returns the access path for value at position pos.
*/
-compound_graph_path *get_compound_ent_value_path(const ir_entity *ent, int pos);
+FIRM_DLL compound_graph_path *get_compound_ent_value_path(const ir_entity *ent, int pos);
/**
* @deprecated
* Returns a constant value given the access path.
* The path must contain array indices for all array element entities.
*/
-ir_node *get_compound_ent_value_by_path(const ir_entity *ent,
- compound_graph_path *path);
+FIRM_DLL ir_node *get_compound_ent_value_by_path(const ir_entity *ent,
+ compound_graph_path *path);
/**
* @deprecated
* free the memory of the paths. (The same path might be used for several
* constant entities.
*/
-void remove_compound_ent_value(ir_entity *ent, ir_entity *value_ent);
+FIRM_DLL void remove_compound_ent_value(ir_entity *ent, ir_entity *value_ent);
/**
* @deprecated
* avoided there. Use add_compound_ent_value_w_path() instead and create
* the path manually.
*/
-void add_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member);
+FIRM_DLL void add_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member);
/**
* @deprecated
* Returns the last member in the path
*/
-ir_entity *get_compound_ent_value_member(const ir_entity *ent, int pos);
+FIRM_DLL ir_entity *get_compound_ent_value_member(const ir_entity *ent, int pos);
/**
* @deprecated
* Sets the path at pos 0
*/
-void set_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member,
- int pos);
+FIRM_DLL void set_compound_ent_value(ir_entity *ent, ir_node *val,
+ ir_entity *member, int pos);
/**
* @deprecated
* fits into the given array size. Does not test whether the
* values have the proper mode for the array.
*/
-void set_array_entity_values(ir_entity *ent, tarval **values, int num_vals);
+FIRM_DLL void set_array_entity_values(ir_entity *ent, tarval **values, int num_vals);
/**
* @deprecated
* @param ent Any entity of compound type with at least pos initialization values.
* @param pos The position of the value for which the offset is requested.
*/
-unsigned get_compound_ent_value_offset_bit_remainder(const ir_entity *ent, int pos);
+FIRM_DLL unsigned get_compound_ent_value_offset_bit_remainder(const ir_entity *ent, int pos);
/**
* @deprecated
* @param ent Any entity of compound type with at least pos initialization values.
* @param pos The position of the value for which the offset is requested.
*/
-unsigned get_compound_ent_value_offset_bytes(const ir_entity *ent, int pos);
+FIRM_DLL unsigned get_compound_ent_value_offset_bytes(const ir_entity *ent, int pos);
/**
* @deprecated
* Returns the number of constant values needed to initialize the entity.
* Asserts if the entity has variability_uninitialized.
*/
-int get_compound_ent_n_values(const ir_entity *ent);
+FIRM_DLL int get_compound_ent_n_values(const ir_entity *ent);
/**
* @deprecated
* Returns a constant value given the position.
*/
-ir_node *get_compound_ent_value(const ir_entity *ent, int pos);
+FIRM_DLL ir_node *get_compound_ent_value(const ir_entity *ent, int pos);
/**
* @deprecated
* return 1 if entity has a compound_graph-style initializer
*/
-int entity_has_compound_ent_values(const ir_entity *entity);
+FIRM_DLL int entity_has_compound_ent_values(const ir_entity *entity);
+
+#include "end.h"
#endif
#include <stdlib.h>
#include "firm_types.h"
#include "ident.h"
+#include "begin.h"
/**
* @defgroup debug The Firm interface to debugging support.
*
* @param a the debug action
*/
-const char *dbg_action_2_str(dbg_action a);
+FIRM_DLL const char *dbg_action_2_str(dbg_action a);
/**
* The type of the debug info merge function.
* Further both functions pass an enumeration indicating the action
* performed by the transformation, e.g. the kind of optimization performed.
*/
-void dbg_init(merge_pair_func *dbg_info_merge_pair,
- merge_sets_func *dbg_info_merge_sets);
+FIRM_DLL void dbg_init(merge_pair_func *dbg_info_merge_pair,
+ merge_sets_func *dbg_info_merge_sets);
/** @} */
*
* @param func the debug retriever function.
*/
-void ir_set_debug_retrieve(retrieve_dbg_func func);
+FIRM_DLL void ir_set_debug_retrieve(retrieve_dbg_func func);
/**
* The type of the type debug info retrieve function.
/**
* Set global print_type_dbg_info function in firm
*/
-void ir_set_type_debug_retrieve(retrieve_type_dbg_func func);
+FIRM_DLL void ir_set_type_debug_retrieve(retrieve_type_dbg_func func);
/**
* Retrieve the debug info.
*/
-const char *ir_retrieve_dbg_info(const dbg_info *dbg, unsigned *line);
+FIRM_DLL const char *ir_retrieve_dbg_info(const dbg_info *dbg, unsigned *line);
/**
* Retrieve type debug info
*/
-void ir_retrieve_type_dbg_info(char *buffer, size_t buffer_size,
- const type_dbg_info *tdbgi);
+FIRM_DLL void ir_retrieve_type_dbg_info(char *buffer, size_t buffer_size,
+ const type_dbg_info *tdbgi);
+
+#include "end.h"
#endif
--- /dev/null
+/*
+ * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
+ *
+ * This file is part of libFirm.
+ *
+ * This file may be distributed and/or modified under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * Licensees holding valid libFirm Professional Edition licenses may use
+ * this file in accordance with the libFirm Commercial License.
+ * Agreement provided with the Software.
+ *
+ * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.
+ */
+
+/**
+ * @file
+ * @brief Should be included in all public firm headers at the end
+ * @author Matthias Braun
+ * @version $Id$
+ */
+#ifndef FIRM_END_H
+#define FIRM_END_H
+
+#ifndef FIRM_BEGIN_H
+#error "end.h included without begin.h?"
+#endif
+
+/* close extern "C" block from begin.h */
+#ifdef __cplusplus
+}
+#endif
+
+#endif
#define FIRM_ANA_EXECFREQ_H
#include "firm_types.h"
+#include "begin.h"
struct ir_exec_freq;
/**
* Create execfreq structure (to be used with set_execfreq)
*/
-ir_exec_freq *create_execfreq(ir_graph *irg);
+FIRM_DLL ir_exec_freq *create_execfreq(ir_graph *irg);
/**
* Set execution frequency of a basic block
*/
-void set_execfreq(ir_exec_freq *ef, const ir_node *block, double freq);
+FIRM_DLL void set_execfreq(ir_exec_freq *ef, const ir_node *block, double freq);
/**
* Create execfreq structure and initialize with estimated frequencies
*/
-ir_exec_freq *compute_execfreq(ir_graph *irg, double loop_weight);
+FIRM_DLL ir_exec_freq *compute_execfreq(ir_graph *irg, double loop_weight);
-void free_execfreq(ir_exec_freq *ef);
+FIRM_DLL void free_execfreq(ir_exec_freq *ef);
-double get_block_execfreq(const ir_exec_freq *ef, const ir_node *block);
-unsigned long get_block_execfreq_ulong(const ir_exec_freq *ef, const ir_node *block);
+FIRM_DLL double get_block_execfreq(const ir_exec_freq *ef,
+ const ir_node *block);
+
+FIRM_DLL unsigned long get_block_execfreq_ulong(const ir_exec_freq *ef,
+ const ir_node *block);
+
+#include "end.h"
#endif
#define FIRM_ANA_EXECUTION_FREQUENCY_H
#include "firm_types.h"
+#include "begin.h"
/* A proj from a Cond that goes to an exception handler. */
-int is_fragile_Proj(ir_node *n);
+FIRM_DLL int is_fragile_Proj(ir_node *n);
/** Returns the number of times the block/region is executed according to
* our estimate. Gives a number relative to the Start node of the procedure
* the block is in, which is weighted with 1. */
-double get_irn_exec_freq (ir_node *n);
-double get_Block_exec_freq (ir_node *b);
-double get_region_exec_freq(void *reg);
+FIRM_DLL double get_irn_exec_freq(ir_node *n);
+FIRM_DLL double get_Block_exec_freq(ir_node *b);
+FIRM_DLL double get_region_exec_freq(void *reg);
/** Compute the execution frequency for all blocks in the given
* graph.
*
* Uses link field.
*/
-void compute_execution_frequency(ir_graph *irg, int default_loop_weight, double exception_probability);
+FIRM_DLL void compute_execution_frequency(ir_graph *irg, int default_loop_weight, double exception_probability);
/** Compute the execution frequency for all graphs.
*
* @param exception_probability The probability that a fragile operation causes an exception.
*
*/
-void compute_execution_frequencies(int default_loop_weight, double exception_probability);
+FIRM_DLL void compute_execution_frequencies(int default_loop_weight, double exception_probability);
/** Free occupied memory, reset for all graphs. */
-void free_execution_frequency(void);
+FIRM_DLL void free_execution_frequency(void);
/** State of execution frequencies for graphs and the whole program.
*
changed since. */
} exec_freq_state;
-exec_freq_state get_irg_exec_freq_state(ir_graph *irg);
-void set_irg_exec_freq_state(ir_graph *irg, exec_freq_state s);
+FIRM_DLL exec_freq_state get_irg_exec_freq_state(ir_graph *irg);
+FIRM_DLL void set_irg_exec_freq_state(ir_graph *irg,
+ exec_freq_state s);
/* Sets irg and irp exec freq state to inconsistent if it is set to consistent. */
-void set_irg_exec_freq_state_inconsistent(ir_graph *irg);
+FIRM_DLL void set_irg_exec_freq_state_inconsistent(ir_graph *irg);
-exec_freq_state get_irp_exec_freq_state(void);
+FIRM_DLL exec_freq_state get_irp_exec_freq_state(void);
/* Sets irp and all irg exec freq states to inconsistent if it is set to consistent. */
-void set_irp_exec_freq_state_inconsistent(void);
+FIRM_DLL void set_irp_exec_freq_state_inconsistent(void);
+#include "end.h"
#endif
#include "firm_types.h"
+#include "begin.h"
+
/* The number of array elements we assume if not both bounds are given. */
#define DEFAULT_N_ARRAY_ELEMENTS 1
-int get_irn_loop_call_depth(ir_node *n);
+FIRM_DLL int get_irn_loop_call_depth(ir_node *n);
/** Return loop depth of node.
*
* Returns the loop depth of n in the control flow. I.e., we
* go from the node to the block to the loop the block is in,
* and return its depth. */
-int get_irn_cfloop_depth(ir_node *n);
-int get_irn_recursion_depth(ir_node *n);
+FIRM_DLL int get_irn_cfloop_depth(ir_node *n);
+FIRM_DLL int get_irn_recursion_depth(ir_node *n);
/** Get the weighted interprocedural loop depth of the node.
The depth is estimated by a heuristic. The heuristic considers
loop and recursion depth. */
-int get_weighted_loop_depth(ir_node *n);
+FIRM_DLL int get_weighted_loop_depth(ir_node *n);
/** Heuristic merging recursion and loop depth. */
-double get_irn_final_cost(ir_node *n);
+FIRM_DLL double get_irn_final_cost(ir_node *n);
/** Get accumulated(really?) execution frequencies.
* A heuristic weights the recursions. */
-double get_type_estimated_n_instances(ir_type *clss);
-double get_type_estimated_mem_consumption_bytes(ir_type *tp);
+FIRM_DLL double get_type_estimated_n_instances(ir_type *clss);
+FIRM_DLL double get_type_estimated_mem_consumption_bytes(ir_type *tp);
+
/** Estimates the size of an object.
*
* The heuristic mainly affects array sizes.
* Further this ignores padding for alignment, especially of small fields. */
-int get_type_estimated_size_bytes(ir_type *tp);
+FIRM_DLL int get_type_estimated_size_bytes(ir_type *tp);
/** Estimates the number of fields of a single Object.
* The heuristic mainly affects array sizes.
* @@@ Misses inherited fields! */
-int get_type_estimated_n_fields(ir_type *tp);
-double get_type_estimated_n_casts(ir_type *clss);
+FIRM_DLL int get_type_estimated_n_fields(ir_type *tp);
+FIRM_DLL double get_type_estimated_n_casts(ir_type *clss);
+
+FIRM_DLL double get_class_estimated_n_upcasts(ir_type *clss);
+FIRM_DLL double get_class_estimated_n_downcasts(ir_type *clss);
-double get_class_estimated_n_upcasts(ir_type *clss);
-double get_class_estimated_n_downcasts(ir_type *clss);
/** Returns the number of accesses to the dispatch table.
*
* This includes the initialization of the pointer field, and accesses
* to virtual fields (as instance marker in Java). Certainly this
* includes virtual method calls. */
-double get_class_estimated_n_dyncalls(ir_type *clss);
+FIRM_DLL double get_class_estimated_n_dyncalls(ir_type *clss);
/** Returns the number of writes to the dispatch pointer.
* This is the same as the number of allocations. */
-double get_class_estimated_dispatch_writes(ir_type *clss);
+FIRM_DLL double get_class_estimated_dispatch_writes(ir_type *clss);
/** Returns the number of reads of the dispatch pointer. */
-double get_class_estimated_dispatch_reads (ir_type *clss);
+FIRM_DLL double get_class_estimated_dispatch_reads (ir_type *clss);
-double get_entity_estimated_n_loads(ir_entity *ent);
-double get_entity_estimated_n_stores(ir_entity *ent);
-double get_entity_estimated_n_calls(ir_entity *ent);
+FIRM_DLL double get_entity_estimated_n_loads(ir_entity *ent);
+FIRM_DLL double get_entity_estimated_n_stores(ir_entity *ent);
+FIRM_DLL double get_entity_estimated_n_calls(ir_entity *ent);
/** The number of accesses to dynamically called methods and
* to other static fields that overwrite/are overwritten. */
-double get_entity_estimated_n_dyncalls(ir_entity *ent);
+FIRM_DLL double get_entity_estimated_n_dyncalls(ir_entity *ent);
/* ------------------------------------------------------------------------- */
/* Accumulate information in the type hierarchy. */
temperature_inconsistent
} irp_temperature_state;
+#include "end.h"
+
#endif
#ifndef FIRM_COMMON_FIRM_H
#define FIRM_COMMON_FIRM_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
#include "analyze_irg_args.h"
#include "be.h"
#include "callgraph.h"
#include "tv.h"
#include "typerep.h"
-#ifdef __cplusplus
-}
-#endif
-
#endif
#define FIRM_COMMON_FIRM_COMMON_H
#include "firm_types.h"
+#include "begin.h"
/**
* libFirm initialization parameters.
* The parameter struct may be NULL. In that case, the original FIRM behavior
* is conserved.
*/
-void ir_init(const firm_parameter_t *params);
+FIRM_DLL void ir_init(const firm_parameter_t *params);
/**
* Frees all memory occupied by the firm library.
*/
-void ir_finish(void);
+FIRM_DLL void ir_finish(void);
/** returns the libFirm major version number */
-unsigned ir_get_version_major(void);
+FIRM_DLL unsigned ir_get_version_major(void);
/** returns libFirm minor version number */
-unsigned ir_get_version_minor(void);
+FIRM_DLL unsigned ir_get_version_minor(void);
/** returns string describing libFirm revision */
-const char *ir_get_version_revision(void);
+FIRM_DLL const char *ir_get_version_revision(void);
/** returns string describing libFirm build */
-const char *ir_get_version_build(void);
+FIRM_DLL const char *ir_get_version_build(void);
*
* @param firm_thing pointer representing a firm object
*/
-firm_kind get_kind(const void *firm_thing);
+FIRM_DLL firm_kind get_kind(const void *firm_thing);
/** Returns the kind of a thing as a string. */
-const char *print_firm_kind(void *firm_thing);
+FIRM_DLL const char *print_firm_kind(void *firm_thing);
/** Print an identification of a firm thing. */
-void firm_identify_thing(void *X);
+FIRM_DLL void firm_identify_thing(void *X);
+
+#include "end.h"
#endif
#ifndef FIRM_COMMON_FIRM_TYPES_H
#define FIRM_COMMON_FIRM_TYPES_H
+#include "begin.h"
+
typedef unsigned long ir_visited_t;
typedef unsigned long ir_exc_region_t;
typedef unsigned long ir_label_t;
ir_bk_inner_trampoline, /**< address of a trampoline for GCC inner functions */
} ir_builtin_kind;
+#include "end.h"
+
#endif
#define FIRM_STAT_FIRMSTAT_H
#include "irhooks.h"
+#include "begin.h"
/**
* Statistic options, can be or'ed.
* @param fname base name of the statistic output file
* @param phase a phase name. Prefix will be firmstat-\<phase\>-
*/
-void stat_dump_snapshot(const char *fname, const char *phase);
+FIRM_DLL void stat_dump_snapshot(const char *fname, const char *phase);
/**
* Creates an ir_prog pass for stat_dump_snapshot().
*
* @return the newly created ir_prog pass
*/
-ir_prog_pass_t *stat_dump_snapshot_pass(
+FIRM_DLL ir_prog_pass_t *stat_dump_snapshot_pass(
const char *name, const char *fname, const char *phase);
/**
*
* @param enable_options a bitmask containing the statistic options
*/
-void firm_init_stat(unsigned enable_options);
+FIRM_DLL void firm_init_stat(unsigned enable_options);
/**
* terminates the statistics module, frees all memory
*/
-void stat_term(void);
+FIRM_DLL void stat_term(void);
/**
* returns 1 if statistic module is active, 0 otherwise
*/
-int stat_is_active(void);
+FIRM_DLL int stat_is_active(void);
-#endif /* FIRM_STAT_FIRMSTAT_H */
+#include "end.h"
+
+#endif
#define FIRM_ANA_HEIGHTS_H
#include "firm_types.h"
+#include "begin.h"
typedef struct _heights_t heights_t;
* @param irn The node.
* @return The height of the node.
*/
-unsigned get_irn_height(heights_t *h, const ir_node *irn);
+FIRM_DLL unsigned get_irn_height(heights_t *h, const ir_node *irn);
/**
* Check, if a certain node is reachable according to data dependence edges from another node.
* @param m The other node.
* @return 1, if n is data dependent on m, 0 if not.
*/
-int heights_reachable_in_block(heights_t *h, const ir_node *n, const ir_node *m);
+FIRM_DLL int heights_reachable_in_block(heights_t *h, const ir_node *n,
+ const ir_node *m);
/**
* Recompute the height information.
* This can be used to recompute the height information if the graph has changed since the last computation.
* @param h The heights object.
*/
-void heights_recompute(heights_t *h);
+FIRM_DLL void heights_recompute(heights_t *h);
/**
* Recompute the height information for a certain block.
* @param block The block
* @return The maximum over all heights in the block.
*/
-unsigned heights_recompute_block(heights_t *h, ir_node *block);
+FIRM_DLL unsigned heights_recompute_block(heights_t *h, ir_node *block);
/**
* Make a new heights object.
* This also computes the heights for each block in the graph.
* @param irg The graph.
*/
-heights_t *heights_new(ir_graph *irg);
+FIRM_DLL heights_t *heights_new(ir_graph *irg);
/**
* Free a heights object.
* @param h The heights object.
*/
-void heights_free(heights_t *h);
+FIRM_DLL void heights_free(heights_t *h);
+#include "end.h"
-#endif /* FIRM_ANA_HEIGHTS_H */
+#endif
#define FIRM_IDENT_IDENT_H
#include "firm_types.h"
+#include "begin.h"
/* Identifiers */
*
* @see get_id_str(), get_id_strlen()
*/
-ident *new_id_from_str(const char *str);
+FIRM_DLL ident *new_id_from_str(const char *str);
/** Store a string and create an ident.
*
*
* @see new_id_from_str(), get_id_strlen()
*/
-ident *new_id_from_chars(const char *str, int len);
+FIRM_DLL ident *new_id_from_chars(const char *str, int len);
/**
* Returns a string represented by an ident.
*
* @see new_id_from_str(), new_id_from_chars(), get_id_strlen()
*/
-const char *get_id_str(ident *id);
+FIRM_DLL const char *get_id_str(ident *id);
/**
* Returns the length of the string represented by an ident.
*
* @see new_id_from_str(), new_id_from_chars(), get_id_str()
*/
-int get_id_strlen(ident *id);
+FIRM_DLL int get_id_strlen(ident *id);
/**
* Returns true if prefix is a prefix of an ident.
*
* @see new_id_from_str(), new_id_from_chars(), get_id_str(), id_is_prefix()
*/
-int id_is_prefix(ident *prefix, ident *id);
+FIRM_DLL int id_is_prefix(ident *prefix, ident *id);
/**
* Returns true if suffix is a suffix of an ident.
*
* @see new_id_from_str(), new_id_from_chars(), get_id_str(), id_is_prefix()
*/
-int id_is_suffix(ident *suffix, ident *id);
+FIRM_DLL int id_is_suffix(ident *suffix, ident *id);
/**
* Return true if an ident contains a given character.
*
* @see new_id_from_str(), new_id_from_chars(), get_id_str()
*/
-int id_contains_char(ident *id, char c);
+FIRM_DLL int id_contains_char(ident *id, char c);
/**
* helper function for creating unique idents. It contains an internal counter
* and replaces a "%u" inside the tag with the counter.
*/
-ident *id_unique(const char *tag);
+FIRM_DLL ident *id_unique(const char *tag);
/** initializes the name mangling code */
-void firm_init_mangle(void);
+FIRM_DLL void firm_init_mangle (void);
/** Computes a definite name for this entity by concatenating
the name of the owner type and the name of the entity with
a separating "_". */
-ident *id_mangle_entity(ir_entity *ent);
+FIRM_DLL ident *id_mangle_entity(ir_entity *ent);
/** mangle underscore: Returns a new ident that represents first_scnd. */
-ident *id_mangle_u(ident *first, ident* scnd);
+FIRM_DLL ident *id_mangle_u(ident *first, ident* scnd);
/** mangle dot: Returns a new ident that represents first.scnd. */
-ident *id_mangle_dot(ident *first, ident* scnd);
+FIRM_DLL ident *id_mangle_dot(ident *first, ident* scnd);
/** mangle: Returns a new ident that represents firstscnd. */
-ident *id_mangle(ident *first, ident* scnd);
+FIRM_DLL ident *id_mangle(ident *first, ident* scnd);
/** Returns a new ident that represents 'prefixscndsuffix'. */
-ident *id_mangle3(const char *prefix, ident *middle, const char *suffix);
+FIRM_DLL ident *id_mangle3(const char *prefix, ident *middle,
+ const char *suffix);
/** returns a mangled name for a Win32 function using its calling convention */
-ident *id_decorate_win32_c_fkt(ir_entity *ent, ident *id);
+FIRM_DLL ident *id_decorate_win32_c_fkt(ir_entity *ent, ident *id);
+
+#include "end.h"
#endif
#define FIRM_ANA_INTERVAL_ANALYSIS_H
#include "firm_types.h"
+#include "begin.h"
/** The ins of regions: regions are loops or blocks.
*
* @todo: we should make a type for the regions, or reuse loop_element.
*/
-int get_region_n_ins(void *region);
-void *get_region_in (void *region, int pos);
-void add_region_in (void *region, void *in);
+FIRM_DLL int get_region_n_ins(void *region);
+FIRM_DLL void *get_region_in(void *region, int pos);
+FIRM_DLL void add_region_in(void *region, void *in);
/** The number of out edges of a region.
*
* This number is useful for evaluation of execution frequencies.
*/
-int get_region_n_outs(void *region);
+FIRM_DLL int get_region_n_outs(void *region);
/** The number of exception out edges of a region.
*
* This number is useful for evaluation of execution frequencies.
*/
-int get_region_n_exc_outs(void *region);
+FIRM_DLL int get_region_n_exc_outs(void *region);
/** The control flow operation corresponding to the loop-region in at
* position pos.
*/
-void *get_loop_cfop(void *region, int pos);
+FIRM_DLL void *get_loop_cfop(void *region, int pos);
/** The algorithm to construct the interval graph.
* @todo: @@@ add flag that states correctness of interval analysis information
* to irg.
**/
-void construct_intervals(ir_graph *irg);
-
+FIRM_DLL void construct_intervals(ir_graph *irg);
/** frees interval information of all graphs. */
-void free_intervals(void);
-
+FIRM_DLL void free_intervals(void);
/** dump a graph with the intervals. File name suffix "-interval". */
-void dump_interval_graph(ir_graph *irg, const char *suffix);
+FIRM_DLL void dump_interval_graph(ir_graph *irg, const char *suffix);
+
+#include "end.h"
#endif
#define FIRM_IR_IRARCH_H
#include "firm_types.h"
+#include "begin.h"
/**
* The Multiplication replacement can consist of the following instructions.
/**
* A default parameter factory for testing purposes.
*/
-const ir_settings_arch_dep_t *arch_dep_default_factory(void);
+FIRM_DLL const ir_settings_arch_dep_t *arch_dep_default_factory(void);
/**
* Optimization flags.
* is not called, the machine dependent optimizations
* are not enabled at all.
*/
-void arch_dep_init(arch_dep_params_factory_t factory);
+FIRM_DLL void arch_dep_init(arch_dep_params_factory_t factory);
/**
* Set the optimizations that shall be applied.
* @param opts An optimization bit mask.
*/
-void arch_dep_set_opts(arch_dep_opts_t opts);
+FIRM_DLL void arch_dep_set_opts(arch_dep_opts_t opts);
/**
* Replace Muls with Lea/Shifts/Add/Subs if these
* @param irn The Firm node to inspect.
* @return A replacement expression for irn.
*/
-ir_node *arch_dep_replace_mul_with_shifts(ir_node *irn);
+FIRM_DLL ir_node *arch_dep_replace_mul_with_shifts(ir_node *irn);
/**
* Replace Divs with Shifts and Add/Subs and Mulh.
* @param irn The Firm node to inspect.
* @return A replacement expression for irn.
*/
-ir_node *arch_dep_replace_div_by_const(ir_node *irn);
+FIRM_DLL ir_node *arch_dep_replace_div_by_const(ir_node *irn);
/**
* Replace Mods with Shifts and Add/Subs and Mulh.
* @param irn The Firm node to inspect.
* @return A replacement expression for irn.
*/
-ir_node *arch_dep_replace_mod_by_const(ir_node *irn);
+FIRM_DLL ir_node *arch_dep_replace_mod_by_const(ir_node *irn);
/**
* Replace DivMods with Shifts and Add/Subs and Mulh.
* @param mod After call contains the Firm node mod result or NULL.
* @param irn The Firm node to inspect.
*/
-void arch_dep_replace_divmod_by_const(ir_node **div, ir_node **mod, ir_node *irn);
+FIRM_DLL void arch_dep_replace_divmod_by_const(ir_node **div, ir_node **mod,
+ ir_node *irn);
+
+#include "end.h"
#endif
#ifdef INTERPROCEDURAL_VIEW
#include "firm_types.h"
+#include "begin.h"
/** Return the current state of the interprocedural view. */
-ip_view_state get_irp_ip_view_state(void);
+FIRM_DLL ip_view_state get_irp_ip_view_state(void);
/** Set the state of the interprocedural view to invalid. */
-void set_irp_ip_view_invalid(void);
+FIRM_DLL void set_irp_ip_view_invalid(void);
/** Construction of the interprocedural view.
*
* are external visible. These methods get an 'Unknown'
* caller.
* @arg arr_len The number of free methods. */
-void cg_construct(int arr_len, ir_entity *free_methods_arr[]);
+FIRM_DLL void cg_construct(int arr_len, ir_entity *free_methods_arr[]);
/** Deconstruction of the interprocedural view. Reduces memory consumption of
the ir. Sets ip_view_no in irp. */
-void cg_destruct(void);
+FIRM_DLL void cg_destruct(void);
+
+#include "end.h"
#endif
#define FIRM_IR_ICGOPT_H
#include "firm_types.h"
+#include "begin.h"
/* Entfernt alle Methoden, die von den Methoden aus "keep_arr"
* (bezgl. der Abschaetzung get_Call_callee) nicht erreichbar sind. Die
* ueberschrieben.
*
* Frees all interprocedural loop information. */
-void gc_irgs(int n_keep, ir_entity *keep_arr[]);
+FIRM_DLL void gc_irgs(int n_keep, ir_entity *keep_arr[]);
/**
* Creates an ir_prog pass for gc_irgs().
*
* @return the newly created ir_graph pass
*/
-ir_prog_pass_t *gc_irgs_pass(const char *name);
+FIRM_DLL ir_prog_pass_t *gc_irgs_pass(const char *name);
+
+#include "end.h"
#endif
#define FIRM_IR_IRCONS_H
#include "firm_types.h"
+#include "begin.h"
/**
* constrained flags for memory operations.
* @param in[] An array of control predecessors. The length of
* the array must be 'arity'. The constructor copies this array.
*/
-ir_node *new_rd_Block(dbg_info *db, ir_graph *irg, int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_rd_Block(dbg_info *db, ir_graph *irg, int arity, ir_node *in[]);
/** Constructor for a Start node.
*
* @param *irg The IR graph the node belongs to.
* @param *block The IR block the node belongs to.
*/
-ir_node *new_rd_Start(dbg_info *db, ir_graph *irg, ir_node *block);
+FIRM_DLL ir_node *new_rd_Start(dbg_info *db, ir_graph *irg, ir_node *block);
/** Constructor for a End node.
*
* @param *irg The IR graph the node belongs to.
* @param *block The IR block the node belongs to.
*/
-ir_node *new_rd_End(dbg_info *db, ir_graph *irg, ir_node *block);
+FIRM_DLL ir_node *new_rd_End(dbg_info *db, ir_graph *irg, ir_node *block);
/** Constructor for a Jmp node.
*
* @param *db A pointer for debug information.
* @param *block The IR block the node belongs to.
*/
-ir_node *new_rd_Jmp(dbg_info *db, ir_node *block);
+FIRM_DLL ir_node *new_rd_Jmp(dbg_info *db, ir_node *block);
/** Constructor for an IJmp node.
*
* @param *block The IR block the node belongs to.
* @param *tgt The IR node representing the target address.
*/
-ir_node *new_rd_IJmp(dbg_info *db, ir_node *block, ir_node *tgt);
+FIRM_DLL ir_node *new_rd_IJmp(dbg_info *db, ir_node *block, ir_node *tgt);
/** Constructor for a Break node.
*
* @param *db A pointer for debug information.
* @param *block The block the node belong to.
*/
-ir_node *new_rd_Break(dbg_info *db, ir_node *block);
+FIRM_DLL ir_node *new_rd_Break(dbg_info *db, ir_node *block);
/** Constructor for a Cond node.
*
* @param *block The IR block the node belongs to.
* @param *c The conditions parameter. Can be of mode b or I_u.
*/
-ir_node *new_rd_Cond(dbg_info *db, ir_node *block, ir_node *c);
+FIRM_DLL ir_node *new_rd_Cond(dbg_info *db, ir_node *block, ir_node *c);
/** Constructor for a Return node.
*
* @param arity Number of return values.
* @param *in Array of length arity with return values. The constructor copies this array.
*/
-ir_node *new_rd_Return(dbg_info *db, ir_node *block,
- ir_node *store, int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_rd_Return(dbg_info *db, ir_node *block,
+ ir_node *store, int arity, ir_node *in[]);
/** Constructor for a Const_type node.
*
* @param *con Points to an entry in the constant table.
* @param *tp The type of the constant.
*/
-ir_node *new_rd_Const_type(dbg_info *db, ir_graph *irg,
- tarval *con, ir_type *tp);
+FIRM_DLL ir_node *new_rd_Const_type(dbg_info *db, ir_graph *irg,
+ tarval *con, ir_type *tp);
/** Constructor for a Const node.
*
* @param *irg The IR graph the node belongs to.
* @param *con Points to an entry in the constant table.
*/
-ir_node *new_rd_Const(dbg_info *db, ir_graph *irg, tarval *con);
+FIRM_DLL ir_node *new_rd_Const(dbg_info *db, ir_graph *irg, tarval *con);
/**
* Constructor for a Const node.
* @param *mode The mode of the operands and results.
* @param value A value from which the tarval is made.
*/
-ir_node *new_rd_Const_long(dbg_info *db, ir_graph *irg,
- ir_mode *mode, long value);
+FIRM_DLL ir_node *new_rd_Const_long(dbg_info *db, ir_graph *irg,
+ ir_mode *mode, long value);
/** Constructor for a SymConst_type node.
*
* @param *db A pointer for debug information.
* @param *irg The IR graph the node belongs to.
* @param mode The mode for the SymConst.
- * @param value A type, ident, entity or enum constant depending on the
+ * @param val A type, ident, entity or enum constant depending on the
* SymConst kind.
* @param kind The kind of the symbolic constant, see the list above
* @param tp The source type of the constant.
*/
-ir_node *new_rd_SymConst_type(dbg_info *db, ir_graph *irg, ir_mode *mode,
- union symconst_symbol value, symconst_kind kind,
- ir_type *tp);
+FIRM_DLL ir_node *new_rd_SymConst_type(dbg_info *db, ir_graph *irg,
+ ir_mode *mode, union symconst_symbol val,
+ symconst_kind kind, ir_type *tp);
/** Constructor for a SymConst node.
*
* Same as new_rd_SymConst_type, except that it sets the type to type_unknown.
*/
-ir_node *new_rd_SymConst(dbg_info *db, ir_graph *irg, ir_mode *mode,
- union symconst_symbol value, symconst_kind kind);
+FIRM_DLL ir_node *new_rd_SymConst(dbg_info *db, ir_graph *irg, ir_mode *mode,
+ union symconst_symbol value,
+ symconst_kind kind);
/** Constructor for a SymConst addr_ent node.
*
* Same as new_rd_SymConst_type, except that the constructor is tailored for
* symconst_addr_ent.
* Adds the SymConst to the start block of irg. */
-ir_node *new_rd_SymConst_addr_ent(dbg_info *db, ir_graph *irg, ir_mode *mode,
- ir_entity *symbol, ir_type *tp);
+FIRM_DLL ir_node *new_rd_SymConst_addr_ent(dbg_info *db, ir_graph *irg,
+ ir_mode *mode, ir_entity *symbol,
+ ir_type *tp);
/** Constructor for a SymConst ofs_ent node.
*
* symconst_ofs_ent.
* Adds the SymConst to the start block of irg.
*/
-ir_node *new_rd_SymConst_ofs_ent(dbg_info *db, ir_graph *irg, ir_mode *mode,
- ir_entity *symbol, ir_type *tp);
+FIRM_DLL ir_node *new_rd_SymConst_ofs_ent(dbg_info *db, ir_graph *irg,
+ ir_mode *mode, ir_entity *symbol,
+ ir_type *tp);
/** Constructor for a SymConst type_tag node.
*
* symconst_type_tag.
* Adds the SymConst to the start block of irg.
*/
-ir_node *new_rd_SymConst_type_tag(dbg_info *db, ir_graph *irg, ir_mode *mode,
- ir_type *symbol, ir_type *tp);
+FIRM_DLL ir_node *new_rd_SymConst_type_tag(dbg_info *db, ir_graph *irg,
+ ir_mode *mode, ir_type *symbol,
+ ir_type *tp);
/** Constructor for a SymConst size node.
*
* Same as new_rd_SymConst_type, except that the constructor is tailored for
* symconst_type_size.
* Adds the SymConst to the start block of irg. */
-ir_node *new_rd_SymConst_size(dbg_info *db, ir_graph *irg, ir_mode *mode,
- ir_type *symbol, ir_type *tp);
+FIRM_DLL ir_node *new_rd_SymConst_size(dbg_info *db, ir_graph *irg,
+ ir_mode *mode, ir_type *symbol,
+ ir_type *tp);
/** Constructor for a SymConst size node.
*
* symconst_type_align.
* Adds the SymConst to the start block of irg.
*/
-ir_node *new_rd_SymConst_align(dbg_info *db, ir_graph *irg, ir_mode *mode,
- ir_type *symbol, ir_type *tp);
+FIRM_DLL ir_node *new_rd_SymConst_align(dbg_info *db, ir_graph *irg,
+ ir_mode *mode, ir_type *symbol,
+ ir_type *tp);
/** Constructor for a simpleSel node.
*
* single attribute out.
* @param *ent The entity to select.
*/
-ir_node *new_rd_simpleSel(dbg_info *db, ir_node *block,
- ir_node *store, ir_node *objptr, ir_entity *ent);
+FIRM_DLL ir_node *new_rd_simpleSel(dbg_info *db, ir_node *block, ir_node *store,
+ ir_node *objptr, ir_entity *ent);
/** Constructor for a Sel node.
*
* element entity. The constructor copies this array.
* @param *ent The entity to select.
*/
-ir_node *new_rd_Sel(dbg_info *db, ir_node *block, ir_node *store,
- ir_node *objptr, int n_index, ir_node *index[], ir_entity *ent);
+FIRM_DLL ir_node *new_rd_Sel(dbg_info *db, ir_node *block, ir_node *store,
+ ir_node *objptr, int n_index, ir_node *index[],
+ ir_entity *ent);
/** Constructor for a Call node.
*
* @param *in[] An array with the procedure parameters. The constructor copies this array.
* @param *tp Type information of the procedure called.
*/
-ir_node *new_rd_Call(dbg_info *db, ir_node *block, ir_node *store,
- ir_node *callee, int arity, ir_node *in[], ir_type *tp);
+FIRM_DLL ir_node *new_rd_Call(dbg_info *db, ir_node *block, ir_node *store,
+ ir_node *callee, int arity, ir_node *in[],
+ ir_type *tp);
/** Constructor for a Builtin node.
*
* @param kind The kind of the called builtin.
* @param *tp Type information of the procedure called.
*/
-ir_node *new_rd_Builtin(dbg_info *db, ir_node *block, ir_node *store,
- int arity, ir_node *in[], ir_builtin_kind kind, ir_type *tp);
+FIRM_DLL ir_node *new_rd_Builtin(dbg_info *db, ir_node *block, ir_node *store,
+ int arity, ir_node *in[], ir_builtin_kind kind,
+ ir_type *tp);
/** Constructor for a Add node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_rd_Add(dbg_info *db, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Add(dbg_info *db, ir_node *block, ir_node *op1,
+ ir_node *op2, ir_mode *mode);
/** Constructor for a Sub node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_rd_Sub(dbg_info *db, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Sub(dbg_info *db, ir_node *block,
+ ir_node *op1, ir_node *op2, ir_mode *mode);
/** Constructor for a Minus node.
*
* @param *op The operand .
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_rd_Minus(dbg_info *db, ir_node *block,
- ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Minus(dbg_info *db, ir_node *block,
+ ir_node *op, ir_mode *mode);
/** Constructor for a Mul node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_rd_Mul(dbg_info *db, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Mul(dbg_info *db, ir_node *block,
+ ir_node *op1, ir_node *op2, ir_mode *mode);
/** Constructor for a Mulh node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_rd_Mulh(dbg_info *db, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Mulh(dbg_info *db, ir_node *block,
+ ir_node *op1, ir_node *op2, ir_mode *mode);
/** Constructor for a Quot node.
*
* @param *mode The mode of the result.
* @param state The pinned state.
*/
-ir_node *new_rd_Quot(dbg_info *db, ir_node *block, ir_node *memop,
- ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_rd_Quot(dbg_info *db, ir_node *block, ir_node *memop,
+ ir_node *op1, ir_node *op2, ir_mode *mode,
+ op_pin_state state);
/** Constructor for a DivMod node.
*
* @param *mode The mode of the results.
* @param state The pinned state.
*/
-ir_node *new_rd_DivMod(dbg_info *db, ir_node *block, ir_node *memop,
- ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_rd_DivMod(dbg_info *db, ir_node *block, ir_node *memop,
+ ir_node *op1, ir_node *op2, ir_mode *mode,
+ op_pin_state state);
/** Constructor for a Div node.
*
* @param *mode The mode of the result.
* @param state The pinned state.
*/
-ir_node *new_rd_Div(dbg_info *db, ir_node *block, ir_node *memop,
- ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_rd_Div(dbg_info *db, ir_node *block, ir_node *memop,
+ ir_node *op1, ir_node *op2, ir_mode *mode,
+ op_pin_state state);
/** Constructor for a remainderless Div node.
*
* @param *mode The mode of the result.
* @param state The pinned state.
*/
-ir_node *new_rd_DivRL(dbg_info *db, ir_node *block, ir_node *memop,
- ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_rd_DivRL(dbg_info *db, ir_node *block, ir_node *memop,
+ ir_node *op1, ir_node *op2, ir_mode *mode,
+ op_pin_state state);
/** Constructor for a Mod node.
*
* @param *mode The mode of the result.
* @param state The pinned state.
*/
-ir_node *new_rd_Mod(dbg_info *db, ir_node *block, ir_node *memop,
- ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_rd_Mod(dbg_info *db, ir_node *block, ir_node *memop,
+ ir_node *op1, ir_node *op2, ir_mode *mode,
+ op_pin_state state);
/** Constructor for a Abs node.
*
* @param *op The operand
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_rd_Abs(dbg_info *db, ir_node *block, ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Abs(dbg_info *db, ir_node *block, ir_node *op,
+ ir_mode *mode);
/** Constructor for a And node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_rd_And(dbg_info *db, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_And(dbg_info *db, ir_node *block,
+ ir_node *op1, ir_node *op2, ir_mode *mode);
/** Constructor for a Or node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_rd_Or(dbg_info *db, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Or(dbg_info *db, ir_node *block,
+ ir_node *op1, ir_node *op2, ir_mode *mode);
/** Constructor for a Eor node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the results.
*/
-ir_node *new_rd_Eor(dbg_info *db, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Eor(dbg_info *db, ir_node *block,
+ ir_node *op1, ir_node *op2, ir_mode *mode);
/** Constructor for a Not node.
*
* @param *op The operand.
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_rd_Not(dbg_info *db, ir_node *block, ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Not(dbg_info *db, ir_node *block, ir_node *op,
+ ir_mode *mode);
/** Constructor for a Cmp node.
*
* @param *op1 The first operand.
* @param *op2 The second operand.
*/
-ir_node *new_rd_Cmp(dbg_info *db, ir_node *block, ir_node *op1, ir_node *op2);
+FIRM_DLL ir_node *new_rd_Cmp(dbg_info *db, ir_node *block,
+ ir_node *op1, ir_node *op2);
/** Constructor for a Shl node.
*
* @param *k The number of bits to shift the operand .
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_rd_Shl(dbg_info *db, ir_node *block,
- ir_node *op, ir_node *k, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Shl(dbg_info *db, ir_node *block,
+ ir_node *op, ir_node *k, ir_mode *mode);
/** Constructor for a Shr node.
*
* @param *k The number of bits to shift the operand .
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_rd_Shr(dbg_info *db, ir_node *block,
- ir_node *op, ir_node *k, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Shr(dbg_info *db, ir_node *block,
+ ir_node *op, ir_node *k, ir_mode *mode);
/** Constructor for a Shrs node.
*
* @param *k The number of bits to shift the operand.
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_rd_Shrs(dbg_info *db, ir_node *block,
- ir_node *op, ir_node *k, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Shrs(dbg_info *db, ir_node *block,
+ ir_node *op, ir_node *k, ir_mode *mode);
/** Constructor for a Rotl node.
*
* @param *k The number of bits to rotate the operand.
* @param *mode The mode of the operand.
*/
-ir_node *new_rd_Rotl(dbg_info *db, ir_node *block,
- ir_node *op, ir_node *k, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Rotl(dbg_info *db, ir_node *block,
+ ir_node *op, ir_node *k, ir_mode *mode);
/** Constructor for a Conv node.
* @param *op The operand.
* @param *mode The mode of this the operand muss be converted .
*/
-ir_node *new_rd_Conv(dbg_info *db, ir_node *block, ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Conv(dbg_info *db, ir_node *block, ir_node *op,
+ ir_mode *mode);
/** Constructor for a strictConv node.
*
* @param *op The operand.
* @param *mode The mode of this the operand muss be converted .
*/
-ir_node *new_rd_strictConv(dbg_info *db, ir_node *block,
- ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_strictConv(dbg_info *db, ir_node *block,
+ ir_node *op, ir_mode *mode);
/** Constructor for a Cast node.
*
* @param *op The operand.
* @param *to_tp The type of this the operand muss be casted .
*/
-ir_node *new_rd_Cast(dbg_info *db, ir_node *block,
- ir_node *op, ir_type *to_tp);
+FIRM_DLL ir_node *new_rd_Cast(dbg_info *db, ir_node *block,
+ ir_node *op, ir_type *to_tp);
/** Constructor for a Carry node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_rd_Carry(dbg_info *db, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Carry(dbg_info *db, ir_node *block,
+ ir_node *op1, ir_node *op2, ir_mode *mode);
/** Constructor for a Borrow node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_rd_Borrow(dbg_info *db, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Borrow(dbg_info *db, ir_node *block,
+ ir_node *op1, ir_node *op2, ir_mode *mode);
/** Constructor for a Phi node.
*
* @param *in[] Array with predecessors. The constructor copies this array.
* @param *mode The mode of it's inputs and output.
*/
-ir_node *new_rd_Phi(dbg_info *db, ir_node *block, int arity,
- ir_node *in[], ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Phi(dbg_info *db, ir_node *block, int arity,
+ ir_node *in[], ir_mode *mode);
/** Constructor for a Load node.
*
* @param *mode The mode of the value to be loaded.
* @param flags Additional flags for alignment, volatility and pin state.
*/
-ir_node *new_rd_Load(dbg_info *db, ir_node *block, ir_node *store,
- ir_node *adr, ir_mode *mode, ir_cons_flags flags);
+FIRM_DLL ir_node *new_rd_Load(dbg_info *db, ir_node *block, ir_node *store,
+ ir_node *adr, ir_mode *mode, ir_cons_flags flags);
/** Constructor for a Store node.
*
* @param *val The value to write to this variable.
* @param flags Additional flags for alignment, volatility and pin state.
*/
-ir_node *new_rd_Store(dbg_info *db, ir_node *block, ir_node *store,
- ir_node *adr, ir_node *val, ir_cons_flags flags);
+FIRM_DLL ir_node *new_rd_Store(dbg_info *db, ir_node *block, ir_node *store,
+ ir_node *adr, ir_node *val, ir_cons_flags flags);
/** Constructor for a Alloc node.
*
* @param *alloc_type The type of the allocated variable.
* @param where Where to allocate the variable, either heap_alloc or stack_alloc.
*/
-ir_node *new_rd_Alloc(dbg_info *db, ir_node *block, ir_node *store,
- ir_node *count, ir_type *alloc_type, ir_where_alloc where);
+FIRM_DLL ir_node *new_rd_Alloc(dbg_info *db, ir_node *block, ir_node *store,
+ ir_node *count, ir_type *alloc_type,
+ ir_where_alloc where);
/** Constructor for a Free node.
*
* @param *free_type The type of the freed variable.
* @param where Where the variable was allocated, either heap_alloc or stack_alloc.
*/
-ir_node *new_rd_Free(dbg_info *db, ir_node *block, ir_node *store,
- ir_node *ptr, ir_node *size, ir_type *free_type, ir_where_alloc where);
+FIRM_DLL ir_node *new_rd_Free(dbg_info *db, ir_node *block, ir_node *store,
+ ir_node *ptr, ir_node *size, ir_type *free_type,
+ ir_where_alloc where);
/** Constructor for a Sync node.
*
* @param *in[] An array of pointers to nodes that produce an output of type
* memory. The constructor copies this array.
*/
-ir_node *new_rd_Sync(dbg_info *db, ir_node *block, int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_rd_Sync(dbg_info *db, ir_node *block, int arity,
+ ir_node *in[]);
/** Constructor for a Proj node.
*
* @param *mode The mode of the value to project.
* @param proj The position of the value in the tuple.
*/
-ir_node *new_rd_Proj(dbg_info *db, ir_node *arg, ir_mode *mode, long proj);
+FIRM_DLL ir_node *new_rd_Proj(dbg_info *db, ir_node *arg, ir_mode *mode,
+ long proj);
/** Constructor for a defaultProj node.
*
* @param arg A node producing a tuple.
* @param max_proj The end position of the value in the tuple.
*/
-ir_node *new_rd_defaultProj(dbg_info *db, ir_node *arg, long max_proj);
+FIRM_DLL ir_node *new_rd_defaultProj(dbg_info *db, ir_node *arg, long max_proj);
/** Constructor for a Tuple node.
*
* @param *in[] An array containing pointers to the nodes producing the tuple
* elements. The constructor copies this array.
*/
-ir_node *new_rd_Tuple(dbg_info *db, ir_node *block,
- int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_rd_Tuple(dbg_info *db, ir_node *block,
+ int arity, ir_node *in[]);
/** Constructor for a Id node.
*
* @param *val The value
* @param *mode The mode of *val.
*/
-ir_node *new_rd_Id(dbg_info *db, ir_node *block,
- ir_node *val, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Id(dbg_info *db, ir_node *block,
+ ir_node *val, ir_mode *mode);
/** Constructor for a Confirm node.
*
* @param *bound The value to compare against. Must be a firm node, typically a constant.
* @param cmp The compare operation.
*/
-ir_node *new_rd_Confirm(dbg_info *db, ir_node *block,
- ir_node *val, ir_node *bound, pn_Cmp cmp);
+FIRM_DLL ir_node *new_rd_Confirm(dbg_info *db, ir_node *block,
+ ir_node *val, ir_node *bound, pn_Cmp cmp);
/** Constructor for an Unknown node.
*
* @param *irg The IR graph the node belongs to.
* @param *m The mode of the unknown value.
*/
-ir_node *new_rd_Unknown(dbg_info *db, ir_graph *irg, ir_mode *m);
+FIRM_DLL ir_node *new_rd_Unknown(dbg_info *db, ir_graph *irg, ir_mode *m);
/** Constructor for a CallBegin node.
*
* @param *ptr pointer to the called function
* @param *call associated call operation
*/
-ir_node *new_rd_CallBegin(dbg_info *db, ir_node *block, ir_node *ptr, ir_node *call);
+FIRM_DLL ir_node *new_rd_CallBegin(dbg_info *db, ir_node *block, ir_node *ptr,
+ ir_node *call);
/** Constructor for a EndReg node.
*
* @param *irg The IR graph the node belong to.
* @param *block The block the node belong to.
*/
-ir_node *new_rd_EndReg(dbg_info *db, ir_graph *irg, ir_node *block);
+FIRM_DLL ir_node *new_rd_EndReg(dbg_info *db, ir_graph *irg, ir_node *block);
/** Constructor for a EndExcept node.
*
* @param *irg The IR graph the node belong to.
* @param *block The block the node belong to.
*/
-ir_node *new_rd_EndExcept(dbg_info *db, ir_graph *irg, ir_node *block);
+FIRM_DLL ir_node *new_rd_EndExcept(dbg_info *db, ir_graph *irg, ir_node *block);
/** Constructor for a Filter node.
*
* @param *mode The mode of the projected value.
* @param proj The position in the tuple to project from.
*/
-ir_node *new_rd_Filter(dbg_info *db,ir_node *block, ir_node *arg,
- ir_mode *mode, long proj);
+FIRM_DLL ir_node *new_rd_Filter(dbg_info *db,ir_node *block, ir_node *arg,
+ ir_mode *mode, long proj);
/** Constructor for a Mux node.
*
* @param *ir_false The ir_node that calculates the false result.
* @param *mode The mode of the node (and it_true and ir_false).
*/
-ir_node *new_rd_Mux(dbg_info *db, ir_node *block, ir_node *sel,
- ir_node *ir_false, ir_node *ir_true, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Mux(dbg_info *db, ir_node *block, ir_node *sel,
+ ir_node *ir_false, ir_node *ir_true,
+ ir_mode *mode);
/** Constructor for a CopyB node.
*
* @param *src The ir_node that represents the source address.
* @param *data_type The type of the copied data
*/
-ir_node *new_rd_CopyB(dbg_info *db, ir_node *block, ir_node *store,
- ir_node *dst, ir_node *src, ir_type *data_type);
+FIRM_DLL ir_node *new_rd_CopyB(dbg_info *db, ir_node *block, ir_node *store,
+ ir_node *dst, ir_node *src, ir_type *data_type);
/** Constructor for a InstOf node.
*
* @param *objptr A pointer to a object of a class type.
* @param *type The type of which objptr must be.
*/
-ir_node *new_rd_InstOf(dbg_info *db, ir_node *block, ir_node *store,
- ir_node *objptr, ir_type *type);
+FIRM_DLL ir_node *new_rd_InstOf(dbg_info *db, ir_node *block, ir_node *store,
+ ir_node *objptr, ir_type *type);
/** Constructor for a Raise node.
*
* @param *store The current memory.
* @param *obj A pointer to the Except variable.
*/
-ir_node *new_rd_Raise(dbg_info *db, ir_node *block, ir_node *store, ir_node *obj);
+FIRM_DLL ir_node *new_rd_Raise(dbg_info *db, ir_node *block, ir_node *store,
+ ir_node *obj);
/** Constructor for a Bound node.
*
* @param *lower The ir_node that represents the lower bound for the index.
* @param *upper The ir_node that represents the upper bound for the index.
*/
-ir_node *new_rd_Bound(dbg_info *db, ir_node *block,
- ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper);
+FIRM_DLL ir_node *new_rd_Bound(dbg_info *db, ir_node *block,
+ ir_node *store, ir_node *idx, ir_node *lower,
+ ir_node *upper);
/** Constructor for a Pin node.
*
* @param *block The block the node belong to.
* @param *node The node which value should be pinned.
*/
-ir_node *new_rd_Pin(dbg_info *db, ir_node *block, ir_node *node);
+FIRM_DLL ir_node *new_rd_Pin(dbg_info *db, ir_node *block, ir_node *node);
/** Constructor for an ASM pseudo node.
*
* @param *clobber The array of length n_clobber of clobbered registers.
* @param *asm_text The assembler text.
*/
-ir_node *new_rd_ASM(dbg_info *db, ir_node *block,
- int arity, ir_node *in[], ir_asm_constraint *inputs,
- int n_outs, ir_asm_constraint *outputs,
- int n_clobber, ident *clobber[], ident *asm_text);
+FIRM_DLL ir_node *new_rd_ASM(dbg_info *db, ir_node *block,
+ int arity, ir_node *in[], ir_asm_constraint *inputs,
+ int n_outs, ir_asm_constraint *outputs,
+ int n_clobber, ident *clobber[], ident *asm_text);
/*-------------------------------------------------------------------------*/
/* The raw interface without debug support */
* @param in[] An array of control predecessors. The length of
* the array must be 'arity'. The constructor copies this array.
*/
-ir_node *new_r_Block(ir_graph *irg, int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_r_Block(ir_graph *irg, int arity, ir_node *in[]);
/** Constructor for a Start node.
*
* @param *irg The IR graph the node belongs to.
* @param *block The IR block the node belongs to.
*/
-ir_node *new_r_Start(ir_graph *irg, ir_node *block);
+FIRM_DLL ir_node *new_r_Start(ir_graph *irg, ir_node *block);
/** Constructor for a End node.
*
* @param *irg The IR graph the node belongs to.
* @param *block The IR block the node belongs to.
*/
-ir_node *new_r_End(ir_graph *irg, ir_node *block);
+FIRM_DLL ir_node *new_r_End(ir_graph *irg, ir_node *block);
/** Constructor for a Jmp node.
*
*
* @param *block The IR block the node belongs to.
*/
-ir_node *new_r_Jmp(ir_node *block);
+FIRM_DLL ir_node *new_r_Jmp(ir_node *block);
/** Constructor for an IJmp node.
*
* @param *block The IR block the node belongs to.
* @param *tgt The IR node representing the target address.
*/
-ir_node *new_r_IJmp(ir_node *block, ir_node *tgt);
+FIRM_DLL ir_node *new_r_IJmp(ir_node *block, ir_node *tgt);
/** Constructor for a Cond node.
*
* @param *block The IR block the node belongs to.
* @param *c The conditions parameter.Can be of mode b or I_u.
*/
-ir_node *new_r_Cond(ir_node *block, ir_node *c);
+FIRM_DLL ir_node *new_r_Cond(ir_node *block, ir_node *c);
/** Constructor for a Return node.
*
* @param arity Number of array indices.
* @param *in[] Array with index inputs to the node. The constructor copies this array.
*/
-ir_node *new_r_Return(ir_node *block, ir_node *store, int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_r_Return(ir_node *block, ir_node *store,
+ int arity, ir_node *in[]);
/** Constructor for a Const node.
*
* @param *irg The IR graph the node belongs to.
* @param *con Points to an entry in the constant table.
*/
-ir_node *new_r_Const(ir_graph *irg, tarval *con);
+FIRM_DLL ir_node *new_r_Const(ir_graph *irg, tarval *con);
/** Constructor for a Const node.
*
* @param *mode The mode of the operands and the results.
* @param value A value from which the tarval is made.
*/
-ir_node *new_r_Const_long(ir_graph *irg, ir_mode *mode, long value);
+FIRM_DLL ir_node *new_r_Const_long(ir_graph *irg, ir_mode *mode, long value);
/** Constructor for a Const_type node.
*
* @param *con Points to an entry in the constant table.
* @param *tp The type of the constant.
*/
-ir_node *new_r_Const_type(ir_graph *irg, tarval *con, ir_type *tp);
+FIRM_DLL ir_node *new_r_Const_type(ir_graph *irg, tarval *con, ir_type *tp);
/** Constructor for a SymConst node.
*
* SymConst kind.
* @param kind The kind of the symbolic constant, see the list above
*/
-ir_node *new_r_SymConst(ir_graph *irg, ir_mode *mode,
- union symconst_symbol value, symconst_kind kind);
+FIRM_DLL ir_node *new_r_SymConst(ir_graph *irg, ir_mode *mode,
+ union symconst_symbol value,
+ symconst_kind kind);
/** Constructor for a simpleSel node.
*
* single attribute out.
* @param *ent The entity to select.
*/
-ir_node *new_r_simpleSel(ir_node *block, ir_node *store,
- ir_node *objptr, ir_entity *ent);
+FIRM_DLL ir_node *new_r_simpleSel(ir_node *block, ir_node *store,
+ ir_node *objptr, ir_entity *ent);
/** Constructor for a Sel node.
*
* element entity. The constructor copies this array.
* @param *ent The entity to select.
*/
-ir_node *new_r_Sel(ir_node *block, ir_node *store,
- ir_node *objptr, int n_index, ir_node *index[],
- ir_entity *ent);
+FIRM_DLL ir_node *new_r_Sel(ir_node *block, ir_node *store,
+ ir_node *objptr, int n_index, ir_node *index[],
+ ir_entity *ent);
/** Constructor for a Call node.
*
* @param *in[] An array with the pointers to the parameters. The constructor copies this array.
* @param *tp Type information of the procedure called.
*/
-ir_node *new_r_Call(ir_node *block, ir_node *store,
- ir_node *callee, int arity, ir_node *in[], ir_type *tp);
+FIRM_DLL ir_node *new_r_Call(ir_node *block, ir_node *store,
+ ir_node *callee, int arity, ir_node *in[],
+ ir_type *tp);
/** Constructor for a Builtin node.
*
* @param kind The kind of the called builtin.
* @param *tp Type information of the procedure called.
*/
-ir_node *new_r_Builtin(ir_node *block, ir_node *store,
- int arity, ir_node *in[], ir_builtin_kind kind, ir_type *tp);
+FIRM_DLL ir_node *new_r_Builtin(ir_node *block, ir_node *store,
+ int arity, ir_node *in[], ir_builtin_kind kind,
+ ir_type *tp);
/** Constructor for a Add node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_r_Add(ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Add(ir_node *block, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/**
* Constructor for a Sub node.
* @param *op2 The second operand.
* @param *mode The mode of the operands and the results.
*/
-ir_node *new_r_Sub(ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Sub(ir_node *block, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/** Constructor for a Minus node.
*
* @param *op The operand.
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_r_Minus(ir_node *block, ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Minus(ir_node *block, ir_node *op, ir_mode *mode);
/** Constructor for a Mul node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_r_Mul(ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Mul(ir_node *block, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/** Constructor for a Mulh node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_r_Mulh(ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Mulh(ir_node *block, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/** Constructor for a Quot node.
*
* @param *mode The mode of the result.
* @param state The pinned state.
*/
-ir_node *new_r_Quot(ir_node *block, ir_node *memop, ir_node *op1, ir_node *op2,
- ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_r_Quot(ir_node *block, ir_node *memop,
+ ir_node *op1, ir_node *op2, ir_mode *mode,
+ op_pin_state state);
/** Constructor for a DivMod node.
*
* @param *mode The mode of the results.
* @param state The pinned state.
*/
-ir_node *new_r_DivMod(ir_node *block, ir_node *memop, ir_node *op1, ir_node *op2,
- ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_r_DivMod(ir_node *block, ir_node *memop,
+ ir_node *op1, ir_node *op2, ir_mode *mode,
+ op_pin_state state);
/** Constructor for a Div node.
*
* @param *mode The mode of the result.
* @param state The pinned state.
*/
-ir_node *new_r_Div(ir_node *block, ir_node *memop, ir_node *op1, ir_node *op2,
- ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_r_Div(ir_node *block, ir_node *memop,
+ ir_node *op1, ir_node *op2, ir_mode *mode,
+ op_pin_state state);
/** Constructor for a remainderless Div node.
*
* @param *mode The mode of the result.
* @param state The pinned state.
*/
-ir_node *new_r_DivRL(ir_node *block, ir_node *memop, ir_node *op1, ir_node *op2,
- ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_r_DivRL(ir_node *block, ir_node *memop,
+ ir_node *op1, ir_node *op2, ir_mode *mode,
+ op_pin_state state);
/** Constructor for a Mod node.
*
* @param *mode The mode of the result.
* @param state The pinned state.
*/
-ir_node *new_r_Mod(ir_node *block, ir_node *memop, ir_node *op1, ir_node *op2,
- ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_r_Mod(ir_node *block, ir_node *memop,
+ ir_node *op1, ir_node *op2, ir_mode *mode,
+ op_pin_state state);
/** Constructor for a Abs node.
*
* @param *op The operand
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_r_Abs(ir_node *block, ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Abs(ir_node *block, ir_node *op, ir_mode *mode);
/** Constructor for a And node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_r_And(ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_r_And(ir_node *block, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/** Constructor for a Or node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_r_Or(ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Or(ir_node *block, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/** Constructor for a Eor node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the results.
*/
-ir_node *new_r_Eor(ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Eor(ir_node *block, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/** Constructor for a Not node.
*
* @param *op The operand.
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_r_Not(ir_node *block, ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Not(ir_node *block, ir_node *op, ir_mode *mode);
/** Constructor for a Cmp node.
*
* @param *op1 The first operand.
* @param *op2 The second operand.
*/
-ir_node *new_r_Cmp(ir_node *block, ir_node *op1, ir_node *op2);
+FIRM_DLL ir_node *new_r_Cmp(ir_node *block, ir_node *op1, ir_node *op2);
/** Constructor for a Shl node.
*
* @param *k The number of bits to shift the operand .
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_r_Shl(ir_node *block, ir_node *op, ir_node *k, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Shl(ir_node *block, ir_node *op, ir_node *k,
+ ir_mode *mode);
/** Constructor for a Shr node.
*
* @param *k The number of bits to shift the operand .
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_r_Shr(ir_node *block, ir_node *op, ir_node *k, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Shr(ir_node *block, ir_node *op, ir_node *k,
+ ir_mode *mode);
/**
* Constructor for a Shrs node.
* @param *k The number of bits to shift the operand.
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_r_Shrs(ir_node *block, ir_node *op, ir_node *k, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Shrs(ir_node *block, ir_node *op, ir_node *k,
+ ir_mode *mode);
/** Constructor for a Rotl node.
*
* @param *k The number of bits to rotate the operand.
* @param *mode The mode of the operand.
*/
-ir_node *new_r_Rotl(ir_node *block, ir_node *op, ir_node *k, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Rotl(ir_node *block, ir_node *op, ir_node *k,
+ ir_mode *mode);
/** Constructor for a Conv node.
*
* @param *op The operand.
* @param *mode The mode of this the operand muss be converted .
*/
-ir_node *new_r_Conv(ir_node *block, ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Conv(ir_node *block, ir_node *op, ir_mode *mode);
/** Constructor for a strict Conv node.
*
* @param *op The operand.
* @param *mode The mode of this the operand muss be converted .
*/
-ir_node *new_r_strictConv(ir_node *block, ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_r_strictConv(ir_node *block, ir_node *op, ir_mode *mode);
/** Constructor for a Cast node.
*
* @param *op The operand.
* @param *to_tp The type of this the operand muss be casted .
*/
-ir_node *new_r_Cast(ir_node *block, ir_node *op, ir_type *to_tp);
+FIRM_DLL ir_node *new_r_Cast(ir_node *block, ir_node *op, ir_type *to_tp);
/** Constructor for a Carry node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_r_Carry(ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Carry(ir_node *block, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/**
* Constructor for a Borrow node.
* @param *op2 The second operand.
* @param *mode The mode of the operands and the results.
*/
-ir_node *new_r_Borrow(ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Borrow(ir_node *block, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/** Constructor for a Phi node.
*
* @param *in[] Array with predecessors. The constructor copies this array.
* @param *mode The mode of it's inputs and output.
*/
-ir_node *new_r_Phi(ir_node *block, int arity, ir_node *in[], ir_mode *mode);
+FIRM_DLL ir_node *new_r_Phi(ir_node *block, int arity, ir_node *in[],
+ ir_mode *mode);
/** Constructor for a Load node.
*
* @param *mode The mode of the value to be loaded.
* @param flags Additional flags for alignment, volatility and pin state.
*/
-ir_node *new_r_Load(ir_node *block, ir_node *store,
- ir_node *adr, ir_mode *mode, ir_cons_flags flags);
+FIRM_DLL ir_node *new_r_Load(ir_node *block, ir_node *store,
+ ir_node *adr, ir_mode *mode, ir_cons_flags flags);
/** Constructor for a Store node.
*
* @param *val The value to write to this variable.
* @param flags Additional flags for alignment, volatility and pin state.
*/
-ir_node *new_r_Store(ir_node *block, ir_node *store,
- ir_node *adr, ir_node *val, ir_cons_flags flags);
+FIRM_DLL ir_node *new_r_Store(ir_node *block, ir_node *store,
+ ir_node *adr, ir_node *val, ir_cons_flags flags);
/** Constructor for a Alloc node.
*
* @param *alloc_type The type of the allocated variable.
* @param where Where to allocate the variable, either heap_alloc or stack_alloc.
*/
-ir_node *new_r_Alloc(ir_node *block, ir_node *store,
- ir_node *count, ir_type *alloc_type, ir_where_alloc where);
+FIRM_DLL ir_node *new_r_Alloc(ir_node *block, ir_node *store,
+ ir_node *count, ir_type *alloc_type,
+ ir_where_alloc where);
/** Constructor for a Free node.
*
* @param *free_type The type of the freed variable.
* @param where Where the variable was allocated, either heap_alloc or stack_alloc.
*/
-ir_node *new_r_Free(ir_node *block, ir_node *store,
- ir_node *ptr, ir_node *size, ir_type *free_type, ir_where_alloc where);
+FIRM_DLL ir_node *new_r_Free(ir_node *block, ir_node *store, ir_node *ptr,
+ ir_node *size, ir_type *free_type,
+ ir_where_alloc where);
/** Constructor for a Sync node.
*
* @param *in[] An array of pointers to nodes that produce an output of type memory.
* The constructor copies this array.
*/
-ir_node *new_r_Sync(ir_node *block, int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_r_Sync(ir_node *block, int arity, ir_node *in[]);
/** Constructor for a Proj node.
*
* @param mode The mode of the value to project.
* @param proj The position of the value in the tuple.
*/
-ir_node *new_r_Proj(ir_node *arg, ir_mode *mode, long proj);
+FIRM_DLL ir_node *new_r_Proj(ir_node *arg, ir_mode *mode, long proj);
/** Constructor for a defaultProj node.
*
* @param arg A node producing a tuple.
* @param max_proj The end position of the value in the tuple.
*/
-ir_node *new_r_defaultProj(ir_node *arg, long max_proj);
+FIRM_DLL ir_node *new_r_defaultProj(ir_node *arg, long max_proj);
/** Constructor for a Tuple node.
* @param *in[] An array containing pointers to the nodes producing the tuple elements.
* The constructor copies this array.
*/
-ir_node *new_r_Tuple(ir_node *block, int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_r_Tuple(ir_node *block, int arity, ir_node *in[]);
/** Constructor for a Id node.
*
* @param *val The operand to Id.
* @param *mode The mode of *val.
*/
-ir_node *new_r_Id(ir_node *block, ir_node *val, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Id(ir_node *block, ir_node *val, ir_mode *mode);
/** Constructor for a Bad node.
*
*
* @param *irg The IR graph the node belongs to.
*/
-ir_node *new_r_Bad(ir_graph *irg);
+FIRM_DLL ir_node *new_r_Bad(ir_graph *irg);
/** Constructor for a Confirm node.
*
* @param *bound The value to compare against. Must be a firm node, typically a constant.
* @param cmp The compare operation.
*/
-ir_node *new_r_Confirm(ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp);
+FIRM_DLL ir_node *new_r_Confirm(ir_node *block, ir_node *val, ir_node *bound,
+ pn_Cmp cmp);
/** Constructor for a Unknown node.
*
* @param *irg The IR graph the node belongs to.
* @param *m The mode of the unknown value.
*/
-ir_node *new_r_Unknown(ir_graph *irg, ir_mode *m);
+FIRM_DLL ir_node *new_r_Unknown(ir_graph *irg, ir_mode *m);
/** Constructor for a CallBegin node.
*
* @param *ptr pointer to the called function
* @param *call associated call operation
*/
-ir_node *new_r_CallBegin(ir_node *block, ir_node *ptr, ir_node *call);
+FIRM_DLL ir_node *new_r_CallBegin(ir_node *block, ir_node *ptr, ir_node *call);
/** Constructor for a EndReg node.
*
* @param *irg The IR graph the node belong to.
* @param *block The block the node belong to.
*/
-ir_node *new_r_EndReg(ir_graph *irg, ir_node *block);
+FIRM_DLL ir_node *new_r_EndReg(ir_graph *irg, ir_node *block);
/** Constructor for a EndExcept node.
*
* @param *irg The IR graph the node belong to.
* @param *block The block the node belong to.
*/
-ir_node *new_r_EndExcept(ir_graph *irg, ir_node *block);
+FIRM_DLL ir_node *new_r_EndExcept(ir_graph *irg, ir_node *block);
/** Constructor for a Break node.
*
*
* @param *block The block the node belong to.
*/
-ir_node *new_r_Break(ir_node *block);
+FIRM_DLL ir_node *new_r_Break(ir_node *block);
/** Constructor for a Filter node.
*
* @param *mode The mode of the projected value.
* @param proj The position in the tuple to project from.
*/
-ir_node *new_r_Filter(ir_node *block, ir_node *arg, ir_mode *mode, long proj);
+FIRM_DLL ir_node *new_r_Filter(ir_node *block, ir_node *arg, ir_mode *mode,
+ long proj);
/** Constructor for a NoMem node.
*
*
* @param *irg The IR graph the node belongs to.
*/
-ir_node *new_r_NoMem(ir_graph *irg);
+FIRM_DLL ir_node *new_r_NoMem(ir_graph *irg);
/** Constructor for a Mux node.
*
* @param *ir_false The ir_node that calculates the false result.
* @param *mode The mode of the node (and it_true and ir_false).
*/
-ir_node *new_r_Mux(ir_node *block, ir_node *sel,
- ir_node *ir_false, ir_node *ir_true, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Mux(ir_node *block, ir_node *sel,
+ ir_node *ir_false, ir_node *ir_true, ir_mode *mode);
/** Constructor for a CopyB node.
*
* @param *src The ir_node that represents the source address.
* @param *data_type The type of the copied data
*/
-ir_node *new_r_CopyB(ir_node *block, ir_node *store,
- ir_node *dst, ir_node *src, ir_type *data_type);
+FIRM_DLL ir_node *new_r_CopyB(ir_node *block, ir_node *store,
+ ir_node *dst, ir_node *src, ir_type *data_type);
/** Constructor for a InstOf node.
*
* @param *objptr A pointer to a object of a class type.
* @param *type The type of which objptr must be.
*/
-ir_node *new_r_InstOf(ir_node *block, ir_node *store,
- ir_node *objptr, ir_type *type);
+FIRM_DLL ir_node *new_r_InstOf(ir_node *block, ir_node *store,
+ ir_node *objptr, ir_type *type);
/** Constructor for a Raise node.
*
* @param *store The current memory.
* @param *obj A pointer to the Except variable.
*/
-ir_node *new_r_Raise(ir_node *block, ir_node *store, ir_node *obj);
+FIRM_DLL ir_node *new_r_Raise(ir_node *block, ir_node *store, ir_node *obj);
/** Constructor for a Bound node.
*
* @param *lower The ir_node that represents the lower bound for the index.
* @param *upper The ir_node that represents the upper bound for the index.
*/
-ir_node *new_r_Bound(ir_node *block, ir_node *store,
- ir_node *idx, ir_node *lower, ir_node *upper);
+FIRM_DLL ir_node *new_r_Bound(ir_node *block, ir_node *store,
+ ir_node *idx, ir_node *lower, ir_node *upper);
/** Constructor for a Pin node.
*
* @param *block The block the node belong to.
* @param *node The node which value should be pinned.
*/
-ir_node *new_r_Pin(ir_node *block, ir_node *node);
+FIRM_DLL ir_node *new_r_Pin(ir_node *block, ir_node *node);
/** Constructor for an ASM pseudo node.
*
* @param *clobber The array of length n_clobber of clobbered registers.
* @param *asm_text The assembler text.
*/
-ir_node *new_r_ASM(ir_node *block,
- int arity, ir_node *in[], ir_asm_constraint *inputs,
- int n_outs, ir_asm_constraint *outputs,
- int n_clobber, ident *clobber[], ident *asm_text);
+FIRM_DLL ir_node *new_r_ASM(ir_node *block,
+ int arity, ir_node *in[], ir_asm_constraint *inputs,
+ int n_outs, ir_asm_constraint *outputs,
+ int n_clobber, ident *clobber[], ident *asm_text);
/*-----------------------------------------------------------------------*/
/* The block oriented interface */
*
* @param target The new current block.
*/
-void set_cur_block(ir_node *target);
+FIRM_DLL void set_cur_block(ir_node *target);
/** Returns the current block of the current graph. */
-ir_node *get_cur_block(void);
+FIRM_DLL ir_node *get_cur_block(void);
/** Constructor for a Block node.
*
* @param in[] An array of control predecessors. The length of
* the array must be 'arity'.
*/
-ir_node *new_d_Block(dbg_info *db, int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_d_Block(dbg_info *db, int arity, ir_node *in[]);
/** Constructor for a Start node.
*
*
* @param *db A pointer for debug information.
*/
-ir_node *new_d_Start(dbg_info *db);
+FIRM_DLL ir_node *new_d_Start(dbg_info *db);
/** Constructor for a End node.
*
*
* @param *db A pointer for debug information.
*/
-ir_node *new_d_End(dbg_info *db);
+FIRM_DLL ir_node *new_d_End(dbg_info *db);
/** Constructor for a Jmp node.
*
*
* @param *db A pointer for debug information.
*/
-ir_node *new_d_Jmp(dbg_info *db);
+FIRM_DLL ir_node *new_d_Jmp(dbg_info *db);
/** Constructor for an IJmp node.
*
* @param *db A pointer for debug information.
* @param *tgt The IR node representing the target address.
*/
-ir_node *new_d_IJmp(dbg_info *db, ir_node *tgt);
+FIRM_DLL ir_node *new_d_IJmp(dbg_info *db, ir_node *tgt);
/** Constructor for a Cond node.
*
* @param *db A pointer for debug information.
* @param *c The conditions parameter.Can be of mode b or I_u.
*/
-ir_node *new_d_Cond(dbg_info *db, ir_node *c);
+FIRM_DLL ir_node *new_d_Cond(dbg_info *db, ir_node *c);
/** Constructor for a Return node.
*
* @param arity Number of array indices.
* @param *in Array with index inputs to the node.
*/
-ir_node *new_d_Return(dbg_info *db, ir_node *store, int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_d_Return(dbg_info *db, ir_node *store,
+ int arity, ir_node *in[]);
/** Constructor for a Const_type node.
*
added to the attributes of the node.
* @param *tp The type of the constant.
*/
-ir_node *new_d_Const_type(dbg_info *db, tarval *con, ir_type *tp);
+FIRM_DLL ir_node *new_d_Const_type(dbg_info *db, tarval *con, ir_type *tp);
/** Constructor for a Const node.
*
* @param *con Points to an entry in the constant table. This pointer is added
* to the attributes of the node.
*/
-ir_node *new_d_Const(dbg_info *db, tarval *con);
+FIRM_DLL ir_node *new_d_Const(dbg_info *db, tarval *con);
/**
* @see new_rd_Const_long()
* @param *mode The mode of the operands and results.
* @param value A value from which the tarval is made.
*/
-ir_node *new_d_Const_long(dbg_info *db, ir_mode *mode, long value);
+FIRM_DLL ir_node *new_d_Const_long(dbg_info *db, ir_mode *mode, long value);
/** Constructor for a SymConst_type node.
*
* @param kind The kind of the symbolic constant, see the list above
* @param tp The source type of the constant.
*/
-ir_node *new_d_SymConst_type(dbg_info *db, ir_mode *mode,
- union symconst_symbol value, symconst_kind kind, ir_type *tp);
+FIRM_DLL ir_node *new_d_SymConst_type(dbg_info *db, ir_mode *mode,
+ union symconst_symbol value,
+ symconst_kind kind, ir_type *tp);
/** Constructor for a SymConst node.
*
* Same as new_d_SymConst_type, except that it sets the type to type_unknown.
*/
-ir_node *new_d_SymConst(dbg_info *db, ir_mode *mode,
- union symconst_symbol value, symconst_kind kind);
+FIRM_DLL ir_node *new_d_SymConst(dbg_info *db, ir_mode *mode,
+ union symconst_symbol value,
+ symconst_kind kind);
/** Constructor for a simpleSel node.
*
* single attribute out.
* @param *ent The entity to select.
*/
-ir_node *new_d_simpleSel(dbg_info *db, ir_node *store, ir_node *objptr, ir_entity *ent);
+FIRM_DLL ir_node *new_d_simpleSel(dbg_info *db, ir_node *store, ir_node *objptr,
+ ir_entity *ent);
/** Constructor for a Sel node.
*
* element entity. The constructor copies this array.
* @param *ent The entity to select.
*/
-ir_node *new_d_Sel(dbg_info *db, ir_node *store, ir_node *objptr, int arity, ir_node *in[],
- ir_entity *ent);
+FIRM_DLL ir_node *new_d_Sel(dbg_info *db, ir_node *store, ir_node *objptr,
+ int arity, ir_node *in[], ir_entity *ent);
/** Constructor for a Call node.
*
* @param *in[] An array with the pointers to the parameters. The constructor copies this array.
* @param *tp Type information of the procedure called.
*/
-ir_node *new_d_Call(dbg_info *db, ir_node *store, ir_node *callee, int arity, ir_node *in[],
- ir_type *tp);
+FIRM_DLL ir_node *new_d_Call(dbg_info *db, ir_node *store, ir_node *callee,
+ int arity, ir_node *in[], ir_type *tp);
/** Constructor for a Builtin node.
*
* @param kind The kind of the called builtin.
* @param *tp Type information of the procedure called.
*/
-ir_node *new_d_Builtin(dbg_info *db, ir_node *store, int arity, ir_node *in[], ir_builtin_kind kind, ir_type *tp);
+FIRM_DLL ir_node *new_d_Builtin(dbg_info *db, ir_node *store,
+ int arity, ir_node *in[],
+ ir_builtin_kind kind, ir_type *tp);
/** Constructor for a Add node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_d_Add(dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Add(dbg_info *db, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/** Constructor for a Sub node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_d_Sub(dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Sub(dbg_info *db, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/** Constructor for a Minus node.
*
* @param *op The operand .
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_d_Minus(dbg_info *db, ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Minus(dbg_info *db, ir_node *op, ir_mode *mode);
/** Constructor for a Mul node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_d_Mul(dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Mul(dbg_info *db, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/** Constructor for a Mulh node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_d_Mulh(dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Mulh(dbg_info *db, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/** Constructor for a Quot node.
*
* @param *mode The mode of the result.
* @param state The pinned state.
*/
-ir_node *new_d_Quot(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_d_Quot(dbg_info *db, ir_node *memop,
+ ir_node *op1, ir_node *op2, ir_mode *mode,
+ op_pin_state state);
/** Constructor for a DivMod node.
*
* @param *mode The mode of the results.
* @param state The pinned state.
*/
-ir_node *new_d_DivMod(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_d_DivMod(dbg_info *db, ir_node *memop, ir_node *op1,
+ ir_node *op2, ir_mode *mode, op_pin_state state);
/** Constructor for a Div node.
*
* @param *mode The mode of the result.
* @param state The pinned state.
*/
-ir_node *new_d_Div(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_d_Div(dbg_info *db, ir_node *memop, ir_node *op1,
+ ir_node *op2, ir_mode *mode, op_pin_state state);
/** Constructor for a remainderless Div node.
*
* @param *mode The mode of the result.
* @param state The pinned state.
*/
-ir_node *new_d_DivRL(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_d_DivRL(dbg_info *db, ir_node *memop,
+ ir_node *op1, ir_node *op2, ir_mode *mode,
+ op_pin_state state);
/** Constructor for a Mod node.
*
* @param *mode The mode of the result.
* @param state The pinned state.
*/
-ir_node *new_d_Mod(dbg_info *db, ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_d_Mod(dbg_info *db, ir_node *memop,
+ ir_node *op1, ir_node *op2, ir_mode *mode,
+ op_pin_state state);
/** Constructor for a Abs node.
*
* @param *op The operand
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_d_Abs(dbg_info *db, ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Abs(dbg_info *db, ir_node *op, ir_mode *mode);
/** Constructor for a And node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_d_And(dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_d_And(dbg_info *db, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/** Constructor for a Or node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_d_Or(dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Or(dbg_info *db, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/** Constructor for a Eor node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the results.
*/
-ir_node *new_d_Eor(dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Eor(dbg_info *db, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/** Constructor for a Not node.
*
* @param *op The operand.
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_d_Not(dbg_info *db, ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Not(dbg_info *db, ir_node *op, ir_mode *mode);
/** Constructor for a Shl node.
*
* @param *k The number of bits to shift the operand .
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_d_Shl(dbg_info *db, ir_node *op, ir_node *k, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Shl(dbg_info *db, ir_node *op, ir_node *k,
+ ir_mode *mode);
/** Constructor for a Shr node.
*
* @param *k The number of bits to shift the operand .
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_d_Shr(dbg_info *db, ir_node *op, ir_node *k, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Shr(dbg_info *db, ir_node *op, ir_node *k,
+ ir_mode *mode);
/** Constructor for a Shrs node.
*
* @param *k The number of bits to shift the operand .
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_d_Shrs(dbg_info *db, ir_node *op, ir_node *k, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Shrs(dbg_info *db, ir_node *op, ir_node *k,
+ ir_mode *mode);
/** Constructor for a Rotl node.
*
* @param *k The number of bits to rotate the operand.
* @param *mode The mode of the operand.
*/
-ir_node *new_d_Rotl(dbg_info *db, ir_node *op, ir_node *k, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Rotl(dbg_info *db, ir_node *op, ir_node *k,
+ ir_mode *mode);
/** Constructor for a Cmp node.
*
* @param *op1 The first operand.
* @param *op2 The second operand.
*/
-ir_node *new_d_Cmp(dbg_info *db, ir_node *op1, ir_node *op2);
+FIRM_DLL ir_node *new_d_Cmp(dbg_info *db, ir_node *op1, ir_node *op2);
/** Constructor for a Conv node.
*
* @param *op The operand.
* @param *mode The mode of this the operand muss be converted .
*/
-ir_node *new_d_Conv(dbg_info *db, ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Conv(dbg_info *db, ir_node *op, ir_mode *mode);
/** Constructor for a strict Conv node.
*
* @param *op The operand.
* @param *mode The mode of this the operand muss be converted .
*/
-ir_node *new_d_strictConv(dbg_info *db, ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_d_strictConv(dbg_info *db, ir_node *op, ir_mode *mode);
/** Constructor for a Cast node.
*
* @param *op The operand.
* @param *to_tp The type of this the operand muss be casted .
*/
-ir_node *new_d_Cast(dbg_info *db, ir_node *op, ir_type *to_tp);
+FIRM_DLL ir_node *new_d_Cast(dbg_info *db, ir_node *op, ir_type *to_tp);
/** Constructor for a Carry node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_d_Carry(dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Carry(dbg_info *db, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/** Constructor for a Borrow node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_d_Borrow(dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Borrow(dbg_info *db, ir_node *op1, ir_node *op2,
+ ir_mode *mode);
/** Constructor for a Phi node.
*
* @param *in Array with predecessors
* @param *mode The mode of it's inputs and output.
*/
-ir_node *new_d_Phi(dbg_info *db, int arity, ir_node *in[], ir_mode *mode);
+FIRM_DLL ir_node *new_d_Phi(dbg_info *db, int arity, ir_node *in[],
+ ir_mode *mode);
/** Constructor for a Load node.
*
* @param *mode The mode of the value to be loaded.
* @param flags Additional flags for alignment, volatility and pin state.
*/
-ir_node *new_d_Load(dbg_info *db, ir_node *store, ir_node *addr, ir_mode *mode, ir_cons_flags flags);
+FIRM_DLL ir_node *new_d_Load(dbg_info *db, ir_node *store, ir_node *addr,
+ ir_mode *mode, ir_cons_flags flags);
/** Constructor for a Store node.
*
* @param *val The value to write to this variable.
* @param flags Additional flags for alignment, volatility and pin state.
*/
-ir_node *new_d_Store(dbg_info *db, ir_node *store, ir_node *addr, ir_node *val, ir_cons_flags flags);
+FIRM_DLL ir_node *new_d_Store(dbg_info *db, ir_node *store, ir_node *addr,
+ ir_node *val, ir_cons_flags flags);
/** Constructor for a Alloc node.
*
* @param *alloc_type The type of the allocated variable.
* @param where Where to allocate the variable, either heap_alloc or stack_alloc.
*/
-ir_node *new_d_Alloc(dbg_info *db, ir_node *store, ir_node *count, ir_type *alloc_type,
- ir_where_alloc where);
+FIRM_DLL ir_node *new_d_Alloc(dbg_info *db, ir_node *store, ir_node *count,
+ ir_type *alloc_type, ir_where_alloc where);
/** Constructor for a Free node.
*
* @param *free_type The type of the freed variable.
* @param where Where the variable was allocated, either heap_alloc or stack_alloc.
*/
-ir_node *new_d_Free(dbg_info *db, ir_node *store, ir_node *ptr, ir_node *size,
- ir_type *free_type, ir_where_alloc where);
+FIRM_DLL ir_node *new_d_Free(dbg_info *db, ir_node *store, ir_node *ptr,
+ ir_node *size, ir_type *free_type,
+ ir_where_alloc where);
/** Constructor for a Sync node.
*
* @param **in An array of pointers to nodes that produce an output of type
* memory. The constructor copies this array.
*/
-ir_node *new_d_Sync(dbg_info *db, int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_d_Sync(dbg_info *db, int arity, ir_node *in[]);
/** Constructor for a Proj node.
*
* @param *mode The mode of the value to project.
* @param proj The position of the value in the tuple.
*/
-ir_node *new_d_Proj(dbg_info *db, ir_node *arg, ir_mode *mode, long proj);
+FIRM_DLL ir_node *new_d_Proj(dbg_info *db, ir_node *arg, ir_mode *mode,
+ long proj);
/** Constructor for a defaultProj node.
*
* @param arg A node producing a tuple.
* @param max_proj The end position of the value in the tuple.
*/
-ir_node *new_d_defaultProj(dbg_info *db, ir_node *arg, long max_proj);
+FIRM_DLL ir_node *new_d_defaultProj(dbg_info *db, ir_node *arg, long max_proj);
/** Constructor for a Tuple node.
*
* @param arity The number of tuple elements.
* @param **in An array containing pointers to the nodes producing the tuple elements.
*/
-ir_node *new_d_Tuple(dbg_info *db, int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_d_Tuple(dbg_info *db, int arity, ir_node *in[]);
/** Constructor for a Id node.
*
* @param *val The operand to Id.
* @param *mode The mode of *val.
*/
-ir_node *new_d_Id(dbg_info *db, ir_node *val, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Id(dbg_info *db, ir_node *val, ir_mode *mode);
/** Constructor for a Confirm node.
*
* @param *bound The value to compare against. Must be a firm node, typically a constant.
* @param cmp The compare operation.
*/
-ir_node *new_d_Confirm(dbg_info *db, ir_node *val, ir_node *bound, pn_Cmp cmp);
+FIRM_DLL ir_node *new_d_Confirm(dbg_info *db, ir_node *val, ir_node *bound,
+ pn_Cmp cmp);
/** Constructor for an Unknown node.
*
* @param *db A pointer for debug information.
* @param *m The mode of the unknown value.
*/
-ir_node *new_d_Unknown(dbg_info *db, ir_mode *m);
+FIRM_DLL ir_node *new_d_Unknown(dbg_info *db, ir_mode *m);
/** Constructor for a CallBegin node.
*
* @param *ptr pointer to the called function
* @param *call associated call operation
*/
-ir_node *new_d_CallBegin(dbg_info *db, ir_node *ptr, ir_node *call);
+FIRM_DLL ir_node *new_d_CallBegin(dbg_info *db, ir_node *ptr, ir_node *call);
/** Constructor for an EndReg node.
*
*
* @param *db A pointer for debug information.
*/
-ir_node *new_d_EndReg(dbg_info *db);
+FIRM_DLL ir_node *new_d_EndReg(dbg_info *db);
/** Constructor for an EndExcept node.
*
*
* @param *db A pointer for debug information.
*/
-ir_node *new_d_EndExcept(dbg_info *db);
+FIRM_DLL ir_node *new_d_EndExcept(dbg_info *db);
/** Constructor for a Break node.
*
*
* @param *db A pointer for debug information.
*/
-ir_node *new_d_Break(dbg_info *db);
+FIRM_DLL ir_node *new_d_Break(dbg_info *db);
/** Constructor for a Filter node.
*
* @param *mode The mode of the projected value.
* @param proj The position in the tuple to project from.
*/
-ir_node *new_d_Filter(dbg_info *db, ir_node *arg, ir_mode *mode, long proj);
+FIRM_DLL ir_node *new_d_Filter(dbg_info *db, ir_node *arg, ir_mode *mode,
+ long proj);
/** Constructor for a Mux node.
*
* @param *ir_false The ir_node that calculates the false result.
* @param *mode The mode of the node (and it_true and ir_false).
*/
-ir_node *new_d_Mux(dbg_info *db, ir_node *sel,
- ir_node *ir_false, ir_node *ir_true, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Mux(dbg_info *db, ir_node *sel,
+ ir_node *ir_false, ir_node *ir_true, ir_mode *mode);
/** Constructor for a CopyB node.
*
* @param *src The ir_node that represents the source address.
* @param *data_type The type of the copied data
*/
-ir_node *new_d_CopyB(dbg_info *db, ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type);
+FIRM_DLL ir_node *new_d_CopyB(dbg_info *db, ir_node *store, ir_node *dst,
+ ir_node *src, ir_type *data_type);
/** Constructor for a InstOf node.
*
* @param *objptr A pointer to a object of a class type.
* @param *type The type of which objptr must be.
*/
-ir_node *new_d_InstOf(dbg_info *db, ir_node *store, ir_node *objptr, ir_type *type);
+FIRM_DLL ir_node *new_d_InstOf(dbg_info *db, ir_node *store, ir_node *objptr,
+ ir_type *type);
/** Constructor for a Raise node.
*
* @param *store The current memory.
* @param *obj A pointer to the Except variable.
*/
-ir_node *new_d_Raise(dbg_info *db, ir_node *store, ir_node *obj);
+FIRM_DLL ir_node *new_d_Raise(dbg_info *db, ir_node *store, ir_node *obj);
/** Constructor for a Bound node.
*
* @param *lower The ir_node that represents the lower bound for the index.
* @param *upper The ir_node that represents the upper bound for the index.
*/
-ir_node *new_d_Bound(dbg_info *db, ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper);
+FIRM_DLL ir_node *new_d_Bound(dbg_info *db, ir_node *store, ir_node *idx,
+ ir_node *lower, ir_node *upper);
/** Constructor for a Pin node.
*
* @param *db A pointer for debug information.
* @param *node The node which value should be pinned.
*/
-ir_node *new_d_Pin(dbg_info *db, ir_node *node);
+FIRM_DLL ir_node *new_d_Pin(dbg_info *db, ir_node *node);
/** Constructor for an ASM pseudo node.
*
* @param *clobber The array of length n_clobber of clobbered registers.
* @param *asm_text The assembler text.
*/
-ir_node *new_d_ASM(dbg_info *db, int arity, ir_node *in[], ir_asm_constraint *inputs,
- int n_outs, ir_asm_constraint *outputs,
- int n_clobber, ident *clobber[], ident *asm_text);
+FIRM_DLL ir_node *new_d_ASM(dbg_info *db, int arity, ir_node *in[],
+ ir_asm_constraint *inputs,
+ int n_outs, ir_asm_constraint *outputs,
+ int n_clobber, ident *clobber[], ident *asm_text);
/*-----------------------------------------------------------------------*/
/* The block oriented interface without debug support */
* @param in An array of control predecessors. The length of
* the array must be 'arity'.
*/
-ir_node *new_Block(int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_Block(int arity, ir_node *in[]);
/** Constructor for a Start node.
*
* Adds the node to the block in current_ir_block.
*
*/
-ir_node *new_Start(void);
+FIRM_DLL ir_node *new_Start(void);
/** Constructor for an End node.
*
* Adds the node to the block in current_ir_block.
*/
-ir_node *new_End(void);
+FIRM_DLL ir_node *new_End(void);
/** Constructor for an EndReg node.
*
* Used to represent regular procedure end in interprocedual view.
* Adds the node to the block in current_ir_block.
*/
-ir_node *new_EndReg(void);
+FIRM_DLL ir_node *new_EndReg(void);
/** Constructor for an EndExpcept node.
*
* Used to represent exceptional procedure end in interprocedural view.
* Adds the node to the block in current_ir_block.
*/
-ir_node *new_EndExcept(void);
+FIRM_DLL ir_node *new_EndExcept(void);
/** Constructor for a Jump node.
*
*
* Jmp represents control flow to a single control successor.
*/
-ir_node *new_Jmp(void);
+FIRM_DLL ir_node *new_Jmp(void);
/** Constructor for an IJmp node.
*
*
* @param *tgt The IR node representing the target address.
*/
-ir_node *new_IJmp(ir_node *tgt);
+FIRM_DLL ir_node *new_IJmp(ir_node *tgt);
/** Constructor for a Break node.
* Break represents control flow to a single control successor just as Jmp.
* behind Call nodes to represent the control flow to called procedures.
* Adds the node to the block in current_ir_block.
*/
-ir_node *new_Break(void);
+FIRM_DLL ir_node *new_Break(void);
/** Constructor for a Cond node.
*
*
* @param *c The conditions parameter.Can be of mode b or I_u.
*/
-ir_node *new_Cond(ir_node *c);
+FIRM_DLL ir_node *new_Cond(ir_node *c);
/** Constructor for a Return node.
*
* @param arity Number of array indices.
* @param *in Array with index inputs to the node.
*/
-ir_node *new_Return(ir_node *store, int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_Return(ir_node *store, int arity, ir_node *in[]);
/** Constructor for a Const node.
*
* @param *con Points to an entry in the constant table. This pointer is
* added to the attributes of the node.
*/
-ir_node *new_Const(tarval *con);
+FIRM_DLL ir_node *new_Const(tarval *con);
/**
* Make a const from a long.
* @param value The value of the constant.
* @return A new const node.
*/
-ir_node *new_Const_long(ir_mode *mode, long value);
+FIRM_DLL ir_node *new_Const_long(ir_mode *mode, long value);
/** Constructor for a Const node.
*
* Derives mode from passed tarval. */
-ir_node *new_Const_type(tarval *con, ir_type *tp);
+FIRM_DLL ir_node *new_Const_type(tarval *con, ir_type *tp);
/** Constructor for a SymConst_type node.
*
* @param kind The kind of the symbolic constant, see the list above
* @param tp The source type of the constant.
*/
-ir_node *new_SymConst_type(ir_mode *mode, union symconst_symbol value, symconst_kind kind, ir_type *tp);
+FIRM_DLL ir_node *new_SymConst_type(ir_mode *mode, union symconst_symbol value,
+ symconst_kind kind, ir_type *tp);
/** Constructor for a SymConst node.
*
* SymConst kind.
* @param kind The kind of the symbolic constant, see the list above
*/
-ir_node *new_SymConst(ir_mode *mode, union symconst_symbol value, symconst_kind kind);
+FIRM_DLL ir_node *new_SymConst(ir_mode *mode, union symconst_symbol value,
+ symconst_kind kind);
/** Constructor for a simpelSel node.
*
* @param *objptr The object from that the Sel operation selects a single attribute out.
* @param *ent The entity to select.
*/
-ir_node *new_simpleSel(ir_node *store, ir_node *objptr, ir_entity *ent);
+FIRM_DLL ir_node *new_simpleSel(ir_node *store, ir_node *objptr,
+ ir_entity *ent);
/** Constructor for a Sel node.
*
* element entity. The constructor copies this array.
* @param *ent The entity to select.
*/
-ir_node *new_Sel(ir_node *store, ir_node *objptr, int arity, ir_node *in[],
- ir_entity *ent);
+FIRM_DLL ir_node *new_Sel(ir_node *store, ir_node *objptr,
+ int arity, ir_node *in[], ir_entity *ent);
/** Constructor for a Call node.
*
* @param *in[] An array with the pointers to the parameters. The constructor copies this array.
* @param *tp Type information of the procedure called.
*/
-ir_node *new_Call(ir_node *store, ir_node *callee, int arity, ir_node *in[],
- ir_type *tp);
+FIRM_DLL ir_node *new_Call(ir_node *store, ir_node *callee,
+ int arity, ir_node *in[], ir_type *tp);
/** Constructor for a Builtin node.
*
* @param *in[] An array with the pointers to the parameters. The constructor copies this array.
* @param *tp Type information of the procedure called.
*/
-ir_node *new_Builtin(ir_node *store, int arity, ir_node *in[],
- ir_builtin_kind kind, ir_type *tp);
+FIRM_DLL ir_node *new_Builtin(ir_node *store, int arity, ir_node *in[],
+ ir_builtin_kind kind, ir_type *tp);
/** Constructor for a CallBegin node.
*
* @param *ptr pointer to the called function
* @param *call associated call operation
*/
-ir_node *new_CallBegin(ir_node *ptr, ir_node *call);
+FIRM_DLL ir_node *new_CallBegin(ir_node *ptr, ir_node *call);
/** Constructor for a Add node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_Add(ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_Add(ir_node *op1, ir_node *op2, ir_mode *mode);
/** Constructor for a Sub node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_Sub(ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_Sub(ir_node *op1, ir_node *op2, ir_mode *mode);
/** Constructor for a Minus node.
*
* @param *op The operand .
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_Minus(ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_Minus(ir_node *op, ir_mode *mode);
/**
* Constructor for a Mul node. Adds the node to the block in current_ir_block.
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_Mul(ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_Mul(ir_node *op1, ir_node *op2, ir_mode *mode);
/**
* Constructor for a Mulh node. Adds the node to the block in current_ir_block.
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_Mulh(ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_Mulh(ir_node *op1, ir_node *op2, ir_mode *mode);
/** Constructor for a Quot node.
*
* @param *mode The mode of the result.
* @param state The pinned state.
*/
-ir_node *new_Quot(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_Quot(ir_node *memop, ir_node *op1, ir_node *op2,
+ ir_mode *mode, op_pin_state state);
/** Constructor for a DivMod node.
*
* @param *mode The mode of the results.
* @param state The pinned state.
*/
-ir_node *new_DivMod(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_DivMod(ir_node *memop, ir_node *op1, ir_node *op2,
+ ir_mode *mode, op_pin_state state);
/** Constructor for a Div node.
*
* @param *mode The mode of the result.
* @param state The pinned state.
*/
-ir_node *new_Div(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_Div(ir_node *memop, ir_node *op1, ir_node *op2,
+ ir_mode *mode, op_pin_state state);
/** Constructor for a remainderless Div node.
*
* @param *mode The mode of the result.
* @param state The pinned state.
*/
-ir_node *new_DivRL(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_DivRL(ir_node *memop, ir_node *op1, ir_node *op2,
+ ir_mode *mode, op_pin_state state);
/** Constructor for a Mod node.
*
* @param *mode The mode of the result.
* @param state The pinned state.
*/
-ir_node *new_Mod(ir_node *memop, ir_node *op1, ir_node *op2, ir_mode *mode, op_pin_state state);
+FIRM_DLL ir_node *new_Mod(ir_node *memop, ir_node *op1, ir_node *op2,
+ ir_mode *mode, op_pin_state state);
/** Constructor for a Abs node.
*
* @param *op The operand
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_Abs(ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_Abs(ir_node *op, ir_mode *mode);
/** Constructor for a And node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_And(ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_And(ir_node *op1, ir_node *op2, ir_mode *mode);
/**
* Constructor for a Or node. Adds the node to the block in current_ir_block.
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_Or(ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_Or(ir_node *op1, ir_node *op2, ir_mode *mode);
/**
* Constructor for a Eor node. Adds the node to the block in current_ir_block.
* @param *op2 The second operand.
* @param *mode The mode of the operands and the results.
*/
-ir_node *new_Eor(ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_Eor(ir_node *op1, ir_node *op2, ir_mode *mode);
/** Constructor for a Not node.
*
* @param *op The operand.
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_Not(ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_Not(ir_node *op, ir_mode *mode);
/** Constructor for a Shl node.
*
* @param *k The number of bits to shift the operand .
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_Shl(ir_node *op, ir_node *k, ir_mode *mode);
+FIRM_DLL ir_node *new_Shl(ir_node *op, ir_node *k, ir_mode *mode);
/**
* Constructor for a Shr node. Adds the node to the block in current_ir_block.
* @param *k The number of bits to shift the operand .
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_Shr(ir_node *op, ir_node *k, ir_mode *mode);
+FIRM_DLL ir_node *new_Shr(ir_node *op, ir_node *k, ir_mode *mode);
/** Constructor for a Shrs node.
*
* @param *k The number of bits to shift the operand .
* @param *mode The mode of the operand and the result.
*/
-ir_node *new_Shrs(ir_node *op, ir_node *k, ir_mode *mode);
+FIRM_DLL ir_node *new_Shrs(ir_node *op, ir_node *k, ir_mode *mode);
/** Constructor for a Rotl node.
*
* @param *k The number of bits to rotate the operand.
* @param *mode The mode of the operand.
*/
-ir_node *new_Rotl(ir_node *op, ir_node *k, ir_mode *mode);
+FIRM_DLL ir_node *new_Rotl(ir_node *op, ir_node *k, ir_mode *mode);
/** Constructor for a Cmp node.
*
* @param *op1 The first operand.
* @param *op2 The second operand.
*/
-ir_node *new_Cmp(ir_node *op1, ir_node *op2);
+FIRM_DLL ir_node *new_Cmp(ir_node *op1, ir_node *op2);
/** Constructor for a Conv node.
*
* @param *op The operand.
* @param *mode The mode of this the operand muss be converted.
*/
-ir_node *new_Conv(ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_Conv(ir_node *op, ir_mode *mode);
/** Constructor for a strict Conv node.
*
* @param *op The operand.
* @param *mode The mode of this the operand muss be converted.
*/
-ir_node *new_strictConv(ir_node *op, ir_mode *mode);
+FIRM_DLL ir_node *new_strictConv(ir_node *op, ir_mode *mode);
/** Constructor for a Cast node.
*
* @param *op The operand.
* @param *to_tp The type of this the operand muss be casted .
*/
-ir_node *new_Cast(ir_node *op, ir_type *to_tp);
+FIRM_DLL ir_node *new_Cast(ir_node *op, ir_type *to_tp);
/** Constructor for a Carry node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_Carry(ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_Carry(ir_node *op1, ir_node *op2, ir_mode *mode);
/** Constructor for a Borrow node.
*
* @param *op2 The second operand.
* @param *mode The mode of the operands and the result.
*/
-ir_node *new_Borrow(ir_node *op1, ir_node *op2, ir_mode *mode);
+FIRM_DLL ir_node *new_Borrow(ir_node *op1, ir_node *op2, ir_mode *mode);
/** Constructor for a Phi node.
*
* @param *in Array with predecessors.
* @param *mode The mode of it's inputs and output.
*/
-ir_node *new_Phi(int arity, ir_node *in[], ir_mode *mode);
+FIRM_DLL ir_node *new_Phi(int arity, ir_node *in[], ir_mode *mode);
/** Constructor for a Load node.
*
* @param *mode The mode of the value to be loaded.
* @param flags Additional flags for alignment, volatility and pin state.
*/
-ir_node *new_Load(ir_node *store, ir_node *addr, ir_mode *mode, ir_cons_flags flags);
+FIRM_DLL ir_node *new_Load(ir_node *store, ir_node *addr, ir_mode *mode,
+ ir_cons_flags flags);
/** Constructor for a Store node.
*
* @param *val The value to write to this variable.
* @param flags Additional flags for alignment, volatility and pin state.
*/
-ir_node *new_Store(ir_node *store, ir_node *addr, ir_node *val, ir_cons_flags flags);
+FIRM_DLL ir_node *new_Store(ir_node *store, ir_node *addr, ir_node *val,
+ ir_cons_flags flags);
/** Constructor for a Alloc node.
*
* @param *alloc_type The type of the allocated variable.
* @param where Where to allocate the variable, either heap_alloc or stack_alloc.
*/
-ir_node *new_Alloc(ir_node *store, ir_node *count, ir_type *alloc_type,
- ir_where_alloc where);
+FIRM_DLL ir_node *new_Alloc(ir_node *store, ir_node *count, ir_type *alloc_type,
+ ir_where_alloc where);
/** Constructor for a Free node.
*
* @param *free_type The type of the freed variable.
* @param where Where the variable was allocated, either heap_alloc or stack_alloc.
*/
-ir_node *new_Free(ir_node *store, ir_node *ptr, ir_node *size,
- ir_type *free_type, ir_where_alloc where);
+FIRM_DLL ir_node *new_Free(ir_node *store, ir_node *ptr, ir_node *size,
+ ir_type *free_type, ir_where_alloc where);
/** Constructor for a Sync node.
*
* @param **in An array of pointers to nodes that produce an output of type
* memory. The constructor copies this array.
*/
-ir_node *new_Sync(int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_Sync(int arity, ir_node *in[]);
/** Constructor for a Proj node.
*
* @param *mode The mode of the value to project.
* @param proj The position of the value in the tuple.
*/
-ir_node *new_Proj(ir_node *arg, ir_mode *mode, long proj);
+FIRM_DLL ir_node *new_Proj(ir_node *arg, ir_mode *mode, long proj);
/** Constructor for a Filter node.
*
* @param *mode The mode of the projected value.
* @param proj The position in the tuple to project from.
*/
-ir_node *new_Filter(ir_node *arg, ir_mode *mode, long proj);
+FIRM_DLL ir_node *new_Filter(ir_node *arg, ir_mode *mode, long proj);
/** Constructor for a defaultProj node.
*
* @param arg A node producing a tuple.
* @param max_proj The end position of the value in the tuple.
*/
-ir_node *new_defaultProj(ir_node *arg, long max_proj);
+FIRM_DLL ir_node *new_defaultProj(ir_node *arg, long max_proj);
/** Constructor for a Tuple node.
*
* @param arity The number of tuple elements.
* @param **in An array containing pointers to the nodes producing the tuple elements.
*/
-ir_node *new_Tuple(int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_Tuple(int arity, ir_node *in[]);
/** Constructor for an Id node.
*
* @param *val The operand to Id.
* @param *mode The mode of *val.
*/
-ir_node *new_Id(ir_node *val, ir_mode *mode);
+FIRM_DLL ir_node *new_Id(ir_node *val, ir_mode *mode);
/** Constructor for a Bad node.
*
* Returns the unique Bad node of the graph. The same as
* get_irg_bad().
*/
-ir_node *new_Bad(void);
+FIRM_DLL ir_node *new_Bad(void);
/** Constructor for a Confirm node.
*
* @param *bound The value to compare against. Must be a firm node, typically a constant.
* @param cmp The compare operation.
*/
-ir_node *new_Confirm(ir_node *val, ir_node *bound, pn_Cmp cmp);
+FIRM_DLL ir_node *new_Confirm(ir_node *val, ir_node *bound, pn_Cmp cmp);
/** Constructor for an Unknown node.
*
*
* @param *m The mode of the unknown value.
*/
-ir_node *new_Unknown(ir_mode *m);
+FIRM_DLL ir_node *new_Unknown(ir_mode *m);
/** Constructor for a NoMem node.
*
* Returns the unique NoMem node of the graph. The same as
* get_irg_no_mem().
*/
-ir_node *new_NoMem(void);
+FIRM_DLL ir_node *new_NoMem(void);
/** Constructor for a Mux node.
*
* @param *ir_false The ir_node that calculates the false result.
* @param *mode The mode of the node (and it_true and ir_false).
*/
-ir_node *new_Mux(ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode);
+FIRM_DLL ir_node *new_Mux(ir_node *sel, ir_node *ir_false, ir_node *ir_true,
+ ir_mode *mode);
/** Constructor for a CopyB node.
*
* @param *src The ir_node that represents the source address.
* @param *data_type The type of the copied data
*/
-ir_node *new_CopyB(ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type);
+FIRM_DLL ir_node *new_CopyB(ir_node *store, ir_node *dst, ir_node *src,
+ ir_type *data_type);
/** Constructor for a InstOf node.
*
* @param *objptr A pointer to a object of a class type.
* @param *type The type of which objptr must be.
*/
-ir_node *new_InstOf(ir_node *store, ir_node *objptr, ir_type *type);
+FIRM_DLL ir_node *new_InstOf(ir_node *store, ir_node *objptr, ir_type *type);
/**Constructor for a Raise node.
*
* @param *store The current memory.
* @param *obj A pointer to the Except variable.
*/
-ir_node *new_Raise(ir_node *store, ir_node *obj);
+FIRM_DLL ir_node *new_Raise(ir_node *store, ir_node *obj);
/** Constructor for a Bound node.
*
* @param *lower The ir_node that represents the lower bound for the index.
* @param *upper The ir_node that represents the upper bound for the index.
*/
-ir_node *new_Bound(ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper);
+FIRM_DLL ir_node *new_Bound(ir_node *store, ir_node *idx, ir_node *lower,
+ ir_node *upper);
/** Constructor for a Pin node.
*
* @param *node The node which value should be pinned.
*/
-ir_node *new_Pin(ir_node *node);
+FIRM_DLL ir_node *new_Pin(ir_node *node);
/** Constructor for an ASM pseudo node.
*
* @param *clobber The array of length n_clobber of clobbered registers.
* @param *asm_text The assembler text.
*/
-ir_node *new_ASM(int arity, ir_node *in[], ir_asm_constraint *inputs,
- int n_outs, ir_asm_constraint *outputs,
- int n_clobber, ident *clobber[], ident *asm_text);
+FIRM_DLL ir_node *new_ASM(int arity, ir_node *in[], ir_asm_constraint *inputs,
+ int n_outs, ir_asm_constraint *outputs,
+ int n_clobber, ident *clobber[], ident *asm_text);
/**
* @brief Constructor for a Dummy node.
* @param *irg the graph to put the node into
* @returns the newly created note
*/
-ir_node *new_rd_Dummy(dbg_info *db, ir_graph *irg, ir_mode *mode);
+FIRM_DLL ir_node *new_rd_Dummy(dbg_info *db, ir_graph *irg, ir_mode *mode);
/**
* @copybrief new_rd_Dummy()
* @param *irg the graph to put the node into
* @returns the newly created note
*/
-ir_node *new_r_Dummy(ir_graph *irg, ir_mode *mode);
+FIRM_DLL ir_node *new_r_Dummy(ir_graph *irg, ir_mode *mode);
/**
* @copybrief new_rd_Dummy()
* @param *mode The mode of the node.
* @returns the newly created note
*/
-ir_node *new_d_Dummy(dbg_info *db, ir_mode *mode);
+FIRM_DLL ir_node *new_d_Dummy(dbg_info *db, ir_mode *mode);
/**
* @copybrief new_rd_Dummy()
* @param *mode The mode of the node.
* @returns the newly created note
*/
-ir_node *new_Dummy(ir_mode *mode);
+FIRM_DLL ir_node *new_Dummy(ir_mode *mode);
/*---------------------------------------------------------------------*/
/* The comfortable interface. */
* Phi node construction.
* This constructor can only be used if the graph is in state_building.
*/
-ir_node *new_d_immBlock(dbg_info *db);
-ir_node *new_immBlock(void);
+FIRM_DLL ir_node *new_d_immBlock(dbg_info *db);
+FIRM_DLL ir_node *new_immBlock(void);
/** Create an immature PartBlock.
*
* This constructor can only be used if the graph is in
* state_building.
*/
-ir_node *new_d_immPartBlock(dbg_info *db, ir_node *pred_jmp);
-ir_node *new_immPartBlock(ir_node *pred_jmp);
+FIRM_DLL ir_node *new_d_immPartBlock(dbg_info *db, ir_node *pred_jmp);
+FIRM_DLL ir_node *new_immPartBlock(ir_node *pred_jmp);
/** Add a control flow edge to an immature block. */
-void add_immBlock_pred(ir_node *immblock, ir_node *jmp);
+FIRM_DLL void add_immBlock_pred(ir_node *immblock, ir_node *jmp);
/** Finalize a Block node, when all control flows are known. */
-void mature_immBlock(ir_node *block);
+FIRM_DLL void mature_immBlock(ir_node *block);
#define mature_cur_block() mature_immBlock(get_cur_block());
* @param pos The position/id of the local variable.
* @param *mode The mode of the value to get.
*/
-ir_node *get_d_value(dbg_info *db, int pos, ir_mode *mode);
-ir_node *get_value(int pos, ir_mode *mode);
+FIRM_DLL ir_node *get_d_value(dbg_info *db, int pos, ir_mode *mode);
+FIRM_DLL ir_node *get_value(int pos, ir_mode *mode);
/** Remark a new definition of a variable.
*
* @param pos The position/id of the local variable.
* @param *value The new value written to the local variable.
*/
-void set_value(int pos, ir_node *value);
+FIRM_DLL void set_value(int pos, ir_node *value);
/**
* Find the value number for a node in the current block.
* @return the value number of the value or -1 if this value has
* no value number in the current block.
*/
-int find_value(ir_node *value);
+FIRM_DLL int find_value(ir_node *value);
/** Get the current memory state.
*
* state. This call automatically inserts Phi nodes for the memory
* state value.
*/
-ir_node *get_store(void);
+FIRM_DLL ir_node *get_store(void);
/** Remark a new definition of the memory state.
*
*
* @param *store The new memory state.
*/
-void set_store(ir_node *store);
+FIRM_DLL void set_store(ir_node *store);
/** keep this node alive even if End is not control-reachable from it
*
* @param ka The node to keep alive.
*/
-void keep_alive(ir_node *ka);
+FIRM_DLL void keep_alive(ir_node *ka);
/** Returns the frame type of the current graph */
-ir_type *get_cur_frame_type(void);
+FIRM_DLL ir_type *get_cur_frame_type(void);
/* --- initialize and finalize IR construction --- */
*
* This also remarks, the construction of types is finished,
* e.g., that no more subtypes will be added. */
-void irp_finalize_cons(void);
+FIRM_DLL void irp_finalize_cons(void);
-/* --- Initialization --- */
+#include "end.h"
#endif
#define FIRM_ANA_IRCONSCONFIRM_H
#include "firm_types.h"
+#include "begin.h"
/**
* Inject Confirm nodes into a graph.
* nodes too. The current solution is to remove Confirms at a later
* pass.
*/
-void construct_confirms(ir_graph *irg);
+FIRM_DLL void construct_confirms(ir_graph *irg);
/**
* Creates an ir_graph pass for construct_confirms().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *construct_confirms_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *construct_confirms_pass(const char *name);
/**
* Remove all Confirm nodes from a graph.
* Note that local_optimize() can handle this if
* the remove Confirm node setting is on (set_opt_remove_Confirm(1)).
*/
-void remove_confirms(ir_graph *irg);
+FIRM_DLL void remove_confirms(ir_graph *irg);
/**
* Creates an ir_graph pass for remove_confirms().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *remove_confirms_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *remove_confirms_pass(const char *name);
+
+#include "end.h"
#endif
#define FIRM_ANA_IRDOM_H
#include "firm_types.h"
-
+#include "begin.h"
/** Accessing the dominator data structure.
*
*
* If the block is not reachable from Start, returns a Bad node.
*/
-ir_node *get_Block_idom(const ir_node *bl);
-void set_Block_idom(ir_node *bl, ir_node *n);
+FIRM_DLL ir_node *get_Block_idom(const ir_node *bl);
+FIRM_DLL void set_Block_idom(ir_node *bl, ir_node *n);
-int get_Block_dom_depth(const ir_node *bl);
-void set_Block_dom_depth(ir_node *bl, int depth);
+FIRM_DLL int get_Block_dom_depth(const ir_node *bl);
+FIRM_DLL void set_Block_dom_depth(ir_node *bl, int depth);
-int get_Block_dom_pre_num(const ir_node *bl);
-void set_Block_dom_pre_num(ir_node *bl, int num);
+FIRM_DLL int get_Block_dom_pre_num(const ir_node *bl);
+FIRM_DLL void set_Block_dom_pre_num(ir_node *bl, int num);
/** Accessing the post dominator data structure.
*
*
* If the block is not reachable from End, returns a Bad node.
*/
-ir_node *get_Block_ipostdom(const ir_node *bl);
-void set_Block_ipostdom(ir_node *bl, ir_node *n);
+FIRM_DLL ir_node *get_Block_ipostdom(const ir_node *bl);
+FIRM_DLL void set_Block_ipostdom(ir_node *bl, ir_node *n);
-int get_Block_postdom_depth(const ir_node *bl);
-void set_Block_postdom_depth(ir_node *bl, int depth);
+FIRM_DLL int get_Block_postdom_depth(const ir_node *bl);
+FIRM_DLL void set_Block_postdom_depth(ir_node *bl, int depth);
-int get_Block_postdom_pre_num(const ir_node *bl);
-void set_Block_postdom_pre_num(ir_node *bl, int num);
+FIRM_DLL int get_Block_postdom_pre_num(const ir_node *bl);
+FIRM_DLL void set_Block_postdom_pre_num(ir_node *bl, int num);
/**
* Get the pre-order number of a block resulting from a
* @param bl The block.
* @return The pre-order number.
*/
-unsigned get_Block_dom_tree_pre_num(const ir_node *bl);
-unsigned get_Block_pdom_tree_pre_num(const ir_node *bl);
+FIRM_DLL unsigned get_Block_dom_tree_pre_num(const ir_node *bl);
+FIRM_DLL unsigned get_Block_pdom_tree_pre_num(const ir_node *bl);
/**
* Get the largest pre-order number found in the subtree of the
* @param bl The block.
* @return The largest pre-order number of block's dominator subtree.
*/
-unsigned get_Block_dom_max_subtree_pre_num(const ir_node *bl);
-unsigned get_Block_pdom_max_subtree_pre_num(const ir_node *bl);
+FIRM_DLL unsigned get_Block_dom_max_subtree_pre_num(const ir_node *bl);
+FIRM_DLL unsigned get_Block_pdom_max_subtree_pre_num(const ir_node *bl);
/**
* Get the first node in the list of nodes dominated by a given block.
* @param bl The block for which to get the first node dominated by @c bl.
* @return The first node dominated by @p bl.
*/
-ir_node *get_Block_dominated_first(const ir_node *bl);
-ir_node *get_Block_postdominated_first(const ir_node *bl);
+FIRM_DLL ir_node *get_Block_dominated_first(const ir_node *bl);
+FIRM_DLL ir_node *get_Block_postdominated_first(const ir_node *bl);
/**
* Get the next node in a list of nodes which are dominated by some
* @param dom The previous node.
* @return The next node in this list or NULL if it was the last.
*/
-ir_node *get_Block_dominated_next(const ir_node *dom);
-ir_node *get_Block_postdominated_next(const ir_node *dom);
+FIRM_DLL ir_node *get_Block_dominated_next(const ir_node *dom);
+FIRM_DLL ir_node *get_Block_postdominated_next(const ir_node *dom);
/**
* Iterate over all nodes which are immediately dominated by a given
*
* @return 1, if @p a dominates @p b, else 0.
*/
-int block_dominates(const ir_node *a, const ir_node *b);
+FIRM_DLL int block_dominates(const ir_node *a, const ir_node *b);
/**
* Check, if a block strictly dominates another block, i.e. a != b.
*
* @return 1, if @p a strictly dominates @p b, else 0.
*/
-int block_strictly_dominates(const ir_node *a, const ir_node *b);
+FIRM_DLL int block_strictly_dominates(const ir_node *a, const ir_node *b);
/**
* Returns the smallest common dominator block of two nodes.
* @param b Another node.
* @return The first block dominating @p a and @p b
*/
-ir_node *node_smallest_common_dominator(ir_node *a, ir_node *b);
+FIRM_DLL ir_node *node_smallest_common_dominator(ir_node *a, ir_node *b);
/**
* Returns the smallest common dominator block of all users of a node
* @param handle_phi 1 if Phis should be handled different
* @return The first block dominating all users of @p irn
*/
-ir_node *node_users_smallest_common_dominator(ir_node *irn, int handle_phi);
+FIRM_DLL ir_node *node_users_smallest_common_dominator(ir_node *irn,
+ int handle_phi);
/**
* Check, if a block post dominates another block.
*
* @return 1, if @p a post dominates @p b, else 0.
*/
-int block_postdominates(const ir_node *a, const ir_node *b);
+FIRM_DLL int block_postdominates(const ir_node *a, const ir_node *b);
/**
* Check, if a block strictly post dominates another block, i.e. a != b.
*
* @return 1, if @p a strictly post dominates @p b, else 0.
*/
-int block_strictly_postdominates(const ir_node *a, const ir_node *b);
+FIRM_DLL int block_strictly_postdominates(const ir_node *a, const ir_node *b);
/**
* Visit all nodes in the dominator subtree of a given node.
* @param post The post-visitor callback.
* @param env Some custom data passed to the visitors.
*/
-void dom_tree_walk(ir_node *n, irg_walk_func *pre,
- irg_walk_func *post, void *env);
+FIRM_DLL void dom_tree_walk(ir_node *n, irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/**
* Visit all nodes in the post dominator subtree of a given node.
* @param post The post-visitor callback.
* @param env Some custom data passed to the visitors.
*/
-void postdom_tree_walk(ir_node *n, irg_walk_func *pre,
- irg_walk_func *post, void *env);
+FIRM_DLL void postdom_tree_walk(ir_node *n, irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/**
* Walk over the dominator tree of an irg starting at the root.
* @param post A post-visitor to call.
* @param env Some private data to give to the visitors.
*/
-void dom_tree_walk_irg(ir_graph *irg, irg_walk_func *pre,
- irg_walk_func *post, void *env);
+FIRM_DLL void dom_tree_walk_irg(ir_graph *irg, irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/**
* Walk over the post dominator tree of an irg starting at the root.
* @param post A post-visitor to call.
* @param env Some private data to give to the visitors.
*/
-void postdom_tree_walk_irg(ir_graph *irg, irg_walk_func *pre,
- irg_walk_func *post, void *env);
+FIRM_DLL void postdom_tree_walk_irg(ir_graph *irg, irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/* ------------ Building and Removing the dominator data structure ----------- */
* Also constructs outs information. As this information is correct after
* the run does not free the outs information.
*/
-void compute_doms(ir_graph *irg);
+FIRM_DLL void compute_doms(ir_graph *irg);
/** Computes the dominator trees on demand, @see compute_doms(). */
-void assure_doms(ir_graph *irg);
+FIRM_DLL void assure_doms(ir_graph *irg);
/** Computes the post dominator trees.
*
* Also constructs outs information. As this information is correct after
* the run does not free the outs information.
*/
-void compute_postdoms(ir_graph *irg);
+FIRM_DLL void compute_postdoms(ir_graph *irg);
/** Computes the dominator trees on demand */
-void assure_postdoms(ir_graph *irg);
+FIRM_DLL void assure_postdoms(ir_graph *irg);
/** Frees the dominator data structures. Sets the flag in irg to "dom_none". */
-void free_dom(ir_graph *irg);
+FIRM_DLL void free_dom(ir_graph *irg);
+
+/**
+ * Frees the post dominator data structures.
+ * Sets the flag in irg to "dom_none".
+ */
+FIRM_DLL void free_postdom(ir_graph *irg);
-/** Frees the post dominator data structures. Sets the flag in irg to "dom_none". */
-void free_postdom(ir_graph *irg);
+#include "end.h"
#endif
#include <stdio.h>
#include "firm_types.h"
+#include "begin.h"
/**
* Symbolic names for the different dumping colors.
typedef int (*DUMP_EDGE_VCGATTR_FUNC)(FILE *F, ir_node *node, int to);
/** Set the ir graph dump hook. */
-void set_dump_ir_graph_hook(DUMP_IR_GRAPH_FUNC hook);
+FIRM_DLL void set_dump_ir_graph_hook(DUMP_IR_GRAPH_FUNC hook);
/** Set the node_vcgattr hook. */
-void set_dump_node_vcgattr_hook(DUMP_NODE_VCGATTR_FUNC hook);
+FIRM_DLL void set_dump_node_vcgattr_hook(DUMP_NODE_VCGATTR_FUNC hook);
/** Set the edge_vcgattr hook. */
-void set_dump_edge_vcgattr_hook(DUMP_EDGE_VCGATTR_FUNC hook);
+FIRM_DLL void set_dump_edge_vcgattr_hook(DUMP_EDGE_VCGATTR_FUNC hook);
typedef int (*DUMP_NODE_EDGE_FUNC)(FILE *f, ir_node *node);
* Set the hook to be called to dump additional edges to a node.
* @param func The hook to be called.
*/
-void set_dump_node_edge_hook(DUMP_NODE_EDGE_FUNC func);
+FIRM_DLL void set_dump_node_edge_hook(DUMP_NODE_EDGE_FUNC func);
/**
* Get the additional edge dump hook.
* @return The current additional edge dump hook.]
*/
-DUMP_NODE_EDGE_FUNC get_dump_node_edge_hook(void);
+FIRM_DLL DUMP_NODE_EDGE_FUNC get_dump_node_edge_hook(void);
/**
* Set the hook to be called to dump additional edges to a block.
* @param func The hook to be called.
*/
-void set_dump_block_edge_hook(DUMP_NODE_EDGE_FUNC func);
+FIRM_DLL void set_dump_block_edge_hook(DUMP_NODE_EDGE_FUNC func);
/**
* Get the additional block edge dump hook.
* @return The current additional block edge dump hook.
*/
-DUMP_NODE_EDGE_FUNC get_dump_block_edge_hook(void);
+FIRM_DLL DUMP_NODE_EDGE_FUNC get_dump_block_edge_hook(void);
/** Dump a firm graph.
*
*
* @see turn_off_edge_labels()
*/
-void dump_ir_graph(ir_graph *irg, const char *suffix);
-void dump_ir_graph_file(ir_graph *irg, FILE *out);
+FIRM_DLL void dump_ir_graph(ir_graph *irg, const char *suffix);
+FIRM_DLL void dump_ir_graph_file(ir_graph *irg, FILE *out);
/** Dump a firm graph without explicit block nodes.
*
*
* @see turn_off_edge_labels()
*/
-void dump_ir_block_graph(ir_graph *irg, const char *suffix);
+FIRM_DLL void dump_ir_block_graph(ir_graph *irg, const char *suffix);
/**
* Does the same as dump_ir_block_graph but dumps to a stream
* @see dump_ir_block_graph()
*/
-void dump_ir_block_graph_file(ir_graph *irg, FILE *out);
+FIRM_DLL void dump_ir_block_graph_file(ir_graph *irg, FILE *out);
/** Dump a firm graph without explicit block nodes but grouped in extended blocks.
*
*
* @see turn_off_edge_labels()
*/
-void dump_ir_extblock_graph(ir_graph *irg, const char *suffix);
+FIRM_DLL void dump_ir_extblock_graph(ir_graph *irg, const char *suffix);
/**
* Does the same as dump_ir_extrblock_graph but dumps to a stream
* @see dump_ir_extblock_graph()
*/
-void dump_ir_extblock_graph_file(ir_graph *irg, FILE *out);
+FIRM_DLL void dump_ir_extblock_graph_file(ir_graph *irg, FILE *out);
/** Dumps all graphs in interprocedural view to a file named All_graphs\<suffix\>.vcg.
*
* @param suffix A suffix for the file name.
*/
-void dump_all_cg_block_graph(const char *suffix);
+FIRM_DLL void dump_all_cg_block_graph(const char *suffix);
/** Dumps a firm graph and all the type information needed for Calls,
* Sels, ... in this graph.
*
* @see turn_off_edge_labels()
*/
-void dump_ir_graph_w_types(ir_graph *irg, const char *suffix);
+FIRM_DLL void dump_ir_graph_w_types(ir_graph *irg, const char *suffix);
/**
* Does the same as dump_ir_graph_w_types but dumps to a stream
* @see dump_ir_graph_w_types()
*/
-void dump_ir_graph_w_types_file(ir_graph *irg, FILE *out);
+FIRM_DLL void dump_ir_graph_w_types_file(ir_graph *irg, FILE *out);
/** Dumps a firm graph and all the type information needed for Calls,
* Sels, ... in this graph.
*
* @see turn_off_edge_labels()
*/
-void dump_ir_block_graph_w_types(ir_graph *irg, const char *suffix);
+FIRM_DLL void dump_ir_block_graph_w_types(ir_graph *irg, const char *suffix);
/**
* same as @see dump_ir_block_graph_w_types() but dumps to a stream
* @param irg the graph to dump
* @param out stream to dump to
*/
-void dump_ir_block_graph_w_types_file(ir_graph *irg, FILE *out);
+FIRM_DLL void dump_ir_block_graph_w_types_file(ir_graph *irg, FILE *out);
/** The type of a dump function that is called for each graph.
*
*
* @see turn_off_edge_labels()
*/
-void dump_all_ir_graphs(dump_graph_func *dump_graph, const char *suffix);
+FIRM_DLL void dump_all_ir_graphs(dump_graph_func *dump_graph,
+ const char *suffix);
/**
* Creates an ir_prog pass for dump_all_ir_graphs().
*
* @return the newly created ir_prog pass
*/
-ir_prog_pass_t *dump_all_ir_graph_pass(
+FIRM_DLL ir_prog_pass_t *dump_all_ir_graph_pass(
const char *name, dump_graph_func *dump_graph, const char *suffix);
/**
*
* @see turn_off_edge_labels()
*/
-void dump_cfg(ir_graph *irg, const char *suffix);
+FIRM_DLL void dump_cfg(ir_graph *irg, const char *suffix);
/**
* Dump a node and its predecessors forming a subgraph to a vcg file.
* @return
* A file containing the subgraph in vcg format.
*/
-void dump_subgraph(ir_node *root, int depth, const char *suffix);
+FIRM_DLL void dump_subgraph(ir_node *root, int depth, const char *suffix);
/* **************************************************************************** */
/* CALLGRAPH DUMPERS */
*
* @see dump_callgraph_loop_tree(const char *suffix)
*/
-void dump_callgraph(const char *suffix);
+FIRM_DLL void dump_callgraph(const char *suffix);
/* **************************************************************************** */
/* TYPEGRAPH DUMPERS */
*
* @see turn_off_edge_labels()
*/
-void dump_type_graph(ir_graph *irg, const char *suffix);
+FIRM_DLL void dump_type_graph(ir_graph *irg, const char *suffix);
/**
* Dumps all type information.
*
* @see turn_off_edge_labels()
*/
-void dump_all_types(const char *suffix);
+FIRM_DLL void dump_all_types(const char *suffix);
/**
* Dumps the class hierarchy with or without entities.
* is dumped along with the entities.
* Dumps to a file class_hierarchy.vcg
*/
-void dump_class_hierarchy(int entities, const char *suffix);
+FIRM_DLL void dump_class_hierarchy(int entities, const char *suffix);
/* **************************************************************************** */
/* LOOPTREE DUMPERS */
* @param irg Dump the loop tree for this graph.
* @param suffix A suffix for the file name.
*/
-void dump_loop_tree(ir_graph *irg, const char *suffix);
+FIRM_DLL void dump_loop_tree(ir_graph *irg, const char *suffix);
/** Dumps the firm nodes in the sub-loop-tree of loop to a graph.
*
* @param l Dump the loop tree for this loop.
* @param suffix A suffix for the file name.
*/
-void dump_loop(ir_loop *l, const char *suffix);
+FIRM_DLL void dump_loop(ir_loop *l, const char *suffix);
/** Dumps the loop tree over the call graph.
*
*
* @param suffix A suffix for the file name.
*/
-void dump_callgraph_loop_tree(const char *suffix);
+FIRM_DLL void dump_callgraph_loop_tree(const char *suffix);
/* **************************************************************************** */
/* **************************************************************************** */
-/** Write the irnode and all its attributes to the file passed.
- * */
-int dump_irnode_to_file(FILE *f, ir_node *n);
+/** Write the irnode and all its attributes to the file passed. */
+FIRM_DLL int dump_irnode_to_file(FILE *f, ir_node *n);
-/** Write the irnode and all its attributes to stdout.
- * */
-void dump_irnode(ir_node *n);
+/** Write the irnode and all its attributes to stdout. */
+FIRM_DLL void dump_irnode(ir_node *n);
/** Write the graph and all its attributes to the file passed.
- * Does not write the nodes.
- * */
-void dump_graph_to_file(FILE *F, ir_graph *irg);
+ * Does not write the nodes. */
+FIRM_DLL void dump_graph_to_file(FILE *F, ir_graph *irg);
/** Write the graph and all its attributes to stdout.
- * Does not write the nodes.
- * */
-void dump_graph(ir_graph *g);
+ * Does not write the nodes. */
+FIRM_DLL void dump_graph(ir_graph *g);
/** Dump graph information as text.
* The file name is the graph name (get_entity_name()), appended by
* \<suffix\>.txt.
*/
-void dump_graph_as_text(ir_graph *irg, const char *suffix);
+FIRM_DLL void dump_graph_as_text(ir_graph *irg, const char *suffix);
/** Verbosity for text dumpers */
/** Write the entity and all its attributes to the passed file.
* */
-void dump_entity_to_file(FILE *F, ir_entity *ent, unsigned verbosity);
+FIRM_DLL void dump_entity_to_file(FILE *F, ir_entity *ent, unsigned verbosity);
/** Write the entity and all its attributes to the stdout.
*
* Calls dump_entity_to_file(). */
-void dump_entity(ir_entity *ent);
+FIRM_DLL void dump_entity(ir_entity *ent);
-/** Write the type and all its attributes to the file passed.
- * */
-void dump_type_to_file(FILE *f, ir_type *tp, dump_verbosity verbosity);
+/** Write the type and all its attributes to the file passed. */
+FIRM_DLL void dump_type_to_file(FILE *f, ir_type *tp, dump_verbosity verbosity);
-/** Write the type and all its attributes to stdout.
- * */
-void dump_type(ir_type *tp);
+/** Write the type and all its attributes to stdout. */
+void dump_type(ir_type *tp);
/** Dump type information as text.
* if the program name is not set, appended by \<suffix\>-types.txt.
* For verbosity see the documentation of the verbosity flags above.
*/
-void dump_types_as_text(unsigned verbosity, const char *suffix);
+FIRM_DLL void dump_types_as_text(unsigned verbosity, const char *suffix);
/** Dumps all global variables as text.
*
* if the program name is not set, appended by \<suffix\>-globals.txt.
* For verbosity see the documentation of the verbosity flags above.
*/
-void dump_globals_as_text(unsigned verbosity, const char *suffix);
+FIRM_DLL void dump_globals_as_text(unsigned verbosity, const char *suffix);
/* **************************************************************************** */
/* FLAGS */
* @param name The prefix of the name (not the ld_name) of the method
* entity to be dumped.
*/
-void only_dump_method_with_name(ident *name);
+FIRM_DLL void only_dump_method_with_name(ident *name);
/** Returns the prefix filter set with only_dump_method_with_name(). */
-ident *get_dump_file_filter_ident(void);
+FIRM_DLL ident *get_dump_file_filter_ident(void);
/** Returns true if dump file filter is not set, or if it is a
* prefix of name. */
-int is_filtered_dump_name(ident *name);
+FIRM_DLL int is_filtered_dump_name(ident *name);
/** Sets the vcg flag "display_edge_labels" to no.
*
* This is necessary as xvcg and aisee both fail to display graphs
* with self-edges if these edges have labels.
*/
-void turn_off_edge_labels(void);
+FIRM_DLL void turn_off_edge_labels(void);
/**
* If set to non-zero constants will be replicated for every use. In non
* edges are dumped, as outs, loop, ...
* Default setting: false.
*/
-void dump_consts_local(int flag);
+FIRM_DLL void dump_consts_local(int flag);
/**
* if set to non-zero node idx will be added to node labels
*/
-void dump_node_idx_label(int flag);
+FIRM_DLL void dump_node_idx_label(int flag);
/** Turns off dumping the values of constant entities. Makes type graphs
* better readable.
*/
-void dump_constant_entity_values(int flag);
+FIRM_DLL void dump_constant_entity_values(int flag);
/** Turns on dumping the edges from the End node to nodes to be kept
* alive.
*/
-void dump_keepalive_edges(int flag);
-int get_opt_dump_keepalive_edges(void);
+FIRM_DLL void dump_keepalive_edges(int flag);
+FIRM_DLL int get_opt_dump_keepalive_edges(void);
/** Turns on dumping the out edges starting from the Start block in
* dump_ir_graph.
*
* To test the consistency of the out data structure.
*/
-void dump_out_edges(int flag);
+FIRM_DLL void dump_out_edges(int flag);
-/** If this flag is set the dumper dumps edges to immediate dominator in cfg.
- */
-void dump_dominator_information(int flag);
+/** If this flag is set the dumper dumps edges to immediate dominator in cfg. */
+FIRM_DLL void dump_dominator_information(int flag);
/** If this flag is set the dumper dumps loop nodes and edges from
* these nodes to the contained ir nodes.
*
* If the loops are interprocedural nodes can be missing.
*/
-void dump_loop_information(int flag);
+FIRM_DLL void dump_loop_information(int flag);
/** If set and backedge info is computed, backedges are dumped dashed
* and as vcg 'backedge' construct.
*
* Default: set.
*/
-void dump_backedge_information(int flag);
+FIRM_DLL void dump_backedge_information(int flag);
/** Dump the information of type field specified in ana/irtypeinfo.h.
*
* If the flag is set, the type name is output in [] in the node label,
* else it is output as info.
*/
-void set_opt_dump_analysed_type_info(int flag);
+FIRM_DLL void set_opt_dump_analysed_type_info(int flag);
/**
* dump iredges (new style out edges)
*/
-void dump_new_edges(int flag);
+FIRM_DLL void dump_new_edges(int flag);
/** Write the address of a node into the vcg info.
*
* This is off per default for automatic comparisons of
* vcg graphs -- these will differ in the pointer values!
*/
-void dump_pointer_values_to_info(int flag);
+FIRM_DLL void dump_pointer_values_to_info(int flag);
/** Dumps ld_names of entities instead of there names.
*
* This option is on per default.
*/
-void dump_ld_names(int flag);
+FIRM_DLL void dump_ld_names(int flag);
/** Dumps all graph anchor nodes, even if they
* are dead.
*
* This option is off per default.
*/
-void dump_all_anchors(int flag);
+FIRM_DLL void dump_all_anchors(int flag);
/** Dumps a MacroBlock edge from every Block to its
* MacroBlock header.
*
* This option is off per default.
*/
-void dump_macroblock_edges(int flag);
+FIRM_DLL void dump_macroblock_edges(int flag);
/** Dumps a marked blocks with a asterisk in the title.
*
* This option is off per default.
*/
-void dump_block_marker_in_title(int flag);
+FIRM_DLL void dump_block_marker_in_title(int flag);
/** A node info dumper callback. */
typedef void (dump_node_info_cb_t)(void *data, FILE *f, const ir_node *n);
*
* @note This functionality is only available, if Firm hooks are enabled (default).
*/
-void *dump_add_node_info_callback(dump_node_info_cb_t *cb, void *data);
+FIRM_DLL void *dump_add_node_info_callback(dump_node_info_cb_t *cb, void *data);
/**
* Remove a previously added info dumper callback.
*
* @param handle the callback handle returned from dump_add_node_info_callback()
*/
-void dump_remv_node_info_callback(void *handle);
+FIRM_DLL void dump_remv_node_info_callback(void *handle);
+
+#include "end.h"
#endif
#ifndef FIRM_IR_IREDGEKINDS_H
#define FIRM_IR_IREDGEKINDS_H
+#include "begin.h"
+
/** Supported Edge kinds. */
enum _ir_edge_kind_t {
EDGE_KIND_NORMAL, /**< Normal data flow edges. */
typedef enum _ir_edge_kind_t ir_edge_kind_t;
+#include "end.h"
+
#endif
#include "firm_types.h"
#include "iredgekinds.h"
+#include "begin.h"
/**
* Get the first edge pointing to some node.
* @param kind The kind of the edge.
* @return The first out edge that points to this node.
*/
-const ir_edge_t *get_irn_out_edge_first_kind(const ir_node *irn, ir_edge_kind_t kind);
+FIRM_DLL const ir_edge_t *get_irn_out_edge_first_kind(const ir_node *irn,
+ ir_edge_kind_t kind);
/**
* Get the next edge in the out list of some node.
* @param last The last out edge you have seen.
* @return The next out edge in @p irn 's out list after @p last.
*/
-const ir_edge_t *get_irn_out_edge_next(const ir_node *irn, const ir_edge_t *last);
+FIRM_DLL const ir_edge_t *get_irn_out_edge_next(const ir_node *irn,
+ const ir_edge_t *last);
/**
* A convenience iteration macro over all out edges of a node.
* @param edge The edge.
* @return The source node of that edge.
*/
-ir_node *get_edge_src_irn(const ir_edge_t *edge);
+FIRM_DLL ir_node *get_edge_src_irn(const ir_edge_t *edge);
/**
* Get the position of an edge.
* @param edge The edge.
* @return The position in the in array of that edges source.
*/
-int get_edge_src_pos(const ir_edge_t *edge);
+FIRM_DLL int get_edge_src_pos(const ir_edge_t *edge);
/**
* Get the edge object of an outgoing edge at a node.
* @return The corresponding edge object or NULL,
* if no such edge exists.
*/
-const ir_edge_t *get_irn_edge_kind(ir_graph *irg, const ir_node *irn, int pos, ir_edge_kind_t kind);
+FIRM_DLL const ir_edge_t *get_irn_edge_kind(ir_graph *irg, const ir_node *irn,
+ int pos, ir_edge_kind_t kind);
/**
* Get the number of registered out edges for a specific kind.
* @param irn The node.
* @param kind The kind.
*/
-int get_irn_n_edges_kind(const ir_node *irn, ir_edge_kind_t kind);
+FIRM_DLL int get_irn_n_edges_kind(const ir_node *irn, ir_edge_kind_t kind);
/**
* Check, if the out edges are activated.
*
* @return 1, if the edges are present for the given irg, 0 if not.
*/
-int edges_activated_kind(const ir_graph *irg, ir_edge_kind_t kind);
+FIRM_DLL int edges_activated_kind(const ir_graph *irg, ir_edge_kind_t kind);
/**
* Activate the edges for an irg.
* @param irg The graph to activate the edges for.
* @param kind The edge kind.
*/
-void edges_activate_kind(ir_graph *irg, ir_edge_kind_t kind);
+FIRM_DLL void edges_activate_kind(ir_graph *irg, ir_edge_kind_t kind);
/**
* Deactivate the edges for an irg.
* @param irg The graph.
* @param kind The edge kind.
*/
-void edges_deactivate_kind(ir_graph *irg, ir_edge_kind_t kind);
+FIRM_DLL void edges_deactivate_kind(ir_graph *irg, ir_edge_kind_t kind);
/**
* Reroute edges of a specified kind from an old node to
* @param kind the edge kind
* @param irg the graph on which the rerouting occurs
*/
-void edges_reroute_kind(ir_node *old, ir_node *nw, ir_edge_kind_t kind, ir_graph *irg);
+FIRM_DLL void edges_reroute_kind(ir_node *old, ir_node *nw, ir_edge_kind_t kind,
+ ir_graph *irg);
/**
* Verifies the out edges of graph @p irg.
* @return 1 if a problem was found, 0 otherwise
*/
-int edges_verify(ir_graph *irg);
+FIRM_DLL int edges_verify(ir_graph *irg);
/**
* veriy a certrain kind of out edges of graph @p irg.
* @returns 1 if a problem was found, 0 otherwise
*/
-int edges_verify_kind(ir_graph *irg, ir_edge_kind_t kind);
+FIRM_DLL int edges_verify_kind(ir_graph *irg, ir_edge_kind_t kind);
/**
* Set edge verification flag.
*/
-void edges_init_dbg(int do_dbg);
+FIRM_DLL void edges_init_dbg(int do_dbg);
/**
* Creates an ir_graph pass for edges_verify().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *irg_verify_edges_pass(const char *name, unsigned assert_on_problem);
+FIRM_DLL ir_graph_pass_t *irg_verify_edges_pass(const char *name,
+ unsigned assert_on_problem);
-const ir_edge_t *get_irn_edge(ir_graph *irg, const ir_node *src, int pos);
+FIRM_DLL const ir_edge_t *get_irn_edge(ir_graph *irg, const ir_node *src,
+ int pos);
#define edges_reroute(old, nw, irg) edges_reroute_kind(old, nw, EDGE_KIND_NORMAL, irg)
#define edges_activated(irg) (edges_activated_kind(irg, EDGE_KIND_NORMAL) && edges_activated_kind(irg, EDGE_KIND_BLOCK))
*
* @param irg The graph to activate the edges for.
*/
-void edges_activate(ir_graph *irg);
+FIRM_DLL void edges_activate(ir_graph *irg);
/**
* Deactivate data and block edges for an irg.
* additionally deactivated.
* @param irg The graph.
*/
-void edges_deactivate(ir_graph *irg);
+FIRM_DLL void edges_deactivate(ir_graph *irg);
/**
* Ensure that edges are activated.
*
* @return 0 if edges was deactivated before the call, 1 else
*/
-int edges_assure(ir_graph *irg);
+FIRM_DLL int edges_assure(ir_graph *irg);
/**
* Ensure that edges of a given kind are activated.
*
* @return 0 if edges was deactivated before the call, 1 else
*/
-int edges_assure_kind(ir_graph *irg, ir_edge_kind_t kind);
+FIRM_DLL int edges_assure_kind(ir_graph *irg, ir_edge_kind_t kind);
-void edges_node_deleted(ir_node *irn, ir_graph *irg);
+FIRM_DLL void edges_node_deleted(ir_node *irn, ir_graph *irg);
/**
* Notify normal and block edges.
*/
-void edges_notify_edge(ir_node *src, int pos, ir_node *tgt, ir_node *old_tgt, ir_graph *irg);
+FIRM_DLL void edges_notify_edge(ir_node *src, int pos, ir_node *tgt,
+ ir_node *old_tgt, ir_graph *irg);
/**
* Walks only over Block nodes in the graph. Uses the block visited
* @param post the post visit function
* @param env the environment for the walker
*/
-void irg_block_edges_walk(ir_node *block, irg_walk_func *pre, irg_walk_func *post, void *env);
+FIRM_DLL void irg_block_edges_walk(ir_node *block, irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/**
* Reset the user's private data at offset 'offset'
* @param offset offset of the private data inside the edge
* @param size length of the private data inside the edge
*/
-void edges_reset_private_data(ir_graph *irg, int offset, unsigned size);
+FIRM_DLL void edges_reset_private_data(ir_graph *irg, int offset,
+ unsigned size);
+
+#include "end.h"
#endif
#include "firm_types.h"
#include "execfreq.h"
+#include "begin.h"
/** Flags for extended basic block state. */
typedef enum {
* Checks whether a pointer points to a extended basic block.
* Intern version for libFirm.
*/
-int is_ir_extbb(const void *thing);
+FIRM_DLL int is_ir_extbb(const void *thing);
/**
* Compute the extended basic blocks for a graph.
*/
-void compute_extbb(ir_graph *irg);
+FIRM_DLL void compute_extbb(ir_graph *irg);
/**
* Compute the extended basic blocks for a graph based on execution frequencies.
*/
-void compute_extbb_execfreqs(ir_graph *irg, ir_exec_freq *execfreqs);
+FIRM_DLL void compute_extbb_execfreqs(ir_graph *irg, ir_exec_freq *execfreqs);
/**
* free all extended block info.
*/
-void free_extbb(ir_graph *irg);
+FIRM_DLL void free_extbb(ir_graph *irg);
/**
* Return the extended block of a node.
*
* @param node the node
*/
-ir_extblk *get_nodes_extbb(const ir_node *node);
+FIRM_DLL ir_extblk *get_nodes_extbb(const ir_node *node);
/**
* Gets the visited counter of an extended block.
*
* @param blk the extended basic block
*/
-ir_visited_t get_extbb_visited(const ir_extblk *blk);
+FIRM_DLL ir_visited_t get_extbb_visited(const ir_extblk *blk);
/**
* Sets the visited counter of an extended block.
* @param blk the extended basic block
* @param visited new value for the visited counter
*/
-void set_extbb_visited(ir_extblk *blk, ir_visited_t visited);
+FIRM_DLL void set_extbb_visited(ir_extblk *blk, ir_visited_t visited);
/**
* Mark an extended block as visited in a graph.
*
* @param blk the extended basic block
*/
-void mark_extbb_visited(ir_extblk *blk);
+FIRM_DLL void mark_extbb_visited(ir_extblk *blk);
/**
* Returns non-zero if an extended was visited.
*
* @param blk the extended basic block
*/
-int extbb_visited(const ir_extblk *blk);
+FIRM_DLL int extbb_visited(const ir_extblk *blk);
/**
* Returns non-zero if an extended block was NOT visited.
*
* @param blk the extended basic block
*/
-int extbb_not_visited(const ir_extblk *blk);
+FIRM_DLL int extbb_not_visited(const ir_extblk *blk);
/**
* Returns the link field of an extended block.
*
* @param blk the extended basic block
*/
-void *get_extbb_link(const ir_extblk *blk);
+FIRM_DLL void *get_extbb_link(const ir_extblk *blk);
/**
* Sets the link field of an extended block.
* @param blk the extended basic block
* @param link the new link value
*/
-void set_extbb_link(ir_extblk *blk, void *link);
+FIRM_DLL void set_extbb_link(ir_extblk *blk, void *link);
/**
* Return the number of basic blocks of an extended block.
*
* @param blk the extended basic block
*/
-int get_extbb_n_blocks(const ir_extblk *blk);
+FIRM_DLL int get_extbb_n_blocks(const ir_extblk *blk);
/**
* Return the i'th basic block of an extended block.
* @param blk the extended basic block
* @param pos the position
*/
-ir_node *get_extbb_block(const ir_extblk *blk, int pos);
+FIRM_DLL ir_node *get_extbb_block(const ir_extblk *blk, int pos);
/**
* Return the leader basic block of an extended block.
*
* @param blk the extended basic block
*/
-ir_node *get_extbb_leader(const ir_extblk *blk);
+FIRM_DLL ir_node *get_extbb_leader(const ir_extblk *blk);
/**
* Return the node number of an extended block.
*
* @param blk the extended basic block
*/
-long get_extbb_node_nr(const ir_extblk *blk);
+FIRM_DLL long get_extbb_node_nr(const ir_extblk *blk);
/**
* Walks only over Extended Basic Block nodes in the graph.
*
* @param blk - the start extended block node
- * @param pre - walker function, executed before the predecessor of a node are visited
- * @param post - walker function, executed after the predecessor of a node are visited
+ * @param pre - walker function, executed before the predecessor of a node are
+ * visited
+ * @param post - walker function, executed after the predecessor of a node are
+ * visited
* @param env - environment, passed to pre and post
*
* This function Walks only over Block nodes in the graph. Has it's own visited
* If a none block is passed, starts at the block this node belongs to.
* If end is passed also visits kept alive blocks. Does not use the link field.
*/
-void irg_extblock_walk(ir_extblk *blk, extbb_walk_func *pre, extbb_walk_func *post, void *env);
+FIRM_DLL void irg_extblock_walk(ir_extblk *blk, extbb_walk_func *pre,
+ extbb_walk_func *post, void *env);
/**
* Walks only over reachable Extended Basic Block nodes in the graph.
* and the block containing Start visited first (in post order).
*
* @param irg - the irg graph
- * @param pre - walker function, executed before the predecessor of a block are visited
- * @param post - walker function, executed after the predecessor of a block are visited
+ * @param pre - walker function, executed before the predecessor of a block
+ * are visited
+ * @param post - walker function, executed after the predecessor of a block
+ * are visited
* @param env - environment, passed to pre and post
*/
-void irg_extblock_walk_graph(ir_graph *irg, extbb_walk_func *pre, extbb_walk_func *post, void *env);
+FIRM_DLL void irg_extblock_walk_graph(ir_graph *irg, extbb_walk_func *pre,
+ extbb_walk_func *post, void *env);
+
+#include "end.h"
#endif
#define FIRM_IR_IRFLAG_H
#include "firm_types.h"
+#include "begin.h"
/**
* A container type to load/restore all optimizations
* If optimize == 0 no optimizations are performed at all.
* Default: optimize == 1.
*/
-void set_optimize(int value);
-int get_optimize(void);
+FIRM_DLL void set_optimize(int value);
+FIRM_DLL int get_optimize(void);
/** Enables/Disables constant folding optimization.
*
* constant expression evaluation (2 + 5 ==> 7, 3 < 2 ==> false)
* Default: opt_constant_folding == 1.
*/
-void set_opt_constant_folding(int value);
+FIRM_DLL void set_opt_constant_folding(int value);
/** Enables/Disables algebraic simplifications.
*
* - simplification of tests ( !(a < b) ==> (a >= b))
* Default: opt_algebraic_simplification == 1.
*/
-void set_opt_algebraic_simplification(int value);
+FIRM_DLL void set_opt_algebraic_simplification(int value);
/** Enables/Disables common subexpression elimination.
*
* If opt_cse == 1 perform common subexpression elimination.
* Default: opt_cse == 1.
*/
-void set_opt_cse(int value);
+FIRM_DLL void set_opt_cse(int value);
/** Returns constant folding optimization setting. */
-int get_opt_cse(void);
+FIRM_DLL int get_opt_cse(void);
/** Enables/Disables global constant subexpression elimination.
*
* right after a call to local_optimize with global cse turned on.
* Default: opt_global_cse == 0.
*/
-void set_opt_global_cse(int value);
+FIRM_DLL void set_opt_global_cse(int value);
/** Enables/Disables unreachable code elimination.
*
* Phi and Tuple) with a Bad predecessor by the Bad node.
* Default: opt_unreachable_code == 1.
*/
-void set_opt_unreachable_code(int value);
+FIRM_DLL void set_opt_unreachable_code(int value);
/** Enables/Disables control flow optimizations.
*
* Sets all separate control flow flags (control_flow_straightening,
* weak_simplification, strong_simplification and critical_edges).
*/
-void set_opt_control_flow(int value);
+FIRM_DLL void set_opt_control_flow(int value);
/** Enables/Disables Straightening. */
-void set_opt_control_flow_straightening(int value);
+FIRM_DLL void set_opt_control_flow_straightening(int value);
/** Enables/Disables if simplifications in local optimizations. */
-void set_opt_control_flow_weak_simplification(int value);
+FIRM_DLL void set_opt_control_flow_weak_simplification(int value);
/** Enables/Disables strong if and loop simplification (in optimize_cf). */
-void set_opt_control_flow_strong_simplification(int value);
+FIRM_DLL void set_opt_control_flow_strong_simplification(int value);
/** Enable/Disable optimization of dynamic method dispatch.
*
* If the flag is turned on Sel nodes can be replaced by Const nodes representing
* the address of a function.
*/
-void set_opt_dyn_meth_dispatch(int value);
-int get_opt_dyn_meth_dispatch(void);
+FIRM_DLL void set_opt_dyn_meth_dispatch(int value);
+FIRM_DLL int get_opt_dyn_meth_dispatch(void);
/** Enable/Disable type optimization of cast nodes.
*
* Controls the optimizations in tropt.h. Default: on.
*/
-void set_opt_optimize_class_casts(int value);
+FIRM_DLL void set_opt_optimize_class_casts(int value);
/** Restricts the behavior of cast optimization.
*
* illegal as in (Super)(Sub) (new Super()). Default:
* 0 == not suppressed.
*/
-void set_opt_suppress_downcast_optimization(int value);
-int get_opt_suppress_downcast_optimization(void);
+FIRM_DLL void set_opt_suppress_downcast_optimization(int value);
+FIRM_DLL int get_opt_suppress_downcast_optimization(void);
/** Enable/Disable floating of fragile ops.
*
* an exception can be place to other basic blocks.
* Otherwise they remain in the block they were created.
*/
-void set_opt_fragile_ops(int value);
+FIRM_DLL void set_opt_fragile_ops(int value);
/**
* Enable/Disable Confirm node removal during local optimization.
*/
-void set_opt_remove_confirm(int value);
+FIRM_DLL void set_opt_remove_confirm(int value);
/**
* Enable/Disable Null exception in Load and Store nodes only.
*
* This flag is enabled by default.
*/
-void set_opt_ldst_only_null_ptr_exceptions(int value);
+FIRM_DLL void set_opt_ldst_only_null_ptr_exceptions(int value);
/**
* Enable/Disable Selection based Null pointer check elimination.
*
* This flag should be set for Java style languages.
*/
-void set_opt_sel_based_null_check_elim(int value);
+FIRM_DLL void set_opt_sel_based_null_check_elim(int value);
/**
* Enable/Disable Global Null Pointer Test Elimination.
*
* This flag should be set for C style languages.
*/
-void set_opt_global_null_ptr_elimination(int value);
+FIRM_DLL void set_opt_global_null_ptr_elimination(int value);
/**
* Enable/Disable Automatic construction of Sync nodes during
*
* This flag should be set for Java style languages.
*/
-void set_opt_auto_create_sync(int value);
+FIRM_DLL void set_opt_auto_create_sync(int value);
/** Enable/Disable normalizations of the firm representation.
*
*
* @note ATTENTION: not all such transformations are guarded by a flag.
*/
-void set_opt_normalize(int value);
+FIRM_DLL void set_opt_normalize(int value);
/**
* Enable/Disable ConvB() nodes with a "semantic behavior", i.e. a real
* operation that must be executed.
*/
-void set_opt_allow_conv_b(int value);
+FIRM_DLL void set_opt_allow_conv_b(int value);
/** Enable/Disable precise exception context.
*
* else it might see a == 2.
* Enable this for languages with strict exception order like Java.
*/
-void set_opt_precise_exc_context(int value);
+FIRM_DLL void set_opt_precise_exc_context(int value);
/** Enable/Disable Alias analysis.
*
* If enabled, memory disambiguation by alias analysis is used.
*/
-void set_opt_alias_analysis(int value);
+FIRM_DLL void set_opt_alias_analysis(int value);
/** Enable/Disable closed world assumption.
*
* external types or callers exist.
* This enables some powerful optimizations.
*/
-void set_opt_closed_world(int value);
+FIRM_DLL void set_opt_closed_world(int value);
/**
* Save the current optimization state.
*/
-void save_optimization_state(optimization_state_t *state);
+FIRM_DLL void save_optimization_state(optimization_state_t *state);
/**
* Restore the current optimization state.
*/
-void restore_optimization_state(const optimization_state_t *state);
+FIRM_DLL void restore_optimization_state(const optimization_state_t *state);
/**
* Switches ALL optimizations off.
*/
-void all_optimizations_off(void);
+FIRM_DLL void all_optimizations_off(void);
/**
* Possible verification modes.
* Per default the verification is in mode NODE_VERIFICATION_ASSERT.
* Turn the verification off during development to check partial implementations.
*/
-void do_node_verification(firm_verification_t mode);
+FIRM_DLL void do_node_verification(firm_verification_t mode);
+
+#include "end.h"
#endif
#define FIRM_IR_IRGMOD_H
#include "firm_types.h"
+#include "begin.h"
/** Exchanges two nodes by conserving edges leaving old (i.e.,
pointers pointing to old). Turns the old node into an Id. */
-void exchange(ir_node *old, ir_node *nw);
+FIRM_DLL void exchange(ir_node *old, ir_node *nw);
/** Turns a node into a "useless" Tuple.
*
* @param node The node to be turned into a tuple.
* @param arity The number of values formed into a Tuple.
*/
-void turn_into_tuple(ir_node *node, int arity);
+FIRM_DLL void turn_into_tuple(ir_node *node, int arity);
/** Walks over the passed IR graph and collects all Phi nodes as a
* list in their corresponding block (using get_Block_phis() API).
* All partBlocks are linked to its macroblock header.
* All other link fields are cleared afterwards.
*/
-void collect_phiprojs(ir_graph *irg);
+FIRM_DLL void collect_phiprojs(ir_graph *irg);
/** Parts a block into two. This is useful to insert other blocks within a
* given block.
*
* @param node The node were to break the block
*/
-void part_block(ir_node *node);
+FIRM_DLL void part_block(ir_node *node);
/**
* Kill a node by setting its predecessors to Bad and finally
* exchange the node by Bad itself.
*/
-void kill_node(ir_node *node);
+FIRM_DLL void kill_node(ir_node *node);
-#endif /* FIRM_IR_IRGMOD_H */
+#include "end.h"
+
+#endif
#define FIRM_IR_IRGOPT_H
#include "firm_types.h"
+#include "begin.h"
-/** Applies local optimizations (see iropt.h) to all nodes reachable from node n.
+/** Applies local optimizations (see iropt.h) to all nodes reachable from node
+ * @p n.
*
* @param n The node to be optimized.
*/
-void local_optimize_node(ir_node *n);
+FIRM_DLL void local_optimize_node(ir_node *n);
/** Applies local optimizations (see iropt.h) to all nodes in the graph.
*
* After applying local_optimize_graph() to a IR-graph, Bad nodes
* only occur as predecessor of Block and Phi nodes.
*/
-void local_optimize_graph(ir_graph *irg);
+FIRM_DLL void local_optimize_graph(ir_graph *irg);
/** Applies local optimizations (see iropt.h) to all nodes in the graph.
*
*
* @return non-zero if the optimization could be applied, 0 else
*/
-int optimize_graph_df(ir_graph *irg);
+FIRM_DLL int optimize_graph_df(ir_graph *irg);
/**
* Creates an ir_graph pass for optimize_graph_df().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *optimize_graph_df_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *optimize_graph_df_pass(const char *name);
/** Places an empty basic block on critical control flow edges thereby
* removing them.
*
* @param irg IR Graph
*/
-void remove_critical_cf_edges(ir_graph *irg);
+FIRM_DLL void remove_critical_cf_edges(ir_graph *irg);
/** Places an empty basic block on critical control flow edges thereby
* removing them.
* @param irg IR Graph
* @param ignore_exception_edges if non-zero, exception edges will be ignored
*/
-void remove_critical_cf_edges_ex(ir_graph *irg, int ignore_exception_edges);
+FIRM_DLL void remove_critical_cf_edges_ex(ir_graph *irg,
+ int ignore_exception_edges);
+
+#include "end.h"
#endif
#include <stddef.h>
#include "firm_types.h"
+#include "begin.h"
/**
* @page ir_graph The struct ir_graph
* interface in ircons and by the optimizations.
* Further it is set by all walker functions.
*/
-extern ir_graph *current_ir_graph;
+FIRM_DLL ir_graph *current_ir_graph;
-ir_graph *get_current_ir_graph(void);
-void set_current_ir_graph(ir_graph *graph);
+FIRM_DLL ir_graph *get_current_ir_graph(void);
+FIRM_DLL void set_current_ir_graph(ir_graph *graph);
#ifdef INTERPROCEDURAL_VIEW
/** This flag indicate the current view. The behavior of some methods
* (get_irn_*, set_irn_*) is influenced by this flag. */
-int get_interprocedural_view(void);
-void set_interprocedural_view(int state);
+FIRM_DLL int get_interprocedural_view(void);
+FIRM_DLL void set_interprocedural_view(int state);
#endif
/**
*
* @see new_pseudo_ir_graph()
*/
-ir_graph *new_ir_graph(ir_entity *ent, int n_loc);
+FIRM_DLL ir_graph *new_ir_graph(ir_entity *ent, int n_loc);
/** Frees the passed irgraph.
* Deallocates all nodes in this graph and the ir_graph structure.
* Does not free types, entities or modes that are used only by this
* graph, nor the entity standing for this graph.
*/
-void free_ir_graph(ir_graph *irg);
+FIRM_DLL void free_ir_graph(ir_graph *irg);
/* --- access routines for all ir_graph attributes --- */
* @return
* true if the thing is a IR graph, else false
*/
-int is_ir_graph(const void *thing);
+FIRM_DLL int is_ir_graph(const void *thing);
/** Returns the entity of an IR graph. */
-ir_entity *get_irg_entity(const ir_graph *irg);
+FIRM_DLL ir_entity *get_irg_entity(const ir_graph *irg);
/** Sets the entity of an IR graph. */
-void set_irg_entity(ir_graph *irg, ir_entity *ent);
+FIRM_DLL void set_irg_entity(ir_graph *irg, ir_entity *ent);
/** Returns the frame type of an IR graph. */
-ir_type *get_irg_frame_type(ir_graph *irg);
+FIRM_DLL ir_type *get_irg_frame_type(ir_graph *irg);
/** Sets the frame type of an IR graph. */
-void set_irg_frame_type(ir_graph *irg, ir_type *ftp);
+FIRM_DLL void set_irg_frame_type(ir_graph *irg, ir_type *ftp);
/** Returns the value parameter type of an IR graph. */
-ir_type *get_irg_value_param_type(ir_graph *irg);
+FIRM_DLL ir_type *get_irg_value_param_type(ir_graph *irg);
/** Returns the start block of an IR graph. */
-ir_node *get_irg_start_block(const ir_graph *irg);
+FIRM_DLL ir_node *get_irg_start_block(const ir_graph *irg);
/** Sets the start block of an IR graph. */
-void set_irg_start_block(ir_graph *irg, ir_node *node);
+FIRM_DLL void set_irg_start_block(ir_graph *irg, ir_node *node);
/** Returns the Start node of an IR graph. */
-ir_node *get_irg_start(const ir_graph *irg);
+FIRM_DLL ir_node *get_irg_start(const ir_graph *irg);
/** Sets the Start node of an IR graph. */
-void set_irg_start(ir_graph *irg, ir_node *node);
+FIRM_DLL void set_irg_start(ir_graph *irg, ir_node *node);
/** Returns the end block of an IR graph. */
-ir_node *get_irg_end_block(const ir_graph *irg);
+FIRM_DLL ir_node *get_irg_end_block(const ir_graph *irg);
/** Sets the end block of an IR graph. */
-void set_irg_end_block(ir_graph *irg, ir_node *node);
+FIRM_DLL void set_irg_end_block(ir_graph *irg, ir_node *node);
/** Returns the End node of an IR graph. */
-ir_node *get_irg_end(const ir_graph *irg);
+FIRM_DLL ir_node *get_irg_end(const ir_graph *irg);
/** Sets the End node of an IR graph. */
-void set_irg_end(ir_graph *irg, ir_node *node);
+FIRM_DLL void set_irg_end(ir_graph *irg, ir_node *node);
/* The fields end_reg and end_except contain the end nodes of the
interprocedural view. If the view is not constructed they contain
the normal end node. */
-ir_node *get_irg_end_reg(const ir_graph *irg);
-void set_irg_end_reg(ir_graph *irg, ir_node *node);
+FIRM_DLL ir_node *get_irg_end_reg(const ir_graph *irg);
+FIRM_DLL void set_irg_end_reg(ir_graph *irg, ir_node *node);
-ir_node *get_irg_end_except(const ir_graph *irg);
-void set_irg_end_except(ir_graph *irg, ir_node *node);
+FIRM_DLL ir_node *get_irg_end_except(const ir_graph *irg);
+FIRM_DLL void set_irg_end_except(ir_graph *irg, ir_node *node);
-/** Returns the node that represents the initial control flow of the given IR graph. */
-ir_node *get_irg_initial_exec(const ir_graph *irg);
+/** Returns the node that represents the initial control flow of the given
+ * IR graph. */
+FIRM_DLL ir_node *get_irg_initial_exec(const ir_graph *irg);
/** Sets the node that represents the initial control of the given IR graph. */
-void set_irg_initial_exec(ir_graph *irg, ir_node *node);
+FIRM_DLL void set_irg_initial_exec(ir_graph *irg, ir_node *node);
/** Returns the node that represents the frame pointer of the given IR graph. */
-ir_node *get_irg_frame(const ir_graph *irg);
+FIRM_DLL ir_node *get_irg_frame(const ir_graph *irg);
/** Sets the node that represents the frame pointer of the given IR graph. */
-void set_irg_frame(ir_graph *irg, ir_node *node);
+FIRM_DLL void set_irg_frame(ir_graph *irg, ir_node *node);
/** Returns the node that represents the tls pointer of the given IR graph. */
-ir_node *get_irg_tls(const ir_graph *irg);
+FIRM_DLL ir_node *get_irg_tls(const ir_graph *irg);
/** Sets the node that represents the tls pointer of the given IR graph. */
-void set_irg_tls(ir_graph *irg, ir_node *node);
+FIRM_DLL void set_irg_tls(ir_graph *irg, ir_node *node);
/** Returns the node that represents the initial memory of the given IR graph. */
-ir_node *get_irg_initial_mem(const ir_graph *irg);
+FIRM_DLL ir_node *get_irg_initial_mem(const ir_graph *irg);
/** Sets the node that represents the initial memory of the given IR graph. */
-void set_irg_initial_mem(ir_graph *irg, ir_node *node);
+FIRM_DLL void set_irg_initial_mem(ir_graph *irg, ir_node *node);
/** Returns the node that represents the argument pointer of the given IR graph. */
-ir_node *get_irg_args(const ir_graph *irg);
+FIRM_DLL ir_node *get_irg_args(const ir_graph *irg);
/** Sets the node that represents the argument pointer of the given IR graph. */
-void set_irg_args(ir_graph *irg, ir_node *node);
+FIRM_DLL void set_irg_args(ir_graph *irg, ir_node *node);
/** Returns the current block of an IR graph. */
-ir_node *get_irg_current_block(const ir_graph *irg);
+FIRM_DLL ir_node *get_irg_current_block(const ir_graph *irg);
/** Sets the current block of an IR graph. */
-void set_irg_current_block(ir_graph *irg, ir_node *node);
+FIRM_DLL void set_irg_current_block(ir_graph *irg, ir_node *node);
/** Returns the Bad node of the given IR graph. Use new_Bad() instead!! */
-ir_node *get_irg_bad(const ir_graph *irg);
-void set_irg_bad(ir_graph *irg, ir_node *node);
+FIRM_DLL ir_node *get_irg_bad(const ir_graph *irg);
+FIRM_DLL void set_irg_bad(ir_graph *irg, ir_node *node);
/** Returns the NoMem node of the given IR graph. Use new_NoMem() instead!! */
-ir_node *get_irg_no_mem(const ir_graph *irg);
-void set_irg_no_mem(ir_graph *irg, ir_node *node);
+FIRM_DLL ir_node *get_irg_no_mem(const ir_graph *irg);
+FIRM_DLL void set_irg_no_mem(ir_graph *irg, ir_node *node);
/** Returns the number of value numbers of an IR graph. */
-int get_irg_n_locs(ir_graph *irg);
+FIRM_DLL int get_irg_n_locs(ir_graph *irg);
/** Returns the graph number. */
-long get_irg_graph_nr(const ir_graph *irg);
+FIRM_DLL long get_irg_graph_nr(const ir_graph *irg);
/**
* Returns the graph number. This is a unique number for the graph and is
* smaller than get_irp_last_idx()
* Note: you cannot use this number for get_irp_irg()
*/
-int get_irg_idx(const ir_graph *irg);
+FIRM_DLL int get_irg_idx(const ir_graph *irg);
/**
* Get the node for an index.
* @param irg The graph.
* @param idx The index you want the node for.
- * @return The node with that index or NULL, if there is no node with that index.
+ * @return The node with that index or NULL, if there is no node with that
+ * index.
* @note The node you got might be dead.
*/
-ir_node *get_idx_irn(ir_graph *irg, unsigned idx);
+FIRM_DLL ir_node *get_idx_irn(ir_graph *irg, unsigned idx);
-/********************************************************************************/
-/* States of an ir_graph. */
-/********************************************************************************/
+/******************************************************************************/
+/* States of an ir_graph. */
+/******************************************************************************/
/*
information associated with the graph. Optimizations invalidate these
} irg_phase_state;
/** Returns the phase_state of an IR graph. */
-irg_phase_state get_irg_phase_state(const ir_graph *irg);
+FIRM_DLL irg_phase_state get_irg_phase_state(const ir_graph *irg);
/** Sets the phase state of an IR graph. */
-void set_irg_phase_state(ir_graph *irg, irg_phase_state state);
+FIRM_DLL void set_irg_phase_state(ir_graph *irg, irg_phase_state state);
/** Sets the phase of the given IR graph to low. */
#define set_irg_phase_low(irg) set_irg_phase_state(irg, phase_low)
invalid block, i.e., the block is not a dominator of all the uses of
the node.
The enum op_pin_state is defined in irop.h. */
-op_pin_state get_irg_pinned(const ir_graph *irg);
+FIRM_DLL op_pin_state get_irg_pinned(const ir_graph *irg);
/** state: outs_state
* Outs are the back edges or def-use edges of ir nodes.
outs_inconsistent /**< Outs have been computed, memory is still allocated,
but the graph has been changed since. */
} irg_outs_state;
-irg_outs_state get_irg_outs_state(const ir_graph *irg);
-void set_irg_outs_inconsistent(ir_graph *irg);
+FIRM_DLL irg_outs_state get_irg_outs_state(const ir_graph *irg);
+FIRM_DLL void set_irg_outs_inconsistent(ir_graph *irg);
/** state: extended basic block state. */
typedef enum {
extblk_valid = 1, /**< Extended basic block information is valid. */
extblk_invalid = 2 /**< Extended basic block information is constructed but invalid. */
} irg_extblk_state;
-irg_extblk_state get_irg_extblk_state(const ir_graph *irg);
-void set_irg_extblk_inconsistent(ir_graph *irg);
+FIRM_DLL irg_extblk_state get_irg_extblk_state(const ir_graph *irg);
+FIRM_DLL void set_irg_extblk_inconsistent(ir_graph *irg);
/** state: dom_state
* Signals the state of the dominator / post dominator information.
} irg_dom_state;
/** returns the dominator state of an IR graph. */
-irg_dom_state get_irg_dom_state(const ir_graph *irg);
+FIRM_DLL irg_dom_state get_irg_dom_state(const ir_graph *irg);
/** returns the post dominator state of an IR graph. */
-irg_dom_state get_irg_postdom_state(const ir_graph *irg);
+FIRM_DLL irg_dom_state get_irg_postdom_state(const ir_graph *irg);
/** sets the dominator and post dominator state of an IR graph to inconsistent. */
-void set_irg_doms_inconsistent(ir_graph *irg);
+FIRM_DLL void set_irg_doms_inconsistent(ir_graph *irg);
/** state: loopinfo_state
* Loop information describes the loops within the control and
} irg_loopinfo_state;
/** Return the current loop information state. */
-irg_loopinfo_state get_irg_loopinfo_state(const ir_graph *irg);
+FIRM_DLL irg_loopinfo_state get_irg_loopinfo_state(const ir_graph *irg);
/** Sets the current loop information state. */
-void set_irg_loopinfo_state(ir_graph *irg, irg_loopinfo_state s);
+FIRM_DLL void set_irg_loopinfo_state(ir_graph *irg, irg_loopinfo_state s);
/** Sets the loop information state to the appropriate inconsistent state.
* If state is 'none' does not change. */
-void set_irg_loopinfo_inconsistent(ir_graph *irg);
+FIRM_DLL void set_irg_loopinfo_inconsistent(ir_graph *irg);
/** Sets the loop information state to the appropriate inconsistent state.
* If state is 'none' does not change.
* Does this for all irgs. */
-void set_irp_loopinfo_inconsistent(void);
+FIRM_DLL void set_irp_loopinfo_inconsistent(void);
/** state: callee_information_state
* Call nodes contain a list of possible callees. This list must be
} irg_callee_info_state;
/** Returns the callee_info_state of an IR graph. */
-irg_callee_info_state get_irg_callee_info_state(const ir_graph *irg);
+FIRM_DLL irg_callee_info_state get_irg_callee_info_state(const ir_graph *irg);
/** Sets the callee_info_state of an IR graph. */
-void set_irg_callee_info_state(ir_graph *irg, irg_callee_info_state s);
+FIRM_DLL void set_irg_callee_info_state(ir_graph *irg, irg_callee_info_state s);
/** property:
* Tells how to handle an ir graph in inlining.
} irg_inline_property;
/** Returns the inline property of a graph. */
-irg_inline_property get_irg_inline_property(const ir_graph *irg);
+FIRM_DLL irg_inline_property get_irg_inline_property(const ir_graph *irg);
/** Sets the inline property of a graph. */
-void set_irg_inline_property(ir_graph *irg, irg_inline_property s);
+FIRM_DLL void set_irg_inline_property(ir_graph *irg, irg_inline_property s);
/**
* Returns the mask of the additional graph properties.
*
* @return a bitset of mtp_additional_property values
*/
-unsigned get_irg_additional_properties(const ir_graph *irg);
+FIRM_DLL unsigned get_irg_additional_properties(const ir_graph *irg);
/** Sets the mask of the additional graph properties. */
-void set_irg_additional_properties(ir_graph *irg, unsigned property_mask);
+FIRM_DLL void set_irg_additional_properties(ir_graph *irg,
+ unsigned property_mask);
/** Sets one additional graph property. */
-void set_irg_additional_property(ir_graph *irg, mtp_additional_property flag);
+FIRM_DLL void set_irg_additional_property(ir_graph *irg,
+ mtp_additional_property flag);
/** A void * field to link arbitrary information to the node. */
-void set_irg_link (ir_graph *irg, void *thing);
-void *get_irg_link (const ir_graph *irg);
+FIRM_DLL void set_irg_link(ir_graph *irg, void *thing);
+FIRM_DLL void *get_irg_link(const ir_graph *irg);
/** Increments visited flag by one.
* @see also: get_irn_visited() get_irg_block_visited(). */
-void inc_irg_visited(ir_graph *irg);
-ir_visited_t get_irg_visited(const ir_graph *irg);
-void set_irg_visited(ir_graph *irg, ir_visited_t i);
+FIRM_DLL void inc_irg_visited(ir_graph *irg);
+FIRM_DLL ir_visited_t get_irg_visited(const ir_graph *irg);
+FIRM_DLL void set_irg_visited(ir_graph *irg, ir_visited_t i);
/** An interprocedural flag valid for all irgs.
* @see also: get_irn_visited() get_irg_block_visited(). */
-ir_visited_t get_max_irg_visited(void);
-void set_max_irg_visited(int val);
-ir_visited_t inc_max_irg_visited(void);
+FIRM_DLL ir_visited_t get_max_irg_visited(void);
+FIRM_DLL void set_max_irg_visited(int val);
+FIRM_DLL ir_visited_t inc_max_irg_visited(void);
/** Increments block_visited by one.
* @see also: get_irn_visited() get_irg_block_visited(). */
-void inc_irg_block_visited(ir_graph *irg);
-ir_visited_t get_irg_block_visited(const ir_graph *irg);
-void set_irg_block_visited(ir_graph *irg, ir_visited_t i);
+FIRM_DLL void inc_irg_block_visited(ir_graph *irg);
+FIRM_DLL ir_visited_t get_irg_block_visited(const ir_graph *irg);
+FIRM_DLL void set_irg_block_visited(ir_graph *irg, ir_visited_t i);
/**
* Debug helpers: You can indicate whether you are currently using visited or
typedef unsigned ir_resources_t;
#ifndef NDEBUG
-void ir_reserve_resources(ir_graph *irg, ir_resources_t resources);
-void ir_free_resources(ir_graph *irg, ir_resources_t resources);
-ir_resources_t ir_resources_reserved(const ir_graph *irg);
+FIRM_DLL void ir_reserve_resources(ir_graph *irg, ir_resources_t resources);
+FIRM_DLL void ir_free_resources(ir_graph *irg, ir_resources_t resources);
+FIRM_DLL ir_resources_t ir_resources_reserved(const ir_graph *irg);
#else
#define ir_reserve_resources(irg,resources) (void)0
#define ir_free_resources(irg,resources) (void)0
} ir_graph_state_t;
/** set some state flags on the graph (this does not clear the other flags) */
-void set_irg_state(ir_graph *irg, ir_graph_state_t state);
+FIRM_DLL void set_irg_state(ir_graph *irg, ir_graph_state_t state);
/** clear some state flags of the graph */
-void clear_irg_state(ir_graph *irg, ir_graph_state_t state);
+FIRM_DLL void clear_irg_state(ir_graph *irg, ir_graph_state_t state);
/** query wether a set of graph state flags are activated */
-int is_irg_state(const ir_graph *irg, ir_graph_state_t state);
+FIRM_DLL int is_irg_state(const ir_graph *irg, ir_graph_state_t state);
/** Normalization: Move Proj nodes into the same block as its predecessors */
-void normalize_proj_nodes(ir_graph *irg);
+FIRM_DLL void normalize_proj_nodes(ir_graph *irg);
/** Set a description for local value n. */
-void set_irg_loc_description(ir_graph *irg, int n, void *description);
+FIRM_DLL void set_irg_loc_description(ir_graph *irg, int n, void *description);
/** Get the description for local value n. */
-void *get_irg_loc_description(ir_graph *irg, int n);
+FIRM_DLL void *get_irg_loc_description(ir_graph *irg, int n);
/** Returns a estimated node count of the irg. This count is updated
* after every irg_walk_graph().
*/
-unsigned get_irg_estimated_node_cnt(const ir_graph *irg);
+FIRM_DLL unsigned get_irg_estimated_node_cnt(const ir_graph *irg);
/** Returns the last irn index for this graph. */
-unsigned get_irg_last_idx(const ir_graph *irg);
+FIRM_DLL unsigned get_irg_last_idx(const ir_graph *irg);
/** Returns the floating point model of this graph. */
-unsigned get_irg_fp_model(const ir_graph *irg);
+FIRM_DLL unsigned get_irg_fp_model(const ir_graph *irg);
/** Sets a floating point model for this graph. */
-void set_irg_fp_model(ir_graph *irg, unsigned model);
+FIRM_DLL void set_irg_fp_model(ir_graph *irg, unsigned model);
/**
* Access custom graph data.
* must be passed to the access macro get_irg_data(), 0 if the
* registration failed.
*/
-size_t register_additional_graph_data(size_t size);
+FIRM_DLL size_t register_additional_graph_data(size_t size);
+
+#include "end.h"
#endif
#define FIRM_IR_IRGWALK_H
#include "firm_types.h"
+#include "begin.h"
/**
* Walks over the ir graph.
* @param env environment, passed to pre and post
*
*/
-void irg_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post,
- void *env);
+FIRM_DLL void irg_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post,
+ void *env);
/**
* core walker function. Does NOT touch current_ir_graph and does not call
* inc_irg_visited before walking
*/
-void irg_walk_core(ir_node *node, irg_walk_func *pre, irg_walk_func *post,
- void *env);
+FIRM_DLL void irg_walk_core(ir_node *node, irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/**
* Walks over all reachable nodes in the ir graph.
* is set to irg. Does not use the link field. If interprocedural_view
* is set, visits all reachable irgs.
*/
-void irg_walk_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env);
+FIRM_DLL void irg_walk_graph(ir_graph *irg, irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/**
* Walks over the ir graph.
* @param env environment, passed to pre and post
*
*/
-void irg_walk_in_or_dep(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env);
+FIRM_DLL void irg_walk_in_or_dep(ir_node *node, irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/**
* Walks over all reachable nodes in the ir graph.
* This walker also follows additional dependency egdes.
* interprocedural_view is not yet supported.
*/
-void irg_walk_in_or_dep_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env);
+FIRM_DLL void irg_walk_in_or_dep_graph(ir_graph *irg, irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/**
* Executes irg_walk(end, pre, post, env) for all irgraphs in irprog.
* current_ir_graph. In interprocedural view nodes can be visited several
* times. Does not use the link field.
*/
-void all_irg_walk(irg_walk_func *pre, irg_walk_func *post, void *env);
+FIRM_DLL void all_irg_walk(irg_walk_func *pre, irg_walk_func *post, void *env);
#ifdef INTERPROCEDURAL_VIEW
/**
* This function walks all irgs in interprocedural view.
* Visits each node only once. Sets current_ir_graph properly. Does not use the link field.
*/
-void cg_walk(irg_walk_func *pre, irg_walk_func *post, void *env);
+FIRM_DLL void cg_walk(irg_walk_func *pre, irg_walk_func *post, void *env);
#endif
/** Walks only over Block nodes in the graph.
* If a none block is passed, starts at the block this node belongs to.
* If end is passed also visits kept alive blocks. Does not use the link field.
*/
-void irg_block_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env);
+FIRM_DLL void irg_block_walk(ir_node *node, irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/**
* Walks only over reachable Block nodes in the graph.
* Like irg_block_walk(), but walks over all reachable blocks in the
* ir graph, starting at the end block. Does not use the link field.
*/
-void irg_block_walk_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env);
+FIRM_DLL void irg_block_walk_graph(ir_graph *irg, irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/**
* Walks over all code in const_code_irg.
* This function walks over all code in const_code_irg.
* Uses visited flag in const_code_irg. Does not use the link field.
*/
-void walk_const_code(irg_walk_func *pre, irg_walk_func *post, void *env);
+FIRM_DLL void walk_const_code(irg_walk_func *pre, irg_walk_func *post,
+ void *env);
/**
* Walks over reachable nodes in block-wise topological order, i.e. visit
* @param post walker function, executed after the predecessor of a node are visited
* @param env environment, passed to pre and post
*/
-void irg_walk_blkwise_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env);
+FIRM_DLL void irg_walk_blkwise_graph(ir_graph *irg, irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/**
* Walks over reachable nodes in block-wise topological order, i.e. visit
* @param post walker function, executed after the predecessor of a node are visited
* @param env environment, passed to pre and post
*/
-void irg_walk_in_or_dep_blkwise_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env);
+FIRM_DLL void irg_walk_in_or_dep_blkwise_graph(ir_graph *irg,
+ irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/**
* Walks over reachable nodes in block-wise topological order, i.e. visit
* @param post walker function, executed after the predecessor of a node are visited
* @param env environment, passed to pre and post
*/
-void irg_walk_blkwise_dom_top_down(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env);
+FIRM_DLL void irg_walk_blkwise_dom_top_down(ir_graph *irg, irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/**
* Additionally walk over all anchors.
* @param post walker function, executed after the predecessor of a node are visited
* @param env environment, passed to pre and post
*/
-void irg_walk_anchors(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env);
+FIRM_DLL void irg_walk_anchors(ir_graph *irg, irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/**
* Walker function which does not increase the visited flag before walking.
unsigned irg_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post,
void *env);
+#include "end.h"
+
#endif
#include "irop.h"
#include "irnode.h"
#include "irgraph.h"
+#include "begin.h"
/**
* options for the hook_merge_nodes hook
* @param hook the hook type
* @param entry the hook entry
*/
-void register_hook(hook_type_t hook, hook_entry_t *entry);
+FIRM_DLL void register_hook(hook_type_t hook, hook_entry_t *entry);
/**
* unregister a hook entry.
* @param hook the hook type
* @param entry the hook entry
*/
-void unregister_hook(hook_type_t hook, hook_entry_t *entry);
+FIRM_DLL void unregister_hook(hook_type_t hook, hook_entry_t *entry);
-extern hook_entry_t *hooks[hook_last];
+FIRM_DLL hook_entry_t *hooks[hook_last];
/**
* execute the hook what with the args args
#define hook_new_type(tp) hook_exec(hook_new_type, (ctx, tp))
#define hook_node_info(F, node) hook_exec(hook_node_info, (ctx, F, node))
+#include "end.h"
+
#endif
#include <stdio.h>
#include "firm_types.h"
+#include "begin.h"
/**
* Exports the whole irp to the given file in a textual form.
*
* Exports all types, all ir graphs, and the constant graph.
*/
-void ir_export(const char *filename);
+FIRM_DLL void ir_export(const char *filename);
/**
* same as ir_export but writes to a FILE*
*/
-void ir_export_file(FILE *output, const char *outputname);
+FIRM_DLL void ir_export_file(FILE *output, const char *outputname);
/**
* Write the given ir graph to a stream in a textual format
*
* Exports the type graph used by the given graph and the graph itself.
*/
-void ir_export_irg(ir_graph *irg, FILE *output, const char *outputname);
+FIRM_DLL void ir_export_irg(ir_graph *irg, FILE *output,
+ const char *outputname);
/**
* Imports the data stored in the given file.
*
* Imports any type graphs and ir graphs contained in the file.
*/
-void ir_import(const char *filename);
+FIRM_DLL void ir_import(const char *filename);
/**
* same as ir_import but imports from a FILE*
*/
-void ir_import_file(FILE *input, const char *inputname);
+FIRM_DLL void ir_import_file(FILE *input, const char *inputname);
+
+#include "end.h"
#endif
#include "firm_types.h"
#include "firm_common.h"
+#include "begin.h"
/* ------------------------------------------------------------------- */
/*
#ifdef INTERPROCEDURAL_VIEW
/** Returns true if the predecessor pos is a backedge in the interprocedural view. */
-int is_inter_backedge(ir_node *n, int pos);
+FIRM_DLL int is_inter_backedge(ir_node *n, int pos);
/** Returns true if the predecessor pos is a backedge in the intraprocedural view. */
-int is_intra_backedge(ir_node *n, int pos);
+FIRM_DLL int is_intra_backedge(ir_node *n, int pos);
#endif
/** Returns non-zero if the predecessor pos is a backedge. */
-int is_backedge(ir_node *n, int pos);
+FIRM_DLL int is_backedge(ir_node *n, int pos);
/** Marks edge pos as a backedge. */
-void set_backedge(ir_node *n, int pos);
+FIRM_DLL void set_backedge(ir_node *n, int pos);
/** Marks edge pos as a non-backedge. */
-void set_not_backedge(ir_node *n, int pos);
+FIRM_DLL void set_not_backedge(ir_node *n, int pos);
/** Returns non-zero if n has backedges. */
-int has_backedges(ir_node *n);
+FIRM_DLL int has_backedges(ir_node *n);
/** Clears all backedge information. */
-void clear_backedges(ir_node *n);
+FIRM_DLL void clear_backedges(ir_node *n);
/** Loop elements: loop nodes and ir nodes */
typedef union {
ir_graph *irg; /**< Pointer to an ir_graph element (only callgraph loop trees) */
} loop_element;
-int is_ir_loop(const void *thing);
+FIRM_DLL int is_ir_loop(const void *thing);
/** Set the outermost loop in ir graph as basic access to loop tree. */
-void set_irg_loop(ir_graph *irg, ir_loop *l);
+FIRM_DLL void set_irg_loop(ir_graph *irg, ir_loop *l);
/* Returns the root loop info (if exists) for an irg. */
-ir_loop *get_irg_loop(const ir_graph *irg);
+FIRM_DLL ir_loop *get_irg_loop(const ir_graph *irg);
/** Returns the loop n is contained in. NULL if node is in no loop. */
-ir_loop *get_irn_loop(const ir_node *n);
+FIRM_DLL ir_loop *get_irn_loop(const ir_node *n);
/** Returns outer loop, itself if outermost. */
-ir_loop *get_loop_outer_loop(const ir_loop *loop);
+FIRM_DLL ir_loop *get_loop_outer_loop(const ir_loop *loop);
/** Returns nesting depth of this loop */
-int get_loop_depth(const ir_loop *loop);
+FIRM_DLL int get_loop_depth(const ir_loop *loop);
/* Sons are the inner loops contained in this loop. */
/** Returns the number of inner loops */
-int get_loop_n_sons(const ir_loop *loop);
+FIRM_DLL int get_loop_n_sons(const ir_loop *loop);
/** Returns the pos`th son loop (inner loop) of a loop.
Returns NULL if there is not a pos`th loop_node. */
-ir_loop *get_loop_son(ir_loop *loop, int pos);
+FIRM_DLL ir_loop *get_loop_son(ir_loop *loop, int pos);
/** Returns the number of nodes contained in loop. */
-int get_loop_n_nodes(const ir_loop *loop);
+FIRM_DLL int get_loop_n_nodes(const ir_loop *loop);
/** Returns the pos`th ir_node of a loop.
Returns NULL if there is not a pos`th ir_node. */
-ir_node *get_loop_node(const ir_loop *loop, int pos);
+FIRM_DLL ir_node *get_loop_node(const ir_loop *loop, int pos);
/** Returns the number of elements contained in loop. */
-int get_loop_n_elements(const ir_loop *loop);
+FIRM_DLL int get_loop_n_elements(const ir_loop *loop);
/** Returns a loop element. A loop element can be interpreted as a
kind pointer, an ir_node* or an ir_loop*. */
-loop_element get_loop_element(const ir_loop *loop, int pos);
+FIRM_DLL loop_element get_loop_element(const ir_loop *loop, int pos);
/** Returns the element number of the loop son in loop.
* Returns -1 if not found. O(|elements|). */
-int get_loop_element_pos(const ir_loop *loop, void *le);
+FIRM_DLL int get_loop_element_pos(const ir_loop *loop, void *le);
/** Returns a unique node number for the loop node to make output
readable. If libfirm_debug is not set it returns the loop cast to
int. */
-int get_loop_loop_nr(const ir_loop *loop);
+FIRM_DLL int get_loop_loop_nr(const ir_loop *loop);
/** A field to connect additional information to a loop. */
-void set_loop_link(ir_loop *loop, void *link);
-void *get_loop_link(const ir_loop *loop);
+FIRM_DLL void set_loop_link(ir_loop *loop, void *link);
+FIRM_DLL void *get_loop_link(const ir_loop *loop);
/* ------------------------------------------------------------------- */
/* Constructing and destructing the loop/backedge information. */
* edges, the cycle is removed. The second Phi node does not get a
* backedge!
*/
-/* @@@ Well, maybe construct_loop_information or analyze_loops ? */
-int construct_backedges(ir_graph *irg);
+FIRM_DLL int construct_backedges(ir_graph *irg);
#ifdef INTERPROCEDURAL_VIEW
/** Constructs backedges for all irgs in interprocedural view.
*
* @returns Maximal depth of loop tree.
*/
-int construct_ip_backedges(void);
+FIRM_DLL int construct_ip_backedges(void);
#endif
/**
*
* @returns Maximal depth of loop tree.
*/
-int construct_cf_backedges(ir_graph *irg);
+FIRM_DLL int construct_cf_backedges(ir_graph *irg);
/**
* Computes Intra-procedural control flow loop tree on demand.
*
* @param irg the graph
*/
-void assure_cf_loop(ir_graph *irg);
+FIRM_DLL void assure_cf_loop(ir_graph *irg);
#ifdef INTERPROCEDURAL_VIEW
/**
*
* @see construct_cf_backedges() and construct_ip_backedges().
*/
-int construct_ip_cf_backedges(void);
+FIRM_DLL int construct_ip_cf_backedges(void);
#endif
/**
* Removes all loop information.
* Resets all backedges. Works for any construction algorithm.
*/
-void free_loop_information(ir_graph *irg);
-void free_all_loop_information (void);
+FIRM_DLL void free_loop_information(ir_graph *irg);
+FIRM_DLL void free_all_loop_information (void);
/* ------------------------------------------------------------------- */
*
* Returns non-zero, if the node n is not changed in the loop block
* belongs to or in inner loops of this block. */
-int is_loop_invariant(const ir_node *n, const ir_node *block);
+FIRM_DLL int is_loop_invariant(const ir_node *n, const ir_node *block);
+
+#include "end.h"
#endif
#define FIRM_ANA_IRMEMORY_H
#include "firm_types.h"
+#include "begin.h"
/** The alias relation of two memory addresses. */
typedef enum {
* @param irn the node representing the base address
* @param ent the base entity of the base address iff any
*/
-ir_storage_class_class_t classify_pointer(const ir_graph *irg, const ir_node *irn, const ir_entity *ent);
+FIRM_DLL ir_storage_class_class_t classify_pointer(const ir_graph *irg,
+ const ir_node *irn,
+ const ir_entity *ent);
/**
* Returns a human readable name for an alias relation.
*/
-const char *get_ir_alias_relation_name(ir_alias_relation rel);
+FIRM_DLL const char *get_ir_alias_relation_name(ir_alias_relation rel);
/**
* Determine the alias relation between two addresses.
* If none of these rules apply, the points-to framework must be
* interrogated to detect the alias relation.
*/
-ir_alias_relation get_alias_relation(
+FIRM_DLL ir_alias_relation get_alias_relation(
const ir_graph *irg,
const ir_node *adr1, const ir_mode *mode1,
const ir_node *adr2, const ir_mode *mode2);
*
* @param func The callback.
*/
-void set_language_memory_disambiguator(DISAMBIGUATOR_FUNC func);
+FIRM_DLL void set_language_memory_disambiguator(DISAMBIGUATOR_FUNC func);
/**
* Initialize the relation cache.
*/
-void mem_disambig_init(void);
+FIRM_DLL void mem_disambig_init(void);
/*
* Determine the alias relation between two addresses and
*
* @see get_alias_relation()
*/
-ir_alias_relation get_alias_relation_ex(
+FIRM_DLL ir_alias_relation get_alias_relation_ex(
const ir_graph *irg,
const ir_node *adr1, const ir_mode *mode1,
const ir_node *adr2, const ir_mode *mode2);
/**
* Free the relation cache.
*/
-void mem_disambig_term(void);
+FIRM_DLL void mem_disambig_term(void);
-ir_entity_usage_computed_state get_irg_entity_usage_state(const ir_graph *irg);
+FIRM_DLL ir_entity_usage_computed_state get_irg_entity_usage_state(const ir_graph *irg);
-void set_irg_entity_usage_state(ir_graph *irg, ir_entity_usage_computed_state state);
+FIRM_DLL void set_irg_entity_usage_state(ir_graph *irg,
+ ir_entity_usage_computed_state state);
/**
* Assure that the entity usage flags have been computed for the given graph.
* Even then the information is not cleaned from the variables, call
* assure_irg_entity_usage_computed() again for recomputation.
*/
-void assure_irg_entity_usage_computed(ir_graph *irg);
+FIRM_DLL void assure_irg_entity_usage_computed(ir_graph *irg);
/**
* Returns the current address taken state of the globals.
*/
-ir_entity_usage_computed_state get_irp_globals_entity_usage_state(void);
+FIRM_DLL ir_entity_usage_computed_state get_irp_globals_entity_usage_state(void);
/**
* Sets the current address taken state of the globals.
*
* @param state the new state
*/
-void set_irp_globals_entity_usage_state(ir_entity_usage_computed_state state);
+FIRM_DLL void set_irp_globals_entity_usage_state(ir_entity_usage_computed_state state);
/**
* Assure that the address taken flag is computed for the global and TLS entities (variables).
* Even then the information is not cleaned from the variables, call
* assure_irp_globals_entity_usage_computed() again for recomputation.
*/
-void assure_irp_globals_entity_usage_computed(void);
+FIRM_DLL void assure_irp_globals_entity_usage_computed(void);
/**
* Get the memory disambiguator options for a graph.
*
* @param irg the graph
*/
-unsigned get_irg_memory_disambiguator_options(const ir_graph *irg);
+FIRM_DLL unsigned get_irg_memory_disambiguator_options(const ir_graph *irg);
/**
* Set the memory disambiguator options for a graph.
* @param irg the graph
* @param options a set of options
*/
-void set_irg_memory_disambiguator_options(ir_graph *irg, unsigned options);
+FIRM_DLL void set_irg_memory_disambiguator_options(ir_graph *irg,
+ unsigned options);
/**
* Set the global disambiguator options for all graphs not having local options.
*
* @param options a set of options
*/
-void set_irp_memory_disambiguator_options(unsigned options);
+FIRM_DLL void set_irp_memory_disambiguator_options(unsigned options);
/**
* Mark all private methods, i.e. those of which all call sites are known.
* We use a very convervative estimation yet: If the address of a method is
* never taken AND its visibility is visibility_local, then it's private.
*/
-void mark_private_methods(void);
+FIRM_DLL void mark_private_methods(void);
/**
* Creates an ir_prog pass for mark_private_methods().
*
* @return the newly created ir_prog pass
*/
-ir_prog_pass_t *mark_private_methods_pass(const char *name);
+FIRM_DLL ir_prog_pass_t *mark_private_methods_pass(const char *name);
-#endif /* FIRM_ANA_IRMEMORY_H */
+#include "end.h"
+
+#endif
#define FIRM_IR_IRMODE_H
#include "firm_types.h"
+#include "begin.h"
/* ********** Predefined modes ********** */
} ir_mode_arithmetic;
/** Returns the name of the arithmetic type. */
-const char *get_mode_arithmetic_name(ir_mode_arithmetic ari);
+FIRM_DLL const char *get_mode_arithmetic_name(ir_mode_arithmetic ari);
/* ********** Constructor for user defined modes **************** */
/**
* It is allowed to construct the default modes. So, a call
* new_ir_mode("Is", irms_int_number, 32, 1, irma_twos_complement, 32) will return mode_Is.
*/
-ir_mode *new_ir_mode(const char *name, ir_mode_sort sort, int bit_size, int sign,
- ir_mode_arithmetic arithmetic, unsigned int modulo_shift);
+FIRM_DLL ir_mode *new_ir_mode(const char *name, ir_mode_sort sort, int bit_size,
+ int sign, ir_mode_arithmetic arithmetic,
+ unsigned int modulo_shift);
/**
* Creates a new vector mode.
* @return
* The new mode or NULL on error.
*/
-ir_mode *new_ir_vector_mode(const char *name, ir_mode_sort sort, int bit_size, unsigned num_of_elem, int sign,
- ir_mode_arithmetic arithmetic, unsigned int modulo_shift);
+FIRM_DLL ir_mode *new_ir_vector_mode(const char *name, ir_mode_sort sort,
+ int bit_size, unsigned num_of_elem,
+ int sign, ir_mode_arithmetic arithmetic,
+ unsigned int modulo_shift);
/**
* Checks whether a pointer points to a mode.
* @return
* true if the thing is a mode, else false
*/
-int is_mode(const void *thing);
+FIRM_DLL int is_mode(const void *thing);
/* ********** Access methods to read mode information *********** */
/** Returns the ident* of the mode */
-ident *get_mode_ident(const ir_mode *mode);
+FIRM_DLL ident *get_mode_ident(const ir_mode *mode);
/** Returns the null-terminated name of this mode. */
-const char *get_mode_name(const ir_mode *mode);
+FIRM_DLL const char *get_mode_name(const ir_mode *mode);
/** Returns a coarse classification of the mode. */
-ir_mode_sort get_mode_sort(const ir_mode *mode);
+FIRM_DLL ir_mode_sort get_mode_sort(const ir_mode *mode);
/** Returns the size of values of the mode in bits. */
-unsigned get_mode_size_bits(const ir_mode *mode);
+FIRM_DLL unsigned get_mode_size_bits(const ir_mode *mode);
/** Returns the size of values of the mode in bytes.
* If the size is not dividable by 8 returns -1. */
-unsigned get_mode_size_bytes(const ir_mode *mode);
+FIRM_DLL unsigned get_mode_size_bytes(const ir_mode *mode);
/** Returns the signess of a mode.
*
* Returns the signess of a mode: 1 if mode is signed. */
-int get_mode_sign(const ir_mode *mode);
+FIRM_DLL int get_mode_sign(const ir_mode *mode);
/** Returns the arithmetic of a mode */
-ir_mode_arithmetic get_mode_arithmetic(const ir_mode *mode);
+FIRM_DLL ir_mode_arithmetic get_mode_arithmetic(const ir_mode *mode);
/** Get the modulo shift attribute.
*
* whether shift applies modulo to value of bits to shift. Zero for
* modes that are not integer.
*/
-unsigned int get_mode_modulo_shift(const ir_mode *mode);
+FIRM_DLL unsigned int get_mode_modulo_shift(const ir_mode *mode);
/** Return the number of vector elements.
*
* a vector mode. For non-vector modes it returns 1 for data and 0
* for all other modes
*/
-unsigned int get_mode_n_vector_elems(const ir_mode *mode);
+FIRM_DLL unsigned int get_mode_n_vector_elems(const ir_mode *mode);
/** Returns the stored intermediate information. */
-void *get_mode_link(const ir_mode *mode);
+FIRM_DLL void *get_mode_link(const ir_mode *mode);
/** Stores new intermediate information. */
-void set_mode_link(ir_mode *mode, void *l);
+FIRM_DLL void set_mode_link(ir_mode *mode, void *l);
/**
* Returns the smallest representable value of a given mode.
* For modes of the sort float_number this is the most negative value
* bigger than -infinite.
*/
-tarval *get_mode_min(ir_mode *mode);
+FIRM_DLL tarval *get_mode_min(ir_mode *mode);
/**
* Returns the biggest representable value o f a given mode.
* For modes of the sort float_number this is the largest value lower
* than infinite.
*/
-tarval *get_mode_max(ir_mode *mode);
+FIRM_DLL tarval *get_mode_max(ir_mode *mode);
/**
* Returns the value Zero represented in this mode.
* op_pin_state_floats and ints, and references (NULL-Pointer)
* else returns tarval_bad.
*/
-tarval *get_mode_null(ir_mode *mode);
+FIRM_DLL tarval *get_mode_null(ir_mode *mode);
/**
* Returns the value One, represented in this mode.
* is defined only for modes allowing multiplication,
* i.e. ints and floats.
*/
-tarval *get_mode_one(ir_mode *mode);
+FIRM_DLL tarval *get_mode_one(ir_mode *mode);
/**
* Returns the value Minus One, represented in this mode.
* Minus One is defined only for modes allowing
* multiplication with signed values, i.e. signed ints and floats.
*/
-tarval *get_mode_minus_one(ir_mode *mode);
+FIRM_DLL tarval *get_mode_minus_one(ir_mode *mode);
/**
* Returns the value where all bits are One, represented in this mode.
*
* All One is defined only for modes integer, reference and boolean modes
*/
-tarval *get_mode_all_one(ir_mode *mode);
+FIRM_DLL tarval *get_mode_all_one(ir_mode *mode);
/**
* Returns the positive infinite value of a mode.
* This is only valid for float_numbers, other modes
* will result in tarval_bad.
*/
-tarval *get_mode_infinite(ir_mode *mode);
+FIRM_DLL tarval *get_mode_infinite(ir_mode *mode);
/**
* Returns the NAN value of a given mode.
* This is only valid for float_numbers, other modes
* will result in tarval_bad.
*/
-tarval *get_mode_NAN(ir_mode *mode);
+FIRM_DLL tarval *get_mode_NAN(ir_mode *mode);
-extern ir_mode *mode_M; /**< memory */
+ir_mode *mode_M; /**< memory */
/* -- A set of predefined, numerical modes according to Techreport 1999-44 -- */
-extern ir_mode *mode_F; /**< signed float(32) */
-extern ir_mode *mode_D; /**< signed double(64) */
-extern ir_mode *mode_E; /**< signed extended(80) */
-extern ir_mode *mode_Bs; /**< signed byte (former char) */
-extern ir_mode *mode_Bu; /**< unsigned byte (former char) */
-extern ir_mode *mode_Hs; /**< signed short integer */
-extern ir_mode *mode_Hu; /**< unsigned short integer */
-extern ir_mode *mode_Is; /**< signed integer */
-extern ir_mode *mode_Iu; /**< unsigned integer */
-extern ir_mode *mode_Ls; /**< signed long integer */
-extern ir_mode *mode_Lu; /**< unsigned long integer */
-extern ir_mode *mode_LLs; /**< signed long long integer */
-extern ir_mode *mode_LLu; /**< unsigned long long integer */
-
-extern ir_mode *mode_P; /**< pointer */
-extern ir_mode *mode_P_code; /**< A pointer mode that is set by the client of libfirm. This mode
+FIRM_DLL ir_mode *mode_F; /**< signed float(32) */
+FIRM_DLL ir_mode *mode_D; /**< signed double(64) */
+FIRM_DLL ir_mode *mode_E; /**< signed extended(80) */
+FIRM_DLL ir_mode *mode_Bs; /**< signed byte (former char) */
+FIRM_DLL ir_mode *mode_Bu; /**< unsigned byte (former char) */
+FIRM_DLL ir_mode *mode_Hs; /**< signed short integer */
+FIRM_DLL ir_mode *mode_Hu; /**< unsigned short integer */
+FIRM_DLL ir_mode *mode_Is; /**< signed integer */
+FIRM_DLL ir_mode *mode_Iu; /**< unsigned integer */
+FIRM_DLL ir_mode *mode_Ls; /**< signed long integer */
+FIRM_DLL ir_mode *mode_Lu; /**< unsigned long integer */
+FIRM_DLL ir_mode *mode_LLs; /**< signed long long integer */
+FIRM_DLL ir_mode *mode_LLu; /**< unsigned long long integer */
+
+FIRM_DLL ir_mode *mode_P; /**< pointer */
+FIRM_DLL ir_mode *mode_P_code; /**< A pointer mode that is set by the client of libfirm. This mode
represents the pointer size of the target machine code addresses. Is initialized
to mode_P. */
-extern ir_mode *mode_P_data; /**< A pointer mode that is set by the client of libfirm. This mode
+FIRM_DLL ir_mode *mode_P_data; /**< A pointer mode that is set by the client of libfirm. This mode
represents the pointer size of the target machine data addresses. Is initialized
to mode_P. */
/* -- Auxiliary modes necessary for the Firm representation -- */
-extern ir_mode *mode_b; /**< internal boolean */
+FIRM_DLL ir_mode *mode_b; /**< internal boolean */
-extern ir_mode *mode_X; /**< execution */
-extern ir_mode *mode_BB; /**< block */
+FIRM_DLL ir_mode *mode_X; /**< execution */
+FIRM_DLL ir_mode *mode_BB; /**< block */
-extern ir_mode *mode_T; /**< tuple (none) */
-extern ir_mode *mode_ANY;/**< undefined mode */
-extern ir_mode *mode_BAD;/**< bad mode */
+FIRM_DLL ir_mode *mode_T; /**< tuple (none) */
+FIRM_DLL ir_mode *mode_ANY;/**< undefined mode */
+FIRM_DLL ir_mode *mode_BAD;/**< bad mode */
/*@{*/
-/** Access routines for JNI Interface */
-ir_mode *get_modeF(void);
-ir_mode *get_modeD(void);
-ir_mode *get_modeE(void);
-ir_mode *get_modeBs(void);
-ir_mode *get_modeBu(void);
-ir_mode *get_modeHs(void);
-ir_mode *get_modeHu(void);
-ir_mode *get_modeIs(void);
-ir_mode *get_modeIu(void);
-ir_mode *get_modeLs(void);
-ir_mode *get_modeLu(void);
-ir_mode *get_modeLLs(void);
-ir_mode *get_modeLLu(void);
-ir_mode *get_modeP(void);
-ir_mode *get_modeb(void);
-ir_mode *get_modeX(void);
-ir_mode *get_modeBB(void);
-ir_mode *get_modeM(void);
-ir_mode *get_modeT(void);
-ir_mode *get_modeANY(void);
-ir_mode *get_modeBAD(void);
+FIRM_DLL ir_mode *get_modeF(void);
+FIRM_DLL ir_mode *get_modeD(void);
+FIRM_DLL ir_mode *get_modeE(void);
+FIRM_DLL ir_mode *get_modeBs(void);
+FIRM_DLL ir_mode *get_modeBu(void);
+FIRM_DLL ir_mode *get_modeHs(void);
+FIRM_DLL ir_mode *get_modeHu(void);
+FIRM_DLL ir_mode *get_modeIs(void);
+FIRM_DLL ir_mode *get_modeIu(void);
+FIRM_DLL ir_mode *get_modeLs(void);
+FIRM_DLL ir_mode *get_modeLu(void);
+FIRM_DLL ir_mode *get_modeLLs(void);
+FIRM_DLL ir_mode *get_modeLLu(void);
+FIRM_DLL ir_mode *get_modeP(void);
+FIRM_DLL ir_mode *get_modeb(void);
+FIRM_DLL ir_mode *get_modeX(void);
+FIRM_DLL ir_mode *get_modeBB(void);
+FIRM_DLL ir_mode *get_modeM(void);
+FIRM_DLL ir_mode *get_modeT(void);
+FIRM_DLL ir_mode *get_modeANY(void);
+FIRM_DLL ir_mode *get_modeBAD(void);
/** Returns the machine specific pointer mode for code addresses. */
-ir_mode *get_modeP_code(void);
+FIRM_DLL ir_mode *get_modeP_code(void);
/** Returns the machine specific pointer mode for data addresses. */
-ir_mode *get_modeP_data(void);
+FIRM_DLL ir_mode *get_modeP_data(void);
/**
* Sets the machine specific pointer mode for code addresses.
* If not set, the predefined mode mode_P will be used.
*/
-void set_modeP_code(ir_mode *p);
+FIRM_DLL void set_modeP_code(ir_mode *p);
/**
* Sets the machine specific pointer mode for data addresses.
* If not set, the predefined mode mode_P will be used.
*/
-void set_modeP_data(ir_mode *p);
+FIRM_DLL void set_modeP_data(ir_mode *p);
/*@{*/
/**
Vector "int" and "float" are defined by the arithmetic and vector_elem > 1.
*/
/* Test for a certain class of modes. */
-int mode_is_signed (const ir_mode *mode);
-int mode_is_float (const ir_mode *mode);
-int mode_is_int (const ir_mode *mode);
-int mode_is_reference (const ir_mode *mode);
-int mode_is_num (const ir_mode *mode);
-int mode_is_data (const ir_mode *mode);
-int mode_is_datab (const ir_mode *mode);
-int mode_is_dataM (const ir_mode *mode);
-int mode_is_float_vector (const ir_mode *mode);
-int mode_is_int_vector (const ir_mode *mode);
+FIRM_DLL int mode_is_signed (const ir_mode *mode);
+FIRM_DLL int mode_is_float (const ir_mode *mode);
+FIRM_DLL int mode_is_int (const ir_mode *mode);
+FIRM_DLL int mode_is_reference (const ir_mode *mode);
+FIRM_DLL int mode_is_num (const ir_mode *mode);
+FIRM_DLL int mode_is_data (const ir_mode *mode);
+FIRM_DLL int mode_is_datab (const ir_mode *mode);
+FIRM_DLL int mode_is_dataM (const ir_mode *mode);
+FIRM_DLL int mode_is_float_vector (const ir_mode *mode);
+FIRM_DLL int mode_is_int_vector (const ir_mode *mode);
/*@}*/
/**
*
* @see values_in_mode()
*/
-int smaller_mode(const ir_mode *sm, const ir_mode *lm);
+FIRM_DLL int smaller_mode(const ir_mode *sm, const ir_mode *lm);
/**
* Returns true if a value of mode sm can be converted into mode lm
*
* @see smaller_mode()
*/
-int values_in_mode(const ir_mode *sm, const ir_mode *lm);
+FIRM_DLL int values_in_mode(const ir_mode *sm, const ir_mode *lm);
/**
* Returns a matching unsigned mode for a given integer signed mode.
* Returns NULL if no matching mode exists.
*/
-ir_mode *find_unsigned_mode(const ir_mode *mode);
+FIRM_DLL ir_mode *find_unsigned_mode(const ir_mode *mode);
/**
* Returns a matching signed mode for a given integer unsigned mode.
* Returns NULL if no matching mode exists.
*/
-ir_mode *find_signed_mode(const ir_mode *mode);
+FIRM_DLL ir_mode *find_signed_mode(const ir_mode *mode);
/**
* Returns an integer mode with 2*n bits for a given integer mode with n bits.
* Returns NULL if no matching mode exists.
*/
-ir_mode *find_double_bits_int_mode(const ir_mode *mode);
+FIRM_DLL ir_mode *find_double_bits_int_mode(const ir_mode *mode);
/**
* Returns non-zero if the given mode honors signed zero's, i.e.,
* a +0 and a -0 exists and handled differently.
*/
-int mode_honor_signed_zeros(const ir_mode *mode);
+FIRM_DLL int mode_honor_signed_zeros(const ir_mode *mode);
/**
* Returns non-zero if the given mode might overflow on unary Minus.
*/
-int mode_overflow_on_unary_Minus(const ir_mode *mode);
+FIRM_DLL int mode_overflow_on_unary_Minus(const ir_mode *mode);
/**
* Returns non-zero if the mode has a reversed wrap-around
* This is normally true for integer modes, not for floating
* point modes.
*/
-int mode_wrap_around(const ir_mode *mode);
+FIRM_DLL int mode_wrap_around(const ir_mode *mode);
/**
* Return the signed integer equivalent mode for an reference mode.
*/
-ir_mode *get_reference_mode_signed_eq(ir_mode *mode);
+FIRM_DLL ir_mode *get_reference_mode_signed_eq(ir_mode *mode);
/**
* Sets the signed integer equivalent mode for an reference mode.
*/
-void set_reference_mode_signed_eq(ir_mode *ref_mode, ir_mode *int_mode);
+FIRM_DLL void set_reference_mode_signed_eq(ir_mode *ref_mode, ir_mode *int_mode);
/**
* Return the unsigned integer equivalent mode for an reference mode.
*/
-ir_mode *get_reference_mode_unsigned_eq(ir_mode *mode);
+FIRM_DLL ir_mode *get_reference_mode_unsigned_eq(ir_mode *mode);
/**
* Sets the unsigned integer equivalent mode for an reference mode.
*/
-void set_reference_mode_unsigned_eq(ir_mode *ref_mode, ir_mode *int_mode);
+FIRM_DLL void set_reference_mode_unsigned_eq(ir_mode *ref_mode, ir_mode *int_mode);
/**
* Returns non-zero if the cast from mode src to mode dst is a
* reinterpret cast (ie. only the bit pattern is reinterpreted,
* no conversion is done)
*/
-int is_reinterpret_cast(const ir_mode *src, const ir_mode *dst);
+FIRM_DLL int is_reinterpret_cast(const ir_mode *src, const ir_mode *dst);
/**
* Returns the primitive type matching the given mode
*/
-ir_type *get_type_for_mode(const ir_mode *mode);
+FIRM_DLL ir_type *get_type_for_mode(const ir_mode *mode);
+
+#include "end.h"
#endif
#include "typerep.h"
#include "irop.h"
#include "irmode.h"
-
-/**
- * @file irnode.h
- *
- * @author Martin Trapp, Christian Schaefer
- *
- * Declarations of an ir node.
- */
+#include "begin.h"
/**
* @defgroup ir_node Declarations of an ir node.
* @param thing an arbitrary pointer
* @return non-zero if the thing is a ir mode, else zero
*/
-int is_ir_node (const void *thing);
+FIRM_DLL int is_ir_node (const void *thing);
/**
* Returns the number of predecessors without the block predecessor.
*
* @param node the IR-node
*/
-int get_irn_arity (const ir_node *node);
-int get_irn_intra_arity(const ir_node *node);
-int get_irn_inter_arity(const ir_node *node);
+FIRM_DLL int get_irn_arity (const ir_node *node);
+FIRM_DLL int get_irn_intra_arity(const ir_node *node);
+FIRM_DLL int get_irn_inter_arity(const ir_node *node);
/** Replaces the old in array by a new one that will contain the ins given in
the parameters. Conserves the block predecessor. It copies the array passed.
Assumes that current_ir_graph is set to the graph containing "node".
"in" must contain all predecessors except the block that are required for
the nodes opcode. */
-void set_irn_in(ir_node *node, int arity, ir_node *in[]);
+FIRM_DLL void set_irn_in(ir_node *node, int arity, ir_node *in[]);
/* to iterate through the predecessors without touching the array. No
order of predecessors guaranteed.
* This function removes Id predecessors.
* This function automatically handles intra- and interprocedural views.
*/
-ir_node *get_irn_n(const ir_node *node, int n);
+FIRM_DLL ir_node *get_irn_n(const ir_node *node, int n);
/**
-* Add a artificial dependency to the node.
-* The dependency is only inserted if it is not there already.
-* This is only allowed in phase_backend!
-*
-* @param node The node.
-* @param dep The dependency target.
-*
-* @return The index in the array (get_irn_dep() with that index returns @p dep).
-*/
-int add_irn_dep(ir_node *node, ir_node *dep);
+ * Add a artificial dependency to the node.
+ * The dependency is only inserted if it is not there already.
+ * This is only allowed in phase_backend!
+ *
+ * @param node The node.
+ * @param dep The dependency target.
+ *
+ * @return The index in the array (get_irn_dep with that index returns @p dep).
+ */
+FIRM_DLL int add_irn_dep(ir_node *node, ir_node *dep);
/**
* Copy all dependencies from a node to another.
* @param tgt The node which should be enriched.
* @param src The node whose dependencies shall be copied.
*/
-void add_irn_deps(ir_node *tgt, ir_node *src);
+FIRM_DLL void add_irn_deps(ir_node *tgt, ir_node *src);
/**
* Get the length of the dependency array.
* @param node The node.
* @return The length of the dependency array or 0 if it has not yet been allocated.
*/
-int get_irn_deps(const ir_node *node);
+FIRM_DLL int get_irn_deps(const ir_node *node);
/**
* Get an entry of the dependency array.
* @param pos The position.
* @return The node at that position.
*/
-ir_node *get_irn_dep(const ir_node *node, int pos);
+FIRM_DLL ir_node *get_irn_dep(const ir_node *node, int pos);
/**
* Set an entry of the dependency array.
* @param pos The position.
* @param dep The dependency target.
*/
-void set_irn_dep(ir_node *node, int pos, ir_node *dep);
+FIRM_DLL void set_irn_dep(ir_node *node, int pos, ir_node *dep);
/**
* Get the n-th predecessor of a node in intraprocedural view.
* Can be used always if it's know that node is not a split one.
*/
-ir_node *get_irn_intra_n(const ir_node *node, int n);
+FIRM_DLL ir_node *get_irn_intra_n(const ir_node *node, int n);
/**
* Get the n-th predecessor of a node in interprocedural view.
*/
-ir_node *get_irn_inter_n(const ir_node *node, int n);
+FIRM_DLL ir_node *get_irn_inter_n(const ir_node *node, int n);
/** Replace the n-th predecessor of a node with a new one. */
-void set_irn_n(ir_node *node, int n, ir_node *in);
+FIRM_DLL void set_irn_n(ir_node *node, int n, ir_node *in);
/**
* Appends a new predecessor to a node. This only works for nodes with
* variable arity!
* @returns the number of the new input
*/
-int add_irn_n(ir_node *node, ir_node *in);
+FIRM_DLL int add_irn_n(ir_node *node, ir_node *in);
/* Remove predecessor i from Sync n */
-void del_Sync_n(ir_node *n, int i);
+FIRM_DLL void del_Sync_n(ir_node *n, int i);
/* Sets the mode struct of node. */
-void set_irn_mode(ir_node *node, ir_mode *mode);
+FIRM_DLL void set_irn_mode(ir_node *node, ir_mode *mode);
/** Gets the mode struct of a node. */
-ir_mode *get_irn_mode(const ir_node *node);
+FIRM_DLL ir_mode *get_irn_mode(const ir_node *node);
/** Gets the ident for a string representation of the mode .*/
-ident *get_irn_modeident(const ir_node *node);
+FIRM_DLL ident *get_irn_modeident(const ir_node *node);
/** Gets the string representation of the mode .*/
-const char *get_irn_modename(const ir_node *node);
+FIRM_DLL const char *get_irn_modename(const ir_node *node);
/** Gets the opcode struct of the node. */
-ir_op *get_irn_op(const ir_node *node);
+FIRM_DLL ir_op *get_irn_op(const ir_node *node);
/** Sets the opcode struct of the node. */
-void set_irn_op(ir_node *node, ir_op *op);
+FIRM_DLL void set_irn_op(ir_node *node, ir_op *op);
/** Gets the opcode-enum of the node. */
-unsigned get_irn_opcode(const ir_node *node);
+FIRM_DLL unsigned get_irn_opcode(const ir_node *node);
/** Get the string representation of the opcode. */
-const char *get_irn_opname(const ir_node *node);
+FIRM_DLL const char *get_irn_opname(const ir_node *node);
/** Get the ident for a string representation of the opcode. */
-ident *get_irn_opident(const ir_node *node);
+FIRM_DLL ident *get_irn_opident(const ir_node *node);
/** If arg is an argument of the node, returns it's position, -1 otherwise */
-int get_irn_pred_pos(ir_node *node, ir_node *arg);
+FIRM_DLL int get_irn_pred_pos(ir_node *node, ir_node *arg);
/** Gets the visited counter of a node. */
-ir_visited_t get_irn_visited(const ir_node *node);
+FIRM_DLL ir_visited_t get_irn_visited(const ir_node *node);
/** Sets the visited counter of a node. */
-void set_irn_visited(ir_node *node, ir_visited_t visited);
+FIRM_DLL void set_irn_visited(ir_node *node, ir_visited_t visited);
/** Sets visited to get_irg_visited(current_ir_graph). */
-void mark_irn_visited(ir_node *node);
+FIRM_DLL void mark_irn_visited(ir_node *node);
/** Returns 1 if visited >= get_irg_visited(current_ir_graph). */
-int irn_visited(const ir_node *node);
+FIRM_DLL int irn_visited(const ir_node *node);
/** Returns 1 if visited >= get_irg_visited(current_ir_graph). Marks the node
* visited, if it was not. */
-int irn_visited_else_mark(ir_node *node);
+FIRM_DLL int irn_visited_else_mark(ir_node *node);
/**
* Sets the link of a node.
* Only allowed if the graph is NOT in phase_building.
*/
-void set_irn_link(ir_node *node, void *link);
+FIRM_DLL void set_irn_link(ir_node *node, void *link);
/** Returns the link of a node. */
-void *get_irn_link(const ir_node *node);
+FIRM_DLL void *get_irn_link(const ir_node *node);
/** Returns the ir_graph this node belongs to. */
-ir_graph *get_irn_irg(const ir_node *node);
+FIRM_DLL ir_graph *get_irn_irg(const ir_node *node);
/** Outputs a unique number for this node if libFIRM is compiled for
debugging, (configure with --enable-debug) else returns address
of node cast to long. */
-long get_irn_node_nr(const ir_node *node);
+FIRM_DLL long get_irn_node_nr(const ir_node *node);
/** Returns the pinned state of a node.
*
*
* @returns Either state op_pin_state_pinned or op_pin_state_floats.
*/
-op_pin_state get_irn_pinned(const ir_node *node);
+FIRM_DLL op_pin_state get_irn_pinned(const ir_node *node);
/** Set pin state for nodes with op pin state op_pin_state_exc_pinned */
-void set_irn_pinned(ir_node *node, op_pin_state state);
+FIRM_DLL void set_irn_pinned(ir_node *node, op_pin_state state);
/** Returns whether the node is currently pinned.
*
* node belongs to is in state op_poin_state_floats then this function
* returns 'floats', else 'pinned'.
*/
-op_pin_state is_irn_pinned_in_irg(const ir_node *node);
+FIRM_DLL op_pin_state is_irn_pinned_in_irg(const ir_node *node);
/**
* IR node constructor.
* @param arity The arity of the new node, <0 if can be changed dynamically.
* @param in An array of arity predecessor nodes.
*/
-ir_node *new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op,
- ir_mode *mode, int arity, ir_node *in[]);
+FIRM_DLL ir_node *new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block,
+ ir_op *op, ir_mode *mode,
+ int arity, ir_node *in[]);
/**
* Return the block the node belongs to. This is only
* To express the difference to access routines that work for all
* nodes we use infix "nodes" and do not name this function
* get_irn_block(). */
-ir_node *get_nodes_block (const ir_node *node);
+FIRM_DLL ir_node *get_nodes_block (const ir_node *node);
/** Sets the Block of a node. */
-void set_nodes_block (ir_node *node, ir_node *block);
+FIRM_DLL void set_nodes_block (ir_node *node, ir_node *block);
/**
* Return the MacroBlock the node belongs to. This is only
* To express the difference to access routines that work for all
* nodes we use infix "nodes" and do not name this function
* get_irn_MacroBlock(). */
-ir_node *get_nodes_MacroBlock(const ir_node *node);
+FIRM_DLL ir_node *get_nodes_MacroBlock(const ir_node *node);
/**
* Projection numbers for result of Start node: use for Proj nodes!
*
* Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
* from Start. If so returns frame type, else Null. */
-ir_type *is_frame_pointer(const ir_node *n);
+FIRM_DLL ir_type *is_frame_pointer(const ir_node *n);
/** Test whether arbitrary node is the thread local storage (tls) pointer.
*
* Test whether arbitrary node is tls pointer, i.e. Proj(pn_Start_P_tls)
* from Start. If so returns tls type, else Null. */
-ir_type *is_tls_pointer(const ir_node *n);
+FIRM_DLL ir_type *is_tls_pointer(const ir_node *n);
/** Return the number of control flow predecessors of a block. */
-int get_Block_n_cfgpreds(const ir_node *block);
+FIRM_DLL int get_Block_n_cfgpreds(const ir_node *block);
/** Return the control flow predecessor of a block at a given position. */
-ir_node *get_Block_cfgpred(const ir_node *block, int pos);
+FIRM_DLL ir_node *get_Block_cfgpred(const ir_node *block, int pos);
/** Set the control flow predecessor of a block at a given position. */
-void set_Block_cfgpred(ir_node *block, int pos, ir_node *pred);
+FIRM_DLL void set_Block_cfgpred(ir_node *block, int pos, ir_node *pred);
/**
* Return the position of the predecessor block pred in the inputs
* with exception exists, a predecessor block might have more
* than one position. In that case it is not specified, with is returned.
*/
-int get_Block_cfgpred_pos(const ir_node *block, const ir_node *pred);
+FIRM_DLL int get_Block_cfgpred_pos(const ir_node *block, const ir_node *pred);
/** Get the predecessor block.
*
* - If we encounter the Bad node, this function does not return
* Start block, but the Bad node.
*/
-ir_node *get_Block_cfgpred_block(const ir_node *node, int pos);
+FIRM_DLL ir_node *get_Block_cfgpred_block(const ir_node *node, int pos);
/** Return the matured flag of a block */
-int get_Block_matured(const ir_node *block);
+FIRM_DLL int get_Block_matured(const ir_node *block);
/** set the matured flag of a block. */
-void set_Block_matured(ir_node *block, int matured);
+FIRM_DLL void set_Block_matured(ir_node *block, int matured);
/** A visited flag only for block nodes.
* @see also: get_irn_visited() inc_irg_visited() inc_irg_block_visited()*/
-ir_visited_t get_Block_block_visited(const ir_node *block);
-void set_Block_block_visited(ir_node *block, ir_visited_t visit);
+FIRM_DLL ir_visited_t get_Block_block_visited(const ir_node *block);
+FIRM_DLL void set_Block_block_visited(ir_node *block, ir_visited_t visit);
/**
* Marks a block as dead but do not replace it with a Bad node.
* Dead blocks are removed in the con
*/
-ir_node *set_Block_dead(ir_node *block);
-int is_Block_dead(const ir_node *block);
+FIRM_DLL ir_node *set_Block_dead(ir_node *block);
+FIRM_DLL int is_Block_dead(const ir_node *block);
/* For this current_ir_graph must be set. */
-void mark_Block_block_visited(ir_node *node);
-int Block_block_visited(const ir_node *node);
+FIRM_DLL void mark_Block_block_visited(ir_node *node);
+FIRM_DLL int Block_block_visited(const ir_node *node);
#ifdef INTERPROCEDURAL_VIEW
/* Set and remove interprocedural predecessors. If the interprocedural
* predecessors are removed, the node has the same predecessors in
* both views.
* @@@ Maybe better: arity is zero if no cg preds. */
-void set_Block_cg_cfgpred_arr(ir_node *node, int arity, ir_node *in[]);
-void set_Block_cg_cfgpred(ir_node *node, int pos, ir_node *pred);
+FIRM_DLL void set_Block_cg_cfgpred_arr(ir_node *node, int arity, ir_node *in[]);
+FIRM_DLL void set_Block_cg_cfgpred(ir_node *node, int pos, ir_node *pred);
/* @@@ not supported */
-ir_node **get_Block_cg_cfgpred_arr(ir_node *node);
+FIRM_DLL ir_node **get_Block_cg_cfgpred_arr(ir_node *node);
/** Returns the number of interprocedural predecessors. 0 if none. */
-int get_Block_cg_n_cfgpreds(const ir_node *node);
+FIRM_DLL int get_Block_cg_n_cfgpreds(const ir_node *node);
/** Return the interprocedural predecessor at position pos. */
-ir_node *get_Block_cg_cfgpred(const ir_node *node, int pos);
+FIRM_DLL ir_node *get_Block_cg_cfgpred(const ir_node *node, int pos);
/** Frees the memory allocated for interprocedural predecessors. */
-void remove_Block_cg_cfgpred_arr(ir_node *node);
+FIRM_DLL void remove_Block_cg_cfgpred_arr(ir_node *node);
#endif
/** Returns the extended basic block a block belongs to. */
-ir_extblk *get_Block_extbb(const ir_node *block);
+FIRM_DLL ir_extblk *get_Block_extbb(const ir_node *block);
/** Sets the extended basic block a block belongs to. */
-void set_Block_extbb(ir_node *block, ir_extblk *extblk);
+FIRM_DLL void set_Block_extbb(ir_node *block, ir_extblk *extblk);
/** Get the Macro Block header of a (sub-) block. */
-ir_node *get_Block_MacroBlock(const ir_node *block);
+FIRM_DLL ir_node *get_Block_MacroBlock(const ir_node *block);
/** Set the Macro Block header of a (sub-) block. */
-void set_Block_MacroBlock(ir_node *block, ir_node *mbh);
+FIRM_DLL void set_Block_MacroBlock(ir_node *block, ir_node *mbh);
/** Get the Macro Block header of a node. */
-ir_node *get_irn_MacroBlock(const ir_node *n);
+FIRM_DLL ir_node *get_irn_MacroBlock(const ir_node *n);
/** Returns the ir_graph this Block belongs to. */
-ir_graph *get_Block_irg(const ir_node *block);
+FIRM_DLL ir_graph *get_Block_irg(const ir_node *block);
/** Returns non-zero if the block has an entity assigned */
-int has_Block_entity(const ir_node *block);
+FIRM_DLL int has_Block_entity(const ir_node *block);
/** Returns the entity for a Block */
-ir_entity *get_Block_entity(const ir_node *block);
+FIRM_DLL ir_entity *get_Block_entity(const ir_node *block);
/** Returns the entity for a Block (creating it if necessary) */
-ir_entity *create_Block_entity(ir_node *block);
+FIRM_DLL ir_entity *create_Block_entity(ir_node *block);
/** Set a new entity for a block */
-void set_Block_entity(ir_node *block, ir_entity *entity);
+FIRM_DLL void set_Block_entity(ir_node *block, ir_entity *entity);
/** Gets the head of the Phi list for this block. */
-ir_node *get_Block_phis(const ir_node *block);
+FIRM_DLL ir_node *get_Block_phis(const ir_node *block);
/** Sets the head of the Phi list for this block. */
-void set_Block_phis(ir_node *block, ir_node *phi);
+FIRM_DLL void set_Block_phis(ir_node *block, ir_node *phi);
/** Add a Phi node to the list of Block Phi's. */
-void add_Block_phi(ir_node *block, ir_node *phi);
+FIRM_DLL void add_Block_phi(ir_node *block, ir_node *phi);
/** Get the Block mark (single bit). */
-unsigned get_Block_mark(const ir_node *block);
+FIRM_DLL unsigned get_Block_mark(const ir_node *block);
/** Set the Block mark (single bit). */
-void set_Block_mark(ir_node *block, unsigned mark);
+FIRM_DLL void set_Block_mark(ir_node *block, unsigned mark);
/** Return the number of Keep alive node. */
-int get_End_n_keepalives(const ir_node *end);
+FIRM_DLL int get_End_n_keepalives(const ir_node *end);
/** Return the Keep alive node a position pos. */
-ir_node *get_End_keepalive(const ir_node *end, int pos);
+FIRM_DLL ir_node *get_End_keepalive(const ir_node *end, int pos);
/** Keep alive dedicated nodes. These must be either PhiM or Block nodes. */
-void add_End_keepalive(ir_node *end, ir_node *ka);
+FIRM_DLL void add_End_keepalive(ir_node *end, ir_node *ka);
/** Set the Keep alive node at position pos. */
-void set_End_keepalive(ir_node *end, int pos, ir_node *ka);
+FIRM_DLL void set_End_keepalive(ir_node *end, int pos, ir_node *ka);
/**
* Set new keep-alives.
* Beware: This might be an expensive operation if dynamic edges are enabled,
* so avoid it in the backend.
*/
-void set_End_keepalives(ir_node *end, int n, ir_node *in[]);
+FIRM_DLL void set_End_keepalives(ir_node *end, int n, ir_node *in[]);
/** Remove irn from the keep-alive set. */
-void remove_End_keepalive(ir_node *end, ir_node *irn);
+FIRM_DLL void remove_End_keepalive(ir_node *end, ir_node *irn);
/* Remove Bads, NoMem and doublets from the keep-alive set. */
-void remove_End_Bads_and_doublets(ir_node *end);
+FIRM_DLL void remove_End_Bads_and_doublets(ir_node *end);
/** Some parts of the End node are allocated separately -- their memory
is not recovered by dead_node_elimination if a End node is dead.
free_End() frees these data structures. */
-void free_End(ir_node *end);
+FIRM_DLL void free_End(ir_node *end);
/** Return the target address of an IJmp */
-ir_node *get_IJmp_target(const ir_node *ijmp);
+FIRM_DLL ir_node *get_IJmp_target(const ir_node *ijmp);
/** Sets the target address of an IJmp */
-void set_IJmp_target(ir_node *ijmp, ir_node *tgt);
+FIRM_DLL void set_IJmp_target(ir_node *ijmp, ir_node *tgt);
-ir_node *get_Cond_selector(const ir_node *node);
-void set_Cond_selector(ir_node *node, ir_node *selector);
-long get_Cond_default_proj(const ir_node *node);
-void set_Cond_default_proj(ir_node *node, long defproj);
+FIRM_DLL ir_node *get_Cond_selector(const ir_node *node);
+FIRM_DLL void set_Cond_selector(ir_node *node, ir_node *selector);
+FIRM_DLL long get_Cond_default_proj(const ir_node *node);
+FIRM_DLL void set_Cond_default_proj(ir_node *node, long defproj);
/**
* Projection numbers for conditions.
pn_Cond_max /**< number of projections from a Cond */
} pn_Cond; /* Projection numbers for Cond. */
-ir_node *get_Return_mem(const ir_node *node);
-void set_Return_mem(ir_node *node, ir_node *mem);
-ir_node **get_Return_res_arr(ir_node *node);
-int get_Return_n_ress(const ir_node *node);
-ir_node *get_Return_res(const ir_node *node, int pos);
-void set_Return_res(ir_node *node, int pos, ir_node *res);
+FIRM_DLL ir_node *get_Return_mem(const ir_node *node);
+FIRM_DLL void set_Return_mem(ir_node *node, ir_node *mem);
+FIRM_DLL ir_node **get_Return_res_arr(ir_node *node);
+FIRM_DLL int get_Return_n_ress(const ir_node *node);
+FIRM_DLL ir_node *get_Return_res(const ir_node *node, int pos);
+FIRM_DLL void set_Return_res(ir_node *node, int pos, ir_node *res);
-tarval *get_Const_tarval(const ir_node *node);
-void set_Const_tarval(ir_node *node, tarval *con);
+FIRM_DLL tarval *get_Const_tarval(const ir_node *node);
+FIRM_DLL void set_Const_tarval(ir_node *node, tarval *con);
/** Return non-zero if the given Const node represents the 0 constant. */
-int is_Const_null(const ir_node *node);
+FIRM_DLL int is_Const_null(const ir_node *node);
/** Return non-zero if the given Const node represents the 1 constant. */
-int is_Const_one(const ir_node *node);
+FIRM_DLL int is_Const_one(const ir_node *node);
/** Return non-zero if the given Const node represents the constant with all bits set. */
-int is_Const_all_one(const ir_node *node);
+FIRM_DLL int is_Const_all_one(const ir_node *node);
/** Returns the source language type of a Const node.
* Must be an atomic type. Mode of type must be mode of node.
*/
-ir_type *get_Const_type(const ir_node *node);
+FIRM_DLL ir_type *get_Const_type(const ir_node *node);
/** Sets the source language type of a Const node. */
-void set_Const_type(ir_node *node, ir_type *tp);
+FIRM_DLL void set_Const_type(ir_node *node, ir_type *tp);
/** Returns non-zero if s symconst kind has a type attribute */
#define SYMCONST_HAS_TYPE(kind) ((kind) <= symconst_type_align)
#define SYMCONST_HAS_ENUM(kind) ((kind) == symconst_enum_const)
/** Get the kind of the SymConst. */
-symconst_kind get_SymConst_kind(const ir_node *node);
+FIRM_DLL symconst_kind get_SymConst_kind(const ir_node *node);
/** Set the kind of the SymConst. */
-void set_SymConst_kind(ir_node *node, symconst_kind num);
+FIRM_DLL void set_SymConst_kind(ir_node *node, symconst_kind num);
/** Only to access SymConst of kind type_tag or size. Else assertion: */
-ir_type *get_SymConst_type(const ir_node *node);
-void set_SymConst_type(ir_node *node, ir_type *tp);
+FIRM_DLL ir_type *get_SymConst_type(const ir_node *node);
+FIRM_DLL void set_SymConst_type(ir_node *node, ir_type *tp);
/** Only to access SymConst of kind addr_ent. Else assertion: */
-ir_entity *get_SymConst_entity(const ir_node *node);
-void set_SymConst_entity(ir_node *node, ir_entity *ent);
+FIRM_DLL ir_entity *get_SymConst_entity(const ir_node *node);
+FIRM_DLL void set_SymConst_entity(ir_node *node, ir_entity *ent);
/** Only to access SymConst of kind symconst_enum_const. Else assertion: */
-ir_enum_const *get_SymConst_enum(const ir_node *node);
-void set_SymConst_enum(ir_node *node, ir_enum_const *ec);
+FIRM_DLL ir_enum_const *get_SymConst_enum(const ir_node *node);
+FIRM_DLL void set_SymConst_enum(ir_node *node, ir_enum_const *ec);
/** Sets both: type and ptrinfo. Needed to treat the node independent of
its semantics. Does a memcpy for the memory sym points to. */
/* write 'union': firmjni then does not create a method... */
-union symconst_symbol get_SymConst_symbol(const ir_node *node);
-void set_SymConst_symbol(ir_node *node,
- union symconst_symbol sym);
+FIRM_DLL union symconst_symbol get_SymConst_symbol(const ir_node *node);
+FIRM_DLL void set_SymConst_symbol(ir_node *node,
+ union symconst_symbol sym);
/** Access the type of the value represented by the SymConst.
*
* Example: primitive type int for SymConst size. */
-ir_type *get_SymConst_value_type(const ir_node *node);
-void set_SymConst_value_type(ir_node *node, ir_type *tp);
-
-ir_node *get_Sel_mem(const ir_node *node);
-void set_Sel_mem(ir_node *node, ir_node *mem);
-ir_node *get_Sel_ptr(const ir_node *node); /* ptr to the object to select from */
-void set_Sel_ptr(ir_node *node, ir_node *ptr);
-ir_node **get_Sel_index_arr(ir_node *node);
-int get_Sel_n_indexs(const ir_node *node);
-ir_node *get_Sel_index(const ir_node *node, int pos);
-void set_Sel_index(ir_node *node, int pos, ir_node *index);
-ir_entity *get_Sel_entity(const ir_node *node); /* entity to select */
-void set_Sel_entity (ir_node *node, ir_entity *ent);
+FIRM_DLL ir_type *get_SymConst_value_type(const ir_node *node);
+FIRM_DLL void set_SymConst_value_type(ir_node *node, ir_type *tp);
+
+FIRM_DLL ir_node *get_Sel_mem(const ir_node *node);
+FIRM_DLL void set_Sel_mem(ir_node *node, ir_node *mem);
+FIRM_DLL ir_node *get_Sel_ptr(const ir_node *node);
+FIRM_DLL void set_Sel_ptr(ir_node *node, ir_node *ptr);
+FIRM_DLL ir_node **get_Sel_index_arr(ir_node *node);
+FIRM_DLL int get_Sel_n_indexs(const ir_node *node);
+FIRM_DLL ir_node *get_Sel_index(const ir_node *node, int pos);
+FIRM_DLL void set_Sel_index(ir_node *node, int pos, ir_node *index);
+FIRM_DLL ir_entity *get_Sel_entity(const ir_node *node);
+FIRM_DLL void set_Sel_entity (ir_node *node, ir_entity *ent);
/**
* Projection numbers for result of Call node: use for Proj nodes!
} pn_Call; /* Projection numbers for Call. */
/** Retrieve the memory input of a Call. */
-ir_node *get_Call_mem(const ir_node *node);
+FIRM_DLL ir_node *get_Call_mem(const ir_node *node);
/** Set the memory input of a Call. */
-void set_Call_mem(ir_node *node, ir_node *mem);
+FIRM_DLL void set_Call_mem(ir_node *node, ir_node *mem);
/** Retrieve the call address of a Call. */
-ir_node *get_Call_ptr(const ir_node *node);
+FIRM_DLL ir_node *get_Call_ptr(const ir_node *node);
/** Set the call address of a Call. */
-void set_Call_ptr(ir_node *node, ir_node *ptr);
-ir_node **get_Call_param_arr(ir_node *node);
+FIRM_DLL void set_Call_ptr(ir_node *node, ir_node *ptr);
+FIRM_DLL ir_node **get_Call_param_arr(ir_node *node);
/** Gets the number of parameters of a call. */
-int get_Call_n_params(const ir_node *node);
+FIRM_DLL int get_Call_n_params(const ir_node *node);
/** Gets the call parameter at position pos. */
-ir_node *get_Call_param(const ir_node *node, int pos);
+FIRM_DLL ir_node *get_Call_param(const ir_node *node, int pos);
/** Sets the call parameter at position pos. */
-void set_Call_param(ir_node *node, int pos, ir_node *param);
+FIRM_DLL void set_Call_param(ir_node *node, int pos, ir_node *param);
/** Gets the type of a call. */
-ir_type *get_Call_type(const ir_node *node);
+FIRM_DLL ir_type *get_Call_type(const ir_node *node);
/** Sets the type of a call. */
-void set_Call_type(ir_node *node, ir_type *tp);
+FIRM_DLL void set_Call_type(ir_node *node, ir_type *tp);
/** Returns non-zero if this call can be a tail-call. */
-unsigned get_Call_tail_call(const ir_node *node);
+FIRM_DLL unsigned get_Call_tail_call(const ir_node *node);
/** Sets the tail call attribute. */
-void set_Call_tail_call(ir_node *node, unsigned tail_call);
+FIRM_DLL void set_Call_tail_call(ir_node *node, unsigned tail_call);
/**
* Returns non-zero if a Call is surely a self-recursive Call.
* Beware: if this functions returns 0, the call might be self-recursive!
*/
-int is_self_recursive_Call(const ir_node *call);
+FIRM_DLL int is_self_recursive_Call(const ir_node *call);
/** Set, get and remove the callee information for a Call node.
*
*
* @param node A Call node.
*/
-int Call_has_callees(const ir_node *node);
-int get_Call_n_callees(const ir_node *node);
-ir_entity *get_Call_callee(const ir_node *node, int pos);
+FIRM_DLL int Call_has_callees(const ir_node *node);
+FIRM_DLL int get_Call_n_callees(const ir_node *node);
+FIRM_DLL ir_entity *get_Call_callee(const ir_node *node, int pos);
/** Set the full callee array.
*
* The passed array is copied. Assumes current_ir_graph set properly! */
-void set_Call_callee_arr(ir_node *node, const int n, ir_entity **arr);
-void remove_Call_callee_arr(ir_node *node);
+FIRM_DLL void set_Call_callee_arr(ir_node *node, const int n, ir_entity **arr);
+FIRM_DLL void remove_Call_callee_arr(ir_node *node);
/**
* Projection numbers for result of Builtin node: use for Proj nodes!
pn_Builtin_max /**< number of projections from a Builtin */
} pn_Builtin; /* Projection numbers for Builtin. */
-ir_node *get_Builtin_mem(const ir_node *node);
-void set_Builtin_mem(ir_node *node, ir_node *mem);
-ir_builtin_kind get_Builtin_kind(const ir_node *node);
-void set_Builtin_kind(ir_node *node, ir_builtin_kind kind);
-ir_node **get_Builtin_param_arr(ir_node *node);
+FIRM_DLL ir_node *get_Builtin_mem(const ir_node *node);
+FIRM_DLL void set_Builtin_mem(ir_node *node, ir_node *mem);
+FIRM_DLL ir_builtin_kind get_Builtin_kind(const ir_node *node);
+FIRM_DLL void set_Builtin_kind(ir_node *node, ir_builtin_kind kind);
+FIRM_DLL ir_node **get_Builtin_param_arr(ir_node *node);
/** Gets the number of parameters of a Builtin. */
-int get_Builtin_n_params(const ir_node *node);
+FIRM_DLL int get_Builtin_n_params(const ir_node *node);
/** Gets the Builtin parameter at position pos. */
-ir_node *get_Builtin_param(const ir_node *node, int pos);
+FIRM_DLL ir_node *get_Builtin_param(const ir_node *node, int pos);
/** Sets the Builtin parameter at position pos. */
-void set_Builtin_param(ir_node *node, int pos, ir_node *param);
+FIRM_DLL void set_Builtin_param(ir_node *node, int pos, ir_node *param);
/** Gets the type of a builtin. */
-ir_type *get_Builtin_type(const ir_node *node);
+FIRM_DLL ir_type *get_Builtin_type(const ir_node *node);
/** Sets the type of a Builtin. */
-void set_Builtin_type(ir_node *node, ir_type *tp);
+FIRM_DLL void set_Builtin_type(ir_node *node, ir_type *tp);
/** Returns a human readable string for the ir_builtin_kind. */
-const char *get_builtin_kind_name(ir_builtin_kind kind);
+FIRM_DLL const char *get_builtin_kind_name(ir_builtin_kind kind);
/** Retrieve the call address of a CallBegin. */
-ir_node *get_CallBegin_ptr(const ir_node *node);
+FIRM_DLL ir_node *get_CallBegin_ptr(const ir_node *node);
/** Set the call address of a CallBegin. */
-void set_CallBegin_ptr(ir_node *node, ir_node *ptr);
+FIRM_DLL void set_CallBegin_ptr(ir_node *node, ir_node *ptr);
/** Retrieve the original Call node of a CallBegin. */
-ir_node *get_CallBegin_call(const ir_node *node);
+FIRM_DLL ir_node *get_CallBegin_call(const ir_node *node);
/** Set the original Call node of a CallBegin. */
-void set_CallBegin_call(ir_node *node, ir_node *call);
+FIRM_DLL void set_CallBegin_call(ir_node *node, ir_node *call);
/* For unary and binary arithmetic operations the access to the
operands can be factored out. Left is the first, right the
unops are: Minus, Abs, Not, Conv, Cast
binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
Shr, Shrs, Rotl, Cmp */
-int is_unop(const ir_node *node);
-ir_node *get_unop_op(const ir_node *node);
-void set_unop_op(ir_node *node, ir_node *op);
-int is_binop(const ir_node *node);
-ir_node *get_binop_left(const ir_node *node);
-void set_binop_left(ir_node *node, ir_node *left);
-ir_node *get_binop_right(const ir_node *node);
-void set_binop_right(ir_node *node, ir_node *right);
-
-ir_node *get_Add_left(const ir_node *node);
-void set_Add_left(ir_node *node, ir_node *left);
-ir_node *get_Add_right(const ir_node *node);
-void set_Add_right(ir_node *node, ir_node *right);
-
-ir_node *get_Carry_left(const ir_node *node);
-void set_Carry_left(ir_node *node, ir_node *left);
-ir_node *get_Carry_right(const ir_node *node);
-void set_Carry_right(ir_node *node, ir_node *right);
-
-ir_node *get_Borrow_left(const ir_node *node);
-void set_Borrow_left(ir_node *node, ir_node *left);
-ir_node *get_Borrow_right(const ir_node *node);
-void set_Borrow_right(ir_node *node, ir_node *right);
-
-ir_node *get_Sub_left(const ir_node *node);
-void set_Sub_left(ir_node *node, ir_node *left);
-ir_node *get_Sub_right(const ir_node *node);
-void set_Sub_right(ir_node *node, ir_node *right);
-
-ir_node *get_Minus_op(const ir_node *node);
-void set_Minus_op(ir_node *node, ir_node *op);
-
-ir_node *get_Mul_left(const ir_node *node);
-void set_Mul_left(ir_node *node, ir_node *left);
-ir_node *get_Mul_right(const ir_node *node);
-void set_Mul_right(ir_node *node, ir_node *right);
-
-ir_node *get_Mulh_left(const ir_node *node);
-void set_Mulh_left(ir_node *node, ir_node *left);
-ir_node *get_Mulh_right(const ir_node *node);
-void set_Mulh_right(ir_node *node, ir_node *right);
-
-ir_node *get_Quot_left(const ir_node *node);
-void set_Quot_left(ir_node *node, ir_node *left);
-ir_node *get_Quot_right(const ir_node *node);
-void set_Quot_right(ir_node *node, ir_node *right);
-ir_node *get_Quot_mem(const ir_node *node);
-void set_Quot_mem(ir_node *node, ir_node *mem);
-ir_mode *get_Quot_resmode(const ir_node *node);
-void set_Quot_resmode(ir_node *node, ir_mode *mode);
+FIRM_DLL int is_unop(const ir_node *node);
+FIRM_DLL ir_node *get_unop_op(const ir_node *node);
+FIRM_DLL void set_unop_op(ir_node *node, ir_node *op);
+FIRM_DLL int is_binop(const ir_node *node);
+FIRM_DLL ir_node *get_binop_left(const ir_node *node);
+FIRM_DLL void set_binop_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_binop_right(const ir_node *node);
+FIRM_DLL void set_binop_right(ir_node *node, ir_node *right);
+
+FIRM_DLL ir_node *get_Add_left(const ir_node *node);
+FIRM_DLL void set_Add_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_Add_right(const ir_node *node);
+FIRM_DLL void set_Add_right(ir_node *node, ir_node *right);
+
+FIRM_DLL ir_node *get_Carry_left(const ir_node *node);
+FIRM_DLL void set_Carry_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_Carry_right(const ir_node *node);
+FIRM_DLL void set_Carry_right(ir_node *node, ir_node *right);
+
+FIRM_DLL ir_node *get_Borrow_left(const ir_node *node);
+FIRM_DLL void set_Borrow_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_Borrow_right(const ir_node *node);
+FIRM_DLL void set_Borrow_right(ir_node *node, ir_node *right);
+
+FIRM_DLL ir_node *get_Sub_left(const ir_node *node);
+FIRM_DLL void set_Sub_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_Sub_right(const ir_node *node);
+FIRM_DLL void set_Sub_right(ir_node *node, ir_node *right);
+
+FIRM_DLL ir_node *get_Minus_op(const ir_node *node);
+FIRM_DLL void set_Minus_op(ir_node *node, ir_node *op);
+
+FIRM_DLL ir_node *get_Mul_left(const ir_node *node);
+FIRM_DLL void set_Mul_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_Mul_right(const ir_node *node);
+FIRM_DLL void set_Mul_right(ir_node *node, ir_node *right);
+
+FIRM_DLL ir_node *get_Mulh_left(const ir_node *node);
+FIRM_DLL void set_Mulh_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_Mulh_right(const ir_node *node);
+FIRM_DLL void set_Mulh_right(ir_node *node, ir_node *right);
+
+FIRM_DLL ir_node *get_Quot_left(const ir_node *node);
+FIRM_DLL void set_Quot_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_Quot_right(const ir_node *node);
+FIRM_DLL void set_Quot_right(ir_node *node, ir_node *right);
+FIRM_DLL ir_node *get_Quot_mem(const ir_node *node);
+FIRM_DLL void set_Quot_mem(ir_node *node, ir_node *mem);
+FIRM_DLL ir_mode *get_Quot_resmode(const ir_node *node);
+FIRM_DLL void set_Quot_resmode(ir_node *node, ir_mode *mode);
/**
* Projection numbers for Quot: use for Proj nodes!
pn_Quot_max /**< number of projections from a Quot */
} pn_Quot; /* Projection numbers for Quot. */
-ir_node *get_DivMod_left(const ir_node *node);
-void set_DivMod_left(ir_node *node, ir_node *left);
-ir_node *get_DivMod_right(const ir_node *node);
-void set_DivMod_right(ir_node *node, ir_node *right);
-ir_node *get_DivMod_mem(const ir_node *node);
-void set_DivMod_mem(ir_node *node, ir_node *mem);
-ir_mode *get_DivMod_resmode(const ir_node *node);
-void set_DivMod_resmode(ir_node *node, ir_mode *mode);
+FIRM_DLL ir_node *get_DivMod_left(const ir_node *node);
+FIRM_DLL void set_DivMod_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_DivMod_right(const ir_node *node);
+FIRM_DLL void set_DivMod_right(ir_node *node, ir_node *right);
+FIRM_DLL ir_node *get_DivMod_mem(const ir_node *node);
+FIRM_DLL void set_DivMod_mem(ir_node *node, ir_node *mem);
+FIRM_DLL ir_mode *get_DivMod_resmode(const ir_node *node);
+FIRM_DLL void set_DivMod_resmode(ir_node *node, ir_mode *mode);
/**
* Projection numbers for DivMod: use for Proj nodes!
pn_DivMod_max /**< number of projections from a DivMod */
} pn_DivMod; /* Projection numbers for DivMod. */
-ir_node *get_Div_left(const ir_node *node);
-void set_Div_left(ir_node *node, ir_node *left);
-ir_node *get_Div_right(const ir_node *node);
-void set_Div_right(ir_node *node, ir_node *right);
-ir_node *get_Div_mem(const ir_node *node);
-void set_Div_mem(ir_node *node, ir_node *mem);
-ir_mode *get_Div_resmode(const ir_node *node);
-void set_Div_resmode(ir_node *node, ir_mode *mode);
-int get_Div_no_remainder(const ir_node *node);
-void set_Div_no_remainder(ir_node *node, int no_remainder);
+FIRM_DLL ir_node *get_Div_left(const ir_node *node);
+FIRM_DLL void set_Div_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_Div_right(const ir_node *node);
+FIRM_DLL void set_Div_right(ir_node *node, ir_node *right);
+FIRM_DLL ir_node *get_Div_mem(const ir_node *node);
+FIRM_DLL void set_Div_mem(ir_node *node, ir_node *mem);
+FIRM_DLL ir_mode *get_Div_resmode(const ir_node *node);
+FIRM_DLL void set_Div_resmode(ir_node *node, ir_mode *mode);
+FIRM_DLL int get_Div_no_remainder(const ir_node *node);
+FIRM_DLL void set_Div_no_remainder(ir_node *node, int no_remainder);
/**
* Projection numbers for Div: use for Proj nodes!
pn_Div_max /**< number of projections from a Div */
} pn_Div; /* Projection numbers for Div. */
-ir_node *get_Mod_left(const ir_node *node);
-void set_Mod_left(ir_node *node, ir_node *left);
-ir_node *get_Mod_right(const ir_node *node);
-void set_Mod_right(ir_node *node, ir_node *right);
-ir_node *get_Mod_mem(const ir_node *node);
-void set_Mod_mem(ir_node *node, ir_node *mem);
-ir_mode *get_Mod_resmode(const ir_node *node);
-void set_Mod_resmode(ir_node *node, ir_mode *mode);
+FIRM_DLL ir_node *get_Mod_left(const ir_node *node);
+FIRM_DLL void set_Mod_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_Mod_right(const ir_node *node);
+FIRM_DLL void set_Mod_right(ir_node *node, ir_node *right);
+FIRM_DLL ir_node *get_Mod_mem(const ir_node *node);
+FIRM_DLL void set_Mod_mem(ir_node *node, ir_node *mem);
+FIRM_DLL ir_mode *get_Mod_resmode(const ir_node *node);
+FIRM_DLL void set_Mod_resmode(ir_node *node, ir_mode *mode);
/**
* Projection numbers for Mod: use for Proj nodes!
pn_Mod_max /**< number of projections from a Mod */
} pn_Mod; /* Projection numbers for Mod. */
-ir_node *get_Abs_op(const ir_node *node);
-void set_Abs_op(ir_node *node, ir_node *op);
+FIRM_DLL ir_node *get_Abs_op(const ir_node *node);
+FIRM_DLL void set_Abs_op(ir_node *node, ir_node *op);
-ir_node *get_And_left(const ir_node *node);
-void set_And_left(ir_node *node, ir_node *left);
-ir_node *get_And_right(const ir_node *node);
-void set_And_right(ir_node *node, ir_node *right);
+FIRM_DLL ir_node *get_And_left(const ir_node *node);
+FIRM_DLL void set_And_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_And_right(const ir_node *node);
+FIRM_DLL void set_And_right(ir_node *node, ir_node *right);
-ir_node *get_Or_left(const ir_node *node);
-void set_Or_left(ir_node *node, ir_node *left);
-ir_node *get_Or_right(const ir_node *node);
-void set_Or_right(ir_node *node, ir_node *right);
+FIRM_DLL ir_node *get_Or_left(const ir_node *node);
+FIRM_DLL void set_Or_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_Or_right(const ir_node *node);
+FIRM_DLL void set_Or_right(ir_node *node, ir_node *right);
-ir_node *get_Eor_left(const ir_node *node);
-void set_Eor_left(ir_node *node, ir_node *left);
-ir_node *get_Eor_right(const ir_node *node);
-void set_Eor_right(ir_node *node, ir_node *right);
+FIRM_DLL ir_node *get_Eor_left(const ir_node *node);
+FIRM_DLL void set_Eor_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_Eor_right(const ir_node *node);
+FIRM_DLL void set_Eor_right(ir_node *node, ir_node *right);
-ir_node *get_Not_op(const ir_node *node);
-void set_Not_op(ir_node *node, ir_node *op);
+FIRM_DLL ir_node *get_Not_op(const ir_node *node);
+FIRM_DLL void set_Not_op(ir_node *node, ir_node *op);
/** returns the pnc name from an pnc constant */
-const char *get_pnc_string(int pnc);
+FIRM_DLL const char *get_pnc_string(int pnc);
/** Calculates the negated (Complement(R)) pnc condition. */
-pn_Cmp get_negated_pnc(long pnc, ir_mode *mode);
+FIRM_DLL pn_Cmp get_negated_pnc(long pnc, ir_mode *mode);
/** Calculates the inversed (R^-1) pnc condition, i.e., "<" --> ">" */
-pn_Cmp get_inversed_pnc(long pnc);
+FIRM_DLL pn_Cmp get_inversed_pnc(long pnc);
/** An alternative name for get_inversed_pnc() that can be better memorized. */
#define get_mirrored_pnc(pnc) get_inversed_pnc(pnc)
-ir_node *get_Cmp_left(const ir_node *node);
-void set_Cmp_left(ir_node *node, ir_node *left);
-ir_node *get_Cmp_right(const ir_node *node);
-void set_Cmp_right(ir_node *node, ir_node *right);
+FIRM_DLL ir_node *get_Cmp_left(const ir_node *node);
+FIRM_DLL void set_Cmp_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_Cmp_right(const ir_node *node);
+FIRM_DLL void set_Cmp_right(ir_node *node, ir_node *right);
-ir_node *get_Shl_left(const ir_node *node);
-void set_Shl_left(ir_node *node, ir_node *left);
-ir_node *get_Shl_right(const ir_node *node);
-void set_Shl_right(ir_node *node, ir_node *right);
+FIRM_DLL ir_node *get_Shl_left(const ir_node *node);
+FIRM_DLL void set_Shl_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_Shl_right(const ir_node *node);
+FIRM_DLL void set_Shl_right(ir_node *node, ir_node *right);
-ir_node *get_Shr_left(const ir_node *node);
-void set_Shr_left(ir_node *node, ir_node *left);
-ir_node *get_Shr_right(const ir_node *node);
-void set_Shr_right(ir_node *node, ir_node *right);
+FIRM_DLL ir_node *get_Shr_left(const ir_node *node);
+FIRM_DLL void set_Shr_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_Shr_right(const ir_node *node);
+FIRM_DLL void set_Shr_right(ir_node *node, ir_node *right);
-ir_node *get_Shrs_left(const ir_node *node);
-void set_Shrs_left(ir_node *node, ir_node *left);
-ir_node *get_Shrs_right(const ir_node *node);
-void set_Shrs_right(ir_node *node, ir_node *right);
+FIRM_DLL ir_node *get_Shrs_left(const ir_node *node);
+FIRM_DLL void set_Shrs_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_Shrs_right(const ir_node *node);
+FIRM_DLL void set_Shrs_right(ir_node *node, ir_node *right);
-ir_node *get_Rotl_left(const ir_node *node);
-void set_Rotl_left(ir_node *node, ir_node *left);
-ir_node *get_Rotl_right(const ir_node *node);
-void set_Rotl_right(ir_node *node, ir_node *right);
+FIRM_DLL ir_node *get_Rotl_left(const ir_node *node);
+FIRM_DLL void set_Rotl_left(ir_node *node, ir_node *left);
+FIRM_DLL ir_node *get_Rotl_right(const ir_node *node);
+FIRM_DLL void set_Rotl_right(ir_node *node, ir_node *right);
-ir_node *get_Conv_op(const ir_node *node);
-void set_Conv_op(ir_node *node, ir_node *op);
-int get_Conv_strict(const ir_node *node);
-void set_Conv_strict(ir_node *node, int flag);
+FIRM_DLL ir_node *get_Conv_op(const ir_node *node);
+FIRM_DLL void set_Conv_op(ir_node *node, ir_node *op);
+FIRM_DLL int get_Conv_strict(const ir_node *node);
+FIRM_DLL void set_Conv_strict(ir_node *node, int flag);
/* Does Cast need a mem operator?
* Cast should only depend on the type, not on the state of an
* are accessed in the cast. This required some precaution, to
* get the right memory into the Loads generated from the cast.
*/
-ir_node *get_Cast_op(const ir_node *node);
-void set_Cast_op(ir_node *node, ir_node *op);
-ir_type *get_Cast_type(const ir_node *node);
-void set_Cast_type(ir_node *node, ir_type *to_tp);
+FIRM_DLL ir_node *get_Cast_op(const ir_node *node);
+FIRM_DLL void set_Cast_op(ir_node *node, ir_node *op);
+FIRM_DLL ir_type *get_Cast_type(const ir_node *node);
+FIRM_DLL void set_Cast_type(ir_node *node, ir_type *to_tp);
/** Checks for upcast.
*
*
* Needs typeinfo calculated.
*/
-int is_Cast_upcast(ir_node *node);
+FIRM_DLL int is_Cast_upcast(ir_node *node);
/** Checks for downcast.
*
*
* Needs typeinfo calculated.
*/
-int is_Cast_downcast(ir_node *node);
+FIRM_DLL int is_Cast_downcast(ir_node *node);
/** Returns true if n is a Phi or a Filter node in INTER-procedural view.
Returns false if irg is in phase phase_building and the Phi has zero
predecessors: it's a Phi0. */
-int is_Phi(const ir_node *n);
+FIRM_DLL int is_Phi(const ir_node *n);
/** Returns true if irg in phase phase_building and the Phi has zero
predecessors. It's a Phi0 then. */
-int is_Phi0(const ir_node *n);
+FIRM_DLL int is_Phi0(const ir_node *n);
/* These routines also work for Filter nodes in INTER-procedural view. */
-ir_node **get_Phi_preds_arr(ir_node *node);
-int get_Phi_n_preds(const ir_node *node);
-ir_node *get_Phi_pred(const ir_node *node, int pos);
-void set_Phi_pred(ir_node *node, int pos, ir_node *pred);
+FIRM_DLL ir_node **get_Phi_preds_arr(ir_node *node);
+FIRM_DLL int get_Phi_n_preds(const ir_node *node);
+FIRM_DLL ir_node *get_Phi_pred(const ir_node *node, int pos);
+FIRM_DLL void set_Phi_pred(ir_node *node, int pos, ir_node *pred);
/**
* Returns the next element of a block phi list.
*/
-ir_node *get_Phi_next(const ir_node *phi);
+FIRM_DLL ir_node *get_Phi_next(const ir_node *phi);
/**
* Sets the next link of a block Phi list.
*/
-void set_Phi_next(ir_node *phi, ir_node *next);
+FIRM_DLL void set_Phi_next(ir_node *phi, ir_node *next);
-ir_node *get_Filter_pred(const ir_node *node);
-void set_Filter_pred(ir_node *node, ir_node *pred);
-long get_Filter_proj(const ir_node *node);
-void set_Filter_proj(ir_node *node, long proj);
+FIRM_DLL ir_node *get_Filter_pred(const ir_node *node);
+FIRM_DLL void set_Filter_pred(ir_node *node, ir_node *pred);
+FIRM_DLL long get_Filter_proj(const ir_node *node);
+FIRM_DLL void set_Filter_proj(ir_node *node, long proj);
/* set the interprocedural predecessors, ...d_arr uses current_ir_graph.
* @@@ Maybe better: arity is zero if no cg preds. */
-void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in);
-void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred);
-int get_Filter_n_cg_preds(const ir_node *node);
-ir_node *get_Filter_cg_pred(const ir_node *node, int pos);
+FIRM_DLL void set_Filter_cg_pred_arr(ir_node *node, int arity, ir_node **in);
+FIRM_DLL void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred);
+FIRM_DLL int get_Filter_n_cg_preds(const ir_node *node);
+FIRM_DLL ir_node *get_Filter_cg_pred(const ir_node *node, int pos);
/** Return true if parameter is a memory operation.
*
* A memory operation is an operation that changes the
* memory. I.e., a Load or a Store operation.
*/
-int is_memop(const ir_node *node);
-ir_node *get_memop_mem(const ir_node *node);
-void set_memop_mem(ir_node *node, ir_node *mem);
-ir_node *get_memop_ptr(const ir_node *node);
-void set_memop_ptr(ir_node *node, ir_node *ptr);
+FIRM_DLL int is_memop(const ir_node *node);
+FIRM_DLL ir_node *get_memop_mem(const ir_node *node);
+FIRM_DLL void set_memop_mem(ir_node *node, ir_node *mem);
+FIRM_DLL ir_node *get_memop_ptr(const ir_node *node);
+FIRM_DLL void set_memop_ptr(ir_node *node, ir_node *ptr);
/**
* Projection numbers for Load: use for Proj nodes!
pn_Load_max /**< number of projections from a Load */
} pn_Load; /* Projection numbers for Load. */
-ir_node *get_Load_mem(const ir_node *node);
-void set_Load_mem(ir_node *node, ir_node *mem);
-ir_node *get_Load_ptr(const ir_node *node);
-void set_Load_ptr(ir_node *node, ir_node *ptr);
-ir_mode *get_Load_mode(const ir_node *node);
-void set_Load_mode(ir_node *node, ir_mode *mode);
-ir_volatility get_Load_volatility(const ir_node *node);
-void set_Load_volatility(ir_node *node, ir_volatility volatility);
-ir_align get_Load_align(const ir_node *node);
-void set_Load_align(ir_node *node, ir_align align);
+FIRM_DLL ir_node *get_Load_mem(const ir_node *node);
+FIRM_DLL void set_Load_mem(ir_node *node, ir_node *mem);
+FIRM_DLL ir_node *get_Load_ptr(const ir_node *node);
+FIRM_DLL void set_Load_ptr(ir_node *node, ir_node *ptr);
+FIRM_DLL ir_mode *get_Load_mode(const ir_node *node);
+FIRM_DLL void set_Load_mode(ir_node *node, ir_mode *mode);
+FIRM_DLL ir_volatility get_Load_volatility(const ir_node *node);
+FIRM_DLL void set_Load_volatility(ir_node *node, ir_volatility volatility);
+FIRM_DLL ir_align get_Load_align(const ir_node *node);
+FIRM_DLL void set_Load_align(ir_node *node, ir_align align);
/**
* Projection numbers for Store: use for Proj nodes!
pn_Store_max = pn_Generic_other /**< number of projections from a Store */
} pn_Store; /* Projection numbers for Store. */
-ir_node *get_Store_mem(const ir_node *node);
-void set_Store_mem(ir_node *node, ir_node *mem);
-ir_node *get_Store_ptr(const ir_node *node);
-void set_Store_ptr(ir_node *node, ir_node *ptr);
-ir_node *get_Store_value(const ir_node *node);
-void set_Store_value(ir_node *node, ir_node *value);
-ir_volatility get_Store_volatility(const ir_node *node);
-void set_Store_volatility(ir_node *node, ir_volatility volatility);
-ir_align get_Store_align(const ir_node *node);
-void set_Store_align(ir_node *node, ir_align align);
+FIRM_DLL ir_node *get_Store_mem(const ir_node *node);
+FIRM_DLL void set_Store_mem(ir_node *node, ir_node *mem);
+FIRM_DLL ir_node *get_Store_ptr(const ir_node *node);
+FIRM_DLL void set_Store_ptr(ir_node *node, ir_node *ptr);
+FIRM_DLL ir_node *get_Store_value(const ir_node *node);
+FIRM_DLL void set_Store_value(ir_node *node, ir_node *value);
+FIRM_DLL ir_volatility get_Store_volatility(const ir_node *node);
+FIRM_DLL void set_Store_volatility(ir_node *node, ir_volatility volatility);
+FIRM_DLL ir_align get_Store_align(const ir_node *node);
+FIRM_DLL void set_Store_align(ir_node *node, ir_align align);
/**
* Projection numbers for Alloc: use for Proj nodes!
pn_Alloc_max /**< number of projections from an Alloc */
} pn_Alloc; /* Projection numbers for Alloc. */
-ir_node *get_Alloc_mem(const ir_node *node);
-void set_Alloc_mem(ir_node *node, ir_node *mem);
-ir_node *get_Alloc_count(const ir_node *node);
-void set_Alloc_count(ir_node *node, ir_node *count);
-ir_type *get_Alloc_type(const ir_node *node);
-void set_Alloc_type(ir_node *node, ir_type *tp);
-
-ir_where_alloc get_Alloc_where(const ir_node *node);
-void set_Alloc_where(ir_node *node, ir_where_alloc where);
-
-ir_node *get_Free_mem(const ir_node *node);
-void set_Free_mem(ir_node *node, ir_node *mem);
-ir_node *get_Free_ptr(const ir_node *node);
-void set_Free_ptr(ir_node *node, ir_node *ptr);
-ir_node *get_Free_size(const ir_node *node);
-void set_Free_size(ir_node *node, ir_node *size);
-ir_type *get_Free_type(const ir_node *node);
-void set_Free_type(ir_node *node, ir_type *tp);
-
-ir_where_alloc get_Free_where(const ir_node *node);
-void set_Free_where(ir_node *node, ir_where_alloc where);
-
-ir_node **get_Sync_preds_arr(ir_node *node);
-int get_Sync_n_preds(const ir_node *node);
-ir_node *get_Sync_pred(const ir_node *node, int pos);
-void set_Sync_pred(ir_node *node, int pos, ir_node *pred);
-void add_Sync_pred(ir_node *node, ir_node *pred);
+FIRM_DLL ir_node *get_Alloc_mem(const ir_node *node);
+FIRM_DLL void set_Alloc_mem(ir_node *node, ir_node *mem);
+FIRM_DLL ir_node *get_Alloc_count(const ir_node *node);
+FIRM_DLL void set_Alloc_count(ir_node *node, ir_node *count);
+FIRM_DLL ir_type *get_Alloc_type(const ir_node *node);
+FIRM_DLL void set_Alloc_type(ir_node *node, ir_type *tp);
+
+FIRM_DLL ir_where_alloc get_Alloc_where(const ir_node *node);
+FIRM_DLL void set_Alloc_where(ir_node *node, ir_where_alloc where);
+
+FIRM_DLL ir_node *get_Free_mem(const ir_node *node);
+FIRM_DLL void set_Free_mem(ir_node *node, ir_node *mem);
+FIRM_DLL ir_node *get_Free_ptr(const ir_node *node);
+FIRM_DLL void set_Free_ptr(ir_node *node, ir_node *ptr);
+FIRM_DLL ir_node *get_Free_size(const ir_node *node);
+FIRM_DLL void set_Free_size(ir_node *node, ir_node *size);
+FIRM_DLL ir_type *get_Free_type(const ir_node *node);
+FIRM_DLL void set_Free_type(ir_node *node, ir_type *tp);
+
+FIRM_DLL ir_where_alloc get_Free_where(const ir_node *node);
+FIRM_DLL void set_Free_where(ir_node *node, ir_where_alloc where);
+
+FIRM_DLL ir_node **get_Sync_preds_arr(ir_node *node);
+FIRM_DLL int get_Sync_n_preds(const ir_node *node);
+FIRM_DLL ir_node *get_Sync_pred(const ir_node *node, int pos);
+FIRM_DLL void set_Sync_pred(ir_node *node, int pos, ir_node *pred);
+FIRM_DLL void add_Sync_pred(ir_node *node, ir_node *pred);
/** Returns the source language type of a Proj node.
* Must be an atomic type. Mode of type must be mode of node.
*/
-ir_type *get_Proj_type(const ir_node *node);
+FIRM_DLL ir_type *get_Proj_type(const ir_node *node);
/** Return the predecessor of a Proj node. */
-ir_node *get_Proj_pred(const ir_node *node);
-void set_Proj_pred(ir_node *node, ir_node *pred);
+FIRM_DLL ir_node *get_Proj_pred(const ir_node *node);
+FIRM_DLL void set_Proj_pred(ir_node *node, ir_node *pred);
/** Return the projection number of a Proj node. */
-long get_Proj_proj(const ir_node *node);
-void set_Proj_proj(ir_node *node, long proj);
+FIRM_DLL long get_Proj_proj(const ir_node *node);
+FIRM_DLL void set_Proj_proj(ir_node *node, long proj);
/**
* Returns non-zero if a node is a routine parameter.
*
* @param node the Proj node to test
*/
-int is_arg_Proj(const ir_node *node);
+FIRM_DLL int is_arg_Proj(const ir_node *node);
-ir_node **get_Tuple_preds_arr(ir_node *node);
-int get_Tuple_n_preds(const ir_node *node);
-ir_node *get_Tuple_pred(const ir_node *node, int pos);
-void set_Tuple_pred(ir_node *node, int pos, ir_node *pred);
+FIRM_DLL ir_node **get_Tuple_preds_arr(ir_node *node);
+FIRM_DLL int get_Tuple_n_preds(const ir_node *node);
+FIRM_DLL ir_node *get_Tuple_pred(const ir_node *node, int pos);
+FIRM_DLL void set_Tuple_pred(ir_node *node, int pos, ir_node *pred);
-ir_node *get_Id_pred(const ir_node *node);
-void set_Id_pred(ir_node *node, ir_node *pred);
+FIRM_DLL ir_node *get_Id_pred(const ir_node *node);
+FIRM_DLL void set_Id_pred(ir_node *node, ir_node *pred);
/** Confirm has a single result and returns 'value' unchanged.
* The node expresses a restriction on 'value':
* 'value' 'cmp' 'bound' == true. */
-ir_node *get_Confirm_value(const ir_node *node);
-void set_Confirm_value(ir_node *node, ir_node *value);
-ir_node *get_Confirm_bound(const ir_node *node);
-void set_Confirm_bound(ir_node *node, ir_node *bound);
-pn_Cmp get_Confirm_cmp(const ir_node *node);
-void set_Confirm_cmp(ir_node *node, pn_Cmp cmp);
+FIRM_DLL ir_node *get_Confirm_value(const ir_node *node);
+FIRM_DLL void set_Confirm_value(ir_node *node, ir_node *value);
+FIRM_DLL ir_node *get_Confirm_bound(const ir_node *node);
+FIRM_DLL void set_Confirm_bound(ir_node *node, ir_node *bound);
+FIRM_DLL pn_Cmp get_Confirm_cmp(const ir_node *node);
+FIRM_DLL void set_Confirm_cmp(ir_node *node, pn_Cmp cmp);
/*
* Mux Support
*/
-ir_node *get_Mux_sel(const ir_node *node);
-void set_Mux_sel(ir_node *node, ir_node *sel);
-ir_node *get_Mux_false(const ir_node *node);
-void set_Mux_false(ir_node *node, ir_node *ir_false);
-ir_node *get_Mux_true(const ir_node *node);
-void set_Mux_true(ir_node *node, ir_node *ir_true);
+FIRM_DLL ir_node *get_Mux_sel(const ir_node *node);
+FIRM_DLL void set_Mux_sel(ir_node *node, ir_node *sel);
+FIRM_DLL ir_node *get_Mux_false(const ir_node *node);
+FIRM_DLL void set_Mux_false(ir_node *node, ir_node *ir_false);
+FIRM_DLL ir_node *get_Mux_true(const ir_node *node);
+FIRM_DLL void set_Mux_true(ir_node *node, ir_node *ir_true);
/**
* Projection numbers for result of CopyB node: use for Proj nodes!
} pn_CopyB; /* Projection numbers for CopyB. */
#define pn_CopyB_M pn_CopyB_M_regular
-ir_node *get_CopyB_mem(const ir_node *node);
-void set_CopyB_mem(ir_node *node, ir_node *mem);
-ir_node *get_CopyB_dst(const ir_node *node);
-void set_CopyB_dst(ir_node *node, ir_node *dst);
-ir_node *get_CopyB_src(const ir_node *node);
-void set_CopyB_src(ir_node *node, ir_node *src);
-ir_type *get_CopyB_type(const ir_node *node);
-void set_CopyB_type(ir_node *node, ir_type *data_type);
+FIRM_DLL ir_node *get_CopyB_mem(const ir_node *node);
+FIRM_DLL void set_CopyB_mem(ir_node *node, ir_node *mem);
+FIRM_DLL ir_node *get_CopyB_dst(const ir_node *node);
+FIRM_DLL void set_CopyB_dst(ir_node *node, ir_node *dst);
+FIRM_DLL ir_node *get_CopyB_src(const ir_node *node);
+FIRM_DLL void set_CopyB_src(ir_node *node, ir_node *src);
+FIRM_DLL ir_type *get_CopyB_type(const ir_node *node);
+FIRM_DLL void set_CopyB_type(ir_node *node, ir_type *data_type);
/**
* Projection numbers for result of InstOf node: use for Proj nodes!
#define pn_InstOf_M pn_InstOf_M_regular
/** InstOf access. */
-ir_type *get_InstOf_type(const ir_node *node);
-void set_InstOf_type(ir_node *node, ir_type *type);
-ir_node *get_InstOf_store(const ir_node *node);
-void set_InstOf_store(ir_node *node, ir_node *obj);
-ir_node *get_InstOf_obj(const ir_node *node);
-void set_InstOf_obj(ir_node *node, ir_node *obj);
+FIRM_DLL ir_type *get_InstOf_type(const ir_node *node);
+FIRM_DLL void set_InstOf_type(ir_node *node, ir_type *type);
+FIRM_DLL ir_node *get_InstOf_store(const ir_node *node);
+FIRM_DLL void set_InstOf_store(ir_node *node, ir_node *obj);
+FIRM_DLL ir_node *get_InstOf_obj(const ir_node *node);
+FIRM_DLL void set_InstOf_obj(ir_node *node, ir_node *obj);
/**
* Projection numbers for Raise.
pn_Raise_max /**< number of projections from a Raise */
} pn_Raise; /* Projection numbers for Raise. */
-ir_node *get_Raise_mem(const ir_node *node);
-void set_Raise_mem(ir_node *node, ir_node *mem);
-ir_node *get_Raise_exo_ptr(const ir_node *node); /* PoinTeR to EXception Object */
-void set_Raise_exo_ptr(ir_node *node, ir_node *exoptr);
+FIRM_DLL ir_node *get_Raise_mem(const ir_node *node);
+FIRM_DLL void set_Raise_mem(ir_node *node, ir_node *mem);
+FIRM_DLL ir_node *get_Raise_exo_ptr(const ir_node *node); /* PoinTeR to EXception Object */
+FIRM_DLL void set_Raise_exo_ptr(ir_node *node, ir_node *exoptr);
/**
* Projection numbers for result of Bound node: use for Proj nodes!
} pn_Bound;
/** Returns the memory input of a Bound operation. */
-ir_node *get_Bound_mem(const ir_node *bound);
-void set_Bound_mem(ir_node *bound, ir_node *mem);
+FIRM_DLL ir_node *get_Bound_mem(const ir_node *bound);
+FIRM_DLL void set_Bound_mem(ir_node *bound, ir_node *mem);
/** Returns the index input of a Bound operation. */
-ir_node *get_Bound_index(const ir_node *bound);
-void set_Bound_index(ir_node *bound, ir_node *idx);
+FIRM_DLL ir_node *get_Bound_index(const ir_node *bound);
+FIRM_DLL void set_Bound_index(ir_node *bound, ir_node *idx);
/** Returns the lower bound input of a Bound operation. */
-ir_node *get_Bound_lower(const ir_node *bound);
-void set_Bound_lower(ir_node *bound, ir_node *lower);
+FIRM_DLL ir_node *get_Bound_lower(const ir_node *bound);
+FIRM_DLL void set_Bound_lower(ir_node *bound, ir_node *lower);
/** Returns the upper bound input of a Bound operation. */
-ir_node *get_Bound_upper(const ir_node *bound);
-void set_Bound_upper(ir_node *bound, ir_node *upper);
+FIRM_DLL ir_node *get_Bound_upper(const ir_node *bound);
+FIRM_DLL void set_Bound_upper(ir_node *bound, ir_node *upper);
/** Return the operand of a Pin node. */
-ir_node *get_Pin_op(const ir_node *pin);
-void set_Pin_op(ir_node *pin, ir_node *node);
+FIRM_DLL ir_node *get_Pin_op(const ir_node *pin);
+FIRM_DLL void set_Pin_op(ir_node *pin, ir_node *node);
/** Return the assembler text of an ASM pseudo node. */
-ident *get_ASM_text(const ir_node *node);
+FIRM_DLL ident *get_ASM_text(const ir_node *node);
/** Set assembler text of ASM node */
-void set_ASM_text(ir_node *node, ident *text);
+FIRM_DLL void set_ASM_text(ir_node *node, ident *text);
/** Return the number of input constraints for an ASM node. */
-int get_ASM_n_input_constraints(const ir_node *node);
+FIRM_DLL int get_ASM_n_input_constraints(const ir_node *node);
/** Return the input constraints for an ASM node. */
-ir_asm_constraint *get_ASM_input_constraints(const ir_node *node);
+FIRM_DLL ir_asm_constraint *get_ASM_input_constraints(const ir_node *node);
/** Set input constraints for ASM node. */
-void set_ASM_input_constraints(ir_node *node, ir_asm_constraint *constraints);
+FIRM_DLL void set_ASM_input_constraints(ir_node *node, ir_asm_constraint *constraints);
/** Return the number of output constraints for an ASM node. */
-int get_ASM_n_output_constraints(const ir_node *node);
+FIRM_DLL int get_ASM_n_output_constraints(const ir_node *node);
/** Return the output constraints for an ASM node. */
-ir_asm_constraint *get_ASM_output_constraints(const ir_node *node);
+FIRM_DLL ir_asm_constraint *get_ASM_output_constraints(const ir_node *node);
/** Set output constraints for ASM node. (note: has to be a firm array) */
-void set_ASM_output_constraints(ir_node *node, ir_asm_constraint *constraints);
+FIRM_DLL void set_ASM_output_constraints(ir_node *node, ir_asm_constraint *constraints);
/** Return the number of clobbered registers for an ASM node. */
-int get_ASM_n_clobbers(const ir_node *node);
+FIRM_DLL int get_ASM_n_clobbers(const ir_node *node);
/** Return the list of clobbered registers for an ASM node. */
-ident **get_ASM_clobbers(const ir_node *node);
+FIRM_DLL ident **get_ASM_clobbers(const ir_node *node);
/** Set list of clobbered register for ASM node (note: has to be a firm
* array) */
-void set_ASM_clobbers(ir_node *node, ident **clobbers);
+FIRM_DLL void set_ASM_clobbers(ir_node *node, ident **clobbers);
/*
*
*/
/** Returns operand of node if node is a Proj. */
-ir_node *skip_Proj(ir_node *node);
+FIRM_DLL ir_node *skip_Proj(ir_node *node);
/** Returns operand of node if node is a Proj. */
-const ir_node *skip_Proj_const(const ir_node *node);
+FIRM_DLL const ir_node *skip_Proj_const(const ir_node *node);
/** Returns operand of node if node is a Id. */
-ir_node *skip_Id(ir_node *node); /* Old name is skip_nop(). */
+FIRM_DLL ir_node *skip_Id(ir_node *node); /* Old name is skip_nop(). */
/** Returns corresponding operand of Tuple if node is a Proj from
a Tuple. */
-ir_node *skip_Tuple(ir_node *node);
+FIRM_DLL ir_node *skip_Tuple(ir_node *node);
/** Returns operand of node if node is a Cast. */
-ir_node *skip_Cast(ir_node *node);
-const ir_node *skip_Cast_const(const ir_node *node);
+FIRM_DLL ir_node *skip_Cast(ir_node *node);
+FIRM_DLL const ir_node *skip_Cast_const(const ir_node *node);
/** Returns operand of node if node is a Pin. */
-ir_node *skip_Pin(ir_node *node);
+FIRM_DLL ir_node *skip_Pin(ir_node *node);
/** Returns operand of node if node is a Confirm */
-ir_node *skip_Confirm(ir_node *node);
+FIRM_DLL ir_node *skip_Confirm(ir_node *node);
/** Skip all high-level Operations (including Cast, Confirm). */
-ir_node *skip_HighLevel_ops(ir_node *node);
+FIRM_DLL ir_node *skip_HighLevel_ops(ir_node *node);
/** Returns true if irn is a Const node. */
-int is_Const(const ir_node *node);
+FIRM_DLL int is_Const(const ir_node *node);
/** Returns true if a node is a Conv node. */
-int is_Conv(const ir_node *node);
+FIRM_DLL int is_Conv(const ir_node *node);
/** Returns true if a node is a strictConv node. */
-int is_strictConv(const ir_node *node);
+FIRM_DLL int is_strictConv(const ir_node *node);
/** Returns true if a node is a Cast node. */
-int is_Cast(const ir_node *node);
+FIRM_DLL int is_Cast(const ir_node *node);
/** Returns true if node is a Bad node. */
-int is_Bad(const ir_node *node);
+FIRM_DLL int is_Bad(const ir_node *node);
/** Returns true if node is a NoMem node. */
-int is_NoMem(const ir_node *node);
+FIRM_DLL int is_NoMem(const ir_node *node);
/** Returns true if node is a Start node. */
-int is_Start(const ir_node *node);
+FIRM_DLL int is_Start(const ir_node *node);
/** Returns true if node is an End node. */
-int is_End(const ir_node *node);
+FIRM_DLL int is_End(const ir_node *node);
/** Returns true if node is an EndExcept node. */
-int is_EndExcept(const ir_node *node);
+FIRM_DLL int is_EndExcept(const ir_node *node);
/** Returns true if node is an EndReg node. */
-int is_EndReg(const ir_node *node);
+FIRM_DLL int is_EndReg(const ir_node *node);
/** Returns true if node is a Minus node. */
-int is_Minus(const ir_node *node);
+FIRM_DLL int is_Minus(const ir_node *node);
/** Returns true if node is a Abs node. */
-int is_Abs(const ir_node *node);
+FIRM_DLL int is_Abs(const ir_node *node);
/** Returns true if node is a Mod node. */
-int is_Mod(const ir_node *node);
+FIRM_DLL int is_Mod(const ir_node *node);
/** Returns true if node is a Div node. */
-int is_Div(const ir_node *node);
+FIRM_DLL int is_Div(const ir_node *node);
/** Returns true if node is a DivMod node. */
-int is_DivMod(const ir_node *node);
+FIRM_DLL int is_DivMod(const ir_node *node);
/** Returns true if node is a Quot node. */
-int is_Quot(const ir_node *node);
+FIRM_DLL int is_Quot(const ir_node *node);
/** Returns true if node is an Add node. */
-int is_Add(const ir_node *node);
+FIRM_DLL int is_Add(const ir_node *node);
/** Returns true if node is a Carry node. */
-int is_Carry(const ir_node *node);
+FIRM_DLL int is_Carry(const ir_node *node);
/** Returns true if node is an And node. */
-int is_And(const ir_node *node);
+FIRM_DLL int is_And(const ir_node *node);
/** Returns true if node is an Or node. */
-int is_Or(const ir_node *node);
+FIRM_DLL int is_Or(const ir_node *node);
/** Returns true if node is an Eor node. */
-int is_Eor(const ir_node *node);
+FIRM_DLL int is_Eor(const ir_node *node);
/** Returns true if node is a Sub node. */
-int is_Sub(const ir_node *node);
+FIRM_DLL int is_Sub(const ir_node *node);
/** Returns true if node is a Not node. */
-int is_Not(const ir_node *node);
+FIRM_DLL int is_Not(const ir_node *node);
/** Returns true if node is a Shl node. */
-int is_Shl(const ir_node *node);
+FIRM_DLL int is_Shl(const ir_node *node);
/** Returns true if node is a Shr node. */
-int is_Shr(const ir_node *node);
+FIRM_DLL int is_Shr(const ir_node *node);
/** Returns true if node is a Shrs node. */
-int is_Shrs(const ir_node *node);
+FIRM_DLL int is_Shrs(const ir_node *node);
/** Returns true if node is a Rotl node. */
-int is_Rotl(const ir_node *node);
+FIRM_DLL int is_Rotl(const ir_node *node);
/** Returns true if node is an Id node. */
-int is_Id(const ir_node *node);
+FIRM_DLL int is_Id(const ir_node *node);
/** Returns true if node is a Tuple node. */
-int is_Tuple(const ir_node *node);
+FIRM_DLL int is_Tuple(const ir_node *node);
/** Returns true if node is a Bound node. */
-int is_Bound(const ir_node *node);
+FIRM_DLL int is_Bound(const ir_node *node);
/** Returns true if the node is not a Block */
-int is_no_Block(const ir_node *node);
+FIRM_DLL int is_no_Block(const ir_node *node);
/** Returns true if the node is a Block */
-int is_Block(const ir_node *node);
+FIRM_DLL int is_Block(const ir_node *node);
/** Returns true if node is an Unknown node. */
-int is_Unknown(const ir_node *node);
+FIRM_DLL int is_Unknown(const ir_node *node);
/** Returns true if node is a Return node. */
-int is_Return(const ir_node *node);
+FIRM_DLL int is_Return(const ir_node *node);
/** Returns true if node is a Call node. */
-int is_Call(const ir_node *node);
+FIRM_DLL int is_Call(const ir_node *node);
/** Returns true if node is a Builtin node. */
-int is_Builtin(const ir_node *node);
+FIRM_DLL int is_Builtin(const ir_node *node);
/** Returns true if node is a CallBegin node. */
-int is_CallBegin(const ir_node *node);
+FIRM_DLL int is_CallBegin(const ir_node *node);
/** Returns true if node is a Sel node. */
-int is_Sel(const ir_node *node);
+FIRM_DLL int is_Sel(const ir_node *node);
/** Returns true if node is a Mul node. */
-int is_Mul(const ir_node *node);
+FIRM_DLL int is_Mul(const ir_node *node);
/** Returns true if node is a Mulh node. */
-int is_Mulh(const ir_node *node);
+FIRM_DLL int is_Mulh(const ir_node *node);
/** Returns true if node is a Mux node. */
-int is_Mux(const ir_node *node);
+FIRM_DLL int is_Mux(const ir_node *node);
/** Returns true if node is a Load node. */
-int is_Load(const ir_node *node);
+FIRM_DLL int is_Load(const ir_node *node);
/** Returns true if node is a Store node. */
-int is_Store(const ir_node *node);
+FIRM_DLL int is_Store(const ir_node *node);
/** Returns true if node is a Sync node. */
-int is_Sync(const ir_node *node);
+FIRM_DLL int is_Sync(const ir_node *node);
/** Returns true if node is a Confirm node. */
-int is_Confirm(const ir_node *node);
+FIRM_DLL int is_Confirm(const ir_node *node);
/** Returns true if node is a Pin node. */
-int is_Pin(const ir_node *node);
+FIRM_DLL int is_Pin(const ir_node *node);
/** Returns true if node is a SymConst node. */
-int is_SymConst(const ir_node *node);
+FIRM_DLL int is_SymConst(const ir_node *node);
/** Returns true if node is a SymConst node with kind symconst_addr_ent. */
-int is_SymConst_addr_ent(const ir_node *node);
+FIRM_DLL int is_SymConst_addr_ent(const ir_node *node);
/** Returns true if node is a Cond node. */
-int is_Cond(const ir_node *node);
+FIRM_DLL int is_Cond(const ir_node *node);
/** Returns true of node is a CopyB node. */
-int is_CopyB(const ir_node *node);
+FIRM_DLL int is_CopyB(const ir_node *node);
/** Returns true if node is a Cmp node. */
-int is_Cmp(const ir_node *node);
+FIRM_DLL int is_Cmp(const ir_node *node);
/** Returns true if node is an Alloc node. */
-int is_Alloc(const ir_node *node);
+FIRM_DLL int is_Alloc(const ir_node *node);
/** Returns true if node is a Free node. */
-int is_Free(const ir_node *node);
+FIRM_DLL int is_Free(const ir_node *node);
/** Returns true if a node is a Jmp node. */
-int is_Jmp(const ir_node *node);
+FIRM_DLL int is_Jmp(const ir_node *node);
/** Returns true if a node is a IJmp node. */
-int is_IJmp(const ir_node *node);
+FIRM_DLL int is_IJmp(const ir_node *node);
/** Returns true if a node is a Raise node. */
-int is_Raise(const ir_node *node);
+FIRM_DLL int is_Raise(const ir_node *node);
/** Returns true if a node is an ASM node. */
-int is_ASM(const ir_node *node);
+FIRM_DLL int is_ASM(const ir_node *node);
/** Returns true if a node is a Dummy node. */
-int is_Dummy(const ir_node *node);
+FIRM_DLL int is_Dummy(const ir_node *node);
/** Returns true if a node is an Anchor node */
-int is_Anchor(const ir_node *node);
+FIRM_DLL int is_Anchor(const ir_node *node);
/** Returns true if a node is a Borrow node */
-int is_Borrow(const ir_node *node);
+FIRM_DLL int is_Borrow(const ir_node *node);
/** Returns true if a node is a Break node */
-int is_Break(const ir_node *node);
+FIRM_DLL int is_Break(const ir_node *node);
/** Returns true if a node is an instff node */
-int is_InstOf(const ir_node *node);
+FIRM_DLL int is_InstOf(const ir_node *node);
/** Returns true if node is a Proj node or a Filter node in INTRA-procedural view. */
-int is_Proj(const ir_node *node);
+FIRM_DLL int is_Proj(const ir_node *node);
/** Returns true if node is a Filter node. */
-int is_Filter(const ir_node *node);
+FIRM_DLL int is_Filter(const ir_node *node);
/** Returns true if the operation manipulates control flow:
Start, End, Jmp, Cond, Return, Raise, Bad, CallBegin, EndReg, EndExcept */
-int is_cfop(const ir_node *node);
+FIRM_DLL int is_cfop(const ir_node *node);
/** Returns true if the operation manipulates interprocedural control flow:
CallBegin, EndReg, EndExcept */
-int is_ip_cfop(const ir_node *node);
+FIRM_DLL int is_ip_cfop(const ir_node *node);
/** Returns true if the operation can change the control flow because
of an exception: Call, Quot, DivMod, Div, Mod, Load, Store, Alloc,
Bad. Raise is not fragile, but a unconditional jump. */
-int is_fragile_op(const ir_node *node);
+FIRM_DLL int is_fragile_op(const ir_node *node);
/** Returns the memory operand of fragile operations. */
-ir_node *get_fragile_op_mem(ir_node *node);
+FIRM_DLL ir_node *get_fragile_op_mem(ir_node *node);
/** Returns the result mode of a Div operation. */
-ir_mode *get_divop_resmod(const ir_node *node);
+FIRM_DLL ir_mode *get_divop_resmod(const ir_node *node);
/** Returns true if the operation is a forking control flow
* operation: Cond. */
-int is_irn_forking(const ir_node *node);
+FIRM_DLL int is_irn_forking(const ir_node *node);
/**
* Copies attributes stored in the old node to a new node.
* temporal or calculated information like visited flags or results of dominance
* or loop calculations
*/
-void copy_node_attr(ir_graph *irg, const ir_node *old_node, ir_node *new_node);
+FIRM_DLL void copy_node_attr(ir_graph *irg, const ir_node *old_node, ir_node *new_node);
/** Return the type associated with the value produced by n
* if the node remarks this type as it is the case for
* Cast, Const, SymConst and some Proj nodes or unknown_type. */
-ir_type *get_irn_type(ir_node *n);
+FIRM_DLL ir_type *get_irn_type(ir_node *n);
/** Return the type attribute of a node n (SymConst, Call, Alloc, Free,
Cast) or NULL.*/
-ir_type *get_irn_type_attr(ir_node *n);
+FIRM_DLL ir_type *get_irn_type_attr(ir_node *n);
/** Return the entity attribute of a node n (SymConst, Sel) or NULL. */
-ir_entity *get_irn_entity_attr(ir_node *n);
+FIRM_DLL ir_entity *get_irn_entity_attr(ir_node *n);
/** Returns non-zero for constant-like nodes. */
-int is_irn_constlike(const ir_node *node);
+FIRM_DLL int is_irn_constlike(const ir_node *node);
/**
* Returns non-zero for nodes that must be always optimized
* (Phi, Id. Proj, Cond, Block, Confirm ...).
*/
-int is_irn_always_opt(const ir_node *node);
+FIRM_DLL int is_irn_always_opt(const ir_node *node);
/**
* Returns non-zero for nodes that are allowed to have keep-alives and
* are neither Block nor PhiM.
*/
-int is_irn_keep(const ir_node *node);
+FIRM_DLL int is_irn_keep(const ir_node *node);
/**
* Returns non-zero for nodes that are always placed in the start block.
*/
-int is_irn_start_block_placed(const ir_node *node);
+FIRM_DLL int is_irn_start_block_placed(const ir_node *node);
/**
* Returns non-zero for nodes that are machine operations.
*/
-int is_irn_machine_op(const ir_node *node);
+FIRM_DLL int is_irn_machine_op(const ir_node *node);
/**
* Returns non-zero for nodes that are machine operands.
*/
-int is_irn_machine_operand(const ir_node *node);
+FIRM_DLL int is_irn_machine_operand(const ir_node *node);
/**
* Returns non-zero for nodes that have the n'th user machine flag set.
*/
-int is_irn_machine_user(const ir_node *node, unsigned n);
+FIRM_DLL int is_irn_machine_user(const ir_node *node, unsigned n);
/**
* Returns non-zero for nodes that are CSE neutral to its users.
*/
-int is_irn_cse_neutral(const ir_node *node);
+FIRM_DLL int is_irn_cse_neutral(const ir_node *node);
/**
* A type to express conditional jump predictions.
} cond_jmp_predicate;
/** Gets the string representation of the jump prediction. */
-const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred);
+FIRM_DLL const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred);
/** Returns the conditional jump prediction of a Cond node. */
-cond_jmp_predicate get_Cond_jmp_pred(const ir_node *cond);
+FIRM_DLL cond_jmp_predicate get_Cond_jmp_pred(const ir_node *cond);
/** Sets a new conditional jump prediction. */
-void set_Cond_jmp_pred(ir_node *cond, cond_jmp_predicate pred);
+FIRM_DLL void set_Cond_jmp_pred(ir_node *cond, cond_jmp_predicate pred);
/** Checks whether a node represents a global address. */
-int is_Global(const ir_node *node);
+FIRM_DLL int is_Global(const ir_node *node);
/* Returns the entity of a global address. */
-ir_entity *get_Global_entity(const ir_node *node);
+FIRM_DLL ir_entity *get_Global_entity(const ir_node *node);
/**
* Access custom node data.
* must be passed to the access macro get_irn_data(), 0 if the
* registration failed.
*/
-unsigned firm_register_additional_node_data(unsigned size);
+FIRM_DLL unsigned firm_register_additional_node_data(unsigned size);
/**
* Return a pointer to the node attributes.
* Needed for user-defined nodes.
*/
-void *get_irn_generic_attr(ir_node *node);
-const void *get_irn_generic_attr_const(const ir_node *node);
+FIRM_DLL void *get_irn_generic_attr(ir_node *node);
+FIRM_DLL const void *get_irn_generic_attr_const(const ir_node *node);
/**
* Returns the unique node index for the node in its graph.
* This index is used to access phase information for this node.
*/
-unsigned get_irn_idx(const ir_node *node);
+FIRM_DLL unsigned get_irn_idx(const ir_node *node);
/**
* Sets the debug information of a node.
* @param n The node.
* @param db The debug info.
*/
-void set_irn_dbg_info(ir_node *n, dbg_info *db);
+FIRM_DLL void set_irn_dbg_info(ir_node *n, dbg_info *db);
/**
* Returns the debug information of an node.
*
* @param n The node.
*/
-dbg_info *get_irn_dbg_info(const ir_node *n);
+FIRM_DLL dbg_info *get_irn_dbg_info(const ir_node *n);
/**
* Calculate a hash value of a node. Only inputs, mode and opcode are used.
*
* @param node the node to hash
*/
-unsigned firm_default_hash(const ir_node *node);
+FIRM_DLL unsigned firm_default_hash(const ir_node *node);
/**
* returns a descriptive name of a node (containing type+number)
*/
-const char *gdb_node_helper(void *firm_object);
+FIRM_DLL const char *gdb_node_helper(void *firm_object);
/*@}*/ /* end of ir_node group definition */
+#include "end.h"
+
#endif
#ifndef FIRM_IR_IROP_H
#define FIRM_IR_IROP_H
-#include "firm_types.h"
-
#include <stdio.h>
+#include "firm_types.h"
#include "ident.h"
+#include "begin.h"
/** The allowed arities. */
typedef enum {
iro_MaxOpcode
} ir_opcode;
-extern ir_op *op_Block; ir_op *get_op_Block (void);
-
-extern ir_op *op_Start; ir_op *get_op_Start (void);
-extern ir_op *op_End; ir_op *get_op_End (void);
-extern ir_op *op_Jmp; ir_op *get_op_Jmp (void);
-extern ir_op *op_IJmp; ir_op *get_op_IJmp (void);
-extern ir_op *op_Cond; ir_op *get_op_Cond (void);
-extern ir_op *op_Return; ir_op *get_op_Return (void);
-extern ir_op *op_Sel; ir_op *get_op_Sel (void);
-
-extern ir_op *op_Const; ir_op *get_op_Const (void);
-extern ir_op *op_SymConst; ir_op *get_op_SymConst (void);
-
-extern ir_op *op_Call; ir_op *get_op_Call (void);
-extern ir_op *op_Add; ir_op *get_op_Add (void);
-extern ir_op *op_Sub; ir_op *get_op_Sub (void);
-extern ir_op *op_Minus; ir_op *get_op_Minus (void);
-extern ir_op *op_Mul; ir_op *get_op_Mul (void);
-extern ir_op *op_Mulh; ir_op *get_op_Mulh (void);
-extern ir_op *op_Quot; ir_op *get_op_Quot (void);
-extern ir_op *op_DivMod; ir_op *get_op_DivMod (void);
-extern ir_op *op_Div; ir_op *get_op_Div (void);
-extern ir_op *op_Mod; ir_op *get_op_Mod (void);
-extern ir_op *op_Abs; ir_op *get_op_Abs (void);
-extern ir_op *op_And; ir_op *get_op_And (void);
-extern ir_op *op_Or; ir_op *get_op_Or (void);
-extern ir_op *op_Eor; ir_op *get_op_Eor (void);
-extern ir_op *op_Not; ir_op *get_op_Not (void);
-extern ir_op *op_Cmp; ir_op *get_op_Cmp (void);
-extern ir_op *op_Shl; ir_op *get_op_Shl (void);
-extern ir_op *op_Shr; ir_op *get_op_Shr (void);
-extern ir_op *op_Shrs; ir_op *get_op_Shrs (void);
-extern ir_op *op_Rotl; ir_op *get_op_Rotl (void);
-extern ir_op *op_Conv; ir_op *get_op_Conv (void);
-extern ir_op *op_Cast; ir_op *get_op_Cast (void);
-extern ir_op *op_Carry; ir_op *get_op_Carry (void);
-extern ir_op *op_Borrow; ir_op *get_op_Borrow (void);
-
-extern ir_op *op_Phi; ir_op *get_op_Phi (void);
-
-extern ir_op *op_Load; ir_op *get_op_Load (void);
-extern ir_op *op_Store; ir_op *get_op_Store (void);
-extern ir_op *op_Alloc; ir_op *get_op_Alloc (void);
-extern ir_op *op_Free; ir_op *get_op_Free (void);
-
-extern ir_op *op_Sync; ir_op *get_op_Sync (void);
-
-extern ir_op *op_Tuple; ir_op *get_op_Tuple (void);
-extern ir_op *op_Proj; ir_op *get_op_Proj (void);
-extern ir_op *op_Id; ir_op *get_op_Id (void);
-extern ir_op *op_Bad; ir_op *get_op_Bad (void);
-extern ir_op *op_Confirm; ir_op *get_op_Confirm (void);
-
-extern ir_op *op_Unknown; ir_op *get_op_Unknown (void);
-extern ir_op *op_Filter; ir_op *get_op_Filter (void);
-extern ir_op *op_Break; ir_op *get_op_Break (void);
-extern ir_op *op_CallBegin; ir_op *get_op_CallBegin (void);
-extern ir_op *op_EndReg; ir_op *get_op_EndReg (void);
-extern ir_op *op_EndExcept; ir_op *get_op_EndExcept (void);
-
-extern ir_op *op_NoMem; ir_op *get_op_NoMem (void);
-extern ir_op *op_Mux; ir_op *get_op_Mux (void);
-extern ir_op *op_CopyB; ir_op *get_op_CopyB (void);
-
-extern ir_op *op_InstOf; ir_op *get_op_InstOf (void);
-extern ir_op *op_Raise; ir_op *get_op_Raise (void);
-extern ir_op *op_Bound; ir_op *get_op_Bound (void);
-
-extern ir_op *op_Pin; ir_op *get_op_Pin (void);
-
-extern ir_op *op_ASM; ir_op *get_op_ASM (void);
-extern ir_op *op_Builtin; ir_op *get_op_Builtin (void);
-
-extern ir_op *op_Dummy; ir_op *get_op_Dummy (void);
-
-extern ir_op *op_Anchor; ir_op *get_op_Anchor (void);
+FIRM_DLL ir_op *op_Abs;
+FIRM_DLL ir_op *op_Add;
+FIRM_DLL ir_op *op_Alloc;
+FIRM_DLL ir_op *op_Anchor;
+FIRM_DLL ir_op *op_And;
+FIRM_DLL ir_op *op_ASM;
+FIRM_DLL ir_op *op_Bad;
+FIRM_DLL ir_op *op_Block;
+FIRM_DLL ir_op *op_Borrow;
+FIRM_DLL ir_op *op_Bound;
+FIRM_DLL ir_op *op_Break;
+FIRM_DLL ir_op *op_Builtin;
+FIRM_DLL ir_op *op_Call;
+FIRM_DLL ir_op *op_CallBegin;
+FIRM_DLL ir_op *op_Carry;
+FIRM_DLL ir_op *op_Cast;
+FIRM_DLL ir_op *op_Cmp;
+FIRM_DLL ir_op *op_Cond;
+FIRM_DLL ir_op *op_Confirm;
+FIRM_DLL ir_op *op_Const;
+FIRM_DLL ir_op *op_Conv;
+FIRM_DLL ir_op *op_CopyB;
+FIRM_DLL ir_op *op_Div;
+FIRM_DLL ir_op *op_DivMod;
+FIRM_DLL ir_op *op_Dummy;
+FIRM_DLL ir_op *op_End;
+FIRM_DLL ir_op *op_EndExcept;
+FIRM_DLL ir_op *op_EndReg;
+FIRM_DLL ir_op *op_Eor;
+FIRM_DLL ir_op *op_Filter;
+FIRM_DLL ir_op *op_Free;
+FIRM_DLL ir_op *op_Id;
+FIRM_DLL ir_op *op_IJmp;
+FIRM_DLL ir_op *op_InstOf;
+FIRM_DLL ir_op *op_Jmp;
+FIRM_DLL ir_op *op_Load;
+FIRM_DLL ir_op *op_Minus;
+FIRM_DLL ir_op *op_Mod;
+FIRM_DLL ir_op *op_Mul;
+FIRM_DLL ir_op *op_Mulh;
+FIRM_DLL ir_op *op_Mux;
+FIRM_DLL ir_op *op_NoMem;
+FIRM_DLL ir_op *op_Not;
+FIRM_DLL ir_op *op_Or;
+FIRM_DLL ir_op *op_Phi;
+FIRM_DLL ir_op *op_Pin;
+FIRM_DLL ir_op *op_Proj;
+FIRM_DLL ir_op *op_Quot;
+FIRM_DLL ir_op *op_Raise;
+FIRM_DLL ir_op *op_Return;
+FIRM_DLL ir_op *op_Rotl;
+FIRM_DLL ir_op *op_Sel;
+FIRM_DLL ir_op *op_Shl;
+FIRM_DLL ir_op *op_Shrs;
+FIRM_DLL ir_op *op_Shr;
+FIRM_DLL ir_op *op_Start;
+FIRM_DLL ir_op *op_Store;
+FIRM_DLL ir_op *op_Sub;
+FIRM_DLL ir_op *op_SymConst;
+FIRM_DLL ir_op *op_Sync;
+FIRM_DLL ir_op *op_Tuple;
+FIRM_DLL ir_op *op_Unknown;
+
+FIRM_DLL ir_op *get_op_Abs (void);
+FIRM_DLL ir_op *get_op_Add (void);
+FIRM_DLL ir_op *get_op_Alloc (void);
+FIRM_DLL ir_op *get_op_Anchor (void);
+FIRM_DLL ir_op *get_op_And (void);
+FIRM_DLL ir_op *get_op_ASM (void);
+FIRM_DLL ir_op *get_op_Bad (void);
+FIRM_DLL ir_op *get_op_Block (void);
+FIRM_DLL ir_op *get_op_Borrow (void);
+FIRM_DLL ir_op *get_op_Bound (void);
+FIRM_DLL ir_op *get_op_Break (void);
+FIRM_DLL ir_op *get_op_Builtin (void);
+FIRM_DLL ir_op *get_op_CallBegin (void);
+FIRM_DLL ir_op *get_op_Call (void);
+FIRM_DLL ir_op *get_op_Carry (void);
+FIRM_DLL ir_op *get_op_Cast (void);
+FIRM_DLL ir_op *get_op_Cmp (void);
+FIRM_DLL ir_op *get_op_Cond (void);
+FIRM_DLL ir_op *get_op_Confirm (void);
+FIRM_DLL ir_op *get_op_Const (void);
+FIRM_DLL ir_op *get_op_Conv (void);
+FIRM_DLL ir_op *get_op_CopyB (void);
+FIRM_DLL ir_op *get_op_DivMod (void);
+FIRM_DLL ir_op *get_op_Div (void);
+FIRM_DLL ir_op *get_op_Dummy (void);
+FIRM_DLL ir_op *get_op_EndExcept (void);
+FIRM_DLL ir_op *get_op_EndReg (void);
+FIRM_DLL ir_op *get_op_End (void);
+FIRM_DLL ir_op *get_op_Eor (void);
+FIRM_DLL ir_op *get_op_Filter (void);
+FIRM_DLL ir_op *get_op_Free (void);
+FIRM_DLL ir_op *get_op_Id (void);
+FIRM_DLL ir_op *get_op_IJmp (void);
+FIRM_DLL ir_op *get_op_InstOf (void);
+FIRM_DLL ir_op *get_op_Jmp (void);
+FIRM_DLL ir_op *get_op_Load (void);
+FIRM_DLL ir_op *get_op_Minus (void);
+FIRM_DLL ir_op *get_op_Mod (void);
+FIRM_DLL ir_op *get_op_Mulh (void);
+FIRM_DLL ir_op *get_op_Mul (void);
+FIRM_DLL ir_op *get_op_Mux (void);
+FIRM_DLL ir_op *get_op_NoMem (void);
+FIRM_DLL ir_op *get_op_Not (void);
+FIRM_DLL ir_op *get_op_Or (void);
+FIRM_DLL ir_op *get_op_Phi (void);
+FIRM_DLL ir_op *get_op_Pin (void);
+FIRM_DLL ir_op *get_op_Proj (void);
+FIRM_DLL ir_op *get_op_Quot (void);
+FIRM_DLL ir_op *get_op_Raise (void);
+FIRM_DLL ir_op *get_op_Return (void);
+FIRM_DLL ir_op *get_op_Rotl (void);
+FIRM_DLL ir_op *get_op_Sel (void);
+FIRM_DLL ir_op *get_op_Shl (void);
+FIRM_DLL ir_op *get_op_Shrs (void);
+FIRM_DLL ir_op *get_op_Shr (void);
+FIRM_DLL ir_op *get_op_Start (void);
+FIRM_DLL ir_op *get_op_Store (void);
+FIRM_DLL ir_op *get_op_Sub (void);
+FIRM_DLL ir_op *get_op_SymConst (void);
+FIRM_DLL ir_op *get_op_Sync (void);
+FIRM_DLL ir_op *get_op_Tuple (void);
+FIRM_DLL ir_op *get_op_Unknown (void);
/** Returns the ident for the opcode name */
-ident *get_op_ident(const ir_op *op);
+FIRM_DLL ident *get_op_ident(const ir_op *op);
/** Returns the string for the opcode. */
-const char *get_op_name(const ir_op *op);
+FIRM_DLL const char *get_op_name(const ir_op *op);
/** Returns the enum for the opcode */
-unsigned get_op_code(const ir_op *op);
+FIRM_DLL unsigned get_op_code(const ir_op *op);
/** Returns a human readable name of an op_pin_state. */
-const char *get_op_pin_state_name(op_pin_state s);
+FIRM_DLL const char *get_op_pin_state_name(op_pin_state s);
/** Gets pinned state of an opcode. */
-op_pin_state get_op_pinned(const ir_op *op);
+FIRM_DLL op_pin_state get_op_pinned(const ir_op *op);
/** Sets pinned in the opcode. Setting it to floating has no effect
for Block, Phi and control flow nodes. */
-void set_op_pinned(ir_op *op, op_pin_state pinned);
+FIRM_DLL void set_op_pinned(ir_op *op, op_pin_state pinned);
/** Returns the next free IR opcode number, allows to register user ops. */
-unsigned get_next_ir_opcode(void);
+FIRM_DLL unsigned get_next_ir_opcode(void);
/** Returns the next free n IR opcode number, allows to register a bunch of user ops. */
-unsigned get_next_ir_opcodes(unsigned num);
+FIRM_DLL unsigned get_next_ir_opcodes(unsigned num);
/**
* A generic function pointer type.
/**
* Returns the generic function pointer from an IR operation.
*/
-op_func get_generic_function_ptr(const ir_op *op);
+FIRM_DLL op_func get_generic_function_ptr(const ir_op *op);
/**
* Store a generic function pointer into an IR operation.
*/
-void set_generic_function_ptr(ir_op *op, op_func func);
+FIRM_DLL void set_generic_function_ptr(ir_op *op, op_func func);
/**
* Return the irop flags of an IR opcode.
*/
-irop_flags get_op_flags(const ir_op *op);
+FIRM_DLL irop_flags get_op_flags(const ir_op *op);
/**
* The hash operation.
* This function can create all standard Firm opcode as well as new ones.
* The behavior of new opcode depends on the operations \c ops and the \c flags.
*/
-ir_op *new_ir_op(unsigned code, const char *name, op_pin_state p,
- unsigned flags, op_arity opar, int op_index, size_t attr_size,
- const ir_op_ops *ops);
+FIRM_DLL ir_op *new_ir_op(unsigned code, const char *name, op_pin_state p,
+ unsigned flags, op_arity opar, int op_index,
+ size_t attr_size, const ir_op_ops *ops);
/** Returns the ir_op_ops of an ir_op. */
-const ir_op_ops *get_op_ops(const ir_op *op);
+FIRM_DLL const ir_op_ops *get_op_ops(const ir_op *op);
+
+#include "end.h"
#endif
#define FIRM_IR_IROPT_H
#include "firm_types.h"
+#include "begin.h"
/**
* The Floating point model.
/** If the expression referenced can be evaluated statically
* computed_value returns a tarval representing the result.
* Else returns tarval_bad. */
-tarval *computed_value(const ir_node *n);
+FIRM_DLL tarval *computed_value(const ir_node *n);
/** Applies all optimizations to n that are expressible as a pattern
* in Firm, i.e., they need not a walk of the graph.
* An equivalent optimization is applied in the constructors defined in
* ircons.ch. There n is freed if a better node could be found.
*/
-ir_node *optimize_in_place(ir_node *n);
+FIRM_DLL ir_node *optimize_in_place(ir_node *n);
+
+#include "end.h"
#endif
#define FIRM_IROPTIMIZE_H
#include "firm_types.h"
+#include "begin.h"
/**
* Control flow optimization.
* optimizations. Call local_optimize_graph() before to remove
* Ids.
*/
-void optimize_cf(ir_graph *irg);
+FIRM_DLL void optimize_cf(ir_graph *irg);
/**
* Creates an ir_graph pass for optimize_cf().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *optimize_cf_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *optimize_cf_pass(const char *name);
/**
* Perform path-sensitive jump threading on the given graph.
*
* @param irg the graph
*/
-void opt_jumpthreading(ir_graph* irg);
+FIRM_DLL void opt_jumpthreading(ir_graph* irg);
/**
* Creates an ir_graph pass for opt_jumpthreading().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *opt_jumpthreading_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *opt_jumpthreading_pass(const char *name);
/**
* Creates an ir_graph pass for opt_loopunroll().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *opt_loopunroll_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *opt_loopunroll_pass(const char *name);
/**
*
* @param irg the graph
*/
-void opt_bool(ir_graph *irg);
+FIRM_DLL void opt_bool(ir_graph *irg);
/**
* Creates an ir_graph pass for opt_bool().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *opt_bool_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *opt_bool_pass(const char *name);
/**
* Try to reduce the number of conv nodes in the given ir graph.
*
* @return non-zero if the optimization could be applied, 0 else
*/
-int conv_opt(ir_graph *irg);
+FIRM_DLL int conv_opt(ir_graph *irg);
/**
* Creates an ir_graph pass for conv_opt().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *conv_opt_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *conv_opt_pass(const char *name);
/**
* Do the scalar replacement optimization.
*
* @param irg the graph which should be optimized
*/
-void data_flow_scalar_replacement_opt(ir_graph *irg);
+FIRM_DLL void data_flow_scalar_replacement_opt(ir_graph *irg);
/**
* A callback that checks whether a entity is an allocation
* @param callback a callback function to check whether a
* given entity is a allocation call
*/
-void escape_enalysis_irg(ir_graph *irg, check_alloc_entity_func callback);
+FIRM_DLL void escape_enalysis_irg(ir_graph *irg,
+ check_alloc_entity_func callback);
/**
* Do simple and fast escape analysis for all graphs.
*
* This is most effective on Java where no other stack variables exists.
*/
-void escape_analysis(int run_scalar_replace, check_alloc_entity_func callback);
+FIRM_DLL void escape_analysis(int run_scalar_replace,
+ check_alloc_entity_func callback);
/**
* Optimize function calls by handling const functions.
*
* @note This optimization destroys the link fields of nodes.
*/
-void optimize_funccalls(int force_run, check_alloc_entity_func callback);
+FIRM_DLL void optimize_funccalls(int force_run,
+ check_alloc_entity_func callback);
/**
* Creates an ir_prog pass for optimize_funccalls().
*
* @return the newly created ir_prog pass
*/
-ir_prog_pass_t *optimize_funccalls_pass(
- const char *name,
- int force_run, check_alloc_entity_func callback);
+FIRM_DLL ir_prog_pass_t *optimize_funccalls_pass(const char *name,
+ int force_run,
+ check_alloc_entity_func callback);
/**
* Does Partial Redundancy Elimination combined with
*
* @param irg the graph
*/
-void do_gvn_pre(ir_graph *irg);
+FIRM_DLL void do_gvn_pre(ir_graph *irg);
/**
* Creates an ir_graph pass for do_gvn_pre().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *do_gvn_pre_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *do_gvn_pre_pass(const char *name);
/**
* This function is called to evaluate, if a
* Cannot handle blocks with Bad control predecessors, so call it after control
* flow optimization.
*/
-void opt_if_conv(ir_graph *irg, const ir_settings_if_conv_t *params);
+FIRM_DLL void opt_if_conv(ir_graph *irg, const ir_settings_if_conv_t *params);
/**
* Creates an ir_graph pass for opt_if_conv().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *opt_if_conv_pass(
+FIRM_DLL ir_graph_pass_t *opt_if_conv_pass(
const char *name, const ir_settings_if_conv_t *params);
/**
* them and synchronising with Sync nodes
* @param irg the graph where memory operations should be parallelised
*/
-void opt_parallelize_mem(ir_graph *irg);
+FIRM_DLL void opt_parallelize_mem(ir_graph *irg);
/**
* Creates an ir_graph pass for opt_sync().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *opt_parallelize_mem_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *opt_parallelize_mem_pass(const char *name);
/*
* Check if we can replace the load by a given const from
* returns a copy of the constant (possibly Conv'ed) on the
* current_ir_graph
*/
-ir_node *can_replace_load_by_const(const ir_node *load, ir_node *c);
+FIRM_DLL ir_node *can_replace_load_by_const(const ir_node *load, ir_node *c);
/**
* Load/Store optimization.
*
* @return non-zero if the optimization could be applied, 0 else
*/
-int optimize_load_store(ir_graph *irg);
+FIRM_DLL int optimize_load_store(ir_graph *irg);
/**
* Creates an ir_graph pass for optimize_load_store().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *optimize_load_store_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *optimize_load_store_pass(const char *name);
/**
* New experimental alternative to optimize_load_store.
* Based on a dataflow analysis, so load/stores are moved out of loops
* where possible
*/
-int opt_ldst(ir_graph *irg);
+FIRM_DLL int opt_ldst(ir_graph *irg);
/**
* Creates an ir_graph pass for opt_ldst().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *opt_ldst_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *opt_ldst_pass(const char *name);
/**
* Optimize loops by peeling or unrolling them if beneficial.
* The layout state of the frame type will be set to layout_undefined
* if entities were removed.
*/
-void loop_optimization(ir_graph *irg);
+FIRM_DLL void loop_optimization(ir_graph *irg);
/**
* Optimize the frame type of an irg by removing
* The layout state of the frame type will be set to layout_undefined
* if entities were removed.
*/
-void opt_frame_irg(ir_graph *irg);
+FIRM_DLL void opt_frame_irg(ir_graph *irg);
/**
* Creates an ir_graph pass for opt_frame_irg().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *opt_frame_irg_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *opt_frame_irg_pass(const char *name);
/** Possible flags for the Operator Scalar Replacement. */
typedef enum osr_flags {
*
* This algorithm destroys the link field of nodes.
*/
-void opt_osr(ir_graph *irg, unsigned flags);
+FIRM_DLL void opt_osr(ir_graph *irg, unsigned flags);
/**
* Creates an ir_graph pass for remove_phi_cycles().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *opt_osr_pass(const char *name, unsigned flags);
+FIRM_DLL ir_graph_pass_t *opt_osr_pass(const char *name, unsigned flags);
/**
* Removes useless Phi cycles, i.e cycles of Phi nodes with only one
*
* This algorithm destroys the link field of nodes.
*/
-void remove_phi_cycles(ir_graph *irg);
+FIRM_DLL void remove_phi_cycles(ir_graph *irg);
/**
* Creates an ir_graph pass for remove_phi_cycles().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *remove_phi_cycles_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *remove_phi_cycles_pass(const char *name);
/** A default threshold. */
* when executing a cloned method. If threshold is 0.0, every possible
* call is cloned.
*/
-void proc_cloning(float threshold);
+FIRM_DLL void proc_cloning(float threshold);
/**
* Creates an ir_prog pass for proc_cloning().
*
* @return the newly created ir_prog pass
*/
-ir_prog_pass_t *proc_cloning_pass(const char *name, float threshold);
+FIRM_DLL ir_prog_pass_t *proc_cloning_pass(const char *name, float threshold);
/**
* Reassociation.
*
* @return non-zero if the optimization could be applied, 0 else
*/
-int optimize_reassociation(ir_graph *irg);
+FIRM_DLL int optimize_reassociation(ir_graph *irg);
/**
* Creates an ir_graph pass for optimize_reassociation().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *optimize_reassociation_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *optimize_reassociation_pass(const char *name);
/**
* Normalize the Returns of a graph by creating a new End block
* res = c;
* return res;
*/
-void normalize_one_return(ir_graph *irg);
+FIRM_DLL void normalize_one_return(ir_graph *irg);
/**
* Creates an ir_graph pass for normalize_one_return().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *normalize_one_return_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *normalize_one_return_pass(const char *name);
/**
* Normalize the Returns of a graph by moving
* else
* return c;
*/
-void normalize_n_returns(ir_graph *irg);
+FIRM_DLL void normalize_n_returns(ir_graph *irg);
/**
* Creates an ir_graph pass for normalize_n_returns().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *normalize_n_returns_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *normalize_n_returns_pass(const char *name);
/**
* Do the scalar replacement optimization.
*
* @return non-zero, if at least one entity was replaced
*/
-int scalar_replacement_opt(ir_graph *irg);
+FIRM_DLL int scalar_replacement_opt(ir_graph *irg);
/**
* Creates an ir_graph pass for scalar_replacement_opt().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *scalar_replacement_opt_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *scalar_replacement_opt_pass(const char *name);
/** Performs strength reduction for the passed graph. */
-void reduce_strength(ir_graph *irg);
+FIRM_DLL void reduce_strength(ir_graph *irg);
/**
* Optimizes tail-recursion calls by converting them into loops.
*
* @return non-zero if the optimization could be applied, 0 else
*/
-int opt_tail_rec_irg(ir_graph *irg);
+FIRM_DLL int opt_tail_rec_irg(ir_graph *irg);
/**
* Creates an ir_graph pass for opt_tail_rec_irg().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *opt_tail_rec_irg_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *opt_tail_rec_irg_pass(const char *name);
/**
* Optimize tail-recursion calls for all IR-Graphs.
* because it expects the memory edges pointing to calls, which might be
* removed by optimize_funccalls().
*/
-void opt_tail_recursion(void);
+FIRM_DLL void opt_tail_recursion(void);
/**
* Creates an ir_prog pass for opt_tail_recursion().
*
* @return the newly created ir_prog pass
*/
-ir_prog_pass_t *opt_tail_recursion_pass(const char *name);
+FIRM_DLL ir_prog_pass_t *opt_tail_recursion_pass(const char *name);
/** This is the type for a method, that returns a pointer type to
* tp. This is needed in the normalization. */
* search to find an existing pointer type. If it can not find a type,
* generates a pointer type with mode_P_mach and suffix "cc_ptr_tp".
*/
-void normalize_irp_class_casts(gen_pointer_type_to_func gppt_fct);
+FIRM_DLL void normalize_irp_class_casts(gen_pointer_type_to_func gppt_fct);
/** Insert Casts so that class type casts conform exactly with the type hierarchy
* in given graph.
*
* This transformation requires that type information is computed. @see irtypeinfo.h.
*/
-void normalize_irg_class_casts(ir_graph *irg, gen_pointer_type_to_func gppt_fct);
+FIRM_DLL void normalize_irg_class_casts(ir_graph *irg,
+ gen_pointer_type_to_func gppt_fct);
/** Optimize casting between class types.
*
* Typeinformation is valid after optimization.
* Invalidates trout information.
*/
-void optimize_class_casts(void);
+FIRM_DLL void optimize_class_casts(void);
/**
* CLiff Click's combo algorithm from
*
* @param irg the graph to run on
*/
-void combo(ir_graph *irg);
+FIRM_DLL void combo(ir_graph *irg);
/**
* Creates an ir_graph pass for combo.
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *combo_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *combo_pass(const char *name);
/**
* Inlines all small methods at call sites where the called address comes
* function leaves a set of obscure Tuple nodes, e.g. a Proj-Tuple-Jmp
* combination as control flow operation.
*/
-void inline_small_irgs(ir_graph *irg, int size);
+FIRM_DLL void inline_small_irgs(ir_graph *irg, int size);
/**
* Creates an ir_graph pass for inline_small_irgs().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *inline_small_irgs_pass(const char *name, int size);
+FIRM_DLL ir_graph_pass_t *inline_small_irgs_pass(const char *name, int size);
/**
* Inlineing with a different heuristic than inline_small_irgs().
* @param ignore_runtime count a function only calling runtime functions as
* leave
*/
-void inline_leave_functions(unsigned maxsize, unsigned leavesize,
- unsigned size, int ignore_runtime);
+FIRM_DLL void inline_leave_functions(unsigned maxsize, unsigned leavesize,
+ unsigned size, int ignore_runtime);
/**
* Creates an ir_prog pass for inline_leave_functions().
*
* @return the newly created ir_prog pass
*/
-ir_prog_pass_t *inline_leave_functions_pass(
- const char *name, unsigned maxsize, unsigned leavesize,
- unsigned size, int ignore_runtime);
+FIRM_DLL ir_prog_pass_t *inline_leave_functions_pass(const char *name,
+ unsigned maxsize, unsigned leavesize, unsigned size,
+ int ignore_runtime);
typedef void (*opt_ptr)(ir_graph *irg);
* @param after_inline_opt optimizations performed immediately after inlining
* some calls
*/
-void inline_functions(unsigned maxsize, int inline_threshold,
- opt_ptr after_inline_opt);
+FIRM_DLL void inline_functions(unsigned maxsize, int inline_threshold,
+ opt_ptr after_inline_opt);
/**
* Creates an ir_prog pass for inline_functions().
*
* @return the newly created ir_prog pass
*/
-ir_prog_pass_t *inline_functions_pass(
- const char *name, unsigned maxsize, int inline_threshold,
- opt_ptr after_inline_opt);
+FIRM_DLL ir_prog_pass_t *inline_functions_pass(const char *name,
+ unsigned maxsize, int inline_threshold, opt_ptr after_inline_opt);
/**
* Combines congruent blocks into one.
*
* @return non-zero if the graph was transformed
*/
-int shape_blocks(ir_graph *irg);
+FIRM_DLL int shape_blocks(ir_graph *irg);
/**
* Creates an ir_graph pass for shape_blocks().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *shape_blocks_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *shape_blocks_pass(const char *name);
/**
* Perform loop inversion on a given graph.
* Loop inversion transforms a head controlled loop (like while(...) {} and
* for(...) {}) into a foot controlled loop (do {} while(...)).
*/
-void do_loop_inversion(ir_graph *irg);
+FIRM_DLL void do_loop_inversion(ir_graph *irg);
/**
* Perform loop unrolling on a given graph.
* Loop unrolling multiplies the number loop completely by a number found
* through a heuristic.
*/
-void do_loop_unrolling(ir_graph *irg);
+FIRM_DLL void do_loop_unrolling(ir_graph *irg);
/**
* Perform loop peeling on a given graph.
*/
-void do_loop_peeling(ir_graph *irg);
+FIRM_DLL void do_loop_peeling(ir_graph *irg);
/**
* Creates an ir_graph pass for loop inversion.
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *loop_inversion_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *loop_inversion_pass(const char *name);
/**
* Creates an ir_graph pass for loop unrolling.
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *loop_unroll_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *loop_unroll_pass(const char *name);
/**
* Creates an ir_graph pass for loop peeling.
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *loop_peeling_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *loop_peeling_pass(const char *name);
typedef ir_type *(*get_Alloc_func)(ir_node *n);
/** Set a new get_Alloc_func and returns the old one. */
-get_Alloc_func firm_set_Alloc_func(get_Alloc_func newf);
+FIRM_DLL get_Alloc_func firm_set_Alloc_func(get_Alloc_func newf);
/**
* Creates an ir_graph pass for set_vrp_data()
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *set_vrp_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *set_vrp_pass(const char *name);
/**
* Removes all entities which are unused.
* This is usually conservative than gc_irgs, but does not respect properties
* of object-oriented programs.
*/
-void garbage_collect_entities(void);
+FIRM_DLL void garbage_collect_entities(void);
/** Pass for garbage_collect_entities */
-ir_prog_pass_t *garbage_collect_entities_pass(const char *name);
+FIRM_DLL ir_prog_pass_t *garbage_collect_entities_pass(const char *name);
/** Performs dead node elimination by copying the ir graph to a new obstack.
*
*
* @param irg The graph to be optimized.
*/
-void dead_node_elimination(ir_graph *irg);
+FIRM_DLL void dead_node_elimination(ir_graph *irg);
/**
* Creates an ir_graph pass for dead_node_elimination().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *dead_node_elimination_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *dead_node_elimination_pass(const char *name);
/** Inlines a method at the given call site.
*
* @return zero if method could not be inlined (recursion for instance),
* non-zero if all went ok
*/
-int inline_method(ir_node *call, ir_graph *called_graph);
+FIRM_DLL int inline_method(ir_node *call, ir_graph *called_graph);
/** Code Placement.
*
* @todo A more powerful code placement would move operations past Phi nodes
* out of loops.
*/
-void place_code(ir_graph *irg);
+FIRM_DLL void place_code(ir_graph *irg);
/**
* Creates an ir_graph pass for place_code().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *place_code_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *place_code_pass(const char *name);
/**
* Determine information about the values of nodes and perform simplications
* using this information. This optimization performs a data-flow analysis to
* find the minimal fixpoint.
*/
-void fixpoint_vrp(ir_graph*);
+FIRM_DLL void fixpoint_vrp(ir_graph*);
/**
* Creates an ir_graph pass for fixpoint_vrp().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *fixpoint_vrp_irg_pass(const char *name);
+FIRM_DLL ir_graph_pass_t *fixpoint_vrp_irg_pass(const char *name);
+
+#include "end.h"
#endif
#define FIRM_ANA_IROUTS_H
#include "firm_types.h"
+#include "begin.h"
/*------------------------------------------------------------------*/
/* Accessing the out datastructures. */
order of successors guaranteed. Will return edges from block to floating
nodes even if irgraph is in state "op_pin_state_floats". */
/* returns the number of successors of the node: */
-int get_irn_n_outs(const ir_node *node);
+FIRM_DLL int get_irn_n_outs(const ir_node *node);
/** Get the User of a node from the Def-Use edge at position pos. */
-ir_node *get_irn_out(const ir_node *def, int pos);
+FIRM_DLL ir_node *get_irn_out(const ir_node *def, int pos);
/**
* Get the User and its input position from the Def-Use edge of def
* at position pos.
*/
-ir_node *get_irn_out_ex(const ir_node *def, int pos, int *in_pos);
+FIRM_DLL ir_node *get_irn_out_ex(const ir_node *def, int pos, int *in_pos);
/**
* Set the User at position pos.
* @param use the Use node
* @param in_pos the number of the corresponding Use-Def edge in the use node in array
*/
-void set_irn_out(ir_node *def, int pos, ir_node *use, int in_pos);
+FIRM_DLL void set_irn_out(ir_node *def, int pos, ir_node *use, int in_pos);
/* Methods to iterate through the control flow graph. Iterate from 0 to
i < get_Block_cfg_outs(block). No order of successors guaranteed. */
/** Return the number of control flow successors, ignore keep-alives. */
-int get_Block_n_cfg_outs(const ir_node *node);
+FIRM_DLL int get_Block_n_cfg_outs(const ir_node *node);
/** Return the number of control flow successors, honor keep-alives. */
-int get_Block_n_cfg_outs_ka(const ir_node *node);
+FIRM_DLL int get_Block_n_cfg_outs_ka(const ir_node *node);
/** Access predecessor n, ignore keep-alives. */
-ir_node *get_Block_cfg_out(const ir_node *node, int pos);
+FIRM_DLL ir_node *get_Block_cfg_out(const ir_node *node, int pos);
/** Access predecessor n, honor keep-alives. */
-ir_node *get_Block_cfg_out_ka(const ir_node *node, int pos);
+FIRM_DLL ir_node *get_Block_cfg_out_ka(const ir_node *node, int pos);
/** Walks over the graph starting at node. Walks also if graph is in state
"outs_inconsistent". Assumes current_ir_graph is set properly. */
-void irg_out_walk(ir_node *node,
- irg_walk_func *pre, irg_walk_func *post,
- void *env);
+FIRM_DLL void irg_out_walk(ir_node *node, irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/** Walks only over Block nodes in the graph. Has it's own visited
flag, so that it can be interleaved with the other walker.
node must be either op_Block or mode_X. */
-void irg_out_block_walk(ir_node *node,
- irg_walk_func *pre, irg_walk_func *post,
- void *env);
+FIRM_DLL void irg_out_block_walk(ir_node *node, irg_walk_func *pre,
+ irg_walk_func *post, void *env);
/**
* returns 1 if outs have been computed for a node, 0 otherwise.
*
* this is useful to detect newly created nodes that have no outs set yet
*/
-int get_irn_outs_computed(const ir_node *node);
+FIRM_DLL int get_irn_outs_computed(const ir_node *node);
/*------------------------------------------------------------------*/
/* Building and Removing the out datastructure */
graph is changed this flag must be set to "outs_inconsistent". Computes
out edges from block to floating nodes even if graph is in state
"op_pin_state_floats". Optimizes Tuple nodes. */
-void compute_irg_outs(ir_graph *irg);
-void compute_irp_outs(void);
+FIRM_DLL void compute_irg_outs(ir_graph *irg);
+FIRM_DLL void compute_irp_outs(void);
-void assure_irg_outs(ir_graph *irg);
+FIRM_DLL void assure_irg_outs(ir_graph *irg);
#ifdef INTERPROCEDURAL_VIEW
/** Computes the out edges in interprocedural view */
-void compute_ip_outs(void);
+FIRM_DLL void compute_ip_outs(void);
/** Frees the out datastructures. Sets the flag in irg to "outs_none". */
-void free_ip_outs(void);
+FIRM_DLL void free_ip_outs(void);
#endif
-void free_irg_outs(ir_graph *irg);
-void free_irp_outs(void);
+FIRM_DLL void free_irg_outs(ir_graph *irg);
+FIRM_DLL void free_irp_outs(void);
+
+#include "end.h"
#endif
#define FIRM_IR_PASS_H
#include "firm_types.h"
+#include "begin.h"
/**
* Creates a new ir_graph pass manager.
*
* @return the newly created manager
*/
-ir_graph_pass_manager_t *new_graph_pass_mgr(
- const char *name, int verify_all, int dump_all);
+FIRM_DLL ir_graph_pass_manager_t *new_graph_pass_mgr(const char *name,
+ int verify_all,
+ int dump_all);
/**
* Add an ir_graph pass to a graph pass manager.
* @param mgr the ir_graph pass manager
* @param pass the pass to add
*/
-void ir_graph_pass_mgr_add(ir_graph_pass_manager_t *mgr, ir_graph_pass_t *pass);
+FIRM_DLL void ir_graph_pass_mgr_add(ir_graph_pass_manager_t *mgr,
+ ir_graph_pass_t *pass);
/**
* Run all passes of an ir_graph pass manager.
*
* @return 0 if all passes return 0, else 1
*/
-int ir_graph_pass_mgr_run(ir_graph_pass_manager_t *mgr);
+FIRM_DLL int ir_graph_pass_mgr_run(ir_graph_pass_manager_t *mgr);
/**
* Terminate an ir_graph pass manager and all owned passes.
*
* @param mgr the manager
*/
-void term_graph_pass_mgr(ir_graph_pass_manager_t *mgr);
+FIRM_DLL void term_graph_pass_mgr(ir_graph_pass_manager_t *mgr);
/**
* Creates a new ir_prog pass manager.
*
* @return the newly created manager
*/
-ir_prog_pass_manager_t *new_prog_pass_mgr(
- const char *name, int verify_all, int dump_all);
+FIRM_DLL ir_prog_pass_manager_t *new_prog_pass_mgr(const char *name,
+ int verify_all,
+ int dump_all);
/**
* Add an ir_prog pass to an ir_prog pass manager.
* @param mgr the ir_prog pass manager
* @param pass the pass to add
*/
-void ir_prog_pass_mgr_add(ir_prog_pass_manager_t *mgr, ir_prog_pass_t *pass);
+FIRM_DLL void ir_prog_pass_mgr_add(ir_prog_pass_manager_t *mgr,
+ ir_prog_pass_t *pass);
/**
* Add an ir_graph_pass_manager as a pass to an ir_prog pass manager.
* @param mgr the ir_prog pass manager
* @param graph_mgr the ir_graph pass manager to be added
*/
-void ir_prog_pass_mgr_add_graph_mgr(
- ir_prog_pass_manager_t *mgr, ir_graph_pass_manager_t *graph_mgr);
+FIRM_DLL void ir_prog_pass_mgr_add_graph_mgr(ir_prog_pass_manager_t *mgr,
+ ir_graph_pass_manager_t *graph_mgr);
/**
* Add an ir_graph_pass as a pass to an ir_prog pass manager.
* @param mgr the ir_prog pass manager
* @param pass the ir_graph pass to be added
*/
-void ir_prog_pass_mgr_add_graph_pass(
- ir_prog_pass_manager_t *mgr, ir_graph_pass_t *pass);
+FIRM_DLL void ir_prog_pass_mgr_add_graph_pass(ir_prog_pass_manager_t *mgr,
+ ir_graph_pass_t *pass);
/**
* Run all passes of an ir_prog pass manager.
*
* @return 0 if all passes return 0, else 1
*/
-int ir_prog_pass_mgr_run(ir_prog_pass_manager_t *mgr);
+FIRM_DLL int ir_prog_pass_mgr_run(ir_prog_pass_manager_t *mgr);
/**
* Terminate an ir_prog pass manager and all owned passes.
*
* @param mgr the manager
*/
-void term_prog_pass_mgr(ir_prog_pass_manager_t *mgr);
+FIRM_DLL void term_prog_pass_mgr(ir_prog_pass_manager_t *mgr);
/**
* Set the run index for an irgraph pass manager.
* @param mgr the manager
* @param run_idx the index for the first pass of this manager
*/
-void ir_graph_pass_mgr_set_run_idx(
+FIRM_DLL void ir_graph_pass_mgr_set_run_idx(
ir_graph_pass_manager_t *mgr, unsigned run_idx);
/**
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *def_graph_pass(
+FIRM_DLL ir_graph_pass_t *def_graph_pass(
const char *name, void (*function)(ir_graph *irg));
/**
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *def_graph_pass_ret(
+FIRM_DLL ir_graph_pass_t *def_graph_pass_ret(
const char *name, int (*function)(ir_graph *irg));
/**
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *def_graph_pass_constructor(
+FIRM_DLL ir_graph_pass_t *def_graph_pass_constructor(
ir_graph_pass_t *memory,
const char *name, int (*function)(ir_graph *irg, void *context));
* @param pass the pass
* @param flag new flag setting
*/
-void ir_graph_pass_set_parallel(ir_graph_pass_t *pass, int flag);
+FIRM_DLL void ir_graph_pass_set_parallel(ir_graph_pass_t *pass, int flag);
/**
* Creates an ir_prog pass for running void function().
*
* @return the newly created ir_graph pass
*/
-ir_prog_pass_t *def_prog_pass(
+FIRM_DLL ir_prog_pass_t *def_prog_pass(
const char *name, void (*function)(void));
/**
*
* @return the newly created ir_prog pass
*/
-ir_prog_pass_t *def_prog_pass_constructor(
+FIRM_DLL ir_prog_pass_t *def_prog_pass_constructor(
ir_prog_pass_t *memory,
const char *name, int (*function)(ir_prog *irp, void *context));
*
* @return the newly created ir_prog pass
*/
-ir_prog_pass_t *call_function_pass(
+FIRM_DLL ir_prog_pass_t *call_function_pass(
const char *name, void (*function)(void *context), void *context);
/**
* @param mgr the manager
* @param run_idx the index for the first pass of this manager
*/
-void ir_prog_pass_mgr_set_run_idx(
+FIRM_DLL void ir_prog_pass_mgr_set_run_idx(
ir_prog_pass_manager_t *mgr, unsigned run_idx);
+#include "end.h"
+
#endif
#include <stddef.h>
#include <stdarg.h>
#include <stdio.h>
+#include "begin.h"
/* forward definition */
struct obstack;
* The @c it_pset is an iterator interface (of type
* @c iterator_t that allows the dumper to traverse the set.
*/
-void ir_printf(const char *fmt, ...);
+FIRM_DLL void ir_printf(const char *fmt, ...);
/**
* @see irn_printf.
*/
-void ir_fprintf(FILE *f, const char *fmt, ...);
+FIRM_DLL void ir_fprintf(FILE *f, const char *fmt, ...);
/**
* @see irn_printf.
*/
-void ir_snprintf(char *buf, size_t n, const char *fmt, ...);
+FIRM_DLL void ir_snprintf(char *buf, size_t n, const char *fmt, ...);
/**
* @see irn_printf.
*/
-void ir_vprintf(const char *fmt, va_list args);
+FIRM_DLL void ir_vprintf(const char *fmt, va_list args);
/**
* @see irn_printf.
*/
-void ir_vfprintf(FILE *f, const char *fmt, va_list args);
+FIRM_DLL void ir_vfprintf(FILE *f, const char *fmt, va_list args);
/**
* @see irn_printf.
*/
-void ir_vsnprintf(char *buf, size_t len, const char *fmt, va_list args);
+FIRM_DLL void ir_vsnprintf(char *buf, size_t len, const char *fmt,
+ va_list args);
/**
* @see irn_printf.
*/
-void ir_obst_vprintf(struct obstack *obst, const char *fmt, va_list args);
+FIRM_DLL void ir_obst_vprintf(struct obstack *obst, const char *fmt,
+ va_list args);
+
+#include "end.h"
#endif
#include "firm_types.h"
#include "irgraph.h"
+#include "begin.h"
typedef enum ir_segment_t {
IR_SEGMENT_FIRST,
* @note
* Think of the irp as the "handle" of a program.
*/
-extern ir_prog *irp;
+FIRM_DLL ir_prog *irp;
#ifndef NDEBUG
-void irp_reserve_resources(ir_prog *irp, ir_resources_t resources);
-void irp_free_resources(ir_prog *irp, ir_resources_t resources);
-ir_resources_t irp_resources_reserved(const ir_prog *irp);
+FIRM_DLL void irp_reserve_resources(ir_prog *irp, ir_resources_t resources);
+FIRM_DLL void irp_free_resources(ir_prog *irp, ir_resources_t resources);
+FIRM_DLL ir_resources_t irp_resources_reserved(const ir_prog *irp);
#else
#define irp_reserve_resources(irp, resources)
#define irp_free_resources(irp, resources)
*
* @see irp
*/
-ir_prog *get_irp(void);
+FIRM_DLL ir_prog *get_irp(void);
/**
* Creates a new ir_prog (a module or compilation unit),
*
* @param name the name of this irp (module)
*/
-ir_prog *new_ir_prog(const char *name);
+FIRM_DLL ir_prog *new_ir_prog(const char *name);
/** frees all memory used by irp. Types in type list and irgs in irg
* list must be freed by hand before. */
-void free_ir_prog(void);
+FIRM_DLL void free_ir_prog(void);
/** Sets the file name / executable name or the like. Initially the
ident 'no_name_set'. */
-void set_irp_prog_name(ident *name);
+FIRM_DLL void set_irp_prog_name(ident *name);
/** Returns true if the user ever set a program name */
-int irp_prog_name_is_set(void);
+FIRM_DLL int irp_prog_name_is_set(void);
/** Gets the name of the current irp. */
-ident *get_irp_ident(void);
+FIRM_DLL ident *get_irp_ident(void);
/** Gets the name of the current irp. */
-const char *get_irp_name(void);
+FIRM_DLL const char *get_irp_name(void);
/** Gets the main routine of the compiled program. */
-ir_graph *get_irp_main_irg(void);
+FIRM_DLL ir_graph *get_irp_main_irg(void);
/** Sets the main routine of the compiled program. */
-void set_irp_main_irg(ir_graph *main_irg);
+FIRM_DLL void set_irp_main_irg(ir_graph *main_irg);
/** Adds irg to the list of ir graphs in the current irp. */
-void add_irp_irg(ir_graph *irg);
+FIRM_DLL void add_irp_irg(ir_graph *irg);
/** Removes irg from the list of irgs and
shrinks the list by one. */
-void remove_irp_irg_from_list(ir_graph *irg);
+FIRM_DLL void remove_irp_irg_from_list(ir_graph *irg);
/** Removes irg from the list of irgs, deallocates it and
shrinks the list by one. */
-void remove_irp_irg(ir_graph *irg);
+FIRM_DLL void remove_irp_irg(ir_graph *irg);
/** returns the biggest not used irg index number */
-int get_irp_last_idx(void);
+FIRM_DLL int get_irp_last_idx(void);
/** Returns the number of ir graphs in the irp. */
-int get_irp_n_irgs(void);
+FIRM_DLL int get_irp_n_irgs(void);
/** Returns the ir graph at position pos in the irp. */
-ir_graph *get_irp_irg(int pos);
+FIRM_DLL ir_graph *get_irp_irg(int pos);
/** Sets the ir graph at position pos. */
-void set_irp_irg(int pos, ir_graph *irg);
+FIRM_DLL void set_irp_irg(int pos, ir_graph *irg);
/** Gets the number of graphs _and_ pseudo graphs. */
-int get_irp_n_allirgs(void);
+FIRM_DLL int get_irp_n_allirgs(void);
/** Returns the ir graph at position pos of all graphs (including
pseudo graphs). Visits first graphs, then pseudo graphs. */
-ir_graph *get_irp_allirg(int pos);
+FIRM_DLL ir_graph *get_irp_allirg(int pos);
/**
* Returns the type containing the entities for a segment.
*
* @param segment the segment
*/
-ir_type *get_segment_type(ir_segment_t segment);
+FIRM_DLL ir_type *get_segment_type(ir_segment_t segment);
/**
* @brief Changes a segment segment type for the program.
* (use with care)
*/
-void set_segment_type(ir_segment_t segment, ir_type *new_type);
+FIRM_DLL void set_segment_type(ir_segment_t segment, ir_type *new_type);
/**
* Returns the "global" type of the irp.
* Upon creation this is an empty class type.
* This is a convenience function for get_segment_type(IR_SEGMENT_GLOBAL)
*/
-ir_type *get_glob_type(void);
+FIRM_DLL ir_type *get_glob_type(void);
/**
* Returns the "thread local storage" type of the irp.
* Upon creation this is an empty struct type.
* This is a convenience function for get_segment_type(IR_SEGMENT_THREAD_LOCAL)
*/
-ir_type *get_tls_type(void);
+FIRM_DLL ir_type *get_tls_type(void);
/** Adds type to the list of types in irp. */
-void add_irp_type(ir_type *typ);
+FIRM_DLL void add_irp_type(ir_type *typ);
/** Removes type from the list of types, deallocates it and
shrinks the list by one. */
-void remove_irp_type(ir_type *typ);
+FIRM_DLL void remove_irp_type(ir_type *typ);
/**
* Returns the number of all types in the irp.
* @deprecated
*/
-int get_irp_n_types(void);
+FIRM_DLL int get_irp_n_types(void);
/**
* Returns the type at position pos in the irp.
* @deprecated
*/
-ir_type *get_irp_type(int pos);
+FIRM_DLL ir_type *get_irp_type(int pos);
/**
* Overwrites the type at position pos with another type.
* @deprecated
*/
-void set_irp_type(int pos, ir_type *typ);
+FIRM_DLL void set_irp_type(int pos, ir_type *typ);
/** Returns the number of all modes in the irp. */
-int get_irp_n_modes(void);
+FIRM_DLL int get_irp_n_modes(void);
/** Returns the mode at position pos in the irp. */
-ir_mode *get_irp_mode(int pos);
+FIRM_DLL ir_mode *get_irp_mode(int pos);
/** Adds opcode to the list of opcodes in irp. */
-void add_irp_opcode(ir_op *opcode);
+FIRM_DLL void add_irp_opcode(ir_op *opcode);
/** Removes opcode from the list of opcodes, deallocates it and
shrinks the list by one. */
-void remove_irp_opcode(ir_op *opcode);
+FIRM_DLL void remove_irp_opcode(ir_op *opcode);
/** Returns the number of all opcodes in the irp. */
-int get_irp_n_opcodes(void);
+FIRM_DLL int get_irp_n_opcodes(void);
/** Returns the opcode at position pos in the irp. */
-ir_op *get_irp_opcode(int pos);
+FIRM_DLL ir_op *get_irp_opcode(int pos);
/** Sets the generic function pointer of all opcodes to NULL */
-void clear_irp_opcodes_generic_func(void);
+FIRM_DLL void clear_irp_opcodes_generic_func(void);
/** Return the graph for global constants of the current irp.
* or any controlflow.
* See also copy_const_code() in entity.h.
*/
-ir_graph *get_const_code_irg(void);
+FIRM_DLL ir_graph *get_const_code_irg(void);
/** The phase state for the program.
* high: all graphs are in state high or low, all types are constructed.
* low: all graphs are in state low, all types are in state layout fixed.
*/
-irg_phase_state get_irp_phase_state(void);
-void set_irp_phase_state(irg_phase_state s);
+FIRM_DLL irg_phase_state get_irp_phase_state(void);
+FIRM_DLL void set_irp_phase_state(irg_phase_state s);
-irg_outs_state get_irp_ip_outs_state(void);
-void set_irp_ip_outs_inconsistent(void);
+FIRM_DLL irg_outs_state get_irp_ip_outs_state(void);
+FIRM_DLL void set_irp_ip_outs_inconsistent(void);
/**
* Creates an ir_prog pass for set_irp_phase_state().
*
* @return the newly created ir_prog pass
*/
-ir_prog_pass_t *set_irp_phase_state_pass(const char *name, irg_phase_state state);
+FIRM_DLL ir_prog_pass_t *set_irp_phase_state_pass(const char *name,
+ irg_phase_state state);
-irg_callee_info_state get_irp_callee_info_state(void);
-void set_irp_callee_info_state(irg_callee_info_state s);
+FIRM_DLL irg_callee_info_state get_irp_callee_info_state(void);
+FIRM_DLL void set_irp_callee_info_state(irg_callee_info_state s);
/** Returns a new, unique exception region number. */
-ir_exc_region_t get_irp_next_region_nr(void);
+FIRM_DLL ir_exc_region_t get_irp_next_region_nr(void);
/** Returns a new, unique label number. */
-ir_label_t get_irp_next_label_nr(void);
+FIRM_DLL ir_label_t get_irp_next_label_nr(void);
/** Add a new global asm include. */
-void add_irp_asm(ident *asm_string);
+FIRM_DLL void add_irp_asm(ident *asm_string);
/** Return the number of global asm includes. */
-int get_irp_n_asms(void);
+FIRM_DLL int get_irp_n_asms(void);
/** Return the global asm include at position pos. */
-ident *get_irp_asm(int pos);
+FIRM_DLL ident *get_irp_asm(int pos);
+
+#include "end.h"
#endif
#include "irgraph.h"
#include "irnode.h"
#include "typerep.h"
-
-
+#include "begin.h"
/* ------------ Building and Removing the type information ----------- */
* Uses the link field of types. Sets this field of each type to point to a
* pointer type that points to the type (Got it? ;-)).
*/
-void simple_analyse_types(void);
+FIRM_DLL void simple_analyse_types(void);
/** Frees all type information datastructures. Sets the flag in irg to "???". */
-void free_simple_type_information(void);
+FIRM_DLL void free_simple_type_information(void);
+
+#include "end.h"
#endif
#define FIRM_ANA_IRTYPEINFO_H
#include "firm_types.h"
+#include "begin.h"
/* ------------ Auxiliary type. --------------------------------------- */
* variable is initialized by init_irtypeinfo(). The type is freed by
* free_irtypeinfo().
*/
-extern ir_type *initial_type;
+FIRM_DLL ir_type *initial_type;
* Calling set/get_irn_typeinfo_type() is invalid before calling init. Requires memory
* in the order of MIN(\<calls to set_irn_typeinfo_type\>, \#irnodes).
*/
-void init_irtypeinfo(void);
-void free_irtypeinfo(void);
+FIRM_DLL void init_irtypeinfo(void);
+FIRM_DLL void free_irtypeinfo(void);
/* ------------ Irgraph state handling. ------------------------------- */
because of other transformations. */
} ir_typeinfo_state;
-void set_irg_typeinfo_state(ir_graph *irg, ir_typeinfo_state s);
-ir_typeinfo_state get_irg_typeinfo_state(const ir_graph *irg);
+FIRM_DLL void set_irg_typeinfo_state(ir_graph *irg, ir_typeinfo_state s);
+FIRM_DLL ir_typeinfo_state get_irg_typeinfo_state(const ir_graph *irg);
/** Returns accumulated type information state information.
*
* consistent. Returns ir_typeinfo_inconsistent if at least one irg has inconsistent
* or no type information. Returns ir_typeinfo_none if no irg contains type information.
*/
-ir_typeinfo_state get_irp_typeinfo_state(void);
-void set_irp_typeinfo_state(ir_typeinfo_state s);
+FIRM_DLL ir_typeinfo_state get_irp_typeinfo_state(void);
+FIRM_DLL void set_irp_typeinfo_state(ir_typeinfo_state s);
/** If typeinfo is consistent, sets it to inconsistent. */
-void set_irp_typeinfo_inconsistent(void);
+FIRM_DLL void set_irp_typeinfo_inconsistent(void);
/* ------------ Irnode type information. ------------------------------ */
* ir_typeinfo_consistent or ir_typeinfo_inconsistent. They
* assume current_ir_graph set properly.
*/
-ir_type *get_irn_typeinfo_type(const ir_node *n);
-void set_irn_typeinfo_type(ir_node *n, ir_type *tp);
+FIRM_DLL ir_type *get_irn_typeinfo_type(const ir_node *n);
+FIRM_DLL void set_irn_typeinfo_type(ir_node *n, ir_type *tp);
+
+#include "end.h"
#endif
#define FIRM_IR_IRVRFY_H
#include "firm_types.h"
+#include "begin.h"
/**
* Tests the modes of checknode and its predecessors.
* @return
* NON-zero on success
*/
-int irn_vrfy(ir_node *checknode);
+FIRM_DLL int irn_vrfy(ir_node *checknode);
/**
* Tests the modes of checknode and its predecessors.
* @return
* NON-zero on success
*/
-int irn_vrfy_irg(ir_node *checknode, ir_graph *irg);
+FIRM_DLL int irn_vrfy_irg(ir_node *checknode, ir_graph *irg);
/**
* Same as irn_vrfy_irg, but temporary sets verification mode to
* @return
* NON-zero on success
*/
-int irn_vrfy_irg_dump(ir_node *checknode, ir_graph *irg, const char **bad_string);
+FIRM_DLL int irn_vrfy_irg_dump(ir_node *checknode, ir_graph *irg, const char **bad_string);
/**
* Flags for irg_verify().
* @return
* NON-zero on success.
*/
-int irg_verify(ir_graph *irg, unsigned flags);
+FIRM_DLL int irg_verify(ir_graph *irg, unsigned flags);
/**
* Compatibility macro. Deprecated soon.
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *irg_verify_pass(const char *name, unsigned flags);
+FIRM_DLL ir_graph_pass_t *irg_verify_pass(const char *name, unsigned flags);
/**
* Possible flags for irg_vrfy_bads().
* which Bads are allowed
* @returns a value combined of verify_bad_flags_t indicating the problems found.
*/
-int irg_vrfy_bads(ir_graph *irg, int flags);
+FIRM_DLL int irg_vrfy_bads(ir_graph *irg, int flags);
/**
* Enable/disable verification of Load/Store nodes with
* its entities. If disabled, Store(SymConst(array)) will be allowed
* (C-frontend builds this :-)
*/
-void vrfy_enable_entity_tests(int enable);
+FIRM_DLL void vrfy_enable_entity_tests(int enable);
+
+#include "end.h"
#endif
#define FIRM_LOWERING_H
#include "firm_types.h"
+
+#include "begin.h"
+
/**
* A type telling where to add hidden parameters.
*/
* If params->find_pointer_type is NULL, new pointer types
* are always created automatically.
*/
-void lower_calls_with_compounds(const lower_params_t *params);
+FIRM_DLL void lower_calls_with_compounds(const lower_params_t *params);
/**
- * * Lower CopyB nodes of size smaller that max_size into Loads/Stores
+ * Lower CopyB nodes of size smaller that max_size into Loads/Stores
*/
-void lower_CopyB(ir_graph *irg, unsigned max_size, unsigned native_mode_bytes);
+FIRM_DLL void lower_CopyB(ir_graph *irg, unsigned max_size,
+ unsigned native_mode_bytes);
/**
* Lowers all Switches (Cond nodes with non-boolean mode) depending on spare_size.
* @param spare_size Allowed spare size for table switches in machine words.
* (Default in edgfe: 128)
*/
-void lower_switch(ir_graph *irg, unsigned spare_size);
+FIRM_DLL void lower_switch(ir_graph *irg, unsigned spare_size);
/**
* Creates an ir_graph pass for lower_switch().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *lower_switch_pass(const char *name, unsigned spare_size);
+FIRM_DLL ir_graph_pass_t *lower_switch_pass(const char *name,
+ unsigned spare_size);
/**
* A callback type for creating an intrinsic entity for a given opcode.
*
* @param param parameter for lowering
*/
-void lower_dw_ops(const lwrdw_param_t *param);
+FIRM_DLL void lower_dw_ops(const lwrdw_param_t *param);
/**
* Creates an ir_prog pass for lower_dw_ops().
*
* @return the newly created ir_prog pass
*/
-ir_prog_pass_t *lower_dw_ops_pass(const char *name, const lwrdw_param_t *param);
+FIRM_DLL ir_prog_pass_t *lower_dw_ops_pass(const char *name,
+ const lwrdw_param_t *param);
/**
* Default implementation. Context is unused.
*/
-ir_entity *def_create_intrinsic_fkt(ir_type *method, const ir_op *op,
- const ir_mode *imode, const ir_mode *omode,
- void *context);
+FIRM_DLL ir_entity *def_create_intrinsic_fkt(ir_type *method, const ir_op *op,
+ const ir_mode *imode,
+ const ir_mode *omode,
+ void *context);
/**
* Replaces SymConsts by a real constant if possible.
* @note: There is NO lowering ob objects oriented types. This is highly compiler
* and ABI specific and should be placed directly in the compiler.
*/
-void lower_highlevel_graph(ir_graph *irg, int lower_bitfields);
+FIRM_DLL void lower_highlevel_graph(ir_graph *irg, int lower_bitfields);
/**
* Creates an ir_graph pass for lower_highlevel_graph().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *lower_highlevel_graph_pass(const char *name, int lower_bitfields);
+FIRM_DLL ir_graph_pass_t *lower_highlevel_graph_pass(const char *name,
+ int lower_bitfields);
/**
* Replaces SymConsts by a real constant if possible.
* @note There is NO lowering of objects oriented types. This is highly compiler
* and ABI specific and should be placed directly in the compiler.
*/
-void lower_highlevel(int lower_bitfields);
+FIRM_DLL void lower_highlevel(int lower_bitfields);
/**
* does the same as lower_highlevel for all nodes on the const code irg
*/
-void lower_const_code(void);
+FIRM_DLL void lower_const_code(void);
/**
* Creates an ir_prog pass for lower_const_code().
*
* @return the newly created ir_prog pass
*/
-ir_prog_pass_t *lower_const_code_pass(const char *name);
+FIRM_DLL ir_prog_pass_t *lower_const_code_pass(const char *name);
typedef struct lower_mode_b_config_t {
/* mode that is used to transport 0/1 values */
* @param irg the firm graph to lower
* @param config configuration for mode_b lowerer
*/
-void ir_lower_mode_b(ir_graph *irg, const lower_mode_b_config_t *config);
+FIRM_DLL void ir_lower_mode_b(ir_graph *irg,
+ const lower_mode_b_config_t *config);
/**
* Creates an ir_graph pass for ir_lower_mode_b().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *ir_lower_mode_b_pass(
- const char *name, const lower_mode_b_config_t *config);
+FIRM_DLL ir_graph_pass_t *ir_lower_mode_b_pass(const char *name,
+ const lower_mode_b_config_t *config);
/**
* Used as callback, whenever a lowerable mux is found. The return value
* @param cb_func The callback function for mux selection. Can be NULL,
* to lower all mux nodes.
*/
-void lower_mux(ir_graph *irg, lower_mux_callback *cb_func);
+FIRM_DLL void lower_mux(ir_graph *irg, lower_mux_callback *cb_func);
/**
* Creates an ir_graph pass for lower_mux().
*
* @return the newly created ir_graph pass
*/
-ir_graph_pass_t *lower_mux_pass(const char *name, lower_mux_callback *cb_func);
+FIRM_DLL ir_graph_pass_t *lower_mux_pass(const char *name,
+ lower_mux_callback *cb_func);
/**
* An intrinsic mapper function.
*
* @return number of found intrinsics.
*/
-unsigned lower_intrinsics(i_record *list, int length, int part_block_used);
+FIRM_DLL unsigned lower_intrinsics(i_record *list, int length,
+ int part_block_used);
/**
* Creates an irprog pass for lower_intrinsics.
* @param length the length of the array
* @param part_block_used set to true if part_block() must be using during lowering
*/
-ir_prog_pass_t *lower_intrinsics_pass(
- const char *name,
- i_record *list, int length, int part_block_used);
+FIRM_DLL ir_prog_pass_t *lower_intrinsics_pass(const char *name, i_record *list,
+ int length, int part_block_used);
/**
* A mapper for the integer/float absolute value: type abs(type v).
*
* @return always 1
*/
-int i_mapper_abs(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_abs(ir_node *call, void *ctx);
/**
* A mapper for the integer byte swap value: type bswap(type v).
*
* @return always 1
*/
-int i_mapper_bswap(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_bswap(ir_node *call, void *ctx);
/**
* A mapper for the floating point sqrt(v): floattype sqrt(floattype v);
*
* @return 1 if the sqrt call was removed, 0 else.
*/
-int i_mapper_sqrt(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_sqrt(ir_node *call, void *ctx);
/**
* A mapper for the floating point cbrt(v): floattype sqrt(floattype v);
*
* @return 1 if the cbrt call was removed, 0 else.
*/
-int i_mapper_cbrt(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_cbrt(ir_node *call, void *ctx);
/**
* A mapper for the floating point pow(a, b): floattype pow(floattype a, floattype b);
*
* @return 1 if the pow call was removed, 0 else.
*/
-int i_mapper_pow(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_pow(ir_node *call, void *ctx);
/**
* A mapper for the floating point exp(a): floattype exp(floattype a);
*
* @return 1 if the exp call was removed, 0 else.
*/
-int i_mapper_exp(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_exp(ir_node *call, void *ctx);
#define i_mapper_exp2 i_mapper_exp
#define i_mapper_exp10 i_mapper_exp
*
* @return 1 if the log call was removed, 0 else.
*/
-int i_mapper_log(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_log(ir_node *call, void *ctx);
#define i_mapper_log2 i_mapper_log
#define i_mapper_log10 i_mapper_log
*
* @return 1 if the sin call was removed, 0 else.
*/
-int i_mapper_sin(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_sin(ir_node *call, void *ctx);
/**
* A mapper for the floating point sin(a): floattype cos(floattype a);
*
* @return 1 if the cos call was removed, 0 else.
*/
-int i_mapper_cos(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_cos(ir_node *call, void *ctx);
/**
* A mapper for the floating point tan(a): floattype tan(floattype a);
*
* @return 1 if the tan call was removed, 0 else.
*/
-int i_mapper_tan(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_tan(ir_node *call, void *ctx);
/**
* A mapper for the floating point asin(a): floattype asin(floattype a);
*
* @return 1 if the asin call was removed, 0 else.
*/
-int i_mapper_asin(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_asin(ir_node *call, void *ctx);
/**
* A mapper for the floating point acos(a): floattype acos(floattype a);
*
* @return 1 if the tan call was removed, 0 else.
*/
-int i_mapper_acos(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_acos(ir_node *call, void *ctx);
/**
* A mapper for the floating point atan(a): floattype atan(floattype a);
*
* @return 1 if the atan call was removed, 0 else.
*/
-int i_mapper_atan(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_atan(ir_node *call, void *ctx);
/**
* A mapper for the floating point sinh(a): floattype sinh(floattype a);
*
* @return 1 if the sinh call was removed, 0 else.
*/
-int i_mapper_sinh(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_sinh(ir_node *call, void *ctx);
/**
* A mapper for the floating point cosh(a): floattype cosh(floattype a);
*
* @return 1 if the cosh call was removed, 0 else.
*/
-int i_mapper_cosh(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_cosh(ir_node *call, void *ctx);
/**
* A mapper for the floating point tanh(a): floattype tanh(floattype a);
*
* @return 1 if the tanh call was removed, 0 else.
*/
-int i_mapper_tanh(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_tanh(ir_node *call, void *ctx);
/**
* A mapper for the strcmp-Function: inttype strcmp(char pointer a, char pointer b);
*
* @return 1 if the strcmp call was removed, 0 else.
*/
-int i_mapper_strcmp(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_strcmp(ir_node *call, void *ctx);
/**
* A mapper for the strncmp-Function: inttype strncmp(char pointer a, char pointer b, inttype len);
*
* @return 1 if the strncmp call was removed, 0 else.
*/
-int i_mapper_strncmp(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_strncmp(ir_node *call, void *ctx);
/**
* A mapper for the strcpy-Function: char pointer strcpy(char pointer a, char pointer b);
*
* @return 1 if the strcpy call was removed, 0 else.
*/
-int i_mapper_strcpy(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_strcpy(ir_node *call, void *ctx);
/**
* A mapper for the strlen-Function: inttype strlen(char pointer a);
*
* @return 1 if the strlen call was removed, 0 else.
*/
-int i_mapper_strlen(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_strlen(ir_node *call, void *ctx);
/**
* A mapper for the memcpy-Function: void pointer memcpy(void pointer d, void pointer s, inttype c);
*
* @return 1 if the memcpy call was removed, 0 else.
*/
-int i_mapper_memcpy(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_memcpy(ir_node *call, void *ctx);
/**
* A mapper for the mempcpy-Function: void pointer mempcpy(void pointer d, void pointer s, inttype c);
*
* @return 1 if the mempcpy call was removed, 0 else.
*/
-int i_mapper_mempcpy(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_mempcpy(ir_node *call, void *ctx);
/**
* A mapper for the memmove-Function: void pointer memmove(void pointer d, void pointer s, inttype c);
*
* @return 1 if the memmove call was removed, 0 else.
*/
-int i_mapper_memmove(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_memmove(ir_node *call, void *ctx);
/**
* A mapper for the memset-Function: void pointer memset(void pointer d, inttype C, inttype len);
*
* @return 1 if the memset call was removed, 0 else.
*/
-int i_mapper_memset(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_memset(ir_node *call, void *ctx);
/**
* A mapper for the strncmp-Function: inttype memcmp(void pointer a, void pointer b, inttype len);
*
* @return 1 if the strncmp call was removed, 0 else.
*/
-int i_mapper_memcmp(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_memcmp(ir_node *call, void *ctx);
/**
* A mapper for the alloca() function: pointer alloca(inttype size)
*
* @return always 1
*/
-int i_mapper_alloca(ir_node *call, void *ctx);
+FIRM_DLL int i_mapper_alloca(ir_node *call, void *ctx);
/**
* A runtime routine description.
};
@endcode
*/
-int i_mapper_RuntimeCall(ir_node *node, runtime_rt *rt);
+FIRM_DLL int i_mapper_RuntimeCall(ir_node *node, runtime_rt *rt);
+
+#include "end.h"
-#endif /* FIRM_LOWERING_H */
+#endif
#include "firm_types.h"
+#include "begin.h"
+
/** Create a new ir graph to build a pseudo representation of a procedure.
*
* The pseudo representation can only be used for analyses. It may not be
* optimized. Pseudo graphs are kept in a separate graph list in irprog.
*/
-ir_graph *new_pseudo_ir_graph(ir_entity *ent, int n_loc);
+FIRM_DLL ir_graph *new_pseudo_ir_graph(ir_entity *ent, int n_loc);
/** Returns non-zero ir ir_graph is pseudo graph.
* Is irg a pseudo graph for analysis? */
-int is_pseudo_ir_graph(ir_graph *irg);
+FIRM_DLL int is_pseudo_ir_graph(ir_graph *irg);
/** Returns the number of pseudo graphs in the program. */
-int get_irp_n_pseudo_irgs(void);
+FIRM_DLL int get_irp_n_pseudo_irgs(void);
/** Add a graph as pseudo irg */
-void add_irp_pseudo_irg(ir_graph *irg);
+FIRM_DLL void add_irp_pseudo_irg(ir_graph *irg);
/** Returns the pos'th pseudo graph in the program. */
-ir_graph *get_irp_pseudo_irg(int pos);
+FIRM_DLL ir_graph *get_irp_pseudo_irg(int pos);
/** If set, get_irp_n_irgs() and get_irp_irg() behave as if all pseudo
graphs are in the irg list. If not set, get_entity_irg() returns
NULL if the entity refers to a pseudo irg. */
-void set_visit_pseudo_irgs(int x);
-int get_visit_pseudo_irgs(void);
+FIRM_DLL void set_visit_pseudo_irgs(int x);
+FIRM_DLL int get_visit_pseudo_irgs(void);
+
+#include "end.h"
#endif
#include "firm_types.h"
+#include "begin.h"
+
/**
* Initialise the RTA data structures and perform RTA.
* Expects that all allocations are done by Alloc nodes.
*/
-void rta_init(void);
+FIRM_DLL void rta_init(void);
/**
* Delete all graphs that have been found to be dead.
*/
-void rta_delete_dead_graphs (void);
+FIRM_DLL void rta_delete_dead_graphs (void);
/** Clean up our data structures.
* Finishes the RTA.
*/
-void rta_cleanup(void);
+FIRM_DLL void rta_cleanup(void);
/** Returns non-zero if the given class is alive. */
-int rta_is_alive_class(ir_type *clazz);
+FIRM_DLL int rta_is_alive_class(ir_type *clazz);
/** Returns non-zero if the given graph is alive. */
-int rta_is_alive_graph(ir_graph *graph);
+FIRM_DLL int rta_is_alive_graph(ir_graph *graph);
/** report for all graphs and types whether they are alive */
-void rta_report(void);
+FIRM_DLL void rta_report(void);
+
+#include "end.h"
#endif
#include "ident.h"
+#include "begin.h"
+
/**
* @typedef seqno_t
*
*
* @return a sequence number for this position.
*/
-seqno_t firm_seqno_enter(const char *filename, unsigned lineno);
+FIRM_DLL seqno_t firm_seqno_enter(const char *filename, unsigned lineno);
/**
* Create a new sequence number from a filename ident and a line number.
*
* @return a sequence number for this position.
*/
-seqno_t firm_seqno_enter_id(ident *filename, unsigned lineno);
+FIRM_DLL seqno_t firm_seqno_enter_id(ident *filename, unsigned lineno);
/**
* Retrieve filename and line number from a sequence number.
*
* @return the file name of this position.
*/
-const char *firm_seqno_retrieve(seqno_t seqno, unsigned *lineno);
+FIRM_DLL const char *firm_seqno_retrieve(seqno_t seqno, unsigned *lineno);
/**
* Creates the sequence number pool.
* support is optional. Call firm_seqno_init() after init_firm()
* if sequence numbers should be used.
*/
-void firm_seqno_init(void);
+FIRM_DLL void firm_seqno_init(void);
/**
* Terminates the sequence number pool.
* Call this function to terminate the sequence
* pool.
*/
-void firm_seqno_term(void);
+FIRM_DLL void firm_seqno_term(void);
+
+#include "end.h"
#endif
#include "firm_types.h"
+#include "begin.h"
+
/**
* This enum describes the different regions constructed by the structural analysis.
*/
*
* @param reg the region
*/
-void *get_region_link(const ir_region *reg);
+FIRM_DLL void *get_region_link(const ir_region *reg);
/**
* Sets the link of a region.
* @param reg the region
* @param data the data
*/
-void set_region_link(ir_region *reg, void *data);
+FIRM_DLL void set_region_link(ir_region *reg, void *data);
/**
* Get the immediate region of a block.
*
* @param block a block node
*/
-ir_region *get_block_region(const ir_node *block);
+FIRM_DLL ir_region *get_block_region(const ir_node *block);
/**
* Sets the immediate region of a block.
* @param block a block node
* @param reg the region
*/
-void set_block_region(ir_node *block, ir_region *reg);
+FIRM_DLL void set_block_region(ir_node *block, ir_region *reg);
/**
* Get the immediate region of a node.
*
* @param n a Firm IR node
*/
-ir_region *get_irn_region(ir_node *n);
+FIRM_DLL ir_region *get_irn_region(ir_node *n);
/**
* Return non-if a given firm thing is a region.
*
* @param thing a Firm object address
*/
-int is_region(const void *thing);
+FIRM_DLL int is_region(const void *thing);
/**
* Return the number of predecessors in a region.
*
* @param reg the region
*/
-int get_region_n_preds(const ir_region *reg);
+FIRM_DLL int get_region_n_preds(const ir_region *reg);
/**
* Return the predecessor region at position pos.
* @param reg the region
* @param pos the position number
*/
-ir_region *get_region_pred(const ir_region *reg, int pos);
+FIRM_DLL ir_region *get_region_pred(const ir_region *reg, int pos);
/**
* Set the predecessor region at position pos.
* @param pos the position number
* @param n the new predecessor region
*/
-void set_region_pred(ir_region *reg, int pos, ir_region *n);
+FIRM_DLL void set_region_pred(ir_region *reg, int pos, ir_region *n);
/**
* Return the number of successors in a region.
*
* @param reg the region
*/
-int get_region_n_succs(const ir_region *reg);
+FIRM_DLL int get_region_n_succs(const ir_region *reg);
/**
* Return the successor region at position pos.
* @param reg the region
* @param pos the position number
*/
-ir_region *get_region_succ(const ir_region *reg, int pos);
+FIRM_DLL ir_region *get_region_succ(const ir_region *reg, int pos);
/**
* Set the successor region at position pos.
* @param pos the position number
* @param n the new successor region
*/
-void set_region_succ(ir_region *reg, int pos, ir_region *n);
+FIRM_DLL void set_region_succ(ir_region *reg, int pos, ir_region *n);
/**
* Construct the region tree of a graph by doing
*
* @return the region tree
*/
-ir_reg_tree *construct_region_tree(ir_graph *irg);
+FIRM_DLL ir_reg_tree *construct_region_tree(ir_graph *irg);
/**
* Walk over the region tree.
* @param post walker function, executed after the children of a tree node are visited
* @param env environment, passed to pre and post
*/
-void region_tree_walk(ir_reg_tree *tree, irg_reg_walk_func *pre, irg_reg_walk_func *post, void *env);
+FIRM_DLL void region_tree_walk(ir_reg_tree *tree, irg_reg_walk_func *pre,
+ irg_reg_walk_func *post, void *env);
+
+#include "end.h"
#endif
#include <stdlib.h>
+#include "begin.h"
+
typedef struct _ir_timer_t ir_timer_t;
/**
* @note You could need special user privileges.
* @return 0 on success, else UNIX error code.
*/
-int ir_timer_enter_high_priority(void);
+FIRM_DLL int ir_timer_enter_high_priority(void);
/**
* Leave the high priority mode.
* @see ir_timer_enter_high_priority()
* @return 0 on success, else UNIX error code.
*/
-int ir_timer_leave_high_priority(void);
+FIRM_DLL int ir_timer_leave_high_priority(void);
/**
* Get the amount of bytes allocated on the heap.
* @return The number of bytes allocated on the heap.
*/
-size_t ir_get_heap_used_bytes(void);
+FIRM_DLL size_t ir_get_heap_used_bytes(void);
/**
* Create a new timer
* @return The timer.
*/
-ir_timer_t *ir_timer_new(void);
+FIRM_DLL ir_timer_t *ir_timer_new(void);
/**
* free memory occupied by a timer
* @param timer The timer
*/
-void ir_timer_free(ir_timer_t *timer);
+FIRM_DLL void ir_timer_free(ir_timer_t *timer);
/**
* Start a timer.
* @param timer The timer.
*/
-void ir_timer_start(ir_timer_t *timer);
+FIRM_DLL void ir_timer_start(ir_timer_t *timer);
/**
* Reset a timer and start it.
* @param timer The timer.
*/
-void ir_timer_reset_and_start(ir_timer_t *timer);
+FIRM_DLL void ir_timer_reset_and_start(ir_timer_t *timer);
/**
* Reset a timer.
* @param timer The timer.
*/
-void ir_timer_reset(ir_timer_t *timer);
+FIRM_DLL void ir_timer_reset(ir_timer_t *timer);
/**
* Stop a timer.
* Stopping a stopped timer has no effect.
* @param timer The timer.
*/
-void ir_timer_stop(ir_timer_t *timer);
+FIRM_DLL void ir_timer_stop(ir_timer_t *timer);
/**
* Push a timer of the timer stack. This automatically
* @param timer The timer to push on stack.
* @return non-zero on succes, zero if the timer is already on the stack.
*/
-int ir_timer_push(ir_timer_t *timer);
+FIRM_DLL int ir_timer_push(ir_timer_t *timer);
/**
* Pop the current timer. This automatically stops it and
* start the timer that is now on the stack.
* @return the popped timer
*/
-ir_timer_t *ir_timer_pop(void);
+FIRM_DLL ir_timer_t *ir_timer_pop(void);
/**
* Get the number of milliseconds, the timer has elapsed.
* @param timer The timer.
* @return The number of milliseconds the timer is (was) running.
*/
-unsigned long ir_timer_elapsed_msec(const ir_timer_t *timer);
+FIRM_DLL unsigned long ir_timer_elapsed_msec(const ir_timer_t *timer);
/**
* Get the number of microseconds, the timer has elapsed.
* @param timer The timer.
* @return The number of milliseconds the timer is (was) running.
*/
-unsigned long ir_timer_elapsed_usec(const ir_timer_t *timer);
+FIRM_DLL unsigned long ir_timer_elapsed_usec(const ir_timer_t *timer);
/**
* Get name of given timer.
* @param timer The timer.
* @return The name of the timer.
*/
-const char *ir_timer_get_name(const ir_timer_t *timer);
+FIRM_DLL const char *ir_timer_get_name(const ir_timer_t *timer);
/**
* Get description of given timer.
* @param timer The timer.
* @return The description of the timer.
*/
-const char *ir_timer_get_description(const ir_timer_t *timer);
+FIRM_DLL const char *ir_timer_get_description(const ir_timer_t *timer);
+
+#include "end.h"
#endif
#include "firm_types.h"
#include "irgraph.h"
+#include "begin.h"
+
/*-----------------------------------------------------------------*/
/* Accessing the trout datastructures. */
/* These routines only work properly if firm is in state */
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/** Number of Load/Store nodes that possibly access this entity. */
-int get_entity_n_accesses(const ir_entity *ent);
+FIRM_DLL int get_entity_n_accesses(const ir_entity *ent);
/** Load/Store node that possibly access this entity. */
-ir_node *get_entity_access(const ir_entity *ent, int pos);
+FIRM_DLL ir_node *get_entity_access(const ir_entity *ent, int pos);
/** Number of references to an entity, in form of SymConst/Sel.
* Including references from constant entities and the like. */
-int get_entity_n_references(const ir_entity *ent);
+FIRM_DLL int get_entity_n_references(const ir_entity *ent);
/** References to an entity, in form of SymConst/Sel
* Including references from constants. */
-ir_node *get_entity_reference(const ir_entity *ent, int pos);
+FIRM_DLL ir_node *get_entity_reference(const ir_entity *ent, int pos);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* types */
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/** Number of Alloc nodes that create an instance of this type. */
-int get_type_n_allocs(const ir_type *tp);
+FIRM_DLL int get_type_n_allocs(const ir_type *tp);
/** Alloc node that create an instance of this type. */
-ir_node *get_type_alloc(const ir_type *tp, int pos);
+FIRM_DLL ir_node *get_type_alloc(const ir_type *tp, int pos);
/** Number of Cast nodes that cast a pointer to this type. */
-int get_type_n_casts(const ir_type *tp);
+FIRM_DLL int get_type_n_casts(const ir_type *tp);
/** Cast node that cast a pointer to this type. */
-ir_node *get_type_cast(const ir_type *tp, int pos);
-void add_type_cast(const ir_type *tp, ir_node *cast);
+FIRM_DLL ir_node *get_type_cast(const ir_type *tp, int pos);
+FIRM_DLL void add_type_cast(const ir_type *tp, ir_node *cast);
/** Return number of upcasts. O(\#casts). */
-int get_class_n_upcasts(const ir_type *clss);
+FIRM_DLL int get_class_n_upcasts(const ir_type *clss);
/** Return number of downcasts. O(\#casts). */
-int get_class_n_downcasts(const ir_type *clss);
+FIRM_DLL int get_class_n_downcasts(const ir_type *clss);
/* Access all pointer types that point to tp. */
-int get_type_n_pointertypes_to(const ir_type *tp);
-ir_type *get_type_pointertype_to(const ir_type *tp, int pos);
-void add_type_pointertype_to(const ir_type *tp, ir_type *ptp);
+FIRM_DLL int get_type_n_pointertypes_to(const ir_type *tp);
+FIRM_DLL ir_type *get_type_pointertype_to(const ir_type *tp, int pos);
+FIRM_DLL void add_type_pointertype_to(const ir_type *tp, ir_type *ptp);
/* Access all array types that contain elements of type tp.
* Does not find subarrays, e.g., int[] being element of int[][]
* for multi dimensional arrays. */
-int get_type_n_arraytypes_of(const ir_type *tp);
-ir_type *get_type_arraytype_of(const ir_type *tp, int pos);
-void add_type_arraytype_of(const ir_type *tp, ir_type *atp);
-
-
-
-/* @@@ TODO: compute all entities that use a type. */
+FIRM_DLL int get_type_n_arraytypes_of(const ir_type *tp);
+FIRM_DLL ir_type *get_type_arraytype_of(const ir_type *tp, int pos);
+FIRM_DLL void add_type_arraytype_of(const ir_type *tp, ir_type *atp);
/*------------------------------------------------------------------*/
/* Building and Removing the trout datastructure */
*
* We reuse the enum of irouts.
* @see irouts.h. */
-irg_outs_state get_trouts_state(void);
+FIRM_DLL irg_outs_state get_trouts_state(void);
/** Set the tr out state to inconsistent if it is consistent. */
-void set_trouts_inconsistent(void);
+FIRM_DLL void set_trouts_inconsistent(void);
/** Compute the outs of types and entities.
*
*
* Sets trout state to outs_consistent.
*/
-void compute_trouts(void);
+FIRM_DLL void compute_trouts(void);
/** Free trout data. */
-void free_trouts(void);
+FIRM_DLL void free_trouts(void);
+
+#include "end.h"
#endif
#include "firm_types.h"
#include "irnode.h"
+#include "begin.h"
+
/* ************************ Constructors for tarvals ************************ */
/**
* new_tarval_from_long()
* new_tarval_from_double()
*/
-tarval *new_tarval_from_str(const char *str, size_t len, ir_mode *mode);
+FIRM_DLL tarval *new_tarval_from_str(const char *str, size_t len,
+ ir_mode *mode);
/**
* Construct a new tarval from a given string.
* represented in the given mode.
* Return bad if the number couldn't successfully be parsed.
*/
-tarval *new_integer_tarval_from_str(const char *str, size_t len, char sign,
- unsigned char base, ir_mode *mode);
+FIRM_DLL tarval *new_integer_tarval_from_str(const char *str, size_t len,
+ char sign, unsigned char base,
+ ir_mode *mode);
/**
* Constructor function for new tarvals
* new_tarval_from_double()
*
*/
-tarval *new_tarval_from_long(long l, ir_mode *mode);
+FIRM_DLL tarval *new_tarval_from_long(long l, ir_mode *mode);
/** Return value as long if possible.
*
* you are doing! (better check with tarval_is_long()...)
* Works only for int modes, even not for character modes!
*/
-long get_tarval_long(tarval *tv);
+FIRM_DLL long get_tarval_long(tarval *tv);
/**
* This validates if get_tarval_long() will return a satisfying
*
* @param tv the tarval
*/
-int tarval_is_long(tarval *tv);
+FIRM_DLL int tarval_is_long(tarval *tv);
/**
* Constructor function for new tarvals.
* new_tarval_from_str()
* new_tarval_from_long()
*/
-tarval *new_tarval_from_double(long double d, ir_mode *mode);
+FIRM_DLL tarval *new_tarval_from_double(long double d, ir_mode *mode);
/**
* This returns a double with the value represented value, or
*
* @param tv the tarval
*/
-long double get_tarval_double(tarval *tv);
+FIRM_DLL long double get_tarval_double(tarval *tv);
/**
* This validates if tarval_to_double() will return a satisfying
*
* @param tv the tarval
*/
-int tarval_is_double(tarval *tv);
+FIRM_DLL int tarval_is_double(tarval *tv);
/** ********** Access routines for tarval fields ********** **/
*
* @param tv the tarval
*/
-ir_mode *get_tarval_mode(const tarval *tv);
+FIRM_DLL ir_mode *get_tarval_mode(const tarval *tv);
/** Returns the contents of the 'link' field of the tarval */
/* void *get_tarval_link (tarval*); */
*
* @param tv the tarval
*/
-int tarval_is_negative(tarval *tv);
+FIRM_DLL int tarval_is_negative(tarval *tv);
/**
* Returns 1 if tv is null
*
* @param tv the tarval
*/
-int tarval_is_null(tarval *tv);
+FIRM_DLL int tarval_is_null(tarval *tv);
/**
* Returns 1 if tv is the "one"
*
* @param tv the tarval
*/
-int tarval_is_one(tarval *tv);
+FIRM_DLL int tarval_is_one(tarval *tv);
/**
* Returns 1 if tv is the "minus one"
*
* @param tv the tarval
*/
-int tarval_is_minus_one(tarval *tv);
+FIRM_DLL int tarval_is_minus_one(tarval *tv);
/**
* returns non-zero if all bits in the tarval are set
*/
-int tarval_is_all_one(tarval *tv);
+FIRM_DLL int tarval_is_all_one(tarval *tv);
/**
* Return non-zero if the tarval is a constant (ie. NOT
* a reserved tarval like bad, undef, reachable etc.)
*/
-int tarval_is_constant(tarval *tv);
+FIRM_DLL int tarval_is_constant(tarval *tv);
/** The 'bad' tarval. */
-extern tarval *tarval_bad;
+FIRM_DLL tarval *tarval_bad;
/** Returns the 'bad' tarval. */
-tarval *get_tarval_bad(void);
+FIRM_DLL tarval *get_tarval_bad(void);
/** The 'undefined' tarval. */
-extern tarval *tarval_undefined;
+FIRM_DLL tarval *tarval_undefined;
/** Returns the 'undefined' tarval. */
-tarval *get_tarval_undefined(void);
+FIRM_DLL tarval *get_tarval_undefined(void);
/** The mode_b tarval 'false'. */
-extern tarval *tarval_b_false;
+FIRM_DLL tarval *tarval_b_false;
/** Returns the mode_b tarval 'false'. */
-tarval *get_tarval_b_false(void);
+FIRM_DLL tarval *get_tarval_b_false(void);
/** The mode_b tarval 'true'. */
-extern tarval *tarval_b_true;
+FIRM_DLL tarval *tarval_b_true;
/** Returns the mode_b tarval 'true'. */
-tarval *get_tarval_b_true(void);
+FIRM_DLL tarval *get_tarval_b_true(void);
/** The mode_X tarval 'unreachable'. */
-extern tarval *tarval_unreachable;
+FIRM_DLL tarval *tarval_unreachable;
/** Returns the mode_X tarval 'unreachable'. */
-tarval *get_tarval_unreachable(void);
+FIRM_DLL tarval *get_tarval_unreachable(void);
/** The mode_X tarval 'reachable'. */
-extern tarval *tarval_reachable;
+FIRM_DLL tarval *tarval_reachable;
/** Returns the mode_X tarval 'reachable'. */
-tarval *get_tarval_reachable(void);
+FIRM_DLL tarval *get_tarval_reachable(void);
/** The 'top' tarval. This is just another name for the 'undefined' tarval. */
#define tarval_top tarval_undefined
* therefore the irmode functions should be preferred to the functions below. */
/** Returns the maximum value of a given mode. */
-tarval *get_tarval_max(ir_mode *mode);
+FIRM_DLL tarval *get_tarval_max(ir_mode *mode);
/** Returns the minimum value of a given mode. */
-tarval *get_tarval_min(ir_mode *mode);
+FIRM_DLL tarval *get_tarval_min(ir_mode *mode);
/** Returns the 0 value (additive neutral) of a given mode.
For reference modes, the NULL value is returned (old tarval_P_void) */
-tarval *get_tarval_null(ir_mode *mode);
+FIRM_DLL tarval *get_tarval_null(ir_mode *mode);
/** Returns the 1 value (multiplicative neutral) of a given mode. */
-tarval *get_tarval_one(ir_mode *mode);
+FIRM_DLL tarval *get_tarval_one(ir_mode *mode);
/** Returns the -1 value (multiplicative neutral) of a given mode.
* Returns tarval bad for unsigned modes */
-tarval *get_tarval_minus_one(ir_mode *mode);
+FIRM_DLL tarval *get_tarval_minus_one(ir_mode *mode);
/** returns the value where all bits are 1 of a given mode.
* returns tarval_bad for float modes */
-tarval *get_tarval_all_one(ir_mode *mode);
+FIRM_DLL tarval *get_tarval_all_one(ir_mode *mode);
/** Return quite nan for float_number modes. */
-tarval *get_tarval_nan(ir_mode *mode);
+FIRM_DLL tarval *get_tarval_nan(ir_mode *mode);
/** Return +inf for float_number modes. */
-tarval *get_tarval_plus_inf(ir_mode *mode);
+FIRM_DLL tarval *get_tarval_plus_inf(ir_mode *mode);
/** Return -inf for float_number modes. */
-tarval *get_tarval_minus_inf(ir_mode *mode);
+FIRM_DLL tarval *get_tarval_minus_inf(ir_mode *mode);
/* ******************** Arithmetic operations on tarvals ******************** */
*
* @param ov_mode one of teh overflow modes
*/
-void tarval_set_integer_overflow_mode(tarval_int_overflow_mode_t ov_mode);
+FIRM_DLL void tarval_set_integer_overflow_mode(tarval_int_overflow_mode_t ov_mode);
/**
* Get the overflow mode for integer operations.
*/
-tarval_int_overflow_mode_t tarval_get_integer_overflow_mode(void);
+FIRM_DLL tarval_int_overflow_mode_t tarval_get_integer_overflow_mode(void);
/**
* Compares two tarvals
* @sa
* irnode.h for the definition of pn_Cmp
*/
-pn_Cmp tarval_cmp(tarval *a, tarval *b);
+FIRM_DLL pn_Cmp tarval_cmp(tarval *a, tarval *b);
/**
* Converts a tarval to another mode.
* FIRM documentation for conversion rules
* mode_is_smaller defined in irmode.h
*/
-tarval *tarval_convert_to(tarval *src, ir_mode *mode);
+FIRM_DLL tarval *tarval_convert_to(tarval *src, ir_mode *mode);
/*
* These function implement basic computations representable as opcodes
*
* @return ~a or tarval_bad
*/
-tarval *tarval_not(tarval *a);
+FIRM_DLL tarval *tarval_not(tarval *a);
/**
* Arithmetic Negation of a tarval.
*
* @return -a or tarval_bad
*/
-tarval *tarval_neg(tarval *a);
+FIRM_DLL tarval *tarval_neg(tarval *a);
/**
* Addition of two tarvals.
*
* @return a + b or tarval_bad
*/
-tarval *tarval_add(tarval *a, tarval *b);
+FIRM_DLL tarval *tarval_add(tarval *a, tarval *b);
/**
* Subtraction from a tarval.
*
* @return a - b or tarval_bad
*/
-tarval *tarval_sub(tarval *a, tarval *b, ir_mode *dst_mode);
+FIRM_DLL tarval *tarval_sub(tarval *a, tarval *b, ir_mode *dst_mode);
/**
* Multiplication of tarvals.
*
* @return a * b or tarval_bad
*/
-tarval *tarval_mul(tarval *a, tarval *b);
+FIRM_DLL tarval *tarval_mul(tarval *a, tarval *b);
/**
* Division of two floating point tarvals.
*
* @return a / b or tarval_bad
*/
-tarval *tarval_quo(tarval *a, tarval *b);
+FIRM_DLL tarval *tarval_quo(tarval *a, tarval *b);
/**
* Integer division of two tarvals.
*
* @return a / b or tarval_bad
*/
-tarval *tarval_div(tarval *a, tarval *b);
+FIRM_DLL tarval *tarval_div(tarval *a, tarval *b);
/**
* Remainder of integer division.
*
* @return a % b or tarval_bad
*/
-tarval *tarval_mod(tarval *a, tarval *b);
+FIRM_DLL tarval *tarval_mod(tarval *a, tarval *b);
/**
* Integer division AND remainder.
*
* @return a / b or tarval_bad
*/
-tarval *tarval_divmod(tarval *a, tarval *b, tarval **mod_res);
+FIRM_DLL tarval *tarval_divmod(tarval *a, tarval *b, tarval **mod_res);
/**
* Absolute value of a tarval.
*
* @return |a| or tarval_bad
*/
-tarval *tarval_abs(tarval *a);
+FIRM_DLL tarval *tarval_abs(tarval *a);
/**
* Bitwise and of two integer tarvals.
*
* @return a & b or tarval_bad
*/
-tarval *tarval_and(tarval *a, tarval *b);
+FIRM_DLL tarval *tarval_and(tarval *a, tarval *b);
/**
* Bitwise and not of two integer tarvals.
*
* @return a & ~b or tarval_bad
*/
-tarval *tarval_andnot(tarval *a, tarval *b);
+FIRM_DLL tarval *tarval_andnot(tarval *a, tarval *b);
/**
* Bitwise or of two integer tarvals.
*
* @return a | b or tarval_bad
*/
-tarval *tarval_or(tarval *a, tarval *b);
+FIRM_DLL tarval *tarval_or(tarval *a, tarval *b);
/**
* Bitwise exclusive or of two integer tarvals.
*
* @return a ^ b or tarval_bad
*/
-tarval *tarval_eor(tarval *a, tarval *b);
+FIRM_DLL tarval *tarval_eor(tarval *a, tarval *b);
/**
* Logical Left shift.
*
* @return a << b or tarval_bad
*/
-tarval *tarval_shl(tarval *a, tarval *b);
+FIRM_DLL tarval *tarval_shl(tarval *a, tarval *b);
/**
* Unsigned (logical) right shift.
*
* @return a >>u b or tarval_bad
*/
-tarval *tarval_shr(tarval *a, tarval *b);
+FIRM_DLL tarval *tarval_shr(tarval *a, tarval *b);
/**
* Signed (arithmetic) right shift.
*
* @return a >>s b or tarval_bad
*/
-tarval *tarval_shrs(tarval *a, tarval *b);
+FIRM_DLL tarval *tarval_shrs(tarval *a, tarval *b);
/**
* Rotation to left.
*
* @return a \<\<L\>\> b or tarval_bad
*/
-tarval *tarval_rotl(tarval *a, tarval *b);
+FIRM_DLL tarval *tarval_rotl(tarval *a, tarval *b);
/**
* Returns the carry flag of the last operation.
*/
-int tarval_carry(void);
+FIRM_DLL int tarval_carry(void);
/* *********** Output of tarvals *********** */
*
* @return zero on success.
*/
-int set_tarval_mode_output_option(ir_mode *mode, const tarval_mode_info *modeinfo);
+FIRM_DLL int set_tarval_mode_output_option(ir_mode *mode,
+ const tarval_mode_info *modeinfo);
/**
* Returns the output options of one mode.
*
* @return the output option
*/
-const tarval_mode_info *get_tarval_mode_output_option(ir_mode *mode);
+FIRM_DLL const tarval_mode_info *get_tarval_mode_output_option(ir_mode *mode);
/**
* Returns Bit representation of a tarval value, as string of '0' and '1'
* irmode.h for the definition of the ir_mode struct
* the size member of aforementioned struct
*/
-char *get_tarval_bitpattern(tarval *tv);
+FIRM_DLL char *get_tarval_bitpattern(tarval *tv);
/**
* Returns the bitpattern of the bytes_ofs byte.
* @note
* The result of this function is undefined if the mode is neither integer nor float.
*/
-unsigned char get_tarval_sub_bits(tarval *tv, unsigned byte_ofs);
+FIRM_DLL unsigned char get_tarval_sub_bits(tarval *tv, unsigned byte_ofs);
/**
* Returns non-zero if a given (integer) tarval has only one single bit
*
* @param tv the tarval
*/
-int tarval_is_single_bit(tarval *tv);
+FIRM_DLL int tarval_is_single_bit(tarval *tv);
/**
* Return the number of set bits in a given (integer) tarval.
*
* @return number of set bits or -1 on error
*/
-int get_tarval_popcount(tarval *tv);
+FIRM_DLL int get_tarval_popcount(tarval *tv);
/**
* Return the number of the lowest set bit in a given (integer) tarval.
*
* @return number of lowest set bit or -1 on error
*/
-int get_tarval_lowest_bit(tarval *tv);
+FIRM_DLL int get_tarval_lowest_bit(tarval *tv);
/**
* Output a tarval to a string buffer.
* @param buflen the length of the buffer
* @param tv the tarval
*/
-int tarval_snprintf(char *buf, size_t buflen, tarval *tv);
+FIRM_DLL int tarval_snprintf(char *buf, size_t buflen, tarval *tv);
/**
* Output a tarval to stdio.
*
* @param tv the tarval
*/
-int tarval_printf(tarval *tv);
+FIRM_DLL int tarval_printf(tarval *tv);
/**
* Returns non-zero if the mantissa of a floating point IEEE-754
*
* @param tv the tarval
*/
-int tarval_ieee754_zero_mantissa(tarval *tv);
+FIRM_DLL int tarval_ieee754_zero_mantissa(tarval *tv);
/**
* Returns the exponent of a floating point IEEE-754
*
* @param tv the tarval
*/
-int tarval_ieee754_get_exponent(tarval *tv);
+FIRM_DLL int tarval_ieee754_get_exponent(tarval *tv);
/**
* Check if the tarval can be converted to the given mode without
* @param tv the tarval
* @param mode the mode to convert to
*/
-int tarval_ieee754_can_conv_lossless(tarval *tv, ir_mode *mode);
+FIRM_DLL int tarval_ieee754_can_conv_lossless(tarval *tv, ir_mode *mode);
/**
* Set the immediate precision for IEEE-754 results. Set this to
*
* @return the old setting
*/
-unsigned tarval_ieee754_set_immediate_precision(unsigned bits);
+FIRM_DLL unsigned tarval_ieee754_set_immediate_precision(unsigned bits);
/**
* Returns non-zero if the result of the last IEEE-754 operation was exact.
*/
-unsigned tarval_ieee754_get_exact(void);
+FIRM_DLL unsigned tarval_ieee754_get_exact(void);
/**
* Return the size of the mantissa in bits (including possible
* implicit bits) for the given mode.
*/
-unsigned tarval_ieee754_get_mantissa_size(const ir_mode *mode);
+FIRM_DLL unsigned tarval_ieee754_get_mantissa_size(const ir_mode *mode);
/**
* Enable/Disable floating point constant folding.
*/
-void tarval_enable_fp_ops(int enable);
+FIRM_DLL void tarval_enable_fp_ops(int enable);
/** returns 0/1 if floating point folding is enable/disabled */
-int tarval_fp_ops_enabled(void);
+FIRM_DLL int tarval_fp_ops_enabled(void);
/**
* Check if its the a floating point NaN.
*
* @param tv the tarval
*/
-int tarval_is_NaN(tarval *tv);
+FIRM_DLL int tarval_is_NaN(tarval *tv);
/**
* Check if its the a floating point +inf.
*
* @param tv the tarval
*/
-int tarval_is_plus_inf(tarval *tv);
+FIRM_DLL int tarval_is_plus_inf(tarval *tv);
/**
* Check if its the a floating point -inf.
*
* @param tv the tarval
*/
-int tarval_is_minus_inf(tarval *tv);
+FIRM_DLL int tarval_is_minus_inf(tarval *tv);
/**
* Check if the tarval represents a finite value, ie neither NaN nor inf.
*
* @param tv the tarval
*/
-int tarval_is_finite(tarval *tv);
+FIRM_DLL int tarval_is_finite(tarval *tv);
/**
* Checks whether a pointer points to a tarval.
* @return
* true if the thing is a tarval, else false
*/
-int is_tarval(const void *thing);
+FIRM_DLL int is_tarval(const void *thing);
+
+#include "end.h"
-#endif /* FIRM_TV_TV_H */
+#endif
#ifndef FIRM_TYPEREP_H
#define FIRM_TYPEREP_H
-#include "firm_types.h"
#include <stdlib.h>
+#include "firm_types.h"
+
+#include "begin.h"
/**
* @page entity Entity representation
/**
* Return the visibility class of an entity
*/
-ir_visibility get_entity_visibility(const ir_entity *entity);
+FIRM_DLL ir_visibility get_entity_visibility(const ir_entity *entity);
/**
* Set visibility class of an entity
*/
-void set_entity_visibility(ir_entity *entity, ir_visibility visibility);
+FIRM_DLL void set_entity_visibility(ir_entity *entity, ir_visibility visibility);
/**
* Return 1 if the entity is visible outside the current compilation unit
* get_entity_visibility(entity) != ir_visibility_local ||
* (get_entity_linkage(entity) & IR_LINKAGE_HIDDEN_USER)
*/
-int entity_is_externally_visible(const ir_entity *entity);
+FIRM_DLL int entity_is_externally_visible(const ir_entity *entity);
/**
* Return 1 if the entity has a definition (initializer) in the current
* compilation unit
*/
-int entity_has_definition(const ir_entity *entity);
+FIRM_DLL int entity_has_definition(const ir_entity *entity);
/**
* Creates a new entity.
* value is a pointer to the method.
* Visibility is local, offset -1, and it is not volatile.
*/
-ir_entity *new_entity(ir_type *owner, ident *name, ir_type *tp);
+FIRM_DLL ir_entity *new_entity(ir_type *owner, ident *name, ir_type *tp);
/**
* Creates a new entity.
* value is a pointer to the method.
* Visibility is local, offset -1, and it is not volatile.
*/
-ir_entity *new_d_entity(ir_type *owner, ident *name, ir_type *tp, dbg_info *db);
+FIRM_DLL ir_entity *new_d_entity(ir_type *owner, ident *name, ir_type *tp,
+ dbg_info *db);
/**
* Copies the entity if the new_owner is different from the
* Resets the overwrites/overwritten_by fields.
* Keeps the old atomic value.
*/
-ir_entity *copy_entity_own(ir_entity *old, ir_type *new_owner);
+FIRM_DLL ir_entity *copy_entity_own(ir_entity *old, ir_type *new_owner);
/**
* Copies the entity if the new_name is different from the
* The mangled name ld_name is set to NULL.
* Overwrites relation is copied from old.
*/
-ir_entity *copy_entity_name(ir_entity *old, ident *new_name);
+FIRM_DLL ir_entity *copy_entity_name(ir_entity *old, ident *new_name);
/**
* Frees the entity.
* The owner will still contain the pointer to this
* entity, as well as all other references!
*/
-void free_entity(ir_entity *ent);
+FIRM_DLL void free_entity(ir_entity *ent);
/** Returns the name of an entity. */
-const char *get_entity_name(const ir_entity *ent);
+FIRM_DLL const char *get_entity_name(const ir_entity *ent);
/** Returns the ident of an entity. */
-ident *get_entity_ident(const ir_entity *ent);
+FIRM_DLL ident *get_entity_ident(const ir_entity *ent);
/** Sets the ident of the entity. */
-void set_entity_ident(ir_entity *ent, ident *id);
+FIRM_DLL void set_entity_ident(ir_entity *ent, ident *id);
/** Returns the mangled name of the entity.
*
* Else it generates a name with mangle_entity()
* and remembers this new name internally.
*/
-ident *get_entity_ld_ident(const ir_entity *ent);
+FIRM_DLL ident *get_entity_ld_ident(const ir_entity *ent);
/** Sets the mangled name of the entity. */
-void set_entity_ld_ident(ir_entity *ent, ident *ld_ident);
+FIRM_DLL void set_entity_ld_ident(ir_entity *ent, ident *ld_ident);
/** Returns the mangled name of the entity as a string. */
-const char *get_entity_ld_name(const ir_entity *ent);
+FIRM_DLL const char *get_entity_ld_name(const ir_entity *ent);
/** Returns the owner of the entity. */
-ir_type *get_entity_owner(const ir_entity *ent);
+FIRM_DLL ir_type *get_entity_owner(const ir_entity *ent);
/** Sets the owner field in entity to owner. Don't forget to add
ent to owner!! */
-void set_entity_owner(ir_entity *ent, ir_type *owner);
+FIRM_DLL void set_entity_owner(ir_entity *ent, ir_type *owner);
/** Returns the type of an entity. */
-ir_type *get_entity_type(const ir_entity *ent);
+FIRM_DLL ir_type *get_entity_type(const ir_entity *ent);
/** Sets the type of an entity. */
-void set_entity_type(ir_entity *ent, ir_type *tp);
+FIRM_DLL void set_entity_type(ir_entity *ent, ir_type *tp);
/** Returns the linkage of an entity. */
-ir_linkage get_entity_linkage(const ir_entity *entity);
+FIRM_DLL ir_linkage get_entity_linkage(const ir_entity *entity);
/** Sets the linkage of an entity. */
-void set_entity_linkage(ir_entity *entity, ir_linkage linkage);
-void add_entity_linkage(ir_entity *entity, ir_linkage linkage);
-void remove_entity_linkage(ir_entity *entity, ir_linkage linkage);
+FIRM_DLL void set_entity_linkage(ir_entity *entity, ir_linkage linkage);
+FIRM_DLL void add_entity_linkage(ir_entity *entity, ir_linkage linkage);
+FIRM_DLL void remove_entity_linkage(ir_entity *entity, ir_linkage linkage);
/** Returns 1 if the value of a global symbol never changes in a program */
-int is_entity_constant(const ir_entity *ent);
+FIRM_DLL int is_entity_constant(const ir_entity *ent);
/**
* This enumeration flags the volatility of entities and Loads/Stores.
* Returns the volatility of an entity.
* @deprecated
*/
-ir_volatility get_entity_volatility(const ir_entity *ent);
+FIRM_DLL ir_volatility get_entity_volatility(const ir_entity *ent);
/**
* Sets the volatility of an entity.
* @deprecated
*/
-void set_entity_volatility(ir_entity *ent, ir_volatility vol);
+FIRM_DLL void set_entity_volatility(ir_entity *ent, ir_volatility vol);
/** Return the name of the volatility. */
-const char *get_volatility_name(ir_volatility var);
+FIRM_DLL const char *get_volatility_name(ir_volatility var);
/** Returns alignment of entity in bytes */
-unsigned get_entity_alignment(const ir_entity *entity);
+FIRM_DLL unsigned get_entity_alignment(const ir_entity *entity);
/** Allows you to override the type alignment for an entity.
* @param entity the entity
* @param alignment alignment in bytes
*/
-void set_entity_alignment(ir_entity *entity, unsigned alignment);
+FIRM_DLL void set_entity_alignment(ir_entity *entity, unsigned alignment);
/**
* Returns indication wether entity is aligned in memory.
* @deprecated
*/
-ir_align get_entity_aligned(const ir_entity *ent);
+FIRM_DLL ir_align get_entity_aligned(const ir_entity *ent);
/**
* Sets indication wether entity is aligned in memory
* @deprecated
*/
-void set_entity_aligned(ir_entity *ent, ir_align a);
+FIRM_DLL void set_entity_aligned(ir_entity *ent, ir_align a);
/** Return the name of the alignment. */
-const char *get_align_name(ir_align a);
+FIRM_DLL const char *get_align_name(ir_align a);
/** Returns the offset of an entity (in a compound) in bytes. Only set if layout = fixed. */
-int get_entity_offset(const ir_entity *ent);
+FIRM_DLL int get_entity_offset(const ir_entity *ent);
/** Sets the offset of an entity (in a compound) in bytes. */
-void set_entity_offset(ir_entity *ent, int offset);
+FIRM_DLL void set_entity_offset(ir_entity *ent, int offset);
/** Returns the offset bit remainder of a bitfield entity (in a compound) in bits. Only set if layout = fixed. */
-unsigned char get_entity_offset_bits_remainder(const ir_entity *ent);
+FIRM_DLL unsigned char get_entity_offset_bits_remainder(const ir_entity *ent);
/** Sets the offset bit remainder of a bitfield entity (in a compound) in bits. */
-void set_entity_offset_bits_remainder(ir_entity *ent, unsigned char offset);
+FIRM_DLL void set_entity_offset_bits_remainder(ir_entity *ent,
+ unsigned char offset);
/** Returns the stored intermediate information. */
-void *get_entity_link(const ir_entity *ent);
+FIRM_DLL void *get_entity_link(const ir_entity *ent);
/** Stores new intermediate information. */
-void set_entity_link(ir_entity *ent, void *l);
+FIRM_DLL void set_entity_link(ir_entity *ent, void *l);
/* -- Fields of method entities -- */
/** The entity knows the corresponding irg if the entity is a method.
This allows to get from a Call to the called irg. */
-ir_graph *get_entity_irg(const ir_entity *ent);
-void set_entity_irg(ir_entity *ent, ir_graph *irg);
+FIRM_DLL ir_graph *get_entity_irg(const ir_entity *ent);
+FIRM_DLL void set_entity_irg(ir_entity *ent, ir_graph *irg);
/** Gets the entity vtable number. */
-unsigned get_entity_vtable_number(const ir_entity *ent);
+FIRM_DLL unsigned get_entity_vtable_number(const ir_entity *ent);
/** Sets the entity vtable number. */
-void set_entity_vtable_number(ir_entity *ent, unsigned vtable_number);
+FIRM_DLL void set_entity_vtable_number(ir_entity *ent, unsigned vtable_number);
/** Set label number of an entity with code type */
-void set_entity_label(ir_entity *ent, ir_label_t label);
+FIRM_DLL void set_entity_label(ir_entity *ent, ir_label_t label);
/** Return label number of an entity with code type */
-ir_label_t get_entity_label(const ir_entity *ent);
+FIRM_DLL ir_label_t get_entity_label(const ir_entity *ent);
/** Checks if an entity is compiler generated. */
-int is_entity_compiler_generated(const ir_entity *ent);
+FIRM_DLL int is_entity_compiler_generated(const ir_entity *ent);
/** Sets/resets the compiler generated flag. */
-void set_entity_compiler_generated(ir_entity *ent, int flag);
+FIRM_DLL void set_entity_compiler_generated(ir_entity *ent, int flag);
/**
* Bitfield type indicating the way an entity is used.
} ir_entity_usage;
/** Return the entity usage */
-ir_entity_usage get_entity_usage(const ir_entity *ent);
+FIRM_DLL ir_entity_usage get_entity_usage(const ir_entity *ent);
/** Sets/resets the state of the address taken flag of an entity. */
-void set_entity_usage(ir_entity *ent, ir_entity_usage flag);
+FIRM_DLL void set_entity_usage(ir_entity *ent, ir_entity_usage flag);
/**
* Returns the debug information of an entity.
*
* @param ent The entity.
*/
-dbg_info *get_entity_dbg_info(const ir_entity *ent);
+FIRM_DLL dbg_info *get_entity_dbg_info(const ir_entity *ent);
/**
* Sets the debug information of an entity.
* @param ent The entity.
* @param db The debug info.
*/
-void set_entity_dbg_info(ir_entity *ent, dbg_info *db);
+FIRM_DLL void set_entity_dbg_info(ir_entity *ent, dbg_info *db);
/* -- Representation of constant values of entities -- */
/**
* @deprecated This function is not used by libFirm and stays here
* only as a helper for the old Jack frontend.
*/
-int is_irn_const_expression(ir_node *n);
+FIRM_DLL int is_irn_const_expression(ir_node *n);
/**
* Copies a Firm subgraph that complies to the restrictions for
* Set current_ir_graph to get_const_code_irg() to generate a constant
* expression.
*/
-ir_node *copy_const_value(dbg_info *dbg, ir_node *n);
+FIRM_DLL ir_node *copy_const_value(dbg_info *dbg, ir_node *n);
/* Set has no effect for existent entities of type method. */
-ir_node *get_atomic_ent_value(ir_entity *ent);
-void set_atomic_ent_value(ir_entity *ent, ir_node *val);
+FIRM_DLL ir_node *get_atomic_ent_value(ir_entity *ent);
+FIRM_DLL void set_atomic_ent_value(ir_entity *ent, ir_node *val);
/** the kind (type) of an initializer */
typedef enum ir_initializer_kind_t {
} ir_initializer_kind_t;
/** returns kind of an initializer */
-ir_initializer_kind_t get_initializer_kind(const ir_initializer_t *initializer);
+FIRM_DLL ir_initializer_kind_t get_initializer_kind(const ir_initializer_t *initializer);
/** Return the name of the initializer kind. */
-const char *get_initializer_kind_name(ir_initializer_kind_t ini);
+FIRM_DLL const char *get_initializer_kind_name(ir_initializer_kind_t ini);
/**
* returns the null initializer (there's only one instance of it in a program )
*/
-ir_initializer_t *get_initializer_null(void);
+FIRM_DLL ir_initializer_t *get_initializer_null(void);
/**
* creates an initializer containing a reference to a node on the const-code
* irg.
*/
-ir_initializer_t *create_initializer_const(ir_node *value);
+FIRM_DLL ir_initializer_t *create_initializer_const(ir_node *value);
/** creates an initializer containing a single tarval value */
-ir_initializer_t *create_initializer_tarval(tarval *tv);
+FIRM_DLL ir_initializer_t *create_initializer_tarval(tarval *tv);
/** return value contained in a const initializer */
-ir_node *get_initializer_const_value(const ir_initializer_t *initializer);
+FIRM_DLL ir_node *get_initializer_const_value(const ir_initializer_t *initializer);
/** return value contained in a tarval initializer */
-tarval *get_initializer_tarval_value(const ir_initializer_t *initialzier);
+FIRM_DLL tarval *get_initializer_tarval_value(const ir_initializer_t *initialzier);
/** creates a compound initializer which holds @p n_entries entries */
-ir_initializer_t *create_initializer_compound(unsigned n_entries);
+FIRM_DLL ir_initializer_t *create_initializer_compound(unsigned n_entries);
/** returns the number of entries in a compound initializer */
-unsigned get_initializer_compound_n_entries(const ir_initializer_t *initializer);
+FIRM_DLL unsigned get_initializer_compound_n_entries(const ir_initializer_t *initializer);
/** sets entry with index @p index to the initializer @p value */
-void set_initializer_compound_value(ir_initializer_t *initializer,
- unsigned index, ir_initializer_t *value);
+FIRM_DLL void set_initializer_compound_value(ir_initializer_t *initializer,
+ unsigned index,
+ ir_initializer_t *value);
/** returns the value with index @p index of a compound initializer */
-ir_initializer_t *get_initializer_compound_value(
+FIRM_DLL ir_initializer_t *get_initializer_compound_value(
const ir_initializer_t *initializer, unsigned index);
/** Sets the new style initializers of an entity. */
-void set_entity_initializer(ir_entity *entity, ir_initializer_t *initializer);
+FIRM_DLL void set_entity_initializer(ir_entity *entity, ir_initializer_t *initializer);
/** Returns true, if an entity has new style initializers. */
-int has_entity_initializer(const ir_entity *entity);
+FIRM_DLL int has_entity_initializer(const ir_entity *entity);
/** Return the new style initializers of an entity. */
-ir_initializer_t *get_entity_initializer(const ir_entity *entity);
+FIRM_DLL ir_initializer_t *get_entity_initializer(const ir_entity *entity);
/* --- Fields of entities with a class type as owner --- */
/* Overwrites is a field that specifies that an access to the overwritten
that is passed to it. Lowering of the Sel node must assure this.
Overwrittenby is the inverse of overwrites. Both add routines add
both relations, they only differ in the order of arguments. */
-void add_entity_overwrites(ir_entity *ent, ir_entity *overwritten);
-int get_entity_n_overwrites(const ir_entity *ent);
-int get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten);
-ir_entity *get_entity_overwrites(const ir_entity *ent, int pos);
-void set_entity_overwrites(ir_entity *ent, int pos, ir_entity *overwritten);
-void remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten);
+FIRM_DLL void add_entity_overwrites(ir_entity *ent, ir_entity *overwritten);
+FIRM_DLL int get_entity_n_overwrites(const ir_entity *ent);
+FIRM_DLL int get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten);
+FIRM_DLL ir_entity *get_entity_overwrites(const ir_entity *ent, int pos);
+FIRM_DLL void set_entity_overwrites(ir_entity *ent, int pos, ir_entity *overwritten);
+FIRM_DLL void remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten);
-void add_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites);
-int get_entity_n_overwrittenby(const ir_entity *ent);
-int get_entity_overwrittenby_index(const ir_entity *ent, ir_entity *overwrites);
-ir_entity *get_entity_overwrittenby(const ir_entity *ent, int pos);
-void set_entity_overwrittenby(ir_entity *ent, int pos, ir_entity *overwrites);
-void remove_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites);
+FIRM_DLL void add_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites);
+FIRM_DLL int get_entity_n_overwrittenby(const ir_entity *ent);
+FIRM_DLL int get_entity_overwrittenby_index(const ir_entity *ent, ir_entity *overwrites);
+FIRM_DLL ir_entity *get_entity_overwrittenby(const ir_entity *ent, int pos);
+FIRM_DLL void set_entity_overwrittenby(ir_entity *ent, int pos, ir_entity *overwrites);
+FIRM_DLL void remove_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites);
/**
* Checks whether a pointer points to an entity.
* @return
* true if the thing is an entity, else false
*/
-int is_entity(const void *thing);
+FIRM_DLL int is_entity(const void *thing);
/** Returns true if the type of the entity is a primitive, pointer
* enumeration or method type.
*
* @note This is a different classification than from is_primitive_type().
*/
-int is_atomic_entity(const ir_entity *ent);
+FIRM_DLL int is_atomic_entity(const ir_entity *ent);
/** Returns true if the type of the entity is a class, structure,
array or union type. */
-int is_compound_entity(const ir_entity *ent);
+FIRM_DLL int is_compound_entity(const ir_entity *ent);
/** Returns true if the type of the entity is a Method type. */
-int is_method_entity(const ir_entity *ent);
+FIRM_DLL int is_method_entity(const ir_entity *ent);
/** Outputs a unique number for this entity if libfirm is compiled for
* debugging, (configure with --enable-debug) else returns the address
* of the type cast to long.
*/
-long get_entity_nr(const ir_entity *ent);
+FIRM_DLL long get_entity_nr(const ir_entity *ent);
/** Returns the entities visited count. */
-ir_visited_t get_entity_visited(const ir_entity *ent);
+FIRM_DLL ir_visited_t get_entity_visited(const ir_entity *ent);
/** Sets the entities visited count. */
-void set_entity_visited(ir_entity *ent, ir_visited_t num);
+FIRM_DLL void set_entity_visited(ir_entity *ent, ir_visited_t num);
/** Sets visited field in entity to entity_visited. */
-void mark_entity_visited(ir_entity *ent);
+FIRM_DLL void mark_entity_visited(ir_entity *ent);
/** Returns true if this entity was visited. */
-int entity_visited(const ir_entity *ent);
+FIRM_DLL int entity_visited(const ir_entity *ent);
/** Returns true if this entity was not visited. */
-int entity_not_visited(const ir_entity *ent);
+FIRM_DLL int entity_not_visited(const ir_entity *ent);
/**
* Returns the mask of the additional entity properties.
* set_entity_additional_properties() or
* set_entity_additional_property().
*/
-unsigned get_entity_additional_properties(const ir_entity *ent);
+FIRM_DLL unsigned get_entity_additional_properties(const ir_entity *ent);
/** Sets the mask of the additional graph properties. */
-void set_entity_additional_properties(ir_entity *ent, unsigned property_mask);
+FIRM_DLL void set_entity_additional_properties(ir_entity *ent,
+ unsigned property_mask);
/** Sets one additional graph property. */
-void set_entity_additional_property(ir_entity *ent, mtp_additional_property flag);
+FIRM_DLL void set_entity_additional_property(ir_entity *ent,
+ mtp_additional_property flag);
/** Returns the class type that this type info entity represents or NULL
if ent is no type info entity. */
-ir_type *get_entity_repr_class(const ir_entity *ent);
+FIRM_DLL ir_type *get_entity_repr_class(const ir_entity *ent);
/**
* @page unknown_entity The Unknown entity
*/
/** A variable that contains the only unknown entity. */
-extern ir_entity *unknown_entity;
+FIRM_DLL ir_entity *unknown_entity;
/** Returns the @link unknown_entity unknown entity @endlink. */
-ir_entity *get_unknown_entity(void);
+FIRM_DLL ir_entity *get_unknown_entity(void);
/** Encodes how a pointer parameter is accessed. */
typedef enum acc_bits {
* @param op The type opcode to get the string from.
* @return a string. (@todo Null terminated?)
*/
-const char *get_tpop_name(const tp_op *op);
+FIRM_DLL const char *get_tpop_name(const tp_op *op);
/**
* Returns an enum for the type opcode.
* @param op The type opcode to get the enum from.
* @return the enum.
*/
-tp_opcode get_tpop_code(const tp_op *op);
+FIRM_DLL tp_opcode get_tpop_code(const tp_op *op);
/**
* This type opcode marks that the corresponding type is a class type.
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern const tp_op *type_class;
-const tp_op *get_tpop_class(void);
+FIRM_DLL const tp_op *type_class;
+FIRM_DLL const tp_op *get_tpop_class(void);
/**
* This type opcode marks that the corresponding type is a compound type
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern const tp_op *type_struct;
-const tp_op *get_tpop_struct(void);
+FIRM_DLL const tp_op *type_struct;
+FIRM_DLL const tp_op *get_tpop_struct(void);
/**
* This type opcode marks that the corresponding type is a method type.
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern const tp_op *type_method;
-const tp_op *get_tpop_method(void);
+FIRM_DLL const tp_op *type_method;
+FIRM_DLL const tp_op *get_tpop_method(void);
/**
* This type opcode marks that the corresponding type is a union type.
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern const tp_op *type_union;
-const tp_op *get_tpop_union(void);
+FIRM_DLL const tp_op *type_union;
+FIRM_DLL const tp_op *get_tpop_union(void);
/**
* This type opcode marks that the corresponding type is an array type.
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern const tp_op *type_array;
-const tp_op *get_tpop_array(void);
+FIRM_DLL const tp_op *type_array;
+FIRM_DLL const tp_op *get_tpop_array(void);
/**
* This type opcode marks that the corresponding type is an enumeration type.
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern const tp_op *type_enumeration;
-const tp_op *get_tpop_enumeration(void);
+FIRM_DLL const tp_op *type_enumeration;
+FIRM_DLL const tp_op *get_tpop_enumeration(void);
/**
* This type opcode marks that the corresponding type is a pointer type.
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern const tp_op *type_pointer;
-const tp_op *get_tpop_pointer(void);
+FIRM_DLL const tp_op *type_pointer;
+FIRM_DLL const tp_op *get_tpop_pointer(void);
/**
* This type opcode marks that the corresponding type is a primitive type.
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern const tp_op *type_primitive;
-const tp_op *get_tpop_primitive(void);
+FIRM_DLL const tp_op *type_primitive;
+FIRM_DLL const tp_op *get_tpop_primitive(void);
/**
* The code type is used to mark pieces of code (basic blocks)
*/
-extern const tp_op *tpop_code;
-const tp_op *get_tpop_code_type(void);
+FIRM_DLL const tp_op *tpop_code;
+FIRM_DLL const tp_op *get_tpop_code_type(void);
/**
* This type opcode is an auxiliary opcode dedicated to support type analyses.
* contain a type or that are initialized for an analysis. There exists exactly
* one type with this opcode.
*/
-extern const tp_op *tpop_none;
-const tp_op *get_tpop_none(void);
+FIRM_DLL const tp_op *tpop_none;
+FIRM_DLL const tp_op *get_tpop_none(void);
/**
* This type opcode is an auxiliary opcode dedicated to support type analyses.
* yet) or to represent the top of a lattice (could not be determined). There exists
* exactly one type with this opcode.
*/
-extern const tp_op *tpop_unknown;
-const tp_op *get_tpop_unknown(void);
+FIRM_DLL const tp_op *tpop_unknown;
+FIRM_DLL const tp_op *get_tpop_unknown(void);
/* ----------------------------------------------------------------------- */
/* Classify pairs of types/entities in the inheritance relations. */
* a subclass of high. I.e, we search in all subtypes of high for low.
* @@@ this can be implemented more efficient if we know the set of all
* subclasses of high. */
-int is_SubClass_of(ir_type *low, ir_type *high);
+FIRM_DLL int is_SubClass_of(ir_type *low, ir_type *high);
/** Subclass check for pointers to classes.
*
* many as possible). If the remaining types are both class types
* and subclasses, returns true, else false. Can also be called with
* two class types. */
-int is_SubClass_ptr_of(ir_type *low, ir_type *high);
+FIRM_DLL int is_SubClass_ptr_of(ir_type *low, ir_type *high);
/** Returns true if high is superclass of low.
*
/** Returns true if high is (transitive) overwritten by low.
*
* Returns false if high == low. */
-int is_overwritten_by(ir_entity *high, ir_entity *low);
+FIRM_DLL int is_overwritten_by(ir_entity *high, ir_entity *low);
/** Resolve polymorphism in the inheritance relation.
*
* Returns the dynamically referenced entity if the static entity and the
* dynamic type are given.
* Searches downwards in overwritten tree. */
-ir_entity *resolve_ent_polymorphy(ir_type *dynamic_class, ir_entity* static_ent);
+FIRM_DLL ir_entity *resolve_ent_polymorphy(ir_type *dynamic_class,
+ ir_entity* static_ent);
/* ----------------------------------------------------------------------- */
/* Resolve implicit inheritance. */
*
* Returns an ident that consists of the name of type followed by an
* underscore and the name (not ld_name) of the entity. */
-ident *default_mangle_inherited_name(const ir_entity *ent, const ir_type *clss);
+FIRM_DLL ident *default_mangle_inherited_name(const ir_entity *ent,
+ const ir_type *clss);
/** Type of argument functions for inheritance resolver.
*
* used.
* @param clss The class type in which the new entity will be placed.
*/
-typedef ident *mangle_inherited_name_func(const ir_entity *ent, const ir_type *clss);
+typedef ident *mangle_inherited_name_func(const ir_entity *ent,
+ const ir_type *clss);
/** Resolve implicit inheritance.
*
* The name of the new entity is generated with the function passed.
* If the function is NULL, the default_mangle_inherited_name() is
* used.
- *
- * This function was moved here from firmlower 3/2005.
*/
-void resolve_inheritance(mangle_inherited_name_func *mfunc);
+FIRM_DLL void resolve_inheritance(mangle_inherited_name_func *mfunc);
/* ----------------------------------------------------------------------- */
inh_transitive_closure_max /**< Invalid value. */
} inh_transitive_closure_state;
-void set_irp_inh_transitive_closure_state(inh_transitive_closure_state s);
-void invalidate_irp_inh_transitive_closure_state(void);
-inh_transitive_closure_state get_irp_inh_transitive_closure_state(void);
+FIRM_DLL void set_irp_inh_transitive_closure_state(inh_transitive_closure_state s);
+FIRM_DLL void invalidate_irp_inh_transitive_closure_state(void);
+FIRM_DLL inh_transitive_closure_state get_irp_inh_transitive_closure_state(void);
/** Compute transitive closure of the subclass/superclass and
*
* This function walks over the ir (O(\#types+\#entities)) to compute the
* transitive closure. */
-void compute_inh_transitive_closure(void);
+FIRM_DLL void compute_inh_transitive_closure(void);
/** Free memory occupied by the transitive closure information. */
-void free_inh_transitive_closure(void);
+FIRM_DLL void free_inh_transitive_closure(void);
/* - subtype ------------------------------------------------------------- */
/** Iterate over all transitive subtypes. */
-ir_type *get_class_trans_subtype_first(const ir_type *tp);
-ir_type *get_class_trans_subtype_next(const ir_type *tp);
-int is_class_trans_subtype(const ir_type *tp, const ir_type *subtp);
+FIRM_DLL ir_type *get_class_trans_subtype_first(const ir_type *tp);
+FIRM_DLL ir_type *get_class_trans_subtype_next(const ir_type *tp);
+FIRM_DLL int is_class_trans_subtype(const ir_type *tp, const ir_type *subtp);
/* - supertype ----------------------------------------------------------- */
/** Iterate over all transitive supertypes. */
-ir_type *get_class_trans_supertype_first(const ir_type *tp);
-ir_type *get_class_trans_supertype_next(const ir_type *tp);
+FIRM_DLL ir_type *get_class_trans_supertype_first(const ir_type *tp);
+FIRM_DLL ir_type *get_class_trans_supertype_next(const ir_type *tp);
/* - overwrittenby ------------------------------------------------------- */
/** Iterate over all entities that transitive overwrite this entities. */
-ir_entity *get_entity_trans_overwrittenby_first(const ir_entity *ent);
-ir_entity *get_entity_trans_overwrittenby_next(const ir_entity *ent);
+FIRM_DLL ir_entity *get_entity_trans_overwrittenby_first(const ir_entity *ent);
+FIRM_DLL ir_entity *get_entity_trans_overwrittenby_next(const ir_entity *ent);
/* - overwrites ---------------------------------------------------------- */
/** Iterate over all transitive overwritten entities. */
-ir_entity *get_entity_trans_overwrites_first(const ir_entity *ent);
-ir_entity *get_entity_trans_overwrites_next(const ir_entity *ent);
+FIRM_DLL ir_entity *get_entity_trans_overwrites_first(const ir_entity *ent);
+FIRM_DLL ir_entity *get_entity_trans_overwrites_next(const ir_entity *ent);
/* ----------------------------------------------------------------------- */
ir_class_casts_normalized = 2, /**< Class casts conform to inheritance edges. */
ir_class_casts_state_max
} ir_class_cast_state;
-const char *get_class_cast_state_string(ir_class_cast_state s);
+FIRM_DLL const char *get_class_cast_state_string(ir_class_cast_state s);
-void set_irg_class_cast_state(ir_graph *irg, ir_class_cast_state s);
-ir_class_cast_state get_irg_class_cast_state(const ir_graph *irg);
-void set_irp_class_cast_state(ir_class_cast_state s);
-ir_class_cast_state get_irp_class_cast_state(void);
+FIRM_DLL void set_irg_class_cast_state(ir_graph *irg,
+ ir_class_cast_state s);
+FIRM_DLL ir_class_cast_state get_irg_class_cast_state(const ir_graph *irg);
+FIRM_DLL void set_irp_class_cast_state(ir_class_cast_state s);
+FIRM_DLL ir_class_cast_state get_irp_class_cast_state(void);
/** Verify the class cast state of an irg.
*
* Asserts if state is to high, outputs debug warning if state is to low
* and firm verbosity is set.
*/
-void verify_irg_class_cast_state(ir_graph *irg);
+FIRM_DLL void verify_irg_class_cast_state(ir_graph *irg);
/**
* possible trvrfy() error codes
* @return
* 0 if no error encountered
*/
-int check_type(ir_type *tp);
+FIRM_DLL int check_type(ir_type *tp);
/**
* Check an entity. Currently, we check only if initialized constants
* 0 if no error encountered
* != 0 a trvrfy_error_codes code
*/
-int check_entity(ir_entity *ent);
+FIRM_DLL int check_entity(ir_entity *ent);
/**
* Walks the type information and performs a set of sanity checks.
* 0 if graph is correct
* else error code.
*/
-int tr_vrfy(void);
+FIRM_DLL int tr_vrfy(void);
/**
* @page type representation of types
* Does not free the array entity.
* Warning: ensure these entities are not referenced anywhere else.
*/
-void free_type_entities(ir_type *tp);
+FIRM_DLL void free_type_entities(ir_type *tp);
/** Frees the memory used by the type.
*
* param subtypes of method types!!! Make sure these are not
* referenced any more. Further make sure there is no pointer type
* that refers to this type. */
-void free_type(ir_type *tp);
+FIRM_DLL void free_type(ir_type *tp);
-const tp_op *get_type_tpop(const ir_type *tp);
-ident *get_type_tpop_nameid(const ir_type *tp);
-const char *get_type_tpop_name(const ir_type *tp);
-tp_opcode get_type_tpop_code(const ir_type *tp);
+FIRM_DLL const tp_op *get_type_tpop(const ir_type *tp);
+FIRM_DLL ident *get_type_tpop_nameid(const ir_type *tp);
+FIRM_DLL const char *get_type_tpop_name(const ir_type *tp);
+FIRM_DLL tp_opcode get_type_tpop_code(const ir_type *tp);
/**
* construct a string representing the type.
* might abstract away some details. The main intention of this is creating
* human redable strings giving an idea of the type.
*/
-void ir_print_type(char *buffer, size_t buffer_size, const ir_type *tp);
+FIRM_DLL void ir_print_type(char *buffer, size_t buffer_size,
+ const ir_type *tp);
/** The state of the type layout. */
typedef enum {
} ir_type_state;
/** Returns a human readable string for the enum entry. */
-const char *get_type_state_name(ir_type_state s);
+FIRM_DLL const char *get_type_state_name(ir_type_state s);
/** Returns the type layout state of a type. */
-ir_type_state get_type_state(const ir_type *tp);
+FIRM_DLL ir_type_state get_type_state(const ir_type *tp);
/** Sets the type layout state of a type.
*
* For primitives, pointer and method types the layout is always fixed.
* This call is legal but has no effect.
*/
-void set_type_state(ir_type *tp, ir_type_state state);
+FIRM_DLL void set_type_state(ir_type *tp, ir_type_state state);
/** Returns the mode of a type.
*
* Returns NULL for all non atomic types.
*/
-ir_mode *get_type_mode(const ir_type *tp);
+FIRM_DLL ir_mode *get_type_mode(const ir_type *tp);
/** Sets the mode of a type.
*
* Only has an effect on primitive, enumeration and pointer types.
*/
-void set_type_mode(ir_type *tp, ir_mode* m);
+FIRM_DLL void set_type_mode(ir_type *tp, ir_mode* m);
/** Returns the size of a type in bytes. */
-unsigned get_type_size_bytes(const ir_type *tp);
+FIRM_DLL unsigned get_type_size_bytes(const ir_type *tp);
/** Sets the size of a type in bytes.
*
* For primitive, enumeration, pointer and method types the size
* is always fixed. This call is legal but has no effect.
*/
-void set_type_size_bytes(ir_type *tp, unsigned size);
+FIRM_DLL void set_type_size_bytes(ir_type *tp, unsigned size);
/** Returns the alignment of a type in bytes. */
-unsigned get_type_alignment_bytes(ir_type *tp);
+FIRM_DLL unsigned get_type_alignment_bytes(ir_type *tp);
/** Returns the alignment of a type in bits.
*
* -#.) method types return 0 here.
* -#.) all other types return 1 here (i.e. aligned at byte).
*/
-void set_type_alignment_bytes(ir_type *tp, unsigned align);
+FIRM_DLL void set_type_alignment_bytes(ir_type *tp, unsigned align);
/** Returns the visited count of a type. */
-ir_visited_t get_type_visited(const ir_type *tp);
+FIRM_DLL ir_visited_t get_type_visited(const ir_type *tp);
/** Sets the visited count of a type to num. */
-void set_type_visited(ir_type *tp, ir_visited_t num);
+FIRM_DLL void set_type_visited(ir_type *tp, ir_visited_t num);
/** Sets visited field in type to type_visited. */
-void mark_type_visited(ir_type *tp);
+FIRM_DLL void mark_type_visited(ir_type *tp);
/** Returns non-zero if the type is already visited */
-int type_visited(const ir_type *tp);
+FIRM_DLL int type_visited(const ir_type *tp);
/** Returns non-zero if the type is not yet visited */
-int type_not_visited(const ir_type *tp);
+FIRM_DLL int type_not_visited(const ir_type *tp);
/** Returns the associated link field of a type. */
-void *get_type_link(const ir_type *tp);
+FIRM_DLL void *get_type_link(const ir_type *tp);
/** Sets the associated link field of a type. */
-void set_type_link(ir_type *tp, void *l);
+FIRM_DLL void set_type_link(ir_type *tp, void *l);
/**
* Visited flag to traverse the type information.
*
* @see typewalk
*/
-void set_master_type_visited(ir_visited_t val);
-ir_visited_t get_master_type_visited(void);
-void inc_master_type_visited(void);
+FIRM_DLL void set_master_type_visited(ir_visited_t val);
+FIRM_DLL ir_visited_t get_master_type_visited(void);
+FIRM_DLL void inc_master_type_visited(void);
/**
* Sets the debug information of a type.
* @param tp The type.
* @param db The debug info.
*/
-void set_type_dbg_info(ir_type *tp, type_dbg_info *db);
+FIRM_DLL void set_type_dbg_info(ir_type *tp, type_dbg_info *db);
/**
* Returns the debug information of a type.
*
* @param tp The type.
*/
-type_dbg_info *get_type_dbg_info(const ir_type *tp);
+FIRM_DLL type_dbg_info *get_type_dbg_info(const ir_type *tp);
/**
* Checks whether a pointer points to a type.
* @return
* true if the thing is a type, else false
*/
-int is_type(const void *thing);
+FIRM_DLL int is_type(const void *thing);
/**
* Checks whether two types are structurally equal.
* This is to avoid endless recursions; with pointer types cyclic
* type graphs are possible.)
*/
-int equal_type(ir_type *typ1, ir_type *typ2);
+FIRM_DLL int equal_type(ir_type *typ1, ir_type *typ2);
/**
* Checks whether two types are structural comparable.
* @return smaller than the points_to type of lt.
*
*/
-int smaller_type(ir_type *st, ir_type *lt);
+FIRM_DLL int smaller_type(ir_type *st, ir_type *lt);
/**
* @page class_type Representation of a class type
*/
/** Creates a new class type. */
-ir_type *new_type_class(ident *name);
+FIRM_DLL ir_type *new_type_class(ident *name);
/** Creates a new class type with debug information. */
-ir_type *new_d_type_class(ident *name, type_dbg_info *db);
+FIRM_DLL ir_type *new_d_type_class(ident *name, type_dbg_info *db);
/* --- manipulate private fields of class type --- */
/** return identifier of the class type */
-ident *get_class_ident(const ir_type *clss);
+FIRM_DLL ident *get_class_ident(const ir_type *clss);
/** return identifier of the class type */
-const char *get_class_name(const ir_type *clss);
+FIRM_DLL const char *get_class_name(const ir_type *clss);
/** Adds the entity as member of the class. */
-void add_class_member(ir_type *clss, ir_entity *member);
+FIRM_DLL void add_class_member(ir_type *clss, ir_entity *member);
/** Returns the number of members of this class. */
-int get_class_n_members(const ir_type *clss);
+FIRM_DLL int get_class_n_members(const ir_type *clss);
/** Returns the member at position pos, 0 <= pos < n_member */
-ir_entity *get_class_member(const ir_type *clss, int pos);
+FIRM_DLL ir_entity *get_class_member(const ir_type *clss, int pos);
/** Returns index of mem in clss, -1 if not contained. */
-int get_class_member_index(const ir_type *clss, ir_entity *mem);
+FIRM_DLL int get_class_member_index(const ir_type *clss, ir_entity *mem);
/** Finds the member with name 'name'. If several members with the same
* name returns one of them. Returns NULL if no member found. */
-ir_entity *get_class_member_by_name(ir_type *clss, ident *name);
+FIRM_DLL ir_entity *get_class_member_by_name(ir_type *clss, ident *name);
/** Overwrites the member at position pos, 0 <= pos < n_member with
* the passed entity. */
-void set_class_member(ir_type *clss, ir_entity *member, int pos);
+FIRM_DLL void set_class_member(ir_type *clss, ir_entity *member, int pos);
/** Replaces complete member list in class type by the list passed.
*
* Copies the list passed. This function is necessary to reduce the number of members.
* members is an array of entities, num the size of this array. Sets all
* owners of the members passed to clss. */
-void set_class_members(ir_type *clss, ir_entity *members[], int arity);
+FIRM_DLL void set_class_members(ir_type *clss, ir_entity *members[], int arity);
/** Finds member in the list of members and removes it.
*
* Shrinks the member list, so iterate from the end!!!
* Does not deallocate the entity. */
-void remove_class_member(ir_type *clss, ir_entity *member);
+FIRM_DLL void remove_class_member(ir_type *clss, ir_entity *member);
/** Adds subtype as subtype to clss.
*
* Checks whether clss is a supertype of subtype. If not
* adds also clss as supertype to subtype. */
-void add_class_subtype(ir_type *clss, ir_type *subtype);
+FIRM_DLL void add_class_subtype(ir_type *clss, ir_type *subtype);
/** Returns the number of subtypes */
-int get_class_n_subtypes(const ir_type *clss);
+FIRM_DLL int get_class_n_subtypes(const ir_type *clss);
/** Gets the subtype at position pos, 0 <= pos < n_subtype. */
-ir_type *get_class_subtype(ir_type *clss, int pos);
+FIRM_DLL ir_type *get_class_subtype(ir_type *clss, int pos);
/** Returns the index to access subclass as subtype of class.
*
* If subclass is no direct subtype of class returns -1.
*/
-int get_class_subtype_index(ir_type *clss, const ir_type *subclass);
+FIRM_DLL int get_class_subtype_index(ir_type *clss, const ir_type *subclass);
/** Sets the subtype at position pos, 0 <= pos < n_subtype.
*
* Does not set the corresponding supertype relation for subtype: this might
* be a different position! */
-void set_class_subtype(ir_type *clss, ir_type *subtype, int pos);
+FIRM_DLL void set_class_subtype(ir_type *clss, ir_type *subtype, int pos);
/** Finds subtype in the list of subtypes and removes it */
-void remove_class_subtype(ir_type *clss, ir_type *subtype);
+FIRM_DLL void remove_class_subtype(ir_type *clss, ir_type *subtype);
/* Convenience macros */
#define add_class_derived_type(clss, drvtype) add_class_subtype(clss, drvtype)
*
* Checks whether clss is a subtype of supertype. If not
* adds also clss as subtype to supertype. */
-void add_class_supertype(ir_type *clss, ir_type *supertype);
+FIRM_DLL void add_class_supertype(ir_type *clss, ir_type *supertype);
/** Returns the number of supertypes */
-int get_class_n_supertypes(const ir_type *clss);
+FIRM_DLL int get_class_n_supertypes(const ir_type *clss);
/** Returns the index to access superclass as supertype of class.
*
* If superclass is no direct supertype of class returns -1.
*/
-int get_class_supertype_index(ir_type *clss, ir_type *super_clss);
+FIRM_DLL int get_class_supertype_index(ir_type *clss, ir_type *super_clss);
/** Gets the supertype at position pos, 0 <= pos < n_supertype. */
-ir_type *get_class_supertype(ir_type *clss, int pos);
+FIRM_DLL ir_type *get_class_supertype(ir_type *clss, int pos);
/** Sets the supertype at position pos, 0 <= pos < n_supertype.
*
* Does not set the corresponding subtype relation for supertype: this might
* be at a different position! */
-void set_class_supertype(ir_type *clss, ir_type *supertype, int pos);
+FIRM_DLL void set_class_supertype(ir_type *clss, ir_type *supertype, int pos);
/** Finds supertype in the list of supertypes and removes it */
-void remove_class_supertype(ir_type *clss, ir_type *supertype);
+FIRM_DLL void remove_class_supertype(ir_type *clss, ir_type *supertype);
/** Convenience macro */
#define add_class_base_type(clss, basetype) add_class_supertype(clss, basetype)
#define remove_class_base_type(clss, basetype) remove_class_supertype(clss, basetype)
/** Returns the type info entity of a class. */
-ir_entity *get_class_type_info(const ir_type *clss);
+FIRM_DLL ir_entity *get_class_type_info(const ir_type *clss);
/** Set a type info entity for the class. */
-void set_class_type_info(ir_type *clss, ir_entity *ent);
+FIRM_DLL void set_class_type_info(ir_type *clss, ir_entity *ent);
/** Returns the size of the virtual function table. */
-unsigned get_class_vtable_size(const ir_type *clss);
+FIRM_DLL unsigned get_class_vtable_size(const ir_type *clss);
/** Sets a new size of the virtual function table. */
-void set_class_vtable_size(ir_type *clss, unsigned size);
+FIRM_DLL void set_class_vtable_size(ir_type *clss, unsigned size);
/** Returns non-zero if a class is final. */
-int is_class_final(const ir_type *clss);
+FIRM_DLL int is_class_final(const ir_type *clss);
/** Sets the class final flag. */
-void set_class_final(ir_type *clss, int flag);
+FIRM_DLL void set_class_final(ir_type *clss, int flag);
/** Return non-zero if a class is an interface */
-int is_class_interface(const ir_type *clss);
+FIRM_DLL int is_class_interface(const ir_type *clss);
/** Sets the class interface flag. */
-void set_class_interface(ir_type *clss, int flag);
+FIRM_DLL void set_class_interface(ir_type *clss, int flag);
/** Return non-zero if a class is an abstract class. */
-int is_class_abstract(const ir_type *clss);
+FIRM_DLL int is_class_abstract(const ir_type *clss);
/** Sets the class abstract flag. */
-void set_class_abstract(ir_type *clss, int flag);
+FIRM_DLL void set_class_abstract(ir_type *clss, int flag);
/** Set and get a class' dfn --
@todo This is an undocumented field, subject to change! */
-void set_class_dfn(ir_type *clss, int dfn);
-int get_class_dfn(const ir_type *clss);
+FIRM_DLL void set_class_dfn(ir_type *clss, int dfn);
+FIRM_DLL int get_class_dfn(const ir_type *clss);
/** Returns true if a type is a class type. */
-int is_Class_type(const ir_type *clss);
+FIRM_DLL int is_Class_type(const ir_type *clss);
/**
* @page struct_type Representation of a struct type
* but not shrinked.
*/
/** Creates a new type struct */
-ir_type *new_type_struct(ident *name);
+FIRM_DLL ir_type *new_type_struct(ident *name);
/** Creates a new type struct with debug information. */
-ir_type *new_d_type_struct(ident *name, type_dbg_info* db);
+FIRM_DLL ir_type *new_d_type_struct(ident *name, type_dbg_info* db);
/* --- manipulate private fields of struct --- */
/** return struct identifier */
-ident *get_struct_ident(const ir_type *strct);
+FIRM_DLL ident *get_struct_ident(const ir_type *strct);
/** return struct identifier as c-string*/
-const char *get_struct_name(const ir_type *strct);
+FIRM_DLL const char *get_struct_name(const ir_type *strct);
/** Adds the entity as member of the struct. */
-void add_struct_member(ir_type *strct, ir_entity *member);
+FIRM_DLL void add_struct_member(ir_type *strct, ir_entity *member);
/** Returns the number of members of this struct. */
-int get_struct_n_members(const ir_type *strct);
+FIRM_DLL int get_struct_n_members(const ir_type *strct);
/** Returns the member at position pos, 0 <= pos < n_member */
-ir_entity *get_struct_member(const ir_type *strct, int pos);
+FIRM_DLL ir_entity *get_struct_member(const ir_type *strct, int pos);
/** Returns index of member in strct, -1 if not contained. */
-int get_struct_member_index(const ir_type *strct, ir_entity *member);
+FIRM_DLL int get_struct_member_index(const ir_type *strct, ir_entity *member);
/** Overwrites the member at position pos, 0 <= pos < n_member with
the passed entity. */
-void set_struct_member(ir_type *strct, int pos, ir_entity *member);
+FIRM_DLL void set_struct_member(ir_type *strct, int pos, ir_entity *member);
/** Finds member in the list of members and removes it. */
-void remove_struct_member(ir_type *strct, ir_entity *member);
+FIRM_DLL void remove_struct_member(ir_type *strct, ir_entity *member);
/** Returns true if a type is a struct type. */
-int is_Struct_type(const ir_type *strct);
+FIRM_DLL int is_Struct_type(const ir_type *strct);
/**
* @page method_type Representation of a method type
* The arrays for the parameter and result types are not initialized by
* the constructor.
*/
-ir_type *new_type_method(int n_param, int n_res);
+FIRM_DLL ir_type *new_type_method(int n_param, int n_res);
/** Create a new method type with debug information.
*
* The arrays for the parameter and result types are not initialized by
* the constructor.
*/
-ir_type *new_d_type_method(int n_param, int n_res, type_dbg_info *db);
+FIRM_DLL ir_type *new_d_type_method(int n_param, int n_res, type_dbg_info *db);
/* -- manipulate private fields of method. -- */
/** Returns the number of parameters of this method. */
-int get_method_n_params(const ir_type *method);
+FIRM_DLL int get_method_n_params(const ir_type *method);
/** Returns the type of the parameter at position pos of a method. */
-ir_type *get_method_param_type(ir_type *method, int pos);
+FIRM_DLL ir_type *get_method_param_type(ir_type *method, int pos);
/** Sets the type of the parameter at position pos of a method.
Also changes the type in the pass-by-value representation by just
changing the type of the corresponding entity if the representation is constructed. */
-void set_method_param_type(ir_type *method, int pos, ir_type *tp);
+FIRM_DLL void set_method_param_type(ir_type *method, int pos, ir_type *tp);
/** Returns an entity that represents the copied value argument. Only necessary
for compounds passed by value. This information is constructed only on demand. */
-ir_entity *get_method_value_param_ent(ir_type *method, int pos);
+FIRM_DLL ir_entity *get_method_value_param_ent(ir_type *method, int pos);
/**
* Sets the type that represents the copied value arguments.
*/
-void set_method_value_param_type(ir_type *method, ir_type *tp);
+FIRM_DLL void set_method_value_param_type(ir_type *method, ir_type *tp);
/**
* Returns a type that represents the copied value arguments if one
* was allocated, else NULL.
*/
-ir_type *get_method_value_param_type(const ir_type *method);
+FIRM_DLL ir_type *get_method_value_param_type(const ir_type *method);
/** Returns an ident representing the parameters name. Returns NULL if not set.
For debug support only. */
-ident *get_method_param_ident(ir_type *method, int pos);
+FIRM_DLL ident *get_method_param_ident(ir_type *method, int pos);
/** Returns a string representing the parameters name. Returns NULL if not set.
For debug support only. */
-const char *get_method_param_name(ir_type *method, int pos);
+FIRM_DLL const char *get_method_param_name(ir_type *method, int pos);
/** Sets an ident representing the parameters name. For debug support only. */
-void set_method_param_ident(ir_type *method, int pos, ident *id);
+FIRM_DLL void set_method_param_ident(ir_type *method, int pos, ident *id);
/** Returns the number of results of a method type. */
-int get_method_n_ress(const ir_type *method);
+FIRM_DLL int get_method_n_ress(const ir_type *method);
/** Returns the return type of a method type at position pos. */
-ir_type *get_method_res_type(ir_type *method, int pos);
+FIRM_DLL ir_type *get_method_res_type(ir_type *method, int pos);
/** Sets the type of the result at position pos of a method.
Also changes the type in the pass-by-value representation by just
changing the type of the corresponding entity if the representation is constructed. */
-void set_method_res_type(ir_type *method, int pos, ir_type *tp);
+FIRM_DLL void set_method_res_type(ir_type *method, int pos, ir_type *tp);
/** Returns an entity that represents the copied value result. Only necessary
for compounds passed by value. This information is constructed only on demand. */
-ir_entity *get_method_value_res_ent(ir_type *method, int pos);
+FIRM_DLL ir_entity *get_method_value_res_ent(ir_type *method, int pos);
/**
* Returns a type that represents the copied value results.
*/
-ir_type *get_method_value_res_type(const ir_type *method);
+FIRM_DLL ir_type *get_method_value_res_type(const ir_type *method);
/**
* This enum flags the variadicity of methods (methods with a
} ir_variadicity;
/** Returns the null-terminated name of this variadicity. */
-const char *get_variadicity_name(ir_variadicity vari);
+FIRM_DLL const char *get_variadicity_name(ir_variadicity vari);
/** Returns the variadicity of a method. */
-ir_variadicity get_method_variadicity(const ir_type *method);
+FIRM_DLL ir_variadicity get_method_variadicity(const ir_type *method);
/** Sets the variadicity of a method. */
-void set_method_variadicity(ir_type *method, ir_variadicity vari);
+FIRM_DLL void set_method_variadicity(ir_type *method, ir_variadicity vari);
/**
* Returns the first variadic parameter index of a type.
* of the method type plus one is returned for variadic functions.
* Non-variadic function types always return -1 here.
*/
-int get_method_first_variadic_param_index(const ir_type *method);
+FIRM_DLL int get_method_first_variadic_param_index(const ir_type *method);
/**
* Sets the first variadic parameter index. This allows to specify
* but still have the knowledge, which parameter must be passed as
* variadic one.
*/
-void set_method_first_variadic_param_index(ir_type *method, int index);
+FIRM_DLL void set_method_first_variadic_param_index(ir_type *method, int index);
/** Returns the mask of the additional graph properties. */
-unsigned get_method_additional_properties(const ir_type *method);
+FIRM_DLL unsigned get_method_additional_properties(const ir_type *method);
/** Sets the mask of the additional graph properties. */
-void set_method_additional_properties(ir_type *method, unsigned property_mask);
+FIRM_DLL void set_method_additional_properties(ir_type *method,
+ unsigned property_mask);
/** Sets one additional graph property. */
-void set_method_additional_property(ir_type *method, mtp_additional_property flag);
+FIRM_DLL void set_method_additional_property(ir_type *method,
+ mtp_additional_property flag);
/**
* Calling conventions: lower 24 bits are the number of register parameters,
#define cc_fastcall_set (cc_reg_param|cc_callee_clear_stk)
/** Returns the default calling convention for method types. */
-unsigned get_default_cc_mask(void);
+FIRM_DLL unsigned get_default_cc_mask(void);
/**
* check for the CDECL calling convention
#define SET_FASTCALL(cc_mask) (((cc_mask) & ~cc_bits) | cc_fastcall_set)
/** Returns the calling convention of an entities graph. */
-unsigned get_method_calling_convention(const ir_type *method);
+FIRM_DLL unsigned get_method_calling_convention(const ir_type *method);
/** Sets the calling convention of an entities graph. */
-void set_method_calling_convention(ir_type *method, unsigned cc_mask);
+FIRM_DLL void set_method_calling_convention(ir_type *method, unsigned cc_mask);
/** Returns the number of registers parameters, 0 means default. */
-unsigned get_method_n_regparams(ir_type *method);
+FIRM_DLL unsigned get_method_n_regparams(ir_type *method);
/** Sets the number of registers parameters, 0 means default. */
-void set_method_n_regparams(ir_type *method, unsigned n_regs);
+FIRM_DLL void set_method_n_regparams(ir_type *method, unsigned n_regs);
/** Returns true if a type is a method type. */
-int is_Method_type(const ir_type *method);
+FIRM_DLL int is_Method_type(const ir_type *method);
/**
* @page union_type Representation of a union (variant) type.
* but not shrinked.
*/
/** Creates a new type union. */
-ir_type *new_type_union(ident *name);
+FIRM_DLL ir_type *new_type_union(ident *name);
/** Creates a new type union with debug information. */
-ir_type *new_d_type_union(ident *name, type_dbg_info* db);
+FIRM_DLL ir_type *new_d_type_union(ident *name, type_dbg_info* db);
/* --- manipulate private fields of struct --- */
/** return union identifier */
-ident *get_union_ident(const ir_type *uni);
+FIRM_DLL ident *get_union_ident(const ir_type *uni);
/** return union identifier as c-string */
-const char *get_union_name(const ir_type *uni);
+FIRM_DLL const char *get_union_name(const ir_type *uni);
/** Returns the number of unioned types of this union */
-int get_union_n_members(const ir_type *uni);
+FIRM_DLL int get_union_n_members(const ir_type *uni);
/** Adds a new entity to a union type */
-void add_union_member(ir_type *uni, ir_entity *member);
+FIRM_DLL void add_union_member(ir_type *uni, ir_entity *member);
/** Returns the entity at position pos of a union */
-ir_entity *get_union_member(const ir_type *uni, int pos);
+FIRM_DLL ir_entity *get_union_member(const ir_type *uni, int pos);
/** Returns index of member in uni, -1 if not contained. */
-int get_union_member_index(const ir_type *uni, ir_entity *member);
+FIRM_DLL int get_union_member_index(const ir_type *uni, ir_entity *member);
/** Overwrites a entity at position pos in a union type. */
-void set_union_member(ir_type *uni, int pos, ir_entity *member);
+FIRM_DLL void set_union_member(ir_type *uni, int pos, ir_entity *member);
/** Finds member in the list of members and removes it. */
-void remove_union_member(ir_type *uni, ir_entity *member);
+FIRM_DLL void remove_union_member(ir_type *uni, ir_entity *member);
/** Returns true if a type is a union type. */
-int is_Union_type(const ir_type *uni);
+FIRM_DLL int is_Union_type(const ir_type *uni);
/**
* @page array_type Representation of an array type
* The entity for array elements is built automatically.
* Set dimension sizes after call to constructor with set_* routines.
*/
-ir_type *new_type_array(int n_dims, ir_type *element_type);
+FIRM_DLL ir_type *new_type_array(int n_dims, ir_type *element_type);
/** Create a new type array with debug information.
*
* Set dimension sizes after call to constructor with set_* routines.
* A legal array type must have at least one dimension set.
*/
-ir_type *new_d_type_array(int n_dims, ir_type *element_type, type_dbg_info* db);
+FIRM_DLL ir_type *new_d_type_array(int n_dims, ir_type *element_type,
+ type_dbg_info* db);
/* --- manipulate private fields of array type --- */
/** Returns the number of array dimensions of this type. */
-int get_array_n_dimensions(const ir_type *array);
+FIRM_DLL int get_array_n_dimensions(const ir_type *array);
/**
* Allocates Const nodes of mode_Is for one array dimension.
* Upper bound in Firm is the element next to the last, i.e. [lower,upper[
*/
-void set_array_bounds_int(ir_type *array, int dimension, int lower_bound,
- int upper_bound);
+FIRM_DLL void set_array_bounds_int(ir_type *array, int dimension,
+ int lower_bound, int upper_bound);
/**
* Sets the bounds for one array dimension.
* Upper bound in Firm is the element next to the last, i.e. [lower,upper[
*/
-void set_array_bounds(ir_type *array, int dimension, ir_node *lower_bound,
- ir_node *upper_bound);
+FIRM_DLL void set_array_bounds(ir_type *array, int dimension,
+ ir_node *lower_bound, ir_node *upper_bound);
/** Sets the lower bound for one array dimension, i.e. [lower,upper[ */
-void set_array_lower_bound(ir_type *array, int dimension, ir_node *lower_bound);
+FIRM_DLL void set_array_lower_bound(ir_type *array, int dimension,
+ ir_node *lower_bound);
/** Allocates Const nodes of mode_Is for the lower bound of an array
dimension, i.e. [lower,upper[ */
-void set_array_lower_bound_int(ir_type *array, int dimension, int lower_bound);
+FIRM_DLL void set_array_lower_bound_int(ir_type *array, int dimension,
+ int lower_bound);
/** Sets the upper bound for one array dimension, i.e. [lower,upper[ */
-void set_array_upper_bound(ir_type *array, int dimension, ir_node *upper_bound);
+FIRM_DLL void set_array_upper_bound(ir_type *array, int dimension,
+ ir_node *upper_bound);
/** Allocates Const nodes of mode_Is for the upper bound of an array
dimension, i.e. [lower,upper[. */
-void set_array_upper_bound_int(ir_type *array, int dimension, int upper_bound);
+FIRM_DLL void set_array_upper_bound_int(ir_type *array, int dimension,
+ int upper_bound);
/** Returns true if lower bound != Unknown. */
-int has_array_lower_bound(const ir_type *array, int dimension);
+FIRM_DLL int has_array_lower_bound(const ir_type *array, int dimension);
/** Returns the lower bound of an array. */
-ir_node *get_array_lower_bound(const ir_type *array, int dimension);
+FIRM_DLL ir_node *get_array_lower_bound(const ir_type *array, int dimension);
/** Works only if bound is Const node with tarval that can be converted to long. */
-long get_array_lower_bound_int(const ir_type *array, int dimension);
+FIRM_DLL long get_array_lower_bound_int(const ir_type *array, int dimension);
/** returns true if lower bound != Unknown */
-int has_array_upper_bound(const ir_type *array, int dimension);
+FIRM_DLL int has_array_upper_bound(const ir_type *array, int dimension);
/** Returns the upper bound of an array. */
-ir_node *get_array_upper_bound(const ir_type *array, int dimension);
+FIRM_DLL ir_node *get_array_upper_bound(const ir_type *array, int dimension);
/** Works only if bound is Const node with tarval that can be converted to long. */
-long get_array_upper_bound_int(const ir_type *array, int dimension);
+FIRM_DLL long get_array_upper_bound_int(const ir_type *array, int dimension);
/** Sets an array dimension to a specific order. */
-void set_array_order(ir_type *array, int dimension, int order);
+FIRM_DLL void set_array_order(ir_type *array, int dimension, int order);
/** Returns the order of an array dimension. */
-int get_array_order(const ir_type *array, int dimension);
+FIRM_DLL int get_array_order(const ir_type *array, int dimension);
/** Find the array dimension that is placed at order order. */
-int find_array_dimension(const ir_type *array, int order);
+FIRM_DLL int find_array_dimension(const ir_type *array, int order);
/** Sets the array element type. */
-void set_array_element_type(ir_type *array, ir_type* tp);
+FIRM_DLL void set_array_element_type(ir_type *array, ir_type* tp);
/** Gets the array element type. */
-ir_type *get_array_element_type(const ir_type *array);
+FIRM_DLL ir_type *get_array_element_type(const ir_type *array);
/** Sets the array element entity. */
-void set_array_element_entity(ir_type *array, ir_entity *ent);
+FIRM_DLL void set_array_element_entity(ir_type *array, ir_entity *ent);
/** Get the array element entity. */
-ir_entity *get_array_element_entity(const ir_type *array);
+FIRM_DLL ir_entity *get_array_element_entity(const ir_type *array);
/** Returns true if a type is an array type. */
-int is_Array_type(const ir_type *array);
+FIRM_DLL int is_Array_type(const ir_type *array);
/**
* @page enumeration_type Representation of an enumeration type
*/
/** Create a new type enumeration -- set the enumerators independently. */
-ir_type *new_type_enumeration(ident *name, int n_enums);
+FIRM_DLL ir_type *new_type_enumeration(ident *name, int n_enums);
/** Create a new type enumeration with debug information -- set the enumerators independently. */
-ir_type *new_d_type_enumeration(ident *name, int n_enums, type_dbg_info *db);
+FIRM_DLL ir_type *new_d_type_enumeration(ident *name, int n_enums,
+ type_dbg_info *db);
/* --- manipulate fields of enumeration type. --- */
/** return enumeration identifier */
-ident *get_enumeration_ident(const ir_type *enumeration);
+FIRM_DLL ident *get_enumeration_ident(const ir_type *enumeration);
/** return enumeration identifier as c-string */
-const char *get_enumeration_name(const ir_type *enumeration);
+FIRM_DLL const char *get_enumeration_name(const ir_type *enumeration);
/** Set an enumeration constant to a enumeration type at a given position. */
-void set_enumeration_const(ir_type *enumeration, int pos, ident *nameid, tarval *con);
+FIRM_DLL void set_enumeration_const(ir_type *enumeration, int pos,
+ ident *nameid, tarval *con);
/** Returns the number of enumeration values of this enumeration */
-int get_enumeration_n_enums(const ir_type *enumeration);
+FIRM_DLL int get_enumeration_n_enums(const ir_type *enumeration);
/** Returns the enumeration constant at a given position. */
-ir_enum_const *get_enumeration_const(const ir_type *enumeration, int pos);
+FIRM_DLL ir_enum_const *get_enumeration_const(const ir_type *enumeration,
+ int pos);
/** Returns the enumeration type owner of an enumeration constant. */
-ir_type *get_enumeration_owner(const ir_enum_const *enum_cnst);
+FIRM_DLL ir_type *get_enumeration_owner(const ir_enum_const *enum_cnst);
/** Sets the enumeration constant value. */
-void set_enumeration_value(ir_enum_const *enum_cnst, tarval *con);
+FIRM_DLL void set_enumeration_value(ir_enum_const *enum_cnst, tarval *con);
/** Returns the enumeration constant value. */
-tarval *get_enumeration_value(const ir_enum_const *enum_cnst);
+FIRM_DLL tarval *get_enumeration_value(const ir_enum_const *enum_cnst);
/** Assign an ident to an enumeration constant. */
-void set_enumeration_nameid(ir_enum_const *enum_cnst, ident *id);
+FIRM_DLL void set_enumeration_nameid(ir_enum_const *enum_cnst, ident *id);
/** Returns the assigned ident of an enumeration constant. */
-ident *get_enumeration_const_nameid(const ir_enum_const *enum_cnst);
+FIRM_DLL ident *get_enumeration_const_nameid(const ir_enum_const *enum_cnst);
/** Returns the assigned name of an enumeration constant. */
-const char *get_enumeration_const_name(const ir_enum_const *enum_cnst);
+FIRM_DLL const char *get_enumeration_const_name(const ir_enum_const *enum_cnst);
/** Returns true if a type is a enumeration type. */
-int is_Enumeration_type(const ir_type *enumeration);
+FIRM_DLL int is_Enumeration_type(const ir_type *enumeration);
/**
* @page pointer_type Representation of a pointer type
*/
/** Creates a new type pointer. */
-ir_type *new_type_pointer(ir_type *points_to);
+FIRM_DLL ir_type *new_type_pointer(ir_type *points_to);
/** Creates a new type pointer with debug information. */
-ir_type *new_d_type_pointer(ir_type *points_to, type_dbg_info* db);
+FIRM_DLL ir_type *new_d_type_pointer(ir_type *points_to, type_dbg_info* db);
/* --- manipulate fields of type_pointer --- */
/** Sets the type to which a pointer points to. */
-void set_pointer_points_to_type(ir_type *pointer, ir_type *tp);
+FIRM_DLL void set_pointer_points_to_type(ir_type *pointer, ir_type *tp);
/** Returns the type to which a pointer points to. */
-ir_type *get_pointer_points_to_type(const ir_type *pointer);
+FIRM_DLL ir_type *get_pointer_points_to_type(const ir_type *pointer);
/** Returns true if a type is a pointer type. */
-int is_Pointer_type(const ir_type *pointer);
+FIRM_DLL int is_Pointer_type(const ir_type *pointer);
/** Returns the first pointer type that has as points_to tp.
* Not efficient: O(\#types).
* If not found returns firm_unknown_type. */
-ir_type *find_pointer_type_to_type(ir_type *tp);
+FIRM_DLL ir_type *find_pointer_type_to_type(ir_type *tp);
/**
* @page primitive_type Representation of a primitive type
* important information they carry is held in the common mode field.
*/
/** Creates a new primitive type. */
-ir_type *new_type_primitive(ir_mode *mode);
+FIRM_DLL ir_type *new_type_primitive(ir_mode *mode);
/** Creates a new primitive type with debug information. */
-ir_type *new_d_type_primitive(ir_mode *mode, type_dbg_info* db);
+FIRM_DLL ir_type *new_d_type_primitive(ir_mode *mode, type_dbg_info* db);
/** Returns true if a type is a primitive type. */
-int is_Primitive_type(const ir_type *primitive);
+FIRM_DLL int is_Primitive_type(const ir_type *primitive);
/** Return the base type of a primitive (bitfield) type or NULL if none. */
-ir_type *get_primitive_base_type(const ir_type *tp);
+FIRM_DLL ir_type *get_primitive_base_type(const ir_type *tp);
/** Sets the base type of a primitive (bitfield) type. */
-void set_primitive_base_type(ir_type *tp, ir_type *base_tp);
+FIRM_DLL void set_primitive_base_type(ir_type *tp, ir_type *base_tp);
/**
* @page none_type The None type
* - size: 0
*/
/** A variable that contains the only none type. */
-extern ir_type *firm_none_type;
+FIRM_DLL ir_type *firm_none_type;
/** A variable that contains the only code type. */
-extern ir_type *firm_code_type;
+FIRM_DLL ir_type *firm_code_type;
/** Returns the none type. */
-ir_type *get_none_type(void);
+FIRM_DLL ir_type *get_none_type(void);
/** Returns the code type. */
-ir_type *get_code_type(void);
+FIRM_DLL ir_type *get_code_type(void);
/**
* @page unknown_type The Unknown type
* - size: 0
*/
/** A variable that contains the only unknown type. */
-extern ir_type *firm_unknown_type;
+FIRM_DLL ir_type *firm_unknown_type;
/** Returns the unknown type. */
-ir_type *get_unknown_type(void);
+FIRM_DLL ir_type *get_unknown_type(void);
/**
* @param tp any type
* @return true if type is primitive, pointer or enumeration
*/
-int is_atomic_type(const ir_type *tp);
+FIRM_DLL int is_atomic_type(const ir_type *tp);
/* --- Support for compound types --- */
/**
* Gets the identifier of a compound type
*/
-ident *get_compound_ident(const ir_type *tp);
+FIRM_DLL ident *get_compound_ident(const ir_type *tp);
/** return compound identifier as c-string */
-const char *get_compound_name(const ir_type *tp);
+FIRM_DLL const char *get_compound_name(const ir_type *tp);
/**
* Gets the number of elements in a Firm compound type.
*
* @return Number of members in the compound type.
*/
-int get_compound_n_members(const ir_type *tp);
+FIRM_DLL int get_compound_n_members(const ir_type *tp);
/**
* Gets the member of a Firm compound type at position pos.
*
* @return The member entity at position pos.
*/
-ir_entity *get_compound_member(const ir_type *tp, int pos);
+FIRM_DLL ir_entity *get_compound_member(const ir_type *tp, int pos);
/** Returns index of member in tp, -1 if not contained. */
-int get_compound_member_index(const ir_type *tp, ir_entity *member);
+FIRM_DLL int get_compound_member_index(const ir_type *tp, ir_entity *member);
/**
* layout members of a struct/union or class type in a default way.
*/
-void default_layout_compound_type(ir_type *tp);
+FIRM_DLL void default_layout_compound_type(ir_type *tp);
/**
* Checks whether a type is a compound type.
*
* @return true if the type is class, structure, union or array type.
*/
-int is_compound_type(const ir_type *tp);
+FIRM_DLL int is_compound_type(const ir_type *tp);
/**
* Checks wether a type is a code type.
*/
-int is_code_type(const ir_type *tp);
+FIRM_DLL int is_code_type(const ir_type *tp);
/**
* Checks, whether a type is a frame type.
*/
-int is_frame_type(const ir_type *tp);
+FIRM_DLL int is_frame_type(const ir_type *tp);
/**
* Checks, whether a type is a value parameter type.
*/
-int is_value_param_type(const ir_type *tp);
+FIRM_DLL int is_value_param_type(const ir_type *tp);
/**
* Checks, whether a type is a lowered type.
*/
-int is_lowered_type(const ir_type *tp);
+FIRM_DLL int is_lowered_type(const ir_type *tp);
/**
* Makes a new value type. Value types are struct types,
* so all struct access functions work.
* Value types are not in the global list of types.
*/
-ir_type *new_type_value(void);
+FIRM_DLL ir_type *new_type_value(void);
/**
* Makes a new frame type. Frame types are class types,
* so all class access functions work.
* Frame types are not in the global list of types.
*/
-ir_type *new_type_frame(void);
+FIRM_DLL ir_type *new_type_frame(void);
/**
* Makes a clone of a frame type.
* Sets entity links from old frame entities to new onces and
* vice versa.
*/
-ir_type *clone_frame_type(ir_type *type);
+FIRM_DLL ir_type *clone_frame_type(ir_type *type);
/**
* Sets a lowered type for a type. This sets both associations
* and marks lowered_type as a "lowered" one.
*/
-void set_lowered_type(ir_type *tp, ir_type *lowered_type);
+FIRM_DLL void set_lowered_type(ir_type *tp, ir_type *lowered_type);
/**
* Gets the lowered/unlowered type of a type or NULL if this type
* has no lowered/unlowered one.
*/
-ir_type *get_associated_type(const ir_type *tp);
+FIRM_DLL ir_type *get_associated_type(const ir_type *tp);
/**
* Allocate an area of size bytes aligned at alignment
*
* @return the entity representing the area
*/
-ir_entity *frame_alloc_area(ir_type *frame_type, int size, unsigned alignment, int at_start);
+FIRM_DLL ir_entity *frame_alloc_area(ir_type *frame_type, int size,
+ unsigned alignment, int at_start);
/*-----------------------------------------------------------------*/
/** Debug aides **/
* debugging, (configure with --enable-debug) else returns the address
* of the type cast to long.
*/
-long get_type_nr(const ir_type *tp);
+FIRM_DLL long get_type_nr(const ir_type *tp);
/* ------------------------------------------------------------------------ */
* Compares the opcode and the name of the types. If these are
* equal returns 0, else non-zero.
*/
-int compare_names(const void *tp1, const void *tp2);
+FIRM_DLL int compare_names(const void *tp1, const void *tp2);
/** Compares two types strict.
*
* returns 0 if tp1 == tp2, else non-zero
*/
-int compare_strict(const void *tp1, const void *tp2);
+FIRM_DLL int compare_strict(const void *tp1, const void *tp2);
/* ------------------------------------------------------------------------ */
*
* Uses the name of the type and the type opcode to compute the hash.
*/
-int firm_hash_name(ir_type *tp);
+FIRM_DLL int firm_hash_name(ir_type *tp);
/* ------------------------------------------------------------------------ */
*
* @param tp The type to mature.
*/
-ir_type *mature_type(ir_type *tp);
+FIRM_DLL ir_type *mature_type(ir_type *tp);
/** Finalize type construction.
*
*
* @param tp The type to mature.
*/
-ir_type *mature_type_free(ir_type *tp);
+FIRM_DLL ir_type *mature_type_free(ir_type *tp);
/** Finalize type construction.
*
*
* @param tp The type to mature.
*/
-ir_type *mature_type_free_entities(ir_type *tp);
+FIRM_DLL ir_type *mature_type_free_entities(ir_type *tp);
/** A data type to treat types and entities as the same. */
typedef union {
* types/entities are created during the traversal these will
* be visited, too.
* Does not touch frame types or types for value params ... */
-void type_walk(type_walk_func *pre, type_walk_func *post, void *env);
+FIRM_DLL void type_walk(type_walk_func *pre, type_walk_func *post, void *env);
/** Touches every type, entity, frame type, and value param type in
* unspecified order (also all segment types). */
-void type_walk_prog(type_walk_func *pre, type_walk_func *post, void *env);
+FIRM_DLL void type_walk_prog(type_walk_func *pre, type_walk_func *post,
+ void *env);
/** Walks over all type information reachable from an ir graph.
*
* Walks over all type information reachable from irg, i.e., starts a
* type walk at the irgs entity, the irgs frame type and all types and
* entities that are attributes to firm nodes. */
-void type_walk_irg(ir_graph *irg, type_walk_func *pre, type_walk_func *post,
- void *env);
+FIRM_DLL void type_walk_irg(ir_graph *irg, type_walk_func *pre,
+ type_walk_func *post, void *env);
/**
Touches every class in specified order:
@deprecated will be removed?
*/
-void type_walk_super2sub(type_walk_func *pre, type_walk_func *post, void *env);
+FIRM_DLL void type_walk_super2sub(type_walk_func *pre, type_walk_func *post,
+ void *env);
/** Walker for class types in inheritance order.
*
* visiting all superclasses.
*
* The arguments pre, post, env may be NULL. */
-void type_walk_super(type_walk_func *pre, type_walk_func *post, void *env);
+FIRM_DLL void type_walk_super(type_walk_func *pre, type_walk_func *post,
+ void *env);
/** Same as type_walk_super2sub, but visits only class types.
Executes pre for a class if all superclasses have been visited.
subclass.
Does not visit global type, frame types.
*/
-void class_walk_super2sub(class_walk_func *pre, class_walk_func *post,
- void *env);
+FIRM_DLL void class_walk_super2sub(class_walk_func *pre, class_walk_func *post,
+ void *env);
/**
* the entity walk function. A function type for entity walkers.
* @param doit the entity walker function
* @param env environment, will be passed to the walker function
*/
-void walk_types_entities(ir_type *tp, entity_walk_func *doit, void *env);
+FIRM_DLL void walk_types_entities(ir_type *tp, entity_walk_func *doit,
+ void *env);
/**
* If we have the closed world assumption, we can calculate the
* After this is done, all classes and entities that are not overridden
* anymore have the final property set.
*/
-void types_calc_finalization(void);
+FIRM_DLL void types_calc_finalization(void);
/** @deprecated */
-ir_visibility get_type_visibility(const ir_type *tp);
+FIRM_DLL ir_visibility get_type_visibility(const ir_type *tp);
/** @deprecated */
-void set_type_visibility(ir_type *tp, ir_visibility v);
+FIRM_DLL void set_type_visibility(ir_type *tp, ir_visibility v);
/** @deprecated */
typedef enum {
allocation_static
} ir_allocation;
/** @deprecated */
-ir_allocation get_entity_allocation(const ir_entity *ent);
+FIRM_DLL ir_allocation get_entity_allocation(const ir_entity *ent);
/** @deprecated */
-void set_entity_allocation(ir_entity *ent, ir_allocation al);
+FIRM_DLL void set_entity_allocation(ir_entity *ent, ir_allocation al);
/** @deprecated */
typedef enum {
peculiarity_inherited
} ir_peculiarity;
/** @deprecated */
-ir_peculiarity get_entity_peculiarity(const ir_entity *ent);
+FIRM_DLL ir_peculiarity get_entity_peculiarity(const ir_entity *ent);
/** @deprecated */
-void set_entity_peculiarity(ir_entity *ent, ir_peculiarity pec);
+FIRM_DLL void set_entity_peculiarity(ir_entity *ent, ir_peculiarity pec);
/** @deprecated */
-int is_entity_final(const ir_entity *ent);
+FIRM_DLL int is_entity_final(const ir_entity *ent);
/** @deprecated */
-void set_entity_final(ir_entity *ent, int final);
+FIRM_DLL void set_entity_final(ir_entity *ent, int final);
/** @deprecated */
-ir_peculiarity get_class_peculiarity(const ir_type *clss);
+FIRM_DLL ir_peculiarity get_class_peculiarity(const ir_type *clss);
/** @deprecated */
-void set_class_peculiarity(ir_type *clss, ir_peculiarity pec);
+FIRM_DLL void set_class_peculiarity(ir_type *clss, ir_peculiarity pec);
+
+#include "end.h"
#endif
* @version $Id$
*
*/
-#include "firm_types.h"
-
#ifndef VRP_H
#define VRP_H
+#include "firm_types.h"
+#include "begin.h"
+
enum range_types {
VRP_UNDEFINED, /**< No information could be derived so far */
VRP_RANGE, /**< bottom and top form a range, including both values */
* Set vrp data on the graph irg
* @param irg graph on which to set vrp data
*/
-void set_vrp_data(ir_graph *irg);
+FIRM_DLL void set_vrp_data(ir_graph *irg);
/**
* Test, if the two nodes can be compared with their vrp information
*
* @return the pn_Cmp, if one can be derived
*/
-pn_Cmp vrp_cmp(const ir_node *left, const ir_node *right);
+FIRM_DLL pn_Cmp vrp_cmp(const ir_node *left, const ir_node *right);
/*
* Return the vrp data for this node
*
* @return a pointer to the vrp data or NULL if there is none
*/
-vrp_attr *vrp_get_info(const ir_node *n);
+FIRM_DLL vrp_attr *vrp_get_info(const ir_node *n);
+
+#include "end.h"
#endif
projects / libfirm / commitdiff