Attachment #229033 for bug #317059

View | Details | Raw Unified | Return to bug 317059
Collapse All | Expand All

Lines 914-920 BUILD_LIBDEPS= $(BUILD_LIBIBERTY) Link Here

(-)a/gcc/Makefile.in (-1 / +4 lines)
914	# How to link with both our special library facilities	914	# How to link with both our special library facilities
915	# and the system's installed libraries.	915	# and the system's installed libraries.
916	LIBS = @LIBS@ $(CPPLIB) $(LIBINTL) $(LIBICONV) $(LIBIBERTY) $(LIBDECNUMBER)	916	LIBS = @LIBS@ $(CPPLIB) $(LIBINTL) $(LIBICONV) $(LIBIBERTY) $(LIBDECNUMBER)
917	BACKENDLIBS = $(CLOOGLIBS) $(PPLLIBS) $(GMPLIBS)	917	BACKENDLIBS = $(GMPLIBS) $(if $(CLOOGLIBS),-ldl)
918	# Any system libraries needed just for GNAT.	918	# Any system libraries needed just for GNAT.
919	SYSLIBS = @GNAT_LIBEXC@	919	SYSLIBS = @GNAT_LIBEXC@
920		920
Lines 3061-3066 $(out_object_file): $(out_file) $(CONFIG_H) coretypes.h $(TM_H) $(TREE_H) \ Link Here
3061	$(CC) -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) \	3061	$(CC) -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) \
3062	$(out_file) $(OUTPUT_OPTION)	3062	$(out_file) $(OUTPUT_OPTION)
3063		3063
		3064	graphite.o : \
		3065	ALL_CFLAGS := -O $(filter-out -fkeep-inline-functions, $(ALL_CFLAGS))
		3066
3064	# Build auxiliary files that support ecoff format.	3067	# Build auxiliary files that support ecoff format.
3065	mips-tfile: mips-tfile.o version.o $(LIBDEPS)	3068	mips-tfile: mips-tfile.o version.o $(LIBDEPS)
3066	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ mips-tfile.o version.o $(LIBS)	3069	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ mips-tfile.o version.o $(LIBS)




#include "cloog/cloog.h"
#include "graphite.h"

#include <dlfcn.h>
#define DYNSYMS \
  DYNSYM (cloog_block_alloc); \
  DYNSYM (cloog_block_list_free); \
  DYNSYM (cloog_block_list_malloc); \
  DYNSYM (cloog_clast_create); \
  DYNSYM (cloog_clast_free); \
  DYNSYM (cloog_domain_free); \
  DYNSYM (cloog_domain_matrix2domain); \
  DYNSYM (cloog_initialize); \
  DYNSYM (cloog_loop_malloc); \
  DYNSYM (cloog_matrix_alloc); \
  DYNSYM (cloog_matrix_copy); \
  DYNSYM (cloog_matrix_free); \
  DYNSYM (cloog_matrix_print); \
  DYNSYM (cloog_names_malloc); \
  DYNSYM (cloog_names_scalarize); \
  DYNSYM (cloog_options_free); \
  DYNSYM (cloog_options_malloc); \
  DYNSYM (cloog_program_dump_cloog); \
  DYNSYM (cloog_program_extract_scalars); \
  DYNSYM (cloog_program_free); \
  DYNSYM (cloog_program_generate); \
  DYNSYM (cloog_program_malloc); \
  DYNSYM (cloog_program_print); \
  DYNSYM (cloog_program_scatter); \
  DYNSYM (cloog_statement_alloc); \
  DYNSYM (ppl_finalize); \
  DYNSYM (pprint); \
  DYNSYM (stmt_block); \
  DYNSYM (stmt_for); \
  DYNSYM (stmt_guard); \
  DYNSYM (stmt_root); \
  DYNSYM (stmt_user);
static struct
{
  bool inited;
  void *h;
#define DYNSYM(x) __typeof (x) *p_##x
  DYNSYMS
#undef DYNSYM
} cloog_pointers;

