Add ppcg-0.04 to lib/External

[grosser]

Summary

ppcg will be used to provide mapping decisions for GPU code generation.

As we do not use C as input language, we do not include pet. However, we include
pet.h from pet 82cacb71 plus a set of dummy functions to ensure ppcg links
without problems.

The version of ppcg committed is unmodified ppcg-0.04 which has been well tested
in the context of LLVM. It does not provide an official library interface yet,
which means that in upcoming commits we will add minor modifications to make
necessary functionality accessible. We will aim to upstream these modifications
after we gained enough experience with GPU generation support in Polly to
propose a stable interface.

[Meinersbur]

lib/CMakeLists.txt

57–61 ↗

(On Diff #62823)

Simpler version:

if (GPU_CODEGEN)
  target_link_libraries(Polly PollyPPCG)
endif ()

[grosser]

Simplify cmake file

polly/trunk/lib/CMakeLists.txt

add_polly_library(Polly
   ${POLLY_JSON_FILES}
   Transform/Canonicalization.cpp
   Transform/CodePreparation.cpp
   Transform/DeadCodeElimination.cpp
   Transform/ScheduleOptimizer.cpp
   ${POLLY_HEADER_FILES}
   )
 
+if (GPU_CODEGEN)
+  target_link_libraries(Polly PollyPPCG)
+endif (GPU_CODEGEN)
+
 target_link_libraries(Polly PollyISL)
 
 if (BUILD_SHARED_LIBS)
   target_link_libraries(Polly
     LLVMSupport
     LLVMCore
     LLVMScalarOpts
     LLVMInstCombine

polly/trunk/lib/External/CMakeLists.txt

 # External: Integer Set Library
 set(ISL_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/isl")
 set(ISL_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/isl")
 
 # Determine version of isl
 if (EXISTS "${ISL_SOURCE_DIR}/GIT_HEAD_ID")
   # The source comes from a 'make dist' archive
-  file(READ "${ISL_SOURCE_DIR}/GIT_HEAD_ID" GIT_HEAD_ID)
-  string(STRIP "${GIT_HEAD_ID}" GIT_HEAD_ID)
+  file(READ "${ISL_SOURCE_DIR}/GIT_HEAD_ID" ISL_GIT_HEAD_ID)
+  string(STRIP "${ISL_GIT_HEAD_ID}" ISL_GIT_HEAD_ID)
 elseif (EXISTS "${ISL_SOURCE_DIR}/gitversion.h")
   # The source directory is preconfigured
   file(READ "${ISL_SOURCE_DIR}/gitversion.h" GITVERSION_H)
-  string(REGEX REPLACE ".*\\\"([^\\\"]*)\\\".*" "\\1" GIT_HEAD_ID "${GITVERSION_H}")
+  string(REGEX REPLACE ".*\\\"([^\\\"]*)\\\".*" "\\1" ISL_GIT_HEAD_ID "${GITVERSION_H}")
 elseif ()
   # Unknown revision
   # TODO: We could look for a .git and get the revision from HEAD
-  set(GIT_HEAD_ID "UNKNOWN")
+  set(ISL_GIT_HEAD_ID "UNKNOWN")
 endif ()
 
-message(STATUS "ISL version: ${GIT_HEAD_ID}")
+message(STATUS "ISL version: ${ISL_GIT_HEAD_ID}")
 
 # Enable small integer optimization and imath
 set(USE_GMP_FOR_MP OFF)
 set(USE_IMATH_FOR_MP ON)
 set(USE_SMALL_INT_OPT ON)
 
 # Determine compiler characteristics
 include(CheckCSourceCompiles)
elseif (HAVE_SYS_INTTYPES_H)
   set(INCLUDE_STDINT_H "#include <sys/inttypes.h>")
 else ()
   message(FATAL_ERROR "No stdint.h or compatible found")
 endif ()
 
 # Write configure result
 # configure_file(... COPYONLY) avoids that the time stamp changes if the file is identical
 file(WRITE "${ISL_BINARY_DIR}/gitversion.h.tmp"
-     "#define GIT_HEAD_ID \"${GIT_HEAD_ID}\"")
+     "#define GIT_HEAD_ID \"${ISL_GIT_HEAD_ID}\"")
 configure_file("${ISL_BINARY_DIR}/gitversion.h.tmp"
                "${ISL_BINARY_DIR}/gitversion.h" COPYONLY)
 
 file(WRITE "${ISL_BINARY_DIR}/include/isl/stdint.h.tmp"
      "${INCLUDE_STDINT_H}\n")
 configure_file("${ISL_BINARY_DIR}/include/isl/stdint.h.tmp"
                "${ISL_BINARY_DIR}/include/isl/stdint.h" COPYONLY)
 

 # could access ISL's symbols in shared library builds.
 #
 # We also disable warnings which should be coped with upstream.
 if (NOT MSVC)
   set_target_properties(PollyISL PROPERTIES
     COMPILE_FLAGS "-fvisibility=hidden -w"
   )
 endif ()
+
+set(PET_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/pet")
+set(PPCG_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ppcg")
+set(PPCG_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/ppcg")
+
+# Determine version of ppcg
+if (EXISTS "${PPCG_SOURCE_DIR}/GIT_HEAD_ID")
+  # The source comes from a 'make dist' archive
+  file(READ "${PPCG_SOURCE_DIR}/GIT_HEAD_ID" PPCG_GIT_HEAD_ID)
+  string(STRIP "${PPCG_GIT_HEAD_ID}" PPCG_GIT_HEAD_ID)
+elseif (EXISTS "${PPCG_SOURCE_DIR}/gitversion.h")
+  # The source directory is preconfigured
+  file(READ "${PPCG_SOURCE_DIR}/gitversion.h" GITVERSION_H)
+  string(REGEX REPLACE ".*\\\"([^\\\"]*)\\\".*" "\\1" PPCG_GIT_HEAD_ID "${GITVERSION_H}")
+elseif ()
+  # Unknown revision
+  # TODO: We could look for a .git and get the revision from HEAD
+  set(PPCG_GIT_HEAD_ID "UNKNOWN")
+endif ()
+
+message(STATUS "PPCG version: ${PPCG_GIT_HEAD_ID}")
+
+set (PPCG_FILES
+     ppcg/cuda.c
+     ppcg/cuda_common.c
+     ppcg/gpu_array_tile.c
+     ppcg/gpu.c
+     ppcg/gpu_group.c
+     ppcg/gpu_print.c
+     ppcg/gpu_tree.c
+     ppcg/ppcg.c
+     ppcg/ppcg_options.c
+     ppcg/schedule.c
+     ppcg/external.c
+     )
+
+include_directories(BEFORE
+  ${PPCG_BINARY_DIR}
+  ${PPCG_SOURCE_DIR}/imath
+  ${PPCG_SOURCE_DIR}/include
+  ${PET_SOURCE_DIR}/include
+)
+
+add_polly_library(PollyPPCG FORCE_STATIC
+  ${PPCG_FILES}
+)
+
+if (NOT MSVC)
+  set_target_properties(PollyPPCG PROPERTIES
+    COMPILE_FLAGS "-fvisibility=hidden -w"
+  )
+endif ()

polly/trunk/lib/External/pet/include/pet.h

+#ifndef PET_H
+#define PET_H
+
+#include <isl/aff.h>
+#include <isl/arg.h>
+#include <isl/ast_build.h>
+#include <isl/set.h>
+#include <isl/map.h>
+#include <isl/union_map.h>
+#include <isl/printer.h>
+#include <isl/id_to_ast_expr.h>
+#include <isl/id_to_pw_aff.h>
+#include <isl/schedule.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+struct pet_options;
+ISL_ARG_DECL(pet_options, struct pet_options, pet_options_args)
+
+/* If autodetect is set, any valid scop is extracted.
+ * Otherwise, the scop needs to be delimited by pragmas.
+ */
+int pet_options_set_autodetect(isl_ctx *ctx, int val);
+int pet_options_get_autodetect(isl_ctx *ctx);
+
+int pet_options_set_detect_conditional_assignment(isl_ctx *ctx, int val);
+int pet_options_get_detect_conditional_assignment(isl_ctx *ctx);
+
+/* If encapsulate-dynamic-control is set, then any dynamic control
+ * in the input program will be encapsulated in macro statements.
+ * This means in particular that no statements with arguments
+ * will be created.
+ */
+int pet_options_set_encapsulate_dynamic_control(isl_ctx *ctx, int val);
+int pet_options_get_encapsulate_dynamic_control(isl_ctx *ctx);
+
+#define PET_OVERFLOW_AVOID  0
+#define PET_OVERFLOW_IGNORE 1
+int pet_options_set_signed_overflow(isl_ctx *ctx, int val);
+int pet_options_get_signed_overflow(isl_ctx *ctx);
+
+struct pet_loc;
+typedef struct pet_loc pet_loc;
+
+/* Return an additional reference to "loc". */
+__isl_give pet_loc *pet_loc_copy(__isl_keep pet_loc *loc);
+/* Free a reference to "loc". */
+pet_loc *pet_loc_free(__isl_take pet_loc *loc);
+
+/* Return the offset in the input file of the start of "loc". */
+unsigned pet_loc_get_start(__isl_keep pet_loc *loc);
+/* Return the offset in the input file of the character after "loc". */
+unsigned pet_loc_get_end(__isl_keep pet_loc *loc);
+/* Return the line number of a line within the "loc" region. */
+int pet_loc_get_line(__isl_keep pet_loc *loc);
+/* Return the indentation of the "loc" region. */
+__isl_keep const char *pet_loc_get_indent(__isl_keep pet_loc *loc);
+
+enum pet_expr_type {
+  pet_expr_error = -1,
+  pet_expr_access,
+  pet_expr_call,
+  pet_expr_cast,
+  pet_expr_int,
+  pet_expr_double,
+  pet_expr_op
+};
+
+enum pet_op_type {
+  /* only compound assignments operators before assignment */
+  pet_op_add_assign,
+  pet_op_sub_assign,
+  pet_op_mul_assign,
+  pet_op_div_assign,
+  pet_op_assign,
+  pet_op_add,
+  pet_op_sub,
+  pet_op_mul,
+  pet_op_div,
+  pet_op_mod,
+  pet_op_shl,
+  pet_op_shr,
+  pet_op_eq,
+  pet_op_ne,
+  pet_op_le,
+  pet_op_ge,
+  pet_op_lt,
+  pet_op_gt,
+  pet_op_minus,
+  pet_op_post_inc,
+  pet_op_post_dec,
+  pet_op_pre_inc,
+  pet_op_pre_dec,
+  pet_op_address_of,
+  pet_op_assume,
+  pet_op_kill,
+  pet_op_and,
+  pet_op_xor,
+  pet_op_or,
+  pet_op_not,
+  pet_op_land,
+  pet_op_lor,
+  pet_op_lnot,
+  pet_op_cond,
+  pet_op_last
+};
+
+/* Index into the pet_expr->args array when pet_expr->type == pet_expr_unary
+ */
+enum pet_un_arg_type {
+  pet_un_arg
+};
+
+/* Indices into the pet_expr->args array when
+ * pet_expr->type == pet_expr_binary
+ */
+enum pet_bin_arg_type {
+  pet_bin_lhs,
+  pet_bin_rhs
+};
+
+/* Indices into the pet_expr->args array when
+ * pet_expr->type == pet_expr_ternary
+ */
+enum pet_ter_arg_type {
+  pet_ter_cond,
+  pet_ter_true,
+  pet_ter_false
+};
+
+struct pet_expr;
+typedef struct pet_expr pet_expr;
+
+/* Return an additional reference to "expr". */
+__isl_give pet_expr *pet_expr_copy(__isl_keep pet_expr *expr);
+/* Free a reference to "expr". */
+__isl_null pet_expr *pet_expr_free(__isl_take pet_expr *expr);
+
+/* Return the isl_ctx in which "expr" was created. */
+isl_ctx *pet_expr_get_ctx(__isl_keep pet_expr *expr);
+
+/* Return the type of "expr". */
+enum pet_expr_type pet_expr_get_type(__isl_keep pet_expr *expr);
+/* Return the number of arguments of "expr". */
+int pet_expr_get_n_arg(__isl_keep pet_expr *expr);
+/* Set the number of arguments of "expr" to "n". */
+__isl_give pet_expr *pet_expr_set_n_arg(__isl_take pet_expr *expr, int n);
+/* Return the argument of "expr" at position "pos". */
+__isl_give pet_expr *pet_expr_get_arg(__isl_keep pet_expr *expr, int pos);
+/* Replace the argument of "expr" at position "pos" by "arg". */
+__isl_give pet_expr *pet_expr_set_arg(__isl_take pet_expr *expr, int pos,
+  __isl_take pet_expr *arg);
+
+/* Return the operation type of operation expression "expr". */
+enum pet_op_type pet_expr_op_get_type(__isl_keep pet_expr *expr);
+/* Replace the operation type of operation expression "expr" by "type". */
+__isl_give pet_expr *pet_expr_op_set_type(__isl_take pet_expr *expr,
+  enum pet_op_type type);
+
+/* Construct a (read) access pet_expr from an index expression. */
+__isl_give pet_expr *pet_expr_from_index(__isl_take isl_multi_pw_aff *index);
+
+/* Does "expr" represent an affine expression? */
+int pet_expr_is_affine(__isl_keep pet_expr *expr);
+/* Does the access expression "expr" read the accessed elements? */
+int pet_expr_access_is_read(__isl_keep pet_expr *expr);
+/* Does the access expression "expr" write to the accessed elements? */
+int pet_expr_access_is_write(__isl_keep pet_expr *expr);
+/* Mark "expr" as a read dependening on "read". */
+__isl_give pet_expr *pet_expr_access_set_read(__isl_take pet_expr *expr,
+  int read);
+/* Mark "expr" as a write dependening on "write". */
+__isl_give pet_expr *pet_expr_access_set_write(__isl_take pet_expr *expr,
+  int write);
+/* Mark "expr" as a kill dependening on "kill". */
+__isl_give pet_expr *pet_expr_access_set_kill(__isl_take pet_expr *expr,
+  int kill);
+/* Return the reference identifier of access expression "expr". */
+__isl_give isl_id *pet_expr_access_get_ref_id(__isl_keep pet_expr *expr);
+/* Replace the reference identifier of access expression "expr" by "ref_id". */
+__isl_give pet_expr *pet_expr_access_set_ref_id(__isl_take pet_expr *expr,
+  __isl_take isl_id *ref_id);
+/* Return the identifier of the outer array accessed by "expr". */
+__isl_give isl_id *pet_expr_access_get_id(__isl_keep pet_expr *expr);
+/* Return the index expression of access expression "expr". */
+__isl_give isl_multi_pw_aff *pet_expr_access_get_index(
+  __isl_keep pet_expr *expr);
+
+/* Return the potential read access relation of access expression "expr". */
+__isl_give isl_union_map *pet_expr_access_get_may_read(
+  __isl_keep pet_expr *expr);
+/* Return the potential write access relation of access expression "expr". */
+__isl_give isl_union_map *pet_expr_access_get_may_write(
+  __isl_keep pet_expr *expr);
+/* Return the definite write access relation of access expression "expr". */
+__isl_give isl_union_map *pet_expr_access_get_must_write(
+  __isl_keep pet_expr *expr);
+/* Return the argument dependent potential read access relation of "expr". */
+__isl_give isl_union_map *pet_expr_access_get_dependent_may_read(
+  __isl_keep pet_expr *expr);
+/* Return the argument dependent potential write access relation of "expr". */
+__isl_give isl_union_map *pet_expr_access_get_dependent_may_write(
+  __isl_keep pet_expr *expr);
+/* Return the argument dependent definite write access relation of "expr". */
+__isl_give isl_union_map *pet_expr_access_get_dependent_must_write(
+  __isl_keep pet_expr *expr);
+/* Return the tagged potential read access relation of access "expr". */
+__isl_give isl_union_map *pet_expr_access_get_tagged_may_read(
+  __isl_keep pet_expr *expr);
+/* Return the tagged potential write access relation of access "expr". */
+__isl_give isl_union_map *pet_expr_access_get_tagged_may_write(
+  __isl_keep pet_expr *expr);
+
+/* Return the name of the function called by "expr". */
+__isl_keep const char *pet_expr_call_get_name(__isl_keep pet_expr *expr);
+/* Replace the name of the function called by "expr" by "name". */
+__isl_give pet_expr *pet_expr_call_set_name(__isl_take pet_expr *expr,
+  __isl_keep const char *name);
+
+/* Create a pet_expr representing a cast of "arg" to "type_name". */
+__isl_give pet_expr *pet_expr_new_cast(const char *type_name,
+  __isl_take pet_expr *arg);
+/* Replace the type of the cast performed by "expr" by "name". */
+__isl_give pet_expr *pet_expr_cast_set_type_name(__isl_take pet_expr *expr,
+  __isl_keep const char *name);
+
+/* Return the value of the integer represented by "expr". */
+__isl_give isl_val *pet_expr_int_get_val(__isl_keep pet_expr *expr);
+/* Replace the value of the integer represented by "expr" by "v". */
+__isl_give pet_expr *pet_expr_int_set_val(__isl_take pet_expr *expr,
+  __isl_take isl_val *v);
+
+/* Return a string representation of the double expression "expr". */
+__isl_give char *pet_expr_double_get_str(__isl_keep pet_expr *expr);
+/* Replace value and string representation of the double expression "expr" */
+__isl_give pet_expr *pet_expr_double_set(__isl_take pet_expr *expr,
+  double d, __isl_keep const char *s);
+
+/* Call "fn" on each of the subexpressions of "expr" of type pet_expr_access. */
+int pet_expr_foreach_access_expr(__isl_keep pet_expr *expr,
+  int (*fn)(__isl_keep pet_expr *expr, void *user), void *user);
+/* Call "fn" on each of the subexpressions of "expr" of type pet_expr_call. */
+int pet_expr_foreach_call_expr(__isl_keep pet_expr *expr,
+  int (*fn)(__isl_keep pet_expr *expr, void *user), void *user);
+
+struct pet_context;
+typedef struct pet_context pet_context;
+
+/* Create a context with the given domain. */
+__isl_give pet_context *pet_context_alloc(__isl_take isl_set *domain);
+/* Return an additional reference to "pc". */
+__isl_give pet_context *pet_context_copy(__isl_keep pet_context *pc);
+/* Free a reference to "pc". */
+__isl_null pet_context *pet_context_free(__isl_take pet_context *pc);
+
+/* Return the isl_ctx in which "pc" was created. */
+isl_ctx *pet_context_get_ctx(__isl_keep pet_context *pc);
+
+/* Extract an affine expression defined over the domain of "pc" from "expr"
+ * or return NaN.
+ */
+__isl_give isl_pw_aff *pet_expr_extract_affine(__isl_keep pet_expr *expr,
+  __isl_keep pet_context *pc);
+
+void pet_expr_dump(__isl_keep pet_expr *expr);
+
+enum pet_tree_type {
+  pet_tree_error = -1,
+  pet_tree_expr,
+  pet_tree_block,
+  pet_tree_break,
+  pet_tree_continue,
+  pet_tree_decl,    /* A declaration without initialization */
+  pet_tree_decl_init, /* A declaration with initialization */
+  pet_tree_if,    /* An if without an else branch */
+  pet_tree_if_else, /* An if with an else branch */
+  pet_tree_for,
+  pet_tree_infinite_loop,
+  pet_tree_while
+};
+
+struct pet_tree;
+typedef struct pet_tree pet_tree;
+
+/* Return the isl_ctx in which "tree" was created. */
+isl_ctx *pet_tree_get_ctx(__isl_keep pet_tree *tree);
+
+/* Return an additional reference to "tree". */
+__isl_give pet_tree *pet_tree_copy(__isl_keep pet_tree *tree);
+/* Free a reference to "tree". */
+__isl_null pet_tree *pet_tree_free(__isl_take pet_tree *tree);
+
+/* Return the location of "tree". */
+__isl_give pet_loc *pet_tree_get_loc(__isl_keep pet_tree *tree);
+
+/* Return the type of "tree". */
+enum pet_tree_type pet_tree_get_type(__isl_keep pet_tree *tree);
+
+/* Return the expression of the expression tree "tree". */
+__isl_give pet_expr *pet_tree_expr_get_expr(__isl_keep pet_tree *tree);
+
+/* Return the number of children of the block tree "tree". */
+int pet_tree_block_n_child(__isl_keep pet_tree *tree);
+/* Return child "pos" of the block tree "tree". */
+__isl_give pet_tree *pet_tree_block_get_child(__isl_keep pet_tree *tree,
+  int pos);
+
+/* Is "tree" a declaration (with or without initialization)? */
+int pet_tree_is_decl(__isl_keep pet_tree *tree);
+/* Return the variable declared by the declaration tree "tree". */
+__isl_give pet_expr *pet_tree_decl_get_var(__isl_keep pet_tree *tree);
+/* Return the initial value of the pet_tree_decl_init tree "tree". */
+__isl_give pet_expr *pet_tree_decl_get_init(__isl_keep pet_tree *tree);
+
+/* Return the condition of the if tree "tree". */
+__isl_give pet_expr *pet_tree_if_get_cond(__isl_keep pet_tree *tree);
+/* Return the then branch of the if tree "tree". */
+__isl_give pet_tree *pet_tree_if_get_then(__isl_keep pet_tree *tree);
+/* Return the else branch of the if tree with else branch "tree". */
+__isl_give pet_tree *pet_tree_if_get_else(__isl_keep pet_tree *tree);
+
+/* Is "tree" a for loop, a while loop or an infinite loop? */
+int pet_tree_is_loop(__isl_keep pet_tree *tree);
+/* Return the induction variable of the for loop "tree" */
+__isl_give pet_expr *pet_tree_loop_get_var(__isl_keep pet_tree *tree);
+/* Return the initial value of the induction variable of the for loop "tree" */
+__isl_give pet_expr *pet_tree_loop_get_init(__isl_keep pet_tree *tree);
+/* Return the condition of the loop tree "tree" */
+__isl_give pet_expr *pet_tree_loop_get_cond(__isl_keep pet_tree *tree);
+/* Return the induction variable of the for loop "tree" */
+__isl_give pet_expr *pet_tree_loop_get_inc(__isl_keep pet_tree *tree);
+/* Return the body of the loop tree "tree" */
+__isl_give pet_tree *pet_tree_loop_get_body(__isl_keep pet_tree *tree);
+
+/* Call "fn" on each top-level expression in the nodes of "tree" */
+int pet_tree_foreach_expr(__isl_keep pet_tree *tree,
+  int (*fn)(__isl_keep pet_expr *expr, void *user), void *user);
+/* Call "fn" on each access subexpression in the nodes of "tree" */
+int pet_tree_foreach_access_expr(__isl_keep pet_tree *tree,
+  int (*fn)(__isl_keep pet_expr *expr, void *user), void *user);
+/* Modify all call subexpressions in the nodes of "tree" through "fn". */
+__isl_give pet_tree *pet_tree_map_call_expr(__isl_take pet_tree *tree,
+  __isl_give pet_expr *(*fn)(__isl_take pet_expr *expr, void *user),
+  void *user);
+
+void pet_tree_dump(__isl_keep pet_tree *tree);
+
+/* "loc" represents the region of the source code that is represented
+ * by this statement.
+ *
+ * If the statement has arguments, i.e., n_arg != 0, then
+ * "domain" is a wrapped map, mapping the iteration domain
+ * to the values of the arguments for which this statement
+ * is executed.
+ * Otherwise, it is simply the iteration domain.
+ *
+ * If one of the arguments is an access expression that accesses
+ * more than one element for a given iteration, then the constraints
+ * on the value of this argument (encoded in "domain") should be satisfied
+ * for all of those accessed elements.
+ */
+struct pet_stmt {
+  pet_loc *loc;
+  isl_set *domain;
+  pet_tree *body;
+
+  unsigned n_arg;
+  pet_expr **args;
+};
+
+/* Return the iteration space of "stmt". */
+__isl_give isl_space *pet_stmt_get_space(struct pet_stmt *stmt);
+
+/* Is "stmt" an assignment statement? */
+int pet_stmt_is_assign(struct pet_stmt *stmt);
+/* Is "stmt" a kill statement? */
+int pet_stmt_is_kill(struct pet_stmt *stmt);
+
+/* pet_stmt_build_ast_exprs is currently limited to only handle
+ * some forms of data dependent accesses.
+ * If pet_stmt_can_build_ast_exprs returns 1, then pet_stmt_build_ast_exprs
+ * can safely be called on "stmt".
+ */
+int pet_stmt_can_build_ast_exprs(struct pet_stmt *stmt);
+/* Construct an associative array from reference identifiers of
+ * access expressions in "stmt" to the corresponding isl_ast_expr.
+ * Each index expression is first transformed through "fn_index"
+ * (if not NULL).  Then an AST expression is generated using "build".
+ * Finally, the AST expression is transformed using "fn_expr"
+ * (if not NULL).
+ */
+__isl_give isl_id_to_ast_expr *pet_stmt_build_ast_exprs(struct pet_stmt *stmt,
+  __isl_keep isl_ast_build *build,
+  __isl_give isl_multi_pw_aff *(*fn_index)(
+    __isl_take isl_multi_pw_aff *mpa, __isl_keep isl_id *id,
+    void *user), void *user_index,
+  __isl_give isl_ast_expr *(*fn_expr)(__isl_take isl_ast_expr *expr,
+    __isl_keep isl_id *id, void *user), void *user_expr);
+
+/* Print "stmt" to "p".
+ *
+ * The access expressions in "stmt" are replaced by the isl_ast_expr
+ * associated to its reference identifier in "ref2expr".
+ */
+__isl_give isl_printer *pet_stmt_print_body(struct pet_stmt *stmt,
+  __isl_take isl_printer *p, __isl_keep isl_id_to_ast_expr *ref2expr);
+
+/* This structure represents a defined type.
+ * "name" is the name of the type, while "definition" is a string
+ * representation of its definition.
+ */
+struct pet_type {
+  char *name;
+  char *definition;
+};
+
+/* context holds constraints on the parameter that ensure that
+ * this array has a valid (i.e., non-negative) size
+ *
+ * extent holds constraints on the indices
+ * 
+ * value_bounds holds constraints on the elements of the array
+ * and may be NULL if no such constraints were specified by the user
+ *
+ * element_size is the size in bytes of each array element
+ * element_type is the type of the array elements.
+ * element_is_record is set if this type is a record type.
+ *
+ * live_out is set if the array appears in a live-out pragma
+ *
+ * if uniquely_defined is set then the array is written by a single access
+ * such that any element that is ever read
+ * is known to be assigned exactly once before the read
+ *
+ * declared is set if the array was declared somewhere inside the scop.
+ * exposed is set if the declared array is visible outside the scop.
+ */
+struct pet_array {
+  isl_set *context;
+  isl_set *extent;
+  isl_set *value_bounds;
+  char *element_type;
+  int element_is_record;
+  int element_size;
+  int live_out;
+  int uniquely_defined;
+  int declared;
+  int exposed;
+};
+
+/* This structure represents an implication on a boolean filter.
+ * In particular, if the filter value of an element in the domain
+ * of "extension" is equal to "satisfied", then the filter values
+ * of the corresponding images in "extension" are also equal
+ * to "satisfied".
+ */
+struct pet_implication {
+  int satisfied;
+  isl_map *extension;
+};
+
+/* This structure represents an independence implied by a for loop
+ * that is marked as independent in the source code.
+ * "filter" contains pairs of statement instances that are guaranteed
+ * not to be dependent on each other based on the independent for loop,
+ * assuming that no dependences carried by this loop are implied
+ * by the variables in "local".
+ * "local" contains the variables that are local to the loop that was
+ * marked independent.
+ */
+struct pet_independence {
+  isl_union_map *filter;
+  isl_union_set *local;
+};
+
+/* "loc" represents the region of the source code that is represented
+ * by this scop.
+ * If the scop was detected based on scop and endscop pragmas, then
+ * the lines containing these pragmas are included in this region.
+ * In the final result, the context describes the set of parameter values
+ * for which the scop can be executed.
+ * During the construction of the pet_scop, the context lives in a set space
+ * where each dimension refers to an outer loop.
+ * context_value describes assignments to the parameters (if any)
+ * outside of the scop.
+ *
+ * "schedule" is the schedule of the statements in the scop.
+ *
+ * The n_type types define types that may be referenced from by the arrays.
+ *
+ * The n_implication implications describe implications on boolean filters.
+ *
+ * The n_independence independences describe independences implied
+ * by for loops that are marked independent in the source code.
+ */
+struct pet_scop {
+  pet_loc *loc;
+
+  isl_set *context;
+  isl_set *context_value;
+  isl_schedule *schedule;
+
+  int n_type;
+  struct pet_type **types;
+
+  int n_array;
+  struct pet_array **arrays;
+
+  int n_stmt;
+  struct pet_stmt **stmts;
+
+  int n_implication;
+  struct pet_implication **implications;
+
+  int n_independence;
+  struct pet_independence **independences;
+};
+
+/* Return a textual representation of the operator. */
+const char *pet_op_str(enum pet_op_type op);
+int pet_op_is_inc_dec(enum pet_op_type op);
+
+/* Extract a pet_scop from a C source file.
+ * If function is not NULL, then the pet_scop is extracted from
+ * a function with that name.
+ */
+struct pet_scop *pet_scop_extract_from_C_source(isl_ctx *ctx,
+  const char *filename, const char *function);
+
+/* Transform the C source file "input" by rewriting each scop
+ * When autodetecting scops, at most one scop per function is rewritten.
+ * The transformed C code is written to "output".
+ */
+int pet_transform_C_source(isl_ctx *ctx, const char *input, FILE *output,
+  __isl_give isl_printer *(*transform)(__isl_take isl_printer *p,
+    struct pet_scop *scop, void *user), void *user);
+/* Given a scop and a printer passed to a pet_transform_C_source callback,
+ * print the original corresponding code to the printer.
+ */
+__isl_give isl_printer *pet_scop_print_original(struct pet_scop *scop,
+  __isl_take isl_printer *p);
+
+/* Update all isl_sets and isl_maps such that they all have the same
+ * parameters in the same order.
+ */
+struct pet_scop *pet_scop_align_params(struct pet_scop *scop);
+
+/* Does "scop" contain any data dependent accesses? */
+int pet_scop_has_data_dependent_accesses(struct pet_scop *scop);
+/* Does "scop" contain any data dependent conditions? */
+int pet_scop_has_data_dependent_conditions(struct pet_scop *scop);
+/* pet_stmt_build_ast_exprs is currently limited to only handle
+ * some forms of data dependent accesses.
+ * If pet_scop_can_build_ast_exprs returns 1, then pet_stmt_build_ast_exprs
+ * can safely be called on all statements in the scop.
+ */
+int pet_scop_can_build_ast_exprs(struct pet_scop *scop);
+
+void pet_scop_dump(struct pet_scop *scop);
+struct pet_scop *pet_scop_free(struct pet_scop *scop);
+
+__isl_give isl_union_set *pet_scop_collect_domains(struct pet_scop *scop);
+/* Collect all potential read access relations. */
+__isl_give isl_union_map *pet_scop_collect_may_reads(struct pet_scop *scop);
+/* Collect all tagged potential read access relations. */
+__isl_give isl_union_map *pet_scop_collect_tagged_may_reads(
+  struct pet_scop *scop);
+/* Collect all potential write access relations. */
+__isl_give isl_union_map *pet_scop_collect_may_writes(struct pet_scop *scop);
+/* Collect all definite write access relations. */
+__isl_give isl_union_map *pet_scop_collect_must_writes(struct pet_scop *scop);
+/* Collect all tagged potential write access relations. */
+__isl_give isl_union_map *pet_scop_collect_tagged_may_writes(
+  struct pet_scop *scop);
+/* Collect all tagged definite write access relations. */
+__isl_give isl_union_map *pet_scop_collect_tagged_must_writes(
+  struct pet_scop *scop);
+/* Collect all definite kill access relations. */
+__isl_give isl_union_map *pet_scop_collect_must_kills(struct pet_scop *scop);
+/* Collect all tagged definite kill access relations. */
+__isl_give isl_union_map *pet_scop_collect_tagged_must_kills(
+  struct pet_scop *scop);
+
+/* Compute a mapping from all outermost arrays (of structs) in scop
+ * to their innermost members.
+ */
+__isl_give isl_union_map *pet_scop_compute_outer_to_inner(
+  struct pet_scop *scop);
+/* Compute a mapping from all outermost arrays (of structs) in scop
+ * to their members, including the outermost arrays themselves.
+ */
+__isl_give isl_union_map *pet_scop_compute_outer_to_any(struct pet_scop *scop);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

polly/trunk/lib/External/ppcg/ChangeLog

+version: 0.04
+date: Wed Jun 17 10:52:58 CEST 2015
+changes:
+  - use schedule trees
+  - fix live-range reordering
+  - improve generation of synchronization
+  - exploit independences during dependence analysis

polly/trunk/lib/External/ppcg/GIT_HEAD_ID

+ppcg-0.04

polly/trunk/lib/External/ppcg/Makefile.am

+if BUNDLED_ISL
+    MAYBE_ISL = isl
+    ISL_LA = $(top_builddir)/isl/libisl.la
+    LOCAL_ISL_LA = isl/libisl.la
+endif
+if BUNDLED_PET
+    MAYBE_PET = pet
+    PET_LA = $(top_builddir)/pet/libpet.la
+endif
+
+SUBDIRS = $(MAYBE_ISL) $(MAYBE_PET) .
+
+FORCE:
+isl/libisl.la: FORCE
+  cd isl; $(MAKE) $(AM_MAKEFLAGS) libisl.la
+pet/libpet.la: FORCE
+  cd pet; $(MAKE) $(AM_MAKEFLAGS) libpet.la
+
+ACLOCAL_AMFLAGS = -I m4
+
+LIB_ISL = $(ISL_LA) @ISL_LIBS@
+LIB_PET = $(PET_LA) @PET_LIBS@
+
+AM_CPPFLAGS = @ISL_CFLAGS@ @PET_CFLAGS@
+LDADD = $(LIB_PET) $(LIB_ISL)
+
+bin_PROGRAMS = ppcg
+ppcg_SOURCES = \
+  cpu.c \
+  cpu.h \
+  cuda.c \
+  cuda.h \
+  opencl.c \
+  opencl.h \
+  cuda_common.h \
+  cuda_common.c \
+  gpu.c \
+  gpu.h \
+  gpu_array_tile.c \
+  gpu_array_tile.h \
+  gpu_group.c \
+  gpu_group.h \
+  gpu_print.c \
+  gpu_print.h \
+  gpu_tree.c \
+  gpu_tree.h \
+  schedule.c \
+  schedule.h \
+  ppcg_options.c \
+  ppcg_options.h \
+  ppcg.c \
+  ppcg.h \
+  print.c \
+  print.h \
+  util.h \
+  version.c
+
+TESTS = @extra_tests@
+EXTRA_TESTS = opencl_test.sh polybench_test.sh
+TEST_EXTENSIONS = .sh
+
+EXTRA_DIST = \
+  ocl_utilities.c \
+  ocl_utilities.h \
+  tests
+
+dist-hook:
+  echo @GIT_HEAD_VERSION@ > $(distdir)/GIT_HEAD_ID
+
+gitversion.h: @GIT_HEAD@
+  $(AM_V_GEN)echo '#define GIT_HEAD_ID "'@GIT_HEAD_VERSION@'"' > $@

polly/trunk/lib/External/ppcg/Makefile.in

+# Makefile.in generated by automake 1.15 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2014 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
+am__make_running_with_option = \
+  case $${target_option-} in \
+      ?) ;; \
+      *) echo "am__make_running_with_option: internal error: invalid" \
+              "target option '$${target_option-}' specified" >&2; \
+         exit 1;; \
+  esac; \
+  has_opt=no; \
+  sane_makeflags=$$MAKEFLAGS; \
+  if $(am__is_gnu_make); then \
+    sane_makeflags=$$MFLAGS; \
+  else \
+    case $$MAKEFLAGS in \
+      *\\[\ \ ]*) \
+        bs=\\; \
+        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+          | sed "s/$$bs$$bs[$$bs $$bs  ]*//g"`;; \
+    esac; \
+  fi; \
+  skip_next=no; \
+  strip_trailopt () \
+  { \
+    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+  }; \
+  for flg in $$sane_makeflags; do \
+    test $$skip_next = yes && { skip_next=no; continue; }; \
+    case $$flg in \
+      *=*|--*) continue;; \
+        -*I) strip_trailopt 'I'; skip_next=yes;; \
+      -*I?*) strip_trailopt 'I';; \
+        -*O) strip_trailopt 'O'; skip_next=yes;; \
+      -*O?*) strip_trailopt 'O';; \
+        -*l) strip_trailopt 'l'; skip_next=yes;; \
+      -*l?*) strip_trailopt 'l';; \
+      -[dEDm]) skip_next=yes;; \
+      -[JT]) skip_next=yes;; \
+    esac; \
+    case $$flg in \
+      *$$target_option*) has_opt=yes; break;; \
+    esac; \
+  done; \
+  test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+bin_PROGRAMS = ppcg$(EXEEXT)
+subdir = .
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ax_check_opencl.m4 \
+  $(top_srcdir)/m4/ax_check_openmp.m4 \
+  $(top_srcdir)/m4/ax_detect_git_head.m4 \
+  $(top_srcdir)/m4/ax_submodule.m4 $(top_srcdir)/m4/libtool.m4 \
+  $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
+  $(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
+  $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+  $(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \
+  $(am__configure_deps) $(am__DIST_COMMON)
+am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
+ configure.lineno config.status.lineno
+mkinstalldirs = $(install_sh) -d
+CONFIG_CLEAN_FILES = polybench_test.sh opencl_test.sh
+CONFIG_CLEAN_VPATH_FILES =
+am__installdirs = "$(DESTDIR)$(bindir)"
+PROGRAMS = $(bin_PROGRAMS)
+am_ppcg_OBJECTS = cpu.$(OBJEXT) cuda.$(OBJEXT) opencl.$(OBJEXT) \
+  cuda_common.$(OBJEXT) gpu.$(OBJEXT) gpu_array_tile.$(OBJEXT) \
+  gpu_group.$(OBJEXT) gpu_print.$(OBJEXT) gpu_tree.$(OBJEXT) \
+  schedule.$(OBJEXT) ppcg_options.$(OBJEXT) ppcg.$(OBJEXT) \
+  print.$(OBJEXT) version.$(OBJEXT)
+ppcg_OBJECTS = $(am_ppcg_OBJECTS)
+ppcg_LDADD = $(LDADD)
+am__DEPENDENCIES_1 = $(PET_LA)
+am__DEPENDENCIES_2 = $(ISL_LA)
+ppcg_DEPENDENCIES = $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_2)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 = 
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 = 
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 = 
+DEFAULT_INCLUDES = -I.@am__isrc@
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+  $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+  $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
+  $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+  $(AM_CFLAGS) $(CFLAGS)
+AM_V_CC = $(am__v_CC_@AM_V@)
+am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
+am__v_CC_0 = @echo "  CC      " $@;
+am__v_CC_1 = 
+CCLD = $(CC)
+LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+  $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+  $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CCLD = $(am__v_CCLD_@AM_V@)
+am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
+am__v_CCLD_0 = @echo "  CCLD    " $@;
+am__v_CCLD_1 = 
+SOURCES = $(ppcg_SOURCES)
+DIST_SOURCES = $(ppcg_SOURCES)
+RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
+  ctags-recursive dvi-recursive html-recursive info-recursive \
+  install-data-recursive install-dvi-recursive \
+  install-exec-recursive install-html-recursive \
+  install-info-recursive install-pdf-recursive \
+  install-ps-recursive install-recursive installcheck-recursive \
+  installdirs-recursive pdf-recursive ps-recursive \
+  tags-recursive uninstall-recursive
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \
+  distclean-recursive maintainer-clean-recursive
+am__recursive_targets = \
+  $(RECURSIVE_TARGETS) \
+  $(RECURSIVE_CLEAN_TARGETS) \
+  $(am__extra_recursive_targets)
+AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
+  cscope check recheck distdir dist dist-all distcheck
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates.  Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+  BEGIN { nonempty = 0; } \
+  { items[$$0] = 1; nonempty = 1; } \
+  END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique.  This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+  list='$(am__tagged_files)'; \
+  unique=`for i in $$list; do \
+    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+  done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+CSCOPE = cscope
+am__tty_colors_dummy = \
+  mgn= red= grn= lgn= blu= brg= std=; \
+  am__color_tests=no
+am__tty_colors = { \
+  $(am__tty_colors_dummy); \
+  if test "X$(AM_COLOR_TESTS)" = Xno; then \
+    am__color_tests=no; \
+  elif test "X$(AM_COLOR_TESTS)" = Xalways; then \
+    am__color_tests=yes; \
+  elif test "X$$TERM" != Xdumb && { test -t 1; } 2>/dev/null; then \
+    am__color_tests=yes; \
+  fi; \
+  if test $$am__color_tests = yes; then \
+    red='␛[0;31m'; \
+    grn='␛[0;32m'; \
+    lgn='␛[1;32m'; \
+    blu='␛[1;34m'; \
+    mgn='␛[0;35m'; \
+    brg='␛[1m'; \
+    std='␛[m'; \
+  fi; \
+}
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+  test -z "$$files" \
+    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+         $(am__cd) "$$dir" && rm -f $$files; }; \
+  }
+am__recheck_rx = ^[   ]*:recheck:[  ]*
+am__global_test_result_rx = ^[  ]*:global-test-result:[   ]*
+am__copy_in_global_log_rx = ^[  ]*:copy-in-global-log:[   ]*
+# A command that, given a newline-separated list of test names on the
+# standard input, print the name of the tests that are to be re-run
+# upon "make recheck".
+am__list_recheck_tests = $(AWK) '{ \
+  recheck = 1; \
+  while ((rc = (getline line < ($$0 ".trs"))) != 0) \
+    { \
+      if (rc < 0) \
+        { \
+          if ((getline line2 < ($$0 ".log")) < 0) \
+      recheck = 0; \
+          break; \
+        } \
+      else if (line ~ /$(am__recheck_rx)[nN][Oo]/) \
+        { \
+          recheck = 0; \
+          break; \
+        } \
+      else if (line ~ /$(am__recheck_rx)[yY][eE][sS]/) \
+        { \
+          break; \
+        } \
+    }; \
+  if (recheck) \
+    print $$0; \
+  close ($$0 ".trs"); \
+  close ($$0 ".log"); \
+}'
+# A command that, given a newline-separated list of test names on the
+# standard input, create the global log from their .trs and .log files.
+am__create_global_log = $(AWK) ' \
+function fatal(msg) \
+{ \
+  print "fatal: making $@: " msg | "cat >&2"; \
+  exit 1; \
+} \
+function rst_section(header) \
+{ \
+  print header; \
+  len = length(header); \
+  for (i = 1; i <= len; i = i + 1) \
+    printf "="; \
+  printf "\n\n"; \
+} \
+{ \
+  copy_in_global_log = 1; \
+  global_test_result = "RUN"; \
+  while ((rc = (getline line < ($$0 ".trs"))) != 0) \
+    { \
+      if (rc < 0) \
+         fatal("failed to read from " $$0 ".trs"); \
+      if (line ~ /$(am__global_test_result_rx)/) \
+        { \
+          sub("$(am__global_test_result_rx)", "", line); \
+          sub("[   ]*$$", "", line); \
+          global_test_result = line; \
+        } \
+      else if (line ~ /$(am__copy_in_global_log_rx)[nN][oO]/) \
+        copy_in_global_log = 0; \
+    }; \
+  if (copy_in_global_log) \
+    { \
+      rst_section(global_test_result ": " $$0); \
+      while ((rc = (getline line < ($$0 ".log"))) != 0) \
+      { \
+        if (rc < 0) \
+          fatal("failed to read from " $$0 ".log"); \
+        print line; \
+      }; \
+      printf "\n"; \
+    }; \
+  close ($$0 ".trs"); \
+  close ($$0 ".log"); \
+}'
+# Restructured Text title.
+am__rst_title = { sed 's/.*/   &   /;h;s/./=/g;p;x;s/ *$$//;p;g' && echo; }
+# Solaris 10 'make', and several other traditional 'make' implementations,
+# pass "-e" to $(SHELL), and POSIX 2008 even requires this.  Work around it
+# by disabling -e (using the XSI extension "set +e") if it's set.
+am__sh_e_setup = case $$- in *e*) set +e;; esac
+# Default flags passed to test drivers.
+am__common_driver_flags = \
+  --color-tests "$$am__color_tests" \
+  --enable-hard-errors "$$am__enable_hard_errors" \
+  --expect-failure "$$am__expect_failure"
+# To be inserted before the command running the test.  Creates the
+# directory for the log if needed.  Stores in $dir the directory
+# containing $f, in $tst the test, in $log the log.  Executes the
+# developer- defined test setup AM_TESTS_ENVIRONMENT (if any), and
+# passes TESTS_ENVIRONMENT.  Set up options for the wrapper that
+# will run the test scripts (or their associated LOG_COMPILER, if
+# thy have one).
+am__check_pre = \
+$(am__sh_e_setup);          \
+$(am__vpath_adj_setup) $(am__vpath_adj)     \
+$(am__tty_colors);          \
+srcdir=$(srcdir); export srcdir;      \
+case "$@" in            \
+  */*) am__odir=`echo "./$@" | sed 's|/[^/]*$$||'`;;  \
+    *) am__odir=.;;           \
+esac;             \
+test "x$$am__odir" = x"." || test -d "$$am__odir"   \
+  || $(MKDIR_P) "$$am__odir" || exit $$?;   \
+if test -f "./$$f"; then dir=./;      \
+elif test -f "$$f"; then dir=;        \
+else dir="$(srcdir)/"; fi;        \
+tst=$$dir$$f; log='$@';         \
+if test -n '$(DISABLE_HARD_ERRORS)'; then   \
+  am__enable_hard_errors=no;        \
+else              \
+  am__enable_hard_errors=yes;         \
+fi;               \
+case " $(XFAIL_TESTS) " in        \
+  *[\ \ ]$$f[\ \  ]* | *[\ \  ]$$dir$$f[\ \ ]*) \
+    am__expect_failure=yes;;        \
+  *)              \
+    am__expect_failure=no;;       \
+esac;               \
+$(AM_TESTS_ENVIRONMENT) $(TESTS_ENVIRONMENT)
+# A shell command to get the names of the tests scripts with any registered
+# extension removed (i.e., equivalently, the names of the test logs, with
+# the '.log' extension removed).  The result is saved in the shell variable
+# '$bases'.  This honors runtime overriding of TESTS and TEST_LOGS.  Sadly,
+# we cannot use something simpler, involving e.g., "$(TEST_LOGS:.log=)",
+# since that might cause problem with VPATH rewrites for suffix-less tests.
+# See also 'test-harness-vpath-rewrite.sh' and 'test-trs-basic.sh'.
+am__set_TESTS_bases = \
+  bases='$(TEST_LOGS)'; \
+  bases=`for i in $$bases; do echo $$i; done | sed 's/\.log$$//'`; \
+  bases=`echo $$bases`
+RECHECK_LOGS = $(TEST_LOGS)
+TEST_SUITE_LOG = test-suite.log
+am__test_logs1 = $(TESTS:=.log)
+am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log)
+TEST_LOGS = $(am__test_logs2:.sh.log=.log)
+SH_LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver
+SH_LOG_COMPILE = $(SH_LOG_COMPILER) $(AM_SH_LOG_FLAGS) $(SH_LOG_FLAGS)
+am__set_b = \
+  case '$@' in \
+    */*) \
+      case '$*' in \
+        */*) b='$*';; \
+          *) b=`echo '$@' | sed 's/\.log$$//'`; \
+       esac;; \
+    *) \
+      b='$*';; \
+  esac
+DIST_SUBDIRS = isl pet .
+am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/opencl_test.sh.in \
+  $(srcdir)/polybench_test.sh.in ChangeLog README compile \
+  config.guess config.sub depcomp install-sh ltmain.sh missing \
+  test-driver
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+distdir = $(PACKAGE)-$(VERSION)
+top_distdir = $(distdir)
+am__remove_distdir = \
+  if test -d "$(distdir)"; then \
+    find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \
+      && rm -rf "$(distdir)" \
+      || { sleep 5 && rm -rf "$(distdir)"; }; \
+  else :; fi
+am__post_remove_distdir = $(am__remove_distdir)
+am__relativize = \
+  dir0=`pwd`; \
+  sed_first='s,^\([^/]*\)/.*$$,\1,'; \
+  sed_rest='s,^[^/]*/*,,'; \
+  sed_last='s,^.*/\([^/]*\)$$,\1,'; \
+  sed_butlast='s,/*[^/]*$$,,'; \
+  while test -n "$$dir1"; do \
+    first=`echo "$$dir1" | sed -e "$$sed_first"`; \
+    if test "$$first" != "."; then \
+      if test "$$first" = ".."; then \
+        dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
+        dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
+      else \
+        first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
+        if test "$$first2" = "$$first"; then \
+          dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
+        else \
+          dir2="../$$dir2"; \
+        fi; \
+        dir0="$$dir0"/"$$first"; \
+      fi; \
+    fi; \
+    dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
+  done; \
+  reldir="$$dir2"
+DIST_ARCHIVES = $(distdir).tar.gz
+GZIP_ENV = --best
+DIST_TARGETS = dist-gzip
+distuninstallcheck_listfiles = find . -type f -print
+am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \
+  | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$'
+distcleancheck_listfiles = find . -type f -print
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GIT_HEAD = @GIT_HEAD@
+GIT_HEAD_ID = @GIT_HEAD_ID@
+GIT_HEAD_VERSION = @GIT_HEAD_VERSION@
+GREP = @GREP@
+HAVE_OPENCL = @HAVE_OPENCL@
+HAVE_OPENMP = @HAVE_OPENMP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+ISL_CFLAGS = @ISL_CFLAGS@
+ISL_LIBS = @ISL_LIBS@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PET_CFLAGS = @PET_CFLAGS@
+PET_LIBS = @PET_LIBS@
+PKG_CONFIG = @PKG_CONFIG@
+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
+POLYBENCH_DIR = @POLYBENCH_DIR@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+extra_tests = @extra_tests@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+subdirs = @subdirs@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+@BUNDLED_ISL_TRUE@MAYBE_ISL = isl
+@BUNDLED_ISL_TRUE@ISL_LA = $(top_builddir)/isl/libisl.la
+@BUNDLED_ISL_TRUE@LOCAL_ISL_LA = isl/libisl.la
+@BUNDLED_PET_TRUE@MAYBE_PET = pet
+@BUNDLED_PET_TRUE@PET_LA = $(top_builddir)/pet/libpet.la
+SUBDIRS = $(MAYBE_ISL) $(MAYBE_PET) .
+ACLOCAL_AMFLAGS = -I m4
+LIB_ISL = $(ISL_LA) @ISL_LIBS@
+LIB_PET = $(PET_LA) @PET_LIBS@
+AM_CPPFLAGS = @ISL_CFLAGS@ @PET_CFLAGS@
+LDADD = $(LIB_PET) $(LIB_ISL)
+ppcg_SOURCES = \
+  cpu.c \
+  cpu.h \
+  cuda.c \
+  cuda.h \
+  opencl.c \
+  opencl.h \
+  cuda_common.h \
+  cuda_common.c \
+  gpu.c \
+  gpu.h \
+  gpu_array_tile.c \
+  gpu_array_tile.h \
+  gpu_group.c \
+  gpu_group.h \
+  gpu_print.c \
+  gpu_print.h \
+  gpu_tree.c \
+  gpu_tree.h \
+  schedule.c \
+  schedule.h \
+  ppcg_options.c \
+  ppcg_options.h \
+  ppcg.c \
+  ppcg.h \
+  print.c \
+  print.h \
+  util.h \
+  version.c
+
+TESTS = @extra_tests@
+EXTRA_TESTS = opencl_test.sh polybench_test.sh
+TEST_EXTENSIONS = .sh
+EXTRA_DIST = \
+  ocl_utilities.c \
+  ocl_utilities.h \
+  tests
+
+all: all-recursive
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .log .o .obj .sh .sh$(EXEEXT) .trs
+am--refresh: Makefile
+  @:
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+  @for dep in $?; do \
+    case '$(am__configure_deps)' in \
+      *$$dep*) \
+        echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \
+        $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \
+    && exit 0; \
+        exit 1;; \
+    esac; \
+  done; \
+  echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \
+  $(am__cd) $(top_srcdir) && \
+    $(AUTOMAKE) --foreign Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+  @case '$?' in \
+    *config.status*) \
+      echo ' $(SHELL) ./config.status'; \
+      $(SHELL) ./config.status;; \
+    *) \
+      echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \
+      cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \
+  esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+  $(SHELL) ./config.status --recheck
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+  $(am__cd) $(srcdir) && $(AUTOCONF)
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+  $(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS)
+$(am__aclocal_m4_deps):
+polybench_test.sh: $(top_builddir)/config.status $(srcdir)/polybench_test.sh.in
+  cd $(top_builddir) && $(SHELL) ./config.status $@
+opencl_test.sh: $(top_builddir)/config.status $(srcdir)/opencl_test.sh.in
+  cd $(top_builddir) && $(SHELL) ./config.status $@
+install-binPROGRAMS: $(bin_PROGRAMS)
+  @$(NORMAL_INSTALL)
+  @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+  if test -n "$$list"; then \
+    echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
+    $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
+  fi; \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed 's/$(EXEEXT)$$//' | \
+  while read p p1; do if test -f $$p \
+   || test -f $$p1 \
+    ; then echo "$$p"; echo "$$p"; else :; fi; \
+  done | \
+  sed -e 'p;s,.*/,,;n;h' \
+      -e 's|.*|.|' \
+      -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
+  sed 'N;N;N;s,\n, ,g' | \
+  $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
+    { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
+      if ($$2 == $$4) files[d] = files[d] " " $$1; \
+      else { print "f", $$3 "/" $$4, $$1; } } \
+    END { for (d in files) print "f", d, files[d] }' | \
+  while read type dir files; do \
+      if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
+      test -z "$$files" || { \
+      echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
+      $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
+      } \
+  ; done
+
+uninstall-binPROGRAMS:
+  @$(NORMAL_UNINSTALL)
+  @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+  files=`for p in $$list; do echo "$$p"; done | \
+    sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
+        -e 's/$$/$(EXEEXT)/' \
+  `; \
+  test -n "$$list" || exit 0; \
+  echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
+  cd "$(DESTDIR)$(bindir)" && rm -f $$files
+
+clean-binPROGRAMS:
+  @list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \
+  echo " rm -f" $$list; \
+  rm -f $$list || exit $$?; \
+  test -n "$(EXEEXT)" || exit 0; \
+  list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+  echo " rm -f" $$list; \
+  rm -f $$list
+
+ppcg$(EXEEXT): $(ppcg_OBJECTS) $(ppcg_DEPENDENCIES) $(EXTRA_ppcg_DEPENDENCIES) 
+  @rm -f ppcg$(EXEEXT)
+  $(AM_V_CCLD)$(LINK) $(ppcg_OBJECTS) $(ppcg_LDADD) $(LIBS)
+
+mostlyclean-compile:
+  -rm -f *.$(OBJEXT)
+
+distclean-compile:
+  -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cpu.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cuda.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cuda_common.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gpu.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gpu_array_tile.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gpu_group.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gpu_print.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gpu_tree.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/opencl.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ppcg.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ppcg_options.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/print.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/schedule.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/version.Po@am__quote@
+
+.c.o:
+@am__fastdepCC_TRUE@  $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@  $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
+
+.c.obj:
+@am__fastdepCC_TRUE@  $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCC_TRUE@  $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@  $(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@  $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+  -rm -f *.lo
+
+clean-libtool:
+  -rm -rf .libs _libs
+
+distclean-libtool:
+  -rm -f libtool config.lt
+
+# This directory's subdirectories are mostly independent; you can cd
+# into them and run 'make' without going through this Makefile.
+# To change the values of 'make' variables: instead of editing Makefiles,
+# (1) if the variable is set in 'config.status', edit 'config.status'
+#     (which will cause the Makefiles to be regenerated when you run 'make');
+# (2) otherwise, pass the desired values on the 'make' command line.
+$(am__recursive_targets):
+  @fail=; \
+  if $(am__make_keepgoing); then \
+    failcom='fail=yes'; \
+  else \
+    failcom='exit 1'; \
+  fi; \
+  dot_seen=no; \
+  target=`echo $@ | sed s/-recursive//`; \
+  case "$@" in \
+    distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
+    *) list='$(SUBDIRS)' ;; \
+  esac; \
+  for subdir in $$list; do \
+    echo "Making $$target in $$subdir"; \
+    if test "$$subdir" = "."; then \
+      dot_seen=yes; \
+      local_target="$$target-am"; \
+    else \
+      local_target="$$target"; \
+    fi; \
+    ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
+    || eval $$failcom; \
+  done; \
+  if test "$$dot_seen" = "no"; then \
+    $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
+  fi; test -z "$$fail"
+
+ID: $(am__tagged_files)
+  $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-recursive
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+  set x; \
+  here=`pwd`; \
+  if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
+    include_option=--etags-include; \
+    empty_fix=.; \
+  else \
+    include_option=--include; \
+    empty_fix=; \
+  fi; \
+  list='$(SUBDIRS)'; for subdir in $$list; do \
+    if test "$$subdir" = .; then :; else \
+      test ! -f $$subdir/TAGS || \
+        set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
+    fi; \
+  done; \
+  $(am__define_uniq_tagged_files); \
+  shift; \
+  if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+    test -n "$$unique" || unique=$$empty_fix; \
+    if test $$# -gt 0; then \
+      $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+        "$$@" $$unique; \
+    else \
+      $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+        $$unique; \
+    fi; \
+  fi
+ctags: ctags-recursive
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+  $(am__define_uniq_tagged_files); \
+  test -z "$(CTAGS_ARGS)$$unique" \
+    || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+       $$unique
+
+GTAGS:
+  here=`$(am__cd) $(top_builddir) && pwd` \
+    && $(am__cd) $(top_srcdir) \
+    && gtags -i $(GTAGS_ARGS) "$$here"
+cscope: cscope.files
+  test ! -s cscope.files \
+    || $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS)
+clean-cscope:
+  -rm -f cscope.files
+cscope.files: clean-cscope cscopelist
+cscopelist: cscopelist-recursive
+
+cscopelist-am: $(am__tagged_files)
+  list='$(am__tagged_files)'; \
+  case "$(srcdir)" in \
+    [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+    *) sdir=$(subdir)/$(srcdir) ;; \
+  esac; \
+  for i in $$list; do \
+    if test -f "$$i"; then \
+      echo "$(subdir)/$$i"; \
+    else \
+      echo "$$sdir/$$i"; \
+    fi; \
+  done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+  -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+  -rm -f cscope.out cscope.in.out cscope.po.out cscope.files
+
+# Recover from deleted '.trs' file; this should ensure that
+# "rm -f foo.log; make foo.trs" re-run 'foo.test', and re-create
+# both 'foo.log' and 'foo.trs'.  Break the recipe in two subshells
+# to avoid problems with "make -n".
+.log.trs:
+  rm -f $< $@
+  $(MAKE) $(AM_MAKEFLAGS) $<
+
+# Leading 'am--fnord' is there to ensure the list of targets does not
+# expand to empty, as could happen e.g. with make check TESTS=''.
+am--fnord $(TEST_LOGS) $(TEST_LOGS:.log=.trs): $(am__force_recheck)
+am--force-recheck:
+  @:
+
+$(TEST_SUITE_LOG): $(TEST_LOGS)
+  @$(am__set_TESTS_bases); \
+  am__f_ok () { test -f "$$1" && test -r "$$1"; }; \
+  redo_bases=`for i in $$bases; do \
+                am__f_ok $$i.trs && am__f_ok $$i.log || echo $$i; \
+              done`; \
+  if test -n "$$redo_bases"; then \
+    redo_logs=`for i in $$redo_bases; do echo $$i.log; done`; \
+    redo_results=`for i in $$redo_bases; do echo $$i.trs; done`; \
+    if $(am__make_dryrun); then :; else \
+      rm -f $$redo_logs && rm -f $$redo_results || exit 1; \
+    fi; \
+  fi; \
+  if test -n "$$am__remaking_logs"; then \
+    echo "fatal: making $(TEST_SUITE_LOG): possible infinite" \
+         "recursion detected" >&2; \
+  elif test -n "$$redo_logs"; then \
+    am__remaking_logs=yes $(MAKE) $(AM_MAKEFLAGS) $$redo_logs; \
+  fi; \
+  if $(am__make_dryrun); then :; else \
+    st=0;  \
+    errmsg="fatal: making $(TEST_SUITE_LOG): failed to create"; \
+    for i in $$redo_bases; do \
+      test -f $$i.trs && test -r $$i.trs \
+        || { echo "$$errmsg $$i.trs" >&2; st=1; }; \
+      test -f $$i.log && test -r $$i.log \
+        || { echo "$$errmsg $$i.log" >&2; st=1; }; \
+    done; \
+    test $$st -eq 0 || exit 1; \
+  fi
+  @$(am__sh_e_setup); $(am__tty_colors); $(am__set_TESTS_bases); \
+  ws='[  ]'; \
+  results=`for b in $$bases; do echo $$b.trs; done`; \
+  test -n "$$results" || results=/dev/null; \
+  all=`  grep "^$$ws*:test-result:"           $$results | wc -l`; \
+  pass=` grep "^$$ws*:test-result:$$ws*PASS"  $$results | wc -l`; \
+  fail=` grep "^$$ws*:test-result:$$ws*FAIL"  $$results | wc -l`; \
+  skip=` grep "^$$ws*:test-result:$$ws*SKIP"  $$results | wc -l`; \
+  xfail=`grep "^$$ws*:test-result:$$ws*XFAIL" $$results | wc -l`; \
+  xpass=`grep "^$$ws*:test-result:$$ws*XPASS" $$results | wc -l`; \
+  error=`grep "^$$ws*:test-result:$$ws*ERROR" $$results | wc -l`; \
+  if test `expr $$fail + $$xpass + $$error` -eq 0; then \
+    success=true; \
+  else \
+    success=false; \
+  fi; \
+  br='==================='; br=$$br$$br$$br$$br; \
+  result_count () \
+  { \
+      if test x"$$1" = x"--maybe-color"; then \
+        maybe_colorize=yes; \
+      elif test x"$$1" = x"--no-color"; then \
+        maybe_colorize=no; \
+      else \
+        echo "$@: invalid 'result_count' usage" >&2; exit 4; \
+      fi; \
+      shift; \
+      desc=$$1 count=$$2; \
+      if test $$maybe_colorize = yes && test $$count -gt 0; then \
+        color_start=$$3 color_end=$$std; \
+      else \
+        color_start= color_end=; \
+      fi; \
+      echo "$${color_start}# $$desc $$count$${color_end}"; \
+  }; \
+  create_testsuite_report () \
+  { \
+    result_count $$1 "TOTAL:" $$all   "$$brg"; \
+    result_count $$1 "PASS: " $$pass  "$$grn"; \
+    result_count $$1 "SKIP: " $$skip  "$$blu"; \
+    result_count $$1 "XFAIL:" $$xfail "$$lgn"; \
+    result_count $$1 "FAIL: " $$fail  "$$red"; \
+    result_count $$1 "XPASS:" $$xpass "$$red"; \
+    result_count $$1 "ERROR:" $$error "$$mgn"; \
+  }; \
+  {               \
+    echo "$(PACKAGE_STRING): $(subdir)/$(TEST_SUITE_LOG)" | \
+      $(am__rst_title);           \
+    create_testsuite_report --no-color;       \
+    echo;               \
+    echo ".. contents:: :depth: 2";       \
+    echo;               \
+    for b in $$bases; do echo $$b; done       \
+      | $(am__create_global_log);         \
+  } >$(TEST_SUITE_LOG).tmp || exit 1;        \
+  mv $(TEST_SUITE_LOG).tmp $(TEST_SUITE_LOG);     \
+  if $$success; then            \
+    col="$$grn";              \
+   else               \
+    col="$$red";              \
+    test x"$$VERBOSE" = x || cat $(TEST_SUITE_LOG);   \
+  fi;               \
+  echo "$${col}$$br$${std}";          \
+  echo "$${col}Testsuite summary for $(PACKAGE_STRING)$${std}"; \
+  echo "$${col}$$br$${std}";          \
+  create_testsuite_report --maybe-color;        \
+  echo "$$col$$br$$std";            \
+  if $$success; then :; else          \
+    echo "$${col}See $(subdir)/$(TEST_SUITE_LOG)$${std}";   \
+    if test -n "$(PACKAGE_BUGREPORT)"; then     \
+      echo "$${col}Please report to $(PACKAGE_BUGREPORT)$${std}"; \
+    fi;               \
+    echo "$$col$$br$$std";          \
+  fi;               \
+  $$success || exit 1
+
+check-TESTS:
+  @list='$(RECHECK_LOGS)';           test -z "$$list" || rm -f $$list
+  @list='$(RECHECK_LOGS:.log=.trs)'; test -z "$$list" || rm -f $$list
+  @test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
+  @set +e; $(am__set_TESTS_bases); \
+  log_list=`for i in $$bases; do echo $$i.log; done`; \
+  trs_list=`for i in $$bases; do echo $$i.trs; done`; \
+  log_list=`echo $$log_list`; trs_list=`echo $$trs_list`; \
+  $(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) TEST_LOGS="$$log_list"; \
+  exit $$?;
+recheck: all 
+  @test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
+  @set +e; $(am__set_TESTS_bases); \
+  bases=`for i in $$bases; do echo $$i; done \
+           | $(am__list_recheck_tests)` || exit 1; \
+  log_list=`for i in $$bases; do echo $$i.log; done`; \
+  log_list=`echo $$log_list`; \
+  $(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) \
+          am__force_recheck=am--force-recheck \
+          TEST_LOGS="$$log_list"; \
+  exit $$?
+.sh.log:
+  @p='$<'; \
+  $(am__set_b); \
+  $(am__check_pre) $(SH_LOG_DRIVER) --test-name "$$f" \
+  --log-file $$b.log --trs-file $$b.trs \
+  $(am__common_driver_flags) $(AM_SH_LOG_DRIVER_FLAGS) $(SH_LOG_DRIVER_FLAGS) -- $(SH_LOG_COMPILE) \
+  "$$tst" $(AM_TESTS_FD_REDIRECT)
+@am__EXEEXT_TRUE@.sh$(EXEEXT).log:
+@am__EXEEXT_TRUE@ @p='$<'; \
+@am__EXEEXT_TRUE@ $(am__set_b); \
+@am__EXEEXT_TRUE@ $(am__check_pre) $(SH_LOG_DRIVER) --test-name "$$f" \
+@am__EXEEXT_TRUE@ --log-file $$b.log --trs-file $$b.trs \
+@am__EXEEXT_TRUE@ $(am__common_driver_flags) $(AM_SH_LOG_DRIVER_FLAGS) $(SH_LOG_DRIVER_FLAGS) -- $(SH_LOG_COMPILE) \
+@am__EXEEXT_TRUE@ "$$tst" $(AM_TESTS_FD_REDIRECT)
+
+distdir: $(DISTFILES)
+  $(am__remove_distdir)
+  test -d "$(distdir)" || mkdir "$(distdir)"
+  @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+  topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+  list='$(DISTFILES)'; \
+    dist_files=`for file in $$list; do echo $$file; done | \
+    sed -e "s|^$$srcdirstrip/||;t" \
+        -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+  case $$dist_files in \
+    */*) $(MKDIR_P) `echo "$$dist_files" | \
+         sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+         sort -u` ;; \
+  esac; \
+  for file in $$dist_files; do \
+    if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+    if test -d $$d/$$file; then \
+      dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+      if test -d "$(distdir)/$$file"; then \
+        find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+      fi; \
+      if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+        cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+        find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+      fi; \
+      cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+    else \
+      test -f "$(distdir)/$$file" \
+      || cp -p $$d/$$file "$(distdir)/$$file" \
+      || exit 1; \
+    fi; \
+  done
+  @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
+    if test "$$subdir" = .; then :; else \
+      $(am__make_dryrun) \
+        || test -d "$(distdir)/$$subdir" \
+        || $(MKDIR_P) "$(distdir)/$$subdir" \
+        || exit 1; \
+      dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
+      $(am__relativize); \
+      new_distdir=$$reldir; \
+      dir1=$$subdir; dir2="$(top_distdir)"; \
+      $(am__relativize); \
+      new_top_distdir=$$reldir; \
+      echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
+      echo "     am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
+      ($(am__cd) $$subdir && \
+        $(MAKE) $(AM_MAKEFLAGS) \
+          top_distdir="$$new_top_distdir" \
+          distdir="$$new_distdir" \
+    am__remove_distdir=: \
+    am__skip_length_check=: \
+    am__skip_mode_fix=: \
+          distdir) \
+        || exit 1; \
+    fi; \
+  done
+  $(MAKE) $(AM_MAKEFLAGS) \
+    top_distdir="$(top_distdir)" distdir="$(distdir)" \
+    dist-hook
+  -test -n "$(am__skip_mode_fix)" \
+  || find "$(distdir)" -type d ! -perm -755 \
+    -exec chmod u+rwx,go+rx {} \; -o \
+    ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \
+    ! -type d ! -perm -400 -exec chmod a+r {} \; -o \
+    ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \
+  || chmod -R a+r "$(distdir)"
+dist-gzip: distdir
+  tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
+  $(am__post_remove_distdir)
+
+dist-bzip2: distdir
+  tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
+  $(am__post_remove_distdir)
+
+dist-lzip: distdir
+  tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz
+  $(am__post_remove_distdir)
+
+dist-xz: distdir
+  tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz
+  $(am__post_remove_distdir)
+
+dist-tarZ: distdir
+  @echo WARNING: "Support for distribution archives compressed with" \
+           "legacy program 'compress' is deprecated." >&2
+  @echo WARNING: "It will be removed altogether in Automake 2.0" >&2
+  tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
+  $(am__post_remove_distdir)
+
+dist-shar: distdir
+  @echo WARNING: "Support for shar distribution archives is" \
+                 "deprecated." >&2
+  @echo WARNING: "It will be removed altogether in Automake 2.0" >&2
+  shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz
+  $(am__post_remove_distdir)
+
+dist-zip: distdir
+  -rm -f $(distdir).zip
+  zip -rq $(distdir).zip $(distdir)
+  $(am__post_remove_distdir)
+
+dist dist-all:
+  $(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:'
+  $(am__post_remove_distdir)
+
+# This target untars the dist file and tries a VPATH configuration.  Then
+# it guarantees that the distribution is self-contained by making another
+# tarfile.
+distcheck: dist
+  case '$(DIST_ARCHIVES)' in \
+  *.tar.gz*) \
+    GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\
+  *.tar.bz2*) \
+    bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\
+  *.tar.lz*) \
+    lzip -dc $(distdir).tar.lz | $(am__untar) ;;\
+  *.tar.xz*) \
+    xz -dc $(distdir).tar.xz | $(am__untar) ;;\
+  *.tar.Z*) \
+    uncompress -c $(distdir).tar.Z | $(am__untar) ;;\
+  *.shar.gz*) \
+    GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\
+  *.zip*) \
+    unzip $(distdir).zip ;;\
+  esac
+  chmod -R a-w $(distdir)
+  chmod u+w $(distdir)
+  mkdir $(distdir)/_build $(distdir)/_build/sub $(distdir)/_inst
+  chmod a-w $(distdir)
+  test -d $(distdir)/_build || exit 0; \
+  dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \
+    && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \
+    && am__cwd=`pwd` \
+    && $(am__cd) $(distdir)/_build/sub \
+    && ../../configure \
+      $(AM_DISTCHECK_CONFIGURE_FLAGS) \
+      $(DISTCHECK_CONFIGURE_FLAGS) \
+      --srcdir=../.. --prefix="$$dc_install_base" \
+    && $(MAKE) $(AM_MAKEFLAGS) \
+    && $(MAKE) $(AM_MAKEFLAGS) dvi \
+    && $(MAKE) $(AM_MAKEFLAGS) check \
+    && $(MAKE) $(AM_MAKEFLAGS) install \
+    && $(MAKE) $(AM_MAKEFLAGS) installcheck \
+    && $(MAKE) $(AM_MAKEFLAGS) uninstall \
+    && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \
+          distuninstallcheck \
+    && chmod -R a-w "$$dc_install_base" \
+    && ({ \
+         (cd ../.. && umask 077 && mkdir "$$dc_destdir") \
+         && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \
+         && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \
+         && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \
+              distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \
+        } || { rm -rf "$$dc_destdir"; exit 1; }) \
+    && rm -rf "$$dc_destdir" \
+    && $(MAKE) $(AM_MAKEFLAGS) dist \
+    && rm -rf $(DIST_ARCHIVES) \
+    && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \
+    && cd "$$am__cwd" \
+    || exit 1
+  $(am__post_remove_distdir)
+  @(echo "$(distdir) archives ready for distribution: "; \
+    list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \
+    sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x'
+distuninstallcheck:
+  @test -n '$(distuninstallcheck_dir)' || { \
+    echo 'ERROR: trying to run $@ with an empty' \
+         '$$(distuninstallcheck_dir)' >&2; \
+    exit 1; \
+  }; \
+  $(am__cd) '$(distuninstallcheck_dir)' || { \
+    echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \
+    exit 1; \
+  }; \
+  test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \
+     || { echo "ERROR: files left after uninstall:" ; \
+          if test -n "$(DESTDIR)"; then \
+            echo "  (check DESTDIR support)"; \
+          fi ; \
+          $(distuninstallcheck_listfiles) ; \
+          exit 1; } >&2
+distcleancheck: distclean
+  @if test '$(srcdir)' = . ; then \
+    echo "ERROR: distcleancheck can only run from a VPATH build" ; \
+    exit 1 ; \
+  fi
+  @test `$(distcleancheck_listfiles) | wc -l` -eq 0 \
+    || { echo "ERROR: files left in build directory after distclean:" ; \
+         $(distcleancheck_listfiles) ; \
+         exit 1; } >&2
+check-am: all-am
+  $(MAKE) $(AM_MAKEFLAGS) check-TESTS
+check: check-recursive
+all-am: Makefile $(PROGRAMS)
+installdirs: installdirs-recursive
+installdirs-am:
+  for dir in "$(DESTDIR)$(bindir)"; do \
+    test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+  done
+install: install-recursive
+install-exec: install-exec-recursive
+install-data: install-data-recursive
+uninstall: uninstall-recursive
+
+install-am: all-am
+  @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-recursive
+install-strip:
+  if test -z '$(STRIP)'; then \
+    $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+      install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+        install; \
+  else \
+    $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+      install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+      "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+  fi
+mostlyclean-generic:
+  -test -z "$(TEST_LOGS)" || rm -f $(TEST_LOGS)
+  -test -z "$(TEST_LOGS:.log=.trs)" || rm -f $(TEST_LOGS:.log=.trs)
+  -test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
+
+clean-generic:
+
+distclean-generic:
+  -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+  -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+  @echo "This command is intended for maintainers to use"
+  @echo "it deletes files that may require special tools to rebuild."
+clean: clean-recursive
+
+clean-am: clean-binPROGRAMS clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-recursive
+  -rm -f $(am__CONFIG_DISTCLEAN_FILES)
+  -rm -rf ./$(DEPDIR)
+  -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+  distclean-libtool distclean-tags
+
+dvi: dvi-recursive
+
+dvi-am:
+
+html: html-recursive
+
+html-am:
+
+info: info-recursive
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-recursive
+
+install-dvi-am:
+
+install-exec-am: install-binPROGRAMS
+
+install-html: install-html-recursive
+
+install-html-am:
+
+install-info: install-info-recursive
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-recursive
+
+install-pdf-am:
+
+install-ps: install-ps-recursive
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-recursive
+  -rm -f $(am__CONFIG_DISTCLEAN_FILES)
+  -rm -rf $(top_srcdir)/autom4te.cache
+  -rm -rf ./$(DEPDIR)
+  -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-recursive
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+  mostlyclean-libtool
+
+pdf: pdf-recursive
+
+pdf-am:
+
+ps: ps-recursive
+
+ps-am:
+
+uninstall-am: uninstall-binPROGRAMS
+
+.MAKE: $(am__recursive_targets) check-am install-am install-strip
+
+.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
+  am--refresh check check-TESTS check-am clean clean-binPROGRAMS \
+  clean-cscope clean-generic clean-libtool cscope cscopelist-am \
+  ctags ctags-am dist dist-all dist-bzip2 dist-gzip dist-hook \
+  dist-lzip dist-shar dist-tarZ dist-xz dist-zip distcheck \
+  distclean distclean-compile distclean-generic \
+  distclean-libtool distclean-tags distcleancheck distdir \
+  distuninstallcheck dvi dvi-am html html-am info info-am \
+  install install-am install-binPROGRAMS install-data \
+  install-data-am install-dvi install-dvi-am install-exec \
+  install-exec-am install-html install-html-am install-info \
+  install-info-am install-man install-pdf install-pdf-am \
+  install-ps install-ps-am install-strip installcheck \
+  installcheck-am installdirs installdirs-am maintainer-clean \
+  maintainer-clean-generic mostlyclean mostlyclean-compile \
+  mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+  recheck tags tags-am uninstall uninstall-am \
+  uninstall-binPROGRAMS
+
+.PRECIOUS: Makefile
+
+
+FORCE:
+isl/libisl.la: FORCE
+  cd isl; $(MAKE) $(AM_MAKEFLAGS) libisl.la
+pet/libpet.la: FORCE
+  cd pet; $(MAKE) $(AM_MAKEFLAGS) libpet.la
+
+dist-hook:
+  echo @GIT_HEAD_VERSION@ > $(distdir)/GIT_HEAD_ID
+
+gitversion.h: @GIT_HEAD@
+  $(AM_V_GEN)echo '#define GIT_HEAD_ID "'@GIT_HEAD_VERSION@'"' > $@
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:

polly/trunk/lib/External/ppcg/README

+Requirements:
+
+- automake, autoconf, libtool
+  (not needed when compiling a release)
+- pkg-config (http://www.freedesktop.org/wiki/Software/pkg-config)
+  (not needed when compiling a release using the included isl and pet)
+- gmp (http://gmplib.org/)
+- libyaml (http://pyyaml.org/wiki/LibYAML)
+  (only needed if you want to compile the pet executable)
+- LLVM/clang libraries, 2.9 or higher (http://clang.llvm.org/get_started.html)
+  Unless you have some other reasons for wanting to use the svn version,
+  it is best to install the latest release (3.6).
+  For more details, see pet/README.
+
+If you are installing on Ubuntu, then you can install the following packages:
+
+automake autoconf libtool pkg-config libgmp3-dev libyaml-dev libclang-dev llvm
+
+Note that you need at least version 3.2 of libclang-dev (ubuntu raring).
+Older versions of this package did not include the required libraries.
+If you are using an older version of ubuntu, then you need to compile and
+install LLVM/clang from source.
+
+
+Preparing:
+
+Grab the latest release and extract it or get the source from
+the git repository as follows.  This process requires autoconf,
+automake, libtool and pkg-config.
+
+  git clone git://repo.or.cz/ppcg.git
+  cd ppcg
+  git submodule init
+  git submodule update
+  ./autogen.sh
+
+
+Compilation:
+
+  ./configure
+  make
+  make check
+
+If you have installed any of the required libraries in a non-standard
+location, then you may need to use the --with-gmp-prefix,
+--with-libyaml-prefix and/or --with-clang-prefix options
+when calling "./configure".
+
+
+Using PPCG to generate CUDA or OpenCL code
+
+To convert a fragment of a C program to CUDA, insert a line containing
+
+  #pragma scop
+
+before the fragment and add a line containing
+
+  #pragma endscop
+
+after the fragment.  To generate CUDA code run
+  
+  ppcg --target=cuda file.c
+
+where file.c is the file containing the fragment.  The generated
+code is stored in file_host.cu and file_kernel.cu.
+
+To generate OpenCL code run
+
+  ppcg --target=opencl file.c
+
+where file.c is the file containing the fragment.  The generated code
+is stored in file_host.c and file_kernel.cl.
+
+
+Specifying tile, grid and block sizes
+
+The iterations space tile size, grid size and block size can
+be specified using the --sizes option.  The argument is a union map
+in isl notation mapping kernels identified by their sequence number
+in a "kernel" space to singleton sets in the "tile", "grid" and "block"
+spaces.  The sizes are specified outermost to innermost.
+
+The dimension of the "tile" space indicates the (maximal) number of loop
+dimensions to tile.  The elements of the single integer tuple
+specify the tile sizes in each dimension.
+
+The dimension of the "grid" space indicates the (maximal) number of block
+dimensions in the grid.  The elements of the single integer tuple
+specify the number of blocks in each dimension.
+
+The dimension of the "block" space indicates the (maximal) number of thread
+dimensions in the grid.  The elements of the single integer tuple
+specify the number of threads in each dimension.
+
+For example,
+
+    { kernel[0] -> tile[64,64]; kernel[i] -> block[16] : i != 4 }
+
+specifies that in kernel 0, two loops should be tiled with a tile
+size of 64 in both dimensions and that all kernels except kernel 4
+should be run using a block of 16 threads.
+
+Since PPCG performs some scheduling, it can be difficult to predict
+what exactly will end up in a kernel.  If you want to specify
+tile, grid or block sizes, you may want to run PPCG first with the defaults,
+examine the kernels and then run PPCG again with the desired sizes.
+Instead of examining the kernels, you can also specify the option
+--dump-sizes on the first run to obtain the effectively used default sizes.
+
+
+Compiling the generated CUDA code with nvcc
+
+To get optimal performance from nvcc, it is important to choose --arch
+according to your target GPU.  Specifically, use the flag "--arch sm_20"
+for fermi, "--arch sm_30" for GK10x Kepler and "--arch sm_35" for
+GK110 Kepler.  We discourage the use of older cards as we have seen
+correctness issues with compilation for older architectures.
+Note that in the absence of any --arch flag, nvcc defaults to
+"--arch sm_13". This will not only be slower, but can also cause
+correctness issues.
+If you want to obtain results that are identical to those obtained
+by the original code, then you may need to disable some optimizations
+by passing the "--fmad=false" option.
+
+
+Compiling the generated OpenCL code with gcc
+
+To compile the host code you need to link against the file
+ocl_utilities.c which contains utility functions used by the generated
+OpenCL host code.  To compile the host code with gcc, run
+
+  gcc -std=c99 file_host.c ocl_utilities.c -lOpenCL
+
+Note that we have experienced the generated OpenCL code freezing
+on some inputs (e.g., the PolyBench symm benchmark) when using
+at least some version of the Nvidia OpenCL library, while the
+corresponding CUDA code runs fine.
+We have experienced no such freezes when using AMD, ARM or Intel
+OpenCL libraries.
+
+By default, the compiled executable will need the _kernel.cl file at
+run time.  Alternatively, the option --opencl-embed-kernel-code may be
+given to place the kernel code in a string literal.  The kernel code is
+then compiled into the host binary, such that the _kernel.cl file is no
+longer needed at run time.  Any kernel include files, in particular
+those supplied using --opencl-include-file, will still be required at
+run time.
+
+
+Function calls
+
+Function calls inside the analyzed fragment are reproduced
+in the CUDA or OpenCL code, but for now it is left to the user
+to make sure that the functions that are being called are
+available from the generated kernels.
+
+In the case of OpenCL code, the --opencl-include-file option
+may be used to specify one or more files to be #include'd
+from the generated code.  These files may then contain
+the definitions of the functions being called from the
+program fragment.  If the pathnames of the included files
+are relative to the current directory, then you may need
+to additionally specify the --opencl-compiler-options=-I.
+to make sure that the files can be found by the OpenCL compiler.
+The included files may contain definitions of types used by the
+generated kernels.  By default, PPCG generates definitions for
+types as needed, but these definitions may collide with those in
+the included files, as PPCG does not consider the contents of the
+included files.  The --no-opencl-print-kernel-types will prevent
+PPCG from generating type definitions.
+
+
+Processing PolyBench
+
+When processing a PolyBench/C 3.2 benchmark, you should always specify
+-DPOLYBENCH_USE_C99_PROTO on the ppcg command line.  Otherwise, the source
+files are inconsistent, having fixed size arrays but parametrically
+bounded loops iterating over them.
+However, you should not specify this define when compiling
+the PPCG generated code using nvcc since CUDA does not support VLAs.
+
+
+CUDA and function overloading
+
+While CUDA supports function overloading based on the arguments types,
+no such function overloading exists in the input language C.  Since PPCG
+simply prints out the same function name as in the original code, this
+may result in a different function being called based on the types
+of the arguments.  For example, if the original code contains a call
+to the function sqrt() with a float argument, then the argument will
+be promoted to a double and the sqrt() function will be called.
+In the transformed (CUDA) code, however, overloading will cause the
+function sqrtf() to be called.  Until this issue has been resolved in PPCG,
+we recommend that users either explicitly call the function sqrtf() or
+explicitly cast the argument to double in the input code.
+
+
+Contact
+
+For bug reports, feature requests and questions,
+contact http://groups.google.com/group/isl-development
+
+
+Citing PPCG
+
+If you use PPCG for your research, you are invited to cite
+the following paper.
+
+@article{Verdoolaege2013PPCG,
+    author = {Verdoolaege, Sven and Juega, Juan Carlos and Cohen, Albert and
+    G\'{o}mez, Jos{\'e} Ignacio and Tenllado, Christian and
+    Catthoor, Francky},
+    title = {Polyhedral parallel code generation for CUDA},
+    journal = {ACM Trans. Archit. Code Optim.},
+    issue_date = {January 2013},
+    volume = {9},
+    number = {4},
+    month = jan,
+    year = {2013},
+    issn = {1544-3566},
+    pages = {54:1--54:23},
+    doi = {10.1145/2400682.2400713},
+    acmid = {2400713},
+    publisher = {ACM},
+    address = {New York, NY, USA},
+}

polly/trunk/lib/External/ppcg/aclocal.m4

+# generated automatically by aclocal 1.15 -*- Autoconf -*-
+
+# Copyright (C) 1996-2014 Free Software Foundation, Inc.
+
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
+m4_ifndef([AC_AUTOCONF_VERSION],
+  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
+m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],,
+[m4_warning([this file was generated for autoconf 2.69.
+You have another version of autoconf.  It may work, but is not guaranteed to.
+If you have problems, you may need to regenerate the build system entirely.
+To do so, use the procedure documented by the package, typically 'autoreconf'.])])
+
+# pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
+# serial 1 (pkg-config-0.24)
+# 
+# Copyright © 2004 Scott James Remnant <[e-mail]>.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# PKG_PROG_PKG_CONFIG([MIN-VERSION])
+# ----------------------------------
+AC_DEFUN([PKG_PROG_PKG_CONFIG],
+[m4_pattern_forbid([^_?PKG_[A-Z_]+$])
+m4_pattern_allow([^PKG_CONFIG(_(PATH|LIBDIR|SYSROOT_DIR|ALLOW_SYSTEM_(CFLAGS|LIBS)))?$])
+m4_pattern_allow([^PKG_CONFIG_(DISABLE_UNINSTALLED|TOP_BUILD_DIR|DEBUG_SPEW)$])
+AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility])
+AC_ARG_VAR([PKG_CONFIG_PATH], [directories to add to pkg-config's search path])
+AC_ARG_VAR([PKG_CONFIG_LIBDIR], [path overriding pkg-config's built-in search path])
+
+if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
+  AC_PATH_TOOL([PKG_CONFIG], [pkg-config])
+fi
+if test -n "$PKG_CONFIG"; then
+  _pkg_min_version=m4_default([$1], [0.9.0])
+  AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version])
+  if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
+    AC_MSG_RESULT([yes])
+  else
+    AC_MSG_RESULT([no])
+    PKG_CONFIG=""
+  fi
+fi[]dnl
+])# PKG_PROG_PKG_CONFIG
+
+# PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+#
+# Check to see whether a particular set of modules exists.  Similar
+# to PKG_CHECK_MODULES(), but does not set variables or print errors.
+#
+# Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG])
+# only at the first occurence in configure.ac, so if the first place
+# it's called might be skipped (such as if it is within an "if", you
+# have to call PKG_CHECK_EXISTS manually
+# --------------------------------------------------------------
+AC_DEFUN([PKG_CHECK_EXISTS],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
+if test -n "$PKG_CONFIG" && \
+    AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then
+  m4_default([$2], [:])
+m4_ifvaln([$3], [else
+  $3])dnl
+fi])
+
+# _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
+# ---------------------------------------------
+m4_define([_PKG_CONFIG],
+[if test -n "$$1"; then
+    pkg_cv_[]$1="$$1"
+ elif test -n "$PKG_CONFIG"; then
+    PKG_CHECK_EXISTS([$3],
+                     [pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null`
+          test "x$?" != "x0" && pkg_failed=yes ],
+         [pkg_failed=yes])
+ else
+    pkg_failed=untried
+fi[]dnl
+])# _PKG_CONFIG
+
+# _PKG_SHORT_ERRORS_SUPPORTED
+# -----------------------------
+AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])
+if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
+        _pkg_short_errors_supported=yes
+else
+        _pkg_short_errors_supported=no
+fi[]dnl
+])# _PKG_SHORT_ERRORS_SUPPORTED
+
+
+# PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
+# [ACTION-IF-NOT-FOUND])
+#
+#
+# Note that if there is a possibility the first call to
+# PKG_CHECK_MODULES might not happen, you should be sure to include an
+# explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
+#
+#
+# --------------------------------------------------------------
+AC_DEFUN([PKG_CHECK_MODULES],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
+AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl
+AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl
+
+pkg_failed=no
+AC_MSG_CHECKING([for $1])
+
+_PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])
+_PKG_CONFIG([$1][_LIBS], [libs], [$2])
+
+m4_define([_PKG_TEXT], [Alternatively, you may set the environment variables $1[]_CFLAGS
+and $1[]_LIBS to avoid the need to call pkg-config.
+See the pkg-config man page for more details.])
+
+if test $pkg_failed = yes; then
+    AC_MSG_RESULT([no])
+        _PKG_SHORT_ERRORS_SUPPORTED
+        if test $_pkg_short_errors_supported = yes; then
+          $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1`
+        else 
+          $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1`
+        fi
+  # Put the nasty error message in config.log where it belongs
+  echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD
+
+  m4_default([$4], [AC_MSG_ERROR(
+[Package requirements ($2) were not met:
+
+$$1_PKG_ERRORS
+
+Consider adjusting the PKG_CONFIG_PATH environment variable if you
+installed software in a non-standard prefix.
+
+_PKG_TEXT])[]dnl
+        ])
+elif test $pkg_failed = untried; then
+      AC_MSG_RESULT([no])
+  m4_default([$4], [AC_MSG_FAILURE(
+[The pkg-config script could not be found or is too old.  Make sure it
+is in your PATH or set the PKG_CONFIG environment variable to the full
+path to pkg-config.
+
+_PKG_TEXT
+
+To get pkg-config, see <http://pkg-config.freedesktop.org/>.])[]dnl
+        ])
+else
+  $1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
+  $1[]_LIBS=$pkg_cv_[]$1[]_LIBS
+        AC_MSG_RESULT([yes])
+  $3
+fi[]dnl
+])# PKG_CHECK_MODULES
+
+
+# PKG_INSTALLDIR(DIRECTORY)
+# -------------------------
+# Substitutes the variable pkgconfigdir as the location where a module
+# should install pkg-config .pc files. By default the directory is
+# $libdir/pkgconfig, but the default can be changed by passing
+# DIRECTORY. The user can override through the --with-pkgconfigdir
+# parameter.
+AC_DEFUN([PKG_INSTALLDIR],
+[m4_pushdef([pkg_default], [m4_default([$1], ['${libdir}/pkgconfig'])])
+m4_pushdef([pkg_description],
+    [pkg-config installation directory @<:@]pkg_default[@:>@])
+AC_ARG_WITH([pkgconfigdir],
+    [AS_HELP_STRING([--with-pkgconfigdir], pkg_description)],,
+    [with_pkgconfigdir=]pkg_default)
+AC_SUBST([pkgconfigdir], [$with_pkgconfigdir])
+m4_popdef([pkg_default])
+m4_popdef([pkg_description])
+]) dnl PKG_INSTALLDIR
+
+
+# PKG_NOARCH_INSTALLDIR(DIRECTORY)
+# -------------------------
+# Substitutes the variable noarch_pkgconfigdir as the location where a
+# module should install arch-independent pkg-config .pc files. By
+# default the directory is $datadir/pkgconfig, but the default can be
+# changed by passing DIRECTORY. The user can override through the
+# --with-noarch-pkgconfigdir parameter.
+AC_DEFUN([PKG_NOARCH_INSTALLDIR],
+[m4_pushdef([pkg_default], [m4_default([$1], ['${datadir}/pkgconfig'])])
+m4_pushdef([pkg_description],
+    [pkg-config arch-independent installation directory @<:@]pkg_default[@:>@])
+AC_ARG_WITH([noarch-pkgconfigdir],
+    [AS_HELP_STRING([--with-noarch-pkgconfigdir], pkg_description)],,
+    [with_noarch_pkgconfigdir=]pkg_default)
+AC_SUBST([noarch_pkgconfigdir], [$with_noarch_pkgconfigdir])
+m4_popdef([pkg_default])
+m4_popdef([pkg_description])
+]) dnl PKG_NOARCH_INSTALLDIR
+
+
+# PKG_CHECK_VAR(VARIABLE, MODULE, CONFIG-VARIABLE,
+# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+# -------------------------------------------
+# Retrieves the value of the pkg-config variable for the given module.
+AC_DEFUN([PKG_CHECK_VAR],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
+AC_ARG_VAR([$1], [value of $3 for $2, overriding pkg-config])dnl
+
+_PKG_CONFIG([$1], [variable="][$3]["], [$2])
+AS_VAR_COPY([$1], [pkg_cv_][$1])
+
+AS_VAR_IF([$1], [""], [$5], [$4])dnl
+])# PKG_CHECK_VAR
+
+# Copyright (C) 2002-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_AUTOMAKE_VERSION(VERSION)
+# ----------------------------
+# Automake X.Y traces this macro to ensure aclocal.m4 has been
+# generated from the m4 files accompanying Automake X.Y.
+# (This private macro should not be called outside this file.)
+AC_DEFUN([AM_AUTOMAKE_VERSION],
+[am__api_version='1.15'
+dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
+dnl require some minimum version.  Point them to the right macro.
+m4_if([$1], [1.15], [],
+      [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
+])
+
+# _AM_AUTOCONF_VERSION(VERSION)
+# -----------------------------
+# aclocal traces this macro to find the Autoconf version.
+# This is a private macro too.  Using m4_define simplifies
+# the logic in aclocal, which can simply ignore this definition.
+m4_define([_AM_AUTOCONF_VERSION], [])
+
+# AM_SET_CURRENT_AUTOMAKE_VERSION
+# -------------------------------
+# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
+# This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
+AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
+[AM_AUTOMAKE_VERSION([1.15])dnl
+m4_ifndef([AC_AUTOCONF_VERSION],
+  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
+_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
+
+# AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
+
+# Copyright (C) 2001-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
+# $ac_aux_dir to '$srcdir/foo'.  In other projects, it is set to
+# '$srcdir', '$srcdir/..', or '$srcdir/../..'.
+#
+# Of course, Automake must honor this variable whenever it calls a
+# tool from the auxiliary directory.  The problem is that $srcdir (and
+# therefore $ac_aux_dir as well) can be either absolute or relative,
+# depending on how configure is run.  This is pretty annoying, since
+# it makes $ac_aux_dir quite unusable in subdirectories: in the top
+# source directory, any form will work fine, but in subdirectories a
+# relative path needs to be adjusted first.
+#
+# $ac_aux_dir/missing
+#    fails when called from a subdirectory if $ac_aux_dir is relative
+# $top_srcdir/$ac_aux_dir/missing
+#    fails if $ac_aux_dir is absolute,
+#    fails when called from a subdirectory in a VPATH build with
+#          a relative $ac_aux_dir
+#
+# The reason of the latter failure is that $top_srcdir and $ac_aux_dir
+# are both prefixed by $srcdir.  In an in-source build this is usually
+# harmless because $srcdir is '.', but things will broke when you
+# start a VPATH build or use an absolute $srcdir.
+#
+# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
+# iff we strip the leading $srcdir from $ac_aux_dir.  That would be:
+#   am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"`
+# and then we would define $MISSING as
+#   MISSING="\${SHELL} $am_aux_dir/missing"
+# This will work as long as MISSING is not called from configure, because
+# unfortunately $(top_srcdir) has no meaning in configure.
+# However there are other variables, like CC, which are often used in
+# configure, and could therefore not use this "fixed" $ac_aux_dir.
+#
+# Another solution, used here, is to always expand $ac_aux_dir to an
+# absolute PATH.  The drawback is that using absolute paths prevent a
+# configured tree to be moved without reconfiguration.
+
+AC_DEFUN([AM_AUX_DIR_EXPAND],
+[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
+# Expand $ac_aux_dir to an absolute path.
+am_aux_dir=`cd "$ac_aux_dir" && pwd`
+])
+
+# AM_CONDITIONAL                                            -*- Autoconf -*-
+
+# Copyright (C) 1997-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_CONDITIONAL(NAME, SHELL-CONDITION)
+# -------------------------------------
+# Define a conditional.
+AC_DEFUN([AM_CONDITIONAL],
+[AC_PREREQ([2.52])dnl
+ m4_if([$1], [TRUE],  [AC_FATAL([$0: invalid condition: $1])],
+       [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
+AC_SUBST([$1_TRUE])dnl
+AC_SUBST([$1_FALSE])dnl
+_AM_SUBST_NOTMAKE([$1_TRUE])dnl
+_AM_SUBST_NOTMAKE([$1_FALSE])dnl
+m4_define([_AM_COND_VALUE_$1], [$2])dnl
+if $2; then
+  $1_TRUE=
+  $1_FALSE='#'
+else
+  $1_TRUE='#'
+  $1_FALSE=
+fi
+AC_CONFIG_COMMANDS_PRE(
+[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then
+  AC_MSG_ERROR([[conditional "$1" was never defined.
+Usually this means the macro was only invoked conditionally.]])
+fi])])
+
+# Copyright (C) 1999-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+
+# There are a few dirty hacks below to avoid letting 'AC_PROG_CC' be
+# written in clear, in which case automake, when reading aclocal.m4,
+# will think it sees a *use*, and therefore will trigger all it's
+# C support machinery.  Also note that it means that autoscan, seeing
+# CC etc. in the Makefile, will ask for an AC_PROG_CC use...
+
+
+# _AM_DEPENDENCIES(NAME)
+# ----------------------
+# See how the compiler implements dependency checking.
+# NAME is "CC", "CXX", "OBJC", "OBJCXX", "UPC", or "GJC".
+# We try a few techniques and use that to set a single cache variable.
+#
+# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was
+# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular
+# dependency, and given that the user is not expected to run this macro,
+# just rely on AC_PROG_CC.
+AC_DEFUN([_AM_DEPENDENCIES],
+[AC_REQUIRE([AM_SET_DEPDIR])dnl
+AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl
+AC_REQUIRE([AM_MAKE_INCLUDE])dnl
+AC_REQUIRE([AM_DEP_TRACK])dnl
+
+m4_if([$1], [CC],   [depcc="$CC"   am_compiler_list=],
+      [$1], [CXX],  [depcc="$CXX"  am_compiler_list=],
+      [$1], [OBJC], [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
+      [$1], [OBJCXX], [depcc="$OBJCXX" am_compiler_list='gcc3 gcc'],
+      [$1], [UPC],  [depcc="$UPC"  am_compiler_list=],
+      [$1], [GCJ],  [depcc="$GCJ"  am_compiler_list='gcc3 gcc'],
+                    [depcc="$$1"   am_compiler_list=])
+
+AC_CACHE_CHECK([dependency style of $depcc],
+               [am_cv_$1_dependencies_compiler_type],
+[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named 'D' -- because '-MD' means "put the output
+  # in D".
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_$1_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp`
+  fi
+  am__universal=false
+  m4_case([$1], [CC],
+    [case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac],
+    [CXX],
+    [case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac])
+
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+      # Solaris 10 /bin/sh.
+      echo '/* dummy */' > sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    # We check with '-c' and '-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle '-M -o', and we need to detect this.  Also, some Intel
+    # versions had trouble with output in subdirs.
+    am__obj=sub/conftest.${OBJEXT-o}
+    am__minus_obj="-o $am__obj"
+    case $depmode in
+    gcc)
+      # This depmode causes a compiler race in universal mode.
+      test "$am__universal" = false || continue
+      ;;
+    nosideeffect)
+      # After this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested.
+      if test "x$enable_dependency_tracking" = xyes; then
+  continue
+      else
+  break
+      fi
+      ;;
+    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+      # This compiler won't grok '-c -o', but also, the minuso test has
+      # not run yet.  These depmodes are late enough in the game, and
+      # so weak that their functioning should not be impacted.
+      am__obj=conftest.${OBJEXT-o}
+      am__minus_obj=
+      ;;
+    none) break ;;
+    esac
+    if depmode=$depmode \
+       source=sub/conftest.c object=$am__obj \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_$1_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_$1_dependencies_compiler_type=none
+fi
+])
+AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type])
+AM_CONDITIONAL([am__fastdep$1], [
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_$1_dependencies_compiler_type" = gcc3])
+])
+
+
+# AM_SET_DEPDIR
+# -------------
+# Choose a directory name for dependency files.
+# This macro is AC_REQUIREd in _AM_DEPENDENCIES.
+AC_DEFUN([AM_SET_DEPDIR],
+[AC_REQUIRE([AM_SET_LEADING_DOT])dnl
+AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl
+])
+
+
+# AM_DEP_TRACK
+# ------------
+AC_DEFUN([AM_DEP_TRACK],
+[AC_ARG_ENABLE([dependency-tracking], [dnl
+AS_HELP_STRING(
+  [--enable-dependency-tracking],
+  [do not reject slow dependency extractors])
+AS_HELP_STRING(
+  [--disable-dependency-tracking],
+  [speeds up one-time build])])
+if test "x$enable_dependency_tracking" != xno; then
+  am_depcomp="$ac_aux_dir/depcomp"
+  AMDEPBACKSLASH='\'
+  am__nodep='_no'
+fi
+AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])
+AC_SUBST([AMDEPBACKSLASH])dnl
+_AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl
+AC_SUBST([am__nodep])dnl
+_AM_SUBST_NOTMAKE([am__nodep])dnl
+])
+
+# Generate code to set up dependency tracking.              -*- Autoconf -*-
+
+# Copyright (C) 1999-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+
+# _AM_OUTPUT_DEPENDENCY_COMMANDS
+# ------------------------------
+AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
+[{
+  # Older Autoconf quotes --file arguments for eval, but not when files
+  # are listed without --file.  Let's play safe and only enable the eval
+  # if we detect the quoting.
+  case $CONFIG_FILES in
+  *\'*) eval set x "$CONFIG_FILES" ;;
+  *)   set x $CONFIG_FILES ;;
+  esac
+  shift
+  for mf
+  do
+    # Strip MF so we end up with the name of the file.
+    mf=`echo "$mf" | sed -e 's/:.*$//'`
+    # Check whether this is an Automake generated Makefile or not.
+    # We used to match only the files named 'Makefile.in', but
+    # some people rename them; so instead we look at the file content.
+    # Grep'ing the first line is not enough: some people post-process
+    # each Makefile.in and add a new line on top of each file to say so.
+    # Grep'ing the whole file is not good either: AIX grep has a line
+    # limit of 2048, but all sed's we know have understand at least 4000.
+    if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
+      dirpart=`AS_DIRNAME("$mf")`
+    else
+      continue
+    fi
+    # Extract the definition of DEPDIR, am__include, and am__quote
+    # from the Makefile without running 'make'.
+    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
+    test -z "$DEPDIR" && continue
+    am__include=`sed -n 's/^am__include = //p' < "$mf"`
+    test -z "$am__include" && continue
+    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
+    # Find all dependency output files, they are included files with
+    # $(DEPDIR) in their names.  We invoke sed twice because it is the
+    # simplest approach to changing $(DEPDIR) to its actual value in the
+    # expansion.
+    for file in `sed -n "
+      s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
+   sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
+      # Make sure the directory exists.
+      test -f "$dirpart/$file" && continue
+      fdir=`AS_DIRNAME(["$file"])`
+      AS_MKDIR_P([$dirpart/$fdir])
+      # echo "creating $dirpart/$file"
+      echo '# dummy' > "$dirpart/$file"
+    done
+  done
+}
+])# _AM_OUTPUT_DEPENDENCY_COMMANDS
+
+
+# AM_OUTPUT_DEPENDENCY_COMMANDS
+# -----------------------------
+# This macro should only be invoked once -- use via AC_REQUIRE.
+#
+# This code is only required when automatic dependency tracking
+# is enabled.  FIXME.  This creates each '.P' file that we will
+# need in order to bootstrap the dependency handling code.
+AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
+[AC_CONFIG_COMMANDS([depfiles],
+     [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],
+     [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"])
+])
+
+# Do all the work for Automake.                             -*- Autoconf -*-
+
+# Copyright (C) 1996-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This macro actually does too much.  Some checks are only needed if
+# your package does certain things.  But this isn't really a big deal.
+
+dnl Redefine AC_PROG_CC to automatically invoke _AM_PROG_CC_C_O.
+m4_define([AC_PROG_CC],
+m4_defn([AC_PROG_CC])
+[_AM_PROG_CC_C_O
+])
+
+# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
+# AM_INIT_AUTOMAKE([OPTIONS])
+# -----------------------------------------------
+# The call with PACKAGE and VERSION arguments is the old style
+# call (pre autoconf-2.50), which is being phased out.  PACKAGE
+# and VERSION should now be passed to AC_INIT and removed from
+# the call to AM_INIT_AUTOMAKE.
+# We support both call styles for the transition.  After
+# the next Automake release, Autoconf can make the AC_INIT
+# arguments mandatory, and then we can depend on a new Autoconf
+# release and drop the old call support.
+AC_DEFUN([AM_INIT_AUTOMAKE],
+[AC_PREREQ([2.65])dnl
+dnl Autoconf wants to disallow AM_ names.  We explicitly allow
+dnl the ones we care about.
+m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
+AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl
+AC_REQUIRE([AC_PROG_INSTALL])dnl
+if test "`cd $srcdir && pwd`" != "`pwd`"; then
+  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
+  # is not polluted with repeated "-I."
+  AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl
+  # test to see if srcdir already configured
+  if test -f $srcdir/config.status; then
+    AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
+  fi
+fi
+
+# test whether we have cygpath
+if test -z "$CYGPATH_W"; then
+  if (cygpath --version) >/dev/null 2>/dev/null; then
+    CYGPATH_W='cygpath -w'
+  else
+    CYGPATH_W=echo
+  fi
+fi
+AC_SUBST([CYGPATH_W])
+
+# Define the identity of the package.
+dnl Distinguish between old-style and new-style calls.
+m4_ifval([$2],
+[AC_DIAGNOSE([obsolete],
+             [$0: two- and three-arguments forms are deprecated.])
+m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
+ AC_SUBST([PACKAGE], [$1])dnl
+ AC_SUBST([VERSION], [$2])],
+[_AM_SET_OPTIONS([$1])dnl
+dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
+m4_if(
+  m4_ifdef([AC_PACKAGE_NAME], [ok]):m4_ifdef([AC_PACKAGE_VERSION], [ok]),
+  [ok:ok],,
+  [m4_fatal([AC_INIT should be called with package and version arguments])])dnl
+ AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
+ AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl
+
+_AM_IF_OPTION([no-define],,
+[AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package])
+ AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl
+
+# Some tools Automake needs.
+AC_REQUIRE([AM_SANITY_CHECK])dnl
+AC_REQUIRE([AC_ARG_PROGRAM])dnl
+AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}])
+AM_MISSING_PROG([AUTOCONF], [autoconf])
+AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}])
+AM_MISSING_PROG([AUTOHEADER], [autoheader])
+AM_MISSING_PROG([MAKEINFO], [makeinfo])
+AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
+AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl
+AC_REQUIRE([AC_PROG_MKDIR_P])dnl
+# For better backward compatibility.  To be removed once Automake 1.9.x
+# dies out for good.  For more background, see:
+# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+AC_SUBST([mkdir_p], ['$(MKDIR_P)'])
+# We need awk for the "check" target (and possibly the TAP driver).  The
+# system "awk" is bad on some platforms.
+AC_REQUIRE([AC_PROG_AWK])dnl
+AC_REQUIRE([AC_PROG_MAKE_SET])dnl
+AC_REQUIRE([AM_SET_LEADING_DOT])dnl
+_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])],
+        [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],
+           [_AM_PROG_TAR([v7])])])
+_AM_IF_OPTION([no-dependencies],,
+[AC_PROVIDE_IFELSE([AC_PROG_CC],
+      [_AM_DEPENDENCIES([CC])],
+      [m4_define([AC_PROG_CC],
+           m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_CXX],
+      [_AM_DEPENDENCIES([CXX])],
+      [m4_define([AC_PROG_CXX],
+           m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_OBJC],
+      [_AM_DEPENDENCIES([OBJC])],
+      [m4_define([AC_PROG_OBJC],
+           m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_OBJCXX],
+      [_AM_DEPENDENCIES([OBJCXX])],
+      [m4_define([AC_PROG_OBJCXX],
+           m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl
+])
+AC_REQUIRE([AM_SILENT_RULES])dnl
+dnl The testsuite driver may need to know about EXEEXT, so add the
+dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen.  This
+dnl macro is hooked onto _AC_COMPILER_EXEEXT early, see below.
+AC_CONFIG_COMMANDS_PRE(dnl
+[m4_provide_if([_AM_COMPILER_EXEEXT],
+  [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl
+
+# POSIX will say in a future version that running "rm -f" with no argument
+# is OK; and we want to be able to make that assumption in our Makefile
+# recipes.  So use an aggressive probe to check that the usage we want is
+# actually supported "in the wild" to an acceptable degree.
+# See automake bug#10828.
+# To make any issue more visible, cause the running configure to be aborted
+# by default if the 'rm' program in use doesn't match our expectations; the
+# user can still override this though.
+if rm -f && rm -fr && rm -rf; then : OK; else
+  cat >&2 <<'END'
+Oops!
+
+Your 'rm' program seems unable to run without file operands specified
+on the command line, even when the '-f' option is present.  This is contrary
+to the behaviour of most rm programs out there, and not conforming with
+the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
+
+Please tell [e-mail] about your system, including the value
+of your $PATH and any error possibly output before this message.  This
+can help us improve future automake versions.
+
+END
+  if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
+    echo 'Configuration will proceed anyway, since you have set the' >&2
+    echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
+    echo >&2
+  else
+    cat >&2 <<'END'
+Aborting the configuration process, to ensure you take notice of the issue.
+
+You can download and install GNU coreutils to get an 'rm' implementation
+that behaves properly: <http://www.gnu.org/software/coreutils/>.
+
+If you want to complete the configuration process using your problematic
+'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
+to "yes", and re-run configure.
+
+END
+    AC_MSG_ERROR([Your 'rm' program is bad, sorry.])
+  fi
+fi
+dnl The trailing newline in this macro's definition is deliberate, for
+dnl backward compatibility and to allow trailing 'dnl'-style comments
+dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841.
+])
+
+dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion.  Do not
+dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
+dnl mangled by Autoconf and run in a shell conditional statement.
+m4_define([_AC_COMPILER_EXEEXT],
+m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])])
+
+# When config.status generates a header, we must update the stamp-h file.
+# This file resides in the same directory as the config header
+# that is generated.  The stamp files are numbered to have different names.
+
+# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the
+# loop where config.status creates the headers, so we can generate
+# our stamp files there.
+AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK],
+[# Compute $1's index in $config_headers.
+_am_arg=$1
+_am_stamp_count=1
+for _am_header in $config_headers :; do
+  case $_am_header in
+    $_am_arg | $_am_arg:* )
+      break ;;
+    * )
+      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+  esac
+done
+echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
+
+# Copyright (C) 2001-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_PROG_INSTALL_SH
+# ------------------
+# Define $install_sh.
+AC_DEFUN([AM_PROG_INSTALL_SH],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+if test x"${install_sh+set}" != xset; then
+  case $am_aux_dir in
+  *\ * | *\ *)
+    install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
+  *)
+    install_sh="\${SHELL} $am_aux_dir/install-sh"
+  esac
+fi
+AC_SUBST([install_sh])])
+
+# Copyright (C) 2003-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# Check whether the underlying file-system supports filenames
+# with a leading dot.  For instance MS-DOS doesn't.
+AC_DEFUN([AM_SET_LEADING_DOT],
+[rm -rf .tst 2>/dev/null
+mkdir .tst 2>/dev/null
+if test -d .tst; then
+  am__leading_dot=.
+else
+  am__leading_dot=_
+fi
+rmdir .tst 2>/dev/null
+AC_SUBST([am__leading_dot])])
+
+# Check to see how 'make' treats includes.              -*- Autoconf -*-
+
+# Copyright (C) 2001-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_MAKE_INCLUDE()
+# -----------------
+# Check to see how make treats includes.
+AC_DEFUN([AM_MAKE_INCLUDE],
+[am_make=${MAKE-make}
+cat > confinc << 'END'
+am__doit:
+  @echo this is the am__doit target
+.PHONY: am__doit
+END
+# If we don't find an include directive, just comment out the code.
+AC_MSG_CHECKING([for style of include used by $am_make])
+am__include="#"
+am__quote=
+_am_result=none
+# First try GNU make style include.
+echo "include confinc" > confmf
+# Ignore all kinds of additional output from 'make'.
+case `$am_make -s -f confmf 2> /dev/null` in #(
+*the\ am__doit\ target*)
+  am__include=include
+  am__quote=
+  _am_result=GNU
+  ;;
+esac
+# Now try BSD make style include.
+if test "$am__include" = "#"; then
+   echo '.include "confinc"' > confmf
+   case `$am_make -s -f confmf 2> /dev/null` in #(
+   *the\ am__doit\ target*)
+     am__include=.include
+     am__quote="\""
+     _am_result=BSD
+     ;;
+   esac
+fi
+AC_SUBST([am__include])
+AC_SUBST([am__quote])
+AC_MSG_RESULT([$_am_result])
+rm -f confinc confmf
+])
+
+# Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-
+
+# Copyright (C) 1997-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_MISSING_PROG(NAME, PROGRAM)
+# ------------------------------
+AC_DEFUN([AM_MISSING_PROG],
+[AC_REQUIRE([AM_MISSING_HAS_RUN])
+$1=${$1-"${am_missing_run}$2"}
+AC_SUBST($1)])
+
+# AM_MISSING_HAS_RUN
+# ------------------
+# Define MISSING if not defined so far and test if it is modern enough.
+# If it is, set am_missing_run to use it, otherwise, to nothing.
+AC_DEFUN([AM_MISSING_HAS_RUN],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+AC_REQUIRE_AUX_FILE([missing])dnl
+if test x"${MISSING+set}" != xset; then
+  case $am_aux_dir in
+  *\ * | *\ *)
+    MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
+  *)
+    MISSING="\${SHELL} $am_aux_dir/missing" ;;
+  esac
+fi
+# Use eval to expand $SHELL
+if eval "$MISSING --is-lightweight"; then
+  am_missing_run="$MISSING "
+else
+  am_missing_run=
+  AC_MSG_WARN(['missing' script is too old or missing])
+fi
+])
+
+# Helper functions for option handling.                     -*- Autoconf -*-
+
+# Copyright (C) 2001-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_MANGLE_OPTION(NAME)
+# -----------------------
+AC_DEFUN([_AM_MANGLE_OPTION],
+[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])
+
+# _AM_SET_OPTION(NAME)
+# --------------------
+# Set option NAME.  Presently that only means defining a flag for this option.
+AC_DEFUN([_AM_SET_OPTION],
+[m4_define(_AM_MANGLE_OPTION([$1]), [1])])
+
+# _AM_SET_OPTIONS(OPTIONS)
+# ------------------------
+# OPTIONS is a space-separated list of Automake options.
+AC_DEFUN([_AM_SET_OPTIONS],
+[m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])])
+
+# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])
+# -------------------------------------------
+# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
+AC_DEFUN([_AM_IF_OPTION],
+[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
+
+# Copyright (C) 1999-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_PROG_CC_C_O
+# ---------------
+# Like AC_PROG_CC_C_O, but changed for automake.  We rewrite AC_PROG_CC
+# to automatically call this.
+AC_DEFUN([_AM_PROG_CC_C_O],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+AC_REQUIRE_AUX_FILE([compile])dnl
+AC_LANG_PUSH([C])dnl
+AC_CACHE_CHECK(
+  [whether $CC understands -c and -o together],
+  [am_cv_prog_cc_c_o],
+  [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
+  # Make sure it works both with $CC and with simple cc.
+  # Following AC_PROG_CC_C_O, we do the test twice because some
+  # compilers refuse to overwrite an existing .o file with -o,
+  # though they will create one.
+  am_cv_prog_cc_c_o=yes
+  for am_i in 1 2; do
+    if AM_RUN_LOG([$CC -c conftest.$ac_ext -o conftest2.$ac_objext]) \
+         && test -f conftest2.$ac_objext; then
+      : OK
+    else
+      am_cv_prog_cc_c_o=no
+      break
+    fi
+  done
+  rm -f core conftest*
+  unset am_i])
+if test "$am_cv_prog_cc_c_o" != yes; then
+   # Losing compiler, so override with the script.
+   # FIXME: It is wrong to rewrite CC.
+   # But if we don't then we get into trouble of one sort or another.
+   # A longer-term fix would be to have automake use am__CC in this case,
+   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+   CC="$am_aux_dir/compile $CC"
+fi
+AC_LANG_POP([C])])
+
+# For backward compatibility.
+AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])])
+
+# Copyright (C) 2001-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_RUN_LOG(COMMAND)
+# -------------------
+# Run COMMAND, save the exit status in ac_status, and log it.
+# (This has been adapted from Autoconf's _AC_RUN_LOG macro.)
+AC_DEFUN([AM_RUN_LOG],
+[{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD
+   ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+   (exit $ac_status); }])
+
+# Check to make sure that the build environment is sane.    -*- Autoconf -*-
+
+# Copyright (C) 1996-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_SANITY_CHECK
+# ---------------
+AC_DEFUN([AM_SANITY_CHECK],
+[AC_MSG_CHECKING([whether build environment is sane])
+# Reject unsafe characters in $srcdir or the absolute working directory
+# name.  Accept space and tab only in the latter.
+am_lf='
+'
+case `pwd` in
+  *[[\\\"\#\$\&\'\`$am_lf]]*)
+    AC_MSG_ERROR([unsafe absolute working directory name]);;
+esac
+case $srcdir in
+  *[[\\\"\#\$\&\'\`$am_lf\ \  ]]*)
+    AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);;
+esac
+
+# Do 'set' in a subshell so we don't clobber the current shell's
+# arguments.  Must try -L first in case configure is actually a
+# symlink; some systems play weird games with the mod time of symlinks
+# (eg FreeBSD returns the mod time of the symlink's containing
+# directory).
+if (
+   am_has_slept=no
+   for am_try in 1 2; do
+     echo "timestamp, slept: $am_has_slept" > conftest.file
+     set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
+     if test "$[*]" = "X"; then
+  # -L didn't work.
+  set X `ls -t "$srcdir/configure" conftest.file`
+     fi
+     if test "$[*]" != "X $srcdir/configure conftest.file" \
+  && test "$[*]" != "X conftest.file $srcdir/configure"; then
+
+  # If neither matched, then we have a broken ls.  This can happen
+  # if, for instance, CONFIG_SHELL is bash and it inherits a
+  # broken ls alias from the environment.  This has actually
+  # happened.  Such a system could not be considered "sane".
+  AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
+  alias in your environment])
+     fi
+     if test "$[2]" = conftest.file || test $am_try -eq 2; then
+       break
+     fi
+     # Just in case.
+     sleep 1
+     am_has_slept=yes
+   done
+   test "$[2]" = conftest.file
+   )
+then
+   # Ok.
+   :
+else
+   AC_MSG_ERROR([newly created file is older than distributed files!
+Check your system clock])
+fi
+AC_MSG_RESULT([yes])
+# If we didn't sleep, we still need to ensure time stamps of config.status and
+# generated files are strictly newer.
+am_sleep_pid=
+if grep 'slept: no' conftest.file >/dev/null 2>&1; then
+  ( sleep 1 ) &
+  am_sleep_pid=$!
+fi
+AC_CONFIG_COMMANDS_PRE(
+  [AC_MSG_CHECKING([that generated files are newer than configure])
+   if test -n "$am_sleep_pid"; then
+     # Hide warnings about reused PIDs.
+     wait $am_sleep_pid 2>/dev/null
+   fi
+   AC_MSG_RESULT([done])])
+rm -f conftest.file
+])
+
+# Copyright (C) 2009-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_SILENT_RULES([DEFAULT])
+# --------------------------
+# Enable less verbose build rules; with the default set to DEFAULT
+# ("yes" being less verbose, "no" or empty being verbose).
+AC_DEFUN([AM_SILENT_RULES],
+[AC_ARG_ENABLE([silent-rules], [dnl
+AS_HELP_STRING(
+  [--enable-silent-rules],
+  [less verbose build output (undo: "make V=1")])
+AS_HELP_STRING(
+  [--disable-silent-rules],
+  [verbose build output (undo: "make V=0")])dnl
+])
+case $enable_silent_rules in @%:@ (((
+  yes) AM_DEFAULT_VERBOSITY=0;;
+   no) AM_DEFAULT_VERBOSITY=1;;
+    *) AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1]);;
+esac
+dnl
+dnl A few 'make' implementations (e.g., NonStop OS and NextStep)
+dnl do not support nested variable expansions.
+dnl See automake bug#9928 and bug#10237.
+am_make=${MAKE-make}
+AC_CACHE_CHECK([whether $am_make supports nested variables],
+   [am_cv_make_support_nested_variables],
+   [if AS_ECHO([['TRUE=$(BAR$(V))
+BAR0=false
+BAR1=true
+V=1
+am__doit:
+  @$(TRUE)
+.PHONY: am__doit']]) | $am_make -f - >/dev/null 2>&1; then
+  am_cv_make_support_nested_variables=yes
+else
+  am_cv_make_support_nested_variables=no
+fi])
+if test $am_cv_make_support_nested_variables = yes; then
+  dnl Using '$V' instead of '$(V)' breaks IRIX make.
+  AM_V='$(V)'
+  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
+else
+  AM_V=$AM_DEFAULT_VERBOSITY
+  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
+fi
+AC_SUBST([AM_V])dnl
+AM_SUBST_NOTMAKE([AM_V])dnl
+AC_SUBST([AM_DEFAULT_V])dnl
+AM_SUBST_NOTMAKE([AM_DEFAULT_V])dnl
+AC_SUBST([AM_DEFAULT_VERBOSITY])dnl
+AM_BACKSLASH='\'
+AC_SUBST([AM_BACKSLASH])dnl
+_AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl
+])
+
+# Copyright (C) 2001-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_PROG_INSTALL_STRIP
+# ---------------------
+# One issue with vendor 'install' (even GNU) is that you can't
+# specify the program used to strip binaries.  This is especially
+# annoying in cross-compiling environments, where the build's strip
+# is unlikely to handle the host's binaries.
+# Fortunately install-sh will honor a STRIPPROG variable, so we
+# always use install-sh in "make install-strip", and initialize
+# STRIPPROG with the value of the STRIP variable (set by the user).
+AC_DEFUN([AM_PROG_INSTALL_STRIP],
+[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
+# Installed binaries are usually stripped using 'strip' when the user
+# run "make install-strip".  However 'strip' might not be the right
+# tool to use in cross-compilation environments, therefore Automake
+# will honor the 'STRIP' environment variable to overrule this program.
+dnl Don't test for $cross_compiling = yes, because it might be 'maybe'.
+if test "$cross_compiling" != no; then
+  AC_CHECK_TOOL([STRIP], [strip], :)
+fi
+INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
+AC_SUBST([INSTALL_STRIP_PROGRAM])])
+
+# Copyright (C) 2006-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_SUBST_NOTMAKE(VARIABLE)
+# ---------------------------
+# Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in.
+# This macro is traced by Automake.
+AC_DEFUN([_AM_SUBST_NOTMAKE])
+
+# AM_SUBST_NOTMAKE(VARIABLE)
+# --------------------------
+# Public sister of _AM_SUBST_NOTMAKE.
+AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)])
+
+# Check how to create a tarball.                            -*- Autoconf -*-
+
+# Copyright (C) 2004-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_PROG_TAR(FORMAT)
+# --------------------
+# Check how to create a tarball in format FORMAT.
+# FORMAT should be one of 'v7', 'ustar', or 'pax'.
+#
+# Substitute a variable $(am__tar) that is a command
+# writing to stdout a FORMAT-tarball containing the directory
+# $tardir.
+#     tardir=directory && $(am__tar) > result.tar
+#
+# Substitute a variable $(am__untar) that extract such
+# a tarball read from stdin.
+#     $(am__untar) < result.tar
+#
+AC_DEFUN([_AM_PROG_TAR],
+[# Always define AMTAR for backward compatibility.  Yes, it's still used
+# in the wild :-(  We should find a proper way to deprecate it ...
+AC_SUBST([AMTAR], ['$${TAR-tar}'])
+
+# We'll loop over all known methods to create a tar archive until one works.
+_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
+
+m4_if([$1], [v7],
+  [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],
+
+  [m4_case([$1],
+    [ustar],
+     [# The POSIX 1988 'ustar' format is defined with fixed-size fields.
+      # There is notably a 21 bits limit for the UID and the GID.  In fact,
+      # the 'pax' utility can hang on bigger UID/GID (see automake bug#8343
+      # and bug#13588).
+      am_max_uid=2097151 # 2^21 - 1
+      am_max_gid=$am_max_uid
+      # The $UID and $GID variables are not portable, so we need to resort
+      # to the POSIX-mandated id(1) utility.  Errors in the 'id' calls
+      # below are definitely unexpected, so allow the users to see them
+      # (that is, avoid stderr redirection).
+      am_uid=`id -u || echo unknown`
+      am_gid=`id -g || echo unknown`
+      AC_MSG_CHECKING([whether UID '$am_uid' is supported by ustar format])
+      if test $am_uid -le $am_max_uid; then
+         AC_MSG_RESULT([yes])
+      else
+         AC_MSG_RESULT([no])
+         _am_tools=none
+      fi
+      AC_MSG_CHECKING([whether GID '$am_gid' is supported by ustar format])
+      if test $am_gid -le $am_max_gid; then
+         AC_MSG_RESULT([yes])
+      else
+        AC_MSG_RESULT([no])
+        _am_tools=none
+      fi],
+
+  [pax],
+    [],
+
+  [m4_fatal([Unknown tar format])])
+
+  AC_MSG_CHECKING([how to create a $1 tar archive])
+
+  # Go ahead even if we have the value already cached.  We do so because we
+  # need to set the values for the 'am__tar' and 'am__untar' variables.
+  _am_tools=${am_cv_prog_tar_$1-$_am_tools}
+
+  for _am_tool in $_am_tools; do
+    case $_am_tool in
+    gnutar)
+      for _am_tar in tar gnutar gtar; do
+        AM_RUN_LOG([$_am_tar --version]) && break
+      done
+      am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
+      am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
+      am__untar="$_am_tar -xf -"
+      ;;
+    plaintar)
+      # Must skip GNU tar: if it does not support --format= it doesn't create
+      # ustar tarball either.
+      (tar --version) >/dev/null 2>&1 && continue
+      am__tar='tar chf - "$$tardir"'
+      am__tar_='tar chf - "$tardir"'
+      am__untar='tar xf -'
+      ;;
+    pax)
+      am__tar='pax -L -x $1 -w "$$tardir"'
+      am__tar_='pax -L -x $1 -w "$tardir"'
+      am__untar='pax -r'
+      ;;
+    cpio)
+      am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
+      am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
+      am__untar='cpio -i -H $1 -d'
+      ;;
+    none)
+      am__tar=false
+      am__tar_=false
+      am__untar=false
+      ;;
+    esac
+
+    # If the value was cached, stop now.  We just wanted to have am__tar
+    # and am__untar set.
+    test -n "${am_cv_prog_tar_$1}" && break
+
+    # tar/untar a dummy directory, and stop if the command works.
+    rm -rf conftest.dir
+    mkdir conftest.dir
+    echo GrepMe > conftest.dir/file
+    AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
+    rm -rf conftest.dir
+    if test -s conftest.tar; then
+      AM_RUN_LOG([$am__untar <conftest.tar])
+      AM_RUN_LOG([cat conftest.dir/file])
+      grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
+    fi
+  done
+  rm -rf conftest.dir
+
+  AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
+  AC_MSG_RESULT([$am_cv_prog_tar_$1])])
+
+AC_SUBST([am__tar])
+AC_SUBST([am__untar])
+]) # _AM_PROG_TAR
+
+m4_include([m4/ax_check_opencl.m4])
+m4_include([m4/ax_check_openmp.m4])
+m4_include([m4/ax_detect_git_head.m4])
+m4_include([m4/ax_submodule.m4])
+m4_include([m4/libtool.m4])
+m4_include([m4/ltoptions.m4])
+m4_include([m4/ltsugar.m4])
+m4_include([m4/ltversion.m4])
+m4_include([m4/lt~obsolete.m4])

polly/trunk/lib/External/ppcg/compile

+#! /bin/sh
+# Wrapper for compilers which do not understand '-c -o'.
+
+scriptversion=2012-10-14.11; # UTC
+
+# Copyright (C) 1999-2013 Free Software Foundation, Inc.
+# Written by Tom Tromey <[e-mail]>.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# This file is maintained in Automake, please report
+# bugs to <[e-mail]> or send patches to
+# <[e-mail]>.
+
+nl='
+'
+
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent tools from complaining about whitespace usage.
+IFS=" "" $nl"
+
+file_conv=
+
+# func_file_conv build_file lazy
+# Convert a $build file to $host form and store it in $file
+# Currently only supports Windows hosts. If the determined conversion
+# type is listed in (the comma separated) LAZY, no conversion will
+# take place.
+func_file_conv ()
+{
+  file=$1
+  case $file in
+    / | /[!/]*) # absolute file, and not a UNC file
+      if test -z "$file_conv"; then
+  # lazily determine how to convert abs files
+  case `uname -s` in
+    MINGW*)
+      file_conv=mingw
+      ;;
+    CYGWIN*)
+      file_conv=cygwin
+      ;;
+    *)
+      file_conv=wine
+      ;;
+  esac
+      fi
+      case $file_conv/,$2, in
+  *,$file_conv,*)
+    ;;
+  mingw/*)
+    file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'`
+    ;;
+  cygwin/*)
+    file=`cygpath -m "$file" || echo "$file"`
+    ;;
+  wine/*)
+    file=`winepath -w "$file" || echo "$file"`
+    ;;
+      esac
+      ;;
+  esac
+}
+
+# func_cl_dashL linkdir
+# Make cl look for libraries in LINKDIR
+func_cl_dashL ()
+{
+  func_file_conv "$1"
+  if test -z "$lib_path"; then
+    lib_path=$file
+  else
+    lib_path="$lib_path;$file"
+  fi
+  linker_opts="$linker_opts -LIBPATH:$file"
+}
+
+# func_cl_dashl library
+# Do a library search-path lookup for cl
+func_cl_dashl ()
+{
+  lib=$1
+  found=no
+  save_IFS=$IFS
+  IFS=';'
+  for dir in $lib_path $LIB
+  do
+    IFS=$save_IFS
+    if $shared && test -f "$dir/$lib.dll.lib"; then
+      found=yes
+      lib=$dir/$lib.dll.lib
+      break
+    fi
+    if test -f "$dir/$lib.lib"; then
+      found=yes
+      lib=$dir/$lib.lib
+      break
+    fi
+    if test -f "$dir/lib$lib.a"; then
+      found=yes
+      lib=$dir/lib$lib.a
+      break
+    fi
+  done
+  IFS=$save_IFS
+
+  if test "$found" != yes; then
+    lib=$lib.lib
+  fi
+}
+
+# func_cl_wrapper cl arg...
+# Adjust compile command to suit cl
+func_cl_wrapper ()
+{
+  # Assume a capable shell
+  lib_path=
+  shared=:
+  linker_opts=
+  for arg
+  do
+    if test -n "$eat"; then
+      eat=
+    else
+      case $1 in
+  -o)
+    # configure might choose to run compile as 'compile cc -o foo foo.c'.
+    eat=1
+    case $2 in
+      *.o | *.[oO][bB][jJ])
+        func_file_conv "$2"
+        set x "$@" -Fo"$file"
+        shift
+        ;;
+      *)
+        func_file_conv "$2"
+        set x "$@" -Fe"$file"
+        shift
+        ;;
+    esac
+    ;;
+  -I)
+    eat=1
+    func_file_conv "$2" mingw
+    set x "$@" -I"$file"
+    shift
+    ;;
+  -I*)
+    func_file_conv "${1#-I}" mingw
+    set x "$@" -I"$file"
+    shift
+    ;;
+  -l)
+    eat=1
+    func_cl_dashl "$2"
+    set x "$@" "$lib"
+    shift
+    ;;
+  -l*)
+    func_cl_dashl "${1#-l}"
+    set x "$@" "$lib"
+    shift
+    ;;
+  -L)
+    eat=1
+    func_cl_dashL "$2"
+    ;;
+  -L*)
+    func_cl_dashL "${1#-L}"
+    ;;
+  -static)
+    shared=false
+    ;;
+  -Wl,*)
+    arg=${1#-Wl,}
+    save_ifs="$IFS"; IFS=','
+    for flag in $arg; do
+      IFS="$save_ifs"
+      linker_opts="$linker_opts $flag"
+    done
+    IFS="$save_ifs"
+    ;;
+  -Xlinker)
+    eat=1
+    linker_opts="$linker_opts $2"
+    ;;
+  -*)
+    set x "$@" "$1"
+    shift
+    ;;
+  *.cc | *.CC | *.cxx | *.CXX | *.[cC]++)
+    func_file_conv "$1"
+    set x "$@" -Tp"$file"
+    shift
+    ;;
+  *.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO])
+    func_file_conv "$1" mingw
+    set x "$@" "$file"
+    shift
+    ;;
+  *)
+    set x "$@" "$1"
+    shift
+    ;;
+      esac
+    fi
+    shift
+  done
+  if test -n "$linker_opts"; then
+    linker_opts="-link$linker_opts"
+  fi
+  exec "$@" $linker_opts
+  exit 1
+}
+
+eat=
+
+case $1 in
+  '')
+     echo "$0: No command.  Try '$0 --help' for more information." 1>&2
+     exit 1;
+     ;;
+  -h | --h*)
+    cat <<\EOF
+Usage: compile [--help] [--version] PROGRAM [ARGS]
+
+Wrapper for compilers which do not understand '-c -o'.
+Remove '-o dest.o' from ARGS, run PROGRAM with the remaining
+arguments, and rename the output as expected.
+
+If you are trying to build a whole package this is not the
+right script to run: please start by reading the file 'INSTALL'.
+
+Report bugs to <[e-mail]>.
+EOF
+    exit $?
+    ;;
+  -v | --v*)
+    echo "compile $scriptversion"
+    exit $?
+    ;;
+  cl | *[/\\]cl | cl.exe | *[/\\]cl.exe )
+    func_cl_wrapper "$@"      # Doesn't return...
+    ;;
+esac
+
+ofile=
+cfile=
+
+for arg
+do
+  if test -n "$eat"; then
+    eat=
+  else
+    case $1 in
+      -o)
+  # configure might choose to run compile as 'compile cc -o foo foo.c'.
+  # So we strip '-o arg' only if arg is an object.
+  eat=1
+  case $2 in
+    *.o | *.obj)
+      ofile=$2
+      ;;
+    *)
+      set x "$@" -o "$2"
+      shift
+      ;;
+  esac
+  ;;
+      *.c)
+  cfile=$1
+  set x "$@" "$1"
+  shift
+  ;;
+      *)
+  set x "$@" "$1"
+  shift
+  ;;
+    esac
+  fi
+  shift
+done
+
+if test -z "$ofile" || test -z "$cfile"; then
+  # If no '-o' option was seen then we might have been invoked from a
+  # pattern rule where we don't need one.  That is ok -- this is a
+  # normal compilation that the losing compiler can handle.  If no
+  # '.c' file was seen then we are probably linking.  That is also
+  # ok.
+  exec "$@"
+fi
+
+# Name of file we expect compiler to create.
+cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'`
+
+# Create the lock directory.
+# Note: use '[/\\:.-]' here to ensure that we don't use the same name
+# that we are using for the .o file.  Also, base the name on the expected
+# object file name, since that is what matters with a parallel build.
+lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d
+while true; do
+  if mkdir "$lockdir" >/dev/null 2>&1; then
+    break
+  fi
+  sleep 1
+done
+# FIXME: race condition here if user kills between mkdir and trap.
+trap "rmdir '$lockdir'; exit 1" 1 2 15
+
+# Run the compile.
+"$@"
+ret=$?
+
+if test -f "$cofile"; then
+  test "$cofile" = "$ofile" || mv "$cofile" "$ofile"
+elif test -f "${cofile}bj"; then
+  test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile"
+fi
+
+rmdir "$lockdir"
+exit $ret
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:

polly/trunk/lib/External/ppcg/config.guess

+#! /bin/sh
+# Attempt to guess a canonical system name.
+#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+#   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+#   2011, 2012 Free Software Foundation, Inc.
+
+timestamp='2012-02-10'
+
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <http://www.gnu.org/licenses/>.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+
+# Originally written by Per Bothner.  Please send patches (context
+# diff format) to <[e-mail]> and include a ChangeLog
+# entry.
+#
+# This script attempts to guess a canonical system name similar to
+# config.sub.  If it succeeds, it prints the system name on stdout, and
+# exits with 0.  Otherwise, it exits with 1.
+#
+# You can get the latest version of this script from:
+# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION]
+
+Output the configuration name of the system \`$me' is run on.
+
+Operation modes:
+  -h, --help         print this help, then exit
+  -t, --time-stamp   print date of last modification, then exit
+  -v, --version      print version number, then exit
+
+Report bugs and patches to <[e-mail]>."
+
+version="\
+GNU config.guess ($timestamp)
+
+Originally written by Per Bothner.
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
+Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+  case $1 in
+    --time-stamp | --time* | -t )
+       echo "$timestamp" ; exit ;;
+    --version | -v )
+       echo "$version" ; exit ;;
+    --help | --h* | -h )
+       echo "$usage"; exit ;;
+    -- )     # Stop option processing
+       shift; break ;;
+    - ) # Use stdin as input.
+       break ;;
+    -* )
+       echo "$me: invalid option $1$help" >&2
+       exit 1 ;;
+    * )
+       break ;;
+  esac
+done
+
+if test $# != 0; then
+  echo "$me: too many arguments$help" >&2
+  exit 1
+fi
+
+trap 'exit 1' 1 2 15
+
+# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
+# compiler to aid in system detection is discouraged as it requires
+# temporary files to be created and, as you can see below, it is a
+# headache to deal with in a portable fashion.
+
+# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
+# use `HOST_CC' if defined, but it is deprecated.
+
+# Portable tmp directory creation inspired by the Autoconf team.
+
+set_cc_for_build='
+trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
+trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
+: ${TMPDIR=/tmp} ;
+ { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
+ { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
+ { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
+ { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
+dummy=$tmp/dummy ;
+tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
+case $CC_FOR_BUILD,$HOST_CC,$CC in
+ ,,)    echo "int x;" > $dummy.c ;
+  for c in cc gcc c89 c99 ; do
+    if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
+       CC_FOR_BUILD="$c"; break ;
+    fi ;
+  done ;
+  if test x"$CC_FOR_BUILD" = x ; then
+    CC_FOR_BUILD=no_compiler_found ;
+  fi
+  ;;
+ ,,*)   CC_FOR_BUILD=$CC ;;
+ ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
+esac ; set_cc_for_build= ;'
+
+# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
+# ([e-mail] 1994-08-24)
+if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
+  PATH=$PATH:/.attbin ; export PATH
+fi
+
+UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
+UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
+UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
+UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
+
+# Note: order is significant - the case branches are not exclusive.
+
+case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
+    *:NetBSD:*:*)
+  # NetBSD (nbsd) targets should (where applicable) match one or
+  # more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
+  # *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
+  # switched to ELF, *-*-netbsd* would select the old
+  # object file format.  This provides both forward
+  # compatibility and a consistent mechanism for selecting the
+  # object file format.
+  #
+  # Note: NetBSD doesn't particularly care about the vendor
+  # portion of the name.  We always set it to "unknown".
+  sysctl="sysctl -n hw.machine_arch"
+  UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \
+      /usr/sbin/$sysctl 2>/dev/null || echo unknown)`
+  case "${UNAME_MACHINE_ARCH}" in
+      armeb) machine=armeb-unknown ;;
+      arm*) machine=arm-unknown ;;
+      sh3el) machine=shl-unknown ;;
+      sh3eb) machine=sh-unknown ;;
+      sh5el) machine=sh5le-unknown ;;
+      *) machine=${UNAME_MACHINE_ARCH}-unknown ;;
+  esac
+  # The Operating System including object format, if it has switched
+  # to ELF recently, or will in the future.
+  case "${UNAME_MACHINE_ARCH}" in
+      arm*|i386|m68k|ns32k|sh3*|sparc|vax)
+    eval $set_cc_for_build
+    if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
+      | grep -q __ELF__
+    then
+        # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
+        # Return netbsd for either.  FIX?
+        os=netbsd
+    else
+        os=netbsdelf
+    fi
+    ;;
+      *)
+    os=netbsd
+    ;;
+  esac
+  # The OS release
+  # Debian GNU/NetBSD machines have a different userland, and
+  # thus, need a distinct triplet. However, they do not need
+  # kernel version information, so it can be replaced with a
+  # suitable tag, in the style of linux-gnu.
+  case "${UNAME_VERSION}" in
+      Debian*)
+    release='-gnu'
+    ;;
+      *)
+    release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
+    ;;
+  esac
+  # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
+  # contains redundant information, the shorter form:
+  # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
+  echo "${machine}-${os}${release}"
+  exit ;;
+    *:OpenBSD:*:*)
+  UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
+  echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
+  exit ;;
+    *:ekkoBSD:*:*)
+  echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
+  exit ;;
+    *:SolidBSD:*:*)
+  echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}
+  exit ;;
+    macppc:MirBSD:*:*)
+  echo powerpc-unknown-mirbsd${UNAME_RELEASE}
+  exit ;;
+    *:MirBSD:*:*)
+  echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
+  exit ;;
+    alpha:OSF1:*:*)
+  case $UNAME_RELEASE in
+  *4.0)
+    UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
+    ;;
+  *5.*)
+    UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
+    ;;
+  esac
+  # According to Compaq, /usr/sbin/psrinfo has been available on
+  # OSF/1 and Tru64 systems produced since 1995.  I hope that
+  # covers most systems running today.  This code pipes the CPU
+  # types through head -n 1, so we only detect the type of CPU 0.
+  ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`
+  case "$ALPHA_CPU_TYPE" in
+      "EV4 (21064)")
+    UNAME_MACHINE="alpha" ;;
+      "EV4.5 (21064)")
+    UNAME_MACHINE="alpha" ;;
+      "LCA4 (21066/21068)")
+    UNAME_MACHINE="alpha" ;;
+      "EV5 (21164)")
+    UNAME_MACHINE="alphaev5" ;;
+      "EV5.6 (21164A)")
+    UNAME_MACHINE="alphaev56" ;;
+      "EV5.6 (21164PC)")
+    UNAME_MACHINE="alphapca56" ;;
+      "EV5.7 (21164PC)")
+    UNAME_MACHINE="alphapca57" ;;
+      "EV6 (21264)")
+    UNAME_MACHINE="alphaev6" ;;
+      "EV6.7 (21264A)")
+    UNAME_MACHINE="alphaev67" ;;
+      "EV6.8CB (21264C)")
+    UNAME_MACHINE="alphaev68" ;;
+      "EV6.8AL (21264B)")
+    UNAME_MACHINE="alphaev68" ;;
+      "EV6.8CX (21264D)")
+    UNAME_MACHINE="alphaev68" ;;
+      "EV6.9A (21264/EV69A)")
+    UNAME_MACHINE="alphaev69" ;;
+      "EV7 (21364)")
+    UNAME_MACHINE="alphaev7" ;;
+      "EV7.9 (21364A)")
+    UNAME_MACHINE="alphaev79" ;;
+  esac
+  # A Pn.n version is a patched version.
+  # A Vn.n version is a released version.
+  # A Tn.n version is a released field test version.
+  # A Xn.n version is an unreleased experimental baselevel.
+  # 1.2 uses "1.2" for uname -r.
+  echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
+  # Reset EXIT trap before exiting to avoid spurious non-zero exit code.
+  exitcode=$?
+  trap '' 0
+  exit $exitcode ;;
+    Alpha\ *:Windows_NT*:*)
+  # How do we know it's Interix rather than the generic POSIX subsystem?
+  # Should we change UNAME_MACHINE based on the output of uname instead
+  # of the specific Alpha model?
+  echo alpha-pc-interix
+  exit ;;
+    21064:Windows_NT:50:3)
+  echo alpha-dec-winnt3.5
+  exit ;;
+    Amiga*:UNIX_System_V:4.0:*)
+  echo m68k-unknown-sysv4
+  exit ;;
+    *:[Aa]miga[Oo][Ss]:*:*)
+  echo ${UNAME_MACHINE}-unknown-amigaos
+  exit ;;
+    *:[Mm]orph[Oo][Ss]:*:*)
+  echo ${UNAME_MACHINE}-unknown-morphos
+  exit ;;
+    *:OS/390:*:*)
+  echo i370-ibm-openedition
+  exit ;;
+    *:z/VM:*:*)
+  echo s390-ibm-zvmoe
+  exit ;;
+    *:OS400:*:*)
+  echo powerpc-ibm-os400
+  exit ;;
+    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
+  echo arm-acorn-riscix${UNAME_RELEASE}
+  exit ;;
+    arm:riscos:*:*|arm:RISCOS:*:*)
+  echo arm-unknown-riscos
+  exit ;;
+    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
+  echo hppa1.1-hitachi-hiuxmpp
+  exit ;;
+    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
+  # [e-mail] (Earle F. Ake) contributed MIS and NILE.
+  if test "`(/bin/universe) 2>/dev/null`" = att ; then
+    echo pyramid-pyramid-sysv3
+  else
+    echo pyramid-pyramid-bsd
+  fi
+  exit ;;
+    NILE*:*:*:dcosx)
+  echo pyramid-pyramid-svr4
+  exit ;;
+    DRS?6000:unix:4.0:6*)
+  echo sparc-icl-nx6
+  exit ;;
+    DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
+  case `/usr/bin/uname -p` in
+      sparc) echo sparc-icl-nx7; exit ;;
+  esac ;;
+    s390x:SunOS:*:*)
+  echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+  exit ;;
+    sun4H:SunOS:5.*:*)
+  echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+  exit ;;
+    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
+  echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+  exit ;;
+    i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
+  echo i386-pc-auroraux${UNAME_RELEASE}
+  exit ;;
+    i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
+  eval $set_cc_for_build
+  SUN_ARCH="i386"
+  # If there is a compiler, see if it is configured for 64-bit objects.
+  # Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
+  # This test works for both compilers.
+  if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
+      if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
+    (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
+    grep IS_64BIT_ARCH >/dev/null
+      then
+    SUN_ARCH="x86_64"
+      fi
+  fi
+  echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+  exit ;;
+    sun4*:SunOS:6*:*)
+  # According to config.sub, this is the proper way to canonicalize
+  # SunOS6.  Hard to guess exactly what SunOS6 will be like, but
+  # it's likely to be more like Solaris than SunOS4.
+  echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+  exit ;;
+    sun4*:SunOS:*:*)
+  case "`/usr/bin/arch -k`" in
+      Series*|S4*)
+    UNAME_RELEASE=`uname -v`
+    ;;
+  esac
+  # Japanese Language versions have a version number like `4.1.3-JL'.
+  echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
+  exit ;;
+    sun3*:SunOS:*:*)
+  echo m68k-sun-sunos${UNAME_RELEASE}
+  exit ;;
+    sun*:*:4.2BSD:*)
+  UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
+  test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3
+  case "`/bin/arch`" in
+      sun3)
+    echo m68k-sun-sunos${UNAME_RELEASE}
+    ;;
+      sun4)
+    echo sparc-sun-sunos${UNAME_RELEASE}
+    ;;
+  esac
+  exit ;;
+    aushp:SunOS:*:*)
+  echo sparc-auspex-sunos${UNAME_RELEASE}
+  exit ;;
+    # The situation for MiNT is a little confusing.  The machine name
+    # can be virtually everything (everything which is not
+    # "atarist" or "atariste" at least should have a processor
+    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
+    # to the lowercase version "mint" (or "freemint").  Finally
+    # the system name "TOS" denotes a system which is actually not
+    # MiNT.  But MiNT is downward compatible to TOS, so this should
+    # be no problem.
+    atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
+  echo m68k-atari-mint${UNAME_RELEASE}
+  exit ;;
+    atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
+  echo m68k-atari-mint${UNAME_RELEASE}
+  exit ;;
+    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
+  echo m68k-atari-mint${UNAME_RELEASE}
+  exit ;;
+    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
+  echo m68k-milan-mint${UNAME_RELEASE}
+  exit ;;
+    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
+  echo m68k-hades-mint${UNAME_RELEASE}
+  exit ;;
+    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
+  echo m68k-unknown-mint${UNAME_RELEASE}
+  exit ;;
+    m68k:machten:*:*)
+  echo m68k-apple-machten${UNAME_RELEASE}
+  exit ;;
+    powerpc:machten:*:*)
+  echo powerpc-apple-machten${UNAME_RELEASE}
+  exit ;;
+    RISC*:Mach:*:*)
+  echo mips-dec-mach_bsd4.3
+  exit ;;
+    RISC*:ULTRIX:*:*)
+  echo mips-dec-ultrix${UNAME_RELEASE}
+  exit ;;
+    VAX*:ULTRIX*:*:*)
+  echo vax-dec-ultrix${UNAME_RELEASE}
+  exit ;;
+    2020:CLIX:*:* | 2430:CLIX:*:*)
+  echo clipper-intergraph-clix${UNAME_RELEASE}
+  exit ;;
+    mips:*:*:UMIPS | mips:*:*:RISCos)
+  eval $set_cc_for_build
+  sed 's/^ //' << EOF >$dummy.c
+#ifdef __cplusplus
+#include <stdio.h>  /* for printf() prototype */
+  int main (int argc, char *argv[]) {
+#else
+  int main (argc, argv) int argc; char *argv[]; {
+#endif
+  #if defined (host_mips) && defined (MIPSEB)
+  #if defined (SYSTYPE_SYSV)
+    printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
+  #endif
+  #if defined (SYSTYPE_SVR4)
+    printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
+  #endif
+  #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
+    printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
+  #endif
+  #endif
+    exit (-1);
+  }
+EOF
+  $CC_FOR_BUILD -o $dummy $dummy.c &&
+    dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` &&
+    SYSTEM_NAME=`$dummy $dummyarg` &&
+      { echo "$SYSTEM_NAME"; exit; }
+  echo mips-mips-riscos${UNAME_RELEASE}
+  exit ;;
+    Motorola:PowerMAX_OS:*:*)
+  echo powerpc-motorola-powermax
+  exit ;;
+    Motorola:*:4.3:PL8-*)
+  echo powerpc-harris-powermax
+  exit ;;
+    Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
+  echo powerpc-harris-powermax
+  exit ;;
+    Night_Hawk:Power_UNIX:*:*)
+  echo powerpc-harris-powerunix
+  exit ;;
+    m88k:CX/UX:7*:*)
+  echo m88k-harris-cxux7
+  exit ;;
+    m88k:*:4*:R4*)
+  echo m88k-motorola-sysv4
+  exit ;;
+    m88k:*:3*:R3*)
+  echo m88k-motorola-sysv3
+  exit ;;
+    AViiON:dgux:*:*)
+  # DG/UX returns AViiON for all architectures
+  UNAME_PROCESSOR=`/usr/bin/uname -p`
+  if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
+  then
+      if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
+         [ ${TARGET_BINARY_INTERFACE}x = x ]
+      then
+    echo m88k-dg-dgux${UNAME_RELEASE}
+      else
+    echo m88k-dg-dguxbcs${UNAME_RELEASE}
+      fi
+  else
+      echo i586-dg-dgux${UNAME_RELEASE}
+  fi
+  exit ;;
+    M88*:DolphinOS:*:*) # DolphinOS (SVR3)
+  echo m88k-dolphin-sysv3
+  exit ;;
+    M88*:*:R3*:*)
+  # Delta 88k system running SVR3
+  echo m88k-motorola-sysv3
+  exit ;;
+    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
+  echo m88k-tektronix-sysv3
+  exit ;;
+    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
+  echo m68k-tektronix-bsd
+  exit ;;
+    *:IRIX*:*:*)
+  echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
+  exit ;;
+    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
+  echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
+  exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '
+    i*86:AIX:*:*)
+  echo i386-ibm-aix
+  exit ;;
+    ia64:AIX:*:*)
+  if [ -x /usr/bin/oslevel ] ; then
+    IBM_REV=`/usr/bin/oslevel`
+  else
+    IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+  fi
+  echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}
+  exit ;;
+    *:AIX:2:3)
+  if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
+    eval $set_cc_for_build
+    sed 's/^   //' << EOF >$dummy.c
+    #include <sys/systemcfg.h>
+
+    main()
+      {
+      if (!__power_pc())
+        exit(1);
+      puts("powerpc-ibm-aix3.2.5");
+      exit(0);
+      }
+EOF
+    if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`
+    then
+      echo "$SYSTEM_NAME"
+    else
+      echo rs6000-ibm-aix3.2.5
+    fi
+  elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
+    echo rs6000-ibm-aix3.2.4
+  else
+    echo rs6000-ibm-aix3.2
+  fi
+  exit ;;
+    *:AIX:*:[4567])
+  IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
+  if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
+    IBM_ARCH=rs6000
+  else
+    IBM_ARCH=powerpc
+  fi
+  if [ -x /usr/bin/oslevel ] ; then
+    IBM_REV=`/usr/bin/oslevel`
+  else
+    IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+  fi
+  echo ${IBM_ARCH}-ibm-aix${IBM_REV}
+  exit ;;
+    *:AIX:*:*)
+  echo rs6000-ibm-aix
+  exit ;;
+    ibmrt:4.4BSD:*|romp-ibm:BSD:*)
+  echo romp-ibm-bsd4.4
+  exit ;;
+    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
+  echo romp-ibm-bsd${UNAME_RELEASE}   # 4.3 with uname added to
+  exit ;;                             # report: romp-ibm BSD 4.3
+    *:BOSX:*:*)
+  echo rs6000-bull-bosx
+  exit ;;
+    DPX/2?00:B.O.S.:*:*)
+  echo m68k-bull-sysv3
+  exit ;;
+    9000/[34]??:4.3bsd:1.*:*)
+  echo m68k-hp-bsd
+  exit ;;
+    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
+  echo m68k-hp-bsd4.4
+  exit ;;
+    9000/[34678]??:HP-UX:*:*)
+  HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+  case "${UNAME_MACHINE}" in
+      9000/31? )            HP_ARCH=m68000 ;;
+      9000/[34]?? )         HP_ARCH=m68k ;;
+      9000/[678][0-9][0-9])
+    if [ -x /usr/bin/getconf ]; then
+        sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
+        sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
+        case "${sc_cpu_version}" in
+          523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
+          528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
+          532)                      # CPU_PA_RISC2_0
+      case "${sc_kernel_bits}" in
+        32) HP_ARCH="hppa2.0n" ;;
+        64) HP_ARCH="hppa2.0w" ;;
+        '') HP_ARCH="hppa2.0" ;;   # HP-UX 10.20
+      esac ;;
+        esac
+    fi
+    if [ "${HP_ARCH}" = "" ]; then
+        eval $set_cc_for_build
+        sed 's/^   //' << EOF >$dummy.c
+
+    #define _HPUX_SOURCE
+    #include <stdlib.h>
+    #include <unistd.h>
+
+    int main ()
+    {
+    #if defined(_SC_KERNEL_BITS)
+        long bits = sysconf(_SC_KERNEL_BITS);
+    #endif
+        long cpu  = sysconf (_SC_CPU_VERSION);
+
+        switch (cpu)
+      {
+      case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
+      case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
+      case CPU_PA_RISC2_0:
+    #if defined(_SC_KERNEL_BITS)
+          switch (bits)
+        {
+        case 64: puts ("hppa2.0w"); break;
+        case 32: puts ("hppa2.0n"); break;
+        default: puts ("hppa2.0"); break;
+        } break;
+    #else  /* !defined(_SC_KERNEL_BITS) */
+          puts ("hppa2.0"); break;
+    #endif
+      default: puts ("hppa1.0"); break;
+      }
+        exit (0);
+    }
+EOF
+        (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
+        test -z "$HP_ARCH" && HP_ARCH=hppa
+    fi ;;
+  esac
+  if [ ${HP_ARCH} = "hppa2.0w" ]
+  then
+      eval $set_cc_for_build
+
+      # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
+      # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
+      # generating 64-bit code.  GNU and HP use different nomenclature:
+      #
+      # $ CC_FOR_BUILD=cc ./config.guess
+      # => hppa2.0w-hp-hpux11.23
+      # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
+      # => hppa64-hp-hpux11.23
+
+      if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) |
+    grep -q __LP64__
+      then
+    HP_ARCH="hppa2.0w"
+      else
+    HP_ARCH="hppa64"
+      fi
+  fi
+  echo ${HP_ARCH}-hp-hpux${HPUX_REV}
+  exit ;;
+    ia64:HP-UX:*:*)
+  HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+  echo ia64-hp-hpux${HPUX_REV}
+  exit ;;
+    3050*:HI-UX:*:*)
+  eval $set_cc_for_build
+  sed 's/^ //' << EOF >$dummy.c
+  #include <unistd.h>
+  int
+  main ()
+  {
+    long cpu = sysconf (_SC_CPU_VERSION);
+    /* The order matters, because CPU_IS_HP_MC68K erroneously returns
+       true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
+       results, however.  */
+    if (CPU_IS_PA_RISC (cpu))
+      {
+        switch (cpu)
+    {
+      case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
+      case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
+      case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
+      default: puts ("hppa-hitachi-hiuxwe2"); break;
+    }
+      }
+    else if (CPU_IS_HP_MC68K (cpu))
+      puts ("m68k-hitachi-hiuxwe2");
+    else puts ("unknown-hitachi-hiuxwe2");
+    exit (0);
+  }
+EOF
+  $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&
+    { echo "$SYSTEM_NAME"; exit; }
+  echo unknown-hitachi-hiuxwe2
+  exit ;;
+    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
+  echo hppa1.1-hp-bsd
+  exit ;;
+    9000/8??:4.3bsd:*:*)
+  echo hppa1.0-hp-bsd
+  exit ;;
+    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
+  echo hppa1.0-hp-mpeix
+  exit ;;
+    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
+  echo hppa1.1-hp-osf
+  exit ;;
+    hp8??:OSF1:*:*)
+  echo hppa1.0-hp-osf
+  exit ;;
+    i*86:OSF1:*:*)
+  if [ -x /usr/sbin/sysversion ] ; then
+      echo ${UNAME_MACHINE}-unknown-osf1mk
+  else
+      echo ${UNAME_MACHINE}-unknown-osf1
+  fi
+  exit ;;
+    parisc*:Lites*:*:*)
+  echo hppa1.1-hp-lites
+  exit ;;
+    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
+  echo c1-convex-bsd
+  exit ;;
+    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
+  if getsysinfo -f scalar_acc
+  then echo c32-convex-bsd
+  else echo c2-convex-bsd
+  fi
+  exit ;;
+    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
+  echo c34-convex-bsd
+  exit ;;
+    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
+  echo c38-convex-bsd
+  exit ;;
+    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
+  echo c4-convex-bsd
+  exit ;;
+    CRAY*Y-MP:*:*:*)
+  echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+  exit ;;
+    CRAY*[A-Z]90:*:*:*)
+  echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
+  | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
+        -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
+        -e 's/\.[^.]*$/.X/'
+  exit ;;
+    CRAY*TS:*:*:*)
+  echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+  exit ;;
+    CRAY*T3E:*:*:*)
+  echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+  exit ;;
+    CRAY*SV1:*:*:*)
+  echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+  exit ;;
+    *:UNICOS/mp:*:*)
+  echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+  exit ;;
+    F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
+  FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
+  FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
+  FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
+  echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+  exit ;;
+    5000:UNIX_System_V:4.*:*)
+  FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
+  FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`
+  echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+  exit ;;
+    i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
+  echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
+  exit ;;
+    sparc*:BSD/OS:*:*)
+  echo sparc-unknown-bsdi${UNAME_RELEASE}
+  exit ;;
+    *:BSD/OS:*:*)
+  echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
+  exit ;;
+    *:FreeBSD:*:*)
+  UNAME_PROCESSOR=`/usr/bin/uname -p`
+  case ${UNAME_PROCESSOR} in
+      amd64)
+    echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+      *)
+    echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+  esac
+  exit ;;
+    i*:CYGWIN*:*)
+  echo ${UNAME_MACHINE}-pc-cygwin
+  exit ;;
+    *:MINGW*:*)
+  echo ${UNAME_MACHINE}-pc-mingw32
+  exit ;;
+    i*:MSYS*:*)
+  echo ${UNAME_MACHINE}-pc-msys
+  exit ;;
+    i*:windows32*:*)
+  # uname -m includes "-pc" on this system.
+  echo ${UNAME_MACHINE}-mingw32
+  exit ;;
+    i*:PW*:*)
+  echo ${UNAME_MACHINE}-pc-pw32
+  exit ;;
+    *:Interix*:*)
+  case ${UNAME_MACHINE} in
+      x86)
+    echo i586-pc-interix${UNAME_RELEASE}
+    exit ;;
+      authenticamd | genuineintel | EM64T)
+    echo x86_64-unknown-interix${UNAME_RELEASE}
+    exit ;;
+      IA64)
+    echo ia64-unknown-interix${UNAME_RELEASE}
+    exit ;;
+  esac ;;
+    [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
+  echo i${UNAME_MACHINE}-pc-mks
+  exit ;;
+    8664:Windows_NT:*)
+  echo x86_64-pc-mks
+  exit ;;
+    i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
+  # How do we know it's Interix rather than the generic POSIX subsystem?
+  # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
+  # UNAME_MACHINE based on the output of uname instead of i386?
+  echo i586-pc-interix
+  exit ;;
+    i*:UWIN*:*)
+  echo ${UNAME_MACHINE}-pc-uwin
+  exit ;;
+    amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
+  echo x86_64-unknown-cygwin
+  exit ;;
+    p*:CYGWIN*:*)
+  echo powerpcle-unknown-cygwin
+  exit ;;
+    prep*:SunOS:5.*:*)
+  echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+  exit ;;
+    *:GNU:*:*)
+  # the GNU system
+  echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
+  exit ;;
+    *:GNU/*:*:*)
+  # other systems with GNU libc and userland
+  echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu
+  exit ;;
+    i*86:Minix:*:*)
+  echo ${UNAME_MACHINE}-pc-minix
+  exit ;;
+    aarch64:Linux:*:*)
+  echo ${UNAME_MACHINE}-unknown-linux-gnu
+  exit ;;
+    aarch64_be:Linux:*:*)
+  UNAME_MACHINE=aarch64_be
+  echo ${UNAME_MACHINE}-unknown-linux-gnu
+  exit ;;
+    alpha:Linux:*:*)
+  case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
+    EV5)   UNAME_MACHINE=alphaev5 ;;
+    EV56)  UNAME_MACHINE=alphaev56 ;;
+    PCA56) UNAME_MACHINE=alphapca56 ;;
+    PCA57) UNAME_MACHINE=alphapca56 ;;
+    EV6)   UNAME_MACHINE=alphaev6 ;;
+    EV67)  UNAME_MACHINE=alphaev67 ;;
+    EV68*) UNAME_MACHINE=alphaev68 ;;
+  esac
+  objdump --private-headers /bin/sh | grep -q ld.so.1
+  if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi
+  echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC}
+  exit ;;
+    arm*:Linux:*:*)
+  eval $set_cc_for_build
+  if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
+      | grep -q __ARM_EABI__
+  then
+      echo ${UNAME_MACHINE}-unknown-linux-gnu
+  else
+      if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
+    | grep -q __ARM_PCS_VFP
+      then
+    echo ${UNAME_MACHINE}-unknown-linux-gnueabi
+      else
+    echo ${UNAME_MACHINE}-unknown-linux-gnueabihf
+      fi
+  fi
+  exit ;;
+    avr32*:Linux:*:*)
+  echo ${UNAME_MACHINE}-unknown-linux-gnu
+  exit ;;
+    cris:Linux:*:*)
+  echo ${UNAME_MACHINE}-axis-linux-gnu
+  exit ;;
+    crisv32:Linux:*:*)
+  echo ${UNAME_MACHINE}-axis-linux-gnu
+  exit ;;
+    frv:Linux:*:*)
+  echo ${UNAME_MACHINE}-unknown-linux-gnu
+  exit ;;
+    hexagon:Linux:*:*)
+  echo ${UNAME_MACHINE}-unknown-linux-gnu
+  exit ;;
+    i*86:Linux:*:*)
+  LIBC=gnu
+  eval $set_cc_for_build
+  sed 's/^ //' << EOF >$dummy.c
+  #ifdef __dietlibc__
+  LIBC=dietlibc
+  #endif
+EOF
+  eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'`
+  echo "${UNAME_MACHINE}-pc-linux-${LIBC}"
+  exit ;;
+    ia64:Linux:*:*)
+  echo ${UNAME_MACHINE}-unknown-linux-gnu
+  exit ;;
+    m32r*:Linux:*:*)
+  echo ${UNAME_MACHINE}-unknown-linux-gnu
+  exit ;;
+    m68*:Linux:*:*)
+  echo ${UNAME_MACHINE}-unknown-linux-gnu
+  exit ;;
+    mips:Linux:*:* | mips64:Linux:*:*)
+  eval $set_cc_for_build
+  sed 's/^ //' << EOF >$dummy.c
+  #undef CPU
+  #undef ${UNAME_MACHINE}
+  #undef ${UNAME_MACHINE}el
+  #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
+  CPU=${UNAME_MACHINE}el
+  #else
+  #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
+  CPU=${UNAME_MACHINE}
+  #else
+  CPU=
+  #endif
+  #endif
+EOF
+  eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'`
+  test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
+  ;;
+    or32:Linux:*:*)
+  echo ${UNAME_MACHINE}-unknown-linux-gnu
+  exit ;;
+    padre:Linux:*:*)
+  echo sparc-unknown-linux-gnu
+  exit ;;
+    parisc64:Linux:*:* | hppa64:Linux:*:*)
+  echo hppa64-unknown-linux-gnu
+  exit ;;
+    parisc:Linux:*:* | hppa:Linux:*:*)
+  # Look for CPU level
+  case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
+    PA7*) echo hppa1.1-unknown-linux-gnu ;;
+    PA8*) echo hppa2.0-unknown-linux-gnu ;;
+    *)    echo hppa-unknown-linux-gnu ;;
+  esac
+  exit ;;
+    ppc64:Linux:*:*)
+  echo powerpc64-unknown-linux-gnu
+  exit ;;
+    ppc:Linux:*:*)
+  echo powerpc-unknown-linux-gnu
+  exit ;;
+    s390:Linux:*:* | s390x:Linux:*:*)
+  echo ${UNAME_MACHINE}-ibm-linux
+  exit ;;
+    sh64*:Linux:*:*)
+  echo ${UNAME_MACHINE}-unknown-linux-gnu
+  exit ;;
+    sh*:Linux:*:*)
+  echo ${UNAME_MACHINE}-unknown-linux-gnu
+  exit ;;
+    sparc:Linux:*:* | sparc64:Linux:*:*)
+  echo ${UNAME_MACHINE}-unknown-linux-gnu
+  exit ;;
+    tile*:Linux:*:*)
+  echo ${UNAME_MACHINE}-unknown-linux-gnu
+  exit ;;
+    vax:Linux:*:*)
+  echo ${UNAME_MACHINE}-dec-linux-gnu
+  exit ;;
+    x86_64:Linux:*:*)
+  echo ${UNAME_MACHINE}-unknown-linux-gnu
+  exit ;;
+    xtensa*:Linux:*:*)
+  echo ${UNAME_MACHINE}-unknown-linux-gnu
+  exit ;;
+    i*86:DYNIX/ptx:4*:*)
+  # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
+  # earlier versions are messed up and put the nodename in both
+  # sysname and nodename.
+  echo i386-sequent-sysv4
+  exit ;;
+    i*86:UNIX_SV:4.2MP:2.*)
+  # Unixware is an offshoot of SVR4, but it has its own version
+  # number series starting with 2...
+  # I am not positive that other SVR4 systems won't match this,
+  # I just have to hope.  -- rms.
+  # Use sysv4.2uw... so that sysv4* matches it.
+  echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
+  exit ;;
+    i*86:OS/2:*:*)
+  # If we were able to find `uname', then EMX Unix compatibility
+  # is probably installed.
+  echo ${UNAME_MACHINE}-pc-os2-emx
+  exit ;;
+    i*86:XTS-300:*:STOP)
+  echo ${UNAME_MACHINE}-unknown-stop
+  exit ;;
+    i*86:atheos:*:*)
+  echo ${UNAME_MACHINE}-unknown-atheos
+  exit ;;
+    i*86:syllable:*:*)
+  echo ${UNAME_MACHINE}-pc-syllable
+  exit ;;
+    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
+  echo i386-unknown-lynxos${UNAME_RELEASE}
+  exit ;;
+    i*86:*DOS:*:*)
+  echo ${UNAME_MACHINE}-pc-msdosdjgpp
+  exit ;;
+    i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
+  UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
+  if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
+    echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
+  else
+    echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
+  fi
+  exit ;;
+    i*86:*:5:[678]*)
+  # UnixWare 7.x, OpenUNIX and OpenServer 6.
+  case `/bin/uname -X | grep "^Machine"` in
+      *486*)       UNAME_MACHINE=i486 ;;
+      *Pentium)      UNAME_MACHINE=i586 ;;
+      *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
+  esac
+  echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
+  exit ;;
+    i*86:*:3.2:*)
+  if test -f /usr/options/cb.name; then
+    UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
+    echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
+  elif /bin/uname -X 2>/dev/null >/dev/null ; then
+    UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
+    (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
+    (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
+      && UNAME_MACHINE=i586
+    (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
+      && UNAME_MACHINE=i686
+    (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
+      && UNAME_MACHINE=i686
+    echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
+  else
+    echo ${UNAME_MACHINE}-pc-sysv32
+  fi
+  exit ;;
+    pc:*:*:*)
+  # Left here for compatibility:
+  # uname -m prints for DJGPP always 'pc', but it prints nothing about
+  # the processor, so we play safe by assuming i586.
+  # Note: whatever this is, it MUST be the same as what config.sub
+  # prints for the "djgpp" host, or else GDB configury will decide that
+  # this is a cross-build.
+  echo i586-pc-msdosdjgpp
+  exit ;;
+    Intel:Mach:3*:*)
+  echo i386-pc-mach3
+  exit ;;
+    paragon:*:*:*)
+  echo i860-intel-osf1
+  exit ;;
+    i860:*:4.*:*) # i860-SVR4
+  if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
+    echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
+  else # Add other i860-SVR4 vendors below as they are discovered.
+    echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4
+  fi
+  exit ;;
+    mini*:CTIX:SYS*5:*)
+  # "miniframe"
+  echo m68010-convergent-sysv
+  exit ;;
+    mc68k:UNIX:SYSTEM5:3.51m)
+  echo m68k-convergent-sysv
+  exit ;;
+    M680?0:D-NIX:5.3:*)
+  echo m68k-diab-dnix
+  exit ;;
+    M68*:*:R3V[5678]*:*)
+  test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
+    3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
+  OS_REL=''
+  test -r /etc/.relid \
+  && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+  /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+    && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+  /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+    && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+    3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
+  /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+    && { echo i486-ncr-sysv4; exit; } ;;
+    NCR*:*:4.2:* | MPRAS*:*:4.2:*)
+  OS_REL='.3'
+  test -r /etc/.relid \
+      && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+  /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+      && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+  /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+      && { echo i586-ncr-sysv4.3${OS_REL}; exit; }
+  /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
+      && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
+  echo m68k-unknown-lynxos${UNAME_RELEASE}
+  exit ;;
+    mc68030:UNIX_System_V:4.*:*)
+  echo m68k-atari-sysv4
+  exit ;;
+    TSUNAMI:LynxOS:2.*:*)
+  echo sparc-unknown-lynxos${UNAME_RELEASE}
+  exit ;;
+    rs6000:LynxOS:2.*:*)
+  echo rs6000-unknown-lynxos${UNAME_RELEASE}
+  exit ;;
+    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
+  echo powerpc-unknown-lynxos${UNAME_RELEASE}
+  exit ;;
+    SM[BE]S:UNIX_SV:*:*)
+  echo mips-dde-sysv${UNAME_RELEASE}
+  exit ;;
+    RM*:ReliantUNIX-*:*:*)
+  echo mips-sni-sysv4
+  exit ;;
+    RM*:SINIX-*:*:*)
+  echo mips-sni-sysv4
+  exit ;;
+    *:SINIX-*:*:*)
+  if uname -p 2>/dev/null >/dev/null ; then
+    UNAME_MACHINE=`(uname -p) 2>/dev/null`
+    echo ${UNAME_MACHINE}-sni-sysv4
+  else
+    echo ns32k-sni-sysv
+  fi
+  exit ;;
+    PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
+      # says <[e-mail]>
+  echo i586-unisys-sysv4
+  exit ;;
+    *:UNIX_System_V:4*:FTX*)
+  # From Gerald Hewes <[e-mail]>.
+  # How about differentiating between stratus architectures? -djm
+  echo hppa1.1-stratus-sysv4
+  exit ;;
+    *:*:*:FTX*)
+  # From [e-mail].
+  echo i860-stratus-sysv4
+  exit ;;
+    i*86:VOS:*:*)
+  # From [e-mail].
+  echo ${UNAME_MACHINE}-stratus-vos
+  exit ;;
+    *:VOS:*:*)
+  # From [e-mail].
+  echo hppa1.1-stratus-vos
+  exit ;;
+    mc68*:A/UX:*:*)
+  echo m68k-apple-aux${UNAME_RELEASE}
+  exit ;;
+    news*:NEWS-OS:6*:*)
+  echo mips-sony-newsos6
+  exit ;;
+    R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
+  if [ -d /usr/nec ]; then
+    echo mips-nec-sysv${UNAME_RELEASE}
+  else
+    echo mips-unknown-sysv${UNAME_RELEASE}
+  fi
+  exit ;;
+    BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only.
+  echo powerpc-be-beos
+  exit ;;
+    BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only.
+  echo powerpc-apple-beos
+  exit ;;
+    BePC:BeOS:*:*)  # BeOS running on Intel PC compatible.
+  echo i586-pc-beos
+  exit ;;
+    BePC:Haiku:*:*) # Haiku running on Intel PC compatible.
+  echo i586-pc-haiku
+  exit ;;
+    SX-4:SUPER-UX:*:*)
+  echo sx4-nec-superux${UNAME_RELEASE}
+  exit ;;
+    SX-5:SUPER-UX:*:*)
+  echo sx5-nec-superux${UNAME_RELEASE}
+  exit ;;
+    SX-6:SUPER-UX:*:*)
+  echo sx6-nec-superux${UNAME_RELEASE}
+  exit ;;
+    SX-7:SUPER-UX:*:*)
+  echo sx7-nec-superux${UNAME_RELEASE}
+  exit ;;
+    SX-8:SUPER-UX:*:*)
+  echo sx8-nec-superux${UNAME_RELEASE}
+  exit ;;
+    SX-8R:SUPER-UX:*:*)
+  echo sx8r-nec-superux${UNAME_RELEASE}
+  exit ;;
+    Power*:Rhapsody:*:*)
+  echo powerpc-apple-rhapsody${UNAME_RELEASE}
+  exit ;;
+    *:Rhapsody:*:*)
+  echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
+  exit ;;
+    *:Darwin:*:*)
+  UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
+  case $UNAME_PROCESSOR in
+      i386)
+    eval $set_cc_for_build
+    if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
+      if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
+          (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
+          grep IS_64BIT_ARCH >/dev/null
+      then
+          UNAME_PROCESSOR="x86_64"
+      fi
+    fi ;;
+      unknown) UNAME_PROCESSOR=powerpc ;;
+  esac
+  echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
+  exit ;;
+    *:procnto*:*:* | *:QNX:[0123456789]*:*)
+  UNAME_PROCESSOR=`uname -p`
+  if test "$UNAME_PROCESSOR" = "x86"; then
+    UNAME_PROCESSOR=i386
+    UNAME_MACHINE=pc
+  fi
+  echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}
+  exit ;;
+    *:QNX:*:4*)
+  echo i386-pc-qnx
+  exit ;;
+    NEO-?:NONSTOP_KERNEL:*:*)
+  echo neo-tandem-nsk${UNAME_RELEASE}
+  exit ;;
+    NSE-?:NONSTOP_KERNEL:*:*)
+  echo nse-tandem-nsk${UNAME_RELEASE}
+  exit ;;
+    NSR-?:NONSTOP_KERNEL:*:*)
+  echo nsr-tandem-nsk${UNAME_RELEASE}
+  exit ;;
+    *:NonStop-UX:*:*)
+  echo mips-compaq-nonstopux
+  exit ;;
+    BS2000:POSIX*:*:*)
+  echo bs2000-siemens-sysv
+  exit ;;
+    DS/*:UNIX_System_V:*:*)
+  echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
+  exit ;;
+    *:Plan9:*:*)
+  # "uname -m" is not consistent, so use $cputype instead. 386
+  # is converted to i386 for consistency with other x86
+  # operating systems.
+  if test "$cputype" = "386"; then
+      UNAME_MACHINE=i386
+  else
+      UNAME_MACHINE="$cputype"
+  fi
+  echo ${UNAME_MACHINE}-unknown-plan9
+  exit ;;
+    *:TOPS-10:*:*)
+  echo pdp10-unknown-tops10
+  exit ;;
+    *:TENEX:*:*)
+  echo pdp10-unknown-tenex
+  exit ;;
+    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
+  echo pdp10-dec-tops20
+  exit ;;
+    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
+  echo pdp10-xkl-tops20
+  exit ;;
+    *:TOPS-20:*:*)
+  echo pdp10-unknown-tops20
+  exit ;;
+    *:ITS:*:*)
+  echo pdp10-unknown-its
+  exit ;;
+    SEI:*:*:SEIUX)
+  echo mips-sei-seiux${UNAME_RELEASE}
+  exit ;;
+    *:DragonFly:*:*)
+  echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
+  exit ;;
+    *:*VMS:*:*)
+  UNAME_MACHINE=`(uname -p) 2>/dev/null`
+  case "${UNAME_MACHINE}" in
+      A*) echo alpha-dec-vms ; exit ;;
+      I*) echo ia64-dec-vms ; exit ;;
+      V*) echo vax-dec-vms ; exit ;;
+  esac ;;
+    *:XENIX:*:SysV)
+  echo i386-pc-xenix
+  exit ;;
+    i*86:skyos:*:*)
+  echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//'
+  exit ;;
+    i*86:rdos:*:*)
+  echo ${UNAME_MACHINE}-pc-rdos
+  exit ;;
+    i*86:AROS:*:*)
+  echo ${UNAME_MACHINE}-pc-aros
+  exit ;;
+    x86_64:VMkernel:*:*)
+  echo ${UNAME_MACHINE}-unknown-esx
+  exit ;;
+esac
+
+#echo '(No uname command or uname output not recognized.)' 1>&2
+#echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2
+
+eval $set_cc_for_build
+cat >$dummy.c <<EOF
+#ifdef _SEQUENT_
+# include <sys/types.h>
+# include <sys/utsname.h>
+#endif
+main ()
+{
+#if defined (sony)
+#if defined (MIPSEB)
+  /* BFD wants "bsd" instead of "newsos".  Perhaps BFD should be changed,
+     I don't know....  */
+  printf ("mips-sony-bsd\n"); exit (0);
+#else
+#include <sys/param.h>
+  printf ("m68k-sony-newsos%s\n",
+#ifdef NEWSOS4
+  "4"
+#else
+  ""
+#endif
+  ); exit (0);
+#endif
+#endif
+
+#if defined (__arm) && defined (__acorn) && defined (__unix)
+  printf ("arm-acorn-riscix\n"); exit (0);
+#endif
+
+#if defined (hp300) && !defined (hpux)
+  printf ("m68k-hp-bsd\n"); exit (0);
+#endif
+
+#if defined (NeXT)
+#if !defined (__ARCHITECTURE__)
+#define __ARCHITECTURE__ "m68k"
+#endif
+  int version;
+  version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
+  if (version < 4)
+    printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
+  else
+    printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
+  exit (0);
+#endif
+
+#if defined (MULTIMAX) || defined (n16)
+#if defined (UMAXV)
+  printf ("ns32k-encore-sysv\n"); exit (0);
+#else
+#if defined (CMU)
+  printf ("ns32k-encore-mach\n"); exit (0);
+#else
+  printf ("ns32k-encore-bsd\n"); exit (0);
+#endif
+#endif
+#endif
+
+#if defined (__386BSD__)
+  printf ("i386-pc-bsd\n"); exit (0);
+#endif
+
+#if defined (sequent)
+#if defined (i386)
+  printf ("i386-sequent-dynix\n"); exit (0);
+#endif
+#if defined (ns32000)
+  printf ("ns32k-sequent-dynix\n"); exit (0);
+#endif
+#endif
+
+#if defined (_SEQUENT_)
+    struct utsname un;
+
+    uname(&un);
+
+    if (strncmp(un.version, "V2", 2) == 0) {
+  printf ("i386-sequent-ptx2\n"); exit (0);
+    }
+    if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
+  printf ("i386-sequent-ptx1\n"); exit (0);
+    }
+    printf ("i386-sequent-ptx\n"); exit (0);
+
+#endif
+
+#if defined (vax)
+# if !defined (ultrix)
+#  include <sys/param.h>
+#  if defined (BSD)
+#   if BSD == 43
+      printf ("vax-dec-bsd4.3\n"); exit (0);
+#   else
+#    if BSD == 199006
+      printf ("vax-dec-bsd4.3reno\n"); exit (0);
+#    else
+      printf ("vax-dec-bsd\n"); exit (0);
+#    endif
+#   endif
+#  else
+    printf ("vax-dec-bsd\n"); exit (0);
+#  endif
+# else
+    printf ("vax-dec-ultrix\n"); exit (0);
+# endif
+#endif
+
+#if defined (alliant) && defined (i860)
+  printf ("i860-alliant-bsd\n"); exit (0);
+#endif
+
+  exit (1);
+}
+EOF
+
+$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` &&
+  { echo "$SYSTEM_NAME"; exit; }
+
+# Apollos put the system type in the environment.
+
+test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; }
+
+# Convex versions that predate uname can use getsysinfo(1)
+
+if [ -x /usr/convex/getsysinfo ]
+then
+    case `getsysinfo -f cpu_type` in
+    c1*)
+  echo c1-convex-bsd
+  exit ;;
+    c2*)
+  if getsysinfo -f scalar_acc
+  then echo c32-convex-bsd
+  else echo c2-convex-bsd
+  fi
+  exit ;;
+    c34*)
+  echo c34-convex-bsd
+  exit ;;
+    c38*)
+  echo c38-convex-bsd
+  exit ;;
+    c4*)
+  echo c4-convex-bsd
+  exit ;;
+    esac
+fi
+
+cat >&2 <<EOF
+$0: unable to guess system type
+
+This script, last modified $timestamp, has failed to recognize
+the operating system you are using. It is advised that you
+download the most up to date version of the config scripts from
+
+  http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
+and
+  http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
+
+If the version you run ($0) is already up to date, please
+send the following data and any information you think might be
+pertinent to <[e-mail]> in order to provide the needed
+information to handle your system.
+
+config.guess timestamp = $timestamp
+
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null`
+
+hostinfo               = `(hostinfo) 2>/dev/null`
+/bin/universe          = `(/bin/universe) 2>/dev/null`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
+/bin/arch              = `(/bin/arch) 2>/dev/null`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
+
+UNAME_MACHINE = ${UNAME_MACHINE}
+UNAME_RELEASE = ${UNAME_RELEASE}
+UNAME_SYSTEM  = ${UNAME_SYSTEM}
+UNAME_VERSION = ${UNAME_VERSION}
+EOF
+
+exit 1
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:

polly/trunk/lib/External/ppcg/config.sub

+#! /bin/sh
+# Configuration validation subroutine script.
+#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+#   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+#   2011, 2012 Free Software Foundation, Inc.
+
+timestamp='2012-04-18'
+
+# This file is (in principle) common to ALL GNU software.
+# The presence of a machine in this file suggests that SOME GNU software
+# can handle that machine.  It does not imply ALL GNU software can.
+#
+# This file is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <http://www.gnu.org/licenses/>.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+
+# Please send patches to <[e-mail]>.  Submit a context
+# diff and a properly formatted GNU ChangeLog entry.
+#
+# Configuration subroutine to validate and canonicalize a configuration type.
+# Supply the specified configuration type as an argument.
+# If it is invalid, we print an error message on stderr and exit with code 1.
+# Otherwise, we print the canonical config type on stdout and succeed.
+
+# You can get the latest version of this script from:
+# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
+
+# This file is supposed to be the same for all GNU packages
+# and recognize all the CPU types, system types and aliases
+# that are meaningful with *any* GNU software.
+# Each package is responsible for reporting which valid configurations
+# it does not support.  The user should be able to distinguish
+# a failure to support a valid configuration from a meaningless
+# configuration.
+
+# The goal of this file is to map all the various variations of a given
+# machine specification into a single specification in the form:
+# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+# or in some cases, the newer four-part form:
+# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+# It is wrong to echo any other type of specification.
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION] CPU-MFR-OPSYS
+       $0 [OPTION] ALIAS
+
+Canonicalize a configuration name.
+
+Operation modes:
+  -h, --help         print this help, then exit
+  -t, --time-stamp   print date of last modification, then exit
+  -v, --version      print version number, then exit
+
+Report bugs and patches to <[e-mail]>."
+
+version="\
+GNU config.sub ($timestamp)
+
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
+Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+  case $1 in
+    --time-stamp | --time* | -t )
+       echo "$timestamp" ; exit ;;
+    --version | -v )
+       echo "$version" ; exit ;;
+    --help | --h* | -h )
+       echo "$usage"; exit ;;
+    -- )     # Stop option processing
+       shift; break ;;
+    - ) # Use stdin as input.
+       break ;;
+    -* )
+       echo "$me: invalid option $1$help"
+       exit 1 ;;
+
+    *local*)
+       # First pass through any local machine types.
+       echo $1
+       exit ;;
+
+    * )
+       break ;;
+  esac
+done
+
+case $# in
+ 0) echo "$me: missing argument$help" >&2
+    exit 1;;
+ 1) ;;
+ *) echo "$me: too many arguments$help" >&2
+    exit 1;;
+esac
+
+# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
+# Here we must recognize all the valid KERNEL-OS combinations.
+maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
+case $maybe_os in
+  nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
+  linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
+  knetbsd*-gnu* | netbsd*-gnu* | \
+  kopensolaris*-gnu* | \
+  storm-chaos* | os2-emx* | rtmk-nova*)
+    os=-$maybe_os
+    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
+    ;;
+  android-linux)
+    os=-linux-android
+    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown
+    ;;
+  *)
+    basic_machine=`echo $1 | sed 's/-[^-]*$//'`
+    if [ $basic_machine != $1 ]
+    then os=`echo $1 | sed 's/.*-/-/'`
+    else os=; fi
+    ;;
+esac
+
+### Let's recognize common machines as not being operating systems so
+### that things like config.sub decstation-3100 work.  We also
+### recognize some manufacturers as not being operating systems, so we
+### can provide default operating systems below.
+case $os in
+  -sun*os*)
+    # Prevent following clause from handling this invalid input.
+    ;;
+  -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
+  -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
+  -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
+  -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
+  -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
+  -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
+  -apple | -axis | -knuth | -cray | -microblaze)
+    os=
+    basic_machine=$1
+    ;;
+  -bluegene*)
+    os=-cnk
+    ;;
+  -sim | -cisco | -oki | -wec | -winbond)
+    os=
+    basic_machine=$1
+    ;;
+  -scout)
+    ;;
+  -wrs)
+    os=-vxworks
+    basic_machine=$1
+    ;;
+  -chorusos*)
+    os=-chorusos
+    basic_machine=$1
+    ;;
+  -chorusrdb)
+    os=-chorusrdb
+    basic_machine=$1
+    ;;
+  -hiux*)
+    os=-hiuxwe2
+    ;;
+  -sco6)
+    os=-sco5v6
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -sco5)
+    os=-sco3.2v5
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -sco4)
+    os=-sco3.2v4
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -sco3.2.[4-9]*)
+    os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -sco3.2v[4-9]*)
+    # Don't forget version if it is 3.2v4 or newer.
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -sco5v6*)
+    # Don't forget version if it is 3.2v4 or newer.
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -sco*)
+    os=-sco3.2v2
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -udk*)
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -isc)
+    os=-isc2.2
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -clix*)
+    basic_machine=clipper-intergraph
+    ;;
+  -isc*)
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -lynx*178)
+    os=-lynxos178
+    ;;
+  -lynx*5)
+    os=-lynxos5
+    ;;
+  -lynx*)
+    os=-lynxos
+    ;;
+  -ptx*)
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`
+    ;;
+  -windowsnt*)
+    os=`echo $os | sed -e 's/windowsnt/winnt/'`
+    ;;
+  -psos*)
+    os=-psos
+    ;;
+  -mint | -mint[0-9]*)
+    basic_machine=m68k-atari
+    os=-mint
+    ;;
+esac
+
+# Decode aliases for certain CPU-COMPANY combinations.
+case $basic_machine in
+  # Recognize the basic CPU types without company name.
+  # Some are omitted here because they have special meanings below.
+  1750a | 580 \
+  | a29k \
+  | aarch64 | aarch64_be \
+  | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
+  | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
+  | am33_2.0 \
+  | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr | avr32 \
+        | be32 | be64 \
+  | bfin \
+  | c4x | clipper \
+  | d10v | d30v | dlx | dsp16xx \
+  | epiphany \
+  | fido | fr30 | frv \
+  | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
+  | hexagon \
+  | i370 | i860 | i960 | ia64 \
+  | ip2k | iq2000 \
+  | le32 | le64 \
+  | lm32 \
+  | m32c | m32r | m32rle | m68000 | m68k | m88k \
+  | maxq | mb | microblaze | mcore | mep | metag \
+  | mips | mipsbe | mipseb | mipsel | mipsle \
+  | mips16 \
+  | mips64 | mips64el \
+  | mips64octeon | mips64octeonel \
+  | mips64orion | mips64orionel \
+  | mips64r5900 | mips64r5900el \
+  | mips64vr | mips64vrel \
+  | mips64vr4100 | mips64vr4100el \
+  | mips64vr4300 | mips64vr4300el \
+  | mips64vr5000 | mips64vr5000el \
+  | mips64vr5900 | mips64vr5900el \
+  | mipsisa32 | mipsisa32el \
+  | mipsisa32r2 | mipsisa32r2el \
+  | mipsisa64 | mipsisa64el \
+  | mipsisa64r2 | mipsisa64r2el \
+  | mipsisa64sb1 | mipsisa64sb1el \
+  | mipsisa64sr71k | mipsisa64sr71kel \
+  | mipstx39 | mipstx39el \
+  | mn10200 | mn10300 \
+  | moxie \
+  | mt \
+  | msp430 \
+  | nds32 | nds32le | nds32be \
+  | nios | nios2 \
+  | ns16k | ns32k \
+  | open8 \
+  | or32 \
+  | pdp10 | pdp11 | pj | pjl \
+  | powerpc | powerpc64 | powerpc64le | powerpcle \
+  | pyramid \
+  | rl78 | rx \
+  | score \
+  | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
+  | sh64 | sh64le \
+  | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
+  | sparcv8 | sparcv9 | sparcv9b | sparcv9v \
+  | spu \
+  | tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
+  | ubicom32 \
+  | v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
+  | we32k \
+  | x86 | xc16x | xstormy16 | xtensa \
+  | z8k | z80)
+    basic_machine=$basic_machine-unknown
+    ;;
+  c54x)
+    basic_machine=tic54x-unknown
+    ;;
+  c55x)
+    basic_machine=tic55x-unknown
+    ;;
+  c6x)
+    basic_machine=tic6x-unknown
+    ;;
+  m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | picochip)
+    basic_machine=$basic_machine-unknown
+    os=-none
+    ;;
+  m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)
+    ;;
+  ms1)
+    basic_machine=mt-unknown
+    ;;
+
+  strongarm | thumb | xscale)
+    basic_machine=arm-unknown
+    ;;
+  xgate)
+    basic_machine=$basic_machine-unknown
+    os=-none
+    ;;
+  xscaleeb)
+    basic_machine=armeb-unknown
+    ;;
+
+  xscaleel)
+    basic_machine=armel-unknown
+    ;;
+
+  # We use `pc' rather than `unknown'
+  # because (1) that's what they normally are, and
+  # (2) the word "unknown" tends to confuse beginning users.
+  i*86 | x86_64)
+    basic_machine=$basic_machine-pc
+    ;;
+  # Object if more than one company name word.
+  *-*-*)
+    echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+    exit 1
+    ;;
+  # Recognize the basic CPU types with company name.
+  580-* \
+  | a29k-* \
+  | aarch64-* | aarch64_be-* \
+  | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
+  | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
+  | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \
+  | arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
+  | avr-* | avr32-* \
+  | be32-* | be64-* \
+  | bfin-* | bs2000-* \
+  | c[123]* | c30-* | [cjt]90-* | c4x-* \
+  | clipper-* | craynv-* | cydra-* \
+  | d10v-* | d30v-* | dlx-* \
+  | elxsi-* \
+  | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
+  | h8300-* | h8500-* \
+  | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
+  | hexagon-* \
+  | i*86-* | i860-* | i960-* | ia64-* \
+  | ip2k-* | iq2000-* \
+  | le32-* | le64-* \
+  | lm32-* \
+  | m32c-* | m32r-* | m32rle-* \
+  | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
+  | m88110-* | m88k-* | maxq-* | mcore-* | metag-* | microblaze-* \
+  | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
+  | mips16-* \
+  | mips64-* | mips64el-* \
+  | mips64octeon-* | mips64octeonel-* \
+  | mips64orion-* | mips64orionel-* \
+  | mips64r5900-* | mips64r5900el-* \
+  | mips64vr-* | mips64vrel-* \
+  | mips64vr4100-* | mips64vr4100el-* \
+  | mips64vr4300-* | mips64vr4300el-* \
+  | mips64vr5000-* | mips64vr5000el-* \
+  | mips64vr5900-* | mips64vr5900el-* \
+  | mipsisa32-* | mipsisa32el-* \
+  | mipsisa32r2-* | mipsisa32r2el-* \
+  | mipsisa64-* | mipsisa64el-* \
+  | mipsisa64r2-* | mipsisa64r2el-* \
+  | mipsisa64sb1-* | mipsisa64sb1el-* \
+  | mipsisa64sr71k-* | mipsisa64sr71kel-* \
+  | mipstx39-* | mipstx39el-* \
+  | mmix-* \
+  | mt-* \
+  | msp430-* \
+  | nds32-* | nds32le-* | nds32be-* \
+  | nios-* | nios2-* \
+  | none-* | np1-* | ns16k-* | ns32k-* \
+  | open8-* \
+  | orion-* \
+  | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
+  | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
+  | pyramid-* \
+  | rl78-* | romp-* | rs6000-* | rx-* \
+  | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
+  | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
+  | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
+  | sparclite-* \
+  | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx?-* \
+  | tahoe-* \
+  | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
+  | tile*-* \
+  | tron-* \
+  | ubicom32-* \
+  | v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
+  | vax-* \
+  | we32k-* \
+  | x86-* | x86_64-* | xc16x-* | xps100-* \
+  | xstormy16-* | xtensa*-* \
+  | ymp-* \
+  | z8k-* | z80-*)
+    ;;
+  # Recognize the basic CPU types without company name, with glob match.
+  xtensa*)
+    basic_machine=$basic_machine-unknown
+    ;;
+  # Recognize the various machine names and aliases which stand
+  # for a CPU type and a company and sometimes even an OS.
+  386bsd)
+    basic_machine=i386-unknown
+    os=-bsd
+    ;;
+  3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
+    basic_machine=m68000-att
+    ;;
+  3b*)
+    basic_machine=we32k-att
+    ;;
+  a29khif)
+    basic_machine=a29k-amd
+    os=-udi
+    ;;
+  abacus)
+    basic_machine=abacus-unknown
+    ;;
+  adobe68k)
+    basic_machine=m68010-adobe
+    os=-scout
+    ;;
+  alliant | fx80)
+    basic_machine=fx80-alliant
+    ;;
+  altos | altos3068)
+    basic_machine=m68k-altos
+    ;;
+  am29k)
+    basic_machine=a29k-none
+    os=-bsd
+    ;;
+  amd64)
+    basic_machine=x86_64-pc
+    ;;
+  amd64-*)
+    basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  amdahl)
+    basic_machine=580-amdahl
+    os=-sysv
+    ;;
+  amiga | amiga-*)
+    basic_machine=m68k-unknown
+    ;;
+  amigaos | amigados)
+    basic_machine=m68k-unknown
+    os=-amigaos
+    ;;
+  amigaunix | amix)
+    basic_machine=m68k-unknown
+    os=-sysv4
+    ;;
+  apollo68)
+    basic_machine=m68k-apollo
+    os=-sysv
+    ;;
+  apollo68bsd)
+    basic_machine=m68k-apollo
+    os=-bsd
+    ;;
+  aros)
+    basic_machine=i386-pc
+    os=-aros
+    ;;
+  aux)
+    basic_machine=m68k-apple
+    os=-aux
+    ;;
+  balance)
+    basic_machine=ns32k-sequent
+    os=-dynix
+    ;;
+  blackfin)
+    basic_machine=bfin-unknown
+    os=-linux
+    ;;
+  blackfin-*)
+    basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'`
+    os=-linux
+    ;;
+  bluegene*)
+    basic_machine=powerpc-ibm
+    os=-cnk
+    ;;
+  c54x-*)
+    basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  c55x-*)
+    basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  c6x-*)
+    basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  c90)
+    basic_machine=c90-cray
+    os=-unicos
+    ;;
+  cegcc)
+    basic_machine=arm-unknown
+    os=-cegcc
+    ;;
+  convex-c1)
+    basic_machine=c1-convex
+    os=-bsd
+    ;;
+  convex-c2)
+    basic_machine=c2-convex
+    os=-bsd
+    ;;
+  convex-c32)
+    basic_machine=c32-convex
+    os=-bsd
+    ;;
+  convex-c34)
+    basic_machine=c34-convex
+    os=-bsd
+    ;;
+  convex-c38)
+    basic_machine=c38-convex
+    os=-bsd
+    ;;
+  cray | j90)
+    basic_machine=j90-cray
+    os=-unicos
+    ;;
+  craynv)
+    basic_machine=craynv-cray
+    os=-unicosmp
+    ;;
+  cr16 | cr16-*)
+    basic_machine=cr16-unknown
+    os=-elf
+    ;;
+  crds | unos)
+    basic_machine=m68k-crds
+    ;;
+  crisv32 | crisv32-* | etraxfs*)
+    basic_machine=crisv32-axis
+    ;;
+  cris | cris-* | etrax*)
+    basic_machine=cris-axis
+    ;;
+  crx)
+    basic_machine=crx-unknown
+    os=-elf
+    ;;
+  da30 | da30-*)
+    basic_machine=m68k-da30
+    ;;
+  decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
+    basic_machine=mips-dec
+    ;;
+  decsystem10* | dec10*)
+    basic_machine=pdp10-dec
+    os=-tops10
+    ;;
+  decsystem20* | dec20*)
+    basic_machine=pdp10-dec
+    os=-tops20
+    ;;
+  delta | 3300 | motorola-3300 | motorola-delta \
+        | 3300-motorola | delta-motorola)
+    basic_machine=m68k-motorola
+    ;;
+  delta88)
+    basic_machine=m88k-motorola
+    os=-sysv3
+    ;;
+  dicos)
+    basic_machine=i686-pc
+    os=-dicos
+    ;;
+  djgpp)
+    basic_machine=i586-pc
+    os=-msdosdjgpp
+    ;;
+  dpx20 | dpx20-*)
+    basic_machine=rs6000-bull
+    os=-bosx
+    ;;
+  dpx2* | dpx2*-bull)
+    basic_machine=m68k-bull
+    os=-sysv3
+    ;;
+  ebmon29k)
+    basic_machine=a29k-amd
+    os=-ebmon
+    ;;
+  elxsi)
+    basic_machine=elxsi-elxsi
+    os=-bsd
+    ;;
+  encore | umax | mmax)
+    basic_machine=ns32k-encore
+    ;;
+  es1800 | OSE68k | ose68k | ose | OSE)
+    basic_machine=m68k-ericsson
+    os=-ose
+    ;;
+  fx2800)
+    basic_machine=i860-alliant
+    ;;
+  genix)
+    basic_machine=ns32k-ns
+    ;;
+  gmicro)
+    basic_machine=tron-gmicro
+    os=-sysv
+    ;;
+  go32)
+    basic_machine=i386-pc
+    os=-go32
+    ;;
+  h3050r* | hiux*)
+    basic_machine=hppa1.1-hitachi
+    os=-hiuxwe2
+    ;;
+  h8300hms)
+    basic_machine=h8300-hitachi
+    os=-hms
+    ;;
+  h8300xray)
+    basic_machine=h8300-hitachi
+    os=-xray
+    ;;
+  h8500hms)
+    basic_machine=h8500-hitachi
+    os=-hms
+    ;;
+  harris)
+    basic_machine=m88k-harris
+    os=-sysv3
+    ;;
+  hp300-*)
+    basic_machine=m68k-hp
+    ;;
+  hp300bsd)
+    basic_machine=m68k-hp
+    os=-bsd
+    ;;
+  hp300hpux)
+    basic_machine=m68k-hp
+    os=-hpux
+    ;;
+  hp3k9[0-9][0-9] | hp9[0-9][0-9])
+    basic_machine=hppa1.0-hp
+    ;;
+  hp9k2[0-9][0-9] | hp9k31[0-9])
+    basic_machine=m68000-hp
+    ;;
+  hp9k3[2-9][0-9])
+    basic_machine=m68k-hp
+    ;;
+  hp9k6[0-9][0-9] | hp6[0-9][0-9])
+    basic_machine=hppa1.0-hp
+    ;;
+  hp9k7[0-79][0-9] | hp7[0-79][0-9])
+    basic_machine=hppa1.1-hp
+    ;;
+  hp9k78[0-9] | hp78[0-9])
+    # FIXME: really hppa2.0-hp
+    basic_machine=hppa1.1-hp
+    ;;
+  hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
+    # FIXME: really hppa2.0-hp
+    basic_machine=hppa1.1-hp
+    ;;
+  hp9k8[0-9][13679] | hp8[0-9][13679])
+    basic_machine=hppa1.1-hp
+    ;;
+  hp9k8[0-9][0-9] | hp8[0-9][0-9])
+    basic_machine=hppa1.0-hp
+    ;;
+  hppa-next)
+    os=-nextstep3
+    ;;
+  hppaosf)
+    basic_machine=hppa1.1-hp
+    os=-osf
+    ;;
+  hppro)
+    basic_machine=hppa1.1-hp
+    os=-proelf
+    ;;
+  i370-ibm* | ibm*)
+    basic_machine=i370-ibm
+    ;;
+  i*86v32)
+    basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+    os=-sysv32
+    ;;
+  i*86v4*)
+    basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+    os=-sysv4
+    ;;
+  i*86v)
+    basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+    os=-sysv
+    ;;
+  i*86sol2)
+    basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+    os=-solaris2
+    ;;
+  i386mach)
+    basic_machine=i386-mach
+    os=-mach
+    ;;
+  i386-vsta | vsta)
+    basic_machine=i386-unknown
+    os=-vsta
+    ;;
+  iris | iris4d)
+    basic_machine=mips-sgi
+    case $os in
+        -irix*)
+      ;;
+        *)
+      os=-irix4
+      ;;
+    esac
+    ;;
+  isi68 | isi)
+    basic_machine=m68k-isi
+    os=-sysv
+    ;;
+  m68knommu)
+    basic_machine=m68k-unknown
+    os=-linux
+    ;;
+  m68knommu-*)
+    basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'`
+    os=-linux
+    ;;
+  m88k-omron*)
+    basic_machine=m88k-omron
+    ;;
+  magnum | m3230)
+    basic_machine=mips-mips
+    os=-sysv
+    ;;
+  merlin)
+    basic_machine=ns32k-utek
+    os=-sysv
+    ;;
+  microblaze)
+    basic_machine=microblaze-xilinx
+    ;;
+  mingw32)
+    basic_machine=i386-pc
+    os=-mingw32
+    ;;
+  mingw32ce)
+    basic_machine=arm-unknown
+    os=-mingw32ce
+    ;;
+  miniframe)
+    basic_machine=m68000-convergent
+    ;;
+  *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
+    basic_machine=m68k-atari
+    os=-mint
+    ;;
+  mips3*-*)
+    basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
+    ;;
+  mips3*)
+    basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
+    ;;
+  monitor)
+    basic_machine=m68k-rom68k
+    os=-coff
+    ;;
+  morphos)
+    basic_machine=powerpc-unknown
+    os=-morphos
+    ;;
+  msdos)
+    basic_machine=i386-pc
+    os=-msdos
+    ;;
+  ms1-*)
+    basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'`
+    ;;
+  msys)
+    basic_machine=i386-pc
+    os=-msys
+    ;;
+  mvs)
+    basic_machine=i370-ibm
+    os=-mvs
+    ;;
+  nacl)
+    basic_machine=le32-unknown
+    os=-nacl
+    ;;
+  ncr3000)
+    basic_machine=i486-ncr
+    os=-sysv4
+    ;;
+  netbsd386)
+    basic_machine=i386-unknown
+    os=-netbsd
+    ;;
+  netwinder)
+    basic_machine=armv4l-rebel
+    os=-linux
+    ;;
+  news | news700 | news800 | news900)
+    basic_machine=m68k-sony
+    os=-newsos
+    ;;
+  news1000)
+    basic_machine=m68030-sony
+    os=-newsos
+    ;;
+  news-3600 | risc-news)
+    basic_machine=mips-sony
+    os=-newsos
+    ;;
+  necv70)
+    basic_machine=v70-nec
+    os=-sysv
+    ;;
+  next | m*-next )
+    basic_machine=m68k-next
+    case $os in
+        -nextstep* )
+      ;;
+        -ns2*)
+          os=-nextstep2
+      ;;
+        *)
+          os=-nextstep3
+      ;;
+    esac
+    ;;
+  nh3000)
+    basic_machine=m68k-harris
+    os=-cxux
+    ;;
+  nh[45]000)
+    basic_machine=m88k-harris
+    os=-cxux
+    ;;
+  nindy960)
+    basic_machine=i960-intel
+    os=-nindy
+    ;;
+  mon960)
+    basic_machine=i960-intel
+    os=-mon960
+    ;;
+  nonstopux)
+    basic_machine=mips-compaq
+    os=-nonstopux
+    ;;
+  np1)
+    basic_machine=np1-gould
+    ;;
+  neo-tandem)
+    basic_machine=neo-tandem
+    ;;
+  nse-tandem)
+    basic_machine=nse-tandem
+    ;;
+  nsr-tandem)
+    basic_machine=nsr-tandem
+    ;;
+  op50n-* | op60c-*)
+    basic_machine=hppa1.1-oki
+    os=-proelf
+    ;;
+  openrisc | openrisc-*)
+    basic_machine=or32-unknown
+    ;;
+  os400)
+    basic_machine=powerpc-ibm
+    os=-os400
+    ;;
+  OSE68000 | ose68000)
+    basic_machine=m68000-ericsson
+    os=-ose
+    ;;
+  os68k)
+    basic_machine=m68k-none
+    os=-os68k
+    ;;
+  pa-hitachi)
+    basic_machine=hppa1.1-hitachi
+    os=-hiuxwe2
+    ;;
+  paragon)
+    basic_machine=i860-intel
+    os=-osf
+    ;;
+  parisc)
+    basic_machine=hppa-unknown
+    os=-linux
+    ;;
+  parisc-*)
+    basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'`
+    os=-linux
+    ;;
+  pbd)
+    basic_machine=sparc-tti
+    ;;
+  pbb)
+    basic_machine=m68k-tti
+    ;;
+  pc532 | pc532-*)
+    basic_machine=ns32k-pc532
+    ;;
+  pc98)
+    basic_machine=i386-pc
+    ;;
+  pc98-*)
+    basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  pentium | p5 | k5 | k6 | nexgen | viac3)
+    basic_machine=i586-pc
+    ;;
+  pentiumpro | p6 | 6x86 | athlon | athlon_*)
+    basic_machine=i686-pc
+    ;;
+  pentiumii | pentium2 | pentiumiii | pentium3)
+    basic_machine=i686-pc
+    ;;
+  pentium4)
+    basic_machine=i786-pc
+    ;;
+  pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
+    basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  pentiumpro-* | p6-* | 6x86-* | athlon-*)
+    basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
+    basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  pentium4-*)
+    basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  pn)
+    basic_machine=pn-gould
+    ;;
+  power)  basic_machine=power-ibm
+    ;;
+  ppc | ppcbe)  basic_machine=powerpc-unknown
+    ;;
+  ppc-* | ppcbe-*)
+    basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  ppcle | powerpclittle | ppc-le | powerpc-little)
+    basic_machine=powerpcle-unknown
+    ;;
+  ppcle-* | powerpclittle-*)
+    basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  ppc64)  basic_machine=powerpc64-unknown
+    ;;
+  ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  ppc64le | powerpc64little | ppc64-le | powerpc64-little)
+    basic_machine=powerpc64le-unknown
+    ;;
+  ppc64le-* | powerpc64little-*)
+    basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  ps2)
+    basic_machine=i386-ibm
+    ;;
+  pw32)
+    basic_machine=i586-unknown
+    os=-pw32
+    ;;
+  rdos)
+    basic_machine=i386-pc
+    os=-rdos
+    ;;
+  rom68k)
+    basic_machine=m68k-rom68k
+    os=-coff
+    ;;
+  rm[46]00)
+    basic_machine=mips-siemens
+    ;;
+  rtpc | rtpc-*)
+    basic_machine=romp-ibm
+    ;;
+  s390 | s390-*)
+    basic_machine=s390-ibm
+    ;;
+  s390x | s390x-*)
+    basic_machine=s390x-ibm
+    ;;
+  sa29200)
+    basic_machine=a29k-amd
+    os=-udi
+    ;;
+  sb1)
+    basic_machine=mipsisa64sb1-unknown
+    ;;
+  sb1el)
+    basic_machine=mipsisa64sb1el-unknown
+    ;;
+  sde)
+    basic_machine=mipsisa32-sde
+    os=-elf
+    ;;
+  sei)
+    basic_machine=mips-sei
+    os=-seiux
+    ;;
+  sequent)
+    basic_machine=i386-sequent
+    ;;
+  sh)
+    basic_machine=sh-hitachi
+    os=-hms
+    ;;
+  sh5el)
+    basic_machine=sh5le-unknown
+    ;;
+  sh64)
+    basic_machine=sh64-unknown
+    ;;
+  sparclite-wrs | simso-wrs)
+    basic_machine=sparclite-wrs
+    os=-vxworks
+    ;;
+  sps7)
+    basic_machine=m68k-bull
+    os=-sysv2
+    ;;
+  spur)
+    basic_machine=spur-unknown
+    ;;
+  st2000)
+    basic_machine=m68k-tandem
+    ;;
+  stratus)
+    basic_machine=i860-stratus
+    os=-sysv4
+    ;;
+  strongarm-* | thumb-*)
+    basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  sun2)
+    basic_machine=m68000-sun
+    ;;
+  sun2os3)
+    basic_machine=m68000-sun
+    os=-sunos3
+    ;;
+  sun2os4)
+    basic_machine=m68000-sun
+    os=-sunos4
+    ;;
+  sun3os3)
+    basic_machine=m68k-sun
+    os=-sunos3
+    ;;
+  sun3os4)
+    basic_machine=m68k-sun
+    os=-sunos4
+    ;;
+  sun4os3)
+    basic_machine=sparc-sun
+    os=-sunos3
+    ;;
+  sun4os4)
+    basic_machine=sparc-sun
+    os=-sunos4
+    ;;
+  sun4sol2)
+    basic_machine=sparc-sun
+    os=-solaris2
+    ;;
+  sun3 | sun3-*)
+    basic_machine=m68k-sun
+    ;;
+  sun4)
+    basic_machine=sparc-sun
+    ;;
+  sun386 | sun386i | roadrunner)
+    basic_machine=i386-sun
+    ;;
+  sv1)
+    basic_machine=sv1-cray
+    os=-unicos
+    ;;
+  symmetry)
+    basic_machine=i386-sequent
+    os=-dynix
+    ;;
+  t3e)
+    basic_machine=alphaev5-cray
+    os=-unicos
+    ;;
+  t90)
+    basic_machine=t90-cray
+    os=-unicos
+    ;;
+  tile*)
+    basic_machine=$basic_machine-unknown
+    os=-linux-gnu
+    ;;
+  tx39)
+    basic_machine=mipstx39-unknown
+    ;;
+  tx39el)
+    basic_machine=mipstx39el-unknown
+    ;;
+  toad1)
+    basic_machine=pdp10-xkl
+    os=-tops20
+    ;;
+  tower | tower-32)
+    basic_machine=m68k-ncr
+    ;;
+  tpf)
+    basic_machine=s390x-ibm
+    os=-tpf
+    ;;
+  udi29k)
+    basic_machine=a29k-amd
+    os=-udi
+    ;;
+  ultra3)
+    basic_machine=a29k-nyu
+    os=-sym1
+    ;;
+  v810 | necv810)
+    basic_machine=v810-nec
+    os=-none
+    ;;
+  vaxv)
+    basic_machine=vax-dec
+    os=-sysv
+    ;;
+  vms)
+    basic_machine=vax-dec
+    os=-vms
+    ;;
+  vpp*|vx|vx-*)
+    basic_machine=f301-fujitsu
+    ;;
+  vxworks960)
+    basic_machine=i960-wrs
+    os=-vxworks
+    ;;
+  vxworks68)
+    basic_machine=m68k-wrs
+    os=-vxworks
+    ;;
+  vxworks29k)
+    basic_machine=a29k-wrs
+    os=-vxworks
+    ;;
+  w65*)
+    basic_machine=w65-wdc
+    os=-none
+    ;;
+  w89k-*)
+    basic_machine=hppa1.1-winbond
+    os=-proelf
+    ;;
+  xbox)
+    basic_machine=i686-pc
+    os=-mingw32
+    ;;
+  xps | xps100)
+    basic_machine=xps100-honeywell
+    ;;
+  xscale-* | xscalee[bl]-*)
+    basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'`
+    ;;
+  ymp)
+    basic_machine=ymp-cray
+    os=-unicos
+    ;;
+  z8k-*-coff)
+    basic_machine=z8k-unknown
+    os=-sim
+    ;;
+  z80-*-coff)
+    basic_machine=z80-unknown
+    os=-sim
+    ;;
+  none)
+    basic_machine=none-none
+    os=-none
+    ;;
+
+# Here we handle the default manufacturer of certain CPU types.  It is in
+# some cases the only manufacturer, in others, it is the most popular.
+  w89k)
+    basic_machine=hppa1.1-winbond
+    ;;
+  op50n)
+    basic_machine=hppa1.1-oki
+    ;;
+  op60c)
+    basic_machine=hppa1.1-oki
+    ;;
+  romp)
+    basic_machine=romp-ibm
+    ;;
+  mmix)
+    basic_machine=mmix-knuth
+    ;;
+  rs6000)
+    basic_machine=rs6000-ibm
+    ;;
+  vax)
+    basic_machine=vax-dec
+    ;;
+  pdp10)
+    # there are many clones, so DEC is not a safe bet
+    basic_machine=pdp10-unknown
+    ;;
+  pdp11)
+    basic_machine=pdp11-dec
+    ;;
+  we32k)
+    basic_machine=we32k-att
+    ;;
+  sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele)
+    basic_machine=sh-unknown
+    ;;
+  sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v)
+    basic_machine=sparc-sun
+    ;;
+  cydra)
+    basic_machine=cydra-cydrome
+    ;;
+  orion)
+    basic_machine=orion-highlevel
+    ;;
+  orion105)
+    basic_machine=clipper-highlevel
+    ;;
+  mac | mpw | mac-mpw)
+    basic_machine=m68k-apple
+    ;;
+  pmac | pmac-mpw)
+    basic_machine=powerpc-apple
+    ;;
+  *-unknown)
+    # Make sure to match an already-canonicalized machine name.
+    ;;
+  *)
+    echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+    exit 1
+    ;;
+esac
+
+# Here we canonicalize certain aliases for manufacturers.
+case $basic_machine in
+  *-digital*)
+    basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
+    ;;
+  *-commodore*)
+    basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
+    ;;
+  *)
+    ;;
+esac
+
+# Decode manufacturer-specific aliases for certain operating systems.
+
+if [ x"$os" != x"" ]
+then
+case $os in
+  # First match some system type aliases
+  # that might get confused with valid system types.
+  # -solaris* is a basic system type, with this one exception.
+  -auroraux)
+    os=-auroraux
+    ;;
+  -solaris1 | -solaris1.*)
+    os=`echo $os | sed -e 's|solaris1|sunos4|'`
+    ;;
+  -solaris)
+    os=-solaris2
+    ;;
+  -svr4*)
+    os=-sysv4
+    ;;
+  -unixware*)
+    os=-sysv4.2uw
+    ;;
+  -gnu/linux*)
+    os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
+    ;;
+  # First accept the basic system types.
+  # The portable systems comes first.
+  # Each alternative MUST END IN A *, to match a version number.
+  # -sysv* is not here because it comes later, after sysvr4.
+  -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
+        | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\
+        | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \
+        | -sym* | -kopensolaris* \
+        | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
+        | -aos* | -aros* \
+        | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
+        | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
+        | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \
+        | -openbsd* | -solidbsd* \
+        | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
+        | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
+        | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
+        | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
+        | -chorusos* | -chorusrdb* | -cegcc* \
+        | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
+        | -mingw32* | -linux-gnu* | -linux-android* \
+        | -linux-newlib* | -linux-uclibc* \
+        | -uxpv* | -beos* | -mpeix* | -udk* \
+        | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
+        | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
+        | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
+        | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
+        | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
+        | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
+        | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es*)
+  # Remember, each alternative MUST END IN *, to match a version number.
+    ;;
+  -qnx*)
+    case $basic_machine in
+        x86-* | i*86-*)
+      ;;
+        *)
+      os=-nto$os
+      ;;
+    esac
+    ;;
+  -nto-qnx*)
+    ;;
+  -nto*)
+    os=`echo $os | sed -e 's|nto|nto-qnx|'`
+    ;;
+  -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
+        | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \
+        | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
+    ;;
+  -mac*)
+    os=`echo $os | sed -e 's|mac|macos|'`
+    ;;
+  -linux-dietlibc)
+    os=-linux-dietlibc
+    ;;
+  -linux*)
+    os=`echo $os | sed -e 's|linux|linux-gnu|'`
+    ;;
+  -sunos5*)
+    os=`echo $os | sed -e 's|sunos5|solaris2|'`
+    ;;
+  -sunos6*)
+    os=`echo $os | sed -e 's|sunos6|solaris3|'`
+    ;;
+  -opened*)
+    os=-openedition
+    ;;
+  -os400*)
+    os=-os400
+    ;;
+  -wince*)
+    os=-wince
+    ;;
+  -osfrose*)
+    os=-osfrose
+    ;;
+  -osf*)
+    os=-osf
+    ;;
+  -utek*)
+    os=-bsd
+    ;;
+  -dynix*)
+    os=-bsd
+    ;;
+  -acis*)
+    os=-aos
+    ;;
+  -atheos*)
+    os=-atheos
+    ;;
+  -syllable*)
+    os=-syllable
+    ;;
+  -386bsd)
+    os=-bsd
+    ;;
+  -ctix* | -uts*)
+    os=-sysv
+    ;;
+  -nova*)
+    os=-rtmk-nova
+    ;;
+  -ns2 )
+    os=-nextstep2
+    ;;
+  -nsk*)
+    os=-nsk
+    ;;
+  # Preserve the version number of sinix5.
+  -sinix5.*)
+    os=`echo $os | sed -e 's|sinix|sysv|'`
+    ;;
+  -sinix*)
+    os=-sysv4
+    ;;
+  -tpf*)
+    os=-tpf
+    ;;
+  -triton*)
+    os=-sysv3
+    ;;
+  -oss*)
+    os=-sysv3
+    ;;
+  -svr4)
+    os=-sysv4
+    ;;
+  -svr3)
+    os=-sysv3
+    ;;
+  -sysvr4)
+    os=-sysv4
+    ;;
+  # This must come after -sysvr4.
+  -sysv*)
+    ;;
+  -ose*)
+    os=-ose
+    ;;
+  -es1800*)
+    os=-ose
+    ;;
+  -xenix)
+    os=-xenix
+    ;;
+  -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+    os=-mint
+    ;;
+  -aros*)
+    os=-aros
+    ;;
+  -kaos*)
+    os=-kaos
+    ;;
+  -zvmoe)
+    os=-zvmoe
+    ;;
+  -dicos*)
+    os=-dicos
+    ;;
+  -nacl*)
+    ;;
+  -none)
+    ;;
+  *)
+    # Get rid of the `-' at the beginning of $os.
+    os=`echo $os | sed 's/[^-]*-//'`
+    echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
+    exit 1
+    ;;
+esac
+else
+
+# Here we handle the default operating systems that come with various machines.
+# The value should be what the vendor currently ships out the door with their
+# machine or put another way, the most popular os provided with the machine.
+
+# Note that if you're going to try to match "-MANUFACTURER" here (say,
+# "-sun"), then you have to tell the case statement up towards the top
+# that MANUFACTURER isn't an operating system.  Otherwise, code above
+# will signal an error saying that MANUFACTURER isn't an operating
+# system, and we'll never get to this point.
+
+case $basic_machine in
+  score-*)
+    os=-elf
+    ;;
+  spu-*)
+    os=-elf
+    ;;
+  *-acorn)
+    os=-riscix1.2
+    ;;
+  arm*-rebel)
+    os=-linux
+    ;;
+  arm*-semi)
+    os=-aout
+    ;;
+  c4x-* | tic4x-*)
+    os=-coff
+    ;;
+  hexagon-*)
+    os=-elf
+    ;;
+  tic54x-*)
+    os=-coff
+    ;;
+  tic55x-*)
+    os=-coff
+    ;;
+  tic6x-*)
+    os=-coff
+    ;;
+  # This must come before the *-dec entry.
+  pdp10-*)
+    os=-tops20
+    ;;
+  pdp11-*)
+    os=-none
+    ;;
+  *-dec | vax-*)
+    os=-ultrix4.2
+    ;;
+  m68*-apollo)
+    os=-domain
+    ;;
+  i386-sun)
+    os=-sunos4.0.2
+    ;;
+  m68000-sun)
+    os=-sunos3
+    ;;
+  m68*-cisco)
+    os=-aout
+    ;;
+  mep-*)
+    os=-elf
+    ;;
+  mips*-cisco)
+    os=-elf
+    ;;
+  mips*-*)
+    os=-elf
+    ;;
+  or32-*)
+    os=-coff
+    ;;
+  *-tti)  # must be before sparc entry or we get the wrong os.
+    os=-sysv3
+    ;;
+  sparc-* | *-sun)
+    os=-sunos4.1.1
+    ;;
+  *-be)
+    os=-beos
+    ;;
+  *-haiku)
+    os=-haiku
+    ;;
+  *-ibm)
+    os=-aix
+    ;;
+  *-knuth)
+    os=-mmixware
+    ;;
+  *-wec)
+    os=-proelf
+    ;;
+  *-winbond)
+    os=-proelf
+    ;;
+  *-oki)
+    os=-proelf
+    ;;
+  *-hp)
+    os=-hpux
+    ;;
+  *-hitachi)
+    os=-hiux
+    ;;
+  i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
+    os=-sysv
+    ;;
+  *-cbm)
+    os=-amigaos
+    ;;
+  *-dg)
+    os=-dgux
+    ;;
+  *-dolphin)
+    os=-sysv3
+    ;;
+  m68k-ccur)
+    os=-rtu
+    ;;
+  m88k-omron*)
+    os=-luna
+    ;;
+  *-next )
+    os=-nextstep
+    ;;
+  *-sequent)
+    os=-ptx
+    ;;
+  *-crds)
+    os=-unos
+    ;;
+  *-ns)
+    os=-genix
+    ;;
+  i370-*)
+    os=-mvs
+    ;;
+  *-next)
+    os=-nextstep3
+    ;;
+  *-gould)
+    os=-sysv
+    ;;
+  *-highlevel)
+    os=-bsd
+    ;;
+  *-encore)
+    os=-bsd
+    ;;
+  *-sgi)
+    os=-irix
+    ;;
+  *-siemens)
+    os=-sysv4
+    ;;
+  *-masscomp)
+    os=-rtu
+    ;;
+  f30[01]-fujitsu | f700-fujitsu)
+    os=-uxpv
+    ;;
+  *-rom68k)
+    os=-coff
+    ;;
+  *-*bug)
+    os=-coff
+    ;;
+  *-apple)
+    os=-macos
+    ;;
+  *-atari*)
+    os=-mint
+    ;;
+  *)
+    os=-none
+    ;;
+esac
+fi
+
+# Here we handle the case where we know the os, and the CPU type, but not the
+# manufacturer.  We pick the logical manufacturer.
+vendor=unknown
+case $basic_machine in
+  *-unknown)
+    case $os in
+      -riscix*)
+        vendor=acorn
+        ;;
+      -sunos*)
+        vendor=sun
+        ;;
+      -cnk*|-aix*)
+        vendor=ibm
+        ;;
+      -beos*)
+        vendor=be
+        ;;
+      -hpux*)
+        vendor=hp
+        ;;
+      -mpeix*)
+        vendor=hp
+        ;;
+      -hiux*)
+        vendor=hitachi
+        ;;
+      -unos*)
+        vendor=crds
+        ;;
+      -dgux*)
+        vendor=dg
+        ;;
+      -luna*)
+        vendor=omron
+        ;;
+      -genix*)
+        vendor=ns
+        ;;
+      -mvs* | -opened*)
+        vendor=ibm
+        ;;
+      -os400*)
+        vendor=ibm
+        ;;
+      -ptx*)
+        vendor=sequent
+        ;;
+      -tpf*)
+        vendor=ibm
+        ;;
+      -vxsim* | -vxworks* | -windiss*)
+        vendor=wrs
+        ;;
+      -aux*)
+        vendor=apple
+        ;;
+      -hms*)
+        vendor=hitachi
+        ;;
+      -mpw* | -macos*)
+        vendor=apple
+        ;;
+      -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+        vendor=atari
+        ;;
+      -vos*)
+        vendor=stratus
+        ;;
+    esac
+    basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
+    ;;
+esac
+
+echo $basic_machine$os
+exit
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:

polly/trunk/lib/External/ppcg/configure.ac

+AC_INIT([ppcg], [0.04], [[e-mail]])
+AC_CONFIG_AUX_DIR([.])
+AC_CONFIG_MACRO_DIR([m4])
+AM_INIT_AUTOMAKE([foreign])
+m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
+
+AC_PROG_CC
+AC_PROG_LIBTOOL
+PKG_PROG_PKG_CONFIG
+
+AX_CHECK_OPENMP
+AX_CHECK_OPENCL
+if test $HAVE_OPENCL = yes; then
+  extra_tests="$extra_tests opencl_test.sh"
+fi
+
+AX_SUBMODULE(isl,build|bundled|system,bundled)
+AM_CONDITIONAL(BUNDLED_ISL, test $with_isl = bundled)
+
+AC_SUBST(ISL_CFLAGS)
+AC_SUBST(ISL_LIBS)
+case "$with_isl" in
+bundled)
+  ISL_CFLAGS="-I\$(top_srcdir)/isl/include -I\$(top_builddir)/isl/include"
+  ISL_CFLAGS="$ISL_CFLAGS"
+  ppcg_configure_args="$ppcg_configure_args --with-isl-builddir=../isl"
+  ppcg_configure_args="$ppcg_configure_args --with-isl=build"
+  ;;
+build)
+  ISL_BUILDDIR=`echo @abs_builddir@ | $with_isl_builddir/config.status --file=-`
+  ppcg_configure_args="$ppcg_configure_args --with-isl-builddir=$ISL_BUILDDIR"
+  ISL_CFLAGS="-I$isl_srcdir/include -I$ISL_BUILDDIR/include"
+  ISL_CFLAGS="$ISL_CFLAGS"
+  ISL_LIBS="$with_isl_builddir/libisl.la"
+  ;;
+system)
+  PKG_CHECK_MODULES([ISL], [isl])
+esac
+
+AX_SUBMODULE(pet,bundled|system,bundled)
+AM_CONDITIONAL(BUNDLED_PET, test $with_pet = bundled)
+
+AC_SUBST(PET_CFLAGS)
+AC_SUBST(PET_LIBS)
+case "$with_pet" in
+bundled)
+  PET_CFLAGS="$PET_CFLAGS -I\$(top_srcdir)/pet/include"
+  ;;
+system)
+  PKG_CHECK_MODULES([PET], [pet])
+  ;;
+esac
+
+AC_SUBST(POLYBENCH_DIR)
+AC_SUBST(extra_tests)
+AC_ARG_WITH([polybench],
+  [AS_HELP_STRING([--with-polybench=DIR], [PolyBench location])],
+  [
+  if test -f "$with_polybench/utilities/benchmark_list"; then
+    POLYBENCH_DIR=$with_polybench
+    extra_tests="$extra_tests polybench_test.sh"
+  fi
+  ])
+
+AX_DETECT_GIT_HEAD
+echo '#define GIT_HEAD_ID "'$GIT_HEAD_ID'"' > gitversion.h
+
+AC_CONFIG_FILES(Makefile)
+AC_CONFIG_FILES([polybench_test.sh], [chmod +x polybench_test.sh])
+AC_CONFIG_FILES([opencl_test.sh], [chmod +x opencl_test.sh])
+if test $with_isl = bundled; then
+  AC_CONFIG_SUBDIRS(isl)
+fi
+if test $with_pet = bundled; then
+  AC_CONFIG_SUBDIRS(pet)
+fi
+AC_CONFIG_COMMANDS_POST([
+  dnl pass on arguments to subdir configures, but don't
+  dnl add them to config.status
+  ac_configure_args="$ac_configure_args $ppcg_configure_args"
+])
+AC_OUTPUT

polly/trunk/lib/External/ppcg/cpu.h

+#ifndef _CPU_H
+#define _CPU_H
+
+#include <isl/ctx.h>
+
+#include "ppcg.h"
+
+struct ppcg_options;
+
+__isl_give isl_printer *print_cpu(__isl_take isl_printer *p,
+  struct ppcg_scop *ps, struct ppcg_options *options);
+int generate_cpu(isl_ctx *ctx, struct ppcg_options *options,
+  const char *input, const char *output);
+
+#endif

polly/trunk/lib/External/ppcg/cpu.c

+/*
+ * Copyright 2012 INRIA Paris-Rocquencourt
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Tobias Grosser, INRIA Paris-Rocquencourt,
+ * Domaine de Voluceau, Rocquenqourt, B.P. 105,
+ * 78153 Le Chesnay Cedex France
+ */
+
+#include <limits.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <isl/aff.h>
+#include <isl/ctx.h>
+#include <isl/map.h>
+#include <isl/ast_build.h>
+#include <pet.h>
+
+#include "ppcg.h"
+#include "ppcg_options.h"
+#include "cpu.h"
+#include "print.h"
+
+/* Representation of a statement inside a generated AST.
+ *
+ * "stmt" refers to the original statement.
+ * "ref2expr" maps the reference identifier of each access in
+ * the statement to an AST expression that should be printed
+ * at the place of the access.
+ */
+struct ppcg_stmt {
+  struct pet_stmt *stmt;
+
+  isl_id_to_ast_expr *ref2expr;
+};
+
+static void ppcg_stmt_free(void *user)
+{
+  struct ppcg_stmt *stmt = user;
+  int i;
+
+  if (!stmt)
+    return;
+
+  isl_id_to_ast_expr_free(stmt->ref2expr);
+
+  free(stmt);
+}
+
+/* Derive the output file name from the input file name.
+ * 'input' is the entire path of the input file. The output
+ * is the file name plus the additional extension.
+ *
+ * We will basically replace everything after the last point
+ * with '.ppcg.c'. This means file.c becomes file.ppcg.c
+ */
+static FILE *get_output_file(const char *input, const char *output)
+{
+  char name[PATH_MAX];
+  const char *ext;
+  const char ppcg_marker[] = ".ppcg";
+  int len;
+  FILE *file;
+
+  len = ppcg_extract_base_name(name, input);
+
+  strcpy(name + len, ppcg_marker);
+  ext = strrchr(input, '.');
+  strcpy(name + len + sizeof(ppcg_marker) - 1, ext ? ext : ".c");
+
+  if (!output)
+    output = name;
+
+  file = fopen(output, "w");
+  if (!file) {
+    fprintf(stderr, "Unable to open '%s' for writing\n", output);
+    return NULL;
+  }
+
+  return file;
+}
+
+/* Data used to annotate for nodes in the ast.
+ */
+struct ast_node_userinfo {
+  /* The for node is an openmp parallel for node. */
+  int is_openmp;
+};
+
+/* Information used while building the ast.
+ */
+struct ast_build_userinfo {
+  /* The current ppcg scop. */
+  struct ppcg_scop *scop;
+
+  /* Are we currently in a parallel for loop? */
+  int in_parallel_for;
+};
+
+/* Check if the current scheduling dimension is parallel.
+ *
+ * We check for parallelism by verifying that the loop does not carry any
+ * dependences.
+ * If the live_range_reordering option is set, then this currently
+ * includes the order dependences.  In principle, non-zero order dependences
+ * could be allowed, but this would require privatization and/or expansion.
+ *
+ * Parallelism test: if the distance is zero in all outer dimensions, then it
+ * has to be zero in the current dimension as well.
+ * Implementation: first, translate dependences into time space, then force
+ * outer dimensions to be equal.  If the distance is zero in the current
+ * dimension, then the loop is parallel.
+ * The distance is zero in the current dimension if it is a subset of a map
+ * with equal values for the current dimension.
+ */
+static int ast_schedule_dim_is_parallel(__isl_keep isl_ast_build *build,
+  struct ppcg_scop *scop)
+{
+  isl_union_map *schedule_node, *schedule, *deps;
+  isl_map *schedule_deps, *test;
+  isl_space *schedule_space;
+  unsigned i, dimension, is_parallel;
+
+  schedule = isl_ast_build_get_schedule(build);
+  schedule_space = isl_ast_build_get_schedule_space(build);
+
+  dimension = isl_space_dim(schedule_space, isl_dim_out) - 1;
+
+  deps = isl_union_map_copy(scop->dep_flow);
+  deps = isl_union_map_union(deps, isl_union_map_copy(scop->dep_false));
+  if (scop->options->live_range_reordering) {
+    isl_union_map *order = isl_union_map_copy(scop->dep_order);
+    deps = isl_union_map_union(deps, order);
+  }
+  deps = isl_union_map_apply_range(deps, isl_union_map_copy(schedule));
+  deps = isl_union_map_apply_domain(deps, schedule);
+
+  if (isl_union_map_is_empty(deps)) {
+    isl_union_map_free(deps);
+    isl_space_free(schedule_space);
+    return 1;
+  }
+
+  schedule_deps = isl_map_from_union_map(deps);
+
+  for (i = 0; i < dimension; i++)
+    schedule_deps = isl_map_equate(schedule_deps, isl_dim_out, i,
+                 isl_dim_in, i);
+
+  test = isl_map_universe(isl_map_get_space(schedule_deps));
+  test = isl_map_equate(test, isl_dim_out, dimension, isl_dim_in,
+            dimension);
+  is_parallel = isl_map_is_subset(schedule_deps, test);
+
+  isl_space_free(schedule_space);
+  isl_map_free(test);
+  isl_map_free(schedule_deps);
+
+  return is_parallel;
+}
+
+/* Mark a for node openmp parallel, if it is the outermost parallel for node.
+ */
+static void mark_openmp_parallel(__isl_keep isl_ast_build *build,
+  struct ast_build_userinfo *build_info,
+  struct ast_node_userinfo *node_info)
+{
+  if (build_info->in_parallel_for)
+    return;
+
+  if (ast_schedule_dim_is_parallel(build, build_info->scop)) {
+    build_info->in_parallel_for = 1;
+    node_info->is_openmp = 1;
+  }
+}
+
+/* Allocate an ast_node_info structure and initialize it with default values.
+ */
+static struct ast_node_userinfo *allocate_ast_node_userinfo()
+{
+  struct ast_node_userinfo *node_info;
+  node_info = (struct ast_node_userinfo *)
+    malloc(sizeof(struct ast_node_userinfo));
+  node_info->is_openmp = 0;
+  return node_info;
+}
+
+/* Free an ast_node_info structure.
+ */
+static void free_ast_node_userinfo(void *ptr)
+{
+  struct ast_node_userinfo *info;
+  info = (struct ast_node_userinfo *) ptr;
+  free(info);
+}
+
+/* This method is executed before the construction of a for node. It creates
+ * an isl_id that is used to annotate the subsequently generated ast for nodes.
+ *
+ * In this function we also run the following analyses:
+ *
+ *  - Detection of openmp parallel loops
+ */
+static __isl_give isl_id *ast_build_before_for(
+  __isl_keep isl_ast_build *build, void *user)
+{
+  isl_id *id;
+  struct ast_build_userinfo *build_info;
+  struct ast_node_userinfo *node_info;
+
+  build_info = (struct ast_build_userinfo *) user;
+  node_info = allocate_ast_node_userinfo();
+  id = isl_id_alloc(isl_ast_build_get_ctx(build), "", node_info);
+  id = isl_id_set_free_user(id, free_ast_node_userinfo);
+
+  mark_openmp_parallel(build, build_info, node_info);
+
+  return id;
+}
+
+/* This method is executed after the construction of a for node.
+ *
+ * It performs the following actions:
+ *
+ *  - Reset the 'in_parallel_for' flag, as soon as we leave a for node,
+ *    that is marked as openmp parallel.
+ *
+ */
+static __isl_give isl_ast_node *ast_build_after_for(__isl_take isl_ast_node *node,
+        __isl_keep isl_ast_build *build, void *user) {
+  isl_id *id;
+  struct ast_build_userinfo *build_info;
+  struct ast_node_userinfo *info;
+
+  id = isl_ast_node_get_annotation(node);
+  info = isl_id_get_user(id);
+
+  if (info && info->is_openmp) {
+    build_info = (struct ast_build_userinfo *) user;
+    build_info->in_parallel_for = 0;
+  }
+
+  isl_id_free(id);
+
+  return node;
+}
+
+/* Find the element in scop->stmts that has the given "id".
+ */
+static struct pet_stmt *find_stmt(struct ppcg_scop *scop, __isl_keep isl_id *id)
+{
+  int i;
+
+  for (i = 0; i < scop->pet->n_stmt; ++i) {
+    struct pet_stmt *stmt = scop->pet->stmts[i];
+    isl_id *id_i;
+
+    id_i = isl_set_get_tuple_id(stmt->domain);
+    isl_id_free(id_i);
+
+    if (id_i == id)
+      return stmt;
+  }
+
+  isl_die(isl_id_get_ctx(id), isl_error_internal,
+    "statement not found", return NULL);
+}
+
+/* Print a user statement in the generated AST.
+ * The ppcg_stmt has been attached to the node in at_each_domain.
+ */
+static __isl_give isl_printer *print_user(__isl_take isl_printer *p,
+  __isl_take isl_ast_print_options *print_options,
+  __isl_keep isl_ast_node *node, void *user)
+{
+  struct ppcg_stmt *stmt;
+  isl_id *id;
+
+  id = isl_ast_node_get_annotation(node);
+  stmt = isl_id_get_user(id);
+  isl_id_free(id);
+
+  p = pet_stmt_print_body(stmt->stmt, p, stmt->ref2expr);
+
+  isl_ast_print_options_free(print_options);
+
+  return p;
+}
+
+
+/* Print a for loop node as an openmp parallel loop.
+ *
+ * To print an openmp parallel loop we print a normal for loop, but add
+ * "#pragma openmp parallel for" in front.
+ *
+ * Variables that are declared within the body of this for loop are
+ * automatically openmp 'private'. Iterators declared outside of the
+ * for loop are automatically openmp 'shared'. As ppcg declares all iterators
+ * at the position where they are assigned, there is no need to explicitly mark
+ * variables. Their automatically assigned type is already correct.
+ *
+ * This function only generates valid OpenMP code, if the ast was generated
+ * with the 'atomic-bounds' option enabled.
+ *
+ */
+static __isl_give isl_printer *print_for_with_openmp(
+  __isl_keep isl_ast_node *node, __isl_take isl_printer *p,
+  __isl_take isl_ast_print_options *print_options)
+{
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "#pragma omp parallel for");
+  p = isl_printer_end_line(p);
+
+  p = isl_ast_node_for_print(node, p, print_options);
+
+  return p;
+}
+
+/* Print a for node.
+ *
+ * Depending on how the node is annotated, we either print a normal
+ * for node or an openmp parallel for node.
+ */
+static __isl_give isl_printer *print_for(__isl_take isl_printer *p,
+  __isl_take isl_ast_print_options *print_options,
+  __isl_keep isl_ast_node *node, void *user)
+{
+  struct ppcg_print_info *print_info;
+  isl_id *id;
+  int openmp;
+
+  openmp = 0;
+  id = isl_ast_node_get_annotation(node);
+
+  if (id) {
+    struct ast_node_userinfo *info;
+
+    info = (struct ast_node_userinfo *) isl_id_get_user(id);
+    if (info && info->is_openmp)
+      openmp = 1;
+  }
+
+  if (openmp)
+    p = print_for_with_openmp(node, p, print_options);
+  else
+    p = isl_ast_node_for_print(node, p, print_options);
+
+  isl_id_free(id);
+
+  return p;
+}
+
+/* Index transformation callback for pet_stmt_build_ast_exprs.
+ *
+ * "index" expresses the array indices in terms of statement iterators
+ * "iterator_map" expresses the statement iterators in terms of
+ * AST loop iterators.
+ *
+ * The result expresses the array indices in terms of
+ * AST loop iterators.
+ */
+static __isl_give isl_multi_pw_aff *pullback_index(
+  __isl_take isl_multi_pw_aff *index, __isl_keep isl_id *id, void *user)
+{
+  isl_pw_multi_aff *iterator_map = user;
+
+  iterator_map = isl_pw_multi_aff_copy(iterator_map);
+  return isl_multi_pw_aff_pullback_pw_multi_aff(index, iterator_map);
+}
+
+/* Transform the accesses in the statement associated to the domain
+ * called by "node" to refer to the AST loop iterators, construct
+ * corresponding AST expressions using "build",
+ * collect them in a ppcg_stmt and annotate the node with the ppcg_stmt.
+ */
+static __isl_give isl_ast_node *at_each_domain(__isl_take isl_ast_node *node,
+  __isl_keep isl_ast_build *build, void *user)
+{
+  struct ppcg_scop *scop = user;
+  isl_ast_expr *expr, *arg;
+  isl_ctx *ctx;
+  isl_id *id;
+  isl_map *map;
+  isl_pw_multi_aff *iterator_map;
+  struct ppcg_stmt *stmt;
+
+  ctx = isl_ast_node_get_ctx(node);
+  stmt = isl_calloc_type(ctx, struct ppcg_stmt);
+  if (!stmt)
+    goto error;
+
+  expr = isl_ast_node_user_get_expr(node);
+  arg = isl_ast_expr_get_op_arg(expr, 0);
+  isl_ast_expr_free(expr);
+  id = isl_ast_expr_get_id(arg);
+  isl_ast_expr_free(arg);
+  stmt->stmt = find_stmt(scop, id);
+  isl_id_free(id);
+  if (!stmt->stmt)
+    goto error;
+
+  map = isl_map_from_union_map(isl_ast_build_get_schedule(build));
+  map = isl_map_reverse(map);
+  iterator_map = isl_pw_multi_aff_from_map(map);
+  stmt->ref2expr = pet_stmt_build_ast_exprs(stmt->stmt, build,
+            &pullback_index, iterator_map, NULL, NULL);
+  isl_pw_multi_aff_free(iterator_map);
+
+  id = isl_id_alloc(isl_ast_node_get_ctx(node), NULL, stmt);
+  id = isl_id_set_free_user(id, &ppcg_stmt_free);
+  return isl_ast_node_set_annotation(node, id);
+error:
+  ppcg_stmt_free(stmt);
+  return isl_ast_node_free(node);
+}
+
+/* Set *depth to the number of scheduling dimensions
+ * for the schedule of the first domain.
+ * We assume here that this number is the same for all domains.
+ */
+static isl_stat set_depth(__isl_take isl_map *map, void *user)
+{
+  unsigned *depth = user;
+
+  *depth = isl_map_dim(map, isl_dim_out);
+
+  isl_map_free(map);
+  return isl_stat_error;
+}
+
+/* Code generate the scop 'scop' and print the corresponding C code to 'p'.
+ */
+static __isl_give isl_printer *print_scop(struct ppcg_scop *scop,
+  __isl_take isl_printer *p, struct ppcg_options *options)
+{
+  isl_ctx *ctx = isl_printer_get_ctx(p);
+  isl_set *context;
+  isl_union_set *domain_set;
+  isl_union_map *schedule_map;
+  isl_ast_build *build;
+  isl_ast_print_options *print_options;
+  isl_ast_node *tree;
+  isl_id_list *iterators;
+  struct ast_build_userinfo build_info;
+  int depth;
+
+  context = isl_set_copy(scop->context);
+  domain_set = isl_union_set_copy(scop->domain);
+  schedule_map = isl_schedule_get_map(scop->schedule);
+  schedule_map = isl_union_map_intersect_domain(schedule_map, domain_set);
+
+  isl_union_map_foreach_map(schedule_map, &set_depth, &depth);
+
+  build = isl_ast_build_from_context(context);
+  iterators = ppcg_scop_generate_names(scop, depth, "c");
+  build = isl_ast_build_set_iterators(build, iterators);
+  build = isl_ast_build_set_at_each_domain(build, &at_each_domain, scop);
+
+  if (options->openmp) {
+    build_info.scop = scop;
+    build_info.in_parallel_for = 0;
+
+    build = isl_ast_build_set_before_each_for(build,
+              &ast_build_before_for,
+              &build_info);
+    build = isl_ast_build_set_after_each_for(build,
+              &ast_build_after_for,
+              &build_info);
+  }
+
+  tree = isl_ast_build_node_from_schedule_map(build, schedule_map);
+  isl_ast_build_free(build);
+
+  print_options = isl_ast_print_options_alloc(ctx);
+  print_options = isl_ast_print_options_set_print_user(print_options,
+              &print_user, NULL);
+
+  print_options = isl_ast_print_options_set_print_for(print_options,
+              &print_for, NULL);
+
+  p = ppcg_print_macros(p, tree);
+  p = isl_ast_node_print(tree, p, print_options);
+
+  isl_ast_node_free(tree);
+
+  return p;
+}
+
+/* Generate CPU code for the scop "ps" and print the corresponding C code
+ * to "p", including variable declarations.
+ */
+__isl_give isl_printer *print_cpu(__isl_take isl_printer *p,
+  struct ppcg_scop *ps, struct ppcg_options *options)
+{
+  int hidden;
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "/* ppcg generated CPU code */");
+  p = isl_printer_end_line(p);
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_end_line(p);
+
+  p = isl_ast_op_type_print_macro(isl_ast_op_fdiv_q, p);
+  p = ppcg_print_exposed_declarations(p, ps);
+  hidden = ppcg_scop_any_hidden_declarations(ps);
+  if (hidden) {
+    p = ppcg_start_block(p);
+    p = ppcg_print_hidden_declarations(p, ps);
+  }
+  if (options->debug->dump_final_schedule)
+    isl_schedule_dump(ps->schedule);
+  p = print_scop(ps, p, options);
+  if (hidden)
+    p = ppcg_end_block(p);
+
+  return p;
+}
+
+/* Wrapper around print_cpu for use as a ppcg_transform callback.
+ */
+static __isl_give isl_printer *print_cpu_wrap(__isl_take isl_printer *p,
+  struct ppcg_scop *scop, void *user)
+{
+  struct ppcg_options *options = user;
+
+  return print_cpu(p, scop, options);
+}
+
+/* Transform the code in the file called "input" by replacing
+ * all scops by corresponding CPU code and write the results to a file
+ * called "output".
+ */
+int generate_cpu(isl_ctx *ctx, struct ppcg_options *options,
+  const char *input, const char *output)
+{
+  FILE *output_file;
+  int r;
+
+  output_file = get_output_file(input, output);
+  if (!output_file)
+    return -1;
+
+  r = ppcg_transform(ctx, input, output_file, options,
+          &print_cpu_wrap, options);
+
+  fclose(output_file);
+
+  return r;
+}

polly/trunk/lib/External/ppcg/cuda.h

+#ifndef _CUDA_H
+#define _CUDA_H
+
+#include "ppcg_options.h"
+#include "ppcg.h"
+
+int generate_cuda(isl_ctx *ctx, struct ppcg_options *options,
+  const char *input);
+
+#endif

polly/trunk/lib/External/ppcg/cuda.c

+/*
+ * Copyright 2012      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
+ */
+
+#include <isl/aff.h>
+#include <isl/ast.h>
+
+#include "cuda_common.h"
+#include "cuda.h"
+#include "gpu.h"
+#include "gpu_print.h"
+#include "print.h"
+#include "util.h"
+
+static __isl_give isl_printer *print_cuda_macros(__isl_take isl_printer *p)
+{
+  const char *macros =
+    "#define cudaCheckReturn(ret) \\\n"
+    "  do { \\\n"
+    "    cudaError_t cudaCheckReturn_e = (ret); \\\n"
+    "    if (cudaCheckReturn_e != cudaSuccess) { \\\n"
+    "      fprintf(stderr, \"CUDA error: %s\\n\", "
+    "cudaGetErrorString(cudaCheckReturn_e)); \\\n"
+    "      fflush(stderr); \\\n"
+    "    } \\\n"
+    "    assert(cudaCheckReturn_e == cudaSuccess); \\\n"
+    "  } while(0)\n"
+    "#define cudaCheckKernel() \\\n"
+    "  do { \\\n"
+    "    cudaCheckReturn(cudaGetLastError()); \\\n"
+    "  } while(0)\n\n";
+
+  p = isl_printer_print_str(p, macros);
+  return p;
+}
+
+/* Print a declaration for the device array corresponding to "array" on "p".
+ */
+static __isl_give isl_printer *declare_device_array(__isl_take isl_printer *p,
+  struct gpu_array_info *array)
+{
+  int i;
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, array->type);
+  p = isl_printer_print_str(p, " ");
+  if (!array->linearize && array->n_index > 1)
+    p = isl_printer_print_str(p, "(");
+  p = isl_printer_print_str(p, "*dev_");
+  p = isl_printer_print_str(p, array->name);
+  if (!array->linearize && array->n_index > 1) {
+    p = isl_printer_print_str(p, ")");
+    for (i = 1; i < array->n_index; i++) {
+      p = isl_printer_print_str(p, "[");
+      p = isl_printer_print_pw_aff(p, array->bound[i]);
+      p = isl_printer_print_str(p, "]");
+    }
+  }
+  p = isl_printer_print_str(p, ";");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+static __isl_give isl_printer *declare_device_arrays(__isl_take isl_printer *p,
+  struct gpu_prog *prog)
+{
+  int i;
+
+  for (i = 0; i < prog->n_array; ++i) {
+    if (!gpu_array_requires_device_allocation(&prog->array[i]))
+      continue;
+
+    p = declare_device_array(p, &prog->array[i]);
+  }
+  p = isl_printer_start_line(p);
+  p = isl_printer_end_line(p);
+  return p;
+}
+
+static __isl_give isl_printer *allocate_device_arrays(
+  __isl_take isl_printer *p, struct gpu_prog *prog)
+{
+  int i;
+
+  for (i = 0; i < prog->n_array; ++i) {
+    if (!gpu_array_requires_device_allocation(&prog->array[i]))
+      continue;
+    p = isl_printer_start_line(p);
+    p = isl_printer_print_str(p,
+      "cudaCheckReturn(cudaMalloc((void **) &dev_");
+    p = isl_printer_print_str(p, prog->array[i].name);
+    p = isl_printer_print_str(p, ", ");
+    p = gpu_array_info_print_size(p, &prog->array[i]);
+    p = isl_printer_print_str(p, "));");
+    p = isl_printer_end_line(p);
+  }
+  p = isl_printer_start_line(p);
+  p = isl_printer_end_line(p);
+  return p;
+}
+
+/* Print code to "p" for copying "array" from the host to the device
+ * in its entirety.  The bounds on the extent of "array" have
+ * been precomputed in extract_array_info and are used in
+ * gpu_array_info_print_size.
+ */
+static __isl_give isl_printer *copy_array_to_device(__isl_take isl_printer *p,
+  struct gpu_array_info *array)
+{
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "cudaCheckReturn(cudaMemcpy(dev_");
+  p = isl_printer_print_str(p, array->name);
+  p = isl_printer_print_str(p, ", ");
+
+  if (gpu_array_is_scalar(array))
+    p = isl_printer_print_str(p, "&");
+  p = isl_printer_print_str(p, array->name);
+  p = isl_printer_print_str(p, ", ");
+
+  p = gpu_array_info_print_size(p, array);
+  p = isl_printer_print_str(p, ", cudaMemcpyHostToDevice));");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+/* Print code to "p" for copying "array" back from the device to the host
+ * in its entirety.  The bounds on the extent of "array" have
+ * been precomputed in extract_array_info and are used in
+ * gpu_array_info_print_size.
+ */
+static __isl_give isl_printer *copy_array_from_device(
+  __isl_take isl_printer *p, struct gpu_array_info *array)
+{
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "cudaCheckReturn(cudaMemcpy(");
+  if (gpu_array_is_scalar(array))
+    p = isl_printer_print_str(p, "&");
+  p = isl_printer_print_str(p, array->name);
+  p = isl_printer_print_str(p, ", dev_");
+  p = isl_printer_print_str(p, array->name);
+  p = isl_printer_print_str(p, ", ");
+  p = gpu_array_info_print_size(p, array);
+  p = isl_printer_print_str(p, ", cudaMemcpyDeviceToHost));");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+static void print_reverse_list(FILE *out, int len, int *list)
+{
+  int i;
+
+  if (len == 0)
+    return;
+
+  fprintf(out, "(");
+  for (i = 0; i < len; ++i) {
+    if (i)
+      fprintf(out, ", ");
+    fprintf(out, "%d", list[len - 1 - i]);
+  }
+  fprintf(out, ")");
+}
+
+/* Print the effective grid size as a list of the sizes in each
+ * dimension, from innermost to outermost.
+ */
+static __isl_give isl_printer *print_grid_size(__isl_take isl_printer *p,
+  struct ppcg_kernel *kernel)
+{
+  int i;
+  int dim;
+
+  dim = isl_multi_pw_aff_dim(kernel->grid_size, isl_dim_set);
+  if (dim == 0)
+    return p;
+
+  p = isl_printer_print_str(p, "(");
+  for (i = dim - 1; i >= 0; --i) {
+    isl_pw_aff *bound;
+
+    bound = isl_multi_pw_aff_get_pw_aff(kernel->grid_size, i);
+    p = isl_printer_print_pw_aff(p, bound);
+    isl_pw_aff_free(bound);
+
+    if (i > 0)
+      p = isl_printer_print_str(p, ", ");
+  }
+
+  p = isl_printer_print_str(p, ")");
+
+  return p;
+}
+
+/* Print the grid definition.
+ */
+static __isl_give isl_printer *print_grid(__isl_take isl_printer *p,
+  struct ppcg_kernel *kernel)
+{
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "dim3 k");
+  p = isl_printer_print_int(p, kernel->id);
+  p = isl_printer_print_str(p, "_dimGrid");
+  p = print_grid_size(p, kernel);
+  p = isl_printer_print_str(p, ";");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+/* Print the arguments to a kernel declaration or call.  If "types" is set,
+ * then print a declaration (including the types of the arguments).
+ *
+ * The arguments are printed in the following order
+ * - the arrays accessed by the kernel
+ * - the parameters
+ * - the host loop iterators
+ */
+static __isl_give isl_printer *print_kernel_arguments(__isl_take isl_printer *p,
+  struct gpu_prog *prog, struct ppcg_kernel *kernel, int types)
+{
+  int i, n;
+  int first = 1;
+  unsigned nparam;
+  isl_space *space;
+  const char *type;
+
+  for (i = 0; i < prog->n_array; ++i) {
+    int required;
+
+    required = ppcg_kernel_requires_array_argument(kernel, i);
+    if (required < 0)
+      return isl_printer_free(p);
+    if (!required)
+      continue;
+
+    if (!first)
+      p = isl_printer_print_str(p, ", ");
+
+    if (types)
+      p = gpu_array_info_print_declaration_argument(p,
+        &prog->array[i], NULL);
+    else
+      p = gpu_array_info_print_call_argument(p,
+        &prog->array[i]);
+
+    first = 0;
+  }
+
+  space = isl_union_set_get_space(kernel->arrays);
+  nparam = isl_space_dim(space, isl_dim_param);
+  for (i = 0; i < nparam; ++i) {
+    const char *name;
+
+    name = isl_space_get_dim_name(space, isl_dim_param, i);
+
+    if (!first)
+      p = isl_printer_print_str(p, ", ");
+    if (types)
+      p = isl_printer_print_str(p, "int ");
+    p = isl_printer_print_str(p, name);
+
+    first = 0;
+  }
+  isl_space_free(space);
+
+  n = isl_space_dim(kernel->space, isl_dim_set);
+  type = isl_options_get_ast_iterator_type(prog->ctx);
+  for (i = 0; i < n; ++i) {
+    const char *name;
+
+    if (!first)
+      p = isl_printer_print_str(p, ", ");
+    name = isl_space_get_dim_name(kernel->space, isl_dim_set, i);
+    if (types) {
+      p = isl_printer_print_str(p, type);
+      p = isl_printer_print_str(p, " ");
+    }
+    p = isl_printer_print_str(p, name);
+
+    first = 0;
+  }
+
+  return p;
+}
+
+/* Print the header of the given kernel.
+ */
+static __isl_give isl_printer *print_kernel_header(__isl_take isl_printer *p,
+  struct gpu_prog *prog, struct ppcg_kernel *kernel)
+{
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "__global__ void kernel");
+  p = isl_printer_print_int(p, kernel->id);
+  p = isl_printer_print_str(p, "(");
+  p = print_kernel_arguments(p, prog, kernel, 1);
+  p = isl_printer_print_str(p, ")");
+
+  return p;
+}
+
+/* Print the header of the given kernel to both gen->cuda.kernel_h
+ * and gen->cuda.kernel_c.
+ */
+static void print_kernel_headers(struct gpu_prog *prog,
+  struct ppcg_kernel *kernel, struct cuda_info *cuda)
+{
+  isl_printer *p;
+
+  p = isl_printer_to_file(prog->ctx, cuda->kernel_h);
+  p = isl_printer_set_output_format(p, ISL_FORMAT_C);
+  p = print_kernel_header(p, prog, kernel);
+  p = isl_printer_print_str(p, ";");
+  p = isl_printer_end_line(p);
+  isl_printer_free(p);
+
+  p = isl_printer_to_file(prog->ctx, cuda->kernel_c);
+  p = isl_printer_set_output_format(p, ISL_FORMAT_C);
+  p = print_kernel_header(p, prog, kernel);
+  p = isl_printer_end_line(p);
+  isl_printer_free(p);
+}
+
+static void print_indent(FILE *dst, int indent)
+{
+  fprintf(dst, "%*s", indent, "");
+}
+
+/* Print a list of iterators of type "type" with names "ids" to "out".
+ * Each iterator is assigned one of the cuda identifiers in cuda_dims.
+ * In particular, the last iterator is assigned the x identifier
+ * (the first in the list of cuda identifiers).
+ */
+static void print_iterators(FILE *out, const char *type,
+  __isl_keep isl_id_list *ids, const char *cuda_dims[])
+{
+  int i, n;
+
+  n = isl_id_list_n_id(ids);
+  if (n <= 0)
+    return;
+  print_indent(out, 4);
+  fprintf(out, "%s ", type);
+  for (i = 0; i < n; ++i) {
+    isl_id *id;
+
+    if (i)
+      fprintf(out, ", ");
+    id = isl_id_list_get_id(ids, i);
+    fprintf(out, "%s = %s", isl_id_get_name(id),
+      cuda_dims[n - 1 - i]);
+    isl_id_free(id);
+  }
+  fprintf(out, ";\n");
+}
+
+static void print_kernel_iterators(FILE *out, struct ppcg_kernel *kernel)
+{
+  isl_ctx *ctx = isl_ast_node_get_ctx(kernel->tree);
+  const char *type;
+  const char *block_dims[] = { "blockIdx.x", "blockIdx.y" };
+  const char *thread_dims[] = { "threadIdx.x", "threadIdx.y",
+          "threadIdx.z" };
+
+  type = isl_options_get_ast_iterator_type(ctx);
+
+  print_iterators(out, type, kernel->block_ids, block_dims);
+  print_iterators(out, type, kernel->thread_ids, thread_dims);
+}
+
+static __isl_give isl_printer *print_kernel_var(__isl_take isl_printer *p,
+  struct ppcg_kernel_var *var)
+{
+  int j;
+
+  p = isl_printer_start_line(p);
+  if (var->type == ppcg_access_shared)
+    p = isl_printer_print_str(p, "__shared__ ");
+  p = isl_printer_print_str(p, var->array->type);
+  p = isl_printer_print_str(p, " ");
+  p = isl_printer_print_str(p,  var->name);
+  for (j = 0; j < var->array->n_index; ++j) {
+    isl_val *v;
+
+    p = isl_printer_print_str(p, "[");
+    v = isl_vec_get_element_val(var->size, j);
+    p = isl_printer_print_val(p, v);
+    isl_val_free(v);
+    p = isl_printer_print_str(p, "]");
+  }
+  p = isl_printer_print_str(p, ";");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+static __isl_give isl_printer *print_kernel_vars(__isl_take isl_printer *p,
+  struct ppcg_kernel *kernel)
+{
+  int i;
+
+  for (i = 0; i < kernel->n_var; ++i)
+    p = print_kernel_var(p, &kernel->var[i]);
+
+  return p;
+}
+
+/* Print a sync statement.
+ */
+static __isl_give isl_printer *print_sync(__isl_take isl_printer *p,
+  struct ppcg_kernel_stmt *stmt)
+{
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "__syncthreads();");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+/* This function is called for each user statement in the AST,
+ * i.e., for each kernel body statement, copy statement or sync statement.
+ */
+static __isl_give isl_printer *print_kernel_stmt(__isl_take isl_printer *p,
+  __isl_take isl_ast_print_options *print_options,
+  __isl_keep isl_ast_node *node, void *user)
+{
+  isl_id *id;
+  struct ppcg_kernel_stmt *stmt;
+
+  id = isl_ast_node_get_annotation(node);
+  stmt = isl_id_get_user(id);
+  isl_id_free(id);
+
+  isl_ast_print_options_free(print_options);
+
+  switch (stmt->type) {
+  case ppcg_kernel_copy:
+    return ppcg_kernel_print_copy(p, stmt);
+  case ppcg_kernel_sync:
+    return print_sync(p, stmt);
+  case ppcg_kernel_domain:
+    return ppcg_kernel_print_domain(p, stmt);
+  }
+
+  return p;
+}
+
+static void print_kernel(struct gpu_prog *prog, struct ppcg_kernel *kernel,
+  struct cuda_info *cuda)
+{
+  isl_ctx *ctx = isl_ast_node_get_ctx(kernel->tree);
+  isl_ast_print_options *print_options;
+  isl_printer *p;
+
+  print_kernel_headers(prog, kernel, cuda);
+  fprintf(cuda->kernel_c, "{\n");
+  print_kernel_iterators(cuda->kernel_c, kernel);
+
+  p = isl_printer_to_file(ctx, cuda->kernel_c);
+  p = isl_printer_set_output_format(p, ISL_FORMAT_C);
+  p = isl_printer_indent(p, 4);
+
+  p = print_kernel_vars(p, kernel);
+  p = isl_printer_end_line(p);
+  p = isl_ast_op_type_print_macro(isl_ast_op_fdiv_q, p);
+  p = ppcg_print_macros(p, kernel->tree);
+
+  print_options = isl_ast_print_options_alloc(ctx);
+  print_options = isl_ast_print_options_set_print_user(print_options,
+                &print_kernel_stmt, NULL);
+  p = isl_ast_node_print(kernel->tree, p, print_options);
+  isl_printer_free(p);
+
+  fprintf(cuda->kernel_c, "}\n");
+}
+
+/* Print a statement for copying an array to or from the device.
+ * The statement identifier is called "to_device_<array name>" or
+ * "from_device_<array name>" and its user pointer points
+ * to the gpu_array_info of the array that needs to be copied.
+ *
+ * Extract the array from the identifier and call
+ * copy_array_to_device or copy_array_from_device.
+ */
+static __isl_give isl_printer *print_to_from_device(__isl_take isl_printer *p,
+  __isl_keep isl_ast_node *node, struct gpu_prog *prog)
+{
+  isl_ast_expr *expr, *arg;
+  isl_id *id;
+  const char *name;
+  struct gpu_array_info *array;
+
+  expr = isl_ast_node_user_get_expr(node);
+  arg = isl_ast_expr_get_op_arg(expr, 0);
+  id = isl_ast_expr_get_id(arg);
+  name = isl_id_get_name(id);
+  array = isl_id_get_user(id);
+  isl_id_free(id);
+  isl_ast_expr_free(arg);
+  isl_ast_expr_free(expr);
+
+  if (!name)
+    array = NULL;
+  if (!array)
+    return isl_printer_free(p);
+
+  if (!prefixcmp(name, "to_device"))
+    return copy_array_to_device(p, array);
+  else
+    return copy_array_from_device(p, array);
+}
+
+struct print_host_user_data {
+  struct cuda_info *cuda;
+  struct gpu_prog *prog;
+};
+
+/* Print the user statement of the host code to "p".
+ *
+ * The host code may contain original user statements, kernel launches and
+ * statements that copy data to/from the device.
+ * The original user statements and the kernel launches have
+ * an associated annotation, while the data copy statements do not.
+ * The latter are handled by print_to_from_device.
+ * The annotation on the user statements is called "user".
+ *
+ * In case of a kernel launch, print a block of statements that
+ * defines the grid and the block and then launches the kernel.
+ */
+static __isl_give isl_printer *print_host_user(__isl_take isl_printer *p,
+  __isl_take isl_ast_print_options *print_options,
+  __isl_keep isl_ast_node *node, void *user)
+{
+  isl_id *id;
+  int is_user;
+  struct ppcg_kernel *kernel;
+  struct ppcg_kernel_stmt *stmt;
+  struct print_host_user_data *data;
+
+  isl_ast_print_options_free(print_options);
+
+  data = (struct print_host_user_data *) user;
+
+  id = isl_ast_node_get_annotation(node);
+  if (!id)
+    return print_to_from_device(p, node, data->prog);
+
+  is_user = !strcmp(isl_id_get_name(id), "user");
+  kernel = is_user ? NULL : isl_id_get_user(id);
+  stmt = is_user ? isl_id_get_user(id) : NULL;
+  isl_id_free(id);
+
+  if (is_user)
+    return ppcg_kernel_print_domain(p, stmt);
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "{");
+  p = isl_printer_end_line(p);
+  p = isl_printer_indent(p, 2);
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "dim3 k");
+  p = isl_printer_print_int(p, kernel->id);
+  p = isl_printer_print_str(p, "_dimBlock");
+  print_reverse_list(isl_printer_get_file(p),
+        kernel->n_block, kernel->block_dim);
+  p = isl_printer_print_str(p, ";");
+  p = isl_printer_end_line(p);
+
+  p = print_grid(p, kernel);
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "kernel");
+  p = isl_printer_print_int(p, kernel->id);
+  p = isl_printer_print_str(p, " <<<k");
+  p = isl_printer_print_int(p, kernel->id);
+  p = isl_printer_print_str(p, "_dimGrid, k");
+  p = isl_printer_print_int(p, kernel->id);
+  p = isl_printer_print_str(p, "_dimBlock>>> (");
+  p = print_kernel_arguments(p, data->prog, kernel, 0);
+  p = isl_printer_print_str(p, ");");
+  p = isl_printer_end_line(p);
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "cudaCheckKernel();");
+  p = isl_printer_end_line(p);
+
+  p = isl_printer_indent(p, -2);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "}");
+  p = isl_printer_end_line(p);
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_end_line(p);
+
+  print_kernel(data->prog, kernel, data->cuda);
+
+  return p;
+}
+
+static __isl_give isl_printer *print_host_code(__isl_take isl_printer *p,
+  struct gpu_prog *prog, __isl_keep isl_ast_node *tree,
+  struct cuda_info *cuda)
+{
+  isl_ast_print_options *print_options;
+  isl_ctx *ctx = isl_ast_node_get_ctx(tree);
+  struct print_host_user_data data = { cuda, prog };
+
+  print_options = isl_ast_print_options_alloc(ctx);
+  print_options = isl_ast_print_options_set_print_user(print_options,
+            &print_host_user, &data);
+
+  p = ppcg_print_macros(p, tree);
+  p = isl_ast_node_print(tree, p, print_options);
+
+  return p;
+}
+
+static __isl_give isl_printer *free_device_arrays(__isl_take isl_printer *p,
+  struct gpu_prog *prog)
+{
+  int i;
+
+  for (i = 0; i < prog->n_array; ++i) {
+    if (!gpu_array_requires_device_allocation(&prog->array[i]))
+      continue;
+    p = isl_printer_start_line(p);
+    p = isl_printer_print_str(p, "cudaCheckReturn(cudaFree(dev_");
+    p = isl_printer_print_str(p, prog->array[i].name);
+    p = isl_printer_print_str(p, "));");
+    p = isl_printer_end_line(p);
+  }
+
+  return p;
+}
+
+/* Given a gpu_prog "prog" and the corresponding transformed AST
+ * "tree", print the entire CUDA code to "p".
+ * "types" collects the types for which a definition has already
+ * been printed.
+ */
+static __isl_give isl_printer *print_cuda(__isl_take isl_printer *p,
+  struct gpu_prog *prog, __isl_keep isl_ast_node *tree,
+  struct gpu_types *types, void *user)
+{
+  struct cuda_info *cuda = user;
+  isl_printer *kernel;
+
+  kernel = isl_printer_to_file(isl_printer_get_ctx(p), cuda->kernel_c);
+  kernel = isl_printer_set_output_format(kernel, ISL_FORMAT_C);
+  kernel = gpu_print_types(kernel, types, prog);
+  isl_printer_free(kernel);
+
+  if (!kernel)
+    return isl_printer_free(p);
+
+  p = ppcg_start_block(p);
+
+  p = print_cuda_macros(p);
+
+  p = gpu_print_local_declarations(p, prog);
+  p = declare_device_arrays(p, prog);
+  p = allocate_device_arrays(p, prog);
+
+  p = print_host_code(p, prog, tree, cuda);
+
+  p = free_device_arrays(p, prog);
+
+  p = ppcg_end_block(p);
+
+  return p;
+}
+
+/* Transform the code in the file called "input" by replacing
+ * all scops by corresponding CUDA code.
+ * The names of the output files are derived from "input".
+ *
+ * We let generate_gpu do all the hard work and then let it call
+ * us back for printing the AST in print_cuda.
+ *
+ * To prepare for this printing, we first open the output files
+ * and we close them after generate_gpu has finished.
+ */
+int generate_cuda(isl_ctx *ctx, struct ppcg_options *options,
+  const char *input)
+{
+  struct cuda_info cuda;
+  int r;
+
+  cuda_open_files(&cuda, input);
+
+  r = generate_gpu(ctx, input, cuda.host_c, options, &print_cuda, &cuda);
+
+  cuda_close_files(&cuda);
+
+  return r;
+}

polly/trunk/lib/External/ppcg/cuda_common.h

+#ifndef _CUDA_COMMON_H_
+#define _CUDA_COMMON_H_
+
+#include <stdio.h>
+
+struct cuda_info {
+  FILE *host_c;
+  FILE *kernel_c;
+  FILE *kernel_h;
+};
+
+void cuda_open_files(struct cuda_info *info, const char *input);
+void cuda_close_files(struct cuda_info *info);
+
+#endif

polly/trunk/lib/External/ppcg/cuda_common.c

+/*
+ * Copyright 2010      INRIA Saclay
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ */
+
+#include <ctype.h>
+#include <limits.h>
+#include <string.h>
+
+#include "cuda_common.h"
+#include "ppcg.h"
+
+/* Open the host .cu file and the kernel .hu and .cu files for writing.
+ * Add the necessary includes.
+ */
+void cuda_open_files(struct cuda_info *info, const char *input)
+{
+    char name[PATH_MAX];
+    int len;
+
+    len = ppcg_extract_base_name(name, input);
+
+    strcpy(name + len, "_host.cu");
+    info->host_c = fopen(name, "w");
+
+    strcpy(name + len, "_kernel.cu");
+    info->kernel_c = fopen(name, "w");
+
+    strcpy(name + len, "_kernel.hu");
+    info->kernel_h = fopen(name, "w");
+    fprintf(info->host_c, "#include <assert.h>\n");
+    fprintf(info->host_c, "#include <stdio.h>\n");
+    fprintf(info->host_c, "#include \"%s\"\n", name);
+    fprintf(info->kernel_c, "#include \"%s\"\n", name);
+    fprintf(info->kernel_h, "#include \"cuda.h\"\n\n");
+}
+
+/* Close all output files.
+ */
+void cuda_close_files(struct cuda_info *info)
+{
+    fclose(info->kernel_c);
+    fclose(info->kernel_h);
+    fclose(info->host_c);
+}

polly/trunk/lib/External/ppcg/depcomp

+#! /bin/sh
+# depcomp - compile a program generating dependencies as side-effects
+
+scriptversion=2012-03-27.16; # UTC
+
+# Copyright (C) 1999, 2000, 2003, 2004, 2005, 2006, 2007, 2009, 2010,
+# 2011, 2012 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Originally written by Alexandre Oliva <[e-mail]>.
+
+case $1 in
+  '')
+     echo "$0: No command.  Try '$0 --help' for more information." 1>&2
+     exit 1;
+     ;;
+  -h | --h*)
+    cat <<\EOF
+Usage: depcomp [--help] [--version] PROGRAM [ARGS]
+
+Run PROGRAMS ARGS to compile a file, generating dependencies
+as side-effects.
+
+Environment variables:
+  depmode     Dependency tracking mode.
+  source      Source file read by 'PROGRAMS ARGS'.
+  object      Object file output by 'PROGRAMS ARGS'.
+  DEPDIR      directory where to store dependencies.
+  depfile     Dependency file to output.
+  tmpdepfile  Temporary file to use when outputting dependencies.
+  libtool     Whether libtool is used (yes/no).
+
+Report bugs to <[e-mail]>.
+EOF
+    exit $?
+    ;;
+  -v | --v*)
+    echo "depcomp $scriptversion"
+    exit $?
+    ;;
+esac
+
+# A tabulation character.
+tab=' '
+# A newline character.
+nl='
+'
+
+if test -z "$depmode" || test -z "$source" || test -z "$object"; then
+  echo "depcomp: Variables source, object and depmode must be set" 1>&2
+  exit 1
+fi
+
+# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
+depfile=${depfile-`echo "$object" |
+  sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
+tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
+
+rm -f "$tmpdepfile"
+
+# Some modes work just like other modes, but use different flags.  We
+# parameterize here, but still list the modes in the big case below,
+# to make depend.m4 easier to write.  Note that we *cannot* use a case
+# here, because this file can only contain one case statement.
+if test "$depmode" = hp; then
+  # HP compiler uses -M and no extra arg.
+  gccflag=-M
+  depmode=gcc
+fi
+
+if test "$depmode" = dashXmstdout; then
+   # This is just like dashmstdout with a different argument.
+   dashmflag=-xM
+   depmode=dashmstdout
+fi
+
+cygpath_u="cygpath -u -f -"
+if test "$depmode" = msvcmsys; then
+   # This is just like msvisualcpp but w/o cygpath translation.
+   # Just convert the backslash-escaped backslashes to single forward
+   # slashes to satisfy depend.m4
+   cygpath_u='sed s,\\\\,/,g'
+   depmode=msvisualcpp
+fi
+
+if test "$depmode" = msvc7msys; then
+   # This is just like msvc7 but w/o cygpath translation.
+   # Just convert the backslash-escaped backslashes to single forward
+   # slashes to satisfy depend.m4
+   cygpath_u='sed s,\\\\,/,g'
+   depmode=msvc7
+fi
+
+if test "$depmode" = xlc; then
+   # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency informations.
+   gccflag=-qmakedep=gcc,-MF
+   depmode=gcc
+fi
+
+case "$depmode" in
+gcc3)
+## gcc 3 implements dependency tracking that does exactly what
+## we want.  Yay!  Note: for some reason libtool 1.4 doesn't like
+## it if -MD -MP comes after the -MF stuff.  Hmm.
+## Unfortunately, FreeBSD c89 acceptance of flags depends upon
+## the command line argument order; so add the flags where they
+## appear in depend2.am.  Note that the slowdown incurred here
+## affects only configure: in makefiles, %FASTDEP% shortcuts this.
+  for arg
+  do
+    case $arg in
+    -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
+    *)  set fnord "$@" "$arg" ;;
+    esac
+    shift # fnord
+    shift # $arg
+  done
+  "$@"
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  mv "$tmpdepfile" "$depfile"
+  ;;
+
+gcc)
+## There are various ways to get dependency output from gcc.  Here's
+## why we pick this rather obscure method:
+## - Don't want to use -MD because we'd like the dependencies to end
+##   up in a subdir.  Having to rename by hand is ugly.
+##   (We might end up doing this anyway to support other compilers.)
+## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
+##   -MM, not -M (despite what the docs say).
+## - Using -M directly means running the compiler twice (even worse
+##   than renaming).
+  if test -z "$gccflag"; then
+    gccflag=-MD,
+  fi
+  "$@" -Wp,"$gccflag$tmpdepfile"
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
+## The second -e expression handles DOS-style file names with drive letters.
+  sed -e 's/^[^:]*: / /' \
+      -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
+## This next piece of magic avoids the "deleted header file" problem.
+## The problem is that when a header file which appears in a .P file
+## is deleted, the dependency causes make to die (because there is
+## typically no way to rebuild the header).  We avoid this by adding
+## dummy dependencies for each header file.  Too bad gcc doesn't do
+## this for us directly.
+  tr ' ' "$nl" < "$tmpdepfile" |
+## Some versions of gcc put a space before the ':'.  On the theory
+## that the space means something, we add a space to the output as
+## well.  hp depmode also adds that space, but also prefixes the VPATH
+## to the object.  Take care to not repeat it in the output.
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+    sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \
+      | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+hp)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+sgi)
+  if test "$libtool" = yes; then
+    "$@" "-Wp,-MDupdate,$tmpdepfile"
+  else
+    "$@" -MDupdate "$tmpdepfile"
+  fi
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+
+  if test -f "$tmpdepfile"; then  # yes, the sourcefile depend on other files
+    echo "$object : \\" > "$depfile"
+
+    # Clip off the initial element (the dependent).  Don't try to be
+    # clever and replace this with sed code, as IRIX sed won't handle
+    # lines with more than a fixed number of characters (4096 in
+    # IRIX 6.2 sed, 8192 in IRIX 6.5).  We also remove comment lines;
+    # the IRIX cc adds comments like '#:fec' to the end of the
+    # dependency line.
+    tr ' ' "$nl" < "$tmpdepfile" \
+    | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \
+    tr "$nl" ' ' >> "$depfile"
+    echo >> "$depfile"
+
+    # The second pass generates a dummy entry for each header file.
+    tr ' ' "$nl" < "$tmpdepfile" \
+   | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
+   >> "$depfile"
+  else
+    # The sourcefile does not contain any dependencies, so just
+    # store a dummy comment line, to avoid errors with the Makefile
+    # "include basename.Plo" scheme.
+    echo "#dummy" > "$depfile"
+  fi
+  rm -f "$tmpdepfile"
+  ;;
+
+xlc)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+aix)
+  # The C for AIX Compiler uses -M and outputs the dependencies
+  # in a .u file.  In older versions, this file always lives in the
+  # current directory.  Also, the AIX compiler puts '$object:' at the
+  # start of each line; $object doesn't have directory information.
+  # Version 6 uses the directory in both cases.
+  dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+  test "x$dir" = "x$object" && dir=
+  base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+  if test "$libtool" = yes; then
+    tmpdepfile1=$dir$base.u
+    tmpdepfile2=$base.u
+    tmpdepfile3=$dir.libs/$base.u
+    "$@" -Wc,-M
+  else
+    tmpdepfile1=$dir$base.u
+    tmpdepfile2=$dir$base.u
+    tmpdepfile3=$dir$base.u
+    "$@" -M
+  fi
+  stat=$?
+
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+    exit $stat
+  fi
+
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  if test -f "$tmpdepfile"; then
+    # Each line is of the form 'foo.o: dependent.h'.
+    # Do two passes, one to just change these to
+    # '$object: dependent.h' and one to simply 'dependent.h:'.
+    sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
+    sed -e 's,^.*\.[a-z]*:['"$tab"' ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
+  else
+    # The sourcefile does not contain any dependencies, so just
+    # store a dummy comment line, to avoid errors with the Makefile
+    # "include basename.Plo" scheme.
+    echo "#dummy" > "$depfile"
+  fi
+  rm -f "$tmpdepfile"
+  ;;
+
+icc)
+  # Intel's C compiler anf tcc (Tiny C Compiler) understand '-MD -MF file'.
+  # However on
+  #    $CC -MD -MF foo.d -c -o sub/foo.o sub/foo.c
+  # ICC 7.0 will fill foo.d with something like
+  #    foo.o: sub/foo.c
+  #    foo.o: sub/foo.h
+  # which is wrong.  We want
+  #    sub/foo.o: sub/foo.c
+  #    sub/foo.o: sub/foo.h
+  #    sub/foo.c:
+  #    sub/foo.h:
+  # ICC 7.1 will output
+  #    foo.o: sub/foo.c sub/foo.h
+  # and will wrap long lines using '\':
+  #    foo.o: sub/foo.c ... \
+  #     sub/foo.h ... \
+  #     ...
+  # tcc 0.9.26 (FIXME still under development at the moment of writing)
+  # will emit a similar output, but also prepend the continuation lines
+  # with horizontal tabulation characters.
+  "$@" -MD -MF "$tmpdepfile"
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  # Each line is of the form 'foo.o: dependent.h',
+  # or 'foo.o: dep1.h dep2.h \', or ' dep3.h dep4.h \'.
+  # Do two passes, one to just change these to
+  # '$object: dependent.h' and one to simply 'dependent.h:'.
+  sed -e "s/^[ $tab][ $tab]*/  /" -e "s,^[^:]*:,$object :," \
+    < "$tmpdepfile" > "$depfile"
+  sed '
+    s/[ '"$tab"'][ '"$tab"']*/ /g
+    s/^ *//
+    s/ *\\*$//
+    s/^[^:]*: *//
+    /^$/d
+    /:$/d
+    s/$/ :/
+  ' < "$tmpdepfile" >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+hp2)
+  # The "hp" stanza above does not work with aCC (C++) and HP's ia64
+  # compilers, which have integrated preprocessors.  The correct option
+  # to use with these is +Maked; it writes dependencies to a file named
+  # 'foo.d', which lands next to the object file, wherever that
+  # happens to be.
+  # Much of this is similar to the tru64 case; see comments there.
+  dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+  test "x$dir" = "x$object" && dir=
+  base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+  if test "$libtool" = yes; then
+    tmpdepfile1=$dir$base.d
+    tmpdepfile2=$dir.libs/$base.d
+    "$@" -Wc,+Maked
+  else
+    tmpdepfile1=$dir$base.d
+    tmpdepfile2=$dir$base.d
+    "$@" +Maked
+  fi
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+     rm -f "$tmpdepfile1" "$tmpdepfile2"
+     exit $stat
+  fi
+
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  if test -f "$tmpdepfile"; then
+    sed -e "s,^.*\.[a-z]*:,$object:," "$tmpdepfile" > "$depfile"
+    # Add 'dependent.h:' lines.
+    sed -ne '2,${
+         s/^ *//
+         s/ \\*$//
+         s/$/:/
+         p
+       }' "$tmpdepfile" >> "$depfile"
+  else
+    echo "#dummy" > "$depfile"
+  fi
+  rm -f "$tmpdepfile" "$tmpdepfile2"
+  ;;
+
+tru64)
+   # The Tru64 compiler uses -MD to generate dependencies as a side
+   # effect.  'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'.
+   # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
+   # dependencies in 'foo.d' instead, so we check for that too.
+   # Subdirectories are respected.
+   dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+   test "x$dir" = "x$object" && dir=
+   base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+
+   if test "$libtool" = yes; then
+      # With Tru64 cc, shared objects can also be used to make a
+      # static library.  This mechanism is used in libtool 1.4 series to
+      # handle both shared and static libraries in a single compilation.
+      # With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d.
+      #
+      # With libtool 1.5 this exception was removed, and libtool now
+      # generates 2 separate objects for the 2 libraries.  These two
+      # compilations output dependencies in $dir.libs/$base.o.d and
+      # in $dir$base.o.d.  We have to check for both files, because
+      # one of the two compilations can be disabled.  We should prefer
+      # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
+      # automatically cleaned when .libs/ is deleted, while ignoring
+      # the former would cause a distcleancheck panic.
+      tmpdepfile1=$dir.libs/$base.lo.d   # libtool 1.4
+      tmpdepfile2=$dir$base.o.d          # libtool 1.5
+      tmpdepfile3=$dir.libs/$base.o.d    # libtool 1.5
+      tmpdepfile4=$dir.libs/$base.d      # Compaq CCC V6.2-504
+      "$@" -Wc,-MD
+   else
+      tmpdepfile1=$dir$base.o.d
+      tmpdepfile2=$dir$base.d
+      tmpdepfile3=$dir$base.d
+      tmpdepfile4=$dir$base.d
+      "$@" -MD
+   fi
+
+   stat=$?
+   if test $stat -eq 0; then :
+   else
+      rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
+      exit $stat
+   fi
+
+   for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
+   do
+     test -f "$tmpdepfile" && break
+   done
+   if test -f "$tmpdepfile"; then
+      sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
+      sed -e 's,^.*\.[a-z]*:['"$tab"' ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
+   else
+      echo "#dummy" > "$depfile"
+   fi
+   rm -f "$tmpdepfile"
+   ;;
+
+msvc7)
+  if test "$libtool" = yes; then
+    showIncludes=-Wc,-showIncludes
+  else
+    showIncludes=-showIncludes
+  fi
+  "$@" $showIncludes > "$tmpdepfile"
+  stat=$?
+  grep -v '^Note: including file: ' "$tmpdepfile"
+  if test "$stat" = 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  # The first sed program below extracts the file names and escapes
+  # backslashes for cygpath.  The second sed program outputs the file
+  # name when reading, but also accumulates all include files in the
+  # hold buffer in order to output them again at the end.  This only
+  # works with sed implementations that can handle large buffers.
+  sed < "$tmpdepfile" -n '
+/^Note: including file:  *\(.*\)/ {
+  s//\1/
+  s/\\/\\\\/g
+  p
+}' | $cygpath_u | sort -u | sed -n '
+s/ /\\ /g
+s/\(.*\)/'"$tab"'\1 \\/p
+s/.\(.*\) \\/\1:/
+H
+$ {
+  s/.*/'"$tab"'/
+  G
+  p
+}' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+msvc7msys)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+#nosideeffect)
+  # This comment above is used by automake to tell side-effect
+  # dependency tracking mechanisms from slower ones.
+
+dashmstdout)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout, regardless of -o.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  # Remove '-o $object'.
+  IFS=" "
+  for arg
+  do
+    case $arg in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    *)
+      set fnord "$@" "$arg"
+      shift # fnord
+      shift # $arg
+      ;;
+    esac
+  done
+
+  test -z "$dashmflag" && dashmflag=-M
+  # Require at least two characters before searching for ':'
+  # in the target name.  This is to cope with DOS-style filenames:
+  # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise.
+  "$@" $dashmflag |
+    sed 's:^['"$tab"' ]*[^:'"$tab"' ][^:][^:]*\:['"$tab"' ]*:'"$object"'\: :' > "$tmpdepfile"
+  rm -f "$depfile"
+  cat < "$tmpdepfile" > "$depfile"
+  tr ' ' "$nl" < "$tmpdepfile" | \
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+dashXmstdout)
+  # This case only exists to satisfy depend.m4.  It is never actually
+  # run, as this mode is specially recognized in the preamble.
+  exit 1
+  ;;
+
+makedepend)
+  "$@" || exit $?
+  # Remove any Libtool call
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+  # X makedepend
+  shift
+  cleared=no eat=no
+  for arg
+  do
+    case $cleared in
+    no)
+      set ""; shift
+      cleared=yes ;;
+    esac
+    if test $eat = yes; then
+      eat=no
+      continue
+    fi
+    case "$arg" in
+    -D*|-I*)
+      set fnord "$@" "$arg"; shift ;;
+    # Strip any option that makedepend may not understand.  Remove
+    # the object too, otherwise makedepend will parse it as a source file.
+    -arch)
+      eat=yes ;;
+    -*|$object)
+      ;;
+    *)
+      set fnord "$@" "$arg"; shift ;;
+    esac
+  done
+  obj_suffix=`echo "$object" | sed 's/^.*\././'`
+  touch "$tmpdepfile"
+  ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
+  rm -f "$depfile"
+  # makedepend may prepend the VPATH from the source file name to the object.
+  # No need to regex-escape $object, excess matching of '.' is harmless.
+  sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile"
+  sed '1,2d' "$tmpdepfile" | tr ' ' "$nl" | \
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile" "$tmpdepfile".bak
+  ;;
+
+cpp)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  # Remove '-o $object'.
+  IFS=" "
+  for arg
+  do
+    case $arg in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    *)
+      set fnord "$@" "$arg"
+      shift # fnord
+      shift # $arg
+      ;;
+    esac
+  done
+
+  "$@" -E |
+    sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
+       -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' |
+    sed '$ s: \\$::' > "$tmpdepfile"
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  cat < "$tmpdepfile" >> "$depfile"
+  sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+msvisualcpp)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  IFS=" "
+  for arg
+  do
+    case "$arg" in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
+  set fnord "$@"
+  shift
+  shift
+  ;;
+    *)
+  set fnord "$@" "$arg"
+  shift
+  shift
+  ;;
+    esac
+  done
+  "$@" -E 2>/dev/null |
+  sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile"
+  echo "$tab" >> "$depfile"
+  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+msvcmsys)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+none)
+  exec "$@"
+  ;;
+
+*)
+  echo "Unknown depmode $depmode" 1>&2
+  exit 1
+  ;;
+esac
+
+exit 0
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:

polly/trunk/lib/External/ppcg/external.c

+void ppcg_start_block(){}
+void ppcg_end_block(){}
+void ppcg_print_macros(){}
+void pet_scop_compute_outer_to_any(){}
+void pet_scop_compute_outer_to_inner(){}
+void pet_tree_get_type(){}
+void pet_tree_foreach_access_expr(){}
+void pet_expr_get_ctx(){}
+void pet_expr_access_is_read(){}
+void pet_expr_access_is_write(){}
+void pet_expr_access_get_tagged_may_read(){}
+void pet_expr_access_get_tagged_may_write(){}
+void pet_expr_access_get_must_write(){}
+void pet_expr_access_get_index(){}
+void pet_expr_access_get_ref_id(){}
+void print_cpu(){}
+void ppcg_print_exposed_declarations(){}
+void ppcg_print_declaration(){}
+void pet_stmt_print_body(){}
+void pet_loc_get_start(){}
+void pet_loc_get_end(){}
+void pet_scop_collect_tagged_may_reads(){}
+void pet_scop_collect_may_reads(){}
+void pet_scop_collect_tagged_may_writes(){}
+void pet_scop_collect_may_writes(){}
+void pet_scop_collect_tagged_must_writes(){}
+void pet_scop_collect_must_writes(){}
+void pet_scop_collect_tagged_must_kills(){}
+void pet_transform_C_source(){}
+void pet_scop_print_original(){}
+void pet_scop_free(){}
+void pet_scop_align_params(){}
+void pet_scop_can_build_ast_exprs(){}
+void pet_scop_has_data_dependent_conditions(){}
+void pet_tree_foreach_expr(){}
+void pet_expr_foreach_call_expr(){}
+void pet_stmt_is_kill(){}
+void pet_options_args() {}
+void ppcg_print_guarded() {}
+void ppcg_version() {}
+void pet_options_set_encapsulate_dynamic_control() {}
+void generate_opencl() {}
+void generate_cpu() {}
+void pet_stmt_build_ast_exprs() {}

polly/trunk/lib/External/ppcg/gpu.h

+#ifndef _GPU_H
+#define _GPU_H
+
+#include <isl/ast.h>
+#include <isl/id_to_ast_expr.h>
+
+#include "ppcg.h"
+#include "ppcg_options.h"
+
+/* Represents an outer array possibly accessed by a gpu_prog.
+ */
+struct gpu_array_info {
+  /* The array data space. */
+  isl_space *space;
+  /* Element type. */
+  char *type;
+  /* Element size. */
+  int size;
+  /* Name of the array. */
+  char *name;
+  /* Extent of the array that needs to be copied. */
+  isl_set *extent;
+  /* Number of indices. */
+  unsigned n_index;
+  /* For each index, a bound on "extent" in that direction. */
+  isl_pw_aff **bound;
+
+  /* All references to this array; point to elements of a linked list. */
+  int n_ref;
+  struct gpu_stmt_access **refs;
+
+  /* Is this array accessed at all by the program? */
+  int accessed;
+
+  /* Is this a scalar that is read-only within the entire program? */
+  int read_only_scalar;
+
+  /* Are the elements of the array structures? */
+  int has_compound_element;
+
+  /* Is the array local to the scop? */
+  int local;
+  /* Is the array local and should it be declared on the host? */
+  int declare_local;
+
+  /* Is the corresponding global device memory accessed in any way? */
+  int global;
+
+  /* Should the array be linearized? */
+  int linearize;
+
+  /* Order dependences on this array.
+   * Only used if live_range_reordering option is set.
+   * It is set to NULL otherwise.
+   */
+  isl_union_map *dep_order;
+};
+
+/* Represents an outer array accessed by a ppcg_kernel, localized
+ * to the context of this kernel.
+ *
+ * "array" points to the corresponding array in the gpu_prog.
+ * The "n_group" "groups" are the reference groups associated to the array.
+ * If "force_private" is set, then the array (in practice a scalar)
+ * must be mapped to a register.
+ * "global" is set if the global device memory corresponding
+ * to this array is accessed by the kernel.
+ * For each index i with 0 <= i < n_index,
+ * bound[i] is equal to array->bound[i] specialized to the current kernel.
+ */
+struct gpu_local_array_info {
+  struct gpu_array_info *array;
+
+  int n_group;
+  struct gpu_array_ref_group **groups;
+
+  int force_private;
+  int global;
+
+  unsigned n_index;
+  isl_pw_aff_list *bound;
+};
+
+__isl_give isl_ast_expr *gpu_local_array_info_linearize_index(
+  struct gpu_local_array_info *array, __isl_take isl_ast_expr *expr);
+
+/* A sequence of "n" names of types.
+ */
+struct gpu_types {
+  int n;
+  char **name;
+};
+
+/* "read" and "write" contain the original access relations, possibly
+ * involving member accesses.
+ *
+ * The elements of "array", as well as the ranges of "copy_in" and "copy_out"
+ * only refer to the outer arrays of any possible member accesses.
+ */
+struct gpu_prog {
+  isl_ctx *ctx;
+
+  struct ppcg_scop *scop;
+
+  /* Set of parameter values */
+  isl_set *context;
+
+  /* All potential read accesses in the entire program */
+  isl_union_map *read;
+
+  /* All potential write accesses in the entire program */
+  isl_union_map *may_write;
+  /* All definite write accesses in the entire program */
+  isl_union_map *must_write;
+  /* All tagged definite kills in the entire program */
+  isl_union_map *tagged_must_kill;
+
+  /* The set of inner array elements that may be preserved. */
+  isl_union_set *may_persist;
+
+  /* A mapping from all innermost arrays to their outer arrays. */
+  isl_union_map *to_outer;
+  /* A mapping from the outer arrays to all corresponding inner arrays. */
+  isl_union_map *to_inner;
+  /* A mapping from all intermediate arrays to their outer arrays,
+   * including an identity mapping from the anoymous 1D space to itself.
+   */
+  isl_union_map *any_to_outer;
+
+  /* Order dependences on non-scalars. */
+  isl_union_map *array_order;
+
+  /* Array of statements */
+  int n_stmts;
+  struct gpu_stmt *stmts;
+
+  int n_array;
+  struct gpu_array_info *array;
+};
+
+struct gpu_gen {
+  isl_ctx *ctx;
+  struct ppcg_options *options;
+
+  /* Callback for printing of AST in appropriate format. */
+  __isl_give isl_printer *(*print)(__isl_take isl_printer *p,
+    struct gpu_prog *prog, __isl_keep isl_ast_node *tree,
+    struct gpu_types *types, void *user);
+  void *print_user;
+
+  struct gpu_prog *prog;
+  /* The generated AST. */
+  isl_ast_node *tree;
+
+  /* The sequence of types for which a definition has been printed. */
+  struct gpu_types types;
+
+  /* User specified tile, grid and block sizes for each kernel */
+  isl_union_map *sizes;
+
+  /* Effectively used tile, grid and block sizes for each kernel */
+  isl_union_map *used_sizes;
+
+  /* Identifier of the next kernel. */
+  int kernel_id;
+};
+
+enum ppcg_kernel_access_type {
+  ppcg_access_global,
+  ppcg_access_shared,
+  ppcg_access_private
+};
+
+enum ppcg_kernel_stmt_type {
+  ppcg_kernel_copy,
+  ppcg_kernel_domain,
+  ppcg_kernel_sync
+};
+
+/* Representation of special statements, in particular copy statements
+ * and __syncthreads statements, inside a kernel.
+ *
+ * type represents the kind of statement
+ *
+ *
+ * for ppcg_kernel_copy statements we have
+ *
+ * read is set if the statement should copy data from global memory
+ * to shared memory or registers.
+ *
+ * index expresses an access to the array element that needs to be copied
+ * local_index expresses the corresponding element in the tile
+ *
+ * array refers to the original array being copied
+ * local_array is a pointer to the appropriate element in the "array"
+ *  array of the ppcg_kernel to which this copy access belongs
+ *
+ *
+ * for ppcg_kernel_domain statements we have
+ *
+ * stmt is the corresponding input statement
+ *
+ * n_access is the number of accesses in stmt
+ * access is an array of local information about the accesses
+ */
+struct ppcg_kernel_stmt {
+  enum ppcg_kernel_stmt_type type;
+
+  union {
+    struct {
+      int read;
+      isl_ast_expr *index;
+      isl_ast_expr *local_index;
+      struct gpu_array_info *array;
+      struct gpu_local_array_info *local_array;
+    } c;
+    struct {
+      struct gpu_stmt *stmt;
+      isl_id_to_ast_expr *ref2expr;
+    } d;
+  } u;
+};
+
+/* Representation of a local variable in a kernel.
+ */
+struct ppcg_kernel_var {
+  struct gpu_array_info *array;
+  enum ppcg_kernel_access_type type;
+  char *name;
+  isl_vec *size;
+};
+
+/* Representation of a kernel.
+ *
+ * prog describes the original code from which the kernel is extracted.
+ *
+ * id is the sequence number of the kernel.
+ *
+ * block_ids contains the list of block identifiers for this kernel.
+ * thread_ids contains the list of thread identifiers for this kernel.
+ *
+ * the first n_grid elements of grid_dim represent the specified size
+ * of the grid.
+ * the first n_block elements of block_dim represent the specified or
+ * effective size of the block.
+ * Note that in the input file, the sizes of the grid and the blocks
+ * are specified in the order x, y, z, but internally, the sizes
+ * are stored in reverse order, so that the last element always
+ * refers to the x dimension.
+ *
+ * grid_size reflects the effective grid size.
+ *
+ * context contains the values of the parameters and outer schedule dimensions
+ * for which any statement instance in this kernel needs to be executed.
+ *
+ * n_sync is the number of synchronization operations that have
+ * been introduced in the schedule tree corresponding to this kernel (so far).
+ *
+ * core contains the spaces of the statement domains that form
+ * the core computation of the kernel.  It is used to navigate
+ * the tree during the construction of the device part of the schedule
+ * tree in create_kernel.
+ *
+ * arrays is the set of possibly accessed outer array elements.
+ *
+ * space is the schedule space of the AST context.  That is, it represents
+ * the loops of the generated host code containing the kernel launch.
+ *
+ * n_array is the total number of arrays in the input program and also
+ * the number of element in the array array.
+ * array contains information about each array that is local
+ * to the current kernel.  If an array is not used in a kernel,
+ * then the corresponding entry does not contain any information.
+ *
+ * any_force_private is set if any array in the kernel is marked force_private
+ *
+ * block_filter contains constraints on the domain elements in the kernel
+ * that encode the mapping to block identifiers, where the block identifiers
+ * are represented by "n_grid" parameters with as names the elements
+ * of "block_ids".
+ *
+ * thread_filter contains constraints on the domain elements in the kernel
+ * that encode the mapping to thread identifiers, where the thread identifiers
+ * are represented by "n_block" parameters with as names the elements
+ * of "thread_ids".
+ *
+ * shared_schedule corresponds to the schedule dimensions of
+ * the (tiled) schedule for this kernel that have been taken into account
+ * for computing private/shared memory tiles.
+ * shared_schedule_dim is the dimension of this schedule.
+ *
+ * sync_writes contains write references that require synchronization.
+ * Each reference is represented by a universe set in a space [S[i,j] -> R[]]
+ * with S[i,j] the statement instance space and R[] the array reference.
+ */
+struct ppcg_kernel {
+  isl_ctx *ctx;
+  struct ppcg_options *options;
+
+  struct gpu_prog *prog;
+
+  int id;
+
+  isl_id_list *block_ids;
+  isl_id_list *thread_ids;
+
+  int n_grid;
+  int n_block;
+  int grid_dim[2];
+  int block_dim[3];
+
+  isl_multi_pw_aff *grid_size;
+  isl_set *context;
+
+  int n_sync;
+  isl_union_set *core;
+  isl_union_set *arrays;
+
+  isl_space *space;
+
+  int n_array;
+  struct gpu_local_array_info *array;
+
+  int n_var;
+  struct ppcg_kernel_var *var;
+
+  int any_force_private;
+
+  isl_union_set *block_filter;
+  isl_union_set *thread_filter;
+  isl_union_pw_multi_aff *shared_schedule;
+  int shared_schedule_dim;
+
+  isl_union_set *sync_writes;
+
+  isl_ast_node *tree;
+};
+
+int gpu_array_is_scalar(struct gpu_array_info *array);
+int gpu_array_is_read_only_scalar(struct gpu_array_info *array);
+int gpu_array_requires_device_allocation(struct gpu_array_info *array);
+__isl_give isl_set *gpu_array_positive_size_guard(struct gpu_array_info *array);
+
+struct gpu_prog *gpu_prog_alloc(isl_ctx *ctx, struct ppcg_scop *scop);
+void *gpu_prog_free(struct gpu_prog *prog);
+
+int ppcg_kernel_requires_array_argument(struct ppcg_kernel *kernel, int i);
+
+int generate_gpu(isl_ctx *ctx, const char *input, FILE *out,
+  struct ppcg_options *options,
+  __isl_give isl_printer *(*print)(__isl_take isl_printer *p,
+    struct gpu_prog *prog, __isl_keep isl_ast_node *tree,
+    struct gpu_types *types, void *user), void *user);
+
+#endif

polly/trunk/lib/External/ppcg/gpu_array_tile.h

+#ifndef GPU_ARRAY_TILE_H
+#define GPU_ARRAY_TILE_H
+
+#include <isl/aff_type.h>
+#include <isl/map_type.h>
+#include <isl/val.h>
+
+/* The fields stride and shift only contain valid information
+ * if shift != NULL.
+ * If so, they express that current index is such that if you add shift,
+ * then the result is always a multiple of stride.
+ * Let D represent the initial group->depth dimensions of the computed schedule.
+ * The spaces of "lb" and "shift" are of the form
+ *
+ *  D -> [b]
+ */
+struct gpu_array_bound {
+  isl_val *size;
+  isl_aff *lb;
+
+  isl_val *stride;
+  isl_aff *shift;
+};
+
+/* A tile of an array.
+ *
+ * requires_unroll is set if the schedule dimensions that are mapped
+ * to threads need to be unrolled for this (private) tile to be used.
+ *
+ * n is the dimension of the array.
+ * bound is an array of size "n" representing the lower bound
+ *  and size for each index.
+ *
+ * tiling maps a tile in the global array to the corresponding
+ * shared/private memory tile and is of the form
+ *
+ *  { [D[i] -> A[a]] -> T[(a + shift(i))/stride - lb(i)] }
+ *
+ * where D represents the initial group->depth dimensions
+ * of the computed schedule.
+ */
+struct gpu_array_tile {
+  isl_ctx *ctx;
+  int requires_unroll;
+  int n;
+  struct gpu_array_bound *bound;
+  isl_multi_aff *tiling;
+};
+
+struct gpu_array_tile *gpu_array_tile_create(isl_ctx *ctx, int n_index);
+struct gpu_array_tile *gpu_array_tile_free(struct gpu_array_tile *tile);
+
+__isl_give isl_val *gpu_array_tile_size(struct gpu_array_tile *tile);
+
+#endif

polly/trunk/lib/External/ppcg/gpu_array_tile.c

+#include <isl/aff.h>
+#include <isl/map.h>
+
+#include "gpu_array_tile.h"
+
+struct gpu_array_tile *gpu_array_tile_free(struct gpu_array_tile *tile)
+{
+  int j;
+
+  if (!tile)
+    return NULL;
+
+  for (j = 0; j < tile->n; ++j) {
+    isl_val_free(tile->bound[j].size);
+    isl_val_free(tile->bound[j].stride);
+    isl_aff_free(tile->bound[j].lb);
+    isl_aff_free(tile->bound[j].shift);
+  }
+  free(tile->bound);
+  isl_multi_aff_free(tile->tiling);
+  free(tile);
+
+  return NULL;
+}
+
+/* Create a gpu_array_tile for an array of dimension "n_index".
+ */
+struct gpu_array_tile *gpu_array_tile_create(isl_ctx *ctx, int n_index)
+{
+  int i;
+  struct gpu_array_tile *tile;
+
+  tile = isl_calloc_type(ctx, struct gpu_array_tile);
+  if (!tile)
+    return NULL;
+
+  tile->ctx = ctx;
+  tile->bound = isl_alloc_array(ctx, struct gpu_array_bound, n_index);
+  if (!tile->bound)
+    return gpu_array_tile_free(tile);
+
+  tile->n = n_index;
+
+  for (i = 0; i < n_index; ++i) {
+    tile->bound[i].size = NULL;
+    tile->bound[i].lb = NULL;
+    tile->bound[i].stride = NULL;
+    tile->bound[i].shift = NULL;
+  }
+
+  return tile;
+}
+
+/* Compute the size of the tile specified by "tile"
+ * in number of elements and return the result.
+ */
+__isl_give isl_val *gpu_array_tile_size(struct gpu_array_tile *tile)
+{
+  int i;
+  isl_val *size;
+
+  if (!tile)
+    return NULL;
+
+  size = isl_val_one(tile->ctx);
+
+  for (i = 0; i < tile->n; ++i)
+    size = isl_val_mul(size, isl_val_copy(tile->bound[i].size));
+
+  return size;
+}

polly/trunk/lib/External/ppcg/gpu_group.h

+#ifndef GPU_GROUP_H
+#define GPU_GROUP_H
+
+#include <isl/schedule_node.h>
+#include "gpu.h"
+
+/* A group of array references in a kernel that should be handled together.
+ * If private_tile is not NULL, then it is mapped to registers.
+ * Otherwise, if shared_tile is not NULL, it is mapped to shared memory.
+ * Otherwise, it is accessed from global memory.
+ * Note that if both private_tile and shared_tile are set, then shared_tile
+ * is only used inside group_common_shared_memory_tile.
+ * "depth" reflects the number of schedule dimensions that affect the tile
+ * (private_tile if set; shared_tile if shared_tile is set and private_tile
+ * is not).  The copying into and/or out of the tile is performed at that
+ * depth.
+ */
+struct gpu_array_ref_group {
+  /* The references in this group access this local array. */
+  struct gpu_local_array_info *local_array;
+  /* This is the corresponding array. */
+  struct gpu_array_info *array;
+  /* Position of this group in the list of reference groups of array. */
+  int nr;
+
+  /* The following fields are use during the construction of the groups.
+   * access is the combined access relation relative to the shared
+   * memory tiling.  In particular, the domain of the map corresponds
+   * to the first shared_schedule_dim dimensions of the kernel schedule.
+   * write is set if any access in the group is a write.
+   * exact_write is set if all writes are definite writes.
+   * slice is set if there is at least one access in the group
+   * that refers to more than one element
+   */
+  isl_map *access;
+  int write;
+  int exact_write;
+  int slice;
+
+  /* The shared memory tile, NULL if none. */
+  struct gpu_array_tile *shared_tile;
+
+  /* The private memory tile, NULL if none. */
+  struct gpu_array_tile *private_tile;
+
+  int depth;
+
+  /* References in this group; point to elements of a linked list. */
+  int n_ref;
+  struct gpu_stmt_access **refs;
+};
+
+int gpu_group_references(struct ppcg_kernel *kernel,
+  __isl_keep isl_schedule_node *node);
+
+__isl_give isl_printer *gpu_array_ref_group_print_name(
+  struct gpu_array_ref_group *group, __isl_take isl_printer *p);
+void gpu_array_ref_group_compute_tiling(struct gpu_array_ref_group *group);
+__isl_give isl_union_map *gpu_array_ref_group_access_relation(
+  struct gpu_array_ref_group *group, int read, int write);
+int gpu_array_ref_group_requires_unroll(struct gpu_array_ref_group *group);
+struct gpu_array_tile *gpu_array_ref_group_tile(
+  struct gpu_array_ref_group *group);
+struct gpu_array_ref_group *gpu_array_ref_group_free(
+  struct gpu_array_ref_group *group);
+
+#endif

polly/trunk/lib/External/ppcg/gpu_group.c

+#include <isl/constraint.h>
+#include <isl/ilp.h>
+
+#include "gpu_array_tile.h"
+#include "gpu_group.h"
+#include "gpu_tree.h"
+#include "schedule.h"
+
+/* Print the name of the local copy of a given group of array references.
+ */
+__isl_give isl_printer *gpu_array_ref_group_print_name(
+  struct gpu_array_ref_group *group, __isl_take isl_printer *p)
+{
+  int global = 0;
+
+  if (group->private_tile)
+    p = isl_printer_print_str(p, "private_");
+  else if (group->shared_tile)
+    p = isl_printer_print_str(p, "shared_");
+  else
+    global = 1;
+  p = isl_printer_print_str(p, group->array->name);
+  if (!global && group->local_array->n_group > 1) {
+    p = isl_printer_print_str(p, "_");
+    p = isl_printer_print_int(p, group->nr);
+  }
+
+  return p;
+}
+
+/* Return the union of all read (read = 1) and/or write (write = 1)
+ * access relations in the group.
+ */
+__isl_give isl_union_map *gpu_array_ref_group_access_relation(
+  struct gpu_array_ref_group *group, int read, int write)
+{
+  int i;
+  isl_union_map *access;
+
+  access = isl_union_map_empty(isl_map_get_space(group->access));
+  for (i = 0; i < group->n_ref; ++i) {
+    isl_map *map_i;
+
+    if (!((read && group->refs[i]->read) ||
+         (write && group->refs[i]->write)))
+      continue;
+    map_i = isl_map_copy(group->refs[i]->access);
+    access = isl_union_map_union(access,
+              isl_union_map_from_map(map_i));
+  }
+
+  return access;
+}
+
+/* Return the effective gpu_array_tile associated to "group" or
+ * NULL if there is no such gpu_array_tile.
+ * If we have computed both a private and a shared tile, then
+ * the private tile is used.
+ */
+struct gpu_array_tile *gpu_array_ref_group_tile(
+  struct gpu_array_ref_group *group)
+{
+  if (group->private_tile)
+    return group->private_tile;
+  if (group->shared_tile)
+    return group->shared_tile;
+  return NULL;
+}
+
+/* Does the tile associated to "group" require unrolling of the schedule
+ * dimensions mapped to threads?
+ * Note that this can only happen for private tiles.
+ */
+int gpu_array_ref_group_requires_unroll(struct gpu_array_ref_group *group)
+{
+  struct gpu_array_tile *tile;
+
+  tile = gpu_array_ref_group_tile(group);
+  if (!tile)
+    return 0;
+  return tile->requires_unroll;
+}
+
+/* Given a constraint
+ *
+ *    a(p,i) + j = g f(e)
+ *
+ * or -a(p,i) - j = g f(e) if sign < 0,
+ * store a(p,i) in bound->shift and g (stride) in bound->stride.
+ * a(p,i) is assumed to be an expression in only the parameters
+ * and the input dimensions.
+ */
+static void extract_stride(__isl_keep isl_constraint *c,
+  struct gpu_array_bound *bound, __isl_keep isl_val *stride, int sign)
+{
+  int i;
+  isl_val *v;
+  isl_space *space;
+  unsigned nparam;
+  unsigned nvar;
+  isl_aff *aff;
+
+  isl_val_free(bound->stride);
+  bound->stride = isl_val_copy(stride);
+
+  space = isl_constraint_get_space(c);
+  space = isl_space_domain(space);
+
+  nparam = isl_space_dim(space, isl_dim_param);
+  nvar = isl_space_dim(space, isl_dim_set);
+
+  v = isl_constraint_get_constant_val(c);
+  if (sign < 0)
+    v = isl_val_neg(v);
+  aff = isl_aff_zero_on_domain(isl_local_space_from_space(space));
+  aff = isl_aff_set_constant_val(aff, v);
+
+  for (i = 0; i < nparam; ++i) {
+    if (!isl_constraint_involves_dims(c, isl_dim_param, i, 1))
+      continue;
+    v = isl_constraint_get_coefficient_val(c, isl_dim_param, i);
+    if (sign < 0)
+      v = isl_val_neg(v);
+    aff = isl_aff_add_coefficient_val(aff, isl_dim_param, i, v);
+  }
+
+  for (i = 0; i < nvar; ++i) {
+    if (!isl_constraint_involves_dims(c, isl_dim_in, i, 1))
+      continue;
+    v = isl_constraint_get_coefficient_val(c, isl_dim_in, i);
+    if (sign < 0)
+      v = isl_val_neg(v);
+    aff = isl_aff_add_coefficient_val(aff, isl_dim_in, i, v);
+  }
+
+  bound->shift = aff;
+}
+
+/* Given an equality constraint of a map with a single output dimension j,
+ * check if the constraint is of the form
+ *
+ *    a(p,i) + j = g f(e)
+ *
+ * with a(p,i) an expression in the parameters and input dimensions
+ * and f(e) an expression in the existentially quantified variables.
+ * If so, and if g is larger than any such g from a previously considered
+ * constraint, then call extract_stride to record the stride information
+ * in bound.
+ */
+static isl_stat check_stride_constraint(__isl_take isl_constraint *c,
+  void *user)
+{
+  int i;
+  isl_ctx *ctx;
+  isl_val *v;
+  unsigned n_div;
+  struct gpu_array_bound *bound = user;
+
+  ctx = isl_constraint_get_ctx(c);
+  n_div = isl_constraint_dim(c, isl_dim_div);
+  v = isl_constraint_get_coefficient_val(c, isl_dim_out, 0);
+
+  if (n_div && (isl_val_is_one(v) || isl_val_is_negone(v))) {
+    int s = isl_val_sgn(v);
+    isl_val *stride = isl_val_zero(ctx);
+
+    isl_val_free(v);
+    for (i = 0; i < n_div; ++i) {
+      v = isl_constraint_get_coefficient_val(c,
+                isl_dim_div, i);
+      stride = isl_val_gcd(stride, v);
+    }
+    if (!isl_val_is_zero(stride) &&
+        isl_val_gt(stride, bound->stride))
+      extract_stride(c, bound, stride, s);
+
+    isl_val_free(stride);
+  } else
+    isl_val_free(v);
+
+  isl_constraint_free(c);
+  return isl_stat_ok;
+}
+
+/* Given contraints on an array index i, check if we can find
+ * a shift a(p) and a stride g such that
+ *
+ *  a(p) + i = 0 mod g
+ *
+ * If so, record the information in bound and apply the mapping
+ * i -> (i + a(p))/g to the array index in bounds and return
+ * the new constraints.
+ * If not, simply return the original constraints.
+ *
+ * If bounds is a subset of the space
+ *
+ *  D -> i
+ *
+ * then the bound recorded in bound->shift is of the form
+ *
+ *  D -> s(D)
+ *
+ * with s(D) equal to a(p) above.
+ * Next, we construct a mapping of the form
+ *
+ *  [D -> i] -> [D -> (i + S(D))/g]
+ *
+ * This mapping is computed as follows.
+ * We first introduce "i" in the domain through precomposition
+ * with [D -> i] -> D obtaining
+ *
+ *  [D -> i] -> s(D)
+ *
+ * Adding [D -> i] -> i produces
+ *
+ *  [D -> i] -> i + s(D)
+ *
+ * and the domain product with [D -> i] -> D yields
+ *
+ *  [D -> i] -> [D -> i + s(D)]
+ *
+ * Composition with [D -> i] -> [D -> i/g] gives the desired result.
+ */
+static __isl_give isl_basic_map *check_stride(struct gpu_array_bound *bound,
+  __isl_take isl_basic_map *bounds)
+{
+  isl_space *space;
+  isl_basic_map *hull;
+  isl_basic_map *shift, *id, *bmap, *scale;
+  isl_basic_set *bset;
+  isl_aff *aff;
+
+  bound->stride = NULL;
+
+  hull = isl_basic_map_affine_hull(isl_basic_map_copy(bounds));
+
+  isl_basic_map_foreach_constraint(hull, &check_stride_constraint, bound);
+
+  isl_basic_map_free(hull);
+
+  if (!bound->stride)
+    return bounds;
+
+  shift = isl_basic_map_from_aff(isl_aff_copy(bound->shift));
+  space = isl_basic_map_get_space(bounds);
+  bmap = isl_basic_map_domain_map(isl_basic_map_universe(space));
+  shift = isl_basic_map_apply_range(bmap, shift);
+  space = isl_basic_map_get_space(bounds);
+  id = isl_basic_map_range_map(isl_basic_map_universe(space));
+  shift = isl_basic_map_sum(id, shift);
+  space = isl_basic_map_get_space(bounds);
+  id = isl_basic_map_domain_map(isl_basic_map_universe(space));
+  shift = isl_basic_map_range_product(id, shift);
+
+  space = isl_space_domain(isl_basic_map_get_space(bounds));
+  id = isl_basic_map_identity(isl_space_map_from_set(space));
+  space = isl_space_range(isl_basic_map_get_space(bounds));
+  aff = isl_aff_zero_on_domain(isl_local_space_from_space(space));
+  aff = isl_aff_add_coefficient_si(aff, isl_dim_in, 0, 1);
+  aff = isl_aff_scale_down_val(aff, isl_val_copy(bound->stride));
+  scale = isl_basic_map_from_aff(aff);
+  scale = isl_basic_map_product(id, scale);
+
+  bmap = isl_basic_map_apply_range(shift, scale);
+  bset = isl_basic_set_apply(isl_basic_map_wrap(bounds), bmap);
+  bounds = isl_basic_set_unwrap(bset);
+
+  return bounds;
+}
+
+/* Data used in compute_array_dim_size and compute_size_in_direction.
+ *
+ * pos is the position of the variable representing the array index,
+ * i.e., the variable for which want to compute the size.  This variable
+ * is also the last variable in the set.
+ */
+struct gpu_size_info {
+  isl_basic_set *bset;
+  struct gpu_array_bound *bound;
+  int pos;
+};
+
+/* Given a constraint from the basic set describing the bounds on
+ * an array index, check if it is a lower bound, say m i >= b(x), and,
+ * if so, check whether the expression "i - ceil(b(x)/m) + 1" has a constant
+ * upper bound.  If so, and if this bound is smaller than any bound
+ * derived from earlier constraints, set the size to this bound on
+ * the expression and the lower bound to ceil(b(x)/m).
+ */
+static isl_stat compute_size_in_direction(__isl_take isl_constraint *c,
+  void *user)
+{
+  struct gpu_size_info *size = user;
+  unsigned nparam;
+  unsigned n_div;
+  isl_val *v;
+  isl_aff *aff;
+  isl_aff *lb;
+
+  nparam = isl_basic_set_dim(size->bset, isl_dim_param);
+  n_div = isl_constraint_dim(c, isl_dim_div);
+
+  if (isl_constraint_involves_dims(c, isl_dim_div, 0, n_div) ||
+      !isl_constraint_is_lower_bound(c, isl_dim_set, size->pos)) {
+    isl_constraint_free(c);
+    return isl_stat_ok;
+  }
+
+  aff = isl_constraint_get_bound(c, isl_dim_set, size->pos);
+  aff = isl_aff_ceil(aff);
+
+  lb = isl_aff_copy(aff);
+
+  aff = isl_aff_neg(aff);
+  aff = isl_aff_add_coefficient_si(aff, isl_dim_in, size->pos, 1);
+
+  v = isl_basic_set_max_val(size->bset, aff);
+  isl_aff_free(aff);
+
+  if (isl_val_is_int(v)) {
+    v = isl_val_add_ui(v, 1);
+    if (!size->bound->size || isl_val_lt(v, size->bound->size)) {
+      isl_val_free(size->bound->size);
+      size->bound->size = isl_val_copy(v);
+      lb = isl_aff_drop_dims(lb, isl_dim_in, size->pos, 1);
+      isl_aff_free(size->bound->lb);
+      size->bound->lb = isl_aff_copy(lb);
+    }
+  }
+  isl_val_free(v);
+  isl_aff_free(lb);
+
+  isl_constraint_free(c);
+
+  return isl_stat_ok;
+}
+
+/* Given a basic map "bounds" that maps parameters and input dimensions
+ * to a single output dimension, look for an expression in the parameters
+ * and input dimensions such that the range of the output dimension shifted
+ * by this expression is a constant.
+ *
+ * In particular, we currently only consider lower bounds on the output
+ * dimension as candidate expressions.
+ */
+static int compute_array_dim_size(struct gpu_array_bound *bound,
+  __isl_take isl_basic_map *bounds)
+{
+  struct gpu_size_info size;
+
+  bounds = isl_basic_map_detect_equalities(bounds);
+  bounds = check_stride(bound, bounds);
+
+  bound->size = NULL;
+  bound->lb = NULL;
+
+  size.bound = bound;
+  size.pos = isl_basic_map_dim(bounds, isl_dim_in);
+  size.bset = isl_basic_map_wrap(bounds);
+  size.bset = isl_basic_set_flatten(size.bset);
+  size.bset = isl_set_simple_hull(isl_basic_set_compute_divs(size.bset));
+  isl_basic_set_foreach_constraint(size.bset, &compute_size_in_direction,
+          &size);
+  isl_basic_set_free(size.bset);
+
+  return bound->size ? 0 : -1;
+}
+
+/* Check if we can find a memory tile for the given array
+ * based on the given accesses, and if so, put the results in "tile".
+ *
+ * We project the accesses on each index in turn and look for a parametric
+ * offset such that the size is constant.
+ */
+static int can_tile(__isl_keep isl_map *access, struct gpu_array_tile *tile)
+{
+  int i;
+
+  for (i = 0; i < tile->n; ++i) {
+    isl_map *access_i;
+    isl_basic_map *hull;
+
+    access_i = isl_map_copy(access);
+    access_i = isl_map_project_out(access_i, isl_dim_out, 0, i);
+    access_i = isl_map_project_out(access_i, isl_dim_out,
+              1, tile->n - (i + 1));
+    access_i = isl_map_compute_divs(access_i);
+    hull = isl_map_simple_hull(access_i);
+    if (compute_array_dim_size(&tile->bound[i], hull) < 0)
+      return 0;
+  }
+
+  return 1;
+}
+
+/* Internal data structure for gpu_group_references.
+ *
+ * scop represents the input scop.
+ * kernel_depth is the schedule depth where the kernel launch will
+ * be introduced, i.e., it is the depth of the band that is mapped
+ * to blocks.
+ * thread_depth is the schedule depth where the thread mark is located,
+ * i.e., it is the depth of the band that is mapped to threads and also
+ * the schedule depth at which the copying to/from shared/private memory
+ * is computed.  The copy operation may then later be hoisted to
+ * a higher level.
+ * n_thread is the number of schedule dimensions in the band that
+ * is mapped to threads.
+ * privatization lives in the range of thread_sched (i.e., it is
+ * of dimension thread_depth + n_thread) and encodes the mapping
+ * to thread identifiers (as parameters).
+ * host_sched contains the kernel_depth dimensions of the host schedule.
+ * shared_sched contains the first thread_depth dimensions of the
+ * kernel schedule.
+ * thread_sched contains the first (thread_depth + n_thread) dimensions
+ * of the kernel schedule.
+ * full_sched is a union_map representation of the entire kernel schedule.
+ */
+struct gpu_group_data {
+  struct ppcg_scop *scop;
+  int kernel_depth;
+  int thread_depth;
+  int n_thread;
+  isl_set *privatization;
+  isl_union_map *host_sched;
+  isl_union_map *shared_sched;
+  isl_union_map *thread_sched;
+  isl_union_map *full_sched;
+};
+
+/* Construct a map from domain_space to domain_space that increments
+ * the dimension at position "pos" and leaves all other dimensions
+ * constant.
+ */
+static __isl_give isl_map *next(__isl_take isl_space *domain_space, int pos)
+{
+  isl_space *space;
+  isl_aff *aff;
+  isl_multi_aff *next;
+
+  space = isl_space_map_from_set(domain_space);
+  next = isl_multi_aff_identity(space);
+  aff = isl_multi_aff_get_aff(next, pos);
+  aff = isl_aff_add_constant_si(aff, 1);
+  next = isl_multi_aff_set_aff(next, pos, aff);
+
+  return isl_map_from_multi_aff(next);
+}
+
+/* Check if the given access is coalesced (or if there is no point
+ * in trying to coalesce the access by mapping the array to shared memory).
+ * That is, check whether incrementing the dimension that will get
+ * wrapped over the last thread index results in incrementing
+ * the last array index.
+ *
+ * If no two consecutive array elements are ever accessed by "access",
+ * then mapping the corresponding array to shared memory will not
+ * improve coalescing.  In fact, the copying will likely be performed
+ * by a single thread.  Consider the access as coalesced such that
+ * the caller will not try and map the array to shared memory just
+ * to improve coalescing.
+ *
+ * This function is only called for access relations without reuse and
+ * kernels with at least one thread identifier.
+ */
+static int access_is_coalesced(struct gpu_group_data *data,
+  __isl_keep isl_union_map *access)
+{
+  isl_space *space;
+  isl_set *accessed;
+  isl_map *access_map;
+  isl_map *next_thread_x;
+  isl_map *next_element;
+  isl_map *map;
+  int coalesced, empty;
+
+  access = isl_union_map_copy(access);
+  access = isl_union_map_apply_domain(access,
+        isl_union_map_copy(data->full_sched));
+  access_map = isl_map_from_union_map(access);
+
+  space = isl_map_get_space(access_map);
+  space = isl_space_range(space);
+  next_element = next(space, isl_space_dim(space, isl_dim_set) - 1);
+
+  accessed = isl_map_range(isl_map_copy(access_map));
+  map = isl_map_copy(next_element);
+  map = isl_map_intersect_domain(map, isl_set_copy(accessed));
+  map = isl_map_intersect_range(map, accessed);
+  empty = isl_map_is_empty(map);
+  isl_map_free(map);
+
+  if (empty < 0 || empty) {
+    isl_map_free(next_element);
+    isl_map_free(access_map);
+    return empty;
+  }
+
+  space = isl_map_get_space(access_map);
+  space = isl_space_domain(space);
+  next_thread_x = next(space, data->thread_depth + data->n_thread - 1);
+
+  map = isl_map_apply_domain(next_thread_x, isl_map_copy(access_map));
+  map = isl_map_apply_range(map, access_map);
+
+  coalesced = isl_map_is_subset(map, next_element);
+
+  isl_map_free(next_element);
+  isl_map_free(map);
+
+  return coalesced;
+}
+
+/* Replace the host schedule dimensions in the access relation "access"
+ * by parameters, so that they are treated as fixed when checking for reuse
+ * (within a kernel) or whether two consecutive elements are accessed
+ * (within a kernel).
+ */
+static __isl_give isl_union_map *localize_access(struct gpu_group_data *data,
+  __isl_take isl_union_map *access)
+{
+  int n;
+  isl_space *space;
+  isl_set *param;
+  isl_union_map *umap;
+  isl_id_list *ids;
+
+  umap = isl_union_map_copy(data->host_sched);
+  space = isl_union_map_get_space(umap);
+  n = data->kernel_depth;
+  ids = ppcg_scop_generate_names(data->scop, n, "__ppcg_host_");
+  param = parametrization(space, n, 0, ids);
+  isl_id_list_free(ids);
+  umap = isl_union_map_intersect_range(umap,
+            isl_union_set_from_set(param));
+  access = isl_union_map_intersect_domain(access,
+            isl_union_map_domain(umap));
+
+  return access;
+}
+
+/* Given an access relation in terms of at least data->thread_depth initial
+ * dimensions of the computed schedule, check if it is bijective for
+ * fixed values of the first data->thread_depth dimensions.
+ * We perform this check by equating these dimensions to parameters.
+ */
+static int access_is_bijective(struct gpu_group_data *data,
+  __isl_keep isl_map *access)
+{
+  int res;
+  int dim;
+  isl_set *par;
+  isl_space *space;
+  isl_id_list *ids;
+
+  access = isl_map_copy(access);
+  space = isl_space_params(isl_map_get_space(access));
+  ids = ppcg_scop_generate_names(data->scop, data->thread_depth, "s");
+  dim = isl_map_dim(access, isl_dim_in);
+  par = parametrization(space, dim, 0, ids);
+  isl_id_list_free(ids);
+  access = isl_map_intersect_domain(access, par);
+  res = isl_map_is_bijective(access);
+  isl_map_free(access);
+
+  return res;
+}
+
+/* Compute the number of outer schedule tile dimensions that affect
+ * the offset of "tile".
+ * If there is no such dimension, then return the index
+ * of the first kernel dimension, i.e., data->kernel_depth.
+ */
+static int compute_tile_depth(struct gpu_group_data *data,
+  struct gpu_array_tile *tile)
+{
+  int i, j;
+
+  for (j = data->thread_depth - 1; j >= data->kernel_depth; --j) {
+    for (i = 0; i < tile->n; ++i) {
+      isl_aff *lb;
+      isl_aff *shift;
+
+      lb = tile->bound[i].lb;
+      if (isl_aff_involves_dims(lb, isl_dim_in, j, 1))
+        break;
+
+      shift = tile->bound[i].shift;
+      if (!shift)
+        continue;
+      if (isl_aff_involves_dims(shift, isl_dim_in, j, 1))
+        break;
+    }
+    if (i < tile->n)
+      break;
+  }
+
+  return ++j;
+}
+
+/* Adjust the fields of "tile" to reflect the new input dimension "new_dim",
+ * where "old_dim" is the old dimension.
+ * The dimension beyond "new_dim" are assumed not to affect the tile,
+ * so they can simply be dropped.
+ */
+static int tile_adjust_depth(struct gpu_array_tile *tile,
+  int old_dim, int new_dim)
+{
+  int i;
+
+  if (old_dim == new_dim)
+    return 0;
+
+  for (i = 0; i < tile->n; ++i) {
+    tile->bound[i].lb = isl_aff_drop_dims(tile->bound[i].lb,
+          isl_dim_in, new_dim, old_dim - new_dim);
+    if (!tile->bound[i].lb)
+      return -1;
+    if (!tile->bound[i].shift)
+      continue;
+    tile->bound[i].shift = isl_aff_drop_dims(tile->bound[i].shift,
+          isl_dim_in, new_dim, old_dim - new_dim);
+    if (!tile->bound[i].shift)
+      return -1;
+  }
+
+  return 0;
+}
+
+/* Determine the number of schedule dimensions that affect the offset of the
+ * shared or private tile and store the result in group->depth, with
+ * a lower bound of data->kernel_depth.
+ * If there is no tile defined on the array reference group,
+ * then set group->depth to data->thread_depth.
+ * Also adjust the fields of the tile to only refer to the group->depth
+ * outer schedule dimensions.
+ */
+static int set_depth(struct gpu_group_data *data,
+  struct gpu_array_ref_group *group)
+{
+  struct gpu_array_tile *tile;
+
+  group->depth = data->thread_depth;
+
+  tile = gpu_array_ref_group_tile(group);
+  if (!tile)
+    return 0;
+
+  group->depth = compute_tile_depth(data, tile);
+  if (tile_adjust_depth(tile, data->thread_depth, group->depth) < 0)
+    return -1;
+
+  return 0;
+}
+
+/* Fill up the groups array with singleton groups, i.e., one group
+ * per reference, initializing the array, access, write, n_ref and refs fields.
+ * In particular the access field is initialized to the scheduled
+ * access relation of the array reference.
+ *
+ * Return the number of elements initialized, i.e., the number of
+ * active references in the current kernel.
+ */
+static int populate_array_references(struct gpu_local_array_info *local,
+  struct gpu_array_ref_group **groups, struct gpu_group_data *data)
+{
+  int i;
+  int n;
+  isl_ctx *ctx = isl_union_map_get_ctx(data->shared_sched);
+
+  n = 0;
+  for (i = 0; i < local->array->n_ref; ++i) {
+    isl_union_map *umap;
+    isl_map *map;
+    struct gpu_array_ref_group *group;
+    struct gpu_stmt_access *access = local->array->refs[i];
+
+    map = isl_map_copy(access->access);
+    umap = isl_union_map_from_map(map);
+    umap = isl_union_map_apply_domain(umap,
+        isl_union_map_copy(data->shared_sched));
+
+    if (isl_union_map_is_empty(umap)) {
+      isl_union_map_free(umap);
+      continue;
+    }
+
+    map = isl_map_from_union_map(umap);
+    map = isl_map_detect_equalities(map);
+
+    group = isl_calloc_type(ctx, struct gpu_array_ref_group);
+    if (!group)
+      return -1;
+    group->local_array = local;
+    group->array = local->array;
+    group->access = map;
+    group->write = access->write;
+    group->exact_write = access->exact_write;
+    group->slice = access->n_index < local->array->n_index;
+    group->refs = &local->array->refs[i];
+    group->n_ref = 1;
+
+    groups[n++] = group;
+  }
+
+  return n;
+}
+
+/* If group->n_ref == 1, then group->refs was set by
+ * populate_array_references to point directly into
+ * group->array->refs and should not be freed.
+ * If group->n_ref > 1, then group->refs was set by join_groups
+ * to point to a newly allocated array.
+ */
+struct gpu_array_ref_group *gpu_array_ref_group_free(
+  struct gpu_array_ref_group *group)
+{
+  if (!group)
+    return NULL;
+  gpu_array_tile_free(group->shared_tile);
+  gpu_array_tile_free(group->private_tile);
+  isl_map_free(group->access);
+  if (group->n_ref > 1)
+    free(group->refs);
+  free(group);
+  return NULL;
+}
+
+/* Check if the access relations of group1 and group2 overlap within
+ * shared_sched.
+ */
+static int accesses_overlap(struct gpu_array_ref_group *group1,
+  struct gpu_array_ref_group *group2)
+{
+  int disjoint;
+
+  disjoint = isl_map_is_disjoint(group1->access, group2->access);
+  if (disjoint < 0)
+    return -1;
+
+  return !disjoint;
+}
+
+/* Combine the given two groups into a single group, containing
+ * the references of both groups.
+ */
+static struct gpu_array_ref_group *join_groups(
+  struct gpu_array_ref_group *group1,
+  struct gpu_array_ref_group *group2)
+{
+  int i;
+  isl_ctx *ctx;
+  struct gpu_array_ref_group *group;
+
+  if (!group1 || !group2)
+    return NULL;
+
+  ctx = isl_map_get_ctx(group1->access);
+  group = isl_calloc_type(ctx, struct gpu_array_ref_group);
+  if (!group)
+    return NULL;
+  group->local_array = group1->local_array;
+  group->array = group1->array;
+  group->access = isl_map_union(isl_map_copy(group1->access),
+          isl_map_copy(group2->access));
+  group->write = group1->write || group2->write;
+  group->exact_write = group1->exact_write && group2->exact_write;
+  group->slice = group1->slice || group2->slice;
+  group->n_ref = group1->n_ref + group2->n_ref;
+  group->refs = isl_alloc_array(ctx, struct gpu_stmt_access *,
+          group->n_ref);
+  if (!group->refs)
+    return gpu_array_ref_group_free(group);
+  for (i = 0; i < group1->n_ref; ++i)
+    group->refs[i] = group1->refs[i];
+  for (i = 0; i < group2->n_ref; ++i)
+    group->refs[group1->n_ref + i] = group2->refs[i];
+
+  return group;
+}
+
+/* Combine the given two groups into a single group and free
+ * the original two groups.
+ */
+static struct gpu_array_ref_group *join_groups_and_free(
+  struct gpu_array_ref_group *group1,
+  struct gpu_array_ref_group *group2)
+{
+  struct gpu_array_ref_group *group;
+
+  group = join_groups(group1, group2);
+  gpu_array_ref_group_free(group1);
+  gpu_array_ref_group_free(group2);
+  return group;
+}
+
+/* Report that the array reference group with the given access relation
+ * is not mapped to shared memory in the given kernel because
+ * it does not exhibit any reuse and is considered to be coalesced.
+ */
+static void report_no_reuse_and_coalesced(struct ppcg_kernel *kernel,
+  __isl_keep isl_union_map *access)
+{
+  isl_ctx *ctx;
+  isl_printer *p;
+
+  ctx = isl_union_map_get_ctx(access);
+  p = isl_printer_to_file(ctx, stdout);
+  p = isl_printer_print_str(p, "Array reference group ");
+  p = isl_printer_print_union_map(p, access);
+  p = isl_printer_print_str(p,
+      " not considered for mapping to shared memory in kernel");
+  p = isl_printer_print_int(p, kernel->id);
+  p = isl_printer_print_str(p,
+      " because it exhibits no reuse and is considered to be coalesced");
+  p = isl_printer_end_line(p);
+  isl_printer_free(p);
+}
+
+/* Given an access relation in terms of the data->thread_depth initial
+ * dimensions of the computed schedule and the thread identifiers
+ * (as parameters), check if the use of the corresponding private tile
+ * requires unrolling.
+ *
+ * If we are creating a private tile because we are forced to,
+ * then no unrolling is required.
+ * Otherwise we check if "access" is bijective and unrolling
+ * is required if it is not.  Note that the access relation
+ * has already been determined to be bijective before the introduction
+ * of the thread identifiers and the removal of the schedule dimensions
+ * that are mapped to these threads.  If the access relation is no longer
+ * bijective, then this means that more than one value of one of those
+ * schedule dimensions is mapped to the same thread and therefore
+ * unrolling is required.
+ */
+static int check_requires_unroll(struct gpu_group_data *data,
+  __isl_keep isl_map *access, int force_private)
+{
+  int bijective;
+
+  if (force_private)
+    return 0;
+  bijective = access_is_bijective(data, access);
+  if (bijective < 0)
+    return -1;
+  return !bijective;
+}
+
+/* Compute the private and/or shared memory tiles for the array
+ * reference group "group" of array "array".
+ * Return 0 on success and -1 on error.
+ *
+ * If the array is a read-only scalar or if the user requested
+ * not to use shared or private memory, then we do not need to do anything.
+ *
+ * If any reference in the reference group accesses more than one element,
+ * then we would have to make sure that the layout in shared memory
+ * is the same as that in global memory.  Since we do not handle this yet
+ * (and it may not even be possible), we refuse to map to private or
+ * shared memory in such cases.
+ *
+ * If the array group involves any may writes (that are not must writes),
+ * then we would have to make sure that we load the data into shared/private
+ * memory first in case the data is not written by the kernel
+ * (but still written back out to global memory).
+ * Since we don't have any such mechanism at the moment, we don't
+ * compute shared/private tiles for groups involving may writes.
+ *
+ * We only try to compute a shared memory tile if there is any reuse
+ * or if the access is not coalesced.
+ * Reuse and coalescing are checked within the given kernel.
+ *
+ * For computing a private memory tile, we also require that there is
+ * some reuse.  Moreover, we require that the access is private
+ * to the thread.  That is, we check that any given array element
+ * is only accessed by a single thread.
+ * We compute an access relation that maps the outer
+ * data->thread_depth + data->n_thread schedule dimensions.
+ * The latter data->n_thread will be mapped to thread identifiers.
+ * We actually check that those iterators that will be wrapped
+ * partition the array space.  This check is stricter than necessary
+ * since several iterations may be mapped onto the same thread
+ * and then they could be allowed to access the same memory elements,
+ * but our check does not allow this situation.
+ *
+ * We also check that the index expression only depends on parallel
+ * loops.  That way, we can move those loops innermost and unroll them.
+ * Again, we use a test that is stricter than necessary.
+ * We actually check whether the index expression only depends
+ * on the iterators that are wrapped over the threads.
+ * These are necessarily parallel, but there may be more parallel loops.
+ *
+ * Combining the injectivity of the first test with the single-valuedness
+ * of the second test, we simply test for bijectivity.
+ *
+ * If the use of the private tile requires unrolling, but some
+ * of the other arrays are forcibly mapped to private memory,
+ * then we do not allow the use of this private tile since
+ * we cannot move the schedule dimensions that need to be unrolled down
+ * without performing some kind of expansion on those arrays
+ * that are forcibly mapped to private memory.
+ *
+ * If the array is marked force_private, then we bypass all checks
+ * and assume we can (and should) use registers.
+ *
+ * If it turns out we can (or have to) use registers, we compute
+ * the private memory tile size using can_tile, after introducing a dependence
+ * on the thread indices.
+ */
+static int compute_group_bounds_core(struct ppcg_kernel *kernel,
+  struct gpu_array_ref_group *group, struct gpu_group_data *data)
+{
+  isl_ctx *ctx = isl_space_get_ctx(group->array->space);
+  isl_union_map *access, *local;
+  int n_index = group->array->n_index;
+  int no_reuse, coalesced;
+  isl_map *acc;
+  int force_private = group->local_array->force_private;
+  int use_shared = kernel->options->use_shared_memory &&
+        data->n_thread > 0;
+  int use_private = force_private || kernel->options->use_private_memory;
+  int r = 0;
+  int requires_unroll;
+
+  if (!use_shared && !use_private)
+    return 0;
+  if (gpu_array_is_read_only_scalar(group->array))
+    return 0;
+  if (!force_private && !group->exact_write)
+    return 0;
+  if (group->slice)
+    return 0;
+
+  access = gpu_array_ref_group_access_relation(group, 1, 1);
+  local = localize_access(data, isl_union_map_copy(access));
+  no_reuse = isl_union_map_is_injective(local);
+  if (no_reuse < 0)
+    r = -1;
+  if (use_shared && no_reuse)
+    coalesced = access_is_coalesced(data, local);
+  isl_union_map_free(local);
+
+  if (r >= 0 && kernel->options->debug->verbose &&
+      use_shared && no_reuse && coalesced)
+    report_no_reuse_and_coalesced(kernel, access);
+
+  if (use_shared && (!no_reuse || !coalesced)) {
+    group->shared_tile = gpu_array_tile_create(ctx,
+              group->array->n_index);
+    if (!group->shared_tile)
+      r = -1;
+    else if (!can_tile(group->access, group->shared_tile))
+      group->shared_tile =
+          gpu_array_tile_free(group->shared_tile);
+  }
+
+  if (r < 0 || (!force_private && (!use_private || no_reuse))) {
+    isl_union_map_free(access);
+    return r;
+  }
+
+  access = isl_union_map_apply_domain(access,
+          isl_union_map_copy(data->thread_sched));
+
+  acc = isl_map_from_union_map(access);
+
+  if (!force_private && !access_is_bijective(data, acc)) {
+    isl_map_free(acc);
+    return 0;
+  }
+
+  acc = isl_map_intersect_domain(acc, isl_set_copy(data->privatization));
+  acc = isl_map_project_out(acc, isl_dim_in, data->thread_depth,
+                data->n_thread);
+  requires_unroll = check_requires_unroll(data, acc, force_private);
+  if (requires_unroll < 0 ||
+      (requires_unroll && kernel->any_force_private)) {
+    isl_map_free(acc);
+    return requires_unroll < 0 ? -1 : 0;
+  }
+
+  group->private_tile = gpu_array_tile_create(ctx, n_index);
+  if (!group->private_tile) {
+    isl_map_free(acc);
+    return -1;
+  }
+  group->private_tile->requires_unroll = requires_unroll;
+  if (!can_tile(acc, group->private_tile))
+    group->private_tile = gpu_array_tile_free(group->private_tile);
+
+  isl_map_free(acc);
+
+  if (force_private && !group->private_tile)
+    isl_die(ctx, isl_error_internal,
+      "unable to map array reference group to registers",
+      return -1);
+
+  return 0;
+}
+
+/* Compute the private and/or shared memory tiles for the array
+ * reference group "group" of array "array" and set the tile depth.
+ * Return 0 on success and -1 on error.
+ */
+static int compute_group_bounds(struct ppcg_kernel *kernel,
+  struct gpu_array_ref_group *group, struct gpu_group_data *data)
+{
+  if (!group)
+    return -1;
+  if (compute_group_bounds_core(kernel, group, data) < 0)
+    return -1;
+  if (set_depth(data, group) < 0)
+    return -1;
+
+  return 0;
+}
+
+/* If two groups have overlapping access relations (as determined by
+ * the "overlap" function) and if one of them involves a write,
+ * then merge the two groups into one.
+ * If "compute_bounds" is set, then call compute_group_bounds
+ * on the merged groups.
+ *
+ * Return the updated number of groups.
+ * Return -1 on error.
+ */
+static int group_writes(struct ppcg_kernel *kernel,
+  int n, struct gpu_array_ref_group **groups,
+  int (*overlap)(struct gpu_array_ref_group *group1,
+    struct gpu_array_ref_group *group2), int compute_bounds,
+  struct gpu_group_data *data)
+{
+  int i, j;
+
+  for (i = 0; i < n; ++i) {
+    for (j = n - 1; j > i; --j) {
+      if (!groups[i]->write && !groups[j]->write)
+        continue;
+
+      if (!overlap(groups[i], groups[j]))
+        continue;
+
+      groups[i] = join_groups_and_free(groups[i], groups[j]);
+      if (j != n - 1)
+        groups[j] = groups[n - 1];
+      groups[n - 1] = NULL;
+      n--;
+
+      if (!groups[i])
+        return -1;
+      if (compute_bounds &&
+          compute_group_bounds(kernel, groups[i], data) < 0)
+        return -1;
+    }
+  }
+
+  return n;
+}
+
+/* If two groups have overlapping access relations (within the innermost
+ * loop) and if one of them involves a write, then merge the two groups
+ * into one.
+ *
+ * Return the updated number of groups.
+ */
+static int group_overlapping_writes(struct ppcg_kernel *kernel,
+  int n, struct gpu_array_ref_group **groups,
+  struct gpu_group_data *data)
+{
+  return group_writes(kernel, n, groups, &accesses_overlap, 0, data);
+}
+
+/* Check if the access relations of group1 and group2 overlap within
+ * the outermost min(group1->depth, group2->depth) loops.
+ */
+static int depth_accesses_overlap(struct gpu_array_ref_group *group1,
+  struct gpu_array_ref_group *group2)
+{
+  int depth;
+  int dim;
+  int empty;
+  isl_map *map_i, *map_j, *map;
+
+  depth = group1->depth;
+  if (group2->depth < depth)
+    depth = group2->depth;
+  map_i = isl_map_copy(group1->access);
+  dim = isl_map_dim(map_i, isl_dim_in);
+  map_i = isl_map_eliminate(map_i, isl_dim_in, depth, dim - depth);
+  map_j = isl_map_copy(group2->access);
+  map_j = isl_map_eliminate(map_j, isl_dim_in, depth, dim - depth);
+  map = isl_map_intersect(map_i, map_j);
+  empty = isl_map_is_empty(map);
+  isl_map_free(map);
+
+  return !empty;
+}
+
+/* If two groups have overlapping access relations (within the outer
+ * depth loops) and if one of them involves a write,
+ * then merge the two groups into one.
+ *
+ * Return the updated number of groups.
+ */
+static int group_depth_overlapping_writes(struct ppcg_kernel *kernel,
+  int n, struct gpu_array_ref_group **groups, struct gpu_group_data *data)
+{
+  return group_writes(kernel, n, groups, &depth_accesses_overlap, 1,
+        data);
+}
+
+/* Is the size of the tile specified by "tile" smaller than the sum of
+ * the sizes of the tiles specified by "tile1" and "tile2"?
+ */
+static int smaller_tile(struct gpu_array_tile *tile,
+  struct gpu_array_tile *tile1, struct gpu_array_tile *tile2)
+{
+  int smaller;
+  isl_val *size, *size1, *size2;
+
+  size = gpu_array_tile_size(tile);
+  size1 = gpu_array_tile_size(tile1);
+  size2 = gpu_array_tile_size(tile2);
+
+  size = isl_val_sub(size, size1);
+  size = isl_val_sub(size, size2);
+  smaller = isl_val_is_neg(size);
+
+  isl_val_free(size);
+
+  return smaller;
+}
+
+/* Given an initial grouping of array references and shared memory tiles
+ * for each group that allows for a shared memory tile, merge two groups
+ * if both have a shared memory tile, the merged group also has
+ * a shared memory tile and the size of the tile for the merge group
+ * is smaller than the sum of the tile sizes of the individual groups.
+ *
+ * If merging two groups decreases the depth of the tile of
+ * one or both of the two groups, then we need to check for overlapping
+ * writes again.
+ *
+ * Return the number of groups after merging.
+ * Return -1 on error.
+ */
+static int group_common_shared_memory_tile(struct ppcg_kernel *kernel,
+  struct gpu_array_info *array, int n,
+  struct gpu_array_ref_group **groups, struct gpu_group_data *data)
+{
+  int i, j;
+  int recompute_overlap = 0;
+  isl_ctx *ctx = isl_space_get_ctx(array->space);
+
+  for (i = 0; i < n; ++i) {
+    if (!groups[i]->shared_tile)
+      continue;
+    for (j = n - 1; j > i; --j) {
+      isl_map *map;
+      int empty;
+      struct gpu_array_ref_group *group;
+
+      if (!groups[j]->shared_tile)
+        continue;
+
+      map = isl_map_intersect(isl_map_copy(groups[i]->access),
+              isl_map_copy(groups[j]->access));
+      empty = isl_map_is_empty(map);
+      isl_map_free(map);
+
+      if (empty)
+        continue;
+
+      group = join_groups(groups[i], groups[j]);
+      if (compute_group_bounds(kernel, group, data) < 0) {
+        gpu_array_ref_group_free(group);
+        return -1;
+      }
+      if (!group->shared_tile ||
+          !smaller_tile(group->shared_tile,
+          groups[i]->shared_tile,
+          groups[j]->shared_tile)) {
+        gpu_array_ref_group_free(group);
+        continue;
+      }
+
+      if (group->depth < groups[i]->depth ||
+          group->depth < groups[j]->depth)
+        recompute_overlap = 1;
+      gpu_array_ref_group_free(groups[i]);
+      gpu_array_ref_group_free(groups[j]);
+      groups[i] = group;
+      if (j != n - 1)
+        groups[j] = groups[n - 1];
+      n--;
+    }
+  }
+
+  if (recompute_overlap)
+    n = group_depth_overlapping_writes(kernel, n, groups, data);
+  return n;
+}
+
+/* Set array->n_group and array->groups to n and groups.
+ *
+ * Additionally, set the "nr" field of each group.
+ */
+static void set_array_groups(struct gpu_local_array_info *array,
+  int n, struct gpu_array_ref_group **groups)
+{
+  int i, j;
+
+  array->n_group = n;
+  array->groups = groups;
+
+  for (i = 0; i < n; ++i)
+    groups[i]->nr = i;
+}
+
+/* Combine all groups in "groups" into a single group and return
+ * the new number of groups (1 or 0 if there were no groups to start with).
+ */
+static int join_all_groups(int n, struct gpu_array_ref_group **groups)
+{
+  int i;
+
+  for (i = n - 1; i > 0; --i) {
+    groups[0] = join_groups_and_free(groups[0], groups[i]);
+    groups[i] = NULL;
+    n--;
+  }
+
+  return n;
+}
+
+/* Group array references that should be considered together when
+ * deciding whether to access them from private, shared or global memory.
+ * Return -1 on error.
+ *
+ * In particular, if two array references overlap and if one of them
+ * is a write, then the two references are grouped together.
+ * We first perform an initial grouping based only on the access relation.
+ * After computing shared and private memory tiles, we check for
+ * overlapping writes again, but this time taking into account
+ * the depth of the effective tile.
+ *
+ * Furthermore, if two groups admit a shared memory tile and if the
+ * combination of the two also admits a shared memory tile, we merge
+ * the two groups.
+ *
+ * If the array contains structures, then we compute a single
+ * reference group without trying to find any tiles
+ * since we do not map such arrays to private or shared
+ * memory.
+ */
+static int group_array_references(struct ppcg_kernel *kernel,
+  struct gpu_local_array_info *local, struct gpu_group_data *data)
+{
+  int i;
+  int n;
+  isl_ctx *ctx = isl_union_map_get_ctx(data->shared_sched);
+  struct gpu_array_ref_group **groups;
+
+  groups = isl_calloc_array(ctx, struct gpu_array_ref_group *,
+          local->array->n_ref);
+  if (!groups)
+    return -1;
+
+  n = populate_array_references(local, groups, data);
+
+  if (local->array->has_compound_element) {
+    n = join_all_groups(n, groups);
+    set_array_groups(local, n, groups);
+    return 0;
+  }
+
+  n = group_overlapping_writes(kernel, n, groups, data);
+
+  for (i = 0; i < n; ++i)
+    if (compute_group_bounds(kernel, groups[i], data) < 0)
+      n = -1;
+
+  n = group_depth_overlapping_writes(kernel, n, groups, data);
+
+  n = group_common_shared_memory_tile(kernel, local->array,
+              n, groups, data);
+
+  set_array_groups(local, n, groups);
+
+  if (n >= 0)
+    return 0;
+
+  for (i = 0; i < local->array->n_ref; ++i)
+    gpu_array_ref_group_free(groups[i]);
+  return -1;
+}
+
+/* For each scalar in the input program, check if there are any
+ * order dependences active inside the current kernel, within
+ * the same iteration of "host_schedule".
+ * If so, mark the scalar as force_private so that it will be
+ * mapped to a register.
+ */
+static void check_scalar_live_ranges_in_host(struct ppcg_kernel *kernel,
+  __isl_take isl_union_map *host_schedule)
+{
+  int i;
+  isl_union_map *sched;
+  isl_union_set *domain;
+  isl_union_map *same_host_iteration;
+
+  kernel->any_force_private = 0;
+
+  sched = isl_union_map_universe(isl_union_map_copy(host_schedule));
+  domain = isl_union_map_domain(sched);
+
+  same_host_iteration = isl_union_map_apply_range(host_schedule,
+        isl_union_map_reverse(isl_union_map_copy(host_schedule)));
+
+  for (i = 0; i < kernel->n_array; ++i) {
+    struct gpu_local_array_info *local = &kernel->array[i];
+    isl_union_map *order;
+
+    local->force_private = 0;
+    if (local->array->n_index != 0)
+      continue;
+    order = isl_union_map_copy(local->array->dep_order);
+    order = isl_union_map_intersect_domain(order,
+                isl_union_set_copy(domain));
+    order = isl_union_map_intersect_range(order,
+                isl_union_set_copy(domain));
+    order = isl_union_map_intersect(order,
+            isl_union_map_copy(same_host_iteration));
+    if (!isl_union_map_is_empty(order)) {
+      local->force_private = 1;
+      kernel->any_force_private = 1;
+    }
+    isl_union_map_free(order);
+  }
+
+  isl_union_map_free(same_host_iteration);
+  isl_union_set_free(domain);
+}
+
+/* For each scalar in the input program, check if there are any
+ * order dependences active inside the current kernel, within
+ * the same iteration of the host schedule, i.e., the prefix
+ * schedule at "node".
+ * If so, mark the scalar as force_private so that it will be
+ * mapped to a register.
+ */
+static void check_scalar_live_ranges(struct ppcg_kernel *kernel,
+  __isl_keep isl_schedule_node *node)
+{
+  isl_union_map *sched;
+
+  if (!kernel->options->live_range_reordering)
+    return;
+
+  sched = isl_schedule_node_get_prefix_schedule_union_map(node);
+
+  check_scalar_live_ranges_in_host(kernel, sched);
+}
+
+/* Create a set of dimension data->thread_depth + data->n_thread
+ * that equates the residue of the final data->n_thread dimensions
+ * modulo the "sizes" to the thread identifiers.
+ * "space" is a parameter space containing the thread identifiers.
+ * Store the computed set in data->privatization.
+ */
+static void compute_privatization(struct gpu_group_data *data,
+  __isl_take isl_space *space, int *sizes)
+{
+  int i;
+  isl_ctx *ctx;
+  isl_local_space *ls;
+  isl_set *set;
+
+  ctx = isl_union_map_get_ctx(data->shared_sched);
+  space = isl_space_set_from_params(space);
+  space = isl_space_add_dims(space, isl_dim_set,
+            data->thread_depth + data->n_thread);
+  set = isl_set_universe(space);
+  space = isl_set_get_space(set);
+  ls = isl_local_space_from_space(space);
+
+  for (i = 0; i < data->n_thread; ++i) {
+    isl_aff *aff, *aff2;
+    isl_constraint *c;
+    isl_val *v;
+    char name[20];
+    int pos;
+
+    aff = isl_aff_var_on_domain(isl_local_space_copy(ls),
+          isl_dim_set, data->thread_depth + i);
+    v = isl_val_int_from_si(ctx, sizes[i]);
+    aff = isl_aff_mod_val(aff, v);
+    snprintf(name, sizeof(name), "t%d", i);
+    pos = isl_set_find_dim_by_name(set, isl_dim_param, name);
+    aff2 = isl_aff_var_on_domain(isl_local_space_copy(ls),
+          isl_dim_param, pos);
+    aff = isl_aff_sub(aff, aff2);
+    c = isl_equality_from_aff(aff);
+    set = isl_set_add_constraint(set, c);
+  }
+
+  isl_local_space_free(ls);
+  data->privatization = set;
+}
+
+/* Group references of all arrays in "kernel".
+ * "node" points to the kernel mark.
+ *
+ * We first extract all required schedule information into
+ * a gpu_group_data structure and then consider each array
+ * in turn.
+ */
+int gpu_group_references(struct ppcg_kernel *kernel,
+  __isl_keep isl_schedule_node *node)
+{
+  int i;
+  int r = 0;
+  isl_space *space;
+  struct gpu_group_data data;
+
+  check_scalar_live_ranges(kernel, node);
+
+  data.scop = kernel->prog->scop;
+
+  data.kernel_depth = isl_schedule_node_get_schedule_depth(node);
+  data.host_sched = isl_schedule_node_get_prefix_schedule_relation(node);
+
+  node = isl_schedule_node_copy(node);
+  node = gpu_tree_move_down_to_thread(node, kernel->core);
+  data.shared_sched =
+    isl_schedule_node_get_prefix_schedule_relation(node);
+  data.shared_sched = isl_union_map_detect_equalities(data.shared_sched);
+
+  node = isl_schedule_node_child(node, 0);
+  data.thread_depth = isl_schedule_node_get_schedule_depth(node);
+  data.n_thread = isl_schedule_node_band_n_member(node);
+  data.thread_sched = isl_union_map_copy(data.shared_sched);
+  data.thread_sched = isl_union_map_flat_range_product(data.thread_sched,
+    isl_schedule_node_band_get_partial_schedule_union_map(node));
+  data.thread_sched = isl_union_map_detect_equalities(data.thread_sched);
+  node = isl_schedule_node_child(node, 0);
+  data.full_sched = isl_union_map_copy(data.thread_sched);
+  data.full_sched = isl_union_map_flat_range_product(data.full_sched,
+    isl_schedule_node_get_subtree_schedule_union_map(node));
+  isl_schedule_node_free(node);
+
+  space = isl_union_set_get_space(kernel->thread_filter);
+  compute_privatization(&data, space, kernel->block_dim);
+
+  for (i = 0; i < kernel->n_array; ++i) {
+    r = group_array_references(kernel, &kernel->array[i], &data);
+    if (r < 0)
+      break;
+  }
+
+  isl_union_map_free(data.host_sched);
+  isl_union_map_free(data.shared_sched);
+  isl_union_map_free(data.thread_sched);
+  isl_union_map_free(data.full_sched);
+  isl_set_free(data.privatization);
+
+  return r;
+}
+
+/* Given a description of an array tile "tile" and the "space"
+ *
+ *  { D -> A }
+ *
+ * where D represents the first group->depth schedule dimensions
+ * and A represents the array, construct an isl_multi_aff
+ *
+ *  { [D[i] -> A[a]] -> A'[a'] }
+ *
+ * with A' a scaled down copy of A according to the shifts and strides
+ * in "tile".  In particular,
+ *
+ *  a' = (a + shift(i))/stride
+ *
+ * "insert_array" represents
+ *
+ *  { [D -> A] -> D }
+ *
+ * and is used to insert A into the domain of functions that only
+ * reference D.
+ */
+static __isl_give isl_multi_aff *strided_tile(
+  struct gpu_array_tile *tile, __isl_keep isl_space *space,
+  __isl_keep isl_multi_aff *insert_array)
+{
+  int i;
+  isl_ctx *ctx;
+  isl_multi_aff *shift;
+  isl_multi_val *stride;
+  isl_space *space2;
+  isl_local_space *ls;
+  isl_multi_aff *tiling;
+
+  ctx = isl_space_get_ctx(space);
+  space2 = isl_space_domain(isl_space_copy(space));
+  ls = isl_local_space_from_space(space2);
+  space2 = isl_space_range(isl_space_copy(space));
+  stride = isl_multi_val_zero(space2);
+  shift = isl_multi_aff_zero(isl_space_copy(space));
+
+  for (i = 0; i < tile->n; ++i) {
+    struct gpu_array_bound *bound = &tile->bound[i];
+    isl_val *stride_i;
+    isl_aff *shift_i;
+
+    if (tile->bound[i].shift) {
+      stride_i = isl_val_copy(bound->stride);
+      shift_i = isl_aff_copy(bound->shift);
+    } else {
+      stride_i = isl_val_one(ctx);
+      shift_i = isl_aff_zero_on_domain(
+          isl_local_space_copy(ls));
+    }
+
+    stride = isl_multi_val_set_val(stride, i, stride_i);
+    shift = isl_multi_aff_set_aff(shift, i, shift_i);
+  }
+  isl_local_space_free(ls);
+
+  shift = isl_multi_aff_pullback_multi_aff(shift,
+            isl_multi_aff_copy(insert_array));
+
+  tiling = isl_multi_aff_range_map(isl_space_copy(space));
+  tiling = isl_multi_aff_add(tiling, shift);
+  tiling = isl_multi_aff_scale_down_multi_val(tiling, stride);
+
+  return tiling;
+}
+
+/* Compute a tiling for the array reference group "group".
+ *
+ * The tiling is of the form
+ *
+ *  { [D[i] -> A[a]] -> T[t] }
+ *
+ * where D represents the first group->depth schedule dimensions,
+ * A represents the global array and T represents the shared or
+ * private memory tile.  The name of T is the name of the local
+ * array.
+ *
+ * If there is any stride in the accesses, then the mapping is
+ *
+ *  t = (a + shift(i))/stride - lb(i)
+ *
+ * otherwise, it is simply
+ *
+ *  t = a - lb(i)
+ */
+void gpu_array_ref_group_compute_tiling(struct gpu_array_ref_group *group)
+{
+  int i;
+  int dim;
+  struct gpu_array_tile *tile;
+  struct gpu_array_info *array = group->array;
+  isl_space *space;
+  isl_multi_aff *tiling, *lb, *insert_array;
+  isl_printer *p;
+  char *local_name;
+
+  tile = group->private_tile;
+  if (!tile)
+    tile = group->shared_tile;
+  if (!tile)
+    return;
+
+  space = isl_map_get_space(group->access);
+  dim = isl_space_dim(space, isl_dim_in);
+  space = isl_space_drop_dims(space, isl_dim_in, group->depth,
+              dim - group->depth);
+  insert_array = isl_multi_aff_domain_map(isl_space_copy(space));
+
+  for (i = 0; i < tile->n; ++i)
+    if (tile->bound[i].shift)
+      break;
+
+  if (i < tile->n)
+    tiling = strided_tile(tile, space, insert_array);
+  else
+    tiling = isl_multi_aff_range_map(isl_space_copy(space));
+
+  lb = isl_multi_aff_zero(space);
+  for (i = 0; i < tile->n; ++i) {
+    isl_aff *lb_i = isl_aff_copy(tile->bound[i].lb);
+    lb = isl_multi_aff_set_aff(lb, i, lb_i);
+  }
+  lb = isl_multi_aff_pullback_multi_aff(lb, insert_array);
+
+  tiling = isl_multi_aff_sub(tiling, lb);
+
+  p = isl_printer_to_str(isl_multi_aff_get_ctx(tiling));
+  p = gpu_array_ref_group_print_name(group, p);
+  local_name = isl_printer_get_str(p);
+  isl_printer_free(p);
+  tiling = isl_multi_aff_set_tuple_name(tiling, isl_dim_out, local_name);
+  free(local_name);
+
+  tile->tiling = tiling;
+}

polly/trunk/lib/External/ppcg/gpu_print.h

+#ifndef GPU_PRINT_H
+#define GPU_PRINT_H
+
+#include "gpu.h"
+
+__isl_give isl_printer *gpu_print_local_declarations(__isl_take isl_printer *p,
+  struct gpu_prog *prog);
+
+__isl_give isl_printer *gpu_print_types(__isl_take isl_printer *p,
+  struct gpu_types *types, struct gpu_prog *prog);
+
+__isl_give isl_printer *gpu_array_info_print_size(__isl_take isl_printer *prn,
+  struct gpu_array_info *array);
+__isl_give isl_printer *gpu_array_info_print_declaration_argument(
+  __isl_take isl_printer *p, struct gpu_array_info *array,
+  const char *memory_space);
+__isl_give isl_printer *gpu_array_info_print_call_argument(
+  __isl_take isl_printer *p, struct gpu_array_info *array);
+
+__isl_give isl_printer *ppcg_kernel_print_copy(__isl_take isl_printer *p,
+  struct ppcg_kernel_stmt *stmt);
+__isl_give isl_printer *ppcg_kernel_print_domain(__isl_take isl_printer *p,
+  struct ppcg_kernel_stmt *stmt);
+
+#endif

polly/trunk/lib/External/ppcg/gpu_print.c

+/*
+ * Copyright 2012      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
+ */
+
+#include <string.h>
+
+#include <isl/aff.h>
+
+#include "gpu_print.h"
+#include "print.h"
+#include "schedule.h"
+
+/* Print declarations to "p" for arrays that are local to "prog"
+ * but that are used on the host and therefore require a declaration.
+ */
+__isl_give isl_printer *gpu_print_local_declarations(__isl_take isl_printer *p,
+  struct gpu_prog *prog)
+{
+  int i;
+  isl_ast_build *build;
+
+  if (!prog)
+    return isl_printer_free(p);
+
+  build = isl_ast_build_from_context(isl_set_copy(prog->scop->context));
+  for (i = 0; i < prog->n_array; ++i) {
+    if (!prog->array[i].declare_local)
+      continue;
+    p = ppcg_print_declaration(p, prog->scop->pet->arrays[i],
+              build);
+  }
+  isl_ast_build_free(build);
+
+  return p;
+}
+
+/* Print an expression for the size of "array" in bytes.
+ */
+__isl_give isl_printer *gpu_array_info_print_size(__isl_take isl_printer *prn,
+  struct gpu_array_info *array)
+{
+  int i;
+
+  for (i = 0; i < array->n_index; ++i) {
+    prn = isl_printer_print_str(prn, "(");
+    prn = isl_printer_print_pw_aff(prn, array->bound[i]);
+    prn = isl_printer_print_str(prn, ") * ");
+  }
+  prn = isl_printer_print_str(prn, "sizeof(");
+  prn = isl_printer_print_str(prn, array->type);
+  prn = isl_printer_print_str(prn, ")");
+
+  return prn;
+}
+
+/* Print the declaration of a non-linearized array argument.
+ */
+static __isl_give isl_printer *print_non_linearized_declaration_argument(
+  __isl_take isl_printer *p, struct gpu_array_info *array)
+{
+  int i;
+
+  p = isl_printer_print_str(p, array->type);
+  p = isl_printer_print_str(p, " ");
+
+  p = isl_printer_print_str(p, array->name);
+
+  for (i = 0; i < array->n_index; i++) {
+    p = isl_printer_print_str(p, "[");
+    p = isl_printer_print_pw_aff(p, array->bound[i]);
+    p = isl_printer_print_str(p, "]");
+  }
+
+  return p;
+}
+
+/* Print the declaration of an array argument.
+ * "memory_space" allows to specify a memory space prefix.
+ */
+__isl_give isl_printer *gpu_array_info_print_declaration_argument(
+  __isl_take isl_printer *p, struct gpu_array_info *array,
+  const char *memory_space)
+{
+  if (gpu_array_is_read_only_scalar(array)) {
+    p = isl_printer_print_str(p, array->type);
+    p = isl_printer_print_str(p, " ");
+    p = isl_printer_print_str(p, array->name);
+    return p;
+  }
+
+  if (memory_space) {
+    p = isl_printer_print_str(p, memory_space);
+    p = isl_printer_print_str(p, " ");
+  }
+
+  if (array->n_index != 0 && !array->linearize)
+    return print_non_linearized_declaration_argument(p, array);
+
+  p = isl_printer_print_str(p, array->type);
+  p = isl_printer_print_str(p, " ");
+  p = isl_printer_print_str(p, "*");
+  p = isl_printer_print_str(p, array->name);
+
+  return p;
+}
+
+/* Print the call of an array argument.
+ */
+__isl_give isl_printer *gpu_array_info_print_call_argument(
+  __isl_take isl_printer *p, struct gpu_array_info *array)
+{
+  if (gpu_array_is_read_only_scalar(array))
+    return isl_printer_print_str(p, array->name);
+
+  p = isl_printer_print_str(p, "dev_");
+  p = isl_printer_print_str(p, array->name);
+
+  return p;
+}
+
+/* Print an access to the element in the private/shared memory copy
+ * described by "stmt".  The index of the copy is recorded in
+ * stmt->local_index as an access to the array.
+ */
+static __isl_give isl_printer *stmt_print_local_index(__isl_take isl_printer *p,
+  struct ppcg_kernel_stmt *stmt)
+{
+  return isl_printer_print_ast_expr(p, stmt->u.c.local_index);
+}
+
+/* Print an access to the element in the global memory copy
+ * described by "stmt".  The index of the copy is recorded in
+ * stmt->index as an access to the array.
+ *
+ * The copy in global memory has been linearized, so we need to take
+ * the array size into account.
+ */
+static __isl_give isl_printer *stmt_print_global_index(
+  __isl_take isl_printer *p, struct ppcg_kernel_stmt *stmt)
+{
+  int i;
+  struct gpu_array_info *array = stmt->u.c.array;
+  struct gpu_local_array_info *local = stmt->u.c.local_array;
+  isl_ast_expr *index;
+
+  if (gpu_array_is_scalar(array)) {
+    if (!gpu_array_is_read_only_scalar(array))
+      p = isl_printer_print_str(p, "*");
+    p = isl_printer_print_str(p, array->name);
+    return p;
+  }
+
+  index = isl_ast_expr_copy(stmt->u.c.index);
+  if (array->linearize)
+    index = gpu_local_array_info_linearize_index(local, index);
+
+  p = isl_printer_print_ast_expr(p, index);
+  isl_ast_expr_free(index);
+
+  return p;
+}
+
+/* Print a copy statement.
+ *
+ * A read copy statement is printed as
+ *
+ *  local = global;
+ *
+ * while a write copy statement is printed as
+ *
+ *  global = local;
+ */
+__isl_give isl_printer *ppcg_kernel_print_copy(__isl_take isl_printer *p,
+  struct ppcg_kernel_stmt *stmt)
+{
+  p = isl_printer_start_line(p);
+  if (stmt->u.c.read) {
+    p = stmt_print_local_index(p, stmt);
+    p = isl_printer_print_str(p, " = ");
+    p = stmt_print_global_index(p, stmt);
+  } else {
+    p = stmt_print_global_index(p, stmt);
+    p = isl_printer_print_str(p, " = ");
+    p = stmt_print_local_index(p, stmt);
+  }
+  p = isl_printer_print_str(p, ";");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+__isl_give isl_printer *ppcg_kernel_print_domain(__isl_take isl_printer *p,
+  struct ppcg_kernel_stmt *stmt)
+{
+  return pet_stmt_print_body(stmt->u.d.stmt->stmt, p, stmt->u.d.ref2expr);
+}
+
+/* Was the definition of "type" printed before?
+ * That is, does its name appear in the list of printed types "types"?
+ */
+static int already_printed(struct gpu_types *types,
+  struct pet_type *type)
+{
+  int i;
+
+  for (i = 0; i < types->n; ++i)
+    if (!strcmp(types->name[i], type->name))
+      return 1;
+
+  return 0;
+}
+
+/* Print the definitions of all types prog->scop that have not been
+ * printed before (according to "types") on "p".
+ * Extend the list of printed types "types" with the newly printed types.
+ */
+__isl_give isl_printer *gpu_print_types(__isl_take isl_printer *p,
+  struct gpu_types *types, struct gpu_prog *prog)
+{
+  int i, n;
+  isl_ctx *ctx;
+  char **name;
+
+  n = prog->scop->pet->n_type;
+
+  if (n == 0)
+    return p;
+
+  ctx = isl_printer_get_ctx(p);
+  name = isl_realloc_array(ctx, types->name, char *, types->n + n);
+  if (!name)
+    return isl_printer_free(p);
+  types->name = name;
+
+  for (i = 0; i < n; ++i) {
+    struct pet_type *type = prog->scop->pet->types[i];
+
+    if (already_printed(types, type))
+      continue;
+
+    p = isl_printer_start_line(p);
+    p = isl_printer_print_str(p, type->definition);
+    p = isl_printer_print_str(p, ";");
+    p = isl_printer_end_line(p);
+
+    types->name[types->n++] = strdup(type->name);
+  }
+
+  return p;
+}

polly/trunk/lib/External/ppcg/gpu_tree.h

+#ifndef GPU_TREE_H
+#define GPU_TREE_H
+
+#include <isl/schedule_node.h>
+
+#include "gpu.h"
+
+int gpu_tree_node_is_kernel(__isl_keep isl_schedule_node *node);
+__isl_give isl_schedule_node *gpu_tree_move_up_to_thread(
+  __isl_take isl_schedule_node *node);
+__isl_give isl_schedule_node *gpu_tree_move_down_to_thread(
+  __isl_take isl_schedule_node *node, __isl_keep isl_union_set *core);
+__isl_give isl_schedule_node *gpu_tree_move_up_to_kernel(
+  __isl_take isl_schedule_node *node);
+__isl_give isl_schedule_node *gpu_tree_move_down_to_depth(
+  __isl_take isl_schedule_node *node, int depth,
+  __isl_keep isl_union_set *core);
+
+int gpu_tree_id_is_sync(__isl_keep isl_id *id, struct ppcg_kernel *kernel);
+__isl_give isl_schedule_node *gpu_tree_ensure_sync_after_core(
+  __isl_take isl_schedule_node *node, struct ppcg_kernel *kernel);
+__isl_give isl_schedule_node *gpu_tree_ensure_following_sync(
+  __isl_take isl_schedule_node *node, struct ppcg_kernel *kernel);
+__isl_give isl_schedule_node *gpu_tree_move_left_to_sync(
+  __isl_take isl_schedule_node *node, struct ppcg_kernel *kernel);
+__isl_give isl_schedule_node *gpu_tree_move_right_to_sync(
+  __isl_take isl_schedule_node *node, struct ppcg_kernel *kernel);
+
+#endif

polly/trunk/lib/External/ppcg/gpu_tree.c

+/*
+ * Copyright 2013      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <string.h>
+
+#include <isl/set.h>
+#include <isl/union_set.h>
+
+#include "gpu_tree.h"
+
+/* The functions in this file are used to navigate part of a schedule tree
+ * that is mapped to blocks.  Initially, this part consists of a linear
+ * branch segment with a mark node with name "kernel" on the outer end
+ * and a mark node with name "thread" on the inner end.
+ * During the mapping to blocks, branching may be introduced, but only
+ * one of the elements in each sequence contains the "thread" mark.
+ * The filter of this element (and only this filter) contains
+ * domain elements identified by the "core" argument of the functions
+ * that move down this tree.
+ *
+ * Synchronization statements have a name that starts with "sync" and
+ * a user pointer pointing to the kernel that contains the synchronization.
+ * The functions inserting or detecting synchronizations take a ppcg_kernel
+ * argument to be able to create or identify such statements.
+ * They may also use two fields in this structure, the "core" field
+ * to move around in the tree and the "n_sync" field to make sure that
+ * each synchronization has a different name (within the kernel).
+ */
+
+/* Is "node" a mark node with an identifier called "name"?
+ */
+static int is_marked(__isl_keep isl_schedule_node *node, const char *name)
+{
+  isl_id *mark;
+  int has_name;
+
+  if (!node)
+    return -1;
+
+  if (isl_schedule_node_get_type(node) != isl_schedule_node_mark)
+    return 0;
+
+  mark = isl_schedule_node_mark_get_id(node);
+  if (!mark)
+    return -1;
+
+  has_name = !strcmp(isl_id_get_name(mark), name);
+  isl_id_free(mark);
+
+  return has_name;
+}
+
+/* Is "node" a mark node with an identifier called "kernel"?
+ */
+int gpu_tree_node_is_kernel(__isl_keep isl_schedule_node *node)
+{
+  return is_marked(node, "kernel");
+}
+
+/* Is "node" a mark node with an identifier called "thread"?
+ */
+static int node_is_thread(__isl_keep isl_schedule_node *node)
+{
+  return is_marked(node, "thread");
+}
+
+/* Assuming "node" is a filter node, does it correspond to the branch
+ * that contains the "thread" mark, i.e., does it contain any elements
+ * in "core"?
+ */
+static int node_is_core(__isl_keep isl_schedule_node *node,
+  __isl_keep isl_union_set *core)
+{
+  int disjoint;
+  isl_union_set *filter;
+
+  filter = isl_schedule_node_filter_get_filter(node);
+  disjoint = isl_union_set_is_disjoint(filter, core);
+  isl_union_set_free(filter);
+  if (disjoint < 0)
+    return -1;
+
+  return !disjoint;
+}
+
+/* Move to the only child of "node" that has the "thread" mark as descendant,
+ * where the branch containing this mark is identified by the domain elements
+ * in "core".
+ *
+ * If "node" is not a sequence, then it only has one child and we move
+ * to that single child.
+ * Otherwise, we check each of the filters in the children, pick
+ * the one that corresponds to "core" and return a pointer to the child
+ * of the filter node.
+ */
+static __isl_give isl_schedule_node *core_child(
+  __isl_take isl_schedule_node *node, __isl_keep isl_union_set *core)
+{
+  int i, n;
+
+  if (isl_schedule_node_get_type(node) != isl_schedule_node_sequence)
+    return isl_schedule_node_child(node, 0);
+
+  n = isl_schedule_node_n_children(node);
+  for (i = 0; i < n; ++i) {
+    int is_core;
+
+    node = isl_schedule_node_child(node, i);
+    is_core = node_is_core(node, core);
+
+    if (is_core < 0)
+      return isl_schedule_node_free(node);
+    if (is_core)
+      return isl_schedule_node_child(node, 0);
+
+    node = isl_schedule_node_parent(node);
+  }
+
+  isl_die(isl_schedule_node_get_ctx(node), isl_error_internal,
+    "core child not found", return isl_schedule_node_free(node));
+}
+
+/* Move down the branch between "kernel" and "thread" until
+ * the "thread" mark is reached, where the branch containing the "thread"
+ * mark is identified by the domain elements in "core".
+ */
+__isl_give isl_schedule_node *gpu_tree_move_down_to_thread(
+  __isl_take isl_schedule_node *node, __isl_keep isl_union_set *core)
+{
+  int is_thread;
+
+  while ((is_thread = node_is_thread(node)) == 0)
+    node = core_child(node, core);
+  if (is_thread < 0)
+    node = isl_schedule_node_free(node);
+
+  return node;
+}
+
+/* Move up the tree underneath the "thread" mark until
+ * the "thread" mark is reached.
+ */
+__isl_give isl_schedule_node *gpu_tree_move_up_to_thread(
+  __isl_take isl_schedule_node *node)
+{
+  int is_thread;
+
+  while ((is_thread = node_is_thread(node)) == 0)
+    node = isl_schedule_node_parent(node);
+  if (is_thread < 0)
+    node = isl_schedule_node_free(node);
+
+  return node;
+}
+
+/* Move up the tree underneath the "kernel" mark until
+ * the "kernel" mark is reached.
+ */
+__isl_give isl_schedule_node *gpu_tree_move_up_to_kernel(
+  __isl_take isl_schedule_node *node)
+{
+  int is_kernel;
+
+  while ((is_kernel = gpu_tree_node_is_kernel(node)) == 0)
+    node = isl_schedule_node_parent(node);
+  if (is_kernel < 0)
+    node = isl_schedule_node_free(node);
+
+  return node;
+}
+
+/* Move down from the "kernel" mark (or at least a node with schedule
+ * depth smaller than or equal to "depth") to a band node at schedule
+ * depth "depth".  The "thread" mark is assumed to have a schedule
+ * depth greater than or equal to "depth".  The branch containing the
+ * "thread" mark is identified by the domain elements in "core".
+ *
+ * If the desired schedule depth is in the middle of band node,
+ * then the band node is split into two pieces, the second piece
+ * at the desired schedule depth.
+ */
+__isl_give isl_schedule_node *gpu_tree_move_down_to_depth(
+  __isl_take isl_schedule_node *node, int depth,
+  __isl_keep isl_union_set *core)
+{
+  int is_thread;
+
+  while (node && isl_schedule_node_get_schedule_depth(node) < depth) {
+    if (isl_schedule_node_get_type(node) ==
+                isl_schedule_node_band) {
+      int node_depth, node_dim;
+      node_depth = isl_schedule_node_get_schedule_depth(node);
+      node_dim = isl_schedule_node_band_n_member(node);
+      if (node_depth + node_dim > depth)
+        node = isl_schedule_node_band_split(node,
+              depth - node_depth);
+    }
+    node = core_child(node, core);
+  }
+  while ((is_thread = node_is_thread(node)) == 0 &&
+      isl_schedule_node_get_type(node) != isl_schedule_node_band)
+    node = core_child(node, core);
+  if (is_thread < 0)
+    node = isl_schedule_node_free(node);
+
+  return node;
+}
+
+/* Create a union set containing a single set with a tuple identifier
+ * called "syncX" and user pointer equal to "kernel".
+ */
+static __isl_give isl_union_set *create_sync_domain(struct ppcg_kernel *kernel)
+{
+  isl_space *space;
+  isl_id *id;
+  char name[40];
+
+  space = isl_space_set_alloc(kernel->ctx, 0, 0);
+  snprintf(name, sizeof(name), "sync%d", kernel->n_sync++);
+  id = isl_id_alloc(kernel->ctx, name, kernel);
+  space = isl_space_set_tuple_id(space, isl_dim_set, id);
+  return isl_union_set_from_set(isl_set_universe(space));
+}
+
+/* Is "id" the identifier of a synchronization statement inside "kernel"?
+ * That is, does its name start with "sync" and does it point to "kernel"?
+ */
+int gpu_tree_id_is_sync(__isl_keep isl_id *id, struct ppcg_kernel *kernel)
+{
+  const char *name;
+
+  name = isl_id_get_name(id);
+  if (!name)
+    return 0;
+  else if (strncmp(name, "sync", 4))
+    return 0;
+  return isl_id_get_user(id) == kernel;
+}
+
+/* Does "domain" consist of a single set with a tuple identifier
+ * corresponding to a synchronization for "kernel"?
+ */
+static int domain_is_sync(__isl_keep isl_union_set *domain,
+  struct ppcg_kernel *kernel)
+{
+  int is_sync;
+  isl_id *id;
+  isl_set *set;
+
+  if (isl_union_set_n_set(domain) != 1)
+    return 0;
+  set = isl_set_from_union_set(isl_union_set_copy(domain));
+  id = isl_set_get_tuple_id(set);
+  is_sync = gpu_tree_id_is_sync(id, kernel);
+  isl_id_free(id);
+  isl_set_free(set);
+
+  return is_sync;
+}
+
+/* Does "node" point to a filter selecting a synchronization statement
+ * for "kernel"?
+ */
+static int node_is_sync_filter(__isl_keep isl_schedule_node *node,
+  struct ppcg_kernel *kernel)
+{
+  int is_sync;
+  enum isl_schedule_node_type type;
+  isl_union_set *domain;
+
+  if (!node)
+    return -1;
+  type = isl_schedule_node_get_type(node);
+  if (type != isl_schedule_node_filter)
+    return 0;
+  domain = isl_schedule_node_filter_get_filter(node);
+  is_sync = domain_is_sync(domain, kernel);
+  isl_union_set_free(domain);
+
+  return is_sync;
+}
+
+/* Is "node" part of a sequence with a previous synchronization statement
+ * for "kernel"?
+ * That is, is the parent of "node" a filter such that there is
+ * a previous filter that picks out exactly such a synchronization statement?
+ */
+static int has_preceding_sync(__isl_keep isl_schedule_node *node,
+  struct ppcg_kernel *kernel)
+{
+  int found = 0;
+
+  node = isl_schedule_node_copy(node);
+  node = isl_schedule_node_parent(node);
+  while (!found && isl_schedule_node_has_previous_sibling(node)) {
+    node = isl_schedule_node_previous_sibling(node);
+    if (!node)
+      break;
+    found = node_is_sync_filter(node, kernel);
+  }
+  if (!node)
+    found = -1;
+  isl_schedule_node_free(node);
+
+  return found;
+}
+
+/* Is "node" part of a sequence with a subsequent synchronization statement
+ * for "kernel"?
+ * That is, is the parent of "node" a filter such that there is
+ * a subsequent filter that picks out exactly such a synchronization statement?
+ */
+static int has_following_sync(__isl_keep isl_schedule_node *node,
+  struct ppcg_kernel *kernel)
+{
+  int found = 0;
+
+  node = isl_schedule_node_copy(node);
+  node = isl_schedule_node_parent(node);
+  while (!found && isl_schedule_node_has_next_sibling(node)) {
+    node = isl_schedule_node_next_sibling(node);
+    if (!node)
+      break;
+    found = node_is_sync_filter(node, kernel);
+  }
+  if (!node)
+    found = -1;
+  isl_schedule_node_free(node);
+
+  return found;
+}
+
+/* Does the subtree rooted at "node" (which is a band node) contain
+ * any synchronization statement for "kernel" that precedes
+ * the core computation of "kernel" (identified by the elements
+ * in kernel->core)?
+ */
+static int has_sync_before_core(__isl_keep isl_schedule_node *node,
+  struct ppcg_kernel *kernel)
+{
+  int has_sync = 0;
+  int is_thread;
+
+  node = isl_schedule_node_copy(node);
+  while ((is_thread = node_is_thread(node)) == 0) {
+    node = core_child(node, kernel->core);
+    has_sync = has_preceding_sync(node, kernel);
+    if (has_sync < 0 || has_sync)
+      break;
+  }
+  if (is_thread < 0 || !node)
+    has_sync = -1;
+  isl_schedule_node_free(node);
+
+  return has_sync;
+}
+
+/* Does the subtree rooted at "node" (which is a band node) contain
+ * any synchronization statement for "kernel" that follows
+ * the core computation of "kernel" (identified by the elements
+ * in kernel->core)?
+ */
+static int has_sync_after_core(__isl_keep isl_schedule_node *node,
+  struct ppcg_kernel *kernel)
+{
+  int has_sync = 0;
+  int is_thread;
+
+  node = isl_schedule_node_copy(node);
+  while ((is_thread = node_is_thread(node)) == 0) {
+    node = core_child(node, kernel->core);
+    has_sync = has_following_sync(node, kernel);
+    if (has_sync < 0 || has_sync)
+      break;
+  }
+  if (is_thread < 0 || !node)
+    has_sync = -1;
+  isl_schedule_node_free(node);
+
+  return has_sync;
+}
+
+/* Insert (or extend) an extension on top of "node" that puts
+ * a synchronization node for "kernel" before "node".
+ * Return a pointer to the original node in the updated schedule tree.
+ */
+static __isl_give isl_schedule_node *insert_sync_before(
+  __isl_take isl_schedule_node *node, struct ppcg_kernel *kernel)
+{
+  isl_union_set *domain;
+  isl_schedule_node *graft;
+
+  if (!node)
+    return NULL;
+
+  domain = create_sync_domain(kernel);
+  graft = isl_schedule_node_from_domain(domain);
+  node = isl_schedule_node_graft_before(node, graft);
+
+  return node;
+}
+
+/* Insert (or extend) an extension on top of "node" that puts
+ * a synchronization node for "kernel" afater "node".
+ * Return a pointer to the original node in the updated schedule tree.
+ */
+static __isl_give isl_schedule_node *insert_sync_after(
+  __isl_take isl_schedule_node *node, struct ppcg_kernel *kernel)
+{
+  isl_union_set *domain;
+  isl_schedule_node *graft;
+
+  if (!node)
+    return NULL;
+
+  domain = create_sync_domain(kernel);
+  graft = isl_schedule_node_from_domain(domain);
+  node = isl_schedule_node_graft_after(node, graft);
+
+  return node;
+}
+
+/* Insert an extension on top of "node" that puts a synchronization node
+ * for "kernel" before "node" unless there already is
+ * such a synchronization node.
+ */
+__isl_give isl_schedule_node *gpu_tree_ensure_preceding_sync(
+  __isl_take isl_schedule_node *node, struct ppcg_kernel *kernel)
+{
+  int has_sync;
+
+  has_sync = has_preceding_sync(node, kernel);
+  if (has_sync < 0)
+    return isl_schedule_node_free(node);
+  if (has_sync)
+    return node;
+  return insert_sync_before(node, kernel);
+}
+
+/* Insert an extension on top of "node" that puts a synchronization node
+ * for "kernel" after "node" unless there already is
+ * such a synchronization node.
+ */
+__isl_give isl_schedule_node *gpu_tree_ensure_following_sync(
+  __isl_take isl_schedule_node *node, struct ppcg_kernel *kernel)
+{
+  int has_sync;
+
+  has_sync = has_following_sync(node, kernel);
+  if (has_sync < 0)
+    return isl_schedule_node_free(node);
+  if (has_sync)
+    return node;
+  return insert_sync_after(node, kernel);
+}
+
+/* Insert an extension on top of "node" that puts a synchronization node
+ * for "kernel" after "node" unless there already is such a sync node or
+ * "node" itself already * contains a synchronization node following
+ * the core computation of "kernel".
+ */
+__isl_give isl_schedule_node *gpu_tree_ensure_sync_after_core(
+  __isl_take isl_schedule_node *node, struct ppcg_kernel *kernel)
+{
+  int has_sync;
+
+  has_sync = has_sync_after_core(node, kernel);
+  if (has_sync < 0)
+    return isl_schedule_node_free(node);
+  if (has_sync)
+    return node;
+  has_sync = has_following_sync(node, kernel);
+  if (has_sync < 0)
+    return isl_schedule_node_free(node);
+  if (has_sync)
+    return node;
+  return insert_sync_after(node, kernel);
+}
+
+/* Move left in the sequence on top of "node" to a synchronization node
+ * for "kernel".
+ * If "node" itself contains a synchronization node preceding
+ * the core computation of "kernel", then return "node" itself.
+ * Otherwise, if "node" does not have a preceding synchronization node,
+ * then create one first.
+ */
+__isl_give isl_schedule_node *gpu_tree_move_left_to_sync(
+  __isl_take isl_schedule_node *node, struct ppcg_kernel *kernel)
+{
+  int has_sync;
+  int is_sync;
+
+  has_sync = has_sync_before_core(node, kernel);
+  if (has_sync < 0)
+    return isl_schedule_node_free(node);
+  if (has_sync)
+    return node;
+  node = gpu_tree_ensure_preceding_sync(node, kernel);
+  node = isl_schedule_node_parent(node);
+  while ((is_sync = node_is_sync_filter(node, kernel)) == 0)
+    node = isl_schedule_node_previous_sibling(node);
+  if (is_sync < 0)
+    node = isl_schedule_node_free(node);
+  node = isl_schedule_node_child(node, 0);
+
+  return node;
+}
+
+/* Move right in the sequence on top of "node" to a synchronization node
+ * for "kernel".
+ * If "node" itself contains a synchronization node following
+ * the core computation of "kernel", then return "node" itself.
+ * Otherwise, if "node" does not have a following synchronization node,
+ * then create one first.
+ */
+__isl_give isl_schedule_node *gpu_tree_move_right_to_sync(
+  __isl_take isl_schedule_node *node, struct ppcg_kernel *kernel)
+{
+  int has_sync;
+  int is_sync;
+
+  has_sync = has_sync_after_core(node, kernel);
+  if (has_sync < 0)
+    return isl_schedule_node_free(node);
+  if (has_sync)
+    return node;
+  node = gpu_tree_ensure_following_sync(node, kernel);
+  node = isl_schedule_node_parent(node);
+  while ((is_sync = node_is_sync_filter(node, kernel)) == 0)
+    node = isl_schedule_node_next_sibling(node);
+  if (is_sync < 0)
+    node = isl_schedule_node_free(node);
+  node = isl_schedule_node_child(node, 0);
+
+  return node;
+}

polly/trunk/lib/External/ppcg/install-sh

+#!/bin/sh
+# install - install a program, script, or datafile
+
+scriptversion=2011-01-19.21; # UTC
+
+# This originates from X11R5 (mit/util/scripts/install.sh), which was
+# later released in X11R6 (xc/config/util/install.sh) with the
+# following copyright and license.
+#
+# Copyright (C) 1994 X Consortium
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
+# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Except as contained in this notice, the name of the X Consortium shall not
+# be used in advertising or otherwise to promote the sale, use or other deal-
+# ings in this Software without prior written authorization from the X Consor-
+# tium.
+#
+#
+# FSF changes to this file are in the public domain.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# `make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.
+
+nl='
+'
+IFS=" "" $nl"
+
+# set DOITPROG to echo to test this script
+
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit=${DOITPROG-}
+if test -z "$doit"; then
+  doit_exec=exec
+else
+  doit_exec=$doit
+fi
+
+# Put in absolute file names if you don't have them in your path;
+# or use environment vars.
+
+chgrpprog=${CHGRPPROG-chgrp}
+chmodprog=${CHMODPROG-chmod}
+chownprog=${CHOWNPROG-chown}
+cmpprog=${CMPPROG-cmp}
+cpprog=${CPPROG-cp}
+mkdirprog=${MKDIRPROG-mkdir}
+mvprog=${MVPROG-mv}
+rmprog=${RMPROG-rm}
+stripprog=${STRIPPROG-strip}
+
+posix_glob='?'
+initialize_posix_glob='
+  test "$posix_glob" != "?" || {
+    if (set -f) 2>/dev/null; then
+      posix_glob=
+    else
+      posix_glob=:
+    fi
+  }
+'
+
+posix_mkdir=
+
+# Desired mode of installed file.
+mode=0755
+
+chgrpcmd=
+chmodcmd=$chmodprog
+chowncmd=
+mvcmd=$mvprog
+rmcmd="$rmprog -f"
+stripcmd=
+
+src=
+dst=
+dir_arg=
+dst_arg=
+
+copy_on_change=false
+no_target_directory=
+
+usage="\
+Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
+   or: $0 [OPTION]... SRCFILES... DIRECTORY
+   or: $0 [OPTION]... -t DIRECTORY SRCFILES...
+   or: $0 [OPTION]... -d DIRECTORIES...
+
+In the 1st form, copy SRCFILE to DSTFILE.
+In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
+In the 4th, create DIRECTORIES.
+
+Options:
+     --help     display this help and exit.
+     --version  display version info and exit.
+
+  -c            (ignored)
+  -C            install only if different (preserve the last data modification time)
+  -d            create directories instead of installing files.
+  -g GROUP      $chgrpprog installed files to GROUP.
+  -m MODE       $chmodprog installed files to MODE.
+  -o USER       $chownprog installed files to USER.
+  -s            $stripprog installed files.
+  -t DIRECTORY  install into DIRECTORY.
+  -T            report an error if DSTFILE is a directory.
+
+Environment variables override the default commands:
+  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
+  RMPROG STRIPPROG
+"
+
+while test $# -ne 0; do
+  case $1 in
+    -c) ;;
+
+    -C) copy_on_change=true;;
+
+    -d) dir_arg=true;;
+
+    -g) chgrpcmd="$chgrpprog $2"
+  shift;;
+
+    --help) echo "$usage"; exit $?;;
+
+    -m) mode=$2
+  case $mode in
+    *' '* | *'  '* | *'
+'*    | *'*'* | *'?'* | *'['*)
+      echo "$0: invalid mode: $mode" >&2
+      exit 1;;
+  esac
+  shift;;
+
+    -o) chowncmd="$chownprog $2"
+  shift;;
+
+    -s) stripcmd=$stripprog;;
+
+    -t) dst_arg=$2
+  # Protect names problematic for `test' and other utilities.
+  case $dst_arg in
+    -* | [=\(\)!]) dst_arg=./$dst_arg;;
+  esac
+  shift;;
+
+    -T) no_target_directory=true;;
+
+    --version) echo "$0 $scriptversion"; exit $?;;
+
+    --) shift
+  break;;
+
+    -*)  echo "$0: invalid option: $1" >&2
+  exit 1;;
+
+    *)  break;;
+  esac
+  shift
+done
+
+if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
+  # When -d is used, all remaining arguments are directories to create.
+  # When -t is used, the destination is already specified.
+  # Otherwise, the last argument is the destination.  Remove it from $@.
+  for arg
+  do
+    if test -n "$dst_arg"; then
+      # $@ is not empty: it contains at least $arg.
+      set fnord "$@" "$dst_arg"
+      shift # fnord
+    fi
+    shift # arg
+    dst_arg=$arg
+    # Protect names problematic for `test' and other utilities.
+    case $dst_arg in
+      -* | [=\(\)!]) dst_arg=./$dst_arg;;
+    esac
+  done
+fi
+
+if test $# -eq 0; then
+  if test -z "$dir_arg"; then
+    echo "$0: no input file specified." >&2
+    exit 1
+  fi
+  # It's OK to call `install-sh -d' without argument.
+  # This can happen when creating conditional directories.
+  exit 0
+fi
+
+if test -z "$dir_arg"; then
+  do_exit='(exit $ret); exit $ret'
+  trap "ret=129; $do_exit" 1
+  trap "ret=130; $do_exit" 2
+  trap "ret=141; $do_exit" 13
+  trap "ret=143; $do_exit" 15
+
+  # Set umask so as not to create temps with too-generous modes.
+  # However, 'strip' requires both read and write access to temps.
+  case $mode in
+    # Optimize common cases.
+    *644) cp_umask=133;;
+    *755) cp_umask=22;;
+
+    *[0-7])
+      if test -z "$stripcmd"; then
+  u_plus_rw=
+      else
+  u_plus_rw='% 200'
+      fi
+      cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
+    *)
+      if test -z "$stripcmd"; then
+  u_plus_rw=
+      else
+  u_plus_rw=,u+rw
+      fi
+      cp_umask=$mode$u_plus_rw;;
+  esac
+fi
+
+for src
+do
+  # Protect names problematic for `test' and other utilities.
+  case $src in
+    -* | [=\(\)!]) src=./$src;;
+  esac
+
+  if test -n "$dir_arg"; then
+    dst=$src
+    dstdir=$dst
+    test -d "$dstdir"
+    dstdir_status=$?
+  else
+
+    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
+    # might cause directories to be created, which would be especially bad
+    # if $src (and thus $dsttmp) contains '*'.
+    if test ! -f "$src" && test ! -d "$src"; then
+      echo "$0: $src does not exist." >&2
+      exit 1
+    fi
+
+    if test -z "$dst_arg"; then
+      echo "$0: no destination specified." >&2
+      exit 1
+    fi
+    dst=$dst_arg
+
+    # If destination is a directory, append the input filename; won't work
+    # if double slashes aren't ignored.
+    if test -d "$dst"; then
+      if test -n "$no_target_directory"; then
+  echo "$0: $dst_arg: Is a directory" >&2
+  exit 1
+      fi
+      dstdir=$dst
+      dst=$dstdir/`basename "$src"`
+      dstdir_status=0
+    else
+      # Prefer dirname, but fall back on a substitute if dirname fails.
+      dstdir=`
+  (dirname "$dst") 2>/dev/null ||
+  expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+       X"$dst" : 'X\(//\)[^/]' \| \
+       X"$dst" : 'X\(//\)$' \| \
+       X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
+  echo X"$dst" |
+      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+       s//\1/
+       q
+     }
+     /^X\(\/\/\)[^/].*/{
+       s//\1/
+       q
+     }
+     /^X\(\/\/\)$/{
+       s//\1/
+       q
+     }
+     /^X\(\/\).*/{
+       s//\1/
+       q
+     }
+     s/.*/./; q'
+      `
+
+      test -d "$dstdir"
+      dstdir_status=$?
+    fi
+  fi
+
+  obsolete_mkdir_used=false
+
+  if test $dstdir_status != 0; then
+    case $posix_mkdir in
+      '')
+  # Create intermediate dirs using mode 755 as modified by the umask.
+  # This is like FreeBSD 'install' as of 1997-10-28.
+  umask=`umask`
+  case $stripcmd.$umask in
+    # Optimize common cases.
+    *[2367][2367]) mkdir_umask=$umask;;
+    .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
+
+    *[0-7])
+      mkdir_umask=`expr $umask + 22 \
+        - $umask % 100 % 40 + $umask % 20 \
+        - $umask % 10 % 4 + $umask % 2
+      `;;
+    *) mkdir_umask=$umask,go-w;;
+  esac
+
+  # With -d, create the new directory with the user-specified mode.
+  # Otherwise, rely on $mkdir_umask.
+  if test -n "$dir_arg"; then
+    mkdir_mode=-m$mode
+  else
+    mkdir_mode=
+  fi
+
+  posix_mkdir=false
+  case $umask in
+    *[123567][0-7][0-7])
+      # POSIX mkdir -p sets u+wx bits regardless of umask, which
+      # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
+      ;;
+    *)
+      tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
+      trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
+
+      if (umask $mkdir_umask &&
+    exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
+      then
+        if test -z "$dir_arg" || {
+       # Check for POSIX incompatibilities with -m.
+       # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
+       # other-writeable bit of parent directory when it shouldn't.
+       # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
+       ls_ld_tmpdir=`ls -ld "$tmpdir"`
+       case $ls_ld_tmpdir in
+         d????-?r-*) different_mode=700;;
+         d????-?--*) different_mode=755;;
+         *) false;;
+       esac &&
+       $mkdirprog -m$different_mode -p -- "$tmpdir" && {
+         ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
+         test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
+       }
+     }
+        then posix_mkdir=:
+        fi
+        rmdir "$tmpdir/d" "$tmpdir"
+      else
+        # Remove any dirs left behind by ancient mkdir implementations.
+        rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
+      fi
+      trap '' 0;;
+  esac;;
+    esac
+
+    if
+      $posix_mkdir && (
+  umask $mkdir_umask &&
+  $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
+      )
+    then :
+    else
+
+      # The umask is ridiculous, or mkdir does not conform to POSIX,
+      # or it failed possibly due to a race condition.  Create the
+      # directory the slow way, step by step, checking for races as we go.
+
+      case $dstdir in
+  /*) prefix='/';;
+  [-=\(\)!]*) prefix='./';;
+  *)  prefix='';;
+      esac
+
+      eval "$initialize_posix_glob"
+
+      oIFS=$IFS
+      IFS=/
+      $posix_glob set -f
+      set fnord $dstdir
+      shift
+      $posix_glob set +f
+      IFS=$oIFS
+
+      prefixes=
+
+      for d
+      do
+  test X"$d" = X && continue
+
+  prefix=$prefix$d
+  if test -d "$prefix"; then
+    prefixes=
+  else
+    if $posix_mkdir; then
+      (umask=$mkdir_umask &&
+       $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
+      # Don't fail if two instances are running concurrently.
+      test -d "$prefix" || exit 1
+    else
+      case $prefix in
+        *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
+        *) qprefix=$prefix;;
+      esac
+      prefixes="$prefixes '$qprefix'"
+    fi
+  fi
+  prefix=$prefix/
+      done
+
+      if test -n "$prefixes"; then
+  # Don't fail if two instances are running concurrently.
+  (umask $mkdir_umask &&
+   eval "\$doit_exec \$mkdirprog $prefixes") ||
+    test -d "$dstdir" || exit 1
+  obsolete_mkdir_used=true
+      fi
+    fi
+  fi
+
+  if test -n "$dir_arg"; then
+    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
+    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
+    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
+      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
+  else
+
+    # Make a couple of temp file names in the proper directory.
+    dsttmp=$dstdir/_inst.$$_
+    rmtmp=$dstdir/_rm.$$_
+
+    # Trap to clean up those temp files at exit.
+    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
+
+    # Copy the file name to the temp name.
+    (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
+
+    # and set any options; do chmod last to preserve setuid bits.
+    #
+    # If any of these fail, we abort the whole thing.  If we want to
+    # ignore errors from any of these, just make sure not to ignore
+    # errors from the above "$doit $cpprog $src $dsttmp" command.
+    #
+    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
+    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
+    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
+    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
+
+    # If -C, don't bother to copy if it wouldn't change the file.
+    if $copy_on_change &&
+       old=`LC_ALL=C ls -dlL "$dst"  2>/dev/null` &&
+       new=`LC_ALL=C ls -dlL "$dsttmp"  2>/dev/null` &&
+
+       eval "$initialize_posix_glob" &&
+       $posix_glob set -f &&
+       set X $old && old=:$2:$4:$5:$6 &&
+       set X $new && new=:$2:$4:$5:$6 &&
+       $posix_glob set +f &&
+
+       test "$old" = "$new" &&
+       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
+    then
+      rm -f "$dsttmp"
+    else
+      # Rename the file to the real destination.
+      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
+
+      # The rename failed, perhaps because mv can't rename something else
+      # to itself, or perhaps because mv is so ancient that it does not
+      # support -f.
+      {
+  # Now remove or move aside any old file at destination location.
+  # We try this two ways since rm can't unlink itself on some
+  # systems and the destination file might be busy for other
+  # reasons.  In this case, the final cleanup might fail but the new
+  # file should still install successfully.
+  {
+    test ! -f "$dst" ||
+    $doit $rmcmd -f "$dst" 2>/dev/null ||
+    { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
+      { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
+    } ||
+    { echo "$0: cannot unlink or rename $dst" >&2
+      (exit 1); exit 1
+    }
+  } &&
+
+  # Now rename the file to the real destination.
+  $doit $mvcmd "$dsttmp" "$dst"
+      }
+    fi || exit 1
+
+    trap '' 0
+  fi
+done
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:

polly/trunk/lib/External/ppcg/m4/ax_check_opencl.m4

+# Check if OpenCL is available and that it supports a CPU device.
+# The check for a CPU device is the same check that is performed
+# by opencl_create_device in ocl_utilities.c
+AC_DEFUN([AX_CHECK_OPENCL], [
+  AC_SUBST(HAVE_OPENCL)
+  HAVE_OPENCL=no
+  AC_CHECK_HEADER([CL/opencl.h], [
+    AC_CHECK_LIB([OpenCL], [clGetPlatformIDs], [
+      SAVE_LIBS=$LIBS
+      LIBS="$LIBS -lOpenCL"
+      AC_MSG_CHECKING([for OpenCL CPU device])
+      AC_RUN_IFELSE([AC_LANG_PROGRAM(
+        [[#include <CL/opencl.h>]], [[
+  cl_platform_id platform;
+  cl_device_id dev;
+
+  if (clGetPlatformIDs(1, &platform, NULL) < 0)
+    return 1;
+  if (clGetDeviceIDs(platform, CL_DEVICE_TYPE_CPU, 1, &dev, NULL) < 0)
+    return 1;
+        ]])], [HAVE_OPENCL=yes])
+      AC_MSG_RESULT($HAVE_OPENCL)
+      LIBS=$SAVE_LIBS
+      ])])
+])

polly/trunk/lib/External/ppcg/m4/ax_check_openmp.m4

+# Check if $CC supports openmp.
+AC_DEFUN([AX_CHECK_OPENMP], [
+  AC_SUBST(HAVE_OPENMP)
+  HAVE_OPENMP=no
+  AC_MSG_CHECKING([for OpenMP support by $CC])
+  echo | $CC -x c - -fsyntax-only -fopenmp -Werror >/dev/null 2>/dev/null
+  if test $? -eq 0; then
+    HAVE_OPENMP=yes
+  fi
+])

polly/trunk/lib/External/ppcg/m4/ax_detect_git_head.m4

+AC_DEFUN([AX_DETECT_GIT_HEAD], [
+  AC_SUBST(GIT_HEAD_ID)
+  AC_SUBST(GIT_HEAD)
+  AC_SUBST(GIT_HEAD_VERSION)
+  if test -f $srcdir/.git/HEAD; then
+    GIT_HEAD="$srcdir/.git/index"
+    GIT_REPO="$srcdir/.git"
+    GIT_HEAD_ID=`GIT_DIR=$GIT_REPO git describe --always`
+  elif test -f $srcdir/GIT_HEAD_ID; then
+    GIT_HEAD_ID=`cat $srcdir/GIT_HEAD_ID`
+  else
+    mysrcdir=`(cd $srcdir; pwd)`
+    head=`basename $mysrcdir | sed -e 's/.*-//'`
+    head2=`echo $head | sed -e 's/[^0-9a-f]//'`
+    head3=`echo $head2 | sed -e 's/........................................//'`
+    if test "x$head3" = "x" -a "x$head" = "x$head2"; then
+      GIT_HEAD_ID="$head"
+    else
+      GIT_HEAD_ID="UNKNOWN"
+    fi
+  fi
+  if test -z "$GIT_REPO" ; then
+    GIT_HEAD_VERSION="$GIT_HEAD_ID"
+  else
+    GIT_HEAD_VERSION="\`GIT_DIR=$GIT_REPO git describe --always\`"
+  fi
+])

polly/trunk/lib/External/ppcg/m4/ax_submodule.m4

+AC_DEFUN([_AX_SUBMODULE],
+[
+
+m4_if(m4_bregexp($3,|,choice),choice,
+  [AC_ARG_WITH($2,
+    [AS_HELP_STRING([--with-$1=$3],
+        [Which $1 to use [default=$4]])])])
+case "system" in
+$3)
+  AC_ARG_WITH($2_prefix,
+        [AS_HELP_STRING([--with-$1-prefix=DIR],
+            [Prefix of $1 installation])])
+  AC_ARG_WITH($2_exec_prefix,
+        [AS_HELP_STRING([--with-$1-exec-prefix=DIR],
+            [Exec prefix of $1 installation])])
+esac
+m4_if(m4_bregexp($3,build,build),build,
+  [AC_ARG_WITH($2_builddir,
+    [AS_HELP_STRING([--with-$1-builddir=DIR],
+        [Location of $1 builddir])])])
+if test "x$with_$2_prefix" != "x" -a "x$with_$2_exec_prefix" = "x"; then
+  with_$2_exec_prefix=$with_$2_prefix
+fi
+if test "x$with_$2_prefix" != "x" -o "x$with_$2_exec_prefix" != "x"; then
+  if test "x$with_$2" != "x" -a "x$with_$2" != "xsystem"; then
+    AC_MSG_ERROR([Setting $with_$2_prefix implies use of system $1])
+  fi
+  with_$2="system"
+fi
+if test "x$with_$2_builddir" != "x"; then
+  if test "x$with_$2" != "x" -a "x$with_$2" != "xbuild"; then
+    AC_MSG_ERROR([Setting $with_$2_builddir implies use of build $1])
+  fi
+  with_$2="build"
+  $2_srcdir=`echo @abs_srcdir@ | $with_$2_builddir/config.status --file=-`
+  AC_MSG_NOTICE($1 sources in $$2_srcdir)
+fi
+if test "x$with_$2_exec_prefix" != "x"; then
+  export PKG_CONFIG_PATH="$with_$2_exec_prefix/lib/pkgconfig${PKG_CONFIG_PATH+:$PKG_CONFIG_PATH}"
+fi
+case "$with_$2" in
+$3)
+  ;;
+*)
+  case "$4" in
+  bundled)
+    if test -d $srcdir/.git -a \
+      -d $srcdir/$1 -a \
+      "`cd $srcdir; git submodule status $1 | cut -c1`" = '-'; then
+      AC_MSG_WARN([git repo detected, but submodule $1 not initialized])
+      AC_MSG_WARN([You may want to run])
+      AC_MSG_WARN([ git submodule init])
+      AC_MSG_WARN([ git submodule update])
+      AC_MSG_WARN([ sh autogen.sh])
+    fi
+    if test -f $srcdir/$1/configure; then
+      with_$2="bundled"
+    else
+      case "system" in
+      $3)
+        with_$2="system"
+        ;;
+      *)
+        with_$2="no"
+        ;;
+      esac
+    fi
+    ;;
+  *)
+    with_$2="$4"
+    ;;
+  esac
+  ;;
+esac
+AC_MSG_CHECKING([which $1 to use])
+AC_MSG_RESULT($with_$2)
+
+])
+
+AC_DEFUN([AX_SUBMODULE], [
+  _AX_SUBMODULE($1, m4_bpatsubst([$1],
+      [[^_abcdefghijklmnopqrstuvwxyz0123456789]],[_]), $2, $3)
+])

polly/trunk/lib/External/ppcg/m4/ltoptions.m4

+# Helper functions for option handling.                    -*- Autoconf -*-
+#
+#   Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation,
+#   Inc.
+#   Written by Gary V. Vaughan, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 7 ltoptions.m4
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])
+
+
+# _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME)
+# ------------------------------------------
+m4_define([_LT_MANGLE_OPTION],
+[[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])])
+
+
+# _LT_SET_OPTION(MACRO-NAME, OPTION-NAME)
+# ---------------------------------------
+# Set option OPTION-NAME for macro MACRO-NAME, and if there is a
+# matching handler defined, dispatch to it.  Other OPTION-NAMEs are
+# saved as a flag.
+m4_define([_LT_SET_OPTION],
+[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl
+m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]),
+        _LT_MANGLE_DEFUN([$1], [$2]),
+    [m4_warning([Unknown $1 option `$2'])])[]dnl
+])
+
+
+# _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET])
+# ------------------------------------------------------------
+# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
+m4_define([_LT_IF_OPTION],
+[m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])])
+
+
+# _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET)
+# -------------------------------------------------------
+# Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME
+# are set.
+m4_define([_LT_UNLESS_OPTIONS],
+[m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
+      [m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option),
+          [m4_define([$0_found])])])[]dnl
+m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3
+])[]dnl
+])
+
+
+# _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST)
+# ----------------------------------------
+# OPTION-LIST is a space-separated list of Libtool options associated
+# with MACRO-NAME.  If any OPTION has a matching handler declared with
+# LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about
+# the unknown option and exit.
+m4_defun([_LT_SET_OPTIONS],
+[# Set options
+m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
+    [_LT_SET_OPTION([$1], _LT_Option)])
+
+m4_if([$1],[LT_INIT],[
+  dnl
+  dnl Simply set some default values (i.e off) if boolean options were not
+  dnl specified:
+  _LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no
+  ])
+  _LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no
+  ])
+  dnl
+  dnl If no reference was made to various pairs of opposing options, then
+  dnl we run the default mode handler for the pair.  For example, if neither
+  dnl `shared' nor `disable-shared' was passed, we enable building of shared
+  dnl archives by default:
+  _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED])
+  _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC])
+  _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC])
+  _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install],
+         [_LT_ENABLE_FAST_INSTALL])
+  ])
+])# _LT_SET_OPTIONS
+
+
+## --------------------------------- ##
+## Macros to handle LT_INIT options. ##
+## --------------------------------- ##
+
+# _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME)
+# -----------------------------------------
+m4_define([_LT_MANGLE_DEFUN],
+[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])])
+
+
+# LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE)
+# -----------------------------------------------
+m4_define([LT_OPTION_DEFINE],
+[m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl
+])# LT_OPTION_DEFINE
+
+
+# dlopen
+# ------
+LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes
+])
+
+AU_DEFUN([AC_LIBTOOL_DLOPEN],
+[_LT_SET_OPTION([LT_INIT], [dlopen])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `dlopen' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], [])
+
+
+# win32-dll
+# ---------
+# Declare package support for building win32 dll's.
+LT_OPTION_DEFINE([LT_INIT], [win32-dll],
+[enable_win32_dll=yes
+
+case $host in
+*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*)
+  AC_CHECK_TOOL(AS, as, false)
+  AC_CHECK_TOOL(DLLTOOL, dlltool, false)
+  AC_CHECK_TOOL(OBJDUMP, objdump, false)
+  ;;
+esac
+
+test -z "$AS" && AS=as
+_LT_DECL([], [AS],      [1], [Assembler program])dnl
+
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+_LT_DECL([], [DLLTOOL], [1], [DLL creation program])dnl
+
+test -z "$OBJDUMP" && OBJDUMP=objdump
+_LT_DECL([], [OBJDUMP], [1], [Object dumper program])dnl
+])# win32-dll
+
+AU_DEFUN([AC_LIBTOOL_WIN32_DLL],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+_LT_SET_OPTION([LT_INIT], [win32-dll])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `win32-dll' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], [])
+
+
+# _LT_ENABLE_SHARED([DEFAULT])
+# ----------------------------
+# implement the --enable-shared flag, and supports the `shared' and
+# `disable-shared' LT_INIT options.
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_SHARED],
+[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([shared],
+    [AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@],
+  [build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_shared=yes ;;
+    no) enable_shared=no ;;
+    *)
+      enable_shared=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+  IFS="$lt_save_ifs"
+  if test "X$pkg" = "X$p"; then
+    enable_shared=yes
+  fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_shared=]_LT_ENABLE_SHARED_DEFAULT)
+
+    _LT_DECL([build_libtool_libs], [enable_shared], [0],
+  [Whether or not to build shared libraries])
+])# _LT_ENABLE_SHARED
+
+LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])])
+
+# Old names:
+AC_DEFUN([AC_ENABLE_SHARED],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared])
+])
+
+AC_DEFUN([AC_DISABLE_SHARED],
+[_LT_SET_OPTION([LT_INIT], [disable-shared])
+])
+
+AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)])
+AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_ENABLE_SHARED], [])
+dnl AC_DEFUN([AM_DISABLE_SHARED], [])
+
+
+
+# _LT_ENABLE_STATIC([DEFAULT])
+# ----------------------------
+# implement the --enable-static flag, and support the `static' and
+# `disable-static' LT_INIT options.
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_STATIC],
+[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([static],
+    [AS_HELP_STRING([--enable-static@<:@=PKGS@:>@],
+  [build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_static=yes ;;
+    no) enable_static=no ;;
+    *)
+     enable_static=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+  IFS="$lt_save_ifs"
+  if test "X$pkg" = "X$p"; then
+    enable_static=yes
+  fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_static=]_LT_ENABLE_STATIC_DEFAULT)
+
+    _LT_DECL([build_old_libs], [enable_static], [0],
+  [Whether or not to build static libraries])
+])# _LT_ENABLE_STATIC
+
+LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])])
+
+# Old names:
+AC_DEFUN([AC_ENABLE_STATIC],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static])
+])
+
+AC_DEFUN([AC_DISABLE_STATIC],
+[_LT_SET_OPTION([LT_INIT], [disable-static])
+])
+
+AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)])
+AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_ENABLE_STATIC], [])
+dnl AC_DEFUN([AM_DISABLE_STATIC], [])
+
+
+
+# _LT_ENABLE_FAST_INSTALL([DEFAULT])
+# ----------------------------------
+# implement the --enable-fast-install flag, and support the `fast-install'
+# and `disable-fast-install' LT_INIT options.
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_FAST_INSTALL],
+[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([fast-install],
+    [AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],
+    [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_fast_install=yes ;;
+    no) enable_fast_install=no ;;
+    *)
+      enable_fast_install=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+  IFS="$lt_save_ifs"
+  if test "X$pkg" = "X$p"; then
+    enable_fast_install=yes
+  fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT)
+
+_LT_DECL([fast_install], [enable_fast_install], [0],
+   [Whether or not to optimize for fast installation])dnl
+])# _LT_ENABLE_FAST_INSTALL
+
+LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])])
+
+# Old names:
+AU_DEFUN([AC_ENABLE_FAST_INSTALL],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the `fast-install' option into LT_INIT's first parameter.])
+])
+
+AU_DEFUN([AC_DISABLE_FAST_INSTALL],
+[_LT_SET_OPTION([LT_INIT], [disable-fast-install])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the `disable-fast-install' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], [])
+dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], [])
+
+
+# _LT_WITH_PIC([MODE])
+# --------------------
+# implement the --with-pic flag, and support the `pic-only' and `no-pic'
+# LT_INIT options.
+# MODE is either `yes' or `no'.  If omitted, it defaults to `both'.
+m4_define([_LT_WITH_PIC],
+[AC_ARG_WITH([pic],
+    [AS_HELP_STRING([--with-pic@<:@=PKGS@:>@],
+  [try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
+    [lt_p=${PACKAGE-default}
+    case $withval in
+    yes|no) pic_mode=$withval ;;
+    *)
+      pic_mode=default
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for lt_pkg in $withval; do
+  IFS="$lt_save_ifs"
+  if test "X$lt_pkg" = "X$lt_p"; then
+    pic_mode=yes
+  fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [pic_mode=default])
+
+test -z "$pic_mode" && pic_mode=m4_default([$1], [default])
+
+_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl
+])# _LT_WITH_PIC
+
+LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])])
+LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])])
+
+# Old name:
+AU_DEFUN([AC_LIBTOOL_PICMODE],
+[_LT_SET_OPTION([LT_INIT], [pic-only])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `pic-only' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_PICMODE], [])
+
+## ----------------- ##
+## LTDL_INIT Options ##
+## ----------------- ##
+
+m4_define([_LTDL_MODE], [])
+LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive],
+     [m4_define([_LTDL_MODE], [nonrecursive])])
+LT_OPTION_DEFINE([LTDL_INIT], [recursive],
+     [m4_define([_LTDL_MODE], [recursive])])
+LT_OPTION_DEFINE([LTDL_INIT], [subproject],
+     [m4_define([_LTDL_MODE], [subproject])])
+
+m4_define([_LTDL_TYPE], [])
+LT_OPTION_DEFINE([LTDL_INIT], [installable],
+     [m4_define([_LTDL_TYPE], [installable])])
+LT_OPTION_DEFINE([LTDL_INIT], [convenience],
+     [m4_define([_LTDL_TYPE], [convenience])])

polly/trunk/lib/External/ppcg/m4/ltsugar.m4

+# ltsugar.m4 -- libtool m4 base layer.                         -*-Autoconf-*-
+#
+# Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
+# Written by Gary V. Vaughan, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 6 ltsugar.m4
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])])
+
+
+# lt_join(SEP, ARG1, [ARG2...])
+# -----------------------------
+# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their
+# associated separator.
+# Needed until we can rely on m4_join from Autoconf 2.62, since all earlier
+# versions in m4sugar had bugs.
+m4_define([lt_join],
+[m4_if([$#], [1], [],
+       [$#], [2], [[$2]],
+       [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])])
+m4_define([_lt_join],
+[m4_if([$#$2], [2], [],
+       [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])])
+
+
+# lt_car(LIST)
+# lt_cdr(LIST)
+# ------------
+# Manipulate m4 lists.
+# These macros are necessary as long as will still need to support
+# Autoconf-2.59 which quotes differently.
+m4_define([lt_car], [[$1]])
+m4_define([lt_cdr],
+[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])],
+       [$#], 1, [],
+       [m4_dquote(m4_shift($@))])])
+m4_define([lt_unquote], $1)
+
+
+# lt_append(MACRO-NAME, STRING, [SEPARATOR])
+# ------------------------------------------
+# Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'.
+# Note that neither SEPARATOR nor STRING are expanded; they are appended
+# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked).
+# No SEPARATOR is output if MACRO-NAME was previously undefined (different
+# than defined and empty).
+#
+# This macro is needed until we can rely on Autoconf 2.62, since earlier
+# versions of m4sugar mistakenly expanded SEPARATOR but not STRING.
+m4_define([lt_append],
+[m4_define([$1],
+     m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])])
+
+
+
+# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...])
+# ----------------------------------------------------------
+# Produce a SEP delimited list of all paired combinations of elements of
+# PREFIX-LIST with SUFFIX1 through SUFFIXn.  Each element of the list
+# has the form PREFIXmINFIXSUFFIXn.
+# Needed until we can rely on m4_combine added in Autoconf 2.62.
+m4_define([lt_combine],
+[m4_if(m4_eval([$# > 3]), [1],
+       [m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl
+[[m4_foreach([_Lt_prefix], [$2],
+       [m4_foreach([_Lt_suffix],
+    ]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[,
+  [_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])])
+
+
+# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ])
+# -----------------------------------------------------------------------
+# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited
+# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ.
+m4_define([lt_if_append_uniq],
+[m4_ifdef([$1],
+    [m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1],
+     [lt_append([$1], [$2], [$3])$4],
+     [$5])],
+    [lt_append([$1], [$2], [$3])$4])])
+
+
+# lt_dict_add(DICT, KEY, VALUE)
+# -----------------------------
+m4_define([lt_dict_add],
+[m4_define([$1($2)], [$3])])
+
+
+# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE)
+# --------------------------------------------
+m4_define([lt_dict_add_subkey],
+[m4_define([$1($2:$3)], [$4])])
+
+
+# lt_dict_fetch(DICT, KEY, [SUBKEY])
+# ----------------------------------
+m4_define([lt_dict_fetch],
+[m4_ifval([$3],
+  m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]),
+    m4_ifdef([$1($2)], [m4_defn([$1($2)])]))])
+
+
+# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE])
+# -----------------------------------------------------------------
+m4_define([lt_if_dict_fetch],
+[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4],
+  [$5],
+    [$6])])
+
+
+# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...])
+# --------------------------------------------------------------
+m4_define([lt_dict_filter],
+[m4_if([$5], [], [],
+  [lt_join(m4_quote(m4_default([$4], [[, ]])),
+           lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]),
+          [lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl
+])

polly/trunk/lib/External/ppcg/m4/ltversion.m4

+# ltversion.m4 -- version numbers     -*- Autoconf -*-
+#
+#   Copyright (C) 2004 Free Software Foundation, Inc.
+#   Written by Scott James Remnant, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# @configure_input@
+
+# serial 3337 ltversion.m4
+# This file is part of GNU Libtool
+
+m4_define([LT_PACKAGE_VERSION], [2.4.2])
+m4_define([LT_PACKAGE_REVISION], [1.3337])
+
+AC_DEFUN([LTVERSION_VERSION],
+[macro_version='2.4.2'
+macro_revision='1.3337'
+_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
+_LT_DECL(, macro_revision, 0)
+])

polly/trunk/lib/External/ppcg/m4/lt~obsolete.m4

+# lt~obsolete.m4 -- aclocal satisfying obsolete definitions.    -*-Autoconf-*-
+#
+#   Copyright (C) 2004, 2005, 2007, 2009 Free Software Foundation, Inc.
+#   Written by Scott James Remnant, 2004.
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 5 lt~obsolete.m4
+
+# These exist entirely to fool aclocal when bootstrapping libtool.
+#
+# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN)
+# which have later been changed to m4_define as they aren't part of the
+# exported API, or moved to Autoconf or Automake where they belong.
+#
+# The trouble is, aclocal is a bit thick.  It'll see the old AC_DEFUN
+# in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us
+# using a macro with the same name in our local m4/libtool.m4 it'll
+# pull the old libtool.m4 in (it doesn't see our shiny new m4_define
+# and doesn't know about Autoconf macros at all.)
+#
+# So we provide this file, which has a silly filename so it's always
+# included after everything else.  This provides aclocal with the
+# AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything
+# because those macros already exist, or will be overwritten later.
+# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6. 
+#
+# Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here.
+# Yes, that means every name once taken will need to remain here until
+# we give up compatibility with versions before 1.7, at which point
+# we need to keep only those names which we still refer to.
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])])
+
+m4_ifndef([AC_LIBTOOL_LINKER_OPTION], [AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])])
+m4_ifndef([AC_PROG_EGREP],    [AC_DEFUN([AC_PROG_EGREP])])
+m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])])
+m4_ifndef([_LT_AC_SHELL_INIT],    [AC_DEFUN([_LT_AC_SHELL_INIT])])
+m4_ifndef([_LT_AC_SYS_LIBPATH_AIX], [AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])])
+m4_ifndef([_LT_PROG_LTMAIN],    [AC_DEFUN([_LT_PROG_LTMAIN])])
+m4_ifndef([_LT_AC_TAGVAR],    [AC_DEFUN([_LT_AC_TAGVAR])])
+m4_ifndef([AC_LTDL_ENABLE_INSTALL], [AC_DEFUN([AC_LTDL_ENABLE_INSTALL])])
+m4_ifndef([AC_LTDL_PREOPEN],    [AC_DEFUN([AC_LTDL_PREOPEN])])
+m4_ifndef([_LT_AC_SYS_COMPILER],  [AC_DEFUN([_LT_AC_SYS_COMPILER])])
+m4_ifndef([_LT_AC_LOCK],    [AC_DEFUN([_LT_AC_LOCK])])
+m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE], [AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])])
+m4_ifndef([_LT_AC_TRY_DLOPEN_SELF], [AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])])
+m4_ifndef([AC_LIBTOOL_PROG_CC_C_O], [AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])])
+m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])])
+m4_ifndef([AC_LIBTOOL_OBJDIR],    [AC_DEFUN([AC_LIBTOOL_OBJDIR])])
+m4_ifndef([AC_LTDL_OBJDIR],   [AC_DEFUN([AC_LTDL_OBJDIR])])
+m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])])
+m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP], [AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])])
+m4_ifndef([AC_PATH_MAGIC],    [AC_DEFUN([AC_PATH_MAGIC])])
+m4_ifndef([AC_PROG_LD_GNU],   [AC_DEFUN([AC_PROG_LD_GNU])])
+m4_ifndef([AC_PROG_LD_RELOAD_FLAG], [AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])])
+m4_ifndef([AC_DEPLIBS_CHECK_METHOD],  [AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])])
+m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])])
+m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])])
+m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])])
+m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS],  [AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])])
+m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP],  [AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])])
+m4_ifndef([LT_AC_PROG_EGREP],   [AC_DEFUN([LT_AC_PROG_EGREP])])
+m4_ifndef([LT_AC_PROG_SED],   [AC_DEFUN([LT_AC_PROG_SED])])
+m4_ifndef([_LT_CC_BASENAME],    [AC_DEFUN([_LT_CC_BASENAME])])
+m4_ifndef([_LT_COMPILER_BOILERPLATE], [AC_DEFUN([_LT_COMPILER_BOILERPLATE])])
+m4_ifndef([_LT_LINKER_BOILERPLATE], [AC_DEFUN([_LT_LINKER_BOILERPLATE])])
+m4_ifndef([_AC_PROG_LIBTOOL],   [AC_DEFUN([_AC_PROG_LIBTOOL])])
+m4_ifndef([AC_LIBTOOL_SETUP],   [AC_DEFUN([AC_LIBTOOL_SETUP])])
+m4_ifndef([_LT_AC_CHECK_DLFCN],   [AC_DEFUN([_LT_AC_CHECK_DLFCN])])
+m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER],  [AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])])
+m4_ifndef([_LT_AC_TAGCONFIG],   [AC_DEFUN([_LT_AC_TAGCONFIG])])
+m4_ifndef([AC_DISABLE_FAST_INSTALL],  [AC_DEFUN([AC_DISABLE_FAST_INSTALL])])
+m4_ifndef([_LT_AC_LANG_CXX],    [AC_DEFUN([_LT_AC_LANG_CXX])])
+m4_ifndef([_LT_AC_LANG_F77],    [AC_DEFUN([_LT_AC_LANG_F77])])
+m4_ifndef([_LT_AC_LANG_GCJ],    [AC_DEFUN([_LT_AC_LANG_GCJ])])
+m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])])
+m4_ifndef([_LT_AC_LANG_C_CONFIG], [AC_DEFUN([_LT_AC_LANG_C_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])])
+m4_ifndef([_LT_AC_LANG_CXX_CONFIG], [AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])])
+m4_ifndef([_LT_AC_LANG_F77_CONFIG], [AC_DEFUN([_LT_AC_LANG_F77_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])])
+m4_ifndef([_LT_AC_LANG_GCJ_CONFIG], [AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG],  [AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])])
+m4_ifndef([_LT_AC_LANG_RC_CONFIG],  [AC_DEFUN([_LT_AC_LANG_RC_CONFIG])])
+m4_ifndef([AC_LIBTOOL_CONFIG],    [AC_DEFUN([AC_LIBTOOL_CONFIG])])
+m4_ifndef([_LT_AC_FILE_LTDLL_C],  [AC_DEFUN([_LT_AC_FILE_LTDLL_C])])
+m4_ifndef([_LT_REQUIRED_DARWIN_CHECKS], [AC_DEFUN([_LT_REQUIRED_DARWIN_CHECKS])])
+m4_ifndef([_LT_AC_PROG_CXXCPP],   [AC_DEFUN([_LT_AC_PROG_CXXCPP])])
+m4_ifndef([_LT_PREPARE_SED_QUOTE_VARS], [AC_DEFUN([_LT_PREPARE_SED_QUOTE_VARS])])
+m4_ifndef([_LT_PROG_ECHO_BACKSLASH],  [AC_DEFUN([_LT_PROG_ECHO_BACKSLASH])])
+m4_ifndef([_LT_PROG_F77],   [AC_DEFUN([_LT_PROG_F77])])
+m4_ifndef([_LT_PROG_FC],    [AC_DEFUN([_LT_PROG_FC])])
+m4_ifndef([_LT_PROG_CXX],   [AC_DEFUN([_LT_PROG_CXX])])

polly/trunk/lib/External/ppcg/missing

+#! /bin/sh
+# Common stub for a few missing GNU programs while installing.
+
+scriptversion=2012-01-06.13; # UTC
+
+# Copyright (C) 1996, 1997, 1999, 2000, 2002, 2003, 2004, 2005, 2006,
+# 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
+# Originally by Fran,cois Pinard <[e-mail]>, 1996.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+if test $# -eq 0; then
+  echo 1>&2 "Try \`$0 --help' for more information"
+  exit 1
+fi
+
+run=:
+sed_output='s/.* --output[ =]\([^ ]*\).*/\1/p'
+sed_minuso='s/.* -o \([^ ]*\).*/\1/p'
+
+# In the cases where this matters, `missing' is being run in the
+# srcdir already.
+if test -f configure.ac; then
+  configure_ac=configure.ac
+else
+  configure_ac=configure.in
+fi
+
+msg="missing on your system"
+
+case $1 in
+--run)
+  # Try to run requested program, and just exit if it succeeds.
+  run=
+  shift
+  "$@" && exit 0
+  # Exit code 63 means version mismatch.  This often happens
+  # when the user try to use an ancient version of a tool on
+  # a file that requires a minimum version.  In this case we
+  # we should proceed has if the program had been absent, or
+  # if --run hadn't been passed.
+  if test $? = 63; then
+    run=:
+    msg="probably too old"
+  fi
+  ;;
+
+  -h|--h|--he|--hel|--help)
+    echo "\
+$0 [OPTION]... PROGRAM [ARGUMENT]...
+
+Handle \`PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an
+error status if there is no known handling for PROGRAM.
+
+Options:
+  -h, --help      display this help and exit
+  -v, --version   output version information and exit
+  --run           try to run the given command, and emulate it if it fails
+
+Supported PROGRAM values:
+  aclocal      touch file \`aclocal.m4'
+  autoconf     touch file \`configure'
+  autoheader   touch file \`config.h.in'
+  autom4te     touch the output file, or create a stub one
+  automake     touch all \`Makefile.in' files
+  bison        create \`y.tab.[ch]', if possible, from existing .[ch]
+  flex         create \`lex.yy.c', if possible, from existing .c
+  help2man     touch the output file
+  lex          create \`lex.yy.c', if possible, from existing .c
+  makeinfo     touch the output file
+  yacc         create \`y.tab.[ch]', if possible, from existing .[ch]
+
+Version suffixes to PROGRAM as well as the prefixes \`gnu-', \`gnu', and
+\`g' are ignored when checking the name.
+
+Send bug reports to <[e-mail]>."
+    exit $?
+    ;;
+
+  -v|--v|--ve|--ver|--vers|--versi|--versio|--version)
+    echo "missing $scriptversion (GNU Automake)"
+    exit $?
+    ;;
+
+  -*)
+    echo 1>&2 "$0: Unknown \`$1' option"
+    echo 1>&2 "Try \`$0 --help' for more information"
+    exit 1
+    ;;
+
+esac
+
+# normalize program name to check for.
+program=`echo "$1" | sed '
+  s/^gnu-//; t
+  s/^gnu//; t
+  s/^g//; t'`
+
+# Now exit if we have it, but it failed.  Also exit now if we
+# don't have it and --version was passed (most likely to detect
+# the program).  This is about non-GNU programs, so use $1 not
+# $program.
+case $1 in
+  lex*|yacc*)
+    # Not GNU programs, they don't have --version.
+    ;;
+
+  *)
+    if test -z "$run" && ($1 --version) > /dev/null 2>&1; then
+       # We have it, but it failed.
+       exit 1
+    elif test "x$2" = "x--version" || test "x$2" = "x--help"; then
+       # Could not run --version or --help.  This is probably someone
+       # running `$TOOL --version' or `$TOOL --help' to check whether
+       # $TOOL exists and not knowing $TOOL uses missing.
+       exit 1
+    fi
+    ;;
+esac
+
+# If it does not exist, or fails to run (possibly an outdated version),
+# try to emulate it.
+case $program in
+  aclocal*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified \`acinclude.m4' or \`${configure_ac}'.  You might want
+         to install the \`Automake' and \`Perl' packages.  Grab them from
+         any GNU archive site."
+    touch aclocal.m4
+    ;;
+
+  autoconf*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified \`${configure_ac}'.  You might want to install the
+         \`Autoconf' and \`GNU m4' packages.  Grab them from any GNU
+         archive site."
+    touch configure
+    ;;
+
+  autoheader*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified \`acconfig.h' or \`${configure_ac}'.  You might want
+         to install the \`Autoconf' and \`GNU m4' packages.  Grab them
+         from any GNU archive site."
+    files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' ${configure_ac}`
+    test -z "$files" && files="config.h"
+    touch_files=
+    for f in $files; do
+      case $f in
+      *:*) touch_files="$touch_files "`echo "$f" |
+               sed -e 's/^[^:]*://' -e 's/:.*//'`;;
+      *) touch_files="$touch_files $f.in";;
+      esac
+    done
+    touch $touch_files
+    ;;
+
+  automake*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified \`Makefile.am', \`acinclude.m4' or \`${configure_ac}'.
+         You might want to install the \`Automake' and \`Perl' packages.
+         Grab them from any GNU archive site."
+    find . -type f -name Makefile.am -print |
+     sed 's/\.am$/.in/' |
+     while read f; do touch "$f"; done
+    ;;
+
+  autom4te*)
+    echo 1>&2 "\
+WARNING: \`$1' is needed, but is $msg.
+         You might have modified some files without having the
+         proper tools for further handling them.
+         You can get \`$1' as part of \`Autoconf' from any GNU
+         archive site."
+
+    file=`echo "$*" | sed -n "$sed_output"`
+    test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
+    if test -f "$file"; then
+  touch $file
+    else
+  test -z "$file" || exec >$file
+  echo "#! /bin/sh"
+  echo "# Created by GNU Automake missing as a replacement of"
+  echo "#  $ $@"
+  echo "exit 0"
+  chmod +x $file
+  exit 1
+    fi
+    ;;
+
+  bison*|yacc*)
+    echo 1>&2 "\
+WARNING: \`$1' $msg.  You should only need it if
+         you modified a \`.y' file.  You may need the \`Bison' package
+         in order for those modifications to take effect.  You can get
+         \`Bison' from any GNU archive site."
+    rm -f y.tab.c y.tab.h
+    if test $# -ne 1; then
+        eval LASTARG=\${$#}
+  case $LASTARG in
+  *.y)
+      SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'`
+      if test -f "$SRCFILE"; then
+           cp "$SRCFILE" y.tab.c
+      fi
+      SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'`
+      if test -f "$SRCFILE"; then
+           cp "$SRCFILE" y.tab.h
+      fi
+    ;;
+  esac
+    fi
+    if test ! -f y.tab.h; then
+  echo >y.tab.h
+    fi
+    if test ! -f y.tab.c; then
+  echo 'main() { return 0; }' >y.tab.c
+    fi
+    ;;
+
+  lex*|flex*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified a \`.l' file.  You may need the \`Flex' package
+         in order for those modifications to take effect.  You can get
+         \`Flex' from any GNU archive site."
+    rm -f lex.yy.c
+    if test $# -ne 1; then
+        eval LASTARG=\${$#}
+  case $LASTARG in
+  *.l)
+      SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'`
+      if test -f "$SRCFILE"; then
+           cp "$SRCFILE" lex.yy.c
+      fi
+    ;;
+  esac
+    fi
+    if test ! -f lex.yy.c; then
+  echo 'main() { return 0; }' >lex.yy.c
+    fi
+    ;;
+
+  help2man*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+   you modified a dependency of a manual page.  You may need the
+   \`Help2man' package in order for those modifications to take
+   effect.  You can get \`Help2man' from any GNU archive site."
+
+    file=`echo "$*" | sed -n "$sed_output"`
+    test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
+    if test -f "$file"; then
+  touch $file
+    else
+  test -z "$file" || exec >$file
+  echo ".ab help2man is required to generate this page"
+  exit $?
+    fi
+    ;;
+
+  makeinfo*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified a \`.texi' or \`.texinfo' file, or any other file
+         indirectly affecting the aspect of the manual.  The spurious
+         call might also be the consequence of using a buggy \`make' (AIX,
+         DU, IRIX).  You might want to install the \`Texinfo' package or
+         the \`GNU make' package.  Grab either from any GNU archive site."
+    # The file to touch is that specified with -o ...
+    file=`echo "$*" | sed -n "$sed_output"`
+    test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
+    if test -z "$file"; then
+      # ... or it is the one specified with @setfilename ...
+      infile=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'`
+      file=`sed -n '
+  /^@setfilename/{
+    s/.* \([^ ]*\) *$/\1/
+    p
+    q
+  }' $infile`
+      # ... or it is derived from the source name (dir/f.texi becomes f.info)
+      test -z "$file" && file=`echo "$infile" | sed 's,.*/,,;s,.[^.]*$,,'`.info
+    fi
+    # If the file does not exist, the user really needs makeinfo;
+    # let's fail without touching anything.
+    test -f $file || exit 1
+    touch $file
+    ;;
+
+  *)
+    echo 1>&2 "\
+WARNING: \`$1' is needed, and is $msg.
+         You might have modified some files without having the
+         proper tools for further handling them.  Check the \`README' file,
+         it often tells you about the needed prerequisites for installing
+         this package.  You may also peek at any GNU archive site, in case
+         some other package would contain this missing \`$1' program."
+    exit 1
+    ;;
+esac
+
+exit 0
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:

polly/trunk/lib/External/ppcg/ocl_utilities.h

+#ifndef OCL_UTILITIES_H
+#define OCL_UTILITIES_H
+
+#if defined(__APPLE__)
+#include <OpenCL/opencl.h>
+#else
+#include <CL/opencl.h>
+#endif
+
+/* Return the OpenCL error string for a given error number.
+ */
+const char *opencl_error_string(cl_int error);
+
+/* Find a GPU or a CPU associated with the first available platform.
+ * If use_gpu is set, then this function first tries to look for a GPU
+ * in the first available platform.
+ * If this fails or if use_gpu is not set, then it tries to use the CPU.
+ */
+cl_device_id opencl_create_device(int use_gpu);
+
+/* Create an OpenCL program from a string and compile it.
+ */
+cl_program opencl_build_program_from_string(cl_context ctx, cl_device_id dev,
+  const char *program_source, size_t program_size,
+  const char *opencl_options);
+
+/* Create an OpenCL program from a source file and compile it.
+ */
+cl_program opencl_build_program_from_file(cl_context ctx, cl_device_id dev,
+  const char* filename, const char* opencl_options);
+
+#endif

polly/trunk/lib/External/ppcg/ocl_utilities.c

+#include <stdio.h>
+#include <stdlib.h>
+#include "ocl_utilities.h"
+
+/* Return the OpenCL error string for a given error number.
+ */
+const char *opencl_error_string(cl_int error)
+{
+  int errorCount;
+  int index;
+
+  static const char *errorString[] = {
+    [CL_SUCCESS] = "CL_SUCCESS",
+    [-CL_DEVICE_NOT_FOUND] = "CL_DEVICE_NOT_FOUND",
+    [-CL_DEVICE_NOT_AVAILABLE] = "CL_DEVICE_NOT_AVAILABLE",
+    [-CL_COMPILER_NOT_AVAILABLE] = "CL_COMPILER_NOT_AVAILABLE",
+    [-CL_MEM_OBJECT_ALLOCATION_FAILURE] =
+      "CL_MEM_OBJECT_ALLOCATION_FAILURE",
+    [-CL_OUT_OF_RESOURCES] = "CL_OUT_OF_RESOURCES",
+    [-CL_OUT_OF_HOST_MEMORY] = "CL_OUT_OF_HOST_MEMORY",
+    [-CL_PROFILING_INFO_NOT_AVAILABLE] =
+      "CL_PROFILING_INFO_NOT_AVAILABLE",
+    [-CL_MEM_COPY_OVERLAP] = "CL_MEM_COPY_OVERLAP",
+    [-CL_IMAGE_FORMAT_MISMATCH] = "CL_IMAGE_FORMAT_MISMATCH",
+    [-CL_IMAGE_FORMAT_NOT_SUPPORTED] =
+      "CL_IMAGE_FORMAT_NOT_SUPPORTED",
+    [-CL_BUILD_PROGRAM_FAILURE] = "CL_BUILD_PROGRAM_FAILURE",
+    [-CL_MAP_FAILURE] = "CL_MAP_FAILURE",
+    [-CL_INVALID_VALUE] = "CL_INVALID_VALUE",
+    [-CL_INVALID_DEVICE_TYPE] = "CL_INVALID_DEVICE_TYPE",
+    [-CL_INVALID_PLATFORM] = "CL_INVALID_PLATFORM",
+    [-CL_INVALID_DEVICE] = "CL_INVALID_DEVICE",
+    [-CL_INVALID_CONTEXT] = "CL_INVALID_CONTEXT",
+    [-CL_INVALID_QUEUE_PROPERTIES] = "CL_INVALID_QUEUE_PROPERTIES",
+    [-CL_INVALID_COMMAND_QUEUE] = "CL_INVALID_COMMAND_QUEUE",
+    [-CL_INVALID_HOST_PTR] = "CL_INVALID_HOST_PTR",
+    [-CL_INVALID_MEM_OBJECT] = "CL_INVALID_MEM_OBJECT",
+    [-CL_INVALID_IMAGE_FORMAT_DESCRIPTOR] =
+      "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR",
+    [-CL_INVALID_IMAGE_SIZE] = "CL_INVALID_IMAGE_SIZE",
+    [-CL_INVALID_SAMPLER] = "CL_INVALID_SAMPLER",
+    [-CL_INVALID_BINARY] = "CL_INVALID_BINARY",
+    [-CL_INVALID_BUILD_OPTIONS] = "CL_INVALID_BUILD_OPTIONS",
+    [-CL_INVALID_PROGRAM] = "CL_INVALID_PROGRAM",
+    [-CL_INVALID_PROGRAM_EXECUTABLE] =
+      "CL_INVALID_PROGRAM_EXECUTABLE",
+    [-CL_INVALID_KERNEL_NAME] = "CL_INVALID_KERNEL_NAME",
+    [-CL_INVALID_KERNEL_DEFINITION] =
+      "CL_INVALID_KERNEL_DEFINITION",
+    [-CL_INVALID_KERNEL] = "CL_INVALID_KERNEL",
+    [-CL_INVALID_ARG_INDEX] = "CL_INVALID_ARG_INDEX",
+    [-CL_INVALID_ARG_VALUE] = "CL_INVALID_ARG_VALUE",
+    [-CL_INVALID_ARG_SIZE] = "CL_INVALID_ARG_SIZE",
+    [-CL_INVALID_KERNEL_ARGS] = "CL_INVALID_KERNEL_ARGS",
+    [-CL_INVALID_WORK_DIMENSION] = "CL_INVALID_WORK_DIMENSION",
+    [-CL_INVALID_WORK_GROUP_SIZE] = "CL_INVALID_WORK_GROUP_SIZE",
+    [-CL_INVALID_WORK_ITEM_SIZE] = "CL_INVALID_WORK_ITEM_SIZE",
+    [-CL_INVALID_GLOBAL_OFFSET] = "CL_INVALID_GLOBAL_OFFSET",
+    [-CL_INVALID_EVENT_WAIT_LIST] = "CL_INVALID_EVENT_WAIT_LIST",
+    [-CL_INVALID_EVENT] = "CL_INVALID_EVENT",
+    [-CL_INVALID_OPERATION] = "CL_INVALID_OPERATION",
+    [-CL_INVALID_GL_OBJECT] = "CL_INVALID_GL_OBJECT",
+    [-CL_INVALID_BUFFER_SIZE] = "CL_INVALID_BUFFER_SIZE",
+    [-CL_INVALID_MIP_LEVEL] = "CL_INVALID_MIP_LEVEL",
+    [-CL_INVALID_GLOBAL_WORK_SIZE] = "CL_INVALID_GLOBAL_WORK_SIZE",
+    [-CL_INVALID_PROPERTY] = "CL_INVALID_PROPERTY"
+  };
+
+  errorCount = sizeof(errorString) / sizeof(errorString[0]);
+  index = -error;
+
+  return (index >= 0 && index < errorCount) ?
+    errorString[index] : "Unspecified Error";
+}
+
+/* Find a GPU or a CPU associated with the first available platform.
+ * If use_gpu is set, then this function first tries to look for a GPU
+ * in the first available platform.
+ * If this fails or if use_gpu is not set, then it tries to use the CPU.
+ */
+cl_device_id opencl_create_device(int use_gpu)
+{
+  cl_platform_id platform;
+  cl_device_id dev;
+  int err;
+
+  err = clGetPlatformIDs(1, &platform, NULL);
+  if (err < 0) {
+    fprintf(stderr, "Error %s while looking for a platform.\n",
+        opencl_error_string(err));
+    exit(1);
+  }
+
+  err = CL_DEVICE_NOT_FOUND;
+  if (use_gpu)
+    err = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &dev,
+        NULL);
+  if (err == CL_DEVICE_NOT_FOUND)
+    err = clGetDeviceIDs(platform, CL_DEVICE_TYPE_CPU, 1, &dev,
+        NULL);
+  if (err < 0) {
+    fprintf(stderr, "Error %s while looking for a device.\n",
+        opencl_error_string(err));
+    exit(1);
+  }
+  return dev;
+}
+
+/* Create an OpenCL program from a string and compile it.
+ */
+cl_program opencl_build_program_from_string(cl_context ctx, cl_device_id dev,
+  const char *program_source, size_t program_size,
+  const char *opencl_options)
+{
+  int err;
+  cl_program program;
+  char *program_log;
+  size_t log_size;
+
+  program = clCreateProgramWithSource(ctx, 1,
+      &program_source, &program_size, &err);
+  if (err < 0) {
+    fprintf(stderr, "Could not create the program\n");
+    exit(1);
+  }
+  err = clBuildProgram(program, 0, NULL, opencl_options, NULL, NULL);
+  if (err < 0) {
+    fprintf(stderr, "Could not build the program.\n");
+    clGetProgramBuildInfo(program, dev, CL_PROGRAM_BUILD_LOG, 0,
+        NULL, &log_size);
+    program_log = (char *) malloc(log_size + 1);
+    program_log[log_size] = '\0';
+    clGetProgramBuildInfo(program, dev, CL_PROGRAM_BUILD_LOG,
+        log_size + 1, program_log, NULL);
+    fprintf(stderr, "%s\n", program_log);
+    free(program_log);
+    exit(1);
+  }
+  return program;
+}
+
+/* Create an OpenCL program from a source file and compile it.
+ */
+cl_program opencl_build_program_from_file(cl_context ctx, cl_device_id dev,
+  const char* filename, const char* opencl_options)
+{
+  cl_program program;
+  FILE *program_file;
+  char *program_source;
+  size_t program_size, read;
+
+  program_file = fopen(filename, "r");
+  if (program_file == NULL) {
+    fprintf(stderr, "Could not find the source file.\n");
+    exit(1);
+  }
+  fseek(program_file, 0, SEEK_END);
+  program_size = ftell(program_file);
+  rewind(program_file);
+  program_source = (char *) malloc(program_size + 1);
+  program_source[program_size] = '\0';
+  read = fread(program_source, sizeof(char), program_size, program_file);
+  if (read != program_size) {
+    fprintf(stderr, "Error while reading the kernel.\n");
+    exit(1);
+  }
+  fclose(program_file);
+
+  program = opencl_build_program_from_string(ctx, dev, program_source,
+            program_size, opencl_options);
+  free(program_source);
+
+  return program;
+}

polly/trunk/lib/External/ppcg/opencl.h

+#ifndef _OPENCL_H
+#define _OPENCL_H
+
+#include <pet.h>
+#include "ppcg_options.h"
+#include "ppcg.h"
+
+int generate_opencl(isl_ctx *ctx, struct ppcg_options *options,
+  const char *input, const char *output);
+
+#endif

polly/trunk/lib/External/ppcg/opencl.c

+/*
+ * Copyright 2013      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege and Riyadh Baghdadi,
+ * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
+ */
+
+#include <ctype.h>
+#include <limits.h>
+#include <string.h>
+
+#include <isl/aff.h>
+#include <isl/ast.h>
+
+#include "opencl.h"
+#include "gpu_print.h"
+#include "gpu.h"
+#include "ppcg.h"
+#include "print.h"
+#include "schedule.h"
+#include "util.h"
+
+#define min(a, b)  (((a) < (b)) ? (a) : (b))
+#define max(a, b)  (((a) > (b)) ? (a) : (b))
+
+/* options are the global options passed to generate_opencl.
+ * input is the name of the input file.
+ * output is the user-specified output file name and may be NULL
+ *  if not specified by the user.
+ * kernel_c_name is the name of the kernel_c file.
+ * kprinter is an isl_printer for the kernel file.
+ * host_c is the generated source file for the host code.  kernel_c is
+ * the generated source file for the kernel.
+ */
+struct opencl_info {
+  struct ppcg_options *options;
+  const char *input;
+  const char *output;
+  char kernel_c_name[PATH_MAX];
+
+  isl_printer *kprinter;
+
+  FILE *host_c;
+  FILE *kernel_c;
+};
+
+/* Open the file called "name" for writing or print an error message.
+ */
+static FILE *open_or_croak(const char *name)
+{
+  FILE *file;
+
+  file = fopen(name, "w");
+  if (!file)
+    fprintf(stderr, "Failed to open \"%s\" for writing\n", name);
+  return file;
+}
+
+/* Open the host .c file and the kernel .h and .cl files for writing.
+ * Their names are derived from info->output (or info->input if
+ * the user did not specify an output file name).
+ * Add the necessary includes to these files, including those specified
+ * by the user.
+ *
+ * Return 0 on success and -1 on failure.
+ */
+static int opencl_open_files(struct opencl_info *info)
+{
+  char name[PATH_MAX];
+  int i;
+  int len;
+
+  if (info->output) {
+    const char *ext;
+
+    ext = strrchr(info->output, '.');
+    len = ext ? ext - info->output : strlen(info->output);
+    memcpy(name, info->output, len);
+
+    info->host_c = open_or_croak(info->output);
+  } else {
+    len = ppcg_extract_base_name(name, info->input);
+
+    strcpy(name + len, "_host.c");
+    info->host_c = open_or_croak(name);
+  }
+
+  memcpy(info->kernel_c_name, name, len);
+  strcpy(info->kernel_c_name + len, "_kernel.cl");
+  info->kernel_c = open_or_croak(info->kernel_c_name);
+
+  if (!info->host_c || !info->kernel_c)
+    return -1;
+
+  fprintf(info->host_c, "#include <assert.h>\n");
+  fprintf(info->host_c, "#include <stdio.h>\n");
+  fprintf(info->host_c, "#include \"ocl_utilities.h\"\n");
+  if (info->options->opencl_embed_kernel_code) {
+    fprintf(info->host_c, "#include \"%s\"\n\n",
+      info->kernel_c_name);
+  }
+
+  for (i = 0; i < info->options->opencl_n_include_file; ++i) {
+    info->kprinter = isl_printer_print_str(info->kprinter,
+          "#include <");
+    info->kprinter = isl_printer_print_str(info->kprinter,
+          info->options->opencl_include_files[i]);
+    info->kprinter = isl_printer_print_str(info->kprinter, ">\n");
+  }
+
+  return 0;
+}
+
+/* Write text to a file and escape some special characters that would break a
+ * C string.
+ */
+static void opencl_print_escaped(const char *str, const char *end, FILE *file)
+{
+  const char *prev = str;
+
+  while ((str = strpbrk(prev, "\"\\")) && str < end) {
+    fwrite(prev, 1, str - prev, file);
+    fprintf(file, "\\%c", *str);
+    prev = str + 1;
+  }
+
+  if (*prev)
+    fwrite(prev, 1, end - prev, file);
+}
+
+/* Write text to a file as a C string literal.
+ *
+ * This function also prints any characters after the last newline, although
+ * normally the input string should end with a newline.
+ */
+static void opencl_print_as_c_string(const char *str, FILE *file)
+{
+  const char *prev = str;
+
+  while ((str = strchr(prev, '\n'))) {
+    fprintf(file, "\n\"");
+    opencl_print_escaped(prev, str, file);
+    fprintf(file, "\\n\"");
+
+    prev = str + 1;
+  }
+
+  if (*prev) {
+    fprintf(file, "\n\"");
+    opencl_print_escaped(prev, prev + strlen(prev), file);
+    fprintf(file, "\"");
+  }
+}
+
+/* Write the code that we have accumulated in the kernel isl_printer to the
+ * kernel.cl file.  If the opencl_embed_kernel_code option has been set, print
+ * the code as a C string literal.  Start that string literal with an empty
+ * line, such that line numbers reported by the OpenCL C compiler match those
+ * of the kernel file.
+ *
+ * Return 0 on success and -1 on failure.
+ */
+static int opencl_write_kernel_file(struct opencl_info *opencl)
+{
+  char *raw = isl_printer_get_str(opencl->kprinter);
+
+  if (!raw)
+    return -1;
+
+  if (opencl->options->opencl_embed_kernel_code) {
+    fprintf(opencl->kernel_c,
+      "static const char kernel_code[] = \"\\n\"");
+    opencl_print_as_c_string(raw, opencl->kernel_c);
+    fprintf(opencl->kernel_c, ";\n");
+  } else
+    fprintf(opencl->kernel_c, "%s", raw);
+
+  free(raw);
+
+  return 0;
+}
+
+/* Close all output files.  Write the kernel contents to the kernel file before
+ * closing it.
+ *
+ * Return 0 on success and -1 on failure.
+ */
+static int opencl_close_files(struct opencl_info *info)
+{
+  int r = 0;
+
+  if (info->kernel_c) {
+    r = opencl_write_kernel_file(info);
+    fclose(info->kernel_c);
+  }
+  if (info->host_c)
+    fclose(info->host_c);
+
+  return r;
+}
+
+static __isl_give isl_printer *opencl_print_host_macros(
+  __isl_take isl_printer *p)
+{
+  const char *macros =
+    "#define openclCheckReturn(ret) \\\n"
+    "  if (ret != CL_SUCCESS) {\\\n"
+    "    fprintf(stderr, \"OpenCL error: %s\\n\", "
+    "opencl_error_string(ret)); \\\n"
+    "    fflush(stderr); \\\n"
+    "    assert(ret == CL_SUCCESS);\\\n  }\n";
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, macros);
+  p = isl_printer_end_line(p);
+
+  p = isl_ast_op_type_print_macro(isl_ast_op_max, p);
+
+  return p;
+}
+
+static __isl_give isl_printer *opencl_declare_device_arrays(
+  __isl_take isl_printer *p, struct gpu_prog *prog)
+{
+  int i;
+
+  for (i = 0; i < prog->n_array; ++i) {
+    if (!gpu_array_requires_device_allocation(&prog->array[i]))
+      continue;
+    p = isl_printer_start_line(p);
+    p = isl_printer_print_str(p, "cl_mem dev_");
+    p = isl_printer_print_str(p, prog->array[i].name);
+    p = isl_printer_print_str(p, ";");
+    p = isl_printer_end_line(p);
+  }
+  p = isl_printer_start_line(p);
+  p = isl_printer_end_line(p);
+  return p;
+}
+
+/* Given an array, check whether its positive size guard expression is
+ * trivial.
+ */
+static int is_array_positive_size_guard_trivial(struct gpu_array_info *array)
+{
+  isl_set *guard;
+  int is_trivial;
+
+  guard = gpu_array_positive_size_guard(array);
+  is_trivial = isl_set_plain_is_universe(guard);
+  isl_set_free(guard);
+  return is_trivial;
+}
+
+/* Allocate a device array for "array'.
+ *
+ * Emit a max-expression to ensure the device array can contain at least one
+ * element if the array's positive size guard expression is not trivial.
+ */
+static __isl_give isl_printer *allocate_device_array(__isl_take isl_printer *p,
+  struct gpu_array_info *array)
+{
+  int need_lower_bound;
+
+  p = ppcg_start_block(p);
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "dev_");
+  p = isl_printer_print_str(p, array->name);
+  p = isl_printer_print_str(p, " = clCreateBuffer(context, ");
+  p = isl_printer_print_str(p, "CL_MEM_READ_WRITE, ");
+
+  need_lower_bound = !is_array_positive_size_guard_trivial(array);
+  if (need_lower_bound) {
+    p = isl_printer_print_str(p, "max(sizeof(");
+    p = isl_printer_print_str(p, array->type);
+    p = isl_printer_print_str(p, "), ");
+  }
+  p = gpu_array_info_print_size(p, array);
+  if (need_lower_bound)
+    p = isl_printer_print_str(p, ")");
+
+  p = isl_printer_print_str(p, ", NULL, &err);");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "openclCheckReturn(err);");
+  p = isl_printer_end_line(p);
+
+  p = ppcg_end_block(p);
+
+  return p;
+}
+
+/* Allocate accessed device arrays.
+ */
+static __isl_give isl_printer *opencl_allocate_device_arrays(
+  __isl_take isl_printer *p, struct gpu_prog *prog)
+{
+  int i;
+
+  for (i = 0; i < prog->n_array; ++i) {
+    struct gpu_array_info *array = &prog->array[i];
+
+    if (!gpu_array_requires_device_allocation(array))
+      continue;
+
+    p = allocate_device_array(p, array);
+  }
+  p = isl_printer_start_line(p);
+  p = isl_printer_end_line(p);
+  return p;
+}
+
+/* Print a call to the OpenCL clSetKernelArg() function which sets
+ * the arguments of the kernel.  arg_name and arg_index are the name and the
+ * index of the kernel argument.  The index of the leftmost argument of
+ * the kernel is 0 whereas the index of the rightmost argument of the kernel
+ * is n - 1, where n is the total number of the kernel arguments.
+ * read_only_scalar is a boolean that indicates whether the argument is a read
+ * only scalar.
+ */
+static __isl_give isl_printer *opencl_set_kernel_argument(
+  __isl_take isl_printer *p, int kernel_id,
+  const char *arg_name, int arg_index, int read_only_scalar)
+{
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p,
+    "openclCheckReturn(clSetKernelArg(kernel");
+  p = isl_printer_print_int(p, kernel_id);
+  p = isl_printer_print_str(p, ", ");
+  p = isl_printer_print_int(p, arg_index);
+  p = isl_printer_print_str(p, ", sizeof(");
+
+  if (read_only_scalar) {
+    p = isl_printer_print_str(p, arg_name);
+    p = isl_printer_print_str(p, "), &");
+  } else
+    p = isl_printer_print_str(p, "cl_mem), (void *) &dev_");
+
+  p = isl_printer_print_str(p, arg_name);
+  p = isl_printer_print_str(p, "));");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+/* Print the block sizes as a list of the sizes in each
+ * dimension.
+ */
+static __isl_give isl_printer *opencl_print_block_sizes(
+  __isl_take isl_printer *p, struct ppcg_kernel *kernel)
+{
+  int i;
+
+  if (kernel->n_block > 0)
+    for (i = 0; i < kernel->n_block; ++i) {
+      if (i)
+        p = isl_printer_print_str(p, ", ");
+      p = isl_printer_print_int(p, kernel->block_dim[i]);
+    }
+  else
+    p = isl_printer_print_str(p, "1");
+
+  return p;
+}
+
+/* Set the arguments of the OpenCL kernel by printing a call to the OpenCL
+ * clSetKernelArg() function for each kernel argument.
+ */
+static __isl_give isl_printer *opencl_set_kernel_arguments(
+  __isl_take isl_printer *p, struct gpu_prog *prog,
+  struct ppcg_kernel *kernel)
+{
+  int i, n, ro;
+  unsigned nparam;
+  isl_space *space;
+  int arg_index = 0;
+
+  for (i = 0; i < prog->n_array; ++i) {
+    int required;
+
+    required = ppcg_kernel_requires_array_argument(kernel, i);
+    if (required < 0)
+      return isl_printer_free(p);
+    if (!required)
+      continue;
+    ro = gpu_array_is_read_only_scalar(&prog->array[i]);
+    opencl_set_kernel_argument(p, kernel->id, prog->array[i].name,
+      arg_index, ro);
+    arg_index++;
+  }
+
+  space = isl_union_set_get_space(kernel->arrays);
+  nparam = isl_space_dim(space, isl_dim_param);
+  for (i = 0; i < nparam; ++i) {
+    const char *name;
+
+    name = isl_space_get_dim_name(space, isl_dim_param, i);
+    opencl_set_kernel_argument(p, kernel->id, name, arg_index, 1);
+    arg_index++;
+  }
+  isl_space_free(space);
+
+  n = isl_space_dim(kernel->space, isl_dim_set);
+  for (i = 0; i < n; ++i) {
+    const char *name;
+
+    name = isl_space_get_dim_name(kernel->space, isl_dim_set, i);
+    opencl_set_kernel_argument(p, kernel->id, name, arg_index, 1);
+    arg_index++;
+  }
+
+  return p;
+}
+
+/* Print the arguments to a kernel declaration or call.  If "types" is set,
+ * then print a declaration (including the types of the arguments).
+ *
+ * The arguments are printed in the following order
+ * - the arrays accessed by the kernel
+ * - the parameters
+ * - the host loop iterators
+ */
+static __isl_give isl_printer *opencl_print_kernel_arguments(
+  __isl_take isl_printer *p, struct gpu_prog *prog,
+  struct ppcg_kernel *kernel, int types)
+{
+  int i, n;
+  int first = 1;
+  unsigned nparam;
+  isl_space *space;
+  const char *type;
+
+  for (i = 0; i < prog->n_array; ++i) {
+    int required;
+
+    required = ppcg_kernel_requires_array_argument(kernel, i);
+    if (required < 0)
+      return isl_printer_free(p);
+    if (!required)
+      continue;
+
+    if (!first)
+      p = isl_printer_print_str(p, ", ");
+
+    if (types)
+      p = gpu_array_info_print_declaration_argument(p,
+        &prog->array[i], "__global");
+    else
+      p = gpu_array_info_print_call_argument(p,
+        &prog->array[i]);
+
+    first = 0;
+  }
+
+  space = isl_union_set_get_space(kernel->arrays);
+  nparam = isl_space_dim(space, isl_dim_param);
+  for (i = 0; i < nparam; ++i) {
+    const char *name;
+
+    name = isl_space_get_dim_name(space, isl_dim_param, i);
+
+    if (!first)
+      p = isl_printer_print_str(p, ", ");
+    if (types)
+      p = isl_printer_print_str(p, "int ");
+    p = isl_printer_print_str(p, name);
+
+    first = 0;
+  }
+  isl_space_free(space);
+
+  n = isl_space_dim(kernel->space, isl_dim_set);
+  type = isl_options_get_ast_iterator_type(prog->ctx);
+  for (i = 0; i < n; ++i) {
+    const char *name;
+
+    if (!first)
+      p = isl_printer_print_str(p, ", ");
+    name = isl_space_get_dim_name(kernel->space, isl_dim_set, i);
+    if (types) {
+      p = isl_printer_print_str(p, type);
+      p = isl_printer_print_str(p, " ");
+    }
+    p = isl_printer_print_str(p, name);
+
+    first = 0;
+  }
+
+  return p;
+}
+
+/* Print the header of the given kernel.
+ */
+static __isl_give isl_printer *opencl_print_kernel_header(
+  __isl_take isl_printer *p, struct gpu_prog *prog,
+  struct ppcg_kernel *kernel)
+{
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "__kernel void kernel");
+  p = isl_printer_print_int(p, kernel->id);
+  p = isl_printer_print_str(p, "(");
+  p = opencl_print_kernel_arguments(p, prog, kernel, 1);
+  p = isl_printer_print_str(p, ")");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+/* Print a list of iterators of type "type" with names "ids" to "p".
+ * Each iterator is assigned the corresponding opencl identifier returned
+ * by the function "opencl_id".
+ * Unlike the equivalent function in the CUDA backend which prints iterators
+ * in reverse order to promote coalescing, this function does not print
+ * iterators in reverse order.  The OpenCL backend currently does not take
+ * into account any coalescing considerations.
+ */
+static __isl_give isl_printer *print_iterators(__isl_take isl_printer *p,
+  const char *type, __isl_keep isl_id_list *ids, const char *opencl_id)
+{
+  int i, n;
+
+  n = isl_id_list_n_id(ids);
+  if (n <= 0)
+    return p;
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, type);
+  p = isl_printer_print_str(p, " ");
+  for (i = 0; i < n; ++i) {
+    isl_id *id;
+
+    if (i)
+      p = isl_printer_print_str(p, ", ");
+    id = isl_id_list_get_id(ids, i);
+    p = isl_printer_print_id(p, id);
+    isl_id_free(id);
+    p = isl_printer_print_str(p, " = ");
+    p = isl_printer_print_str(p, opencl_id);
+    p = isl_printer_print_str(p, "(");
+    p = isl_printer_print_int(p, i);
+    p = isl_printer_print_str(p, ")");
+  }
+  p = isl_printer_print_str(p, ";");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+static __isl_give isl_printer *opencl_print_kernel_iterators(
+  __isl_take isl_printer *p, struct ppcg_kernel *kernel)
+{
+  isl_ctx *ctx = isl_ast_node_get_ctx(kernel->tree);
+  const char *type;
+
+  type = isl_options_get_ast_iterator_type(ctx);
+
+  p = print_iterators(p, type, kernel->block_ids, "get_group_id");
+  p = print_iterators(p, type, kernel->thread_ids, "get_local_id");
+
+  return p;
+}
+
+static __isl_give isl_printer *opencl_print_kernel_var(
+  __isl_take isl_printer *p, struct ppcg_kernel_var *var)
+{
+  int j;
+  isl_val *v;
+
+  p = isl_printer_start_line(p);
+  if (var->type == ppcg_access_shared)
+    p = isl_printer_print_str(p, "__local ");
+  p = isl_printer_print_str(p, var->array->type);
+  p = isl_printer_print_str(p, " ");
+  p = isl_printer_print_str(p, var->name);
+  for (j = 0; j < var->array->n_index; ++j) {
+    p = isl_printer_print_str(p, "[");
+    v = isl_vec_get_element_val(var->size, j);
+    p = isl_printer_print_val(p, v);
+    p = isl_printer_print_str(p, "]");
+    isl_val_free(v);
+  }
+  p = isl_printer_print_str(p, ";");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+static __isl_give isl_printer *opencl_print_kernel_vars(
+    __isl_take isl_printer *p, struct ppcg_kernel *kernel)
+{
+  int i;
+
+  for (i = 0; i < kernel->n_var; ++i)
+    p = opencl_print_kernel_var(p, &kernel->var[i]);
+
+  return p;
+}
+
+/* Print a call to barrier() which is a sync statement.
+ * All work-items in a work-group executing the kernel on a processor must
+ * execute the barrier() function before any are allowed to continue execution
+ * beyond the barrier.
+ * The flag CLK_LOCAL_MEM_FENCE makes the barrier function either flush any
+ * variables stored in local memory or queue a memory fence to ensure correct
+ * ordering of memory operations to local memory.
+ * The flag CLK_GLOBAL_MEM_FENCE makes the barrier function queue a memory
+ * fence to ensure correct ordering of memory operations to global memory.
+ */
+static __isl_give isl_printer *opencl_print_sync(__isl_take isl_printer *p,
+  struct ppcg_kernel_stmt *stmt)
+{
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p,
+    "barrier(CLK_LOCAL_MEM_FENCE | CLK_GLOBAL_MEM_FENCE);");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+/* Data structure containing function names for which the calls
+ * should be changed from
+ *
+ *  name(arg)
+ *
+ * to
+ *
+ *  opencl_name((type) (arg))
+ */
+static struct ppcg_opencl_fn {
+  const char *name;
+  const char *opencl_name;
+  const char *type;
+} opencl_fn[] = {
+  { "expf", "exp",    "float" },
+  { "powf", "pow",    "float" },
+  { "sqrtf",  "sqrt",   "float" },
+};
+
+#define ARRAY_SIZE(array) (sizeof(array)/sizeof(*array))
+
+/* If the name of function called by "expr" matches any of those
+ * in ppcg_opencl_fn, then replace the call by a cast to the corresponding
+ * type in ppcg_opencl_fn and a call to corresponding OpenCL function.
+ */
+static __isl_give pet_expr *map_opencl_call(__isl_take pet_expr *expr,
+  void *user)
+{
+  const char *name;
+  int i;
+
+  name = pet_expr_call_get_name(expr);
+  for (i = 0; i < ARRAY_SIZE(opencl_fn); ++i) {
+    pet_expr *arg;
+
+    if (strcmp(name, opencl_fn[i].name))
+      continue;
+    expr = pet_expr_call_set_name(expr, opencl_fn[i].opencl_name);
+    arg = pet_expr_get_arg(expr, 0);
+    arg = pet_expr_new_cast(opencl_fn[i].type, arg);
+    expr = pet_expr_set_arg(expr, 0, arg);
+  }
+  return expr;
+}
+
+/* Print the body of a statement from the input program,
+ * for use in OpenCL code.
+ *
+ * Before calling ppcg_kernel_print_domain to print the actual statement body,
+ * we first modify this body to take into account that the output code
+ * is OpenCL code.  In particular, if the statement calls any function
+ * with a "f" suffix, then it needs to be replaced by a call to
+ * the corresponding function without suffix after casting the argument
+ * to a float.
+ */
+static __isl_give isl_printer *print_opencl_kernel_domain(
+  __isl_take isl_printer *p, struct ppcg_kernel_stmt *stmt)
+{
+  struct pet_stmt *ps;
+  pet_tree *tree;
+
+  ps = stmt->u.d.stmt->stmt;
+  tree = pet_tree_copy(ps->body);
+  ps->body = pet_tree_map_call_expr(ps->body, &map_opencl_call, NULL);
+  p = ppcg_kernel_print_domain(p, stmt);
+  pet_tree_free(ps->body);
+  ps->body = tree;
+
+  return p;
+}
+
+/* This function is called for each user statement in the AST,
+ * i.e., for each kernel body statement, copy statement or sync statement.
+ */
+static __isl_give isl_printer *opencl_print_kernel_stmt(
+  __isl_take isl_printer *p,
+  __isl_take isl_ast_print_options *print_options,
+  __isl_keep isl_ast_node *node, void *user)
+{
+  isl_id *id;
+  struct ppcg_kernel_stmt *stmt;
+
+  id = isl_ast_node_get_annotation(node);
+  stmt = isl_id_get_user(id);
+  isl_id_free(id);
+
+  isl_ast_print_options_free(print_options);
+
+  switch (stmt->type) {
+  case ppcg_kernel_copy:
+    return ppcg_kernel_print_copy(p, stmt);
+  case ppcg_kernel_sync:
+    return opencl_print_sync(p, stmt);
+  case ppcg_kernel_domain:
+    return print_opencl_kernel_domain(p, stmt);
+  }
+
+  return p;
+}
+
+/* Return true if there is a double array in prog->array or
+ * if any of the types in prog->scop involve any doubles.
+ * To check the latter condition, we simply search for the string "double"
+ * in the type definitions, which may result in false positives.
+ */
+static __isl_give int any_double_elements(struct gpu_prog *prog)
+{
+  int i;
+
+  for (i = 0; i < prog->n_array; ++i)
+    if (strcmp(prog->array[i].type, "double") == 0)
+      return 1;
+
+  for (i = 0; i < prog->scop->pet->n_type; ++i) {
+    struct pet_type *type = prog->scop->pet->types[i];
+
+    if (strstr(type->definition, "double"))
+      return 1;
+  }
+
+  return 0;
+}
+
+/* Prints a #pragma to enable support for double floating-point
+ * precision.  OpenCL 1.0 adds support for double precision floating-point as
+ * an optional extension. An application that wants to use double will need to
+ * include the #pragma OPENCL EXTENSION cl_khr_fp64 : enable directive before
+ * any double precision data type is declared in the kernel code.
+ */
+static __isl_give isl_printer *opencl_enable_double_support(
+  __isl_take isl_printer *p)
+{
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "#pragma OPENCL EXTENSION cl_khr_fp64 :"
+    " enable");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+static __isl_give isl_printer *opencl_print_kernel(struct gpu_prog *prog,
+  struct ppcg_kernel *kernel, __isl_take isl_printer *p)
+{
+  isl_ctx *ctx = isl_ast_node_get_ctx(kernel->tree);
+  isl_ast_print_options *print_options;
+
+  print_options = isl_ast_print_options_alloc(ctx);
+  print_options = isl_ast_print_options_set_print_user(print_options,
+        &opencl_print_kernel_stmt, NULL);
+
+  p = isl_printer_set_output_format(p, ISL_FORMAT_C);
+  p = opencl_print_kernel_header(p, prog, kernel);
+  p = isl_printer_print_str(p, "{");
+  p = isl_printer_end_line(p);
+  p = isl_printer_indent(p, 4);
+  p = opencl_print_kernel_iterators(p, kernel);
+  p = opencl_print_kernel_vars(p, kernel);
+  p = isl_printer_end_line(p);
+  p = isl_ast_op_type_print_macro(isl_ast_op_fdiv_q, p);
+  p = ppcg_print_macros(p, kernel->tree);
+  p = isl_ast_node_print(kernel->tree, p, print_options);
+  p = isl_printer_indent(p, -4);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "}");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+struct print_host_user_data_opencl {
+  struct opencl_info *opencl;
+  struct gpu_prog *prog;
+};
+
+/* This function prints the i'th block size multiplied by the i'th grid size,
+ * where i (a parameter to this function) is one of the possible dimensions of
+ * grid sizes and block sizes.
+ * If the dimension of block sizes is not equal to the dimension of grid sizes
+ * the output is calculated as follows:
+ *
+ * Suppose that:
+ * block_sizes[dim1] is the list of blocks sizes and it contains dim1 elements.
+ * grid_sizes[dim2] is the list of grid sizes and it contains dim2 elements.
+ *
+ * The output is:
+ * If (i > dim2) then the output is block_sizes[i]
+ * If (i > dim1) then the output is grid_sizes[i]
+ */
+static __isl_give isl_printer *opencl_print_total_number_of_work_items_for_dim(
+  __isl_take isl_printer *p, struct ppcg_kernel *kernel, int i)
+{
+  int grid_dim, block_dim;
+  isl_pw_aff *bound_grid;
+
+  grid_dim = isl_multi_pw_aff_dim(kernel->grid_size, isl_dim_set);
+  block_dim = kernel->n_block;
+
+  if (i < min(grid_dim, block_dim)) {
+    bound_grid = isl_multi_pw_aff_get_pw_aff(kernel->grid_size, i);
+    p = isl_printer_print_str(p, "(");
+    p = isl_printer_print_pw_aff(p, bound_grid);
+    p = isl_printer_print_str(p, ") * ");
+    p = isl_printer_print_int(p, kernel->block_dim[i]);
+    isl_pw_aff_free(bound_grid);
+  } else if (i >= grid_dim)
+    p = isl_printer_print_int(p, kernel->block_dim[i]);
+  else {
+    bound_grid = isl_multi_pw_aff_get_pw_aff(kernel->grid_size, i);
+    p = isl_printer_print_pw_aff(p, bound_grid);
+    isl_pw_aff_free(bound_grid);
+  }
+
+  return p;
+}
+
+/* Print a list that represents the total number of work items.  The list is
+ * constructed by performing an element-wise multiplication of the block sizes
+ * and the grid sizes.  To explain how the list is constructed, suppose that:
+ * block_sizes[dim1] is the list of blocks sizes and it contains dim1 elements.
+ * grid_sizes[dim2] is the list of grid sizes and it contains dim2 elements.
+ *
+ * The output of this function is constructed as follows:
+ * If (dim1 > dim2) then the output is the following list:
+ * grid_sizes[0]*block_sizes[0], ..., grid_sizes[dim2-1]*block_sizes[dim2-1],
+ * block_sizes[dim2], ..., block_sizes[dim1-2], block_sizes[dim1-1].
+ *
+ * If (dim2 > dim1) then the output is the following list:
+ * grid_sizes[0]*block_sizes[0], ..., grid_sizes[dim1-1] * block_sizes[dim1-1],
+ * grid_sizes[dim1], grid_sizes[dim2-2], grid_sizes[dim2-1].
+ *
+ * To calculate the total number of work items out of the list constructed by
+ * this function, the user should multiply the elements of the list.
+ */
+static __isl_give isl_printer *opencl_print_total_number_of_work_items_as_list(
+  __isl_take isl_printer *p, struct ppcg_kernel *kernel)
+{
+  int i;
+  int grid_dim, block_dim;
+
+  grid_dim = isl_multi_pw_aff_dim(kernel->grid_size, isl_dim_set);
+  block_dim = kernel->n_block;
+
+  if ((grid_dim <= 0) || (block_dim <= 0)) {
+    p = isl_printer_print_str(p, "1");
+    return p;
+  }
+
+  for (i = 0; i <= max(grid_dim, block_dim) - 1; i++) {
+    if (i > 0)
+      p = isl_printer_print_str(p, ", ");
+
+    p = opencl_print_total_number_of_work_items_for_dim(p,
+      kernel, i);
+  }
+
+  return p;
+}
+
+/* Copy "array" from the host to the device (to_host = 0) or
+ * back from the device to the host (to_host = 1).
+ */
+static __isl_give isl_printer *copy_array(__isl_take isl_printer *p,
+  struct gpu_array_info *array, int to_host)
+{
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "openclCheckReturn(");
+  if (to_host)
+    p = isl_printer_print_str(p, "clEnqueueReadBuffer");
+  else
+    p = isl_printer_print_str(p, "clEnqueueWriteBuffer");
+  p = isl_printer_print_str(p, "(queue, dev_");
+  p = isl_printer_print_str(p, array->name);
+  p = isl_printer_print_str(p, ", CL_TRUE, 0, ");
+  p = gpu_array_info_print_size(p, array);
+
+  if (gpu_array_is_scalar(array))
+    p = isl_printer_print_str(p, ", &");
+  else
+    p = isl_printer_print_str(p, ", ");
+  p = isl_printer_print_str(p, array->name);
+  p = isl_printer_print_str(p, ", 0, NULL, NULL));");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+/* Print a statement for copying an array to or from the device.
+ * The statement identifier is called "to_device_<array name>" or
+ * "from_device_<array name>" and its user pointer points
+ * to the gpu_array_info of the array that needs to be copied.
+ *
+ * Extract the array from the identifier and call
+ * copy_array_to_device or copy_array_from_device.
+ */
+static __isl_give isl_printer *print_to_from_device(__isl_take isl_printer *p,
+  __isl_keep isl_ast_node *node, struct gpu_prog *prog)
+{
+  isl_ast_expr *expr, *arg;
+  isl_id *id;
+  const char *name;
+  struct gpu_array_info *array;
+
+  expr = isl_ast_node_user_get_expr(node);
+  arg = isl_ast_expr_get_op_arg(expr, 0);
+  id = isl_ast_expr_get_id(arg);
+  name = isl_id_get_name(id);
+  array = isl_id_get_user(id);
+  isl_id_free(id);
+  isl_ast_expr_free(arg);
+  isl_ast_expr_free(expr);
+
+  if (!name)
+    array = NULL;
+  if (!array)
+    return isl_printer_free(p);
+
+  if (!prefixcmp(name, "to_device"))
+    return copy_array(p, array, 0);
+  else
+    return copy_array(p, array, 1);
+}
+
+/* Print the user statement of the host code to "p".
+ *
+ * The host code may contain original user statements, kernel launches and
+ * statements that copy data to/from the device.
+ * The original user statements and the kernel launches have
+ * an associated annotation, while the data copy statements do not.
+ * The latter are handled by print_to_from_device.
+ * The annotation on the user statements is called "user".
+ *
+ * In case of a kernel launch, print a block of statements that
+ * defines the grid and the work group and then launches the kernel.
+ *
+ * A grid is composed of many work groups (blocks), each work group holds
+ * many work-items (threads).
+ *
+ * global_work_size[kernel->n_block] represents the total number of work
+ * items.  It points to an array of kernel->n_block unsigned
+ * values that describe the total number of work-items that will execute
+ * the kernel.  The total number of work-items is computed as:
+ * global_work_size[0] *...* global_work_size[kernel->n_block - 1].
+ *
+ * The size of each work group (i.e. the number of work-items in each work
+ * group) is described using block_size[kernel->n_block].  The total
+ * number of work-items in a block (work-group) is computed as:
+ * block_size[0] *... * block_size[kernel->n_block - 1].
+ *
+ * For more information check:
+ * http://www.khronos.org/registry/cl/sdk/1.0/docs/man/xhtml/clEnqueueNDRangeKernel.html
+ */
+static __isl_give isl_printer *opencl_print_host_user(
+  __isl_take isl_printer *p,
+  __isl_take isl_ast_print_options *print_options,
+  __isl_keep isl_ast_node *node, void *user)
+{
+  isl_id *id;
+  int is_user;
+  struct ppcg_kernel *kernel;
+  struct ppcg_kernel_stmt *stmt;
+  struct print_host_user_data_opencl *data;
+
+  isl_ast_print_options_free(print_options);
+
+  data = (struct print_host_user_data_opencl *) user;
+
+  id = isl_ast_node_get_annotation(node);
+  if (!id)
+    return print_to_from_device(p, node, data->prog);
+
+  is_user = !strcmp(isl_id_get_name(id), "user");
+  kernel = is_user ? NULL : isl_id_get_user(id);
+  stmt = is_user ? isl_id_get_user(id) : NULL;
+  isl_id_free(id);
+
+  if (is_user)
+    return ppcg_kernel_print_domain(p, stmt);
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "{");
+  p = isl_printer_end_line(p);
+  p = isl_printer_indent(p, 2);
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "size_t global_work_size[");
+
+  if (kernel->n_block > 0)
+    p = isl_printer_print_int(p, kernel->n_block);
+  else
+    p = isl_printer_print_int(p, 1);
+
+  p = isl_printer_print_str(p, "] = {");
+  p = opencl_print_total_number_of_work_items_as_list(p, kernel);
+  p = isl_printer_print_str(p, "};");
+  p = isl_printer_end_line(p);
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "size_t block_size[");
+
+  if (kernel->n_block > 0)
+    p = isl_printer_print_int(p, kernel->n_block);
+  else
+    p = isl_printer_print_int(p, 1);
+
+  p = isl_printer_print_str(p, "] = {");
+  p = opencl_print_block_sizes(p, kernel);
+  p = isl_printer_print_str(p, "};");
+  p = isl_printer_end_line(p);
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "cl_kernel kernel");
+  p = isl_printer_print_int(p, kernel->id);
+  p = isl_printer_print_str(p, " = clCreateKernel(program, \"kernel");
+  p = isl_printer_print_int(p, kernel->id);
+  p = isl_printer_print_str(p, "\", &err);");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "openclCheckReturn(err);");
+  p = isl_printer_end_line(p);
+
+  opencl_set_kernel_arguments(p, data->prog, kernel);
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "openclCheckReturn(clEnqueueNDRangeKernel"
+    "(queue, kernel");
+  p = isl_printer_print_int(p, kernel->id);
+  p = isl_printer_print_str(p, ", ");
+  if (kernel->n_block > 0)
+    p = isl_printer_print_int(p, kernel->n_block);
+  else
+    p = isl_printer_print_int(p, 1);
+
+  p = isl_printer_print_str(p, ", NULL, global_work_size, "
+          "block_size, "
+          "0, NULL, NULL));");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "openclCheckReturn("
+          "clReleaseKernel(kernel");
+  p = isl_printer_print_int(p, kernel->id);
+  p = isl_printer_print_str(p, "));");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "clFinish(queue);");
+  p = isl_printer_end_line(p);
+  p = isl_printer_indent(p, -2);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "}");
+  p = isl_printer_end_line(p);
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_end_line(p);
+
+  data->opencl->kprinter = opencl_print_kernel(data->prog, kernel,
+            data->opencl->kprinter);
+
+  return p;
+}
+
+static __isl_give isl_printer *opencl_print_host_code(
+  __isl_take isl_printer *p, struct gpu_prog *prog,
+  __isl_keep isl_ast_node *tree, struct opencl_info *opencl)
+{
+  isl_ast_print_options *print_options;
+  isl_ctx *ctx = isl_ast_node_get_ctx(tree);
+  struct print_host_user_data_opencl data = { opencl, prog };
+
+  print_options = isl_ast_print_options_alloc(ctx);
+  print_options = isl_ast_print_options_set_print_user(print_options,
+        &opencl_print_host_user, &data);
+
+  p = ppcg_print_macros(p, tree);
+  p = isl_ast_node_print(tree, p, print_options);
+
+  return p;
+}
+
+/* Create an OpenCL device, context, command queue and build the kernel.
+ * input is the name of the input file provided to ppcg.
+ */
+static __isl_give isl_printer *opencl_setup(__isl_take isl_printer *p,
+  const char *input, struct opencl_info *info)
+{
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "cl_device_id device;");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "cl_context context;");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "cl_program program;");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "cl_command_queue queue;");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "cl_int err;");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "device = opencl_create_device(");
+  p = isl_printer_print_int(p, info->options->opencl_use_gpu);
+  p = isl_printer_print_str(p, ");");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "context = clCreateContext(NULL, 1, "
+    "&device, NULL, NULL, &err);");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "openclCheckReturn(err);");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "queue = clCreateCommandQueue"
+          "(context, device, 0, &err);");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "openclCheckReturn(err);");
+  p = isl_printer_end_line(p);
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "program = ");
+
+  if (info->options->opencl_embed_kernel_code) {
+    p = isl_printer_print_str(p, "opencl_build_program_from_string("
+            "context, device, kernel_code, "
+            "sizeof(kernel_code), \"");
+  } else {
+    p = isl_printer_print_str(p, "opencl_build_program_from_file("
+            "context, device, \"");
+    p = isl_printer_print_str(p, info->kernel_c_name);
+    p = isl_printer_print_str(p, "\", \"");
+  }
+
+  if (info->options->opencl_compiler_options)
+    p = isl_printer_print_str(p,
+          info->options->opencl_compiler_options);
+
+  p = isl_printer_print_str(p, "\");");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+static __isl_give isl_printer *opencl_release_cl_objects(
+  __isl_take isl_printer *p, struct opencl_info *info)
+{
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "openclCheckReturn(clReleaseCommandQueue"
+          "(queue));");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "openclCheckReturn(clReleaseProgram"
+          "(program));");
+  p = isl_printer_end_line(p);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "openclCheckReturn(clReleaseContext"
+          "(context));");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+/* Free the device array corresponding to "array"
+ */
+static __isl_give isl_printer *release_device_array(__isl_take isl_printer *p,
+  struct gpu_array_info *array)
+{
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "openclCheckReturn("
+          "clReleaseMemObject(dev_");
+  p = isl_printer_print_str(p, array->name);
+  p = isl_printer_print_str(p, "));");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+/* Free the accessed device arrays.
+ */
+static __isl_give isl_printer *opencl_release_device_arrays(
+  __isl_take isl_printer *p, struct gpu_prog *prog)
+{
+  int i;
+
+  for (i = 0; i < prog->n_array; ++i) {
+    struct gpu_array_info *array = &prog->array[i];
+    if (!gpu_array_requires_device_allocation(array))
+      continue;
+
+    p = release_device_array(p, array);
+  }
+  return p;
+}
+
+/* Given a gpu_prog "prog" and the corresponding transformed AST
+ * "tree", print the entire OpenCL code to "p".
+ */
+static __isl_give isl_printer *print_opencl(__isl_take isl_printer *p,
+  struct gpu_prog *prog, __isl_keep isl_ast_node *tree,
+  struct gpu_types *types, void *user)
+{
+  struct opencl_info *opencl = user;
+
+  opencl->kprinter = isl_printer_set_output_format(opencl->kprinter,
+              ISL_FORMAT_C);
+  if (any_double_elements(prog))
+    opencl->kprinter = opencl_enable_double_support(
+              opencl->kprinter);
+  if (opencl->options->opencl_print_kernel_types)
+    opencl->kprinter = gpu_print_types(opencl->kprinter, types,
+                prog);
+
+  if (!opencl->kprinter)
+    return isl_printer_free(p);
+
+  p = ppcg_start_block(p);
+
+  p = opencl_print_host_macros(p);
+
+  p = gpu_print_local_declarations(p, prog);
+  p = opencl_declare_device_arrays(p, prog);
+  p = opencl_setup(p, opencl->input, opencl);
+  p = opencl_allocate_device_arrays(p, prog);
+
+  p = opencl_print_host_code(p, prog, tree, opencl);
+
+  p = opencl_release_device_arrays(p, prog);
+  p = opencl_release_cl_objects(p, opencl);
+
+  p = ppcg_end_block(p);
+
+  return p;
+}
+
+/* Transform the code in the file called "input" by replacing
+ * all scops by corresponding OpenCL code.
+ * The host code is written to "output" or a name derived from
+ * "input" if "output" is NULL.
+ * The kernel code is placed in separate files with names
+ * derived from "output" or "input".
+ *
+ * We let generate_gpu do all the hard work and then let it call
+ * us back for printing the AST in print_opencl.
+ *
+ * To prepare for this printing, we first open the output files
+ * and we close them after generate_gpu has finished.
+ */
+int generate_opencl(isl_ctx *ctx, struct ppcg_options *options,
+  const char *input, const char *output)
+{
+  struct opencl_info opencl = { options, input, output };
+  int r;
+
+  opencl.kprinter = isl_printer_to_str(ctx);
+  r = opencl_open_files(&opencl);
+
+  if (r >= 0)
+    r = generate_gpu(ctx, input, opencl.host_c, options,
+        &print_opencl, &opencl);
+
+  if (opencl_close_files(&opencl) < 0)
+    r = -1;
+  isl_printer_free(opencl.kprinter);
+
+  return r;
+}

polly/trunk/lib/External/ppcg/opencl_test.sh.in

+#!/bin/sh
+
+keep=no
+
+for option; do
+  case "$option" in
+    --keep)
+      keep=yes
+      ;;
+  esac
+done
+
+EXEEXT=@EXEEXT@
+VERSION=@GIT_HEAD_VERSION@
+CC="@CC@"
+CFLAGS="--std=gnu99"
+srcdir="@srcdir@"
+
+if [ $keep = "yes" ]; then
+  OUTDIR="opencl_test.$VERSION"
+  mkdir "$OUTDIR" || exit 1
+else
+  if test "x$TMPDIR" = "x"; then
+    TMPDIR=/tmp
+  fi
+  OUTDIR=`mktemp -d $TMPDIR/ppcg.XXXXXXXXXX` || exit 1
+fi
+
+run_tests () {
+  subdir=$1
+  ppcg_options=$2
+
+  echo Test with PPCG options \'$ppcg_options\'
+  mkdir ${OUTDIR}/${subdir} || exit 1
+  for i in $srcdir/tests/*.c; do
+    echo $i
+    name=`basename $i`
+    name="${name%.c}"
+    out_c="${OUTDIR}/${subdir}/$name.ppcg.c"
+    out="${OUTDIR}/${subdir}/$name.ppcg$EXEEXT"
+    options="--target=opencl --opencl-no-use-gpu $ppcg_options"
+    functions="$srcdir/tests/${name}_opencl_functions.cl"
+    if test -f $functions; then
+      options="$options --opencl-include-file=$functions"
+      options="$options --opencl-compiler-options=-I."
+    fi
+    ./ppcg$EXEEXT $options $i -o "$out_c" || exit
+    $CC $CFLAGS -I "$srcdir" "$srcdir/ocl_utilities.c" -lOpenCL \
+      -I. "$out_c" -o "$out" || exit
+    $out || exit
+  done
+}
+
+run_tests default
+run_tests embed --opencl-embed-kernel-code
+
+if [ $keep = "no" ]; then
+  rm -r "${OUTDIR}"
+fi

polly/trunk/lib/External/ppcg/polybench_test.sh.in

+#!/bin/sh
+
+keep=no
+verbose=no
+
+for option; do
+  case "$option" in
+    --keep)
+      keep=yes
+      ;;
+    --verbose)
+      verbose=yes
+      ;;
+  esac
+done
+
+EXEEXT=@EXEEXT@
+DIR=@POLYBENCH_DIR@
+VERSION=@GIT_HEAD_VERSION@
+SIZE=-DMINI_DATASET
+CC="@CC@"
+HAVE_OPENCL=@HAVE_OPENCL@
+HAVE_OPENMP=@HAVE_OPENMP@
+srcdir="@srcdir@"
+if [ $keep = "yes" ]; then
+  OUTDIR="out.$VERSION"
+  mkdir "$OUTDIR" || exit 1
+else
+  if test "x$TMPDIR" = "x"; then
+    TMPDIR=/tmp
+  fi
+  OUTDIR=`mktemp -d $TMPDIR/ppcg.XXXXXXXXXX` || exit 1
+fi
+CPPFLAGS="-DPOLYBENCH_USE_C99_PROTO -DPOLYBENCH_DUMP_ARRAYS"
+CPPFLAGS="$CPPFLAGS $SIZE -I $DIR/utilities"
+CFLAGS="-lm --std=gnu99"
+
+echo "Running tests in folder ${OUTDIR}"
+
+run_tests () {
+  ext=$1
+
+  ppcg_options=$2
+  cc_options=$3
+
+  if [ "x$ppcg_options" = "x" ]; then
+    ppcg_option_str="none"
+  else
+    ppcg_option_str=$ppcg_options
+  fi
+
+  if [ "x$cc_options" = "x" ]; then
+    cc_option_str="none"
+  else
+    cc_option_str=$cc_options
+  fi
+
+  echo Test: $ext, ppcg options: $ppcg_option_str, CC options: $cc_option_str
+  for i in `cat $DIR/utilities/benchmark_list`; do
+    echo $i
+    name=`basename $i`
+    name=${name%.c}
+    source_opt="${OUTDIR}/$name.$ext.c"
+    prog_orig=${OUTDIR}/$name.orig${EXEEXT}
+    prog_opt=${OUTDIR}/$name.$ext${EXEEXT}
+    output_orig=${OUTDIR}/$name.orig.out
+    output_opt=${OUTDIR}/$name.$ext.out
+    dir=`dirname $i`
+    if [ $verbose = "yes" ]; then
+      echo ./ppcg$EXEEXT -I $DIR/$dir $DIR/$i \
+        $CPPFLAGS -o $source_opt $ppcg_options
+    fi
+    ./ppcg$EXEEXT -I $DIR/$dir $DIR/$i $CPPFLAGS \
+      -o $source_opt $ppcg_options || exit
+    $CC -I $DIR/$dir $CPPFLAGS $DIR/$i -o $prog_orig \
+      $DIR/utilities/polybench.c $CFLAGS
+    $prog_orig 2> $output_orig
+    if [ $verbose = "yes" ]; then
+      echo $CC -I $DIR/$dir $CPPFLAGS $source_opt \
+        -o $prog_opt $DIR/utilities/polybench.c \
+        $CFLAGS $cc_options
+    fi
+    $CC -I $DIR/$dir $CPPFLAGS $source_opt -o $prog_opt \
+      $DIR/utilities/polybench.c $CFLAGS $cc_options || exit
+
+    $prog_opt 2> $output_opt
+    cmp $output_orig $output_opt || exit
+  done
+}
+
+run_tests ppcg --target=c
+run_tests ppcg_live "--target=c --no-live-range-reordering"
+
+# Test OpenMP code, if compiler supports openmp
+if [ $HAVE_OPENMP = "yes" ]; then
+  run_tests ppcg_omp "--target=c --openmp" -fopenmp
+  echo Introduced `grep -R 'omp parallel' "${OUTDIR}" | wc -l` '"pragma omp parallel for"'
+else
+  echo Compiler does not support OpenMP. Skipping OpenMP tests.
+fi
+
+if [ $HAVE_OPENCL = "yes" ]; then
+  run_tests ppcg_opencl "--target=opencl --opencl-no-use-gpu" \
+        "-I $srcdir $srcdir/ocl_utilities.c -lOpenCL"
+fi
+
+if [ $keep = "no" ]; then
+  rm -r "${OUTDIR}"
+fi

polly/trunk/lib/External/ppcg/ppcg.h

+#ifndef PPCG_H
+#define PPCG_H
+
+#include <isl/schedule.h>
+#include <isl/set.h>
+#include <isl/union_set.h>
+#include <isl/union_map.h>
+#include <isl/id_to_ast_expr.h>
+#include <pet.h>
+
+#include "ppcg_options.h"
+
+const char *ppcg_base_name(const char *filename);
+int ppcg_extract_base_name(char *name, const char *input);
+
+/* Representation of the scop for use inside PPCG.
+ *
+ * "options" are the options specified by the user.
+ * Some fields in this structure may depend on some of the options.
+ *
+ * "start" and "end" are file offsets of the corresponding program text.
+ * "context" represents constraints on the parameters.
+ * "domain" is the union of all iteration domains.
+ * "call" contains the iteration domains of statements with a call expression.
+ * "reads" contains all potential read accesses.
+ * "tagged_reads" is the same as "reads", except that the domain is a wrapped
+ *  relation mapping an iteration domain to a reference identifier
+ * "live_in" contains the potential read accesses that potentially
+ *  have no corresponding writes in the scop.
+ * "may_writes" contains all potential write accesses.
+ * "tagged_may_writes" is the same as "may_writes", except that the domain
+ *  is a wrapped relation mapping an iteration domain
+ *  to a reference identifier
+ * "must_writes" contains all definite write accesses.
+ * "tagged_must_writes" is the same as "must_writes", except that the domain
+ *  is a wrapped relation mapping an iteration domain
+ *  to a reference identifier
+ * "live_out" contains the potential write accesses that are potentially
+ *  not killed by any kills or any other writes.
+ * "tagged_must_kills" contains all definite kill accesses with
+ *  a reference identifier in the domain.
+ *
+ * "tagger" maps tagged iteration domains to the corresponding untagged
+ *  iteration domain.
+ *
+ * "independence" is the union of all independence filters.
+ *
+ * "dep_flow" represents the potential flow dependences.
+ * "tagged_dep_flow" is the same as "dep_flow", except that both domain and
+ *  range are wrapped relations mapping an iteration domain to
+ *  a reference identifier.  May be NULL if not computed.
+ * "dep_false" represents the potential false (anti and output) dependences.
+ * "dep_forced" represents the validity constraints that should be enforced
+ *  even when live-range reordering is used.
+ *  In particular, these constraints ensure that all live-in
+ *  accesses remain live-in and that all live-out accesses remain live-out
+ *  and that multiple potential sources for the same read are
+ *  executed in the original order.
+ * "dep_order"/"tagged_dep_order" represents the order dependences between
+ *  the live range intervals in "dep_flow"/"tagged_dep_flow".
+ *  It is only used if the live_range_reordering
+ *  option is set.  Otherwise it is NULL.
+ *  If "dep_order" is used, then "dep_false" only contains a limited
+ *  set of anti and output dependences.
+ * "schedule" represents the (original) schedule.
+ *
+ * "names" contains all variable names that are in use by the scop.
+ * The names are mapped to a dummy value.
+ *
+ * "pet" is the original pet_scop.
+ */
+struct ppcg_scop {
+  struct ppcg_options *options;
+
+  unsigned start;
+  unsigned end;
+
+  isl_set *context;
+  isl_union_set *domain;
+  isl_union_set *call;
+  isl_union_map *tagged_reads;
+  isl_union_map *reads;
+  isl_union_map *live_in;
+  isl_union_map *tagged_may_writes;
+  isl_union_map *may_writes;
+  isl_union_map *tagged_must_writes;
+  isl_union_map *must_writes;
+  isl_union_map *live_out;
+  isl_union_map *tagged_must_kills;
+
+  isl_union_pw_multi_aff *tagger;
+
+  isl_union_map *independence;
+
+  isl_union_map *dep_flow;
+  isl_union_map *tagged_dep_flow;
+  isl_union_map *dep_false;
+  isl_union_map *dep_forced;
+  isl_union_map *dep_order;
+  isl_union_map *tagged_dep_order;
+  isl_schedule *schedule;
+
+  isl_id_to_ast_expr *names;
+
+  struct pet_scop *pet;
+};
+
+int ppcg_scop_any_hidden_declarations(struct ppcg_scop *scop);
+__isl_give isl_id_list *ppcg_scop_generate_names(struct ppcg_scop *scop,
+  int n, const char *prefix);
+
+int ppcg_transform(isl_ctx *ctx, const char *input, FILE *out,
+  struct ppcg_options *options,
+  __isl_give isl_printer *(*fn)(__isl_take isl_printer *p,
+    struct ppcg_scop *scop, void *user), void *user);
+
+#endif

polly/trunk/lib/External/ppcg/ppcg.c

+/*
+ * Copyright 2011      INRIA Saclay
+ * Copyright 2013      Ecole Normale Superieure
+ * Copyright 2015      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <isl/ctx.h>
+#include <isl/flow.h>
+#include <isl/options.h>
+#include <isl/schedule.h>
+#include <isl/ast_build.h>
+#include <isl/schedule.h>
+#include <pet.h>
+#include "ppcg.h"
+#include "ppcg_options.h"
+#include "cuda.h"
+#include "opencl.h"
+#include "cpu.h"
+
+struct options {
+  struct isl_options *isl;
+  struct pet_options *pet;
+  struct ppcg_options *ppcg;
+  char *input;
+  char *output;
+};
+
+const char *ppcg_version(void);
+static void print_version(void)
+{
+  printf("%s", ppcg_version());
+}
+
+ISL_ARGS_START(struct options, options_args)
+ISL_ARG_CHILD(struct options, isl, "isl", &isl_options_args, "isl options")
+ISL_ARG_CHILD(struct options, pet, "pet", &pet_options_args, "pet options")
+ISL_ARG_CHILD(struct options, ppcg, NULL, &ppcg_options_args, "ppcg options")
+ISL_ARG_STR(struct options, output, 'o', NULL,
+  "filename", NULL, "output filename (c and opencl targets)")
+ISL_ARG_ARG(struct options, input, "input", NULL)
+ISL_ARG_VERSION(print_version)
+ISL_ARGS_END
+
+ISL_ARG_DEF(options, struct options, options_args)
+
+/* Return a pointer to the final path component of "filename" or
+ * to "filename" itself if it does not contain any components.
+ */
+const char *ppcg_base_name(const char *filename)
+{
+  const char *base;
+
+  base = strrchr(filename, '/');
+  if (base)
+    return ++base;
+  else
+    return filename;
+}
+
+/* Copy the base name of "input" to "name" and return its length.
+ * "name" is not NULL terminated.
+ *
+ * In particular, remove all leading directory components and
+ * the final extension, if any.
+ */
+int ppcg_extract_base_name(char *name, const char *input)
+{
+  const char *base;
+  const char *ext;
+  int len;
+
+  base = ppcg_base_name(input);
+  ext = strrchr(base, '.');
+  len = ext ? ext - base : strlen(base);
+
+  memcpy(name, base, len);
+
+  return len;
+}
+
+/* Does "scop" refer to any arrays that are declared, but not
+ * exposed to the code after the scop?
+ */
+int ppcg_scop_any_hidden_declarations(struct ppcg_scop *scop)
+{
+  int i;
+
+  if (!scop)
+    return 0;
+
+  for (i = 0; i < scop->pet->n_array; ++i)
+    if (scop->pet->arrays[i]->declared &&
+        !scop->pet->arrays[i]->exposed)
+      return 1;
+
+  return 0;
+}
+
+/* Collect all variable names that are in use in "scop".
+ * In particular, collect all parameters in the context and
+ * all the array names.
+ * Store these names in an isl_id_to_ast_expr by mapping
+ * them to a dummy value (0).
+ */
+static __isl_give isl_id_to_ast_expr *collect_names(struct pet_scop *scop)
+{
+  int i, n;
+  isl_ctx *ctx;
+  isl_ast_expr *zero;
+  isl_id_to_ast_expr *names;
+
+  ctx = isl_set_get_ctx(scop->context);
+
+  n = isl_set_dim(scop->context, isl_dim_param);
+
+  names = isl_id_to_ast_expr_alloc(ctx, n + scop->n_array);
+  zero = isl_ast_expr_from_val(isl_val_zero(ctx));
+
+  for (i = 0; i < n; ++i) {
+    isl_id *id;
+
+    id = isl_set_get_dim_id(scop->context, isl_dim_param, i);
+    names = isl_id_to_ast_expr_set(names,
+            id, isl_ast_expr_copy(zero));
+  }
+
+  for (i = 0; i < scop->n_array; ++i) {
+    struct pet_array *array = scop->arrays[i];
+    isl_id *id;
+
+    id = isl_set_get_tuple_id(array->extent);
+    names = isl_id_to_ast_expr_set(names,
+            id, isl_ast_expr_copy(zero));
+  }
+
+  isl_ast_expr_free(zero);
+
+  return names;
+}
+
+/* Return an isl_id called "prefix%d", with "%d" set to "i".
+ * If an isl_id with such a name already appears among the variable names
+ * of "scop", then adjust the name to "prefix%d_%d".
+ */
+static __isl_give isl_id *generate_name(struct ppcg_scop *scop,
+  const char *prefix, int i)
+{
+  int j;
+  char name[16];
+  isl_ctx *ctx;
+  isl_id *id;
+  int has_name;
+
+  ctx = isl_set_get_ctx(scop->context);
+  snprintf(name, sizeof(name), "%s%d", prefix, i);
+  id = isl_id_alloc(ctx, name, NULL);
+
+  j = 0;
+  while ((has_name = isl_id_to_ast_expr_has(scop->names, id)) == 1) {
+    isl_id_free(id);
+    snprintf(name, sizeof(name), "%s%d_%d", prefix, i, j++);
+    id = isl_id_alloc(ctx, name, NULL);
+  }
+
+  return has_name < 0 ? isl_id_free(id) : id;
+}
+
+/* Return a list of "n" isl_ids of the form "prefix%d".
+ * If an isl_id with such a name already appears among the variable names
+ * of "scop", then adjust the name to "prefix%d_%d".
+ */
+__isl_give isl_id_list *ppcg_scop_generate_names(struct ppcg_scop *scop,
+  int n, const char *prefix)
+{
+  int i;
+  char name[10];
+  isl_ctx *ctx;
+  isl_id_list *names;
+
+  ctx = isl_set_get_ctx(scop->context);
+  names = isl_id_list_alloc(ctx, n);
+  for (i = 0; i < n; ++i) {
+    isl_id *id;
+
+    id = generate_name(scop, prefix, i);
+    names = isl_id_list_add(names, id);
+  }
+
+  return names;
+}
+
+/* Is "stmt" not a kill statement?
+ */
+static int is_not_kill(struct pet_stmt *stmt)
+{
+  return !pet_stmt_is_kill(stmt);
+}
+
+/* Collect the iteration domains of the statements in "scop" that
+ * satisfy "pred".
+ */
+static __isl_give isl_union_set *collect_domains(struct pet_scop *scop,
+  int (*pred)(struct pet_stmt *stmt))
+{
+  int i;
+  isl_set *domain_i;
+  isl_union_set *domain;
+
+  if (!scop)
+    return NULL;
+
+  domain = isl_union_set_empty(isl_set_get_space(scop->context));
+
+  for (i = 0; i < scop->n_stmt; ++i) {
+    struct pet_stmt *stmt = scop->stmts[i];
+
+    if (!pred(stmt))
+      continue;
+
+    if (stmt->n_arg > 0)
+      isl_die(isl_union_set_get_ctx(domain),
+        isl_error_unsupported,
+        "data dependent conditions not supported",
+        return isl_union_set_free(domain));
+
+    domain_i = isl_set_copy(scop->stmts[i]->domain);
+    domain = isl_union_set_add_set(domain, domain_i);
+  }
+
+  return domain;
+}
+
+/* Collect the iteration domains of the statements in "scop",
+ * skipping kill statements.
+ */
+static __isl_give isl_union_set *collect_non_kill_domains(struct pet_scop *scop)
+{
+  return collect_domains(scop, &is_not_kill);
+}
+
+/* This function is used as a callback to pet_expr_foreach_call_expr
+ * to detect if there is any call expression in the input expression.
+ * Assign the value 1 to the integer that "user" points to and
+ * abort the search since we have found what we were looking for.
+ */
+static int set_has_call(__isl_keep pet_expr *expr, void *user)
+{
+  int *has_call = user;
+
+  *has_call = 1;
+
+  return -1;
+}
+
+/* Does "expr" contain any call expressions?
+ */
+static int expr_has_call(__isl_keep pet_expr *expr)
+{
+  int has_call = 0;
+
+  if (pet_expr_foreach_call_expr(expr, &set_has_call, &has_call) < 0 &&
+      !has_call)
+    return -1;
+
+  return has_call;
+}
+
+/* This function is a callback for pet_tree_foreach_expr.
+ * If "expr" contains any call (sub)expressions, then set *has_call
+ * and abort the search.
+ */
+static int check_call(__isl_keep pet_expr *expr, void *user)
+{
+  int *has_call = user;
+
+  if (expr_has_call(expr))
+    *has_call = 1;
+
+  return *has_call ? -1 : 0;
+}
+
+/* Does "stmt" contain any call expressions?
+ */
+static int has_call(struct pet_stmt *stmt)
+{
+  int has_call = 0;
+
+  if (pet_tree_foreach_expr(stmt->body, &check_call, &has_call) < 0 &&
+      !has_call)
+    return -1;
+
+  return has_call;
+}
+
+/* Collect the iteration domains of the statements in "scop"
+ * that contain a call expression.
+ */
+static __isl_give isl_union_set *collect_call_domains(struct pet_scop *scop)
+{
+  return collect_domains(scop, &has_call);
+}
+
+/* Given a union of "tagged" access relations of the form
+ *
+ *  [S_i[...] -> R_j[]] -> A_k[...]
+ *
+ * project out the "tags" (R_j[]).
+ * That is, return a union of relations of the form
+ *
+ *  S_i[...] -> A_k[...]
+ */
+static __isl_give isl_union_map *project_out_tags(
+  __isl_take isl_union_map *umap)
+{
+  return isl_union_map_domain_factor_domain(umap);
+}
+
+/* Construct a function from tagged iteration domains to the corresponding
+ * untagged iteration domains with as range of the wrapped map in the domain
+ * the reference tags that appear in any of the reads, writes or kills.
+ * Store the result in ps->tagger.
+ *
+ * For example, if the statement with iteration space S[i,j]
+ * contains two array references R_1[] and R_2[], then ps->tagger will contain
+ *
+ *  { [S[i,j] -> R_1[]] -> S[i,j]; [S[i,j] -> R_2[]] -> S[i,j] }
+ */
+static void compute_tagger(struct ppcg_scop *ps)
+{
+  isl_union_map *tagged;
+  isl_union_pw_multi_aff *tagger;
+
+  tagged = isl_union_map_copy(ps->tagged_reads);
+  tagged = isl_union_map_union(tagged,
+        isl_union_map_copy(ps->tagged_may_writes));
+  tagged = isl_union_map_union(tagged,
+        isl_union_map_copy(ps->tagged_must_kills));
+  tagged = isl_union_map_universe(tagged);
+  tagged = isl_union_set_unwrap(isl_union_map_domain(tagged));
+
+  tagger = isl_union_map_domain_map_union_pw_multi_aff(tagged);
+
+  ps->tagger = tagger;
+}
+
+/* Compute the live out accesses, i.e., the writes that are
+ * potentially not killed by any kills or any other writes, and
+ * store them in ps->live_out.
+ *
+ * We compute the "dependence" of any "kill" (an explicit kill
+ * or a must write) on any may write.
+ * The may writes with a "depending" kill are definitely killed.
+ * The remaining may writes can potentially be live out.
+ */
+static void compute_live_out(struct ppcg_scop *ps)
+{
+  isl_union_pw_multi_aff *tagger;
+  isl_schedule *schedule;
+  isl_union_map *kills;
+  isl_union_map *exposed;
+  isl_union_map *covering;
+  isl_union_access_info *access;
+  isl_union_flow *flow;
+
+  tagger = isl_union_pw_multi_aff_copy(ps->tagger);
+  schedule = isl_schedule_copy(ps->schedule);
+  schedule = isl_schedule_pullback_union_pw_multi_aff(schedule, tagger);
+  kills = isl_union_map_union(isl_union_map_copy(ps->tagged_must_writes),
+            isl_union_map_copy(ps->tagged_must_kills));
+  access = isl_union_access_info_from_sink(kills);
+  access = isl_union_access_info_set_may_source(access,
+        isl_union_map_copy(ps->tagged_may_writes));
+  access = isl_union_access_info_set_schedule(access, schedule);
+  flow = isl_union_access_info_compute_flow(access);
+  covering = isl_union_flow_get_may_dependence(flow);
+  isl_union_flow_free(flow);
+  exposed = isl_union_map_copy(ps->tagged_may_writes);
+  exposed = isl_union_map_subtract_domain(exposed,
+        isl_union_map_domain(covering));
+  ps->live_out = project_out_tags(exposed);
+}
+
+/* Compute the tagged flow dependences and the live_in accesses and store
+ * the results in ps->tagged_dep_flow and ps->live_in.
+ *
+ * We allow both the must writes and the must kills to serve as
+ * definite sources such that a subsequent read would not depend
+ * on any earlier write.  The resulting flow dependences with
+ * a must kill as source reflect possibly uninitialized reads.
+ * No dependences need to be introduced to protect such reads
+ * (other than those imposed by potential flows from may writes
+ * that follow the kill).  We therefore remove those flow dependences.
+ * This is also useful for the dead code elimination, which assumes
+ * the flow sources are non-kill instances.
+ */
+static void compute_tagged_flow_dep_only(struct ppcg_scop *ps)
+{
+  isl_union_pw_multi_aff *tagger;
+  isl_schedule *schedule;
+  isl_union_map *live_in;
+  isl_union_access_info *access;
+  isl_union_flow *flow;
+  isl_union_map *must_source;
+  isl_union_map *kills;
+  isl_union_map *tagged_flow;
+
+  tagger = isl_union_pw_multi_aff_copy(ps->tagger);
+  schedule = isl_schedule_copy(ps->schedule);
+  schedule = isl_schedule_pullback_union_pw_multi_aff(schedule, tagger);
+  kills = isl_union_map_copy(ps->tagged_must_kills);
+  must_source = isl_union_map_copy(ps->tagged_must_writes);
+  must_source = isl_union_map_union(must_source,
+        isl_union_map_copy(kills));
+  access = isl_union_access_info_from_sink(
+        isl_union_map_copy(ps->tagged_reads));
+  access = isl_union_access_info_set_must_source(access, must_source);
+  access = isl_union_access_info_set_may_source(access,
+        isl_union_map_copy(ps->tagged_may_writes));
+  access = isl_union_access_info_set_schedule(access, schedule);
+  flow = isl_union_access_info_compute_flow(access);
+  tagged_flow = isl_union_flow_get_may_dependence(flow);
+  tagged_flow = isl_union_map_subtract_domain(tagged_flow,
+        isl_union_map_domain(kills));
+  ps->tagged_dep_flow = tagged_flow;
+  live_in = isl_union_flow_get_may_no_source(flow);
+  ps->live_in = project_out_tags(live_in);
+  isl_union_flow_free(flow);
+}
+
+/* Compute ps->dep_flow from ps->tagged_dep_flow
+ * by projecting out the reference tags.
+ */
+static void derive_flow_dep_from_tagged_flow_dep(struct ppcg_scop *ps)
+{
+  ps->dep_flow = isl_union_map_copy(ps->tagged_dep_flow);
+  ps->dep_flow = isl_union_map_factor_domain(ps->dep_flow);
+}
+
+/* Compute the flow dependences and the live_in accesses and store
+ * the results in ps->dep_flow and ps->live_in.
+ * A copy of the flow dependences, tagged with the reference tags
+ * is stored in ps->tagged_dep_flow.
+ *
+ * We first compute ps->tagged_dep_flow, i.e., the tagged flow dependences
+ * and then project out the tags.
+ */
+static void compute_tagged_flow_dep(struct ppcg_scop *ps)
+{
+  compute_tagged_flow_dep_only(ps);
+  derive_flow_dep_from_tagged_flow_dep(ps);
+}
+
+/* Compute the order dependences that prevent the potential live ranges
+ * from overlapping.
+ *
+ * In particular, construct a union of relations
+ *
+ *  [R[...] -> R_1[]] -> [W[...] -> R_2[]]
+ *
+ * where [R[...] -> R_1[]] is the range of one or more live ranges
+ * (i.e., a read) and [W[...] -> R_2[]] is the domain of one or more
+ * live ranges (i.e., a write).  Moreover, the read and the write
+ * access the same memory element and the read occurs before the write
+ * in the original schedule.
+ * The scheduler allows some of these dependences to be violated, provided
+ * the adjacent live ranges are all local (i.e., their domain and range
+ * are mapped to the same point by the current schedule band).
+ *
+ * Note that if a live range is not local, then we need to make
+ * sure it does not overlap with _any_ other live range, and not
+ * just with the "previous" and/or the "next" live range.
+ * We therefore add order dependences between reads and
+ * _any_ later potential write.
+ *
+ * We also need to be careful about writes without a corresponding read.
+ * They are already prevented from moving past non-local preceding
+ * intervals, but we also need to prevent them from moving past non-local
+ * following intervals.  We therefore also add order dependences from
+ * potential writes that do not appear in any intervals
+ * to all later potential writes.
+ * Note that dead code elimination should have removed most of these
+ * dead writes, but the dead code elimination may not remove all dead writes,
+ * so we need to consider them to be safe.
+ *
+ * The order dependences are computed by computing the "dataflow"
+ * from the above unmatched writes and the reads to the may writes.
+ * The unmatched writes and the reads are treated as may sources
+ * such that they would not kill order dependences from earlier
+ * such writes and reads.
+ */
+static void compute_order_dependences(struct ppcg_scop *ps)
+{
+  isl_union_map *reads;
+  isl_union_map *shared_access;
+  isl_union_set *matched;
+  isl_union_map *unmatched;
+  isl_union_pw_multi_aff *tagger;
+  isl_schedule *schedule;
+  isl_union_access_info *access;
+  isl_union_flow *flow;
+
+  tagger = isl_union_pw_multi_aff_copy(ps->tagger);
+  schedule = isl_schedule_copy(ps->schedule);
+  schedule = isl_schedule_pullback_union_pw_multi_aff(schedule, tagger);
+  reads = isl_union_map_copy(ps->tagged_reads);
+  matched = isl_union_map_domain(isl_union_map_copy(ps->tagged_dep_flow));
+  unmatched = isl_union_map_copy(ps->tagged_may_writes);
+  unmatched = isl_union_map_subtract_domain(unmatched, matched);
+  reads = isl_union_map_union(reads, unmatched);
+  access = isl_union_access_info_from_sink(
+        isl_union_map_copy(ps->tagged_may_writes));
+  access = isl_union_access_info_set_may_source(access, reads);
+  access = isl_union_access_info_set_schedule(access, schedule);
+  flow = isl_union_access_info_compute_flow(access);
+  shared_access = isl_union_flow_get_may_dependence(flow);
+  isl_union_flow_free(flow);
+
+  ps->tagged_dep_order = isl_union_map_copy(shared_access);
+  ps->dep_order = isl_union_map_factor_domain(shared_access);
+}
+
+/* Compute those validity dependences of the program represented by "scop"
+ * that should be unconditionally enforced even when live-range reordering
+ * is used.
+ *
+ * In particular, compute the external false dependences
+ * as well as order dependences between sources with the same sink.
+ * The anti-dependences are already taken care of by the order dependences.
+ * The external false dependences are only used to ensure that live-in and
+ * live-out data is not overwritten by any writes inside the scop.
+ * The independences are removed from the external false dependences,
+ * but not from the order dependences between sources with the same sink.
+ *
+ * In particular, the reads from live-in data need to precede any
+ * later write to the same memory element.
+ * As to live-out data, the last writes need to remain the last writes.
+ * That is, any earlier write in the original schedule needs to precede
+ * the last write to the same memory element in the computed schedule.
+ * The possible last writes have been computed by compute_live_out.
+ * They may include kills, but if the last access is a kill,
+ * then the corresponding dependences will effectively be ignored
+ * since we do not schedule any kill statements.
+ *
+ * Note that the set of live-in and live-out accesses may be
+ * an overapproximation.  There may therefore be potential writes
+ * before a live-in access and after a live-out access.
+ *
+ * In the presence of may-writes, there may be multiple live-ranges
+ * with the same sink, accessing the same memory element.
+ * The sources of these live-ranges need to be executed
+ * in the same relative order as in the original program
+ * since we do not know which of the may-writes will actually
+ * perform a write.  Consider all sources that share a sink and
+ * that may write to the same memory element and compute
+ * the order dependences among them.
+ */
+static void compute_forced_dependences(struct ppcg_scop *ps)
+{
+  isl_union_map *shared_access;
+  isl_union_map *exposed;
+  isl_union_map *live_in;
+  isl_union_map *sink_access;
+  isl_union_map *shared_sink;
+  isl_union_access_info *access;
+  isl_union_flow *flow;
+  isl_schedule *schedule;
+
+  exposed = isl_union_map_copy(ps->live_out);
+  schedule = isl_schedule_copy(ps->schedule);
+  access = isl_union_access_info_from_sink(exposed);
+  access = isl_union_access_info_set_may_source(access,
+        isl_union_map_copy(ps->may_writes));
+  access = isl_union_access_info_set_schedule(access, schedule);
+  flow = isl_union_access_info_compute_flow(access);
+  shared_access = isl_union_flow_get_may_dependence(flow);
+  isl_union_flow_free(flow);
+  ps->dep_forced = shared_access;
+
+  schedule = isl_schedule_copy(ps->schedule);
+  access = isl_union_access_info_from_sink(
+        isl_union_map_copy(ps->may_writes));
+  access = isl_union_access_info_set_may_source(access,
+        isl_union_map_copy(ps->live_in));
+  access = isl_union_access_info_set_schedule(access, schedule);
+  flow = isl_union_access_info_compute_flow(access);
+  live_in = isl_union_flow_get_may_dependence(flow);
+  isl_union_flow_free(flow);
+
+  ps->dep_forced = isl_union_map_union(ps->dep_forced, live_in);
+  ps->dep_forced = isl_union_map_subtract(ps->dep_forced,
+        isl_union_map_copy(ps->independence));
+
+  schedule = isl_schedule_copy(ps->schedule);
+  sink_access = isl_union_map_copy(ps->tagged_dep_flow);
+  sink_access = isl_union_map_range_product(sink_access,
+        isl_union_map_copy(ps->tagged_may_writes));
+  sink_access = isl_union_map_domain_factor_domain(sink_access);
+  access = isl_union_access_info_from_sink(
+        isl_union_map_copy(sink_access));
+  access = isl_union_access_info_set_may_source(access, sink_access);
+  access = isl_union_access_info_set_schedule(access, schedule);
+  flow = isl_union_access_info_compute_flow(access);
+  shared_sink = isl_union_flow_get_may_dependence(flow);
+  isl_union_flow_free(flow);
+  ps->dep_forced = isl_union_map_union(ps->dep_forced, shared_sink);
+}
+
+/* Remove independence from the tagged flow dependences.
+ * Since the user has guaranteed that source and sink of an independence
+ * can be executed in any order, there cannot be a flow dependence
+ * between them, so they can be removed from the set of flow dependences.
+ * However, if the source of such a flow dependence is a must write,
+ * then it may have killed other potential sources, which would have
+ * to be recovered if we were to remove those flow dependences.
+ * We therefore keep the flow dependences that originate in a must write,
+ * even if it corresponds to a known independence.
+ */
+static void remove_independences_from_tagged_flow(struct ppcg_scop *ps)
+{
+  isl_union_map *tf;
+  isl_union_set *indep;
+  isl_union_set *mw;
+
+  tf = isl_union_map_copy(ps->tagged_dep_flow);
+  tf = isl_union_map_zip(tf);
+  indep = isl_union_map_wrap(isl_union_map_copy(ps->independence));
+  tf = isl_union_map_intersect_domain(tf, indep);
+  tf = isl_union_map_zip(tf);
+  mw = isl_union_map_domain(isl_union_map_copy(ps->tagged_must_writes));
+  tf = isl_union_map_subtract_domain(tf, mw);
+  ps->tagged_dep_flow = isl_union_map_subtract(ps->tagged_dep_flow, tf);
+}
+
+/* Compute the dependences of the program represented by "scop"
+ * in case live range reordering is allowed.
+ *
+ * We compute the actual live ranges and the corresponding order
+ * false dependences.
+ *
+ * The independences are removed from the flow dependences
+ * (provided the source is not a must-write) as well as
+ * from the external false dependences (by compute_forced_dependences).
+ */
+static void compute_live_range_reordering_dependences(struct ppcg_scop *ps)
+{
+  compute_tagged_flow_dep_only(ps);
+  remove_independences_from_tagged_flow(ps);
+  derive_flow_dep_from_tagged_flow_dep(ps);
+  compute_order_dependences(ps);
+  compute_forced_dependences(ps);
+}
+
+/* Compute the potential flow dependences and the potential live in
+ * accesses.
+ */
+static void compute_flow_dep(struct ppcg_scop *ps)
+{
+  isl_union_access_info *access;
+  isl_union_flow *flow;
+
+  access = isl_union_access_info_from_sink(isl_union_map_copy(ps->reads));
+  access = isl_union_access_info_set_must_source(access,
+        isl_union_map_copy(ps->must_writes));
+  access = isl_union_access_info_set_may_source(access,
+        isl_union_map_copy(ps->may_writes));
+  access = isl_union_access_info_set_schedule(access,
+        isl_schedule_copy(ps->schedule));
+  flow = isl_union_access_info_compute_flow(access);
+
+  ps->dep_flow = isl_union_flow_get_may_dependence(flow);
+  ps->live_in = isl_union_flow_get_may_no_source(flow);
+  isl_union_flow_free(flow);
+}
+
+/* Compute the dependences of the program represented by "scop".
+ * Store the computed potential flow dependences
+ * in scop->dep_flow and the reads with potentially no corresponding writes in
+ * scop->live_in.
+ * Store the potential live out accesses in scop->live_out.
+ * Store the potential false (anti and output) dependences in scop->dep_false.
+ *
+ * If live range reordering is allowed, then we compute a separate
+ * set of order dependences and a set of external false dependences
+ * in compute_live_range_reordering_dependences.
+ */
+static void compute_dependences(struct ppcg_scop *scop)
+{
+  isl_union_map *may_source;
+  isl_union_access_info *access;
+  isl_union_flow *flow;
+
+  if (!scop)
+    return;
+
+  compute_live_out(scop);
+
+  if (scop->options->live_range_reordering)
+    compute_live_range_reordering_dependences(scop);
+  else if (scop->options->target != PPCG_TARGET_C)
+    compute_tagged_flow_dep(scop);
+  else
+    compute_flow_dep(scop);
+
+  may_source = isl_union_map_union(isl_union_map_copy(scop->may_writes),
+          isl_union_map_copy(scop->reads));
+  access = isl_union_access_info_from_sink(
+        isl_union_map_copy(scop->may_writes));
+  access = isl_union_access_info_set_must_source(access,
+        isl_union_map_copy(scop->must_writes));
+  access = isl_union_access_info_set_may_source(access, may_source);
+  access = isl_union_access_info_set_schedule(access,
+        isl_schedule_copy(scop->schedule));
+  flow = isl_union_access_info_compute_flow(access);
+
+  scop->dep_false = isl_union_flow_get_may_dependence(flow);
+  scop->dep_false = isl_union_map_coalesce(scop->dep_false);
+  isl_union_flow_free(flow);
+}
+
+/* Eliminate dead code from ps->domain.
+ *
+ * In particular, intersect both ps->domain and the domain of
+ * ps->schedule with the (parts of) iteration
+ * domains that are needed to produce the output or for statement
+ * iterations that call functions.
+ * Also intersect the range of the dataflow dependences with
+ * this domain such that the removed instances will no longer
+ * be considered as targets of dataflow.
+ *
+ * We start with the iteration domains that call functions
+ * and the set of iterations that last write to an array
+ * (except those that are later killed).
+ *
+ * Then we add those statement iterations that produce
+ * something needed by the "live" statements iterations.
+ * We keep doing this until no more statement iterations can be added.
+ * To ensure that the procedure terminates, we compute the affine
+ * hull of the live iterations (bounded to the original iteration
+ * domains) each time we have added extra iterations.
+ */
+static void eliminate_dead_code(struct ppcg_scop *ps)
+{
+  isl_union_set *live;
+  isl_union_map *dep;
+  isl_union_pw_multi_aff *tagger;
+
+  live = isl_union_map_domain(isl_union_map_copy(ps->live_out));
+  if (!isl_union_set_is_empty(ps->call)) {
+    live = isl_union_set_union(live, isl_union_set_copy(ps->call));
+    live = isl_union_set_coalesce(live);
+  }
+
+  dep = isl_union_map_copy(ps->dep_flow);
+  dep = isl_union_map_reverse(dep);
+
+  for (;;) {
+    isl_union_set *extra;
+
+    extra = isl_union_set_apply(isl_union_set_copy(live),
+              isl_union_map_copy(dep));
+    if (isl_union_set_is_subset(extra, live)) {
+      isl_union_set_free(extra);
+      break;
+    }
+
+    live = isl_union_set_union(live, extra);
+    live = isl_union_set_affine_hull(live);
+    live = isl_union_set_intersect(live,
+              isl_union_set_copy(ps->domain));
+  }
+
+  isl_union_map_free(dep);
+
+  ps->domain = isl_union_set_intersect(ps->domain,
+            isl_union_set_copy(live));
+  ps->schedule = isl_schedule_intersect_domain(ps->schedule,
+            isl_union_set_copy(live));
+  ps->dep_flow = isl_union_map_intersect_range(ps->dep_flow,
+            isl_union_set_copy(live));
+  tagger = isl_union_pw_multi_aff_copy(ps->tagger);
+  live = isl_union_set_preimage_union_pw_multi_aff(live, tagger);
+  ps->tagged_dep_flow = isl_union_map_intersect_range(ps->tagged_dep_flow,
+            live);
+}
+
+/* Intersect "set" with the set described by "str", taking the NULL
+ * string to represent the universal set.
+ */
+static __isl_give isl_set *set_intersect_str(__isl_take isl_set *set,
+  const char *str)
+{
+  isl_ctx *ctx;
+  isl_set *set2;
+
+  if (!str)
+    return set;
+
+  ctx = isl_set_get_ctx(set);
+  set2 = isl_set_read_from_str(ctx, str);
+  set = isl_set_intersect(set, set2);
+
+  return set;
+}
+
+static void *ppcg_scop_free(struct ppcg_scop *ps)
+{
+  if (!ps)
+    return NULL;
+
+  isl_set_free(ps->context);
+  isl_union_set_free(ps->domain);
+  isl_union_set_free(ps->call);
+  isl_union_map_free(ps->tagged_reads);
+  isl_union_map_free(ps->reads);
+  isl_union_map_free(ps->live_in);
+  isl_union_map_free(ps->tagged_may_writes);
+  isl_union_map_free(ps->tagged_must_writes);
+  isl_union_map_free(ps->may_writes);
+  isl_union_map_free(ps->must_writes);
+  isl_union_map_free(ps->live_out);
+  isl_union_map_free(ps->tagged_must_kills);
+  isl_union_map_free(ps->tagged_dep_flow);
+  isl_union_map_free(ps->dep_flow);
+  isl_union_map_free(ps->dep_false);
+  isl_union_map_free(ps->dep_forced);
+  isl_union_map_free(ps->tagged_dep_order);
+  isl_union_map_free(ps->dep_order);
+  isl_schedule_free(ps->schedule);
+  isl_union_pw_multi_aff_free(ps->tagger);
+  isl_union_map_free(ps->independence);
+  isl_id_to_ast_expr_free(ps->names);
+
+  free(ps);
+
+  return NULL;
+}
+
+/* Extract a ppcg_scop from a pet_scop.
+ *
+ * The constructed ppcg_scop refers to elements from the pet_scop
+ * so the pet_scop should not be freed before the ppcg_scop.
+ */
+static struct ppcg_scop *ppcg_scop_from_pet_scop(struct pet_scop *scop,
+  struct ppcg_options *options)
+{
+  int i;
+  isl_ctx *ctx;
+  struct ppcg_scop *ps;
+
+  if (!scop)
+    return NULL;
+
+  ctx = isl_set_get_ctx(scop->context);
+
+  ps = isl_calloc_type(ctx, struct ppcg_scop);
+  if (!ps)
+    return NULL;
+
+  ps->names = collect_names(scop);
+  ps->options = options;
+  ps->start = pet_loc_get_start(scop->loc);
+  ps->end = pet_loc_get_end(scop->loc);
+  ps->context = isl_set_copy(scop->context);
+  ps->context = set_intersect_str(ps->context, options->ctx);
+  if (options->non_negative_parameters) {
+    isl_space *space = isl_set_get_space(ps->context);
+    isl_set *nn = isl_set_nat_universe(space);
+    ps->context = isl_set_intersect(ps->context, nn);
+  }
+  ps->domain = collect_non_kill_domains(scop);
+  ps->call = collect_call_domains(scop);
+  ps->tagged_reads = pet_scop_collect_tagged_may_reads(scop);
+  ps->reads = pet_scop_collect_may_reads(scop);
+  ps->tagged_may_writes = pet_scop_collect_tagged_may_writes(scop);
+  ps->may_writes = pet_scop_collect_may_writes(scop);
+  ps->tagged_must_writes = pet_scop_collect_tagged_must_writes(scop);
+  ps->must_writes = pet_scop_collect_must_writes(scop);
+  ps->tagged_must_kills = pet_scop_collect_tagged_must_kills(scop);
+  ps->schedule = isl_schedule_copy(scop->schedule);
+  ps->pet = scop;
+  ps->independence = isl_union_map_empty(isl_set_get_space(ps->context));
+  for (i = 0; i < scop->n_independence; ++i)
+    ps->independence = isl_union_map_union(ps->independence,
+      isl_union_map_copy(scop->independences[i]->filter));
+
+  compute_tagger(ps);
+  compute_dependences(ps);
+  eliminate_dead_code(ps);
+
+  if (!ps->context || !ps->domain || !ps->call || !ps->reads ||
+      !ps->may_writes || !ps->must_writes || !ps->tagged_must_kills ||
+      !ps->schedule || !ps->independence || !ps->names)
+    return ppcg_scop_free(ps);
+
+  return ps;
+}
+
+/* Internal data structure for ppcg_transform.
+ */
+struct ppcg_transform_data {
+  struct ppcg_options *options;
+  __isl_give isl_printer *(*transform)(__isl_take isl_printer *p,
+    struct ppcg_scop *scop, void *user);
+  void *user;
+};
+
+/* Should we print the original code?
+ * That is, does "scop" involve any data dependent conditions or
+ * nested expressions that cannot be handled by pet_stmt_build_ast_exprs?
+ */
+static int print_original(struct pet_scop *scop, struct ppcg_options *options)
+{
+  if (!pet_scop_can_build_ast_exprs(scop)) {
+    if (options->debug->verbose)
+      fprintf(stdout, "Printing original code because "
+        "some index expressions cannot currently "
+        "be printed\n");
+    return 1;
+  }
+
+  if (pet_scop_has_data_dependent_conditions(scop)) {
+    if (options->debug->verbose)
+      fprintf(stdout, "Printing original code because "
+        "input involves data dependent conditions\n");
+    return 1;
+  }
+
+  return 0;
+}
+
+/* Callback for pet_transform_C_source that transforms
+ * the given pet_scop to a ppcg_scop before calling the
+ * ppcg_transform callback.
+ *
+ * If "scop" contains any data dependent conditions or if we may
+ * not be able to print the transformed program, then just print
+ * the original code.
+ */
+static __isl_give isl_printer *transform(__isl_take isl_printer *p,
+  struct pet_scop *scop, void *user)
+{
+  struct ppcg_transform_data *data = user;
+  struct ppcg_scop *ps;
+
+  if (print_original(scop, data->options)) {
+    p = pet_scop_print_original(scop, p);
+    pet_scop_free(scop);
+    return p;
+  }
+
+  scop = pet_scop_align_params(scop);
+  ps = ppcg_scop_from_pet_scop(scop, data->options);
+
+  p = data->transform(p, ps, data->user);
+
+  ppcg_scop_free(ps);
+  pet_scop_free(scop);
+
+  return p;
+}
+
+/* Transform the C source file "input" by rewriting each scop
+ * through a call to "transform".
+ * The transformed C code is written to "out".
+ *
+ * This is a wrapper around pet_transform_C_source that transforms
+ * the pet_scop to a ppcg_scop before calling "fn".
+ */
+int ppcg_transform(isl_ctx *ctx, const char *input, FILE *out,
+  struct ppcg_options *options,
+  __isl_give isl_printer *(*fn)(__isl_take isl_printer *p,
+    struct ppcg_scop *scop, void *user), void *user)
+{
+  struct ppcg_transform_data data = { options, fn, user };
+  return pet_transform_C_source(ctx, input, out, &transform, &data);
+}
+
+/* Check consistency of options.
+ *
+ * Return -1 on error.
+ */
+static int check_options(isl_ctx *ctx)
+{
+  struct options *options;
+
+  options = isl_ctx_peek_options(ctx, &options_args);
+  if (!options)
+    isl_die(ctx, isl_error_internal,
+      "unable to find options", return -1);
+
+  if (options->ppcg->openmp &&
+      !isl_options_get_ast_build_atomic_upper_bound(ctx))
+    isl_die(ctx, isl_error_invalid,
+      "OpenMP requires atomic bounds", return -1);
+
+  return 0;
+}
+
+int main(int argc, char **argv)
+{
+  int r;
+  isl_ctx *ctx;
+  struct options *options;
+
+  options = options_new_with_defaults();
+  assert(options);
+
+  ctx = isl_ctx_alloc_with_options(&options_args, options);
+  isl_options_set_schedule_outer_coincidence(ctx, 1);
+  isl_options_set_schedule_maximize_band_depth(ctx, 1);
+  pet_options_set_encapsulate_dynamic_control(ctx, 1);
+  argc = options_parse(options, argc, argv, ISL_ARG_ALL);
+
+  if (check_options(ctx) < 0)
+    r = EXIT_FAILURE;
+  else if (options->ppcg->target == PPCG_TARGET_CUDA)
+    r = generate_cuda(ctx, options->ppcg, options->input);
+  else if (options->ppcg->target == PPCG_TARGET_OPENCL)
+    r = generate_opencl(ctx, options->ppcg, options->input,
+        options->output);
+  else
+    r = generate_cpu(ctx, options->ppcg, options->input,
+        options->output);
+
+  isl_ctx_free(ctx);
+
+  return r;
+}

polly/trunk/lib/External/ppcg/ppcg_options.h

+#ifndef PPCG_OPTIONS_H
+#define PPCG_OPTIONS_H
+
+#include <isl/arg.h>
+
+struct ppcg_debug_options {
+  int dump_schedule_constraints;
+  int dump_schedule;
+  int dump_final_schedule;
+  int dump_sizes;
+  int verbose;
+};
+
+struct ppcg_options {
+  struct ppcg_debug_options *debug;
+
+  /* Use isl to compute a schedule replacing the original schedule. */
+  int reschedule;
+  int scale_tile_loops;
+  int wrap;
+
+  /* Assume all parameters are non-negative. */
+  int non_negative_parameters;
+  char *ctx;
+  char *sizes;
+
+  int tile_size;
+
+  /* Take advantage of private memory. */
+  int use_private_memory;
+
+  /* Take advantage of shared memory. */
+  int use_shared_memory;
+
+  /* Maximal amount of shared memory. */
+  int max_shared_memory;
+
+  /* The target we generate code for. */
+  int target;
+
+  /* Generate OpenMP macros (C target only). */
+  int openmp;
+
+  /* Linearize all device arrays. */
+  int linearize_device_arrays;
+
+  /* Allow live range to be reordered. */
+  int live_range_reordering;
+
+  /* Options to pass to the OpenCL compiler.  */
+  char *opencl_compiler_options;
+  /* Prefer GPU device over CPU. */
+  int opencl_use_gpu;
+  /* Number of files to include. */
+  int opencl_n_include_file;
+  /* Files to include. */
+  const char **opencl_include_files;
+  /* Print definitions of types in kernels. */
+  int opencl_print_kernel_types;
+  /* Embed OpenCL kernel code in host code. */
+  int opencl_embed_kernel_code;
+
+  /* Name of file for saving isl computed schedule or NULL. */
+  char *save_schedule_file;
+  /* Name of file for loading schedule or NULL. */
+  char *load_schedule_file;
+};
+
+ISL_ARG_DECL(ppcg_debug_options, struct ppcg_debug_options,
+  ppcg_debug_options_args)
+ISL_ARG_DECL(ppcg_options, struct ppcg_options, ppcg_options_args)
+
+#define   PPCG_TARGET_C   0
+#define   PPCG_TARGET_CUDA  1
+#define   PPCG_TARGET_OPENCL      2
+
+#endif

polly/trunk/lib/External/ppcg/ppcg_options.c

+/*
+ * Copyright 2010-2011 INRIA Saclay
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ */
+
+#include "ppcg_options.h"
+
+static struct isl_arg_choice target[] = {
+  {"c",   PPCG_TARGET_C},
+  {"cuda",  PPCG_TARGET_CUDA},
+  {"opencl",      PPCG_TARGET_OPENCL},
+  {0}
+};
+
+ISL_ARGS_START(struct ppcg_debug_options, ppcg_debug_options_args)
+ISL_ARG_BOOL(struct ppcg_debug_options, dump_schedule_constraints, 0,
+  "dump-schedule-constraints", 0, "dump schedule constraints")
+ISL_ARG_BOOL(struct ppcg_debug_options, dump_schedule, 0,
+  "dump-schedule", 0, "dump isl computed schedule")
+ISL_ARG_BOOL(struct ppcg_debug_options, dump_final_schedule, 0,
+  "dump-final-schedule", 0, "dump PPCG computed schedule")
+ISL_ARG_BOOL(struct ppcg_debug_options, dump_sizes, 0,
+  "dump-sizes", 0,
+  "dump effectively used per kernel tile, grid and block sizes")
+ISL_ARG_BOOL(struct ppcg_debug_options, verbose, 'v', "verbose", 0, NULL)
+ISL_ARGS_END
+
+ISL_ARGS_START(struct ppcg_options, ppcg_opencl_options_args)
+ISL_ARG_STR(struct ppcg_options, opencl_compiler_options, 0, "compiler-options",
+  "options", NULL, "options to pass to the OpenCL compiler")
+ISL_ARG_BOOL(struct ppcg_options, opencl_use_gpu, 0, "use-gpu", 1,
+  "use GPU device (if available)")
+ISL_ARG_STR_LIST(struct ppcg_options, opencl_n_include_file,
+  opencl_include_files, 0, "include-file", "filename",
+  "file to #include in generated OpenCL code")
+ISL_ARG_BOOL(struct ppcg_options, opencl_print_kernel_types, 0,
+  "print-kernel-types", 1,
+  "print definitions of types in the kernel file")
+ISL_ARG_BOOL(struct ppcg_options, opencl_embed_kernel_code, 0,
+  "embed-kernel-code", 0, "embed kernel code into host code")
+ISL_ARGS_END
+
+ISL_ARGS_START(struct ppcg_options, ppcg_options_args)
+ISL_ARG_CHILD(struct ppcg_options, debug, NULL, &ppcg_debug_options_args,
+  "debugging options")
+ISL_ARG_BOOL(struct ppcg_options, reschedule, 0, "reschedule", 1,
+  "replace original schedule by isl computed schedule (except C target)")
+ISL_ARG_BOOL(struct ppcg_options, scale_tile_loops, 0,
+  "scale-tile-loops", 1, NULL)
+ISL_ARG_BOOL(struct ppcg_options, wrap, 0, "wrap", 1, NULL)
+ISL_ARG_BOOL(struct ppcg_options, use_shared_memory, 0, "shared-memory", 1,
+  "use shared memory in kernel code")
+ISL_ARG_BOOL(struct ppcg_options, use_private_memory, 0, "private-memory", 1,
+  "use private memory in kernel code")
+ISL_ARG_STR(struct ppcg_options, ctx, 0, "ctx", "context", NULL,
+    "Constraints on parameters")
+ISL_ARG_BOOL(struct ppcg_options, non_negative_parameters, 0,
+  "assume-non-negative-parameters", 0,
+  "assume all parameters are non-negative)")
+ISL_ARG_INT(struct ppcg_options, tile_size, 'S', "tile-size", "size", 32, NULL)
+ISL_ARG_STR(struct ppcg_options, sizes, 0, "sizes", "sizes", NULL,
+  "Per kernel tile, grid and block sizes")
+ISL_ARG_INT(struct ppcg_options, max_shared_memory, 0,
+  "max-shared-memory", "size", 8192, "maximal amount of shared memory")
+ISL_ARG_BOOL(struct ppcg_options, openmp, 0, "openmp", 0,
+  "Generate OpenMP macros (only for C target)")
+ISL_ARG_CHOICE(struct ppcg_options, target, 0, "target", target,
+  PPCG_TARGET_CUDA, "the target to generate code for")
+ISL_ARG_BOOL(struct ppcg_options, linearize_device_arrays, 0,
+  "linearize-device-arrays", 1,
+  "linearize all device arrays, even those of fixed size")
+ISL_ARG_BOOL(struct ppcg_options, live_range_reordering, 0,
+  "live-range-reordering", 1,
+  "allow successive live ranges on the same memory element "
+  "to be reordered")
+ISL_ARG_GROUP("opencl", &ppcg_opencl_options_args, "OpenCL options")
+ISL_ARG_STR(struct ppcg_options, save_schedule_file, 0, "save-schedule",
+  "file", NULL, "save isl computed schedule to <file>")
+ISL_ARG_STR(struct ppcg_options, load_schedule_file, 0, "load-schedule",
+  "file", NULL, "load schedule from <file>, "
+  "using it instead of an isl computed schedule")
+ISL_ARGS_END

polly/trunk/lib/External/ppcg/print.h

+#ifndef PRINT_H
+#define PRINT_H
+
+#include <isl/ast.h>
+
+#include "ppcg.h"
+
+__isl_give isl_printer *ppcg_start_block(__isl_take isl_printer *p);
+__isl_give isl_printer *ppcg_end_block(__isl_take isl_printer *p);
+
+__isl_give isl_printer *ppcg_print_macros(__isl_take isl_printer *p,
+  __isl_keep isl_ast_node *node);
+
+__isl_give isl_printer *ppcg_print_declaration(__isl_take isl_printer *p,
+  struct pet_array *array, __isl_keep isl_ast_build *build);
+__isl_give isl_printer *ppcg_print_exposed_declarations(
+  __isl_take isl_printer *p, struct ppcg_scop *scop);
+__isl_give isl_printer *ppcg_print_hidden_declarations(
+  __isl_take isl_printer *p, struct ppcg_scop *scop);
+
+__isl_give isl_printer *ppcg_print_guarded(__isl_take isl_printer *p,
+  __isl_take isl_set *guard, __isl_take isl_set *context,
+  __isl_give isl_printer *(*fn)(__isl_take isl_printer *p, void *user),
+  void *user);
+
+#endif

polly/trunk/lib/External/ppcg/print.c

+/*
+ * Copyright 2012-2013 Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
+ */
+
+#include <isl/aff.h>
+#include <isl/ast_build.h>
+
+#include "print.h"
+
+__isl_give isl_printer *ppcg_start_block(__isl_take isl_printer *p)
+{
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "{");
+  p = isl_printer_end_line(p);
+  p = isl_printer_indent(p, 2);
+  return p;
+}
+
+__isl_give isl_printer *ppcg_end_block(__isl_take isl_printer *p)
+{
+  p = isl_printer_indent(p, -2);
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, "}");
+  p = isl_printer_end_line(p);
+  return p;
+}
+
+static int print_macro(enum isl_ast_op_type type, void *user)
+{
+  isl_printer **p = user;
+
+  if (type == isl_ast_op_fdiv_q)
+    return 0;
+
+  *p = isl_ast_op_type_print_macro(type, *p);
+
+  return 0;
+}
+
+/* Print the required macros for "node", except one for floord.
+ * The caller is assumed to have printed a macro for floord already
+ * as it may also appear in the declarations and the statements.
+ */
+__isl_give isl_printer *ppcg_print_macros(__isl_take isl_printer *p,
+  __isl_keep isl_ast_node *node)
+{
+  if (isl_ast_node_foreach_ast_op_type(node, &print_macro, &p) < 0)
+    return isl_printer_free(p);
+  return p;
+}
+
+/* Print "extent" as a sequence of
+ *
+ *  [1 + maximal_value]
+ *
+ * one for each dimension.
+ * "build" is used to simplify the size expressions, if any.
+ */
+static __isl_give isl_printer *print_extent(__isl_take isl_printer *p,
+  __isl_keep isl_set *extent, __isl_keep isl_ast_build *build)
+{
+  int i, n;
+
+  n = isl_set_dim(extent, isl_dim_set);
+  if (n == 0)
+    return p;
+
+  for (i = 0; i < n; ++i) {
+    isl_set *dom;
+    isl_local_space *ls;
+    isl_aff *one;
+    isl_pw_aff *bound;
+    isl_ast_expr *expr;
+
+    bound = isl_set_dim_max(isl_set_copy(extent), i);
+    dom = isl_pw_aff_domain(isl_pw_aff_copy(bound));
+    ls = isl_local_space_from_space(isl_set_get_space(dom));
+    one = isl_aff_zero_on_domain(ls);
+    one = isl_aff_add_constant_si(one, 1);
+    bound = isl_pw_aff_add(bound, isl_pw_aff_alloc(dom, one));
+
+    p = isl_printer_print_str(p, "[");
+    expr = isl_ast_build_expr_from_pw_aff(build, bound);
+    p = isl_printer_print_ast_expr(p, expr);
+    p = isl_printer_print_str(p, "]");
+
+    isl_ast_expr_free(expr);
+  }
+
+  return p;
+}
+
+/* Print a declaration for array "array" to "p", using "build"
+ * to simplify any size expressions.
+ */
+__isl_give isl_printer *ppcg_print_declaration(__isl_take isl_printer *p,
+  struct pet_array *array, __isl_keep isl_ast_build *build)
+{
+  const char *name;
+
+  if (!array)
+    return isl_printer_free(p);
+
+  name = isl_set_get_tuple_name(array->extent);
+
+  p = isl_printer_start_line(p);
+  p = isl_printer_print_str(p, array->element_type);
+  p = isl_printer_print_str(p, " ");
+  p = isl_printer_print_str(p, name);
+  p = print_extent(p, array->extent, build);
+  p = isl_printer_print_str(p, ";");
+  p = isl_printer_end_line(p);
+
+  return p;
+}
+
+/* Print declarations for the arrays in "scop" that are declared
+ * and that are exposed (if exposed == 1) or not exposed (if exposed == 0).
+ */
+static __isl_give isl_printer *print_declarations(__isl_take isl_printer *p,
+  struct ppcg_scop *scop, int exposed)
+{
+  int i;
+  isl_ast_build *build;
+
+  if (!scop)
+    return isl_printer_free(p);
+
+  build = isl_ast_build_from_context(isl_set_copy(scop->context));
+  for (i = 0; i < scop->pet->n_array; ++i) {
+    struct pet_array *array = scop->pet->arrays[i];
+
+    if (!array->declared)
+      continue;
+    if (array->exposed != exposed)
+      continue;
+
+    p = ppcg_print_declaration(p, array, build);
+  }
+  isl_ast_build_free(build);
+
+  return p;
+}
+
+/* Print declarations for the arrays in "scop" that are declared
+ * and exposed to the code after the scop.
+ */
+__isl_give isl_printer *ppcg_print_exposed_declarations(
+  __isl_take isl_printer *p, struct ppcg_scop *scop)
+{
+  return print_declarations(p, scop, 1);
+}
+
+/* Print declarations for the arrays in "scop" that are declared,
+ * but not exposed to the code after the scop.
+ */
+__isl_give isl_printer *ppcg_print_hidden_declarations(
+  __isl_take isl_printer *p, struct ppcg_scop *scop)
+{
+  return print_declarations(p, scop, 0);
+}
+
+/* Internal data structure for print_guarded_user.
+ *
+ * fn is the function that should be called to print the body.
+ * user is the argument that should be passed to this function.
+ */
+struct ppcg_print_guarded_data {
+  __isl_give isl_printer *(*fn)(__isl_take isl_printer *p, void *user);
+  void *user;
+};
+
+/* Print the body of the if statement expressing the guard passed
+ * to "ppcg_print_guarded" by calling data->fn.
+ */
+static __isl_give isl_printer *print_guarded_user(__isl_take isl_printer *p,
+  __isl_take isl_ast_print_options *options,
+  __isl_keep isl_ast_node *node, void *user)
+{
+  struct ppcg_print_guarded_data *data = user;
+
+  p = data->fn(p, data->user);
+
+  isl_ast_print_options_free(options);
+  return p;
+}
+
+/* Print a condition for the given "guard" within the given "context"
+ * on "p", calling "fn" with "user" to print the body of the if statement.
+ * If the guard is implied by the context, then no if statement is printed
+ * and the body is printed directly to "p".
+ *
+ * Both "guard" and "context" are assumed to be parameter sets.
+ *
+ * We slightly abuse the AST generator to print this guard.
+ * In particular, we create a trivial schedule for an iteration
+ * domain with a single instance, restricted by the guard.
+ */
+__isl_give isl_printer *ppcg_print_guarded(__isl_take isl_printer *p,
+  __isl_take isl_set *guard, __isl_take isl_set *context,
+  __isl_give isl_printer *(*fn)(__isl_take isl_printer *p, void *user),
+  void *user)
+{
+  struct ppcg_print_guarded_data data = { fn, user };
+  isl_ctx *ctx;
+  isl_union_map *schedule;
+  isl_ast_build *build;
+  isl_ast_node *tree;
+  isl_ast_print_options *options;
+
+  ctx = isl_printer_get_ctx(p);
+  guard = isl_set_from_params(guard);
+  schedule = isl_union_map_from_map(isl_map_from_domain(guard));
+  build = isl_ast_build_from_context(context);
+  tree = isl_ast_build_node_from_schedule_map(build, schedule);
+  isl_ast_build_free(build);
+
+  options = isl_ast_print_options_alloc(ctx);
+  options = isl_ast_print_options_set_print_user(options,
+            &print_guarded_user, &data);
+  p = isl_ast_node_print(tree, p, options);
+  isl_ast_node_free(tree);
+
+  return p;
+}

polly/trunk/lib/External/ppcg/schedule.h

+#ifndef _SCHEDULE_H
+#define _SCHEDULE_H
+
+#include <isl/id.h>
+#include <isl/set_type.h>
+#include <isl/map_type.h>
+#include <isl/union_map_type.h>
+
+#include <pet.h>
+
+/* An access to an outer array element or an iterator.
+ * Accesses to iterators have an access relation that maps to an unnamed space.
+ * An access may be both read and write.
+ * If the access relation is empty, then the output dimension may
+ * not be equal to the dimension of the corresponding array.
+ */
+struct gpu_stmt_access {
+  /* Access reads elements */
+  int read;
+  /* Access writes elements */
+  int write;
+  /* All writes are definite writes. */
+  int exact_write;
+  /* The number of index expressions specified in the access. */
+  int n_index;
+
+  /* May access relation */
+  isl_map *access;
+  /* May access relation with as domain a mapping from iteration domain
+   * to a reference identifier.
+   */
+  isl_map *tagged_access;
+  /* The reference id of the corresponding pet_expr. */
+  isl_id *ref_id;
+
+  struct gpu_stmt_access *next;
+};
+
+struct gpu_stmt {
+  isl_id *id;
+  struct pet_stmt *stmt;
+
+  /* Linked list of accesses. */
+  struct gpu_stmt_access *accesses;
+};
+
+__isl_give isl_map *project_out(__isl_take isl_space *dim,
+  int len, int first, int n);
+__isl_give isl_map *projection(__isl_take isl_space *dim,
+  int src_len, int dst_len);
+__isl_give isl_set *parametrization(__isl_take isl_space *space,
+  int len, int first, __isl_keep isl_id_list *names);
+__isl_give isl_set *extend(__isl_take isl_set *set, int dst_len);
+__isl_give isl_union_map *align_range(__isl_take isl_union_map *umap);
+
+#endif

polly/trunk/lib/External/ppcg/schedule.c

+/*
+ * Copyright 2010-2011 INRIA Saclay
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ */
+
+#include <assert.h>
+#include <ctype.h>
+#include <string.h>
+
+#include <isl/set.h>
+#include <isl/map.h>
+#include <isl/constraint.h>
+
+#include "schedule.h"
+
+/* Construct a map from a len-dimensional domain to
+ * a (len-n)-dimensional domain that projects out the n coordinates
+ * starting at first.
+ * "dim" prescribes the parameters.
+ */
+__isl_give isl_map *project_out(__isl_take isl_space *dim,
+    int len, int first, int n)
+{
+    int i, j;
+    isl_basic_map *bmap;
+
+    dim = isl_space_add_dims(dim, isl_dim_in, len);
+    dim = isl_space_add_dims(dim, isl_dim_out, len - n);
+    bmap = isl_basic_map_universe(dim);
+
+    for (i = 0, j = 0; i < len; ++i) {
+        if (i >= first && i < first + n)
+            continue;
+  bmap = isl_basic_map_equate(bmap, isl_dim_in, i, isl_dim_out, j);
+        ++j;
+    }
+
+    return isl_map_from_basic_map(bmap);
+}
+
+/* Construct a projection that maps a src_len dimensional domain
+ * to its first dst_len coordinates.
+ * "dim" prescribes the parameters.
+ */
+__isl_give isl_map *projection(__isl_take isl_space *dim,
+    int src_len, int dst_len)
+{
+    return project_out(dim, src_len, dst_len, src_len - dst_len);
+}
+
+/* Add parameters with identifiers "ids" to "set".
+ */
+static __isl_give isl_set *add_params(__isl_take isl_set *set,
+  __isl_keep isl_id_list *ids)
+{
+  int i, n;
+  unsigned nparam;
+
+  n = isl_id_list_n_id(ids);
+
+  nparam = isl_set_dim(set, isl_dim_param);
+  set = isl_set_add_dims(set, isl_dim_param, n);
+
+  for (i = 0; i < n; ++i) {
+    isl_id *id;
+
+    id = isl_id_list_get_id(ids, i);
+    set = isl_set_set_dim_id(set, isl_dim_param, nparam + i, id);
+  }
+
+  return set;
+}
+
+/* Equate the dimensions of "set" starting at "first" to
+ * freshly created parameters with identifiers "ids".
+ * The number of equated dimensions is equal to the number of elements in "ids".
+ */
+static __isl_give isl_set *parametrize(__isl_take isl_set *set,
+  int first, __isl_keep isl_id_list *ids)
+{
+  int i, n;
+  unsigned nparam;
+
+  nparam = isl_set_dim(set, isl_dim_param);
+
+  set = add_params(set, ids);
+
+  n = isl_id_list_n_id(ids);
+  for (i = 0; i < n; ++i)
+    set = isl_set_equate(set, isl_dim_param, nparam + i,
+          isl_dim_set, first + i);
+
+  return set;
+}
+
+/* Given a parameter space "space", create a set of dimension "len"
+ * of which the dimensions starting at "first" are equated to
+ * freshly created parameters with identifiers "ids".
+ */
+__isl_give isl_set *parametrization(__isl_take isl_space *space,
+  int len, int first, __isl_keep isl_id_list *ids)
+{
+  isl_set *set;
+
+  space = isl_space_set_from_params(space);
+  space = isl_space_add_dims(space, isl_dim_set, len);
+  set = isl_set_universe(space);
+
+  return parametrize(set, first, ids);
+}
+
+/* Extend "set" with unconstrained coordinates to a total length of "dst_len".
+ */
+__isl_give isl_set *extend(__isl_take isl_set *set, int dst_len)
+{
+    int n_set;
+    isl_space *dim;
+    isl_map *map;
+
+    dim = isl_set_get_space(set);
+    n_set = isl_space_dim(dim, isl_dim_set);
+    dim = isl_space_drop_dims(dim, isl_dim_set, 0, n_set);
+    map = projection(dim, dst_len, n_set);
+    map = isl_map_reverse(map);
+
+    return isl_set_apply(set, map);
+}
+
+/* Set max_out to the maximal number of output dimensions over
+ * all maps.
+ */
+static isl_stat update_max_out(__isl_take isl_map *map, void *user)
+{
+  int *max_out = user;
+  int n_out = isl_map_dim(map, isl_dim_out);
+
+  if (n_out > *max_out)
+    *max_out = n_out;
+
+  isl_map_free(map);
+  return isl_stat_ok;
+}
+
+struct align_range_data {
+  int max_out;
+  isl_union_map *res;
+};
+
+/* Extend the dimension of the range of the given map to data->max_out and
+ * then add the result to data->res.
+ */
+static isl_stat map_align_range(__isl_take isl_map *map, void *user)
+{
+  struct align_range_data *data = user;
+  int i;
+  isl_space *dim;
+  isl_map *proj;
+  int n_out = isl_map_dim(map, isl_dim_out);
+
+  dim = isl_union_map_get_space(data->res);
+  proj = isl_map_reverse(projection(dim, data->max_out, n_out));
+  for (i = n_out; i < data->max_out; ++i)
+    proj = isl_map_fix_si(proj, isl_dim_out, i, 0);
+
+  map = isl_map_apply_range(map, proj);
+
+  data->res = isl_union_map_add_map(data->res, map);
+
+  return isl_stat_ok;
+}
+
+/* Extend the ranges of the maps in the union map such they all have
+ * the same dimension.
+ */
+__isl_give isl_union_map *align_range(__isl_take isl_union_map *umap)
+{
+  struct align_range_data data;
+
+  data.max_out = 0;
+  isl_union_map_foreach_map(umap, &update_max_out, &data.max_out);
+
+  data.res = isl_union_map_empty(isl_union_map_get_space(umap));
+  isl_union_map_foreach_map(umap, &map_align_range, &data);
+
+  isl_union_map_free(umap);
+  return data.res;
+}

polly/trunk/lib/External/ppcg/test-driver

+#! /bin/sh
+# test-driver - basic testsuite driver script.
+
+scriptversion=2013-07-13.22; # UTC
+
+# Copyright (C) 2011-2013 Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# This file is maintained in Automake, please report
+# bugs to <[e-mail]> or send patches to
+# <[e-mail]>.
+
+# Make unconditional expansion of undefined variables an error.  This
+# helps a lot in preventing typo-related bugs.
+set -u
+
+usage_error ()
+{
+  echo "$0: $*" >&2
+  print_usage >&2
+  exit 2
+}
+
+print_usage ()
+{
+  cat <<END
+Usage:
+  test-driver --test-name=NAME --log-file=PATH --trs-file=PATH
+              [--expect-failure={yes|no}] [--color-tests={yes|no}]
+              [--enable-hard-errors={yes|no}] [--]
+              TEST-SCRIPT [TEST-SCRIPT-ARGUMENTS]
+The '--test-name', '--log-file' and '--trs-file' options are mandatory.
+END
+}
+
+test_name= # Used for reporting.
+log_file=  # Where to save the output of the test script.
+trs_file=  # Where to save the metadata of the test run.
+expect_failure=no
+color_tests=no
+enable_hard_errors=yes
+while test $# -gt 0; do
+  case $1 in
+  --help) print_usage; exit $?;;
+  --version) echo "test-driver $scriptversion"; exit $?;;
+  --test-name) test_name=$2; shift;;
+  --log-file) log_file=$2; shift;;
+  --trs-file) trs_file=$2; shift;;
+  --color-tests) color_tests=$2; shift;;
+  --expect-failure) expect_failure=$2; shift;;
+  --enable-hard-errors) enable_hard_errors=$2; shift;;
+  --) shift; break;;
+  -*) usage_error "invalid option: '$1'";;
+   *) break;;
+  esac
+  shift
+done
+
+missing_opts=
+test x"$test_name" = x && missing_opts="$missing_opts --test-name"
+test x"$log_file"  = x && missing_opts="$missing_opts --log-file"
+test x"$trs_file"  = x && missing_opts="$missing_opts --trs-file"
+if test x"$missing_opts" != x; then
+  usage_error "the following mandatory options are missing:$missing_opts"
+fi
+
+if test $# -eq 0; then
+  usage_error "missing argument"
+fi
+
+if test $color_tests = yes; then
+  # Keep this in sync with 'lib/am/check.am:$(am__tty_colors)'.
+  red='␛[0;31m' # Red.
+  grn='␛[0;32m' # Green.
+  lgn='␛[1;32m' # Light green.
+  blu='␛[1;34m' # Blue.
+  mgn='␛[0;35m' # Magenta.
+  std='␛[m'     # No color.
+else
+  red= grn= lgn= blu= mgn= std=
+fi
+
+do_exit='rm -f $log_file $trs_file; (exit $st); exit $st'
+trap "st=129; $do_exit" 1
+trap "st=130; $do_exit" 2
+trap "st=141; $do_exit" 13
+trap "st=143; $do_exit" 15
+
+# Test script is run here.
+"$@" >$log_file 2>&1
+estatus=$?
+if test $enable_hard_errors = no && test $estatus -eq 99; then
+  estatus=1
+fi
+
+case $estatus:$expect_failure in
+  0:yes) col=$red res=XPASS recheck=yes gcopy=yes;;
+  0:*)   col=$grn res=PASS  recheck=no  gcopy=no;;
+  77:*)  col=$blu res=SKIP  recheck=no  gcopy=yes;;
+  99:*)  col=$mgn res=ERROR recheck=yes gcopy=yes;;
+  *:yes) col=$lgn res=XFAIL recheck=no  gcopy=yes;;
+  *:*)   col=$red res=FAIL  recheck=yes gcopy=yes;;
+esac
+
+# Report outcome to console.
+echo "${col}${res}${std}: $test_name"
+
+# Register the test result, and other relevant metadata.
+echo ":test-result: $res" > $trs_file
+echo ":global-test-result: $res" >> $trs_file
+echo ":recheck: $recheck" >> $trs_file
+echo ":copy-in-global-log: $gcopy" >> $trs_file
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:

polly/trunk/lib/External/ppcg/tests/allow-sparse-copy-in.c

+#include <stdlib.h>
+
+int main()
+{
+  int A[2][1000][1000];
+  int B[2][1000][1000];
+
+#pragma scop
+  {
+    for (int i = 0; i < 256; ++i)
+      for (int j = 0; j < 256; ++j)
+        if (j % 8 <= 2 || j % 8 >= 6)
+          A[1][i][j] = B[1][j][i];
+  }
+#pragma endscop
+
+/* 
+
+When compiled with:
+
+./ppcg tests/allow-sparse-copy-in.c --no-linearize-device-arrays
+  --on-error=abort --sizes='{kernel[i]->tile[8,8]; kernel[i]->block[1,8]}'
+  --max-shared-memory=-1  --unroll-copy-shared
+
+this originally resulted in the following copy-in code:
+
+      shared_B[0][0][t1] = B[1][8 * b1][8 * b0 + t1];
+      shared_B[0][1][t1] = B[1][8 * b1 + 1][8 * b0 + t1];
+      shared_B[0][2][t1] = B[1][8 * b1 + 2][8 * b0 + t1];
+      shared_B[0][3][t1] = B[1][8 * b1 + 3][8 * b0 + t1];
+      shared_B[0][4][t1] = B[1][8 * b1 + 4][8 * b0 + t1];
+      shared_B[0][5][t1] = B[1][8 * b1 + 5][8 * b0 + t1];
+      shared_B[0][6][t1] = B[1][8 * b1 + 6][8 * b0 + t1];
+      shared_B[0][7][t1] = B[1][8 * b1 + 7][8 * b0 + t1];
+
+whereas we only want to only perform copies that are actually needed:
+
+      shared_B[0][0][t1] = B[1][8 * b1][8 * b0 + t1];
+      shared_B[0][1][t1] = B[1][8 * b1 + 1][8 * b0 + t1];
+      shared_B[0][2][t1] = B[1][8 * b1 + 2][8 * b0 + t1];
+      shared_B[0][6][t1] = B[1][8 * b1 + 6][8 * b0 + t1];
+      shared_B[0][7][t1] = B[1][8 * b1 + 7][8 * b0 + t1];
+*/
+  for (int i = 0; i < 100; ++i)
+    if (A[1][0][i] != i)
+      return EXIT_FAILURE;
+
+  return EXIT_SUCCESS;
+}

polly/trunk/lib/External/ppcg/tests/call.c

+#include <stdlib.h>
+
+void copy_summary(int b[1000], int a[1000], int pos)
+{
+  b[pos] = 0;
+  int c = a[pos];
+}
+
+#ifdef pencil_access
+__attribute__((pencil_access(copy_summary)))
+#endif
+void copy(int b[1000], int a[1000], int pos);
+
+int main()
+{
+  int a[1000], b[1000];
+
+  for (int i = 0; i < 1000; ++i)
+    a[i] = i;
+#pragma scop
+  for (int i = 0; i < 1000; ++i)
+    copy(b, a, i);
+#pragma endscop
+  for (int i = 0; i < 1000; ++i)
+    if (b[i] != a[i])
+      return EXIT_FAILURE;
+
+  return EXIT_SUCCESS;
+}

polly/trunk/lib/External/ppcg/tests/call2.c

+#include <stdlib.h>
+
+void copy_summary(int b[1000], int a[1000], int pos)
+{
+  b[pos] = 0;
+  int c = a[pos];
+}
+
+#ifdef pencil_access
+__attribute__((pencil_access(copy_summary)))
+#endif
+void copy(int b[1000], int a[1000], int pos);
+
+int main()
+{
+  int a[2][1000];
+
+  for (int i = 0; i < 1000; ++i)
+    a[0][i] = i;
+#pragma scop
+  for (int i = 0; i < 1000; ++i)
+    copy(a[1], a[0], i);
+#pragma endscop
+  for (int i = 0; i < 1000; ++i)
+    if (a[1][i] != a[0][i])
+      return EXIT_FAILURE;
+
+  return EXIT_SUCCESS;
+}

polly/trunk/lib/External/ppcg/tests/call2_opencl_functions.cl

+void copy(__global int b[1000], __global int a[1000], int pos)
+{
+  b[pos] = a[pos];
+}

polly/trunk/lib/External/ppcg/tests/call3.c

+#include <stdlib.h>
+
+void copy_summary(int b[100], int a[100])
+{
+  for (int i = 0; i < 100; ++i) {
+    b[i] = 0;
+    int c = a[i];
+  }
+}
+
+#ifdef pencil_access
+__attribute__((pencil_access(copy_summary)))
+#endif
+void copy(int b[100], int a[100]);
+
+int main()
+{
+  int A[100][100], B[100];
+
+  for (int i = 0; i < 100; ++i)
+    B[i] = i;
+#pragma scop
+  for (int i = 0; i < 100; ++i)
+    copy(A[i], B);
+#pragma endscop
+  for (int i = 0; i < 100; ++i)
+    for (int j = 0; j < 100; ++j)
+      if (A[j][i] != B[i])
+        return EXIT_FAILURE;
+
+  return EXIT_SUCCESS;
+}

polly/trunk/lib/External/ppcg/tests/call3_opencl_functions.cl

+void copy(__global int b[100], __global int a[100])
+{
+  for (int i = 0; i < 100; ++i)
+    b[i] = a[i];
+}

polly/trunk/lib/External/ppcg/tests/call_opencl_functions.cl

+void copy(__global int b[1000], __global int a[1000], int pos)
+{
+  b[pos] = a[pos];
+}

polly/trunk/lib/External/ppcg/tests/dead.c

+#include <stdlib.h>
+
+int main()
+{
+  int a[1000], b[1000];
+
+  for (int i = 0; i < 1000; ++i)
+    a[i] = i;
+#pragma scop
+  for (int i = 0; i < 1000; ++i) {
+    int c;
+    int d;
+    c = a[i];
+    d = c;
+    b[i] = c;
+  }
+#pragma endscop
+  for (int i = 0; i < 1000; ++i)
+    if (b[i] != a[i])
+      return EXIT_FAILURE;
+
+  return EXIT_SUCCESS;
+}

polly/trunk/lib/External/ppcg/tests/loop.c

+#include <stdlib.h>
+
+int main()
+{
+  int a[1000], b[1000];
+
+  for (int i = 0; i < 1000; ++i)
+    a[i] = i;
+#pragma scop
+  for (int i = 0; i < 1000; ++i)
+    b[i] = a[i];
+#pragma endscop
+  for (int i = 0; i < 1000; ++i)
+    if (b[i] != a[i])
+      return EXIT_FAILURE;
+
+  return EXIT_SUCCESS;
+}

polly/trunk/lib/External/ppcg/tests/not_accessed.c

+#include <stdlib.h>
+
+void copy_summary(int b[1000], int a[1000], int pos, int c[1000])
+{
+  b[pos] = 0;
+  int d = a[pos];
+}
+
+#ifdef pencil_access
+__attribute__((pencil_access(copy_summary)))
+#endif
+void copy(int b[1000], int a[1000], int pos, int c[1000]);
+
+int main()
+{
+  int a[1000], b[1000], c[1000];
+
+  for (int i = 0; i < 1000; ++i)
+    a[i] = i;
+#pragma scop
+  for (int i = 0; i < 1000; ++i)
+    copy(b, a, i, c);
+#pragma endscop
+  for (int i = 0; i < 1000; ++i)
+    if (b[i] != a[i])
+      return EXIT_FAILURE;
+
+  return EXIT_SUCCESS;
+}

polly/trunk/lib/External/ppcg/tests/not_accessed_opencl_functions.cl

+void copy(__global int b[1000], __global int a[1000], int pos,
+  __global int c[1000])
+{
+  b[pos] = a[pos];
+}

polly/trunk/lib/External/ppcg/tests/scalar.c

+#include <stdlib.h>
+
+int main()
+{
+  int a;
+#pragma scop
+  a = 1;
+#pragma endscop
+  if (a != 1)
+    return EXIT_FAILURE;
+
+  return EXIT_SUCCESS;
+}

polly/trunk/lib/External/ppcg/tests/shared_sink.c

+#include <stdlib.h>
+
+/* Check that the sources of live ranges with the same sink
+ * are executed in order.
+ */
+int main()
+{
+  int A[128];
+  int n = 128;
+
+  A[0] = 0;
+#pragma scop
+  for (int i = 0; i < n; ++i) {
+    int set = 0;
+    if (A[i] < 2)
+      set = 1;
+    if (set)
+      A[i] = 2;
+  }
+#pragma endscop
+  if (A[0] != 2)
+    return EXIT_FAILURE;
+
+  return EXIT_SUCCESS;
+}

polly/trunk/lib/External/ppcg/tests/struct.c

+#include <stdlib.h>
+
+struct s {
+  int c[10][10];
+};
+
+int main()
+{
+  struct s a[10][10], b[10][10];
+
+  for (int i = 0; i < 10; ++i)
+    for (int j = 0; j < 10; ++j)
+      for (int k = 0; k < 10; ++k)
+        for (int l = 0; l < 10; ++l)
+          a[i][j].c[k][l] = i + j + k + l;
+#pragma scop
+  for (int i = 0; i < 10; ++i)
+    for (int j = 0; j < 10; ++j)
+      for (int k = 0; k < 10; ++k)
+        for (int l = 0; l < 10; ++l)
+          b[i][j].c[k][l] = i + j + k + l;
+#pragma endscop
+  for (int i = 0; i < 10; ++i)
+    for (int j = 0; j < 10; ++j)
+      for (int k = 0; k < 10; ++k)
+        for (int l = 0; l < 10; ++l)
+          if (b[i][j].c[k][l] != a[i][j].c[k][l])
+            return EXIT_FAILURE;
+
+  return EXIT_SUCCESS;
+}

polly/trunk/lib/External/ppcg/tests/struct2.c

+#include <stdlib.h>
+
+struct s {
+  int a;
+};
+
+int main()
+{
+  struct s a, b[10];
+
+#pragma scop
+  a.a = 42;
+  for (int i = 0; i < 10; ++i)
+    b[i].a = a.a;
+#pragma endscop
+  for (int i = 0; i < 10; ++i)
+    if (b[i].a != 42)
+      return EXIT_FAILURE;
+
+  return EXIT_SUCCESS;
+}

polly/trunk/lib/External/ppcg/tests/struct3.c

+#include <stdlib.h>
+
+struct s {
+  int a;
+  int b;
+};
+
+int main()
+{
+  struct s a, b[10];
+
+  a.b = 57;
+#pragma scop
+  a.a = 42;
+  for (int i = 0; i < 10; ++i)
+    b[i] = a;
+#pragma endscop
+  for (int i = 0; i < 10; ++i)
+    if (b[i].a != 42)
+      return EXIT_FAILURE;
+  if (a.b != 57)
+    return EXIT_FAILURE;
+
+  return EXIT_SUCCESS;
+}

polly/trunk/lib/External/ppcg/util.h

+#ifndef UTIL_H
+#define UTIL_H
+
+#include <string.h>
+
+/* Compare the prefix of "s" to "prefix" up to the length of "prefix".
+ */
+static inline int prefixcmp(const char *s, const char *prefix)
+{
+  return strncmp(s, prefix, strlen(prefix));
+}
+
+#endif

polly/trunk/lib/External/ppcg/version.c

+#include "gitversion.h"
+
+const char *ppcg_version(void)
+{
+  return GIT_HEAD_ID"\n";
+}