#define cloog_block_alloc (*cloog_pointers.p_cloog_block_alloc)
#define cloog_block_list_free (*cloog_pointers.p_cloog_block_list_free)
#define cloog_block_list_malloc (*cloog_pointers.p_cloog_block_list_malloc)
#define cloog_clast_create (*cloog_pointers.p_cloog_clast_create)
#define cloog_clast_free (*cloog_pointers.p_cloog_clast_free)
#define cloog_domain_free (*cloog_pointers.p_cloog_domain_free)
#define cloog_domain_matrix2domain (*cloog_pointers.p_cloog_domain_matrix2domain)
#define cloog_initialize (*cloog_pointers.p_cloog_initialize)
#define cloog_loop_malloc (*cloog_pointers.p_cloog_loop_malloc)
#define cloog_matrix_alloc (*cloog_pointers.p_cloog_matrix_alloc)
#define cloog_matrix_copy (*cloog_pointers.p_cloog_matrix_copy)
#define cloog_matrix_free (*cloog_pointers.p_cloog_matrix_free)
#define cloog_matrix_print (*cloog_pointers.p_cloog_matrix_print)
#define cloog_names_malloc (*cloog_pointers.p_cloog_names_malloc)
#define cloog_names_scalarize (*cloog_pointers.p_cloog_names_scalarize)
#define cloog_options_free (*cloog_pointers.p_cloog_options_free)
#define cloog_options_malloc (*cloog_pointers.p_cloog_options_malloc)
#define cloog_program_dump_cloog (*cloog_pointers.p_cloog_program_dump_cloog)
#define cloog_program_extract_scalars (*cloog_pointers.p_cloog_program_extract_scalars)
#define cloog_program_free (*cloog_pointers.p_cloog_program_free)
#define cloog_program_generate (*cloog_pointers.p_cloog_program_generate)
#define cloog_program_malloc (*cloog_pointers.p_cloog_program_malloc)
#define cloog_program_print (*cloog_pointers.p_cloog_program_print)
#define cloog_program_scatter (*cloog_pointers.p_cloog_program_scatter)
#define cloog_statement_alloc (*cloog_pointers.p_cloog_statement_alloc)
#define ppl_finalize (*cloog_pointers.p_ppl_finalize)
#define pprint (*cloog_pointers.p_pprint)
#define stmt_block (*cloog_pointers.p_stmt_block)
#define stmt_for (*cloog_pointers.p_stmt_for)
#define stmt_guard (*cloog_pointers.p_stmt_guard)
#define stmt_root (*cloog_pointers.p_stmt_root)
#define stmt_user (*cloog_pointers.p_stmt_user)

#define cloog_finalize (*cloog_pointers.p_ppl_finalize)

static bool
init_cloog_pointers (void)
{
  void *h;

  if (cloog_pointers.inited)
    return cloog_pointers.h != NULL;
  h = dlopen ("libcloog.so.0", RTLD_LAZY);
  cloog_pointers.h = h;
  if (h == NULL)
    return false;
#define DYNSYM(x) \
  do \
    { \
      union { __typeof (cloog_pointers.p_##x) p; void *q; } u; \
      u.q = dlsym (h, #x); \
      if (u.q == NULL) \
	return false; \
      cloog_pointers.p_##x = u.p; \
    } \
  while (0)
  DYNSYMS
#undef DYNSYM
  return true;
}

static VEC (scop_p, heap) *current_scops;

/* Converts a GMP constant V to a tree and returns it.  */

   STMT.  */

static tree
gcc_type_for_iv_of_clast_loop (struct clast_for *stmt_fora)
{
  struct clast_user_stmt *stmt = clast_get_body_of_loop ((struct clast_stmt *) stmt_fora);
  const char *cloog_iv = stmt_fora->iterator;
  CloogStatement *cs = stmt->statement;
  graphite_bb_p gbb = (graphite_bb_p) cloog_statement_usr (cs);


  if (number_of_loops () <= 1)
    return;

  if (!init_cloog_pointers ())
    {
      sorry ("Graphite loop optimizations cannot be used");
      return;
    }

  current_scops = VEC_alloc (scop_p, heap, 3);
  recompute_all_dominators ();


Return to bug 317059

Lines 59-64 along with GCC; see the file COPYING3. If not see Link Here

(-)a/gcc/graphite.c (-3 / +113 lines)
59	#include "cloog/cloog.h"	59	#include "cloog/cloog.h"
60	#include "graphite.h"	60	#include "graphite.h"
61		61
		62	#include <dlfcn.h>
		63	#define DYNSYMS \
		64	DYNSYM (cloog_block_alloc); \
		65	DYNSYM (cloog_block_list_free); \
		66	DYNSYM (cloog_block_list_malloc); \
		67	DYNSYM (cloog_clast_create); \
		68	DYNSYM (cloog_clast_free); \
		69	DYNSYM (cloog_domain_free); \
		70	DYNSYM (cloog_domain_matrix2domain); \
		71	DYNSYM (cloog_initialize); \
		72	DYNSYM (cloog_loop_malloc); \
		73	DYNSYM (cloog_matrix_alloc); \
		74	DYNSYM (cloog_matrix_copy); \
		75	DYNSYM (cloog_matrix_free); \
		76	DYNSYM (cloog_matrix_print); \
		77	DYNSYM (cloog_names_malloc); \
		78	DYNSYM (cloog_names_scalarize); \
		79	DYNSYM (cloog_options_free); \
		80	DYNSYM (cloog_options_malloc); \
		81	DYNSYM (cloog_program_dump_cloog); \
		82	DYNSYM (cloog_program_extract_scalars); \
		83	DYNSYM (cloog_program_free); \
		84	DYNSYM (cloog_program_generate); \
		85	DYNSYM (cloog_program_malloc); \
		86	DYNSYM (cloog_program_print); \
		87	DYNSYM (cloog_program_scatter); \
		88	DYNSYM (cloog_statement_alloc); \
		89	DYNSYM (ppl_finalize); \
		90	DYNSYM (pprint); \
		91	DYNSYM (stmt_block); \
		92	DYNSYM (stmt_for); \
		93	DYNSYM (stmt_guard); \
		94	DYNSYM (stmt_root); \
		95	DYNSYM (stmt_user);
		96	static struct
		97	{
		98	bool inited;
		99	void *h;
		100	#define DYNSYM(x) __typeof (x) *p_##x
		101	DYNSYMS
		102	#undef DYNSYM
		103	} cloog_pointers;
		104
		105	#define cloog_block_alloc (*cloog_pointers.p_cloog_block_alloc)
		106	#define cloog_block_list_free (*cloog_pointers.p_cloog_block_list_free)
		107	#define cloog_block_list_malloc (*cloog_pointers.p_cloog_block_list_malloc)
		108	#define cloog_clast_create (*cloog_pointers.p_cloog_clast_create)
		109	#define cloog_clast_free (*cloog_pointers.p_cloog_clast_free)
		110	#define cloog_domain_free (*cloog_pointers.p_cloog_domain_free)
		111	#define cloog_domain_matrix2domain (*cloog_pointers.p_cloog_domain_matrix2domain)
		112	#define cloog_initialize (*cloog_pointers.p_cloog_initialize)
		113	#define cloog_loop_malloc (*cloog_pointers.p_cloog_loop_malloc)
		114	#define cloog_matrix_alloc (*cloog_pointers.p_cloog_matrix_alloc)
		115	#define cloog_matrix_copy (*cloog_pointers.p_cloog_matrix_copy)
		116	#define cloog_matrix_free (*cloog_pointers.p_cloog_matrix_free)
		117	#define cloog_matrix_print (*cloog_pointers.p_cloog_matrix_print)
		118	#define cloog_names_malloc (*cloog_pointers.p_cloog_names_malloc)
		119	#define cloog_names_scalarize (*cloog_pointers.p_cloog_names_scalarize)
		120	#define cloog_options_free (*cloog_pointers.p_cloog_options_free)
		121	#define cloog_options_malloc (*cloog_pointers.p_cloog_options_malloc)
		122	#define cloog_program_dump_cloog (*cloog_pointers.p_cloog_program_dump_cloog)
		123	#define cloog_program_extract_scalars (*cloog_pointers.p_cloog_program_extract_scalars)
		124	#define cloog_program_free (*cloog_pointers.p_cloog_program_free)
		125	#define cloog_program_generate (*cloog_pointers.p_cloog_program_generate)
126	#define cloog_program_malloc (*cloog_pointers.p_cloog_program_malloc)
127	#define cloog_program_print (*cloog_pointers.p_cloog_program_print)
128	#define cloog_program_scatter (*cloog_pointers.p_cloog_program_scatter)
129	#define cloog_statement_alloc (*cloog_pointers.p_cloog_statement_alloc)
130	#define ppl_finalize (*cloog_pointers.p_ppl_finalize)
131	#define pprint (*cloog_pointers.p_pprint)
132	#define stmt_block (*cloog_pointers.p_stmt_block)
133	#define stmt_for (*cloog_pointers.p_stmt_for)
134	#define stmt_guard (*cloog_pointers.p_stmt_guard)
135	#define stmt_root (*cloog_pointers.p_stmt_root)
136	#define stmt_user (*cloog_pointers.p_stmt_user)
137
138	#define cloog_finalize (*cloog_pointers.p_ppl_finalize)
139
140	static bool
141	init_cloog_pointers (void)
142	{
143	void *h;
144
145	if (cloog_pointers.inited)
146	return cloog_pointers.h != NULL;
147	h = dlopen ("libcloog.so.0", RTLD_LAZY);
148	cloog_pointers.h = h;
149	if (h == NULL)
150	return false;
151	#define DYNSYM(x) \
152	do \
153	{ \
154	union { __typeof (cloog_pointers.p_##x) p; void *q; } u; \
155	u.q = dlsym (h, #x); \
156	if (u.q == NULL) \
157	return false; \
158	cloog_pointers.p_##x = u.p; \
159	} \
160	while (0)
161	DYNSYMS
162	#undef DYNSYM
163	return true;
164	}
165
62	static VEC (scop_p, heap) *current_scops;	166	static VEC (scop_p, heap) *current_scops;
63		167
64	/* Converts a GMP constant V to a tree and returns it. */	168	/* Converts a GMP constant V to a tree and returns it. */
Lines 4075-4084 clast_get_body_of_loop (struct clast_stmt *stmt) Link Here
4075	STMT. */	4179	STMT. */
4076		4180
4077	static tree	4181	static tree
4078	gcc_type_for_iv_of_clast_loop (struct clast_for *stmt_for)	4182	gcc_type_for_iv_of_clast_loop (struct clast_for *stmt_fora)
4079	{	4183	{
4080	struct clast_user_stmt stmt = clast_get_body_of_loop ((struct clast_stmt ) stmt_for);	4184	struct clast_user_stmt stmt = clast_get_body_of_loop ((struct clast_stmt ) stmt_fora);
4081	const char *cloog_iv = stmt_for->iterator;	4185	const char *cloog_iv = stmt_fora->iterator;
4082	CloogStatement *cs = stmt->statement;	4186	CloogStatement *cs = stmt->statement;
4083	graphite_bb_p gbb = (graphite_bb_p) cloog_statement_usr (cs);	4187	graphite_bb_p gbb = (graphite_bb_p) cloog_statement_usr (cs);
4084		4188
Lines 6109-6114 graphite_transform_loops (void) Link Here
6109	if (number_of_loops () <= 1)	6213	if (number_of_loops () <= 1)
6110	return;	6214	return;
6111		6215
		6216	if (!init_cloog_pointers ())
		6217	{
		6218	sorry ("Graphite loop optimizations cannot be used");
		6219	return;
		6220	}
		6221
6112	current_scops = VEC_alloc (scop_p, heap, 3);	6222	current_scops = VEC_alloc (scop_p, heap, 3);
6113	recompute_all_dominators ();	6223	recompute_all_dominators ();
6114		6224